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
, struct objfile
*objfile
)
1481 struct breakpoint
*b
;
1482 struct minimal_symbol
*m
;
1484 m
= lookup_minimal_symbol_text (func_name
, objfile
);
1488 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
1490 b
->addr_string
= xstrdup (func_name
);
1492 if (overlay_debugging
== ovly_auto
)
1494 b
->enable_state
= bp_enabled
;
1495 overlay_events_enabled
= 1;
1499 b
->enable_state
= bp_disabled
;
1500 overlay_events_enabled
= 0;
1502 update_global_location_list (1);
1506 update_breakpoints_after_exec (void)
1508 struct breakpoint
*b
;
1509 struct breakpoint
*temp
;
1510 struct bp_location
*bploc
;
1511 struct objfile
*objfile
;
1513 /* We're about to delete breakpoints from GDB's lists. If the
1514 INSERTED flag is true, GDB will try to lift the breakpoints by
1515 writing the breakpoints' "shadow contents" back into memory. The
1516 "shadow contents" are NOT valid after an exec, so GDB should not
1517 do that. Instead, the target is responsible from marking
1518 breakpoints out as soon as it detects an exec. We don't do that
1519 here instead, because there may be other attempts to delete
1520 breakpoints after detecting an exec and before reaching here. */
1521 ALL_BP_LOCATIONS (bploc
)
1522 gdb_assert (!bploc
->inserted
);
1524 ALL_BREAKPOINTS_SAFE (b
, temp
)
1526 /* Solib breakpoints must be explicitly reset after an exec(). */
1527 if (b
->type
== bp_shlib_event
)
1529 delete_breakpoint (b
);
1533 /* Thread event breakpoints must be set anew after an exec(),
1534 as must overlay event breakpoints. */
1535 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1537 delete_breakpoint (b
);
1541 /* Step-resume breakpoints are meaningless after an exec(). */
1542 if (b
->type
== bp_step_resume
)
1544 delete_breakpoint (b
);
1548 /* Longjmp and longjmp-resume breakpoints are also meaningless
1550 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
1552 delete_breakpoint (b
);
1556 if (b
->type
== bp_catchpoint
)
1558 /* For now, none of the bp_catchpoint breakpoints need to
1559 do anything at this point. In the future, if some of
1560 the catchpoints need to something, we will need to add
1561 a new method, and call this method from here. */
1565 /* bp_finish is a special case. The only way we ought to be able
1566 to see one of these when an exec() has happened, is if the user
1567 caught a vfork, and then said "finish". Ordinarily a finish just
1568 carries them to the call-site of the current callee, by setting
1569 a temporary bp there and resuming. But in this case, the finish
1570 will carry them entirely through the vfork & exec.
1572 We don't want to allow a bp_finish to remain inserted now. But
1573 we can't safely delete it, 'cause finish_command has a handle to
1574 the bp on a bpstat, and will later want to delete it. There's a
1575 chance (and I've seen it happen) that if we delete the bp_finish
1576 here, that its storage will get reused by the time finish_command
1577 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1578 We really must allow finish_command to delete a bp_finish.
1580 In the absense of a general solution for the "how do we know
1581 it's safe to delete something others may have handles to?"
1582 problem, what we'll do here is just uninsert the bp_finish, and
1583 let finish_command delete it.
1585 (We know the bp_finish is "doomed" in the sense that it's
1586 momentary, and will be deleted as soon as finish_command sees
1587 the inferior stopped. So it doesn't matter that the bp's
1588 address is probably bogus in the new a.out, unlike e.g., the
1589 solib breakpoints.) */
1591 if (b
->type
== bp_finish
)
1596 /* Without a symbolic address, we have little hope of the
1597 pre-exec() address meaning the same thing in the post-exec()
1599 if (b
->addr_string
== NULL
)
1601 delete_breakpoint (b
);
1605 /* FIXME what about longjmp breakpoints? Re-create them here? */
1606 ALL_OBJFILES (objfile
)
1607 create_overlay_event_breakpoint ("_ovly_debug_event", objfile
);
1611 detach_breakpoints (int pid
)
1613 struct bp_location
*b
;
1615 struct cleanup
*old_chain
= save_inferior_ptid ();
1617 if (pid
== PIDGET (inferior_ptid
))
1618 error (_("Cannot detach breakpoints of inferior_ptid"));
1620 /* Set inferior_ptid; remove_breakpoint uses this global. */
1621 inferior_ptid
= pid_to_ptid (pid
);
1622 ALL_BP_LOCATIONS (b
)
1626 val
= remove_breakpoint (b
, mark_inserted
);
1629 do_cleanups (old_chain
);
1634 do_cleanups (old_chain
);
1639 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1643 if (b
->owner
->enable_state
== bp_permanent
)
1644 /* Permanent breakpoints cannot be inserted or removed. */
1647 /* The type of none suggests that owner is actually deleted.
1648 This should not ever happen. */
1649 gdb_assert (b
->owner
->type
!= bp_none
);
1651 if (b
->loc_type
== bp_loc_software_breakpoint
1652 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1654 /* "Normal" instruction breakpoint: either the standard
1655 trap-instruction bp (bp_breakpoint), or a
1656 bp_hardware_breakpoint. */
1658 /* First check to see if we have to handle an overlay. */
1659 if (overlay_debugging
== ovly_off
1660 || b
->section
== NULL
1661 || !(section_is_overlay (b
->section
)))
1663 /* No overlay handling: just remove the breakpoint. */
1665 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1666 val
= target_remove_hw_breakpoint (&b
->target_info
);
1668 val
= target_remove_breakpoint (&b
->target_info
);
1672 /* This breakpoint is in an overlay section.
1673 Did we set a breakpoint at the LMA? */
1674 if (!overlay_events_enabled
)
1676 /* Yes -- overlay event support is not active, so we
1677 should have set a breakpoint at the LMA. Remove it.
1679 /* Ignore any failures: if the LMA is in ROM, we will
1680 have already warned when we failed to insert it. */
1681 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1682 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1684 target_remove_breakpoint (&b
->overlay_target_info
);
1686 /* Did we set a breakpoint at the VMA?
1687 If so, we will have marked the breakpoint 'inserted'. */
1690 /* Yes -- remove it. Previously we did not bother to
1691 remove the breakpoint if the section had been
1692 unmapped, but let's not rely on that being safe. We
1693 don't know what the overlay manager might do. */
1694 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1695 val
= target_remove_hw_breakpoint (&b
->target_info
);
1697 /* However, we should remove *software* breakpoints only
1698 if the section is still mapped, or else we overwrite
1699 wrong code with the saved shadow contents. */
1700 else if (section_is_mapped (b
->section
))
1701 val
= target_remove_breakpoint (&b
->target_info
);
1707 /* No -- not inserted, so no need to remove. No error. */
1712 /* In some cases, we might not be able to remove a breakpoint
1713 in a shared library that has already been removed, but we
1714 have not yet processed the shlib unload event. */
1715 if (val
&& solib_name_from_address (b
->address
))
1720 b
->inserted
= (is
== mark_inserted
);
1722 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1727 b
->inserted
= (is
== mark_inserted
);
1728 val
= target_remove_watchpoint (b
->address
, b
->length
,
1729 b
->watchpoint_type
);
1731 /* Failure to remove any of the hardware watchpoints comes here. */
1732 if ((is
== mark_uninserted
) && (b
->inserted
))
1733 warning (_("Could not remove hardware watchpoint %d."),
1736 else if (b
->owner
->type
== bp_catchpoint
1737 && breakpoint_enabled (b
->owner
)
1740 gdb_assert (b
->owner
->ops
!= NULL
&& b
->owner
->ops
->remove
!= NULL
);
1742 val
= b
->owner
->ops
->remove (b
->owner
);
1745 b
->inserted
= (is
== mark_inserted
);
1751 /* Clear the "inserted" flag in all breakpoints. */
1754 mark_breakpoints_out (void)
1756 struct bp_location
*bpt
;
1758 ALL_BP_LOCATIONS (bpt
)
1762 /* Clear the "inserted" flag in all breakpoints and delete any
1763 breakpoints which should go away between runs of the program.
1765 Plus other such housekeeping that has to be done for breakpoints
1768 Note: this function gets called at the end of a run (by
1769 generic_mourn_inferior) and when a run begins (by
1770 init_wait_for_inferior). */
1775 breakpoint_init_inferior (enum inf_context context
)
1777 struct breakpoint
*b
, *temp
;
1778 struct bp_location
*bpt
;
1781 /* If breakpoint locations are shared across processes, then there's
1783 if (gdbarch_has_global_breakpoints (target_gdbarch
))
1786 ALL_BP_LOCATIONS (bpt
)
1787 if (bpt
->owner
->enable_state
!= bp_permanent
)
1790 ALL_BREAKPOINTS_SAFE (b
, temp
)
1795 case bp_watchpoint_scope
:
1797 /* If the call dummy breakpoint is at the entry point it will
1798 cause problems when the inferior is rerun, so we better
1801 Also get rid of scope breakpoints. */
1802 delete_breakpoint (b
);
1806 case bp_hardware_watchpoint
:
1807 case bp_read_watchpoint
:
1808 case bp_access_watchpoint
:
1810 /* Likewise for watchpoints on local expressions. */
1811 if (b
->exp_valid_block
!= NULL
)
1812 delete_breakpoint (b
);
1813 else if (context
== inf_starting
)
1815 /* Reset val field to force reread of starting value
1816 in insert_breakpoints. */
1818 value_free (b
->val
);
1828 /* Get rid of the moribund locations. */
1829 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bpt
); ++ix
)
1830 free_bp_location (bpt
);
1831 VEC_free (bp_location_p
, moribund_locations
);
1834 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1835 exists at PC. It returns ordinary_breakpoint_here if it's an
1836 ordinary breakpoint, or permanent_breakpoint_here if it's a
1837 permanent breakpoint.
1838 - When continuing from a location with an ordinary breakpoint, we
1839 actually single step once before calling insert_breakpoints.
1840 - When continuing from a localion with a permanent breakpoint, we
1841 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1842 the target, to advance the PC past the breakpoint. */
1844 enum breakpoint_here
1845 breakpoint_here_p (CORE_ADDR pc
)
1847 const struct bp_location
*bpt
;
1848 int any_breakpoint_here
= 0;
1850 ALL_BP_LOCATIONS (bpt
)
1852 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1853 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1856 if ((breakpoint_enabled (bpt
->owner
)
1857 || bpt
->owner
->enable_state
== bp_permanent
)
1858 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1860 if (overlay_debugging
1861 && section_is_overlay (bpt
->section
)
1862 && !section_is_mapped (bpt
->section
))
1863 continue; /* unmapped overlay -- can't be a match */
1864 else if (bpt
->owner
->enable_state
== bp_permanent
)
1865 return permanent_breakpoint_here
;
1867 any_breakpoint_here
= 1;
1871 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1874 /* Return true if there's a moribund breakpoint at PC. */
1877 moribund_breakpoint_here_p (CORE_ADDR pc
)
1879 struct bp_location
*loc
;
1882 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
1883 if (loc
->address
== pc
)
1889 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1890 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1891 This does not check for single-step breakpoints, which are
1892 inserted and removed using direct target manipulation. */
1895 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1897 const struct bp_location
*bpt
;
1899 ALL_BP_LOCATIONS (bpt
)
1901 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1902 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1906 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1908 if (overlay_debugging
1909 && section_is_overlay (bpt
->section
)
1910 && !section_is_mapped (bpt
->section
))
1911 continue; /* unmapped overlay -- can't be a match */
1919 /* Returns non-zero iff there's either regular breakpoint
1920 or a single step breakpoint inserted at PC. */
1923 breakpoint_inserted_here_p (CORE_ADDR pc
)
1925 if (regular_breakpoint_inserted_here_p (pc
))
1928 if (single_step_breakpoint_inserted_here_p (pc
))
1934 /* This function returns non-zero iff there is a software breakpoint
1938 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1940 const struct bp_location
*bpt
;
1941 int any_breakpoint_here
= 0;
1943 ALL_BP_LOCATIONS (bpt
)
1945 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1949 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1951 if (overlay_debugging
1952 && section_is_overlay (bpt
->section
)
1953 && !section_is_mapped (bpt
->section
))
1954 continue; /* unmapped overlay -- can't be a match */
1960 /* Also check for software single-step breakpoints. */
1961 if (single_step_breakpoint_inserted_here_p (pc
))
1967 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1968 PC is valid for process/thread PTID. */
1971 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1973 const struct bp_location
*bpt
;
1974 /* The thread and task IDs associated to PTID, computed lazily. */
1978 ALL_BP_LOCATIONS (bpt
)
1980 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1981 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1984 if (!breakpoint_enabled (bpt
->owner
)
1985 && bpt
->owner
->enable_state
!= bp_permanent
)
1988 if (bpt
->address
!= pc
)
1991 if (bpt
->owner
->thread
!= -1)
1993 /* This is a thread-specific breakpoint. Check that ptid
1994 matches that thread. If thread hasn't been computed yet,
1995 it is now time to do so. */
1997 thread
= pid_to_thread_id (ptid
);
1998 if (bpt
->owner
->thread
!= thread
)
2002 if (bpt
->owner
->task
!= 0)
2004 /* This is a task-specific breakpoint. Check that ptid
2005 matches that task. If task hasn't been computed yet,
2006 it is now time to do so. */
2008 task
= ada_get_task_number (ptid
);
2009 if (bpt
->owner
->task
!= task
)
2013 if (overlay_debugging
2014 && section_is_overlay (bpt
->section
)
2015 && !section_is_mapped (bpt
->section
))
2016 continue; /* unmapped overlay -- can't be a match */
2025 /* bpstat stuff. External routines' interfaces are documented
2029 ep_is_catchpoint (struct breakpoint
*ep
)
2031 return (ep
->type
== bp_catchpoint
);
2035 bpstat_free (bpstat bs
)
2037 if (bs
->old_val
!= NULL
)
2038 value_free (bs
->old_val
);
2039 free_command_lines (&bs
->commands
);
2043 /* Clear a bpstat so that it says we are not at any breakpoint.
2044 Also free any storage that is part of a bpstat. */
2047 bpstat_clear (bpstat
*bsp
)
2064 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
2065 is part of the bpstat is copied as well. */
2068 bpstat_copy (bpstat bs
)
2072 bpstat retval
= NULL
;
2077 for (; bs
!= NULL
; bs
= bs
->next
)
2079 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
2080 memcpy (tmp
, bs
, sizeof (*tmp
));
2081 if (bs
->commands
!= NULL
)
2082 tmp
->commands
= copy_command_lines (bs
->commands
);
2083 if (bs
->old_val
!= NULL
)
2085 tmp
->old_val
= value_copy (bs
->old_val
);
2086 release_value (tmp
->old_val
);
2090 /* This is the first thing in the chain. */
2100 /* Find the bpstat associated with this breakpoint */
2103 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2108 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2110 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2116 /* Find a step_resume breakpoint associated with this bpstat.
2117 (If there are multiple step_resume bp's on the list, this function
2118 will arbitrarily pick one.)
2120 It is an error to use this function if BPSTAT doesn't contain a
2121 step_resume breakpoint.
2123 See wait_for_inferior's use of this function. */
2125 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2129 gdb_assert (bsp
!= NULL
);
2131 current_thread
= pid_to_thread_id (inferior_ptid
);
2133 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2135 if ((bsp
->breakpoint_at
!= NULL
)
2136 && (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
)
2137 && (bsp
->breakpoint_at
->owner
->thread
== current_thread
2138 || bsp
->breakpoint_at
->owner
->thread
== -1))
2139 return bsp
->breakpoint_at
->owner
;
2142 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2146 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2147 at. *BSP upon return is a bpstat which points to the remaining
2148 breakpoints stopped at (but which is not guaranteed to be good for
2149 anything but further calls to bpstat_num).
2150 Return 0 if passed a bpstat which does not indicate any breakpoints.
2151 Return -1 if stopped at a breakpoint that has been deleted since
2153 Return 1 otherwise. */
2156 bpstat_num (bpstat
*bsp
, int *num
)
2158 struct breakpoint
*b
;
2161 return 0; /* No more breakpoint values */
2163 /* We assume we'll never have several bpstats that
2164 correspond to a single breakpoint -- otherwise,
2165 this function might return the same number more
2166 than once and this will look ugly. */
2167 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2168 *bsp
= (*bsp
)->next
;
2170 return -1; /* breakpoint that's been deleted since */
2172 *num
= b
->number
; /* We have its number */
2176 /* Modify BS so that the actions will not be performed. */
2179 bpstat_clear_actions (bpstat bs
)
2181 for (; bs
!= NULL
; bs
= bs
->next
)
2183 free_command_lines (&bs
->commands
);
2184 if (bs
->old_val
!= NULL
)
2186 value_free (bs
->old_val
);
2192 /* Called when a command is about to proceed the inferior. */
2195 breakpoint_about_to_proceed (void)
2197 if (!ptid_equal (inferior_ptid
, null_ptid
))
2199 struct thread_info
*tp
= inferior_thread ();
2201 /* Allow inferior function calls in breakpoint commands to not
2202 interrupt the command list. When the call finishes
2203 successfully, the inferior will be standing at the same
2204 breakpoint as if nothing happened. */
2209 breakpoint_proceeded
= 1;
2212 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2214 cleanup_executing_breakpoints (void *ignore
)
2216 executing_breakpoint_commands
= 0;
2219 /* Execute all the commands associated with all the breakpoints at this
2220 location. Any of these commands could cause the process to proceed
2221 beyond this point, etc. We look out for such changes by checking
2222 the global "breakpoint_proceeded" after each command.
2224 Returns true if a breakpoint command resumed the inferior. In that
2225 case, it is the caller's responsibility to recall it again with the
2226 bpstat of the current thread. */
2229 bpstat_do_actions_1 (bpstat
*bsp
)
2232 struct cleanup
*old_chain
;
2235 /* Avoid endless recursion if a `source' command is contained
2237 if (executing_breakpoint_commands
)
2240 executing_breakpoint_commands
= 1;
2241 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2243 /* This pointer will iterate over the list of bpstat's. */
2246 breakpoint_proceeded
= 0;
2247 for (; bs
!= NULL
; bs
= bs
->next
)
2249 struct command_line
*cmd
;
2250 struct cleanup
*this_cmd_tree_chain
;
2252 /* Take ownership of the BSP's command tree, if it has one.
2254 The command tree could legitimately contain commands like
2255 'step' and 'next', which call clear_proceed_status, which
2256 frees stop_bpstat's command tree. To make sure this doesn't
2257 free the tree we're executing out from under us, we need to
2258 take ownership of the tree ourselves. Since a given bpstat's
2259 commands are only executed once, we don't need to copy it; we
2260 can clear the pointer in the bpstat, and make sure we free
2261 the tree when we're done. */
2264 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2268 execute_control_command (cmd
);
2270 if (breakpoint_proceeded
)
2276 /* We can free this command tree now. */
2277 do_cleanups (this_cmd_tree_chain
);
2279 if (breakpoint_proceeded
)
2281 if (target_can_async_p ())
2282 /* If we are in async mode, then the target might be still
2283 running, not stopped at any breakpoint, so nothing for
2284 us to do here -- just return to the event loop. */
2287 /* In sync mode, when execute_control_command returns
2288 we're already standing on the next breakpoint.
2289 Breakpoint commands for that stop were not run, since
2290 execute_command does not run breakpoint commands --
2291 only command_line_handler does, but that one is not
2292 involved in execution of breakpoint commands. So, we
2293 can now execute breakpoint commands. It should be
2294 noted that making execute_command do bpstat actions is
2295 not an option -- in this case we'll have recursive
2296 invocation of bpstat for each breakpoint with a
2297 command, and can easily blow up GDB stack. Instead, we
2298 return true, which will trigger the caller to recall us
2299 with the new stop_bpstat. */
2304 do_cleanups (old_chain
);
2309 bpstat_do_actions (void)
2311 /* Do any commands attached to breakpoint we are stopped at. */
2312 while (!ptid_equal (inferior_ptid
, null_ptid
)
2313 && target_has_execution
2314 && !is_exited (inferior_ptid
)
2315 && !is_executing (inferior_ptid
))
2316 /* Since in sync mode, bpstat_do_actions may resume the inferior,
2317 and only return when it is stopped at the next breakpoint, we
2318 keep doing breakpoint actions until it returns false to
2319 indicate the inferior was not resumed. */
2320 if (!bpstat_do_actions_1 (&inferior_thread ()->stop_bpstat
))
2324 /* Print out the (old or new) value associated with a watchpoint. */
2327 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2330 fprintf_unfiltered (stream
, _("<unreadable>"));
2333 struct value_print_options opts
;
2334 get_user_print_options (&opts
);
2335 value_print (val
, stream
, &opts
);
2339 /* This is the normal print function for a bpstat. In the future,
2340 much of this logic could (should?) be moved to bpstat_stop_status,
2341 by having it set different print_it values.
2343 Current scheme: When we stop, bpstat_print() is called. It loops
2344 through the bpstat list of things causing this stop, calling the
2345 print_bp_stop_message function on each one. The behavior of the
2346 print_bp_stop_message function depends on the print_it field of
2347 bpstat. If such field so indicates, call this function here.
2349 Return values from this routine (ultimately used by bpstat_print()
2350 and normal_stop() to decide what to do):
2351 PRINT_NOTHING: Means we already printed all we needed to print,
2352 don't print anything else.
2353 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2354 that something to be followed by a location.
2355 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2356 that something to be followed by a location.
2357 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2360 static enum print_stop_action
2361 print_it_typical (bpstat bs
)
2363 struct cleanup
*old_chain
;
2364 struct breakpoint
*b
;
2365 const struct bp_location
*bl
;
2366 struct ui_stream
*stb
;
2368 enum print_stop_action result
;
2370 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2371 which has since been deleted. */
2372 if (bs
->breakpoint_at
== NULL
)
2373 return PRINT_UNKNOWN
;
2374 bl
= bs
->breakpoint_at
;
2377 stb
= ui_out_stream_new (uiout
);
2378 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2383 case bp_hardware_breakpoint
:
2384 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2385 if (bl
->address
!= bl
->requested_address
)
2386 breakpoint_adjustment_warning (bl
->requested_address
,
2389 annotate_breakpoint (b
->number
);
2391 ui_out_text (uiout
, "\nTemporary breakpoint ");
2393 ui_out_text (uiout
, "\nBreakpoint ");
2394 if (ui_out_is_mi_like_p (uiout
))
2396 ui_out_field_string (uiout
, "reason",
2397 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2398 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2400 ui_out_field_int (uiout
, "bkptno", b
->number
);
2401 ui_out_text (uiout
, ", ");
2402 result
= PRINT_SRC_AND_LOC
;
2405 case bp_shlib_event
:
2406 /* Did we stop because the user set the stop_on_solib_events
2407 variable? (If so, we report this as a generic, "Stopped due
2408 to shlib event" message.) */
2409 printf_filtered (_("Stopped due to shared library event\n"));
2410 result
= PRINT_NOTHING
;
2413 case bp_thread_event
:
2414 /* Not sure how we will get here.
2415 GDB should not stop for these breakpoints. */
2416 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2417 result
= PRINT_NOTHING
;
2420 case bp_overlay_event
:
2421 /* By analogy with the thread event, GDB should not stop for these. */
2422 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2423 result
= PRINT_NOTHING
;
2427 case bp_hardware_watchpoint
:
2428 annotate_watchpoint (b
->number
);
2429 if (ui_out_is_mi_like_p (uiout
))
2432 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2434 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2435 ui_out_text (uiout
, "\nOld value = ");
2436 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2437 ui_out_field_stream (uiout
, "old", stb
);
2438 ui_out_text (uiout
, "\nNew value = ");
2439 watchpoint_value_print (b
->val
, stb
->stream
);
2440 ui_out_field_stream (uiout
, "new", stb
);
2441 ui_out_text (uiout
, "\n");
2442 /* More than one watchpoint may have been triggered. */
2443 result
= PRINT_UNKNOWN
;
2446 case bp_read_watchpoint
:
2447 if (ui_out_is_mi_like_p (uiout
))
2450 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2452 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2453 ui_out_text (uiout
, "\nValue = ");
2454 watchpoint_value_print (b
->val
, stb
->stream
);
2455 ui_out_field_stream (uiout
, "value", stb
);
2456 ui_out_text (uiout
, "\n");
2457 result
= PRINT_UNKNOWN
;
2460 case bp_access_watchpoint
:
2461 if (bs
->old_val
!= NULL
)
2463 annotate_watchpoint (b
->number
);
2464 if (ui_out_is_mi_like_p (uiout
))
2467 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2469 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2470 ui_out_text (uiout
, "\nOld value = ");
2471 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2472 ui_out_field_stream (uiout
, "old", stb
);
2473 ui_out_text (uiout
, "\nNew value = ");
2478 if (ui_out_is_mi_like_p (uiout
))
2481 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2482 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2483 ui_out_text (uiout
, "\nValue = ");
2485 watchpoint_value_print (b
->val
, stb
->stream
);
2486 ui_out_field_stream (uiout
, "new", stb
);
2487 ui_out_text (uiout
, "\n");
2488 result
= PRINT_UNKNOWN
;
2491 /* Fall through, we don't deal with these types of breakpoints
2495 if (ui_out_is_mi_like_p (uiout
))
2498 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2499 result
= PRINT_UNKNOWN
;
2503 if (ui_out_is_mi_like_p (uiout
))
2506 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2507 result
= PRINT_UNKNOWN
;
2512 case bp_longjmp_resume
:
2513 case bp_step_resume
:
2514 case bp_watchpoint_scope
:
2518 result
= PRINT_UNKNOWN
;
2522 do_cleanups (old_chain
);
2526 /* Generic routine for printing messages indicating why we
2527 stopped. The behavior of this function depends on the value
2528 'print_it' in the bpstat structure. Under some circumstances we
2529 may decide not to print anything here and delegate the task to
2532 static enum print_stop_action
2533 print_bp_stop_message (bpstat bs
)
2535 switch (bs
->print_it
)
2538 /* Nothing should be printed for this bpstat entry. */
2539 return PRINT_UNKNOWN
;
2543 /* We still want to print the frame, but we already printed the
2544 relevant messages. */
2545 return PRINT_SRC_AND_LOC
;
2548 case print_it_normal
:
2550 const struct bp_location
*bl
= bs
->breakpoint_at
;
2551 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2553 /* Normal case. Call the breakpoint's print_it method, or
2554 print_it_typical. */
2555 /* FIXME: how breakpoint can ever be NULL here? */
2556 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2557 return b
->ops
->print_it (b
);
2559 return print_it_typical (bs
);
2564 internal_error (__FILE__
, __LINE__
,
2565 _("print_bp_stop_message: unrecognized enum value"));
2570 /* Print a message indicating what happened. This is called from
2571 normal_stop(). The input to this routine is the head of the bpstat
2572 list - a list of the eventpoints that caused this stop. This
2573 routine calls the generic print routine for printing a message
2574 about reasons for stopping. This will print (for example) the
2575 "Breakpoint n," part of the output. The return value of this
2578 PRINT_UNKNOWN: Means we printed nothing
2579 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2580 code to print the location. An example is
2581 "Breakpoint 1, " which should be followed by
2583 PRINT_SRC_ONLY: Means we printed something, but there is no need
2584 to also print the location part of the message.
2585 An example is the catch/throw messages, which
2586 don't require a location appended to the end.
2587 PRINT_NOTHING: We have done some printing and we don't need any
2588 further info to be printed.*/
2590 enum print_stop_action
2591 bpstat_print (bpstat bs
)
2595 /* Maybe another breakpoint in the chain caused us to stop.
2596 (Currently all watchpoints go on the bpstat whether hit or not.
2597 That probably could (should) be changed, provided care is taken
2598 with respect to bpstat_explains_signal). */
2599 for (; bs
; bs
= bs
->next
)
2601 val
= print_bp_stop_message (bs
);
2602 if (val
== PRINT_SRC_ONLY
2603 || val
== PRINT_SRC_AND_LOC
2604 || val
== PRINT_NOTHING
)
2608 /* We reached the end of the chain, or we got a null BS to start
2609 with and nothing was printed. */
2610 return PRINT_UNKNOWN
;
2613 /* Evaluate the expression EXP and return 1 if value is zero.
2614 This is used inside a catch_errors to evaluate the breakpoint condition.
2615 The argument is a "struct expression *" that has been cast to char * to
2616 make it pass through catch_errors. */
2619 breakpoint_cond_eval (void *exp
)
2621 struct value
*mark
= value_mark ();
2622 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2623 value_free_to_mark (mark
);
2627 /* Allocate a new bpstat and chain it to the current one. */
2630 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2634 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2636 bs
->breakpoint_at
= bl
;
2637 /* If the condition is false, etc., don't do the commands. */
2638 bs
->commands
= NULL
;
2640 bs
->print_it
= print_it_normal
;
2644 /* The target has stopped with waitstatus WS. Check if any hardware
2645 watchpoints have triggered, according to the target. */
2648 watchpoints_triggered (struct target_waitstatus
*ws
)
2650 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
2652 struct breakpoint
*b
;
2654 if (!stopped_by_watchpoint
)
2656 /* We were not stopped by a watchpoint. Mark all watchpoints
2657 as not triggered. */
2659 if (b
->type
== bp_hardware_watchpoint
2660 || b
->type
== bp_read_watchpoint
2661 || b
->type
== bp_access_watchpoint
)
2662 b
->watchpoint_triggered
= watch_triggered_no
;
2667 if (!target_stopped_data_address (¤t_target
, &addr
))
2669 /* We were stopped by a watchpoint, but we don't know where.
2670 Mark all watchpoints as unknown. */
2672 if (b
->type
== bp_hardware_watchpoint
2673 || b
->type
== bp_read_watchpoint
2674 || b
->type
== bp_access_watchpoint
)
2675 b
->watchpoint_triggered
= watch_triggered_unknown
;
2677 return stopped_by_watchpoint
;
2680 /* The target could report the data address. Mark watchpoints
2681 affected by this data address as triggered, and all others as not
2685 if (b
->type
== bp_hardware_watchpoint
2686 || b
->type
== bp_read_watchpoint
2687 || b
->type
== bp_access_watchpoint
)
2689 struct bp_location
*loc
;
2692 b
->watchpoint_triggered
= watch_triggered_no
;
2693 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2694 /* Exact match not required. Within range is
2696 if (target_watchpoint_addr_within_range (¤t_target
,
2700 b
->watchpoint_triggered
= watch_triggered_yes
;
2708 /* Possible return values for watchpoint_check (this can't be an enum
2709 because of check_errors). */
2710 /* The watchpoint has been deleted. */
2711 #define WP_DELETED 1
2712 /* The value has changed. */
2713 #define WP_VALUE_CHANGED 2
2714 /* The value has not changed. */
2715 #define WP_VALUE_NOT_CHANGED 3
2717 #define BP_TEMPFLAG 1
2718 #define BP_HARDWAREFLAG 2
2720 /* Check watchpoint condition. */
2723 watchpoint_check (void *p
)
2725 bpstat bs
= (bpstat
) p
;
2726 struct breakpoint
*b
;
2727 struct frame_info
*fr
;
2728 int within_current_scope
;
2730 b
= bs
->breakpoint_at
->owner
;
2732 if (b
->exp_valid_block
== NULL
)
2733 within_current_scope
= 1;
2736 /* There is no current frame at this moment. If we're going to have
2737 any chance of handling watchpoints on local variables, we'll need
2738 the frame chain (so we can determine if we're in scope). */
2739 reinit_frame_cache ();
2740 fr
= frame_find_by_id (b
->watchpoint_frame
);
2741 within_current_scope
= (fr
!= NULL
);
2743 /* If we've gotten confused in the unwinder, we might have
2744 returned a frame that can't describe this variable. */
2745 if (within_current_scope
2746 && (block_linkage_function (b
->exp_valid_block
)
2747 != get_frame_function (fr
)))
2748 within_current_scope
= 0;
2750 /* in_function_epilogue_p() returns a non-zero value if we're still
2751 in the function but the stack frame has already been invalidated.
2752 Since we can't rely on the values of local variables after the
2753 stack has been destroyed, we are treating the watchpoint in that
2754 state as `not changed' without further checking.
2756 vinschen/2003-09-04: The former implementation left out the case
2757 that the watchpoint frame couldn't be found by frame_find_by_id()
2758 because the current PC is currently in an epilogue. Calling
2759 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2760 if (!within_current_scope
|| fr
== get_current_frame ())
2762 struct frame_info
*frame
= get_current_frame ();
2763 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
2764 CORE_ADDR frame_pc
= get_frame_pc (frame
);
2766 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
2767 return WP_VALUE_NOT_CHANGED
;
2769 if (fr
&& within_current_scope
)
2770 /* If we end up stopping, the current frame will get selected
2771 in normal_stop. So this call to select_frame won't affect
2776 if (within_current_scope
)
2778 /* We use value_{,free_to_}mark because it could be a
2779 *long* time before we return to the command level and
2780 call free_all_values. We can't call free_all_values because
2781 we might be in the middle of evaluating a function call. */
2783 struct value
*mark
= value_mark ();
2784 struct value
*new_val
;
2786 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2787 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2788 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2790 if (new_val
!= NULL
)
2792 release_value (new_val
);
2793 value_free_to_mark (mark
);
2795 bs
->old_val
= b
->val
;
2798 /* We will stop here */
2799 return WP_VALUE_CHANGED
;
2803 /* Nothing changed, don't do anything. */
2804 value_free_to_mark (mark
);
2805 /* We won't stop here */
2806 return WP_VALUE_NOT_CHANGED
;
2811 /* This seems like the only logical thing to do because
2812 if we temporarily ignored the watchpoint, then when
2813 we reenter the block in which it is valid it contains
2814 garbage (in the case of a function, it may have two
2815 garbage values, one before and one after the prologue).
2816 So we can't even detect the first assignment to it and
2817 watch after that (since the garbage may or may not equal
2818 the first value assigned). */
2819 /* We print all the stop information in print_it_typical(), but
2820 in this case, by the time we call print_it_typical() this bp
2821 will be deleted already. So we have no choice but print the
2822 information here. */
2823 if (ui_out_is_mi_like_p (uiout
))
2825 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2826 ui_out_text (uiout
, "\nWatchpoint ");
2827 ui_out_field_int (uiout
, "wpnum", b
->number
);
2828 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2829 which its expression is valid.\n");
2831 if (b
->related_breakpoint
)
2832 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2833 b
->disposition
= disp_del_at_next_stop
;
2839 /* Return true if it looks like target has stopped due to hitting
2840 breakpoint location BL. This function does not check if we
2841 should stop, only if BL explains the stop. */
2843 bpstat_check_location (const struct bp_location
*bl
, CORE_ADDR bp_addr
)
2845 struct breakpoint
*b
= bl
->owner
;
2847 if (b
->type
!= bp_watchpoint
2848 && b
->type
!= bp_hardware_watchpoint
2849 && b
->type
!= bp_read_watchpoint
2850 && b
->type
!= bp_access_watchpoint
2851 && b
->type
!= bp_hardware_breakpoint
2852 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
2854 if (bl
->address
!= bp_addr
) /* address doesn't match */
2856 if (overlay_debugging
/* unmapped overlay section */
2857 && section_is_overlay (bl
->section
)
2858 && !section_is_mapped (bl
->section
))
2862 /* Continuable hardware watchpoints are treated as non-existent if the
2863 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2864 some data address). Otherwise gdb won't stop on a break instruction
2865 in the code (not from a breakpoint) when a hardware watchpoint has
2866 been defined. Also skip watchpoints which we know did not trigger
2867 (did not match the data address). */
2869 if ((b
->type
== bp_hardware_watchpoint
2870 || b
->type
== bp_read_watchpoint
2871 || b
->type
== bp_access_watchpoint
)
2872 && b
->watchpoint_triggered
== watch_triggered_no
)
2875 if (b
->type
== bp_hardware_breakpoint
)
2877 if (bl
->address
!= bp_addr
)
2879 if (overlay_debugging
/* unmapped overlay section */
2880 && section_is_overlay (bl
->section
)
2881 && !section_is_mapped (bl
->section
))
2885 if (b
->type
== bp_catchpoint
)
2887 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
2888 if (!b
->ops
->breakpoint_hit (b
))
2895 /* If BS refers to a watchpoint, determine if the watched values
2896 has actually changed, and we should stop. If not, set BS->stop
2899 bpstat_check_watchpoint (bpstat bs
)
2901 const struct bp_location
*bl
= bs
->breakpoint_at
;
2902 struct breakpoint
*b
= bl
->owner
;
2904 if (b
->type
== bp_watchpoint
2905 || b
->type
== bp_read_watchpoint
2906 || b
->type
== bp_access_watchpoint
2907 || b
->type
== bp_hardware_watchpoint
)
2911 int must_check_value
= 0;
2913 if (b
->type
== bp_watchpoint
)
2914 /* For a software watchpoint, we must always check the
2916 must_check_value
= 1;
2917 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2918 /* We have a hardware watchpoint (read, write, or access)
2919 and the target earlier reported an address watched by
2921 must_check_value
= 1;
2922 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2923 && b
->type
== bp_hardware_watchpoint
)
2924 /* We were stopped by a hardware watchpoint, but the target could
2925 not report the data address. We must check the watchpoint's
2926 value. Access and read watchpoints are out of luck; without
2927 a data address, we can't figure it out. */
2928 must_check_value
= 1;
2930 if (must_check_value
)
2932 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2934 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2935 int e
= catch_errors (watchpoint_check
, bs
, message
,
2937 do_cleanups (cleanups
);
2941 /* We've already printed what needs to be printed. */
2942 bs
->print_it
= print_it_done
;
2945 case WP_VALUE_CHANGED
:
2946 if (b
->type
== bp_read_watchpoint
)
2948 /* Don't stop: read watchpoints shouldn't fire if
2949 the value has changed. This is for targets
2950 which cannot set read-only watchpoints. */
2951 bs
->print_it
= print_it_noop
;
2955 case WP_VALUE_NOT_CHANGED
:
2956 if (b
->type
== bp_hardware_watchpoint
2957 || b
->type
== bp_watchpoint
)
2959 /* Don't stop: write watchpoints shouldn't fire if
2960 the value hasn't changed. */
2961 bs
->print_it
= print_it_noop
;
2969 /* Error from catch_errors. */
2970 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2971 if (b
->related_breakpoint
)
2972 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2973 b
->disposition
= disp_del_at_next_stop
;
2974 /* We've already printed what needs to be printed. */
2975 bs
->print_it
= print_it_done
;
2979 else /* must_check_value == 0 */
2981 /* This is a case where some watchpoint(s) triggered, but
2982 not at the address of this watchpoint, or else no
2983 watchpoint triggered after all. So don't print
2984 anything for this watchpoint. */
2985 bs
->print_it
= print_it_noop
;
2992 /* Check conditions (condition proper, frame, thread and ignore count)
2993 of breakpoint referred to by BS. If we should not stop for this
2994 breakpoint, set BS->stop to 0. */
2996 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
2998 int thread_id
= pid_to_thread_id (ptid
);
2999 const struct bp_location
*bl
= bs
->breakpoint_at
;
3000 struct breakpoint
*b
= bl
->owner
;
3002 if (frame_id_p (b
->frame_id
)
3003 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
3007 int value_is_zero
= 0;
3009 /* If this is a scope breakpoint, mark the associated
3010 watchpoint as triggered so that we will handle the
3011 out-of-scope event. We'll get to the watchpoint next
3013 if (b
->type
== bp_watchpoint_scope
)
3014 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
3016 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
3018 /* We use value_mark and value_free_to_mark because it could
3019 be a long time before we return to the command level and
3020 call free_all_values. We can't call free_all_values
3021 because we might be in the middle of evaluating a
3023 struct value
*mark
= value_mark ();
3025 /* Need to select the frame, with all that implies
3026 so that the conditions will have the right context. */
3027 select_frame (get_current_frame ());
3029 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
3030 "Error in testing breakpoint condition:\n",
3032 /* FIXME-someday, should give breakpoint # */
3033 value_free_to_mark (mark
);
3035 if (bl
->cond
&& value_is_zero
)
3039 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
3043 else if (b
->ignore_count
> 0)
3046 annotate_ignore_count_change ();
3048 /* Increase the hit count even though we don't
3056 /* Get a bpstat associated with having just stopped at address
3057 BP_ADDR in thread PTID.
3059 Determine whether we stopped at a breakpoint, etc, or whether we
3060 don't understand this stop. Result is a chain of bpstat's such that:
3062 if we don't understand the stop, the result is a null pointer.
3064 if we understand why we stopped, the result is not null.
3066 Each element of the chain refers to a particular breakpoint or
3067 watchpoint at which we have stopped. (We may have stopped for
3068 several reasons concurrently.)
3070 Each element of the chain has valid next, breakpoint_at,
3071 commands, FIXME??? fields. */
3074 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
3076 struct breakpoint
*b
= NULL
;
3077 const struct bp_location
*bl
;
3078 struct bp_location
*loc
;
3079 /* Root of the chain of bpstat's */
3080 struct bpstats root_bs
[1];
3081 /* Pointer to the last thing in the chain currently. */
3082 bpstat bs
= root_bs
;
3084 int need_remove_insert
;
3086 ALL_BP_LOCATIONS (bl
)
3090 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3093 /* For hardware watchpoints, we look only at the first location.
3094 The watchpoint_check function will work on entire expression,
3095 not the individual locations. For read watchopints, the
3096 watchpoints_triggered function have checked all locations
3099 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3102 if (!bpstat_check_location (bl
, bp_addr
))
3105 /* Come here if it's a watchpoint, or if the break address matches */
3107 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3109 /* Assume we stop. Should we find watchpoint that is not actually
3110 triggered, or if condition of breakpoint is false, we'll reset
3115 bpstat_check_watchpoint (bs
);
3119 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
3120 /* We do not stop for these. */
3123 bpstat_check_breakpoint_conditions (bs
, ptid
);
3129 /* We will stop here */
3130 if (b
->disposition
== disp_disable
)
3132 if (b
->enable_state
!= bp_permanent
)
3133 b
->enable_state
= bp_disabled
;
3134 update_global_location_list (0);
3138 bs
->commands
= b
->commands
;
3140 && (strcmp ("silent", bs
->commands
->line
) == 0
3141 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3143 bs
->commands
= bs
->commands
->next
;
3146 bs
->commands
= copy_command_lines (bs
->commands
);
3149 /* Print nothing for this entry if we dont stop or if we dont print. */
3150 if (bs
->stop
== 0 || bs
->print
== 0)
3151 bs
->print_it
= print_it_noop
;
3154 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
3156 if (loc
->address
== bp_addr
)
3158 bs
= bpstat_alloc (loc
, bs
);
3159 /* For hits of moribund locations, we should just proceed. */
3162 bs
->print_it
= print_it_noop
;
3166 bs
->next
= NULL
; /* Terminate the chain */
3167 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3169 /* If we aren't stopping, the value of some hardware watchpoint may
3170 not have changed, but the intermediate memory locations we are
3171 watching may have. Don't bother if we're stopping; this will get
3173 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3177 need_remove_insert
= 0;
3179 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3181 && bs
->breakpoint_at
->owner
3182 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3183 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3184 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3186 /* remove/insert can invalidate bs->breakpoint_at, if this
3187 location is no longer used by the watchpoint. Prevent
3188 further code from trying to use it. */
3189 bs
->breakpoint_at
= NULL
;
3190 need_remove_insert
= 1;
3193 if (need_remove_insert
)
3195 remove_breakpoints ();
3196 insert_breakpoints ();
3199 return root_bs
->next
;
3202 /* Tell what to do about this bpstat. */
3204 bpstat_what (bpstat bs
)
3206 /* Classify each bpstat as one of the following. */
3209 /* This bpstat element has no effect on the main_action. */
3212 /* There was a watchpoint, stop but don't print. */
3215 /* There was a watchpoint, stop and print. */
3218 /* There was a breakpoint but we're not stopping. */
3221 /* There was a breakpoint, stop but don't print. */
3224 /* There was a breakpoint, stop and print. */
3227 /* We hit the longjmp breakpoint. */
3230 /* We hit the longjmp_resume breakpoint. */
3233 /* We hit the step_resume breakpoint. */
3236 /* We hit the shared library event breakpoint. */
3239 /* This is just used to count how many enums there are. */
3243 /* Here is the table which drives this routine. So that we can
3244 format it pretty, we define some abbreviations for the
3245 enum bpstat_what codes. */
3246 #define kc BPSTAT_WHAT_KEEP_CHECKING
3247 #define ss BPSTAT_WHAT_STOP_SILENT
3248 #define sn BPSTAT_WHAT_STOP_NOISY
3249 #define sgl BPSTAT_WHAT_SINGLE
3250 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3251 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3252 #define sr BPSTAT_WHAT_STEP_RESUME
3253 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3255 /* "Can't happen." Might want to print an error message.
3256 abort() is not out of the question, but chances are GDB is just
3257 a bit confused, not unusable. */
3258 #define err BPSTAT_WHAT_STOP_NOISY
3260 /* Given an old action and a class, come up with a new action. */
3261 /* One interesting property of this table is that wp_silent is the same
3262 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3263 after stopping, the check for whether to step over a breakpoint
3264 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3265 reference to how we stopped. We retain separate wp_silent and
3266 bp_silent codes in case we want to change that someday.
3268 Another possibly interesting property of this table is that
3269 there's a partial ordering, priority-like, of the actions. Once
3270 you've decided that some action is appropriate, you'll never go
3271 back and decide something of a lower priority is better. The
3274 kc < clr sgl shl slr sn sr ss
3275 sgl < shl slr sn sr ss
3276 slr < err shl sn sr ss
3277 clr < err shl sn sr ss
3283 What I think this means is that we don't need a damned table
3284 here. If you just put the rows and columns in the right order,
3285 it'd look awfully regular. We could simply walk the bpstat list
3286 and choose the highest priority action we find, with a little
3287 logic to handle the 'err' cases. */
3289 /* step_resume entries: a step resume breakpoint overrides another
3290 breakpoint of signal handling (see comment in wait_for_inferior
3291 at where we set the step_resume breakpoint). */
3293 static const enum bpstat_what_main_action
3294 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3297 /* kc ss sn sgl slr clr sr shl
3300 {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
},
3302 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3304 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3306 {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
},
3308 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3310 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3312 {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
},
3314 {clr
, ss
, sn
, err
, err
, err
, sr
, shl
},
3316 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3318 {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
}
3331 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3332 struct bpstat_what retval
;
3334 retval
.call_dummy
= 0;
3335 for (; bs
!= NULL
; bs
= bs
->next
)
3337 enum class bs_class
= no_effect
;
3338 if (bs
->breakpoint_at
== NULL
)
3339 /* I suspect this can happen if it was a momentary breakpoint
3340 which has since been deleted. */
3342 if (bs
->breakpoint_at
->owner
== NULL
)
3343 bs_class
= bp_nostop
;
3345 switch (bs
->breakpoint_at
->owner
->type
)
3351 case bp_hardware_breakpoint
:
3357 bs_class
= bp_noisy
;
3359 bs_class
= bp_silent
;
3362 bs_class
= bp_nostop
;
3365 case bp_hardware_watchpoint
:
3366 case bp_read_watchpoint
:
3367 case bp_access_watchpoint
:
3371 bs_class
= wp_noisy
;
3373 bs_class
= wp_silent
;
3376 /* There was a watchpoint, but we're not stopping.
3377 This requires no further action. */
3378 bs_class
= no_effect
;
3381 bs_class
= long_jump
;
3383 case bp_longjmp_resume
:
3384 bs_class
= long_resume
;
3386 case bp_step_resume
:
3389 bs_class
= step_resume
;
3392 /* It is for the wrong frame. */
3393 bs_class
= bp_nostop
;
3395 case bp_watchpoint_scope
:
3396 bs_class
= bp_nostop
;
3398 case bp_shlib_event
:
3399 bs_class
= shlib_event
;
3401 case bp_thread_event
:
3402 case bp_overlay_event
:
3403 bs_class
= bp_nostop
;
3409 bs_class
= bp_noisy
;
3411 bs_class
= bp_silent
;
3414 /* There was a catchpoint, but we're not stopping.
3415 This requires no further action. */
3416 bs_class
= no_effect
;
3419 /* Make sure the action is stop (silent or noisy),
3420 so infrun.c pops the dummy frame. */
3421 bs_class
= bp_silent
;
3422 retval
.call_dummy
= 1;
3425 /* Tracepoint hits should not be reported back to GDB, and
3426 if one got through somehow, it should have been filtered
3428 internal_error (__FILE__
, __LINE__
,
3429 _("bpstat_what: bp_tracepoint encountered"));
3432 current_action
= table
[(int) bs_class
][(int) current_action
];
3434 retval
.main_action
= current_action
;
3438 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3439 without hardware support). This isn't related to a specific bpstat,
3440 just to things like whether watchpoints are set. */
3443 bpstat_should_step (void)
3445 struct breakpoint
*b
;
3447 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
3454 static void print_breakpoint_location (struct breakpoint
*b
,
3455 struct bp_location
*loc
,
3457 struct ui_stream
*stb
)
3462 = find_pc_sect_function (loc
->address
, loc
->section
);
3465 ui_out_text (uiout
, "in ");
3466 ui_out_field_string (uiout
, "func",
3467 SYMBOL_PRINT_NAME (sym
));
3468 ui_out_wrap_hint (uiout
, wrap_indent
);
3469 ui_out_text (uiout
, " at ");
3471 ui_out_field_string (uiout
, "file", b
->source_file
);
3472 ui_out_text (uiout
, ":");
3474 if (ui_out_is_mi_like_p (uiout
))
3476 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3477 char *fullname
= symtab_to_fullname (sal
.symtab
);
3480 ui_out_field_string (uiout
, "fullname", fullname
);
3483 ui_out_field_int (uiout
, "line", b
->line_number
);
3487 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3491 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3492 ui_out_field_stream (uiout
, "at", stb
);
3496 /* Print B to gdb_stdout. */
3498 print_one_breakpoint_location (struct breakpoint
*b
,
3499 struct bp_location
*loc
,
3501 CORE_ADDR
*last_addr
)
3503 struct command_line
*l
;
3505 struct ep_type_description
3510 static struct ep_type_description bptypes
[] =
3512 {bp_none
, "?deleted?"},
3513 {bp_breakpoint
, "breakpoint"},
3514 {bp_hardware_breakpoint
, "hw breakpoint"},
3515 {bp_until
, "until"},
3516 {bp_finish
, "finish"},
3517 {bp_watchpoint
, "watchpoint"},
3518 {bp_hardware_watchpoint
, "hw watchpoint"},
3519 {bp_read_watchpoint
, "read watchpoint"},
3520 {bp_access_watchpoint
, "acc watchpoint"},
3521 {bp_longjmp
, "longjmp"},
3522 {bp_longjmp_resume
, "longjmp resume"},
3523 {bp_step_resume
, "step resume"},
3524 {bp_watchpoint_scope
, "watchpoint scope"},
3525 {bp_call_dummy
, "call dummy"},
3526 {bp_shlib_event
, "shlib events"},
3527 {bp_thread_event
, "thread events"},
3528 {bp_overlay_event
, "overlay events"},
3529 {bp_catchpoint
, "catchpoint"},
3530 {bp_tracepoint
, "tracepoint"},
3533 static char bpenables
[] = "nynny";
3534 char wrap_indent
[80];
3535 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3536 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3537 struct cleanup
*bkpt_chain
;
3539 int header_of_multiple
= 0;
3540 int part_of_multiple
= (loc
!= NULL
);
3541 struct value_print_options opts
;
3543 get_user_print_options (&opts
);
3545 gdb_assert (!loc
|| loc_number
!= 0);
3546 /* See comment in print_one_breakpoint concerning
3547 treatment of breakpoints with single disabled
3551 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3552 header_of_multiple
= 1;
3557 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3561 if (part_of_multiple
)
3564 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3565 ui_out_field_string (uiout
, "number", formatted
);
3570 ui_out_field_int (uiout
, "number", b
->number
);
3575 if (part_of_multiple
)
3576 ui_out_field_skip (uiout
, "type");
3579 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3580 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3581 internal_error (__FILE__
, __LINE__
,
3582 _("bptypes table does not describe type #%d."),
3584 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3589 if (part_of_multiple
)
3590 ui_out_field_skip (uiout
, "disp");
3592 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3597 if (part_of_multiple
)
3598 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3600 ui_out_field_fmt (uiout
, "enabled", "%c",
3601 bpenables
[(int) b
->enable_state
]);
3602 ui_out_spaces (uiout
, 2);
3606 strcpy (wrap_indent
, " ");
3607 if (opts
.addressprint
)
3609 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3610 strcat (wrap_indent
, " ");
3612 strcat (wrap_indent
, " ");
3615 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3617 /* Although the print_one can possibly print
3618 all locations, calling it here is not likely
3619 to get any nice result. So, make sure there's
3620 just one location. */
3621 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3622 b
->ops
->print_one (b
, last_addr
);
3628 internal_error (__FILE__
, __LINE__
,
3629 _("print_one_breakpoint: bp_none encountered\n"));
3633 case bp_hardware_watchpoint
:
3634 case bp_read_watchpoint
:
3635 case bp_access_watchpoint
:
3636 /* Field 4, the address, is omitted (which makes the columns
3637 not line up too nicely with the headers, but the effect
3638 is relatively readable). */
3639 if (opts
.addressprint
)
3640 ui_out_field_skip (uiout
, "addr");
3642 ui_out_field_string (uiout
, "what", b
->exp_string
);
3646 case bp_hardware_breakpoint
:
3650 case bp_longjmp_resume
:
3651 case bp_step_resume
:
3652 case bp_watchpoint_scope
:
3654 case bp_shlib_event
:
3655 case bp_thread_event
:
3656 case bp_overlay_event
:
3658 if (opts
.addressprint
)
3661 if (header_of_multiple
)
3662 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3663 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3664 ui_out_field_string (uiout
, "addr", "<PENDING>");
3666 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3669 if (!header_of_multiple
)
3670 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3672 *last_addr
= b
->loc
->address
;
3676 if (!part_of_multiple
)
3678 if (b
->thread
!= -1)
3680 /* FIXME: This seems to be redundant and lost here; see the
3681 "stop only in" line a little further down. */
3682 ui_out_text (uiout
, " thread ");
3683 ui_out_field_int (uiout
, "thread", b
->thread
);
3685 else if (b
->task
!= 0)
3687 ui_out_text (uiout
, " task ");
3688 ui_out_field_int (uiout
, "task", b
->task
);
3692 ui_out_text (uiout
, "\n");
3694 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3697 ui_out_text (uiout
, "\tstop only in stack frame at ");
3698 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3700 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3701 ui_out_text (uiout
, "\n");
3704 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3706 /* We do not print the condition for Ada exception catchpoints
3707 because the condition is an internal implementation detail
3708 that we do not want to expose to the user. */
3710 if (b
->type
== bp_tracepoint
)
3711 ui_out_text (uiout
, "\ttrace only if ");
3713 ui_out_text (uiout
, "\tstop only if ");
3714 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3715 ui_out_text (uiout
, "\n");
3718 if (!part_of_multiple
&& b
->thread
!= -1)
3720 /* FIXME should make an annotation for this */
3721 ui_out_text (uiout
, "\tstop only in thread ");
3722 ui_out_field_int (uiout
, "thread", b
->thread
);
3723 ui_out_text (uiout
, "\n");
3726 if (!part_of_multiple
&& b
->hit_count
)
3728 /* FIXME should make an annotation for this */
3729 if (ep_is_catchpoint (b
))
3730 ui_out_text (uiout
, "\tcatchpoint");
3732 ui_out_text (uiout
, "\tbreakpoint");
3733 ui_out_text (uiout
, " already hit ");
3734 ui_out_field_int (uiout
, "times", b
->hit_count
);
3735 if (b
->hit_count
== 1)
3736 ui_out_text (uiout
, " time\n");
3738 ui_out_text (uiout
, " times\n");
3741 /* Output the count also if it is zero, but only if this is
3742 mi. FIXME: Should have a better test for this. */
3743 if (ui_out_is_mi_like_p (uiout
))
3744 if (!part_of_multiple
&& b
->hit_count
== 0)
3745 ui_out_field_int (uiout
, "times", b
->hit_count
);
3747 if (!part_of_multiple
&& b
->ignore_count
)
3750 ui_out_text (uiout
, "\tignore next ");
3751 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3752 ui_out_text (uiout
, " hits\n");
3756 if (!part_of_multiple
&& l
)
3758 struct cleanup
*script_chain
;
3761 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3762 print_command_lines (uiout
, l
, 4);
3763 do_cleanups (script_chain
);
3766 if (!part_of_multiple
&& b
->pass_count
)
3768 annotate_field (10);
3769 ui_out_text (uiout
, "\tpass count ");
3770 ui_out_field_int (uiout
, "pass", b
->pass_count
);
3771 ui_out_text (uiout
, " \n");
3774 if (!part_of_multiple
&& b
->step_count
)
3776 annotate_field (11);
3777 ui_out_text (uiout
, "\tstep count ");
3778 ui_out_field_int (uiout
, "step", b
->step_count
);
3779 ui_out_text (uiout
, " \n");
3782 if (!part_of_multiple
&& b
->actions
)
3784 struct action_line
*action
;
3785 annotate_field (12);
3786 for (action
= b
->actions
; action
; action
= action
->next
)
3788 ui_out_text (uiout
, " A\t");
3789 ui_out_text (uiout
, action
->action
);
3790 ui_out_text (uiout
, "\n");
3794 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
3797 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
3798 else if (b
->exp_string
)
3799 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
3802 do_cleanups (bkpt_chain
);
3803 do_cleanups (old_chain
);
3807 print_one_breakpoint (struct breakpoint
*b
,
3808 CORE_ADDR
*last_addr
)
3810 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3812 /* If this breakpoint has custom print function,
3813 it's already printed. Otherwise, print individual
3814 locations, if any. */
3815 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3817 /* If breakpoint has a single location that is
3818 disabled, we print it as if it had
3819 several locations, since otherwise it's hard to
3820 represent "breakpoint enabled, location disabled"
3822 Note that while hardware watchpoints have
3823 several locations internally, that's no a property
3826 && !is_hardware_watchpoint (b
)
3827 && (b
->loc
->next
|| !b
->loc
->enabled
)
3828 && !ui_out_is_mi_like_p (uiout
))
3830 struct bp_location
*loc
;
3832 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3833 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3839 struct captured_breakpoint_query_args
3845 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3847 struct captured_breakpoint_query_args
*args
= data
;
3848 struct breakpoint
*b
;
3849 CORE_ADDR dummy_addr
= 0;
3852 if (args
->bnum
== b
->number
)
3854 print_one_breakpoint (b
, &dummy_addr
);
3862 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3864 struct captured_breakpoint_query_args args
;
3866 /* For the moment we don't trust print_one_breakpoint() to not throw
3868 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3869 error_message
, RETURN_MASK_ALL
) < 0)
3875 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3876 catchpoints, et.al.). */
3879 user_settable_breakpoint (const struct breakpoint
*b
)
3881 return (b
->type
== bp_breakpoint
3882 || b
->type
== bp_catchpoint
3883 || b
->type
== bp_hardware_breakpoint
3884 || b
->type
== bp_tracepoint
3885 || b
->type
== bp_watchpoint
3886 || b
->type
== bp_read_watchpoint
3887 || b
->type
== bp_access_watchpoint
3888 || b
->type
== bp_hardware_watchpoint
);
3891 /* Print information on user settable breakpoint (watchpoint, etc)
3892 number BNUM. If BNUM is -1 print all user settable breakpoints.
3893 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3896 breakpoint_1 (int bnum
, int allflag
)
3898 struct breakpoint
*b
;
3899 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3900 int nr_printable_breakpoints
;
3901 struct cleanup
*bkpttbl_chain
;
3902 struct value_print_options opts
;
3904 get_user_print_options (&opts
);
3906 /* Compute the number of rows in the table. */
3907 nr_printable_breakpoints
= 0;
3910 || bnum
== b
->number
)
3912 if (allflag
|| user_settable_breakpoint (b
))
3913 nr_printable_breakpoints
++;
3916 if (opts
.addressprint
)
3918 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3922 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3925 if (nr_printable_breakpoints
> 0)
3926 annotate_breakpoints_headers ();
3927 if (nr_printable_breakpoints
> 0)
3929 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3930 if (nr_printable_breakpoints
> 0)
3932 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3933 if (nr_printable_breakpoints
> 0)
3935 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3936 if (nr_printable_breakpoints
> 0)
3938 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3939 if (opts
.addressprint
)
3941 if (nr_printable_breakpoints
> 0)
3943 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3944 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3946 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3948 if (nr_printable_breakpoints
> 0)
3950 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3951 ui_out_table_body (uiout
);
3952 if (nr_printable_breakpoints
> 0)
3953 annotate_breakpoints_table ();
3957 || bnum
== b
->number
)
3959 /* We only print out user settable breakpoints unless the
3961 if (allflag
|| user_settable_breakpoint (b
))
3962 print_one_breakpoint (b
, &last_addr
);
3965 do_cleanups (bkpttbl_chain
);
3967 if (nr_printable_breakpoints
== 0)
3970 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3972 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3977 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3978 that a comparison of an unsigned with -1 is always false. */
3979 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3980 set_next_address (current_gdbarch
, last_addr
);
3983 /* FIXME? Should this be moved up so that it is only called when
3984 there have been breakpoints? */
3985 annotate_breakpoints_table_end ();
3989 breakpoints_info (char *bnum_exp
, int from_tty
)
3994 bnum
= parse_and_eval_long (bnum_exp
);
3996 breakpoint_1 (bnum
, 0);
4000 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4005 bnum
= parse_and_eval_long (bnum_exp
);
4007 breakpoint_1 (bnum
, 1);
4011 breakpoint_has_pc (struct breakpoint
*b
,
4012 CORE_ADDR pc
, struct obj_section
*section
)
4014 struct bp_location
*bl
= b
->loc
;
4015 for (; bl
; bl
= bl
->next
)
4017 if (bl
->address
== pc
4018 && (!overlay_debugging
|| bl
->section
== section
))
4024 /* Print a message describing any breakpoints set at PC. */
4027 describe_other_breakpoints (CORE_ADDR pc
, struct obj_section
*section
,
4031 struct breakpoint
*b
;
4034 others
+= breakpoint_has_pc (b
, pc
, section
);
4038 printf_filtered (_("Note: breakpoint "));
4039 else /* if (others == ???) */
4040 printf_filtered (_("Note: breakpoints "));
4042 if (breakpoint_has_pc (b
, pc
, section
))
4045 printf_filtered ("%d", b
->number
);
4046 if (b
->thread
== -1 && thread
!= -1)
4047 printf_filtered (" (all threads)");
4048 else if (b
->thread
!= -1)
4049 printf_filtered (" (thread %d)", b
->thread
);
4050 printf_filtered ("%s%s ",
4051 ((b
->enable_state
== bp_disabled
4052 || b
->enable_state
== bp_call_disabled
)
4054 : b
->enable_state
== bp_permanent
4058 : ((others
== 1) ? " and" : ""));
4060 printf_filtered (_("also set at pc "));
4061 fputs_filtered (paddress (pc
), gdb_stdout
);
4062 printf_filtered (".\n");
4066 /* Set the default place to put a breakpoint
4067 for the `break' command with no arguments. */
4070 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
4073 default_breakpoint_valid
= valid
;
4074 default_breakpoint_address
= addr
;
4075 default_breakpoint_symtab
= symtab
;
4076 default_breakpoint_line
= line
;
4079 /* Return true iff it is meaningful to use the address member of
4080 BPT. For some breakpoint types, the address member is irrelevant
4081 and it makes no sense to attempt to compare it to other addresses
4082 (or use it for any other purpose either).
4084 More specifically, each of the following breakpoint types will always
4085 have a zero valued address and we don't want check_duplicates() to mark
4086 breakpoints of any of these types to be a duplicate of an actual
4087 breakpoint at address zero:
4090 bp_hardware_watchpoint
4092 bp_access_watchpoint
4096 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4098 enum bptype type
= bpt
->type
;
4100 return (type
!= bp_watchpoint
4101 && type
!= bp_hardware_watchpoint
4102 && type
!= bp_read_watchpoint
4103 && type
!= bp_access_watchpoint
4104 && type
!= bp_catchpoint
);
4107 /* Rescan breakpoints at the same address and section as BPT,
4108 marking the first one as "first" and any others as "duplicates".
4109 This is so that the bpt instruction is only inserted once.
4110 If we have a permanent breakpoint at the same place as BPT, make
4111 that one the official one, and the rest as duplicates. */
4114 check_duplicates_for (CORE_ADDR address
, struct obj_section
*section
)
4116 struct bp_location
*b
;
4118 struct bp_location
*perm_bp
= 0;
4120 ALL_BP_LOCATIONS (b
)
4121 if (b
->owner
->enable_state
!= bp_disabled
4122 && b
->owner
->enable_state
!= bp_call_disabled
4124 && !b
->shlib_disabled
4125 && b
->address
== address
/* address / overlay match */
4126 && (!overlay_debugging
|| b
->section
== section
)
4127 && breakpoint_address_is_meaningful (b
->owner
))
4129 /* Have we found a permanent breakpoint? */
4130 if (b
->owner
->enable_state
== bp_permanent
)
4137 b
->duplicate
= count
> 1;
4140 /* If we found a permanent breakpoint at this address, go over the
4141 list again and declare all the other breakpoints there (except
4142 other permanent breakpoints) to be the duplicates. */
4145 perm_bp
->duplicate
= 0;
4147 /* Permanent breakpoint should always be inserted. */
4148 if (! perm_bp
->inserted
)
4149 internal_error (__FILE__
, __LINE__
,
4150 _("allegedly permanent breakpoint is not "
4151 "actually inserted"));
4153 ALL_BP_LOCATIONS (b
)
4156 if (b
->owner
->enable_state
!= bp_permanent
4157 && b
->owner
->enable_state
!= bp_disabled
4158 && b
->owner
->enable_state
!= bp_call_disabled
4159 && b
->enabled
&& !b
->shlib_disabled
4160 && b
->address
== address
/* address / overlay match */
4161 && (!overlay_debugging
|| b
->section
== section
)
4162 && breakpoint_address_is_meaningful (b
->owner
))
4165 internal_error (__FILE__
, __LINE__
,
4166 _("another breakpoint was inserted on top of "
4167 "a permanent breakpoint"));
4176 check_duplicates (struct breakpoint
*bpt
)
4178 struct bp_location
*bl
= bpt
->loc
;
4180 if (! breakpoint_address_is_meaningful (bpt
))
4183 for (; bl
; bl
= bl
->next
)
4184 check_duplicates_for (bl
->address
, bl
->section
);
4188 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4189 int bnum
, int have_bnum
)
4194 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4195 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4197 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4198 bnum
, astr1
, astr2
);
4200 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4203 /* Adjust a breakpoint's address to account for architectural constraints
4204 on breakpoint placement. Return the adjusted address. Note: Very
4205 few targets require this kind of adjustment. For most targets,
4206 this function is simply the identity function. */
4209 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4211 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4213 /* Very few targets need any kind of breakpoint adjustment. */
4216 else if (bptype
== bp_watchpoint
4217 || bptype
== bp_hardware_watchpoint
4218 || bptype
== bp_read_watchpoint
4219 || bptype
== bp_access_watchpoint
4220 || bptype
== bp_catchpoint
)
4222 /* Watchpoints and the various bp_catch_* eventpoints should not
4223 have their addresses modified. */
4228 CORE_ADDR adjusted_bpaddr
;
4230 /* Some targets have architectural constraints on the placement
4231 of breakpoint instructions. Obtain the adjusted address. */
4232 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4235 /* An adjusted breakpoint address can significantly alter
4236 a user's expectations. Print a warning if an adjustment
4238 if (adjusted_bpaddr
!= bpaddr
)
4239 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4241 return adjusted_bpaddr
;
4245 /* Allocate a struct bp_location. */
4247 static struct bp_location
*
4248 allocate_bp_location (struct breakpoint
*bpt
)
4250 struct bp_location
*loc
, *loc_p
;
4252 loc
= xmalloc (sizeof (struct bp_location
));
4253 memset (loc
, 0, sizeof (*loc
));
4257 loc
->shlib_disabled
= 0;
4267 case bp_longjmp_resume
:
4268 case bp_step_resume
:
4269 case bp_watchpoint_scope
:
4271 case bp_shlib_event
:
4272 case bp_thread_event
:
4273 case bp_overlay_event
:
4274 loc
->loc_type
= bp_loc_software_breakpoint
;
4276 case bp_hardware_breakpoint
:
4277 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4279 case bp_hardware_watchpoint
:
4280 case bp_read_watchpoint
:
4281 case bp_access_watchpoint
:
4282 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4286 loc
->loc_type
= bp_loc_other
;
4289 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4295 static void free_bp_location (struct bp_location
*loc
)
4300 if (loc
->function_name
)
4301 xfree (loc
->function_name
);
4306 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4307 that has type BPTYPE and has no locations as yet. */
4309 static struct breakpoint
*
4310 set_raw_breakpoint_without_location (enum bptype bptype
)
4312 struct breakpoint
*b
, *b1
;
4314 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4315 memset (b
, 0, sizeof (*b
));
4318 b
->language
= current_language
->la_language
;
4319 b
->input_radix
= input_radix
;
4321 b
->enable_state
= bp_enabled
;
4324 b
->ignore_count
= 0;
4326 b
->frame_id
= null_frame_id
;
4327 b
->forked_inferior_pid
= null_ptid
;
4328 b
->exec_pathname
= NULL
;
4330 b
->condition_not_parsed
= 0;
4332 /* Add this breakpoint to the end of the chain
4333 so that a list of breakpoints will come out in order
4334 of increasing numbers. */
4336 b1
= breakpoint_chain
;
4338 breakpoint_chain
= b
;
4348 /* Initialize loc->function_name. */
4350 set_breakpoint_location_function (struct bp_location
*loc
)
4352 if (loc
->owner
->type
== bp_breakpoint
4353 || loc
->owner
->type
== bp_hardware_breakpoint
4354 || loc
->owner
->type
== bp_tracepoint
)
4356 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4358 if (loc
->function_name
)
4359 loc
->function_name
= xstrdup (loc
->function_name
);
4363 /* set_raw_breakpoint is a low level routine for allocating and
4364 partially initializing a breakpoint of type BPTYPE. The newly
4365 created breakpoint's address, section, source file name, and line
4366 number are provided by SAL. The newly created and partially
4367 initialized breakpoint is added to the breakpoint chain and
4368 is also returned as the value of this function.
4370 It is expected that the caller will complete the initialization of
4371 the newly created breakpoint struct as well as output any status
4372 information regarding the creation of a new breakpoint. In
4373 particular, set_raw_breakpoint does NOT set the breakpoint
4374 number! Care should be taken to not allow an error to occur
4375 prior to completing the initialization of the breakpoint. If this
4376 should happen, a bogus breakpoint will be left on the chain. */
4379 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4381 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4382 CORE_ADDR adjusted_address
;
4384 /* Adjust the breakpoint's address prior to allocating a location.
4385 Once we call allocate_bp_location(), that mostly uninitialized
4386 location will be placed on the location chain. Adjustment of the
4387 breakpoint may cause target_read_memory() to be called and we do
4388 not want its scan of the location chain to find a breakpoint and
4389 location that's only been partially initialized. */
4390 adjusted_address
= adjust_breakpoint_address (sal
.pc
, b
->type
);
4392 b
->loc
= allocate_bp_location (b
);
4393 b
->loc
->requested_address
= sal
.pc
;
4394 b
->loc
->address
= adjusted_address
;
4396 if (sal
.symtab
== NULL
)
4397 b
->source_file
= NULL
;
4399 b
->source_file
= xstrdup (sal
.symtab
->filename
);
4400 b
->loc
->section
= sal
.section
;
4401 b
->line_number
= sal
.line
;
4403 set_breakpoint_location_function (b
->loc
);
4405 breakpoints_changed ();
4411 /* Note that the breakpoint object B describes a permanent breakpoint
4412 instruction, hard-wired into the inferior's code. */
4414 make_breakpoint_permanent (struct breakpoint
*b
)
4416 struct bp_location
*bl
;
4417 b
->enable_state
= bp_permanent
;
4419 /* By definition, permanent breakpoints are already present in the code.
4420 Mark all locations as inserted. For now, make_breakpoint_permanent
4421 is called in just one place, so it's hard to say if it's reasonable
4422 to have permanent breakpoint with multiple locations or not,
4423 but it's easy to implmement. */
4424 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4429 create_longjmp_breakpoint (char *func_name
)
4431 struct minimal_symbol
*m
;
4433 m
= lookup_minimal_symbol_text (func_name
, NULL
);
4436 set_momentary_breakpoint_at_pc (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4437 update_global_location_list (1);
4440 /* Call this routine when stepping and nexting to enable a breakpoint
4441 if we do a longjmp(). When we hit that breakpoint, call
4442 set_longjmp_resume_breakpoint() to figure out where we are going. */
4445 set_longjmp_breakpoint (void)
4447 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
4449 create_longjmp_breakpoint ("longjmp");
4450 create_longjmp_breakpoint ("_longjmp");
4451 create_longjmp_breakpoint ("siglongjmp");
4452 create_longjmp_breakpoint ("_siglongjmp");
4456 /* Delete all longjmp breakpoints from THREAD. */
4458 delete_longjmp_breakpoint (int thread
)
4460 struct breakpoint
*b
, *temp
;
4462 ALL_BREAKPOINTS_SAFE (b
, temp
)
4463 if (b
->type
== bp_longjmp
)
4465 if (b
->thread
== thread
)
4466 delete_breakpoint (b
);
4471 enable_overlay_breakpoints (void)
4473 struct breakpoint
*b
;
4476 if (b
->type
== bp_overlay_event
)
4478 b
->enable_state
= bp_enabled
;
4479 update_global_location_list (1);
4480 overlay_events_enabled
= 1;
4485 disable_overlay_breakpoints (void)
4487 struct breakpoint
*b
;
4490 if (b
->type
== bp_overlay_event
)
4492 b
->enable_state
= bp_disabled
;
4493 update_global_location_list (0);
4494 overlay_events_enabled
= 0;
4499 create_thread_event_breakpoint (CORE_ADDR address
)
4501 struct breakpoint
*b
;
4503 b
= create_internal_breakpoint (address
, bp_thread_event
);
4505 b
->enable_state
= bp_enabled
;
4506 /* addr_string has to be used or breakpoint_re_set will delete me. */
4507 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4509 update_global_location_list_nothrow (1);
4515 remove_thread_event_breakpoints (void)
4517 struct breakpoint
*b
, *temp
;
4519 ALL_BREAKPOINTS_SAFE (b
, temp
)
4520 if (b
->type
== bp_thread_event
)
4521 delete_breakpoint (b
);
4524 struct captured_parse_breakpoint_args
4527 struct symtabs_and_lines
*sals_p
;
4528 char ***addr_string_p
;
4532 struct lang_and_radix
4540 remove_solib_event_breakpoints (void)
4542 struct breakpoint
*b
, *temp
;
4544 ALL_BREAKPOINTS_SAFE (b
, temp
)
4545 if (b
->type
== bp_shlib_event
)
4546 delete_breakpoint (b
);
4550 create_solib_event_breakpoint (CORE_ADDR address
)
4552 struct breakpoint
*b
;
4554 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4555 update_global_location_list_nothrow (1);
4559 /* Disable any breakpoints that are on code in shared libraries. Only
4560 apply to enabled breakpoints, disabled ones can just stay disabled. */
4563 disable_breakpoints_in_shlibs (void)
4565 struct bp_location
*loc
;
4567 ALL_BP_LOCATIONS (loc
)
4569 struct breakpoint
*b
= loc
->owner
;
4570 /* We apply the check to all breakpoints, including disabled
4571 for those with loc->duplicate set. This is so that when breakpoint
4572 becomes enabled, or the duplicate is removed, gdb will try to insert
4573 all breakpoints. If we don't set shlib_disabled here, we'll try
4574 to insert those breakpoints and fail. */
4575 if (((b
->type
== bp_breakpoint
)
4576 || (b
->type
== bp_hardware_breakpoint
)
4577 || (b
->type
== bp_tracepoint
))
4578 && !loc
->shlib_disabled
4580 && PC_SOLIB (loc
->address
)
4582 && solib_name_from_address (loc
->address
)
4586 loc
->shlib_disabled
= 1;
4591 /* Disable any breakpoints that are in in an unloaded shared library. Only
4592 apply to enabled breakpoints, disabled ones can just stay disabled. */
4595 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4597 struct bp_location
*loc
;
4598 int disabled_shlib_breaks
= 0;
4600 /* SunOS a.out shared libraries are always mapped, so do not
4601 disable breakpoints; they will only be reported as unloaded
4602 through clear_solib when GDB discards its shared library
4603 list. See clear_solib for more information. */
4604 if (exec_bfd
!= NULL
4605 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
4608 ALL_BP_LOCATIONS (loc
)
4610 struct breakpoint
*b
= loc
->owner
;
4611 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4612 || loc
->loc_type
== bp_loc_software_breakpoint
)
4613 && !loc
->shlib_disabled
4614 && (b
->type
== bp_breakpoint
|| b
->type
== bp_hardware_breakpoint
)
4615 && solib_contains_address_p (solib
, loc
->address
))
4617 loc
->shlib_disabled
= 1;
4618 /* At this point, we cannot rely on remove_breakpoint
4619 succeeding so we must mark the breakpoint as not inserted
4620 to prevent future errors occurring in remove_breakpoints. */
4622 if (!disabled_shlib_breaks
)
4624 target_terminal_ours_for_output ();
4625 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4628 disabled_shlib_breaks
= 1;
4633 /* FORK & VFORK catchpoints. */
4635 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
4638 insert_catch_fork (struct breakpoint
*b
)
4640 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
4643 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
4646 remove_catch_fork (struct breakpoint
*b
)
4648 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
4651 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
4655 breakpoint_hit_catch_fork (struct breakpoint
*b
)
4657 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
4660 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
4662 static enum print_stop_action
4663 print_it_catch_fork (struct breakpoint
*b
)
4665 annotate_catchpoint (b
->number
);
4666 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
4667 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4668 return PRINT_SRC_AND_LOC
;
4671 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
4674 print_one_catch_fork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4676 struct value_print_options opts
;
4678 get_user_print_options (&opts
);
4680 /* Field 4, the address, is omitted (which makes the columns
4681 not line up too nicely with the headers, but the effect
4682 is relatively readable). */
4683 if (opts
.addressprint
)
4684 ui_out_field_skip (uiout
, "addr");
4686 ui_out_text (uiout
, "fork");
4687 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4689 ui_out_text (uiout
, ", process ");
4690 ui_out_field_int (uiout
, "what",
4691 ptid_get_pid (b
->forked_inferior_pid
));
4692 ui_out_spaces (uiout
, 1);
4696 /* Implement the "print_mention" breakpoint_ops method for fork
4700 print_mention_catch_fork (struct breakpoint
*b
)
4702 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
4705 /* The breakpoint_ops structure to be used in fork catchpoints. */
4707 static struct breakpoint_ops catch_fork_breakpoint_ops
=
4711 breakpoint_hit_catch_fork
,
4712 print_it_catch_fork
,
4713 print_one_catch_fork
,
4714 print_mention_catch_fork
4717 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
4720 insert_catch_vfork (struct breakpoint
*b
)
4722 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
4725 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
4728 remove_catch_vfork (struct breakpoint
*b
)
4730 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
4733 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
4737 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
4739 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
4742 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
4744 static enum print_stop_action
4745 print_it_catch_vfork (struct breakpoint
*b
)
4747 annotate_catchpoint (b
->number
);
4748 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
4749 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4750 return PRINT_SRC_AND_LOC
;
4753 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
4756 print_one_catch_vfork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4758 struct value_print_options opts
;
4760 get_user_print_options (&opts
);
4761 /* Field 4, the address, is omitted (which makes the columns
4762 not line up too nicely with the headers, but the effect
4763 is relatively readable). */
4764 if (opts
.addressprint
)
4765 ui_out_field_skip (uiout
, "addr");
4767 ui_out_text (uiout
, "vfork");
4768 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4770 ui_out_text (uiout
, ", process ");
4771 ui_out_field_int (uiout
, "what",
4772 ptid_get_pid (b
->forked_inferior_pid
));
4773 ui_out_spaces (uiout
, 1);
4777 /* Implement the "print_mention" breakpoint_ops method for vfork
4781 print_mention_catch_vfork (struct breakpoint
*b
)
4783 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
4786 /* The breakpoint_ops structure to be used in vfork catchpoints. */
4788 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
4792 breakpoint_hit_catch_vfork
,
4793 print_it_catch_vfork
,
4794 print_one_catch_vfork
,
4795 print_mention_catch_vfork
4798 /* Create a new breakpoint of the bp_catchpoint kind and return it.
4800 If TEMPFLAG is non-zero, then make the breakpoint temporary.
4801 If COND_STRING is not NULL, then store it in the breakpoint.
4802 OPS, if not NULL, is the breakpoint_ops structure associated
4803 to the catchpoint. */
4805 static struct breakpoint
*
4806 create_catchpoint (int tempflag
, char *cond_string
,
4807 struct breakpoint_ops
*ops
)
4809 struct symtab_and_line sal
;
4810 struct breakpoint
*b
;
4817 b
= set_raw_breakpoint (sal
, bp_catchpoint
);
4818 set_breakpoint_count (breakpoint_count
+ 1);
4819 b
->number
= breakpoint_count
;
4821 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
4823 b
->addr_string
= NULL
;
4824 b
->enable_state
= bp_enabled
;
4825 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4829 update_global_location_list (1);
4835 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4836 struct breakpoint_ops
*ops
)
4838 struct breakpoint
*b
= create_catchpoint (tempflag
, cond_string
, ops
);
4840 /* FIXME: We should put this information in a breakpoint private data
4842 b
->forked_inferior_pid
= null_ptid
;
4845 /* Exec catchpoints. */
4848 insert_catch_exec (struct breakpoint
*b
)
4850 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
4854 remove_catch_exec (struct breakpoint
*b
)
4856 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
4860 breakpoint_hit_catch_exec (struct breakpoint
*b
)
4862 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
4865 static enum print_stop_action
4866 print_it_catch_exec (struct breakpoint
*b
)
4868 annotate_catchpoint (b
->number
);
4869 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
4871 return PRINT_SRC_AND_LOC
;
4875 print_one_catch_exec (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4877 struct value_print_options opts
;
4879 get_user_print_options (&opts
);
4881 /* Field 4, the address, is omitted (which makes the columns
4882 not line up too nicely with the headers, but the effect
4883 is relatively readable). */
4884 if (opts
.addressprint
)
4885 ui_out_field_skip (uiout
, "addr");
4887 ui_out_text (uiout
, "exec");
4888 if (b
->exec_pathname
!= NULL
)
4890 ui_out_text (uiout
, ", program \"");
4891 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
4892 ui_out_text (uiout
, "\" ");
4897 print_mention_catch_exec (struct breakpoint
*b
)
4899 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
4902 static struct breakpoint_ops catch_exec_breakpoint_ops
=
4906 breakpoint_hit_catch_exec
,
4907 print_it_catch_exec
,
4908 print_one_catch_exec
,
4909 print_mention_catch_exec
4913 hw_breakpoint_used_count (void)
4915 struct breakpoint
*b
;
4920 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
4928 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4930 struct breakpoint
*b
;
4933 *other_type_used
= 0;
4936 if (breakpoint_enabled (b
))
4938 if (b
->type
== type
)
4940 else if ((b
->type
== bp_hardware_watchpoint
4941 || b
->type
== bp_read_watchpoint
4942 || b
->type
== bp_access_watchpoint
))
4943 *other_type_used
= 1;
4950 disable_watchpoints_before_interactive_call_start (void)
4952 struct breakpoint
*b
;
4956 if (((b
->type
== bp_watchpoint
)
4957 || (b
->type
== bp_hardware_watchpoint
)
4958 || (b
->type
== bp_read_watchpoint
)
4959 || (b
->type
== bp_access_watchpoint
))
4960 && breakpoint_enabled (b
))
4962 b
->enable_state
= bp_call_disabled
;
4963 update_global_location_list (0);
4969 enable_watchpoints_after_interactive_call_stop (void)
4971 struct breakpoint
*b
;
4975 if (((b
->type
== bp_watchpoint
)
4976 || (b
->type
== bp_hardware_watchpoint
)
4977 || (b
->type
== bp_read_watchpoint
)
4978 || (b
->type
== bp_access_watchpoint
))
4979 && (b
->enable_state
== bp_call_disabled
))
4981 b
->enable_state
= bp_enabled
;
4982 update_global_location_list (1);
4988 /* Set a breakpoint that will evaporate an end of command
4989 at address specified by SAL.
4990 Restrict it to frame FRAME if FRAME is nonzero. */
4993 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4996 struct breakpoint
*b
;
4997 b
= set_raw_breakpoint (sal
, type
);
4998 b
->enable_state
= bp_enabled
;
4999 b
->disposition
= disp_donttouch
;
5000 b
->frame_id
= frame_id
;
5002 /* If we're debugging a multi-threaded program, then we
5003 want momentary breakpoints to be active in only a
5004 single thread of control. */
5005 if (in_thread_list (inferior_ptid
))
5006 b
->thread
= pid_to_thread_id (inferior_ptid
);
5008 update_global_location_list_nothrow (1);
5013 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
5017 clone_momentary_breakpoint (struct breakpoint
*orig
)
5019 struct breakpoint
*copy
;
5021 /* If there's nothing to clone, then return nothing. */
5025 copy
= set_raw_breakpoint_without_location (orig
->type
);
5026 copy
->loc
= allocate_bp_location (copy
);
5027 set_breakpoint_location_function (copy
->loc
);
5029 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
5030 copy
->loc
->address
= orig
->loc
->address
;
5031 copy
->loc
->section
= orig
->loc
->section
;
5033 if (orig
->source_file
== NULL
)
5034 copy
->source_file
= NULL
;
5036 copy
->source_file
= xstrdup (orig
->source_file
);
5038 copy
->line_number
= orig
->line_number
;
5039 copy
->frame_id
= orig
->frame_id
;
5040 copy
->thread
= orig
->thread
;
5042 copy
->enable_state
= bp_enabled
;
5043 copy
->disposition
= disp_donttouch
;
5044 copy
->number
= internal_breakpoint_number
--;
5046 update_global_location_list_nothrow (0);
5051 set_momentary_breakpoint_at_pc (CORE_ADDR pc
, enum bptype type
)
5053 struct symtab_and_line sal
;
5055 sal
= find_pc_line (pc
, 0);
5057 sal
.section
= find_pc_overlay (pc
);
5058 sal
.explicit_pc
= 1;
5060 return set_momentary_breakpoint (sal
, null_frame_id
, type
);
5064 /* Tell the user we have just set a breakpoint B. */
5067 mention (struct breakpoint
*b
)
5070 struct cleanup
*ui_out_chain
;
5071 struct value_print_options opts
;
5073 get_user_print_options (&opts
);
5075 /* FIXME: This is misplaced; mention() is called by things (like
5076 hitting a watchpoint) other than breakpoint creation. It should
5077 be possible to clean this up and at the same time replace the
5078 random calls to breakpoint_changed with this hook. */
5079 observer_notify_breakpoint_created (b
->number
);
5081 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
5082 b
->ops
->print_mention (b
);
5087 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
5090 ui_out_text (uiout
, "Watchpoint ");
5091 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5092 ui_out_field_int (uiout
, "number", b
->number
);
5093 ui_out_text (uiout
, ": ");
5094 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5095 do_cleanups (ui_out_chain
);
5097 case bp_hardware_watchpoint
:
5098 ui_out_text (uiout
, "Hardware watchpoint ");
5099 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5100 ui_out_field_int (uiout
, "number", b
->number
);
5101 ui_out_text (uiout
, ": ");
5102 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5103 do_cleanups (ui_out_chain
);
5105 case bp_read_watchpoint
:
5106 ui_out_text (uiout
, "Hardware read watchpoint ");
5107 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
5108 ui_out_field_int (uiout
, "number", b
->number
);
5109 ui_out_text (uiout
, ": ");
5110 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5111 do_cleanups (ui_out_chain
);
5113 case bp_access_watchpoint
:
5114 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
5115 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
5116 ui_out_field_int (uiout
, "number", b
->number
);
5117 ui_out_text (uiout
, ": ");
5118 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5119 do_cleanups (ui_out_chain
);
5122 if (ui_out_is_mi_like_p (uiout
))
5127 if (b
->disposition
== disp_del
)
5128 printf_filtered (_("Temporary breakpoint"));
5130 printf_filtered (_("Breakpoint"));
5131 printf_filtered (_(" %d"), b
->number
);
5134 case bp_hardware_breakpoint
:
5135 if (ui_out_is_mi_like_p (uiout
))
5140 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
5144 if (ui_out_is_mi_like_p (uiout
))
5149 printf_filtered (_("Tracepoint"));
5150 printf_filtered (_(" %d"), b
->number
);
5157 case bp_longjmp_resume
:
5158 case bp_step_resume
:
5160 case bp_watchpoint_scope
:
5161 case bp_shlib_event
:
5162 case bp_thread_event
:
5163 case bp_overlay_event
:
5169 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5173 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5177 if (opts
.addressprint
|| b
->source_file
== NULL
)
5179 printf_filtered (" at ");
5180 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
5183 printf_filtered (": file %s, line %d.",
5184 b
->source_file
, b
->line_number
);
5188 struct bp_location
*loc
= b
->loc
;
5190 for (; loc
; loc
= loc
->next
)
5192 printf_filtered (" (%d locations)", n
);
5197 if (ui_out_is_mi_like_p (uiout
))
5199 printf_filtered ("\n");
5203 static struct bp_location
*
5204 add_location_to_breakpoint (struct breakpoint
*b
,
5205 const struct symtab_and_line
*sal
)
5207 struct bp_location
*loc
, **tmp
;
5209 loc
= allocate_bp_location (b
);
5210 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5213 loc
->requested_address
= sal
->pc
;
5214 loc
->address
= adjust_breakpoint_address (loc
->requested_address
, b
->type
);
5215 loc
->section
= sal
->section
;
5217 set_breakpoint_location_function (loc
);
5222 /* Return 1 if LOC is pointing to a permanent breakpoint,
5223 return 0 otherwise. */
5226 bp_loc_is_permanent (struct bp_location
*loc
)
5230 const gdb_byte
*brk
;
5231 gdb_byte
*target_mem
;
5232 struct cleanup
*cleanup
;
5235 gdb_assert (loc
!= NULL
);
5237 addr
= loc
->address
;
5238 brk
= gdbarch_breakpoint_from_pc (current_gdbarch
, &addr
, &len
);
5240 /* Software breakpoints unsupported? */
5244 target_mem
= alloca (len
);
5246 /* Enable the automatic memory restoration from breakpoints while
5247 we read the memory. Otherwise we could say about our temporary
5248 breakpoints they are permanent. */
5249 cleanup
= make_show_memory_breakpoints_cleanup (0);
5251 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
5252 && memcmp (target_mem
, brk
, len
) == 0)
5255 do_cleanups (cleanup
);
5262 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5263 as textual description of the location, and COND_STRING
5264 as condition expression. */
5267 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5269 enum bptype type
, enum bpdisp disposition
,
5270 int thread
, int task
, int ignore_count
,
5271 struct breakpoint_ops
*ops
, int from_tty
, int enabled
)
5273 struct breakpoint
*b
= NULL
;
5276 if (type
== bp_hardware_breakpoint
)
5278 int i
= hw_breakpoint_used_count ();
5279 int target_resources_ok
=
5280 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
5282 if (target_resources_ok
== 0)
5283 error (_("No hardware breakpoint support in the target."));
5284 else if (target_resources_ok
< 0)
5285 error (_("Hardware breakpoints used exceeds limit."));
5288 for (i
= 0; i
< sals
.nelts
; ++i
)
5290 struct symtab_and_line sal
= sals
.sals
[i
];
5291 struct bp_location
*loc
;
5294 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5298 b
= set_raw_breakpoint (sal
, type
);
5299 set_breakpoint_count (breakpoint_count
+ 1);
5300 b
->number
= breakpoint_count
;
5304 b
->cond_string
= cond_string
;
5305 b
->ignore_count
= ignore_count
;
5306 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
5307 b
->disposition
= disposition
;
5313 loc
= add_location_to_breakpoint (b
, &sal
);
5316 if (bp_loc_is_permanent (loc
))
5317 make_breakpoint_permanent (b
);
5321 char *arg
= b
->cond_string
;
5322 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5324 error (_("Garbage %s follows condition"), arg
);
5329 b
->addr_string
= addr_string
;
5331 /* addr_string has to be used or breakpoint_re_set will delete
5333 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5339 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5340 elements to fill the void space. */
5342 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5344 int i
= index_to_remove
+1;
5345 int last_index
= sal
->nelts
-1;
5347 for (;i
<= last_index
; ++i
)
5348 sal
->sals
[i
-1] = sal
->sals
[i
];
5353 /* If appropriate, obtains all sals that correspond
5354 to the same file and line as SAL. This is done
5355 only if SAL does not have explicit PC and has
5356 line and file information. If we got just a single
5357 expanded sal, return the original.
5359 Otherwise, if SAL.explicit_line is not set, filter out
5360 all sals for which the name of enclosing function
5361 is different from SAL. This makes sure that if we have
5362 breakpoint originally set in template instantiation, say
5363 foo<int>(), we won't expand SAL to locations at the same
5364 line in all existing instantiations of 'foo'.
5367 static struct symtabs_and_lines
5368 expand_line_sal_maybe (struct symtab_and_line sal
)
5370 struct symtabs_and_lines expanded
;
5371 CORE_ADDR original_pc
= sal
.pc
;
5372 char *original_function
= NULL
;
5376 /* If we have explicit pc, don't expand.
5377 If we have no line number, we can't expand. */
5378 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5381 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5382 expanded
.sals
[0] = sal
;
5387 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5389 expanded
= expand_line_sal (sal
);
5390 if (expanded
.nelts
== 1)
5392 /* We had one sal, we got one sal. Without futher
5393 processing, just return the original sal. */
5394 xfree (expanded
.sals
);
5396 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5397 sal
.pc
= original_pc
;
5398 expanded
.sals
[0] = sal
;
5402 if (!sal
.explicit_line
)
5404 CORE_ADDR func_addr
, func_end
;
5405 for (i
= 0; i
< expanded
.nelts
; ++i
)
5407 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5408 char *this_function
;
5409 if (find_pc_partial_function (pc
, &this_function
,
5410 &func_addr
, &func_end
))
5413 && strcmp (this_function
, original_function
) != 0)
5415 remove_sal (&expanded
, i
);
5418 else if (func_addr
== pc
)
5420 /* We're at beginning of a function, and should
5422 struct symbol
*sym
= find_pc_function (pc
);
5424 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5427 /* Since find_pc_partial_function returned true,
5428 we should really always find the section here. */
5429 struct obj_section
*section
= find_pc_section (pc
);
5432 struct gdbarch
*gdbarch
5433 = get_objfile_arch (section
->objfile
);
5435 = gdbarch_skip_prologue (gdbarch
, pc
);
5444 for (i
= 0; i
< expanded
.nelts
; ++i
)
5446 /* If this SAL corresponds to a breakpoint inserted using a
5447 line number, then skip the function prologue if necessary. */
5448 skip_prologue_sal (&expanded
.sals
[i
]);
5453 if (expanded
.nelts
<= 1)
5455 /* This is un ugly workaround. If we get zero
5456 expanded sals then something is really wrong.
5457 Fix that by returnign the original sal. */
5458 xfree (expanded
.sals
);
5460 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5461 sal
.pc
= original_pc
;
5462 expanded
.sals
[0] = sal
;
5469 for (i
= 0; i
< expanded
.nelts
; ++i
)
5470 if (expanded
.sals
[i
].pc
== original_pc
)
5481 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5482 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5483 value. COND_STRING, if not NULL, specified the condition to be
5484 used for all breakpoints. Essentially the only case where
5485 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5486 function. In that case, it's still not possible to specify
5487 separate conditions for different overloaded functions, so
5488 we take just a single condition string.
5490 NOTE: If the function succeeds, the caller is expected to cleanup
5491 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5492 array contents). If the function fails (error() is called), the
5493 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5494 COND and SALS arrays and each of those arrays contents. */
5497 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5499 enum bptype type
, enum bpdisp disposition
,
5500 int thread
, int task
, int ignore_count
,
5501 struct breakpoint_ops
*ops
, int from_tty
,
5505 for (i
= 0; i
< sals
.nelts
; ++i
)
5507 struct symtabs_and_lines expanded
=
5508 expand_line_sal_maybe (sals
.sals
[i
]);
5510 create_breakpoint (expanded
, addr_string
[i
],
5511 cond_string
, type
, disposition
,
5512 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
5516 /* Parse ARG which is assumed to be a SAL specification possibly
5517 followed by conditionals. On return, SALS contains an array of SAL
5518 addresses found. ADDR_STRING contains a vector of (canonical)
5519 address strings. ARG points to the end of the SAL. */
5522 parse_breakpoint_sals (char **address
,
5523 struct symtabs_and_lines
*sals
,
5524 char ***addr_string
,
5527 char *addr_start
= *address
;
5528 *addr_string
= NULL
;
5529 /* If no arg given, or if first arg is 'if ', use the default
5531 if ((*address
) == NULL
5532 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5534 if (default_breakpoint_valid
)
5536 struct symtab_and_line sal
;
5537 init_sal (&sal
); /* initialize to zeroes */
5538 sals
->sals
= (struct symtab_and_line
*)
5539 xmalloc (sizeof (struct symtab_and_line
));
5540 sal
.pc
= default_breakpoint_address
;
5541 sal
.line
= default_breakpoint_line
;
5542 sal
.symtab
= default_breakpoint_symtab
;
5543 sal
.section
= find_pc_overlay (sal
.pc
);
5545 /* "break" without arguments is equivalent to "break *PC" where PC is
5546 the default_breakpoint_address. So make sure to set
5547 sal.explicit_pc to prevent GDB from trying to expand the list of
5548 sals to include all other instances with the same symtab and line.
5550 sal
.explicit_pc
= 1;
5552 sals
->sals
[0] = sal
;
5556 error (_("No default breakpoint address now."));
5560 /* Force almost all breakpoints to be in terms of the
5561 current_source_symtab (which is decode_line_1's default). This
5562 should produce the results we want almost all of the time while
5563 leaving default_breakpoint_* alone.
5564 ObjC: However, don't match an Objective-C method name which
5565 may have a '+' or '-' succeeded by a '[' */
5567 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5569 if (default_breakpoint_valid
5571 || ((strchr ("+-", (*address
)[0]) != NULL
)
5572 && ((*address
)[1] != '['))))
5573 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5574 default_breakpoint_line
, addr_string
,
5577 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5578 addr_string
, not_found_ptr
);
5580 /* For any SAL that didn't have a canonical string, fill one in. */
5581 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5582 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5583 if (addr_start
!= (*address
))
5586 for (i
= 0; i
< sals
->nelts
; i
++)
5588 /* Add the string if not present. */
5589 if ((*addr_string
)[i
] == NULL
)
5590 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5596 /* Convert each SAL into a real PC. Verify that the PC can be
5597 inserted as a breakpoint. If it can't throw an error. */
5600 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5604 for (i
= 0; i
< sals
->nelts
; i
++)
5605 resolve_sal_pc (&sals
->sals
[i
]);
5609 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5611 struct captured_parse_breakpoint_args
*args
= data
;
5613 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5614 args
->not_found_ptr
);
5617 /* Given TOK, a string specification of condition and thread, as
5618 accepted by the 'break' command, extract the condition
5619 string and thread number and set *COND_STRING and *THREAD.
5620 PC identifies the context at which the condition should be parsed.
5621 If no condition is found, *COND_STRING is set to NULL.
5622 If no thread is found, *THREAD is set to -1. */
5624 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5625 char **cond_string
, int *thread
, int *task
)
5627 *cond_string
= NULL
;
5633 char *cond_start
= NULL
;
5634 char *cond_end
= NULL
;
5635 while (*tok
== ' ' || *tok
== '\t')
5640 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5643 toklen
= end_tok
- tok
;
5645 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5647 struct expression
*expr
;
5649 tok
= cond_start
= end_tok
+ 1;
5650 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5653 *cond_string
= savestring (cond_start
,
5654 cond_end
- cond_start
);
5656 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5662 *thread
= strtol (tok
, &tok
, 0);
5664 error (_("Junk after thread keyword."));
5665 if (!valid_thread_id (*thread
))
5666 error (_("Unknown thread %d."), *thread
);
5668 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
5674 *task
= strtol (tok
, &tok
, 0);
5676 error (_("Junk after task keyword."));
5677 if (!valid_task_id (*task
))
5678 error (_("Unknown task %d\n"), *task
);
5681 error (_("Junk at end of arguments."));
5685 /* Set a breakpoint. This function is shared between
5686 CLI and MI functions for setting a breakpoint.
5687 This function has two major modes of operations,
5688 selected by the PARSE_CONDITION_AND_THREAD parameter.
5689 If non-zero, the function will parse arg, extracting
5690 breakpoint location, address and thread. Otherwise,
5691 ARG is just the location of breakpoint, with condition
5692 and thread specified by the COND_STRING and THREAD
5696 break_command_really (char *arg
, char *cond_string
, int thread
,
5697 int parse_condition_and_thread
,
5698 int tempflag
, int hardwareflag
, int traceflag
,
5700 enum auto_boolean pending_break_support
,
5701 struct breakpoint_ops
*ops
,
5705 struct gdb_exception e
;
5706 struct symtabs_and_lines sals
;
5707 struct symtab_and_line pending_sal
;
5710 char *addr_start
= arg
;
5712 struct cleanup
*old_chain
;
5713 struct cleanup
*bkpt_chain
= NULL
;
5714 struct captured_parse_breakpoint_args parse_args
;
5718 enum bptype type_wanted
;
5725 parse_args
.arg_p
= &arg
;
5726 parse_args
.sals_p
= &sals
;
5727 parse_args
.addr_string_p
= &addr_string
;
5728 parse_args
.not_found_ptr
= ¬_found
;
5730 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5731 &parse_args
, RETURN_MASK_ALL
);
5733 /* If caller is interested in rc value from parse, set value. */
5737 throw_exception (e
);
5741 case NOT_FOUND_ERROR
:
5743 /* If pending breakpoint support is turned off, throw
5746 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5747 throw_exception (e
);
5749 exception_print (gdb_stderr
, e
);
5751 /* If pending breakpoint support is auto query and the user
5752 selects no, then simply return the error code. */
5753 if (pending_break_support
== AUTO_BOOLEAN_AUTO
5754 && !nquery ("Make breakpoint pending on future shared library load? "))
5757 /* At this point, either the user was queried about setting
5758 a pending breakpoint and selected yes, or pending
5759 breakpoint behavior is on and thus a pending breakpoint
5760 is defaulted on behalf of the user. */
5761 copy_arg
= xstrdup (addr_start
);
5762 addr_string
= ©_arg
;
5764 sals
.sals
= &pending_sal
;
5769 throw_exception (e
);
5776 /* Create a chain of things that always need to be cleaned up. */
5777 old_chain
= make_cleanup (null_cleanup
, 0);
5781 /* Make sure that all storage allocated to SALS gets freed. */
5782 make_cleanup (xfree
, sals
.sals
);
5784 /* Cleanup the addr_string array but not its contents. */
5785 make_cleanup (xfree
, addr_string
);
5788 /* ----------------------------- SNIP -----------------------------
5789 Anything added to the cleanup chain beyond this point is assumed
5790 to be part of a breakpoint. If the breakpoint create succeeds
5791 then the memory is not reclaimed. */
5792 bkpt_chain
= make_cleanup (null_cleanup
, 0);
5794 /* Mark the contents of the addr_string for cleanup. These go on
5795 the bkpt_chain and only occur if the breakpoint create fails. */
5796 for (i
= 0; i
< sals
.nelts
; i
++)
5798 if (addr_string
[i
] != NULL
)
5799 make_cleanup (xfree
, addr_string
[i
]);
5802 /* Resolve all line numbers to PC's and verify that the addresses
5803 are ok for the target. */
5805 breakpoint_sals_to_pc (&sals
, addr_start
);
5807 type_wanted
= (traceflag
5809 : (hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
));
5811 /* Verify that condition can be parsed, before setting any
5812 breakpoints. Allocate a separate condition expression for each
5816 if (parse_condition_and_thread
)
5818 /* Here we only parse 'arg' to separate condition
5819 from thread number, so parsing in context of first
5820 sal is OK. When setting the breakpoint we'll
5821 re-parse it in context of each sal. */
5824 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
5827 make_cleanup (xfree
, cond_string
);
5831 /* Create a private copy of condition string. */
5834 cond_string
= xstrdup (cond_string
);
5835 make_cleanup (xfree
, cond_string
);
5838 create_breakpoints (sals
, addr_string
, cond_string
, type_wanted
,
5839 tempflag
? disp_del
: disp_donttouch
,
5840 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
5844 struct symtab_and_line sal
= {0};
5845 struct breakpoint
*b
;
5847 make_cleanup (xfree
, copy_arg
);
5849 b
= set_raw_breakpoint_without_location (type_wanted
);
5850 set_breakpoint_count (breakpoint_count
+ 1);
5851 b
->number
= breakpoint_count
;
5853 b
->addr_string
= addr_string
[0];
5854 b
->cond_string
= NULL
;
5855 b
->ignore_count
= ignore_count
;
5856 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5857 b
->condition_not_parsed
= 1;
5859 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
5865 warning (_("Multiple breakpoints were set.\n"
5866 "Use the \"delete\" command to delete unwanted breakpoints."));
5867 /* That's it. Discard the cleanups for data inserted into the
5869 discard_cleanups (bkpt_chain
);
5870 /* But cleanup everything else. */
5871 do_cleanups (old_chain
);
5873 /* error call may happen here - have BKPT_CHAIN already discarded. */
5874 update_global_location_list (1);
5877 /* Set a breakpoint.
5878 ARG is a string describing breakpoint address,
5879 condition, and thread.
5880 FLAG specifies if a breakpoint is hardware on,
5881 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5885 break_command_1 (char *arg
, int flag
, int from_tty
)
5887 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5888 int tempflag
= flag
& BP_TEMPFLAG
;
5890 break_command_really (arg
,
5891 NULL
, 0, 1 /* parse arg */,
5892 tempflag
, hardwareflag
, 0 /* traceflag */,
5893 0 /* Ignore count */,
5894 pending_break_support
,
5895 NULL
/* breakpoint_ops */,
5902 set_breakpoint (char *address
, char *condition
,
5903 int hardwareflag
, int tempflag
,
5904 int thread
, int ignore_count
,
5905 int pending
, int enabled
)
5907 break_command_really (address
, condition
, thread
,
5908 0 /* condition and thread are valid. */,
5909 tempflag
, hardwareflag
, 0 /* traceflag */,
5912 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5916 /* Adjust SAL to the first instruction past the function prologue.
5917 The end of the prologue is determined using the line table from
5918 the debugging information. explicit_pc and explicit_line are
5921 If SAL is already past the prologue, then do nothing. */
5924 skip_prologue_sal (struct symtab_and_line
*sal
)
5926 struct symbol
*sym
= find_pc_function (sal
->pc
);
5927 struct symtab_and_line start_sal
;
5932 start_sal
= find_function_start_sal (sym
, 1);
5933 if (sal
->pc
< start_sal
.pc
)
5935 start_sal
.explicit_line
= sal
->explicit_line
;
5936 start_sal
.explicit_pc
= sal
->explicit_pc
;
5941 /* Helper function for break_command_1 and disassemble_command. */
5944 resolve_sal_pc (struct symtab_and_line
*sal
)
5948 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5950 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5951 error (_("No line %d in file \"%s\"."),
5952 sal
->line
, sal
->symtab
->filename
);
5955 /* If this SAL corresponds to a breakpoint inserted using
5956 a line number, then skip the function prologue if necessary. */
5957 if (sal
->explicit_line
)
5959 /* Preserve the original line number. */
5960 int saved_line
= sal
->line
;
5961 skip_prologue_sal (sal
);
5962 sal
->line
= saved_line
;
5966 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5968 struct blockvector
*bv
;
5972 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
5975 sym
= block_linkage_function (b
);
5978 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5979 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
5983 /* It really is worthwhile to have the section, so we'll just
5984 have to look harder. This case can be executed if we have
5985 line numbers but no functions (as can happen in assembly
5988 struct minimal_symbol
*msym
;
5990 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5992 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
5999 break_command (char *arg
, int from_tty
)
6001 break_command_1 (arg
, 0, from_tty
);
6005 tbreak_command (char *arg
, int from_tty
)
6007 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
6011 hbreak_command (char *arg
, int from_tty
)
6013 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
6017 thbreak_command (char *arg
, int from_tty
)
6019 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
6023 stop_command (char *arg
, int from_tty
)
6025 printf_filtered (_("Specify the type of breakpoint to set.\n\
6026 Usage: stop in <function | address>\n\
6027 stop at <line>\n"));
6031 stopin_command (char *arg
, int from_tty
)
6035 if (arg
== (char *) NULL
)
6037 else if (*arg
!= '*')
6042 /* look for a ':'. If this is a line number specification, then
6043 say it is bad, otherwise, it should be an address or
6044 function/method name */
6045 while (*argptr
&& !hasColon
)
6047 hasColon
= (*argptr
== ':');
6052 badInput
= (*argptr
!= ':'); /* Not a class::method */
6054 badInput
= isdigit (*arg
); /* a simple line number */
6058 printf_filtered (_("Usage: stop in <function | address>\n"));
6060 break_command_1 (arg
, 0, from_tty
);
6064 stopat_command (char *arg
, int from_tty
)
6068 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
6075 /* look for a ':'. If there is a '::' then get out, otherwise
6076 it is probably a line number. */
6077 while (*argptr
&& !hasColon
)
6079 hasColon
= (*argptr
== ':');
6084 badInput
= (*argptr
== ':'); /* we have class::method */
6086 badInput
= !isdigit (*arg
); /* not a line number */
6090 printf_filtered (_("Usage: stop at <line>\n"));
6092 break_command_1 (arg
, 0, from_tty
);
6095 /* accessflag: hw_write: watch write,
6096 hw_read: watch read,
6097 hw_access: watch access (read or write) */
6099 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
6101 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
6102 struct symtab_and_line sal
;
6103 struct expression
*exp
;
6104 struct block
*exp_valid_block
;
6105 struct value
*val
, *mark
;
6106 struct frame_info
*frame
;
6107 struct frame_info
*prev_frame
= NULL
;
6108 char *exp_start
= NULL
;
6109 char *exp_end
= NULL
;
6110 char *tok
, *id_tok_start
, *end_tok
;
6112 char *cond_start
= NULL
;
6113 char *cond_end
= NULL
;
6114 struct expression
*cond
= NULL
;
6115 int i
, other_type_used
, target_resources_ok
= 0;
6116 enum bptype bp_type
;
6120 init_sal (&sal
); /* initialize to zeroes */
6122 /* Make sure that we actually have parameters to parse. */
6123 if (arg
!= NULL
&& arg
[0] != '\0')
6125 toklen
= strlen (arg
); /* Size of argument list. */
6127 /* Points tok to the end of the argument list. */
6128 tok
= arg
+ toklen
- 1;
6130 /* Go backwards in the parameters list. Skip the last parameter.
6131 If we're expecting a 'thread <thread_num>' parameter, this should
6132 be the thread identifier. */
6133 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6135 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6138 /* Points end_tok to the beginning of the last token. */
6139 id_tok_start
= tok
+ 1;
6141 /* Go backwards in the parameters list. Skip one more parameter.
6142 If we're expecting a 'thread <thread_num>' parameter, we should
6143 reach a "thread" token. */
6144 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6149 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6152 /* Move the pointer forward to skip the whitespace and
6153 calculate the length of the token. */
6155 toklen
= end_tok
- tok
;
6157 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
6159 /* At this point we've found a "thread" token, which means
6160 the user is trying to set a watchpoint that triggers
6161 only in a specific thread. */
6164 /* Extract the thread ID from the next token. */
6165 thread
= strtol (id_tok_start
, &endp
, 0);
6167 /* Check if the user provided a valid numeric value for the
6169 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
6170 error (_("Invalid thread ID specification %s."), id_tok_start
);
6172 /* Check if the thread actually exists. */
6173 if (!valid_thread_id (thread
))
6174 error (_("Unknown thread %d."), thread
);
6176 /* Truncate the string and get rid of the thread <thread_num>
6177 parameter before the parameter list is parsed by the
6178 evaluate_expression() function. */
6183 /* Parse the rest of the arguments. */
6184 innermost_block
= NULL
;
6186 exp
= parse_exp_1 (&arg
, 0, 0);
6188 /* Remove trailing whitespace from the expression before saving it.
6189 This makes the eventual display of the expression string a bit
6191 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
6194 exp_valid_block
= innermost_block
;
6195 mark
= value_mark ();
6196 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
6198 release_value (val
);
6201 while (*tok
== ' ' || *tok
== '\t')
6205 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
6208 toklen
= end_tok
- tok
;
6209 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
6211 tok
= cond_start
= end_tok
+ 1;
6212 cond
= parse_exp_1 (&tok
, 0, 0);
6216 error (_("Junk at end of command."));
6218 if (accessflag
== hw_read
)
6219 bp_type
= bp_read_watchpoint
;
6220 else if (accessflag
== hw_access
)
6221 bp_type
= bp_access_watchpoint
;
6223 bp_type
= bp_hardware_watchpoint
;
6225 mem_cnt
= can_use_hardware_watchpoint (val
);
6226 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
6227 error (_("Expression cannot be implemented with read/access watchpoint."));
6230 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
6231 target_resources_ok
=
6232 target_can_use_hardware_watchpoint (bp_type
, i
+ mem_cnt
,
6234 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
6235 error (_("Target does not support this type of hardware watchpoint."));
6237 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
6238 error (_("Target can only support one kind of HW watchpoint at a time."));
6241 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
6242 watchpoint could not be set. */
6243 if (!mem_cnt
|| target_resources_ok
<= 0)
6244 bp_type
= bp_watchpoint
;
6246 frame
= block_innermost_frame (exp_valid_block
);
6248 prev_frame
= get_prev_frame (frame
);
6252 /* If the expression is "local", then set up a "watchpoint scope"
6253 breakpoint at the point where we've left the scope of the watchpoint
6254 expression. Create the scope breakpoint before the watchpoint, so
6255 that we will encounter it first in bpstat_stop_status. */
6256 if (innermost_block
&& prev_frame
)
6258 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
6259 bp_watchpoint_scope
);
6261 scope_breakpoint
->enable_state
= bp_enabled
;
6263 /* Automatically delete the breakpoint when it hits. */
6264 scope_breakpoint
->disposition
= disp_del
;
6266 /* Only break in the proper frame (help with recursion). */
6267 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
6269 /* Set the address at which we will stop. */
6270 scope_breakpoint
->loc
->requested_address
6271 = get_frame_pc (prev_frame
);
6272 scope_breakpoint
->loc
->address
6273 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
6274 scope_breakpoint
->type
);
6277 /* Now set up the breakpoint. */
6278 b
= set_raw_breakpoint (sal
, bp_type
);
6279 set_breakpoint_count (breakpoint_count
+ 1);
6280 b
->number
= breakpoint_count
;
6282 b
->disposition
= disp_donttouch
;
6284 b
->exp_valid_block
= exp_valid_block
;
6285 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
6288 b
->loc
->cond
= cond
;
6290 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
6295 b
->watchpoint_frame
= get_frame_id (frame
);
6297 b
->watchpoint_frame
= null_frame_id
;
6299 if (scope_breakpoint
!= NULL
)
6301 /* The scope breakpoint is related to the watchpoint. We will
6302 need to act on them together. */
6303 b
->related_breakpoint
= scope_breakpoint
;
6304 scope_breakpoint
->related_breakpoint
= b
;
6307 value_free_to_mark (mark
);
6309 update_global_location_list (1);
6312 /* Return count of locations need to be watched and can be handled
6313 in hardware. If the watchpoint can not be handled
6314 in hardware return zero. */
6317 can_use_hardware_watchpoint (struct value
*v
)
6319 int found_memory_cnt
= 0;
6320 struct value
*head
= v
;
6322 /* Did the user specifically forbid us to use hardware watchpoints? */
6323 if (!can_use_hw_watchpoints
)
6326 /* Make sure that the value of the expression depends only upon
6327 memory contents, and values computed from them within GDB. If we
6328 find any register references or function calls, we can't use a
6329 hardware watchpoint.
6331 The idea here is that evaluating an expression generates a series
6332 of values, one holding the value of every subexpression. (The
6333 expression a*b+c has five subexpressions: a, b, a*b, c, and
6334 a*b+c.) GDB's values hold almost enough information to establish
6335 the criteria given above --- they identify memory lvalues,
6336 register lvalues, computed values, etcetera. So we can evaluate
6337 the expression, and then scan the chain of values that leaves
6338 behind to decide whether we can detect any possible change to the
6339 expression's final value using only hardware watchpoints.
6341 However, I don't think that the values returned by inferior
6342 function calls are special in any way. So this function may not
6343 notice that an expression involving an inferior function call
6344 can't be watched with hardware watchpoints. FIXME. */
6345 for (; v
; v
= value_next (v
))
6347 if (VALUE_LVAL (v
) == lval_memory
)
6350 /* A lazy memory lvalue is one that GDB never needed to fetch;
6351 we either just used its address (e.g., `a' in `a.b') or
6352 we never needed it at all (e.g., `a' in `a,b'). */
6356 /* Ahh, memory we actually used! Check if we can cover
6357 it with hardware watchpoints. */
6358 struct type
*vtype
= check_typedef (value_type (v
));
6360 /* We only watch structs and arrays if user asked for it
6361 explicitly, never if they just happen to appear in a
6362 middle of some value chain. */
6364 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6365 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6367 CORE_ADDR vaddr
= value_address (v
);
6368 int len
= TYPE_LENGTH (value_type (v
));
6370 if (!target_region_ok_for_hw_watchpoint (vaddr
, len
))
6377 else if (VALUE_LVAL (v
) != not_lval
6378 && deprecated_value_modifiable (v
) == 0)
6379 return 0; /* ??? What does this represent? */
6380 else if (VALUE_LVAL (v
) == lval_register
)
6381 return 0; /* cannot watch a register with a HW watchpoint */
6384 /* The expression itself looks suitable for using a hardware
6385 watchpoint, but give the target machine a chance to reject it. */
6386 return found_memory_cnt
;
6390 watch_command_wrapper (char *arg
, int from_tty
)
6392 watch_command (arg
, from_tty
);
6396 watch_command (char *arg
, int from_tty
)
6398 watch_command_1 (arg
, hw_write
, from_tty
);
6402 rwatch_command_wrapper (char *arg
, int from_tty
)
6404 rwatch_command (arg
, from_tty
);
6408 rwatch_command (char *arg
, int from_tty
)
6410 watch_command_1 (arg
, hw_read
, from_tty
);
6414 awatch_command_wrapper (char *arg
, int from_tty
)
6416 awatch_command (arg
, from_tty
);
6420 awatch_command (char *arg
, int from_tty
)
6422 watch_command_1 (arg
, hw_access
, from_tty
);
6426 /* Helper routines for the until_command routine in infcmd.c. Here
6427 because it uses the mechanisms of breakpoints. */
6429 struct until_break_command_continuation_args
6431 struct breakpoint
*breakpoint
;
6432 struct breakpoint
*breakpoint2
;
6435 /* This function is called by fetch_inferior_event via the
6436 cmd_continuation pointer, to complete the until command. It takes
6437 care of cleaning up the temporary breakpoints set up by the until
6440 until_break_command_continuation (void *arg
)
6442 struct until_break_command_continuation_args
*a
= arg
;
6444 delete_breakpoint (a
->breakpoint
);
6446 delete_breakpoint (a
->breakpoint2
);
6450 until_break_command (char *arg
, int from_tty
, int anywhere
)
6452 struct symtabs_and_lines sals
;
6453 struct symtab_and_line sal
;
6454 struct frame_info
*frame
= get_selected_frame (NULL
);
6455 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6456 struct breakpoint
*breakpoint
;
6457 struct breakpoint
*breakpoint2
= NULL
;
6458 struct cleanup
*old_chain
;
6460 clear_proceed_status ();
6462 /* Set a breakpoint where the user wants it and at return from
6465 if (default_breakpoint_valid
)
6466 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6467 default_breakpoint_line
, (char ***) NULL
, NULL
);
6469 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6470 0, (char ***) NULL
, NULL
);
6472 if (sals
.nelts
!= 1)
6473 error (_("Couldn't get information on specified line."));
6476 xfree (sals
.sals
); /* malloc'd, so freed */
6479 error (_("Junk at end of arguments."));
6481 resolve_sal_pc (&sal
);
6484 /* If the user told us to continue until a specified location,
6485 we don't specify a frame at which we need to stop. */
6486 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6488 /* Otherwise, specify the current frame, because we want to stop only
6489 at the very same frame. */
6490 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6493 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6495 /* Keep within the current frame, or in frames called by the current
6499 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6500 sal
.pc
= get_frame_pc (prev_frame
);
6501 breakpoint2
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6503 make_cleanup_delete_breakpoint (breakpoint2
);
6506 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6508 /* If we are running asynchronously, and proceed call above has actually
6509 managed to start the target, arrange for breakpoints to be
6510 deleted when the target stops. Otherwise, we're already stopped and
6511 delete breakpoints via cleanup chain. */
6513 if (target_can_async_p () && is_running (inferior_ptid
))
6515 struct until_break_command_continuation_args
*args
;
6516 args
= xmalloc (sizeof (*args
));
6518 args
->breakpoint
= breakpoint
;
6519 args
->breakpoint2
= breakpoint2
;
6521 discard_cleanups (old_chain
);
6522 add_continuation (inferior_thread (),
6523 until_break_command_continuation
, args
,
6527 do_cleanups (old_chain
);
6531 ep_skip_leading_whitespace (char **s
)
6533 if ((s
== NULL
) || (*s
== NULL
))
6535 while (isspace (**s
))
6539 /* This function attempts to parse an optional "if <cond>" clause
6540 from the arg string. If one is not found, it returns NULL.
6542 Else, it returns a pointer to the condition string. (It does not
6543 attempt to evaluate the string against a particular block.) And,
6544 it updates arg to point to the first character following the parsed
6545 if clause in the arg string. */
6548 ep_parse_optional_if_clause (char **arg
)
6552 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6555 /* Skip the "if" keyword. */
6558 /* Skip any extra leading whitespace, and record the start of the
6559 condition string. */
6560 ep_skip_leading_whitespace (arg
);
6563 /* Assume that the condition occupies the remainder of the arg string. */
6564 (*arg
) += strlen (cond_string
);
6569 /* This function attempts to parse an optional filename from the arg
6570 string. If one is not found, it returns NULL.
6572 Else, it returns a pointer to the parsed filename. (This function
6573 makes no attempt to verify that a file of that name exists, or is
6574 accessible.) And, it updates arg to point to the first character
6575 following the parsed filename in the arg string.
6577 Note that clients needing to preserve the returned filename for
6578 future access should copy it to their own buffers. */
6580 ep_parse_optional_filename (char **arg
)
6582 static char filename
[1024];
6587 if ((*arg_p
== '\0') || isspace (*arg_p
))
6605 /* Commands to deal with catching events, such as signals, exceptions,
6606 process start/exit, etc. */
6610 catch_fork_temporary
, catch_vfork_temporary
,
6611 catch_fork_permanent
, catch_vfork_permanent
6616 catch_fork_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6618 char *cond_string
= NULL
;
6619 catch_fork_kind fork_kind
;
6622 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
6623 tempflag
= (fork_kind
== catch_fork_temporary
6624 || fork_kind
== catch_vfork_temporary
);
6628 ep_skip_leading_whitespace (&arg
);
6630 /* The allowed syntax is:
6632 catch [v]fork if <cond>
6634 First, check if there's an if clause. */
6635 cond_string
= ep_parse_optional_if_clause (&arg
);
6637 if ((*arg
!= '\0') && !isspace (*arg
))
6638 error (_("Junk at end of arguments."));
6640 /* If this target supports it, create a fork or vfork catchpoint
6641 and enable reporting of such events. */
6644 case catch_fork_temporary
:
6645 case catch_fork_permanent
:
6646 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6647 &catch_fork_breakpoint_ops
);
6649 case catch_vfork_temporary
:
6650 case catch_vfork_permanent
:
6651 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6652 &catch_vfork_breakpoint_ops
);
6655 error (_("unsupported or unknown fork kind; cannot catch it"));
6661 catch_exec_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6664 char *cond_string
= NULL
;
6666 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6670 ep_skip_leading_whitespace (&arg
);
6672 /* The allowed syntax is:
6674 catch exec if <cond>
6676 First, check if there's an if clause. */
6677 cond_string
= ep_parse_optional_if_clause (&arg
);
6679 if ((*arg
!= '\0') && !isspace (*arg
))
6680 error (_("Junk at end of arguments."));
6682 /* If this target supports it, create an exec catchpoint
6683 and enable reporting of such events. */
6684 create_catchpoint (tempflag
, cond_string
, &catch_exec_breakpoint_ops
);
6687 static enum print_stop_action
6688 print_exception_catchpoint (struct breakpoint
*b
)
6690 int bp_temp
, bp_throw
;
6692 annotate_catchpoint (b
->number
);
6694 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6695 if (b
->loc
->address
!= b
->loc
->requested_address
)
6696 breakpoint_adjustment_warning (b
->loc
->requested_address
,
6699 bp_temp
= b
->disposition
== disp_del
;
6701 bp_temp
? "Temporary catchpoint "
6703 if (!ui_out_is_mi_like_p (uiout
))
6704 ui_out_field_int (uiout
, "bkptno", b
->number
);
6706 bp_throw
? " (exception thrown), "
6707 : " (exception caught), ");
6708 if (ui_out_is_mi_like_p (uiout
))
6710 ui_out_field_string (uiout
, "reason",
6711 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
6712 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6713 ui_out_field_int (uiout
, "bkptno", b
->number
);
6715 return PRINT_SRC_AND_LOC
;
6719 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6721 struct value_print_options opts
;
6722 get_user_print_options (&opts
);
6723 if (opts
.addressprint
)
6726 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
6727 ui_out_field_string (uiout
, "addr", "<PENDING>");
6729 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6733 *last_addr
= b
->loc
->address
;
6734 if (strstr (b
->addr_string
, "throw") != NULL
)
6735 ui_out_field_string (uiout
, "what", "exception throw");
6737 ui_out_field_string (uiout
, "what", "exception catch");
6741 print_mention_exception_catchpoint (struct breakpoint
*b
)
6746 bp_temp
= b
->disposition
== disp_del
;
6747 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6748 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
6749 : _("Catchpoint "));
6750 ui_out_field_int (uiout
, "bkptno", b
->number
);
6751 ui_out_text (uiout
, bp_throw
? _(" (throw)")
6755 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6758 NULL
, /* breakpoint_hit */
6759 print_exception_catchpoint
,
6760 print_one_exception_catchpoint
,
6761 print_mention_exception_catchpoint
6765 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6766 enum exception_event_kind ex_event
, int from_tty
)
6768 char *trigger_func_name
;
6770 if (ex_event
== EX_EVENT_CATCH
)
6771 trigger_func_name
= "__cxa_begin_catch";
6773 trigger_func_name
= "__cxa_throw";
6775 break_command_really (trigger_func_name
, cond_string
, -1,
6776 0 /* condition and thread are valid. */,
6779 AUTO_BOOLEAN_TRUE
/* pending */,
6780 &gnu_v3_exception_catchpoint_ops
, from_tty
,
6786 /* Deal with "catch catch" and "catch throw" commands */
6789 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6790 int tempflag
, int from_tty
)
6792 char *cond_string
= NULL
;
6793 struct symtab_and_line
*sal
= NULL
;
6797 ep_skip_leading_whitespace (&arg
);
6799 cond_string
= ep_parse_optional_if_clause (&arg
);
6801 if ((*arg
!= '\0') && !isspace (*arg
))
6802 error (_("Junk at end of arguments."));
6804 if (ex_event
!= EX_EVENT_THROW
6805 && ex_event
!= EX_EVENT_CATCH
)
6806 error (_("Unsupported or unknown exception event; cannot catch it"));
6808 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6811 warning (_("Unsupported with this platform/compiler combination."));
6814 /* Implementation of "catch catch" command. */
6817 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6819 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6820 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
6823 /* Implementation of "catch throw" command. */
6826 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6828 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6829 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
6832 /* Create a breakpoint struct for Ada exception catchpoints. */
6835 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6839 struct expression
*cond
,
6840 struct breakpoint_ops
*ops
,
6844 struct breakpoint
*b
;
6848 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6849 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6850 version for exception catchpoints, because two catchpoints
6851 used for different exception names will use the same address.
6852 In this case, a "breakpoint ... also set at..." warning is
6853 unproductive. Besides. the warning phrasing is also a bit
6854 inapropriate, we should use the word catchpoint, and tell
6855 the user what type of catchpoint it is. The above is good
6856 enough for now, though. */
6859 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6860 set_breakpoint_count (breakpoint_count
+ 1);
6862 b
->enable_state
= bp_enabled
;
6863 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6864 b
->number
= breakpoint_count
;
6865 b
->ignore_count
= 0;
6866 b
->loc
->cond
= cond
;
6867 b
->addr_string
= addr_string
;
6868 b
->language
= language_ada
;
6869 b
->cond_string
= cond_string
;
6870 b
->exp_string
= exp_string
;
6875 update_global_location_list (1);
6878 /* Implement the "catch exception" command. */
6881 catch_ada_exception_command (char *arg
, int from_tty
,
6882 struct cmd_list_element
*command
)
6885 struct symtab_and_line sal
;
6887 char *addr_string
= NULL
;
6888 char *exp_string
= NULL
;
6889 char *cond_string
= NULL
;
6890 struct expression
*cond
= NULL
;
6891 struct breakpoint_ops
*ops
= NULL
;
6893 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6897 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6898 &cond_string
, &cond
, &ops
);
6899 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6900 cond_string
, cond
, ops
, tempflag
,
6904 /* Implement the "catch assert" command. */
6907 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6910 struct symtab_and_line sal
;
6911 char *addr_string
= NULL
;
6912 struct breakpoint_ops
*ops
= NULL
;
6914 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6918 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6919 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6920 tempflag
, from_tty
);
6924 catch_command (char *arg
, int from_tty
)
6926 error (_("Catch requires an event name."));
6931 tcatch_command (char *arg
, int from_tty
)
6933 error (_("Catch requires an event name."));
6936 /* Delete breakpoints by address or line. */
6939 clear_command (char *arg
, int from_tty
)
6941 struct breakpoint
*b
;
6942 VEC(breakpoint_p
) *found
= 0;
6945 struct symtabs_and_lines sals
;
6946 struct symtab_and_line sal
;
6951 sals
= decode_line_spec (arg
, 1);
6956 sals
.sals
= (struct symtab_and_line
*)
6957 xmalloc (sizeof (struct symtab_and_line
));
6958 make_cleanup (xfree
, sals
.sals
);
6959 init_sal (&sal
); /* initialize to zeroes */
6960 sal
.line
= default_breakpoint_line
;
6961 sal
.symtab
= default_breakpoint_symtab
;
6962 sal
.pc
= default_breakpoint_address
;
6963 if (sal
.symtab
== 0)
6964 error (_("No source file specified."));
6972 /* We don't call resolve_sal_pc here. That's not
6973 as bad as it seems, because all existing breakpoints
6974 typically have both file/line and pc set. So, if
6975 clear is given file/line, we can match this to existing
6976 breakpoint without obtaining pc at all.
6978 We only support clearing given the address explicitly
6979 present in breakpoint table. Say, we've set breakpoint
6980 at file:line. There were several PC values for that file:line,
6981 due to optimization, all in one block.
6982 We've picked one PC value. If "clear" is issued with another
6983 PC corresponding to the same file:line, the breakpoint won't
6984 be cleared. We probably can still clear the breakpoint, but
6985 since the other PC value is never presented to user, user
6986 can only find it by guessing, and it does not seem important
6989 /* For each line spec given, delete bps which correspond
6990 to it. Do it in two passes, solely to preserve the current
6991 behavior that from_tty is forced true if we delete more than
6995 for (i
= 0; i
< sals
.nelts
; i
++)
6997 /* If exact pc given, clear bpts at that pc.
6998 If line given (pc == 0), clear all bpts on specified line.
6999 If defaulting, clear all bpts on default line
7002 defaulting sal.pc != 0 tests to do
7007 1 0 <can't happen> */
7011 /* Find all matching breakpoints and add them to
7016 /* Are we going to delete b? */
7017 if (b
->type
!= bp_none
7018 && b
->type
!= bp_watchpoint
7019 && b
->type
!= bp_hardware_watchpoint
7020 && b
->type
!= bp_read_watchpoint
7021 && b
->type
!= bp_access_watchpoint
)
7023 struct bp_location
*loc
= b
->loc
;
7024 for (; loc
; loc
= loc
->next
)
7026 int pc_match
= sal
.pc
7027 && (loc
->address
== sal
.pc
)
7028 && (!section_is_overlay (loc
->section
)
7029 || loc
->section
== sal
.section
);
7030 int line_match
= ((default_match
|| (0 == sal
.pc
))
7031 && b
->source_file
!= NULL
7032 && sal
.symtab
!= NULL
7033 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
7034 && b
->line_number
== sal
.line
);
7035 if (pc_match
|| line_match
)
7044 VEC_safe_push(breakpoint_p
, found
, b
);
7047 /* Now go thru the 'found' chain and delete them. */
7048 if (VEC_empty(breakpoint_p
, found
))
7051 error (_("No breakpoint at %s."), arg
);
7053 error (_("No breakpoint at this line."));
7056 if (VEC_length(breakpoint_p
, found
) > 1)
7057 from_tty
= 1; /* Always report if deleted more than one */
7060 if (VEC_length(breakpoint_p
, found
) == 1)
7061 printf_unfiltered (_("Deleted breakpoint "));
7063 printf_unfiltered (_("Deleted breakpoints "));
7065 breakpoints_changed ();
7067 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
7070 printf_unfiltered ("%d ", b
->number
);
7071 delete_breakpoint (b
);
7074 putchar_unfiltered ('\n');
7077 /* Delete breakpoint in BS if they are `delete' breakpoints and
7078 all breakpoints that are marked for deletion, whether hit or not.
7079 This is called after any breakpoint is hit, or after errors. */
7082 breakpoint_auto_delete (bpstat bs
)
7084 struct breakpoint
*b
, *temp
;
7086 for (; bs
; bs
= bs
->next
)
7087 if (bs
->breakpoint_at
7088 && bs
->breakpoint_at
->owner
7089 && bs
->breakpoint_at
->owner
->disposition
== disp_del
7091 delete_breakpoint (bs
->breakpoint_at
->owner
);
7093 ALL_BREAKPOINTS_SAFE (b
, temp
)
7095 if (b
->disposition
== disp_del_at_next_stop
)
7096 delete_breakpoint (b
);
7100 /* A cleanup function which destroys a vector. */
7103 do_vec_free (void *p
)
7105 VEC(bp_location_p
) **vec
= p
;
7107 VEC_free (bp_location_p
, *vec
);
7110 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
7111 into the inferior, only remove already-inserted locations that no
7112 longer should be inserted. Functions that delete a breakpoint or
7113 breakpoints should pass false, so that deleting a breakpoint
7114 doesn't have the side effect of inserting the locations of other
7115 breakpoints that are marked not-inserted, but should_be_inserted
7116 returns true on them.
7118 This behaviour is useful is situations close to tear-down -- e.g.,
7119 after an exec, while the target still has execution, but breakpoint
7120 shadows of the previous executable image should *NOT* be restored
7121 to the new image; or before detaching, where the target still has
7122 execution and wants to delete breakpoints from GDB's lists, and all
7123 breakpoints had already been removed from the inferior. */
7126 update_global_location_list (int should_insert
)
7128 struct breakpoint
*b
;
7129 struct bp_location
**next
= &bp_location_chain
;
7130 struct bp_location
*loc
;
7131 struct bp_location
*loc2
;
7132 VEC(bp_location_p
) *old_locations
= NULL
;
7135 struct cleanup
*cleanups
;
7137 cleanups
= make_cleanup (do_vec_free
, &old_locations
);
7138 /* Store old locations for future reference. */
7139 for (loc
= bp_location_chain
; loc
; loc
= loc
->global_next
)
7140 VEC_safe_push (bp_location_p
, old_locations
, loc
);
7142 bp_location_chain
= NULL
;
7145 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
7148 next
= &(loc
->global_next
);
7153 /* Identify bp_location instances that are no longer present in the new
7154 list, and therefore should be freed. Note that it's not necessary that
7155 those locations should be removed from inferior -- if there's another
7156 location at the same address (previously marked as duplicate),
7157 we don't need to remove/insert the location. */
7158 for (ix
= 0; VEC_iterate(bp_location_p
, old_locations
, ix
, loc
); ++ix
)
7160 /* Tells if 'loc' is found amoung the new locations. If not, we
7162 int found_object
= 0;
7163 /* Tells if the location should remain inserted in the target. */
7164 int keep_in_target
= 0;
7166 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7173 /* If this location is no longer present, and inserted, look if there's
7174 maybe a new location at the same address. If so, mark that one
7175 inserted, and don't remove this one. This is needed so that we
7176 don't have a time window where a breakpoint at certain location is not
7181 /* If the location is inserted now, we might have to remove it. */
7183 if (found_object
&& should_be_inserted (loc
))
7185 /* The location is still present in the location list, and still
7186 should be inserted. Don't do anything. */
7191 /* The location is either no longer present, or got disabled.
7192 See if there's another location at the same address, in which
7193 case we don't need to remove this one from the target. */
7194 if (breakpoint_address_is_meaningful (loc
->owner
))
7195 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7197 /* For the sake of should_insert_location. The
7198 call to check_duplicates will fix up this later. */
7199 loc2
->duplicate
= 0;
7200 if (should_be_inserted (loc2
)
7201 && loc2
!= loc
&& loc2
->address
== loc
->address
)
7204 loc2
->target_info
= loc
->target_info
;
7211 if (!keep_in_target
)
7213 if (remove_breakpoint (loc
, mark_uninserted
))
7215 /* This is just about all we can do. We could keep this
7216 location on the global list, and try to remove it next
7217 time, but there's no particular reason why we will
7220 Note that at this point, loc->owner is still valid,
7221 as delete_breakpoint frees the breakpoint only
7222 after calling us. */
7223 printf_filtered (_("warning: Error removing breakpoint %d\n"),
7224 loc
->owner
->number
);
7232 if (removed
&& non_stop
)
7234 /* This location was removed from the targets. In non-stop mode,
7235 a race condition is possible where we've removed a breakpoint,
7236 but stop events for that breakpoint are already queued and will
7237 arrive later. To suppress spurious SIGTRAPs reported to user,
7238 we keep this breakpoint location for a bit, and will retire it
7239 after we see 3 * thread_count events.
7240 The theory here is that reporting of events should,
7241 "on the average", be fair, so after that many event we'll see
7242 events from all threads that have anything of interest, and no
7243 longer need to keep this breakpoint. This is just a
7244 heuristic, but if it's wrong, we'll report unexpected SIGTRAP,
7245 which is usability issue, but not a correctness problem. */
7246 loc
->events_till_retirement
= 3 * (thread_count () + 1);
7249 VEC_safe_push (bp_location_p
, moribund_locations
, loc
);
7252 free_bp_location (loc
);
7258 check_duplicates (b
);
7261 if (breakpoints_always_inserted_mode () && should_insert
7262 && (have_live_inferiors ()
7263 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
7264 insert_breakpoint_locations ();
7266 do_cleanups (cleanups
);
7270 breakpoint_retire_moribund (void)
7272 struct bp_location
*loc
;
7275 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
7276 if (--(loc
->events_till_retirement
) == 0)
7278 free_bp_location (loc
);
7279 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
7285 update_global_location_list_nothrow (int inserting
)
7287 struct gdb_exception e
;
7288 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7289 update_global_location_list (inserting
);
7292 /* Clear BPT from a BPS. */
7294 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
7297 for (bs
= bps
; bs
; bs
= bs
->next
)
7298 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7300 bs
->breakpoint_at
= NULL
;
7302 /* bs->commands will be freed later. */
7306 /* Callback for iterate_over_threads. */
7308 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
7310 struct breakpoint
*bpt
= data
;
7311 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
7315 /* Delete a breakpoint and clean up all traces of it in the data
7319 delete_breakpoint (struct breakpoint
*bpt
)
7321 struct breakpoint
*b
;
7322 struct bp_location
*loc
, *next
;
7324 gdb_assert (bpt
!= NULL
);
7326 /* Has this bp already been deleted? This can happen because multiple
7327 lists can hold pointers to bp's. bpstat lists are especial culprits.
7329 One example of this happening is a watchpoint's scope bp. When the
7330 scope bp triggers, we notice that the watchpoint is out of scope, and
7331 delete it. We also delete its scope bp. But the scope bp is marked
7332 "auto-deleting", and is already on a bpstat. That bpstat is then
7333 checked for auto-deleting bp's, which are deleted.
7335 A real solution to this problem might involve reference counts in bp's,
7336 and/or giving them pointers back to their referencing bpstat's, and
7337 teaching delete_breakpoint to only free a bp's storage when no more
7338 references were extent. A cheaper bandaid was chosen. */
7339 if (bpt
->type
== bp_none
)
7342 observer_notify_breakpoint_deleted (bpt
->number
);
7344 if (breakpoint_chain
== bpt
)
7345 breakpoint_chain
= bpt
->next
;
7350 b
->next
= bpt
->next
;
7354 free_command_lines (&bpt
->commands
);
7355 if (bpt
->cond_string
!= NULL
)
7356 xfree (bpt
->cond_string
);
7357 if (bpt
->addr_string
!= NULL
)
7358 xfree (bpt
->addr_string
);
7359 if (bpt
->exp
!= NULL
)
7361 if (bpt
->exp_string
!= NULL
)
7362 xfree (bpt
->exp_string
);
7363 if (bpt
->val
!= NULL
)
7364 value_free (bpt
->val
);
7365 if (bpt
->source_file
!= NULL
)
7366 xfree (bpt
->source_file
);
7367 if (bpt
->exec_pathname
!= NULL
)
7368 xfree (bpt
->exec_pathname
);
7370 /* Be sure no bpstat's are pointing at it after it's been freed. */
7371 /* FIXME, how can we find all bpstat's?
7372 We just check stop_bpstat for now. Note that we cannot just
7373 remove bpstats pointing at bpt from the stop_bpstat list
7374 entirely, as breakpoint commands are associated with the bpstat;
7375 if we remove it here, then the later call to
7376 bpstat_do_actions (&stop_bpstat);
7377 in event-top.c won't do anything, and temporary breakpoints
7378 with commands won't work. */
7380 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
7382 /* Now that breakpoint is removed from breakpoint
7383 list, update the global location list. This
7384 will remove locations that used to belong to
7385 this breakpoint. Do this before freeing
7386 the breakpoint itself, since remove_breakpoint
7387 looks at location's owner. It might be better
7388 design to have location completely self-contained,
7389 but it's not the case now. */
7390 update_global_location_list (0);
7393 /* On the chance that someone will soon try again to delete this same
7394 bp, we mark it as deleted before freeing its storage. */
7395 bpt
->type
= bp_none
;
7401 do_delete_breakpoint_cleanup (void *b
)
7403 delete_breakpoint (b
);
7407 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7409 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7413 delete_command (char *arg
, int from_tty
)
7415 struct breakpoint
*b
, *temp
;
7421 int breaks_to_delete
= 0;
7423 /* Delete all breakpoints if no argument.
7424 Do not delete internal or call-dummy breakpoints, these
7425 have to be deleted with an explicit breakpoint number argument. */
7428 if (b
->type
!= bp_call_dummy
7429 && b
->type
!= bp_shlib_event
7430 && b
->type
!= bp_thread_event
7431 && b
->type
!= bp_overlay_event
7434 breaks_to_delete
= 1;
7439 /* Ask user only if there are some breakpoints to delete. */
7441 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7443 ALL_BREAKPOINTS_SAFE (b
, temp
)
7445 if (b
->type
!= bp_call_dummy
7446 && b
->type
!= bp_shlib_event
7447 && b
->type
!= bp_thread_event
7448 && b
->type
!= bp_overlay_event
7450 delete_breakpoint (b
);
7455 map_breakpoint_numbers (arg
, delete_breakpoint
);
7459 all_locations_are_pending (struct bp_location
*loc
)
7461 for (; loc
; loc
= loc
->next
)
7462 if (!loc
->shlib_disabled
)
7467 /* Subroutine of update_breakpoint_locations to simplify it.
7468 Return non-zero if multiple fns in list LOC have the same name.
7469 Null names are ignored. */
7472 ambiguous_names_p (struct bp_location
*loc
)
7474 struct bp_location
*l
;
7475 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7476 (int (*) (const void *, const void *)) streq
,
7477 NULL
, xcalloc
, xfree
);
7479 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7482 const char *name
= l
->function_name
;
7484 /* Allow for some names to be NULL, ignore them. */
7488 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7490 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7505 update_breakpoint_locations (struct breakpoint
*b
,
7506 struct symtabs_and_lines sals
)
7510 struct bp_location
*existing_locations
= b
->loc
;
7512 /* If there's no new locations, and all existing locations
7513 are pending, don't do anything. This optimizes
7514 the common case where all locations are in the same
7515 shared library, that was unloaded. We'd like to
7516 retain the location, so that when the library
7517 is loaded again, we don't loose the enabled/disabled
7518 status of the individual locations. */
7519 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7524 for (i
= 0; i
< sals
.nelts
; ++i
)
7526 struct bp_location
*new_loc
=
7527 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
7529 /* Reparse conditions, they might contain references to the
7531 if (b
->cond_string
!= NULL
)
7533 struct gdb_exception e
;
7536 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7538 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7543 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7544 b
->number
, e
.message
);
7545 new_loc
->enabled
= 0;
7549 if (b
->source_file
!= NULL
)
7550 xfree (b
->source_file
);
7551 if (sals
.sals
[i
].symtab
== NULL
)
7552 b
->source_file
= NULL
;
7554 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
7556 if (b
->line_number
== 0)
7557 b
->line_number
= sals
.sals
[i
].line
;
7560 /* Update locations of permanent breakpoints. */
7561 if (b
->enable_state
== bp_permanent
)
7562 make_breakpoint_permanent (b
);
7564 /* If possible, carry over 'disable' status from existing breakpoints. */
7566 struct bp_location
*e
= existing_locations
;
7567 /* If there are multiple breakpoints with the same function name,
7568 e.g. for inline functions, comparing function names won't work.
7569 Instead compare pc addresses; this is just a heuristic as things
7570 may have moved, but in practice it gives the correct answer
7571 often enough until a better solution is found. */
7572 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7574 for (; e
; e
= e
->next
)
7576 if (!e
->enabled
&& e
->function_name
)
7578 struct bp_location
*l
= b
->loc
;
7579 if (have_ambiguous_names
)
7581 for (; l
; l
= l
->next
)
7582 if (e
->address
== l
->address
)
7590 for (; l
; l
= l
->next
)
7591 if (l
->function_name
7592 && strcmp (e
->function_name
, l
->function_name
) == 0)
7602 update_global_location_list (1);
7606 /* Reset a breakpoint given it's struct breakpoint * BINT.
7607 The value we return ends up being the return value from catch_errors.
7608 Unused in this case. */
7611 breakpoint_re_set_one (void *bint
)
7613 /* get past catch_errs */
7614 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7618 int *not_found_ptr
= ¬_found
;
7619 struct symtabs_and_lines sals
= {};
7620 struct symtabs_and_lines expanded
;
7622 enum enable_state save_enable
;
7623 struct gdb_exception e
;
7624 struct cleanup
*cleanups
;
7629 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7633 case bp_hardware_breakpoint
:
7635 if (b
->addr_string
== NULL
)
7637 /* Anything without a string can't be re-set. */
7638 delete_breakpoint (b
);
7642 set_language (b
->language
);
7643 input_radix
= b
->input_radix
;
7645 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7647 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7652 int not_found_and_ok
= 0;
7653 /* For pending breakpoints, it's expected that parsing
7654 will fail until the right shared library is loaded.
7655 User has already told to create pending breakpoints and
7656 don't need extra messages. If breakpoint is in bp_shlib_disabled
7657 state, then user already saw the message about that breakpoint
7658 being disabled, and don't want to see more errors. */
7660 && (b
->condition_not_parsed
7661 || (b
->loc
&& b
->loc
->shlib_disabled
)
7662 || b
->enable_state
== bp_disabled
))
7663 not_found_and_ok
= 1;
7665 if (!not_found_and_ok
)
7667 /* We surely don't want to warn about the same breakpoint
7668 10 times. One solution, implemented here, is disable
7669 the breakpoint on error. Another solution would be to
7670 have separate 'warning emitted' flag. Since this
7671 happens only when a binary has changed, I don't know
7672 which approach is better. */
7673 b
->enable_state
= bp_disabled
;
7674 throw_exception (e
);
7681 gdb_assert (sals
.nelts
== 1);
7682 resolve_sal_pc (&sals
.sals
[0]);
7683 if (b
->condition_not_parsed
&& s
&& s
[0])
7685 char *cond_string
= 0;
7689 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7690 &cond_string
, &thread
, &task
);
7692 b
->cond_string
= cond_string
;
7695 b
->condition_not_parsed
= 0;
7697 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7698 cleanups
= make_cleanup (xfree
, sals
.sals
);
7699 update_breakpoint_locations (b
, expanded
);
7700 do_cleanups (cleanups
);
7704 case bp_hardware_watchpoint
:
7705 case bp_read_watchpoint
:
7706 case bp_access_watchpoint
:
7707 /* Watchpoint can be either on expression using entirely global variables,
7708 or it can be on local variables.
7710 Watchpoints of the first kind are never auto-deleted, and even persist
7711 across program restarts. Since they can use variables from shared
7712 libraries, we need to reparse expression as libraries are loaded
7715 Watchpoints on local variables can also change meaning as result
7716 of solib event. For example, if a watchpoint uses both a local and
7717 a global variables in expression, it's a local watchpoint, but
7718 unloading of a shared library will make the expression invalid.
7719 This is not a very common use case, but we still re-evaluate
7720 expression, to avoid surprises to the user.
7722 Note that for local watchpoints, we re-evaluate it only if
7723 watchpoints frame id is still valid. If it's not, it means
7724 the watchpoint is out of scope and will be deleted soon. In fact,
7725 I'm not sure we'll ever be called in this case.
7727 If a local watchpoint's frame id is still valid, then
7728 b->exp_valid_block is likewise valid, and we can safely use it.
7730 Don't do anything about disabled watchpoints, since they will
7731 be reevaluated again when enabled. */
7732 update_watchpoint (b
, 1 /* reparse */);
7734 /* We needn't really do anything to reset these, since the mask
7735 that requests them is unaffected by e.g., new libraries being
7741 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7743 /* Delete overlay event breakpoints; they will be reset later by
7744 breakpoint_re_set. */
7745 case bp_overlay_event
:
7746 delete_breakpoint (b
);
7749 /* This breakpoint is special, it's set up when the inferior
7750 starts and we really don't want to touch it. */
7751 case bp_shlib_event
:
7753 /* Like bp_shlib_event, this breakpoint type is special.
7754 Once it is set up, we do not want to touch it. */
7755 case bp_thread_event
:
7757 /* Keep temporary breakpoints, which can be encountered when we step
7758 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7759 Otherwise these should have been blown away via the cleanup chain
7760 or by breakpoint_init_inferior when we rerun the executable. */
7763 case bp_watchpoint_scope
:
7765 case bp_step_resume
:
7767 case bp_longjmp_resume
:
7774 /* Re-set all breakpoints after symbols have been re-loaded.
7776 If OBJFILE is non-null, create overlay break point only in OBJFILE
7777 (speed optimization). Otherwise rescan all loaded objfiles. */
7780 breakpoint_re_set_objfile (struct objfile
*objfile
)
7782 struct breakpoint
*b
, *temp
;
7783 enum language save_language
;
7784 int save_input_radix
;
7786 save_language
= current_language
->la_language
;
7787 save_input_radix
= input_radix
;
7788 ALL_BREAKPOINTS_SAFE (b
, temp
)
7790 /* Format possible error msg */
7791 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7793 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7794 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7795 do_cleanups (cleanups
);
7797 set_language (save_language
);
7798 input_radix
= save_input_radix
;
7800 if (objfile
== NULL
)
7801 ALL_OBJFILES (objfile
)
7802 create_overlay_event_breakpoint ("_ovly_debug_event", objfile
);
7804 create_overlay_event_breakpoint ("_ovly_debug_event", objfile
);
7807 /* Re-set all breakpoints after symbols have been re-loaded. */
7810 breakpoint_re_set (void)
7812 breakpoint_re_set_objfile (NULL
);
7815 /* Reset the thread number of this breakpoint:
7817 - If the breakpoint is for all threads, leave it as-is.
7818 - Else, reset it to the current thread for inferior_ptid. */
7820 breakpoint_re_set_thread (struct breakpoint
*b
)
7822 if (b
->thread
!= -1)
7824 if (in_thread_list (inferior_ptid
))
7825 b
->thread
= pid_to_thread_id (inferior_ptid
);
7829 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7830 If from_tty is nonzero, it prints a message to that effect,
7831 which ends with a period (no newline). */
7834 set_ignore_count (int bptnum
, int count
, int from_tty
)
7836 struct breakpoint
*b
;
7842 if (b
->number
== bptnum
)
7844 b
->ignore_count
= count
;
7848 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7850 else if (count
== 1)
7851 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7854 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7857 breakpoints_changed ();
7858 observer_notify_breakpoint_modified (b
->number
);
7862 error (_("No breakpoint number %d."), bptnum
);
7866 make_breakpoint_silent (struct breakpoint
*b
)
7868 /* Silence the breakpoint. */
7872 /* Command to set ignore-count of breakpoint N to COUNT. */
7875 ignore_command (char *args
, int from_tty
)
7881 error_no_arg (_("a breakpoint number"));
7883 num
= get_number (&p
);
7885 error (_("bad breakpoint number: '%s'"), args
);
7887 error (_("Second argument (specified ignore-count) is missing."));
7889 set_ignore_count (num
,
7890 longest_to_int (value_as_long (parse_and_eval (p
))),
7893 printf_filtered ("\n");
7896 /* Call FUNCTION on each of the breakpoints
7897 whose numbers are given in ARGS. */
7900 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7905 struct breakpoint
*b
, *tmp
;
7909 error_no_arg (_("one or more breakpoint numbers"));
7916 num
= get_number_or_range (&p1
);
7919 warning (_("bad breakpoint number at or near '%s'"), p
);
7923 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7924 if (b
->number
== num
)
7926 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7929 if (related_breakpoint
)
7930 function (related_breakpoint
);
7934 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7940 static struct bp_location
*
7941 find_location_by_number (char *number
)
7943 char *dot
= strchr (number
, '.');
7947 struct breakpoint
*b
;
7948 struct bp_location
*loc
;
7953 bp_num
= get_number_or_range (&p1
);
7955 error (_("Bad breakpoint number '%s'"), number
);
7958 if (b
->number
== bp_num
)
7963 if (!b
|| b
->number
!= bp_num
)
7964 error (_("Bad breakpoint number '%s'"), number
);
7967 loc_num
= get_number_or_range (&p1
);
7969 error (_("Bad breakpoint location number '%s'"), number
);
7973 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7976 error (_("Bad breakpoint location number '%s'"), dot
+1);
7982 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7983 If from_tty is nonzero, it prints a message to that effect,
7984 which ends with a period (no newline). */
7987 disable_breakpoint (struct breakpoint
*bpt
)
7989 /* Never disable a watchpoint scope breakpoint; we want to
7990 hit them when we leave scope so we can delete both the
7991 watchpoint and its scope breakpoint at that time. */
7992 if (bpt
->type
== bp_watchpoint_scope
)
7995 /* You can't disable permanent breakpoints. */
7996 if (bpt
->enable_state
== bp_permanent
)
7999 bpt
->enable_state
= bp_disabled
;
8001 update_global_location_list (0);
8003 observer_notify_breakpoint_modified (bpt
->number
);
8007 disable_command (char *args
, int from_tty
)
8009 struct breakpoint
*bpt
;
8011 ALL_BREAKPOINTS (bpt
)
8015 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
8021 case bp_hardware_breakpoint
:
8023 case bp_hardware_watchpoint
:
8024 case bp_read_watchpoint
:
8025 case bp_access_watchpoint
:
8026 disable_breakpoint (bpt
);
8030 else if (strchr (args
, '.'))
8032 struct bp_location
*loc
= find_location_by_number (args
);
8035 update_global_location_list (0);
8038 map_breakpoint_numbers (args
, disable_breakpoint
);
8042 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
8044 int target_resources_ok
, other_type_used
;
8047 if (bpt
->type
== bp_hardware_breakpoint
)
8050 i
= hw_breakpoint_used_count ();
8051 target_resources_ok
=
8052 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8054 if (target_resources_ok
== 0)
8055 error (_("No hardware breakpoint support in the target."));
8056 else if (target_resources_ok
< 0)
8057 error (_("Hardware breakpoints used exceeds limit."));
8060 if (bpt
->type
== bp_watchpoint
8061 || bpt
->type
== bp_hardware_watchpoint
8062 || bpt
->type
== bp_read_watchpoint
8063 || bpt
->type
== bp_access_watchpoint
)
8065 struct gdb_exception e
;
8067 TRY_CATCH (e
, RETURN_MASK_ALL
)
8069 update_watchpoint (bpt
, 1 /* reparse */);
8073 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
8079 if (bpt
->enable_state
!= bp_permanent
)
8080 bpt
->enable_state
= bp_enabled
;
8081 bpt
->disposition
= disposition
;
8082 update_global_location_list (1);
8083 breakpoints_changed ();
8085 observer_notify_breakpoint_modified (bpt
->number
);
8090 enable_breakpoint (struct breakpoint
*bpt
)
8092 do_enable_breakpoint (bpt
, bpt
->disposition
);
8095 /* The enable command enables the specified breakpoints (or all defined
8096 breakpoints) so they once again become (or continue to be) effective
8097 in stopping the inferior. */
8100 enable_command (char *args
, int from_tty
)
8102 struct breakpoint
*bpt
;
8104 ALL_BREAKPOINTS (bpt
)
8108 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
8114 case bp_hardware_breakpoint
:
8116 case bp_hardware_watchpoint
:
8117 case bp_read_watchpoint
:
8118 case bp_access_watchpoint
:
8119 enable_breakpoint (bpt
);
8123 else if (strchr (args
, '.'))
8125 struct bp_location
*loc
= find_location_by_number (args
);
8128 update_global_location_list (1);
8131 map_breakpoint_numbers (args
, enable_breakpoint
);
8135 enable_once_breakpoint (struct breakpoint
*bpt
)
8137 do_enable_breakpoint (bpt
, disp_disable
);
8141 enable_once_command (char *args
, int from_tty
)
8143 map_breakpoint_numbers (args
, enable_once_breakpoint
);
8147 enable_delete_breakpoint (struct breakpoint
*bpt
)
8149 do_enable_breakpoint (bpt
, disp_del
);
8153 enable_delete_command (char *args
, int from_tty
)
8155 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
8159 set_breakpoint_cmd (char *args
, int from_tty
)
8164 show_breakpoint_cmd (char *args
, int from_tty
)
8168 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
8170 struct symtabs_and_lines
8171 decode_line_spec_1 (char *string
, int funfirstline
)
8173 struct symtabs_and_lines sals
;
8175 error (_("Empty line specification."));
8176 if (default_breakpoint_valid
)
8177 sals
= decode_line_1 (&string
, funfirstline
,
8178 default_breakpoint_symtab
,
8179 default_breakpoint_line
,
8180 (char ***) NULL
, NULL
);
8182 sals
= decode_line_1 (&string
, funfirstline
,
8183 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8185 error (_("Junk at end of line specification: %s"), string
);
8189 /* Create and insert a raw software breakpoint at PC. Return an
8190 identifier, which should be used to remove the breakpoint later.
8191 In general, places which call this should be using something on the
8192 breakpoint chain instead; this function should be eliminated
8196 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8198 struct bp_target_info
*bp_tgt
;
8200 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8201 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8203 bp_tgt
->placed_address
= pc
;
8204 if (target_insert_breakpoint (bp_tgt
) != 0)
8206 /* Could not insert the breakpoint. */
8214 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8217 deprecated_remove_raw_breakpoint (void *bp
)
8219 struct bp_target_info
*bp_tgt
= bp
;
8222 ret
= target_remove_breakpoint (bp_tgt
);
8228 /* One (or perhaps two) breakpoints used for software single stepping. */
8230 static void *single_step_breakpoints
[2];
8232 /* Create and insert a breakpoint for software single step. */
8235 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8239 if (single_step_breakpoints
[0] == NULL
)
8240 bpt_p
= &single_step_breakpoints
[0];
8243 gdb_assert (single_step_breakpoints
[1] == NULL
);
8244 bpt_p
= &single_step_breakpoints
[1];
8247 /* NOTE drow/2006-04-11: A future improvement to this function would be
8248 to only create the breakpoints once, and actually put them on the
8249 breakpoint chain. That would let us use set_raw_breakpoint. We could
8250 adjust the addresses each time they were needed. Doing this requires
8251 corresponding changes elsewhere where single step breakpoints are
8252 handled, however. So, for now, we use this. */
8254 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8256 error (_("Could not insert single-step breakpoint at 0x%s"),
8257 paddr_nz (next_pc
));
8260 /* Remove and delete any breakpoints used for software single step. */
8263 remove_single_step_breakpoints (void)
8265 gdb_assert (single_step_breakpoints
[0] != NULL
);
8267 /* See insert_single_step_breakpoint for more about this deprecated
8269 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8270 single_step_breakpoints
[0] = NULL
;
8272 if (single_step_breakpoints
[1] != NULL
)
8274 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8275 single_step_breakpoints
[1] = NULL
;
8279 /* Check whether a software single-step breakpoint is inserted at PC. */
8282 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8286 for (i
= 0; i
< 2; i
++)
8288 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8289 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8296 /* Tracepoint-specific operations. */
8298 /* Set tracepoint count to NUM. */
8300 set_tracepoint_count (int num
)
8302 tracepoint_count
= num
;
8303 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
8307 trace_command (char *arg
, int from_tty
)
8309 break_command_really (arg
,
8310 NULL
, 0, 1 /* parse arg */,
8311 0 /* tempflag */, 0 /* hardwareflag */,
8313 0 /* Ignore count */,
8314 pending_break_support
,
8318 set_tracepoint_count (breakpoint_count
);
8321 /* Print information on tracepoint number TPNUM_EXP, or all if
8325 tracepoints_info (char *tpnum_exp
, int from_tty
)
8327 struct breakpoint
*b
;
8328 int tps_to_list
= 0;
8330 /* In the no-arguments case, say "No tracepoints" if none found. */
8343 ui_out_message (uiout
, 0, "No tracepoints.\n");
8348 /* Otherwise be the same as "info break". */
8349 breakpoints_info (tpnum_exp
, from_tty
);
8352 /* The 'enable trace' command enables tracepoints.
8353 Not supported by all targets. */
8355 enable_trace_command (char *args
, int from_tty
)
8357 enable_command (args
, from_tty
);
8360 /* The 'disable trace' command disables tracepoints.
8361 Not supported by all targets. */
8363 disable_trace_command (char *args
, int from_tty
)
8365 disable_command (args
, from_tty
);
8368 /* Remove a tracepoint (or all if no argument) */
8370 delete_trace_command (char *arg
, int from_tty
)
8372 struct breakpoint
*b
, *temp
;
8378 int breaks_to_delete
= 0;
8380 /* Delete all breakpoints if no argument.
8381 Do not delete internal or call-dummy breakpoints, these
8382 have to be deleted with an explicit breakpoint number argument. */
8387 breaks_to_delete
= 1;
8392 /* Ask user only if there are some breakpoints to delete. */
8394 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
8396 ALL_BREAKPOINTS_SAFE (b
, temp
)
8398 if (b
->type
== bp_tracepoint
8400 delete_breakpoint (b
);
8405 map_breakpoint_numbers (arg
, delete_breakpoint
);
8408 /* Set passcount for tracepoint.
8410 First command argument is passcount, second is tracepoint number.
8411 If tracepoint number omitted, apply to most recently defined.
8412 Also accepts special argument "all". */
8415 trace_pass_command (char *args
, int from_tty
)
8417 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
8421 if (args
== 0 || *args
== 0)
8422 error (_("passcount command requires an argument (count + optional TP num)"));
8424 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
8426 while (*args
&& isspace ((int) *args
))
8429 if (*args
&& strncasecmp (args
, "all", 3) == 0)
8431 args
+= 3; /* Skip special argument "all". */
8434 error (_("Junk at end of arguments."));
8437 t1
= get_tracepoint_by_number (&args
, 1, 1);
8443 ALL_TRACEPOINTS (t2
)
8444 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
8446 t2
->pass_count
= count
;
8447 observer_notify_tracepoint_modified (t2
->number
);
8449 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
8453 t1
= get_tracepoint_by_number (&args
, 1, 0);
8460 get_tracepoint (int num
)
8462 struct breakpoint
*t
;
8465 if (t
->number
== num
)
8471 /* Utility: parse a tracepoint number and look it up in the list.
8472 If MULTI_P is true, there might be a range of tracepoints in ARG.
8473 if OPTIONAL_P is true, then if the argument is missing, the most
8474 recent tracepoint (tracepoint_count) is returned. */
8476 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
8478 extern int tracepoint_count
;
8479 struct breakpoint
*t
;
8481 char *instring
= arg
== NULL
? NULL
: *arg
;
8483 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
8486 tpnum
= tracepoint_count
;
8488 error_no_arg (_("tracepoint number"));
8491 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
8495 if (instring
&& *instring
)
8496 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
8499 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
8504 if (t
->number
== tpnum
)
8509 /* FIXME: if we are in the middle of a range we don't want to give
8510 a message. The current interface to get_number_or_range doesn't
8511 allow us to discover this. */
8512 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
8516 /* save-tracepoints command */
8518 tracepoint_save_command (char *args
, int from_tty
)
8520 struct breakpoint
*tp
;
8522 struct action_line
*line
;
8524 char *i1
= " ", *i2
= " ";
8525 char *indent
, *actionline
, *pathname
;
8527 struct cleanup
*cleanup
;
8529 if (args
== 0 || *args
== 0)
8530 error (_("Argument required (file name in which to save tracepoints)"));
8532 /* See if we have anything to save. */
8533 ALL_TRACEPOINTS (tp
)
8540 warning (_("save-tracepoints: no tracepoints to save."));
8544 pathname
= tilde_expand (args
);
8545 cleanup
= make_cleanup (xfree
, pathname
);
8546 fp
= fopen (pathname
, "w");
8548 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
8549 args
, safe_strerror (errno
));
8550 make_cleanup_fclose (fp
);
8552 ALL_TRACEPOINTS (tp
)
8554 if (tp
->addr_string
)
8555 fprintf (fp
, "trace %s\n", tp
->addr_string
);
8558 sprintf_vma (tmp
, tp
->loc
->address
);
8559 fprintf (fp
, "trace *0x%s\n", tmp
);
8563 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
8567 fprintf (fp
, " actions\n");
8569 for (line
= tp
->actions
; line
; line
= line
->next
)
8571 struct cmd_list_element
*cmd
;
8573 QUIT
; /* allow user to bail out with ^C */
8574 actionline
= line
->action
;
8575 while (isspace ((int) *actionline
))
8578 fprintf (fp
, "%s%s\n", indent
, actionline
);
8579 if (*actionline
!= '#') /* skip for comment lines */
8581 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
8583 error (_("Bad action list item: %s"), actionline
);
8584 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
8586 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
8592 do_cleanups (cleanup
);
8594 printf_filtered (_("Tracepoints saved to file '%s'.\n"), args
);
8598 /* Create a vector of all tracepoints. */
8603 VEC(breakpoint_p
) *tp_vec
= 0;
8604 struct breakpoint
*tp
;
8606 ALL_TRACEPOINTS (tp
)
8608 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
8615 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8616 It is defined as a macro to prevent duplication.
8617 COMMAND should be a string constant containing the name of the command. */
8618 #define BREAK_ARGS_HELP(command) \
8619 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8620 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8621 If a line number is specified, break at start of code for that line.\n\
8622 If a function is specified, break at start of code for that function.\n\
8623 If an address is specified, break at that exact address.\n\
8624 With no LOCATION, uses current execution address of selected stack frame.\n\
8625 This is useful for breaking on return to a stack frame.\n\
8627 THREADNUM is the number from \"info threads\".\n\
8628 CONDITION is a boolean expression.\n\
8630 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8632 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8634 /* List of subcommands for "catch". */
8635 static struct cmd_list_element
*catch_cmdlist
;
8637 /* List of subcommands for "tcatch". */
8638 static struct cmd_list_element
*tcatch_cmdlist
;
8640 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
8641 lists, and pass some additional user data to the command function. */
8643 add_catch_command (char *name
, char *docstring
,
8644 void (*sfunc
) (char *args
, int from_tty
,
8645 struct cmd_list_element
*command
),
8646 void *user_data_catch
,
8647 void *user_data_tcatch
)
8649 struct cmd_list_element
*command
;
8651 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8653 set_cmd_sfunc (command
, sfunc
);
8654 set_cmd_context (command
, user_data_catch
);
8656 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8658 set_cmd_sfunc (command
, sfunc
);
8659 set_cmd_context (command
, user_data_tcatch
);
8663 _initialize_breakpoint (void)
8665 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8666 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8667 struct cmd_list_element
*c
;
8669 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8671 breakpoint_chain
= 0;
8672 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8673 before a breakpoint is set. */
8674 breakpoint_count
= 0;
8676 tracepoint_count
= 0;
8678 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8679 Set ignore-count of breakpoint number N to COUNT.\n\
8680 Usage is `ignore N COUNT'."));
8682 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8684 add_com ("commands", class_breakpoint
, commands_command
, _("\
8685 Set commands to be executed when a breakpoint is hit.\n\
8686 Give breakpoint number as argument after \"commands\".\n\
8687 With no argument, the targeted breakpoint is the last one set.\n\
8688 The commands themselves follow starting on the next line.\n\
8689 Type a line containing \"end\" to indicate the end of them.\n\
8690 Give \"silent\" as the first line to make the breakpoint silent;\n\
8691 then no output is printed when it is hit, except what the commands print."));
8693 add_com ("condition", class_breakpoint
, condition_command
, _("\
8694 Specify breakpoint number N to break only if COND is true.\n\
8695 Usage is `condition N COND', where N is an integer and COND is an\n\
8696 expression to be evaluated whenever breakpoint N is reached."));
8698 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8699 Set a temporary breakpoint.\n\
8700 Like \"break\" except the breakpoint is only temporary,\n\
8701 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8702 by using \"enable delete\" on the breakpoint number.\n\
8704 BREAK_ARGS_HELP ("tbreak")));
8705 set_cmd_completer (c
, location_completer
);
8707 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8708 Set a hardware assisted breakpoint.\n\
8709 Like \"break\" except the breakpoint requires hardware support,\n\
8710 some target hardware may not have this support.\n\
8712 BREAK_ARGS_HELP ("hbreak")));
8713 set_cmd_completer (c
, location_completer
);
8715 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8716 Set a temporary hardware assisted breakpoint.\n\
8717 Like \"hbreak\" except the breakpoint is only temporary,\n\
8718 so it will be deleted when hit.\n\
8720 BREAK_ARGS_HELP ("thbreak")));
8721 set_cmd_completer (c
, location_completer
);
8723 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8724 Enable some breakpoints.\n\
8725 Give breakpoint numbers (separated by spaces) as arguments.\n\
8726 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8727 This is used to cancel the effect of the \"disable\" command.\n\
8728 With a subcommand you can enable temporarily."),
8729 &enablelist
, "enable ", 1, &cmdlist
);
8731 add_com ("ab", class_breakpoint
, enable_command
, _("\
8732 Enable some breakpoints.\n\
8733 Give breakpoint numbers (separated by spaces) as arguments.\n\
8734 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8735 This is used to cancel the effect of the \"disable\" command.\n\
8736 With a subcommand you can enable temporarily."));
8738 add_com_alias ("en", "enable", class_breakpoint
, 1);
8740 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8741 Enable some breakpoints.\n\
8742 Give breakpoint numbers (separated by spaces) as arguments.\n\
8743 This is used to cancel the effect of the \"disable\" command.\n\
8744 May be abbreviated to simply \"enable\".\n"),
8745 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8747 add_cmd ("once", no_class
, enable_once_command
, _("\
8748 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8749 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8752 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8753 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8754 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8757 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8758 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8759 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8762 add_cmd ("once", no_class
, enable_once_command
, _("\
8763 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8764 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8767 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8768 Disable some breakpoints.\n\
8769 Arguments are breakpoint numbers with spaces in between.\n\
8770 To disable all breakpoints, give no argument.\n\
8771 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8772 &disablelist
, "disable ", 1, &cmdlist
);
8773 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8774 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8776 add_com ("sb", class_breakpoint
, disable_command
, _("\
8777 Disable some breakpoints.\n\
8778 Arguments are breakpoint numbers with spaces in between.\n\
8779 To disable all breakpoints, give no argument.\n\
8780 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8782 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8783 Disable some breakpoints.\n\
8784 Arguments are breakpoint numbers with spaces in between.\n\
8785 To disable all breakpoints, give no argument.\n\
8786 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8787 This command may be abbreviated \"disable\"."),
8790 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8791 Delete some breakpoints or auto-display expressions.\n\
8792 Arguments are breakpoint numbers with spaces in between.\n\
8793 To delete all breakpoints, give no argument.\n\
8795 Also a prefix command for deletion of other GDB objects.\n\
8796 The \"unset\" command is also an alias for \"delete\"."),
8797 &deletelist
, "delete ", 1, &cmdlist
);
8798 add_com_alias ("d", "delete", class_breakpoint
, 1);
8799 add_com_alias ("del", "delete", class_breakpoint
, 1);
8801 add_com ("db", class_breakpoint
, delete_command
, _("\
8802 Delete some breakpoints.\n\
8803 Arguments are breakpoint numbers with spaces in between.\n\
8804 To delete all breakpoints, give no argument.\n"));
8806 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8807 Delete some breakpoints or auto-display expressions.\n\
8808 Arguments are breakpoint numbers with spaces in between.\n\
8809 To delete all breakpoints, give no argument.\n\
8810 This command may be abbreviated \"delete\"."),
8813 add_com ("clear", class_breakpoint
, clear_command
, _("\
8814 Clear breakpoint at specified line or function.\n\
8815 Argument may be line number, function name, or \"*\" and an address.\n\
8816 If line number is specified, all breakpoints in that line are cleared.\n\
8817 If function is specified, breakpoints at beginning of function are cleared.\n\
8818 If an address is specified, breakpoints at that address are cleared.\n\
8820 With no argument, clears all breakpoints in the line that the selected frame\n\
8823 See also the \"delete\" command which clears breakpoints by number."));
8825 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8826 Set breakpoint at specified line or function.\n"
8827 BREAK_ARGS_HELP ("break")));
8828 set_cmd_completer (c
, location_completer
);
8830 add_com_alias ("b", "break", class_run
, 1);
8831 add_com_alias ("br", "break", class_run
, 1);
8832 add_com_alias ("bre", "break", class_run
, 1);
8833 add_com_alias ("brea", "break", class_run
, 1);
8836 add_com_alias ("ba", "break", class_breakpoint
, 1);
8840 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8841 Break in function/address or break at a line in the current file."),
8842 &stoplist
, "stop ", 1, &cmdlist
);
8843 add_cmd ("in", class_breakpoint
, stopin_command
,
8844 _("Break in function or address."), &stoplist
);
8845 add_cmd ("at", class_breakpoint
, stopat_command
,
8846 _("Break at a line in the current file."), &stoplist
);
8847 add_com ("status", class_info
, breakpoints_info
, _("\
8848 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8849 The \"Type\" column indicates one of:\n\
8850 \tbreakpoint - normal breakpoint\n\
8851 \twatchpoint - watchpoint\n\
8852 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8853 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8854 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8855 address and file/line number respectively.\n\
8857 Convenience variable \"$_\" and default examine address for \"x\"\n\
8858 are set to the address of the last breakpoint listed unless the command\n\
8859 is prefixed with \"server \".\n\n\
8860 Convenience variable \"$bpnum\" contains the number of the last\n\
8864 add_info ("breakpoints", breakpoints_info
, _("\
8865 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8866 The \"Type\" column indicates one of:\n\
8867 \tbreakpoint - normal breakpoint\n\
8868 \twatchpoint - watchpoint\n\
8869 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8870 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8871 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8872 address and file/line number respectively.\n\
8874 Convenience variable \"$_\" and default examine address for \"x\"\n\
8875 are set to the address of the last breakpoint listed unless the command\n\
8876 is prefixed with \"server \".\n\n\
8877 Convenience variable \"$bpnum\" contains the number of the last\n\
8881 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8882 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8883 The \"Type\" column indicates one of:\n\
8884 \tbreakpoint - normal breakpoint\n\
8885 \twatchpoint - watchpoint\n\
8886 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8887 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8888 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8889 address and file/line number respectively.\n\
8891 Convenience variable \"$_\" and default examine address for \"x\"\n\
8892 are set to the address of the last breakpoint listed unless the command\n\
8893 is prefixed with \"server \".\n\n\
8894 Convenience variable \"$bpnum\" contains the number of the last\n\
8897 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8898 Status of all breakpoints, or breakpoint number NUMBER.\n\
8899 The \"Type\" column indicates one of:\n\
8900 \tbreakpoint - normal breakpoint\n\
8901 \twatchpoint - watchpoint\n\
8902 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8903 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8904 \tuntil - internal breakpoint used by the \"until\" command\n\
8905 \tfinish - internal breakpoint used by the \"finish\" command\n\
8906 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8907 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8908 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8909 address and file/line number respectively.\n\
8911 Convenience variable \"$_\" and default examine address for \"x\"\n\
8912 are set to the address of the last breakpoint listed unless the command\n\
8913 is prefixed with \"server \".\n\n\
8914 Convenience variable \"$bpnum\" contains the number of the last\n\
8916 &maintenanceinfolist
);
8918 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
8919 Set catchpoints to catch events."),
8920 &catch_cmdlist
, "catch ",
8921 0/*allow-unknown*/, &cmdlist
);
8923 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
8924 Set temporary catchpoints to catch events."),
8925 &tcatch_cmdlist
, "tcatch ",
8926 0/*allow-unknown*/, &cmdlist
);
8928 /* Add catch and tcatch sub-commands. */
8929 add_catch_command ("catch", _("\
8930 Catch an exception, when caught.\n\
8931 With an argument, catch only exceptions with the given name."),
8932 catch_catch_command
,
8935 add_catch_command ("throw", _("\
8936 Catch an exception, when thrown.\n\
8937 With an argument, catch only exceptions with the given name."),
8938 catch_throw_command
,
8941 add_catch_command ("fork", _("Catch calls to fork."),
8942 catch_fork_command_1
,
8943 (void *) (uintptr_t) catch_fork_permanent
,
8944 (void *) (uintptr_t) catch_fork_temporary
);
8945 add_catch_command ("vfork", _("Catch calls to vfork."),
8946 catch_fork_command_1
,
8947 (void *) (uintptr_t) catch_vfork_permanent
,
8948 (void *) (uintptr_t) catch_vfork_temporary
);
8949 add_catch_command ("exec", _("Catch calls to exec."),
8950 catch_exec_command_1
,
8953 add_catch_command ("exception", _("\
8954 Catch Ada exceptions, when raised.\n\
8955 With an argument, catch only exceptions with the given name."),
8956 catch_ada_exception_command
,
8959 add_catch_command ("assert", _("\
8960 Catch failed Ada assertions, when raised.\n\
8961 With an argument, catch only exceptions with the given name."),
8962 catch_assert_command
,
8966 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8967 Set a watchpoint for an expression.\n\
8968 A watchpoint stops execution of your program whenever the value of\n\
8969 an expression changes."));
8970 set_cmd_completer (c
, expression_completer
);
8972 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8973 Set a read watchpoint for an expression.\n\
8974 A watchpoint stops execution of your program whenever the value of\n\
8975 an expression is read."));
8976 set_cmd_completer (c
, expression_completer
);
8978 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8979 Set a watchpoint for an expression.\n\
8980 A watchpoint stops execution of your program whenever the value of\n\
8981 an expression is either read or written."));
8982 set_cmd_completer (c
, expression_completer
);
8984 add_info ("watchpoints", breakpoints_info
,
8985 _("Synonym for ``info breakpoints''."));
8988 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8989 respond to changes - contrary to the description. */
8990 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8991 &can_use_hw_watchpoints
, _("\
8992 Set debugger's willingness to use watchpoint hardware."), _("\
8993 Show debugger's willingness to use watchpoint hardware."), _("\
8994 If zero, gdb will not use hardware for new watchpoints, even if\n\
8995 such is available. (However, any hardware watchpoints that were\n\
8996 created before setting this to nonzero, will continue to use watchpoint\n\
8999 show_can_use_hw_watchpoints
,
9000 &setlist
, &showlist
);
9002 can_use_hw_watchpoints
= 1;
9004 /* Tracepoint manipulation commands. */
9006 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
9007 Set a tracepoint at specified line or function.\n\
9009 BREAK_ARGS_HELP ("trace") "\n\
9010 Do \"help tracepoints\" for info on other tracepoint commands."));
9011 set_cmd_completer (c
, location_completer
);
9013 add_com_alias ("tp", "trace", class_alias
, 0);
9014 add_com_alias ("tr", "trace", class_alias
, 1);
9015 add_com_alias ("tra", "trace", class_alias
, 1);
9016 add_com_alias ("trac", "trace", class_alias
, 1);
9018 add_info ("tracepoints", tracepoints_info
, _("\
9019 Status of tracepoints, or tracepoint number NUMBER.\n\
9020 Convenience variable \"$tpnum\" contains the number of the\n\
9021 last tracepoint set."));
9023 add_info_alias ("tp", "tracepoints", 1);
9025 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
9026 Delete specified tracepoints.\n\
9027 Arguments are tracepoint numbers, separated by spaces.\n\
9028 No argument means delete all tracepoints."),
9031 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
9032 Disable specified tracepoints.\n\
9033 Arguments are tracepoint numbers, separated by spaces.\n\
9034 No argument means disable all tracepoints."),
9036 deprecate_cmd (c
, "disable");
9038 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
9039 Enable specified tracepoints.\n\
9040 Arguments are tracepoint numbers, separated by spaces.\n\
9041 No argument means enable all tracepoints."),
9043 deprecate_cmd (c
, "enable");
9045 add_com ("passcount", class_trace
, trace_pass_command
, _("\
9046 Set the passcount for a tracepoint.\n\
9047 The trace will end when the tracepoint has been passed 'count' times.\n\
9048 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
9049 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
9051 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
9052 Save current tracepoint definitions as a script.\n\
9053 Use the 'source' command in another debug session to restore them."));
9054 set_cmd_completer (c
, filename_completer
);
9056 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
9057 Breakpoint specific settings\n\
9058 Configure various breakpoint-specific variables such as\n\
9059 pending breakpoint behavior"),
9060 &breakpoint_set_cmdlist
, "set breakpoint ",
9061 0/*allow-unknown*/, &setlist
);
9062 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
9063 Breakpoint specific settings\n\
9064 Configure various breakpoint-specific variables such as\n\
9065 pending breakpoint behavior"),
9066 &breakpoint_show_cmdlist
, "show breakpoint ",
9067 0/*allow-unknown*/, &showlist
);
9069 add_setshow_auto_boolean_cmd ("pending", no_class
,
9070 &pending_break_support
, _("\
9071 Set debugger's behavior regarding pending breakpoints."), _("\
9072 Show debugger's behavior regarding pending breakpoints."), _("\
9073 If on, an unrecognized breakpoint location will cause gdb to create a\n\
9074 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
9075 an error. If auto, an unrecognized breakpoint location results in a\n\
9076 user-query to see if a pending breakpoint should be created."),
9078 show_pending_break_support
,
9079 &breakpoint_set_cmdlist
,
9080 &breakpoint_show_cmdlist
);
9082 pending_break_support
= AUTO_BOOLEAN_AUTO
;
9084 add_setshow_boolean_cmd ("auto-hw", no_class
,
9085 &automatic_hardware_breakpoints
, _("\
9086 Set automatic usage of hardware breakpoints."), _("\
9087 Show automatic usage of hardware breakpoints."), _("\
9088 If set, the debugger will automatically use hardware breakpoints for\n\
9089 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
9090 a warning will be emitted for such breakpoints."),
9092 show_automatic_hardware_breakpoints
,
9093 &breakpoint_set_cmdlist
,
9094 &breakpoint_show_cmdlist
);
9096 add_setshow_enum_cmd ("always-inserted", class_support
,
9097 always_inserted_enums
, &always_inserted_mode
, _("\
9098 Set mode for inserting breakpoints."), _("\
9099 Show mode for inserting breakpoints."), _("\
9100 When this mode is off, breakpoints are inserted in inferior when it is\n\
9101 resumed, and removed when execution stops. When this mode is on,\n\
9102 breakpoints are inserted immediately and removed only when the user\n\
9103 deletes the breakpoint. When this mode is auto (which is the default),\n\
9104 the behaviour depends on the non-stop setting (see help set non-stop).\n\
9105 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
9106 behaves as if always-inserted mode is on; if gdb is controlling the\n\
9107 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
9109 &show_always_inserted_mode
,
9110 &breakpoint_set_cmdlist
,
9111 &breakpoint_show_cmdlist
);
9113 automatic_hardware_breakpoints
= 1;
9115 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);