1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009 Free Software Foundation, Inc.
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 3 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, see <http://www.gnu.org/licenses/>. */
27 #include "breakpoint.h"
28 #include "tracepoint.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"
55 #include "exceptions.h"
62 /* readline include files */
63 #include "readline/readline.h"
64 #include "readline/history.h"
66 /* readline defines this. */
69 #include "mi/mi-common.h"
71 /* Arguments to pass as context to some catch command handlers. */
72 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
73 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
75 /* Prototypes for local functions. */
77 static void enable_delete_command (char *, int);
79 static void enable_delete_breakpoint (struct breakpoint
*);
81 static void enable_once_command (char *, int);
83 static void enable_once_breakpoint (struct breakpoint
*);
85 static void disable_command (char *, int);
87 static void enable_command (char *, int);
89 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
91 static void ignore_command (char *, int);
93 static int breakpoint_re_set_one (void *);
95 static void clear_command (char *, int);
97 static void catch_command (char *, int);
99 static void watch_command (char *, int);
101 static int can_use_hardware_watchpoint (struct value
*);
103 static void break_command_1 (char *, int, int);
105 static void mention (struct breakpoint
*);
107 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
109 static void check_duplicates (struct breakpoint
*);
111 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
113 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
116 static void describe_other_breakpoints (CORE_ADDR
, struct obj_section
*, int);
118 static void breakpoints_info (char *, int);
120 static void breakpoint_1 (int, int);
122 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
124 static int breakpoint_cond_eval (void *);
126 static void cleanup_executing_breakpoints (void *);
128 static void commands_command (char *, int);
130 static void condition_command (char *, int);
132 static int get_number_trailer (char **, int);
134 void set_breakpoint_count (int);
143 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
145 static enum print_stop_action
print_it_typical (bpstat
);
147 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
149 static int watchpoint_check (void *);
151 static void maintenance_info_breakpoints (char *, int);
153 static int hw_breakpoint_used_count (void);
155 static int hw_watchpoint_used_count (enum bptype
, int *);
157 static void hbreak_command (char *, int);
159 static void thbreak_command (char *, int);
161 static void watch_command_1 (char *, int, int);
163 static void rwatch_command (char *, int);
165 static void awatch_command (char *, int);
167 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
169 static void stop_command (char *arg
, int from_tty
);
171 static void stopin_command (char *arg
, int from_tty
);
173 static void stopat_command (char *arg
, int from_tty
);
175 static char *ep_parse_optional_if_clause (char **arg
);
177 static char *ep_parse_optional_filename (char **arg
);
179 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
180 char *arg
, int tempflag
, int from_tty
);
182 static void tcatch_command (char *arg
, int from_tty
);
184 static void ep_skip_leading_whitespace (char **s
);
186 static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc
);
188 static void free_bp_location (struct bp_location
*loc
);
190 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
192 static void update_global_location_list (int);
194 static void update_global_location_list_nothrow (int);
196 static int is_hardware_watchpoint (struct breakpoint
*bpt
);
198 static void insert_breakpoint_locations (void);
200 static void tracepoints_info (char *, int);
202 static void delete_trace_command (char *, int);
204 static void enable_trace_command (char *, int);
206 static void disable_trace_command (char *, int);
208 static void trace_pass_command (char *, int);
210 /* Flag indicating that a command has proceeded the inferior past the
211 current breakpoint. */
213 static int breakpoint_proceeded
;
216 bpdisp_text (enum bpdisp disp
)
218 /* NOTE: the following values are a part of MI protocol and represent
219 values of 'disp' field returned when inferior stops at a breakpoint. */
220 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
221 return bpdisps
[(int) disp
];
224 /* Prototypes for exported functions. */
225 /* If FALSE, gdb will not use hardware support for watchpoints, even
226 if such is available. */
227 static int can_use_hw_watchpoints
;
230 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
231 struct cmd_list_element
*c
,
234 fprintf_filtered (file
, _("\
235 Debugger's willingness to use watchpoint hardware is %s.\n"),
239 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
240 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
241 for unrecognized breakpoint locations.
242 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
243 static enum auto_boolean pending_break_support
;
245 show_pending_break_support (struct ui_file
*file
, int from_tty
,
246 struct cmd_list_element
*c
,
249 fprintf_filtered (file
, _("\
250 Debugger's behavior regarding pending breakpoints is %s.\n"),
254 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
255 set with "break" but falling in read-only memory.
256 If 0, gdb will warn about such breakpoints, but won't automatically
257 use hardware breakpoints. */
258 static int automatic_hardware_breakpoints
;
260 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
261 struct cmd_list_element
*c
,
264 fprintf_filtered (file
, _("\
265 Automatic usage of hardware breakpoints is %s.\n"),
269 /* If on, gdb will keep breakpoints inserted even as inferior is
270 stopped, and immediately insert any new breakpoints. If off, gdb
271 will insert breakpoints into inferior only when resuming it, and
272 will remove breakpoints upon stop. If auto, GDB will behave as ON
273 if in non-stop mode, and as OFF if all-stop mode.*/
275 static const char always_inserted_auto
[] = "auto";
276 static const char always_inserted_on
[] = "on";
277 static const char always_inserted_off
[] = "off";
278 static const char *always_inserted_enums
[] = {
279 always_inserted_auto
,
284 static const char *always_inserted_mode
= always_inserted_auto
;
286 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
287 struct cmd_list_element
*c
, const char *value
)
289 if (always_inserted_mode
== always_inserted_auto
)
290 fprintf_filtered (file
, _("\
291 Always inserted breakpoint mode is %s (currently %s).\n"),
293 breakpoints_always_inserted_mode () ? "on" : "off");
295 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
299 breakpoints_always_inserted_mode (void)
301 return (always_inserted_mode
== always_inserted_on
302 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
305 void _initialize_breakpoint (void);
307 /* Are we executing breakpoint commands? */
308 static int executing_breakpoint_commands
;
310 /* Are overlay event breakpoints enabled? */
311 static int overlay_events_enabled
;
313 /* Walk the following statement or block through all breakpoints.
314 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
317 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
319 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
320 for (B = breakpoint_chain; \
321 B ? (TMP=B->next, 1): 0; \
324 /* Similar iterators for the low-level breakpoints. */
326 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
328 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
329 for (B = bp_location_chain; \
330 B ? (TMP=B->global_next, 1): 0; \
333 /* Iterator for tracepoints only. */
335 #define ALL_TRACEPOINTS(B) \
336 for (B = breakpoint_chain; B; B = B->next) \
337 if ((B)->type == bp_tracepoint)
339 /* Chains of all breakpoints defined. */
341 struct breakpoint
*breakpoint_chain
;
343 struct bp_location
*bp_location_chain
;
345 /* The locations that no longer correspond to any breakpoint,
346 unlinked from bp_location_chain, but for which a hit
347 may still be reported by a target. */
348 VEC(bp_location_p
) *moribund_locations
= NULL
;
350 /* Number of last breakpoint made. */
352 int breakpoint_count
;
354 /* Number of last tracepoint made. */
356 int tracepoint_count
;
358 /* Return whether a breakpoint is an active enabled breakpoint. */
360 breakpoint_enabled (struct breakpoint
*b
)
362 return (b
->enable_state
== bp_enabled
);
365 /* Set breakpoint count to NUM. */
368 set_breakpoint_count (int num
)
370 breakpoint_count
= num
;
371 set_internalvar (lookup_internalvar ("bpnum"),
372 value_from_longest (builtin_type_int32
, (LONGEST
) num
));
375 /* Used in run_command to zero the hit count when a new run starts. */
378 clear_breakpoint_hit_counts (void)
380 struct breakpoint
*b
;
386 /* Default address, symtab and line to put a breakpoint at
387 for "break" command with no arg.
388 if default_breakpoint_valid is zero, the other three are
389 not valid, and "break" with no arg is an error.
391 This set by print_stack_frame, which calls set_default_breakpoint. */
393 int default_breakpoint_valid
;
394 CORE_ADDR default_breakpoint_address
;
395 struct symtab
*default_breakpoint_symtab
;
396 int default_breakpoint_line
;
398 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
399 Advance *PP after the string and any trailing whitespace.
401 Currently the string can either be a number or "$" followed by the name
402 of a convenience variable. Making it an expression wouldn't work well
403 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
405 If the string is a NULL pointer, that denotes the last breakpoint.
407 TRAILER is a character which can be found after the number; most
408 commonly this is `-'. If you don't want a trailer, use \0. */
410 get_number_trailer (char **pp
, int trailer
)
412 int retval
= 0; /* default */
416 /* Empty line means refer to the last breakpoint. */
417 return breakpoint_count
;
420 /* Make a copy of the name, so we can null-terminate it
421 to pass to lookup_internalvar(). */
426 while (isalnum (*p
) || *p
== '_')
428 varname
= (char *) alloca (p
- start
+ 1);
429 strncpy (varname
, start
, p
- start
);
430 varname
[p
- start
] = '\0';
431 val
= value_of_internalvar (lookup_internalvar (varname
));
432 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
433 retval
= (int) value_as_long (val
);
436 printf_filtered (_("Convenience variable must have integer value.\n"));
444 while (*p
>= '0' && *p
<= '9')
447 /* There is no number here. (e.g. "cond a == b"). */
449 /* Skip non-numeric token */
450 while (*p
&& !isspace((int) *p
))
452 /* Return zero, which caller must interpret as error. */
458 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
460 /* Trailing junk: return 0 and let caller print error msg. */
461 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
472 /* Like get_number_trailer, but don't allow a trailer. */
474 get_number (char **pp
)
476 return get_number_trailer (pp
, '\0');
479 /* Parse a number or a range.
480 * A number will be of the form handled by get_number.
481 * A range will be of the form <number1> - <number2>, and
482 * will represent all the integers between number1 and number2,
485 * While processing a range, this fuction is called iteratively;
486 * At each call it will return the next value in the range.
488 * At the beginning of parsing a range, the char pointer PP will
489 * be advanced past <number1> and left pointing at the '-' token.
490 * Subsequent calls will not advance the pointer until the range
491 * is completed. The call that completes the range will advance
492 * pointer PP past <number2>.
496 get_number_or_range (char **pp
)
498 static int last_retval
, end_value
;
499 static char *end_ptr
;
500 static int in_range
= 0;
504 /* Default case: pp is pointing either to a solo number,
505 or to the first number of a range. */
506 last_retval
= get_number_trailer (pp
, '-');
511 /* This is the start of a range (<number1> - <number2>).
512 Skip the '-', parse and remember the second number,
513 and also remember the end of the final token. */
517 while (isspace ((int) *end_ptr
))
518 end_ptr
++; /* skip white space */
519 end_value
= get_number (temp
);
520 if (end_value
< last_retval
)
522 error (_("inverted range"));
524 else if (end_value
== last_retval
)
526 /* degenerate range (number1 == number2). Advance the
527 token pointer so that the range will be treated as a
536 error (_("negative value"));
539 /* pp points to the '-' that betokens a range. All
540 number-parsing has already been done. Return the next
541 integer value (one greater than the saved previous value).
542 Do not advance the token pointer 'pp' until the end of range
545 if (++last_retval
== end_value
)
547 /* End of range reached; advance token pointer. */
557 /* condition N EXP -- set break condition of breakpoint N to EXP. */
560 condition_command (char *arg
, int from_tty
)
562 struct breakpoint
*b
;
567 error_no_arg (_("breakpoint number"));
570 bnum
= get_number (&p
);
572 error (_("Bad breakpoint argument: '%s'"), arg
);
575 if (b
->number
== bnum
)
577 struct bp_location
*loc
= b
->loc
;
578 for (; loc
; loc
= loc
->next
)
586 if (b
->cond_string
!= NULL
)
587 xfree (b
->cond_string
);
591 b
->cond_string
= NULL
;
593 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
598 /* I don't know if it matters whether this is the string the user
599 typed in or the decompiled expression. */
600 b
->cond_string
= savestring (arg
, strlen (arg
));
601 b
->condition_not_parsed
= 0;
602 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
606 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
608 error (_("Junk at end of expression"));
611 breakpoints_changed ();
612 observer_notify_breakpoint_modified (b
->number
);
616 error (_("No breakpoint number %d."), bnum
);
620 commands_command (char *arg
, int from_tty
)
622 struct breakpoint
*b
;
625 struct command_line
*l
;
627 /* If we allowed this, we would have problems with when to
628 free the storage, if we change the commands currently
631 if (executing_breakpoint_commands
)
632 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
635 bnum
= get_number (&p
);
638 error (_("Unexpected extra arguments following breakpoint number."));
641 if (b
->number
== bnum
)
643 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
645 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
646 l
= read_command_lines (tmpbuf
, from_tty
, 1);
647 do_cleanups (cleanups
);
648 free_command_lines (&b
->commands
);
650 breakpoints_changed ();
651 observer_notify_breakpoint_modified (b
->number
);
654 error (_("No breakpoint number %d."), bnum
);
657 /* Like commands_command, but instead of reading the commands from
658 input stream, takes them from an already parsed command structure.
660 This is used by cli-script.c to DTRT with breakpoint commands
661 that are part of if and while bodies. */
662 enum command_control_type
663 commands_from_control_command (char *arg
, struct command_line
*cmd
)
665 struct breakpoint
*b
;
669 /* If we allowed this, we would have problems with when to
670 free the storage, if we change the commands currently
673 if (executing_breakpoint_commands
)
674 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
676 /* An empty string for the breakpoint number means the last
677 breakpoint, but get_number expects a NULL pointer. */
682 bnum
= get_number (&p
);
685 error (_("Unexpected extra arguments following breakpoint number."));
688 if (b
->number
== bnum
)
690 free_command_lines (&b
->commands
);
691 if (cmd
->body_count
!= 1)
692 error (_("Invalid \"commands\" block structure."));
693 /* We need to copy the commands because if/while will free the
694 list after it finishes execution. */
695 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
696 breakpoints_changed ();
697 observer_notify_breakpoint_modified (b
->number
);
698 return simple_control
;
700 error (_("No breakpoint number %d."), bnum
);
703 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
704 by replacing any memory breakpoints with their shadowed contents. */
707 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
709 struct bp_location
*b
;
710 CORE_ADDR bp_addr
= 0;
716 if (b
->owner
->type
== bp_none
)
717 warning (_("reading through apparently deleted breakpoint #%d?"),
720 if (b
->loc_type
!= bp_loc_software_breakpoint
)
724 /* Addresses and length of the part of the breakpoint that
726 bp_addr
= b
->target_info
.placed_address
;
727 bp_size
= b
->target_info
.shadow_len
;
729 /* bp isn't valid, or doesn't shadow memory. */
732 if (bp_addr
+ bp_size
<= memaddr
)
733 /* The breakpoint is entirely before the chunk of memory we
737 if (bp_addr
>= memaddr
+ len
)
738 /* The breakpoint is entirely after the chunk of memory we are
742 /* Offset within shadow_contents. */
743 if (bp_addr
< memaddr
)
745 /* Only copy the second part of the breakpoint. */
746 bp_size
-= memaddr
- bp_addr
;
747 bptoffset
= memaddr
- bp_addr
;
751 if (bp_addr
+ bp_size
> memaddr
+ len
)
753 /* Only copy the first part of the breakpoint. */
754 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
757 memcpy (buf
+ bp_addr
- memaddr
,
758 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
763 /* A wrapper function for inserting catchpoints. */
765 insert_catchpoint (struct ui_out
*uo
, void *args
)
767 struct breakpoint
*b
= (struct breakpoint
*) args
;
770 gdb_assert (b
->type
== bp_catchpoint
);
771 gdb_assert (b
->ops
!= NULL
&& b
->ops
->insert
!= NULL
);
777 is_hardware_watchpoint (struct breakpoint
*bpt
)
779 return (bpt
->type
== bp_hardware_watchpoint
780 || bpt
->type
== bp_read_watchpoint
781 || bpt
->type
== bp_access_watchpoint
);
784 /* Find the current value of a watchpoint on EXP. Return the value in
785 *VALP and *RESULTP and the chain of intermediate and final values
786 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
789 If a memory error occurs while evaluating the expression, *RESULTP will
790 be set to NULL. *RESULTP may be a lazy value, if the result could
791 not be read from memory. It is used to determine whether a value
792 is user-specified (we should watch the whole value) or intermediate
793 (we should watch only the bit used to locate the final value).
795 If the final value, or any intermediate value, could not be read
796 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
797 set to any referenced values. *VALP will never be a lazy value.
798 This is the value which we store in struct breakpoint.
800 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
801 value chain. The caller must free the values individually. If
802 VAL_CHAIN is NULL, all generated values will be left on the value
806 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
807 struct value
**resultp
, struct value
**val_chain
)
809 struct value
*mark
, *new_mark
, *result
;
810 volatile struct gdb_exception ex
;
818 /* Evaluate the expression. */
819 mark
= value_mark ();
822 TRY_CATCH (ex
, RETURN_MASK_ALL
)
824 result
= evaluate_expression (exp
);
828 /* Ignore memory errors, we want watchpoints pointing at
829 inaccessible memory to still be created; otherwise, throw the
830 error to some higher catcher. */
836 throw_exception (ex
);
841 new_mark
= value_mark ();
842 if (mark
== new_mark
)
847 /* Make sure it's not lazy, so that after the target stops again we
848 have a non-lazy previous value to compare with. */
850 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
855 /* Return the chain of intermediate values. We use this to
856 decide which addresses to watch. */
857 *val_chain
= new_mark
;
858 value_release_to_mark (mark
);
862 /* Assuming that B is a watchpoint:
863 - Reparse watchpoint expression, if REPARSE is non-zero
864 - Evaluate expression and store the result in B->val
865 - Evaluate the condition if there is one, and store the result
867 - Update the list of values that must be watched in B->loc.
869 If the watchpoint disposition is disp_del_at_next_stop, then do nothing.
870 If this is local watchpoint that is out of scope, delete it. */
872 update_watchpoint (struct breakpoint
*b
, int reparse
)
874 int within_current_scope
;
875 struct frame_id saved_frame_id
;
876 struct bp_location
*loc
;
879 /* We don't free locations. They are stored in bp_location_chain and
880 update_global_locations will eventually delete them and remove
881 breakpoints if needed. */
884 if (b
->disposition
== disp_del_at_next_stop
)
887 /* Save the current frame's ID so we can restore it after
888 evaluating the watchpoint expression on its own frame. */
889 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
890 took a frame parameter, so that we didn't have to change the
892 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
894 /* Determine if the watchpoint is within scope. */
895 if (b
->exp_valid_block
== NULL
)
896 within_current_scope
= 1;
899 struct frame_info
*fi
;
900 fi
= frame_find_by_id (b
->watchpoint_frame
);
901 within_current_scope
= (fi
!= NULL
);
902 if (within_current_scope
)
906 if (within_current_scope
&& reparse
)
915 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
916 /* If the meaning of expression itself changed, the old value is
917 no longer relevant. We don't want to report a watchpoint hit
918 to the user when the old value and the new value may actually
919 be completely different objects. */
925 /* If we failed to parse the expression, for example because
926 it refers to a global variable in a not-yet-loaded shared library,
927 don't try to insert watchpoint. We don't automatically delete
928 such watchpoint, though, since failure to parse expression
929 is different from out-of-scope watchpoint. */
930 if (within_current_scope
&& b
->exp
)
932 struct value
*val_chain
, *v
, *result
, *next
;
934 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
936 /* Avoid setting b->val if it's already set. The meaning of
937 b->val is 'the last value' user saw, and we should update
938 it only if we reported that last value to user. As it
939 happens, the code that reports it updates b->val directly. */
946 /* Change the type of breakpoint between hardware assisted or an
947 ordinary watchpoint depending on the hardware support and free
948 hardware slots. REPARSE is set when the inferior is started. */
949 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
952 int i
, mem_cnt
, other_type_used
;
954 i
= hw_watchpoint_used_count (bp_hardware_watchpoint
,
956 mem_cnt
= can_use_hardware_watchpoint (val_chain
);
959 b
->type
= bp_watchpoint
;
962 int target_resources_ok
= target_can_use_hardware_watchpoint
963 (bp_hardware_watchpoint
, i
+ mem_cnt
, other_type_used
);
964 if (target_resources_ok
<= 0)
965 b
->type
= bp_watchpoint
;
967 b
->type
= bp_hardware_watchpoint
;
971 /* Look at each value on the value chain. */
972 for (v
= val_chain
; v
; v
= next
)
974 /* If it's a memory location, and GDB actually needed
975 its contents to evaluate the expression, then we
976 must watch it. If the first value returned is
977 still lazy, that means an error occurred reading it;
978 watch it anyway in case it becomes readable. */
979 if (VALUE_LVAL (v
) == lval_memory
980 && (v
== val_chain
|| ! value_lazy (v
)))
982 struct type
*vtype
= check_typedef (value_type (v
));
984 /* We only watch structs and arrays if user asked
985 for it explicitly, never if they just happen to
986 appear in the middle of some value chain. */
988 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
989 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
993 struct bp_location
*loc
, **tmp
;
995 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
996 len
= TYPE_LENGTH (value_type (v
));
998 if (b
->type
== bp_read_watchpoint
)
1000 else if (b
->type
== bp_access_watchpoint
)
1003 loc
= allocate_bp_location (b
);
1004 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1007 loc
->address
= addr
;
1009 loc
->watchpoint_type
= type
;
1013 next
= value_next (v
);
1018 /* We just regenerated the list of breakpoint locations.
1019 The new location does not have its condition field set to anything
1020 and therefore, we must always reparse the cond_string, independently
1021 of the value of the reparse flag. */
1022 if (b
->cond_string
!= NULL
)
1024 char *s
= b
->cond_string
;
1025 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1028 else if (!within_current_scope
)
1030 printf_filtered (_("\
1031 Watchpoint %d deleted because the program has left the block \n\
1032 in which its expression is valid.\n"),
1034 if (b
->related_breakpoint
)
1035 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1036 b
->disposition
= disp_del_at_next_stop
;
1039 /* Restore the selected frame. */
1040 select_frame (frame_find_by_id (saved_frame_id
));
1044 /* Returns 1 iff breakpoint location should be
1045 inserted in the inferior. */
1047 should_be_inserted (struct bp_location
*bpt
)
1049 if (!breakpoint_enabled (bpt
->owner
))
1052 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
1055 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1058 /* Tracepoints are inserted by the target at a time of its choosing,
1060 if (bpt
->owner
->type
== bp_tracepoint
)
1066 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1067 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1068 and HW_BREAKPOINT_ERROR are used to report problems.
1070 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1071 method for each breakpoint or catchpoint type. */
1073 insert_bp_location (struct bp_location
*bpt
,
1074 struct ui_file
*tmp_error_stream
,
1075 int *disabled_breaks
,
1076 int *hw_breakpoint_error
)
1080 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1083 /* Initialize the target-specific information. */
1084 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1085 bpt
->target_info
.placed_address
= bpt
->address
;
1087 if (bpt
->loc_type
== bp_loc_software_breakpoint
1088 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1090 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1092 /* If the explicitly specified breakpoint type
1093 is not hardware breakpoint, check the memory map to see
1094 if the breakpoint address is in read only memory or not.
1095 Two important cases are:
1096 - location type is not hardware breakpoint, memory
1097 is readonly. We change the type of the location to
1098 hardware breakpoint.
1099 - location type is hardware breakpoint, memory is read-write.
1100 This means we've previously made the location hardware one, but
1101 then the memory map changed, so we undo.
1103 When breakpoints are removed, remove_breakpoints will
1104 use location types we've just set here, the only possible
1105 problem is that memory map has changed during running program,
1106 but it's not going to work anyway with current gdb. */
1107 struct mem_region
*mr
1108 = lookup_mem_region (bpt
->target_info
.placed_address
);
1112 if (automatic_hardware_breakpoints
)
1115 enum bp_loc_type new_type
;
1117 if (mr
->attrib
.mode
!= MEM_RW
)
1118 new_type
= bp_loc_hardware_breakpoint
;
1120 new_type
= bp_loc_software_breakpoint
;
1122 if (new_type
!= bpt
->loc_type
)
1124 static int said
= 0;
1125 bpt
->loc_type
= new_type
;
1128 fprintf_filtered (gdb_stdout
, _("\
1129 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1134 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1135 && mr
->attrib
.mode
!= MEM_RW
)
1136 warning (_("cannot set software breakpoint at readonly address %s"),
1137 paddr (bpt
->address
));
1141 /* First check to see if we have to handle an overlay. */
1142 if (overlay_debugging
== ovly_off
1143 || bpt
->section
== NULL
1144 || !(section_is_overlay (bpt
->section
)))
1146 /* No overlay handling: just set the breakpoint. */
1148 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1149 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1151 val
= target_insert_breakpoint (&bpt
->target_info
);
1155 /* This breakpoint is in an overlay section.
1156 Shall we set a breakpoint at the LMA? */
1157 if (!overlay_events_enabled
)
1159 /* Yes -- overlay event support is not active,
1160 so we must try to set a breakpoint at the LMA.
1161 This will not work for a hardware breakpoint. */
1162 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1163 warning (_("hardware breakpoint %d not supported in overlay!"),
1164 bpt
->owner
->number
);
1167 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1169 /* Set a software (trap) breakpoint at the LMA. */
1170 bpt
->overlay_target_info
= bpt
->target_info
;
1171 bpt
->overlay_target_info
.placed_address
= addr
;
1172 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
1174 fprintf_unfiltered (tmp_error_stream
,
1175 "Overlay breakpoint %d failed: in ROM?\n",
1176 bpt
->owner
->number
);
1179 /* Shall we set a breakpoint at the VMA? */
1180 if (section_is_mapped (bpt
->section
))
1182 /* Yes. This overlay section is mapped into memory. */
1183 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1184 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1186 val
= target_insert_breakpoint (&bpt
->target_info
);
1190 /* No. This breakpoint will not be inserted.
1191 No error, but do not mark the bp as 'inserted'. */
1198 /* Can't set the breakpoint. */
1199 if (solib_name_from_address (bpt
->address
))
1201 /* See also: disable_breakpoints_in_shlibs. */
1203 bpt
->shlib_disabled
= 1;
1204 if (!*disabled_breaks
)
1206 fprintf_unfiltered (tmp_error_stream
,
1207 "Cannot insert breakpoint %d.\n",
1208 bpt
->owner
->number
);
1209 fprintf_unfiltered (tmp_error_stream
,
1210 "Temporarily disabling shared library breakpoints:\n");
1212 *disabled_breaks
= 1;
1213 fprintf_unfiltered (tmp_error_stream
,
1214 "breakpoint #%d\n", bpt
->owner
->number
);
1218 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1220 *hw_breakpoint_error
= 1;
1221 fprintf_unfiltered (tmp_error_stream
,
1222 "Cannot insert hardware breakpoint %d.\n",
1223 bpt
->owner
->number
);
1227 fprintf_unfiltered (tmp_error_stream
,
1228 "Cannot insert breakpoint %d.\n",
1229 bpt
->owner
->number
);
1230 fprintf_filtered (tmp_error_stream
,
1231 "Error accessing memory address ");
1232 fputs_filtered (paddress (bpt
->address
), tmp_error_stream
);
1233 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1234 safe_strerror (val
));
1245 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1246 /* NOTE drow/2003-09-08: This state only exists for removing
1247 watchpoints. It's not clear that it's necessary... */
1248 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1250 val
= target_insert_watchpoint (bpt
->address
,
1252 bpt
->watchpoint_type
);
1253 bpt
->inserted
= (val
!= -1);
1256 else if (bpt
->owner
->type
== bp_catchpoint
)
1258 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1259 bpt
->owner
, RETURN_MASK_ERROR
);
1260 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1261 bpt
->owner
->number
);
1263 bpt
->owner
->enable_state
= bp_disabled
;
1267 /* We've already printed an error message if there was a problem
1268 inserting this catchpoint, and we've disabled the catchpoint,
1269 so just return success. */
1276 /* Make sure all breakpoints are inserted in inferior.
1277 Throws exception on any error.
1278 A breakpoint that is already inserted won't be inserted
1279 again, so calling this function twice is safe. */
1281 insert_breakpoints (void)
1283 struct breakpoint
*bpt
;
1285 ALL_BREAKPOINTS (bpt
)
1286 if (is_hardware_watchpoint (bpt
))
1287 update_watchpoint (bpt
, 0 /* don't reparse. */);
1289 update_global_location_list (1);
1291 if (!breakpoints_always_inserted_mode ()
1292 && (target_has_execution
1293 || (gdbarch_has_global_solist (target_gdbarch
)
1294 && target_supports_multi_process ())))
1295 /* update_global_location_list does not insert breakpoints
1296 when always_inserted_mode is not enabled. Explicitly
1298 insert_breakpoint_locations ();
1301 /* insert_breakpoints is used when starting or continuing the program.
1302 remove_breakpoints is used when the program stops.
1303 Both return zero if successful,
1304 or an `errno' value if could not write the inferior. */
1307 insert_breakpoint_locations (void)
1309 struct breakpoint
*bpt
;
1310 struct bp_location
*b
, *temp
;
1313 int disabled_breaks
= 0;
1314 int hw_breakpoint_error
= 0;
1316 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1317 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1319 /* Explicitly mark the warning -- this will only be printed if
1320 there was an error. */
1321 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1323 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1325 if (!should_be_inserted (b
) || b
->inserted
)
1328 /* There is no point inserting thread-specific breakpoints if the
1329 thread no longer exists. */
1330 if (b
->owner
->thread
!= -1
1331 && !valid_thread_id (b
->owner
->thread
))
1334 val
= insert_bp_location (b
, tmp_error_stream
,
1336 &hw_breakpoint_error
);
1341 /* If we failed to insert all locations of a watchpoint,
1342 remove them, as half-inserted watchpoint is of limited use. */
1343 ALL_BREAKPOINTS (bpt
)
1345 int some_failed
= 0;
1346 struct bp_location
*loc
;
1348 if (!is_hardware_watchpoint (bpt
))
1351 if (!breakpoint_enabled (bpt
))
1354 if (bpt
->disposition
== disp_del_at_next_stop
)
1357 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1365 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1367 remove_breakpoint (loc
, mark_uninserted
);
1369 hw_breakpoint_error
= 1;
1370 fprintf_unfiltered (tmp_error_stream
,
1371 "Could not insert hardware watchpoint %d.\n",
1379 /* If a hardware breakpoint or watchpoint was inserted, add a
1380 message about possibly exhausted resources. */
1381 if (hw_breakpoint_error
)
1383 fprintf_unfiltered (tmp_error_stream
,
1384 "Could not insert hardware breakpoints:\n\
1385 You may have requested too many hardware breakpoints/watchpoints.\n");
1387 target_terminal_ours_for_output ();
1388 error_stream (tmp_error_stream
);
1391 do_cleanups (cleanups
);
1395 remove_breakpoints (void)
1397 struct bp_location
*b
;
1400 ALL_BP_LOCATIONS (b
)
1404 val
= remove_breakpoint (b
, mark_uninserted
);
1413 remove_hw_watchpoints (void)
1415 struct bp_location
*b
;
1418 ALL_BP_LOCATIONS (b
)
1420 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1422 val
= remove_breakpoint (b
, mark_uninserted
);
1431 reattach_breakpoints (int pid
)
1433 struct bp_location
*b
;
1435 struct cleanup
*old_chain
= save_inferior_ptid ();
1436 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1437 int dummy1
= 0, dummy2
= 0;
1439 make_cleanup_ui_file_delete (tmp_error_stream
);
1441 inferior_ptid
= pid_to_ptid (pid
);
1442 ALL_BP_LOCATIONS (b
)
1447 val
= insert_bp_location (b
, tmp_error_stream
,
1451 do_cleanups (old_chain
);
1456 do_cleanups (old_chain
);
1460 static struct breakpoint
*
1461 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
1463 static int internal_breakpoint_number
= -1;
1464 struct symtab_and_line sal
;
1465 struct breakpoint
*b
;
1467 init_sal (&sal
); /* initialize to zeroes */
1470 sal
.section
= find_pc_overlay (sal
.pc
);
1472 b
= set_raw_breakpoint (sal
, type
);
1473 b
->number
= internal_breakpoint_number
--;
1474 b
->disposition
= disp_donttouch
;
1480 create_overlay_event_breakpoint (char *func_name
, struct objfile
*objfile
)
1482 struct breakpoint
*b
;
1483 struct minimal_symbol
*m
;
1485 if ((m
= lookup_minimal_symbol_text (func_name
, objfile
)) == NULL
)
1488 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
1490 b
->addr_string
= xstrdup (func_name
);
1492 if (overlay_debugging
== ovly_auto
)
1494 b
->enable_state
= bp_enabled
;
1495 overlay_events_enabled
= 1;
1499 b
->enable_state
= bp_disabled
;
1500 overlay_events_enabled
= 0;
1502 update_global_location_list (1);
1506 update_breakpoints_after_exec (void)
1508 struct breakpoint
*b
;
1509 struct breakpoint
*temp
;
1510 struct bp_location
*bploc
;
1511 struct objfile
*objfile
;
1513 /* We're about to delete breakpoints from GDB's lists. If the
1514 INSERTED flag is true, GDB will try to lift the breakpoints by
1515 writing the breakpoints' "shadow contents" back into memory. The
1516 "shadow contents" are NOT valid after an exec, so GDB should not
1517 do that. Instead, the target is responsible from marking
1518 breakpoints out as soon as it detects an exec. We don't do that
1519 here instead, because there may be other attempts to delete
1520 breakpoints after detecting an exec and before reaching here. */
1521 ALL_BP_LOCATIONS (bploc
)
1522 gdb_assert (!bploc
->inserted
);
1524 ALL_BREAKPOINTS_SAFE (b
, temp
)
1526 /* Solib breakpoints must be explicitly reset after an exec(). */
1527 if (b
->type
== bp_shlib_event
)
1529 delete_breakpoint (b
);
1533 /* Thread event breakpoints must be set anew after an exec(),
1534 as must overlay event breakpoints. */
1535 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1537 delete_breakpoint (b
);
1541 /* Step-resume breakpoints are meaningless after an exec(). */
1542 if (b
->type
== bp_step_resume
)
1544 delete_breakpoint (b
);
1548 /* Longjmp and longjmp-resume breakpoints are also meaningless
1550 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
1552 delete_breakpoint (b
);
1556 if (b
->type
== bp_catchpoint
)
1558 /* For now, none of the bp_catchpoint breakpoints need to
1559 do anything at this point. In the future, if some of
1560 the catchpoints need to something, we will need to add
1561 a new method, and call this method from here. */
1565 /* bp_finish is a special case. The only way we ought to be able
1566 to see one of these when an exec() has happened, is if the user
1567 caught a vfork, and then said "finish". Ordinarily a finish just
1568 carries them to the call-site of the current callee, by setting
1569 a temporary bp there and resuming. But in this case, the finish
1570 will carry them entirely through the vfork & exec.
1572 We don't want to allow a bp_finish to remain inserted now. But
1573 we can't safely delete it, 'cause finish_command has a handle to
1574 the bp on a bpstat, and will later want to delete it. There's a
1575 chance (and I've seen it happen) that if we delete the bp_finish
1576 here, that its storage will get reused by the time finish_command
1577 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1578 We really must allow finish_command to delete a bp_finish.
1580 In the absense of a general solution for the "how do we know
1581 it's safe to delete something others may have handles to?"
1582 problem, what we'll do here is just uninsert the bp_finish, and
1583 let finish_command delete it.
1585 (We know the bp_finish is "doomed" in the sense that it's
1586 momentary, and will be deleted as soon as finish_command sees
1587 the inferior stopped. So it doesn't matter that the bp's
1588 address is probably bogus in the new a.out, unlike e.g., the
1589 solib breakpoints.) */
1591 if (b
->type
== bp_finish
)
1596 /* Without a symbolic address, we have little hope of the
1597 pre-exec() address meaning the same thing in the post-exec()
1599 if (b
->addr_string
== NULL
)
1601 delete_breakpoint (b
);
1605 /* FIXME what about longjmp breakpoints? Re-create them here? */
1606 ALL_OBJFILES (objfile
)
1607 create_overlay_event_breakpoint ("_ovly_debug_event", objfile
);
1611 detach_breakpoints (int pid
)
1613 struct bp_location
*b
;
1615 struct cleanup
*old_chain
= save_inferior_ptid ();
1617 if (pid
== PIDGET (inferior_ptid
))
1618 error (_("Cannot detach breakpoints of inferior_ptid"));
1620 /* Set inferior_ptid; remove_breakpoint uses this global. */
1621 inferior_ptid
= pid_to_ptid (pid
);
1622 ALL_BP_LOCATIONS (b
)
1626 val
= remove_breakpoint (b
, mark_inserted
);
1629 do_cleanups (old_chain
);
1634 do_cleanups (old_chain
);
1639 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1643 if (b
->owner
->enable_state
== bp_permanent
)
1644 /* Permanent breakpoints cannot be inserted or removed. */
1647 /* The type of none suggests that owner is actually deleted.
1648 This should not ever happen. */
1649 gdb_assert (b
->owner
->type
!= bp_none
);
1651 if (b
->loc_type
== bp_loc_software_breakpoint
1652 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1654 /* "Normal" instruction breakpoint: either the standard
1655 trap-instruction bp (bp_breakpoint), or a
1656 bp_hardware_breakpoint. */
1658 /* First check to see if we have to handle an overlay. */
1659 if (overlay_debugging
== ovly_off
1660 || b
->section
== NULL
1661 || !(section_is_overlay (b
->section
)))
1663 /* No overlay handling: just remove the breakpoint. */
1665 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1666 val
= target_remove_hw_breakpoint (&b
->target_info
);
1668 val
= target_remove_breakpoint (&b
->target_info
);
1672 /* This breakpoint is in an overlay section.
1673 Did we set a breakpoint at the LMA? */
1674 if (!overlay_events_enabled
)
1676 /* Yes -- overlay event support is not active, so we
1677 should have set a breakpoint at the LMA. Remove it.
1679 /* Ignore any failures: if the LMA is in ROM, we will
1680 have already warned when we failed to insert it. */
1681 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1682 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1684 target_remove_breakpoint (&b
->overlay_target_info
);
1686 /* Did we set a breakpoint at the VMA?
1687 If so, we will have marked the breakpoint 'inserted'. */
1690 /* Yes -- remove it. Previously we did not bother to
1691 remove the breakpoint if the section had been
1692 unmapped, but let's not rely on that being safe. We
1693 don't know what the overlay manager might do. */
1694 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1695 val
= target_remove_hw_breakpoint (&b
->target_info
);
1697 /* However, we should remove *software* breakpoints only
1698 if the section is still mapped, or else we overwrite
1699 wrong code with the saved shadow contents. */
1700 else if (section_is_mapped (b
->section
))
1701 val
= target_remove_breakpoint (&b
->target_info
);
1707 /* No -- not inserted, so no need to remove. No error. */
1712 /* In some cases, we might not be able to remove a breakpoint
1713 in a shared library that has already been removed, but we
1714 have not yet processed the shlib unload event. */
1715 if (val
&& solib_name_from_address (b
->address
))
1720 b
->inserted
= (is
== mark_inserted
);
1722 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1727 b
->inserted
= (is
== mark_inserted
);
1728 val
= target_remove_watchpoint (b
->address
, b
->length
,
1729 b
->watchpoint_type
);
1731 /* Failure to remove any of the hardware watchpoints comes here. */
1732 if ((is
== mark_uninserted
) && (b
->inserted
))
1733 warning (_("Could not remove hardware watchpoint %d."),
1736 else if (b
->owner
->type
== bp_catchpoint
1737 && breakpoint_enabled (b
->owner
)
1740 gdb_assert (b
->owner
->ops
!= NULL
&& b
->owner
->ops
->remove
!= NULL
);
1742 val
= b
->owner
->ops
->remove (b
->owner
);
1745 b
->inserted
= (is
== mark_inserted
);
1751 /* Clear the "inserted" flag in all breakpoints. */
1754 mark_breakpoints_out (void)
1756 struct bp_location
*bpt
;
1758 ALL_BP_LOCATIONS (bpt
)
1762 /* Clear the "inserted" flag in all breakpoints and delete any
1763 breakpoints which should go away between runs of the program.
1765 Plus other such housekeeping that has to be done for breakpoints
1768 Note: this function gets called at the end of a run (by
1769 generic_mourn_inferior) and when a run begins (by
1770 init_wait_for_inferior). */
1775 breakpoint_init_inferior (enum inf_context context
)
1777 struct breakpoint
*b
, *temp
;
1778 struct bp_location
*bpt
;
1781 /* If breakpoint locations are shared across processes, then there's
1783 if (gdbarch_has_global_solist (target_gdbarch
))
1786 ALL_BP_LOCATIONS (bpt
)
1787 if (bpt
->owner
->enable_state
!= bp_permanent
)
1790 ALL_BREAKPOINTS_SAFE (b
, temp
)
1795 case bp_watchpoint_scope
:
1797 /* If the call dummy breakpoint is at the entry point it will
1798 cause problems when the inferior is rerun, so we better
1801 Also get rid of scope breakpoints. */
1802 delete_breakpoint (b
);
1806 case bp_hardware_watchpoint
:
1807 case bp_read_watchpoint
:
1808 case bp_access_watchpoint
:
1810 /* Likewise for watchpoints on local expressions. */
1811 if (b
->exp_valid_block
!= NULL
)
1812 delete_breakpoint (b
);
1813 else if (context
== inf_starting
)
1815 /* Reset val field to force reread of starting value
1816 in insert_breakpoints. */
1818 value_free (b
->val
);
1828 /* Get rid of the moribund locations. */
1829 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bpt
); ++ix
)
1830 free_bp_location (bpt
);
1831 VEC_free (bp_location_p
, moribund_locations
);
1834 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1835 exists at PC. It returns ordinary_breakpoint_here if it's an
1836 ordinary breakpoint, or permanent_breakpoint_here if it's a
1837 permanent breakpoint.
1838 - When continuing from a location with an ordinary breakpoint, we
1839 actually single step once before calling insert_breakpoints.
1840 - When continuing from a localion with a permanent breakpoint, we
1841 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1842 the target, to advance the PC past the breakpoint. */
1844 enum breakpoint_here
1845 breakpoint_here_p (CORE_ADDR pc
)
1847 const struct bp_location
*bpt
;
1848 int any_breakpoint_here
= 0;
1850 ALL_BP_LOCATIONS (bpt
)
1852 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1853 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1856 if ((breakpoint_enabled (bpt
->owner
)
1857 || bpt
->owner
->enable_state
== bp_permanent
)
1858 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1860 if (overlay_debugging
1861 && section_is_overlay (bpt
->section
)
1862 && !section_is_mapped (bpt
->section
))
1863 continue; /* unmapped overlay -- can't be a match */
1864 else if (bpt
->owner
->enable_state
== bp_permanent
)
1865 return permanent_breakpoint_here
;
1867 any_breakpoint_here
= 1;
1871 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1874 /* Return true if there's a moribund breakpoint at PC. */
1877 moribund_breakpoint_here_p (CORE_ADDR pc
)
1879 struct bp_location
*loc
;
1882 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
1883 if (loc
->address
== pc
)
1889 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1890 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1891 This does not check for single-step breakpoints, which are
1892 inserted and removed using direct target manipulation. */
1895 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1897 const struct bp_location
*bpt
;
1899 ALL_BP_LOCATIONS (bpt
)
1901 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1902 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1906 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1908 if (overlay_debugging
1909 && section_is_overlay (bpt
->section
)
1910 && !section_is_mapped (bpt
->section
))
1911 continue; /* unmapped overlay -- can't be a match */
1919 /* Returns non-zero iff there's either regular breakpoint
1920 or a single step breakpoint inserted at PC. */
1923 breakpoint_inserted_here_p (CORE_ADDR pc
)
1925 if (regular_breakpoint_inserted_here_p (pc
))
1928 if (single_step_breakpoint_inserted_here_p (pc
))
1934 /* This function returns non-zero iff there is a software breakpoint
1938 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1940 const struct bp_location
*bpt
;
1941 int any_breakpoint_here
= 0;
1943 ALL_BP_LOCATIONS (bpt
)
1945 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1949 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1951 if (overlay_debugging
1952 && section_is_overlay (bpt
->section
)
1953 && !section_is_mapped (bpt
->section
))
1954 continue; /* unmapped overlay -- can't be a match */
1960 /* Also check for software single-step breakpoints. */
1961 if (single_step_breakpoint_inserted_here_p (pc
))
1967 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1968 PC is valid for process/thread PTID. */
1971 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1973 const struct bp_location
*bpt
;
1974 /* The thread and task IDs associated to PTID, computed lazily. */
1978 ALL_BP_LOCATIONS (bpt
)
1980 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1981 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1984 if (!breakpoint_enabled (bpt
->owner
)
1985 && bpt
->owner
->enable_state
!= bp_permanent
)
1988 if (bpt
->address
!= pc
)
1991 if (bpt
->owner
->thread
!= -1)
1993 /* This is a thread-specific breakpoint. Check that ptid
1994 matches that thread. If thread hasn't been computed yet,
1995 it is now time to do so. */
1997 thread
= pid_to_thread_id (ptid
);
1998 if (bpt
->owner
->thread
!= thread
)
2002 if (bpt
->owner
->task
!= 0)
2004 /* This is a task-specific breakpoint. Check that ptid
2005 matches that task. If task hasn't been computed yet,
2006 it is now time to do so. */
2008 task
= ada_get_task_number (ptid
);
2009 if (bpt
->owner
->task
!= task
)
2013 if (overlay_debugging
2014 && section_is_overlay (bpt
->section
)
2015 && !section_is_mapped (bpt
->section
))
2016 continue; /* unmapped overlay -- can't be a match */
2025 /* bpstat stuff. External routines' interfaces are documented
2029 ep_is_catchpoint (struct breakpoint
*ep
)
2031 return (ep
->type
== bp_catchpoint
);
2035 bpstat_free (bpstat bs
)
2037 if (bs
->old_val
!= NULL
)
2038 value_free (bs
->old_val
);
2039 free_command_lines (&bs
->commands
);
2043 /* Clear a bpstat so that it says we are not at any breakpoint.
2044 Also free any storage that is part of a bpstat. */
2047 bpstat_clear (bpstat
*bsp
)
2064 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
2065 is part of the bpstat is copied as well. */
2068 bpstat_copy (bpstat bs
)
2072 bpstat retval
= NULL
;
2077 for (; bs
!= NULL
; bs
= bs
->next
)
2079 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
2080 memcpy (tmp
, bs
, sizeof (*tmp
));
2081 if (bs
->commands
!= NULL
)
2082 tmp
->commands
= copy_command_lines (bs
->commands
);
2083 if (bs
->old_val
!= NULL
)
2085 tmp
->old_val
= value_copy (bs
->old_val
);
2086 release_value (tmp
->old_val
);
2090 /* This is the first thing in the chain. */
2100 /* Find the bpstat associated with this breakpoint */
2103 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2108 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2110 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2116 /* Find a step_resume breakpoint associated with this bpstat.
2117 (If there are multiple step_resume bp's on the list, this function
2118 will arbitrarily pick one.)
2120 It is an error to use this function if BPSTAT doesn't contain a
2121 step_resume breakpoint.
2123 See wait_for_inferior's use of this function. */
2125 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2129 gdb_assert (bsp
!= NULL
);
2131 current_thread
= pid_to_thread_id (inferior_ptid
);
2133 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2135 if ((bsp
->breakpoint_at
!= NULL
) &&
2136 (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
) &&
2137 (bsp
->breakpoint_at
->owner
->thread
== current_thread
||
2138 bsp
->breakpoint_at
->owner
->thread
== -1))
2139 return bsp
->breakpoint_at
->owner
;
2142 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2146 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2147 at. *BSP upon return is a bpstat which points to the remaining
2148 breakpoints stopped at (but which is not guaranteed to be good for
2149 anything but further calls to bpstat_num).
2150 Return 0 if passed a bpstat which does not indicate any breakpoints.
2151 Return -1 if stopped at a breakpoint that has been deleted since
2153 Return 1 otherwise. */
2156 bpstat_num (bpstat
*bsp
, int *num
)
2158 struct breakpoint
*b
;
2161 return 0; /* No more breakpoint values */
2163 /* We assume we'll never have several bpstats that
2164 correspond to a single breakpoint -- otherwise,
2165 this function might return the same number more
2166 than once and this will look ugly. */
2167 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2168 *bsp
= (*bsp
)->next
;
2170 return -1; /* breakpoint that's been deleted since */
2172 *num
= b
->number
; /* We have its number */
2176 /* Modify BS so that the actions will not be performed. */
2179 bpstat_clear_actions (bpstat bs
)
2181 for (; bs
!= NULL
; bs
= bs
->next
)
2183 free_command_lines (&bs
->commands
);
2184 if (bs
->old_val
!= NULL
)
2186 value_free (bs
->old_val
);
2192 /* Called when a command is about to proceed the inferior. */
2195 breakpoint_about_to_proceed (void)
2197 if (!ptid_equal (inferior_ptid
, null_ptid
))
2199 struct thread_info
*tp
= inferior_thread ();
2201 /* Allow inferior function calls in breakpoint commands to not
2202 interrupt the command list. When the call finishes
2203 successfully, the inferior will be standing at the same
2204 breakpoint as if nothing happened. */
2209 breakpoint_proceeded
= 1;
2212 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2214 cleanup_executing_breakpoints (void *ignore
)
2216 executing_breakpoint_commands
= 0;
2219 /* Execute all the commands associated with all the breakpoints at this
2220 location. Any of these commands could cause the process to proceed
2221 beyond this point, etc. We look out for such changes by checking
2222 the global "breakpoint_proceeded" after each command.
2224 Returns true if a breakpoint command resumed the inferior. In that
2225 case, it is the caller's responsibility to recall it again with the
2226 bpstat of the current thread. */
2229 bpstat_do_actions_1 (bpstat
*bsp
)
2232 struct cleanup
*old_chain
;
2235 /* Avoid endless recursion if a `source' command is contained
2237 if (executing_breakpoint_commands
)
2240 executing_breakpoint_commands
= 1;
2241 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2243 /* This pointer will iterate over the list of bpstat's. */
2246 breakpoint_proceeded
= 0;
2247 for (; bs
!= NULL
; bs
= bs
->next
)
2249 struct command_line
*cmd
;
2250 struct cleanup
*this_cmd_tree_chain
;
2252 /* Take ownership of the BSP's command tree, if it has one.
2254 The command tree could legitimately contain commands like
2255 'step' and 'next', which call clear_proceed_status, which
2256 frees stop_bpstat's command tree. To make sure this doesn't
2257 free the tree we're executing out from under us, we need to
2258 take ownership of the tree ourselves. Since a given bpstat's
2259 commands are only executed once, we don't need to copy it; we
2260 can clear the pointer in the bpstat, and make sure we free
2261 the tree when we're done. */
2264 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2268 execute_control_command (cmd
);
2270 if (breakpoint_proceeded
)
2276 /* We can free this command tree now. */
2277 do_cleanups (this_cmd_tree_chain
);
2279 if (breakpoint_proceeded
)
2281 if (target_can_async_p ())
2282 /* If we are in async mode, then the target might be still
2283 running, not stopped at any breakpoint, so nothing for
2284 us to do here -- just return to the event loop. */
2287 /* In sync mode, when execute_control_command returns
2288 we're already standing on the next breakpoint.
2289 Breakpoint commands for that stop were not run, since
2290 execute_command does not run breakpoint commands --
2291 only command_line_handler does, but that one is not
2292 involved in execution of breakpoint commands. So, we
2293 can now execute breakpoint commands. It should be
2294 noted that making execute_command do bpstat actions is
2295 not an option -- in this case we'll have recursive
2296 invocation of bpstat for each breakpoint with a
2297 command, and can easily blow up GDB stack. Instead, we
2298 return true, which will trigger the caller to recall us
2299 with the new stop_bpstat. */
2304 do_cleanups (old_chain
);
2309 bpstat_do_actions (void)
2311 /* Do any commands attached to breakpoint we are stopped at. */
2312 while (!ptid_equal (inferior_ptid
, null_ptid
)
2313 && target_has_execution
2314 && !is_exited (inferior_ptid
)
2315 && !is_executing (inferior_ptid
))
2316 /* Since in sync mode, bpstat_do_actions may resume the inferior,
2317 and only return when it is stopped at the next breakpoint, we
2318 keep doing breakpoint actions until it returns false to
2319 indicate the inferior was not resumed. */
2320 if (!bpstat_do_actions_1 (&inferior_thread ()->stop_bpstat
))
2324 /* Print out the (old or new) value associated with a watchpoint. */
2327 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2330 fprintf_unfiltered (stream
, _("<unreadable>"));
2333 struct value_print_options opts
;
2334 get_user_print_options (&opts
);
2335 value_print (val
, stream
, &opts
);
2339 /* This is the normal print function for a bpstat. In the future,
2340 much of this logic could (should?) be moved to bpstat_stop_status,
2341 by having it set different print_it values.
2343 Current scheme: When we stop, bpstat_print() is called. It loops
2344 through the bpstat list of things causing this stop, calling the
2345 print_bp_stop_message function on each one. The behavior of the
2346 print_bp_stop_message function depends on the print_it field of
2347 bpstat. If such field so indicates, call this function here.
2349 Return values from this routine (ultimately used by bpstat_print()
2350 and normal_stop() to decide what to do):
2351 PRINT_NOTHING: Means we already printed all we needed to print,
2352 don't print anything else.
2353 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2354 that something to be followed by a location.
2355 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2356 that something to be followed by a location.
2357 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2360 static enum print_stop_action
2361 print_it_typical (bpstat bs
)
2363 struct cleanup
*old_chain
;
2364 struct breakpoint
*b
;
2365 const struct bp_location
*bl
;
2366 struct ui_stream
*stb
;
2368 enum print_stop_action result
;
2370 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2371 which has since been deleted. */
2372 if (bs
->breakpoint_at
== NULL
)
2373 return PRINT_UNKNOWN
;
2374 bl
= bs
->breakpoint_at
;
2377 stb
= ui_out_stream_new (uiout
);
2378 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2383 case bp_hardware_breakpoint
:
2384 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2385 if (bl
->address
!= bl
->requested_address
)
2386 breakpoint_adjustment_warning (bl
->requested_address
,
2389 annotate_breakpoint (b
->number
);
2391 ui_out_text (uiout
, "\nTemporary breakpoint ");
2393 ui_out_text (uiout
, "\nBreakpoint ");
2394 if (ui_out_is_mi_like_p (uiout
))
2396 ui_out_field_string (uiout
, "reason",
2397 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2398 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2400 ui_out_field_int (uiout
, "bkptno", b
->number
);
2401 ui_out_text (uiout
, ", ");
2402 result
= PRINT_SRC_AND_LOC
;
2405 case bp_shlib_event
:
2406 /* Did we stop because the user set the stop_on_solib_events
2407 variable? (If so, we report this as a generic, "Stopped due
2408 to shlib event" message.) */
2409 printf_filtered (_("Stopped due to shared library event\n"));
2410 result
= PRINT_NOTHING
;
2413 case bp_thread_event
:
2414 /* Not sure how we will get here.
2415 GDB should not stop for these breakpoints. */
2416 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2417 result
= PRINT_NOTHING
;
2420 case bp_overlay_event
:
2421 /* By analogy with the thread event, GDB should not stop for these. */
2422 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2423 result
= PRINT_NOTHING
;
2427 case bp_hardware_watchpoint
:
2428 annotate_watchpoint (b
->number
);
2429 if (ui_out_is_mi_like_p (uiout
))
2432 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2434 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2435 ui_out_text (uiout
, "\nOld value = ");
2436 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2437 ui_out_field_stream (uiout
, "old", stb
);
2438 ui_out_text (uiout
, "\nNew value = ");
2439 watchpoint_value_print (b
->val
, stb
->stream
);
2440 ui_out_field_stream (uiout
, "new", stb
);
2441 ui_out_text (uiout
, "\n");
2442 /* More than one watchpoint may have been triggered. */
2443 result
= PRINT_UNKNOWN
;
2446 case bp_read_watchpoint
:
2447 if (ui_out_is_mi_like_p (uiout
))
2450 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2452 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2453 ui_out_text (uiout
, "\nValue = ");
2454 watchpoint_value_print (b
->val
, stb
->stream
);
2455 ui_out_field_stream (uiout
, "value", stb
);
2456 ui_out_text (uiout
, "\n");
2457 result
= PRINT_UNKNOWN
;
2460 case bp_access_watchpoint
:
2461 if (bs
->old_val
!= NULL
)
2463 annotate_watchpoint (b
->number
);
2464 if (ui_out_is_mi_like_p (uiout
))
2467 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2469 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2470 ui_out_text (uiout
, "\nOld value = ");
2471 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2472 ui_out_field_stream (uiout
, "old", stb
);
2473 ui_out_text (uiout
, "\nNew value = ");
2478 if (ui_out_is_mi_like_p (uiout
))
2481 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2482 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2483 ui_out_text (uiout
, "\nValue = ");
2485 watchpoint_value_print (b
->val
, stb
->stream
);
2486 ui_out_field_stream (uiout
, "new", stb
);
2487 ui_out_text (uiout
, "\n");
2488 result
= PRINT_UNKNOWN
;
2491 /* Fall through, we don't deal with these types of breakpoints
2495 if (ui_out_is_mi_like_p (uiout
))
2498 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2499 result
= PRINT_UNKNOWN
;
2503 if (ui_out_is_mi_like_p (uiout
))
2506 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2507 result
= PRINT_UNKNOWN
;
2512 case bp_longjmp_resume
:
2513 case bp_step_resume
:
2514 case bp_watchpoint_scope
:
2518 result
= PRINT_UNKNOWN
;
2522 do_cleanups (old_chain
);
2526 /* Generic routine for printing messages indicating why we
2527 stopped. The behavior of this function depends on the value
2528 'print_it' in the bpstat structure. Under some circumstances we
2529 may decide not to print anything here and delegate the task to
2532 static enum print_stop_action
2533 print_bp_stop_message (bpstat bs
)
2535 switch (bs
->print_it
)
2538 /* Nothing should be printed for this bpstat entry. */
2539 return PRINT_UNKNOWN
;
2543 /* We still want to print the frame, but we already printed the
2544 relevant messages. */
2545 return PRINT_SRC_AND_LOC
;
2548 case print_it_normal
:
2550 const struct bp_location
*bl
= bs
->breakpoint_at
;
2551 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2553 /* Normal case. Call the breakpoint's print_it method, or
2554 print_it_typical. */
2555 /* FIXME: how breakpoint can ever be NULL here? */
2556 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2557 return b
->ops
->print_it (b
);
2559 return print_it_typical (bs
);
2564 internal_error (__FILE__
, __LINE__
,
2565 _("print_bp_stop_message: unrecognized enum value"));
2570 /* Print a message indicating what happened. This is called from
2571 normal_stop(). The input to this routine is the head of the bpstat
2572 list - a list of the eventpoints that caused this stop. This
2573 routine calls the generic print routine for printing a message
2574 about reasons for stopping. This will print (for example) the
2575 "Breakpoint n," part of the output. The return value of this
2578 PRINT_UNKNOWN: Means we printed nothing
2579 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2580 code to print the location. An example is
2581 "Breakpoint 1, " which should be followed by
2583 PRINT_SRC_ONLY: Means we printed something, but there is no need
2584 to also print the location part of the message.
2585 An example is the catch/throw messages, which
2586 don't require a location appended to the end.
2587 PRINT_NOTHING: We have done some printing and we don't need any
2588 further info to be printed.*/
2590 enum print_stop_action
2591 bpstat_print (bpstat bs
)
2595 /* Maybe another breakpoint in the chain caused us to stop.
2596 (Currently all watchpoints go on the bpstat whether hit or not.
2597 That probably could (should) be changed, provided care is taken
2598 with respect to bpstat_explains_signal). */
2599 for (; bs
; bs
= bs
->next
)
2601 val
= print_bp_stop_message (bs
);
2602 if (val
== PRINT_SRC_ONLY
2603 || val
== PRINT_SRC_AND_LOC
2604 || val
== PRINT_NOTHING
)
2608 /* We reached the end of the chain, or we got a null BS to start
2609 with and nothing was printed. */
2610 return PRINT_UNKNOWN
;
2613 /* Evaluate the expression EXP and return 1 if value is zero.
2614 This is used inside a catch_errors to evaluate the breakpoint condition.
2615 The argument is a "struct expression *" that has been cast to char * to
2616 make it pass through catch_errors. */
2619 breakpoint_cond_eval (void *exp
)
2621 struct value
*mark
= value_mark ();
2622 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2623 value_free_to_mark (mark
);
2627 /* Allocate a new bpstat and chain it to the current one. */
2630 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2634 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2636 bs
->breakpoint_at
= bl
;
2637 /* If the condition is false, etc., don't do the commands. */
2638 bs
->commands
= NULL
;
2640 bs
->print_it
= print_it_normal
;
2644 /* The target has stopped with waitstatus WS. Check if any hardware
2645 watchpoints have triggered, according to the target. */
2648 watchpoints_triggered (struct target_waitstatus
*ws
)
2650 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
2652 struct breakpoint
*b
;
2654 if (!stopped_by_watchpoint
)
2656 /* We were not stopped by a watchpoint. Mark all watchpoints
2657 as not triggered. */
2659 if (b
->type
== bp_hardware_watchpoint
2660 || b
->type
== bp_read_watchpoint
2661 || b
->type
== bp_access_watchpoint
)
2662 b
->watchpoint_triggered
= watch_triggered_no
;
2667 if (!target_stopped_data_address (¤t_target
, &addr
))
2669 /* We were stopped by a watchpoint, but we don't know where.
2670 Mark all watchpoints as unknown. */
2672 if (b
->type
== bp_hardware_watchpoint
2673 || b
->type
== bp_read_watchpoint
2674 || b
->type
== bp_access_watchpoint
)
2675 b
->watchpoint_triggered
= watch_triggered_unknown
;
2677 return stopped_by_watchpoint
;
2680 /* The target could report the data address. Mark watchpoints
2681 affected by this data address as triggered, and all others as not
2685 if (b
->type
== bp_hardware_watchpoint
2686 || b
->type
== bp_read_watchpoint
2687 || b
->type
== bp_access_watchpoint
)
2689 struct bp_location
*loc
;
2692 b
->watchpoint_triggered
= watch_triggered_no
;
2693 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2694 /* Exact match not required. Within range is
2696 if (target_watchpoint_addr_within_range (¤t_target
,
2700 b
->watchpoint_triggered
= watch_triggered_yes
;
2708 /* Possible return values for watchpoint_check (this can't be an enum
2709 because of check_errors). */
2710 /* The watchpoint has been deleted. */
2711 #define WP_DELETED 1
2712 /* The value has changed. */
2713 #define WP_VALUE_CHANGED 2
2714 /* The value has not changed. */
2715 #define WP_VALUE_NOT_CHANGED 3
2717 #define BP_TEMPFLAG 1
2718 #define BP_HARDWAREFLAG 2
2720 /* Check watchpoint condition. */
2723 watchpoint_check (void *p
)
2725 bpstat bs
= (bpstat
) p
;
2726 struct breakpoint
*b
;
2727 struct frame_info
*fr
;
2728 int within_current_scope
;
2730 b
= bs
->breakpoint_at
->owner
;
2732 if (b
->exp_valid_block
== NULL
)
2733 within_current_scope
= 1;
2736 /* There is no current frame at this moment. If we're going to have
2737 any chance of handling watchpoints on local variables, we'll need
2738 the frame chain (so we can determine if we're in scope). */
2739 reinit_frame_cache ();
2740 fr
= frame_find_by_id (b
->watchpoint_frame
);
2741 within_current_scope
= (fr
!= NULL
);
2743 /* If we've gotten confused in the unwinder, we might have
2744 returned a frame that can't describe this variable. */
2745 if (within_current_scope
2746 && (block_linkage_function (b
->exp_valid_block
)
2747 != get_frame_function (fr
)))
2748 within_current_scope
= 0;
2750 /* in_function_epilogue_p() returns a non-zero value if we're still
2751 in the function but the stack frame has already been invalidated.
2752 Since we can't rely on the values of local variables after the
2753 stack has been destroyed, we are treating the watchpoint in that
2754 state as `not changed' without further checking.
2756 vinschen/2003-09-04: The former implementation left out the case
2757 that the watchpoint frame couldn't be found by frame_find_by_id()
2758 because the current PC is currently in an epilogue. Calling
2759 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2760 if (!within_current_scope
|| fr
== get_current_frame ())
2762 struct frame_info
*frame
= get_current_frame ();
2763 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
2764 CORE_ADDR frame_pc
= get_frame_pc (frame
);
2766 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
2767 return WP_VALUE_NOT_CHANGED
;
2769 if (fr
&& within_current_scope
)
2770 /* If we end up stopping, the current frame will get selected
2771 in normal_stop. So this call to select_frame won't affect
2776 if (within_current_scope
)
2778 /* We use value_{,free_to_}mark because it could be a
2779 *long* time before we return to the command level and
2780 call free_all_values. We can't call free_all_values because
2781 we might be in the middle of evaluating a function call. */
2783 struct value
*mark
= value_mark ();
2784 struct value
*new_val
;
2786 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2787 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2788 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2790 if (new_val
!= NULL
)
2792 release_value (new_val
);
2793 value_free_to_mark (mark
);
2795 bs
->old_val
= b
->val
;
2798 /* We will stop here */
2799 return WP_VALUE_CHANGED
;
2803 /* Nothing changed, don't do anything. */
2804 value_free_to_mark (mark
);
2805 /* We won't stop here */
2806 return WP_VALUE_NOT_CHANGED
;
2811 /* This seems like the only logical thing to do because
2812 if we temporarily ignored the watchpoint, then when
2813 we reenter the block in which it is valid it contains
2814 garbage (in the case of a function, it may have two
2815 garbage values, one before and one after the prologue).
2816 So we can't even detect the first assignment to it and
2817 watch after that (since the garbage may or may not equal
2818 the first value assigned). */
2819 /* We print all the stop information in print_it_typical(), but
2820 in this case, by the time we call print_it_typical() this bp
2821 will be deleted already. So we have no choice but print the
2822 information here. */
2823 if (ui_out_is_mi_like_p (uiout
))
2825 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2826 ui_out_text (uiout
, "\nWatchpoint ");
2827 ui_out_field_int (uiout
, "wpnum", b
->number
);
2828 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2829 which its expression is valid.\n");
2831 if (b
->related_breakpoint
)
2832 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2833 b
->disposition
= disp_del_at_next_stop
;
2839 /* Return true if it looks like target has stopped due to hitting
2840 breakpoint location BL. This function does not check if we
2841 should stop, only if BL explains the stop. */
2843 bpstat_check_location (const struct bp_location
*bl
, CORE_ADDR bp_addr
)
2845 struct breakpoint
*b
= bl
->owner
;
2847 if (b
->type
!= bp_watchpoint
2848 && b
->type
!= bp_hardware_watchpoint
2849 && b
->type
!= bp_read_watchpoint
2850 && b
->type
!= bp_access_watchpoint
2851 && b
->type
!= bp_hardware_breakpoint
2852 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
2854 if (bl
->address
!= bp_addr
) /* address doesn't match */
2856 if (overlay_debugging
/* unmapped overlay section */
2857 && section_is_overlay (bl
->section
)
2858 && !section_is_mapped (bl
->section
))
2862 /* Continuable hardware watchpoints are treated as non-existent if the
2863 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2864 some data address). Otherwise gdb won't stop on a break instruction
2865 in the code (not from a breakpoint) when a hardware watchpoint has
2866 been defined. Also skip watchpoints which we know did not trigger
2867 (did not match the data address). */
2869 if ((b
->type
== bp_hardware_watchpoint
2870 || b
->type
== bp_read_watchpoint
2871 || b
->type
== bp_access_watchpoint
)
2872 && b
->watchpoint_triggered
== watch_triggered_no
)
2875 if (b
->type
== bp_hardware_breakpoint
)
2877 if (bl
->address
!= bp_addr
)
2879 if (overlay_debugging
/* unmapped overlay section */
2880 && section_is_overlay (bl
->section
)
2881 && !section_is_mapped (bl
->section
))
2885 if (b
->type
== bp_catchpoint
)
2887 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
2888 if (!b
->ops
->breakpoint_hit (b
))
2895 /* If BS refers to a watchpoint, determine if the watched values
2896 has actually changed, and we should stop. If not, set BS->stop
2899 bpstat_check_watchpoint (bpstat bs
)
2901 const struct bp_location
*bl
= bs
->breakpoint_at
;
2902 struct breakpoint
*b
= bl
->owner
;
2904 if (b
->type
== bp_watchpoint
2905 || b
->type
== bp_read_watchpoint
2906 || b
->type
== bp_access_watchpoint
2907 || b
->type
== bp_hardware_watchpoint
)
2911 int must_check_value
= 0;
2913 if (b
->type
== bp_watchpoint
)
2914 /* For a software watchpoint, we must always check the
2916 must_check_value
= 1;
2917 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2918 /* We have a hardware watchpoint (read, write, or access)
2919 and the target earlier reported an address watched by
2921 must_check_value
= 1;
2922 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2923 && b
->type
== bp_hardware_watchpoint
)
2924 /* We were stopped by a hardware watchpoint, but the target could
2925 not report the data address. We must check the watchpoint's
2926 value. Access and read watchpoints are out of luck; without
2927 a data address, we can't figure it out. */
2928 must_check_value
= 1;
2930 if (must_check_value
)
2932 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2934 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2935 int e
= catch_errors (watchpoint_check
, bs
, message
,
2937 do_cleanups (cleanups
);
2941 /* We've already printed what needs to be printed. */
2942 bs
->print_it
= print_it_done
;
2945 case WP_VALUE_CHANGED
:
2946 if (b
->type
== bp_read_watchpoint
)
2948 /* Don't stop: read watchpoints shouldn't fire if
2949 the value has changed. This is for targets
2950 which cannot set read-only watchpoints. */
2951 bs
->print_it
= print_it_noop
;
2955 case WP_VALUE_NOT_CHANGED
:
2956 if (b
->type
== bp_hardware_watchpoint
2957 || b
->type
== bp_watchpoint
)
2959 /* Don't stop: write watchpoints shouldn't fire if
2960 the value hasn't changed. */
2961 bs
->print_it
= print_it_noop
;
2969 /* Error from catch_errors. */
2970 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2971 if (b
->related_breakpoint
)
2972 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2973 b
->disposition
= disp_del_at_next_stop
;
2974 /* We've already printed what needs to be printed. */
2975 bs
->print_it
= print_it_done
;
2979 else /* must_check_value == 0 */
2981 /* This is a case where some watchpoint(s) triggered, but
2982 not at the address of this watchpoint, or else no
2983 watchpoint triggered after all. So don't print
2984 anything for this watchpoint. */
2985 bs
->print_it
= print_it_noop
;
2992 /* Check conditions (condition proper, frame, thread and ignore count)
2993 of breakpoint referred to by BS. If we should not stop for this
2994 breakpoint, set BS->stop to 0. */
2996 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
2998 int thread_id
= pid_to_thread_id (ptid
);
2999 const struct bp_location
*bl
= bs
->breakpoint_at
;
3000 struct breakpoint
*b
= bl
->owner
;
3002 if (frame_id_p (b
->frame_id
)
3003 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
3007 int value_is_zero
= 0;
3009 /* If this is a scope breakpoint, mark the associated
3010 watchpoint as triggered so that we will handle the
3011 out-of-scope event. We'll get to the watchpoint next
3013 if (b
->type
== bp_watchpoint_scope
)
3014 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
3016 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
3018 /* We use value_mark and value_free_to_mark because it could
3019 be a long time before we return to the command level and
3020 call free_all_values. We can't call free_all_values
3021 because we might be in the middle of evaluating a
3023 struct value
*mark
= value_mark ();
3025 /* Need to select the frame, with all that implies
3026 so that the conditions will have the right context. */
3027 select_frame (get_current_frame ());
3029 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
3030 "Error in testing breakpoint condition:\n",
3032 /* FIXME-someday, should give breakpoint # */
3033 value_free_to_mark (mark
);
3035 if (bl
->cond
&& value_is_zero
)
3039 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
3043 else if (b
->ignore_count
> 0)
3046 annotate_ignore_count_change ();
3048 /* Increase the hit count even though we don't
3056 /* Get a bpstat associated with having just stopped at address
3057 BP_ADDR in thread PTID.
3059 Determine whether we stopped at a breakpoint, etc, or whether we
3060 don't understand this stop. Result is a chain of bpstat's such that:
3062 if we don't understand the stop, the result is a null pointer.
3064 if we understand why we stopped, the result is not null.
3066 Each element of the chain refers to a particular breakpoint or
3067 watchpoint at which we have stopped. (We may have stopped for
3068 several reasons concurrently.)
3070 Each element of the chain has valid next, breakpoint_at,
3071 commands, FIXME??? fields. */
3074 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
3076 struct breakpoint
*b
= NULL
;
3077 const struct bp_location
*bl
;
3078 struct bp_location
*loc
;
3079 /* Root of the chain of bpstat's */
3080 struct bpstats root_bs
[1];
3081 /* Pointer to the last thing in the chain currently. */
3082 bpstat bs
= root_bs
;
3084 int need_remove_insert
;
3086 ALL_BP_LOCATIONS (bl
)
3090 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3093 /* For hardware watchpoints, we look only at the first location.
3094 The watchpoint_check function will work on entire expression,
3095 not the individual locations. For read watchopints, the
3096 watchpoints_triggered function have checked all locations
3099 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3102 if (!bpstat_check_location (bl
, bp_addr
))
3105 /* Come here if it's a watchpoint, or if the break address matches */
3107 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3109 /* Assume we stop. Should we find watchpoint that is not actually
3110 triggered, or if condition of breakpoint is false, we'll reset
3115 bpstat_check_watchpoint (bs
);
3119 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
3120 /* We do not stop for these. */
3123 bpstat_check_breakpoint_conditions (bs
, ptid
);
3129 /* We will stop here */
3130 if (b
->disposition
== disp_disable
)
3132 if (b
->enable_state
!= bp_permanent
)
3133 b
->enable_state
= bp_disabled
;
3134 update_global_location_list (0);
3138 bs
->commands
= b
->commands
;
3140 (strcmp ("silent", bs
->commands
->line
) == 0
3141 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3143 bs
->commands
= bs
->commands
->next
;
3146 bs
->commands
= copy_command_lines (bs
->commands
);
3149 /* Print nothing for this entry if we dont stop or if we dont print. */
3150 if (bs
->stop
== 0 || bs
->print
== 0)
3151 bs
->print_it
= print_it_noop
;
3154 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
3156 if (loc
->address
== bp_addr
)
3158 bs
= bpstat_alloc (loc
, bs
);
3159 /* For hits of moribund locations, we should just proceed. */
3162 bs
->print_it
= print_it_noop
;
3166 bs
->next
= NULL
; /* Terminate the chain */
3167 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3169 /* If we aren't stopping, the value of some hardware watchpoint may
3170 not have changed, but the intermediate memory locations we are
3171 watching may have. Don't bother if we're stopping; this will get
3173 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3177 need_remove_insert
= 0;
3179 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3181 && bs
->breakpoint_at
->owner
3182 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3183 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3184 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3186 /* remove/insert can invalidate bs->breakpoint_at, if this
3187 location is no longer used by the watchpoint. Prevent
3188 further code from trying to use it. */
3189 bs
->breakpoint_at
= NULL
;
3190 need_remove_insert
= 1;
3193 if (need_remove_insert
)
3195 remove_breakpoints ();
3196 insert_breakpoints ();
3199 return root_bs
->next
;
3202 /* Tell what to do about this bpstat. */
3204 bpstat_what (bpstat bs
)
3206 /* Classify each bpstat as one of the following. */
3209 /* This bpstat element has no effect on the main_action. */
3212 /* There was a watchpoint, stop but don't print. */
3215 /* There was a watchpoint, stop and print. */
3218 /* There was a breakpoint but we're not stopping. */
3221 /* There was a breakpoint, stop but don't print. */
3224 /* There was a breakpoint, stop and print. */
3227 /* We hit the longjmp breakpoint. */
3230 /* We hit the longjmp_resume breakpoint. */
3233 /* We hit the step_resume breakpoint. */
3236 /* We hit the shared library event breakpoint. */
3239 /* This is just used to count how many enums there are. */
3243 /* Here is the table which drives this routine. So that we can
3244 format it pretty, we define some abbreviations for the
3245 enum bpstat_what codes. */
3246 #define kc BPSTAT_WHAT_KEEP_CHECKING
3247 #define ss BPSTAT_WHAT_STOP_SILENT
3248 #define sn BPSTAT_WHAT_STOP_NOISY
3249 #define sgl BPSTAT_WHAT_SINGLE
3250 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3251 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3252 #define sr BPSTAT_WHAT_STEP_RESUME
3253 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3255 /* "Can't happen." Might want to print an error message.
3256 abort() is not out of the question, but chances are GDB is just
3257 a bit confused, not unusable. */
3258 #define err BPSTAT_WHAT_STOP_NOISY
3260 /* Given an old action and a class, come up with a new action. */
3261 /* One interesting property of this table is that wp_silent is the same
3262 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3263 after stopping, the check for whether to step over a breakpoint
3264 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3265 reference to how we stopped. We retain separate wp_silent and
3266 bp_silent codes in case we want to change that someday.
3268 Another possibly interesting property of this table is that
3269 there's a partial ordering, priority-like, of the actions. Once
3270 you've decided that some action is appropriate, you'll never go
3271 back and decide something of a lower priority is better. The
3274 kc < clr sgl shl slr sn sr ss
3275 sgl < shl slr sn sr ss
3276 slr < err shl sn sr ss
3277 clr < err shl sn sr ss
3283 What I think this means is that we don't need a damned table
3284 here. If you just put the rows and columns in the right order,
3285 it'd look awfully regular. We could simply walk the bpstat list
3286 and choose the highest priority action we find, with a little
3287 logic to handle the 'err' cases. */
3289 /* step_resume entries: a step resume breakpoint overrides another
3290 breakpoint of signal handling (see comment in wait_for_inferior
3291 at where we set the step_resume breakpoint). */
3293 static const enum bpstat_what_main_action
3294 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3297 /* kc ss sn sgl slr clr sr shl
3300 {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
},
3302 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3304 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3306 {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
},
3308 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3310 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3312 {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
},
3314 {clr
, ss
, sn
, err
, err
, err
, sr
, shl
},
3316 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3318 {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
}
3331 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3332 struct bpstat_what retval
;
3334 retval
.call_dummy
= 0;
3335 for (; bs
!= NULL
; bs
= bs
->next
)
3337 enum class bs_class
= no_effect
;
3338 if (bs
->breakpoint_at
== NULL
)
3339 /* I suspect this can happen if it was a momentary breakpoint
3340 which has since been deleted. */
3342 if (bs
->breakpoint_at
->owner
== NULL
)
3343 bs_class
= bp_nostop
;
3345 switch (bs
->breakpoint_at
->owner
->type
)
3351 case bp_hardware_breakpoint
:
3357 bs_class
= bp_noisy
;
3359 bs_class
= bp_silent
;
3362 bs_class
= bp_nostop
;
3365 case bp_hardware_watchpoint
:
3366 case bp_read_watchpoint
:
3367 case bp_access_watchpoint
:
3371 bs_class
= wp_noisy
;
3373 bs_class
= wp_silent
;
3376 /* There was a watchpoint, but we're not stopping.
3377 This requires no further action. */
3378 bs_class
= no_effect
;
3381 bs_class
= long_jump
;
3383 case bp_longjmp_resume
:
3384 bs_class
= long_resume
;
3386 case bp_step_resume
:
3389 bs_class
= step_resume
;
3392 /* It is for the wrong frame. */
3393 bs_class
= bp_nostop
;
3395 case bp_watchpoint_scope
:
3396 bs_class
= bp_nostop
;
3398 case bp_shlib_event
:
3399 bs_class
= shlib_event
;
3401 case bp_thread_event
:
3402 case bp_overlay_event
:
3403 bs_class
= bp_nostop
;
3409 bs_class
= bp_noisy
;
3411 bs_class
= bp_silent
;
3414 /* There was a catchpoint, but we're not stopping.
3415 This requires no further action. */
3416 bs_class
= no_effect
;
3419 /* Make sure the action is stop (silent or noisy),
3420 so infrun.c pops the dummy frame. */
3421 bs_class
= bp_silent
;
3422 retval
.call_dummy
= 1;
3425 /* Tracepoint hits should not be reported back to GDB, and
3426 if one got through somehow, it should have been filtered
3428 internal_error (__FILE__
, __LINE__
,
3429 _("bpstat_what: bp_tracepoint encountered"));
3432 current_action
= table
[(int) bs_class
][(int) current_action
];
3434 retval
.main_action
= current_action
;
3438 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3439 without hardware support). This isn't related to a specific bpstat,
3440 just to things like whether watchpoints are set. */
3443 bpstat_should_step (void)
3445 struct breakpoint
*b
;
3447 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
3454 static void print_breakpoint_location (struct breakpoint
*b
,
3455 struct bp_location
*loc
,
3457 struct ui_stream
*stb
)
3462 = find_pc_sect_function (loc
->address
, loc
->section
);
3465 ui_out_text (uiout
, "in ");
3466 ui_out_field_string (uiout
, "func",
3467 SYMBOL_PRINT_NAME (sym
));
3468 ui_out_wrap_hint (uiout
, wrap_indent
);
3469 ui_out_text (uiout
, " at ");
3471 ui_out_field_string (uiout
, "file", b
->source_file
);
3472 ui_out_text (uiout
, ":");
3474 if (ui_out_is_mi_like_p (uiout
))
3476 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3477 char *fullname
= symtab_to_fullname (sal
.symtab
);
3480 ui_out_field_string (uiout
, "fullname", fullname
);
3483 ui_out_field_int (uiout
, "line", b
->line_number
);
3487 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3491 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3492 ui_out_field_stream (uiout
, "at", stb
);
3496 /* Print B to gdb_stdout. */
3498 print_one_breakpoint_location (struct breakpoint
*b
,
3499 struct bp_location
*loc
,
3501 CORE_ADDR
*last_addr
)
3503 struct command_line
*l
;
3505 struct ep_type_description
3510 static struct ep_type_description bptypes
[] =
3512 {bp_none
, "?deleted?"},
3513 {bp_breakpoint
, "breakpoint"},
3514 {bp_hardware_breakpoint
, "hw breakpoint"},
3515 {bp_until
, "until"},
3516 {bp_finish
, "finish"},
3517 {bp_watchpoint
, "watchpoint"},
3518 {bp_hardware_watchpoint
, "hw watchpoint"},
3519 {bp_read_watchpoint
, "read watchpoint"},
3520 {bp_access_watchpoint
, "acc watchpoint"},
3521 {bp_longjmp
, "longjmp"},
3522 {bp_longjmp_resume
, "longjmp resume"},
3523 {bp_step_resume
, "step resume"},
3524 {bp_watchpoint_scope
, "watchpoint scope"},
3525 {bp_call_dummy
, "call dummy"},
3526 {bp_shlib_event
, "shlib events"},
3527 {bp_thread_event
, "thread events"},
3528 {bp_overlay_event
, "overlay events"},
3529 {bp_catchpoint
, "catchpoint"},
3530 {bp_tracepoint
, "tracepoint"},
3533 static char bpenables
[] = "nynny";
3534 char wrap_indent
[80];
3535 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3536 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3537 struct cleanup
*bkpt_chain
;
3539 int header_of_multiple
= 0;
3540 int part_of_multiple
= (loc
!= NULL
);
3541 struct value_print_options opts
;
3543 get_user_print_options (&opts
);
3545 gdb_assert (!loc
|| loc_number
!= 0);
3546 /* See comment in print_one_breakpoint concerning
3547 treatment of breakpoints with single disabled
3551 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3552 header_of_multiple
= 1;
3557 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3561 if (part_of_multiple
)
3564 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3565 ui_out_field_string (uiout
, "number", formatted
);
3570 ui_out_field_int (uiout
, "number", b
->number
);
3575 if (part_of_multiple
)
3576 ui_out_field_skip (uiout
, "type");
3579 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3580 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3581 internal_error (__FILE__
, __LINE__
,
3582 _("bptypes table does not describe type #%d."),
3584 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3589 if (part_of_multiple
)
3590 ui_out_field_skip (uiout
, "disp");
3592 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3597 if (part_of_multiple
)
3598 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3600 ui_out_field_fmt (uiout
, "enabled", "%c",
3601 bpenables
[(int) b
->enable_state
]);
3602 ui_out_spaces (uiout
, 2);
3606 strcpy (wrap_indent
, " ");
3607 if (opts
.addressprint
)
3609 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3610 strcat (wrap_indent
, " ");
3612 strcat (wrap_indent
, " ");
3615 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3617 /* Although the print_one can possibly print
3618 all locations, calling it here is not likely
3619 to get any nice result. So, make sure there's
3620 just one location. */
3621 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3622 b
->ops
->print_one (b
, last_addr
);
3628 internal_error (__FILE__
, __LINE__
,
3629 _("print_one_breakpoint: bp_none encountered\n"));
3633 case bp_hardware_watchpoint
:
3634 case bp_read_watchpoint
:
3635 case bp_access_watchpoint
:
3636 /* Field 4, the address, is omitted (which makes the columns
3637 not line up too nicely with the headers, but the effect
3638 is relatively readable). */
3639 if (opts
.addressprint
)
3640 ui_out_field_skip (uiout
, "addr");
3642 ui_out_field_string (uiout
, "what", b
->exp_string
);
3646 case bp_hardware_breakpoint
:
3650 case bp_longjmp_resume
:
3651 case bp_step_resume
:
3652 case bp_watchpoint_scope
:
3654 case bp_shlib_event
:
3655 case bp_thread_event
:
3656 case bp_overlay_event
:
3658 if (opts
.addressprint
)
3661 if (header_of_multiple
)
3662 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3663 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3664 ui_out_field_string (uiout
, "addr", "<PENDING>");
3666 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3669 if (!header_of_multiple
)
3670 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3672 *last_addr
= b
->loc
->address
;
3676 if (!part_of_multiple
)
3678 if (b
->thread
!= -1)
3680 /* FIXME: This seems to be redundant and lost here; see the
3681 "stop only in" line a little further down. */
3682 ui_out_text (uiout
, " thread ");
3683 ui_out_field_int (uiout
, "thread", b
->thread
);
3685 else if (b
->task
!= 0)
3687 ui_out_text (uiout
, " task ");
3688 ui_out_field_int (uiout
, "task", b
->task
);
3692 ui_out_text (uiout
, "\n");
3694 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3697 ui_out_text (uiout
, "\tstop only in stack frame at ");
3698 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3700 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3701 ui_out_text (uiout
, "\n");
3704 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3706 /* We do not print the condition for Ada exception catchpoints
3707 because the condition is an internal implementation detail
3708 that we do not want to expose to the user. */
3710 if (b
->type
== bp_tracepoint
)
3711 ui_out_text (uiout
, "\ttrace only if ");
3713 ui_out_text (uiout
, "\tstop only if ");
3714 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3715 ui_out_text (uiout
, "\n");
3718 if (!part_of_multiple
&& b
->thread
!= -1)
3720 /* FIXME should make an annotation for this */
3721 ui_out_text (uiout
, "\tstop only in thread ");
3722 ui_out_field_int (uiout
, "thread", b
->thread
);
3723 ui_out_text (uiout
, "\n");
3726 if (!part_of_multiple
&& b
->hit_count
)
3728 /* FIXME should make an annotation for this */
3729 if (ep_is_catchpoint (b
))
3730 ui_out_text (uiout
, "\tcatchpoint");
3732 ui_out_text (uiout
, "\tbreakpoint");
3733 ui_out_text (uiout
, " already hit ");
3734 ui_out_field_int (uiout
, "times", b
->hit_count
);
3735 if (b
->hit_count
== 1)
3736 ui_out_text (uiout
, " time\n");
3738 ui_out_text (uiout
, " times\n");
3741 /* Output the count also if it is zero, but only if this is
3742 mi. FIXME: Should have a better test for this. */
3743 if (ui_out_is_mi_like_p (uiout
))
3744 if (!part_of_multiple
&& b
->hit_count
== 0)
3745 ui_out_field_int (uiout
, "times", b
->hit_count
);
3747 if (!part_of_multiple
&& b
->ignore_count
)
3750 ui_out_text (uiout
, "\tignore next ");
3751 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3752 ui_out_text (uiout
, " hits\n");
3755 if (!part_of_multiple
&& (l
= b
->commands
))
3757 struct cleanup
*script_chain
;
3760 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3761 print_command_lines (uiout
, l
, 4);
3762 do_cleanups (script_chain
);
3765 if (!part_of_multiple
&& b
->pass_count
)
3767 annotate_field (10);
3768 ui_out_text (uiout
, "\tpass count ");
3769 ui_out_field_int (uiout
, "pass", b
->pass_count
);
3770 ui_out_text (uiout
, " \n");
3773 if (!part_of_multiple
&& b
->step_count
)
3775 annotate_field (11);
3776 ui_out_text (uiout
, "\tstep count ");
3777 ui_out_field_int (uiout
, "step", b
->step_count
);
3778 ui_out_text (uiout
, " \n");
3781 if (!part_of_multiple
&& b
->actions
)
3783 struct action_line
*action
;
3784 annotate_field (12);
3785 for (action
= b
->actions
; action
; action
= action
->next
)
3787 ui_out_text (uiout
, " A\t");
3788 ui_out_text (uiout
, action
->action
);
3789 ui_out_text (uiout
, "\n");
3793 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
3796 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
3797 else if (b
->exp_string
)
3798 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
3801 do_cleanups (bkpt_chain
);
3802 do_cleanups (old_chain
);
3806 print_one_breakpoint (struct breakpoint
*b
,
3807 CORE_ADDR
*last_addr
)
3809 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3811 /* If this breakpoint has custom print function,
3812 it's already printed. Otherwise, print individual
3813 locations, if any. */
3814 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3816 /* If breakpoint has a single location that is
3817 disabled, we print it as if it had
3818 several locations, since otherwise it's hard to
3819 represent "breakpoint enabled, location disabled"
3821 Note that while hardware watchpoints have
3822 several locations internally, that's no a property
3825 && !is_hardware_watchpoint (b
)
3826 && (b
->loc
->next
|| !b
->loc
->enabled
)
3827 && !ui_out_is_mi_like_p (uiout
))
3829 struct bp_location
*loc
;
3831 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3832 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3838 struct captured_breakpoint_query_args
3844 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3846 struct captured_breakpoint_query_args
*args
= data
;
3847 struct breakpoint
*b
;
3848 CORE_ADDR dummy_addr
= 0;
3851 if (args
->bnum
== b
->number
)
3853 print_one_breakpoint (b
, &dummy_addr
);
3861 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3863 struct captured_breakpoint_query_args args
;
3865 /* For the moment we don't trust print_one_breakpoint() to not throw
3867 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3868 error_message
, RETURN_MASK_ALL
) < 0)
3874 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3875 catchpoints, et.al.). */
3878 user_settable_breakpoint (const struct breakpoint
*b
)
3880 return (b
->type
== bp_breakpoint
3881 || b
->type
== bp_catchpoint
3882 || b
->type
== bp_hardware_breakpoint
3883 || b
->type
== bp_tracepoint
3884 || b
->type
== bp_watchpoint
3885 || b
->type
== bp_read_watchpoint
3886 || b
->type
== bp_access_watchpoint
3887 || b
->type
== bp_hardware_watchpoint
);
3890 /* Print information on user settable breakpoint (watchpoint, etc)
3891 number BNUM. If BNUM is -1 print all user settable breakpoints.
3892 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3895 breakpoint_1 (int bnum
, int allflag
)
3897 struct breakpoint
*b
;
3898 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3899 int nr_printable_breakpoints
;
3900 struct cleanup
*bkpttbl_chain
;
3901 struct value_print_options opts
;
3903 get_user_print_options (&opts
);
3905 /* Compute the number of rows in the table. */
3906 nr_printable_breakpoints
= 0;
3909 || bnum
== b
->number
)
3911 if (allflag
|| user_settable_breakpoint (b
))
3912 nr_printable_breakpoints
++;
3915 if (opts
.addressprint
)
3917 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3921 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3924 if (nr_printable_breakpoints
> 0)
3925 annotate_breakpoints_headers ();
3926 if (nr_printable_breakpoints
> 0)
3928 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3929 if (nr_printable_breakpoints
> 0)
3931 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3932 if (nr_printable_breakpoints
> 0)
3934 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3935 if (nr_printable_breakpoints
> 0)
3937 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3938 if (opts
.addressprint
)
3940 if (nr_printable_breakpoints
> 0)
3942 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3943 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3945 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3947 if (nr_printable_breakpoints
> 0)
3949 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3950 ui_out_table_body (uiout
);
3951 if (nr_printable_breakpoints
> 0)
3952 annotate_breakpoints_table ();
3956 || bnum
== b
->number
)
3958 /* We only print out user settable breakpoints unless the
3960 if (allflag
|| user_settable_breakpoint (b
))
3961 print_one_breakpoint (b
, &last_addr
);
3964 do_cleanups (bkpttbl_chain
);
3966 if (nr_printable_breakpoints
== 0)
3969 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3971 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3976 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3977 that a comparison of an unsigned with -1 is always false. */
3978 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3979 set_next_address (current_gdbarch
, last_addr
);
3982 /* FIXME? Should this be moved up so that it is only called when
3983 there have been breakpoints? */
3984 annotate_breakpoints_table_end ();
3988 breakpoints_info (char *bnum_exp
, int from_tty
)
3993 bnum
= parse_and_eval_long (bnum_exp
);
3995 breakpoint_1 (bnum
, 0);
3999 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4004 bnum
= parse_and_eval_long (bnum_exp
);
4006 breakpoint_1 (bnum
, 1);
4010 breakpoint_has_pc (struct breakpoint
*b
,
4011 CORE_ADDR pc
, struct obj_section
*section
)
4013 struct bp_location
*bl
= b
->loc
;
4014 for (; bl
; bl
= bl
->next
)
4016 if (bl
->address
== pc
4017 && (!overlay_debugging
|| bl
->section
== section
))
4023 /* Print a message describing any breakpoints set at PC. */
4026 describe_other_breakpoints (CORE_ADDR pc
, struct obj_section
*section
,
4030 struct breakpoint
*b
;
4033 others
+= breakpoint_has_pc (b
, pc
, section
);
4037 printf_filtered (_("Note: breakpoint "));
4038 else /* if (others == ???) */
4039 printf_filtered (_("Note: breakpoints "));
4041 if (breakpoint_has_pc (b
, pc
, section
))
4044 printf_filtered ("%d", b
->number
);
4045 if (b
->thread
== -1 && thread
!= -1)
4046 printf_filtered (" (all threads)");
4047 else if (b
->thread
!= -1)
4048 printf_filtered (" (thread %d)", b
->thread
);
4049 printf_filtered ("%s%s ",
4050 ((b
->enable_state
== bp_disabled
||
4051 b
->enable_state
== bp_call_disabled
)
4053 : b
->enable_state
== bp_permanent
4057 : ((others
== 1) ? " and" : ""));
4059 printf_filtered (_("also set at pc "));
4060 fputs_filtered (paddress (pc
), gdb_stdout
);
4061 printf_filtered (".\n");
4065 /* Set the default place to put a breakpoint
4066 for the `break' command with no arguments. */
4069 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
4072 default_breakpoint_valid
= valid
;
4073 default_breakpoint_address
= addr
;
4074 default_breakpoint_symtab
= symtab
;
4075 default_breakpoint_line
= line
;
4078 /* Return true iff it is meaningful to use the address member of
4079 BPT. For some breakpoint types, the address member is irrelevant
4080 and it makes no sense to attempt to compare it to other addresses
4081 (or use it for any other purpose either).
4083 More specifically, each of the following breakpoint types will always
4084 have a zero valued address and we don't want check_duplicates() to mark
4085 breakpoints of any of these types to be a duplicate of an actual
4086 breakpoint at address zero:
4089 bp_hardware_watchpoint
4091 bp_access_watchpoint
4095 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4097 enum bptype type
= bpt
->type
;
4099 return (type
!= bp_watchpoint
4100 && type
!= bp_hardware_watchpoint
4101 && type
!= bp_read_watchpoint
4102 && type
!= bp_access_watchpoint
4103 && type
!= bp_catchpoint
);
4106 /* Rescan breakpoints at the same address and section as BPT,
4107 marking the first one as "first" and any others as "duplicates".
4108 This is so that the bpt instruction is only inserted once.
4109 If we have a permanent breakpoint at the same place as BPT, make
4110 that one the official one, and the rest as duplicates. */
4113 check_duplicates_for (CORE_ADDR address
, struct obj_section
*section
)
4115 struct bp_location
*b
;
4117 struct bp_location
*perm_bp
= 0;
4119 ALL_BP_LOCATIONS (b
)
4120 if (b
->owner
->enable_state
!= bp_disabled
4121 && b
->owner
->enable_state
!= bp_call_disabled
4123 && !b
->shlib_disabled
4124 && b
->address
== address
/* address / overlay match */
4125 && (!overlay_debugging
|| b
->section
== section
)
4126 && breakpoint_address_is_meaningful (b
->owner
))
4128 /* Have we found a permanent breakpoint? */
4129 if (b
->owner
->enable_state
== bp_permanent
)
4136 b
->duplicate
= count
> 1;
4139 /* If we found a permanent breakpoint at this address, go over the
4140 list again and declare all the other breakpoints there (except
4141 other permanent breakpoints) to be the duplicates. */
4144 perm_bp
->duplicate
= 0;
4146 /* Permanent breakpoint should always be inserted. */
4147 if (! perm_bp
->inserted
)
4148 internal_error (__FILE__
, __LINE__
,
4149 _("allegedly permanent breakpoint is not "
4150 "actually inserted"));
4152 ALL_BP_LOCATIONS (b
)
4155 if (b
->owner
->enable_state
!= bp_permanent
4156 && b
->owner
->enable_state
!= bp_disabled
4157 && b
->owner
->enable_state
!= bp_call_disabled
4158 && b
->enabled
&& !b
->shlib_disabled
4159 && b
->address
== address
/* address / overlay match */
4160 && (!overlay_debugging
|| b
->section
== section
)
4161 && breakpoint_address_is_meaningful (b
->owner
))
4164 internal_error (__FILE__
, __LINE__
,
4165 _("another breakpoint was inserted on top of "
4166 "a permanent breakpoint"));
4175 check_duplicates (struct breakpoint
*bpt
)
4177 struct bp_location
*bl
= bpt
->loc
;
4179 if (! breakpoint_address_is_meaningful (bpt
))
4182 for (; bl
; bl
= bl
->next
)
4183 check_duplicates_for (bl
->address
, bl
->section
);
4187 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4188 int bnum
, int have_bnum
)
4193 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4194 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4196 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4197 bnum
, astr1
, astr2
);
4199 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4202 /* Adjust a breakpoint's address to account for architectural constraints
4203 on breakpoint placement. Return the adjusted address. Note: Very
4204 few targets require this kind of adjustment. For most targets,
4205 this function is simply the identity function. */
4208 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4210 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4212 /* Very few targets need any kind of breakpoint adjustment. */
4215 else if (bptype
== bp_watchpoint
4216 || bptype
== bp_hardware_watchpoint
4217 || bptype
== bp_read_watchpoint
4218 || bptype
== bp_access_watchpoint
4219 || bptype
== bp_catchpoint
)
4221 /* Watchpoints and the various bp_catch_* eventpoints should not
4222 have their addresses modified. */
4227 CORE_ADDR adjusted_bpaddr
;
4229 /* Some targets have architectural constraints on the placement
4230 of breakpoint instructions. Obtain the adjusted address. */
4231 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4234 /* An adjusted breakpoint address can significantly alter
4235 a user's expectations. Print a warning if an adjustment
4237 if (adjusted_bpaddr
!= bpaddr
)
4238 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4240 return adjusted_bpaddr
;
4244 /* Allocate a struct bp_location. */
4246 static struct bp_location
*
4247 allocate_bp_location (struct breakpoint
*bpt
)
4249 struct bp_location
*loc
, *loc_p
;
4251 loc
= xmalloc (sizeof (struct bp_location
));
4252 memset (loc
, 0, sizeof (*loc
));
4256 loc
->shlib_disabled
= 0;
4266 case bp_longjmp_resume
:
4267 case bp_step_resume
:
4268 case bp_watchpoint_scope
:
4270 case bp_shlib_event
:
4271 case bp_thread_event
:
4272 case bp_overlay_event
:
4273 loc
->loc_type
= bp_loc_software_breakpoint
;
4275 case bp_hardware_breakpoint
:
4276 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4278 case bp_hardware_watchpoint
:
4279 case bp_read_watchpoint
:
4280 case bp_access_watchpoint
:
4281 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4285 loc
->loc_type
= bp_loc_other
;
4288 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4294 static void free_bp_location (struct bp_location
*loc
)
4299 if (loc
->function_name
)
4300 xfree (loc
->function_name
);
4305 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4306 that has type BPTYPE and has no locations as yet. */
4308 static struct breakpoint
*
4309 set_raw_breakpoint_without_location (enum bptype bptype
)
4311 struct breakpoint
*b
, *b1
;
4313 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4314 memset (b
, 0, sizeof (*b
));
4317 b
->language
= current_language
->la_language
;
4318 b
->input_radix
= input_radix
;
4320 b
->enable_state
= bp_enabled
;
4323 b
->ignore_count
= 0;
4325 b
->frame_id
= null_frame_id
;
4326 b
->forked_inferior_pid
= null_ptid
;
4327 b
->exec_pathname
= NULL
;
4329 b
->condition_not_parsed
= 0;
4331 /* Add this breakpoint to the end of the chain
4332 so that a list of breakpoints will come out in order
4333 of increasing numbers. */
4335 b1
= breakpoint_chain
;
4337 breakpoint_chain
= b
;
4347 /* Initialize loc->function_name. */
4349 set_breakpoint_location_function (struct bp_location
*loc
)
4351 if (loc
->owner
->type
== bp_breakpoint
4352 || loc
->owner
->type
== bp_hardware_breakpoint
4353 || loc
->owner
->type
== bp_tracepoint
)
4355 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4357 if (loc
->function_name
)
4358 loc
->function_name
= xstrdup (loc
->function_name
);
4362 /* set_raw_breakpoint is a low level routine for allocating and
4363 partially initializing a breakpoint of type BPTYPE. The newly
4364 created breakpoint's address, section, source file name, and line
4365 number are provided by SAL. The newly created and partially
4366 initialized breakpoint is added to the breakpoint chain and
4367 is also returned as the value of this function.
4369 It is expected that the caller will complete the initialization of
4370 the newly created breakpoint struct as well as output any status
4371 information regarding the creation of a new breakpoint. In
4372 particular, set_raw_breakpoint does NOT set the breakpoint
4373 number! Care should be taken to not allow an error to occur
4374 prior to completing the initialization of the breakpoint. If this
4375 should happen, a bogus breakpoint will be left on the chain. */
4378 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4380 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4381 CORE_ADDR adjusted_address
;
4383 /* Adjust the breakpoint's address prior to allocating a location.
4384 Once we call allocate_bp_location(), that mostly uninitialized
4385 location will be placed on the location chain. Adjustment of the
4386 breakpoint may cause target_read_memory() to be called and we do
4387 not want its scan of the location chain to find a breakpoint and
4388 location that's only been partially initialized. */
4389 adjusted_address
= adjust_breakpoint_address (sal
.pc
, b
->type
);
4391 b
->loc
= allocate_bp_location (b
);
4392 b
->loc
->requested_address
= sal
.pc
;
4393 b
->loc
->address
= adjusted_address
;
4395 if (sal
.symtab
== NULL
)
4396 b
->source_file
= NULL
;
4398 b
->source_file
= savestring (sal
.symtab
->filename
,
4399 strlen (sal
.symtab
->filename
));
4400 b
->loc
->section
= sal
.section
;
4401 b
->line_number
= sal
.line
;
4403 set_breakpoint_location_function (b
->loc
);
4405 breakpoints_changed ();
4411 /* Note that the breakpoint object B describes a permanent breakpoint
4412 instruction, hard-wired into the inferior's code. */
4414 make_breakpoint_permanent (struct breakpoint
*b
)
4416 struct bp_location
*bl
;
4417 b
->enable_state
= bp_permanent
;
4419 /* By definition, permanent breakpoints are already present in the code.
4420 Mark all locations as inserted. For now, make_breakpoint_permanent
4421 is called in just one place, so it's hard to say if it's reasonable
4422 to have permanent breakpoint with multiple locations or not,
4423 but it's easy to implmement. */
4424 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4429 create_longjmp_breakpoint (char *func_name
)
4431 struct minimal_symbol
*m
;
4433 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4435 set_momentary_breakpoint_at_pc (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4436 update_global_location_list (1);
4439 /* Call this routine when stepping and nexting to enable a breakpoint
4440 if we do a longjmp(). When we hit that breakpoint, call
4441 set_longjmp_resume_breakpoint() to figure out where we are going. */
4444 set_longjmp_breakpoint (void)
4446 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
4448 create_longjmp_breakpoint ("longjmp");
4449 create_longjmp_breakpoint ("_longjmp");
4450 create_longjmp_breakpoint ("siglongjmp");
4451 create_longjmp_breakpoint ("_siglongjmp");
4455 /* Delete all longjmp breakpoints from THREAD. */
4457 delete_longjmp_breakpoint (int thread
)
4459 struct breakpoint
*b
, *temp
;
4461 ALL_BREAKPOINTS_SAFE (b
, temp
)
4462 if (b
->type
== bp_longjmp
)
4464 if (b
->thread
== thread
)
4465 delete_breakpoint (b
);
4470 enable_overlay_breakpoints (void)
4472 struct breakpoint
*b
;
4475 if (b
->type
== bp_overlay_event
)
4477 b
->enable_state
= bp_enabled
;
4478 update_global_location_list (1);
4479 overlay_events_enabled
= 1;
4484 disable_overlay_breakpoints (void)
4486 struct breakpoint
*b
;
4489 if (b
->type
== bp_overlay_event
)
4491 b
->enable_state
= bp_disabled
;
4492 update_global_location_list (0);
4493 overlay_events_enabled
= 0;
4498 create_thread_event_breakpoint (CORE_ADDR address
)
4500 struct breakpoint
*b
;
4502 b
= create_internal_breakpoint (address
, bp_thread_event
);
4504 b
->enable_state
= bp_enabled
;
4505 /* addr_string has to be used or breakpoint_re_set will delete me. */
4506 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4508 update_global_location_list_nothrow (1);
4514 remove_thread_event_breakpoints (void)
4516 struct breakpoint
*b
, *temp
;
4518 ALL_BREAKPOINTS_SAFE (b
, temp
)
4519 if (b
->type
== bp_thread_event
)
4520 delete_breakpoint (b
);
4523 struct captured_parse_breakpoint_args
4526 struct symtabs_and_lines
*sals_p
;
4527 char ***addr_string_p
;
4531 struct lang_and_radix
4539 remove_solib_event_breakpoints (void)
4541 struct breakpoint
*b
, *temp
;
4543 ALL_BREAKPOINTS_SAFE (b
, temp
)
4544 if (b
->type
== bp_shlib_event
)
4545 delete_breakpoint (b
);
4549 create_solib_event_breakpoint (CORE_ADDR address
)
4551 struct breakpoint
*b
;
4553 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4554 update_global_location_list_nothrow (1);
4558 /* Disable any breakpoints that are on code in shared libraries. Only
4559 apply to enabled breakpoints, disabled ones can just stay disabled. */
4562 disable_breakpoints_in_shlibs (void)
4564 struct bp_location
*loc
;
4566 ALL_BP_LOCATIONS (loc
)
4568 struct breakpoint
*b
= loc
->owner
;
4569 /* We apply the check to all breakpoints, including disabled
4570 for those with loc->duplicate set. This is so that when breakpoint
4571 becomes enabled, or the duplicate is removed, gdb will try to insert
4572 all breakpoints. If we don't set shlib_disabled here, we'll try
4573 to insert those breakpoints and fail. */
4574 if (((b
->type
== bp_breakpoint
)
4575 || (b
->type
== bp_hardware_breakpoint
)
4576 || (b
->type
== bp_tracepoint
))
4577 && !loc
->shlib_disabled
4579 && PC_SOLIB (loc
->address
)
4581 && solib_name_from_address (loc
->address
)
4585 loc
->shlib_disabled
= 1;
4590 /* Disable any breakpoints that are in in an unloaded shared library. Only
4591 apply to enabled breakpoints, disabled ones can just stay disabled. */
4594 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4596 struct bp_location
*loc
;
4597 int disabled_shlib_breaks
= 0;
4599 /* SunOS a.out shared libraries are always mapped, so do not
4600 disable breakpoints; they will only be reported as unloaded
4601 through clear_solib when GDB discards its shared library
4602 list. See clear_solib for more information. */
4603 if (exec_bfd
!= NULL
4604 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
4607 ALL_BP_LOCATIONS (loc
)
4609 struct breakpoint
*b
= loc
->owner
;
4610 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4611 || loc
->loc_type
== bp_loc_software_breakpoint
)
4612 && !loc
->shlib_disabled
4613 && (b
->type
== bp_breakpoint
|| b
->type
== bp_hardware_breakpoint
)
4614 && solib_contains_address_p (solib
, loc
->address
))
4616 loc
->shlib_disabled
= 1;
4617 /* At this point, we cannot rely on remove_breakpoint
4618 succeeding so we must mark the breakpoint as not inserted
4619 to prevent future errors occurring in remove_breakpoints. */
4621 if (!disabled_shlib_breaks
)
4623 target_terminal_ours_for_output ();
4624 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4627 disabled_shlib_breaks
= 1;
4632 /* FORK & VFORK catchpoints. */
4634 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
4637 insert_catch_fork (struct breakpoint
*b
)
4639 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
4642 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
4645 remove_catch_fork (struct breakpoint
*b
)
4647 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
4650 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
4654 breakpoint_hit_catch_fork (struct breakpoint
*b
)
4656 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
4659 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
4661 static enum print_stop_action
4662 print_it_catch_fork (struct breakpoint
*b
)
4664 annotate_catchpoint (b
->number
);
4665 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
4666 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4667 return PRINT_SRC_AND_LOC
;
4670 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
4673 print_one_catch_fork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4675 struct value_print_options opts
;
4677 get_user_print_options (&opts
);
4679 /* Field 4, the address, is omitted (which makes the columns
4680 not line up too nicely with the headers, but the effect
4681 is relatively readable). */
4682 if (opts
.addressprint
)
4683 ui_out_field_skip (uiout
, "addr");
4685 ui_out_text (uiout
, "fork");
4686 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4688 ui_out_text (uiout
, ", process ");
4689 ui_out_field_int (uiout
, "what",
4690 ptid_get_pid (b
->forked_inferior_pid
));
4691 ui_out_spaces (uiout
, 1);
4695 /* Implement the "print_mention" breakpoint_ops method for fork
4699 print_mention_catch_fork (struct breakpoint
*b
)
4701 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
4704 /* The breakpoint_ops structure to be used in fork catchpoints. */
4706 static struct breakpoint_ops catch_fork_breakpoint_ops
=
4710 breakpoint_hit_catch_fork
,
4711 print_it_catch_fork
,
4712 print_one_catch_fork
,
4713 print_mention_catch_fork
4716 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
4719 insert_catch_vfork (struct breakpoint
*b
)
4721 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
4724 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
4727 remove_catch_vfork (struct breakpoint
*b
)
4729 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
4732 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
4736 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
4738 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
4741 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
4743 static enum print_stop_action
4744 print_it_catch_vfork (struct breakpoint
*b
)
4746 annotate_catchpoint (b
->number
);
4747 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
4748 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4749 return PRINT_SRC_AND_LOC
;
4752 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
4755 print_one_catch_vfork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4757 struct value_print_options opts
;
4759 get_user_print_options (&opts
);
4760 /* Field 4, the address, is omitted (which makes the columns
4761 not line up too nicely with the headers, but the effect
4762 is relatively readable). */
4763 if (opts
.addressprint
)
4764 ui_out_field_skip (uiout
, "addr");
4766 ui_out_text (uiout
, "vfork");
4767 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4769 ui_out_text (uiout
, ", process ");
4770 ui_out_field_int (uiout
, "what",
4771 ptid_get_pid (b
->forked_inferior_pid
));
4772 ui_out_spaces (uiout
, 1);
4776 /* Implement the "print_mention" breakpoint_ops method for vfork
4780 print_mention_catch_vfork (struct breakpoint
*b
)
4782 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
4785 /* The breakpoint_ops structure to be used in vfork catchpoints. */
4787 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
4791 breakpoint_hit_catch_vfork
,
4792 print_it_catch_vfork
,
4793 print_one_catch_vfork
,
4794 print_mention_catch_vfork
4797 /* Create a new breakpoint of the bp_catchpoint kind and return it.
4799 If TEMPFLAG is non-zero, then make the breakpoint temporary.
4800 If COND_STRING is not NULL, then store it in the breakpoint.
4801 OPS, if not NULL, is the breakpoint_ops structure associated
4802 to the catchpoint. */
4804 static struct breakpoint
*
4805 create_catchpoint (int tempflag
, char *cond_string
,
4806 struct breakpoint_ops
*ops
)
4808 struct symtab_and_line sal
;
4809 struct breakpoint
*b
;
4816 b
= set_raw_breakpoint (sal
, bp_catchpoint
);
4817 set_breakpoint_count (breakpoint_count
+ 1);
4818 b
->number
= breakpoint_count
;
4820 b
->cond_string
= (cond_string
== NULL
) ?
4821 NULL
: savestring (cond_string
, strlen (cond_string
));
4823 b
->addr_string
= NULL
;
4824 b
->enable_state
= bp_enabled
;
4825 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4829 update_global_location_list (1);
4835 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4836 struct breakpoint_ops
*ops
)
4838 struct breakpoint
*b
= create_catchpoint (tempflag
, cond_string
, ops
);
4840 /* FIXME: We should put this information in a breakpoint private data
4842 b
->forked_inferior_pid
= null_ptid
;
4845 /* Exec catchpoints. */
4848 insert_catch_exec (struct breakpoint
*b
)
4850 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
4854 remove_catch_exec (struct breakpoint
*b
)
4856 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
4860 breakpoint_hit_catch_exec (struct breakpoint
*b
)
4862 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
4865 static enum print_stop_action
4866 print_it_catch_exec (struct breakpoint
*b
)
4868 annotate_catchpoint (b
->number
);
4869 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
4871 return PRINT_SRC_AND_LOC
;
4875 print_one_catch_exec (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4877 struct value_print_options opts
;
4879 get_user_print_options (&opts
);
4881 /* Field 4, the address, is omitted (which makes the columns
4882 not line up too nicely with the headers, but the effect
4883 is relatively readable). */
4884 if (opts
.addressprint
)
4885 ui_out_field_skip (uiout
, "addr");
4887 ui_out_text (uiout
, "exec");
4888 if (b
->exec_pathname
!= NULL
)
4890 ui_out_text (uiout
, ", program \"");
4891 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
4892 ui_out_text (uiout
, "\" ");
4897 print_mention_catch_exec (struct breakpoint
*b
)
4899 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
4902 static struct breakpoint_ops catch_exec_breakpoint_ops
=
4906 breakpoint_hit_catch_exec
,
4907 print_it_catch_exec
,
4908 print_one_catch_exec
,
4909 print_mention_catch_exec
4913 hw_breakpoint_used_count (void)
4915 struct breakpoint
*b
;
4920 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
4928 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4930 struct breakpoint
*b
;
4933 *other_type_used
= 0;
4936 if (breakpoint_enabled (b
))
4938 if (b
->type
== type
)
4940 else if ((b
->type
== bp_hardware_watchpoint
||
4941 b
->type
== bp_read_watchpoint
||
4942 b
->type
== bp_access_watchpoint
))
4943 *other_type_used
= 1;
4950 disable_watchpoints_before_interactive_call_start (void)
4952 struct breakpoint
*b
;
4956 if (((b
->type
== bp_watchpoint
)
4957 || (b
->type
== bp_hardware_watchpoint
)
4958 || (b
->type
== bp_read_watchpoint
)
4959 || (b
->type
== bp_access_watchpoint
))
4960 && breakpoint_enabled (b
))
4962 b
->enable_state
= bp_call_disabled
;
4963 update_global_location_list (0);
4969 enable_watchpoints_after_interactive_call_stop (void)
4971 struct breakpoint
*b
;
4975 if (((b
->type
== bp_watchpoint
)
4976 || (b
->type
== bp_hardware_watchpoint
)
4977 || (b
->type
== bp_read_watchpoint
)
4978 || (b
->type
== bp_access_watchpoint
))
4979 && (b
->enable_state
== bp_call_disabled
))
4981 b
->enable_state
= bp_enabled
;
4982 update_global_location_list (1);
4988 /* Set a breakpoint that will evaporate an end of command
4989 at address specified by SAL.
4990 Restrict it to frame FRAME if FRAME is nonzero. */
4993 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4996 struct breakpoint
*b
;
4997 b
= set_raw_breakpoint (sal
, type
);
4998 b
->enable_state
= bp_enabled
;
4999 b
->disposition
= disp_donttouch
;
5000 b
->frame_id
= frame_id
;
5002 /* If we're debugging a multi-threaded program, then we
5003 want momentary breakpoints to be active in only a
5004 single thread of control. */
5005 if (in_thread_list (inferior_ptid
))
5006 b
->thread
= pid_to_thread_id (inferior_ptid
);
5008 update_global_location_list_nothrow (1);
5014 set_momentary_breakpoint_at_pc (CORE_ADDR pc
, enum bptype type
)
5016 struct symtab_and_line sal
;
5018 sal
= find_pc_line (pc
, 0);
5020 sal
.section
= find_pc_overlay (pc
);
5021 sal
.explicit_pc
= 1;
5023 return set_momentary_breakpoint (sal
, null_frame_id
, type
);
5027 /* Tell the user we have just set a breakpoint B. */
5030 mention (struct breakpoint
*b
)
5033 struct cleanup
*ui_out_chain
;
5034 struct value_print_options opts
;
5036 get_user_print_options (&opts
);
5038 /* FIXME: This is misplaced; mention() is called by things (like
5039 hitting a watchpoint) other than breakpoint creation. It should
5040 be possible to clean this up and at the same time replace the
5041 random calls to breakpoint_changed with this hook. */
5042 observer_notify_breakpoint_created (b
->number
);
5044 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
5045 b
->ops
->print_mention (b
);
5050 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
5053 ui_out_text (uiout
, "Watchpoint ");
5054 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5055 ui_out_field_int (uiout
, "number", b
->number
);
5056 ui_out_text (uiout
, ": ");
5057 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5058 do_cleanups (ui_out_chain
);
5060 case bp_hardware_watchpoint
:
5061 ui_out_text (uiout
, "Hardware watchpoint ");
5062 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5063 ui_out_field_int (uiout
, "number", b
->number
);
5064 ui_out_text (uiout
, ": ");
5065 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5066 do_cleanups (ui_out_chain
);
5068 case bp_read_watchpoint
:
5069 ui_out_text (uiout
, "Hardware read watchpoint ");
5070 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
5071 ui_out_field_int (uiout
, "number", b
->number
);
5072 ui_out_text (uiout
, ": ");
5073 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5074 do_cleanups (ui_out_chain
);
5076 case bp_access_watchpoint
:
5077 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
5078 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
5079 ui_out_field_int (uiout
, "number", b
->number
);
5080 ui_out_text (uiout
, ": ");
5081 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5082 do_cleanups (ui_out_chain
);
5085 if (ui_out_is_mi_like_p (uiout
))
5090 if (b
->disposition
== disp_del
)
5091 printf_filtered (_("Temporary breakpoint"));
5093 printf_filtered (_("Breakpoint"));
5094 printf_filtered (_(" %d"), b
->number
);
5097 case bp_hardware_breakpoint
:
5098 if (ui_out_is_mi_like_p (uiout
))
5103 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
5107 if (ui_out_is_mi_like_p (uiout
))
5112 printf_filtered (_("Tracepoint"));
5113 printf_filtered (_(" %d"), b
->number
);
5120 case bp_longjmp_resume
:
5121 case bp_step_resume
:
5123 case bp_watchpoint_scope
:
5124 case bp_shlib_event
:
5125 case bp_thread_event
:
5126 case bp_overlay_event
:
5132 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5136 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5140 if (opts
.addressprint
|| b
->source_file
== NULL
)
5142 printf_filtered (" at ");
5143 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
5146 printf_filtered (": file %s, line %d.",
5147 b
->source_file
, b
->line_number
);
5151 struct bp_location
*loc
= b
->loc
;
5153 for (; loc
; loc
= loc
->next
)
5155 printf_filtered (" (%d locations)", n
);
5160 if (ui_out_is_mi_like_p (uiout
))
5162 printf_filtered ("\n");
5166 static struct bp_location
*
5167 add_location_to_breakpoint (struct breakpoint
*b
,
5168 const struct symtab_and_line
*sal
)
5170 struct bp_location
*loc
, **tmp
;
5172 loc
= allocate_bp_location (b
);
5173 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5176 loc
->requested_address
= sal
->pc
;
5177 loc
->address
= adjust_breakpoint_address (loc
->requested_address
, b
->type
);
5178 loc
->section
= sal
->section
;
5180 set_breakpoint_location_function (loc
);
5185 /* Return 1 if LOC is pointing to a permanent breakpoint,
5186 return 0 otherwise. */
5189 bp_loc_is_permanent (struct bp_location
*loc
)
5193 const gdb_byte
*brk
;
5194 gdb_byte
*target_mem
;
5195 struct cleanup
*cleanup
;
5198 gdb_assert (loc
!= NULL
);
5200 addr
= loc
->address
;
5201 brk
= gdbarch_breakpoint_from_pc (current_gdbarch
, &addr
, &len
);
5203 /* Software breakpoints unsupported? */
5207 target_mem
= alloca (len
);
5209 /* Enable the automatic memory restoration from breakpoints while
5210 we read the memory. Otherwise we could say about our temporary
5211 breakpoints they are permanent. */
5212 cleanup
= make_show_memory_breakpoints_cleanup (0);
5214 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
5215 && memcmp (target_mem
, brk
, len
) == 0)
5218 do_cleanups (cleanup
);
5225 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5226 as textual description of the location, and COND_STRING
5227 as condition expression. */
5230 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5232 enum bptype type
, enum bpdisp disposition
,
5233 int thread
, int task
, int ignore_count
,
5234 struct breakpoint_ops
*ops
, int from_tty
, int enabled
)
5236 struct breakpoint
*b
= NULL
;
5239 if (type
== bp_hardware_breakpoint
)
5241 int i
= hw_breakpoint_used_count ();
5242 int target_resources_ok
=
5243 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
5245 if (target_resources_ok
== 0)
5246 error (_("No hardware breakpoint support in the target."));
5247 else if (target_resources_ok
< 0)
5248 error (_("Hardware breakpoints used exceeds limit."));
5251 for (i
= 0; i
< sals
.nelts
; ++i
)
5253 struct symtab_and_line sal
= sals
.sals
[i
];
5254 struct bp_location
*loc
;
5257 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5261 b
= set_raw_breakpoint (sal
, type
);
5262 set_breakpoint_count (breakpoint_count
+ 1);
5263 b
->number
= breakpoint_count
;
5267 b
->cond_string
= cond_string
;
5268 b
->ignore_count
= ignore_count
;
5269 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
5270 b
->disposition
= disposition
;
5276 loc
= add_location_to_breakpoint (b
, &sal
);
5279 if (bp_loc_is_permanent (loc
))
5280 make_breakpoint_permanent (b
);
5284 char *arg
= b
->cond_string
;
5285 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5287 error (_("Garbage %s follows condition"), arg
);
5292 b
->addr_string
= addr_string
;
5294 /* addr_string has to be used or breakpoint_re_set will delete
5296 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5302 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5303 elements to fill the void space. */
5305 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5307 int i
= index_to_remove
+1;
5308 int last_index
= sal
->nelts
-1;
5310 for (;i
<= last_index
; ++i
)
5311 sal
->sals
[i
-1] = sal
->sals
[i
];
5316 /* If appropriate, obtains all sals that correspond
5317 to the same file and line as SAL. This is done
5318 only if SAL does not have explicit PC and has
5319 line and file information. If we got just a single
5320 expanded sal, return the original.
5322 Otherwise, if SAL.explicit_line is not set, filter out
5323 all sals for which the name of enclosing function
5324 is different from SAL. This makes sure that if we have
5325 breakpoint originally set in template instantiation, say
5326 foo<int>(), we won't expand SAL to locations at the same
5327 line in all existing instantiations of 'foo'.
5330 static struct symtabs_and_lines
5331 expand_line_sal_maybe (struct symtab_and_line sal
)
5333 struct symtabs_and_lines expanded
;
5334 CORE_ADDR original_pc
= sal
.pc
;
5335 char *original_function
= NULL
;
5339 /* If we have explicit pc, don't expand.
5340 If we have no line number, we can't expand. */
5341 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5344 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5345 expanded
.sals
[0] = sal
;
5350 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5352 expanded
= expand_line_sal (sal
);
5353 if (expanded
.nelts
== 1)
5355 /* We had one sal, we got one sal. Without futher
5356 processing, just return the original sal. */
5357 xfree (expanded
.sals
);
5359 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5360 sal
.pc
= original_pc
;
5361 expanded
.sals
[0] = sal
;
5365 if (!sal
.explicit_line
)
5367 CORE_ADDR func_addr
, func_end
;
5368 for (i
= 0; i
< expanded
.nelts
; ++i
)
5370 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5371 char *this_function
;
5372 if (find_pc_partial_function (pc
, &this_function
,
5373 &func_addr
, &func_end
))
5375 if (this_function
&&
5376 strcmp (this_function
, original_function
) != 0)
5378 remove_sal (&expanded
, i
);
5381 else if (func_addr
== pc
)
5383 /* We're at beginning of a function, and should
5385 struct symbol
*sym
= find_pc_function (pc
);
5387 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5390 = gdbarch_skip_prologue (current_gdbarch
, pc
);
5397 if (expanded
.nelts
<= 1)
5399 /* This is un ugly workaround. If we get zero
5400 expanded sals then something is really wrong.
5401 Fix that by returnign the original sal. */
5402 xfree (expanded
.sals
);
5404 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5405 sal
.pc
= original_pc
;
5406 expanded
.sals
[0] = sal
;
5413 for (i
= 0; i
< expanded
.nelts
; ++i
)
5414 if (expanded
.sals
[i
].pc
== original_pc
)
5425 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5426 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5427 value. COND_STRING, if not NULL, specified the condition to be
5428 used for all breakpoints. Essentially the only case where
5429 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5430 function. In that case, it's still not possible to specify
5431 separate conditions for different overloaded functions, so
5432 we take just a single condition string.
5434 NOTE: If the function succeeds, the caller is expected to cleanup
5435 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5436 array contents). If the function fails (error() is called), the
5437 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5438 COND and SALS arrays and each of those arrays contents. */
5441 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5443 enum bptype type
, enum bpdisp disposition
,
5444 int thread
, int task
, int ignore_count
,
5445 struct breakpoint_ops
*ops
, int from_tty
,
5449 for (i
= 0; i
< sals
.nelts
; ++i
)
5451 struct symtabs_and_lines expanded
=
5452 expand_line_sal_maybe (sals
.sals
[i
]);
5454 create_breakpoint (expanded
, addr_string
[i
],
5455 cond_string
, type
, disposition
,
5456 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
5460 /* Parse ARG which is assumed to be a SAL specification possibly
5461 followed by conditionals. On return, SALS contains an array of SAL
5462 addresses found. ADDR_STRING contains a vector of (canonical)
5463 address strings. ARG points to the end of the SAL. */
5466 parse_breakpoint_sals (char **address
,
5467 struct symtabs_and_lines
*sals
,
5468 char ***addr_string
,
5471 char *addr_start
= *address
;
5472 *addr_string
= NULL
;
5473 /* If no arg given, or if first arg is 'if ', use the default
5475 if ((*address
) == NULL
5476 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5478 if (default_breakpoint_valid
)
5480 struct symtab_and_line sal
;
5481 init_sal (&sal
); /* initialize to zeroes */
5482 sals
->sals
= (struct symtab_and_line
*)
5483 xmalloc (sizeof (struct symtab_and_line
));
5484 sal
.pc
= default_breakpoint_address
;
5485 sal
.line
= default_breakpoint_line
;
5486 sal
.symtab
= default_breakpoint_symtab
;
5487 sal
.section
= find_pc_overlay (sal
.pc
);
5489 /* "break" without arguments is equivalent to "break *PC" where PC is
5490 the default_breakpoint_address. So make sure to set
5491 sal.explicit_pc to prevent GDB from trying to expand the list of
5492 sals to include all other instances with the same symtab and line.
5494 sal
.explicit_pc
= 1;
5496 sals
->sals
[0] = sal
;
5500 error (_("No default breakpoint address now."));
5504 /* Force almost all breakpoints to be in terms of the
5505 current_source_symtab (which is decode_line_1's default). This
5506 should produce the results we want almost all of the time while
5507 leaving default_breakpoint_* alone.
5508 ObjC: However, don't match an Objective-C method name which
5509 may have a '+' or '-' succeeded by a '[' */
5511 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5513 if (default_breakpoint_valid
5515 || ((strchr ("+-", (*address
)[0]) != NULL
)
5516 && ((*address
)[1] != '['))))
5517 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5518 default_breakpoint_line
, addr_string
,
5521 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5522 addr_string
, not_found_ptr
);
5524 /* For any SAL that didn't have a canonical string, fill one in. */
5525 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5526 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5527 if (addr_start
!= (*address
))
5530 for (i
= 0; i
< sals
->nelts
; i
++)
5532 /* Add the string if not present. */
5533 if ((*addr_string
)[i
] == NULL
)
5534 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5540 /* Convert each SAL into a real PC. Verify that the PC can be
5541 inserted as a breakpoint. If it can't throw an error. */
5544 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5548 for (i
= 0; i
< sals
->nelts
; i
++)
5549 resolve_sal_pc (&sals
->sals
[i
]);
5553 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5555 struct captured_parse_breakpoint_args
*args
= data
;
5557 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5558 args
->not_found_ptr
);
5561 /* Given TOK, a string specification of condition and thread, as
5562 accepted by the 'break' command, extract the condition
5563 string and thread number and set *COND_STRING and *THREAD.
5564 PC identifies the context at which the condition should be parsed.
5565 If no condition is found, *COND_STRING is set to NULL.
5566 If no thread is found, *THREAD is set to -1. */
5568 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5569 char **cond_string
, int *thread
, int *task
)
5571 *cond_string
= NULL
;
5577 char *cond_start
= NULL
;
5578 char *cond_end
= NULL
;
5579 while (*tok
== ' ' || *tok
== '\t')
5584 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5587 toklen
= end_tok
- tok
;
5589 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5591 struct expression
*expr
;
5593 tok
= cond_start
= end_tok
+ 1;
5594 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5597 *cond_string
= savestring (cond_start
,
5598 cond_end
- cond_start
);
5600 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5606 *thread
= strtol (tok
, &tok
, 0);
5608 error (_("Junk after thread keyword."));
5609 if (!valid_thread_id (*thread
))
5610 error (_("Unknown thread %d."), *thread
);
5612 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
5618 *task
= strtol (tok
, &tok
, 0);
5620 error (_("Junk after task keyword."));
5621 if (!valid_task_id (*task
))
5622 error (_("Unknown task %d\n"), *task
);
5625 error (_("Junk at end of arguments."));
5629 /* Set a breakpoint. This function is shared between
5630 CLI and MI functions for setting a breakpoint.
5631 This function has two major modes of operations,
5632 selected by the PARSE_CONDITION_AND_THREAD parameter.
5633 If non-zero, the function will parse arg, extracting
5634 breakpoint location, address and thread. Otherwise,
5635 ARG is just the location of breakpoint, with condition
5636 and thread specified by the COND_STRING and THREAD
5640 break_command_really (char *arg
, char *cond_string
, int thread
,
5641 int parse_condition_and_thread
,
5642 int tempflag
, int hardwareflag
, int traceflag
,
5644 enum auto_boolean pending_break_support
,
5645 struct breakpoint_ops
*ops
,
5649 struct gdb_exception e
;
5650 struct symtabs_and_lines sals
;
5651 struct symtab_and_line pending_sal
;
5654 char *addr_start
= arg
;
5656 struct cleanup
*old_chain
;
5657 struct cleanup
*breakpoint_chain
= NULL
;
5658 struct captured_parse_breakpoint_args parse_args
;
5662 enum bptype type_wanted
;
5669 parse_args
.arg_p
= &arg
;
5670 parse_args
.sals_p
= &sals
;
5671 parse_args
.addr_string_p
= &addr_string
;
5672 parse_args
.not_found_ptr
= ¬_found
;
5674 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5675 &parse_args
, RETURN_MASK_ALL
);
5677 /* If caller is interested in rc value from parse, set value. */
5681 throw_exception (e
);
5685 case NOT_FOUND_ERROR
:
5687 /* If pending breakpoint support is turned off, throw
5690 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5691 throw_exception (e
);
5693 exception_print (gdb_stderr
, e
);
5695 /* If pending breakpoint support is auto query and the user
5696 selects no, then simply return the error code. */
5697 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5698 !nquery ("Make breakpoint pending on future shared library load? "))
5701 /* At this point, either the user was queried about setting
5702 a pending breakpoint and selected yes, or pending
5703 breakpoint behavior is on and thus a pending breakpoint
5704 is defaulted on behalf of the user. */
5705 copy_arg
= xstrdup (addr_start
);
5706 addr_string
= ©_arg
;
5708 sals
.sals
= &pending_sal
;
5713 throw_exception (e
);
5720 /* Create a chain of things that always need to be cleaned up. */
5721 old_chain
= make_cleanup (null_cleanup
, 0);
5725 /* Make sure that all storage allocated to SALS gets freed. */
5726 make_cleanup (xfree
, sals
.sals
);
5728 /* Cleanup the addr_string array but not its contents. */
5729 make_cleanup (xfree
, addr_string
);
5732 /* ----------------------------- SNIP -----------------------------
5733 Anything added to the cleanup chain beyond this point is assumed
5734 to be part of a breakpoint. If the breakpoint create succeeds
5735 then the memory is not reclaimed. */
5736 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5738 /* Mark the contents of the addr_string for cleanup. These go on
5739 the breakpoint_chain and only occure if the breakpoint create
5741 for (i
= 0; i
< sals
.nelts
; i
++)
5743 if (addr_string
[i
] != NULL
)
5744 make_cleanup (xfree
, addr_string
[i
]);
5747 /* Resolve all line numbers to PC's and verify that the addresses
5748 are ok for the target. */
5750 breakpoint_sals_to_pc (&sals
, addr_start
);
5752 type_wanted
= (traceflag
5754 : (hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
));
5756 /* Verify that condition can be parsed, before setting any
5757 breakpoints. Allocate a separate condition expression for each
5761 if (parse_condition_and_thread
)
5763 /* Here we only parse 'arg' to separate condition
5764 from thread number, so parsing in context of first
5765 sal is OK. When setting the breakpoint we'll
5766 re-parse it in context of each sal. */
5769 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
5772 make_cleanup (xfree
, cond_string
);
5776 /* Create a private copy of condition string. */
5779 cond_string
= xstrdup (cond_string
);
5780 make_cleanup (xfree
, cond_string
);
5783 create_breakpoints (sals
, addr_string
, cond_string
, type_wanted
,
5784 tempflag
? disp_del
: disp_donttouch
,
5785 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
5789 struct symtab_and_line sal
= {0};
5790 struct breakpoint
*b
;
5792 make_cleanup (xfree
, copy_arg
);
5794 b
= set_raw_breakpoint_without_location (type_wanted
);
5795 set_breakpoint_count (breakpoint_count
+ 1);
5796 b
->number
= breakpoint_count
;
5798 b
->addr_string
= addr_string
[0];
5799 b
->cond_string
= NULL
;
5800 b
->ignore_count
= ignore_count
;
5801 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5802 b
->condition_not_parsed
= 1;
5804 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
5810 warning (_("Multiple breakpoints were set.\n"
5811 "Use the \"delete\" command to delete unwanted breakpoints."));
5812 /* That's it. Discard the cleanups for data inserted into the
5814 discard_cleanups (breakpoint_chain
);
5815 /* But cleanup everything else. */
5816 do_cleanups (old_chain
);
5818 /* error call may happen here - have BREAKPOINT_CHAIN already discarded. */
5819 update_global_location_list (1);
5822 /* Set a breakpoint.
5823 ARG is a string describing breakpoint address,
5824 condition, and thread.
5825 FLAG specifies if a breakpoint is hardware on,
5826 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5830 break_command_1 (char *arg
, int flag
, int from_tty
)
5832 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5833 int tempflag
= flag
& BP_TEMPFLAG
;
5835 break_command_really (arg
,
5836 NULL
, 0, 1 /* parse arg */,
5837 tempflag
, hardwareflag
, 0 /* traceflag */,
5838 0 /* Ignore count */,
5839 pending_break_support
,
5840 NULL
/* breakpoint_ops */,
5847 set_breakpoint (char *address
, char *condition
,
5848 int hardwareflag
, int tempflag
,
5849 int thread
, int ignore_count
,
5850 int pending
, int enabled
)
5852 break_command_really (address
, condition
, thread
,
5853 0 /* condition and thread are valid. */,
5854 tempflag
, hardwareflag
, 0 /* traceflag */,
5857 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5861 /* Adjust SAL to the first instruction past the function prologue.
5862 The end of the prologue is determined using the line table from
5863 the debugging information.
5865 If SAL is already past the prologue, then do nothing. */
5868 skip_prologue_sal (struct symtab_and_line
*sal
)
5870 struct symbol
*sym
= find_pc_function (sal
->pc
);
5871 struct symtab_and_line start_sal
;
5876 start_sal
= find_function_start_sal (sym
, 1);
5877 if (sal
->pc
< start_sal
.pc
)
5881 /* Helper function for break_command_1 and disassemble_command. */
5884 resolve_sal_pc (struct symtab_and_line
*sal
)
5888 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5890 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5891 error (_("No line %d in file \"%s\"."),
5892 sal
->line
, sal
->symtab
->filename
);
5895 /* If this SAL corresponds to a breakpoint inserted using
5896 a line number, then skip the function prologue if necessary. */
5897 if (sal
->explicit_line
)
5899 /* Preserve the original line number. */
5900 int saved_line
= sal
->line
;
5901 skip_prologue_sal (sal
);
5902 sal
->line
= saved_line
;
5906 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5908 struct blockvector
*bv
;
5912 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
5915 sym
= block_linkage_function (b
);
5918 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5919 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
5923 /* It really is worthwhile to have the section, so we'll just
5924 have to look harder. This case can be executed if we have
5925 line numbers but no functions (as can happen in assembly
5928 struct minimal_symbol
*msym
;
5930 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5932 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
5939 break_command (char *arg
, int from_tty
)
5941 break_command_1 (arg
, 0, from_tty
);
5945 tbreak_command (char *arg
, int from_tty
)
5947 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5951 hbreak_command (char *arg
, int from_tty
)
5953 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5957 thbreak_command (char *arg
, int from_tty
)
5959 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5963 stop_command (char *arg
, int from_tty
)
5965 printf_filtered (_("Specify the type of breakpoint to set.\n\
5966 Usage: stop in <function | address>\n\
5967 stop at <line>\n"));
5971 stopin_command (char *arg
, int from_tty
)
5975 if (arg
== (char *) NULL
)
5977 else if (*arg
!= '*')
5982 /* look for a ':'. If this is a line number specification, then
5983 say it is bad, otherwise, it should be an address or
5984 function/method name */
5985 while (*argptr
&& !hasColon
)
5987 hasColon
= (*argptr
== ':');
5992 badInput
= (*argptr
!= ':'); /* Not a class::method */
5994 badInput
= isdigit (*arg
); /* a simple line number */
5998 printf_filtered (_("Usage: stop in <function | address>\n"));
6000 break_command_1 (arg
, 0, from_tty
);
6004 stopat_command (char *arg
, int from_tty
)
6008 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
6015 /* look for a ':'. If there is a '::' then get out, otherwise
6016 it is probably a line number. */
6017 while (*argptr
&& !hasColon
)
6019 hasColon
= (*argptr
== ':');
6024 badInput
= (*argptr
== ':'); /* we have class::method */
6026 badInput
= !isdigit (*arg
); /* not a line number */
6030 printf_filtered (_("Usage: stop at <line>\n"));
6032 break_command_1 (arg
, 0, from_tty
);
6035 /* accessflag: hw_write: watch write,
6036 hw_read: watch read,
6037 hw_access: watch access (read or write) */
6039 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
6041 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
6042 struct symtab_and_line sal
;
6043 struct expression
*exp
;
6044 struct block
*exp_valid_block
;
6045 struct value
*val
, *mark
;
6046 struct frame_info
*frame
;
6047 struct frame_info
*prev_frame
= NULL
;
6048 char *exp_start
= NULL
;
6049 char *exp_end
= NULL
;
6050 char *tok
, *id_tok_start
, *end_tok
;
6052 char *cond_start
= NULL
;
6053 char *cond_end
= NULL
;
6054 struct expression
*cond
= NULL
;
6055 int i
, other_type_used
, target_resources_ok
= 0;
6056 enum bptype bp_type
;
6060 init_sal (&sal
); /* initialize to zeroes */
6062 /* Make sure that we actually have parameters to parse. */
6063 if (arg
!= NULL
&& arg
[0] != '\0')
6065 toklen
= strlen (arg
); /* Size of argument list. */
6067 /* Points tok to the end of the argument list. */
6068 tok
= arg
+ toklen
- 1;
6070 /* Go backwards in the parameters list. Skip the last parameter.
6071 If we're expecting a 'thread <thread_num>' parameter, this should
6072 be the thread identifier. */
6073 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6075 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6078 /* Points end_tok to the beginning of the last token. */
6079 id_tok_start
= tok
+ 1;
6081 /* Go backwards in the parameters list. Skip one more parameter.
6082 If we're expecting a 'thread <thread_num>' parameter, we should
6083 reach a "thread" token. */
6084 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6089 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6092 /* Move the pointer forward to skip the whitespace and
6093 calculate the length of the token. */
6095 toklen
= end_tok
- tok
;
6097 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
6099 /* At this point we've found a "thread" token, which means
6100 the user is trying to set a watchpoint that triggers
6101 only in a specific thread. */
6104 /* Extract the thread ID from the next token. */
6105 thread
= strtol (id_tok_start
, &endp
, 0);
6107 /* Check if the user provided a valid numeric value for the
6109 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
6110 error (_("Invalid thread ID specification %s."), id_tok_start
);
6112 /* Check if the thread actually exists. */
6113 if (!valid_thread_id (thread
))
6114 error (_("Unknown thread %d."), thread
);
6116 /* Truncate the string and get rid of the thread <thread_num>
6117 parameter before the parameter list is parsed by the
6118 evaluate_expression() function. */
6123 /* Parse the rest of the arguments. */
6124 innermost_block
= NULL
;
6126 exp
= parse_exp_1 (&arg
, 0, 0);
6128 /* Remove trailing whitespace from the expression before saving it.
6129 This makes the eventual display of the expression string a bit
6131 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
6134 exp_valid_block
= innermost_block
;
6135 mark
= value_mark ();
6136 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
6138 release_value (val
);
6141 while (*tok
== ' ' || *tok
== '\t')
6145 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
6148 toklen
= end_tok
- tok
;
6149 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
6151 tok
= cond_start
= end_tok
+ 1;
6152 cond
= parse_exp_1 (&tok
, 0, 0);
6156 error (_("Junk at end of command."));
6158 if (accessflag
== hw_read
)
6159 bp_type
= bp_read_watchpoint
;
6160 else if (accessflag
== hw_access
)
6161 bp_type
= bp_access_watchpoint
;
6163 bp_type
= bp_hardware_watchpoint
;
6165 mem_cnt
= can_use_hardware_watchpoint (val
);
6166 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
6167 error (_("Expression cannot be implemented with read/access watchpoint."));
6170 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
6171 target_resources_ok
=
6172 target_can_use_hardware_watchpoint (bp_type
, i
+ mem_cnt
,
6174 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
6175 error (_("Target does not support this type of hardware watchpoint."));
6177 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
6178 error (_("Target can only support one kind of HW watchpoint at a time."));
6181 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
6182 watchpoint could not be set. */
6183 if (!mem_cnt
|| target_resources_ok
<= 0)
6184 bp_type
= bp_watchpoint
;
6186 frame
= block_innermost_frame (exp_valid_block
);
6188 prev_frame
= get_prev_frame (frame
);
6192 /* If the expression is "local", then set up a "watchpoint scope"
6193 breakpoint at the point where we've left the scope of the watchpoint
6194 expression. Create the scope breakpoint before the watchpoint, so
6195 that we will encounter it first in bpstat_stop_status. */
6196 if (innermost_block
&& prev_frame
)
6198 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
6199 bp_watchpoint_scope
);
6201 scope_breakpoint
->enable_state
= bp_enabled
;
6203 /* Automatically delete the breakpoint when it hits. */
6204 scope_breakpoint
->disposition
= disp_del
;
6206 /* Only break in the proper frame (help with recursion). */
6207 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
6209 /* Set the address at which we will stop. */
6210 scope_breakpoint
->loc
->requested_address
6211 = get_frame_pc (prev_frame
);
6212 scope_breakpoint
->loc
->address
6213 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
6214 scope_breakpoint
->type
);
6217 /* Now set up the breakpoint. */
6218 b
= set_raw_breakpoint (sal
, bp_type
);
6219 set_breakpoint_count (breakpoint_count
+ 1);
6220 b
->number
= breakpoint_count
;
6222 b
->disposition
= disp_donttouch
;
6224 b
->exp_valid_block
= exp_valid_block
;
6225 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
6228 b
->loc
->cond
= cond
;
6230 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
6235 b
->watchpoint_frame
= get_frame_id (frame
);
6237 b
->watchpoint_frame
= null_frame_id
;
6239 if (scope_breakpoint
!= NULL
)
6241 /* The scope breakpoint is related to the watchpoint. We will
6242 need to act on them together. */
6243 b
->related_breakpoint
= scope_breakpoint
;
6244 scope_breakpoint
->related_breakpoint
= b
;
6247 value_free_to_mark (mark
);
6249 update_global_location_list (1);
6252 /* Return count of locations need to be watched and can be handled
6253 in hardware. If the watchpoint can not be handled
6254 in hardware return zero. */
6257 can_use_hardware_watchpoint (struct value
*v
)
6259 int found_memory_cnt
= 0;
6260 struct value
*head
= v
;
6262 /* Did the user specifically forbid us to use hardware watchpoints? */
6263 if (!can_use_hw_watchpoints
)
6266 /* Make sure that the value of the expression depends only upon
6267 memory contents, and values computed from them within GDB. If we
6268 find any register references or function calls, we can't use a
6269 hardware watchpoint.
6271 The idea here is that evaluating an expression generates a series
6272 of values, one holding the value of every subexpression. (The
6273 expression a*b+c has five subexpressions: a, b, a*b, c, and
6274 a*b+c.) GDB's values hold almost enough information to establish
6275 the criteria given above --- they identify memory lvalues,
6276 register lvalues, computed values, etcetera. So we can evaluate
6277 the expression, and then scan the chain of values that leaves
6278 behind to decide whether we can detect any possible change to the
6279 expression's final value using only hardware watchpoints.
6281 However, I don't think that the values returned by inferior
6282 function calls are special in any way. So this function may not
6283 notice that an expression involving an inferior function call
6284 can't be watched with hardware watchpoints. FIXME. */
6285 for (; v
; v
= value_next (v
))
6287 if (VALUE_LVAL (v
) == lval_memory
)
6290 /* A lazy memory lvalue is one that GDB never needed to fetch;
6291 we either just used its address (e.g., `a' in `a.b') or
6292 we never needed it at all (e.g., `a' in `a,b'). */
6296 /* Ahh, memory we actually used! Check if we can cover
6297 it with hardware watchpoints. */
6298 struct type
*vtype
= check_typedef (value_type (v
));
6300 /* We only watch structs and arrays if user asked for it
6301 explicitly, never if they just happen to appear in a
6302 middle of some value chain. */
6304 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6305 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6307 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
6308 int len
= TYPE_LENGTH (value_type (v
));
6310 if (!target_region_ok_for_hw_watchpoint (vaddr
, len
))
6317 else if (VALUE_LVAL (v
) != not_lval
6318 && deprecated_value_modifiable (v
) == 0)
6319 return 0; /* ??? What does this represent? */
6320 else if (VALUE_LVAL (v
) == lval_register
)
6321 return 0; /* cannot watch a register with a HW watchpoint */
6324 /* The expression itself looks suitable for using a hardware
6325 watchpoint, but give the target machine a chance to reject it. */
6326 return found_memory_cnt
;
6330 watch_command_wrapper (char *arg
, int from_tty
)
6332 watch_command (arg
, from_tty
);
6336 watch_command (char *arg
, int from_tty
)
6338 watch_command_1 (arg
, hw_write
, from_tty
);
6342 rwatch_command_wrapper (char *arg
, int from_tty
)
6344 rwatch_command (arg
, from_tty
);
6348 rwatch_command (char *arg
, int from_tty
)
6350 watch_command_1 (arg
, hw_read
, from_tty
);
6354 awatch_command_wrapper (char *arg
, int from_tty
)
6356 awatch_command (arg
, from_tty
);
6360 awatch_command (char *arg
, int from_tty
)
6362 watch_command_1 (arg
, hw_access
, from_tty
);
6366 /* Helper routines for the until_command routine in infcmd.c. Here
6367 because it uses the mechanisms of breakpoints. */
6369 struct until_break_command_continuation_args
6371 struct breakpoint
*breakpoint
;
6372 struct breakpoint
*breakpoint2
;
6375 /* This function is called by fetch_inferior_event via the
6376 cmd_continuation pointer, to complete the until command. It takes
6377 care of cleaning up the temporary breakpoints set up by the until
6380 until_break_command_continuation (void *arg
)
6382 struct until_break_command_continuation_args
*a
= arg
;
6384 delete_breakpoint (a
->breakpoint
);
6386 delete_breakpoint (a
->breakpoint2
);
6390 until_break_command (char *arg
, int from_tty
, int anywhere
)
6392 struct symtabs_and_lines sals
;
6393 struct symtab_and_line sal
;
6394 struct frame_info
*frame
= get_selected_frame (NULL
);
6395 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6396 struct breakpoint
*breakpoint
;
6397 struct breakpoint
*breakpoint2
= NULL
;
6398 struct cleanup
*old_chain
;
6400 clear_proceed_status ();
6402 /* Set a breakpoint where the user wants it and at return from
6405 if (default_breakpoint_valid
)
6406 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6407 default_breakpoint_line
, (char ***) NULL
, NULL
);
6409 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6410 0, (char ***) NULL
, NULL
);
6412 if (sals
.nelts
!= 1)
6413 error (_("Couldn't get information on specified line."));
6416 xfree (sals
.sals
); /* malloc'd, so freed */
6419 error (_("Junk at end of arguments."));
6421 resolve_sal_pc (&sal
);
6424 /* If the user told us to continue until a specified location,
6425 we don't specify a frame at which we need to stop. */
6426 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6428 /* Otherwise, specify the current frame, because we want to stop only
6429 at the very same frame. */
6430 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6433 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6435 /* Keep within the current frame, or in frames called by the current
6439 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6440 sal
.pc
= get_frame_pc (prev_frame
);
6441 breakpoint2
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6443 make_cleanup_delete_breakpoint (breakpoint2
);
6446 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6448 /* If we are running asynchronously, and proceed call above has actually
6449 managed to start the target, arrange for breakpoints to be
6450 deleted when the target stops. Otherwise, we're already stopped and
6451 delete breakpoints via cleanup chain. */
6453 if (target_can_async_p () && is_running (inferior_ptid
))
6455 struct until_break_command_continuation_args
*args
;
6456 args
= xmalloc (sizeof (*args
));
6458 args
->breakpoint
= breakpoint
;
6459 args
->breakpoint2
= breakpoint2
;
6461 discard_cleanups (old_chain
);
6462 add_continuation (inferior_thread (),
6463 until_break_command_continuation
, args
,
6467 do_cleanups (old_chain
);
6471 ep_skip_leading_whitespace (char **s
)
6473 if ((s
== NULL
) || (*s
== NULL
))
6475 while (isspace (**s
))
6479 /* This function attempts to parse an optional "if <cond>" clause
6480 from the arg string. If one is not found, it returns NULL.
6482 Else, it returns a pointer to the condition string. (It does not
6483 attempt to evaluate the string against a particular block.) And,
6484 it updates arg to point to the first character following the parsed
6485 if clause in the arg string. */
6488 ep_parse_optional_if_clause (char **arg
)
6492 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6495 /* Skip the "if" keyword. */
6498 /* Skip any extra leading whitespace, and record the start of the
6499 condition string. */
6500 ep_skip_leading_whitespace (arg
);
6503 /* Assume that the condition occupies the remainder of the arg string. */
6504 (*arg
) += strlen (cond_string
);
6509 /* This function attempts to parse an optional filename from the arg
6510 string. If one is not found, it returns NULL.
6512 Else, it returns a pointer to the parsed filename. (This function
6513 makes no attempt to verify that a file of that name exists, or is
6514 accessible.) And, it updates arg to point to the first character
6515 following the parsed filename in the arg string.
6517 Note that clients needing to preserve the returned filename for
6518 future access should copy it to their own buffers. */
6520 ep_parse_optional_filename (char **arg
)
6522 static char filename
[1024];
6527 if ((*arg_p
== '\0') || isspace (*arg_p
))
6545 /* Commands to deal with catching events, such as signals, exceptions,
6546 process start/exit, etc. */
6550 catch_fork_temporary
, catch_vfork_temporary
,
6551 catch_fork_permanent
, catch_vfork_permanent
6556 catch_fork_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6558 char *cond_string
= NULL
;
6559 catch_fork_kind fork_kind
;
6562 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
6563 tempflag
= (fork_kind
== catch_fork_temporary
6564 || fork_kind
== catch_vfork_temporary
);
6568 ep_skip_leading_whitespace (&arg
);
6570 /* The allowed syntax is:
6572 catch [v]fork if <cond>
6574 First, check if there's an if clause. */
6575 cond_string
= ep_parse_optional_if_clause (&arg
);
6577 if ((*arg
!= '\0') && !isspace (*arg
))
6578 error (_("Junk at end of arguments."));
6580 /* If this target supports it, create a fork or vfork catchpoint
6581 and enable reporting of such events. */
6584 case catch_fork_temporary
:
6585 case catch_fork_permanent
:
6586 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6587 &catch_fork_breakpoint_ops
);
6589 case catch_vfork_temporary
:
6590 case catch_vfork_permanent
:
6591 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6592 &catch_vfork_breakpoint_ops
);
6595 error (_("unsupported or unknown fork kind; cannot catch it"));
6601 catch_exec_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6604 char *cond_string
= NULL
;
6606 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6610 ep_skip_leading_whitespace (&arg
);
6612 /* The allowed syntax is:
6614 catch exec if <cond>
6616 First, check if there's an if clause. */
6617 cond_string
= ep_parse_optional_if_clause (&arg
);
6619 if ((*arg
!= '\0') && !isspace (*arg
))
6620 error (_("Junk at end of arguments."));
6622 /* If this target supports it, create an exec catchpoint
6623 and enable reporting of such events. */
6624 create_catchpoint (tempflag
, cond_string
, &catch_exec_breakpoint_ops
);
6627 static enum print_stop_action
6628 print_exception_catchpoint (struct breakpoint
*b
)
6630 int bp_temp
, bp_throw
;
6632 annotate_catchpoint (b
->number
);
6634 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6635 if (b
->loc
->address
!= b
->loc
->requested_address
)
6636 breakpoint_adjustment_warning (b
->loc
->requested_address
,
6639 bp_temp
= b
->disposition
== disp_del
;
6641 bp_temp
? "Temporary catchpoint "
6643 if (!ui_out_is_mi_like_p (uiout
))
6644 ui_out_field_int (uiout
, "bkptno", b
->number
);
6646 bp_throw
? " (exception thrown), "
6647 : " (exception caught), ");
6648 if (ui_out_is_mi_like_p (uiout
))
6650 ui_out_field_string (uiout
, "reason",
6651 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
6652 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6653 ui_out_field_int (uiout
, "bkptno", b
->number
);
6655 return PRINT_SRC_AND_LOC
;
6659 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6661 struct value_print_options opts
;
6662 get_user_print_options (&opts
);
6663 if (opts
.addressprint
)
6666 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
6667 ui_out_field_string (uiout
, "addr", "<PENDING>");
6669 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6673 *last_addr
= b
->loc
->address
;
6674 if (strstr (b
->addr_string
, "throw") != NULL
)
6675 ui_out_field_string (uiout
, "what", "exception throw");
6677 ui_out_field_string (uiout
, "what", "exception catch");
6681 print_mention_exception_catchpoint (struct breakpoint
*b
)
6686 bp_temp
= b
->disposition
== disp_del
;
6687 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6688 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
6689 : _("Catchpoint "));
6690 ui_out_field_int (uiout
, "bkptno", b
->number
);
6691 ui_out_text (uiout
, bp_throw
? _(" (throw)")
6695 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6698 NULL
, /* breakpoint_hit */
6699 print_exception_catchpoint
,
6700 print_one_exception_catchpoint
,
6701 print_mention_exception_catchpoint
6705 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6706 enum exception_event_kind ex_event
, int from_tty
)
6708 char *trigger_func_name
;
6710 if (ex_event
== EX_EVENT_CATCH
)
6711 trigger_func_name
= "__cxa_begin_catch";
6713 trigger_func_name
= "__cxa_throw";
6715 break_command_really (trigger_func_name
, cond_string
, -1,
6716 0 /* condition and thread are valid. */,
6719 AUTO_BOOLEAN_TRUE
/* pending */,
6720 &gnu_v3_exception_catchpoint_ops
, from_tty
,
6726 /* Deal with "catch catch" and "catch throw" commands */
6729 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6730 int tempflag
, int from_tty
)
6732 char *cond_string
= NULL
;
6733 struct symtab_and_line
*sal
= NULL
;
6737 ep_skip_leading_whitespace (&arg
);
6739 cond_string
= ep_parse_optional_if_clause (&arg
);
6741 if ((*arg
!= '\0') && !isspace (*arg
))
6742 error (_("Junk at end of arguments."));
6744 if ((ex_event
!= EX_EVENT_THROW
) &&
6745 (ex_event
!= EX_EVENT_CATCH
))
6746 error (_("Unsupported or unknown exception event; cannot catch it"));
6748 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6751 warning (_("Unsupported with this platform/compiler combination."));
6754 /* Implementation of "catch catch" command. */
6757 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6759 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6760 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
6763 /* Implementation of "catch throw" command. */
6766 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6768 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6769 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
6772 /* Create a breakpoint struct for Ada exception catchpoints. */
6775 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6779 struct expression
*cond
,
6780 struct breakpoint_ops
*ops
,
6784 struct breakpoint
*b
;
6788 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6789 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6790 version for exception catchpoints, because two catchpoints
6791 used for different exception names will use the same address.
6792 In this case, a "breakpoint ... also set at..." warning is
6793 unproductive. Besides. the warning phrasing is also a bit
6794 inapropriate, we should use the word catchpoint, and tell
6795 the user what type of catchpoint it is. The above is good
6796 enough for now, though. */
6799 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6800 set_breakpoint_count (breakpoint_count
+ 1);
6802 b
->enable_state
= bp_enabled
;
6803 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6804 b
->number
= breakpoint_count
;
6805 b
->ignore_count
= 0;
6806 b
->loc
->cond
= cond
;
6807 b
->addr_string
= addr_string
;
6808 b
->language
= language_ada
;
6809 b
->cond_string
= cond_string
;
6810 b
->exp_string
= exp_string
;
6815 update_global_location_list (1);
6818 /* Implement the "catch exception" command. */
6821 catch_ada_exception_command (char *arg
, int from_tty
,
6822 struct cmd_list_element
*command
)
6825 struct symtab_and_line sal
;
6827 char *addr_string
= NULL
;
6828 char *exp_string
= NULL
;
6829 char *cond_string
= NULL
;
6830 struct expression
*cond
= NULL
;
6831 struct breakpoint_ops
*ops
= NULL
;
6833 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6837 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6838 &cond_string
, &cond
, &ops
);
6839 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6840 cond_string
, cond
, ops
, tempflag
,
6844 /* Implement the "catch assert" command. */
6847 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6850 struct symtab_and_line sal
;
6851 char *addr_string
= NULL
;
6852 struct breakpoint_ops
*ops
= NULL
;
6854 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6858 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6859 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6860 tempflag
, from_tty
);
6864 catch_command (char *arg
, int from_tty
)
6866 error (_("Catch requires an event name."));
6871 tcatch_command (char *arg
, int from_tty
)
6873 error (_("Catch requires an event name."));
6876 /* Delete breakpoints by address or line. */
6879 clear_command (char *arg
, int from_tty
)
6881 struct breakpoint
*b
;
6882 VEC(breakpoint_p
) *found
= 0;
6885 struct symtabs_and_lines sals
;
6886 struct symtab_and_line sal
;
6891 sals
= decode_line_spec (arg
, 1);
6896 sals
.sals
= (struct symtab_and_line
*)
6897 xmalloc (sizeof (struct symtab_and_line
));
6898 make_cleanup (xfree
, sals
.sals
);
6899 init_sal (&sal
); /* initialize to zeroes */
6900 sal
.line
= default_breakpoint_line
;
6901 sal
.symtab
= default_breakpoint_symtab
;
6902 sal
.pc
= default_breakpoint_address
;
6903 if (sal
.symtab
== 0)
6904 error (_("No source file specified."));
6912 /* We don't call resolve_sal_pc here. That's not
6913 as bad as it seems, because all existing breakpoints
6914 typically have both file/line and pc set. So, if
6915 clear is given file/line, we can match this to existing
6916 breakpoint without obtaining pc at all.
6918 We only support clearing given the address explicitly
6919 present in breakpoint table. Say, we've set breakpoint
6920 at file:line. There were several PC values for that file:line,
6921 due to optimization, all in one block.
6922 We've picked one PC value. If "clear" is issued with another
6923 PC corresponding to the same file:line, the breakpoint won't
6924 be cleared. We probably can still clear the breakpoint, but
6925 since the other PC value is never presented to user, user
6926 can only find it by guessing, and it does not seem important
6929 /* For each line spec given, delete bps which correspond
6930 to it. Do it in two passes, solely to preserve the current
6931 behavior that from_tty is forced true if we delete more than
6935 for (i
= 0; i
< sals
.nelts
; i
++)
6937 /* If exact pc given, clear bpts at that pc.
6938 If line given (pc == 0), clear all bpts on specified line.
6939 If defaulting, clear all bpts on default line
6942 defaulting sal.pc != 0 tests to do
6947 1 0 <can't happen> */
6951 /* Find all matching breakpoints and add them to
6956 /* Are we going to delete b? */
6957 if (b
->type
!= bp_none
6958 && b
->type
!= bp_watchpoint
6959 && b
->type
!= bp_hardware_watchpoint
6960 && b
->type
!= bp_read_watchpoint
6961 && b
->type
!= bp_access_watchpoint
)
6963 struct bp_location
*loc
= b
->loc
;
6964 for (; loc
; loc
= loc
->next
)
6966 int pc_match
= sal
.pc
6967 && (loc
->address
== sal
.pc
)
6968 && (!section_is_overlay (loc
->section
)
6969 || loc
->section
== sal
.section
);
6970 int line_match
= ((default_match
|| (0 == sal
.pc
))
6971 && b
->source_file
!= NULL
6972 && sal
.symtab
!= NULL
6973 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6974 && b
->line_number
== sal
.line
);
6975 if (pc_match
|| line_match
)
6984 VEC_safe_push(breakpoint_p
, found
, b
);
6987 /* Now go thru the 'found' chain and delete them. */
6988 if (VEC_empty(breakpoint_p
, found
))
6991 error (_("No breakpoint at %s."), arg
);
6993 error (_("No breakpoint at this line."));
6996 if (VEC_length(breakpoint_p
, found
) > 1)
6997 from_tty
= 1; /* Always report if deleted more than one */
7000 if (VEC_length(breakpoint_p
, found
) == 1)
7001 printf_unfiltered (_("Deleted breakpoint "));
7003 printf_unfiltered (_("Deleted breakpoints "));
7005 breakpoints_changed ();
7007 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
7010 printf_unfiltered ("%d ", b
->number
);
7011 delete_breakpoint (b
);
7014 putchar_unfiltered ('\n');
7017 /* Delete breakpoint in BS if they are `delete' breakpoints and
7018 all breakpoints that are marked for deletion, whether hit or not.
7019 This is called after any breakpoint is hit, or after errors. */
7022 breakpoint_auto_delete (bpstat bs
)
7024 struct breakpoint
*b
, *temp
;
7026 for (; bs
; bs
= bs
->next
)
7027 if (bs
->breakpoint_at
7028 && bs
->breakpoint_at
->owner
7029 && bs
->breakpoint_at
->owner
->disposition
== disp_del
7031 delete_breakpoint (bs
->breakpoint_at
->owner
);
7033 ALL_BREAKPOINTS_SAFE (b
, temp
)
7035 if (b
->disposition
== disp_del_at_next_stop
)
7036 delete_breakpoint (b
);
7040 /* A cleanup function which destroys a vector. */
7043 do_vec_free (void *p
)
7045 VEC(bp_location_p
) **vec
= p
;
7047 VEC_free (bp_location_p
, *vec
);
7050 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
7051 into the inferior, only remove already-inserted locations that no
7052 longer should be inserted. Functions that delete a breakpoint or
7053 breakpoints should pass false, so that deleting a breakpoint
7054 doesn't have the side effect of inserting the locations of other
7055 breakpoints that are marked not-inserted, but should_be_inserted
7056 returns true on them.
7058 This behaviour is useful is situations close to tear-down -- e.g.,
7059 after an exec, while the target still has execution, but breakpoint
7060 shadows of the previous executable image should *NOT* be restored
7061 to the new image; or before detaching, where the target still has
7062 execution and wants to delete breakpoints from GDB's lists, and all
7063 breakpoints had already been removed from the inferior. */
7066 update_global_location_list (int should_insert
)
7068 struct breakpoint
*b
;
7069 struct bp_location
**next
= &bp_location_chain
;
7070 struct bp_location
*loc
;
7071 struct bp_location
*loc2
;
7072 VEC(bp_location_p
) *old_locations
= NULL
;
7075 struct cleanup
*cleanups
;
7077 cleanups
= make_cleanup (do_vec_free
, &old_locations
);
7078 /* Store old locations for future reference. */
7079 for (loc
= bp_location_chain
; loc
; loc
= loc
->global_next
)
7080 VEC_safe_push (bp_location_p
, old_locations
, loc
);
7082 bp_location_chain
= NULL
;
7085 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
7088 next
= &(loc
->global_next
);
7093 /* Identify bp_location instances that are no longer present in the new
7094 list, and therefore should be freed. Note that it's not necessary that
7095 those locations should be removed from inferior -- if there's another
7096 location at the same address (previously marked as duplicate),
7097 we don't need to remove/insert the location. */
7098 for (ix
= 0; VEC_iterate(bp_location_p
, old_locations
, ix
, loc
); ++ix
)
7100 /* Tells if 'loc' is found amoung the new locations. If not, we
7102 int found_object
= 0;
7103 /* Tells if the location should remain inserted in the target. */
7104 int keep_in_target
= 0;
7106 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7113 /* If this location is no longer present, and inserted, look if there's
7114 maybe a new location at the same address. If so, mark that one
7115 inserted, and don't remove this one. This is needed so that we
7116 don't have a time window where a breakpoint at certain location is not
7121 /* If the location is inserted now, we might have to remove it. */
7123 if (found_object
&& should_be_inserted (loc
))
7125 /* The location is still present in the location list, and still
7126 should be inserted. Don't do anything. */
7131 /* The location is either no longer present, or got disabled.
7132 See if there's another location at the same address, in which
7133 case we don't need to remove this one from the target. */
7134 if (breakpoint_address_is_meaningful (loc
->owner
))
7135 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7137 /* For the sake of should_insert_location. The
7138 call to check_duplicates will fix up this later. */
7139 loc2
->duplicate
= 0;
7140 if (should_be_inserted (loc2
)
7141 && loc2
!= loc
&& loc2
->address
== loc
->address
)
7144 loc2
->target_info
= loc
->target_info
;
7151 if (!keep_in_target
)
7153 if (remove_breakpoint (loc
, mark_uninserted
))
7155 /* This is just about all we can do. We could keep this
7156 location on the global list, and try to remove it next
7157 time, but there's no particular reason why we will
7160 Note that at this point, loc->owner is still valid,
7161 as delete_breakpoint frees the breakpoint only
7162 after calling us. */
7163 printf_filtered (_("warning: Error removing breakpoint %d\n"),
7164 loc
->owner
->number
);
7172 if (removed
&& non_stop
)
7174 /* This location was removed from the targets. In non-stop mode,
7175 a race condition is possible where we've removed a breakpoint,
7176 but stop events for that breakpoint are already queued and will
7177 arrive later. To suppress spurious SIGTRAPs reported to user,
7178 we keep this breakpoint location for a bit, and will retire it
7179 after we see 3 * thread_count events.
7180 The theory here is that reporting of events should,
7181 "on the average", be fair, so after that many event we'll see
7182 events from all threads that have anything of interest, and no
7183 longer need to keep this breakpoint. This is just a
7184 heuristic, but if it's wrong, we'll report unexpected SIGTRAP,
7185 which is usability issue, but not a correctness problem. */
7186 loc
->events_till_retirement
= 3 * (thread_count () + 1);
7189 VEC_safe_push (bp_location_p
, moribund_locations
, loc
);
7192 free_bp_location (loc
);
7198 check_duplicates (b
);
7201 if (breakpoints_always_inserted_mode () && should_insert
7202 && (target_has_execution
7203 || (gdbarch_has_global_solist (target_gdbarch
)
7204 && target_supports_multi_process ())))
7205 insert_breakpoint_locations ();
7207 do_cleanups (cleanups
);
7211 breakpoint_retire_moribund (void)
7213 struct bp_location
*loc
;
7216 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
7217 if (--(loc
->events_till_retirement
) == 0)
7219 free_bp_location (loc
);
7220 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
7226 update_global_location_list_nothrow (int inserting
)
7228 struct gdb_exception e
;
7229 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7230 update_global_location_list (inserting
);
7233 /* Clear BPT from a BPS. */
7235 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
7238 for (bs
= bps
; bs
; bs
= bs
->next
)
7239 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7241 bs
->breakpoint_at
= NULL
;
7243 /* bs->commands will be freed later. */
7247 /* Callback for iterate_over_threads. */
7249 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
7251 struct breakpoint
*bpt
= data
;
7252 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
7256 /* Delete a breakpoint and clean up all traces of it in the data
7260 delete_breakpoint (struct breakpoint
*bpt
)
7262 struct breakpoint
*b
;
7263 struct bp_location
*loc
, *next
;
7265 gdb_assert (bpt
!= NULL
);
7267 /* Has this bp already been deleted? This can happen because multiple
7268 lists can hold pointers to bp's. bpstat lists are especial culprits.
7270 One example of this happening is a watchpoint's scope bp. When the
7271 scope bp triggers, we notice that the watchpoint is out of scope, and
7272 delete it. We also delete its scope bp. But the scope bp is marked
7273 "auto-deleting", and is already on a bpstat. That bpstat is then
7274 checked for auto-deleting bp's, which are deleted.
7276 A real solution to this problem might involve reference counts in bp's,
7277 and/or giving them pointers back to their referencing bpstat's, and
7278 teaching delete_breakpoint to only free a bp's storage when no more
7279 references were extent. A cheaper bandaid was chosen. */
7280 if (bpt
->type
== bp_none
)
7283 observer_notify_breakpoint_deleted (bpt
->number
);
7285 if (breakpoint_chain
== bpt
)
7286 breakpoint_chain
= bpt
->next
;
7291 b
->next
= bpt
->next
;
7295 free_command_lines (&bpt
->commands
);
7296 if (bpt
->cond_string
!= NULL
)
7297 xfree (bpt
->cond_string
);
7298 if (bpt
->addr_string
!= NULL
)
7299 xfree (bpt
->addr_string
);
7300 if (bpt
->exp
!= NULL
)
7302 if (bpt
->exp_string
!= NULL
)
7303 xfree (bpt
->exp_string
);
7304 if (bpt
->val
!= NULL
)
7305 value_free (bpt
->val
);
7306 if (bpt
->source_file
!= NULL
)
7307 xfree (bpt
->source_file
);
7308 if (bpt
->exec_pathname
!= NULL
)
7309 xfree (bpt
->exec_pathname
);
7311 /* Be sure no bpstat's are pointing at it after it's been freed. */
7312 /* FIXME, how can we find all bpstat's?
7313 We just check stop_bpstat for now. Note that we cannot just
7314 remove bpstats pointing at bpt from the stop_bpstat list
7315 entirely, as breakpoint commands are associated with the bpstat;
7316 if we remove it here, then the later call to
7317 bpstat_do_actions (&stop_bpstat);
7318 in event-top.c won't do anything, and temporary breakpoints
7319 with commands won't work. */
7321 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
7323 /* Now that breakpoint is removed from breakpoint
7324 list, update the global location list. This
7325 will remove locations that used to belong to
7326 this breakpoint. Do this before freeing
7327 the breakpoint itself, since remove_breakpoint
7328 looks at location's owner. It might be better
7329 design to have location completely self-contained,
7330 but it's not the case now. */
7331 update_global_location_list (0);
7334 /* On the chance that someone will soon try again to delete this same
7335 bp, we mark it as deleted before freeing its storage. */
7336 bpt
->type
= bp_none
;
7342 do_delete_breakpoint_cleanup (void *b
)
7344 delete_breakpoint (b
);
7348 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7350 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7354 delete_command (char *arg
, int from_tty
)
7356 struct breakpoint
*b
, *temp
;
7362 int breaks_to_delete
= 0;
7364 /* Delete all breakpoints if no argument.
7365 Do not delete internal or call-dummy breakpoints, these
7366 have to be deleted with an explicit breakpoint number argument. */
7369 if (b
->type
!= bp_call_dummy
&&
7370 b
->type
!= bp_shlib_event
&&
7371 b
->type
!= bp_thread_event
&&
7372 b
->type
!= bp_overlay_event
&&
7375 breaks_to_delete
= 1;
7380 /* Ask user only if there are some breakpoints to delete. */
7382 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7384 ALL_BREAKPOINTS_SAFE (b
, temp
)
7386 if (b
->type
!= bp_call_dummy
&&
7387 b
->type
!= bp_shlib_event
&&
7388 b
->type
!= bp_thread_event
&&
7389 b
->type
!= bp_overlay_event
&&
7391 delete_breakpoint (b
);
7396 map_breakpoint_numbers (arg
, delete_breakpoint
);
7400 all_locations_are_pending (struct bp_location
*loc
)
7402 for (; loc
; loc
= loc
->next
)
7403 if (!loc
->shlib_disabled
)
7408 /* Subroutine of update_breakpoint_locations to simplify it.
7409 Return non-zero if multiple fns in list LOC have the same name.
7410 Null names are ignored. */
7413 ambiguous_names_p (struct bp_location
*loc
)
7415 struct bp_location
*l
;
7416 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7417 (int (*) (const void *, const void *)) streq
,
7418 NULL
, xcalloc
, xfree
);
7420 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7423 const char *name
= l
->function_name
;
7425 /* Allow for some names to be NULL, ignore them. */
7429 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7431 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7446 update_breakpoint_locations (struct breakpoint
*b
,
7447 struct symtabs_and_lines sals
)
7451 struct bp_location
*existing_locations
= b
->loc
;
7453 /* If there's no new locations, and all existing locations
7454 are pending, don't do anything. This optimizes
7455 the common case where all locations are in the same
7456 shared library, that was unloaded. We'd like to
7457 retain the location, so that when the library
7458 is loaded again, we don't loose the enabled/disabled
7459 status of the individual locations. */
7460 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7465 for (i
= 0; i
< sals
.nelts
; ++i
)
7467 struct bp_location
*new_loc
=
7468 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
7470 /* Reparse conditions, they might contain references to the
7472 if (b
->cond_string
!= NULL
)
7474 struct gdb_exception e
;
7477 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7479 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7484 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7485 b
->number
, e
.message
);
7486 new_loc
->enabled
= 0;
7490 if (b
->source_file
!= NULL
)
7491 xfree (b
->source_file
);
7492 if (sals
.sals
[i
].symtab
== NULL
)
7493 b
->source_file
= NULL
;
7496 savestring (sals
.sals
[i
].symtab
->filename
,
7497 strlen (sals
.sals
[i
].symtab
->filename
));
7499 if (b
->line_number
== 0)
7500 b
->line_number
= sals
.sals
[i
].line
;
7503 /* Update locations of permanent breakpoints. */
7504 if (b
->enable_state
== bp_permanent
)
7505 make_breakpoint_permanent (b
);
7507 /* If possible, carry over 'disable' status from existing breakpoints. */
7509 struct bp_location
*e
= existing_locations
;
7510 /* If there are multiple breakpoints with the same function name,
7511 e.g. for inline functions, comparing function names won't work.
7512 Instead compare pc addresses; this is just a heuristic as things
7513 may have moved, but in practice it gives the correct answer
7514 often enough until a better solution is found. */
7515 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7517 for (; e
; e
= e
->next
)
7519 if (!e
->enabled
&& e
->function_name
)
7521 struct bp_location
*l
= b
->loc
;
7522 if (have_ambiguous_names
)
7524 for (; l
; l
= l
->next
)
7525 if (e
->address
== l
->address
)
7533 for (; l
; l
= l
->next
)
7534 if (l
->function_name
7535 && strcmp (e
->function_name
, l
->function_name
) == 0)
7545 update_global_location_list (1);
7549 /* Reset a breakpoint given it's struct breakpoint * BINT.
7550 The value we return ends up being the return value from catch_errors.
7551 Unused in this case. */
7554 breakpoint_re_set_one (void *bint
)
7556 /* get past catch_errs */
7557 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7561 int *not_found_ptr
= ¬_found
;
7562 struct symtabs_and_lines sals
= {};
7563 struct symtabs_and_lines expanded
;
7565 enum enable_state save_enable
;
7566 struct gdb_exception e
;
7567 struct cleanup
*cleanups
;
7572 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7576 case bp_hardware_breakpoint
:
7578 if (b
->addr_string
== NULL
)
7580 /* Anything without a string can't be re-set. */
7581 delete_breakpoint (b
);
7585 set_language (b
->language
);
7586 input_radix
= b
->input_radix
;
7588 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7590 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7595 int not_found_and_ok
= 0;
7596 /* For pending breakpoints, it's expected that parsing
7597 will fail until the right shared library is loaded.
7598 User has already told to create pending breakpoints and
7599 don't need extra messages. If breakpoint is in bp_shlib_disabled
7600 state, then user already saw the message about that breakpoint
7601 being disabled, and don't want to see more errors. */
7603 && (b
->condition_not_parsed
7604 || (b
->loc
&& b
->loc
->shlib_disabled
)
7605 || b
->enable_state
== bp_disabled
))
7606 not_found_and_ok
= 1;
7608 if (!not_found_and_ok
)
7610 /* We surely don't want to warn about the same breakpoint
7611 10 times. One solution, implemented here, is disable
7612 the breakpoint on error. Another solution would be to
7613 have separate 'warning emitted' flag. Since this
7614 happens only when a binary has changed, I don't know
7615 which approach is better. */
7616 b
->enable_state
= bp_disabled
;
7617 throw_exception (e
);
7624 gdb_assert (sals
.nelts
== 1);
7625 resolve_sal_pc (&sals
.sals
[0]);
7626 if (b
->condition_not_parsed
&& s
&& s
[0])
7628 char *cond_string
= 0;
7632 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7633 &cond_string
, &thread
, &task
);
7635 b
->cond_string
= cond_string
;
7638 b
->condition_not_parsed
= 0;
7640 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7641 cleanups
= make_cleanup (xfree
, sals
.sals
);
7642 update_breakpoint_locations (b
, expanded
);
7643 do_cleanups (cleanups
);
7647 case bp_hardware_watchpoint
:
7648 case bp_read_watchpoint
:
7649 case bp_access_watchpoint
:
7650 /* Watchpoint can be either on expression using entirely global variables,
7651 or it can be on local variables.
7653 Watchpoints of the first kind are never auto-deleted, and even persist
7654 across program restarts. Since they can use variables from shared
7655 libraries, we need to reparse expression as libraries are loaded
7658 Watchpoints on local variables can also change meaning as result
7659 of solib event. For example, if a watchpoint uses both a local and
7660 a global variables in expression, it's a local watchpoint, but
7661 unloading of a shared library will make the expression invalid.
7662 This is not a very common use case, but we still re-evaluate
7663 expression, to avoid surprises to the user.
7665 Note that for local watchpoints, we re-evaluate it only if
7666 watchpoints frame id is still valid. If it's not, it means
7667 the watchpoint is out of scope and will be deleted soon. In fact,
7668 I'm not sure we'll ever be called in this case.
7670 If a local watchpoint's frame id is still valid, then
7671 b->exp_valid_block is likewise valid, and we can safely use it.
7673 Don't do anything about disabled watchpoints, since they will
7674 be reevaluated again when enabled. */
7675 update_watchpoint (b
, 1 /* reparse */);
7677 /* We needn't really do anything to reset these, since the mask
7678 that requests them is unaffected by e.g., new libraries being
7684 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7686 /* Delete overlay event breakpoints; they will be reset later by
7687 breakpoint_re_set. */
7688 case bp_overlay_event
:
7689 delete_breakpoint (b
);
7692 /* This breakpoint is special, it's set up when the inferior
7693 starts and we really don't want to touch it. */
7694 case bp_shlib_event
:
7696 /* Like bp_shlib_event, this breakpoint type is special.
7697 Once it is set up, we do not want to touch it. */
7698 case bp_thread_event
:
7700 /* Keep temporary breakpoints, which can be encountered when we step
7701 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7702 Otherwise these should have been blown away via the cleanup chain
7703 or by breakpoint_init_inferior when we rerun the executable. */
7706 case bp_watchpoint_scope
:
7708 case bp_step_resume
:
7710 case bp_longjmp_resume
:
7717 /* Re-set all breakpoints after symbols have been re-loaded.
7719 If OBJFILE is non-null, create overlay break point only in OBJFILE
7720 (speed optimization). Otherwise rescan all loaded objfiles. */
7723 breakpoint_re_set_objfile (struct objfile
*objfile
)
7725 struct breakpoint
*b
, *temp
;
7726 enum language save_language
;
7727 int save_input_radix
;
7729 save_language
= current_language
->la_language
;
7730 save_input_radix
= input_radix
;
7731 ALL_BREAKPOINTS_SAFE (b
, temp
)
7733 /* Format possible error msg */
7734 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7736 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7737 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7738 do_cleanups (cleanups
);
7740 set_language (save_language
);
7741 input_radix
= save_input_radix
;
7743 if (objfile
== NULL
)
7744 ALL_OBJFILES (objfile
)
7745 create_overlay_event_breakpoint ("_ovly_debug_event", objfile
);
7747 create_overlay_event_breakpoint ("_ovly_debug_event", objfile
);
7750 /* Re-set all breakpoints after symbols have been re-loaded. */
7753 breakpoint_re_set (void)
7755 breakpoint_re_set_objfile (NULL
);
7758 /* Reset the thread number of this breakpoint:
7760 - If the breakpoint is for all threads, leave it as-is.
7761 - Else, reset it to the current thread for inferior_ptid. */
7763 breakpoint_re_set_thread (struct breakpoint
*b
)
7765 if (b
->thread
!= -1)
7767 if (in_thread_list (inferior_ptid
))
7768 b
->thread
= pid_to_thread_id (inferior_ptid
);
7772 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7773 If from_tty is nonzero, it prints a message to that effect,
7774 which ends with a period (no newline). */
7777 set_ignore_count (int bptnum
, int count
, int from_tty
)
7779 struct breakpoint
*b
;
7785 if (b
->number
== bptnum
)
7787 b
->ignore_count
= count
;
7791 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7793 else if (count
== 1)
7794 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7797 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7800 breakpoints_changed ();
7801 observer_notify_breakpoint_modified (b
->number
);
7805 error (_("No breakpoint number %d."), bptnum
);
7809 make_breakpoint_silent (struct breakpoint
*b
)
7811 /* Silence the breakpoint. */
7815 /* Command to set ignore-count of breakpoint N to COUNT. */
7818 ignore_command (char *args
, int from_tty
)
7824 error_no_arg (_("a breakpoint number"));
7826 num
= get_number (&p
);
7828 error (_("bad breakpoint number: '%s'"), args
);
7830 error (_("Second argument (specified ignore-count) is missing."));
7832 set_ignore_count (num
,
7833 longest_to_int (value_as_long (parse_and_eval (p
))),
7836 printf_filtered ("\n");
7839 /* Call FUNCTION on each of the breakpoints
7840 whose numbers are given in ARGS. */
7843 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7848 struct breakpoint
*b
, *tmp
;
7852 error_no_arg (_("one or more breakpoint numbers"));
7859 num
= get_number_or_range (&p1
);
7862 warning (_("bad breakpoint number at or near '%s'"), p
);
7866 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7867 if (b
->number
== num
)
7869 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7872 if (related_breakpoint
)
7873 function (related_breakpoint
);
7877 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7883 static struct bp_location
*
7884 find_location_by_number (char *number
)
7886 char *dot
= strchr (number
, '.');
7890 struct breakpoint
*b
;
7891 struct bp_location
*loc
;
7896 bp_num
= get_number_or_range (&p1
);
7898 error (_("Bad breakpoint number '%s'"), number
);
7901 if (b
->number
== bp_num
)
7906 if (!b
|| b
->number
!= bp_num
)
7907 error (_("Bad breakpoint number '%s'"), number
);
7910 loc_num
= get_number_or_range (&p1
);
7912 error (_("Bad breakpoint location number '%s'"), number
);
7916 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7919 error (_("Bad breakpoint location number '%s'"), dot
+1);
7925 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7926 If from_tty is nonzero, it prints a message to that effect,
7927 which ends with a period (no newline). */
7930 disable_breakpoint (struct breakpoint
*bpt
)
7932 /* Never disable a watchpoint scope breakpoint; we want to
7933 hit them when we leave scope so we can delete both the
7934 watchpoint and its scope breakpoint at that time. */
7935 if (bpt
->type
== bp_watchpoint_scope
)
7938 /* You can't disable permanent breakpoints. */
7939 if (bpt
->enable_state
== bp_permanent
)
7942 bpt
->enable_state
= bp_disabled
;
7944 update_global_location_list (0);
7946 observer_notify_breakpoint_modified (bpt
->number
);
7950 disable_command (char *args
, int from_tty
)
7952 struct breakpoint
*bpt
;
7954 ALL_BREAKPOINTS (bpt
)
7958 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7964 case bp_hardware_breakpoint
:
7966 case bp_hardware_watchpoint
:
7967 case bp_read_watchpoint
:
7968 case bp_access_watchpoint
:
7969 disable_breakpoint (bpt
);
7973 else if (strchr (args
, '.'))
7975 struct bp_location
*loc
= find_location_by_number (args
);
7978 update_global_location_list (0);
7981 map_breakpoint_numbers (args
, disable_breakpoint
);
7985 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7987 int target_resources_ok
, other_type_used
;
7990 if (bpt
->type
== bp_hardware_breakpoint
)
7993 i
= hw_breakpoint_used_count ();
7994 target_resources_ok
=
7995 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
7997 if (target_resources_ok
== 0)
7998 error (_("No hardware breakpoint support in the target."));
7999 else if (target_resources_ok
< 0)
8000 error (_("Hardware breakpoints used exceeds limit."));
8003 if (bpt
->type
== bp_watchpoint
||
8004 bpt
->type
== bp_hardware_watchpoint
||
8005 bpt
->type
== bp_read_watchpoint
||
8006 bpt
->type
== bp_access_watchpoint
)
8008 struct gdb_exception e
;
8010 TRY_CATCH (e
, RETURN_MASK_ALL
)
8012 update_watchpoint (bpt
, 1 /* reparse */);
8016 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
8022 if (bpt
->enable_state
!= bp_permanent
)
8023 bpt
->enable_state
= bp_enabled
;
8024 bpt
->disposition
= disposition
;
8025 update_global_location_list (1);
8026 breakpoints_changed ();
8028 observer_notify_breakpoint_modified (bpt
->number
);
8033 enable_breakpoint (struct breakpoint
*bpt
)
8035 do_enable_breakpoint (bpt
, bpt
->disposition
);
8038 /* The enable command enables the specified breakpoints (or all defined
8039 breakpoints) so they once again become (or continue to be) effective
8040 in stopping the inferior. */
8043 enable_command (char *args
, int from_tty
)
8045 struct breakpoint
*bpt
;
8047 ALL_BREAKPOINTS (bpt
)
8051 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
8057 case bp_hardware_breakpoint
:
8059 case bp_hardware_watchpoint
:
8060 case bp_read_watchpoint
:
8061 case bp_access_watchpoint
:
8062 enable_breakpoint (bpt
);
8066 else if (strchr (args
, '.'))
8068 struct bp_location
*loc
= find_location_by_number (args
);
8071 update_global_location_list (1);
8074 map_breakpoint_numbers (args
, enable_breakpoint
);
8078 enable_once_breakpoint (struct breakpoint
*bpt
)
8080 do_enable_breakpoint (bpt
, disp_disable
);
8084 enable_once_command (char *args
, int from_tty
)
8086 map_breakpoint_numbers (args
, enable_once_breakpoint
);
8090 enable_delete_breakpoint (struct breakpoint
*bpt
)
8092 do_enable_breakpoint (bpt
, disp_del
);
8096 enable_delete_command (char *args
, int from_tty
)
8098 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
8102 set_breakpoint_cmd (char *args
, int from_tty
)
8107 show_breakpoint_cmd (char *args
, int from_tty
)
8111 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
8113 struct symtabs_and_lines
8114 decode_line_spec_1 (char *string
, int funfirstline
)
8116 struct symtabs_and_lines sals
;
8118 error (_("Empty line specification."));
8119 if (default_breakpoint_valid
)
8120 sals
= decode_line_1 (&string
, funfirstline
,
8121 default_breakpoint_symtab
,
8122 default_breakpoint_line
,
8123 (char ***) NULL
, NULL
);
8125 sals
= decode_line_1 (&string
, funfirstline
,
8126 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8128 error (_("Junk at end of line specification: %s"), string
);
8132 /* Create and insert a raw software breakpoint at PC. Return an
8133 identifier, which should be used to remove the breakpoint later.
8134 In general, places which call this should be using something on the
8135 breakpoint chain instead; this function should be eliminated
8139 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8141 struct bp_target_info
*bp_tgt
;
8143 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8144 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8146 bp_tgt
->placed_address
= pc
;
8147 if (target_insert_breakpoint (bp_tgt
) != 0)
8149 /* Could not insert the breakpoint. */
8157 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8160 deprecated_remove_raw_breakpoint (void *bp
)
8162 struct bp_target_info
*bp_tgt
= bp
;
8165 ret
= target_remove_breakpoint (bp_tgt
);
8171 /* One (or perhaps two) breakpoints used for software single stepping. */
8173 static void *single_step_breakpoints
[2];
8175 /* Create and insert a breakpoint for software single step. */
8178 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8182 if (single_step_breakpoints
[0] == NULL
)
8183 bpt_p
= &single_step_breakpoints
[0];
8186 gdb_assert (single_step_breakpoints
[1] == NULL
);
8187 bpt_p
= &single_step_breakpoints
[1];
8190 /* NOTE drow/2006-04-11: A future improvement to this function would be
8191 to only create the breakpoints once, and actually put them on the
8192 breakpoint chain. That would let us use set_raw_breakpoint. We could
8193 adjust the addresses each time they were needed. Doing this requires
8194 corresponding changes elsewhere where single step breakpoints are
8195 handled, however. So, for now, we use this. */
8197 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8199 error (_("Could not insert single-step breakpoint at 0x%s"),
8200 paddr_nz (next_pc
));
8203 /* Remove and delete any breakpoints used for software single step. */
8206 remove_single_step_breakpoints (void)
8208 gdb_assert (single_step_breakpoints
[0] != NULL
);
8210 /* See insert_single_step_breakpoint for more about this deprecated
8212 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8213 single_step_breakpoints
[0] = NULL
;
8215 if (single_step_breakpoints
[1] != NULL
)
8217 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8218 single_step_breakpoints
[1] = NULL
;
8222 /* Check whether a software single-step breakpoint is inserted at PC. */
8225 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8229 for (i
= 0; i
< 2; i
++)
8231 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8232 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8239 /* Tracepoint-specific operations. */
8241 /* Set tracepoint count to NUM. */
8243 set_tracepoint_count (int num
)
8245 tracepoint_count
= num
;
8246 set_internalvar (lookup_internalvar ("tpnum"),
8247 value_from_longest (builtin_type_int32
, (LONGEST
) num
));
8251 trace_command (char *arg
, int from_tty
)
8253 break_command_really (arg
,
8254 NULL
, 0, 1 /* parse arg */,
8255 0 /* tempflag */, 0 /* hardwareflag */,
8257 0 /* Ignore count */,
8258 pending_break_support
,
8262 set_tracepoint_count (breakpoint_count
);
8265 /* Print information on tracepoint number TPNUM_EXP, or all if
8269 tracepoints_info (char *tpnum_exp
, int from_tty
)
8271 struct breakpoint
*b
;
8272 int tps_to_list
= 0;
8274 /* In the no-arguments case, say "No tracepoints" if none found. */
8287 ui_out_message (uiout
, 0, "No tracepoints.\n");
8292 /* Otherwise be the same as "info break". */
8293 breakpoints_info (tpnum_exp
, from_tty
);
8296 /* The 'enable trace' command enables tracepoints.
8297 Not supported by all targets. */
8299 enable_trace_command (char *args
, int from_tty
)
8301 enable_command (args
, from_tty
);
8304 /* The 'disable trace' command disables tracepoints.
8305 Not supported by all targets. */
8307 disable_trace_command (char *args
, int from_tty
)
8309 disable_command (args
, from_tty
);
8312 /* Remove a tracepoint (or all if no argument) */
8314 delete_trace_command (char *arg
, int from_tty
)
8316 struct breakpoint
*b
, *temp
;
8322 int breaks_to_delete
= 0;
8324 /* Delete all breakpoints if no argument.
8325 Do not delete internal or call-dummy breakpoints, these
8326 have to be deleted with an explicit breakpoint number argument. */
8331 breaks_to_delete
= 1;
8336 /* Ask user only if there are some breakpoints to delete. */
8338 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
8340 ALL_BREAKPOINTS_SAFE (b
, temp
)
8342 if (b
->type
== bp_tracepoint
&&
8344 delete_breakpoint (b
);
8349 map_breakpoint_numbers (arg
, delete_breakpoint
);
8352 /* Set passcount for tracepoint.
8354 First command argument is passcount, second is tracepoint number.
8355 If tracepoint number omitted, apply to most recently defined.
8356 Also accepts special argument "all". */
8359 trace_pass_command (char *args
, int from_tty
)
8361 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
8365 if (args
== 0 || *args
== 0)
8366 error (_("passcount command requires an argument (count + optional TP num)"));
8368 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
8370 while (*args
&& isspace ((int) *args
))
8373 if (*args
&& strncasecmp (args
, "all", 3) == 0)
8375 args
+= 3; /* Skip special argument "all". */
8378 error (_("Junk at end of arguments."));
8381 t1
= get_tracepoint_by_number (&args
, 1, 1);
8387 ALL_TRACEPOINTS (t2
)
8388 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
8390 t2
->pass_count
= count
;
8391 observer_notify_tracepoint_modified (t2
->number
);
8393 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
8397 t1
= get_tracepoint_by_number (&args
, 1, 0);
8404 get_tracepoint (int num
)
8406 struct breakpoint
*t
;
8409 if (t
->number
== num
)
8415 /* Utility: parse a tracepoint number and look it up in the list.
8416 If MULTI_P is true, there might be a range of tracepoints in ARG.
8417 if OPTIONAL_P is true, then if the argument is missing, the most
8418 recent tracepoint (tracepoint_count) is returned. */
8420 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
8422 extern int tracepoint_count
;
8423 struct breakpoint
*t
;
8425 char *instring
= arg
== NULL
? NULL
: *arg
;
8427 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
8430 tpnum
= tracepoint_count
;
8432 error_no_arg (_("tracepoint number"));
8435 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
8439 if (instring
&& *instring
)
8440 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
8443 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
8448 if (t
->number
== tpnum
)
8453 /* FIXME: if we are in the middle of a range we don't want to give
8454 a message. The current interface to get_number_or_range doesn't
8455 allow us to discover this. */
8456 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
8460 /* save-tracepoints command */
8462 tracepoint_save_command (char *args
, int from_tty
)
8464 struct breakpoint
*tp
;
8466 struct action_line
*line
;
8468 char *i1
= " ", *i2
= " ";
8469 char *indent
, *actionline
, *pathname
;
8471 struct cleanup
*cleanup
;
8473 if (args
== 0 || *args
== 0)
8474 error (_("Argument required (file name in which to save tracepoints)"));
8476 /* See if we have anything to save. */
8477 ALL_TRACEPOINTS (tp
)
8484 warning (_("save-tracepoints: no tracepoints to save."));
8488 pathname
= tilde_expand (args
);
8489 cleanup
= make_cleanup (xfree
, pathname
);
8490 if (!(fp
= fopen (pathname
, "w")))
8491 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
8492 args
, safe_strerror (errno
));
8493 make_cleanup_fclose (fp
);
8495 ALL_TRACEPOINTS (tp
)
8497 if (tp
->addr_string
)
8498 fprintf (fp
, "trace %s\n", tp
->addr_string
);
8501 sprintf_vma (tmp
, tp
->loc
->address
);
8502 fprintf (fp
, "trace *0x%s\n", tmp
);
8506 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
8510 fprintf (fp
, " actions\n");
8512 for (line
= tp
->actions
; line
; line
= line
->next
)
8514 struct cmd_list_element
*cmd
;
8516 QUIT
; /* allow user to bail out with ^C */
8517 actionline
= line
->action
;
8518 while (isspace ((int) *actionline
))
8521 fprintf (fp
, "%s%s\n", indent
, actionline
);
8522 if (*actionline
!= '#') /* skip for comment lines */
8524 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
8526 error (_("Bad action list item: %s"), actionline
);
8527 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
8529 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
8535 do_cleanups (cleanup
);
8537 printf_filtered (_("Tracepoints saved to file '%s'.\n"), args
);
8541 /* Create a vector of all tracepoints. */
8546 VEC(breakpoint_p
) *tp_vec
= 0;
8547 struct breakpoint
*tp
;
8549 ALL_TRACEPOINTS (tp
)
8551 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
8558 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8559 It is defined as a macro to prevent duplication.
8560 COMMAND should be a string constant containing the name of the command. */
8561 #define BREAK_ARGS_HELP(command) \
8562 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8563 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8564 If a line number is specified, break at start of code for that line.\n\
8565 If a function is specified, break at start of code for that function.\n\
8566 If an address is specified, break at that exact address.\n\
8567 With no LOCATION, uses current execution address of selected stack frame.\n\
8568 This is useful for breaking on return to a stack frame.\n\
8570 THREADNUM is the number from \"info threads\".\n\
8571 CONDITION is a boolean expression.\n\
8573 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8575 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8577 /* List of subcommands for "catch". */
8578 static struct cmd_list_element
*catch_cmdlist
;
8580 /* List of subcommands for "tcatch". */
8581 static struct cmd_list_element
*tcatch_cmdlist
;
8583 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
8584 lists, and pass some additional user data to the command function. */
8586 add_catch_command (char *name
, char *docstring
,
8587 void (*sfunc
) (char *args
, int from_tty
,
8588 struct cmd_list_element
*command
),
8589 void *user_data_catch
,
8590 void *user_data_tcatch
)
8592 struct cmd_list_element
*command
;
8594 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8596 set_cmd_sfunc (command
, sfunc
);
8597 set_cmd_context (command
, user_data_catch
);
8599 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8601 set_cmd_sfunc (command
, sfunc
);
8602 set_cmd_context (command
, user_data_tcatch
);
8606 _initialize_breakpoint (void)
8608 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8609 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8610 struct cmd_list_element
*c
;
8612 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8614 breakpoint_chain
= 0;
8615 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8616 before a breakpoint is set. */
8617 breakpoint_count
= 0;
8619 tracepoint_count
= 0;
8621 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8622 Set ignore-count of breakpoint number N to COUNT.\n\
8623 Usage is `ignore N COUNT'."));
8625 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8627 add_com ("commands", class_breakpoint
, commands_command
, _("\
8628 Set commands to be executed when a breakpoint is hit.\n\
8629 Give breakpoint number as argument after \"commands\".\n\
8630 With no argument, the targeted breakpoint is the last one set.\n\
8631 The commands themselves follow starting on the next line.\n\
8632 Type a line containing \"end\" to indicate the end of them.\n\
8633 Give \"silent\" as the first line to make the breakpoint silent;\n\
8634 then no output is printed when it is hit, except what the commands print."));
8636 add_com ("condition", class_breakpoint
, condition_command
, _("\
8637 Specify breakpoint number N to break only if COND is true.\n\
8638 Usage is `condition N COND', where N is an integer and COND is an\n\
8639 expression to be evaluated whenever breakpoint N is reached."));
8641 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8642 Set a temporary breakpoint.\n\
8643 Like \"break\" except the breakpoint is only temporary,\n\
8644 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8645 by using \"enable delete\" on the breakpoint number.\n\
8647 BREAK_ARGS_HELP ("tbreak")));
8648 set_cmd_completer (c
, location_completer
);
8650 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8651 Set a hardware assisted breakpoint.\n\
8652 Like \"break\" except the breakpoint requires hardware support,\n\
8653 some target hardware may not have this support.\n\
8655 BREAK_ARGS_HELP ("hbreak")));
8656 set_cmd_completer (c
, location_completer
);
8658 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8659 Set a temporary hardware assisted breakpoint.\n\
8660 Like \"hbreak\" except the breakpoint is only temporary,\n\
8661 so it will be deleted when hit.\n\
8663 BREAK_ARGS_HELP ("thbreak")));
8664 set_cmd_completer (c
, location_completer
);
8666 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8667 Enable some breakpoints.\n\
8668 Give breakpoint numbers (separated by spaces) as arguments.\n\
8669 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8670 This is used to cancel the effect of the \"disable\" command.\n\
8671 With a subcommand you can enable temporarily."),
8672 &enablelist
, "enable ", 1, &cmdlist
);
8674 add_com ("ab", class_breakpoint
, enable_command
, _("\
8675 Enable some breakpoints.\n\
8676 Give breakpoint numbers (separated by spaces) as arguments.\n\
8677 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8678 This is used to cancel the effect of the \"disable\" command.\n\
8679 With a subcommand you can enable temporarily."));
8681 add_com_alias ("en", "enable", class_breakpoint
, 1);
8683 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8684 Enable some breakpoints.\n\
8685 Give breakpoint numbers (separated by spaces) as arguments.\n\
8686 This is used to cancel the effect of the \"disable\" command.\n\
8687 May be abbreviated to simply \"enable\".\n"),
8688 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8690 add_cmd ("once", no_class
, enable_once_command
, _("\
8691 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8692 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8695 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8696 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8697 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8700 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8701 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8702 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8705 add_cmd ("once", no_class
, enable_once_command
, _("\
8706 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8707 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8710 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8711 Disable some breakpoints.\n\
8712 Arguments are breakpoint numbers with spaces in between.\n\
8713 To disable all breakpoints, give no argument.\n\
8714 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8715 &disablelist
, "disable ", 1, &cmdlist
);
8716 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8717 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8719 add_com ("sb", class_breakpoint
, disable_command
, _("\
8720 Disable some breakpoints.\n\
8721 Arguments are breakpoint numbers with spaces in between.\n\
8722 To disable all breakpoints, give no argument.\n\
8723 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8725 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8726 Disable some breakpoints.\n\
8727 Arguments are breakpoint numbers with spaces in between.\n\
8728 To disable all breakpoints, give no argument.\n\
8729 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8730 This command may be abbreviated \"disable\"."),
8733 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8734 Delete some breakpoints or auto-display expressions.\n\
8735 Arguments are breakpoint numbers with spaces in between.\n\
8736 To delete all breakpoints, give no argument.\n\
8738 Also a prefix command for deletion of other GDB objects.\n\
8739 The \"unset\" command is also an alias for \"delete\"."),
8740 &deletelist
, "delete ", 1, &cmdlist
);
8741 add_com_alias ("d", "delete", class_breakpoint
, 1);
8742 add_com_alias ("del", "delete", class_breakpoint
, 1);
8744 add_com ("db", class_breakpoint
, delete_command
, _("\
8745 Delete some breakpoints.\n\
8746 Arguments are breakpoint numbers with spaces in between.\n\
8747 To delete all breakpoints, give no argument.\n"));
8749 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8750 Delete some breakpoints or auto-display expressions.\n\
8751 Arguments are breakpoint numbers with spaces in between.\n\
8752 To delete all breakpoints, give no argument.\n\
8753 This command may be abbreviated \"delete\"."),
8756 add_com ("clear", class_breakpoint
, clear_command
, _("\
8757 Clear breakpoint at specified line or function.\n\
8758 Argument may be line number, function name, or \"*\" and an address.\n\
8759 If line number is specified, all breakpoints in that line are cleared.\n\
8760 If function is specified, breakpoints at beginning of function are cleared.\n\
8761 If an address is specified, breakpoints at that address are cleared.\n\
8763 With no argument, clears all breakpoints in the line that the selected frame\n\
8766 See also the \"delete\" command which clears breakpoints by number."));
8768 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8769 Set breakpoint at specified line or function.\n"
8770 BREAK_ARGS_HELP ("break")));
8771 set_cmd_completer (c
, location_completer
);
8773 add_com_alias ("b", "break", class_run
, 1);
8774 add_com_alias ("br", "break", class_run
, 1);
8775 add_com_alias ("bre", "break", class_run
, 1);
8776 add_com_alias ("brea", "break", class_run
, 1);
8780 add_com_alias ("ba", "break", class_breakpoint
, 1);
8781 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8786 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8787 Break in function/address or break at a line in the current file."),
8788 &stoplist
, "stop ", 1, &cmdlist
);
8789 add_cmd ("in", class_breakpoint
, stopin_command
,
8790 _("Break in function or address."), &stoplist
);
8791 add_cmd ("at", class_breakpoint
, stopat_command
,
8792 _("Break at a line in the current file."), &stoplist
);
8793 add_com ("status", class_info
, breakpoints_info
, _("\
8794 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8795 The \"Type\" column indicates one of:\n\
8796 \tbreakpoint - normal breakpoint\n\
8797 \twatchpoint - watchpoint\n\
8798 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8799 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8800 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8801 address and file/line number respectively.\n\
8803 Convenience variable \"$_\" and default examine address for \"x\"\n\
8804 are set to the address of the last breakpoint listed unless the command\n\
8805 is prefixed with \"server \".\n\n\
8806 Convenience variable \"$bpnum\" contains the number of the last\n\
8810 add_info ("breakpoints", breakpoints_info
, _("\
8811 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8812 The \"Type\" column indicates one of:\n\
8813 \tbreakpoint - normal breakpoint\n\
8814 \twatchpoint - watchpoint\n\
8815 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8816 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8817 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8818 address and file/line number respectively.\n\
8820 Convenience variable \"$_\" and default examine address for \"x\"\n\
8821 are set to the address of the last breakpoint listed unless the command\n\
8822 is prefixed with \"server \".\n\n\
8823 Convenience variable \"$bpnum\" contains the number of the last\n\
8827 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8828 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8829 The \"Type\" column indicates one of:\n\
8830 \tbreakpoint - normal breakpoint\n\
8831 \twatchpoint - watchpoint\n\
8832 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8833 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8834 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8835 address and file/line number respectively.\n\
8837 Convenience variable \"$_\" and default examine address for \"x\"\n\
8838 are set to the address of the last breakpoint listed unless the command\n\
8839 is prefixed with \"server \".\n\n\
8840 Convenience variable \"$bpnum\" contains the number of the last\n\
8843 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8844 Status of all breakpoints, or breakpoint number NUMBER.\n\
8845 The \"Type\" column indicates one of:\n\
8846 \tbreakpoint - normal breakpoint\n\
8847 \twatchpoint - watchpoint\n\
8848 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8849 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8850 \tuntil - internal breakpoint used by the \"until\" command\n\
8851 \tfinish - internal breakpoint used by the \"finish\" command\n\
8852 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8853 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8854 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8855 address and file/line number respectively.\n\
8857 Convenience variable \"$_\" and default examine address for \"x\"\n\
8858 are set to the address of the last breakpoint listed unless the command\n\
8859 is prefixed with \"server \".\n\n\
8860 Convenience variable \"$bpnum\" contains the number of the last\n\
8862 &maintenanceinfolist
);
8864 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
8865 Set catchpoints to catch events."),
8866 &catch_cmdlist
, "catch ",
8867 0/*allow-unknown*/, &cmdlist
);
8869 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
8870 Set temporary catchpoints to catch events."),
8871 &tcatch_cmdlist
, "tcatch ",
8872 0/*allow-unknown*/, &cmdlist
);
8874 /* Add catch and tcatch sub-commands. */
8875 add_catch_command ("catch", _("\
8876 Catch an exception, when caught.\n\
8877 With an argument, catch only exceptions with the given name."),
8878 catch_catch_command
,
8881 add_catch_command ("throw", _("\
8882 Catch an exception, when thrown.\n\
8883 With an argument, catch only exceptions with the given name."),
8884 catch_throw_command
,
8887 add_catch_command ("fork", _("Catch calls to fork."),
8888 catch_fork_command_1
,
8889 (void *) (uintptr_t) catch_fork_permanent
,
8890 (void *) (uintptr_t) catch_fork_temporary
);
8891 add_catch_command ("vfork", _("Catch calls to vfork."),
8892 catch_fork_command_1
,
8893 (void *) (uintptr_t) catch_vfork_permanent
,
8894 (void *) (uintptr_t) catch_vfork_temporary
);
8895 add_catch_command ("exec", _("Catch calls to exec."),
8896 catch_exec_command_1
,
8899 add_catch_command ("exception", _("\
8900 Catch Ada exceptions, when raised.\n\
8901 With an argument, catch only exceptions with the given name."),
8902 catch_ada_exception_command
,
8905 add_catch_command ("assert", _("\
8906 Catch failed Ada assertions, when raised.\n\
8907 With an argument, catch only exceptions with the given name."),
8908 catch_assert_command
,
8912 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8913 Set a watchpoint for an expression.\n\
8914 A watchpoint stops execution of your program whenever the value of\n\
8915 an expression changes."));
8916 set_cmd_completer (c
, expression_completer
);
8918 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8919 Set a read watchpoint for an expression.\n\
8920 A watchpoint stops execution of your program whenever the value of\n\
8921 an expression is read."));
8922 set_cmd_completer (c
, expression_completer
);
8924 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8925 Set a watchpoint for an expression.\n\
8926 A watchpoint stops execution of your program whenever the value of\n\
8927 an expression is either read or written."));
8928 set_cmd_completer (c
, expression_completer
);
8930 add_info ("watchpoints", breakpoints_info
,
8931 _("Synonym for ``info breakpoints''."));
8934 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8935 respond to changes - contrary to the description. */
8936 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8937 &can_use_hw_watchpoints
, _("\
8938 Set debugger's willingness to use watchpoint hardware."), _("\
8939 Show debugger's willingness to use watchpoint hardware."), _("\
8940 If zero, gdb will not use hardware for new watchpoints, even if\n\
8941 such is available. (However, any hardware watchpoints that were\n\
8942 created before setting this to nonzero, will continue to use watchpoint\n\
8945 show_can_use_hw_watchpoints
,
8946 &setlist
, &showlist
);
8948 can_use_hw_watchpoints
= 1;
8950 /* Tracepoint manipulation commands. */
8952 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
8953 Set a tracepoint at specified line or function.\n\
8955 BREAK_ARGS_HELP ("trace") "\n\
8956 Do \"help tracepoints\" for info on other tracepoint commands."));
8957 set_cmd_completer (c
, location_completer
);
8959 add_com_alias ("tp", "trace", class_alias
, 0);
8960 add_com_alias ("tr", "trace", class_alias
, 1);
8961 add_com_alias ("tra", "trace", class_alias
, 1);
8962 add_com_alias ("trac", "trace", class_alias
, 1);
8964 add_info ("tracepoints", tracepoints_info
, _("\
8965 Status of tracepoints, or tracepoint number NUMBER.\n\
8966 Convenience variable \"$tpnum\" contains the number of the\n\
8967 last tracepoint set."));
8969 add_info_alias ("tp", "tracepoints", 1);
8971 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
8972 Delete specified tracepoints.\n\
8973 Arguments are tracepoint numbers, separated by spaces.\n\
8974 No argument means delete all tracepoints."),
8977 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
8978 Disable specified tracepoints.\n\
8979 Arguments are tracepoint numbers, separated by spaces.\n\
8980 No argument means disable all tracepoints."),
8982 deprecate_cmd (c
, "disable");
8984 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
8985 Enable specified tracepoints.\n\
8986 Arguments are tracepoint numbers, separated by spaces.\n\
8987 No argument means enable all tracepoints."),
8989 deprecate_cmd (c
, "enable");
8991 add_com ("passcount", class_trace
, trace_pass_command
, _("\
8992 Set the passcount for a tracepoint.\n\
8993 The trace will end when the tracepoint has been passed 'count' times.\n\
8994 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
8995 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
8997 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
8998 Save current tracepoint definitions as a script.\n\
8999 Use the 'source' command in another debug session to restore them."));
9000 set_cmd_completer (c
, filename_completer
);
9002 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
9003 Breakpoint specific settings\n\
9004 Configure various breakpoint-specific variables such as\n\
9005 pending breakpoint behavior"),
9006 &breakpoint_set_cmdlist
, "set breakpoint ",
9007 0/*allow-unknown*/, &setlist
);
9008 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
9009 Breakpoint specific settings\n\
9010 Configure various breakpoint-specific variables such as\n\
9011 pending breakpoint behavior"),
9012 &breakpoint_show_cmdlist
, "show breakpoint ",
9013 0/*allow-unknown*/, &showlist
);
9015 add_setshow_auto_boolean_cmd ("pending", no_class
,
9016 &pending_break_support
, _("\
9017 Set debugger's behavior regarding pending breakpoints."), _("\
9018 Show debugger's behavior regarding pending breakpoints."), _("\
9019 If on, an unrecognized breakpoint location will cause gdb to create a\n\
9020 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
9021 an error. If auto, an unrecognized breakpoint location results in a\n\
9022 user-query to see if a pending breakpoint should be created."),
9024 show_pending_break_support
,
9025 &breakpoint_set_cmdlist
,
9026 &breakpoint_show_cmdlist
);
9028 pending_break_support
= AUTO_BOOLEAN_AUTO
;
9030 add_setshow_boolean_cmd ("auto-hw", no_class
,
9031 &automatic_hardware_breakpoints
, _("\
9032 Set automatic usage of hardware breakpoints."), _("\
9033 Show automatic usage of hardware breakpoints."), _("\
9034 If set, the debugger will automatically use hardware breakpoints for\n\
9035 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
9036 a warning will be emitted for such breakpoints."),
9038 show_automatic_hardware_breakpoints
,
9039 &breakpoint_set_cmdlist
,
9040 &breakpoint_show_cmdlist
);
9042 add_setshow_enum_cmd ("always-inserted", class_support
,
9043 always_inserted_enums
, &always_inserted_mode
, _("\
9044 Set mode for inserting breakpoints."), _("\
9045 Show mode for inserting breakpoints."), _("\
9046 When this mode is off, breakpoints are inserted in inferior when it is\n\
9047 resumed, and removed when execution stops. When this mode is on,\n\
9048 breakpoints are inserted immediately and removed only when the user\n\
9049 deletes the breakpoint. When this mode is auto (which is the default),\n\
9050 the behaviour depends on the non-stop setting (see help set non-stop).\n\
9051 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
9052 behaves as if always-inserted mode is on; if gdb is controlling the\n\
9053 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
9055 &show_always_inserted_mode
,
9056 &breakpoint_set_cmdlist
,
9057 &breakpoint_show_cmdlist
);
9059 automatic_hardware_breakpoints
= 1;
9061 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);