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 static void skip_prologue_sal (struct symtab_and_line
*sal
);
213 /* Flag indicating that a command has proceeded the inferior past the
214 current breakpoint. */
216 static int breakpoint_proceeded
;
219 bpdisp_text (enum bpdisp disp
)
221 /* NOTE: the following values are a part of MI protocol and represent
222 values of 'disp' field returned when inferior stops at a breakpoint. */
223 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
224 return bpdisps
[(int) disp
];
227 /* Prototypes for exported functions. */
228 /* If FALSE, gdb will not use hardware support for watchpoints, even
229 if such is available. */
230 static int can_use_hw_watchpoints
;
233 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
234 struct cmd_list_element
*c
,
237 fprintf_filtered (file
, _("\
238 Debugger's willingness to use watchpoint hardware is %s.\n"),
242 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
243 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
244 for unrecognized breakpoint locations.
245 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
246 static enum auto_boolean pending_break_support
;
248 show_pending_break_support (struct ui_file
*file
, int from_tty
,
249 struct cmd_list_element
*c
,
252 fprintf_filtered (file
, _("\
253 Debugger's behavior regarding pending breakpoints is %s.\n"),
257 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
258 set with "break" but falling in read-only memory.
259 If 0, gdb will warn about such breakpoints, but won't automatically
260 use hardware breakpoints. */
261 static int automatic_hardware_breakpoints
;
263 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
264 struct cmd_list_element
*c
,
267 fprintf_filtered (file
, _("\
268 Automatic usage of hardware breakpoints is %s.\n"),
272 /* If on, gdb will keep breakpoints inserted even as inferior is
273 stopped, and immediately insert any new breakpoints. If off, gdb
274 will insert breakpoints into inferior only when resuming it, and
275 will remove breakpoints upon stop. If auto, GDB will behave as ON
276 if in non-stop mode, and as OFF if all-stop mode.*/
278 static const char always_inserted_auto
[] = "auto";
279 static const char always_inserted_on
[] = "on";
280 static const char always_inserted_off
[] = "off";
281 static const char *always_inserted_enums
[] = {
282 always_inserted_auto
,
287 static const char *always_inserted_mode
= always_inserted_auto
;
289 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
290 struct cmd_list_element
*c
, const char *value
)
292 if (always_inserted_mode
== always_inserted_auto
)
293 fprintf_filtered (file
, _("\
294 Always inserted breakpoint mode is %s (currently %s).\n"),
296 breakpoints_always_inserted_mode () ? "on" : "off");
298 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
302 breakpoints_always_inserted_mode (void)
304 return (always_inserted_mode
== always_inserted_on
305 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
308 void _initialize_breakpoint (void);
310 /* Are we executing breakpoint commands? */
311 static int executing_breakpoint_commands
;
313 /* Are overlay event breakpoints enabled? */
314 static int overlay_events_enabled
;
316 /* Walk the following statement or block through all breakpoints.
317 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
320 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
322 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
323 for (B = breakpoint_chain; \
324 B ? (TMP=B->next, 1): 0; \
327 /* Similar iterators for the low-level breakpoints. */
329 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
331 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
332 for (B = bp_location_chain; \
333 B ? (TMP=B->global_next, 1): 0; \
336 /* Iterator for tracepoints only. */
338 #define ALL_TRACEPOINTS(B) \
339 for (B = breakpoint_chain; B; B = B->next) \
340 if ((B)->type == bp_tracepoint)
342 /* Chains of all breakpoints defined. */
344 struct breakpoint
*breakpoint_chain
;
346 struct bp_location
*bp_location_chain
;
348 /* The locations that no longer correspond to any breakpoint,
349 unlinked from bp_location_chain, but for which a hit
350 may still be reported by a target. */
351 VEC(bp_location_p
) *moribund_locations
= NULL
;
353 /* Number of last breakpoint made. */
355 int breakpoint_count
;
357 /* Number of last tracepoint made. */
359 int tracepoint_count
;
361 /* Return whether a breakpoint is an active enabled breakpoint. */
363 breakpoint_enabled (struct breakpoint
*b
)
365 return (b
->enable_state
== bp_enabled
);
368 /* Set breakpoint count to NUM. */
371 set_breakpoint_count (int num
)
373 breakpoint_count
= num
;
374 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
377 /* Used in run_command to zero the hit count when a new run starts. */
380 clear_breakpoint_hit_counts (void)
382 struct breakpoint
*b
;
388 /* Default address, symtab and line to put a breakpoint at
389 for "break" command with no arg.
390 if default_breakpoint_valid is zero, the other three are
391 not valid, and "break" with no arg is an error.
393 This set by print_stack_frame, which calls set_default_breakpoint. */
395 int default_breakpoint_valid
;
396 CORE_ADDR default_breakpoint_address
;
397 struct symtab
*default_breakpoint_symtab
;
398 int default_breakpoint_line
;
400 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
401 Advance *PP after the string and any trailing whitespace.
403 Currently the string can either be a number or "$" followed by the name
404 of a convenience variable. Making it an expression wouldn't work well
405 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
407 If the string is a NULL pointer, that denotes the last breakpoint.
409 TRAILER is a character which can be found after the number; most
410 commonly this is `-'. If you don't want a trailer, use \0. */
412 get_number_trailer (char **pp
, int trailer
)
414 int retval
= 0; /* default */
418 /* Empty line means refer to the last breakpoint. */
419 return breakpoint_count
;
422 /* Make a copy of the name, so we can null-terminate it
423 to pass to lookup_internalvar(). */
428 while (isalnum (*p
) || *p
== '_')
430 varname
= (char *) alloca (p
- start
+ 1);
431 strncpy (varname
, start
, p
- start
);
432 varname
[p
- start
] = '\0';
433 if (get_internalvar_integer (lookup_internalvar (varname
), &val
))
437 printf_filtered (_("Convenience variable must have integer value.\n"));
445 while (*p
>= '0' && *p
<= '9')
448 /* There is no number here. (e.g. "cond a == b"). */
450 /* Skip non-numeric token */
451 while (*p
&& !isspace((int) *p
))
453 /* Return zero, which caller must interpret as error. */
459 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
461 /* Trailing junk: return 0 and let caller print error msg. */
462 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
473 /* Like get_number_trailer, but don't allow a trailer. */
475 get_number (char **pp
)
477 return get_number_trailer (pp
, '\0');
480 /* Parse a number or a range.
481 * A number will be of the form handled by get_number.
482 * A range will be of the form <number1> - <number2>, and
483 * will represent all the integers between number1 and number2,
486 * While processing a range, this fuction is called iteratively;
487 * At each call it will return the next value in the range.
489 * At the beginning of parsing a range, the char pointer PP will
490 * be advanced past <number1> and left pointing at the '-' token.
491 * Subsequent calls will not advance the pointer until the range
492 * is completed. The call that completes the range will advance
493 * pointer PP past <number2>.
497 get_number_or_range (char **pp
)
499 static int last_retval
, end_value
;
500 static char *end_ptr
;
501 static int in_range
= 0;
505 /* Default case: pp is pointing either to a solo number,
506 or to the first number of a range. */
507 last_retval
= get_number_trailer (pp
, '-');
512 /* This is the start of a range (<number1> - <number2>).
513 Skip the '-', parse and remember the second number,
514 and also remember the end of the final token. */
518 while (isspace ((int) *end_ptr
))
519 end_ptr
++; /* skip white space */
520 end_value
= get_number (temp
);
521 if (end_value
< last_retval
)
523 error (_("inverted range"));
525 else if (end_value
== last_retval
)
527 /* degenerate range (number1 == number2). Advance the
528 token pointer so that the range will be treated as a
537 error (_("negative value"));
540 /* pp points to the '-' that betokens a range. All
541 number-parsing has already been done. Return the next
542 integer value (one greater than the saved previous value).
543 Do not advance the token pointer 'pp' until the end of range
546 if (++last_retval
== end_value
)
548 /* End of range reached; advance token pointer. */
558 /* condition N EXP -- set break condition of breakpoint N to EXP. */
561 condition_command (char *arg
, int from_tty
)
563 struct breakpoint
*b
;
568 error_no_arg (_("breakpoint number"));
571 bnum
= get_number (&p
);
573 error (_("Bad breakpoint argument: '%s'"), arg
);
576 if (b
->number
== bnum
)
578 struct bp_location
*loc
= b
->loc
;
579 for (; loc
; loc
= loc
->next
)
587 if (b
->cond_string
!= NULL
)
588 xfree (b
->cond_string
);
592 b
->cond_string
= NULL
;
594 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
599 /* I don't know if it matters whether this is the string the user
600 typed in or the decompiled expression. */
601 b
->cond_string
= xstrdup (arg
);
602 b
->condition_not_parsed
= 0;
603 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
607 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
609 error (_("Junk at end of expression"));
612 breakpoints_changed ();
613 observer_notify_breakpoint_modified (b
->number
);
617 error (_("No breakpoint number %d."), bnum
);
621 commands_command (char *arg
, int from_tty
)
623 struct breakpoint
*b
;
626 struct command_line
*l
;
628 /* If we allowed this, we would have problems with when to
629 free the storage, if we change the commands currently
632 if (executing_breakpoint_commands
)
633 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
636 bnum
= get_number (&p
);
639 error (_("Unexpected extra arguments following breakpoint number."));
642 if (b
->number
== bnum
)
644 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
646 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
647 l
= read_command_lines (tmpbuf
, from_tty
, 1);
648 do_cleanups (cleanups
);
649 free_command_lines (&b
->commands
);
651 breakpoints_changed ();
652 observer_notify_breakpoint_modified (b
->number
);
655 error (_("No breakpoint number %d."), bnum
);
658 /* Like commands_command, but instead of reading the commands from
659 input stream, takes them from an already parsed command structure.
661 This is used by cli-script.c to DTRT with breakpoint commands
662 that are part of if and while bodies. */
663 enum command_control_type
664 commands_from_control_command (char *arg
, struct command_line
*cmd
)
666 struct breakpoint
*b
;
670 /* If we allowed this, we would have problems with when to
671 free the storage, if we change the commands currently
674 if (executing_breakpoint_commands
)
675 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
677 /* An empty string for the breakpoint number means the last
678 breakpoint, but get_number expects a NULL pointer. */
683 bnum
= get_number (&p
);
686 error (_("Unexpected extra arguments following breakpoint number."));
689 if (b
->number
== bnum
)
691 free_command_lines (&b
->commands
);
692 if (cmd
->body_count
!= 1)
693 error (_("Invalid \"commands\" block structure."));
694 /* We need to copy the commands because if/while will free the
695 list after it finishes execution. */
696 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
697 breakpoints_changed ();
698 observer_notify_breakpoint_modified (b
->number
);
699 return simple_control
;
701 error (_("No breakpoint number %d."), bnum
);
704 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
705 by replacing any memory breakpoints with their shadowed contents. */
708 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
710 struct bp_location
*b
;
711 CORE_ADDR bp_addr
= 0;
717 if (b
->owner
->type
== bp_none
)
718 warning (_("reading through apparently deleted breakpoint #%d?"),
721 if (b
->loc_type
!= bp_loc_software_breakpoint
)
725 /* Addresses and length of the part of the breakpoint that
727 bp_addr
= b
->target_info
.placed_address
;
728 bp_size
= b
->target_info
.shadow_len
;
730 /* bp isn't valid, or doesn't shadow memory. */
733 if (bp_addr
+ bp_size
<= memaddr
)
734 /* The breakpoint is entirely before the chunk of memory we
738 if (bp_addr
>= memaddr
+ len
)
739 /* The breakpoint is entirely after the chunk of memory we are
743 /* Offset within shadow_contents. */
744 if (bp_addr
< memaddr
)
746 /* Only copy the second part of the breakpoint. */
747 bp_size
-= memaddr
- bp_addr
;
748 bptoffset
= memaddr
- bp_addr
;
752 if (bp_addr
+ bp_size
> memaddr
+ len
)
754 /* Only copy the first part of the breakpoint. */
755 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
758 memcpy (buf
+ bp_addr
- memaddr
,
759 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
764 /* A wrapper function for inserting catchpoints. */
766 insert_catchpoint (struct ui_out
*uo
, void *args
)
768 struct breakpoint
*b
= (struct breakpoint
*) args
;
771 gdb_assert (b
->type
== bp_catchpoint
);
772 gdb_assert (b
->ops
!= NULL
&& b
->ops
->insert
!= NULL
);
778 is_hardware_watchpoint (struct breakpoint
*bpt
)
780 return (bpt
->type
== bp_hardware_watchpoint
781 || bpt
->type
== bp_read_watchpoint
782 || bpt
->type
== bp_access_watchpoint
);
785 /* Find the current value of a watchpoint on EXP. Return the value in
786 *VALP and *RESULTP and the chain of intermediate and final values
787 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
790 If a memory error occurs while evaluating the expression, *RESULTP will
791 be set to NULL. *RESULTP may be a lazy value, if the result could
792 not be read from memory. It is used to determine whether a value
793 is user-specified (we should watch the whole value) or intermediate
794 (we should watch only the bit used to locate the final value).
796 If the final value, or any intermediate value, could not be read
797 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
798 set to any referenced values. *VALP will never be a lazy value.
799 This is the value which we store in struct breakpoint.
801 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
802 value chain. The caller must free the values individually. If
803 VAL_CHAIN is NULL, all generated values will be left on the value
807 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
808 struct value
**resultp
, struct value
**val_chain
)
810 struct value
*mark
, *new_mark
, *result
;
811 volatile struct gdb_exception ex
;
819 /* Evaluate the expression. */
820 mark
= value_mark ();
823 TRY_CATCH (ex
, RETURN_MASK_ALL
)
825 result
= evaluate_expression (exp
);
829 /* Ignore memory errors, we want watchpoints pointing at
830 inaccessible memory to still be created; otherwise, throw the
831 error to some higher catcher. */
837 throw_exception (ex
);
842 new_mark
= value_mark ();
843 if (mark
== new_mark
)
848 /* Make sure it's not lazy, so that after the target stops again we
849 have a non-lazy previous value to compare with. */
851 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
856 /* Return the chain of intermediate values. We use this to
857 decide which addresses to watch. */
858 *val_chain
= new_mark
;
859 value_release_to_mark (mark
);
863 /* Assuming that B is a watchpoint:
864 - Reparse watchpoint expression, if REPARSE is non-zero
865 - Evaluate expression and store the result in B->val
866 - Evaluate the condition if there is one, and store the result
868 - Update the list of values that must be watched in B->loc.
870 If the watchpoint disposition is disp_del_at_next_stop, then do nothing.
871 If this is local watchpoint that is out of scope, delete it. */
873 update_watchpoint (struct breakpoint
*b
, int reparse
)
875 int within_current_scope
;
876 struct frame_id saved_frame_id
;
877 struct bp_location
*loc
;
880 /* We don't free locations. They are stored in bp_location_chain and
881 update_global_locations will eventually delete them and remove
882 breakpoints if needed. */
885 if (b
->disposition
== disp_del_at_next_stop
)
888 /* Save the current frame's ID so we can restore it after
889 evaluating the watchpoint expression on its own frame. */
890 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
891 took a frame parameter, so that we didn't have to change the
893 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
895 /* Determine if the watchpoint is within scope. */
896 if (b
->exp_valid_block
== NULL
)
897 within_current_scope
= 1;
900 struct frame_info
*fi
;
901 fi
= frame_find_by_id (b
->watchpoint_frame
);
902 within_current_scope
= (fi
!= NULL
);
903 if (within_current_scope
)
907 if (within_current_scope
&& reparse
)
916 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
917 /* If the meaning of expression itself changed, the old value is
918 no longer relevant. We don't want to report a watchpoint hit
919 to the user when the old value and the new value may actually
920 be completely different objects. */
926 /* If we failed to parse the expression, for example because
927 it refers to a global variable in a not-yet-loaded shared library,
928 don't try to insert watchpoint. We don't automatically delete
929 such watchpoint, though, since failure to parse expression
930 is different from out-of-scope watchpoint. */
931 if (within_current_scope
&& b
->exp
)
933 struct value
*val_chain
, *v
, *result
, *next
;
935 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
937 /* Avoid setting b->val if it's already set. The meaning of
938 b->val is 'the last value' user saw, and we should update
939 it only if we reported that last value to user. As it
940 happens, the code that reports it updates b->val directly. */
947 /* Change the type of breakpoint between hardware assisted or an
948 ordinary watchpoint depending on the hardware support and free
949 hardware slots. REPARSE is set when the inferior is started. */
950 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
953 int i
, mem_cnt
, other_type_used
;
955 i
= hw_watchpoint_used_count (bp_hardware_watchpoint
,
957 mem_cnt
= can_use_hardware_watchpoint (val_chain
);
960 b
->type
= bp_watchpoint
;
963 int target_resources_ok
= target_can_use_hardware_watchpoint
964 (bp_hardware_watchpoint
, i
+ mem_cnt
, other_type_used
);
965 if (target_resources_ok
<= 0)
966 b
->type
= bp_watchpoint
;
968 b
->type
= bp_hardware_watchpoint
;
972 /* Look at each value on the value chain. */
973 for (v
= val_chain
; v
; v
= next
)
975 /* If it's a memory location, and GDB actually needed
976 its contents to evaluate the expression, then we
977 must watch it. If the first value returned is
978 still lazy, that means an error occurred reading it;
979 watch it anyway in case it becomes readable. */
980 if (VALUE_LVAL (v
) == lval_memory
981 && (v
== val_chain
|| ! value_lazy (v
)))
983 struct type
*vtype
= check_typedef (value_type (v
));
985 /* We only watch structs and arrays if user asked
986 for it explicitly, never if they just happen to
987 appear in the middle of some value chain. */
989 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
990 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
994 struct bp_location
*loc
, **tmp
;
996 addr
= value_address (v
);
997 len
= TYPE_LENGTH (value_type (v
));
999 if (b
->type
== bp_read_watchpoint
)
1001 else if (b
->type
== bp_access_watchpoint
)
1004 loc
= allocate_bp_location (b
);
1005 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1008 loc
->address
= addr
;
1010 loc
->watchpoint_type
= type
;
1014 next
= value_next (v
);
1019 /* We just regenerated the list of breakpoint locations.
1020 The new location does not have its condition field set to anything
1021 and therefore, we must always reparse the cond_string, independently
1022 of the value of the reparse flag. */
1023 if (b
->cond_string
!= NULL
)
1025 char *s
= b
->cond_string
;
1026 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1029 else if (!within_current_scope
)
1031 printf_filtered (_("\
1032 Watchpoint %d deleted because the program has left the block \n\
1033 in which its expression is valid.\n"),
1035 if (b
->related_breakpoint
)
1036 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1037 b
->disposition
= disp_del_at_next_stop
;
1040 /* Restore the selected frame. */
1041 select_frame (frame_find_by_id (saved_frame_id
));
1045 /* Returns 1 iff breakpoint location should be
1046 inserted in the inferior. */
1048 should_be_inserted (struct bp_location
*bpt
)
1050 if (!breakpoint_enabled (bpt
->owner
))
1053 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
1056 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1059 /* Tracepoints are inserted by the target at a time of its choosing,
1061 if (bpt
->owner
->type
== bp_tracepoint
)
1067 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1068 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1069 and HW_BREAKPOINT_ERROR are used to report problems.
1071 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1072 method for each breakpoint or catchpoint type. */
1074 insert_bp_location (struct bp_location
*bpt
,
1075 struct ui_file
*tmp_error_stream
,
1076 int *disabled_breaks
,
1077 int *hw_breakpoint_error
)
1081 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1084 /* Initialize the target-specific information. */
1085 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1086 bpt
->target_info
.placed_address
= bpt
->address
;
1088 if (bpt
->loc_type
== bp_loc_software_breakpoint
1089 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1091 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1093 /* If the explicitly specified breakpoint type
1094 is not hardware breakpoint, check the memory map to see
1095 if the breakpoint address is in read only memory or not.
1096 Two important cases are:
1097 - location type is not hardware breakpoint, memory
1098 is readonly. We change the type of the location to
1099 hardware breakpoint.
1100 - location type is hardware breakpoint, memory is read-write.
1101 This means we've previously made the location hardware one, but
1102 then the memory map changed, so we undo.
1104 When breakpoints are removed, remove_breakpoints will
1105 use location types we've just set here, the only possible
1106 problem is that memory map has changed during running program,
1107 but it's not going to work anyway with current gdb. */
1108 struct mem_region
*mr
1109 = lookup_mem_region (bpt
->target_info
.placed_address
);
1113 if (automatic_hardware_breakpoints
)
1116 enum bp_loc_type new_type
;
1118 if (mr
->attrib
.mode
!= MEM_RW
)
1119 new_type
= bp_loc_hardware_breakpoint
;
1121 new_type
= bp_loc_software_breakpoint
;
1123 if (new_type
!= bpt
->loc_type
)
1125 static int said
= 0;
1126 bpt
->loc_type
= new_type
;
1129 fprintf_filtered (gdb_stdout
, _("\
1130 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1135 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1136 && mr
->attrib
.mode
!= MEM_RW
)
1137 warning (_("cannot set software breakpoint at readonly address %s"),
1138 paddr (bpt
->address
));
1142 /* First check to see if we have to handle an overlay. */
1143 if (overlay_debugging
== ovly_off
1144 || bpt
->section
== NULL
1145 || !(section_is_overlay (bpt
->section
)))
1147 /* No overlay handling: just set the breakpoint. */
1149 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1150 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1152 val
= target_insert_breakpoint (&bpt
->target_info
);
1156 /* This breakpoint is in an overlay section.
1157 Shall we set a breakpoint at the LMA? */
1158 if (!overlay_events_enabled
)
1160 /* Yes -- overlay event support is not active,
1161 so we must try to set a breakpoint at the LMA.
1162 This will not work for a hardware breakpoint. */
1163 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1164 warning (_("hardware breakpoint %d not supported in overlay!"),
1165 bpt
->owner
->number
);
1168 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1170 /* Set a software (trap) breakpoint at the LMA. */
1171 bpt
->overlay_target_info
= bpt
->target_info
;
1172 bpt
->overlay_target_info
.placed_address
= addr
;
1173 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
1175 fprintf_unfiltered (tmp_error_stream
,
1176 "Overlay breakpoint %d failed: in ROM?\n",
1177 bpt
->owner
->number
);
1180 /* Shall we set a breakpoint at the VMA? */
1181 if (section_is_mapped (bpt
->section
))
1183 /* Yes. This overlay section is mapped into memory. */
1184 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1185 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1187 val
= target_insert_breakpoint (&bpt
->target_info
);
1191 /* No. This breakpoint will not be inserted.
1192 No error, but do not mark the bp as 'inserted'. */
1199 /* Can't set the breakpoint. */
1200 if (solib_name_from_address (bpt
->address
))
1202 /* See also: disable_breakpoints_in_shlibs. */
1204 bpt
->shlib_disabled
= 1;
1205 if (!*disabled_breaks
)
1207 fprintf_unfiltered (tmp_error_stream
,
1208 "Cannot insert breakpoint %d.\n",
1209 bpt
->owner
->number
);
1210 fprintf_unfiltered (tmp_error_stream
,
1211 "Temporarily disabling shared library breakpoints:\n");
1213 *disabled_breaks
= 1;
1214 fprintf_unfiltered (tmp_error_stream
,
1215 "breakpoint #%d\n", bpt
->owner
->number
);
1219 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1221 *hw_breakpoint_error
= 1;
1222 fprintf_unfiltered (tmp_error_stream
,
1223 "Cannot insert hardware breakpoint %d.\n",
1224 bpt
->owner
->number
);
1228 fprintf_unfiltered (tmp_error_stream
,
1229 "Cannot insert breakpoint %d.\n",
1230 bpt
->owner
->number
);
1231 fprintf_filtered (tmp_error_stream
,
1232 "Error accessing memory address ");
1233 fputs_filtered (paddress (bpt
->address
), tmp_error_stream
);
1234 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1235 safe_strerror (val
));
1246 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1247 /* NOTE drow/2003-09-08: This state only exists for removing
1248 watchpoints. It's not clear that it's necessary... */
1249 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1251 val
= target_insert_watchpoint (bpt
->address
,
1253 bpt
->watchpoint_type
);
1254 bpt
->inserted
= (val
!= -1);
1257 else if (bpt
->owner
->type
== bp_catchpoint
)
1259 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1260 bpt
->owner
, RETURN_MASK_ERROR
);
1261 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1262 bpt
->owner
->number
);
1264 bpt
->owner
->enable_state
= bp_disabled
;
1268 /* We've already printed an error message if there was a problem
1269 inserting this catchpoint, and we've disabled the catchpoint,
1270 so just return success. */
1277 /* Make sure all breakpoints are inserted in inferior.
1278 Throws exception on any error.
1279 A breakpoint that is already inserted won't be inserted
1280 again, so calling this function twice is safe. */
1282 insert_breakpoints (void)
1284 struct breakpoint
*bpt
;
1286 ALL_BREAKPOINTS (bpt
)
1287 if (is_hardware_watchpoint (bpt
))
1288 update_watchpoint (bpt
, 0 /* don't reparse. */);
1290 update_global_location_list (1);
1292 /* update_global_location_list does not insert breakpoints when
1293 always_inserted_mode is not enabled. Explicitly insert them
1295 if (!breakpoints_always_inserted_mode ())
1296 insert_breakpoint_locations ();
1299 /* insert_breakpoints is used when starting or continuing the program.
1300 remove_breakpoints is used when the program stops.
1301 Both return zero if successful,
1302 or an `errno' value if could not write the inferior. */
1305 insert_breakpoint_locations (void)
1307 struct breakpoint
*bpt
;
1308 struct bp_location
*b
, *temp
;
1311 int disabled_breaks
= 0;
1312 int hw_breakpoint_error
= 0;
1314 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1315 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1317 /* Explicitly mark the warning -- this will only be printed if
1318 there was an error. */
1319 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1321 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1323 if (!should_be_inserted (b
) || b
->inserted
)
1326 /* There is no point inserting thread-specific breakpoints if the
1327 thread no longer exists. */
1328 if (b
->owner
->thread
!= -1
1329 && !valid_thread_id (b
->owner
->thread
))
1332 val
= insert_bp_location (b
, tmp_error_stream
,
1334 &hw_breakpoint_error
);
1339 /* If we failed to insert all locations of a watchpoint,
1340 remove them, as half-inserted watchpoint is of limited use. */
1341 ALL_BREAKPOINTS (bpt
)
1343 int some_failed
= 0;
1344 struct bp_location
*loc
;
1346 if (!is_hardware_watchpoint (bpt
))
1349 if (!breakpoint_enabled (bpt
))
1352 if (bpt
->disposition
== disp_del_at_next_stop
)
1355 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1363 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1365 remove_breakpoint (loc
, mark_uninserted
);
1367 hw_breakpoint_error
= 1;
1368 fprintf_unfiltered (tmp_error_stream
,
1369 "Could not insert hardware watchpoint %d.\n",
1377 /* If a hardware breakpoint or watchpoint was inserted, add a
1378 message about possibly exhausted resources. */
1379 if (hw_breakpoint_error
)
1381 fprintf_unfiltered (tmp_error_stream
,
1382 "Could not insert hardware breakpoints:\n\
1383 You may have requested too many hardware breakpoints/watchpoints.\n");
1385 target_terminal_ours_for_output ();
1386 error_stream (tmp_error_stream
);
1389 do_cleanups (cleanups
);
1393 remove_breakpoints (void)
1395 struct bp_location
*b
;
1398 ALL_BP_LOCATIONS (b
)
1402 val
= remove_breakpoint (b
, mark_uninserted
);
1411 remove_hw_watchpoints (void)
1413 struct bp_location
*b
;
1416 ALL_BP_LOCATIONS (b
)
1418 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1420 val
= remove_breakpoint (b
, mark_uninserted
);
1429 reattach_breakpoints (int pid
)
1431 struct bp_location
*b
;
1433 struct cleanup
*old_chain
= save_inferior_ptid ();
1434 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1435 int dummy1
= 0, dummy2
= 0;
1437 make_cleanup_ui_file_delete (tmp_error_stream
);
1439 inferior_ptid
= pid_to_ptid (pid
);
1440 ALL_BP_LOCATIONS (b
)
1445 val
= insert_bp_location (b
, tmp_error_stream
,
1449 do_cleanups (old_chain
);
1454 do_cleanups (old_chain
);
1458 static int internal_breakpoint_number
= -1;
1460 static struct breakpoint
*
1461 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
1463 struct symtab_and_line sal
;
1464 struct breakpoint
*b
;
1466 init_sal (&sal
); /* initialize to zeroes */
1469 sal
.section
= find_pc_overlay (sal
.pc
);
1471 b
= set_raw_breakpoint (sal
, type
);
1472 b
->number
= internal_breakpoint_number
--;
1473 b
->disposition
= disp_donttouch
;
1479 create_overlay_event_breakpoint (char *func_name
)
1481 struct objfile
*objfile
;
1483 ALL_OBJFILES (objfile
)
1485 struct breakpoint
*b
;
1486 struct minimal_symbol
*m
;
1488 m
= lookup_minimal_symbol_text (func_name
, objfile
);
1492 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
1494 b
->addr_string
= xstrdup (func_name
);
1496 if (overlay_debugging
== ovly_auto
)
1498 b
->enable_state
= bp_enabled
;
1499 overlay_events_enabled
= 1;
1503 b
->enable_state
= bp_disabled
;
1504 overlay_events_enabled
= 0;
1507 update_global_location_list (1);
1511 update_breakpoints_after_exec (void)
1513 struct breakpoint
*b
;
1514 struct breakpoint
*temp
;
1515 struct bp_location
*bploc
;
1517 /* We're about to delete breakpoints from GDB's lists. If the
1518 INSERTED flag is true, GDB will try to lift the breakpoints by
1519 writing the breakpoints' "shadow contents" back into memory. The
1520 "shadow contents" are NOT valid after an exec, so GDB should not
1521 do that. Instead, the target is responsible from marking
1522 breakpoints out as soon as it detects an exec. We don't do that
1523 here instead, because there may be other attempts to delete
1524 breakpoints after detecting an exec and before reaching here. */
1525 ALL_BP_LOCATIONS (bploc
)
1526 gdb_assert (!bploc
->inserted
);
1528 ALL_BREAKPOINTS_SAFE (b
, temp
)
1530 /* Solib breakpoints must be explicitly reset after an exec(). */
1531 if (b
->type
== bp_shlib_event
)
1533 delete_breakpoint (b
);
1537 /* Thread event breakpoints must be set anew after an exec(),
1538 as must overlay event breakpoints. */
1539 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1541 delete_breakpoint (b
);
1545 /* Step-resume breakpoints are meaningless after an exec(). */
1546 if (b
->type
== bp_step_resume
)
1548 delete_breakpoint (b
);
1552 /* Longjmp and longjmp-resume breakpoints are also meaningless
1554 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
1556 delete_breakpoint (b
);
1560 if (b
->type
== bp_catchpoint
)
1562 /* For now, none of the bp_catchpoint breakpoints need to
1563 do anything at this point. In the future, if some of
1564 the catchpoints need to something, we will need to add
1565 a new method, and call this method from here. */
1569 /* bp_finish is a special case. The only way we ought to be able
1570 to see one of these when an exec() has happened, is if the user
1571 caught a vfork, and then said "finish". Ordinarily a finish just
1572 carries them to the call-site of the current callee, by setting
1573 a temporary bp there and resuming. But in this case, the finish
1574 will carry them entirely through the vfork & exec.
1576 We don't want to allow a bp_finish to remain inserted now. But
1577 we can't safely delete it, 'cause finish_command has a handle to
1578 the bp on a bpstat, and will later want to delete it. There's a
1579 chance (and I've seen it happen) that if we delete the bp_finish
1580 here, that its storage will get reused by the time finish_command
1581 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1582 We really must allow finish_command to delete a bp_finish.
1584 In the absense of a general solution for the "how do we know
1585 it's safe to delete something others may have handles to?"
1586 problem, what we'll do here is just uninsert the bp_finish, and
1587 let finish_command delete it.
1589 (We know the bp_finish is "doomed" in the sense that it's
1590 momentary, and will be deleted as soon as finish_command sees
1591 the inferior stopped. So it doesn't matter that the bp's
1592 address is probably bogus in the new a.out, unlike e.g., the
1593 solib breakpoints.) */
1595 if (b
->type
== bp_finish
)
1600 /* Without a symbolic address, we have little hope of the
1601 pre-exec() address meaning the same thing in the post-exec()
1603 if (b
->addr_string
== NULL
)
1605 delete_breakpoint (b
);
1609 /* FIXME what about longjmp breakpoints? Re-create them here? */
1610 create_overlay_event_breakpoint ("_ovly_debug_event");
1614 detach_breakpoints (int pid
)
1616 struct bp_location
*b
;
1618 struct cleanup
*old_chain
= save_inferior_ptid ();
1620 if (pid
== PIDGET (inferior_ptid
))
1621 error (_("Cannot detach breakpoints of inferior_ptid"));
1623 /* Set inferior_ptid; remove_breakpoint uses this global. */
1624 inferior_ptid
= pid_to_ptid (pid
);
1625 ALL_BP_LOCATIONS (b
)
1629 val
= remove_breakpoint (b
, mark_inserted
);
1632 do_cleanups (old_chain
);
1637 do_cleanups (old_chain
);
1642 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1646 if (b
->owner
->enable_state
== bp_permanent
)
1647 /* Permanent breakpoints cannot be inserted or removed. */
1650 /* The type of none suggests that owner is actually deleted.
1651 This should not ever happen. */
1652 gdb_assert (b
->owner
->type
!= bp_none
);
1654 if (b
->loc_type
== bp_loc_software_breakpoint
1655 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1657 /* "Normal" instruction breakpoint: either the standard
1658 trap-instruction bp (bp_breakpoint), or a
1659 bp_hardware_breakpoint. */
1661 /* First check to see if we have to handle an overlay. */
1662 if (overlay_debugging
== ovly_off
1663 || b
->section
== NULL
1664 || !(section_is_overlay (b
->section
)))
1666 /* No overlay handling: just remove the breakpoint. */
1668 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1669 val
= target_remove_hw_breakpoint (&b
->target_info
);
1671 val
= target_remove_breakpoint (&b
->target_info
);
1675 /* This breakpoint is in an overlay section.
1676 Did we set a breakpoint at the LMA? */
1677 if (!overlay_events_enabled
)
1679 /* Yes -- overlay event support is not active, so we
1680 should have set a breakpoint at the LMA. Remove it.
1682 /* Ignore any failures: if the LMA is in ROM, we will
1683 have already warned when we failed to insert it. */
1684 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1685 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1687 target_remove_breakpoint (&b
->overlay_target_info
);
1689 /* Did we set a breakpoint at the VMA?
1690 If so, we will have marked the breakpoint 'inserted'. */
1693 /* Yes -- remove it. Previously we did not bother to
1694 remove the breakpoint if the section had been
1695 unmapped, but let's not rely on that being safe. We
1696 don't know what the overlay manager might do. */
1697 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1698 val
= target_remove_hw_breakpoint (&b
->target_info
);
1700 /* However, we should remove *software* breakpoints only
1701 if the section is still mapped, or else we overwrite
1702 wrong code with the saved shadow contents. */
1703 else if (section_is_mapped (b
->section
))
1704 val
= target_remove_breakpoint (&b
->target_info
);
1710 /* No -- not inserted, so no need to remove. No error. */
1715 /* In some cases, we might not be able to remove a breakpoint
1716 in a shared library that has already been removed, but we
1717 have not yet processed the shlib unload event. */
1718 if (val
&& solib_name_from_address (b
->address
))
1723 b
->inserted
= (is
== mark_inserted
);
1725 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1730 b
->inserted
= (is
== mark_inserted
);
1731 val
= target_remove_watchpoint (b
->address
, b
->length
,
1732 b
->watchpoint_type
);
1734 /* Failure to remove any of the hardware watchpoints comes here. */
1735 if ((is
== mark_uninserted
) && (b
->inserted
))
1736 warning (_("Could not remove hardware watchpoint %d."),
1739 else if (b
->owner
->type
== bp_catchpoint
1740 && breakpoint_enabled (b
->owner
)
1743 gdb_assert (b
->owner
->ops
!= NULL
&& b
->owner
->ops
->remove
!= NULL
);
1745 val
= b
->owner
->ops
->remove (b
->owner
);
1748 b
->inserted
= (is
== mark_inserted
);
1754 /* Clear the "inserted" flag in all breakpoints. */
1757 mark_breakpoints_out (void)
1759 struct bp_location
*bpt
;
1761 ALL_BP_LOCATIONS (bpt
)
1765 /* Clear the "inserted" flag in all breakpoints and delete any
1766 breakpoints which should go away between runs of the program.
1768 Plus other such housekeeping that has to be done for breakpoints
1771 Note: this function gets called at the end of a run (by
1772 generic_mourn_inferior) and when a run begins (by
1773 init_wait_for_inferior). */
1778 breakpoint_init_inferior (enum inf_context context
)
1780 struct breakpoint
*b
, *temp
;
1781 struct bp_location
*bpt
;
1784 /* If breakpoint locations are shared across processes, then there's
1786 if (gdbarch_has_global_breakpoints (target_gdbarch
))
1789 ALL_BP_LOCATIONS (bpt
)
1790 if (bpt
->owner
->enable_state
!= bp_permanent
)
1793 ALL_BREAKPOINTS_SAFE (b
, temp
)
1798 case bp_watchpoint_scope
:
1800 /* If the call dummy breakpoint is at the entry point it will
1801 cause problems when the inferior is rerun, so we better
1804 Also get rid of scope breakpoints. */
1805 delete_breakpoint (b
);
1809 case bp_hardware_watchpoint
:
1810 case bp_read_watchpoint
:
1811 case bp_access_watchpoint
:
1813 /* Likewise for watchpoints on local expressions. */
1814 if (b
->exp_valid_block
!= NULL
)
1815 delete_breakpoint (b
);
1816 else if (context
== inf_starting
)
1818 /* Reset val field to force reread of starting value
1819 in insert_breakpoints. */
1821 value_free (b
->val
);
1831 /* Get rid of the moribund locations. */
1832 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bpt
); ++ix
)
1833 free_bp_location (bpt
);
1834 VEC_free (bp_location_p
, moribund_locations
);
1837 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1838 exists at PC. It returns ordinary_breakpoint_here if it's an
1839 ordinary breakpoint, or permanent_breakpoint_here if it's a
1840 permanent breakpoint.
1841 - When continuing from a location with an ordinary breakpoint, we
1842 actually single step once before calling insert_breakpoints.
1843 - When continuing from a localion with a permanent breakpoint, we
1844 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1845 the target, to advance the PC past the breakpoint. */
1847 enum breakpoint_here
1848 breakpoint_here_p (CORE_ADDR pc
)
1850 const struct bp_location
*bpt
;
1851 int any_breakpoint_here
= 0;
1853 ALL_BP_LOCATIONS (bpt
)
1855 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1856 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1859 if ((breakpoint_enabled (bpt
->owner
)
1860 || bpt
->owner
->enable_state
== bp_permanent
)
1861 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1863 if (overlay_debugging
1864 && section_is_overlay (bpt
->section
)
1865 && !section_is_mapped (bpt
->section
))
1866 continue; /* unmapped overlay -- can't be a match */
1867 else if (bpt
->owner
->enable_state
== bp_permanent
)
1868 return permanent_breakpoint_here
;
1870 any_breakpoint_here
= 1;
1874 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1877 /* Return true if there's a moribund breakpoint at PC. */
1880 moribund_breakpoint_here_p (CORE_ADDR pc
)
1882 struct bp_location
*loc
;
1885 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
1886 if (loc
->address
== pc
)
1892 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1893 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1894 This does not check for single-step breakpoints, which are
1895 inserted and removed using direct target manipulation. */
1898 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1900 const struct bp_location
*bpt
;
1902 ALL_BP_LOCATIONS (bpt
)
1904 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1905 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1909 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1911 if (overlay_debugging
1912 && section_is_overlay (bpt
->section
)
1913 && !section_is_mapped (bpt
->section
))
1914 continue; /* unmapped overlay -- can't be a match */
1922 /* Returns non-zero iff there's either regular breakpoint
1923 or a single step breakpoint inserted at PC. */
1926 breakpoint_inserted_here_p (CORE_ADDR pc
)
1928 if (regular_breakpoint_inserted_here_p (pc
))
1931 if (single_step_breakpoint_inserted_here_p (pc
))
1937 /* This function returns non-zero iff there is a software breakpoint
1941 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1943 const struct bp_location
*bpt
;
1944 int any_breakpoint_here
= 0;
1946 ALL_BP_LOCATIONS (bpt
)
1948 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1952 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1954 if (overlay_debugging
1955 && section_is_overlay (bpt
->section
)
1956 && !section_is_mapped (bpt
->section
))
1957 continue; /* unmapped overlay -- can't be a match */
1963 /* Also check for software single-step breakpoints. */
1964 if (single_step_breakpoint_inserted_here_p (pc
))
1970 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1971 PC is valid for process/thread PTID. */
1974 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1976 const struct bp_location
*bpt
;
1977 /* The thread and task IDs associated to PTID, computed lazily. */
1981 ALL_BP_LOCATIONS (bpt
)
1983 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1984 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1987 if (!breakpoint_enabled (bpt
->owner
)
1988 && bpt
->owner
->enable_state
!= bp_permanent
)
1991 if (bpt
->address
!= pc
)
1994 if (bpt
->owner
->thread
!= -1)
1996 /* This is a thread-specific breakpoint. Check that ptid
1997 matches that thread. If thread hasn't been computed yet,
1998 it is now time to do so. */
2000 thread
= pid_to_thread_id (ptid
);
2001 if (bpt
->owner
->thread
!= thread
)
2005 if (bpt
->owner
->task
!= 0)
2007 /* This is a task-specific breakpoint. Check that ptid
2008 matches that task. If task hasn't been computed yet,
2009 it is now time to do so. */
2011 task
= ada_get_task_number (ptid
);
2012 if (bpt
->owner
->task
!= task
)
2016 if (overlay_debugging
2017 && section_is_overlay (bpt
->section
)
2018 && !section_is_mapped (bpt
->section
))
2019 continue; /* unmapped overlay -- can't be a match */
2028 /* bpstat stuff. External routines' interfaces are documented
2032 ep_is_catchpoint (struct breakpoint
*ep
)
2034 return (ep
->type
== bp_catchpoint
);
2038 bpstat_free (bpstat bs
)
2040 if (bs
->old_val
!= NULL
)
2041 value_free (bs
->old_val
);
2042 free_command_lines (&bs
->commands
);
2046 /* Clear a bpstat so that it says we are not at any breakpoint.
2047 Also free any storage that is part of a bpstat. */
2050 bpstat_clear (bpstat
*bsp
)
2067 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
2068 is part of the bpstat is copied as well. */
2071 bpstat_copy (bpstat bs
)
2075 bpstat retval
= NULL
;
2080 for (; bs
!= NULL
; bs
= bs
->next
)
2082 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
2083 memcpy (tmp
, bs
, sizeof (*tmp
));
2084 if (bs
->commands
!= NULL
)
2085 tmp
->commands
= copy_command_lines (bs
->commands
);
2086 if (bs
->old_val
!= NULL
)
2088 tmp
->old_val
= value_copy (bs
->old_val
);
2089 release_value (tmp
->old_val
);
2093 /* This is the first thing in the chain. */
2103 /* Find the bpstat associated with this breakpoint */
2106 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2111 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2113 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2119 /* Find a step_resume breakpoint associated with this bpstat.
2120 (If there are multiple step_resume bp's on the list, this function
2121 will arbitrarily pick one.)
2123 It is an error to use this function if BPSTAT doesn't contain a
2124 step_resume breakpoint.
2126 See wait_for_inferior's use of this function. */
2128 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2132 gdb_assert (bsp
!= NULL
);
2134 current_thread
= pid_to_thread_id (inferior_ptid
);
2136 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2138 if ((bsp
->breakpoint_at
!= NULL
)
2139 && (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
)
2140 && (bsp
->breakpoint_at
->owner
->thread
== current_thread
2141 || bsp
->breakpoint_at
->owner
->thread
== -1))
2142 return bsp
->breakpoint_at
->owner
;
2145 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2149 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2150 at. *BSP upon return is a bpstat which points to the remaining
2151 breakpoints stopped at (but which is not guaranteed to be good for
2152 anything but further calls to bpstat_num).
2153 Return 0 if passed a bpstat which does not indicate any breakpoints.
2154 Return -1 if stopped at a breakpoint that has been deleted since
2156 Return 1 otherwise. */
2159 bpstat_num (bpstat
*bsp
, int *num
)
2161 struct breakpoint
*b
;
2164 return 0; /* No more breakpoint values */
2166 /* We assume we'll never have several bpstats that
2167 correspond to a single breakpoint -- otherwise,
2168 this function might return the same number more
2169 than once and this will look ugly. */
2170 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2171 *bsp
= (*bsp
)->next
;
2173 return -1; /* breakpoint that's been deleted since */
2175 *num
= b
->number
; /* We have its number */
2179 /* Modify BS so that the actions will not be performed. */
2182 bpstat_clear_actions (bpstat bs
)
2184 for (; bs
!= NULL
; bs
= bs
->next
)
2186 free_command_lines (&bs
->commands
);
2187 if (bs
->old_val
!= NULL
)
2189 value_free (bs
->old_val
);
2195 /* Called when a command is about to proceed the inferior. */
2198 breakpoint_about_to_proceed (void)
2200 if (!ptid_equal (inferior_ptid
, null_ptid
))
2202 struct thread_info
*tp
= inferior_thread ();
2204 /* Allow inferior function calls in breakpoint commands to not
2205 interrupt the command list. When the call finishes
2206 successfully, the inferior will be standing at the same
2207 breakpoint as if nothing happened. */
2212 breakpoint_proceeded
= 1;
2215 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2217 cleanup_executing_breakpoints (void *ignore
)
2219 executing_breakpoint_commands
= 0;
2222 /* Execute all the commands associated with all the breakpoints at this
2223 location. Any of these commands could cause the process to proceed
2224 beyond this point, etc. We look out for such changes by checking
2225 the global "breakpoint_proceeded" after each command.
2227 Returns true if a breakpoint command resumed the inferior. In that
2228 case, it is the caller's responsibility to recall it again with the
2229 bpstat of the current thread. */
2232 bpstat_do_actions_1 (bpstat
*bsp
)
2235 struct cleanup
*old_chain
;
2238 /* Avoid endless recursion if a `source' command is contained
2240 if (executing_breakpoint_commands
)
2243 executing_breakpoint_commands
= 1;
2244 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2246 /* This pointer will iterate over the list of bpstat's. */
2249 breakpoint_proceeded
= 0;
2250 for (; bs
!= NULL
; bs
= bs
->next
)
2252 struct command_line
*cmd
;
2253 struct cleanup
*this_cmd_tree_chain
;
2255 /* Take ownership of the BSP's command tree, if it has one.
2257 The command tree could legitimately contain commands like
2258 'step' and 'next', which call clear_proceed_status, which
2259 frees stop_bpstat's command tree. To make sure this doesn't
2260 free the tree we're executing out from under us, we need to
2261 take ownership of the tree ourselves. Since a given bpstat's
2262 commands are only executed once, we don't need to copy it; we
2263 can clear the pointer in the bpstat, and make sure we free
2264 the tree when we're done. */
2267 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2271 execute_control_command (cmd
);
2273 if (breakpoint_proceeded
)
2279 /* We can free this command tree now. */
2280 do_cleanups (this_cmd_tree_chain
);
2282 if (breakpoint_proceeded
)
2284 if (target_can_async_p ())
2285 /* If we are in async mode, then the target might be still
2286 running, not stopped at any breakpoint, so nothing for
2287 us to do here -- just return to the event loop. */
2290 /* In sync mode, when execute_control_command returns
2291 we're already standing on the next breakpoint.
2292 Breakpoint commands for that stop were not run, since
2293 execute_command does not run breakpoint commands --
2294 only command_line_handler does, but that one is not
2295 involved in execution of breakpoint commands. So, we
2296 can now execute breakpoint commands. It should be
2297 noted that making execute_command do bpstat actions is
2298 not an option -- in this case we'll have recursive
2299 invocation of bpstat for each breakpoint with a
2300 command, and can easily blow up GDB stack. Instead, we
2301 return true, which will trigger the caller to recall us
2302 with the new stop_bpstat. */
2307 do_cleanups (old_chain
);
2312 bpstat_do_actions (void)
2314 /* Do any commands attached to breakpoint we are stopped at. */
2315 while (!ptid_equal (inferior_ptid
, null_ptid
)
2316 && target_has_execution
2317 && !is_exited (inferior_ptid
)
2318 && !is_executing (inferior_ptid
))
2319 /* Since in sync mode, bpstat_do_actions may resume the inferior,
2320 and only return when it is stopped at the next breakpoint, we
2321 keep doing breakpoint actions until it returns false to
2322 indicate the inferior was not resumed. */
2323 if (!bpstat_do_actions_1 (&inferior_thread ()->stop_bpstat
))
2327 /* Print out the (old or new) value associated with a watchpoint. */
2330 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2333 fprintf_unfiltered (stream
, _("<unreadable>"));
2336 struct value_print_options opts
;
2337 get_user_print_options (&opts
);
2338 value_print (val
, stream
, &opts
);
2342 /* This is the normal print function for a bpstat. In the future,
2343 much of this logic could (should?) be moved to bpstat_stop_status,
2344 by having it set different print_it values.
2346 Current scheme: When we stop, bpstat_print() is called. It loops
2347 through the bpstat list of things causing this stop, calling the
2348 print_bp_stop_message function on each one. The behavior of the
2349 print_bp_stop_message function depends on the print_it field of
2350 bpstat. If such field so indicates, call this function here.
2352 Return values from this routine (ultimately used by bpstat_print()
2353 and normal_stop() to decide what to do):
2354 PRINT_NOTHING: Means we already printed all we needed to print,
2355 don't print anything else.
2356 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2357 that something to be followed by a location.
2358 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2359 that something to be followed by a location.
2360 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2363 static enum print_stop_action
2364 print_it_typical (bpstat bs
)
2366 struct cleanup
*old_chain
;
2367 struct breakpoint
*b
;
2368 const struct bp_location
*bl
;
2369 struct ui_stream
*stb
;
2371 enum print_stop_action result
;
2373 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2374 which has since been deleted. */
2375 if (bs
->breakpoint_at
== NULL
)
2376 return PRINT_UNKNOWN
;
2377 bl
= bs
->breakpoint_at
;
2380 stb
= ui_out_stream_new (uiout
);
2381 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2386 case bp_hardware_breakpoint
:
2387 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2388 if (bl
->address
!= bl
->requested_address
)
2389 breakpoint_adjustment_warning (bl
->requested_address
,
2392 annotate_breakpoint (b
->number
);
2394 ui_out_text (uiout
, "\nTemporary breakpoint ");
2396 ui_out_text (uiout
, "\nBreakpoint ");
2397 if (ui_out_is_mi_like_p (uiout
))
2399 ui_out_field_string (uiout
, "reason",
2400 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2401 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2403 ui_out_field_int (uiout
, "bkptno", b
->number
);
2404 ui_out_text (uiout
, ", ");
2405 result
= PRINT_SRC_AND_LOC
;
2408 case bp_shlib_event
:
2409 /* Did we stop because the user set the stop_on_solib_events
2410 variable? (If so, we report this as a generic, "Stopped due
2411 to shlib event" message.) */
2412 printf_filtered (_("Stopped due to shared library event\n"));
2413 result
= PRINT_NOTHING
;
2416 case bp_thread_event
:
2417 /* Not sure how we will get here.
2418 GDB should not stop for these breakpoints. */
2419 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2420 result
= PRINT_NOTHING
;
2423 case bp_overlay_event
:
2424 /* By analogy with the thread event, GDB should not stop for these. */
2425 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2426 result
= PRINT_NOTHING
;
2430 case bp_hardware_watchpoint
:
2431 annotate_watchpoint (b
->number
);
2432 if (ui_out_is_mi_like_p (uiout
))
2435 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2437 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2438 ui_out_text (uiout
, "\nOld value = ");
2439 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2440 ui_out_field_stream (uiout
, "old", stb
);
2441 ui_out_text (uiout
, "\nNew value = ");
2442 watchpoint_value_print (b
->val
, stb
->stream
);
2443 ui_out_field_stream (uiout
, "new", stb
);
2444 ui_out_text (uiout
, "\n");
2445 /* More than one watchpoint may have been triggered. */
2446 result
= PRINT_UNKNOWN
;
2449 case bp_read_watchpoint
:
2450 if (ui_out_is_mi_like_p (uiout
))
2453 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2455 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2456 ui_out_text (uiout
, "\nValue = ");
2457 watchpoint_value_print (b
->val
, stb
->stream
);
2458 ui_out_field_stream (uiout
, "value", stb
);
2459 ui_out_text (uiout
, "\n");
2460 result
= PRINT_UNKNOWN
;
2463 case bp_access_watchpoint
:
2464 if (bs
->old_val
!= NULL
)
2466 annotate_watchpoint (b
->number
);
2467 if (ui_out_is_mi_like_p (uiout
))
2470 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2472 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2473 ui_out_text (uiout
, "\nOld value = ");
2474 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2475 ui_out_field_stream (uiout
, "old", stb
);
2476 ui_out_text (uiout
, "\nNew value = ");
2481 if (ui_out_is_mi_like_p (uiout
))
2484 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2485 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2486 ui_out_text (uiout
, "\nValue = ");
2488 watchpoint_value_print (b
->val
, stb
->stream
);
2489 ui_out_field_stream (uiout
, "new", stb
);
2490 ui_out_text (uiout
, "\n");
2491 result
= PRINT_UNKNOWN
;
2494 /* Fall through, we don't deal with these types of breakpoints
2498 if (ui_out_is_mi_like_p (uiout
))
2501 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2502 result
= PRINT_UNKNOWN
;
2506 if (ui_out_is_mi_like_p (uiout
))
2509 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2510 result
= PRINT_UNKNOWN
;
2515 case bp_longjmp_resume
:
2516 case bp_step_resume
:
2517 case bp_watchpoint_scope
:
2521 result
= PRINT_UNKNOWN
;
2525 do_cleanups (old_chain
);
2529 /* Generic routine for printing messages indicating why we
2530 stopped. The behavior of this function depends on the value
2531 'print_it' in the bpstat structure. Under some circumstances we
2532 may decide not to print anything here and delegate the task to
2535 static enum print_stop_action
2536 print_bp_stop_message (bpstat bs
)
2538 switch (bs
->print_it
)
2541 /* Nothing should be printed for this bpstat entry. */
2542 return PRINT_UNKNOWN
;
2546 /* We still want to print the frame, but we already printed the
2547 relevant messages. */
2548 return PRINT_SRC_AND_LOC
;
2551 case print_it_normal
:
2553 const struct bp_location
*bl
= bs
->breakpoint_at
;
2554 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2556 /* Normal case. Call the breakpoint's print_it method, or
2557 print_it_typical. */
2558 /* FIXME: how breakpoint can ever be NULL here? */
2559 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2560 return b
->ops
->print_it (b
);
2562 return print_it_typical (bs
);
2567 internal_error (__FILE__
, __LINE__
,
2568 _("print_bp_stop_message: unrecognized enum value"));
2573 /* Print a message indicating what happened. This is called from
2574 normal_stop(). The input to this routine is the head of the bpstat
2575 list - a list of the eventpoints that caused this stop. This
2576 routine calls the generic print routine for printing a message
2577 about reasons for stopping. This will print (for example) the
2578 "Breakpoint n," part of the output. The return value of this
2581 PRINT_UNKNOWN: Means we printed nothing
2582 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2583 code to print the location. An example is
2584 "Breakpoint 1, " which should be followed by
2586 PRINT_SRC_ONLY: Means we printed something, but there is no need
2587 to also print the location part of the message.
2588 An example is the catch/throw messages, which
2589 don't require a location appended to the end.
2590 PRINT_NOTHING: We have done some printing and we don't need any
2591 further info to be printed.*/
2593 enum print_stop_action
2594 bpstat_print (bpstat bs
)
2598 /* Maybe another breakpoint in the chain caused us to stop.
2599 (Currently all watchpoints go on the bpstat whether hit or not.
2600 That probably could (should) be changed, provided care is taken
2601 with respect to bpstat_explains_signal). */
2602 for (; bs
; bs
= bs
->next
)
2604 val
= print_bp_stop_message (bs
);
2605 if (val
== PRINT_SRC_ONLY
2606 || val
== PRINT_SRC_AND_LOC
2607 || val
== PRINT_NOTHING
)
2611 /* We reached the end of the chain, or we got a null BS to start
2612 with and nothing was printed. */
2613 return PRINT_UNKNOWN
;
2616 /* Evaluate the expression EXP and return 1 if value is zero.
2617 This is used inside a catch_errors to evaluate the breakpoint condition.
2618 The argument is a "struct expression *" that has been cast to char * to
2619 make it pass through catch_errors. */
2622 breakpoint_cond_eval (void *exp
)
2624 struct value
*mark
= value_mark ();
2625 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2626 value_free_to_mark (mark
);
2630 /* Allocate a new bpstat and chain it to the current one. */
2633 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2637 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2639 bs
->breakpoint_at
= bl
;
2640 /* If the condition is false, etc., don't do the commands. */
2641 bs
->commands
= NULL
;
2643 bs
->print_it
= print_it_normal
;
2647 /* The target has stopped with waitstatus WS. Check if any hardware
2648 watchpoints have triggered, according to the target. */
2651 watchpoints_triggered (struct target_waitstatus
*ws
)
2653 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
2655 struct breakpoint
*b
;
2657 if (!stopped_by_watchpoint
)
2659 /* We were not stopped by a watchpoint. Mark all watchpoints
2660 as not triggered. */
2662 if (b
->type
== bp_hardware_watchpoint
2663 || b
->type
== bp_read_watchpoint
2664 || b
->type
== bp_access_watchpoint
)
2665 b
->watchpoint_triggered
= watch_triggered_no
;
2670 if (!target_stopped_data_address (¤t_target
, &addr
))
2672 /* We were stopped by a watchpoint, but we don't know where.
2673 Mark all watchpoints as unknown. */
2675 if (b
->type
== bp_hardware_watchpoint
2676 || b
->type
== bp_read_watchpoint
2677 || b
->type
== bp_access_watchpoint
)
2678 b
->watchpoint_triggered
= watch_triggered_unknown
;
2680 return stopped_by_watchpoint
;
2683 /* The target could report the data address. Mark watchpoints
2684 affected by this data address as triggered, and all others as not
2688 if (b
->type
== bp_hardware_watchpoint
2689 || b
->type
== bp_read_watchpoint
2690 || b
->type
== bp_access_watchpoint
)
2692 struct bp_location
*loc
;
2695 b
->watchpoint_triggered
= watch_triggered_no
;
2696 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2697 /* Exact match not required. Within range is
2699 if (target_watchpoint_addr_within_range (¤t_target
,
2703 b
->watchpoint_triggered
= watch_triggered_yes
;
2711 /* Possible return values for watchpoint_check (this can't be an enum
2712 because of check_errors). */
2713 /* The watchpoint has been deleted. */
2714 #define WP_DELETED 1
2715 /* The value has changed. */
2716 #define WP_VALUE_CHANGED 2
2717 /* The value has not changed. */
2718 #define WP_VALUE_NOT_CHANGED 3
2720 #define BP_TEMPFLAG 1
2721 #define BP_HARDWAREFLAG 2
2723 /* Check watchpoint condition. */
2726 watchpoint_check (void *p
)
2728 bpstat bs
= (bpstat
) p
;
2729 struct breakpoint
*b
;
2730 struct frame_info
*fr
;
2731 int within_current_scope
;
2733 b
= bs
->breakpoint_at
->owner
;
2735 if (b
->exp_valid_block
== NULL
)
2736 within_current_scope
= 1;
2739 /* There is no current frame at this moment. If we're going to have
2740 any chance of handling watchpoints on local variables, we'll need
2741 the frame chain (so we can determine if we're in scope). */
2742 reinit_frame_cache ();
2743 fr
= frame_find_by_id (b
->watchpoint_frame
);
2744 within_current_scope
= (fr
!= NULL
);
2746 /* If we've gotten confused in the unwinder, we might have
2747 returned a frame that can't describe this variable. */
2748 if (within_current_scope
2749 && (block_linkage_function (b
->exp_valid_block
)
2750 != get_frame_function (fr
)))
2751 within_current_scope
= 0;
2753 /* in_function_epilogue_p() returns a non-zero value if we're still
2754 in the function but the stack frame has already been invalidated.
2755 Since we can't rely on the values of local variables after the
2756 stack has been destroyed, we are treating the watchpoint in that
2757 state as `not changed' without further checking.
2759 vinschen/2003-09-04: The former implementation left out the case
2760 that the watchpoint frame couldn't be found by frame_find_by_id()
2761 because the current PC is currently in an epilogue. Calling
2762 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2763 if (!within_current_scope
|| fr
== get_current_frame ())
2765 struct frame_info
*frame
= get_current_frame ();
2766 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
2767 CORE_ADDR frame_pc
= get_frame_pc (frame
);
2769 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
2770 return WP_VALUE_NOT_CHANGED
;
2772 if (fr
&& within_current_scope
)
2773 /* If we end up stopping, the current frame will get selected
2774 in normal_stop. So this call to select_frame won't affect
2779 if (within_current_scope
)
2781 /* We use value_{,free_to_}mark because it could be a
2782 *long* time before we return to the command level and
2783 call free_all_values. We can't call free_all_values because
2784 we might be in the middle of evaluating a function call. */
2786 struct value
*mark
= value_mark ();
2787 struct value
*new_val
;
2789 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2790 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2791 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2793 if (new_val
!= NULL
)
2795 release_value (new_val
);
2796 value_free_to_mark (mark
);
2798 bs
->old_val
= b
->val
;
2801 /* We will stop here */
2802 return WP_VALUE_CHANGED
;
2806 /* Nothing changed, don't do anything. */
2807 value_free_to_mark (mark
);
2808 /* We won't stop here */
2809 return WP_VALUE_NOT_CHANGED
;
2814 /* This seems like the only logical thing to do because
2815 if we temporarily ignored the watchpoint, then when
2816 we reenter the block in which it is valid it contains
2817 garbage (in the case of a function, it may have two
2818 garbage values, one before and one after the prologue).
2819 So we can't even detect the first assignment to it and
2820 watch after that (since the garbage may or may not equal
2821 the first value assigned). */
2822 /* We print all the stop information in print_it_typical(), but
2823 in this case, by the time we call print_it_typical() this bp
2824 will be deleted already. So we have no choice but print the
2825 information here. */
2826 if (ui_out_is_mi_like_p (uiout
))
2828 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2829 ui_out_text (uiout
, "\nWatchpoint ");
2830 ui_out_field_int (uiout
, "wpnum", b
->number
);
2831 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2832 which its expression is valid.\n");
2834 if (b
->related_breakpoint
)
2835 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2836 b
->disposition
= disp_del_at_next_stop
;
2842 /* Return true if it looks like target has stopped due to hitting
2843 breakpoint location BL. This function does not check if we
2844 should stop, only if BL explains the stop. */
2846 bpstat_check_location (const struct bp_location
*bl
, CORE_ADDR bp_addr
)
2848 struct breakpoint
*b
= bl
->owner
;
2850 if (b
->type
!= bp_watchpoint
2851 && b
->type
!= bp_hardware_watchpoint
2852 && b
->type
!= bp_read_watchpoint
2853 && b
->type
!= bp_access_watchpoint
2854 && b
->type
!= bp_hardware_breakpoint
2855 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
2857 if (bl
->address
!= bp_addr
) /* address doesn't match */
2859 if (overlay_debugging
/* unmapped overlay section */
2860 && section_is_overlay (bl
->section
)
2861 && !section_is_mapped (bl
->section
))
2865 /* Continuable hardware watchpoints are treated as non-existent if the
2866 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2867 some data address). Otherwise gdb won't stop on a break instruction
2868 in the code (not from a breakpoint) when a hardware watchpoint has
2869 been defined. Also skip watchpoints which we know did not trigger
2870 (did not match the data address). */
2872 if ((b
->type
== bp_hardware_watchpoint
2873 || b
->type
== bp_read_watchpoint
2874 || b
->type
== bp_access_watchpoint
)
2875 && b
->watchpoint_triggered
== watch_triggered_no
)
2878 if (b
->type
== bp_hardware_breakpoint
)
2880 if (bl
->address
!= bp_addr
)
2882 if (overlay_debugging
/* unmapped overlay section */
2883 && section_is_overlay (bl
->section
)
2884 && !section_is_mapped (bl
->section
))
2888 if (b
->type
== bp_catchpoint
)
2890 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
2891 if (!b
->ops
->breakpoint_hit (b
))
2898 /* If BS refers to a watchpoint, determine if the watched values
2899 has actually changed, and we should stop. If not, set BS->stop
2902 bpstat_check_watchpoint (bpstat bs
)
2904 const struct bp_location
*bl
= bs
->breakpoint_at
;
2905 struct breakpoint
*b
= bl
->owner
;
2907 if (b
->type
== bp_watchpoint
2908 || b
->type
== bp_read_watchpoint
2909 || b
->type
== bp_access_watchpoint
2910 || b
->type
== bp_hardware_watchpoint
)
2914 int must_check_value
= 0;
2916 if (b
->type
== bp_watchpoint
)
2917 /* For a software watchpoint, we must always check the
2919 must_check_value
= 1;
2920 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2921 /* We have a hardware watchpoint (read, write, or access)
2922 and the target earlier reported an address watched by
2924 must_check_value
= 1;
2925 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2926 && b
->type
== bp_hardware_watchpoint
)
2927 /* We were stopped by a hardware watchpoint, but the target could
2928 not report the data address. We must check the watchpoint's
2929 value. Access and read watchpoints are out of luck; without
2930 a data address, we can't figure it out. */
2931 must_check_value
= 1;
2933 if (must_check_value
)
2935 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2937 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2938 int e
= catch_errors (watchpoint_check
, bs
, message
,
2940 do_cleanups (cleanups
);
2944 /* We've already printed what needs to be printed. */
2945 bs
->print_it
= print_it_done
;
2948 case WP_VALUE_CHANGED
:
2949 if (b
->type
== bp_read_watchpoint
)
2951 /* Don't stop: read watchpoints shouldn't fire if
2952 the value has changed. This is for targets
2953 which cannot set read-only watchpoints. */
2954 bs
->print_it
= print_it_noop
;
2958 case WP_VALUE_NOT_CHANGED
:
2959 if (b
->type
== bp_hardware_watchpoint
2960 || b
->type
== bp_watchpoint
)
2962 /* Don't stop: write watchpoints shouldn't fire if
2963 the value hasn't changed. */
2964 bs
->print_it
= print_it_noop
;
2972 /* Error from catch_errors. */
2973 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2974 if (b
->related_breakpoint
)
2975 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2976 b
->disposition
= disp_del_at_next_stop
;
2977 /* We've already printed what needs to be printed. */
2978 bs
->print_it
= print_it_done
;
2982 else /* must_check_value == 0 */
2984 /* This is a case where some watchpoint(s) triggered, but
2985 not at the address of this watchpoint, or else no
2986 watchpoint triggered after all. So don't print
2987 anything for this watchpoint. */
2988 bs
->print_it
= print_it_noop
;
2995 /* Check conditions (condition proper, frame, thread and ignore count)
2996 of breakpoint referred to by BS. If we should not stop for this
2997 breakpoint, set BS->stop to 0. */
2999 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
3001 int thread_id
= pid_to_thread_id (ptid
);
3002 const struct bp_location
*bl
= bs
->breakpoint_at
;
3003 struct breakpoint
*b
= bl
->owner
;
3005 if (frame_id_p (b
->frame_id
)
3006 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
3010 int value_is_zero
= 0;
3012 /* If this is a scope breakpoint, mark the associated
3013 watchpoint as triggered so that we will handle the
3014 out-of-scope event. We'll get to the watchpoint next
3016 if (b
->type
== bp_watchpoint_scope
)
3017 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
3019 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
3021 /* We use value_mark and value_free_to_mark because it could
3022 be a long time before we return to the command level and
3023 call free_all_values. We can't call free_all_values
3024 because we might be in the middle of evaluating a
3026 struct value
*mark
= value_mark ();
3028 /* Need to select the frame, with all that implies
3029 so that the conditions will have the right context. */
3030 select_frame (get_current_frame ());
3032 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
3033 "Error in testing breakpoint condition:\n",
3035 /* FIXME-someday, should give breakpoint # */
3036 value_free_to_mark (mark
);
3038 if (bl
->cond
&& value_is_zero
)
3042 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
3046 else if (b
->ignore_count
> 0)
3049 annotate_ignore_count_change ();
3051 /* Increase the hit count even though we don't
3059 /* Get a bpstat associated with having just stopped at address
3060 BP_ADDR in thread PTID.
3062 Determine whether we stopped at a breakpoint, etc, or whether we
3063 don't understand this stop. Result is a chain of bpstat's such that:
3065 if we don't understand the stop, the result is a null pointer.
3067 if we understand why we stopped, the result is not null.
3069 Each element of the chain refers to a particular breakpoint or
3070 watchpoint at which we have stopped. (We may have stopped for
3071 several reasons concurrently.)
3073 Each element of the chain has valid next, breakpoint_at,
3074 commands, FIXME??? fields. */
3077 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
3079 struct breakpoint
*b
= NULL
;
3080 const struct bp_location
*bl
;
3081 struct bp_location
*loc
;
3082 /* Root of the chain of bpstat's */
3083 struct bpstats root_bs
[1];
3084 /* Pointer to the last thing in the chain currently. */
3085 bpstat bs
= root_bs
;
3087 int need_remove_insert
;
3089 ALL_BP_LOCATIONS (bl
)
3093 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3096 /* For hardware watchpoints, we look only at the first location.
3097 The watchpoint_check function will work on entire expression,
3098 not the individual locations. For read watchopints, the
3099 watchpoints_triggered function have checked all locations
3102 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3105 if (!bpstat_check_location (bl
, bp_addr
))
3108 /* Come here if it's a watchpoint, or if the break address matches */
3110 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3112 /* Assume we stop. Should we find watchpoint that is not actually
3113 triggered, or if condition of breakpoint is false, we'll reset
3118 bpstat_check_watchpoint (bs
);
3122 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
3123 /* We do not stop for these. */
3126 bpstat_check_breakpoint_conditions (bs
, ptid
);
3132 /* We will stop here */
3133 if (b
->disposition
== disp_disable
)
3135 if (b
->enable_state
!= bp_permanent
)
3136 b
->enable_state
= bp_disabled
;
3137 update_global_location_list (0);
3141 bs
->commands
= b
->commands
;
3143 && (strcmp ("silent", bs
->commands
->line
) == 0
3144 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3146 bs
->commands
= bs
->commands
->next
;
3149 bs
->commands
= copy_command_lines (bs
->commands
);
3152 /* Print nothing for this entry if we dont stop or if we dont print. */
3153 if (bs
->stop
== 0 || bs
->print
== 0)
3154 bs
->print_it
= print_it_noop
;
3157 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
3159 if (loc
->address
== bp_addr
)
3161 bs
= bpstat_alloc (loc
, bs
);
3162 /* For hits of moribund locations, we should just proceed. */
3165 bs
->print_it
= print_it_noop
;
3169 bs
->next
= NULL
; /* Terminate the chain */
3170 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3172 /* If we aren't stopping, the value of some hardware watchpoint may
3173 not have changed, but the intermediate memory locations we are
3174 watching may have. Don't bother if we're stopping; this will get
3176 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3180 need_remove_insert
= 0;
3182 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3184 && bs
->breakpoint_at
->owner
3185 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3186 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3187 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3189 /* remove/insert can invalidate bs->breakpoint_at, if this
3190 location is no longer used by the watchpoint. Prevent
3191 further code from trying to use it. */
3192 bs
->breakpoint_at
= NULL
;
3193 need_remove_insert
= 1;
3196 if (need_remove_insert
)
3198 remove_breakpoints ();
3199 insert_breakpoints ();
3202 return root_bs
->next
;
3205 /* Tell what to do about this bpstat. */
3207 bpstat_what (bpstat bs
)
3209 /* Classify each bpstat as one of the following. */
3212 /* This bpstat element has no effect on the main_action. */
3215 /* There was a watchpoint, stop but don't print. */
3218 /* There was a watchpoint, stop and print. */
3221 /* There was a breakpoint but we're not stopping. */
3224 /* There was a breakpoint, stop but don't print. */
3227 /* There was a breakpoint, stop and print. */
3230 /* We hit the longjmp breakpoint. */
3233 /* We hit the longjmp_resume breakpoint. */
3236 /* We hit the step_resume breakpoint. */
3239 /* We hit the shared library event breakpoint. */
3242 /* This is just used to count how many enums there are. */
3246 /* Here is the table which drives this routine. So that we can
3247 format it pretty, we define some abbreviations for the
3248 enum bpstat_what codes. */
3249 #define kc BPSTAT_WHAT_KEEP_CHECKING
3250 #define ss BPSTAT_WHAT_STOP_SILENT
3251 #define sn BPSTAT_WHAT_STOP_NOISY
3252 #define sgl BPSTAT_WHAT_SINGLE
3253 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3254 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3255 #define sr BPSTAT_WHAT_STEP_RESUME
3256 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3258 /* "Can't happen." Might want to print an error message.
3259 abort() is not out of the question, but chances are GDB is just
3260 a bit confused, not unusable. */
3261 #define err BPSTAT_WHAT_STOP_NOISY
3263 /* Given an old action and a class, come up with a new action. */
3264 /* One interesting property of this table is that wp_silent is the same
3265 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3266 after stopping, the check for whether to step over a breakpoint
3267 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3268 reference to how we stopped. We retain separate wp_silent and
3269 bp_silent codes in case we want to change that someday.
3271 Another possibly interesting property of this table is that
3272 there's a partial ordering, priority-like, of the actions. Once
3273 you've decided that some action is appropriate, you'll never go
3274 back and decide something of a lower priority is better. The
3277 kc < clr sgl shl slr sn sr ss
3278 sgl < shl slr sn sr ss
3279 slr < err shl sn sr ss
3280 clr < err shl sn sr ss
3286 What I think this means is that we don't need a damned table
3287 here. If you just put the rows and columns in the right order,
3288 it'd look awfully regular. We could simply walk the bpstat list
3289 and choose the highest priority action we find, with a little
3290 logic to handle the 'err' cases. */
3292 /* step_resume entries: a step resume breakpoint overrides another
3293 breakpoint of signal handling (see comment in wait_for_inferior
3294 at where we set the step_resume breakpoint). */
3296 static const enum bpstat_what_main_action
3297 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3300 /* kc ss sn sgl slr clr sr shl
3303 {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
},
3305 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3307 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3309 {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
},
3311 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3313 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3315 {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
},
3317 {clr
, ss
, sn
, err
, err
, err
, sr
, shl
},
3319 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3321 {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
}
3334 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3335 struct bpstat_what retval
;
3337 retval
.call_dummy
= 0;
3338 for (; bs
!= NULL
; bs
= bs
->next
)
3340 enum class bs_class
= no_effect
;
3341 if (bs
->breakpoint_at
== NULL
)
3342 /* I suspect this can happen if it was a momentary breakpoint
3343 which has since been deleted. */
3345 if (bs
->breakpoint_at
->owner
== NULL
)
3346 bs_class
= bp_nostop
;
3348 switch (bs
->breakpoint_at
->owner
->type
)
3354 case bp_hardware_breakpoint
:
3360 bs_class
= bp_noisy
;
3362 bs_class
= bp_silent
;
3365 bs_class
= bp_nostop
;
3368 case bp_hardware_watchpoint
:
3369 case bp_read_watchpoint
:
3370 case bp_access_watchpoint
:
3374 bs_class
= wp_noisy
;
3376 bs_class
= wp_silent
;
3379 /* There was a watchpoint, but we're not stopping.
3380 This requires no further action. */
3381 bs_class
= no_effect
;
3384 bs_class
= long_jump
;
3386 case bp_longjmp_resume
:
3387 bs_class
= long_resume
;
3389 case bp_step_resume
:
3392 bs_class
= step_resume
;
3395 /* It is for the wrong frame. */
3396 bs_class
= bp_nostop
;
3398 case bp_watchpoint_scope
:
3399 bs_class
= bp_nostop
;
3401 case bp_shlib_event
:
3402 bs_class
= shlib_event
;
3404 case bp_thread_event
:
3405 case bp_overlay_event
:
3406 bs_class
= bp_nostop
;
3412 bs_class
= bp_noisy
;
3414 bs_class
= bp_silent
;
3417 /* There was a catchpoint, but we're not stopping.
3418 This requires no further action. */
3419 bs_class
= no_effect
;
3422 /* Make sure the action is stop (silent or noisy),
3423 so infrun.c pops the dummy frame. */
3424 bs_class
= bp_silent
;
3425 retval
.call_dummy
= 1;
3428 /* Tracepoint hits should not be reported back to GDB, and
3429 if one got through somehow, it should have been filtered
3431 internal_error (__FILE__
, __LINE__
,
3432 _("bpstat_what: bp_tracepoint encountered"));
3435 current_action
= table
[(int) bs_class
][(int) current_action
];
3437 retval
.main_action
= current_action
;
3441 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3442 without hardware support). This isn't related to a specific bpstat,
3443 just to things like whether watchpoints are set. */
3446 bpstat_should_step (void)
3448 struct breakpoint
*b
;
3450 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
3457 static void print_breakpoint_location (struct breakpoint
*b
,
3458 struct bp_location
*loc
,
3460 struct ui_stream
*stb
)
3465 = find_pc_sect_function (loc
->address
, loc
->section
);
3468 ui_out_text (uiout
, "in ");
3469 ui_out_field_string (uiout
, "func",
3470 SYMBOL_PRINT_NAME (sym
));
3471 ui_out_wrap_hint (uiout
, wrap_indent
);
3472 ui_out_text (uiout
, " at ");
3474 ui_out_field_string (uiout
, "file", b
->source_file
);
3475 ui_out_text (uiout
, ":");
3477 if (ui_out_is_mi_like_p (uiout
))
3479 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3480 char *fullname
= symtab_to_fullname (sal
.symtab
);
3483 ui_out_field_string (uiout
, "fullname", fullname
);
3486 ui_out_field_int (uiout
, "line", b
->line_number
);
3490 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3494 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3495 ui_out_field_stream (uiout
, "at", stb
);
3499 /* Print B to gdb_stdout. */
3501 print_one_breakpoint_location (struct breakpoint
*b
,
3502 struct bp_location
*loc
,
3504 CORE_ADDR
*last_addr
)
3506 struct command_line
*l
;
3508 struct ep_type_description
3513 static struct ep_type_description bptypes
[] =
3515 {bp_none
, "?deleted?"},
3516 {bp_breakpoint
, "breakpoint"},
3517 {bp_hardware_breakpoint
, "hw breakpoint"},
3518 {bp_until
, "until"},
3519 {bp_finish
, "finish"},
3520 {bp_watchpoint
, "watchpoint"},
3521 {bp_hardware_watchpoint
, "hw watchpoint"},
3522 {bp_read_watchpoint
, "read watchpoint"},
3523 {bp_access_watchpoint
, "acc watchpoint"},
3524 {bp_longjmp
, "longjmp"},
3525 {bp_longjmp_resume
, "longjmp resume"},
3526 {bp_step_resume
, "step resume"},
3527 {bp_watchpoint_scope
, "watchpoint scope"},
3528 {bp_call_dummy
, "call dummy"},
3529 {bp_shlib_event
, "shlib events"},
3530 {bp_thread_event
, "thread events"},
3531 {bp_overlay_event
, "overlay events"},
3532 {bp_catchpoint
, "catchpoint"},
3533 {bp_tracepoint
, "tracepoint"},
3536 static char bpenables
[] = "nynny";
3537 char wrap_indent
[80];
3538 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3539 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3540 struct cleanup
*bkpt_chain
;
3542 int header_of_multiple
= 0;
3543 int part_of_multiple
= (loc
!= NULL
);
3544 struct value_print_options opts
;
3546 get_user_print_options (&opts
);
3548 gdb_assert (!loc
|| loc_number
!= 0);
3549 /* See comment in print_one_breakpoint concerning
3550 treatment of breakpoints with single disabled
3554 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3555 header_of_multiple
= 1;
3560 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3564 if (part_of_multiple
)
3567 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3568 ui_out_field_string (uiout
, "number", formatted
);
3573 ui_out_field_int (uiout
, "number", b
->number
);
3578 if (part_of_multiple
)
3579 ui_out_field_skip (uiout
, "type");
3582 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3583 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3584 internal_error (__FILE__
, __LINE__
,
3585 _("bptypes table does not describe type #%d."),
3587 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3592 if (part_of_multiple
)
3593 ui_out_field_skip (uiout
, "disp");
3595 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3600 if (part_of_multiple
)
3601 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3603 ui_out_field_fmt (uiout
, "enabled", "%c",
3604 bpenables
[(int) b
->enable_state
]);
3605 ui_out_spaces (uiout
, 2);
3609 strcpy (wrap_indent
, " ");
3610 if (opts
.addressprint
)
3612 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3613 strcat (wrap_indent
, " ");
3615 strcat (wrap_indent
, " ");
3618 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3620 /* Although the print_one can possibly print
3621 all locations, calling it here is not likely
3622 to get any nice result. So, make sure there's
3623 just one location. */
3624 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3625 b
->ops
->print_one (b
, last_addr
);
3631 internal_error (__FILE__
, __LINE__
,
3632 _("print_one_breakpoint: bp_none encountered\n"));
3636 case bp_hardware_watchpoint
:
3637 case bp_read_watchpoint
:
3638 case bp_access_watchpoint
:
3639 /* Field 4, the address, is omitted (which makes the columns
3640 not line up too nicely with the headers, but the effect
3641 is relatively readable). */
3642 if (opts
.addressprint
)
3643 ui_out_field_skip (uiout
, "addr");
3645 ui_out_field_string (uiout
, "what", b
->exp_string
);
3649 case bp_hardware_breakpoint
:
3653 case bp_longjmp_resume
:
3654 case bp_step_resume
:
3655 case bp_watchpoint_scope
:
3657 case bp_shlib_event
:
3658 case bp_thread_event
:
3659 case bp_overlay_event
:
3661 if (opts
.addressprint
)
3664 if (header_of_multiple
)
3665 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3666 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3667 ui_out_field_string (uiout
, "addr", "<PENDING>");
3669 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3672 if (!header_of_multiple
)
3673 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3675 *last_addr
= b
->loc
->address
;
3679 if (!part_of_multiple
)
3681 if (b
->thread
!= -1)
3683 /* FIXME: This seems to be redundant and lost here; see the
3684 "stop only in" line a little further down. */
3685 ui_out_text (uiout
, " thread ");
3686 ui_out_field_int (uiout
, "thread", b
->thread
);
3688 else if (b
->task
!= 0)
3690 ui_out_text (uiout
, " task ");
3691 ui_out_field_int (uiout
, "task", b
->task
);
3695 ui_out_text (uiout
, "\n");
3697 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3700 ui_out_text (uiout
, "\tstop only in stack frame at ");
3701 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3703 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3704 ui_out_text (uiout
, "\n");
3707 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3709 /* We do not print the condition for Ada exception catchpoints
3710 because the condition is an internal implementation detail
3711 that we do not want to expose to the user. */
3713 if (b
->type
== bp_tracepoint
)
3714 ui_out_text (uiout
, "\ttrace only if ");
3716 ui_out_text (uiout
, "\tstop only if ");
3717 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3718 ui_out_text (uiout
, "\n");
3721 if (!part_of_multiple
&& b
->thread
!= -1)
3723 /* FIXME should make an annotation for this */
3724 ui_out_text (uiout
, "\tstop only in thread ");
3725 ui_out_field_int (uiout
, "thread", b
->thread
);
3726 ui_out_text (uiout
, "\n");
3729 if (!part_of_multiple
&& b
->hit_count
)
3731 /* FIXME should make an annotation for this */
3732 if (ep_is_catchpoint (b
))
3733 ui_out_text (uiout
, "\tcatchpoint");
3735 ui_out_text (uiout
, "\tbreakpoint");
3736 ui_out_text (uiout
, " already hit ");
3737 ui_out_field_int (uiout
, "times", b
->hit_count
);
3738 if (b
->hit_count
== 1)
3739 ui_out_text (uiout
, " time\n");
3741 ui_out_text (uiout
, " times\n");
3744 /* Output the count also if it is zero, but only if this is
3745 mi. FIXME: Should have a better test for this. */
3746 if (ui_out_is_mi_like_p (uiout
))
3747 if (!part_of_multiple
&& b
->hit_count
== 0)
3748 ui_out_field_int (uiout
, "times", b
->hit_count
);
3750 if (!part_of_multiple
&& b
->ignore_count
)
3753 ui_out_text (uiout
, "\tignore next ");
3754 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3755 ui_out_text (uiout
, " hits\n");
3759 if (!part_of_multiple
&& l
)
3761 struct cleanup
*script_chain
;
3764 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3765 print_command_lines (uiout
, l
, 4);
3766 do_cleanups (script_chain
);
3769 if (!part_of_multiple
&& b
->pass_count
)
3771 annotate_field (10);
3772 ui_out_text (uiout
, "\tpass count ");
3773 ui_out_field_int (uiout
, "pass", b
->pass_count
);
3774 ui_out_text (uiout
, " \n");
3777 if (!part_of_multiple
&& b
->step_count
)
3779 annotate_field (11);
3780 ui_out_text (uiout
, "\tstep count ");
3781 ui_out_field_int (uiout
, "step", b
->step_count
);
3782 ui_out_text (uiout
, " \n");
3785 if (!part_of_multiple
&& b
->actions
)
3787 struct action_line
*action
;
3788 annotate_field (12);
3789 for (action
= b
->actions
; action
; action
= action
->next
)
3791 ui_out_text (uiout
, " A\t");
3792 ui_out_text (uiout
, action
->action
);
3793 ui_out_text (uiout
, "\n");
3797 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
3800 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
3801 else if (b
->exp_string
)
3802 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
3805 do_cleanups (bkpt_chain
);
3806 do_cleanups (old_chain
);
3810 print_one_breakpoint (struct breakpoint
*b
,
3811 CORE_ADDR
*last_addr
)
3813 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3815 /* If this breakpoint has custom print function,
3816 it's already printed. Otherwise, print individual
3817 locations, if any. */
3818 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3820 /* If breakpoint has a single location that is
3821 disabled, we print it as if it had
3822 several locations, since otherwise it's hard to
3823 represent "breakpoint enabled, location disabled"
3825 Note that while hardware watchpoints have
3826 several locations internally, that's no a property
3829 && !is_hardware_watchpoint (b
)
3830 && (b
->loc
->next
|| !b
->loc
->enabled
)
3831 && !ui_out_is_mi_like_p (uiout
))
3833 struct bp_location
*loc
;
3835 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3836 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3842 struct captured_breakpoint_query_args
3848 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3850 struct captured_breakpoint_query_args
*args
= data
;
3851 struct breakpoint
*b
;
3852 CORE_ADDR dummy_addr
= 0;
3855 if (args
->bnum
== b
->number
)
3857 print_one_breakpoint (b
, &dummy_addr
);
3865 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3867 struct captured_breakpoint_query_args args
;
3869 /* For the moment we don't trust print_one_breakpoint() to not throw
3871 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3872 error_message
, RETURN_MASK_ALL
) < 0)
3878 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3879 catchpoints, et.al.). */
3882 user_settable_breakpoint (const struct breakpoint
*b
)
3884 return (b
->type
== bp_breakpoint
3885 || b
->type
== bp_catchpoint
3886 || b
->type
== bp_hardware_breakpoint
3887 || b
->type
== bp_tracepoint
3888 || b
->type
== bp_watchpoint
3889 || b
->type
== bp_read_watchpoint
3890 || b
->type
== bp_access_watchpoint
3891 || b
->type
== bp_hardware_watchpoint
);
3894 /* Print information on user settable breakpoint (watchpoint, etc)
3895 number BNUM. If BNUM is -1 print all user settable breakpoints.
3896 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3899 breakpoint_1 (int bnum
, int allflag
)
3901 struct breakpoint
*b
;
3902 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3903 int nr_printable_breakpoints
;
3904 struct cleanup
*bkpttbl_chain
;
3905 struct value_print_options opts
;
3907 get_user_print_options (&opts
);
3909 /* Compute the number of rows in the table. */
3910 nr_printable_breakpoints
= 0;
3913 || bnum
== b
->number
)
3915 if (allflag
|| user_settable_breakpoint (b
))
3916 nr_printable_breakpoints
++;
3919 if (opts
.addressprint
)
3921 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3925 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3928 if (nr_printable_breakpoints
> 0)
3929 annotate_breakpoints_headers ();
3930 if (nr_printable_breakpoints
> 0)
3932 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3933 if (nr_printable_breakpoints
> 0)
3935 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3936 if (nr_printable_breakpoints
> 0)
3938 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3939 if (nr_printable_breakpoints
> 0)
3941 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3942 if (opts
.addressprint
)
3944 if (nr_printable_breakpoints
> 0)
3946 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3947 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3949 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3951 if (nr_printable_breakpoints
> 0)
3953 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3954 ui_out_table_body (uiout
);
3955 if (nr_printable_breakpoints
> 0)
3956 annotate_breakpoints_table ();
3960 || bnum
== b
->number
)
3962 /* We only print out user settable breakpoints unless the
3964 if (allflag
|| user_settable_breakpoint (b
))
3965 print_one_breakpoint (b
, &last_addr
);
3968 do_cleanups (bkpttbl_chain
);
3970 if (nr_printable_breakpoints
== 0)
3973 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3975 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3980 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3981 that a comparison of an unsigned with -1 is always false. */
3982 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3983 set_next_address (current_gdbarch
, last_addr
);
3986 /* FIXME? Should this be moved up so that it is only called when
3987 there have been breakpoints? */
3988 annotate_breakpoints_table_end ();
3992 breakpoints_info (char *bnum_exp
, int from_tty
)
3997 bnum
= parse_and_eval_long (bnum_exp
);
3999 breakpoint_1 (bnum
, 0);
4003 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4008 bnum
= parse_and_eval_long (bnum_exp
);
4010 breakpoint_1 (bnum
, 1);
4014 breakpoint_has_pc (struct breakpoint
*b
,
4015 CORE_ADDR pc
, struct obj_section
*section
)
4017 struct bp_location
*bl
= b
->loc
;
4018 for (; bl
; bl
= bl
->next
)
4020 if (bl
->address
== pc
4021 && (!overlay_debugging
|| bl
->section
== section
))
4027 /* Print a message describing any breakpoints set at PC. */
4030 describe_other_breakpoints (CORE_ADDR pc
, struct obj_section
*section
,
4034 struct breakpoint
*b
;
4037 others
+= breakpoint_has_pc (b
, pc
, section
);
4041 printf_filtered (_("Note: breakpoint "));
4042 else /* if (others == ???) */
4043 printf_filtered (_("Note: breakpoints "));
4045 if (breakpoint_has_pc (b
, pc
, section
))
4048 printf_filtered ("%d", b
->number
);
4049 if (b
->thread
== -1 && thread
!= -1)
4050 printf_filtered (" (all threads)");
4051 else if (b
->thread
!= -1)
4052 printf_filtered (" (thread %d)", b
->thread
);
4053 printf_filtered ("%s%s ",
4054 ((b
->enable_state
== bp_disabled
4055 || b
->enable_state
== bp_call_disabled
)
4057 : b
->enable_state
== bp_permanent
4061 : ((others
== 1) ? " and" : ""));
4063 printf_filtered (_("also set at pc "));
4064 fputs_filtered (paddress (pc
), gdb_stdout
);
4065 printf_filtered (".\n");
4069 /* Set the default place to put a breakpoint
4070 for the `break' command with no arguments. */
4073 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
4076 default_breakpoint_valid
= valid
;
4077 default_breakpoint_address
= addr
;
4078 default_breakpoint_symtab
= symtab
;
4079 default_breakpoint_line
= line
;
4082 /* Return true iff it is meaningful to use the address member of
4083 BPT. For some breakpoint types, the address member is irrelevant
4084 and it makes no sense to attempt to compare it to other addresses
4085 (or use it for any other purpose either).
4087 More specifically, each of the following breakpoint types will always
4088 have a zero valued address and we don't want check_duplicates() to mark
4089 breakpoints of any of these types to be a duplicate of an actual
4090 breakpoint at address zero:
4093 bp_hardware_watchpoint
4095 bp_access_watchpoint
4099 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4101 enum bptype type
= bpt
->type
;
4103 return (type
!= bp_watchpoint
4104 && type
!= bp_hardware_watchpoint
4105 && type
!= bp_read_watchpoint
4106 && type
!= bp_access_watchpoint
4107 && type
!= bp_catchpoint
);
4110 /* Rescan breakpoints at the same address and section as BPT,
4111 marking the first one as "first" and any others as "duplicates".
4112 This is so that the bpt instruction is only inserted once.
4113 If we have a permanent breakpoint at the same place as BPT, make
4114 that one the official one, and the rest as duplicates. */
4117 check_duplicates_for (CORE_ADDR address
, struct obj_section
*section
)
4119 struct bp_location
*b
;
4121 struct bp_location
*perm_bp
= 0;
4123 ALL_BP_LOCATIONS (b
)
4124 if (b
->owner
->enable_state
!= bp_disabled
4125 && b
->owner
->enable_state
!= bp_call_disabled
4127 && !b
->shlib_disabled
4128 && b
->address
== address
/* address / overlay match */
4129 && (!overlay_debugging
|| b
->section
== section
)
4130 && breakpoint_address_is_meaningful (b
->owner
))
4132 /* Have we found a permanent breakpoint? */
4133 if (b
->owner
->enable_state
== bp_permanent
)
4140 b
->duplicate
= count
> 1;
4143 /* If we found a permanent breakpoint at this address, go over the
4144 list again and declare all the other breakpoints there (except
4145 other permanent breakpoints) to be the duplicates. */
4148 perm_bp
->duplicate
= 0;
4150 /* Permanent breakpoint should always be inserted. */
4151 if (! perm_bp
->inserted
)
4152 internal_error (__FILE__
, __LINE__
,
4153 _("allegedly permanent breakpoint is not "
4154 "actually inserted"));
4156 ALL_BP_LOCATIONS (b
)
4159 if (b
->owner
->enable_state
!= bp_permanent
4160 && b
->owner
->enable_state
!= bp_disabled
4161 && b
->owner
->enable_state
!= bp_call_disabled
4162 && b
->enabled
&& !b
->shlib_disabled
4163 && b
->address
== address
/* address / overlay match */
4164 && (!overlay_debugging
|| b
->section
== section
)
4165 && breakpoint_address_is_meaningful (b
->owner
))
4168 internal_error (__FILE__
, __LINE__
,
4169 _("another breakpoint was inserted on top of "
4170 "a permanent breakpoint"));
4179 check_duplicates (struct breakpoint
*bpt
)
4181 struct bp_location
*bl
= bpt
->loc
;
4183 if (! breakpoint_address_is_meaningful (bpt
))
4186 for (; bl
; bl
= bl
->next
)
4187 check_duplicates_for (bl
->address
, bl
->section
);
4191 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4192 int bnum
, int have_bnum
)
4197 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4198 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4200 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4201 bnum
, astr1
, astr2
);
4203 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4206 /* Adjust a breakpoint's address to account for architectural constraints
4207 on breakpoint placement. Return the adjusted address. Note: Very
4208 few targets require this kind of adjustment. For most targets,
4209 this function is simply the identity function. */
4212 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4214 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4216 /* Very few targets need any kind of breakpoint adjustment. */
4219 else if (bptype
== bp_watchpoint
4220 || bptype
== bp_hardware_watchpoint
4221 || bptype
== bp_read_watchpoint
4222 || bptype
== bp_access_watchpoint
4223 || bptype
== bp_catchpoint
)
4225 /* Watchpoints and the various bp_catch_* eventpoints should not
4226 have their addresses modified. */
4231 CORE_ADDR adjusted_bpaddr
;
4233 /* Some targets have architectural constraints on the placement
4234 of breakpoint instructions. Obtain the adjusted address. */
4235 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4238 /* An adjusted breakpoint address can significantly alter
4239 a user's expectations. Print a warning if an adjustment
4241 if (adjusted_bpaddr
!= bpaddr
)
4242 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4244 return adjusted_bpaddr
;
4248 /* Allocate a struct bp_location. */
4250 static struct bp_location
*
4251 allocate_bp_location (struct breakpoint
*bpt
)
4253 struct bp_location
*loc
, *loc_p
;
4255 loc
= xmalloc (sizeof (struct bp_location
));
4256 memset (loc
, 0, sizeof (*loc
));
4260 loc
->shlib_disabled
= 0;
4270 case bp_longjmp_resume
:
4271 case bp_step_resume
:
4272 case bp_watchpoint_scope
:
4274 case bp_shlib_event
:
4275 case bp_thread_event
:
4276 case bp_overlay_event
:
4277 loc
->loc_type
= bp_loc_software_breakpoint
;
4279 case bp_hardware_breakpoint
:
4280 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4282 case bp_hardware_watchpoint
:
4283 case bp_read_watchpoint
:
4284 case bp_access_watchpoint
:
4285 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4289 loc
->loc_type
= bp_loc_other
;
4292 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4298 static void free_bp_location (struct bp_location
*loc
)
4303 if (loc
->function_name
)
4304 xfree (loc
->function_name
);
4309 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4310 that has type BPTYPE and has no locations as yet. */
4312 static struct breakpoint
*
4313 set_raw_breakpoint_without_location (enum bptype bptype
)
4315 struct breakpoint
*b
, *b1
;
4317 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4318 memset (b
, 0, sizeof (*b
));
4321 b
->language
= current_language
->la_language
;
4322 b
->input_radix
= input_radix
;
4324 b
->enable_state
= bp_enabled
;
4327 b
->ignore_count
= 0;
4329 b
->frame_id
= null_frame_id
;
4330 b
->forked_inferior_pid
= null_ptid
;
4331 b
->exec_pathname
= NULL
;
4333 b
->condition_not_parsed
= 0;
4335 /* Add this breakpoint to the end of the chain
4336 so that a list of breakpoints will come out in order
4337 of increasing numbers. */
4339 b1
= breakpoint_chain
;
4341 breakpoint_chain
= b
;
4351 /* Initialize loc->function_name. */
4353 set_breakpoint_location_function (struct bp_location
*loc
)
4355 if (loc
->owner
->type
== bp_breakpoint
4356 || loc
->owner
->type
== bp_hardware_breakpoint
4357 || loc
->owner
->type
== bp_tracepoint
)
4359 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4361 if (loc
->function_name
)
4362 loc
->function_name
= xstrdup (loc
->function_name
);
4366 /* set_raw_breakpoint is a low level routine for allocating and
4367 partially initializing a breakpoint of type BPTYPE. The newly
4368 created breakpoint's address, section, source file name, and line
4369 number are provided by SAL. The newly created and partially
4370 initialized breakpoint is added to the breakpoint chain and
4371 is also returned as the value of this function.
4373 It is expected that the caller will complete the initialization of
4374 the newly created breakpoint struct as well as output any status
4375 information regarding the creation of a new breakpoint. In
4376 particular, set_raw_breakpoint does NOT set the breakpoint
4377 number! Care should be taken to not allow an error to occur
4378 prior to completing the initialization of the breakpoint. If this
4379 should happen, a bogus breakpoint will be left on the chain. */
4382 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4384 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4385 CORE_ADDR adjusted_address
;
4387 /* Adjust the breakpoint's address prior to allocating a location.
4388 Once we call allocate_bp_location(), that mostly uninitialized
4389 location will be placed on the location chain. Adjustment of the
4390 breakpoint may cause target_read_memory() to be called and we do
4391 not want its scan of the location chain to find a breakpoint and
4392 location that's only been partially initialized. */
4393 adjusted_address
= adjust_breakpoint_address (sal
.pc
, b
->type
);
4395 b
->loc
= allocate_bp_location (b
);
4396 b
->loc
->requested_address
= sal
.pc
;
4397 b
->loc
->address
= adjusted_address
;
4399 if (sal
.symtab
== NULL
)
4400 b
->source_file
= NULL
;
4402 b
->source_file
= xstrdup (sal
.symtab
->filename
);
4403 b
->loc
->section
= sal
.section
;
4404 b
->line_number
= sal
.line
;
4406 set_breakpoint_location_function (b
->loc
);
4408 breakpoints_changed ();
4414 /* Note that the breakpoint object B describes a permanent breakpoint
4415 instruction, hard-wired into the inferior's code. */
4417 make_breakpoint_permanent (struct breakpoint
*b
)
4419 struct bp_location
*bl
;
4420 b
->enable_state
= bp_permanent
;
4422 /* By definition, permanent breakpoints are already present in the code.
4423 Mark all locations as inserted. For now, make_breakpoint_permanent
4424 is called in just one place, so it's hard to say if it's reasonable
4425 to have permanent breakpoint with multiple locations or not,
4426 but it's easy to implmement. */
4427 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4432 create_longjmp_breakpoint (char *func_name
)
4434 struct minimal_symbol
*m
;
4436 m
= lookup_minimal_symbol_text (func_name
, NULL
);
4439 set_momentary_breakpoint_at_pc (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4440 update_global_location_list (1);
4443 /* Call this routine when stepping and nexting to enable a breakpoint
4444 if we do a longjmp(). When we hit that breakpoint, call
4445 set_longjmp_resume_breakpoint() to figure out where we are going. */
4448 set_longjmp_breakpoint (void)
4450 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
4452 create_longjmp_breakpoint ("longjmp");
4453 create_longjmp_breakpoint ("_longjmp");
4454 create_longjmp_breakpoint ("siglongjmp");
4455 create_longjmp_breakpoint ("_siglongjmp");
4459 /* Delete all longjmp breakpoints from THREAD. */
4461 delete_longjmp_breakpoint (int thread
)
4463 struct breakpoint
*b
, *temp
;
4465 ALL_BREAKPOINTS_SAFE (b
, temp
)
4466 if (b
->type
== bp_longjmp
)
4468 if (b
->thread
== thread
)
4469 delete_breakpoint (b
);
4474 enable_overlay_breakpoints (void)
4476 struct breakpoint
*b
;
4479 if (b
->type
== bp_overlay_event
)
4481 b
->enable_state
= bp_enabled
;
4482 update_global_location_list (1);
4483 overlay_events_enabled
= 1;
4488 disable_overlay_breakpoints (void)
4490 struct breakpoint
*b
;
4493 if (b
->type
== bp_overlay_event
)
4495 b
->enable_state
= bp_disabled
;
4496 update_global_location_list (0);
4497 overlay_events_enabled
= 0;
4502 create_thread_event_breakpoint (CORE_ADDR address
)
4504 struct breakpoint
*b
;
4506 b
= create_internal_breakpoint (address
, bp_thread_event
);
4508 b
->enable_state
= bp_enabled
;
4509 /* addr_string has to be used or breakpoint_re_set will delete me. */
4510 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4512 update_global_location_list_nothrow (1);
4518 remove_thread_event_breakpoints (void)
4520 struct breakpoint
*b
, *temp
;
4522 ALL_BREAKPOINTS_SAFE (b
, temp
)
4523 if (b
->type
== bp_thread_event
)
4524 delete_breakpoint (b
);
4527 struct captured_parse_breakpoint_args
4530 struct symtabs_and_lines
*sals_p
;
4531 char ***addr_string_p
;
4535 struct lang_and_radix
4543 remove_solib_event_breakpoints (void)
4545 struct breakpoint
*b
, *temp
;
4547 ALL_BREAKPOINTS_SAFE (b
, temp
)
4548 if (b
->type
== bp_shlib_event
)
4549 delete_breakpoint (b
);
4553 create_solib_event_breakpoint (CORE_ADDR address
)
4555 struct breakpoint
*b
;
4557 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4558 update_global_location_list_nothrow (1);
4562 /* Disable any breakpoints that are on code in shared libraries. Only
4563 apply to enabled breakpoints, disabled ones can just stay disabled. */
4566 disable_breakpoints_in_shlibs (void)
4568 struct bp_location
*loc
;
4570 ALL_BP_LOCATIONS (loc
)
4572 struct breakpoint
*b
= loc
->owner
;
4573 /* We apply the check to all breakpoints, including disabled
4574 for those with loc->duplicate set. This is so that when breakpoint
4575 becomes enabled, or the duplicate is removed, gdb will try to insert
4576 all breakpoints. If we don't set shlib_disabled here, we'll try
4577 to insert those breakpoints and fail. */
4578 if (((b
->type
== bp_breakpoint
)
4579 || (b
->type
== bp_hardware_breakpoint
)
4580 || (b
->type
== bp_tracepoint
))
4581 && !loc
->shlib_disabled
4583 && PC_SOLIB (loc
->address
)
4585 && solib_name_from_address (loc
->address
)
4589 loc
->shlib_disabled
= 1;
4594 /* Disable any breakpoints that are in in an unloaded shared library. Only
4595 apply to enabled breakpoints, disabled ones can just stay disabled. */
4598 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4600 struct bp_location
*loc
;
4601 int disabled_shlib_breaks
= 0;
4603 /* SunOS a.out shared libraries are always mapped, so do not
4604 disable breakpoints; they will only be reported as unloaded
4605 through clear_solib when GDB discards its shared library
4606 list. See clear_solib for more information. */
4607 if (exec_bfd
!= NULL
4608 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
4611 ALL_BP_LOCATIONS (loc
)
4613 struct breakpoint
*b
= loc
->owner
;
4614 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4615 || loc
->loc_type
== bp_loc_software_breakpoint
)
4616 && !loc
->shlib_disabled
4617 && (b
->type
== bp_breakpoint
|| b
->type
== bp_hardware_breakpoint
)
4618 && solib_contains_address_p (solib
, loc
->address
))
4620 loc
->shlib_disabled
= 1;
4621 /* At this point, we cannot rely on remove_breakpoint
4622 succeeding so we must mark the breakpoint as not inserted
4623 to prevent future errors occurring in remove_breakpoints. */
4625 if (!disabled_shlib_breaks
)
4627 target_terminal_ours_for_output ();
4628 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4631 disabled_shlib_breaks
= 1;
4636 /* FORK & VFORK catchpoints. */
4638 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
4641 insert_catch_fork (struct breakpoint
*b
)
4643 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
4646 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
4649 remove_catch_fork (struct breakpoint
*b
)
4651 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
4654 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
4658 breakpoint_hit_catch_fork (struct breakpoint
*b
)
4660 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
4663 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
4665 static enum print_stop_action
4666 print_it_catch_fork (struct breakpoint
*b
)
4668 annotate_catchpoint (b
->number
);
4669 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
4670 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4671 return PRINT_SRC_AND_LOC
;
4674 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
4677 print_one_catch_fork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4679 struct value_print_options opts
;
4681 get_user_print_options (&opts
);
4683 /* Field 4, the address, is omitted (which makes the columns
4684 not line up too nicely with the headers, but the effect
4685 is relatively readable). */
4686 if (opts
.addressprint
)
4687 ui_out_field_skip (uiout
, "addr");
4689 ui_out_text (uiout
, "fork");
4690 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4692 ui_out_text (uiout
, ", process ");
4693 ui_out_field_int (uiout
, "what",
4694 ptid_get_pid (b
->forked_inferior_pid
));
4695 ui_out_spaces (uiout
, 1);
4699 /* Implement the "print_mention" breakpoint_ops method for fork
4703 print_mention_catch_fork (struct breakpoint
*b
)
4705 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
4708 /* The breakpoint_ops structure to be used in fork catchpoints. */
4710 static struct breakpoint_ops catch_fork_breakpoint_ops
=
4714 breakpoint_hit_catch_fork
,
4715 print_it_catch_fork
,
4716 print_one_catch_fork
,
4717 print_mention_catch_fork
4720 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
4723 insert_catch_vfork (struct breakpoint
*b
)
4725 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
4728 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
4731 remove_catch_vfork (struct breakpoint
*b
)
4733 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
4736 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
4740 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
4742 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
4745 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
4747 static enum print_stop_action
4748 print_it_catch_vfork (struct breakpoint
*b
)
4750 annotate_catchpoint (b
->number
);
4751 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
4752 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4753 return PRINT_SRC_AND_LOC
;
4756 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
4759 print_one_catch_vfork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4761 struct value_print_options opts
;
4763 get_user_print_options (&opts
);
4764 /* Field 4, the address, is omitted (which makes the columns
4765 not line up too nicely with the headers, but the effect
4766 is relatively readable). */
4767 if (opts
.addressprint
)
4768 ui_out_field_skip (uiout
, "addr");
4770 ui_out_text (uiout
, "vfork");
4771 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4773 ui_out_text (uiout
, ", process ");
4774 ui_out_field_int (uiout
, "what",
4775 ptid_get_pid (b
->forked_inferior_pid
));
4776 ui_out_spaces (uiout
, 1);
4780 /* Implement the "print_mention" breakpoint_ops method for vfork
4784 print_mention_catch_vfork (struct breakpoint
*b
)
4786 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
4789 /* The breakpoint_ops structure to be used in vfork catchpoints. */
4791 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
4795 breakpoint_hit_catch_vfork
,
4796 print_it_catch_vfork
,
4797 print_one_catch_vfork
,
4798 print_mention_catch_vfork
4801 /* Create a new breakpoint of the bp_catchpoint kind and return it.
4803 If TEMPFLAG is non-zero, then make the breakpoint temporary.
4804 If COND_STRING is not NULL, then store it in the breakpoint.
4805 OPS, if not NULL, is the breakpoint_ops structure associated
4806 to the catchpoint. */
4808 static struct breakpoint
*
4809 create_catchpoint (int tempflag
, char *cond_string
,
4810 struct breakpoint_ops
*ops
)
4812 struct symtab_and_line sal
;
4813 struct breakpoint
*b
;
4820 b
= set_raw_breakpoint (sal
, bp_catchpoint
);
4821 set_breakpoint_count (breakpoint_count
+ 1);
4822 b
->number
= breakpoint_count
;
4824 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
4826 b
->addr_string
= NULL
;
4827 b
->enable_state
= bp_enabled
;
4828 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4832 update_global_location_list (1);
4838 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4839 struct breakpoint_ops
*ops
)
4841 struct breakpoint
*b
= create_catchpoint (tempflag
, cond_string
, ops
);
4843 /* FIXME: We should put this information in a breakpoint private data
4845 b
->forked_inferior_pid
= null_ptid
;
4848 /* Exec catchpoints. */
4851 insert_catch_exec (struct breakpoint
*b
)
4853 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
4857 remove_catch_exec (struct breakpoint
*b
)
4859 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
4863 breakpoint_hit_catch_exec (struct breakpoint
*b
)
4865 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
4868 static enum print_stop_action
4869 print_it_catch_exec (struct breakpoint
*b
)
4871 annotate_catchpoint (b
->number
);
4872 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
4874 return PRINT_SRC_AND_LOC
;
4878 print_one_catch_exec (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4880 struct value_print_options opts
;
4882 get_user_print_options (&opts
);
4884 /* Field 4, the address, is omitted (which makes the columns
4885 not line up too nicely with the headers, but the effect
4886 is relatively readable). */
4887 if (opts
.addressprint
)
4888 ui_out_field_skip (uiout
, "addr");
4890 ui_out_text (uiout
, "exec");
4891 if (b
->exec_pathname
!= NULL
)
4893 ui_out_text (uiout
, ", program \"");
4894 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
4895 ui_out_text (uiout
, "\" ");
4900 print_mention_catch_exec (struct breakpoint
*b
)
4902 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
4905 static struct breakpoint_ops catch_exec_breakpoint_ops
=
4909 breakpoint_hit_catch_exec
,
4910 print_it_catch_exec
,
4911 print_one_catch_exec
,
4912 print_mention_catch_exec
4916 hw_breakpoint_used_count (void)
4918 struct breakpoint
*b
;
4923 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
4931 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4933 struct breakpoint
*b
;
4936 *other_type_used
= 0;
4939 if (breakpoint_enabled (b
))
4941 if (b
->type
== type
)
4943 else if ((b
->type
== bp_hardware_watchpoint
4944 || b
->type
== bp_read_watchpoint
4945 || b
->type
== bp_access_watchpoint
))
4946 *other_type_used
= 1;
4953 disable_watchpoints_before_interactive_call_start (void)
4955 struct breakpoint
*b
;
4959 if (((b
->type
== bp_watchpoint
)
4960 || (b
->type
== bp_hardware_watchpoint
)
4961 || (b
->type
== bp_read_watchpoint
)
4962 || (b
->type
== bp_access_watchpoint
))
4963 && breakpoint_enabled (b
))
4965 b
->enable_state
= bp_call_disabled
;
4966 update_global_location_list (0);
4972 enable_watchpoints_after_interactive_call_stop (void)
4974 struct breakpoint
*b
;
4978 if (((b
->type
== bp_watchpoint
)
4979 || (b
->type
== bp_hardware_watchpoint
)
4980 || (b
->type
== bp_read_watchpoint
)
4981 || (b
->type
== bp_access_watchpoint
))
4982 && (b
->enable_state
== bp_call_disabled
))
4984 b
->enable_state
= bp_enabled
;
4985 update_global_location_list (1);
4991 /* Set a breakpoint that will evaporate an end of command
4992 at address specified by SAL.
4993 Restrict it to frame FRAME if FRAME is nonzero. */
4996 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4999 struct breakpoint
*b
;
5000 b
= set_raw_breakpoint (sal
, type
);
5001 b
->enable_state
= bp_enabled
;
5002 b
->disposition
= disp_donttouch
;
5003 b
->frame_id
= frame_id
;
5005 /* If we're debugging a multi-threaded program, then we
5006 want momentary breakpoints to be active in only a
5007 single thread of control. */
5008 if (in_thread_list (inferior_ptid
))
5009 b
->thread
= pid_to_thread_id (inferior_ptid
);
5011 update_global_location_list_nothrow (1);
5016 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
5020 clone_momentary_breakpoint (struct breakpoint
*orig
)
5022 struct breakpoint
*copy
;
5024 /* If there's nothing to clone, then return nothing. */
5028 copy
= set_raw_breakpoint_without_location (orig
->type
);
5029 copy
->loc
= allocate_bp_location (copy
);
5030 set_breakpoint_location_function (copy
->loc
);
5032 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
5033 copy
->loc
->address
= orig
->loc
->address
;
5034 copy
->loc
->section
= orig
->loc
->section
;
5036 if (orig
->source_file
== NULL
)
5037 copy
->source_file
= NULL
;
5039 copy
->source_file
= xstrdup (orig
->source_file
);
5041 copy
->line_number
= orig
->line_number
;
5042 copy
->frame_id
= orig
->frame_id
;
5043 copy
->thread
= orig
->thread
;
5045 copy
->enable_state
= bp_enabled
;
5046 copy
->disposition
= disp_donttouch
;
5047 copy
->number
= internal_breakpoint_number
--;
5049 update_global_location_list_nothrow (0);
5054 set_momentary_breakpoint_at_pc (CORE_ADDR pc
, enum bptype type
)
5056 struct symtab_and_line sal
;
5058 sal
= find_pc_line (pc
, 0);
5060 sal
.section
= find_pc_overlay (pc
);
5061 sal
.explicit_pc
= 1;
5063 return set_momentary_breakpoint (sal
, null_frame_id
, type
);
5067 /* Tell the user we have just set a breakpoint B. */
5070 mention (struct breakpoint
*b
)
5073 struct cleanup
*ui_out_chain
;
5074 struct value_print_options opts
;
5076 get_user_print_options (&opts
);
5078 /* FIXME: This is misplaced; mention() is called by things (like
5079 hitting a watchpoint) other than breakpoint creation. It should
5080 be possible to clean this up and at the same time replace the
5081 random calls to breakpoint_changed with this hook. */
5082 observer_notify_breakpoint_created (b
->number
);
5084 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
5085 b
->ops
->print_mention (b
);
5090 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
5093 ui_out_text (uiout
, "Watchpoint ");
5094 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5095 ui_out_field_int (uiout
, "number", b
->number
);
5096 ui_out_text (uiout
, ": ");
5097 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5098 do_cleanups (ui_out_chain
);
5100 case bp_hardware_watchpoint
:
5101 ui_out_text (uiout
, "Hardware watchpoint ");
5102 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5103 ui_out_field_int (uiout
, "number", b
->number
);
5104 ui_out_text (uiout
, ": ");
5105 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5106 do_cleanups (ui_out_chain
);
5108 case bp_read_watchpoint
:
5109 ui_out_text (uiout
, "Hardware read watchpoint ");
5110 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
5111 ui_out_field_int (uiout
, "number", b
->number
);
5112 ui_out_text (uiout
, ": ");
5113 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5114 do_cleanups (ui_out_chain
);
5116 case bp_access_watchpoint
:
5117 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
5118 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
5119 ui_out_field_int (uiout
, "number", b
->number
);
5120 ui_out_text (uiout
, ": ");
5121 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5122 do_cleanups (ui_out_chain
);
5125 if (ui_out_is_mi_like_p (uiout
))
5130 if (b
->disposition
== disp_del
)
5131 printf_filtered (_("Temporary breakpoint"));
5133 printf_filtered (_("Breakpoint"));
5134 printf_filtered (_(" %d"), b
->number
);
5137 case bp_hardware_breakpoint
:
5138 if (ui_out_is_mi_like_p (uiout
))
5143 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
5147 if (ui_out_is_mi_like_p (uiout
))
5152 printf_filtered (_("Tracepoint"));
5153 printf_filtered (_(" %d"), b
->number
);
5160 case bp_longjmp_resume
:
5161 case bp_step_resume
:
5163 case bp_watchpoint_scope
:
5164 case bp_shlib_event
:
5165 case bp_thread_event
:
5166 case bp_overlay_event
:
5172 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5176 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5180 if (opts
.addressprint
|| b
->source_file
== NULL
)
5182 printf_filtered (" at ");
5183 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
5186 printf_filtered (": file %s, line %d.",
5187 b
->source_file
, b
->line_number
);
5191 struct bp_location
*loc
= b
->loc
;
5193 for (; loc
; loc
= loc
->next
)
5195 printf_filtered (" (%d locations)", n
);
5200 if (ui_out_is_mi_like_p (uiout
))
5202 printf_filtered ("\n");
5206 static struct bp_location
*
5207 add_location_to_breakpoint (struct breakpoint
*b
,
5208 const struct symtab_and_line
*sal
)
5210 struct bp_location
*loc
, **tmp
;
5212 loc
= allocate_bp_location (b
);
5213 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5216 loc
->requested_address
= sal
->pc
;
5217 loc
->address
= adjust_breakpoint_address (loc
->requested_address
, b
->type
);
5218 loc
->section
= sal
->section
;
5220 set_breakpoint_location_function (loc
);
5225 /* Return 1 if LOC is pointing to a permanent breakpoint,
5226 return 0 otherwise. */
5229 bp_loc_is_permanent (struct bp_location
*loc
)
5233 const gdb_byte
*brk
;
5234 gdb_byte
*target_mem
;
5235 struct cleanup
*cleanup
;
5238 gdb_assert (loc
!= NULL
);
5240 addr
= loc
->address
;
5241 brk
= gdbarch_breakpoint_from_pc (current_gdbarch
, &addr
, &len
);
5243 /* Software breakpoints unsupported? */
5247 target_mem
= alloca (len
);
5249 /* Enable the automatic memory restoration from breakpoints while
5250 we read the memory. Otherwise we could say about our temporary
5251 breakpoints they are permanent. */
5252 cleanup
= make_show_memory_breakpoints_cleanup (0);
5254 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
5255 && memcmp (target_mem
, brk
, len
) == 0)
5258 do_cleanups (cleanup
);
5265 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5266 as textual description of the location, and COND_STRING
5267 as condition expression. */
5270 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5272 enum bptype type
, enum bpdisp disposition
,
5273 int thread
, int task
, int ignore_count
,
5274 struct breakpoint_ops
*ops
, int from_tty
, int enabled
)
5276 struct breakpoint
*b
= NULL
;
5279 if (type
== bp_hardware_breakpoint
)
5281 int i
= hw_breakpoint_used_count ();
5282 int target_resources_ok
=
5283 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
5285 if (target_resources_ok
== 0)
5286 error (_("No hardware breakpoint support in the target."));
5287 else if (target_resources_ok
< 0)
5288 error (_("Hardware breakpoints used exceeds limit."));
5291 for (i
= 0; i
< sals
.nelts
; ++i
)
5293 struct symtab_and_line sal
= sals
.sals
[i
];
5294 struct bp_location
*loc
;
5297 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5301 b
= set_raw_breakpoint (sal
, type
);
5302 set_breakpoint_count (breakpoint_count
+ 1);
5303 b
->number
= breakpoint_count
;
5307 b
->cond_string
= cond_string
;
5308 b
->ignore_count
= ignore_count
;
5309 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
5310 b
->disposition
= disposition
;
5316 loc
= add_location_to_breakpoint (b
, &sal
);
5319 if (bp_loc_is_permanent (loc
))
5320 make_breakpoint_permanent (b
);
5324 char *arg
= b
->cond_string
;
5325 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5327 error (_("Garbage %s follows condition"), arg
);
5332 b
->addr_string
= addr_string
;
5334 /* addr_string has to be used or breakpoint_re_set will delete
5336 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5342 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5343 elements to fill the void space. */
5345 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5347 int i
= index_to_remove
+1;
5348 int last_index
= sal
->nelts
-1;
5350 for (;i
<= last_index
; ++i
)
5351 sal
->sals
[i
-1] = sal
->sals
[i
];
5356 /* If appropriate, obtains all sals that correspond
5357 to the same file and line as SAL. This is done
5358 only if SAL does not have explicit PC and has
5359 line and file information. If we got just a single
5360 expanded sal, return the original.
5362 Otherwise, if SAL.explicit_line is not set, filter out
5363 all sals for which the name of enclosing function
5364 is different from SAL. This makes sure that if we have
5365 breakpoint originally set in template instantiation, say
5366 foo<int>(), we won't expand SAL to locations at the same
5367 line in all existing instantiations of 'foo'.
5370 static struct symtabs_and_lines
5371 expand_line_sal_maybe (struct symtab_and_line sal
)
5373 struct symtabs_and_lines expanded
;
5374 CORE_ADDR original_pc
= sal
.pc
;
5375 char *original_function
= NULL
;
5379 /* If we have explicit pc, don't expand.
5380 If we have no line number, we can't expand. */
5381 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5384 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5385 expanded
.sals
[0] = sal
;
5390 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5392 expanded
= expand_line_sal (sal
);
5393 if (expanded
.nelts
== 1)
5395 /* We had one sal, we got one sal. Without futher
5396 processing, just return the original sal. */
5397 xfree (expanded
.sals
);
5399 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5400 sal
.pc
= original_pc
;
5401 expanded
.sals
[0] = sal
;
5405 if (!sal
.explicit_line
)
5407 CORE_ADDR func_addr
, func_end
;
5408 for (i
= 0; i
< expanded
.nelts
; ++i
)
5410 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5411 char *this_function
;
5412 if (find_pc_partial_function (pc
, &this_function
,
5413 &func_addr
, &func_end
))
5416 && strcmp (this_function
, original_function
) != 0)
5418 remove_sal (&expanded
, i
);
5421 else if (func_addr
== pc
)
5423 /* We're at beginning of a function, and should
5425 struct symbol
*sym
= find_pc_function (pc
);
5427 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5430 /* Since find_pc_partial_function returned true,
5431 we should really always find the section here. */
5432 struct obj_section
*section
= find_pc_section (pc
);
5435 struct gdbarch
*gdbarch
5436 = get_objfile_arch (section
->objfile
);
5438 = gdbarch_skip_prologue (gdbarch
, pc
);
5447 for (i
= 0; i
< expanded
.nelts
; ++i
)
5449 /* If this SAL corresponds to a breakpoint inserted using a
5450 line number, then skip the function prologue if necessary. */
5451 skip_prologue_sal (&expanded
.sals
[i
]);
5456 if (expanded
.nelts
<= 1)
5458 /* This is un ugly workaround. If we get zero
5459 expanded sals then something is really wrong.
5460 Fix that by returnign the original sal. */
5461 xfree (expanded
.sals
);
5463 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5464 sal
.pc
= original_pc
;
5465 expanded
.sals
[0] = sal
;
5472 for (i
= 0; i
< expanded
.nelts
; ++i
)
5473 if (expanded
.sals
[i
].pc
== original_pc
)
5484 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5485 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5486 value. COND_STRING, if not NULL, specified the condition to be
5487 used for all breakpoints. Essentially the only case where
5488 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5489 function. In that case, it's still not possible to specify
5490 separate conditions for different overloaded functions, so
5491 we take just a single condition string.
5493 NOTE: If the function succeeds, the caller is expected to cleanup
5494 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5495 array contents). If the function fails (error() is called), the
5496 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5497 COND and SALS arrays and each of those arrays contents. */
5500 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5502 enum bptype type
, enum bpdisp disposition
,
5503 int thread
, int task
, int ignore_count
,
5504 struct breakpoint_ops
*ops
, int from_tty
,
5508 for (i
= 0; i
< sals
.nelts
; ++i
)
5510 struct symtabs_and_lines expanded
=
5511 expand_line_sal_maybe (sals
.sals
[i
]);
5513 create_breakpoint (expanded
, addr_string
[i
],
5514 cond_string
, type
, disposition
,
5515 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
5519 /* Parse ARG which is assumed to be a SAL specification possibly
5520 followed by conditionals. On return, SALS contains an array of SAL
5521 addresses found. ADDR_STRING contains a vector of (canonical)
5522 address strings. ARG points to the end of the SAL. */
5525 parse_breakpoint_sals (char **address
,
5526 struct symtabs_and_lines
*sals
,
5527 char ***addr_string
,
5530 char *addr_start
= *address
;
5531 *addr_string
= NULL
;
5532 /* If no arg given, or if first arg is 'if ', use the default
5534 if ((*address
) == NULL
5535 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5537 if (default_breakpoint_valid
)
5539 struct symtab_and_line sal
;
5540 init_sal (&sal
); /* initialize to zeroes */
5541 sals
->sals
= (struct symtab_and_line
*)
5542 xmalloc (sizeof (struct symtab_and_line
));
5543 sal
.pc
= default_breakpoint_address
;
5544 sal
.line
= default_breakpoint_line
;
5545 sal
.symtab
= default_breakpoint_symtab
;
5546 sal
.section
= find_pc_overlay (sal
.pc
);
5548 /* "break" without arguments is equivalent to "break *PC" where PC is
5549 the default_breakpoint_address. So make sure to set
5550 sal.explicit_pc to prevent GDB from trying to expand the list of
5551 sals to include all other instances with the same symtab and line.
5553 sal
.explicit_pc
= 1;
5555 sals
->sals
[0] = sal
;
5559 error (_("No default breakpoint address now."));
5563 /* Force almost all breakpoints to be in terms of the
5564 current_source_symtab (which is decode_line_1's default). This
5565 should produce the results we want almost all of the time while
5566 leaving default_breakpoint_* alone.
5567 ObjC: However, don't match an Objective-C method name which
5568 may have a '+' or '-' succeeded by a '[' */
5570 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5572 if (default_breakpoint_valid
5574 || ((strchr ("+-", (*address
)[0]) != NULL
)
5575 && ((*address
)[1] != '['))))
5576 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5577 default_breakpoint_line
, addr_string
,
5580 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5581 addr_string
, not_found_ptr
);
5583 /* For any SAL that didn't have a canonical string, fill one in. */
5584 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5585 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5586 if (addr_start
!= (*address
))
5589 for (i
= 0; i
< sals
->nelts
; i
++)
5591 /* Add the string if not present. */
5592 if ((*addr_string
)[i
] == NULL
)
5593 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5599 /* Convert each SAL into a real PC. Verify that the PC can be
5600 inserted as a breakpoint. If it can't throw an error. */
5603 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5607 for (i
= 0; i
< sals
->nelts
; i
++)
5608 resolve_sal_pc (&sals
->sals
[i
]);
5612 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5614 struct captured_parse_breakpoint_args
*args
= data
;
5616 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5617 args
->not_found_ptr
);
5620 /* Given TOK, a string specification of condition and thread, as
5621 accepted by the 'break' command, extract the condition
5622 string and thread number and set *COND_STRING and *THREAD.
5623 PC identifies the context at which the condition should be parsed.
5624 If no condition is found, *COND_STRING is set to NULL.
5625 If no thread is found, *THREAD is set to -1. */
5627 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5628 char **cond_string
, int *thread
, int *task
)
5630 *cond_string
= NULL
;
5636 char *cond_start
= NULL
;
5637 char *cond_end
= NULL
;
5638 while (*tok
== ' ' || *tok
== '\t')
5643 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5646 toklen
= end_tok
- tok
;
5648 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5650 struct expression
*expr
;
5652 tok
= cond_start
= end_tok
+ 1;
5653 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5656 *cond_string
= savestring (cond_start
,
5657 cond_end
- cond_start
);
5659 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5665 *thread
= strtol (tok
, &tok
, 0);
5667 error (_("Junk after thread keyword."));
5668 if (!valid_thread_id (*thread
))
5669 error (_("Unknown thread %d."), *thread
);
5671 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
5677 *task
= strtol (tok
, &tok
, 0);
5679 error (_("Junk after task keyword."));
5680 if (!valid_task_id (*task
))
5681 error (_("Unknown task %d\n"), *task
);
5684 error (_("Junk at end of arguments."));
5688 /* Set a breakpoint. This function is shared between
5689 CLI and MI functions for setting a breakpoint.
5690 This function has two major modes of operations,
5691 selected by the PARSE_CONDITION_AND_THREAD parameter.
5692 If non-zero, the function will parse arg, extracting
5693 breakpoint location, address and thread. Otherwise,
5694 ARG is just the location of breakpoint, with condition
5695 and thread specified by the COND_STRING and THREAD
5699 break_command_really (char *arg
, char *cond_string
, int thread
,
5700 int parse_condition_and_thread
,
5701 int tempflag
, int hardwareflag
, int traceflag
,
5703 enum auto_boolean pending_break_support
,
5704 struct breakpoint_ops
*ops
,
5708 struct gdb_exception e
;
5709 struct symtabs_and_lines sals
;
5710 struct symtab_and_line pending_sal
;
5713 char *addr_start
= arg
;
5715 struct cleanup
*old_chain
;
5716 struct cleanup
*bkpt_chain
= NULL
;
5717 struct captured_parse_breakpoint_args parse_args
;
5721 enum bptype type_wanted
;
5728 parse_args
.arg_p
= &arg
;
5729 parse_args
.sals_p
= &sals
;
5730 parse_args
.addr_string_p
= &addr_string
;
5731 parse_args
.not_found_ptr
= ¬_found
;
5733 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5734 &parse_args
, RETURN_MASK_ALL
);
5736 /* If caller is interested in rc value from parse, set value. */
5740 throw_exception (e
);
5744 case NOT_FOUND_ERROR
:
5746 /* If pending breakpoint support is turned off, throw
5749 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5750 throw_exception (e
);
5752 exception_print (gdb_stderr
, e
);
5754 /* If pending breakpoint support is auto query and the user
5755 selects no, then simply return the error code. */
5756 if (pending_break_support
== AUTO_BOOLEAN_AUTO
5757 && !nquery ("Make breakpoint pending on future shared library load? "))
5760 /* At this point, either the user was queried about setting
5761 a pending breakpoint and selected yes, or pending
5762 breakpoint behavior is on and thus a pending breakpoint
5763 is defaulted on behalf of the user. */
5764 copy_arg
= xstrdup (addr_start
);
5765 addr_string
= ©_arg
;
5767 sals
.sals
= &pending_sal
;
5772 throw_exception (e
);
5779 /* Create a chain of things that always need to be cleaned up. */
5780 old_chain
= make_cleanup (null_cleanup
, 0);
5784 /* Make sure that all storage allocated to SALS gets freed. */
5785 make_cleanup (xfree
, sals
.sals
);
5787 /* Cleanup the addr_string array but not its contents. */
5788 make_cleanup (xfree
, addr_string
);
5791 /* ----------------------------- SNIP -----------------------------
5792 Anything added to the cleanup chain beyond this point is assumed
5793 to be part of a breakpoint. If the breakpoint create succeeds
5794 then the memory is not reclaimed. */
5795 bkpt_chain
= make_cleanup (null_cleanup
, 0);
5797 /* Mark the contents of the addr_string for cleanup. These go on
5798 the bkpt_chain and only occur if the breakpoint create fails. */
5799 for (i
= 0; i
< sals
.nelts
; i
++)
5801 if (addr_string
[i
] != NULL
)
5802 make_cleanup (xfree
, addr_string
[i
]);
5805 /* Resolve all line numbers to PC's and verify that the addresses
5806 are ok for the target. */
5808 breakpoint_sals_to_pc (&sals
, addr_start
);
5810 type_wanted
= (traceflag
5812 : (hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
));
5814 /* Verify that condition can be parsed, before setting any
5815 breakpoints. Allocate a separate condition expression for each
5819 if (parse_condition_and_thread
)
5821 /* Here we only parse 'arg' to separate condition
5822 from thread number, so parsing in context of first
5823 sal is OK. When setting the breakpoint we'll
5824 re-parse it in context of each sal. */
5827 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
5830 make_cleanup (xfree
, cond_string
);
5834 /* Create a private copy of condition string. */
5837 cond_string
= xstrdup (cond_string
);
5838 make_cleanup (xfree
, cond_string
);
5841 create_breakpoints (sals
, addr_string
, cond_string
, type_wanted
,
5842 tempflag
? disp_del
: disp_donttouch
,
5843 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
5847 struct symtab_and_line sal
= {0};
5848 struct breakpoint
*b
;
5850 make_cleanup (xfree
, copy_arg
);
5852 b
= set_raw_breakpoint_without_location (type_wanted
);
5853 set_breakpoint_count (breakpoint_count
+ 1);
5854 b
->number
= breakpoint_count
;
5856 b
->addr_string
= addr_string
[0];
5857 b
->cond_string
= NULL
;
5858 b
->ignore_count
= ignore_count
;
5859 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5860 b
->condition_not_parsed
= 1;
5862 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
5868 warning (_("Multiple breakpoints were set.\n"
5869 "Use the \"delete\" command to delete unwanted breakpoints."));
5870 /* That's it. Discard the cleanups for data inserted into the
5872 discard_cleanups (bkpt_chain
);
5873 /* But cleanup everything else. */
5874 do_cleanups (old_chain
);
5876 /* error call may happen here - have BKPT_CHAIN already discarded. */
5877 update_global_location_list (1);
5880 /* Set a breakpoint.
5881 ARG is a string describing breakpoint address,
5882 condition, and thread.
5883 FLAG specifies if a breakpoint is hardware on,
5884 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5888 break_command_1 (char *arg
, int flag
, int from_tty
)
5890 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5891 int tempflag
= flag
& BP_TEMPFLAG
;
5893 break_command_really (arg
,
5894 NULL
, 0, 1 /* parse arg */,
5895 tempflag
, hardwareflag
, 0 /* traceflag */,
5896 0 /* Ignore count */,
5897 pending_break_support
,
5898 NULL
/* breakpoint_ops */,
5905 set_breakpoint (char *address
, char *condition
,
5906 int hardwareflag
, int tempflag
,
5907 int thread
, int ignore_count
,
5908 int pending
, int enabled
)
5910 break_command_really (address
, condition
, thread
,
5911 0 /* condition and thread are valid. */,
5912 tempflag
, hardwareflag
, 0 /* traceflag */,
5915 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5919 /* Adjust SAL to the first instruction past the function prologue.
5920 The end of the prologue is determined using the line table from
5921 the debugging information. explicit_pc and explicit_line are
5924 If SAL is already past the prologue, then do nothing. */
5927 skip_prologue_sal (struct symtab_and_line
*sal
)
5929 struct symbol
*sym
= find_pc_function (sal
->pc
);
5930 struct symtab_and_line start_sal
;
5935 start_sal
= find_function_start_sal (sym
, 1);
5936 if (sal
->pc
< start_sal
.pc
)
5938 start_sal
.explicit_line
= sal
->explicit_line
;
5939 start_sal
.explicit_pc
= sal
->explicit_pc
;
5944 /* Helper function for break_command_1 and disassemble_command. */
5947 resolve_sal_pc (struct symtab_and_line
*sal
)
5951 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5953 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5954 error (_("No line %d in file \"%s\"."),
5955 sal
->line
, sal
->symtab
->filename
);
5958 /* If this SAL corresponds to a breakpoint inserted using
5959 a line number, then skip the function prologue if necessary. */
5960 if (sal
->explicit_line
)
5962 /* Preserve the original line number. */
5963 int saved_line
= sal
->line
;
5964 skip_prologue_sal (sal
);
5965 sal
->line
= saved_line
;
5969 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5971 struct blockvector
*bv
;
5975 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
5978 sym
= block_linkage_function (b
);
5981 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5982 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
5986 /* It really is worthwhile to have the section, so we'll just
5987 have to look harder. This case can be executed if we have
5988 line numbers but no functions (as can happen in assembly
5991 struct minimal_symbol
*msym
;
5993 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5995 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
6002 break_command (char *arg
, int from_tty
)
6004 break_command_1 (arg
, 0, from_tty
);
6008 tbreak_command (char *arg
, int from_tty
)
6010 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
6014 hbreak_command (char *arg
, int from_tty
)
6016 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
6020 thbreak_command (char *arg
, int from_tty
)
6022 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
6026 stop_command (char *arg
, int from_tty
)
6028 printf_filtered (_("Specify the type of breakpoint to set.\n\
6029 Usage: stop in <function | address>\n\
6030 stop at <line>\n"));
6034 stopin_command (char *arg
, int from_tty
)
6038 if (arg
== (char *) NULL
)
6040 else if (*arg
!= '*')
6045 /* look for a ':'. If this is a line number specification, then
6046 say it is bad, otherwise, it should be an address or
6047 function/method name */
6048 while (*argptr
&& !hasColon
)
6050 hasColon
= (*argptr
== ':');
6055 badInput
= (*argptr
!= ':'); /* Not a class::method */
6057 badInput
= isdigit (*arg
); /* a simple line number */
6061 printf_filtered (_("Usage: stop in <function | address>\n"));
6063 break_command_1 (arg
, 0, from_tty
);
6067 stopat_command (char *arg
, int from_tty
)
6071 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
6078 /* look for a ':'. If there is a '::' then get out, otherwise
6079 it is probably a line number. */
6080 while (*argptr
&& !hasColon
)
6082 hasColon
= (*argptr
== ':');
6087 badInput
= (*argptr
== ':'); /* we have class::method */
6089 badInput
= !isdigit (*arg
); /* not a line number */
6093 printf_filtered (_("Usage: stop at <line>\n"));
6095 break_command_1 (arg
, 0, from_tty
);
6098 /* accessflag: hw_write: watch write,
6099 hw_read: watch read,
6100 hw_access: watch access (read or write) */
6102 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
6104 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
6105 struct symtab_and_line sal
;
6106 struct expression
*exp
;
6107 struct block
*exp_valid_block
;
6108 struct value
*val
, *mark
;
6109 struct frame_info
*frame
;
6110 struct frame_info
*prev_frame
= NULL
;
6111 char *exp_start
= NULL
;
6112 char *exp_end
= NULL
;
6113 char *tok
, *id_tok_start
, *end_tok
;
6115 char *cond_start
= NULL
;
6116 char *cond_end
= NULL
;
6117 struct expression
*cond
= NULL
;
6118 int i
, other_type_used
, target_resources_ok
= 0;
6119 enum bptype bp_type
;
6123 init_sal (&sal
); /* initialize to zeroes */
6125 /* Make sure that we actually have parameters to parse. */
6126 if (arg
!= NULL
&& arg
[0] != '\0')
6128 toklen
= strlen (arg
); /* Size of argument list. */
6130 /* Points tok to the end of the argument list. */
6131 tok
= arg
+ toklen
- 1;
6133 /* Go backwards in the parameters list. Skip the last parameter.
6134 If we're expecting a 'thread <thread_num>' parameter, this should
6135 be the thread identifier. */
6136 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6138 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6141 /* Points end_tok to the beginning of the last token. */
6142 id_tok_start
= tok
+ 1;
6144 /* Go backwards in the parameters list. Skip one more parameter.
6145 If we're expecting a 'thread <thread_num>' parameter, we should
6146 reach a "thread" token. */
6147 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6152 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6155 /* Move the pointer forward to skip the whitespace and
6156 calculate the length of the token. */
6158 toklen
= end_tok
- tok
;
6160 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
6162 /* At this point we've found a "thread" token, which means
6163 the user is trying to set a watchpoint that triggers
6164 only in a specific thread. */
6167 /* Extract the thread ID from the next token. */
6168 thread
= strtol (id_tok_start
, &endp
, 0);
6170 /* Check if the user provided a valid numeric value for the
6172 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
6173 error (_("Invalid thread ID specification %s."), id_tok_start
);
6175 /* Check if the thread actually exists. */
6176 if (!valid_thread_id (thread
))
6177 error (_("Unknown thread %d."), thread
);
6179 /* Truncate the string and get rid of the thread <thread_num>
6180 parameter before the parameter list is parsed by the
6181 evaluate_expression() function. */
6186 /* Parse the rest of the arguments. */
6187 innermost_block
= NULL
;
6189 exp
= parse_exp_1 (&arg
, 0, 0);
6191 /* Remove trailing whitespace from the expression before saving it.
6192 This makes the eventual display of the expression string a bit
6194 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
6197 exp_valid_block
= innermost_block
;
6198 mark
= value_mark ();
6199 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
6201 release_value (val
);
6204 while (*tok
== ' ' || *tok
== '\t')
6208 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
6211 toklen
= end_tok
- tok
;
6212 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
6214 tok
= cond_start
= end_tok
+ 1;
6215 cond
= parse_exp_1 (&tok
, 0, 0);
6219 error (_("Junk at end of command."));
6221 if (accessflag
== hw_read
)
6222 bp_type
= bp_read_watchpoint
;
6223 else if (accessflag
== hw_access
)
6224 bp_type
= bp_access_watchpoint
;
6226 bp_type
= bp_hardware_watchpoint
;
6228 mem_cnt
= can_use_hardware_watchpoint (val
);
6229 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
6230 error (_("Expression cannot be implemented with read/access watchpoint."));
6233 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
6234 target_resources_ok
=
6235 target_can_use_hardware_watchpoint (bp_type
, i
+ mem_cnt
,
6237 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
6238 error (_("Target does not support this type of hardware watchpoint."));
6240 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
6241 error (_("Target can only support one kind of HW watchpoint at a time."));
6244 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
6245 watchpoint could not be set. */
6246 if (!mem_cnt
|| target_resources_ok
<= 0)
6247 bp_type
= bp_watchpoint
;
6249 frame
= block_innermost_frame (exp_valid_block
);
6251 prev_frame
= get_prev_frame (frame
);
6255 /* If the expression is "local", then set up a "watchpoint scope"
6256 breakpoint at the point where we've left the scope of the watchpoint
6257 expression. Create the scope breakpoint before the watchpoint, so
6258 that we will encounter it first in bpstat_stop_status. */
6259 if (innermost_block
&& prev_frame
)
6261 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
6262 bp_watchpoint_scope
);
6264 scope_breakpoint
->enable_state
= bp_enabled
;
6266 /* Automatically delete the breakpoint when it hits. */
6267 scope_breakpoint
->disposition
= disp_del
;
6269 /* Only break in the proper frame (help with recursion). */
6270 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
6272 /* Set the address at which we will stop. */
6273 scope_breakpoint
->loc
->requested_address
6274 = get_frame_pc (prev_frame
);
6275 scope_breakpoint
->loc
->address
6276 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
6277 scope_breakpoint
->type
);
6280 /* Now set up the breakpoint. */
6281 b
= set_raw_breakpoint (sal
, bp_type
);
6282 set_breakpoint_count (breakpoint_count
+ 1);
6283 b
->number
= breakpoint_count
;
6285 b
->disposition
= disp_donttouch
;
6287 b
->exp_valid_block
= exp_valid_block
;
6288 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
6291 b
->loc
->cond
= cond
;
6293 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
6298 b
->watchpoint_frame
= get_frame_id (frame
);
6300 b
->watchpoint_frame
= null_frame_id
;
6302 if (scope_breakpoint
!= NULL
)
6304 /* The scope breakpoint is related to the watchpoint. We will
6305 need to act on them together. */
6306 b
->related_breakpoint
= scope_breakpoint
;
6307 scope_breakpoint
->related_breakpoint
= b
;
6310 value_free_to_mark (mark
);
6312 update_global_location_list (1);
6315 /* Return count of locations need to be watched and can be handled
6316 in hardware. If the watchpoint can not be handled
6317 in hardware return zero. */
6320 can_use_hardware_watchpoint (struct value
*v
)
6322 int found_memory_cnt
= 0;
6323 struct value
*head
= v
;
6325 /* Did the user specifically forbid us to use hardware watchpoints? */
6326 if (!can_use_hw_watchpoints
)
6329 /* Make sure that the value of the expression depends only upon
6330 memory contents, and values computed from them within GDB. If we
6331 find any register references or function calls, we can't use a
6332 hardware watchpoint.
6334 The idea here is that evaluating an expression generates a series
6335 of values, one holding the value of every subexpression. (The
6336 expression a*b+c has five subexpressions: a, b, a*b, c, and
6337 a*b+c.) GDB's values hold almost enough information to establish
6338 the criteria given above --- they identify memory lvalues,
6339 register lvalues, computed values, etcetera. So we can evaluate
6340 the expression, and then scan the chain of values that leaves
6341 behind to decide whether we can detect any possible change to the
6342 expression's final value using only hardware watchpoints.
6344 However, I don't think that the values returned by inferior
6345 function calls are special in any way. So this function may not
6346 notice that an expression involving an inferior function call
6347 can't be watched with hardware watchpoints. FIXME. */
6348 for (; v
; v
= value_next (v
))
6350 if (VALUE_LVAL (v
) == lval_memory
)
6353 /* A lazy memory lvalue is one that GDB never needed to fetch;
6354 we either just used its address (e.g., `a' in `a.b') or
6355 we never needed it at all (e.g., `a' in `a,b'). */
6359 /* Ahh, memory we actually used! Check if we can cover
6360 it with hardware watchpoints. */
6361 struct type
*vtype
= check_typedef (value_type (v
));
6363 /* We only watch structs and arrays if user asked for it
6364 explicitly, never if they just happen to appear in a
6365 middle of some value chain. */
6367 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6368 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6370 CORE_ADDR vaddr
= value_address (v
);
6371 int len
= TYPE_LENGTH (value_type (v
));
6373 if (!target_region_ok_for_hw_watchpoint (vaddr
, len
))
6380 else if (VALUE_LVAL (v
) != not_lval
6381 && deprecated_value_modifiable (v
) == 0)
6382 return 0; /* ??? What does this represent? */
6383 else if (VALUE_LVAL (v
) == lval_register
)
6384 return 0; /* cannot watch a register with a HW watchpoint */
6387 /* The expression itself looks suitable for using a hardware
6388 watchpoint, but give the target machine a chance to reject it. */
6389 return found_memory_cnt
;
6393 watch_command_wrapper (char *arg
, int from_tty
)
6395 watch_command (arg
, from_tty
);
6399 watch_command (char *arg
, int from_tty
)
6401 watch_command_1 (arg
, hw_write
, from_tty
);
6405 rwatch_command_wrapper (char *arg
, int from_tty
)
6407 rwatch_command (arg
, from_tty
);
6411 rwatch_command (char *arg
, int from_tty
)
6413 watch_command_1 (arg
, hw_read
, from_tty
);
6417 awatch_command_wrapper (char *arg
, int from_tty
)
6419 awatch_command (arg
, from_tty
);
6423 awatch_command (char *arg
, int from_tty
)
6425 watch_command_1 (arg
, hw_access
, from_tty
);
6429 /* Helper routines for the until_command routine in infcmd.c. Here
6430 because it uses the mechanisms of breakpoints. */
6432 struct until_break_command_continuation_args
6434 struct breakpoint
*breakpoint
;
6435 struct breakpoint
*breakpoint2
;
6438 /* This function is called by fetch_inferior_event via the
6439 cmd_continuation pointer, to complete the until command. It takes
6440 care of cleaning up the temporary breakpoints set up by the until
6443 until_break_command_continuation (void *arg
)
6445 struct until_break_command_continuation_args
*a
= arg
;
6447 delete_breakpoint (a
->breakpoint
);
6449 delete_breakpoint (a
->breakpoint2
);
6453 until_break_command (char *arg
, int from_tty
, int anywhere
)
6455 struct symtabs_and_lines sals
;
6456 struct symtab_and_line sal
;
6457 struct frame_info
*frame
= get_selected_frame (NULL
);
6458 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6459 struct breakpoint
*breakpoint
;
6460 struct breakpoint
*breakpoint2
= NULL
;
6461 struct cleanup
*old_chain
;
6463 clear_proceed_status ();
6465 /* Set a breakpoint where the user wants it and at return from
6468 if (default_breakpoint_valid
)
6469 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6470 default_breakpoint_line
, (char ***) NULL
, NULL
);
6472 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6473 0, (char ***) NULL
, NULL
);
6475 if (sals
.nelts
!= 1)
6476 error (_("Couldn't get information on specified line."));
6479 xfree (sals
.sals
); /* malloc'd, so freed */
6482 error (_("Junk at end of arguments."));
6484 resolve_sal_pc (&sal
);
6487 /* If the user told us to continue until a specified location,
6488 we don't specify a frame at which we need to stop. */
6489 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6491 /* Otherwise, specify the current frame, because we want to stop only
6492 at the very same frame. */
6493 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6496 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6498 /* Keep within the current frame, or in frames called by the current
6502 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6503 sal
.pc
= get_frame_pc (prev_frame
);
6504 breakpoint2
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6506 make_cleanup_delete_breakpoint (breakpoint2
);
6509 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6511 /* If we are running asynchronously, and proceed call above has actually
6512 managed to start the target, arrange for breakpoints to be
6513 deleted when the target stops. Otherwise, we're already stopped and
6514 delete breakpoints via cleanup chain. */
6516 if (target_can_async_p () && is_running (inferior_ptid
))
6518 struct until_break_command_continuation_args
*args
;
6519 args
= xmalloc (sizeof (*args
));
6521 args
->breakpoint
= breakpoint
;
6522 args
->breakpoint2
= breakpoint2
;
6524 discard_cleanups (old_chain
);
6525 add_continuation (inferior_thread (),
6526 until_break_command_continuation
, args
,
6530 do_cleanups (old_chain
);
6534 ep_skip_leading_whitespace (char **s
)
6536 if ((s
== NULL
) || (*s
== NULL
))
6538 while (isspace (**s
))
6542 /* This function attempts to parse an optional "if <cond>" clause
6543 from the arg string. If one is not found, it returns NULL.
6545 Else, it returns a pointer to the condition string. (It does not
6546 attempt to evaluate the string against a particular block.) And,
6547 it updates arg to point to the first character following the parsed
6548 if clause in the arg string. */
6551 ep_parse_optional_if_clause (char **arg
)
6555 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6558 /* Skip the "if" keyword. */
6561 /* Skip any extra leading whitespace, and record the start of the
6562 condition string. */
6563 ep_skip_leading_whitespace (arg
);
6566 /* Assume that the condition occupies the remainder of the arg string. */
6567 (*arg
) += strlen (cond_string
);
6572 /* This function attempts to parse an optional filename from the arg
6573 string. If one is not found, it returns NULL.
6575 Else, it returns a pointer to the parsed filename. (This function
6576 makes no attempt to verify that a file of that name exists, or is
6577 accessible.) And, it updates arg to point to the first character
6578 following the parsed filename in the arg string.
6580 Note that clients needing to preserve the returned filename for
6581 future access should copy it to their own buffers. */
6583 ep_parse_optional_filename (char **arg
)
6585 static char filename
[1024];
6590 if ((*arg_p
== '\0') || isspace (*arg_p
))
6608 /* Commands to deal with catching events, such as signals, exceptions,
6609 process start/exit, etc. */
6613 catch_fork_temporary
, catch_vfork_temporary
,
6614 catch_fork_permanent
, catch_vfork_permanent
6619 catch_fork_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6621 char *cond_string
= NULL
;
6622 catch_fork_kind fork_kind
;
6625 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
6626 tempflag
= (fork_kind
== catch_fork_temporary
6627 || fork_kind
== catch_vfork_temporary
);
6631 ep_skip_leading_whitespace (&arg
);
6633 /* The allowed syntax is:
6635 catch [v]fork if <cond>
6637 First, check if there's an if clause. */
6638 cond_string
= ep_parse_optional_if_clause (&arg
);
6640 if ((*arg
!= '\0') && !isspace (*arg
))
6641 error (_("Junk at end of arguments."));
6643 /* If this target supports it, create a fork or vfork catchpoint
6644 and enable reporting of such events. */
6647 case catch_fork_temporary
:
6648 case catch_fork_permanent
:
6649 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6650 &catch_fork_breakpoint_ops
);
6652 case catch_vfork_temporary
:
6653 case catch_vfork_permanent
:
6654 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6655 &catch_vfork_breakpoint_ops
);
6658 error (_("unsupported or unknown fork kind; cannot catch it"));
6664 catch_exec_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6667 char *cond_string
= NULL
;
6669 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6673 ep_skip_leading_whitespace (&arg
);
6675 /* The allowed syntax is:
6677 catch exec if <cond>
6679 First, check if there's an if clause. */
6680 cond_string
= ep_parse_optional_if_clause (&arg
);
6682 if ((*arg
!= '\0') && !isspace (*arg
))
6683 error (_("Junk at end of arguments."));
6685 /* If this target supports it, create an exec catchpoint
6686 and enable reporting of such events. */
6687 create_catchpoint (tempflag
, cond_string
, &catch_exec_breakpoint_ops
);
6690 static enum print_stop_action
6691 print_exception_catchpoint (struct breakpoint
*b
)
6693 int bp_temp
, bp_throw
;
6695 annotate_catchpoint (b
->number
);
6697 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6698 if (b
->loc
->address
!= b
->loc
->requested_address
)
6699 breakpoint_adjustment_warning (b
->loc
->requested_address
,
6702 bp_temp
= b
->disposition
== disp_del
;
6704 bp_temp
? "Temporary catchpoint "
6706 if (!ui_out_is_mi_like_p (uiout
))
6707 ui_out_field_int (uiout
, "bkptno", b
->number
);
6709 bp_throw
? " (exception thrown), "
6710 : " (exception caught), ");
6711 if (ui_out_is_mi_like_p (uiout
))
6713 ui_out_field_string (uiout
, "reason",
6714 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
6715 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6716 ui_out_field_int (uiout
, "bkptno", b
->number
);
6718 return PRINT_SRC_AND_LOC
;
6722 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6724 struct value_print_options opts
;
6725 get_user_print_options (&opts
);
6726 if (opts
.addressprint
)
6729 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
6730 ui_out_field_string (uiout
, "addr", "<PENDING>");
6732 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6736 *last_addr
= b
->loc
->address
;
6737 if (strstr (b
->addr_string
, "throw") != NULL
)
6738 ui_out_field_string (uiout
, "what", "exception throw");
6740 ui_out_field_string (uiout
, "what", "exception catch");
6744 print_mention_exception_catchpoint (struct breakpoint
*b
)
6749 bp_temp
= b
->disposition
== disp_del
;
6750 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6751 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
6752 : _("Catchpoint "));
6753 ui_out_field_int (uiout
, "bkptno", b
->number
);
6754 ui_out_text (uiout
, bp_throw
? _(" (throw)")
6758 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6761 NULL
, /* breakpoint_hit */
6762 print_exception_catchpoint
,
6763 print_one_exception_catchpoint
,
6764 print_mention_exception_catchpoint
6768 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6769 enum exception_event_kind ex_event
, int from_tty
)
6771 char *trigger_func_name
;
6773 if (ex_event
== EX_EVENT_CATCH
)
6774 trigger_func_name
= "__cxa_begin_catch";
6776 trigger_func_name
= "__cxa_throw";
6778 break_command_really (trigger_func_name
, cond_string
, -1,
6779 0 /* condition and thread are valid. */,
6782 AUTO_BOOLEAN_TRUE
/* pending */,
6783 &gnu_v3_exception_catchpoint_ops
, from_tty
,
6789 /* Deal with "catch catch" and "catch throw" commands */
6792 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6793 int tempflag
, int from_tty
)
6795 char *cond_string
= NULL
;
6796 struct symtab_and_line
*sal
= NULL
;
6800 ep_skip_leading_whitespace (&arg
);
6802 cond_string
= ep_parse_optional_if_clause (&arg
);
6804 if ((*arg
!= '\0') && !isspace (*arg
))
6805 error (_("Junk at end of arguments."));
6807 if (ex_event
!= EX_EVENT_THROW
6808 && ex_event
!= EX_EVENT_CATCH
)
6809 error (_("Unsupported or unknown exception event; cannot catch it"));
6811 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6814 warning (_("Unsupported with this platform/compiler combination."));
6817 /* Implementation of "catch catch" command. */
6820 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6822 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6823 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
6826 /* Implementation of "catch throw" command. */
6829 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6831 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6832 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
6835 /* Create a breakpoint struct for Ada exception catchpoints. */
6838 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6842 struct expression
*cond
,
6843 struct breakpoint_ops
*ops
,
6847 struct breakpoint
*b
;
6851 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6852 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6853 version for exception catchpoints, because two catchpoints
6854 used for different exception names will use the same address.
6855 In this case, a "breakpoint ... also set at..." warning is
6856 unproductive. Besides. the warning phrasing is also a bit
6857 inapropriate, we should use the word catchpoint, and tell
6858 the user what type of catchpoint it is. The above is good
6859 enough for now, though. */
6862 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6863 set_breakpoint_count (breakpoint_count
+ 1);
6865 b
->enable_state
= bp_enabled
;
6866 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6867 b
->number
= breakpoint_count
;
6868 b
->ignore_count
= 0;
6869 b
->loc
->cond
= cond
;
6870 b
->addr_string
= addr_string
;
6871 b
->language
= language_ada
;
6872 b
->cond_string
= cond_string
;
6873 b
->exp_string
= exp_string
;
6878 update_global_location_list (1);
6881 /* Implement the "catch exception" command. */
6884 catch_ada_exception_command (char *arg
, int from_tty
,
6885 struct cmd_list_element
*command
)
6888 struct symtab_and_line sal
;
6890 char *addr_string
= NULL
;
6891 char *exp_string
= NULL
;
6892 char *cond_string
= NULL
;
6893 struct expression
*cond
= NULL
;
6894 struct breakpoint_ops
*ops
= NULL
;
6896 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6900 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6901 &cond_string
, &cond
, &ops
);
6902 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6903 cond_string
, cond
, ops
, tempflag
,
6907 /* Implement the "catch assert" command. */
6910 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6913 struct symtab_and_line sal
;
6914 char *addr_string
= NULL
;
6915 struct breakpoint_ops
*ops
= NULL
;
6917 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6921 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6922 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6923 tempflag
, from_tty
);
6927 catch_command (char *arg
, int from_tty
)
6929 error (_("Catch requires an event name."));
6934 tcatch_command (char *arg
, int from_tty
)
6936 error (_("Catch requires an event name."));
6939 /* Delete breakpoints by address or line. */
6942 clear_command (char *arg
, int from_tty
)
6944 struct breakpoint
*b
;
6945 VEC(breakpoint_p
) *found
= 0;
6948 struct symtabs_and_lines sals
;
6949 struct symtab_and_line sal
;
6954 sals
= decode_line_spec (arg
, 1);
6959 sals
.sals
= (struct symtab_and_line
*)
6960 xmalloc (sizeof (struct symtab_and_line
));
6961 make_cleanup (xfree
, sals
.sals
);
6962 init_sal (&sal
); /* initialize to zeroes */
6963 sal
.line
= default_breakpoint_line
;
6964 sal
.symtab
= default_breakpoint_symtab
;
6965 sal
.pc
= default_breakpoint_address
;
6966 if (sal
.symtab
== 0)
6967 error (_("No source file specified."));
6975 /* We don't call resolve_sal_pc here. That's not
6976 as bad as it seems, because all existing breakpoints
6977 typically have both file/line and pc set. So, if
6978 clear is given file/line, we can match this to existing
6979 breakpoint without obtaining pc at all.
6981 We only support clearing given the address explicitly
6982 present in breakpoint table. Say, we've set breakpoint
6983 at file:line. There were several PC values for that file:line,
6984 due to optimization, all in one block.
6985 We've picked one PC value. If "clear" is issued with another
6986 PC corresponding to the same file:line, the breakpoint won't
6987 be cleared. We probably can still clear the breakpoint, but
6988 since the other PC value is never presented to user, user
6989 can only find it by guessing, and it does not seem important
6992 /* For each line spec given, delete bps which correspond
6993 to it. Do it in two passes, solely to preserve the current
6994 behavior that from_tty is forced true if we delete more than
6998 for (i
= 0; i
< sals
.nelts
; i
++)
7000 /* If exact pc given, clear bpts at that pc.
7001 If line given (pc == 0), clear all bpts on specified line.
7002 If defaulting, clear all bpts on default line
7005 defaulting sal.pc != 0 tests to do
7010 1 0 <can't happen> */
7014 /* Find all matching breakpoints and add them to
7019 /* Are we going to delete b? */
7020 if (b
->type
!= bp_none
7021 && b
->type
!= bp_watchpoint
7022 && b
->type
!= bp_hardware_watchpoint
7023 && b
->type
!= bp_read_watchpoint
7024 && b
->type
!= bp_access_watchpoint
)
7026 struct bp_location
*loc
= b
->loc
;
7027 for (; loc
; loc
= loc
->next
)
7029 int pc_match
= sal
.pc
7030 && (loc
->address
== sal
.pc
)
7031 && (!section_is_overlay (loc
->section
)
7032 || loc
->section
== sal
.section
);
7033 int line_match
= ((default_match
|| (0 == sal
.pc
))
7034 && b
->source_file
!= NULL
7035 && sal
.symtab
!= NULL
7036 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
7037 && b
->line_number
== sal
.line
);
7038 if (pc_match
|| line_match
)
7047 VEC_safe_push(breakpoint_p
, found
, b
);
7050 /* Now go thru the 'found' chain and delete them. */
7051 if (VEC_empty(breakpoint_p
, found
))
7054 error (_("No breakpoint at %s."), arg
);
7056 error (_("No breakpoint at this line."));
7059 if (VEC_length(breakpoint_p
, found
) > 1)
7060 from_tty
= 1; /* Always report if deleted more than one */
7063 if (VEC_length(breakpoint_p
, found
) == 1)
7064 printf_unfiltered (_("Deleted breakpoint "));
7066 printf_unfiltered (_("Deleted breakpoints "));
7068 breakpoints_changed ();
7070 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
7073 printf_unfiltered ("%d ", b
->number
);
7074 delete_breakpoint (b
);
7077 putchar_unfiltered ('\n');
7080 /* Delete breakpoint in BS if they are `delete' breakpoints and
7081 all breakpoints that are marked for deletion, whether hit or not.
7082 This is called after any breakpoint is hit, or after errors. */
7085 breakpoint_auto_delete (bpstat bs
)
7087 struct breakpoint
*b
, *temp
;
7089 for (; bs
; bs
= bs
->next
)
7090 if (bs
->breakpoint_at
7091 && bs
->breakpoint_at
->owner
7092 && bs
->breakpoint_at
->owner
->disposition
== disp_del
7094 delete_breakpoint (bs
->breakpoint_at
->owner
);
7096 ALL_BREAKPOINTS_SAFE (b
, temp
)
7098 if (b
->disposition
== disp_del_at_next_stop
)
7099 delete_breakpoint (b
);
7103 /* A cleanup function which destroys a vector. */
7106 do_vec_free (void *p
)
7108 VEC(bp_location_p
) **vec
= p
;
7110 VEC_free (bp_location_p
, *vec
);
7113 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
7114 into the inferior, only remove already-inserted locations that no
7115 longer should be inserted. Functions that delete a breakpoint or
7116 breakpoints should pass false, so that deleting a breakpoint
7117 doesn't have the side effect of inserting the locations of other
7118 breakpoints that are marked not-inserted, but should_be_inserted
7119 returns true on them.
7121 This behaviour is useful is situations close to tear-down -- e.g.,
7122 after an exec, while the target still has execution, but breakpoint
7123 shadows of the previous executable image should *NOT* be restored
7124 to the new image; or before detaching, where the target still has
7125 execution and wants to delete breakpoints from GDB's lists, and all
7126 breakpoints had already been removed from the inferior. */
7129 update_global_location_list (int should_insert
)
7131 struct breakpoint
*b
;
7132 struct bp_location
**next
= &bp_location_chain
;
7133 struct bp_location
*loc
;
7134 struct bp_location
*loc2
;
7135 VEC(bp_location_p
) *old_locations
= NULL
;
7138 struct cleanup
*cleanups
;
7140 cleanups
= make_cleanup (do_vec_free
, &old_locations
);
7141 /* Store old locations for future reference. */
7142 for (loc
= bp_location_chain
; loc
; loc
= loc
->global_next
)
7143 VEC_safe_push (bp_location_p
, old_locations
, loc
);
7145 bp_location_chain
= NULL
;
7148 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
7151 next
= &(loc
->global_next
);
7156 /* Identify bp_location instances that are no longer present in the new
7157 list, and therefore should be freed. Note that it's not necessary that
7158 those locations should be removed from inferior -- if there's another
7159 location at the same address (previously marked as duplicate),
7160 we don't need to remove/insert the location. */
7161 for (ix
= 0; VEC_iterate(bp_location_p
, old_locations
, ix
, loc
); ++ix
)
7163 /* Tells if 'loc' is found amoung the new locations. If not, we
7165 int found_object
= 0;
7166 /* Tells if the location should remain inserted in the target. */
7167 int keep_in_target
= 0;
7169 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7176 /* If this location is no longer present, and inserted, look if there's
7177 maybe a new location at the same address. If so, mark that one
7178 inserted, and don't remove this one. This is needed so that we
7179 don't have a time window where a breakpoint at certain location is not
7184 /* If the location is inserted now, we might have to remove it. */
7186 if (found_object
&& should_be_inserted (loc
))
7188 /* The location is still present in the location list, and still
7189 should be inserted. Don't do anything. */
7194 /* The location is either no longer present, or got disabled.
7195 See if there's another location at the same address, in which
7196 case we don't need to remove this one from the target. */
7197 if (breakpoint_address_is_meaningful (loc
->owner
))
7198 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7200 /* For the sake of should_insert_location. The
7201 call to check_duplicates will fix up this later. */
7202 loc2
->duplicate
= 0;
7203 if (should_be_inserted (loc2
)
7204 && loc2
!= loc
&& loc2
->address
== loc
->address
)
7207 loc2
->target_info
= loc
->target_info
;
7214 if (!keep_in_target
)
7216 if (remove_breakpoint (loc
, mark_uninserted
))
7218 /* This is just about all we can do. We could keep this
7219 location on the global list, and try to remove it next
7220 time, but there's no particular reason why we will
7223 Note that at this point, loc->owner is still valid,
7224 as delete_breakpoint frees the breakpoint only
7225 after calling us. */
7226 printf_filtered (_("warning: Error removing breakpoint %d\n"),
7227 loc
->owner
->number
);
7235 if (removed
&& non_stop
)
7237 /* This location was removed from the targets. In non-stop mode,
7238 a race condition is possible where we've removed a breakpoint,
7239 but stop events for that breakpoint are already queued and will
7240 arrive later. To suppress spurious SIGTRAPs reported to user,
7241 we keep this breakpoint location for a bit, and will retire it
7242 after we see 3 * thread_count events.
7243 The theory here is that reporting of events should,
7244 "on the average", be fair, so after that many event we'll see
7245 events from all threads that have anything of interest, and no
7246 longer need to keep this breakpoint. This is just a
7247 heuristic, but if it's wrong, we'll report unexpected SIGTRAP,
7248 which is usability issue, but not a correctness problem. */
7249 loc
->events_till_retirement
= 3 * (thread_count () + 1);
7252 VEC_safe_push (bp_location_p
, moribund_locations
, loc
);
7255 free_bp_location (loc
);
7261 check_duplicates (b
);
7264 if (breakpoints_always_inserted_mode () && should_insert
7265 && (have_live_inferiors ()
7266 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
7267 insert_breakpoint_locations ();
7269 do_cleanups (cleanups
);
7273 breakpoint_retire_moribund (void)
7275 struct bp_location
*loc
;
7278 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
7279 if (--(loc
->events_till_retirement
) == 0)
7281 free_bp_location (loc
);
7282 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
7288 update_global_location_list_nothrow (int inserting
)
7290 struct gdb_exception e
;
7291 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7292 update_global_location_list (inserting
);
7295 /* Clear BPT from a BPS. */
7297 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
7300 for (bs
= bps
; bs
; bs
= bs
->next
)
7301 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7303 bs
->breakpoint_at
= NULL
;
7305 /* bs->commands will be freed later. */
7309 /* Callback for iterate_over_threads. */
7311 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
7313 struct breakpoint
*bpt
= data
;
7314 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
7318 /* Delete a breakpoint and clean up all traces of it in the data
7322 delete_breakpoint (struct breakpoint
*bpt
)
7324 struct breakpoint
*b
;
7325 struct bp_location
*loc
, *next
;
7327 gdb_assert (bpt
!= NULL
);
7329 /* Has this bp already been deleted? This can happen because multiple
7330 lists can hold pointers to bp's. bpstat lists are especial culprits.
7332 One example of this happening is a watchpoint's scope bp. When the
7333 scope bp triggers, we notice that the watchpoint is out of scope, and
7334 delete it. We also delete its scope bp. But the scope bp is marked
7335 "auto-deleting", and is already on a bpstat. That bpstat is then
7336 checked for auto-deleting bp's, which are deleted.
7338 A real solution to this problem might involve reference counts in bp's,
7339 and/or giving them pointers back to their referencing bpstat's, and
7340 teaching delete_breakpoint to only free a bp's storage when no more
7341 references were extent. A cheaper bandaid was chosen. */
7342 if (bpt
->type
== bp_none
)
7345 observer_notify_breakpoint_deleted (bpt
->number
);
7347 if (breakpoint_chain
== bpt
)
7348 breakpoint_chain
= bpt
->next
;
7353 b
->next
= bpt
->next
;
7357 free_command_lines (&bpt
->commands
);
7358 if (bpt
->cond_string
!= NULL
)
7359 xfree (bpt
->cond_string
);
7360 if (bpt
->addr_string
!= NULL
)
7361 xfree (bpt
->addr_string
);
7362 if (bpt
->exp
!= NULL
)
7364 if (bpt
->exp_string
!= NULL
)
7365 xfree (bpt
->exp_string
);
7366 if (bpt
->val
!= NULL
)
7367 value_free (bpt
->val
);
7368 if (bpt
->source_file
!= NULL
)
7369 xfree (bpt
->source_file
);
7370 if (bpt
->exec_pathname
!= NULL
)
7371 xfree (bpt
->exec_pathname
);
7373 /* Be sure no bpstat's are pointing at it after it's been freed. */
7374 /* FIXME, how can we find all bpstat's?
7375 We just check stop_bpstat for now. Note that we cannot just
7376 remove bpstats pointing at bpt from the stop_bpstat list
7377 entirely, as breakpoint commands are associated with the bpstat;
7378 if we remove it here, then the later call to
7379 bpstat_do_actions (&stop_bpstat);
7380 in event-top.c won't do anything, and temporary breakpoints
7381 with commands won't work. */
7383 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
7385 /* Now that breakpoint is removed from breakpoint
7386 list, update the global location list. This
7387 will remove locations that used to belong to
7388 this breakpoint. Do this before freeing
7389 the breakpoint itself, since remove_breakpoint
7390 looks at location's owner. It might be better
7391 design to have location completely self-contained,
7392 but it's not the case now. */
7393 update_global_location_list (0);
7396 /* On the chance that someone will soon try again to delete this same
7397 bp, we mark it as deleted before freeing its storage. */
7398 bpt
->type
= bp_none
;
7404 do_delete_breakpoint_cleanup (void *b
)
7406 delete_breakpoint (b
);
7410 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7412 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7416 delete_command (char *arg
, int from_tty
)
7418 struct breakpoint
*b
, *temp
;
7424 int breaks_to_delete
= 0;
7426 /* Delete all breakpoints if no argument.
7427 Do not delete internal or call-dummy breakpoints, these
7428 have to be deleted with an explicit breakpoint number argument. */
7431 if (b
->type
!= bp_call_dummy
7432 && b
->type
!= bp_shlib_event
7433 && b
->type
!= bp_thread_event
7434 && b
->type
!= bp_overlay_event
7437 breaks_to_delete
= 1;
7442 /* Ask user only if there are some breakpoints to delete. */
7444 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7446 ALL_BREAKPOINTS_SAFE (b
, temp
)
7448 if (b
->type
!= bp_call_dummy
7449 && b
->type
!= bp_shlib_event
7450 && b
->type
!= bp_thread_event
7451 && b
->type
!= bp_overlay_event
7453 delete_breakpoint (b
);
7458 map_breakpoint_numbers (arg
, delete_breakpoint
);
7462 all_locations_are_pending (struct bp_location
*loc
)
7464 for (; loc
; loc
= loc
->next
)
7465 if (!loc
->shlib_disabled
)
7470 /* Subroutine of update_breakpoint_locations to simplify it.
7471 Return non-zero if multiple fns in list LOC have the same name.
7472 Null names are ignored. */
7475 ambiguous_names_p (struct bp_location
*loc
)
7477 struct bp_location
*l
;
7478 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7479 (int (*) (const void *, const void *)) streq
,
7480 NULL
, xcalloc
, xfree
);
7482 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7485 const char *name
= l
->function_name
;
7487 /* Allow for some names to be NULL, ignore them. */
7491 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7493 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7508 update_breakpoint_locations (struct breakpoint
*b
,
7509 struct symtabs_and_lines sals
)
7513 struct bp_location
*existing_locations
= b
->loc
;
7515 /* If there's no new locations, and all existing locations
7516 are pending, don't do anything. This optimizes
7517 the common case where all locations are in the same
7518 shared library, that was unloaded. We'd like to
7519 retain the location, so that when the library
7520 is loaded again, we don't loose the enabled/disabled
7521 status of the individual locations. */
7522 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7527 for (i
= 0; i
< sals
.nelts
; ++i
)
7529 struct bp_location
*new_loc
=
7530 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
7532 /* Reparse conditions, they might contain references to the
7534 if (b
->cond_string
!= NULL
)
7536 struct gdb_exception e
;
7539 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7541 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7546 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7547 b
->number
, e
.message
);
7548 new_loc
->enabled
= 0;
7552 if (b
->source_file
!= NULL
)
7553 xfree (b
->source_file
);
7554 if (sals
.sals
[i
].symtab
== NULL
)
7555 b
->source_file
= NULL
;
7557 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
7559 if (b
->line_number
== 0)
7560 b
->line_number
= sals
.sals
[i
].line
;
7563 /* Update locations of permanent breakpoints. */
7564 if (b
->enable_state
== bp_permanent
)
7565 make_breakpoint_permanent (b
);
7567 /* If possible, carry over 'disable' status from existing breakpoints. */
7569 struct bp_location
*e
= existing_locations
;
7570 /* If there are multiple breakpoints with the same function name,
7571 e.g. for inline functions, comparing function names won't work.
7572 Instead compare pc addresses; this is just a heuristic as things
7573 may have moved, but in practice it gives the correct answer
7574 often enough until a better solution is found. */
7575 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7577 for (; e
; e
= e
->next
)
7579 if (!e
->enabled
&& e
->function_name
)
7581 struct bp_location
*l
= b
->loc
;
7582 if (have_ambiguous_names
)
7584 for (; l
; l
= l
->next
)
7585 if (e
->address
== l
->address
)
7593 for (; l
; l
= l
->next
)
7594 if (l
->function_name
7595 && strcmp (e
->function_name
, l
->function_name
) == 0)
7605 update_global_location_list (1);
7609 /* Reset a breakpoint given it's struct breakpoint * BINT.
7610 The value we return ends up being the return value from catch_errors.
7611 Unused in this case. */
7614 breakpoint_re_set_one (void *bint
)
7616 /* get past catch_errs */
7617 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7621 int *not_found_ptr
= ¬_found
;
7622 struct symtabs_and_lines sals
= {};
7623 struct symtabs_and_lines expanded
;
7625 enum enable_state save_enable
;
7626 struct gdb_exception e
;
7627 struct cleanup
*cleanups
;
7632 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7636 case bp_hardware_breakpoint
:
7638 if (b
->addr_string
== NULL
)
7640 /* Anything without a string can't be re-set. */
7641 delete_breakpoint (b
);
7645 set_language (b
->language
);
7646 input_radix
= b
->input_radix
;
7648 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7650 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7655 int not_found_and_ok
= 0;
7656 /* For pending breakpoints, it's expected that parsing
7657 will fail until the right shared library is loaded.
7658 User has already told to create pending breakpoints and
7659 don't need extra messages. If breakpoint is in bp_shlib_disabled
7660 state, then user already saw the message about that breakpoint
7661 being disabled, and don't want to see more errors. */
7663 && (b
->condition_not_parsed
7664 || (b
->loc
&& b
->loc
->shlib_disabled
)
7665 || b
->enable_state
== bp_disabled
))
7666 not_found_and_ok
= 1;
7668 if (!not_found_and_ok
)
7670 /* We surely don't want to warn about the same breakpoint
7671 10 times. One solution, implemented here, is disable
7672 the breakpoint on error. Another solution would be to
7673 have separate 'warning emitted' flag. Since this
7674 happens only when a binary has changed, I don't know
7675 which approach is better. */
7676 b
->enable_state
= bp_disabled
;
7677 throw_exception (e
);
7684 gdb_assert (sals
.nelts
== 1);
7685 resolve_sal_pc (&sals
.sals
[0]);
7686 if (b
->condition_not_parsed
&& s
&& s
[0])
7688 char *cond_string
= 0;
7692 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7693 &cond_string
, &thread
, &task
);
7695 b
->cond_string
= cond_string
;
7698 b
->condition_not_parsed
= 0;
7700 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7701 cleanups
= make_cleanup (xfree
, sals
.sals
);
7702 update_breakpoint_locations (b
, expanded
);
7703 do_cleanups (cleanups
);
7707 case bp_hardware_watchpoint
:
7708 case bp_read_watchpoint
:
7709 case bp_access_watchpoint
:
7710 /* Watchpoint can be either on expression using entirely global variables,
7711 or it can be on local variables.
7713 Watchpoints of the first kind are never auto-deleted, and even persist
7714 across program restarts. Since they can use variables from shared
7715 libraries, we need to reparse expression as libraries are loaded
7718 Watchpoints on local variables can also change meaning as result
7719 of solib event. For example, if a watchpoint uses both a local and
7720 a global variables in expression, it's a local watchpoint, but
7721 unloading of a shared library will make the expression invalid.
7722 This is not a very common use case, but we still re-evaluate
7723 expression, to avoid surprises to the user.
7725 Note that for local watchpoints, we re-evaluate it only if
7726 watchpoints frame id is still valid. If it's not, it means
7727 the watchpoint is out of scope and will be deleted soon. In fact,
7728 I'm not sure we'll ever be called in this case.
7730 If a local watchpoint's frame id is still valid, then
7731 b->exp_valid_block is likewise valid, and we can safely use it.
7733 Don't do anything about disabled watchpoints, since they will
7734 be reevaluated again when enabled. */
7735 update_watchpoint (b
, 1 /* reparse */);
7737 /* We needn't really do anything to reset these, since the mask
7738 that requests them is unaffected by e.g., new libraries being
7744 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7746 /* Delete overlay event breakpoints; they will be reset later by
7747 breakpoint_re_set. */
7748 case bp_overlay_event
:
7749 delete_breakpoint (b
);
7752 /* This breakpoint is special, it's set up when the inferior
7753 starts and we really don't want to touch it. */
7754 case bp_shlib_event
:
7756 /* Like bp_shlib_event, this breakpoint type is special.
7757 Once it is set up, we do not want to touch it. */
7758 case bp_thread_event
:
7760 /* Keep temporary breakpoints, which can be encountered when we step
7761 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7762 Otherwise these should have been blown away via the cleanup chain
7763 or by breakpoint_init_inferior when we rerun the executable. */
7766 case bp_watchpoint_scope
:
7768 case bp_step_resume
:
7770 case bp_longjmp_resume
:
7777 /* Re-set all breakpoints after symbols have been re-loaded. */
7779 breakpoint_re_set (void)
7781 struct breakpoint
*b
, *temp
;
7782 enum language save_language
;
7783 int save_input_radix
;
7785 save_language
= current_language
->la_language
;
7786 save_input_radix
= input_radix
;
7787 ALL_BREAKPOINTS_SAFE (b
, temp
)
7789 /* Format possible error msg */
7790 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7792 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7793 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7794 do_cleanups (cleanups
);
7796 set_language (save_language
);
7797 input_radix
= save_input_radix
;
7799 create_overlay_event_breakpoint ("_ovly_debug_event");
7802 /* Reset the thread number of this breakpoint:
7804 - If the breakpoint is for all threads, leave it as-is.
7805 - Else, reset it to the current thread for inferior_ptid. */
7807 breakpoint_re_set_thread (struct breakpoint
*b
)
7809 if (b
->thread
!= -1)
7811 if (in_thread_list (inferior_ptid
))
7812 b
->thread
= pid_to_thread_id (inferior_ptid
);
7816 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7817 If from_tty is nonzero, it prints a message to that effect,
7818 which ends with a period (no newline). */
7821 set_ignore_count (int bptnum
, int count
, int from_tty
)
7823 struct breakpoint
*b
;
7829 if (b
->number
== bptnum
)
7831 b
->ignore_count
= count
;
7835 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7837 else if (count
== 1)
7838 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7841 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7844 breakpoints_changed ();
7845 observer_notify_breakpoint_modified (b
->number
);
7849 error (_("No breakpoint number %d."), bptnum
);
7853 make_breakpoint_silent (struct breakpoint
*b
)
7855 /* Silence the breakpoint. */
7859 /* Command to set ignore-count of breakpoint N to COUNT. */
7862 ignore_command (char *args
, int from_tty
)
7868 error_no_arg (_("a breakpoint number"));
7870 num
= get_number (&p
);
7872 error (_("bad breakpoint number: '%s'"), args
);
7874 error (_("Second argument (specified ignore-count) is missing."));
7876 set_ignore_count (num
,
7877 longest_to_int (value_as_long (parse_and_eval (p
))),
7880 printf_filtered ("\n");
7883 /* Call FUNCTION on each of the breakpoints
7884 whose numbers are given in ARGS. */
7887 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7892 struct breakpoint
*b
, *tmp
;
7896 error_no_arg (_("one or more breakpoint numbers"));
7903 num
= get_number_or_range (&p1
);
7906 warning (_("bad breakpoint number at or near '%s'"), p
);
7910 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7911 if (b
->number
== num
)
7913 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7916 if (related_breakpoint
)
7917 function (related_breakpoint
);
7921 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7927 static struct bp_location
*
7928 find_location_by_number (char *number
)
7930 char *dot
= strchr (number
, '.');
7934 struct breakpoint
*b
;
7935 struct bp_location
*loc
;
7940 bp_num
= get_number_or_range (&p1
);
7942 error (_("Bad breakpoint number '%s'"), number
);
7945 if (b
->number
== bp_num
)
7950 if (!b
|| b
->number
!= bp_num
)
7951 error (_("Bad breakpoint number '%s'"), number
);
7954 loc_num
= get_number_or_range (&p1
);
7956 error (_("Bad breakpoint location number '%s'"), number
);
7960 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7963 error (_("Bad breakpoint location number '%s'"), dot
+1);
7969 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7970 If from_tty is nonzero, it prints a message to that effect,
7971 which ends with a period (no newline). */
7974 disable_breakpoint (struct breakpoint
*bpt
)
7976 /* Never disable a watchpoint scope breakpoint; we want to
7977 hit them when we leave scope so we can delete both the
7978 watchpoint and its scope breakpoint at that time. */
7979 if (bpt
->type
== bp_watchpoint_scope
)
7982 /* You can't disable permanent breakpoints. */
7983 if (bpt
->enable_state
== bp_permanent
)
7986 bpt
->enable_state
= bp_disabled
;
7988 update_global_location_list (0);
7990 observer_notify_breakpoint_modified (bpt
->number
);
7994 disable_command (char *args
, int from_tty
)
7996 struct breakpoint
*bpt
;
7998 ALL_BREAKPOINTS (bpt
)
8002 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
8008 case bp_hardware_breakpoint
:
8010 case bp_hardware_watchpoint
:
8011 case bp_read_watchpoint
:
8012 case bp_access_watchpoint
:
8013 disable_breakpoint (bpt
);
8017 else if (strchr (args
, '.'))
8019 struct bp_location
*loc
= find_location_by_number (args
);
8022 update_global_location_list (0);
8025 map_breakpoint_numbers (args
, disable_breakpoint
);
8029 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
8031 int target_resources_ok
, other_type_used
;
8034 if (bpt
->type
== bp_hardware_breakpoint
)
8037 i
= hw_breakpoint_used_count ();
8038 target_resources_ok
=
8039 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8041 if (target_resources_ok
== 0)
8042 error (_("No hardware breakpoint support in the target."));
8043 else if (target_resources_ok
< 0)
8044 error (_("Hardware breakpoints used exceeds limit."));
8047 if (bpt
->type
== bp_watchpoint
8048 || bpt
->type
== bp_hardware_watchpoint
8049 || bpt
->type
== bp_read_watchpoint
8050 || bpt
->type
== bp_access_watchpoint
)
8052 struct gdb_exception e
;
8054 TRY_CATCH (e
, RETURN_MASK_ALL
)
8056 update_watchpoint (bpt
, 1 /* reparse */);
8060 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
8066 if (bpt
->enable_state
!= bp_permanent
)
8067 bpt
->enable_state
= bp_enabled
;
8068 bpt
->disposition
= disposition
;
8069 update_global_location_list (1);
8070 breakpoints_changed ();
8072 observer_notify_breakpoint_modified (bpt
->number
);
8077 enable_breakpoint (struct breakpoint
*bpt
)
8079 do_enable_breakpoint (bpt
, bpt
->disposition
);
8082 /* The enable command enables the specified breakpoints (or all defined
8083 breakpoints) so they once again become (or continue to be) effective
8084 in stopping the inferior. */
8087 enable_command (char *args
, int from_tty
)
8089 struct breakpoint
*bpt
;
8091 ALL_BREAKPOINTS (bpt
)
8095 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
8101 case bp_hardware_breakpoint
:
8103 case bp_hardware_watchpoint
:
8104 case bp_read_watchpoint
:
8105 case bp_access_watchpoint
:
8106 enable_breakpoint (bpt
);
8110 else if (strchr (args
, '.'))
8112 struct bp_location
*loc
= find_location_by_number (args
);
8115 update_global_location_list (1);
8118 map_breakpoint_numbers (args
, enable_breakpoint
);
8122 enable_once_breakpoint (struct breakpoint
*bpt
)
8124 do_enable_breakpoint (bpt
, disp_disable
);
8128 enable_once_command (char *args
, int from_tty
)
8130 map_breakpoint_numbers (args
, enable_once_breakpoint
);
8134 enable_delete_breakpoint (struct breakpoint
*bpt
)
8136 do_enable_breakpoint (bpt
, disp_del
);
8140 enable_delete_command (char *args
, int from_tty
)
8142 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
8146 set_breakpoint_cmd (char *args
, int from_tty
)
8151 show_breakpoint_cmd (char *args
, int from_tty
)
8155 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
8157 struct symtabs_and_lines
8158 decode_line_spec_1 (char *string
, int funfirstline
)
8160 struct symtabs_and_lines sals
;
8162 error (_("Empty line specification."));
8163 if (default_breakpoint_valid
)
8164 sals
= decode_line_1 (&string
, funfirstline
,
8165 default_breakpoint_symtab
,
8166 default_breakpoint_line
,
8167 (char ***) NULL
, NULL
);
8169 sals
= decode_line_1 (&string
, funfirstline
,
8170 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8172 error (_("Junk at end of line specification: %s"), string
);
8176 /* Create and insert a raw software breakpoint at PC. Return an
8177 identifier, which should be used to remove the breakpoint later.
8178 In general, places which call this should be using something on the
8179 breakpoint chain instead; this function should be eliminated
8183 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8185 struct bp_target_info
*bp_tgt
;
8187 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8188 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8190 bp_tgt
->placed_address
= pc
;
8191 if (target_insert_breakpoint (bp_tgt
) != 0)
8193 /* Could not insert the breakpoint. */
8201 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8204 deprecated_remove_raw_breakpoint (void *bp
)
8206 struct bp_target_info
*bp_tgt
= bp
;
8209 ret
= target_remove_breakpoint (bp_tgt
);
8215 /* One (or perhaps two) breakpoints used for software single stepping. */
8217 static void *single_step_breakpoints
[2];
8219 /* Create and insert a breakpoint for software single step. */
8222 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8226 if (single_step_breakpoints
[0] == NULL
)
8227 bpt_p
= &single_step_breakpoints
[0];
8230 gdb_assert (single_step_breakpoints
[1] == NULL
);
8231 bpt_p
= &single_step_breakpoints
[1];
8234 /* NOTE drow/2006-04-11: A future improvement to this function would be
8235 to only create the breakpoints once, and actually put them on the
8236 breakpoint chain. That would let us use set_raw_breakpoint. We could
8237 adjust the addresses each time they were needed. Doing this requires
8238 corresponding changes elsewhere where single step breakpoints are
8239 handled, however. So, for now, we use this. */
8241 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8243 error (_("Could not insert single-step breakpoint at 0x%s"),
8244 paddr_nz (next_pc
));
8247 /* Remove and delete any breakpoints used for software single step. */
8250 remove_single_step_breakpoints (void)
8252 gdb_assert (single_step_breakpoints
[0] != NULL
);
8254 /* See insert_single_step_breakpoint for more about this deprecated
8256 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8257 single_step_breakpoints
[0] = NULL
;
8259 if (single_step_breakpoints
[1] != NULL
)
8261 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8262 single_step_breakpoints
[1] = NULL
;
8266 /* Check whether a software single-step breakpoint is inserted at PC. */
8269 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8273 for (i
= 0; i
< 2; i
++)
8275 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8276 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8283 /* Tracepoint-specific operations. */
8285 /* Set tracepoint count to NUM. */
8287 set_tracepoint_count (int num
)
8289 tracepoint_count
= num
;
8290 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
8294 trace_command (char *arg
, int from_tty
)
8296 break_command_really (arg
,
8297 NULL
, 0, 1 /* parse arg */,
8298 0 /* tempflag */, 0 /* hardwareflag */,
8300 0 /* Ignore count */,
8301 pending_break_support
,
8305 set_tracepoint_count (breakpoint_count
);
8308 /* Print information on tracepoint number TPNUM_EXP, or all if
8312 tracepoints_info (char *tpnum_exp
, int from_tty
)
8314 struct breakpoint
*b
;
8315 int tps_to_list
= 0;
8317 /* In the no-arguments case, say "No tracepoints" if none found. */
8330 ui_out_message (uiout
, 0, "No tracepoints.\n");
8335 /* Otherwise be the same as "info break". */
8336 breakpoints_info (tpnum_exp
, from_tty
);
8339 /* The 'enable trace' command enables tracepoints.
8340 Not supported by all targets. */
8342 enable_trace_command (char *args
, int from_tty
)
8344 enable_command (args
, from_tty
);
8347 /* The 'disable trace' command disables tracepoints.
8348 Not supported by all targets. */
8350 disable_trace_command (char *args
, int from_tty
)
8352 disable_command (args
, from_tty
);
8355 /* Remove a tracepoint (or all if no argument) */
8357 delete_trace_command (char *arg
, int from_tty
)
8359 struct breakpoint
*b
, *temp
;
8365 int breaks_to_delete
= 0;
8367 /* Delete all breakpoints if no argument.
8368 Do not delete internal or call-dummy breakpoints, these
8369 have to be deleted with an explicit breakpoint number argument. */
8374 breaks_to_delete
= 1;
8379 /* Ask user only if there are some breakpoints to delete. */
8381 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
8383 ALL_BREAKPOINTS_SAFE (b
, temp
)
8385 if (b
->type
== bp_tracepoint
8387 delete_breakpoint (b
);
8392 map_breakpoint_numbers (arg
, delete_breakpoint
);
8395 /* Set passcount for tracepoint.
8397 First command argument is passcount, second is tracepoint number.
8398 If tracepoint number omitted, apply to most recently defined.
8399 Also accepts special argument "all". */
8402 trace_pass_command (char *args
, int from_tty
)
8404 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
8408 if (args
== 0 || *args
== 0)
8409 error (_("passcount command requires an argument (count + optional TP num)"));
8411 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
8413 while (*args
&& isspace ((int) *args
))
8416 if (*args
&& strncasecmp (args
, "all", 3) == 0)
8418 args
+= 3; /* Skip special argument "all". */
8421 error (_("Junk at end of arguments."));
8424 t1
= get_tracepoint_by_number (&args
, 1, 1);
8430 ALL_TRACEPOINTS (t2
)
8431 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
8433 t2
->pass_count
= count
;
8434 observer_notify_tracepoint_modified (t2
->number
);
8436 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
8440 t1
= get_tracepoint_by_number (&args
, 1, 0);
8447 get_tracepoint (int num
)
8449 struct breakpoint
*t
;
8452 if (t
->number
== num
)
8458 /* Utility: parse a tracepoint number and look it up in the list.
8459 If MULTI_P is true, there might be a range of tracepoints in ARG.
8460 if OPTIONAL_P is true, then if the argument is missing, the most
8461 recent tracepoint (tracepoint_count) is returned. */
8463 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
8465 extern int tracepoint_count
;
8466 struct breakpoint
*t
;
8468 char *instring
= arg
== NULL
? NULL
: *arg
;
8470 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
8473 tpnum
= tracepoint_count
;
8475 error_no_arg (_("tracepoint number"));
8478 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
8482 if (instring
&& *instring
)
8483 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
8486 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
8491 if (t
->number
== tpnum
)
8496 /* FIXME: if we are in the middle of a range we don't want to give
8497 a message. The current interface to get_number_or_range doesn't
8498 allow us to discover this. */
8499 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
8503 /* save-tracepoints command */
8505 tracepoint_save_command (char *args
, int from_tty
)
8507 struct breakpoint
*tp
;
8509 struct action_line
*line
;
8511 char *i1
= " ", *i2
= " ";
8512 char *indent
, *actionline
, *pathname
;
8514 struct cleanup
*cleanup
;
8516 if (args
== 0 || *args
== 0)
8517 error (_("Argument required (file name in which to save tracepoints)"));
8519 /* See if we have anything to save. */
8520 ALL_TRACEPOINTS (tp
)
8527 warning (_("save-tracepoints: no tracepoints to save."));
8531 pathname
= tilde_expand (args
);
8532 cleanup
= make_cleanup (xfree
, pathname
);
8533 fp
= fopen (pathname
, "w");
8535 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
8536 args
, safe_strerror (errno
));
8537 make_cleanup_fclose (fp
);
8539 ALL_TRACEPOINTS (tp
)
8541 if (tp
->addr_string
)
8542 fprintf (fp
, "trace %s\n", tp
->addr_string
);
8545 sprintf_vma (tmp
, tp
->loc
->address
);
8546 fprintf (fp
, "trace *0x%s\n", tmp
);
8550 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
8554 fprintf (fp
, " actions\n");
8556 for (line
= tp
->actions
; line
; line
= line
->next
)
8558 struct cmd_list_element
*cmd
;
8560 QUIT
; /* allow user to bail out with ^C */
8561 actionline
= line
->action
;
8562 while (isspace ((int) *actionline
))
8565 fprintf (fp
, "%s%s\n", indent
, actionline
);
8566 if (*actionline
!= '#') /* skip for comment lines */
8568 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
8570 error (_("Bad action list item: %s"), actionline
);
8571 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
8573 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
8579 do_cleanups (cleanup
);
8581 printf_filtered (_("Tracepoints saved to file '%s'.\n"), args
);
8585 /* Create a vector of all tracepoints. */
8590 VEC(breakpoint_p
) *tp_vec
= 0;
8591 struct breakpoint
*tp
;
8593 ALL_TRACEPOINTS (tp
)
8595 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
8602 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8603 It is defined as a macro to prevent duplication.
8604 COMMAND should be a string constant containing the name of the command. */
8605 #define BREAK_ARGS_HELP(command) \
8606 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8607 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8608 If a line number is specified, break at start of code for that line.\n\
8609 If a function is specified, break at start of code for that function.\n\
8610 If an address is specified, break at that exact address.\n\
8611 With no LOCATION, uses current execution address of selected stack frame.\n\
8612 This is useful for breaking on return to a stack frame.\n\
8614 THREADNUM is the number from \"info threads\".\n\
8615 CONDITION is a boolean expression.\n\
8617 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8619 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8621 /* List of subcommands for "catch". */
8622 static struct cmd_list_element
*catch_cmdlist
;
8624 /* List of subcommands for "tcatch". */
8625 static struct cmd_list_element
*tcatch_cmdlist
;
8627 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
8628 lists, and pass some additional user data to the command function. */
8630 add_catch_command (char *name
, char *docstring
,
8631 void (*sfunc
) (char *args
, int from_tty
,
8632 struct cmd_list_element
*command
),
8633 void *user_data_catch
,
8634 void *user_data_tcatch
)
8636 struct cmd_list_element
*command
;
8638 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8640 set_cmd_sfunc (command
, sfunc
);
8641 set_cmd_context (command
, user_data_catch
);
8643 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8645 set_cmd_sfunc (command
, sfunc
);
8646 set_cmd_context (command
, user_data_tcatch
);
8650 _initialize_breakpoint (void)
8652 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8653 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8654 struct cmd_list_element
*c
;
8656 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8658 breakpoint_chain
= 0;
8659 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8660 before a breakpoint is set. */
8661 breakpoint_count
= 0;
8663 tracepoint_count
= 0;
8665 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8666 Set ignore-count of breakpoint number N to COUNT.\n\
8667 Usage is `ignore N COUNT'."));
8669 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8671 add_com ("commands", class_breakpoint
, commands_command
, _("\
8672 Set commands to be executed when a breakpoint is hit.\n\
8673 Give breakpoint number as argument after \"commands\".\n\
8674 With no argument, the targeted breakpoint is the last one set.\n\
8675 The commands themselves follow starting on the next line.\n\
8676 Type a line containing \"end\" to indicate the end of them.\n\
8677 Give \"silent\" as the first line to make the breakpoint silent;\n\
8678 then no output is printed when it is hit, except what the commands print."));
8680 add_com ("condition", class_breakpoint
, condition_command
, _("\
8681 Specify breakpoint number N to break only if COND is true.\n\
8682 Usage is `condition N COND', where N is an integer and COND is an\n\
8683 expression to be evaluated whenever breakpoint N is reached."));
8685 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8686 Set a temporary breakpoint.\n\
8687 Like \"break\" except the breakpoint is only temporary,\n\
8688 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8689 by using \"enable delete\" on the breakpoint number.\n\
8691 BREAK_ARGS_HELP ("tbreak")));
8692 set_cmd_completer (c
, location_completer
);
8694 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8695 Set a hardware assisted breakpoint.\n\
8696 Like \"break\" except the breakpoint requires hardware support,\n\
8697 some target hardware may not have this support.\n\
8699 BREAK_ARGS_HELP ("hbreak")));
8700 set_cmd_completer (c
, location_completer
);
8702 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8703 Set a temporary hardware assisted breakpoint.\n\
8704 Like \"hbreak\" except the breakpoint is only temporary,\n\
8705 so it will be deleted when hit.\n\
8707 BREAK_ARGS_HELP ("thbreak")));
8708 set_cmd_completer (c
, location_completer
);
8710 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8711 Enable some breakpoints.\n\
8712 Give breakpoint numbers (separated by spaces) as arguments.\n\
8713 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8714 This is used to cancel the effect of the \"disable\" command.\n\
8715 With a subcommand you can enable temporarily."),
8716 &enablelist
, "enable ", 1, &cmdlist
);
8718 add_com ("ab", class_breakpoint
, enable_command
, _("\
8719 Enable some breakpoints.\n\
8720 Give breakpoint numbers (separated by spaces) as arguments.\n\
8721 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8722 This is used to cancel the effect of the \"disable\" command.\n\
8723 With a subcommand you can enable temporarily."));
8725 add_com_alias ("en", "enable", class_breakpoint
, 1);
8727 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8728 Enable some breakpoints.\n\
8729 Give breakpoint numbers (separated by spaces) as arguments.\n\
8730 This is used to cancel the effect of the \"disable\" command.\n\
8731 May be abbreviated to simply \"enable\".\n"),
8732 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8734 add_cmd ("once", no_class
, enable_once_command
, _("\
8735 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8736 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8739 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8740 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8741 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8744 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8745 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8746 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8749 add_cmd ("once", no_class
, enable_once_command
, _("\
8750 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8751 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8754 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8755 Disable some breakpoints.\n\
8756 Arguments are breakpoint numbers with spaces in between.\n\
8757 To disable all breakpoints, give no argument.\n\
8758 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8759 &disablelist
, "disable ", 1, &cmdlist
);
8760 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8761 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8763 add_com ("sb", class_breakpoint
, disable_command
, _("\
8764 Disable some breakpoints.\n\
8765 Arguments are breakpoint numbers with spaces in between.\n\
8766 To disable all breakpoints, give no argument.\n\
8767 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8769 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8770 Disable some breakpoints.\n\
8771 Arguments are breakpoint numbers with spaces in between.\n\
8772 To disable all breakpoints, give no argument.\n\
8773 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8774 This command may be abbreviated \"disable\"."),
8777 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8778 Delete some breakpoints or auto-display expressions.\n\
8779 Arguments are breakpoint numbers with spaces in between.\n\
8780 To delete all breakpoints, give no argument.\n\
8782 Also a prefix command for deletion of other GDB objects.\n\
8783 The \"unset\" command is also an alias for \"delete\"."),
8784 &deletelist
, "delete ", 1, &cmdlist
);
8785 add_com_alias ("d", "delete", class_breakpoint
, 1);
8786 add_com_alias ("del", "delete", class_breakpoint
, 1);
8788 add_com ("db", class_breakpoint
, delete_command
, _("\
8789 Delete some breakpoints.\n\
8790 Arguments are breakpoint numbers with spaces in between.\n\
8791 To delete all breakpoints, give no argument.\n"));
8793 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8794 Delete some breakpoints or auto-display expressions.\n\
8795 Arguments are breakpoint numbers with spaces in between.\n\
8796 To delete all breakpoints, give no argument.\n\
8797 This command may be abbreviated \"delete\"."),
8800 add_com ("clear", class_breakpoint
, clear_command
, _("\
8801 Clear breakpoint at specified line or function.\n\
8802 Argument may be line number, function name, or \"*\" and an address.\n\
8803 If line number is specified, all breakpoints in that line are cleared.\n\
8804 If function is specified, breakpoints at beginning of function are cleared.\n\
8805 If an address is specified, breakpoints at that address are cleared.\n\
8807 With no argument, clears all breakpoints in the line that the selected frame\n\
8810 See also the \"delete\" command which clears breakpoints by number."));
8812 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8813 Set breakpoint at specified line or function.\n"
8814 BREAK_ARGS_HELP ("break")));
8815 set_cmd_completer (c
, location_completer
);
8817 add_com_alias ("b", "break", class_run
, 1);
8818 add_com_alias ("br", "break", class_run
, 1);
8819 add_com_alias ("bre", "break", class_run
, 1);
8820 add_com_alias ("brea", "break", class_run
, 1);
8823 add_com_alias ("ba", "break", class_breakpoint
, 1);
8827 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8828 Break in function/address or break at a line in the current file."),
8829 &stoplist
, "stop ", 1, &cmdlist
);
8830 add_cmd ("in", class_breakpoint
, stopin_command
,
8831 _("Break in function or address."), &stoplist
);
8832 add_cmd ("at", class_breakpoint
, stopat_command
,
8833 _("Break at a line in the current file."), &stoplist
);
8834 add_com ("status", class_info
, breakpoints_info
, _("\
8835 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8836 The \"Type\" column indicates one of:\n\
8837 \tbreakpoint - normal breakpoint\n\
8838 \twatchpoint - watchpoint\n\
8839 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8840 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8841 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8842 address and file/line number respectively.\n\
8844 Convenience variable \"$_\" and default examine address for \"x\"\n\
8845 are set to the address of the last breakpoint listed unless the command\n\
8846 is prefixed with \"server \".\n\n\
8847 Convenience variable \"$bpnum\" contains the number of the last\n\
8851 add_info ("breakpoints", breakpoints_info
, _("\
8852 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8853 The \"Type\" column indicates one of:\n\
8854 \tbreakpoint - normal breakpoint\n\
8855 \twatchpoint - watchpoint\n\
8856 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8857 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8858 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8859 address and file/line number respectively.\n\
8861 Convenience variable \"$_\" and default examine address for \"x\"\n\
8862 are set to the address of the last breakpoint listed unless the command\n\
8863 is prefixed with \"server \".\n\n\
8864 Convenience variable \"$bpnum\" contains the number of the last\n\
8868 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8869 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8870 The \"Type\" column indicates one of:\n\
8871 \tbreakpoint - normal breakpoint\n\
8872 \twatchpoint - watchpoint\n\
8873 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8874 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8875 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8876 address and file/line number respectively.\n\
8878 Convenience variable \"$_\" and default examine address for \"x\"\n\
8879 are set to the address of the last breakpoint listed unless the command\n\
8880 is prefixed with \"server \".\n\n\
8881 Convenience variable \"$bpnum\" contains the number of the last\n\
8884 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8885 Status of all breakpoints, or breakpoint number NUMBER.\n\
8886 The \"Type\" column indicates one of:\n\
8887 \tbreakpoint - normal breakpoint\n\
8888 \twatchpoint - watchpoint\n\
8889 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8890 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8891 \tuntil - internal breakpoint used by the \"until\" command\n\
8892 \tfinish - internal breakpoint used by the \"finish\" command\n\
8893 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8894 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8895 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8896 address and file/line number respectively.\n\
8898 Convenience variable \"$_\" and default examine address for \"x\"\n\
8899 are set to the address of the last breakpoint listed unless the command\n\
8900 is prefixed with \"server \".\n\n\
8901 Convenience variable \"$bpnum\" contains the number of the last\n\
8903 &maintenanceinfolist
);
8905 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
8906 Set catchpoints to catch events."),
8907 &catch_cmdlist
, "catch ",
8908 0/*allow-unknown*/, &cmdlist
);
8910 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
8911 Set temporary catchpoints to catch events."),
8912 &tcatch_cmdlist
, "tcatch ",
8913 0/*allow-unknown*/, &cmdlist
);
8915 /* Add catch and tcatch sub-commands. */
8916 add_catch_command ("catch", _("\
8917 Catch an exception, when caught.\n\
8918 With an argument, catch only exceptions with the given name."),
8919 catch_catch_command
,
8922 add_catch_command ("throw", _("\
8923 Catch an exception, when thrown.\n\
8924 With an argument, catch only exceptions with the given name."),
8925 catch_throw_command
,
8928 add_catch_command ("fork", _("Catch calls to fork."),
8929 catch_fork_command_1
,
8930 (void *) (uintptr_t) catch_fork_permanent
,
8931 (void *) (uintptr_t) catch_fork_temporary
);
8932 add_catch_command ("vfork", _("Catch calls to vfork."),
8933 catch_fork_command_1
,
8934 (void *) (uintptr_t) catch_vfork_permanent
,
8935 (void *) (uintptr_t) catch_vfork_temporary
);
8936 add_catch_command ("exec", _("Catch calls to exec."),
8937 catch_exec_command_1
,
8940 add_catch_command ("exception", _("\
8941 Catch Ada exceptions, when raised.\n\
8942 With an argument, catch only exceptions with the given name."),
8943 catch_ada_exception_command
,
8946 add_catch_command ("assert", _("\
8947 Catch failed Ada assertions, when raised.\n\
8948 With an argument, catch only exceptions with the given name."),
8949 catch_assert_command
,
8953 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8954 Set a watchpoint for an expression.\n\
8955 A watchpoint stops execution of your program whenever the value of\n\
8956 an expression changes."));
8957 set_cmd_completer (c
, expression_completer
);
8959 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8960 Set a read watchpoint for an expression.\n\
8961 A watchpoint stops execution of your program whenever the value of\n\
8962 an expression is read."));
8963 set_cmd_completer (c
, expression_completer
);
8965 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8966 Set a watchpoint for an expression.\n\
8967 A watchpoint stops execution of your program whenever the value of\n\
8968 an expression is either read or written."));
8969 set_cmd_completer (c
, expression_completer
);
8971 add_info ("watchpoints", breakpoints_info
,
8972 _("Synonym for ``info breakpoints''."));
8975 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8976 respond to changes - contrary to the description. */
8977 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8978 &can_use_hw_watchpoints
, _("\
8979 Set debugger's willingness to use watchpoint hardware."), _("\
8980 Show debugger's willingness to use watchpoint hardware."), _("\
8981 If zero, gdb will not use hardware for new watchpoints, even if\n\
8982 such is available. (However, any hardware watchpoints that were\n\
8983 created before setting this to nonzero, will continue to use watchpoint\n\
8986 show_can_use_hw_watchpoints
,
8987 &setlist
, &showlist
);
8989 can_use_hw_watchpoints
= 1;
8991 /* Tracepoint manipulation commands. */
8993 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
8994 Set a tracepoint at specified line or function.\n\
8996 BREAK_ARGS_HELP ("trace") "\n\
8997 Do \"help tracepoints\" for info on other tracepoint commands."));
8998 set_cmd_completer (c
, location_completer
);
9000 add_com_alias ("tp", "trace", class_alias
, 0);
9001 add_com_alias ("tr", "trace", class_alias
, 1);
9002 add_com_alias ("tra", "trace", class_alias
, 1);
9003 add_com_alias ("trac", "trace", class_alias
, 1);
9005 add_info ("tracepoints", tracepoints_info
, _("\
9006 Status of tracepoints, or tracepoint number NUMBER.\n\
9007 Convenience variable \"$tpnum\" contains the number of the\n\
9008 last tracepoint set."));
9010 add_info_alias ("tp", "tracepoints", 1);
9012 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
9013 Delete specified tracepoints.\n\
9014 Arguments are tracepoint numbers, separated by spaces.\n\
9015 No argument means delete all tracepoints."),
9018 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
9019 Disable specified tracepoints.\n\
9020 Arguments are tracepoint numbers, separated by spaces.\n\
9021 No argument means disable all tracepoints."),
9023 deprecate_cmd (c
, "disable");
9025 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
9026 Enable specified tracepoints.\n\
9027 Arguments are tracepoint numbers, separated by spaces.\n\
9028 No argument means enable all tracepoints."),
9030 deprecate_cmd (c
, "enable");
9032 add_com ("passcount", class_trace
, trace_pass_command
, _("\
9033 Set the passcount for a tracepoint.\n\
9034 The trace will end when the tracepoint has been passed 'count' times.\n\
9035 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
9036 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
9038 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
9039 Save current tracepoint definitions as a script.\n\
9040 Use the 'source' command in another debug session to restore them."));
9041 set_cmd_completer (c
, filename_completer
);
9043 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
9044 Breakpoint specific settings\n\
9045 Configure various breakpoint-specific variables such as\n\
9046 pending breakpoint behavior"),
9047 &breakpoint_set_cmdlist
, "set breakpoint ",
9048 0/*allow-unknown*/, &setlist
);
9049 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
9050 Breakpoint specific settings\n\
9051 Configure various breakpoint-specific variables such as\n\
9052 pending breakpoint behavior"),
9053 &breakpoint_show_cmdlist
, "show breakpoint ",
9054 0/*allow-unknown*/, &showlist
);
9056 add_setshow_auto_boolean_cmd ("pending", no_class
,
9057 &pending_break_support
, _("\
9058 Set debugger's behavior regarding pending breakpoints."), _("\
9059 Show debugger's behavior regarding pending breakpoints."), _("\
9060 If on, an unrecognized breakpoint location will cause gdb to create a\n\
9061 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
9062 an error. If auto, an unrecognized breakpoint location results in a\n\
9063 user-query to see if a pending breakpoint should be created."),
9065 show_pending_break_support
,
9066 &breakpoint_set_cmdlist
,
9067 &breakpoint_show_cmdlist
);
9069 pending_break_support
= AUTO_BOOLEAN_AUTO
;
9071 add_setshow_boolean_cmd ("auto-hw", no_class
,
9072 &automatic_hardware_breakpoints
, _("\
9073 Set automatic usage of hardware breakpoints."), _("\
9074 Show automatic usage of hardware breakpoints."), _("\
9075 If set, the debugger will automatically use hardware breakpoints for\n\
9076 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
9077 a warning will be emitted for such breakpoints."),
9079 show_automatic_hardware_breakpoints
,
9080 &breakpoint_set_cmdlist
,
9081 &breakpoint_show_cmdlist
);
9083 add_setshow_enum_cmd ("always-inserted", class_support
,
9084 always_inserted_enums
, &always_inserted_mode
, _("\
9085 Set mode for inserting breakpoints."), _("\
9086 Show mode for inserting breakpoints."), _("\
9087 When this mode is off, breakpoints are inserted in inferior when it is\n\
9088 resumed, and removed when execution stops. When this mode is on,\n\
9089 breakpoints are inserted immediately and removed only when the user\n\
9090 deletes the breakpoint. When this mode is auto (which is the default),\n\
9091 the behaviour depends on the non-stop setting (see help set non-stop).\n\
9092 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
9093 behaves as if always-inserted mode is on; if gdb is controlling the\n\
9094 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
9096 &show_always_inserted_mode
,
9097 &breakpoint_set_cmdlist
,
9098 &breakpoint_show_cmdlist
);
9100 automatic_hardware_breakpoints
= 1;
9102 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);