1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "breakpoint.h"
28 #include "tracepoint.h"
30 #include "expression.h"
36 #include "gdbthread.h"
39 #include "gdb_string.h"
46 #include "completer.h"
49 #include "cli/cli-script.h"
50 #include "gdb_assert.h"
55 #include "exceptions.h"
62 /* readline include files */
63 #include "readline/readline.h"
64 #include "readline/history.h"
66 /* readline defines this. */
69 #include "mi/mi-common.h"
71 /* Arguments to pass as context to some catch command handlers. */
72 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
73 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
75 /* Prototypes for local functions. */
77 static void enable_delete_command (char *, int);
79 static void enable_delete_breakpoint (struct breakpoint
*);
81 static void enable_once_command (char *, int);
83 static void enable_once_breakpoint (struct breakpoint
*);
85 static void disable_command (char *, int);
87 static void enable_command (char *, int);
89 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
91 static void ignore_command (char *, int);
93 static int breakpoint_re_set_one (void *);
95 static void clear_command (char *, int);
97 static void catch_command (char *, int);
99 static void watch_command (char *, int);
101 static int can_use_hardware_watchpoint (struct value
*);
103 static void break_command_1 (char *, int, int);
105 static void mention (struct breakpoint
*);
107 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
109 static void check_duplicates (struct breakpoint
*);
111 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
113 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
116 static void describe_other_breakpoints (CORE_ADDR
, struct obj_section
*, int);
118 static void breakpoints_info (char *, int);
120 static void breakpoint_1 (int, int);
122 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
124 static int breakpoint_cond_eval (void *);
126 static void cleanup_executing_breakpoints (void *);
128 static void commands_command (char *, int);
130 static void condition_command (char *, int);
132 static int get_number_trailer (char **, int);
134 void set_breakpoint_count (int);
143 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
145 static enum print_stop_action
print_it_typical (bpstat
);
147 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
149 static int watchpoint_check (void *);
151 static void maintenance_info_breakpoints (char *, int);
153 static int hw_breakpoint_used_count (void);
155 static int hw_watchpoint_used_count (enum bptype
, int *);
157 static void hbreak_command (char *, int);
159 static void thbreak_command (char *, int);
161 static void watch_command_1 (char *, int, int);
163 static void rwatch_command (char *, int);
165 static void awatch_command (char *, int);
167 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
169 static void stop_command (char *arg
, int from_tty
);
171 static void stopin_command (char *arg
, int from_tty
);
173 static void stopat_command (char *arg
, int from_tty
);
175 static char *ep_parse_optional_if_clause (char **arg
);
177 static char *ep_parse_optional_filename (char **arg
);
179 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
180 char *arg
, int tempflag
, int from_tty
);
182 static void tcatch_command (char *arg
, int from_tty
);
184 static void ep_skip_leading_whitespace (char **s
);
186 static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc
);
188 static void free_bp_location (struct bp_location
*loc
);
190 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
192 static void update_global_location_list (int);
194 static void update_global_location_list_nothrow (int);
196 static int is_hardware_watchpoint (struct breakpoint
*bpt
);
198 static void insert_breakpoint_locations (void);
200 static void tracepoints_info (char *, int);
202 static void delete_trace_command (char *, int);
204 static void enable_trace_command (char *, int);
206 static void disable_trace_command (char *, int);
208 static void trace_pass_command (char *, int);
210 static void skip_prologue_sal (struct symtab_and_line
*sal
);
213 /* Flag indicating that a command has proceeded the inferior past the
214 current breakpoint. */
216 static int breakpoint_proceeded
;
219 bpdisp_text (enum bpdisp disp
)
221 /* NOTE: the following values are a part of MI protocol and represent
222 values of 'disp' field returned when inferior stops at a breakpoint. */
223 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
224 return bpdisps
[(int) disp
];
227 /* Prototypes for exported functions. */
228 /* If FALSE, gdb will not use hardware support for watchpoints, even
229 if such is available. */
230 static int can_use_hw_watchpoints
;
233 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
234 struct cmd_list_element
*c
,
237 fprintf_filtered (file
, _("\
238 Debugger's willingness to use watchpoint hardware is %s.\n"),
242 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
243 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
244 for unrecognized breakpoint locations.
245 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
246 static enum auto_boolean pending_break_support
;
248 show_pending_break_support (struct ui_file
*file
, int from_tty
,
249 struct cmd_list_element
*c
,
252 fprintf_filtered (file
, _("\
253 Debugger's behavior regarding pending breakpoints is %s.\n"),
257 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
258 set with "break" but falling in read-only memory.
259 If 0, gdb will warn about such breakpoints, but won't automatically
260 use hardware breakpoints. */
261 static int automatic_hardware_breakpoints
;
263 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
264 struct cmd_list_element
*c
,
267 fprintf_filtered (file
, _("\
268 Automatic usage of hardware breakpoints is %s.\n"),
272 /* If on, gdb will keep breakpoints inserted even as inferior is
273 stopped, and immediately insert any new breakpoints. If off, gdb
274 will insert breakpoints into inferior only when resuming it, and
275 will remove breakpoints upon stop. If auto, GDB will behave as ON
276 if in non-stop mode, and as OFF if all-stop mode.*/
278 static const char always_inserted_auto
[] = "auto";
279 static const char always_inserted_on
[] = "on";
280 static const char always_inserted_off
[] = "off";
281 static const char *always_inserted_enums
[] = {
282 always_inserted_auto
,
287 static const char *always_inserted_mode
= always_inserted_auto
;
289 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
290 struct cmd_list_element
*c
, const char *value
)
292 if (always_inserted_mode
== always_inserted_auto
)
293 fprintf_filtered (file
, _("\
294 Always inserted breakpoint mode is %s (currently %s).\n"),
296 breakpoints_always_inserted_mode () ? "on" : "off");
298 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
302 breakpoints_always_inserted_mode (void)
304 return (always_inserted_mode
== always_inserted_on
305 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
308 void _initialize_breakpoint (void);
310 /* Are we executing breakpoint commands? */
311 static int executing_breakpoint_commands
;
313 /* Are overlay event breakpoints enabled? */
314 static int overlay_events_enabled
;
316 /* Walk the following statement or block through all breakpoints.
317 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
320 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
322 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
323 for (B = breakpoint_chain; \
324 B ? (TMP=B->next, 1): 0; \
327 /* Similar iterators for the low-level breakpoints. */
329 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
331 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
332 for (B = bp_location_chain; \
333 B ? (TMP=B->global_next, 1): 0; \
336 /* Iterator for tracepoints only. */
338 #define ALL_TRACEPOINTS(B) \
339 for (B = breakpoint_chain; B; B = B->next) \
340 if ((B)->type == bp_tracepoint)
342 /* Chains of all breakpoints defined. */
344 struct breakpoint
*breakpoint_chain
;
346 struct bp_location
*bp_location_chain
;
348 /* The locations that no longer correspond to any breakpoint,
349 unlinked from bp_location_chain, but for which a hit
350 may still be reported by a target. */
351 VEC(bp_location_p
) *moribund_locations
= NULL
;
353 /* Number of last breakpoint made. */
355 int breakpoint_count
;
357 /* Number of last tracepoint made. */
359 int tracepoint_count
;
361 /* Return whether a breakpoint is an active enabled breakpoint. */
363 breakpoint_enabled (struct breakpoint
*b
)
365 return (b
->enable_state
== bp_enabled
);
368 /* Set breakpoint count to NUM. */
371 set_breakpoint_count (int num
)
373 breakpoint_count
= num
;
374 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
377 /* Used in run_command to zero the hit count when a new run starts. */
380 clear_breakpoint_hit_counts (void)
382 struct breakpoint
*b
;
388 /* Default address, symtab and line to put a breakpoint at
389 for "break" command with no arg.
390 if default_breakpoint_valid is zero, the other three are
391 not valid, and "break" with no arg is an error.
393 This set by print_stack_frame, which calls set_default_breakpoint. */
395 int default_breakpoint_valid
;
396 CORE_ADDR default_breakpoint_address
;
397 struct symtab
*default_breakpoint_symtab
;
398 int default_breakpoint_line
;
400 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
401 Advance *PP after the string and any trailing whitespace.
403 Currently the string can either be a number or "$" followed by the name
404 of a convenience variable. Making it an expression wouldn't work well
405 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
407 If the string is a NULL pointer, that denotes the last breakpoint.
409 TRAILER is a character which can be found after the number; most
410 commonly this is `-'. If you don't want a trailer, use \0. */
412 get_number_trailer (char **pp
, int trailer
)
414 int retval
= 0; /* default */
418 /* Empty line means refer to the last breakpoint. */
419 return breakpoint_count
;
422 /* Make a copy of the name, so we can null-terminate it
423 to pass to lookup_internalvar(). */
428 while (isalnum (*p
) || *p
== '_')
430 varname
= (char *) alloca (p
- start
+ 1);
431 strncpy (varname
, start
, p
- start
);
432 varname
[p
- start
] = '\0';
433 if (get_internalvar_integer (lookup_internalvar (varname
), &val
))
437 printf_filtered (_("Convenience variable must have integer value.\n"));
445 while (*p
>= '0' && *p
<= '9')
448 /* There is no number here. (e.g. "cond a == b"). */
450 /* Skip non-numeric token */
451 while (*p
&& !isspace((int) *p
))
453 /* Return zero, which caller must interpret as error. */
459 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
461 /* Trailing junk: return 0 and let caller print error msg. */
462 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
473 /* Like get_number_trailer, but don't allow a trailer. */
475 get_number (char **pp
)
477 return get_number_trailer (pp
, '\0');
480 /* Parse a number or a range.
481 * A number will be of the form handled by get_number.
482 * A range will be of the form <number1> - <number2>, and
483 * will represent all the integers between number1 and number2,
486 * While processing a range, this fuction is called iteratively;
487 * At each call it will return the next value in the range.
489 * At the beginning of parsing a range, the char pointer PP will
490 * be advanced past <number1> and left pointing at the '-' token.
491 * Subsequent calls will not advance the pointer until the range
492 * is completed. The call that completes the range will advance
493 * pointer PP past <number2>.
497 get_number_or_range (char **pp
)
499 static int last_retval
, end_value
;
500 static char *end_ptr
;
501 static int in_range
= 0;
505 /* Default case: pp is pointing either to a solo number,
506 or to the first number of a range. */
507 last_retval
= get_number_trailer (pp
, '-');
512 /* This is the start of a range (<number1> - <number2>).
513 Skip the '-', parse and remember the second number,
514 and also remember the end of the final token. */
518 while (isspace ((int) *end_ptr
))
519 end_ptr
++; /* skip white space */
520 end_value
= get_number (temp
);
521 if (end_value
< last_retval
)
523 error (_("inverted range"));
525 else if (end_value
== last_retval
)
527 /* degenerate range (number1 == number2). Advance the
528 token pointer so that the range will be treated as a
537 error (_("negative value"));
540 /* pp points to the '-' that betokens a range. All
541 number-parsing has already been done. Return the next
542 integer value (one greater than the saved previous value).
543 Do not advance the token pointer 'pp' until the end of range
546 if (++last_retval
== end_value
)
548 /* End of range reached; advance token pointer. */
558 /* condition N EXP -- set break condition of breakpoint N to EXP. */
561 condition_command (char *arg
, int from_tty
)
563 struct breakpoint
*b
;
568 error_no_arg (_("breakpoint number"));
571 bnum
= get_number (&p
);
573 error (_("Bad breakpoint argument: '%s'"), arg
);
576 if (b
->number
== bnum
)
578 struct bp_location
*loc
= b
->loc
;
579 for (; loc
; loc
= loc
->next
)
587 if (b
->cond_string
!= NULL
)
588 xfree (b
->cond_string
);
592 b
->cond_string
= NULL
;
594 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
599 /* I don't know if it matters whether this is the string the user
600 typed in or the decompiled expression. */
601 b
->cond_string
= xstrdup (arg
);
602 b
->condition_not_parsed
= 0;
603 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
607 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
609 error (_("Junk at end of expression"));
612 breakpoints_changed ();
613 observer_notify_breakpoint_modified (b
->number
);
617 error (_("No breakpoint number %d."), bnum
);
621 commands_command (char *arg
, int from_tty
)
623 struct breakpoint
*b
;
626 struct command_line
*l
;
628 /* If we allowed this, we would have problems with when to
629 free the storage, if we change the commands currently
632 if (executing_breakpoint_commands
)
633 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
636 bnum
= get_number (&p
);
639 error (_("Unexpected extra arguments following breakpoint number."));
642 if (b
->number
== bnum
)
644 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
646 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
647 l
= read_command_lines (tmpbuf
, from_tty
, 1);
648 do_cleanups (cleanups
);
649 free_command_lines (&b
->commands
);
651 breakpoints_changed ();
652 observer_notify_breakpoint_modified (b
->number
);
655 error (_("No breakpoint number %d."), bnum
);
658 /* Like commands_command, but instead of reading the commands from
659 input stream, takes them from an already parsed command structure.
661 This is used by cli-script.c to DTRT with breakpoint commands
662 that are part of if and while bodies. */
663 enum command_control_type
664 commands_from_control_command (char *arg
, struct command_line
*cmd
)
666 struct breakpoint
*b
;
670 /* If we allowed this, we would have problems with when to
671 free the storage, if we change the commands currently
674 if (executing_breakpoint_commands
)
675 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
677 /* An empty string for the breakpoint number means the last
678 breakpoint, but get_number expects a NULL pointer. */
683 bnum
= get_number (&p
);
686 error (_("Unexpected extra arguments following breakpoint number."));
689 if (b
->number
== bnum
)
691 free_command_lines (&b
->commands
);
692 if (cmd
->body_count
!= 1)
693 error (_("Invalid \"commands\" block structure."));
694 /* We need to copy the commands because if/while will free the
695 list after it finishes execution. */
696 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
697 breakpoints_changed ();
698 observer_notify_breakpoint_modified (b
->number
);
699 return simple_control
;
701 error (_("No breakpoint number %d."), bnum
);
704 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
705 by replacing any memory breakpoints with their shadowed contents. */
708 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
710 struct bp_location
*b
;
711 CORE_ADDR bp_addr
= 0;
717 if (b
->owner
->type
== bp_none
)
718 warning (_("reading through apparently deleted breakpoint #%d?"),
721 if (b
->loc_type
!= bp_loc_software_breakpoint
)
725 /* Addresses and length of the part of the breakpoint that
727 bp_addr
= b
->target_info
.placed_address
;
728 bp_size
= b
->target_info
.shadow_len
;
730 /* bp isn't valid, or doesn't shadow memory. */
733 if (bp_addr
+ bp_size
<= memaddr
)
734 /* The breakpoint is entirely before the chunk of memory we
738 if (bp_addr
>= memaddr
+ len
)
739 /* The breakpoint is entirely after the chunk of memory we are
743 /* Offset within shadow_contents. */
744 if (bp_addr
< memaddr
)
746 /* Only copy the second part of the breakpoint. */
747 bp_size
-= memaddr
- bp_addr
;
748 bptoffset
= memaddr
- bp_addr
;
752 if (bp_addr
+ bp_size
> memaddr
+ len
)
754 /* Only copy the first part of the breakpoint. */
755 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
758 memcpy (buf
+ bp_addr
- memaddr
,
759 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
764 /* A wrapper function for inserting catchpoints. */
766 insert_catchpoint (struct ui_out
*uo
, void *args
)
768 struct breakpoint
*b
= (struct breakpoint
*) args
;
771 gdb_assert (b
->type
== bp_catchpoint
);
772 gdb_assert (b
->ops
!= NULL
&& b
->ops
->insert
!= NULL
);
778 is_hardware_watchpoint (struct breakpoint
*bpt
)
780 return (bpt
->type
== bp_hardware_watchpoint
781 || bpt
->type
== bp_read_watchpoint
782 || bpt
->type
== bp_access_watchpoint
);
785 /* Find the current value of a watchpoint on EXP. Return the value in
786 *VALP and *RESULTP and the chain of intermediate and final values
787 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
790 If a memory error occurs while evaluating the expression, *RESULTP will
791 be set to NULL. *RESULTP may be a lazy value, if the result could
792 not be read from memory. It is used to determine whether a value
793 is user-specified (we should watch the whole value) or intermediate
794 (we should watch only the bit used to locate the final value).
796 If the final value, or any intermediate value, could not be read
797 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
798 set to any referenced values. *VALP will never be a lazy value.
799 This is the value which we store in struct breakpoint.
801 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
802 value chain. The caller must free the values individually. If
803 VAL_CHAIN is NULL, all generated values will be left on the value
807 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
808 struct value
**resultp
, struct value
**val_chain
)
810 struct value
*mark
, *new_mark
, *result
;
811 volatile struct gdb_exception ex
;
819 /* Evaluate the expression. */
820 mark
= value_mark ();
823 TRY_CATCH (ex
, RETURN_MASK_ALL
)
825 result
= evaluate_expression (exp
);
829 /* Ignore memory errors, we want watchpoints pointing at
830 inaccessible memory to still be created; otherwise, throw the
831 error to some higher catcher. */
837 throw_exception (ex
);
842 new_mark
= value_mark ();
843 if (mark
== new_mark
)
848 /* Make sure it's not lazy, so that after the target stops again we
849 have a non-lazy previous value to compare with. */
851 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
856 /* Return the chain of intermediate values. We use this to
857 decide which addresses to watch. */
858 *val_chain
= new_mark
;
859 value_release_to_mark (mark
);
863 /* Assuming that B is a watchpoint:
864 - Reparse watchpoint expression, if REPARSE is non-zero
865 - Evaluate expression and store the result in B->val
866 - Evaluate the condition if there is one, and store the result
868 - Update the list of values that must be watched in B->loc.
870 If the watchpoint disposition is disp_del_at_next_stop, then do nothing.
871 If this is local watchpoint that is out of scope, delete it. */
873 update_watchpoint (struct breakpoint
*b
, int reparse
)
875 int within_current_scope
;
876 struct frame_id saved_frame_id
;
877 struct bp_location
*loc
;
880 /* We don't free locations. They are stored in bp_location_chain and
881 update_global_locations will eventually delete them and remove
882 breakpoints if needed. */
885 if (b
->disposition
== disp_del_at_next_stop
)
888 /* Save the current frame's ID so we can restore it after
889 evaluating the watchpoint expression on its own frame. */
890 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
891 took a frame parameter, so that we didn't have to change the
893 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
895 /* Determine if the watchpoint is within scope. */
896 if (b
->exp_valid_block
== NULL
)
897 within_current_scope
= 1;
900 struct frame_info
*fi
;
901 fi
= frame_find_by_id (b
->watchpoint_frame
);
902 within_current_scope
= (fi
!= NULL
);
903 if (within_current_scope
)
907 if (within_current_scope
&& reparse
)
916 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
917 /* If the meaning of expression itself changed, the old value is
918 no longer relevant. We don't want to report a watchpoint hit
919 to the user when the old value and the new value may actually
920 be completely different objects. */
926 /* If we failed to parse the expression, for example because
927 it refers to a global variable in a not-yet-loaded shared library,
928 don't try to insert watchpoint. We don't automatically delete
929 such watchpoint, though, since failure to parse expression
930 is different from out-of-scope watchpoint. */
931 if (within_current_scope
&& b
->exp
)
933 struct value
*val_chain
, *v
, *result
, *next
;
935 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
937 /* Avoid setting b->val if it's already set. The meaning of
938 b->val is 'the last value' user saw, and we should update
939 it only if we reported that last value to user. As it
940 happens, the code that reports it updates b->val directly. */
947 /* Change the type of breakpoint between hardware assisted or an
948 ordinary watchpoint depending on the hardware support and free
949 hardware slots. REPARSE is set when the inferior is started. */
950 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
953 int i
, mem_cnt
, other_type_used
;
955 i
= hw_watchpoint_used_count (bp_hardware_watchpoint
,
957 mem_cnt
= can_use_hardware_watchpoint (val_chain
);
960 b
->type
= bp_watchpoint
;
963 int target_resources_ok
= target_can_use_hardware_watchpoint
964 (bp_hardware_watchpoint
, i
+ mem_cnt
, other_type_used
);
965 if (target_resources_ok
<= 0)
966 b
->type
= bp_watchpoint
;
968 b
->type
= bp_hardware_watchpoint
;
972 /* Look at each value on the value chain. */
973 for (v
= val_chain
; v
; v
= next
)
975 /* If it's a memory location, and GDB actually needed
976 its contents to evaluate the expression, then we
977 must watch it. If the first value returned is
978 still lazy, that means an error occurred reading it;
979 watch it anyway in case it becomes readable. */
980 if (VALUE_LVAL (v
) == lval_memory
981 && (v
== val_chain
|| ! value_lazy (v
)))
983 struct type
*vtype
= check_typedef (value_type (v
));
985 /* We only watch structs and arrays if user asked
986 for it explicitly, never if they just happen to
987 appear in the middle of some value chain. */
989 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
990 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
994 struct bp_location
*loc
, **tmp
;
996 addr
= value_address (v
);
997 len
= TYPE_LENGTH (value_type (v
));
999 if (b
->type
== bp_read_watchpoint
)
1001 else if (b
->type
== bp_access_watchpoint
)
1004 loc
= allocate_bp_location (b
);
1005 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1008 loc
->address
= addr
;
1010 loc
->watchpoint_type
= type
;
1014 next
= value_next (v
);
1019 /* We just regenerated the list of breakpoint locations.
1020 The new location does not have its condition field set to anything
1021 and therefore, we must always reparse the cond_string, independently
1022 of the value of the reparse flag. */
1023 if (b
->cond_string
!= NULL
)
1025 char *s
= b
->cond_string
;
1026 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1029 else if (!within_current_scope
)
1031 printf_filtered (_("\
1032 Watchpoint %d deleted because the program has left the block \n\
1033 in which its expression is valid.\n"),
1035 if (b
->related_breakpoint
)
1036 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1037 b
->disposition
= disp_del_at_next_stop
;
1040 /* Restore the selected frame. */
1041 select_frame (frame_find_by_id (saved_frame_id
));
1045 /* Returns 1 iff breakpoint location should be
1046 inserted in the inferior. */
1048 should_be_inserted (struct bp_location
*bpt
)
1050 if (!breakpoint_enabled (bpt
->owner
))
1053 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
1056 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1059 /* Tracepoints are inserted by the target at a time of its choosing,
1061 if (bpt
->owner
->type
== bp_tracepoint
)
1067 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1068 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1069 and HW_BREAKPOINT_ERROR are used to report problems.
1071 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1072 method for each breakpoint or catchpoint type. */
1074 insert_bp_location (struct bp_location
*bpt
,
1075 struct ui_file
*tmp_error_stream
,
1076 int *disabled_breaks
,
1077 int *hw_breakpoint_error
)
1081 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1084 /* Initialize the target-specific information. */
1085 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1086 bpt
->target_info
.placed_address
= bpt
->address
;
1088 if (bpt
->loc_type
== bp_loc_software_breakpoint
1089 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1091 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1093 /* If the explicitly specified breakpoint type
1094 is not hardware breakpoint, check the memory map to see
1095 if the breakpoint address is in read only memory or not.
1096 Two important cases are:
1097 - location type is not hardware breakpoint, memory
1098 is readonly. We change the type of the location to
1099 hardware breakpoint.
1100 - location type is hardware breakpoint, memory is read-write.
1101 This means we've previously made the location hardware one, but
1102 then the memory map changed, so we undo.
1104 When breakpoints are removed, remove_breakpoints will
1105 use location types we've just set here, the only possible
1106 problem is that memory map has changed during running program,
1107 but it's not going to work anyway with current gdb. */
1108 struct mem_region
*mr
1109 = lookup_mem_region (bpt
->target_info
.placed_address
);
1113 if (automatic_hardware_breakpoints
)
1116 enum bp_loc_type new_type
;
1118 if (mr
->attrib
.mode
!= MEM_RW
)
1119 new_type
= bp_loc_hardware_breakpoint
;
1121 new_type
= bp_loc_software_breakpoint
;
1123 if (new_type
!= bpt
->loc_type
)
1125 static int said
= 0;
1126 bpt
->loc_type
= new_type
;
1129 fprintf_filtered (gdb_stdout
, _("\
1130 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1135 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1136 && mr
->attrib
.mode
!= MEM_RW
)
1137 warning (_("cannot set software breakpoint at readonly address %s"),
1138 paddr (bpt
->address
));
1142 /* First check to see if we have to handle an overlay. */
1143 if (overlay_debugging
== ovly_off
1144 || bpt
->section
== NULL
1145 || !(section_is_overlay (bpt
->section
)))
1147 /* No overlay handling: just set the breakpoint. */
1149 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1150 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1152 val
= target_insert_breakpoint (&bpt
->target_info
);
1156 /* This breakpoint is in an overlay section.
1157 Shall we set a breakpoint at the LMA? */
1158 if (!overlay_events_enabled
)
1160 /* Yes -- overlay event support is not active,
1161 so we must try to set a breakpoint at the LMA.
1162 This will not work for a hardware breakpoint. */
1163 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1164 warning (_("hardware breakpoint %d not supported in overlay!"),
1165 bpt
->owner
->number
);
1168 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1170 /* Set a software (trap) breakpoint at the LMA. */
1171 bpt
->overlay_target_info
= bpt
->target_info
;
1172 bpt
->overlay_target_info
.placed_address
= addr
;
1173 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
1175 fprintf_unfiltered (tmp_error_stream
,
1176 "Overlay breakpoint %d failed: in ROM?\n",
1177 bpt
->owner
->number
);
1180 /* Shall we set a breakpoint at the VMA? */
1181 if (section_is_mapped (bpt
->section
))
1183 /* Yes. This overlay section is mapped into memory. */
1184 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1185 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1187 val
= target_insert_breakpoint (&bpt
->target_info
);
1191 /* No. This breakpoint will not be inserted.
1192 No error, but do not mark the bp as 'inserted'. */
1199 /* Can't set the breakpoint. */
1200 if (solib_name_from_address (bpt
->address
))
1202 /* See also: disable_breakpoints_in_shlibs. */
1204 bpt
->shlib_disabled
= 1;
1205 if (!*disabled_breaks
)
1207 fprintf_unfiltered (tmp_error_stream
,
1208 "Cannot insert breakpoint %d.\n",
1209 bpt
->owner
->number
);
1210 fprintf_unfiltered (tmp_error_stream
,
1211 "Temporarily disabling shared library breakpoints:\n");
1213 *disabled_breaks
= 1;
1214 fprintf_unfiltered (tmp_error_stream
,
1215 "breakpoint #%d\n", bpt
->owner
->number
);
1219 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1221 *hw_breakpoint_error
= 1;
1222 fprintf_unfiltered (tmp_error_stream
,
1223 "Cannot insert hardware breakpoint %d.\n",
1224 bpt
->owner
->number
);
1228 fprintf_unfiltered (tmp_error_stream
,
1229 "Cannot insert breakpoint %d.\n",
1230 bpt
->owner
->number
);
1231 fprintf_filtered (tmp_error_stream
,
1232 "Error accessing memory address ");
1233 fputs_filtered (paddress (bpt
->address
), tmp_error_stream
);
1234 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1235 safe_strerror (val
));
1246 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1247 /* NOTE drow/2003-09-08: This state only exists for removing
1248 watchpoints. It's not clear that it's necessary... */
1249 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1251 val
= target_insert_watchpoint (bpt
->address
,
1253 bpt
->watchpoint_type
);
1254 bpt
->inserted
= (val
!= -1);
1257 else if (bpt
->owner
->type
== bp_catchpoint
)
1259 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1260 bpt
->owner
, RETURN_MASK_ERROR
);
1261 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1262 bpt
->owner
->number
);
1264 bpt
->owner
->enable_state
= bp_disabled
;
1268 /* We've already printed an error message if there was a problem
1269 inserting this catchpoint, and we've disabled the catchpoint,
1270 so just return success. */
1277 /* Make sure all breakpoints are inserted in inferior.
1278 Throws exception on any error.
1279 A breakpoint that is already inserted won't be inserted
1280 again, so calling this function twice is safe. */
1282 insert_breakpoints (void)
1284 struct breakpoint
*bpt
;
1286 ALL_BREAKPOINTS (bpt
)
1287 if (is_hardware_watchpoint (bpt
))
1288 update_watchpoint (bpt
, 0 /* don't reparse. */);
1290 update_global_location_list (1);
1292 /* update_global_location_list does not insert breakpoints when
1293 always_inserted_mode is not enabled. Explicitly insert them
1295 if (!breakpoints_always_inserted_mode ())
1296 insert_breakpoint_locations ();
1299 /* insert_breakpoints is used when starting or continuing the program.
1300 remove_breakpoints is used when the program stops.
1301 Both return zero if successful,
1302 or an `errno' value if could not write the inferior. */
1305 insert_breakpoint_locations (void)
1307 struct breakpoint
*bpt
;
1308 struct bp_location
*b
, *temp
;
1311 int disabled_breaks
= 0;
1312 int hw_breakpoint_error
= 0;
1314 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1315 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1317 /* Explicitly mark the warning -- this will only be printed if
1318 there was an error. */
1319 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1321 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1323 if (!should_be_inserted (b
) || b
->inserted
)
1326 /* There is no point inserting thread-specific breakpoints if the
1327 thread no longer exists. */
1328 if (b
->owner
->thread
!= -1
1329 && !valid_thread_id (b
->owner
->thread
))
1332 val
= insert_bp_location (b
, tmp_error_stream
,
1334 &hw_breakpoint_error
);
1339 /* If we failed to insert all locations of a watchpoint,
1340 remove them, as half-inserted watchpoint is of limited use. */
1341 ALL_BREAKPOINTS (bpt
)
1343 int some_failed
= 0;
1344 struct bp_location
*loc
;
1346 if (!is_hardware_watchpoint (bpt
))
1349 if (!breakpoint_enabled (bpt
))
1352 if (bpt
->disposition
== disp_del_at_next_stop
)
1355 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1363 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1365 remove_breakpoint (loc
, mark_uninserted
);
1367 hw_breakpoint_error
= 1;
1368 fprintf_unfiltered (tmp_error_stream
,
1369 "Could not insert hardware watchpoint %d.\n",
1377 /* If a hardware breakpoint or watchpoint was inserted, add a
1378 message about possibly exhausted resources. */
1379 if (hw_breakpoint_error
)
1381 fprintf_unfiltered (tmp_error_stream
,
1382 "Could not insert hardware breakpoints:\n\
1383 You may have requested too many hardware breakpoints/watchpoints.\n");
1385 target_terminal_ours_for_output ();
1386 error_stream (tmp_error_stream
);
1389 do_cleanups (cleanups
);
1393 remove_breakpoints (void)
1395 struct bp_location
*b
;
1398 ALL_BP_LOCATIONS (b
)
1402 val
= remove_breakpoint (b
, mark_uninserted
);
1411 remove_hw_watchpoints (void)
1413 struct bp_location
*b
;
1416 ALL_BP_LOCATIONS (b
)
1418 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1420 val
= remove_breakpoint (b
, mark_uninserted
);
1429 reattach_breakpoints (int pid
)
1431 struct bp_location
*b
;
1433 struct cleanup
*old_chain
= save_inferior_ptid ();
1434 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1435 int dummy1
= 0, dummy2
= 0;
1437 make_cleanup_ui_file_delete (tmp_error_stream
);
1439 inferior_ptid
= pid_to_ptid (pid
);
1440 ALL_BP_LOCATIONS (b
)
1445 val
= insert_bp_location (b
, tmp_error_stream
,
1449 do_cleanups (old_chain
);
1454 do_cleanups (old_chain
);
1458 static int internal_breakpoint_number
= -1;
1460 static struct breakpoint
*
1461 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
1463 struct symtab_and_line sal
;
1464 struct breakpoint
*b
;
1466 init_sal (&sal
); /* initialize to zeroes */
1469 sal
.section
= find_pc_overlay (sal
.pc
);
1471 b
= set_raw_breakpoint (sal
, type
);
1472 b
->number
= internal_breakpoint_number
--;
1473 b
->disposition
= disp_donttouch
;
1479 create_overlay_event_breakpoint (char *func_name
)
1481 struct objfile
*objfile
;
1483 ALL_OBJFILES (objfile
)
1485 struct breakpoint
*b
;
1486 struct minimal_symbol
*m
;
1488 m
= lookup_minimal_symbol_text (func_name
, objfile
);
1492 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
1494 b
->addr_string
= xstrdup (func_name
);
1496 if (overlay_debugging
== ovly_auto
)
1498 b
->enable_state
= bp_enabled
;
1499 overlay_events_enabled
= 1;
1503 b
->enable_state
= bp_disabled
;
1504 overlay_events_enabled
= 0;
1507 update_global_location_list (1);
1511 create_longjmp_master_breakpoint (char *func_name
)
1513 struct objfile
*objfile
;
1515 ALL_OBJFILES (objfile
)
1517 struct breakpoint
*b
;
1518 struct minimal_symbol
*m
;
1520 if (!gdbarch_get_longjmp_target_p (get_objfile_arch (objfile
)))
1523 m
= lookup_minimal_symbol_text (func_name
, objfile
);
1527 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
1529 b
->addr_string
= xstrdup (func_name
);
1530 b
->enable_state
= bp_disabled
;
1532 update_global_location_list (1);
1536 update_breakpoints_after_exec (void)
1538 struct breakpoint
*b
;
1539 struct breakpoint
*temp
;
1540 struct bp_location
*bploc
;
1542 /* We're about to delete breakpoints from GDB's lists. If the
1543 INSERTED flag is true, GDB will try to lift the breakpoints by
1544 writing the breakpoints' "shadow contents" back into memory. The
1545 "shadow contents" are NOT valid after an exec, so GDB should not
1546 do that. Instead, the target is responsible from marking
1547 breakpoints out as soon as it detects an exec. We don't do that
1548 here instead, because there may be other attempts to delete
1549 breakpoints after detecting an exec and before reaching here. */
1550 ALL_BP_LOCATIONS (bploc
)
1551 gdb_assert (!bploc
->inserted
);
1553 ALL_BREAKPOINTS_SAFE (b
, temp
)
1555 /* Solib breakpoints must be explicitly reset after an exec(). */
1556 if (b
->type
== bp_shlib_event
)
1558 delete_breakpoint (b
);
1562 /* Thread event breakpoints must be set anew after an exec(),
1563 as must overlay event and longjmp master breakpoints. */
1564 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
1565 || b
->type
== bp_longjmp_master
)
1567 delete_breakpoint (b
);
1571 /* Step-resume breakpoints are meaningless after an exec(). */
1572 if (b
->type
== bp_step_resume
)
1574 delete_breakpoint (b
);
1578 /* Longjmp and longjmp-resume breakpoints are also meaningless
1580 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
1582 delete_breakpoint (b
);
1586 if (b
->type
== bp_catchpoint
)
1588 /* For now, none of the bp_catchpoint breakpoints need to
1589 do anything at this point. In the future, if some of
1590 the catchpoints need to something, we will need to add
1591 a new method, and call this method from here. */
1595 /* bp_finish is a special case. The only way we ought to be able
1596 to see one of these when an exec() has happened, is if the user
1597 caught a vfork, and then said "finish". Ordinarily a finish just
1598 carries them to the call-site of the current callee, by setting
1599 a temporary bp there and resuming. But in this case, the finish
1600 will carry them entirely through the vfork & exec.
1602 We don't want to allow a bp_finish to remain inserted now. But
1603 we can't safely delete it, 'cause finish_command has a handle to
1604 the bp on a bpstat, and will later want to delete it. There's a
1605 chance (and I've seen it happen) that if we delete the bp_finish
1606 here, that its storage will get reused by the time finish_command
1607 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1608 We really must allow finish_command to delete a bp_finish.
1610 In the absense of a general solution for the "how do we know
1611 it's safe to delete something others may have handles to?"
1612 problem, what we'll do here is just uninsert the bp_finish, and
1613 let finish_command delete it.
1615 (We know the bp_finish is "doomed" in the sense that it's
1616 momentary, and will be deleted as soon as finish_command sees
1617 the inferior stopped. So it doesn't matter that the bp's
1618 address is probably bogus in the new a.out, unlike e.g., the
1619 solib breakpoints.) */
1621 if (b
->type
== bp_finish
)
1626 /* Without a symbolic address, we have little hope of the
1627 pre-exec() address meaning the same thing in the post-exec()
1629 if (b
->addr_string
== NULL
)
1631 delete_breakpoint (b
);
1635 /* FIXME what about longjmp breakpoints? Re-create them here? */
1636 create_overlay_event_breakpoint ("_ovly_debug_event");
1637 create_longjmp_master_breakpoint ("longjmp");
1638 create_longjmp_master_breakpoint ("_longjmp");
1639 create_longjmp_master_breakpoint ("siglongjmp");
1640 create_longjmp_master_breakpoint ("_siglongjmp");
1644 detach_breakpoints (int pid
)
1646 struct bp_location
*b
;
1648 struct cleanup
*old_chain
= save_inferior_ptid ();
1650 if (pid
== PIDGET (inferior_ptid
))
1651 error (_("Cannot detach breakpoints of inferior_ptid"));
1653 /* Set inferior_ptid; remove_breakpoint uses this global. */
1654 inferior_ptid
= pid_to_ptid (pid
);
1655 ALL_BP_LOCATIONS (b
)
1659 val
= remove_breakpoint (b
, mark_inserted
);
1662 do_cleanups (old_chain
);
1667 do_cleanups (old_chain
);
1672 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1676 if (b
->owner
->enable_state
== bp_permanent
)
1677 /* Permanent breakpoints cannot be inserted or removed. */
1680 /* The type of none suggests that owner is actually deleted.
1681 This should not ever happen. */
1682 gdb_assert (b
->owner
->type
!= bp_none
);
1684 if (b
->loc_type
== bp_loc_software_breakpoint
1685 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1687 /* "Normal" instruction breakpoint: either the standard
1688 trap-instruction bp (bp_breakpoint), or a
1689 bp_hardware_breakpoint. */
1691 /* First check to see if we have to handle an overlay. */
1692 if (overlay_debugging
== ovly_off
1693 || b
->section
== NULL
1694 || !(section_is_overlay (b
->section
)))
1696 /* No overlay handling: just remove the breakpoint. */
1698 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1699 val
= target_remove_hw_breakpoint (&b
->target_info
);
1701 val
= target_remove_breakpoint (&b
->target_info
);
1705 /* This breakpoint is in an overlay section.
1706 Did we set a breakpoint at the LMA? */
1707 if (!overlay_events_enabled
)
1709 /* Yes -- overlay event support is not active, so we
1710 should have set a breakpoint at the LMA. Remove it.
1712 /* Ignore any failures: if the LMA is in ROM, we will
1713 have already warned when we failed to insert it. */
1714 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1715 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1717 target_remove_breakpoint (&b
->overlay_target_info
);
1719 /* Did we set a breakpoint at the VMA?
1720 If so, we will have marked the breakpoint 'inserted'. */
1723 /* Yes -- remove it. Previously we did not bother to
1724 remove the breakpoint if the section had been
1725 unmapped, but let's not rely on that being safe. We
1726 don't know what the overlay manager might do. */
1727 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1728 val
= target_remove_hw_breakpoint (&b
->target_info
);
1730 /* However, we should remove *software* breakpoints only
1731 if the section is still mapped, or else we overwrite
1732 wrong code with the saved shadow contents. */
1733 else if (section_is_mapped (b
->section
))
1734 val
= target_remove_breakpoint (&b
->target_info
);
1740 /* No -- not inserted, so no need to remove. No error. */
1745 /* In some cases, we might not be able to remove a breakpoint
1746 in a shared library that has already been removed, but we
1747 have not yet processed the shlib unload event. */
1748 if (val
&& solib_name_from_address (b
->address
))
1753 b
->inserted
= (is
== mark_inserted
);
1755 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1760 b
->inserted
= (is
== mark_inserted
);
1761 val
= target_remove_watchpoint (b
->address
, b
->length
,
1762 b
->watchpoint_type
);
1764 /* Failure to remove any of the hardware watchpoints comes here. */
1765 if ((is
== mark_uninserted
) && (b
->inserted
))
1766 warning (_("Could not remove hardware watchpoint %d."),
1769 else if (b
->owner
->type
== bp_catchpoint
1770 && breakpoint_enabled (b
->owner
)
1773 gdb_assert (b
->owner
->ops
!= NULL
&& b
->owner
->ops
->remove
!= NULL
);
1775 val
= b
->owner
->ops
->remove (b
->owner
);
1778 b
->inserted
= (is
== mark_inserted
);
1784 /* Clear the "inserted" flag in all breakpoints. */
1787 mark_breakpoints_out (void)
1789 struct bp_location
*bpt
;
1791 ALL_BP_LOCATIONS (bpt
)
1795 /* Clear the "inserted" flag in all breakpoints and delete any
1796 breakpoints which should go away between runs of the program.
1798 Plus other such housekeeping that has to be done for breakpoints
1801 Note: this function gets called at the end of a run (by
1802 generic_mourn_inferior) and when a run begins (by
1803 init_wait_for_inferior). */
1808 breakpoint_init_inferior (enum inf_context context
)
1810 struct breakpoint
*b
, *temp
;
1811 struct bp_location
*bpt
;
1814 /* If breakpoint locations are shared across processes, then there's
1816 if (gdbarch_has_global_breakpoints (target_gdbarch
))
1819 ALL_BP_LOCATIONS (bpt
)
1820 if (bpt
->owner
->enable_state
!= bp_permanent
)
1823 ALL_BREAKPOINTS_SAFE (b
, temp
)
1828 case bp_watchpoint_scope
:
1830 /* If the call dummy breakpoint is at the entry point it will
1831 cause problems when the inferior is rerun, so we better
1834 Also get rid of scope breakpoints. */
1835 delete_breakpoint (b
);
1839 case bp_hardware_watchpoint
:
1840 case bp_read_watchpoint
:
1841 case bp_access_watchpoint
:
1843 /* Likewise for watchpoints on local expressions. */
1844 if (b
->exp_valid_block
!= NULL
)
1845 delete_breakpoint (b
);
1846 else if (context
== inf_starting
)
1848 /* Reset val field to force reread of starting value
1849 in insert_breakpoints. */
1851 value_free (b
->val
);
1861 /* Get rid of the moribund locations. */
1862 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bpt
); ++ix
)
1863 free_bp_location (bpt
);
1864 VEC_free (bp_location_p
, moribund_locations
);
1867 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1868 exists at PC. It returns ordinary_breakpoint_here if it's an
1869 ordinary breakpoint, or permanent_breakpoint_here if it's a
1870 permanent breakpoint.
1871 - When continuing from a location with an ordinary breakpoint, we
1872 actually single step once before calling insert_breakpoints.
1873 - When continuing from a localion with a permanent breakpoint, we
1874 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1875 the target, to advance the PC past the breakpoint. */
1877 enum breakpoint_here
1878 breakpoint_here_p (CORE_ADDR pc
)
1880 const struct bp_location
*bpt
;
1881 int any_breakpoint_here
= 0;
1883 ALL_BP_LOCATIONS (bpt
)
1885 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1886 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1889 if ((breakpoint_enabled (bpt
->owner
)
1890 || bpt
->owner
->enable_state
== bp_permanent
)
1891 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1893 if (overlay_debugging
1894 && section_is_overlay (bpt
->section
)
1895 && !section_is_mapped (bpt
->section
))
1896 continue; /* unmapped overlay -- can't be a match */
1897 else if (bpt
->owner
->enable_state
== bp_permanent
)
1898 return permanent_breakpoint_here
;
1900 any_breakpoint_here
= 1;
1904 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1907 /* Return true if there's a moribund breakpoint at PC. */
1910 moribund_breakpoint_here_p (CORE_ADDR pc
)
1912 struct bp_location
*loc
;
1915 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
1916 if (loc
->address
== pc
)
1922 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1923 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1924 This does not check for single-step breakpoints, which are
1925 inserted and removed using direct target manipulation. */
1928 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1930 const struct bp_location
*bpt
;
1932 ALL_BP_LOCATIONS (bpt
)
1934 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1935 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1939 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1941 if (overlay_debugging
1942 && section_is_overlay (bpt
->section
)
1943 && !section_is_mapped (bpt
->section
))
1944 continue; /* unmapped overlay -- can't be a match */
1952 /* Returns non-zero iff there's either regular breakpoint
1953 or a single step breakpoint inserted at PC. */
1956 breakpoint_inserted_here_p (CORE_ADDR pc
)
1958 if (regular_breakpoint_inserted_here_p (pc
))
1961 if (single_step_breakpoint_inserted_here_p (pc
))
1967 /* This function returns non-zero iff there is a software breakpoint
1971 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1973 const struct bp_location
*bpt
;
1974 int any_breakpoint_here
= 0;
1976 ALL_BP_LOCATIONS (bpt
)
1978 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1982 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1984 if (overlay_debugging
1985 && section_is_overlay (bpt
->section
)
1986 && !section_is_mapped (bpt
->section
))
1987 continue; /* unmapped overlay -- can't be a match */
1993 /* Also check for software single-step breakpoints. */
1994 if (single_step_breakpoint_inserted_here_p (pc
))
2000 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2001 PC is valid for process/thread PTID. */
2004 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
2006 const struct bp_location
*bpt
;
2007 /* The thread and task IDs associated to PTID, computed lazily. */
2011 ALL_BP_LOCATIONS (bpt
)
2013 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2014 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2017 if (!breakpoint_enabled (bpt
->owner
)
2018 && bpt
->owner
->enable_state
!= bp_permanent
)
2021 if (bpt
->address
!= pc
)
2024 if (bpt
->owner
->thread
!= -1)
2026 /* This is a thread-specific breakpoint. Check that ptid
2027 matches that thread. If thread hasn't been computed yet,
2028 it is now time to do so. */
2030 thread
= pid_to_thread_id (ptid
);
2031 if (bpt
->owner
->thread
!= thread
)
2035 if (bpt
->owner
->task
!= 0)
2037 /* This is a task-specific breakpoint. Check that ptid
2038 matches that task. If task hasn't been computed yet,
2039 it is now time to do so. */
2041 task
= ada_get_task_number (ptid
);
2042 if (bpt
->owner
->task
!= task
)
2046 if (overlay_debugging
2047 && section_is_overlay (bpt
->section
)
2048 && !section_is_mapped (bpt
->section
))
2049 continue; /* unmapped overlay -- can't be a match */
2058 /* bpstat stuff. External routines' interfaces are documented
2062 ep_is_catchpoint (struct breakpoint
*ep
)
2064 return (ep
->type
== bp_catchpoint
);
2068 bpstat_free (bpstat bs
)
2070 if (bs
->old_val
!= NULL
)
2071 value_free (bs
->old_val
);
2072 free_command_lines (&bs
->commands
);
2076 /* Clear a bpstat so that it says we are not at any breakpoint.
2077 Also free any storage that is part of a bpstat. */
2080 bpstat_clear (bpstat
*bsp
)
2097 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
2098 is part of the bpstat is copied as well. */
2101 bpstat_copy (bpstat bs
)
2105 bpstat retval
= NULL
;
2110 for (; bs
!= NULL
; bs
= bs
->next
)
2112 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
2113 memcpy (tmp
, bs
, sizeof (*tmp
));
2114 if (bs
->commands
!= NULL
)
2115 tmp
->commands
= copy_command_lines (bs
->commands
);
2116 if (bs
->old_val
!= NULL
)
2118 tmp
->old_val
= value_copy (bs
->old_val
);
2119 release_value (tmp
->old_val
);
2123 /* This is the first thing in the chain. */
2133 /* Find the bpstat associated with this breakpoint */
2136 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2141 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2143 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2149 /* Find a step_resume breakpoint associated with this bpstat.
2150 (If there are multiple step_resume bp's on the list, this function
2151 will arbitrarily pick one.)
2153 It is an error to use this function if BPSTAT doesn't contain a
2154 step_resume breakpoint.
2156 See wait_for_inferior's use of this function. */
2158 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2162 gdb_assert (bsp
!= NULL
);
2164 current_thread
= pid_to_thread_id (inferior_ptid
);
2166 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2168 if ((bsp
->breakpoint_at
!= NULL
)
2169 && (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
)
2170 && (bsp
->breakpoint_at
->owner
->thread
== current_thread
2171 || bsp
->breakpoint_at
->owner
->thread
== -1))
2172 return bsp
->breakpoint_at
->owner
;
2175 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2179 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2180 at. *BSP upon return is a bpstat which points to the remaining
2181 breakpoints stopped at (but which is not guaranteed to be good for
2182 anything but further calls to bpstat_num).
2183 Return 0 if passed a bpstat which does not indicate any breakpoints.
2184 Return -1 if stopped at a breakpoint that has been deleted since
2186 Return 1 otherwise. */
2189 bpstat_num (bpstat
*bsp
, int *num
)
2191 struct breakpoint
*b
;
2194 return 0; /* No more breakpoint values */
2196 /* We assume we'll never have several bpstats that
2197 correspond to a single breakpoint -- otherwise,
2198 this function might return the same number more
2199 than once and this will look ugly. */
2200 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2201 *bsp
= (*bsp
)->next
;
2203 return -1; /* breakpoint that's been deleted since */
2205 *num
= b
->number
; /* We have its number */
2209 /* Modify BS so that the actions will not be performed. */
2212 bpstat_clear_actions (bpstat bs
)
2214 for (; bs
!= NULL
; bs
= bs
->next
)
2216 free_command_lines (&bs
->commands
);
2217 if (bs
->old_val
!= NULL
)
2219 value_free (bs
->old_val
);
2225 /* Called when a command is about to proceed the inferior. */
2228 breakpoint_about_to_proceed (void)
2230 if (!ptid_equal (inferior_ptid
, null_ptid
))
2232 struct thread_info
*tp
= inferior_thread ();
2234 /* Allow inferior function calls in breakpoint commands to not
2235 interrupt the command list. When the call finishes
2236 successfully, the inferior will be standing at the same
2237 breakpoint as if nothing happened. */
2242 breakpoint_proceeded
= 1;
2245 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2247 cleanup_executing_breakpoints (void *ignore
)
2249 executing_breakpoint_commands
= 0;
2252 /* Execute all the commands associated with all the breakpoints at this
2253 location. Any of these commands could cause the process to proceed
2254 beyond this point, etc. We look out for such changes by checking
2255 the global "breakpoint_proceeded" after each command.
2257 Returns true if a breakpoint command resumed the inferior. In that
2258 case, it is the caller's responsibility to recall it again with the
2259 bpstat of the current thread. */
2262 bpstat_do_actions_1 (bpstat
*bsp
)
2265 struct cleanup
*old_chain
;
2268 /* Avoid endless recursion if a `source' command is contained
2270 if (executing_breakpoint_commands
)
2273 executing_breakpoint_commands
= 1;
2274 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2276 /* This pointer will iterate over the list of bpstat's. */
2279 breakpoint_proceeded
= 0;
2280 for (; bs
!= NULL
; bs
= bs
->next
)
2282 struct command_line
*cmd
;
2283 struct cleanup
*this_cmd_tree_chain
;
2285 /* Take ownership of the BSP's command tree, if it has one.
2287 The command tree could legitimately contain commands like
2288 'step' and 'next', which call clear_proceed_status, which
2289 frees stop_bpstat's command tree. To make sure this doesn't
2290 free the tree we're executing out from under us, we need to
2291 take ownership of the tree ourselves. Since a given bpstat's
2292 commands are only executed once, we don't need to copy it; we
2293 can clear the pointer in the bpstat, and make sure we free
2294 the tree when we're done. */
2297 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2301 execute_control_command (cmd
);
2303 if (breakpoint_proceeded
)
2309 /* We can free this command tree now. */
2310 do_cleanups (this_cmd_tree_chain
);
2312 if (breakpoint_proceeded
)
2314 if (target_can_async_p ())
2315 /* If we are in async mode, then the target might be still
2316 running, not stopped at any breakpoint, so nothing for
2317 us to do here -- just return to the event loop. */
2320 /* In sync mode, when execute_control_command returns
2321 we're already standing on the next breakpoint.
2322 Breakpoint commands for that stop were not run, since
2323 execute_command does not run breakpoint commands --
2324 only command_line_handler does, but that one is not
2325 involved in execution of breakpoint commands. So, we
2326 can now execute breakpoint commands. It should be
2327 noted that making execute_command do bpstat actions is
2328 not an option -- in this case we'll have recursive
2329 invocation of bpstat for each breakpoint with a
2330 command, and can easily blow up GDB stack. Instead, we
2331 return true, which will trigger the caller to recall us
2332 with the new stop_bpstat. */
2337 do_cleanups (old_chain
);
2342 bpstat_do_actions (void)
2344 /* Do any commands attached to breakpoint we are stopped at. */
2345 while (!ptid_equal (inferior_ptid
, null_ptid
)
2346 && target_has_execution
2347 && !is_exited (inferior_ptid
)
2348 && !is_executing (inferior_ptid
))
2349 /* Since in sync mode, bpstat_do_actions may resume the inferior,
2350 and only return when it is stopped at the next breakpoint, we
2351 keep doing breakpoint actions until it returns false to
2352 indicate the inferior was not resumed. */
2353 if (!bpstat_do_actions_1 (&inferior_thread ()->stop_bpstat
))
2357 /* Print out the (old or new) value associated with a watchpoint. */
2360 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2363 fprintf_unfiltered (stream
, _("<unreadable>"));
2366 struct value_print_options opts
;
2367 get_user_print_options (&opts
);
2368 value_print (val
, stream
, &opts
);
2372 /* This is the normal print function for a bpstat. In the future,
2373 much of this logic could (should?) be moved to bpstat_stop_status,
2374 by having it set different print_it values.
2376 Current scheme: When we stop, bpstat_print() is called. It loops
2377 through the bpstat list of things causing this stop, calling the
2378 print_bp_stop_message function on each one. The behavior of the
2379 print_bp_stop_message function depends on the print_it field of
2380 bpstat. If such field so indicates, call this function here.
2382 Return values from this routine (ultimately used by bpstat_print()
2383 and normal_stop() to decide what to do):
2384 PRINT_NOTHING: Means we already printed all we needed to print,
2385 don't print anything else.
2386 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2387 that something to be followed by a location.
2388 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2389 that something to be followed by a location.
2390 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2393 static enum print_stop_action
2394 print_it_typical (bpstat bs
)
2396 struct cleanup
*old_chain
;
2397 struct breakpoint
*b
;
2398 const struct bp_location
*bl
;
2399 struct ui_stream
*stb
;
2401 enum print_stop_action result
;
2403 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2404 which has since been deleted. */
2405 if (bs
->breakpoint_at
== NULL
)
2406 return PRINT_UNKNOWN
;
2407 bl
= bs
->breakpoint_at
;
2410 stb
= ui_out_stream_new (uiout
);
2411 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2416 case bp_hardware_breakpoint
:
2417 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2418 if (bl
->address
!= bl
->requested_address
)
2419 breakpoint_adjustment_warning (bl
->requested_address
,
2422 annotate_breakpoint (b
->number
);
2424 ui_out_text (uiout
, "\nTemporary breakpoint ");
2426 ui_out_text (uiout
, "\nBreakpoint ");
2427 if (ui_out_is_mi_like_p (uiout
))
2429 ui_out_field_string (uiout
, "reason",
2430 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2431 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2433 ui_out_field_int (uiout
, "bkptno", b
->number
);
2434 ui_out_text (uiout
, ", ");
2435 result
= PRINT_SRC_AND_LOC
;
2438 case bp_shlib_event
:
2439 /* Did we stop because the user set the stop_on_solib_events
2440 variable? (If so, we report this as a generic, "Stopped due
2441 to shlib event" message.) */
2442 printf_filtered (_("Stopped due to shared library event\n"));
2443 result
= PRINT_NOTHING
;
2446 case bp_thread_event
:
2447 /* Not sure how we will get here.
2448 GDB should not stop for these breakpoints. */
2449 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2450 result
= PRINT_NOTHING
;
2453 case bp_overlay_event
:
2454 /* By analogy with the thread event, GDB should not stop for these. */
2455 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2456 result
= PRINT_NOTHING
;
2459 case bp_longjmp_master
:
2460 /* These should never be enabled. */
2461 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
2462 result
= PRINT_NOTHING
;
2466 case bp_hardware_watchpoint
:
2467 annotate_watchpoint (b
->number
);
2468 if (ui_out_is_mi_like_p (uiout
))
2471 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2473 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2474 ui_out_text (uiout
, "\nOld value = ");
2475 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2476 ui_out_field_stream (uiout
, "old", stb
);
2477 ui_out_text (uiout
, "\nNew value = ");
2478 watchpoint_value_print (b
->val
, stb
->stream
);
2479 ui_out_field_stream (uiout
, "new", stb
);
2480 ui_out_text (uiout
, "\n");
2481 /* More than one watchpoint may have been triggered. */
2482 result
= PRINT_UNKNOWN
;
2485 case bp_read_watchpoint
:
2486 if (ui_out_is_mi_like_p (uiout
))
2489 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2491 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2492 ui_out_text (uiout
, "\nValue = ");
2493 watchpoint_value_print (b
->val
, stb
->stream
);
2494 ui_out_field_stream (uiout
, "value", stb
);
2495 ui_out_text (uiout
, "\n");
2496 result
= PRINT_UNKNOWN
;
2499 case bp_access_watchpoint
:
2500 if (bs
->old_val
!= NULL
)
2502 annotate_watchpoint (b
->number
);
2503 if (ui_out_is_mi_like_p (uiout
))
2506 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2508 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2509 ui_out_text (uiout
, "\nOld value = ");
2510 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2511 ui_out_field_stream (uiout
, "old", stb
);
2512 ui_out_text (uiout
, "\nNew value = ");
2517 if (ui_out_is_mi_like_p (uiout
))
2520 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2521 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2522 ui_out_text (uiout
, "\nValue = ");
2524 watchpoint_value_print (b
->val
, stb
->stream
);
2525 ui_out_field_stream (uiout
, "new", stb
);
2526 ui_out_text (uiout
, "\n");
2527 result
= PRINT_UNKNOWN
;
2530 /* Fall through, we don't deal with these types of breakpoints
2534 if (ui_out_is_mi_like_p (uiout
))
2537 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2538 result
= PRINT_UNKNOWN
;
2542 if (ui_out_is_mi_like_p (uiout
))
2545 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2546 result
= PRINT_UNKNOWN
;
2551 case bp_longjmp_resume
:
2552 case bp_step_resume
:
2553 case bp_watchpoint_scope
:
2557 result
= PRINT_UNKNOWN
;
2561 do_cleanups (old_chain
);
2565 /* Generic routine for printing messages indicating why we
2566 stopped. The behavior of this function depends on the value
2567 'print_it' in the bpstat structure. Under some circumstances we
2568 may decide not to print anything here and delegate the task to
2571 static enum print_stop_action
2572 print_bp_stop_message (bpstat bs
)
2574 switch (bs
->print_it
)
2577 /* Nothing should be printed for this bpstat entry. */
2578 return PRINT_UNKNOWN
;
2582 /* We still want to print the frame, but we already printed the
2583 relevant messages. */
2584 return PRINT_SRC_AND_LOC
;
2587 case print_it_normal
:
2589 const struct bp_location
*bl
= bs
->breakpoint_at
;
2590 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2592 /* Normal case. Call the breakpoint's print_it method, or
2593 print_it_typical. */
2594 /* FIXME: how breakpoint can ever be NULL here? */
2595 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2596 return b
->ops
->print_it (b
);
2598 return print_it_typical (bs
);
2603 internal_error (__FILE__
, __LINE__
,
2604 _("print_bp_stop_message: unrecognized enum value"));
2609 /* Print a message indicating what happened. This is called from
2610 normal_stop(). The input to this routine is the head of the bpstat
2611 list - a list of the eventpoints that caused this stop. This
2612 routine calls the generic print routine for printing a message
2613 about reasons for stopping. This will print (for example) the
2614 "Breakpoint n," part of the output. The return value of this
2617 PRINT_UNKNOWN: Means we printed nothing
2618 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2619 code to print the location. An example is
2620 "Breakpoint 1, " which should be followed by
2622 PRINT_SRC_ONLY: Means we printed something, but there is no need
2623 to also print the location part of the message.
2624 An example is the catch/throw messages, which
2625 don't require a location appended to the end.
2626 PRINT_NOTHING: We have done some printing and we don't need any
2627 further info to be printed.*/
2629 enum print_stop_action
2630 bpstat_print (bpstat bs
)
2634 /* Maybe another breakpoint in the chain caused us to stop.
2635 (Currently all watchpoints go on the bpstat whether hit or not.
2636 That probably could (should) be changed, provided care is taken
2637 with respect to bpstat_explains_signal). */
2638 for (; bs
; bs
= bs
->next
)
2640 val
= print_bp_stop_message (bs
);
2641 if (val
== PRINT_SRC_ONLY
2642 || val
== PRINT_SRC_AND_LOC
2643 || val
== PRINT_NOTHING
)
2647 /* We reached the end of the chain, or we got a null BS to start
2648 with and nothing was printed. */
2649 return PRINT_UNKNOWN
;
2652 /* Evaluate the expression EXP and return 1 if value is zero.
2653 This is used inside a catch_errors to evaluate the breakpoint condition.
2654 The argument is a "struct expression *" that has been cast to char * to
2655 make it pass through catch_errors. */
2658 breakpoint_cond_eval (void *exp
)
2660 struct value
*mark
= value_mark ();
2661 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2662 value_free_to_mark (mark
);
2666 /* Allocate a new bpstat and chain it to the current one. */
2669 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2673 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2675 bs
->breakpoint_at
= bl
;
2676 /* If the condition is false, etc., don't do the commands. */
2677 bs
->commands
= NULL
;
2679 bs
->print_it
= print_it_normal
;
2683 /* The target has stopped with waitstatus WS. Check if any hardware
2684 watchpoints have triggered, according to the target. */
2687 watchpoints_triggered (struct target_waitstatus
*ws
)
2689 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
2691 struct breakpoint
*b
;
2693 if (!stopped_by_watchpoint
)
2695 /* We were not stopped by a watchpoint. Mark all watchpoints
2696 as not triggered. */
2698 if (b
->type
== bp_hardware_watchpoint
2699 || b
->type
== bp_read_watchpoint
2700 || b
->type
== bp_access_watchpoint
)
2701 b
->watchpoint_triggered
= watch_triggered_no
;
2706 if (!target_stopped_data_address (¤t_target
, &addr
))
2708 /* We were stopped by a watchpoint, but we don't know where.
2709 Mark all watchpoints as unknown. */
2711 if (b
->type
== bp_hardware_watchpoint
2712 || b
->type
== bp_read_watchpoint
2713 || b
->type
== bp_access_watchpoint
)
2714 b
->watchpoint_triggered
= watch_triggered_unknown
;
2716 return stopped_by_watchpoint
;
2719 /* The target could report the data address. Mark watchpoints
2720 affected by this data address as triggered, and all others as not
2724 if (b
->type
== bp_hardware_watchpoint
2725 || b
->type
== bp_read_watchpoint
2726 || b
->type
== bp_access_watchpoint
)
2728 struct bp_location
*loc
;
2731 b
->watchpoint_triggered
= watch_triggered_no
;
2732 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2733 /* Exact match not required. Within range is
2735 if (target_watchpoint_addr_within_range (¤t_target
,
2739 b
->watchpoint_triggered
= watch_triggered_yes
;
2747 /* Possible return values for watchpoint_check (this can't be an enum
2748 because of check_errors). */
2749 /* The watchpoint has been deleted. */
2750 #define WP_DELETED 1
2751 /* The value has changed. */
2752 #define WP_VALUE_CHANGED 2
2753 /* The value has not changed. */
2754 #define WP_VALUE_NOT_CHANGED 3
2756 #define BP_TEMPFLAG 1
2757 #define BP_HARDWAREFLAG 2
2759 /* Check watchpoint condition. */
2762 watchpoint_check (void *p
)
2764 bpstat bs
= (bpstat
) p
;
2765 struct breakpoint
*b
;
2766 struct frame_info
*fr
;
2767 int within_current_scope
;
2769 b
= bs
->breakpoint_at
->owner
;
2771 if (b
->exp_valid_block
== NULL
)
2772 within_current_scope
= 1;
2775 struct frame_info
*frame
= get_current_frame ();
2776 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
2777 CORE_ADDR frame_pc
= get_frame_pc (frame
);
2779 fr
= frame_find_by_id (b
->watchpoint_frame
);
2780 within_current_scope
= (fr
!= NULL
);
2782 /* If we've gotten confused in the unwinder, we might have
2783 returned a frame that can't describe this variable. */
2784 if (within_current_scope
)
2786 struct symbol
*function
;
2788 function
= get_frame_function (fr
);
2789 if (function
== NULL
2790 || !contained_in (b
->exp_valid_block
,
2791 SYMBOL_BLOCK_VALUE (function
)))
2792 within_current_scope
= 0;
2795 /* in_function_epilogue_p() returns a non-zero value if we're still
2796 in the function but the stack frame has already been invalidated.
2797 Since we can't rely on the values of local variables after the
2798 stack has been destroyed, we are treating the watchpoint in that
2799 state as `not changed' without further checking. Don't mark
2800 watchpoints as changed if the current frame is in an epilogue -
2801 even if they are in some other frame, our view of the stack
2802 is likely to be wrong. */
2803 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
2804 return WP_VALUE_NOT_CHANGED
;
2806 if (within_current_scope
)
2807 /* If we end up stopping, the current frame will get selected
2808 in normal_stop. So this call to select_frame won't affect
2813 if (within_current_scope
)
2815 /* We use value_{,free_to_}mark because it could be a
2816 *long* time before we return to the command level and
2817 call free_all_values. We can't call free_all_values because
2818 we might be in the middle of evaluating a function call. */
2820 struct value
*mark
= value_mark ();
2821 struct value
*new_val
;
2823 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2824 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2825 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2827 if (new_val
!= NULL
)
2829 release_value (new_val
);
2830 value_free_to_mark (mark
);
2832 bs
->old_val
= b
->val
;
2835 /* We will stop here */
2836 return WP_VALUE_CHANGED
;
2840 /* Nothing changed, don't do anything. */
2841 value_free_to_mark (mark
);
2842 /* We won't stop here */
2843 return WP_VALUE_NOT_CHANGED
;
2848 /* This seems like the only logical thing to do because
2849 if we temporarily ignored the watchpoint, then when
2850 we reenter the block in which it is valid it contains
2851 garbage (in the case of a function, it may have two
2852 garbage values, one before and one after the prologue).
2853 So we can't even detect the first assignment to it and
2854 watch after that (since the garbage may or may not equal
2855 the first value assigned). */
2856 /* We print all the stop information in print_it_typical(), but
2857 in this case, by the time we call print_it_typical() this bp
2858 will be deleted already. So we have no choice but print the
2859 information here. */
2860 if (ui_out_is_mi_like_p (uiout
))
2862 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2863 ui_out_text (uiout
, "\nWatchpoint ");
2864 ui_out_field_int (uiout
, "wpnum", b
->number
);
2865 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2866 which its expression is valid.\n");
2868 if (b
->related_breakpoint
)
2869 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2870 b
->disposition
= disp_del_at_next_stop
;
2876 /* Return true if it looks like target has stopped due to hitting
2877 breakpoint location BL. This function does not check if we
2878 should stop, only if BL explains the stop. */
2880 bpstat_check_location (const struct bp_location
*bl
, CORE_ADDR bp_addr
)
2882 struct breakpoint
*b
= bl
->owner
;
2884 if (b
->type
!= bp_watchpoint
2885 && b
->type
!= bp_hardware_watchpoint
2886 && b
->type
!= bp_read_watchpoint
2887 && b
->type
!= bp_access_watchpoint
2888 && b
->type
!= bp_hardware_breakpoint
2889 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
2891 if (bl
->address
!= bp_addr
) /* address doesn't match */
2893 if (overlay_debugging
/* unmapped overlay section */
2894 && section_is_overlay (bl
->section
)
2895 && !section_is_mapped (bl
->section
))
2899 /* Continuable hardware watchpoints are treated as non-existent if the
2900 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2901 some data address). Otherwise gdb won't stop on a break instruction
2902 in the code (not from a breakpoint) when a hardware watchpoint has
2903 been defined. Also skip watchpoints which we know did not trigger
2904 (did not match the data address). */
2906 if ((b
->type
== bp_hardware_watchpoint
2907 || b
->type
== bp_read_watchpoint
2908 || b
->type
== bp_access_watchpoint
)
2909 && b
->watchpoint_triggered
== watch_triggered_no
)
2912 if (b
->type
== bp_hardware_breakpoint
)
2914 if (bl
->address
!= bp_addr
)
2916 if (overlay_debugging
/* unmapped overlay section */
2917 && section_is_overlay (bl
->section
)
2918 && !section_is_mapped (bl
->section
))
2922 if (b
->type
== bp_catchpoint
)
2924 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
2925 if (!b
->ops
->breakpoint_hit (b
))
2932 /* If BS refers to a watchpoint, determine if the watched values
2933 has actually changed, and we should stop. If not, set BS->stop
2936 bpstat_check_watchpoint (bpstat bs
)
2938 const struct bp_location
*bl
= bs
->breakpoint_at
;
2939 struct breakpoint
*b
= bl
->owner
;
2941 if (b
->type
== bp_watchpoint
2942 || b
->type
== bp_read_watchpoint
2943 || b
->type
== bp_access_watchpoint
2944 || b
->type
== bp_hardware_watchpoint
)
2948 int must_check_value
= 0;
2950 if (b
->type
== bp_watchpoint
)
2951 /* For a software watchpoint, we must always check the
2953 must_check_value
= 1;
2954 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2955 /* We have a hardware watchpoint (read, write, or access)
2956 and the target earlier reported an address watched by
2958 must_check_value
= 1;
2959 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2960 && b
->type
== bp_hardware_watchpoint
)
2961 /* We were stopped by a hardware watchpoint, but the target could
2962 not report the data address. We must check the watchpoint's
2963 value. Access and read watchpoints are out of luck; without
2964 a data address, we can't figure it out. */
2965 must_check_value
= 1;
2967 if (must_check_value
)
2969 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2971 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2972 int e
= catch_errors (watchpoint_check
, bs
, message
,
2974 do_cleanups (cleanups
);
2978 /* We've already printed what needs to be printed. */
2979 bs
->print_it
= print_it_done
;
2982 case WP_VALUE_CHANGED
:
2983 if (b
->type
== bp_read_watchpoint
)
2985 /* Don't stop: read watchpoints shouldn't fire if
2986 the value has changed. This is for targets
2987 which cannot set read-only watchpoints. */
2988 bs
->print_it
= print_it_noop
;
2992 case WP_VALUE_NOT_CHANGED
:
2993 if (b
->type
== bp_hardware_watchpoint
2994 || b
->type
== bp_watchpoint
)
2996 /* Don't stop: write watchpoints shouldn't fire if
2997 the value hasn't changed. */
2998 bs
->print_it
= print_it_noop
;
3006 /* Error from catch_errors. */
3007 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
3008 if (b
->related_breakpoint
)
3009 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3010 b
->disposition
= disp_del_at_next_stop
;
3011 /* We've already printed what needs to be printed. */
3012 bs
->print_it
= print_it_done
;
3016 else /* must_check_value == 0 */
3018 /* This is a case where some watchpoint(s) triggered, but
3019 not at the address of this watchpoint, or else no
3020 watchpoint triggered after all. So don't print
3021 anything for this watchpoint. */
3022 bs
->print_it
= print_it_noop
;
3029 /* Check conditions (condition proper, frame, thread and ignore count)
3030 of breakpoint referred to by BS. If we should not stop for this
3031 breakpoint, set BS->stop to 0. */
3033 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
3035 int thread_id
= pid_to_thread_id (ptid
);
3036 const struct bp_location
*bl
= bs
->breakpoint_at
;
3037 struct breakpoint
*b
= bl
->owner
;
3039 if (frame_id_p (b
->frame_id
)
3040 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
3044 int value_is_zero
= 0;
3046 /* If this is a scope breakpoint, mark the associated
3047 watchpoint as triggered so that we will handle the
3048 out-of-scope event. We'll get to the watchpoint next
3050 if (b
->type
== bp_watchpoint_scope
)
3051 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
3053 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
3055 /* We use value_mark and value_free_to_mark because it could
3056 be a long time before we return to the command level and
3057 call free_all_values. We can't call free_all_values
3058 because we might be in the middle of evaluating a
3060 struct value
*mark
= value_mark ();
3062 /* Need to select the frame, with all that implies so that
3063 the conditions will have the right context. Because we
3064 use the frame, we will not see an inlined function's
3065 variables when we arrive at a breakpoint at the start
3066 of the inlined function; the current frame will be the
3068 select_frame (get_current_frame ());
3070 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
3071 "Error in testing breakpoint condition:\n",
3073 /* FIXME-someday, should give breakpoint # */
3074 value_free_to_mark (mark
);
3076 if (bl
->cond
&& value_is_zero
)
3080 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
3084 else if (b
->ignore_count
> 0)
3087 annotate_ignore_count_change ();
3089 /* Increase the hit count even though we don't
3097 /* Get a bpstat associated with having just stopped at address
3098 BP_ADDR in thread PTID.
3100 Determine whether we stopped at a breakpoint, etc, or whether we
3101 don't understand this stop. Result is a chain of bpstat's such that:
3103 if we don't understand the stop, the result is a null pointer.
3105 if we understand why we stopped, the result is not null.
3107 Each element of the chain refers to a particular breakpoint or
3108 watchpoint at which we have stopped. (We may have stopped for
3109 several reasons concurrently.)
3111 Each element of the chain has valid next, breakpoint_at,
3112 commands, FIXME??? fields. */
3115 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
3117 struct breakpoint
*b
= NULL
;
3118 const struct bp_location
*bl
;
3119 struct bp_location
*loc
;
3120 /* Root of the chain of bpstat's */
3121 struct bpstats root_bs
[1];
3122 /* Pointer to the last thing in the chain currently. */
3123 bpstat bs
= root_bs
;
3125 int need_remove_insert
;
3127 ALL_BP_LOCATIONS (bl
)
3131 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3134 /* For hardware watchpoints, we look only at the first location.
3135 The watchpoint_check function will work on entire expression,
3136 not the individual locations. For read watchopints, the
3137 watchpoints_triggered function have checked all locations
3140 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3143 if (!bpstat_check_location (bl
, bp_addr
))
3146 /* Come here if it's a watchpoint, or if the break address matches */
3148 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3150 /* Assume we stop. Should we find watchpoint that is not actually
3151 triggered, or if condition of breakpoint is false, we'll reset
3156 bpstat_check_watchpoint (bs
);
3160 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3161 || b
->type
== bp_longjmp_master
)
3162 /* We do not stop for these. */
3165 bpstat_check_breakpoint_conditions (bs
, ptid
);
3171 /* We will stop here */
3172 if (b
->disposition
== disp_disable
)
3174 if (b
->enable_state
!= bp_permanent
)
3175 b
->enable_state
= bp_disabled
;
3176 update_global_location_list (0);
3180 bs
->commands
= b
->commands
;
3182 && (strcmp ("silent", bs
->commands
->line
) == 0
3183 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3185 bs
->commands
= bs
->commands
->next
;
3188 bs
->commands
= copy_command_lines (bs
->commands
);
3191 /* Print nothing for this entry if we dont stop or if we dont print. */
3192 if (bs
->stop
== 0 || bs
->print
== 0)
3193 bs
->print_it
= print_it_noop
;
3196 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
3198 if (loc
->address
== bp_addr
)
3200 bs
= bpstat_alloc (loc
, bs
);
3201 /* For hits of moribund locations, we should just proceed. */
3204 bs
->print_it
= print_it_noop
;
3208 bs
->next
= NULL
; /* Terminate the chain */
3209 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3211 /* If we aren't stopping, the value of some hardware watchpoint may
3212 not have changed, but the intermediate memory locations we are
3213 watching may have. Don't bother if we're stopping; this will get
3215 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3219 need_remove_insert
= 0;
3221 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3223 && bs
->breakpoint_at
->owner
3224 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3225 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3226 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3228 /* remove/insert can invalidate bs->breakpoint_at, if this
3229 location is no longer used by the watchpoint. Prevent
3230 further code from trying to use it. */
3231 bs
->breakpoint_at
= NULL
;
3232 need_remove_insert
= 1;
3235 if (need_remove_insert
)
3237 remove_breakpoints ();
3238 insert_breakpoints ();
3241 return root_bs
->next
;
3244 /* Tell what to do about this bpstat. */
3246 bpstat_what (bpstat bs
)
3248 /* Classify each bpstat as one of the following. */
3251 /* This bpstat element has no effect on the main_action. */
3254 /* There was a watchpoint, stop but don't print. */
3257 /* There was a watchpoint, stop and print. */
3260 /* There was a breakpoint but we're not stopping. */
3263 /* There was a breakpoint, stop but don't print. */
3266 /* There was a breakpoint, stop and print. */
3269 /* We hit the longjmp breakpoint. */
3272 /* We hit the longjmp_resume breakpoint. */
3275 /* We hit the step_resume breakpoint. */
3278 /* We hit the shared library event breakpoint. */
3281 /* This is just used to count how many enums there are. */
3285 /* Here is the table which drives this routine. So that we can
3286 format it pretty, we define some abbreviations for the
3287 enum bpstat_what codes. */
3288 #define kc BPSTAT_WHAT_KEEP_CHECKING
3289 #define ss BPSTAT_WHAT_STOP_SILENT
3290 #define sn BPSTAT_WHAT_STOP_NOISY
3291 #define sgl BPSTAT_WHAT_SINGLE
3292 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3293 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3294 #define sr BPSTAT_WHAT_STEP_RESUME
3295 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3297 /* "Can't happen." Might want to print an error message.
3298 abort() is not out of the question, but chances are GDB is just
3299 a bit confused, not unusable. */
3300 #define err BPSTAT_WHAT_STOP_NOISY
3302 /* Given an old action and a class, come up with a new action. */
3303 /* One interesting property of this table is that wp_silent is the same
3304 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3305 after stopping, the check for whether to step over a breakpoint
3306 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3307 reference to how we stopped. We retain separate wp_silent and
3308 bp_silent codes in case we want to change that someday.
3310 Another possibly interesting property of this table is that
3311 there's a partial ordering, priority-like, of the actions. Once
3312 you've decided that some action is appropriate, you'll never go
3313 back and decide something of a lower priority is better. The
3316 kc < clr sgl shl slr sn sr ss
3317 sgl < shl slr sn sr ss
3318 slr < err shl sn sr ss
3319 clr < err shl sn sr ss
3325 What I think this means is that we don't need a damned table
3326 here. If you just put the rows and columns in the right order,
3327 it'd look awfully regular. We could simply walk the bpstat list
3328 and choose the highest priority action we find, with a little
3329 logic to handle the 'err' cases. */
3331 /* step_resume entries: a step resume breakpoint overrides another
3332 breakpoint of signal handling (see comment in wait_for_inferior
3333 at where we set the step_resume breakpoint). */
3335 static const enum bpstat_what_main_action
3336 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3339 /* kc ss sn sgl slr clr sr shl
3342 {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
},
3344 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3346 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3348 {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
},
3350 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3352 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3354 {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
},
3356 {clr
, ss
, sn
, err
, err
, err
, sr
, shl
},
3358 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3360 {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
}
3373 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3374 struct bpstat_what retval
;
3376 retval
.call_dummy
= 0;
3377 for (; bs
!= NULL
; bs
= bs
->next
)
3379 enum class bs_class
= no_effect
;
3380 if (bs
->breakpoint_at
== NULL
)
3381 /* I suspect this can happen if it was a momentary breakpoint
3382 which has since been deleted. */
3384 if (bs
->breakpoint_at
->owner
== NULL
)
3385 bs_class
= bp_nostop
;
3387 switch (bs
->breakpoint_at
->owner
->type
)
3393 case bp_hardware_breakpoint
:
3399 bs_class
= bp_noisy
;
3401 bs_class
= bp_silent
;
3404 bs_class
= bp_nostop
;
3407 case bp_hardware_watchpoint
:
3408 case bp_read_watchpoint
:
3409 case bp_access_watchpoint
:
3413 bs_class
= wp_noisy
;
3415 bs_class
= wp_silent
;
3418 /* There was a watchpoint, but we're not stopping.
3419 This requires no further action. */
3420 bs_class
= no_effect
;
3423 bs_class
= long_jump
;
3425 case bp_longjmp_resume
:
3426 bs_class
= long_resume
;
3428 case bp_step_resume
:
3431 bs_class
= step_resume
;
3434 /* It is for the wrong frame. */
3435 bs_class
= bp_nostop
;
3437 case bp_watchpoint_scope
:
3438 bs_class
= bp_nostop
;
3440 case bp_shlib_event
:
3441 bs_class
= shlib_event
;
3443 case bp_thread_event
:
3444 case bp_overlay_event
:
3445 case bp_longjmp_master
:
3446 bs_class
= bp_nostop
;
3452 bs_class
= bp_noisy
;
3454 bs_class
= bp_silent
;
3457 /* There was a catchpoint, but we're not stopping.
3458 This requires no further action. */
3459 bs_class
= no_effect
;
3462 /* Make sure the action is stop (silent or noisy),
3463 so infrun.c pops the dummy frame. */
3464 bs_class
= bp_silent
;
3465 retval
.call_dummy
= 1;
3468 /* Tracepoint hits should not be reported back to GDB, and
3469 if one got through somehow, it should have been filtered
3471 internal_error (__FILE__
, __LINE__
,
3472 _("bpstat_what: bp_tracepoint encountered"));
3475 current_action
= table
[(int) bs_class
][(int) current_action
];
3477 retval
.main_action
= current_action
;
3481 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3482 without hardware support). This isn't related to a specific bpstat,
3483 just to things like whether watchpoints are set. */
3486 bpstat_should_step (void)
3488 struct breakpoint
*b
;
3490 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
3497 static void print_breakpoint_location (struct breakpoint
*b
,
3498 struct bp_location
*loc
,
3500 struct ui_stream
*stb
)
3505 = find_pc_sect_function (loc
->address
, loc
->section
);
3508 ui_out_text (uiout
, "in ");
3509 ui_out_field_string (uiout
, "func",
3510 SYMBOL_PRINT_NAME (sym
));
3511 ui_out_wrap_hint (uiout
, wrap_indent
);
3512 ui_out_text (uiout
, " at ");
3514 ui_out_field_string (uiout
, "file", b
->source_file
);
3515 ui_out_text (uiout
, ":");
3517 if (ui_out_is_mi_like_p (uiout
))
3519 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3520 char *fullname
= symtab_to_fullname (sal
.symtab
);
3523 ui_out_field_string (uiout
, "fullname", fullname
);
3526 ui_out_field_int (uiout
, "line", b
->line_number
);
3530 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3534 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3535 ui_out_field_stream (uiout
, "at", stb
);
3539 /* Print B to gdb_stdout. */
3541 print_one_breakpoint_location (struct breakpoint
*b
,
3542 struct bp_location
*loc
,
3544 CORE_ADDR
*last_addr
)
3546 struct command_line
*l
;
3548 struct ep_type_description
3553 static struct ep_type_description bptypes
[] =
3555 {bp_none
, "?deleted?"},
3556 {bp_breakpoint
, "breakpoint"},
3557 {bp_hardware_breakpoint
, "hw breakpoint"},
3558 {bp_until
, "until"},
3559 {bp_finish
, "finish"},
3560 {bp_watchpoint
, "watchpoint"},
3561 {bp_hardware_watchpoint
, "hw watchpoint"},
3562 {bp_read_watchpoint
, "read watchpoint"},
3563 {bp_access_watchpoint
, "acc watchpoint"},
3564 {bp_longjmp
, "longjmp"},
3565 {bp_longjmp_resume
, "longjmp resume"},
3566 {bp_step_resume
, "step resume"},
3567 {bp_watchpoint_scope
, "watchpoint scope"},
3568 {bp_call_dummy
, "call dummy"},
3569 {bp_shlib_event
, "shlib events"},
3570 {bp_thread_event
, "thread events"},
3571 {bp_overlay_event
, "overlay events"},
3572 {bp_longjmp_master
, "longjmp master"},
3573 {bp_catchpoint
, "catchpoint"},
3574 {bp_tracepoint
, "tracepoint"},
3577 static char bpenables
[] = "nynny";
3578 char wrap_indent
[80];
3579 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3580 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3581 struct cleanup
*bkpt_chain
;
3583 int header_of_multiple
= 0;
3584 int part_of_multiple
= (loc
!= NULL
);
3585 struct value_print_options opts
;
3587 get_user_print_options (&opts
);
3589 gdb_assert (!loc
|| loc_number
!= 0);
3590 /* See comment in print_one_breakpoint concerning
3591 treatment of breakpoints with single disabled
3595 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3596 header_of_multiple
= 1;
3601 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3605 if (part_of_multiple
)
3608 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3609 ui_out_field_string (uiout
, "number", formatted
);
3614 ui_out_field_int (uiout
, "number", b
->number
);
3619 if (part_of_multiple
)
3620 ui_out_field_skip (uiout
, "type");
3623 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3624 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3625 internal_error (__FILE__
, __LINE__
,
3626 _("bptypes table does not describe type #%d."),
3628 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3633 if (part_of_multiple
)
3634 ui_out_field_skip (uiout
, "disp");
3636 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3641 if (part_of_multiple
)
3642 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3644 ui_out_field_fmt (uiout
, "enabled", "%c",
3645 bpenables
[(int) b
->enable_state
]);
3646 ui_out_spaces (uiout
, 2);
3650 strcpy (wrap_indent
, " ");
3651 if (opts
.addressprint
)
3653 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3654 strcat (wrap_indent
, " ");
3656 strcat (wrap_indent
, " ");
3659 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3661 /* Although the print_one can possibly print
3662 all locations, calling it here is not likely
3663 to get any nice result. So, make sure there's
3664 just one location. */
3665 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3666 b
->ops
->print_one (b
, last_addr
);
3672 internal_error (__FILE__
, __LINE__
,
3673 _("print_one_breakpoint: bp_none encountered\n"));
3677 case bp_hardware_watchpoint
:
3678 case bp_read_watchpoint
:
3679 case bp_access_watchpoint
:
3680 /* Field 4, the address, is omitted (which makes the columns
3681 not line up too nicely with the headers, but the effect
3682 is relatively readable). */
3683 if (opts
.addressprint
)
3684 ui_out_field_skip (uiout
, "addr");
3686 ui_out_field_string (uiout
, "what", b
->exp_string
);
3690 case bp_hardware_breakpoint
:
3694 case bp_longjmp_resume
:
3695 case bp_step_resume
:
3696 case bp_watchpoint_scope
:
3698 case bp_shlib_event
:
3699 case bp_thread_event
:
3700 case bp_overlay_event
:
3701 case bp_longjmp_master
:
3703 if (opts
.addressprint
)
3706 if (header_of_multiple
)
3707 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3708 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3709 ui_out_field_string (uiout
, "addr", "<PENDING>");
3711 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3714 if (!header_of_multiple
)
3715 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3717 *last_addr
= b
->loc
->address
;
3721 if (!part_of_multiple
)
3723 if (b
->thread
!= -1)
3725 /* FIXME: This seems to be redundant and lost here; see the
3726 "stop only in" line a little further down. */
3727 ui_out_text (uiout
, " thread ");
3728 ui_out_field_int (uiout
, "thread", b
->thread
);
3730 else if (b
->task
!= 0)
3732 ui_out_text (uiout
, " task ");
3733 ui_out_field_int (uiout
, "task", b
->task
);
3737 ui_out_text (uiout
, "\n");
3739 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3742 ui_out_text (uiout
, "\tstop only in stack frame at ");
3743 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3745 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3746 ui_out_text (uiout
, "\n");
3749 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3751 /* We do not print the condition for Ada exception catchpoints
3752 because the condition is an internal implementation detail
3753 that we do not want to expose to the user. */
3755 if (b
->type
== bp_tracepoint
)
3756 ui_out_text (uiout
, "\ttrace only if ");
3758 ui_out_text (uiout
, "\tstop only if ");
3759 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3760 ui_out_text (uiout
, "\n");
3763 if (!part_of_multiple
&& b
->thread
!= -1)
3765 /* FIXME should make an annotation for this */
3766 ui_out_text (uiout
, "\tstop only in thread ");
3767 ui_out_field_int (uiout
, "thread", b
->thread
);
3768 ui_out_text (uiout
, "\n");
3771 if (!part_of_multiple
&& b
->hit_count
)
3773 /* FIXME should make an annotation for this */
3774 if (ep_is_catchpoint (b
))
3775 ui_out_text (uiout
, "\tcatchpoint");
3777 ui_out_text (uiout
, "\tbreakpoint");
3778 ui_out_text (uiout
, " already hit ");
3779 ui_out_field_int (uiout
, "times", b
->hit_count
);
3780 if (b
->hit_count
== 1)
3781 ui_out_text (uiout
, " time\n");
3783 ui_out_text (uiout
, " times\n");
3786 /* Output the count also if it is zero, but only if this is
3787 mi. FIXME: Should have a better test for this. */
3788 if (ui_out_is_mi_like_p (uiout
))
3789 if (!part_of_multiple
&& b
->hit_count
== 0)
3790 ui_out_field_int (uiout
, "times", b
->hit_count
);
3792 if (!part_of_multiple
&& b
->ignore_count
)
3795 ui_out_text (uiout
, "\tignore next ");
3796 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3797 ui_out_text (uiout
, " hits\n");
3801 if (!part_of_multiple
&& l
)
3803 struct cleanup
*script_chain
;
3806 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3807 print_command_lines (uiout
, l
, 4);
3808 do_cleanups (script_chain
);
3811 if (!part_of_multiple
&& b
->pass_count
)
3813 annotate_field (10);
3814 ui_out_text (uiout
, "\tpass count ");
3815 ui_out_field_int (uiout
, "pass", b
->pass_count
);
3816 ui_out_text (uiout
, " \n");
3819 if (!part_of_multiple
&& b
->step_count
)
3821 annotate_field (11);
3822 ui_out_text (uiout
, "\tstep count ");
3823 ui_out_field_int (uiout
, "step", b
->step_count
);
3824 ui_out_text (uiout
, " \n");
3827 if (!part_of_multiple
&& b
->actions
)
3829 struct action_line
*action
;
3830 annotate_field (12);
3831 for (action
= b
->actions
; action
; action
= action
->next
)
3833 ui_out_text (uiout
, " A\t");
3834 ui_out_text (uiout
, action
->action
);
3835 ui_out_text (uiout
, "\n");
3839 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
3842 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
3843 else if (b
->exp_string
)
3844 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
3847 do_cleanups (bkpt_chain
);
3848 do_cleanups (old_chain
);
3852 print_one_breakpoint (struct breakpoint
*b
,
3853 CORE_ADDR
*last_addr
)
3855 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3857 /* If this breakpoint has custom print function,
3858 it's already printed. Otherwise, print individual
3859 locations, if any. */
3860 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3862 /* If breakpoint has a single location that is
3863 disabled, we print it as if it had
3864 several locations, since otherwise it's hard to
3865 represent "breakpoint enabled, location disabled"
3867 Note that while hardware watchpoints have
3868 several locations internally, that's no a property
3871 && !is_hardware_watchpoint (b
)
3872 && (b
->loc
->next
|| !b
->loc
->enabled
)
3873 && !ui_out_is_mi_like_p (uiout
))
3875 struct bp_location
*loc
;
3877 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3878 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3884 struct captured_breakpoint_query_args
3890 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3892 struct captured_breakpoint_query_args
*args
= data
;
3893 struct breakpoint
*b
;
3894 CORE_ADDR dummy_addr
= 0;
3897 if (args
->bnum
== b
->number
)
3899 print_one_breakpoint (b
, &dummy_addr
);
3907 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3909 struct captured_breakpoint_query_args args
;
3911 /* For the moment we don't trust print_one_breakpoint() to not throw
3913 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3914 error_message
, RETURN_MASK_ALL
) < 0)
3920 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3921 catchpoints, et.al.). */
3924 user_settable_breakpoint (const struct breakpoint
*b
)
3926 return (b
->type
== bp_breakpoint
3927 || b
->type
== bp_catchpoint
3928 || b
->type
== bp_hardware_breakpoint
3929 || b
->type
== bp_tracepoint
3930 || b
->type
== bp_watchpoint
3931 || b
->type
== bp_read_watchpoint
3932 || b
->type
== bp_access_watchpoint
3933 || b
->type
== bp_hardware_watchpoint
);
3936 /* Print information on user settable breakpoint (watchpoint, etc)
3937 number BNUM. If BNUM is -1 print all user settable breakpoints.
3938 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3941 breakpoint_1 (int bnum
, int allflag
)
3943 struct breakpoint
*b
;
3944 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3945 int nr_printable_breakpoints
;
3946 struct cleanup
*bkpttbl_chain
;
3947 struct value_print_options opts
;
3949 get_user_print_options (&opts
);
3951 /* Compute the number of rows in the table. */
3952 nr_printable_breakpoints
= 0;
3955 || bnum
== b
->number
)
3957 if (allflag
|| user_settable_breakpoint (b
))
3958 nr_printable_breakpoints
++;
3961 if (opts
.addressprint
)
3963 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3967 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3970 if (nr_printable_breakpoints
> 0)
3971 annotate_breakpoints_headers ();
3972 if (nr_printable_breakpoints
> 0)
3974 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3975 if (nr_printable_breakpoints
> 0)
3977 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3978 if (nr_printable_breakpoints
> 0)
3980 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3981 if (nr_printable_breakpoints
> 0)
3983 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3984 if (opts
.addressprint
)
3986 if (nr_printable_breakpoints
> 0)
3988 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3989 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3991 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3993 if (nr_printable_breakpoints
> 0)
3995 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3996 ui_out_table_body (uiout
);
3997 if (nr_printable_breakpoints
> 0)
3998 annotate_breakpoints_table ();
4002 || bnum
== b
->number
)
4004 /* We only print out user settable breakpoints unless the
4006 if (allflag
|| user_settable_breakpoint (b
))
4007 print_one_breakpoint (b
, &last_addr
);
4010 do_cleanups (bkpttbl_chain
);
4012 if (nr_printable_breakpoints
== 0)
4015 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
4017 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
4022 /* Compare against (CORE_ADDR)-1 in case some compiler decides
4023 that a comparison of an unsigned with -1 is always false. */
4024 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
4025 set_next_address (current_gdbarch
, last_addr
);
4028 /* FIXME? Should this be moved up so that it is only called when
4029 there have been breakpoints? */
4030 annotate_breakpoints_table_end ();
4034 breakpoints_info (char *bnum_exp
, int from_tty
)
4039 bnum
= parse_and_eval_long (bnum_exp
);
4041 breakpoint_1 (bnum
, 0);
4045 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4050 bnum
= parse_and_eval_long (bnum_exp
);
4052 breakpoint_1 (bnum
, 1);
4056 breakpoint_has_pc (struct breakpoint
*b
,
4057 CORE_ADDR pc
, struct obj_section
*section
)
4059 struct bp_location
*bl
= b
->loc
;
4060 for (; bl
; bl
= bl
->next
)
4062 if (bl
->address
== pc
4063 && (!overlay_debugging
|| bl
->section
== section
))
4069 /* Print a message describing any breakpoints set at PC. */
4072 describe_other_breakpoints (CORE_ADDR pc
, struct obj_section
*section
,
4076 struct breakpoint
*b
;
4079 others
+= breakpoint_has_pc (b
, pc
, section
);
4083 printf_filtered (_("Note: breakpoint "));
4084 else /* if (others == ???) */
4085 printf_filtered (_("Note: breakpoints "));
4087 if (breakpoint_has_pc (b
, pc
, section
))
4090 printf_filtered ("%d", b
->number
);
4091 if (b
->thread
== -1 && thread
!= -1)
4092 printf_filtered (" (all threads)");
4093 else if (b
->thread
!= -1)
4094 printf_filtered (" (thread %d)", b
->thread
);
4095 printf_filtered ("%s%s ",
4096 ((b
->enable_state
== bp_disabled
4097 || b
->enable_state
== bp_call_disabled
)
4099 : b
->enable_state
== bp_permanent
4103 : ((others
== 1) ? " and" : ""));
4105 printf_filtered (_("also set at pc "));
4106 fputs_filtered (paddress (pc
), gdb_stdout
);
4107 printf_filtered (".\n");
4111 /* Set the default place to put a breakpoint
4112 for the `break' command with no arguments. */
4115 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
4118 default_breakpoint_valid
= valid
;
4119 default_breakpoint_address
= addr
;
4120 default_breakpoint_symtab
= symtab
;
4121 default_breakpoint_line
= line
;
4124 /* Return true iff it is meaningful to use the address member of
4125 BPT. For some breakpoint types, the address member is irrelevant
4126 and it makes no sense to attempt to compare it to other addresses
4127 (or use it for any other purpose either).
4129 More specifically, each of the following breakpoint types will always
4130 have a zero valued address and we don't want check_duplicates() to mark
4131 breakpoints of any of these types to be a duplicate of an actual
4132 breakpoint at address zero:
4135 bp_hardware_watchpoint
4137 bp_access_watchpoint
4141 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4143 enum bptype type
= bpt
->type
;
4145 return (type
!= bp_watchpoint
4146 && type
!= bp_hardware_watchpoint
4147 && type
!= bp_read_watchpoint
4148 && type
!= bp_access_watchpoint
4149 && type
!= bp_catchpoint
);
4152 /* Rescan breakpoints at the same address and section as BPT,
4153 marking the first one as "first" and any others as "duplicates".
4154 This is so that the bpt instruction is only inserted once.
4155 If we have a permanent breakpoint at the same place as BPT, make
4156 that one the official one, and the rest as duplicates. */
4159 check_duplicates_for (CORE_ADDR address
, struct obj_section
*section
)
4161 struct bp_location
*b
;
4163 struct bp_location
*perm_bp
= 0;
4165 ALL_BP_LOCATIONS (b
)
4166 if (b
->owner
->enable_state
!= bp_disabled
4167 && b
->owner
->enable_state
!= bp_call_disabled
4169 && !b
->shlib_disabled
4170 && b
->address
== address
/* address / overlay match */
4171 && (!overlay_debugging
|| b
->section
== section
)
4172 && breakpoint_address_is_meaningful (b
->owner
))
4174 /* Have we found a permanent breakpoint? */
4175 if (b
->owner
->enable_state
== bp_permanent
)
4182 b
->duplicate
= count
> 1;
4185 /* If we found a permanent breakpoint at this address, go over the
4186 list again and declare all the other breakpoints there (except
4187 other permanent breakpoints) to be the duplicates. */
4190 perm_bp
->duplicate
= 0;
4192 /* Permanent breakpoint should always be inserted. */
4193 if (! perm_bp
->inserted
)
4194 internal_error (__FILE__
, __LINE__
,
4195 _("allegedly permanent breakpoint is not "
4196 "actually inserted"));
4198 ALL_BP_LOCATIONS (b
)
4201 if (b
->owner
->enable_state
!= bp_permanent
4202 && b
->owner
->enable_state
!= bp_disabled
4203 && b
->owner
->enable_state
!= bp_call_disabled
4204 && b
->enabled
&& !b
->shlib_disabled
4205 && b
->address
== address
/* address / overlay match */
4206 && (!overlay_debugging
|| b
->section
== section
)
4207 && breakpoint_address_is_meaningful (b
->owner
))
4210 internal_error (__FILE__
, __LINE__
,
4211 _("another breakpoint was inserted on top of "
4212 "a permanent breakpoint"));
4221 check_duplicates (struct breakpoint
*bpt
)
4223 struct bp_location
*bl
= bpt
->loc
;
4225 if (! breakpoint_address_is_meaningful (bpt
))
4228 for (; bl
; bl
= bl
->next
)
4229 check_duplicates_for (bl
->address
, bl
->section
);
4233 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4234 int bnum
, int have_bnum
)
4239 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4240 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4242 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4243 bnum
, astr1
, astr2
);
4245 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4248 /* Adjust a breakpoint's address to account for architectural constraints
4249 on breakpoint placement. Return the adjusted address. Note: Very
4250 few targets require this kind of adjustment. For most targets,
4251 this function is simply the identity function. */
4254 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4256 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4258 /* Very few targets need any kind of breakpoint adjustment. */
4261 else if (bptype
== bp_watchpoint
4262 || bptype
== bp_hardware_watchpoint
4263 || bptype
== bp_read_watchpoint
4264 || bptype
== bp_access_watchpoint
4265 || bptype
== bp_catchpoint
)
4267 /* Watchpoints and the various bp_catch_* eventpoints should not
4268 have their addresses modified. */
4273 CORE_ADDR adjusted_bpaddr
;
4275 /* Some targets have architectural constraints on the placement
4276 of breakpoint instructions. Obtain the adjusted address. */
4277 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4280 /* An adjusted breakpoint address can significantly alter
4281 a user's expectations. Print a warning if an adjustment
4283 if (adjusted_bpaddr
!= bpaddr
)
4284 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4286 return adjusted_bpaddr
;
4290 /* Allocate a struct bp_location. */
4292 static struct bp_location
*
4293 allocate_bp_location (struct breakpoint
*bpt
)
4295 struct bp_location
*loc
, *loc_p
;
4297 loc
= xmalloc (sizeof (struct bp_location
));
4298 memset (loc
, 0, sizeof (*loc
));
4302 loc
->shlib_disabled
= 0;
4312 case bp_longjmp_resume
:
4313 case bp_step_resume
:
4314 case bp_watchpoint_scope
:
4316 case bp_shlib_event
:
4317 case bp_thread_event
:
4318 case bp_overlay_event
:
4319 case bp_longjmp_master
:
4320 loc
->loc_type
= bp_loc_software_breakpoint
;
4322 case bp_hardware_breakpoint
:
4323 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4325 case bp_hardware_watchpoint
:
4326 case bp_read_watchpoint
:
4327 case bp_access_watchpoint
:
4328 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4332 loc
->loc_type
= bp_loc_other
;
4335 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4341 static void free_bp_location (struct bp_location
*loc
)
4346 if (loc
->function_name
)
4347 xfree (loc
->function_name
);
4352 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4353 that has type BPTYPE and has no locations as yet. */
4355 static struct breakpoint
*
4356 set_raw_breakpoint_without_location (enum bptype bptype
)
4358 struct breakpoint
*b
, *b1
;
4360 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4361 memset (b
, 0, sizeof (*b
));
4364 b
->language
= current_language
->la_language
;
4365 b
->input_radix
= input_radix
;
4367 b
->enable_state
= bp_enabled
;
4370 b
->ignore_count
= 0;
4372 b
->frame_id
= null_frame_id
;
4373 b
->forked_inferior_pid
= null_ptid
;
4374 b
->exec_pathname
= NULL
;
4376 b
->condition_not_parsed
= 0;
4378 /* Add this breakpoint to the end of the chain
4379 so that a list of breakpoints will come out in order
4380 of increasing numbers. */
4382 b1
= breakpoint_chain
;
4384 breakpoint_chain
= b
;
4394 /* Initialize loc->function_name. */
4396 set_breakpoint_location_function (struct bp_location
*loc
)
4398 if (loc
->owner
->type
== bp_breakpoint
4399 || loc
->owner
->type
== bp_hardware_breakpoint
4400 || loc
->owner
->type
== bp_tracepoint
)
4402 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4404 if (loc
->function_name
)
4405 loc
->function_name
= xstrdup (loc
->function_name
);
4409 /* set_raw_breakpoint is a low level routine for allocating and
4410 partially initializing a breakpoint of type BPTYPE. The newly
4411 created breakpoint's address, section, source file name, and line
4412 number are provided by SAL. The newly created and partially
4413 initialized breakpoint is added to the breakpoint chain and
4414 is also returned as the value of this function.
4416 It is expected that the caller will complete the initialization of
4417 the newly created breakpoint struct as well as output any status
4418 information regarding the creation of a new breakpoint. In
4419 particular, set_raw_breakpoint does NOT set the breakpoint
4420 number! Care should be taken to not allow an error to occur
4421 prior to completing the initialization of the breakpoint. If this
4422 should happen, a bogus breakpoint will be left on the chain. */
4425 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4427 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4428 CORE_ADDR adjusted_address
;
4430 /* Adjust the breakpoint's address prior to allocating a location.
4431 Once we call allocate_bp_location(), that mostly uninitialized
4432 location will be placed on the location chain. Adjustment of the
4433 breakpoint may cause target_read_memory() to be called and we do
4434 not want its scan of the location chain to find a breakpoint and
4435 location that's only been partially initialized. */
4436 adjusted_address
= adjust_breakpoint_address (sal
.pc
, b
->type
);
4438 b
->loc
= allocate_bp_location (b
);
4439 b
->loc
->requested_address
= sal
.pc
;
4440 b
->loc
->address
= adjusted_address
;
4442 if (sal
.symtab
== NULL
)
4443 b
->source_file
= NULL
;
4445 b
->source_file
= xstrdup (sal
.symtab
->filename
);
4446 b
->loc
->section
= sal
.section
;
4447 b
->line_number
= sal
.line
;
4449 set_breakpoint_location_function (b
->loc
);
4451 breakpoints_changed ();
4457 /* Note that the breakpoint object B describes a permanent breakpoint
4458 instruction, hard-wired into the inferior's code. */
4460 make_breakpoint_permanent (struct breakpoint
*b
)
4462 struct bp_location
*bl
;
4463 b
->enable_state
= bp_permanent
;
4465 /* By definition, permanent breakpoints are already present in the code.
4466 Mark all locations as inserted. For now, make_breakpoint_permanent
4467 is called in just one place, so it's hard to say if it's reasonable
4468 to have permanent breakpoint with multiple locations or not,
4469 but it's easy to implmement. */
4470 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4474 /* Call this routine when stepping and nexting to enable a breakpoint
4475 if we do a longjmp() in THREAD. When we hit that breakpoint, call
4476 set_longjmp_resume_breakpoint() to figure out where we are going. */
4479 set_longjmp_breakpoint (int thread
)
4481 struct breakpoint
*b
, *temp
;
4483 /* To avoid having to rescan all objfile symbols at every step,
4484 we maintain a list of continually-inserted but always disabled
4485 longjmp "master" breakpoints. Here, we simply create momentary
4486 clones of those and enable them for the requested thread. */
4487 ALL_BREAKPOINTS_SAFE (b
, temp
)
4488 if (b
->type
== bp_longjmp_master
)
4490 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
4491 clone
->type
= bp_longjmp
;
4492 clone
->thread
= thread
;
4496 /* Delete all longjmp breakpoints from THREAD. */
4498 delete_longjmp_breakpoint (int thread
)
4500 struct breakpoint
*b
, *temp
;
4502 ALL_BREAKPOINTS_SAFE (b
, temp
)
4503 if (b
->type
== bp_longjmp
)
4505 if (b
->thread
== thread
)
4506 delete_breakpoint (b
);
4511 enable_overlay_breakpoints (void)
4513 struct breakpoint
*b
;
4516 if (b
->type
== bp_overlay_event
)
4518 b
->enable_state
= bp_enabled
;
4519 update_global_location_list (1);
4520 overlay_events_enabled
= 1;
4525 disable_overlay_breakpoints (void)
4527 struct breakpoint
*b
;
4530 if (b
->type
== bp_overlay_event
)
4532 b
->enable_state
= bp_disabled
;
4533 update_global_location_list (0);
4534 overlay_events_enabled
= 0;
4539 create_thread_event_breakpoint (CORE_ADDR address
)
4541 struct breakpoint
*b
;
4543 b
= create_internal_breakpoint (address
, bp_thread_event
);
4545 b
->enable_state
= bp_enabled
;
4546 /* addr_string has to be used or breakpoint_re_set will delete me. */
4547 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4549 update_global_location_list_nothrow (1);
4555 remove_thread_event_breakpoints (void)
4557 struct breakpoint
*b
, *temp
;
4559 ALL_BREAKPOINTS_SAFE (b
, temp
)
4560 if (b
->type
== bp_thread_event
)
4561 delete_breakpoint (b
);
4564 struct captured_parse_breakpoint_args
4567 struct symtabs_and_lines
*sals_p
;
4568 char ***addr_string_p
;
4572 struct lang_and_radix
4580 remove_solib_event_breakpoints (void)
4582 struct breakpoint
*b
, *temp
;
4584 ALL_BREAKPOINTS_SAFE (b
, temp
)
4585 if (b
->type
== bp_shlib_event
)
4586 delete_breakpoint (b
);
4590 create_solib_event_breakpoint (CORE_ADDR address
)
4592 struct breakpoint
*b
;
4594 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4595 update_global_location_list_nothrow (1);
4599 /* Disable any breakpoints that are on code in shared libraries. Only
4600 apply to enabled breakpoints, disabled ones can just stay disabled. */
4603 disable_breakpoints_in_shlibs (void)
4605 struct bp_location
*loc
;
4607 ALL_BP_LOCATIONS (loc
)
4609 struct breakpoint
*b
= loc
->owner
;
4610 /* We apply the check to all breakpoints, including disabled
4611 for those with loc->duplicate set. This is so that when breakpoint
4612 becomes enabled, or the duplicate is removed, gdb will try to insert
4613 all breakpoints. If we don't set shlib_disabled here, we'll try
4614 to insert those breakpoints and fail. */
4615 if (((b
->type
== bp_breakpoint
)
4616 || (b
->type
== bp_hardware_breakpoint
)
4617 || (b
->type
== bp_tracepoint
))
4618 && !loc
->shlib_disabled
4620 && PC_SOLIB (loc
->address
)
4622 && solib_name_from_address (loc
->address
)
4626 loc
->shlib_disabled
= 1;
4631 /* Disable any breakpoints that are in in an unloaded shared library. Only
4632 apply to enabled breakpoints, disabled ones can just stay disabled. */
4635 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4637 struct bp_location
*loc
;
4638 int disabled_shlib_breaks
= 0;
4640 /* SunOS a.out shared libraries are always mapped, so do not
4641 disable breakpoints; they will only be reported as unloaded
4642 through clear_solib when GDB discards its shared library
4643 list. See clear_solib for more information. */
4644 if (exec_bfd
!= NULL
4645 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
4648 ALL_BP_LOCATIONS (loc
)
4650 struct breakpoint
*b
= loc
->owner
;
4651 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4652 || loc
->loc_type
== bp_loc_software_breakpoint
)
4653 && !loc
->shlib_disabled
4654 && (b
->type
== bp_breakpoint
|| b
->type
== bp_hardware_breakpoint
)
4655 && solib_contains_address_p (solib
, loc
->address
))
4657 loc
->shlib_disabled
= 1;
4658 /* At this point, we cannot rely on remove_breakpoint
4659 succeeding so we must mark the breakpoint as not inserted
4660 to prevent future errors occurring in remove_breakpoints. */
4662 if (!disabled_shlib_breaks
)
4664 target_terminal_ours_for_output ();
4665 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4668 disabled_shlib_breaks
= 1;
4673 /* FORK & VFORK catchpoints. */
4675 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
4678 insert_catch_fork (struct breakpoint
*b
)
4680 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
4683 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
4686 remove_catch_fork (struct breakpoint
*b
)
4688 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
4691 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
4695 breakpoint_hit_catch_fork (struct breakpoint
*b
)
4697 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
4700 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
4702 static enum print_stop_action
4703 print_it_catch_fork (struct breakpoint
*b
)
4705 annotate_catchpoint (b
->number
);
4706 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
4707 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4708 return PRINT_SRC_AND_LOC
;
4711 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
4714 print_one_catch_fork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4716 struct value_print_options opts
;
4718 get_user_print_options (&opts
);
4720 /* Field 4, the address, is omitted (which makes the columns
4721 not line up too nicely with the headers, but the effect
4722 is relatively readable). */
4723 if (opts
.addressprint
)
4724 ui_out_field_skip (uiout
, "addr");
4726 ui_out_text (uiout
, "fork");
4727 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4729 ui_out_text (uiout
, ", process ");
4730 ui_out_field_int (uiout
, "what",
4731 ptid_get_pid (b
->forked_inferior_pid
));
4732 ui_out_spaces (uiout
, 1);
4736 /* Implement the "print_mention" breakpoint_ops method for fork
4740 print_mention_catch_fork (struct breakpoint
*b
)
4742 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
4745 /* The breakpoint_ops structure to be used in fork catchpoints. */
4747 static struct breakpoint_ops catch_fork_breakpoint_ops
=
4751 breakpoint_hit_catch_fork
,
4752 print_it_catch_fork
,
4753 print_one_catch_fork
,
4754 print_mention_catch_fork
4757 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
4760 insert_catch_vfork (struct breakpoint
*b
)
4762 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
4765 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
4768 remove_catch_vfork (struct breakpoint
*b
)
4770 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
4773 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
4777 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
4779 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
4782 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
4784 static enum print_stop_action
4785 print_it_catch_vfork (struct breakpoint
*b
)
4787 annotate_catchpoint (b
->number
);
4788 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
4789 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4790 return PRINT_SRC_AND_LOC
;
4793 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
4796 print_one_catch_vfork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4798 struct value_print_options opts
;
4800 get_user_print_options (&opts
);
4801 /* Field 4, the address, is omitted (which makes the columns
4802 not line up too nicely with the headers, but the effect
4803 is relatively readable). */
4804 if (opts
.addressprint
)
4805 ui_out_field_skip (uiout
, "addr");
4807 ui_out_text (uiout
, "vfork");
4808 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4810 ui_out_text (uiout
, ", process ");
4811 ui_out_field_int (uiout
, "what",
4812 ptid_get_pid (b
->forked_inferior_pid
));
4813 ui_out_spaces (uiout
, 1);
4817 /* Implement the "print_mention" breakpoint_ops method for vfork
4821 print_mention_catch_vfork (struct breakpoint
*b
)
4823 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
4826 /* The breakpoint_ops structure to be used in vfork catchpoints. */
4828 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
4832 breakpoint_hit_catch_vfork
,
4833 print_it_catch_vfork
,
4834 print_one_catch_vfork
,
4835 print_mention_catch_vfork
4838 /* Create a new breakpoint of the bp_catchpoint kind and return it.
4840 If TEMPFLAG is non-zero, then make the breakpoint temporary.
4841 If COND_STRING is not NULL, then store it in the breakpoint.
4842 OPS, if not NULL, is the breakpoint_ops structure associated
4843 to the catchpoint. */
4845 static struct breakpoint
*
4846 create_catchpoint (int tempflag
, char *cond_string
,
4847 struct breakpoint_ops
*ops
)
4849 struct symtab_and_line sal
;
4850 struct breakpoint
*b
;
4857 b
= set_raw_breakpoint (sal
, bp_catchpoint
);
4858 set_breakpoint_count (breakpoint_count
+ 1);
4859 b
->number
= breakpoint_count
;
4861 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
4863 b
->addr_string
= NULL
;
4864 b
->enable_state
= bp_enabled
;
4865 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4869 update_global_location_list (1);
4875 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4876 struct breakpoint_ops
*ops
)
4878 struct breakpoint
*b
= create_catchpoint (tempflag
, cond_string
, ops
);
4880 /* FIXME: We should put this information in a breakpoint private data
4882 b
->forked_inferior_pid
= null_ptid
;
4885 /* Exec catchpoints. */
4888 insert_catch_exec (struct breakpoint
*b
)
4890 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
4894 remove_catch_exec (struct breakpoint
*b
)
4896 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
4900 breakpoint_hit_catch_exec (struct breakpoint
*b
)
4902 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
4905 static enum print_stop_action
4906 print_it_catch_exec (struct breakpoint
*b
)
4908 annotate_catchpoint (b
->number
);
4909 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
4911 return PRINT_SRC_AND_LOC
;
4915 print_one_catch_exec (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4917 struct value_print_options opts
;
4919 get_user_print_options (&opts
);
4921 /* Field 4, the address, is omitted (which makes the columns
4922 not line up too nicely with the headers, but the effect
4923 is relatively readable). */
4924 if (opts
.addressprint
)
4925 ui_out_field_skip (uiout
, "addr");
4927 ui_out_text (uiout
, "exec");
4928 if (b
->exec_pathname
!= NULL
)
4930 ui_out_text (uiout
, ", program \"");
4931 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
4932 ui_out_text (uiout
, "\" ");
4937 print_mention_catch_exec (struct breakpoint
*b
)
4939 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
4942 static struct breakpoint_ops catch_exec_breakpoint_ops
=
4946 breakpoint_hit_catch_exec
,
4947 print_it_catch_exec
,
4948 print_one_catch_exec
,
4949 print_mention_catch_exec
4953 hw_breakpoint_used_count (void)
4955 struct breakpoint
*b
;
4960 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
4968 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4970 struct breakpoint
*b
;
4973 *other_type_used
= 0;
4976 if (breakpoint_enabled (b
))
4978 if (b
->type
== type
)
4980 else if ((b
->type
== bp_hardware_watchpoint
4981 || b
->type
== bp_read_watchpoint
4982 || b
->type
== bp_access_watchpoint
))
4983 *other_type_used
= 1;
4990 disable_watchpoints_before_interactive_call_start (void)
4992 struct breakpoint
*b
;
4996 if (((b
->type
== bp_watchpoint
)
4997 || (b
->type
== bp_hardware_watchpoint
)
4998 || (b
->type
== bp_read_watchpoint
)
4999 || (b
->type
== bp_access_watchpoint
))
5000 && breakpoint_enabled (b
))
5002 b
->enable_state
= bp_call_disabled
;
5003 update_global_location_list (0);
5009 enable_watchpoints_after_interactive_call_stop (void)
5011 struct breakpoint
*b
;
5015 if (((b
->type
== bp_watchpoint
)
5016 || (b
->type
== bp_hardware_watchpoint
)
5017 || (b
->type
== bp_read_watchpoint
)
5018 || (b
->type
== bp_access_watchpoint
))
5019 && (b
->enable_state
== bp_call_disabled
))
5021 b
->enable_state
= bp_enabled
;
5022 update_global_location_list (1);
5028 /* Set a breakpoint that will evaporate an end of command
5029 at address specified by SAL.
5030 Restrict it to frame FRAME if FRAME is nonzero. */
5033 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
5036 struct breakpoint
*b
;
5038 /* If FRAME_ID is valid, it should be a real frame, not an inlined
5040 gdb_assert (!frame_id_inlined_p (frame_id
));
5042 b
= set_raw_breakpoint (sal
, type
);
5043 b
->enable_state
= bp_enabled
;
5044 b
->disposition
= disp_donttouch
;
5045 b
->frame_id
= frame_id
;
5047 /* If we're debugging a multi-threaded program, then we
5048 want momentary breakpoints to be active in only a
5049 single thread of control. */
5050 if (in_thread_list (inferior_ptid
))
5051 b
->thread
= pid_to_thread_id (inferior_ptid
);
5053 update_global_location_list_nothrow (1);
5058 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
5062 clone_momentary_breakpoint (struct breakpoint
*orig
)
5064 struct breakpoint
*copy
;
5066 /* If there's nothing to clone, then return nothing. */
5070 copy
= set_raw_breakpoint_without_location (orig
->type
);
5071 copy
->loc
= allocate_bp_location (copy
);
5072 set_breakpoint_location_function (copy
->loc
);
5074 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
5075 copy
->loc
->address
= orig
->loc
->address
;
5076 copy
->loc
->section
= orig
->loc
->section
;
5078 if (orig
->source_file
== NULL
)
5079 copy
->source_file
= NULL
;
5081 copy
->source_file
= xstrdup (orig
->source_file
);
5083 copy
->line_number
= orig
->line_number
;
5084 copy
->frame_id
= orig
->frame_id
;
5085 copy
->thread
= orig
->thread
;
5087 copy
->enable_state
= bp_enabled
;
5088 copy
->disposition
= disp_donttouch
;
5089 copy
->number
= internal_breakpoint_number
--;
5091 update_global_location_list_nothrow (0);
5096 set_momentary_breakpoint_at_pc (CORE_ADDR pc
, enum bptype type
)
5098 struct symtab_and_line sal
;
5100 sal
= find_pc_line (pc
, 0);
5102 sal
.section
= find_pc_overlay (pc
);
5103 sal
.explicit_pc
= 1;
5105 return set_momentary_breakpoint (sal
, null_frame_id
, type
);
5109 /* Tell the user we have just set a breakpoint B. */
5112 mention (struct breakpoint
*b
)
5115 struct cleanup
*ui_out_chain
;
5116 struct value_print_options opts
;
5118 get_user_print_options (&opts
);
5120 /* FIXME: This is misplaced; mention() is called by things (like
5121 hitting a watchpoint) other than breakpoint creation. It should
5122 be possible to clean this up and at the same time replace the
5123 random calls to breakpoint_changed with this hook. */
5124 observer_notify_breakpoint_created (b
->number
);
5126 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
5127 b
->ops
->print_mention (b
);
5132 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
5135 ui_out_text (uiout
, "Watchpoint ");
5136 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5137 ui_out_field_int (uiout
, "number", b
->number
);
5138 ui_out_text (uiout
, ": ");
5139 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5140 do_cleanups (ui_out_chain
);
5142 case bp_hardware_watchpoint
:
5143 ui_out_text (uiout
, "Hardware watchpoint ");
5144 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5145 ui_out_field_int (uiout
, "number", b
->number
);
5146 ui_out_text (uiout
, ": ");
5147 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5148 do_cleanups (ui_out_chain
);
5150 case bp_read_watchpoint
:
5151 ui_out_text (uiout
, "Hardware read watchpoint ");
5152 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
5153 ui_out_field_int (uiout
, "number", b
->number
);
5154 ui_out_text (uiout
, ": ");
5155 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5156 do_cleanups (ui_out_chain
);
5158 case bp_access_watchpoint
:
5159 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
5160 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
5161 ui_out_field_int (uiout
, "number", b
->number
);
5162 ui_out_text (uiout
, ": ");
5163 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5164 do_cleanups (ui_out_chain
);
5167 if (ui_out_is_mi_like_p (uiout
))
5172 if (b
->disposition
== disp_del
)
5173 printf_filtered (_("Temporary breakpoint"));
5175 printf_filtered (_("Breakpoint"));
5176 printf_filtered (_(" %d"), b
->number
);
5179 case bp_hardware_breakpoint
:
5180 if (ui_out_is_mi_like_p (uiout
))
5185 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
5189 if (ui_out_is_mi_like_p (uiout
))
5194 printf_filtered (_("Tracepoint"));
5195 printf_filtered (_(" %d"), b
->number
);
5202 case bp_longjmp_resume
:
5203 case bp_step_resume
:
5205 case bp_watchpoint_scope
:
5206 case bp_shlib_event
:
5207 case bp_thread_event
:
5208 case bp_overlay_event
:
5209 case bp_longjmp_master
:
5215 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5219 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5223 if (opts
.addressprint
|| b
->source_file
== NULL
)
5225 printf_filtered (" at ");
5226 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
5229 printf_filtered (": file %s, line %d.",
5230 b
->source_file
, b
->line_number
);
5234 struct bp_location
*loc
= b
->loc
;
5236 for (; loc
; loc
= loc
->next
)
5238 printf_filtered (" (%d locations)", n
);
5243 if (ui_out_is_mi_like_p (uiout
))
5245 printf_filtered ("\n");
5249 static struct bp_location
*
5250 add_location_to_breakpoint (struct breakpoint
*b
,
5251 const struct symtab_and_line
*sal
)
5253 struct bp_location
*loc
, **tmp
;
5255 loc
= allocate_bp_location (b
);
5256 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5259 loc
->requested_address
= sal
->pc
;
5260 loc
->address
= adjust_breakpoint_address (loc
->requested_address
, b
->type
);
5261 loc
->section
= sal
->section
;
5263 set_breakpoint_location_function (loc
);
5268 /* Return 1 if LOC is pointing to a permanent breakpoint,
5269 return 0 otherwise. */
5272 bp_loc_is_permanent (struct bp_location
*loc
)
5276 const gdb_byte
*brk
;
5277 gdb_byte
*target_mem
;
5278 struct cleanup
*cleanup
;
5281 gdb_assert (loc
!= NULL
);
5283 addr
= loc
->address
;
5284 brk
= gdbarch_breakpoint_from_pc (current_gdbarch
, &addr
, &len
);
5286 /* Software breakpoints unsupported? */
5290 target_mem
= alloca (len
);
5292 /* Enable the automatic memory restoration from breakpoints while
5293 we read the memory. Otherwise we could say about our temporary
5294 breakpoints they are permanent. */
5295 cleanup
= make_show_memory_breakpoints_cleanup (0);
5297 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
5298 && memcmp (target_mem
, brk
, len
) == 0)
5301 do_cleanups (cleanup
);
5308 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5309 as textual description of the location, and COND_STRING
5310 as condition expression. */
5313 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5315 enum bptype type
, enum bpdisp disposition
,
5316 int thread
, int task
, int ignore_count
,
5317 struct breakpoint_ops
*ops
, int from_tty
, int enabled
)
5319 struct breakpoint
*b
= NULL
;
5322 if (type
== bp_hardware_breakpoint
)
5324 int i
= hw_breakpoint_used_count ();
5325 int target_resources_ok
=
5326 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
5328 if (target_resources_ok
== 0)
5329 error (_("No hardware breakpoint support in the target."));
5330 else if (target_resources_ok
< 0)
5331 error (_("Hardware breakpoints used exceeds limit."));
5334 for (i
= 0; i
< sals
.nelts
; ++i
)
5336 struct symtab_and_line sal
= sals
.sals
[i
];
5337 struct bp_location
*loc
;
5340 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5344 b
= set_raw_breakpoint (sal
, type
);
5345 set_breakpoint_count (breakpoint_count
+ 1);
5346 b
->number
= breakpoint_count
;
5350 b
->cond_string
= cond_string
;
5351 b
->ignore_count
= ignore_count
;
5352 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
5353 b
->disposition
= disposition
;
5359 loc
= add_location_to_breakpoint (b
, &sal
);
5362 if (bp_loc_is_permanent (loc
))
5363 make_breakpoint_permanent (b
);
5367 char *arg
= b
->cond_string
;
5368 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5370 error (_("Garbage %s follows condition"), arg
);
5375 b
->addr_string
= addr_string
;
5377 /* addr_string has to be used or breakpoint_re_set will delete
5379 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5385 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5386 elements to fill the void space. */
5388 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5390 int i
= index_to_remove
+1;
5391 int last_index
= sal
->nelts
-1;
5393 for (;i
<= last_index
; ++i
)
5394 sal
->sals
[i
-1] = sal
->sals
[i
];
5399 /* If appropriate, obtains all sals that correspond
5400 to the same file and line as SAL. This is done
5401 only if SAL does not have explicit PC and has
5402 line and file information. If we got just a single
5403 expanded sal, return the original.
5405 Otherwise, if SAL.explicit_line is not set, filter out
5406 all sals for which the name of enclosing function
5407 is different from SAL. This makes sure that if we have
5408 breakpoint originally set in template instantiation, say
5409 foo<int>(), we won't expand SAL to locations at the same
5410 line in all existing instantiations of 'foo'.
5413 static struct symtabs_and_lines
5414 expand_line_sal_maybe (struct symtab_and_line sal
)
5416 struct symtabs_and_lines expanded
;
5417 CORE_ADDR original_pc
= sal
.pc
;
5418 char *original_function
= NULL
;
5422 /* If we have explicit pc, don't expand.
5423 If we have no line number, we can't expand. */
5424 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5427 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5428 expanded
.sals
[0] = sal
;
5433 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5435 expanded
= expand_line_sal (sal
);
5436 if (expanded
.nelts
== 1)
5438 /* We had one sal, we got one sal. Without futher
5439 processing, just return the original sal. */
5440 xfree (expanded
.sals
);
5442 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5443 sal
.pc
= original_pc
;
5444 expanded
.sals
[0] = sal
;
5448 if (!sal
.explicit_line
)
5450 CORE_ADDR func_addr
, func_end
;
5451 for (i
= 0; i
< expanded
.nelts
; ++i
)
5453 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5454 char *this_function
;
5455 if (find_pc_partial_function (pc
, &this_function
,
5456 &func_addr
, &func_end
))
5459 && strcmp (this_function
, original_function
) != 0)
5461 remove_sal (&expanded
, i
);
5464 else if (func_addr
== pc
)
5466 /* We're at beginning of a function, and should
5468 struct symbol
*sym
= find_pc_function (pc
);
5470 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5473 /* Since find_pc_partial_function returned true,
5474 we should really always find the section here. */
5475 struct obj_section
*section
= find_pc_section (pc
);
5478 struct gdbarch
*gdbarch
5479 = get_objfile_arch (section
->objfile
);
5481 = gdbarch_skip_prologue (gdbarch
, pc
);
5490 for (i
= 0; i
< expanded
.nelts
; ++i
)
5492 /* If this SAL corresponds to a breakpoint inserted using a
5493 line number, then skip the function prologue if necessary. */
5494 skip_prologue_sal (&expanded
.sals
[i
]);
5499 if (expanded
.nelts
<= 1)
5501 /* This is un ugly workaround. If we get zero
5502 expanded sals then something is really wrong.
5503 Fix that by returnign the original sal. */
5504 xfree (expanded
.sals
);
5506 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5507 sal
.pc
= original_pc
;
5508 expanded
.sals
[0] = sal
;
5515 for (i
= 0; i
< expanded
.nelts
; ++i
)
5516 if (expanded
.sals
[i
].pc
== original_pc
)
5527 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5528 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5529 value. COND_STRING, if not NULL, specified the condition to be
5530 used for all breakpoints. Essentially the only case where
5531 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5532 function. In that case, it's still not possible to specify
5533 separate conditions for different overloaded functions, so
5534 we take just a single condition string.
5536 NOTE: If the function succeeds, the caller is expected to cleanup
5537 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5538 array contents). If the function fails (error() is called), the
5539 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5540 COND and SALS arrays and each of those arrays contents. */
5543 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5545 enum bptype type
, enum bpdisp disposition
,
5546 int thread
, int task
, int ignore_count
,
5547 struct breakpoint_ops
*ops
, int from_tty
,
5551 for (i
= 0; i
< sals
.nelts
; ++i
)
5553 struct symtabs_and_lines expanded
=
5554 expand_line_sal_maybe (sals
.sals
[i
]);
5556 create_breakpoint (expanded
, addr_string
[i
],
5557 cond_string
, type
, disposition
,
5558 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
5562 /* Parse ARG which is assumed to be a SAL specification possibly
5563 followed by conditionals. On return, SALS contains an array of SAL
5564 addresses found. ADDR_STRING contains a vector of (canonical)
5565 address strings. ARG points to the end of the SAL. */
5568 parse_breakpoint_sals (char **address
,
5569 struct symtabs_and_lines
*sals
,
5570 char ***addr_string
,
5573 char *addr_start
= *address
;
5574 *addr_string
= NULL
;
5575 /* If no arg given, or if first arg is 'if ', use the default
5577 if ((*address
) == NULL
5578 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5580 if (default_breakpoint_valid
)
5582 struct symtab_and_line sal
;
5583 init_sal (&sal
); /* initialize to zeroes */
5584 sals
->sals
= (struct symtab_and_line
*)
5585 xmalloc (sizeof (struct symtab_and_line
));
5586 sal
.pc
= default_breakpoint_address
;
5587 sal
.line
= default_breakpoint_line
;
5588 sal
.symtab
= default_breakpoint_symtab
;
5589 sal
.section
= find_pc_overlay (sal
.pc
);
5591 /* "break" without arguments is equivalent to "break *PC" where PC is
5592 the default_breakpoint_address. So make sure to set
5593 sal.explicit_pc to prevent GDB from trying to expand the list of
5594 sals to include all other instances with the same symtab and line.
5596 sal
.explicit_pc
= 1;
5598 sals
->sals
[0] = sal
;
5602 error (_("No default breakpoint address now."));
5606 /* Force almost all breakpoints to be in terms of the
5607 current_source_symtab (which is decode_line_1's default). This
5608 should produce the results we want almost all of the time while
5609 leaving default_breakpoint_* alone.
5610 ObjC: However, don't match an Objective-C method name which
5611 may have a '+' or '-' succeeded by a '[' */
5613 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5615 if (default_breakpoint_valid
5617 || ((strchr ("+-", (*address
)[0]) != NULL
)
5618 && ((*address
)[1] != '['))))
5619 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5620 default_breakpoint_line
, addr_string
,
5623 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5624 addr_string
, not_found_ptr
);
5626 /* For any SAL that didn't have a canonical string, fill one in. */
5627 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5628 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5629 if (addr_start
!= (*address
))
5632 for (i
= 0; i
< sals
->nelts
; i
++)
5634 /* Add the string if not present. */
5635 if ((*addr_string
)[i
] == NULL
)
5636 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5642 /* Convert each SAL into a real PC. Verify that the PC can be
5643 inserted as a breakpoint. If it can't throw an error. */
5646 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5650 for (i
= 0; i
< sals
->nelts
; i
++)
5651 resolve_sal_pc (&sals
->sals
[i
]);
5655 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5657 struct captured_parse_breakpoint_args
*args
= data
;
5659 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5660 args
->not_found_ptr
);
5663 /* Given TOK, a string specification of condition and thread, as
5664 accepted by the 'break' command, extract the condition
5665 string and thread number and set *COND_STRING and *THREAD.
5666 PC identifies the context at which the condition should be parsed.
5667 If no condition is found, *COND_STRING is set to NULL.
5668 If no thread is found, *THREAD is set to -1. */
5670 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5671 char **cond_string
, int *thread
, int *task
)
5673 *cond_string
= NULL
;
5679 char *cond_start
= NULL
;
5680 char *cond_end
= NULL
;
5681 while (*tok
== ' ' || *tok
== '\t')
5686 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5689 toklen
= end_tok
- tok
;
5691 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5693 struct expression
*expr
;
5695 tok
= cond_start
= end_tok
+ 1;
5696 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5699 *cond_string
= savestring (cond_start
,
5700 cond_end
- cond_start
);
5702 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5708 *thread
= strtol (tok
, &tok
, 0);
5710 error (_("Junk after thread keyword."));
5711 if (!valid_thread_id (*thread
))
5712 error (_("Unknown thread %d."), *thread
);
5714 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
5720 *task
= strtol (tok
, &tok
, 0);
5722 error (_("Junk after task keyword."));
5723 if (!valid_task_id (*task
))
5724 error (_("Unknown task %d\n"), *task
);
5727 error (_("Junk at end of arguments."));
5731 /* Set a breakpoint. This function is shared between
5732 CLI and MI functions for setting a breakpoint.
5733 This function has two major modes of operations,
5734 selected by the PARSE_CONDITION_AND_THREAD parameter.
5735 If non-zero, the function will parse arg, extracting
5736 breakpoint location, address and thread. Otherwise,
5737 ARG is just the location of breakpoint, with condition
5738 and thread specified by the COND_STRING and THREAD
5742 break_command_really (char *arg
, char *cond_string
, int thread
,
5743 int parse_condition_and_thread
,
5744 int tempflag
, int hardwareflag
, int traceflag
,
5746 enum auto_boolean pending_break_support
,
5747 struct breakpoint_ops
*ops
,
5751 struct gdb_exception e
;
5752 struct symtabs_and_lines sals
;
5753 struct symtab_and_line pending_sal
;
5756 char *addr_start
= arg
;
5758 struct cleanup
*old_chain
;
5759 struct cleanup
*bkpt_chain
= NULL
;
5760 struct captured_parse_breakpoint_args parse_args
;
5764 enum bptype type_wanted
;
5771 parse_args
.arg_p
= &arg
;
5772 parse_args
.sals_p
= &sals
;
5773 parse_args
.addr_string_p
= &addr_string
;
5774 parse_args
.not_found_ptr
= ¬_found
;
5776 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5777 &parse_args
, RETURN_MASK_ALL
);
5779 /* If caller is interested in rc value from parse, set value. */
5783 throw_exception (e
);
5787 case NOT_FOUND_ERROR
:
5789 /* If pending breakpoint support is turned off, throw
5792 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5793 throw_exception (e
);
5795 exception_print (gdb_stderr
, e
);
5797 /* If pending breakpoint support is auto query and the user
5798 selects no, then simply return the error code. */
5799 if (pending_break_support
== AUTO_BOOLEAN_AUTO
5800 && !nquery ("Make breakpoint pending on future shared library load? "))
5803 /* At this point, either the user was queried about setting
5804 a pending breakpoint and selected yes, or pending
5805 breakpoint behavior is on and thus a pending breakpoint
5806 is defaulted on behalf of the user. */
5807 copy_arg
= xstrdup (addr_start
);
5808 addr_string
= ©_arg
;
5810 sals
.sals
= &pending_sal
;
5815 throw_exception (e
);
5822 /* Create a chain of things that always need to be cleaned up. */
5823 old_chain
= make_cleanup (null_cleanup
, 0);
5827 /* Make sure that all storage allocated to SALS gets freed. */
5828 make_cleanup (xfree
, sals
.sals
);
5830 /* Cleanup the addr_string array but not its contents. */
5831 make_cleanup (xfree
, addr_string
);
5834 /* ----------------------------- SNIP -----------------------------
5835 Anything added to the cleanup chain beyond this point is assumed
5836 to be part of a breakpoint. If the breakpoint create succeeds
5837 then the memory is not reclaimed. */
5838 bkpt_chain
= make_cleanup (null_cleanup
, 0);
5840 /* Mark the contents of the addr_string for cleanup. These go on
5841 the bkpt_chain and only occur if the breakpoint create fails. */
5842 for (i
= 0; i
< sals
.nelts
; i
++)
5844 if (addr_string
[i
] != NULL
)
5845 make_cleanup (xfree
, addr_string
[i
]);
5848 /* Resolve all line numbers to PC's and verify that the addresses
5849 are ok for the target. */
5851 breakpoint_sals_to_pc (&sals
, addr_start
);
5853 type_wanted
= (traceflag
5855 : (hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
));
5857 /* Verify that condition can be parsed, before setting any
5858 breakpoints. Allocate a separate condition expression for each
5862 if (parse_condition_and_thread
)
5864 /* Here we only parse 'arg' to separate condition
5865 from thread number, so parsing in context of first
5866 sal is OK. When setting the breakpoint we'll
5867 re-parse it in context of each sal. */
5870 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
5873 make_cleanup (xfree
, cond_string
);
5877 /* Create a private copy of condition string. */
5880 cond_string
= xstrdup (cond_string
);
5881 make_cleanup (xfree
, cond_string
);
5884 create_breakpoints (sals
, addr_string
, cond_string
, type_wanted
,
5885 tempflag
? disp_del
: disp_donttouch
,
5886 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
5890 struct symtab_and_line sal
= {0};
5891 struct breakpoint
*b
;
5893 make_cleanup (xfree
, copy_arg
);
5895 b
= set_raw_breakpoint_without_location (type_wanted
);
5896 set_breakpoint_count (breakpoint_count
+ 1);
5897 b
->number
= breakpoint_count
;
5899 b
->addr_string
= addr_string
[0];
5900 b
->cond_string
= NULL
;
5901 b
->ignore_count
= ignore_count
;
5902 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5903 b
->condition_not_parsed
= 1;
5905 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
5911 warning (_("Multiple breakpoints were set.\n"
5912 "Use the \"delete\" command to delete unwanted breakpoints."));
5913 /* That's it. Discard the cleanups for data inserted into the
5915 discard_cleanups (bkpt_chain
);
5916 /* But cleanup everything else. */
5917 do_cleanups (old_chain
);
5919 /* error call may happen here - have BKPT_CHAIN already discarded. */
5920 update_global_location_list (1);
5923 /* Set a breakpoint.
5924 ARG is a string describing breakpoint address,
5925 condition, and thread.
5926 FLAG specifies if a breakpoint is hardware on,
5927 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5931 break_command_1 (char *arg
, int flag
, int from_tty
)
5933 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5934 int tempflag
= flag
& BP_TEMPFLAG
;
5936 break_command_really (arg
,
5937 NULL
, 0, 1 /* parse arg */,
5938 tempflag
, hardwareflag
, 0 /* traceflag */,
5939 0 /* Ignore count */,
5940 pending_break_support
,
5941 NULL
/* breakpoint_ops */,
5948 set_breakpoint (char *address
, char *condition
,
5949 int hardwareflag
, int tempflag
,
5950 int thread
, int ignore_count
,
5951 int pending
, int enabled
)
5953 break_command_really (address
, condition
, thread
,
5954 0 /* condition and thread are valid. */,
5955 tempflag
, hardwareflag
, 0 /* traceflag */,
5958 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5962 /* Adjust SAL to the first instruction past the function prologue.
5963 The end of the prologue is determined using the line table from
5964 the debugging information. explicit_pc and explicit_line are
5967 If SAL is already past the prologue, then do nothing. */
5970 skip_prologue_sal (struct symtab_and_line
*sal
)
5972 struct symbol
*sym
= find_pc_function (sal
->pc
);
5973 struct symtab_and_line start_sal
;
5978 start_sal
= find_function_start_sal (sym
, 1);
5979 if (sal
->pc
< start_sal
.pc
)
5981 start_sal
.explicit_line
= sal
->explicit_line
;
5982 start_sal
.explicit_pc
= sal
->explicit_pc
;
5987 /* Helper function for break_command_1 and disassemble_command. */
5990 resolve_sal_pc (struct symtab_and_line
*sal
)
5994 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5996 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5997 error (_("No line %d in file \"%s\"."),
5998 sal
->line
, sal
->symtab
->filename
);
6001 /* If this SAL corresponds to a breakpoint inserted using
6002 a line number, then skip the function prologue if necessary. */
6003 if (sal
->explicit_line
)
6005 /* Preserve the original line number. */
6006 int saved_line
= sal
->line
;
6007 skip_prologue_sal (sal
);
6008 sal
->line
= saved_line
;
6012 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
6014 struct blockvector
*bv
;
6018 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
6021 sym
= block_linkage_function (b
);
6024 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
6025 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
6029 /* It really is worthwhile to have the section, so we'll just
6030 have to look harder. This case can be executed if we have
6031 line numbers but no functions (as can happen in assembly
6034 struct minimal_symbol
*msym
;
6036 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
6038 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
6045 break_command (char *arg
, int from_tty
)
6047 break_command_1 (arg
, 0, from_tty
);
6051 tbreak_command (char *arg
, int from_tty
)
6053 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
6057 hbreak_command (char *arg
, int from_tty
)
6059 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
6063 thbreak_command (char *arg
, int from_tty
)
6065 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
6069 stop_command (char *arg
, int from_tty
)
6071 printf_filtered (_("Specify the type of breakpoint to set.\n\
6072 Usage: stop in <function | address>\n\
6073 stop at <line>\n"));
6077 stopin_command (char *arg
, int from_tty
)
6081 if (arg
== (char *) NULL
)
6083 else if (*arg
!= '*')
6088 /* look for a ':'. If this is a line number specification, then
6089 say it is bad, otherwise, it should be an address or
6090 function/method name */
6091 while (*argptr
&& !hasColon
)
6093 hasColon
= (*argptr
== ':');
6098 badInput
= (*argptr
!= ':'); /* Not a class::method */
6100 badInput
= isdigit (*arg
); /* a simple line number */
6104 printf_filtered (_("Usage: stop in <function | address>\n"));
6106 break_command_1 (arg
, 0, from_tty
);
6110 stopat_command (char *arg
, int from_tty
)
6114 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
6121 /* look for a ':'. If there is a '::' then get out, otherwise
6122 it is probably a line number. */
6123 while (*argptr
&& !hasColon
)
6125 hasColon
= (*argptr
== ':');
6130 badInput
= (*argptr
== ':'); /* we have class::method */
6132 badInput
= !isdigit (*arg
); /* not a line number */
6136 printf_filtered (_("Usage: stop at <line>\n"));
6138 break_command_1 (arg
, 0, from_tty
);
6141 /* accessflag: hw_write: watch write,
6142 hw_read: watch read,
6143 hw_access: watch access (read or write) */
6145 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
6147 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
6148 struct symtab_and_line sal
;
6149 struct expression
*exp
;
6150 struct block
*exp_valid_block
;
6151 struct value
*val
, *mark
;
6152 struct frame_info
*frame
;
6153 char *exp_start
= NULL
;
6154 char *exp_end
= NULL
;
6155 char *tok
, *id_tok_start
, *end_tok
;
6157 char *cond_start
= NULL
;
6158 char *cond_end
= NULL
;
6159 struct expression
*cond
= NULL
;
6160 int i
, other_type_used
, target_resources_ok
= 0;
6161 enum bptype bp_type
;
6165 init_sal (&sal
); /* initialize to zeroes */
6167 /* Make sure that we actually have parameters to parse. */
6168 if (arg
!= NULL
&& arg
[0] != '\0')
6170 toklen
= strlen (arg
); /* Size of argument list. */
6172 /* Points tok to the end of the argument list. */
6173 tok
= arg
+ toklen
- 1;
6175 /* Go backwards in the parameters list. Skip the last parameter.
6176 If we're expecting a 'thread <thread_num>' parameter, this should
6177 be the thread identifier. */
6178 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6180 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6183 /* Points end_tok to the beginning of the last token. */
6184 id_tok_start
= tok
+ 1;
6186 /* Go backwards in the parameters list. Skip one more parameter.
6187 If we're expecting a 'thread <thread_num>' parameter, we should
6188 reach a "thread" token. */
6189 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6194 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6197 /* Move the pointer forward to skip the whitespace and
6198 calculate the length of the token. */
6200 toklen
= end_tok
- tok
;
6202 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
6204 /* At this point we've found a "thread" token, which means
6205 the user is trying to set a watchpoint that triggers
6206 only in a specific thread. */
6209 /* Extract the thread ID from the next token. */
6210 thread
= strtol (id_tok_start
, &endp
, 0);
6212 /* Check if the user provided a valid numeric value for the
6214 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
6215 error (_("Invalid thread ID specification %s."), id_tok_start
);
6217 /* Check if the thread actually exists. */
6218 if (!valid_thread_id (thread
))
6219 error (_("Unknown thread %d."), thread
);
6221 /* Truncate the string and get rid of the thread <thread_num>
6222 parameter before the parameter list is parsed by the
6223 evaluate_expression() function. */
6228 /* Parse the rest of the arguments. */
6229 innermost_block
= NULL
;
6231 exp
= parse_exp_1 (&arg
, 0, 0);
6233 /* Remove trailing whitespace from the expression before saving it.
6234 This makes the eventual display of the expression string a bit
6236 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
6239 exp_valid_block
= innermost_block
;
6240 mark
= value_mark ();
6241 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
6243 release_value (val
);
6246 while (*tok
== ' ' || *tok
== '\t')
6250 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
6253 toklen
= end_tok
- tok
;
6254 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
6256 tok
= cond_start
= end_tok
+ 1;
6257 cond
= parse_exp_1 (&tok
, 0, 0);
6261 error (_("Junk at end of command."));
6263 if (accessflag
== hw_read
)
6264 bp_type
= bp_read_watchpoint
;
6265 else if (accessflag
== hw_access
)
6266 bp_type
= bp_access_watchpoint
;
6268 bp_type
= bp_hardware_watchpoint
;
6270 mem_cnt
= can_use_hardware_watchpoint (val
);
6271 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
6272 error (_("Expression cannot be implemented with read/access watchpoint."));
6275 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
6276 target_resources_ok
=
6277 target_can_use_hardware_watchpoint (bp_type
, i
+ mem_cnt
,
6279 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
6280 error (_("Target does not support this type of hardware watchpoint."));
6282 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
6283 error (_("Target can only support one kind of HW watchpoint at a time."));
6286 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
6287 watchpoint could not be set. */
6288 if (!mem_cnt
|| target_resources_ok
<= 0)
6289 bp_type
= bp_watchpoint
;
6291 frame
= block_innermost_frame (exp_valid_block
);
6293 /* If the expression is "local", then set up a "watchpoint scope"
6294 breakpoint at the point where we've left the scope of the watchpoint
6295 expression. Create the scope breakpoint before the watchpoint, so
6296 that we will encounter it first in bpstat_stop_status. */
6297 if (innermost_block
&& frame
)
6299 if (frame_id_p (frame_unwind_caller_id (frame
)))
6302 = create_internal_breakpoint (frame_unwind_caller_pc (frame
),
6303 bp_watchpoint_scope
);
6305 scope_breakpoint
->enable_state
= bp_enabled
;
6307 /* Automatically delete the breakpoint when it hits. */
6308 scope_breakpoint
->disposition
= disp_del
;
6310 /* Only break in the proper frame (help with recursion). */
6311 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
6313 /* Set the address at which we will stop. */
6314 scope_breakpoint
->loc
->requested_address
6315 = frame_unwind_caller_pc (frame
);
6316 scope_breakpoint
->loc
->address
6317 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
6318 scope_breakpoint
->type
);
6322 /* Now set up the breakpoint. */
6323 b
= set_raw_breakpoint (sal
, bp_type
);
6324 set_breakpoint_count (breakpoint_count
+ 1);
6325 b
->number
= breakpoint_count
;
6327 b
->disposition
= disp_donttouch
;
6329 b
->exp_valid_block
= exp_valid_block
;
6330 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
6333 b
->loc
->cond
= cond
;
6335 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
6340 b
->watchpoint_frame
= get_frame_id (frame
);
6342 b
->watchpoint_frame
= null_frame_id
;
6344 if (scope_breakpoint
!= NULL
)
6346 /* The scope breakpoint is related to the watchpoint. We will
6347 need to act on them together. */
6348 b
->related_breakpoint
= scope_breakpoint
;
6349 scope_breakpoint
->related_breakpoint
= b
;
6352 value_free_to_mark (mark
);
6354 update_global_location_list (1);
6357 /* Return count of locations need to be watched and can be handled
6358 in hardware. If the watchpoint can not be handled
6359 in hardware return zero. */
6362 can_use_hardware_watchpoint (struct value
*v
)
6364 int found_memory_cnt
= 0;
6365 struct value
*head
= v
;
6367 /* Did the user specifically forbid us to use hardware watchpoints? */
6368 if (!can_use_hw_watchpoints
)
6371 /* Make sure that the value of the expression depends only upon
6372 memory contents, and values computed from them within GDB. If we
6373 find any register references or function calls, we can't use a
6374 hardware watchpoint.
6376 The idea here is that evaluating an expression generates a series
6377 of values, one holding the value of every subexpression. (The
6378 expression a*b+c has five subexpressions: a, b, a*b, c, and
6379 a*b+c.) GDB's values hold almost enough information to establish
6380 the criteria given above --- they identify memory lvalues,
6381 register lvalues, computed values, etcetera. So we can evaluate
6382 the expression, and then scan the chain of values that leaves
6383 behind to decide whether we can detect any possible change to the
6384 expression's final value using only hardware watchpoints.
6386 However, I don't think that the values returned by inferior
6387 function calls are special in any way. So this function may not
6388 notice that an expression involving an inferior function call
6389 can't be watched with hardware watchpoints. FIXME. */
6390 for (; v
; v
= value_next (v
))
6392 if (VALUE_LVAL (v
) == lval_memory
)
6395 /* A lazy memory lvalue is one that GDB never needed to fetch;
6396 we either just used its address (e.g., `a' in `a.b') or
6397 we never needed it at all (e.g., `a' in `a,b'). */
6401 /* Ahh, memory we actually used! Check if we can cover
6402 it with hardware watchpoints. */
6403 struct type
*vtype
= check_typedef (value_type (v
));
6405 /* We only watch structs and arrays if user asked for it
6406 explicitly, never if they just happen to appear in a
6407 middle of some value chain. */
6409 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6410 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6412 CORE_ADDR vaddr
= value_address (v
);
6413 int len
= TYPE_LENGTH (value_type (v
));
6415 if (!target_region_ok_for_hw_watchpoint (vaddr
, len
))
6422 else if (VALUE_LVAL (v
) != not_lval
6423 && deprecated_value_modifiable (v
) == 0)
6424 return 0; /* ??? What does this represent? */
6425 else if (VALUE_LVAL (v
) == lval_register
)
6426 return 0; /* cannot watch a register with a HW watchpoint */
6429 /* The expression itself looks suitable for using a hardware
6430 watchpoint, but give the target machine a chance to reject it. */
6431 return found_memory_cnt
;
6435 watch_command_wrapper (char *arg
, int from_tty
)
6437 watch_command (arg
, from_tty
);
6441 watch_command (char *arg
, int from_tty
)
6443 watch_command_1 (arg
, hw_write
, from_tty
);
6447 rwatch_command_wrapper (char *arg
, int from_tty
)
6449 rwatch_command (arg
, from_tty
);
6453 rwatch_command (char *arg
, int from_tty
)
6455 watch_command_1 (arg
, hw_read
, from_tty
);
6459 awatch_command_wrapper (char *arg
, int from_tty
)
6461 awatch_command (arg
, from_tty
);
6465 awatch_command (char *arg
, int from_tty
)
6467 watch_command_1 (arg
, hw_access
, from_tty
);
6471 /* Helper routines for the until_command routine in infcmd.c. Here
6472 because it uses the mechanisms of breakpoints. */
6474 struct until_break_command_continuation_args
6476 struct breakpoint
*breakpoint
;
6477 struct breakpoint
*breakpoint2
;
6480 /* This function is called by fetch_inferior_event via the
6481 cmd_continuation pointer, to complete the until command. It takes
6482 care of cleaning up the temporary breakpoints set up by the until
6485 until_break_command_continuation (void *arg
)
6487 struct until_break_command_continuation_args
*a
= arg
;
6489 delete_breakpoint (a
->breakpoint
);
6491 delete_breakpoint (a
->breakpoint2
);
6495 until_break_command (char *arg
, int from_tty
, int anywhere
)
6497 struct symtabs_and_lines sals
;
6498 struct symtab_and_line sal
;
6499 struct frame_info
*frame
= get_selected_frame (NULL
);
6500 struct breakpoint
*breakpoint
;
6501 struct breakpoint
*breakpoint2
= NULL
;
6502 struct cleanup
*old_chain
;
6504 clear_proceed_status ();
6506 /* Set a breakpoint where the user wants it and at return from
6509 if (default_breakpoint_valid
)
6510 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6511 default_breakpoint_line
, (char ***) NULL
, NULL
);
6513 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6514 0, (char ***) NULL
, NULL
);
6516 if (sals
.nelts
!= 1)
6517 error (_("Couldn't get information on specified line."));
6520 xfree (sals
.sals
); /* malloc'd, so freed */
6523 error (_("Junk at end of arguments."));
6525 resolve_sal_pc (&sal
);
6528 /* If the user told us to continue until a specified location,
6529 we don't specify a frame at which we need to stop. */
6530 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6532 /* Otherwise, specify the selected frame, because we want to stop only
6533 at the very same frame. */
6534 breakpoint
= set_momentary_breakpoint (sal
, get_stack_frame_id (frame
),
6537 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6539 /* Keep within the current frame, or in frames called by the current
6542 if (frame_id_p (frame_unwind_caller_id (frame
)))
6544 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
6545 sal
.pc
= frame_unwind_caller_pc (frame
);
6546 breakpoint2
= set_momentary_breakpoint (sal
,
6547 frame_unwind_caller_id (frame
),
6549 make_cleanup_delete_breakpoint (breakpoint2
);
6552 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6554 /* If we are running asynchronously, and proceed call above has actually
6555 managed to start the target, arrange for breakpoints to be
6556 deleted when the target stops. Otherwise, we're already stopped and
6557 delete breakpoints via cleanup chain. */
6559 if (target_can_async_p () && is_running (inferior_ptid
))
6561 struct until_break_command_continuation_args
*args
;
6562 args
= xmalloc (sizeof (*args
));
6564 args
->breakpoint
= breakpoint
;
6565 args
->breakpoint2
= breakpoint2
;
6567 discard_cleanups (old_chain
);
6568 add_continuation (inferior_thread (),
6569 until_break_command_continuation
, args
,
6573 do_cleanups (old_chain
);
6577 ep_skip_leading_whitespace (char **s
)
6579 if ((s
== NULL
) || (*s
== NULL
))
6581 while (isspace (**s
))
6585 /* This function attempts to parse an optional "if <cond>" clause
6586 from the arg string. If one is not found, it returns NULL.
6588 Else, it returns a pointer to the condition string. (It does not
6589 attempt to evaluate the string against a particular block.) And,
6590 it updates arg to point to the first character following the parsed
6591 if clause in the arg string. */
6594 ep_parse_optional_if_clause (char **arg
)
6598 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6601 /* Skip the "if" keyword. */
6604 /* Skip any extra leading whitespace, and record the start of the
6605 condition string. */
6606 ep_skip_leading_whitespace (arg
);
6609 /* Assume that the condition occupies the remainder of the arg string. */
6610 (*arg
) += strlen (cond_string
);
6615 /* This function attempts to parse an optional filename from the arg
6616 string. If one is not found, it returns NULL.
6618 Else, it returns a pointer to the parsed filename. (This function
6619 makes no attempt to verify that a file of that name exists, or is
6620 accessible.) And, it updates arg to point to the first character
6621 following the parsed filename in the arg string.
6623 Note that clients needing to preserve the returned filename for
6624 future access should copy it to their own buffers. */
6626 ep_parse_optional_filename (char **arg
)
6628 static char filename
[1024];
6633 if ((*arg_p
== '\0') || isspace (*arg_p
))
6651 /* Commands to deal with catching events, such as signals, exceptions,
6652 process start/exit, etc. */
6656 catch_fork_temporary
, catch_vfork_temporary
,
6657 catch_fork_permanent
, catch_vfork_permanent
6662 catch_fork_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6664 char *cond_string
= NULL
;
6665 catch_fork_kind fork_kind
;
6668 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
6669 tempflag
= (fork_kind
== catch_fork_temporary
6670 || fork_kind
== catch_vfork_temporary
);
6674 ep_skip_leading_whitespace (&arg
);
6676 /* The allowed syntax is:
6678 catch [v]fork if <cond>
6680 First, check if there's an if clause. */
6681 cond_string
= ep_parse_optional_if_clause (&arg
);
6683 if ((*arg
!= '\0') && !isspace (*arg
))
6684 error (_("Junk at end of arguments."));
6686 /* If this target supports it, create a fork or vfork catchpoint
6687 and enable reporting of such events. */
6690 case catch_fork_temporary
:
6691 case catch_fork_permanent
:
6692 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6693 &catch_fork_breakpoint_ops
);
6695 case catch_vfork_temporary
:
6696 case catch_vfork_permanent
:
6697 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6698 &catch_vfork_breakpoint_ops
);
6701 error (_("unsupported or unknown fork kind; cannot catch it"));
6707 catch_exec_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6710 char *cond_string
= NULL
;
6712 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6716 ep_skip_leading_whitespace (&arg
);
6718 /* The allowed syntax is:
6720 catch exec if <cond>
6722 First, check if there's an if clause. */
6723 cond_string
= ep_parse_optional_if_clause (&arg
);
6725 if ((*arg
!= '\0') && !isspace (*arg
))
6726 error (_("Junk at end of arguments."));
6728 /* If this target supports it, create an exec catchpoint
6729 and enable reporting of such events. */
6730 create_catchpoint (tempflag
, cond_string
, &catch_exec_breakpoint_ops
);
6733 static enum print_stop_action
6734 print_exception_catchpoint (struct breakpoint
*b
)
6736 int bp_temp
, bp_throw
;
6738 annotate_catchpoint (b
->number
);
6740 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6741 if (b
->loc
->address
!= b
->loc
->requested_address
)
6742 breakpoint_adjustment_warning (b
->loc
->requested_address
,
6745 bp_temp
= b
->disposition
== disp_del
;
6747 bp_temp
? "Temporary catchpoint "
6749 if (!ui_out_is_mi_like_p (uiout
))
6750 ui_out_field_int (uiout
, "bkptno", b
->number
);
6752 bp_throw
? " (exception thrown), "
6753 : " (exception caught), ");
6754 if (ui_out_is_mi_like_p (uiout
))
6756 ui_out_field_string (uiout
, "reason",
6757 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
6758 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6759 ui_out_field_int (uiout
, "bkptno", b
->number
);
6761 return PRINT_SRC_AND_LOC
;
6765 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6767 struct value_print_options opts
;
6768 get_user_print_options (&opts
);
6769 if (opts
.addressprint
)
6772 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
6773 ui_out_field_string (uiout
, "addr", "<PENDING>");
6775 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6779 *last_addr
= b
->loc
->address
;
6780 if (strstr (b
->addr_string
, "throw") != NULL
)
6781 ui_out_field_string (uiout
, "what", "exception throw");
6783 ui_out_field_string (uiout
, "what", "exception catch");
6787 print_mention_exception_catchpoint (struct breakpoint
*b
)
6792 bp_temp
= b
->disposition
== disp_del
;
6793 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6794 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
6795 : _("Catchpoint "));
6796 ui_out_field_int (uiout
, "bkptno", b
->number
);
6797 ui_out_text (uiout
, bp_throw
? _(" (throw)")
6801 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6804 NULL
, /* breakpoint_hit */
6805 print_exception_catchpoint
,
6806 print_one_exception_catchpoint
,
6807 print_mention_exception_catchpoint
6811 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6812 enum exception_event_kind ex_event
, int from_tty
)
6814 char *trigger_func_name
;
6816 if (ex_event
== EX_EVENT_CATCH
)
6817 trigger_func_name
= "__cxa_begin_catch";
6819 trigger_func_name
= "__cxa_throw";
6821 break_command_really (trigger_func_name
, cond_string
, -1,
6822 0 /* condition and thread are valid. */,
6825 AUTO_BOOLEAN_TRUE
/* pending */,
6826 &gnu_v3_exception_catchpoint_ops
, from_tty
,
6832 /* Deal with "catch catch" and "catch throw" commands */
6835 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6836 int tempflag
, int from_tty
)
6838 char *cond_string
= NULL
;
6839 struct symtab_and_line
*sal
= NULL
;
6843 ep_skip_leading_whitespace (&arg
);
6845 cond_string
= ep_parse_optional_if_clause (&arg
);
6847 if ((*arg
!= '\0') && !isspace (*arg
))
6848 error (_("Junk at end of arguments."));
6850 if (ex_event
!= EX_EVENT_THROW
6851 && ex_event
!= EX_EVENT_CATCH
)
6852 error (_("Unsupported or unknown exception event; cannot catch it"));
6854 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6857 warning (_("Unsupported with this platform/compiler combination."));
6860 /* Implementation of "catch catch" command. */
6863 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6865 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6866 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
6869 /* Implementation of "catch throw" command. */
6872 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6874 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6875 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
6878 /* Create a breakpoint struct for Ada exception catchpoints. */
6881 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6885 struct expression
*cond
,
6886 struct breakpoint_ops
*ops
,
6890 struct breakpoint
*b
;
6894 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6895 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6896 version for exception catchpoints, because two catchpoints
6897 used for different exception names will use the same address.
6898 In this case, a "breakpoint ... also set at..." warning is
6899 unproductive. Besides. the warning phrasing is also a bit
6900 inapropriate, we should use the word catchpoint, and tell
6901 the user what type of catchpoint it is. The above is good
6902 enough for now, though. */
6905 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6906 set_breakpoint_count (breakpoint_count
+ 1);
6908 b
->enable_state
= bp_enabled
;
6909 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6910 b
->number
= breakpoint_count
;
6911 b
->ignore_count
= 0;
6912 b
->loc
->cond
= cond
;
6913 b
->addr_string
= addr_string
;
6914 b
->language
= language_ada
;
6915 b
->cond_string
= cond_string
;
6916 b
->exp_string
= exp_string
;
6921 update_global_location_list (1);
6924 /* Implement the "catch exception" command. */
6927 catch_ada_exception_command (char *arg
, int from_tty
,
6928 struct cmd_list_element
*command
)
6931 struct symtab_and_line sal
;
6933 char *addr_string
= NULL
;
6934 char *exp_string
= NULL
;
6935 char *cond_string
= NULL
;
6936 struct expression
*cond
= NULL
;
6937 struct breakpoint_ops
*ops
= NULL
;
6939 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6943 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6944 &cond_string
, &cond
, &ops
);
6945 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6946 cond_string
, cond
, ops
, tempflag
,
6950 /* Implement the "catch assert" command. */
6953 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6956 struct symtab_and_line sal
;
6957 char *addr_string
= NULL
;
6958 struct breakpoint_ops
*ops
= NULL
;
6960 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6964 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6965 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6966 tempflag
, from_tty
);
6970 catch_command (char *arg
, int from_tty
)
6972 error (_("Catch requires an event name."));
6977 tcatch_command (char *arg
, int from_tty
)
6979 error (_("Catch requires an event name."));
6982 /* Delete breakpoints by address or line. */
6985 clear_command (char *arg
, int from_tty
)
6987 struct breakpoint
*b
;
6988 VEC(breakpoint_p
) *found
= 0;
6991 struct symtabs_and_lines sals
;
6992 struct symtab_and_line sal
;
6997 sals
= decode_line_spec (arg
, 1);
7002 sals
.sals
= (struct symtab_and_line
*)
7003 xmalloc (sizeof (struct symtab_and_line
));
7004 make_cleanup (xfree
, sals
.sals
);
7005 init_sal (&sal
); /* initialize to zeroes */
7006 sal
.line
= default_breakpoint_line
;
7007 sal
.symtab
= default_breakpoint_symtab
;
7008 sal
.pc
= default_breakpoint_address
;
7009 if (sal
.symtab
== 0)
7010 error (_("No source file specified."));
7018 /* We don't call resolve_sal_pc here. That's not
7019 as bad as it seems, because all existing breakpoints
7020 typically have both file/line and pc set. So, if
7021 clear is given file/line, we can match this to existing
7022 breakpoint without obtaining pc at all.
7024 We only support clearing given the address explicitly
7025 present in breakpoint table. Say, we've set breakpoint
7026 at file:line. There were several PC values for that file:line,
7027 due to optimization, all in one block.
7028 We've picked one PC value. If "clear" is issued with another
7029 PC corresponding to the same file:line, the breakpoint won't
7030 be cleared. We probably can still clear the breakpoint, but
7031 since the other PC value is never presented to user, user
7032 can only find it by guessing, and it does not seem important
7035 /* For each line spec given, delete bps which correspond
7036 to it. Do it in two passes, solely to preserve the current
7037 behavior that from_tty is forced true if we delete more than
7041 for (i
= 0; i
< sals
.nelts
; i
++)
7043 /* If exact pc given, clear bpts at that pc.
7044 If line given (pc == 0), clear all bpts on specified line.
7045 If defaulting, clear all bpts on default line
7048 defaulting sal.pc != 0 tests to do
7053 1 0 <can't happen> */
7057 /* Find all matching breakpoints and add them to
7062 /* Are we going to delete b? */
7063 if (b
->type
!= bp_none
7064 && b
->type
!= bp_watchpoint
7065 && b
->type
!= bp_hardware_watchpoint
7066 && b
->type
!= bp_read_watchpoint
7067 && b
->type
!= bp_access_watchpoint
)
7069 struct bp_location
*loc
= b
->loc
;
7070 for (; loc
; loc
= loc
->next
)
7072 int pc_match
= sal
.pc
7073 && (loc
->address
== sal
.pc
)
7074 && (!section_is_overlay (loc
->section
)
7075 || loc
->section
== sal
.section
);
7076 int line_match
= ((default_match
|| (0 == sal
.pc
))
7077 && b
->source_file
!= NULL
7078 && sal
.symtab
!= NULL
7079 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
7080 && b
->line_number
== sal
.line
);
7081 if (pc_match
|| line_match
)
7090 VEC_safe_push(breakpoint_p
, found
, b
);
7093 /* Now go thru the 'found' chain and delete them. */
7094 if (VEC_empty(breakpoint_p
, found
))
7097 error (_("No breakpoint at %s."), arg
);
7099 error (_("No breakpoint at this line."));
7102 if (VEC_length(breakpoint_p
, found
) > 1)
7103 from_tty
= 1; /* Always report if deleted more than one */
7106 if (VEC_length(breakpoint_p
, found
) == 1)
7107 printf_unfiltered (_("Deleted breakpoint "));
7109 printf_unfiltered (_("Deleted breakpoints "));
7111 breakpoints_changed ();
7113 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
7116 printf_unfiltered ("%d ", b
->number
);
7117 delete_breakpoint (b
);
7120 putchar_unfiltered ('\n');
7123 /* Delete breakpoint in BS if they are `delete' breakpoints and
7124 all breakpoints that are marked for deletion, whether hit or not.
7125 This is called after any breakpoint is hit, or after errors. */
7128 breakpoint_auto_delete (bpstat bs
)
7130 struct breakpoint
*b
, *temp
;
7132 for (; bs
; bs
= bs
->next
)
7133 if (bs
->breakpoint_at
7134 && bs
->breakpoint_at
->owner
7135 && bs
->breakpoint_at
->owner
->disposition
== disp_del
7137 delete_breakpoint (bs
->breakpoint_at
->owner
);
7139 ALL_BREAKPOINTS_SAFE (b
, temp
)
7141 if (b
->disposition
== disp_del_at_next_stop
)
7142 delete_breakpoint (b
);
7146 /* A cleanup function which destroys a vector. */
7149 do_vec_free (void *p
)
7151 VEC(bp_location_p
) **vec
= p
;
7153 VEC_free (bp_location_p
, *vec
);
7156 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
7157 into the inferior, only remove already-inserted locations that no
7158 longer should be inserted. Functions that delete a breakpoint or
7159 breakpoints should pass false, so that deleting a breakpoint
7160 doesn't have the side effect of inserting the locations of other
7161 breakpoints that are marked not-inserted, but should_be_inserted
7162 returns true on them.
7164 This behaviour is useful is situations close to tear-down -- e.g.,
7165 after an exec, while the target still has execution, but breakpoint
7166 shadows of the previous executable image should *NOT* be restored
7167 to the new image; or before detaching, where the target still has
7168 execution and wants to delete breakpoints from GDB's lists, and all
7169 breakpoints had already been removed from the inferior. */
7172 update_global_location_list (int should_insert
)
7174 struct breakpoint
*b
;
7175 struct bp_location
**next
= &bp_location_chain
;
7176 struct bp_location
*loc
;
7177 struct bp_location
*loc2
;
7178 VEC(bp_location_p
) *old_locations
= NULL
;
7181 struct cleanup
*cleanups
;
7183 cleanups
= make_cleanup (do_vec_free
, &old_locations
);
7184 /* Store old locations for future reference. */
7185 for (loc
= bp_location_chain
; loc
; loc
= loc
->global_next
)
7186 VEC_safe_push (bp_location_p
, old_locations
, loc
);
7188 bp_location_chain
= NULL
;
7191 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
7194 next
= &(loc
->global_next
);
7199 /* Identify bp_location instances that are no longer present in the new
7200 list, and therefore should be freed. Note that it's not necessary that
7201 those locations should be removed from inferior -- if there's another
7202 location at the same address (previously marked as duplicate),
7203 we don't need to remove/insert the location. */
7204 for (ix
= 0; VEC_iterate(bp_location_p
, old_locations
, ix
, loc
); ++ix
)
7206 /* Tells if 'loc' is found amoung the new locations. If not, we
7208 int found_object
= 0;
7209 /* Tells if the location should remain inserted in the target. */
7210 int keep_in_target
= 0;
7212 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7219 /* If this location is no longer present, and inserted, look if there's
7220 maybe a new location at the same address. If so, mark that one
7221 inserted, and don't remove this one. This is needed so that we
7222 don't have a time window where a breakpoint at certain location is not
7227 /* If the location is inserted now, we might have to remove it. */
7229 if (found_object
&& should_be_inserted (loc
))
7231 /* The location is still present in the location list, and still
7232 should be inserted. Don't do anything. */
7237 /* The location is either no longer present, or got disabled.
7238 See if there's another location at the same address, in which
7239 case we don't need to remove this one from the target. */
7240 if (breakpoint_address_is_meaningful (loc
->owner
))
7241 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7243 /* For the sake of should_insert_location. The
7244 call to check_duplicates will fix up this later. */
7245 loc2
->duplicate
= 0;
7246 if (should_be_inserted (loc2
)
7247 && loc2
!= loc
&& loc2
->address
== loc
->address
)
7250 loc2
->target_info
= loc
->target_info
;
7257 if (!keep_in_target
)
7259 if (remove_breakpoint (loc
, mark_uninserted
))
7261 /* This is just about all we can do. We could keep this
7262 location on the global list, and try to remove it next
7263 time, but there's no particular reason why we will
7266 Note that at this point, loc->owner is still valid,
7267 as delete_breakpoint frees the breakpoint only
7268 after calling us. */
7269 printf_filtered (_("warning: Error removing breakpoint %d\n"),
7270 loc
->owner
->number
);
7278 if (removed
&& non_stop
)
7280 /* This location was removed from the targets. In non-stop mode,
7281 a race condition is possible where we've removed a breakpoint,
7282 but stop events for that breakpoint are already queued and will
7283 arrive later. To suppress spurious SIGTRAPs reported to user,
7284 we keep this breakpoint location for a bit, and will retire it
7285 after we see 3 * thread_count events.
7286 The theory here is that reporting of events should,
7287 "on the average", be fair, so after that many event we'll see
7288 events from all threads that have anything of interest, and no
7289 longer need to keep this breakpoint. This is just a
7290 heuristic, but if it's wrong, we'll report unexpected SIGTRAP,
7291 which is usability issue, but not a correctness problem. */
7292 loc
->events_till_retirement
= 3 * (thread_count () + 1);
7295 VEC_safe_push (bp_location_p
, moribund_locations
, loc
);
7298 free_bp_location (loc
);
7304 check_duplicates (b
);
7307 if (breakpoints_always_inserted_mode () && should_insert
7308 && (have_live_inferiors ()
7309 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
7310 insert_breakpoint_locations ();
7312 do_cleanups (cleanups
);
7316 breakpoint_retire_moribund (void)
7318 struct bp_location
*loc
;
7321 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
7322 if (--(loc
->events_till_retirement
) == 0)
7324 free_bp_location (loc
);
7325 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
7331 update_global_location_list_nothrow (int inserting
)
7333 struct gdb_exception e
;
7334 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7335 update_global_location_list (inserting
);
7338 /* Clear BPT from a BPS. */
7340 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
7343 for (bs
= bps
; bs
; bs
= bs
->next
)
7344 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7346 bs
->breakpoint_at
= NULL
;
7348 /* bs->commands will be freed later. */
7352 /* Callback for iterate_over_threads. */
7354 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
7356 struct breakpoint
*bpt
= data
;
7357 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
7361 /* Delete a breakpoint and clean up all traces of it in the data
7365 delete_breakpoint (struct breakpoint
*bpt
)
7367 struct breakpoint
*b
;
7368 struct bp_location
*loc
, *next
;
7370 gdb_assert (bpt
!= NULL
);
7372 /* Has this bp already been deleted? This can happen because multiple
7373 lists can hold pointers to bp's. bpstat lists are especial culprits.
7375 One example of this happening is a watchpoint's scope bp. When the
7376 scope bp triggers, we notice that the watchpoint is out of scope, and
7377 delete it. We also delete its scope bp. But the scope bp is marked
7378 "auto-deleting", and is already on a bpstat. That bpstat is then
7379 checked for auto-deleting bp's, which are deleted.
7381 A real solution to this problem might involve reference counts in bp's,
7382 and/or giving them pointers back to their referencing bpstat's, and
7383 teaching delete_breakpoint to only free a bp's storage when no more
7384 references were extent. A cheaper bandaid was chosen. */
7385 if (bpt
->type
== bp_none
)
7388 observer_notify_breakpoint_deleted (bpt
->number
);
7390 if (breakpoint_chain
== bpt
)
7391 breakpoint_chain
= bpt
->next
;
7396 b
->next
= bpt
->next
;
7400 free_command_lines (&bpt
->commands
);
7401 if (bpt
->cond_string
!= NULL
)
7402 xfree (bpt
->cond_string
);
7403 if (bpt
->addr_string
!= NULL
)
7404 xfree (bpt
->addr_string
);
7405 if (bpt
->exp
!= NULL
)
7407 if (bpt
->exp_string
!= NULL
)
7408 xfree (bpt
->exp_string
);
7409 if (bpt
->val
!= NULL
)
7410 value_free (bpt
->val
);
7411 if (bpt
->source_file
!= NULL
)
7412 xfree (bpt
->source_file
);
7413 if (bpt
->exec_pathname
!= NULL
)
7414 xfree (bpt
->exec_pathname
);
7416 /* Be sure no bpstat's are pointing at it after it's been freed. */
7417 /* FIXME, how can we find all bpstat's?
7418 We just check stop_bpstat for now. Note that we cannot just
7419 remove bpstats pointing at bpt from the stop_bpstat list
7420 entirely, as breakpoint commands are associated with the bpstat;
7421 if we remove it here, then the later call to
7422 bpstat_do_actions (&stop_bpstat);
7423 in event-top.c won't do anything, and temporary breakpoints
7424 with commands won't work. */
7426 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
7428 /* Now that breakpoint is removed from breakpoint
7429 list, update the global location list. This
7430 will remove locations that used to belong to
7431 this breakpoint. Do this before freeing
7432 the breakpoint itself, since remove_breakpoint
7433 looks at location's owner. It might be better
7434 design to have location completely self-contained,
7435 but it's not the case now. */
7436 update_global_location_list (0);
7439 /* On the chance that someone will soon try again to delete this same
7440 bp, we mark it as deleted before freeing its storage. */
7441 bpt
->type
= bp_none
;
7447 do_delete_breakpoint_cleanup (void *b
)
7449 delete_breakpoint (b
);
7453 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7455 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7459 delete_command (char *arg
, int from_tty
)
7461 struct breakpoint
*b
, *temp
;
7467 int breaks_to_delete
= 0;
7469 /* Delete all breakpoints if no argument.
7470 Do not delete internal or call-dummy breakpoints, these
7471 have to be deleted with an explicit breakpoint number argument. */
7474 if (b
->type
!= bp_call_dummy
7475 && b
->type
!= bp_shlib_event
7476 && b
->type
!= bp_thread_event
7477 && b
->type
!= bp_overlay_event
7478 && b
->type
!= bp_longjmp_master
7481 breaks_to_delete
= 1;
7486 /* Ask user only if there are some breakpoints to delete. */
7488 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7490 ALL_BREAKPOINTS_SAFE (b
, temp
)
7492 if (b
->type
!= bp_call_dummy
7493 && b
->type
!= bp_shlib_event
7494 && b
->type
!= bp_thread_event
7495 && b
->type
!= bp_overlay_event
7496 && b
->type
!= bp_longjmp_master
7498 delete_breakpoint (b
);
7503 map_breakpoint_numbers (arg
, delete_breakpoint
);
7507 all_locations_are_pending (struct bp_location
*loc
)
7509 for (; loc
; loc
= loc
->next
)
7510 if (!loc
->shlib_disabled
)
7515 /* Subroutine of update_breakpoint_locations to simplify it.
7516 Return non-zero if multiple fns in list LOC have the same name.
7517 Null names are ignored. */
7520 ambiguous_names_p (struct bp_location
*loc
)
7522 struct bp_location
*l
;
7523 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7524 (int (*) (const void *, const void *)) streq
,
7525 NULL
, xcalloc
, xfree
);
7527 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7530 const char *name
= l
->function_name
;
7532 /* Allow for some names to be NULL, ignore them. */
7536 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7538 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7553 update_breakpoint_locations (struct breakpoint
*b
,
7554 struct symtabs_and_lines sals
)
7558 struct bp_location
*existing_locations
= b
->loc
;
7560 /* If there's no new locations, and all existing locations
7561 are pending, don't do anything. This optimizes
7562 the common case where all locations are in the same
7563 shared library, that was unloaded. We'd like to
7564 retain the location, so that when the library
7565 is loaded again, we don't loose the enabled/disabled
7566 status of the individual locations. */
7567 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7572 for (i
= 0; i
< sals
.nelts
; ++i
)
7574 struct bp_location
*new_loc
=
7575 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
7577 /* Reparse conditions, they might contain references to the
7579 if (b
->cond_string
!= NULL
)
7581 struct gdb_exception e
;
7584 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7586 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7591 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7592 b
->number
, e
.message
);
7593 new_loc
->enabled
= 0;
7597 if (b
->source_file
!= NULL
)
7598 xfree (b
->source_file
);
7599 if (sals
.sals
[i
].symtab
== NULL
)
7600 b
->source_file
= NULL
;
7602 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
7604 if (b
->line_number
== 0)
7605 b
->line_number
= sals
.sals
[i
].line
;
7608 /* Update locations of permanent breakpoints. */
7609 if (b
->enable_state
== bp_permanent
)
7610 make_breakpoint_permanent (b
);
7612 /* If possible, carry over 'disable' status from existing breakpoints. */
7614 struct bp_location
*e
= existing_locations
;
7615 /* If there are multiple breakpoints with the same function name,
7616 e.g. for inline functions, comparing function names won't work.
7617 Instead compare pc addresses; this is just a heuristic as things
7618 may have moved, but in practice it gives the correct answer
7619 often enough until a better solution is found. */
7620 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7622 for (; e
; e
= e
->next
)
7624 if (!e
->enabled
&& e
->function_name
)
7626 struct bp_location
*l
= b
->loc
;
7627 if (have_ambiguous_names
)
7629 for (; l
; l
= l
->next
)
7630 if (e
->address
== l
->address
)
7638 for (; l
; l
= l
->next
)
7639 if (l
->function_name
7640 && strcmp (e
->function_name
, l
->function_name
) == 0)
7650 update_global_location_list (1);
7654 /* Reset a breakpoint given it's struct breakpoint * BINT.
7655 The value we return ends up being the return value from catch_errors.
7656 Unused in this case. */
7659 breakpoint_re_set_one (void *bint
)
7661 /* get past catch_errs */
7662 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7666 int *not_found_ptr
= ¬_found
;
7667 struct symtabs_and_lines sals
= {};
7668 struct symtabs_and_lines expanded
;
7670 enum enable_state save_enable
;
7671 struct gdb_exception e
;
7672 struct cleanup
*cleanups
;
7677 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7681 case bp_hardware_breakpoint
:
7683 if (b
->addr_string
== NULL
)
7685 /* Anything without a string can't be re-set. */
7686 delete_breakpoint (b
);
7690 set_language (b
->language
);
7691 input_radix
= b
->input_radix
;
7693 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7695 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7700 int not_found_and_ok
= 0;
7701 /* For pending breakpoints, it's expected that parsing
7702 will fail until the right shared library is loaded.
7703 User has already told to create pending breakpoints and
7704 don't need extra messages. If breakpoint is in bp_shlib_disabled
7705 state, then user already saw the message about that breakpoint
7706 being disabled, and don't want to see more errors. */
7708 && (b
->condition_not_parsed
7709 || (b
->loc
&& b
->loc
->shlib_disabled
)
7710 || b
->enable_state
== bp_disabled
))
7711 not_found_and_ok
= 1;
7713 if (!not_found_and_ok
)
7715 /* We surely don't want to warn about the same breakpoint
7716 10 times. One solution, implemented here, is disable
7717 the breakpoint on error. Another solution would be to
7718 have separate 'warning emitted' flag. Since this
7719 happens only when a binary has changed, I don't know
7720 which approach is better. */
7721 b
->enable_state
= bp_disabled
;
7722 throw_exception (e
);
7729 gdb_assert (sals
.nelts
== 1);
7730 resolve_sal_pc (&sals
.sals
[0]);
7731 if (b
->condition_not_parsed
&& s
&& s
[0])
7733 char *cond_string
= 0;
7737 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7738 &cond_string
, &thread
, &task
);
7740 b
->cond_string
= cond_string
;
7743 b
->condition_not_parsed
= 0;
7745 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7746 cleanups
= make_cleanup (xfree
, sals
.sals
);
7747 update_breakpoint_locations (b
, expanded
);
7748 do_cleanups (cleanups
);
7752 case bp_hardware_watchpoint
:
7753 case bp_read_watchpoint
:
7754 case bp_access_watchpoint
:
7755 /* Watchpoint can be either on expression using entirely global variables,
7756 or it can be on local variables.
7758 Watchpoints of the first kind are never auto-deleted, and even persist
7759 across program restarts. Since they can use variables from shared
7760 libraries, we need to reparse expression as libraries are loaded
7763 Watchpoints on local variables can also change meaning as result
7764 of solib event. For example, if a watchpoint uses both a local and
7765 a global variables in expression, it's a local watchpoint, but
7766 unloading of a shared library will make the expression invalid.
7767 This is not a very common use case, but we still re-evaluate
7768 expression, to avoid surprises to the user.
7770 Note that for local watchpoints, we re-evaluate it only if
7771 watchpoints frame id is still valid. If it's not, it means
7772 the watchpoint is out of scope and will be deleted soon. In fact,
7773 I'm not sure we'll ever be called in this case.
7775 If a local watchpoint's frame id is still valid, then
7776 b->exp_valid_block is likewise valid, and we can safely use it.
7778 Don't do anything about disabled watchpoints, since they will
7779 be reevaluated again when enabled. */
7780 update_watchpoint (b
, 1 /* reparse */);
7782 /* We needn't really do anything to reset these, since the mask
7783 that requests them is unaffected by e.g., new libraries being
7789 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7791 /* Delete overlay event and longjmp master breakpoints; they will be
7792 reset later by breakpoint_re_set. */
7793 case bp_overlay_event
:
7794 case bp_longjmp_master
:
7795 delete_breakpoint (b
);
7798 /* This breakpoint is special, it's set up when the inferior
7799 starts and we really don't want to touch it. */
7800 case bp_shlib_event
:
7802 /* Like bp_shlib_event, this breakpoint type is special.
7803 Once it is set up, we do not want to touch it. */
7804 case bp_thread_event
:
7806 /* Keep temporary breakpoints, which can be encountered when we step
7807 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7808 Otherwise these should have been blown away via the cleanup chain
7809 or by breakpoint_init_inferior when we rerun the executable. */
7812 case bp_watchpoint_scope
:
7814 case bp_step_resume
:
7816 case bp_longjmp_resume
:
7823 /* Re-set all breakpoints after symbols have been re-loaded. */
7825 breakpoint_re_set (void)
7827 struct breakpoint
*b
, *temp
;
7828 enum language save_language
;
7829 int save_input_radix
;
7831 save_language
= current_language
->la_language
;
7832 save_input_radix
= input_radix
;
7833 ALL_BREAKPOINTS_SAFE (b
, temp
)
7835 /* Format possible error msg */
7836 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7838 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7839 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7840 do_cleanups (cleanups
);
7842 set_language (save_language
);
7843 input_radix
= save_input_radix
;
7845 create_overlay_event_breakpoint ("_ovly_debug_event");
7846 create_longjmp_master_breakpoint ("longjmp");
7847 create_longjmp_master_breakpoint ("_longjmp");
7848 create_longjmp_master_breakpoint ("siglongjmp");
7849 create_longjmp_master_breakpoint ("_siglongjmp");
7852 /* Reset the thread number of this breakpoint:
7854 - If the breakpoint is for all threads, leave it as-is.
7855 - Else, reset it to the current thread for inferior_ptid. */
7857 breakpoint_re_set_thread (struct breakpoint
*b
)
7859 if (b
->thread
!= -1)
7861 if (in_thread_list (inferior_ptid
))
7862 b
->thread
= pid_to_thread_id (inferior_ptid
);
7866 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7867 If from_tty is nonzero, it prints a message to that effect,
7868 which ends with a period (no newline). */
7871 set_ignore_count (int bptnum
, int count
, int from_tty
)
7873 struct breakpoint
*b
;
7879 if (b
->number
== bptnum
)
7881 b
->ignore_count
= count
;
7885 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7887 else if (count
== 1)
7888 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7891 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7894 breakpoints_changed ();
7895 observer_notify_breakpoint_modified (b
->number
);
7899 error (_("No breakpoint number %d."), bptnum
);
7903 make_breakpoint_silent (struct breakpoint
*b
)
7905 /* Silence the breakpoint. */
7909 /* Command to set ignore-count of breakpoint N to COUNT. */
7912 ignore_command (char *args
, int from_tty
)
7918 error_no_arg (_("a breakpoint number"));
7920 num
= get_number (&p
);
7922 error (_("bad breakpoint number: '%s'"), args
);
7924 error (_("Second argument (specified ignore-count) is missing."));
7926 set_ignore_count (num
,
7927 longest_to_int (value_as_long (parse_and_eval (p
))),
7930 printf_filtered ("\n");
7933 /* Call FUNCTION on each of the breakpoints
7934 whose numbers are given in ARGS. */
7937 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7942 struct breakpoint
*b
, *tmp
;
7946 error_no_arg (_("one or more breakpoint numbers"));
7953 num
= get_number_or_range (&p1
);
7956 warning (_("bad breakpoint number at or near '%s'"), p
);
7960 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7961 if (b
->number
== num
)
7963 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7966 if (related_breakpoint
)
7967 function (related_breakpoint
);
7971 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7977 static struct bp_location
*
7978 find_location_by_number (char *number
)
7980 char *dot
= strchr (number
, '.');
7984 struct breakpoint
*b
;
7985 struct bp_location
*loc
;
7990 bp_num
= get_number_or_range (&p1
);
7992 error (_("Bad breakpoint number '%s'"), number
);
7995 if (b
->number
== bp_num
)
8000 if (!b
|| b
->number
!= bp_num
)
8001 error (_("Bad breakpoint number '%s'"), number
);
8004 loc_num
= get_number_or_range (&p1
);
8006 error (_("Bad breakpoint location number '%s'"), number
);
8010 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
8013 error (_("Bad breakpoint location number '%s'"), dot
+1);
8019 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
8020 If from_tty is nonzero, it prints a message to that effect,
8021 which ends with a period (no newline). */
8024 disable_breakpoint (struct breakpoint
*bpt
)
8026 /* Never disable a watchpoint scope breakpoint; we want to
8027 hit them when we leave scope so we can delete both the
8028 watchpoint and its scope breakpoint at that time. */
8029 if (bpt
->type
== bp_watchpoint_scope
)
8032 /* You can't disable permanent breakpoints. */
8033 if (bpt
->enable_state
== bp_permanent
)
8036 bpt
->enable_state
= bp_disabled
;
8038 update_global_location_list (0);
8040 observer_notify_breakpoint_modified (bpt
->number
);
8044 disable_command (char *args
, int from_tty
)
8046 struct breakpoint
*bpt
;
8048 ALL_BREAKPOINTS (bpt
)
8052 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
8058 case bp_hardware_breakpoint
:
8060 case bp_hardware_watchpoint
:
8061 case bp_read_watchpoint
:
8062 case bp_access_watchpoint
:
8063 disable_breakpoint (bpt
);
8067 else if (strchr (args
, '.'))
8069 struct bp_location
*loc
= find_location_by_number (args
);
8072 update_global_location_list (0);
8075 map_breakpoint_numbers (args
, disable_breakpoint
);
8079 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
8081 int target_resources_ok
, other_type_used
;
8084 if (bpt
->type
== bp_hardware_breakpoint
)
8087 i
= hw_breakpoint_used_count ();
8088 target_resources_ok
=
8089 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8091 if (target_resources_ok
== 0)
8092 error (_("No hardware breakpoint support in the target."));
8093 else if (target_resources_ok
< 0)
8094 error (_("Hardware breakpoints used exceeds limit."));
8097 if (bpt
->type
== bp_watchpoint
8098 || bpt
->type
== bp_hardware_watchpoint
8099 || bpt
->type
== bp_read_watchpoint
8100 || bpt
->type
== bp_access_watchpoint
)
8102 struct gdb_exception e
;
8104 TRY_CATCH (e
, RETURN_MASK_ALL
)
8106 update_watchpoint (bpt
, 1 /* reparse */);
8110 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
8116 if (bpt
->enable_state
!= bp_permanent
)
8117 bpt
->enable_state
= bp_enabled
;
8118 bpt
->disposition
= disposition
;
8119 update_global_location_list (1);
8120 breakpoints_changed ();
8122 observer_notify_breakpoint_modified (bpt
->number
);
8127 enable_breakpoint (struct breakpoint
*bpt
)
8129 do_enable_breakpoint (bpt
, bpt
->disposition
);
8132 /* The enable command enables the specified breakpoints (or all defined
8133 breakpoints) so they once again become (or continue to be) effective
8134 in stopping the inferior. */
8137 enable_command (char *args
, int from_tty
)
8139 struct breakpoint
*bpt
;
8141 ALL_BREAKPOINTS (bpt
)
8145 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
8151 case bp_hardware_breakpoint
:
8153 case bp_hardware_watchpoint
:
8154 case bp_read_watchpoint
:
8155 case bp_access_watchpoint
:
8156 enable_breakpoint (bpt
);
8160 else if (strchr (args
, '.'))
8162 struct bp_location
*loc
= find_location_by_number (args
);
8165 update_global_location_list (1);
8168 map_breakpoint_numbers (args
, enable_breakpoint
);
8172 enable_once_breakpoint (struct breakpoint
*bpt
)
8174 do_enable_breakpoint (bpt
, disp_disable
);
8178 enable_once_command (char *args
, int from_tty
)
8180 map_breakpoint_numbers (args
, enable_once_breakpoint
);
8184 enable_delete_breakpoint (struct breakpoint
*bpt
)
8186 do_enable_breakpoint (bpt
, disp_del
);
8190 enable_delete_command (char *args
, int from_tty
)
8192 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
8196 set_breakpoint_cmd (char *args
, int from_tty
)
8201 show_breakpoint_cmd (char *args
, int from_tty
)
8205 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
8207 struct symtabs_and_lines
8208 decode_line_spec_1 (char *string
, int funfirstline
)
8210 struct symtabs_and_lines sals
;
8212 error (_("Empty line specification."));
8213 if (default_breakpoint_valid
)
8214 sals
= decode_line_1 (&string
, funfirstline
,
8215 default_breakpoint_symtab
,
8216 default_breakpoint_line
,
8217 (char ***) NULL
, NULL
);
8219 sals
= decode_line_1 (&string
, funfirstline
,
8220 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8222 error (_("Junk at end of line specification: %s"), string
);
8226 /* Create and insert a raw software breakpoint at PC. Return an
8227 identifier, which should be used to remove the breakpoint later.
8228 In general, places which call this should be using something on the
8229 breakpoint chain instead; this function should be eliminated
8233 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8235 struct bp_target_info
*bp_tgt
;
8237 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8238 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8240 bp_tgt
->placed_address
= pc
;
8241 if (target_insert_breakpoint (bp_tgt
) != 0)
8243 /* Could not insert the breakpoint. */
8251 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8254 deprecated_remove_raw_breakpoint (void *bp
)
8256 struct bp_target_info
*bp_tgt
= bp
;
8259 ret
= target_remove_breakpoint (bp_tgt
);
8265 /* One (or perhaps two) breakpoints used for software single stepping. */
8267 static void *single_step_breakpoints
[2];
8269 /* Create and insert a breakpoint for software single step. */
8272 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8276 if (single_step_breakpoints
[0] == NULL
)
8277 bpt_p
= &single_step_breakpoints
[0];
8280 gdb_assert (single_step_breakpoints
[1] == NULL
);
8281 bpt_p
= &single_step_breakpoints
[1];
8284 /* NOTE drow/2006-04-11: A future improvement to this function would be
8285 to only create the breakpoints once, and actually put them on the
8286 breakpoint chain. That would let us use set_raw_breakpoint. We could
8287 adjust the addresses each time they were needed. Doing this requires
8288 corresponding changes elsewhere where single step breakpoints are
8289 handled, however. So, for now, we use this. */
8291 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8293 error (_("Could not insert single-step breakpoint at 0x%s"),
8294 paddr_nz (next_pc
));
8297 /* Remove and delete any breakpoints used for software single step. */
8300 remove_single_step_breakpoints (void)
8302 gdb_assert (single_step_breakpoints
[0] != NULL
);
8304 /* See insert_single_step_breakpoint for more about this deprecated
8306 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8307 single_step_breakpoints
[0] = NULL
;
8309 if (single_step_breakpoints
[1] != NULL
)
8311 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8312 single_step_breakpoints
[1] = NULL
;
8316 /* Check whether a software single-step breakpoint is inserted at PC. */
8319 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8323 for (i
= 0; i
< 2; i
++)
8325 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8326 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8333 /* Tracepoint-specific operations. */
8335 /* Set tracepoint count to NUM. */
8337 set_tracepoint_count (int num
)
8339 tracepoint_count
= num
;
8340 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
8344 trace_command (char *arg
, int from_tty
)
8346 break_command_really (arg
,
8347 NULL
, 0, 1 /* parse arg */,
8348 0 /* tempflag */, 0 /* hardwareflag */,
8350 0 /* Ignore count */,
8351 pending_break_support
,
8355 set_tracepoint_count (breakpoint_count
);
8358 /* Print information on tracepoint number TPNUM_EXP, or all if
8362 tracepoints_info (char *tpnum_exp
, int from_tty
)
8364 struct breakpoint
*b
;
8365 int tps_to_list
= 0;
8367 /* In the no-arguments case, say "No tracepoints" if none found. */
8380 ui_out_message (uiout
, 0, "No tracepoints.\n");
8385 /* Otherwise be the same as "info break". */
8386 breakpoints_info (tpnum_exp
, from_tty
);
8389 /* The 'enable trace' command enables tracepoints.
8390 Not supported by all targets. */
8392 enable_trace_command (char *args
, int from_tty
)
8394 enable_command (args
, from_tty
);
8397 /* The 'disable trace' command disables tracepoints.
8398 Not supported by all targets. */
8400 disable_trace_command (char *args
, int from_tty
)
8402 disable_command (args
, from_tty
);
8405 /* Remove a tracepoint (or all if no argument) */
8407 delete_trace_command (char *arg
, int from_tty
)
8409 struct breakpoint
*b
, *temp
;
8415 int breaks_to_delete
= 0;
8417 /* Delete all breakpoints if no argument.
8418 Do not delete internal or call-dummy breakpoints, these
8419 have to be deleted with an explicit breakpoint number argument. */
8424 breaks_to_delete
= 1;
8429 /* Ask user only if there are some breakpoints to delete. */
8431 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
8433 ALL_BREAKPOINTS_SAFE (b
, temp
)
8435 if (b
->type
== bp_tracepoint
8437 delete_breakpoint (b
);
8442 map_breakpoint_numbers (arg
, delete_breakpoint
);
8445 /* Set passcount for tracepoint.
8447 First command argument is passcount, second is tracepoint number.
8448 If tracepoint number omitted, apply to most recently defined.
8449 Also accepts special argument "all". */
8452 trace_pass_command (char *args
, int from_tty
)
8454 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
8458 if (args
== 0 || *args
== 0)
8459 error (_("passcount command requires an argument (count + optional TP num)"));
8461 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
8463 while (*args
&& isspace ((int) *args
))
8466 if (*args
&& strncasecmp (args
, "all", 3) == 0)
8468 args
+= 3; /* Skip special argument "all". */
8471 error (_("Junk at end of arguments."));
8474 t1
= get_tracepoint_by_number (&args
, 1, 1);
8480 ALL_TRACEPOINTS (t2
)
8481 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
8483 t2
->pass_count
= count
;
8484 observer_notify_tracepoint_modified (t2
->number
);
8486 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
8490 t1
= get_tracepoint_by_number (&args
, 1, 0);
8497 get_tracepoint (int num
)
8499 struct breakpoint
*t
;
8502 if (t
->number
== num
)
8508 /* Utility: parse a tracepoint number and look it up in the list.
8509 If MULTI_P is true, there might be a range of tracepoints in ARG.
8510 if OPTIONAL_P is true, then if the argument is missing, the most
8511 recent tracepoint (tracepoint_count) is returned. */
8513 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
8515 extern int tracepoint_count
;
8516 struct breakpoint
*t
;
8518 char *instring
= arg
== NULL
? NULL
: *arg
;
8520 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
8523 tpnum
= tracepoint_count
;
8525 error_no_arg (_("tracepoint number"));
8528 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
8532 if (instring
&& *instring
)
8533 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
8536 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
8541 if (t
->number
== tpnum
)
8546 /* FIXME: if we are in the middle of a range we don't want to give
8547 a message. The current interface to get_number_or_range doesn't
8548 allow us to discover this. */
8549 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
8553 /* save-tracepoints command */
8555 tracepoint_save_command (char *args
, int from_tty
)
8557 struct breakpoint
*tp
;
8559 struct action_line
*line
;
8561 char *i1
= " ", *i2
= " ";
8562 char *indent
, *actionline
, *pathname
;
8564 struct cleanup
*cleanup
;
8566 if (args
== 0 || *args
== 0)
8567 error (_("Argument required (file name in which to save tracepoints)"));
8569 /* See if we have anything to save. */
8570 ALL_TRACEPOINTS (tp
)
8577 warning (_("save-tracepoints: no tracepoints to save."));
8581 pathname
= tilde_expand (args
);
8582 cleanup
= make_cleanup (xfree
, pathname
);
8583 fp
= fopen (pathname
, "w");
8585 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
8586 args
, safe_strerror (errno
));
8587 make_cleanup_fclose (fp
);
8589 ALL_TRACEPOINTS (tp
)
8591 if (tp
->addr_string
)
8592 fprintf (fp
, "trace %s\n", tp
->addr_string
);
8595 sprintf_vma (tmp
, tp
->loc
->address
);
8596 fprintf (fp
, "trace *0x%s\n", tmp
);
8600 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
8604 fprintf (fp
, " actions\n");
8606 for (line
= tp
->actions
; line
; line
= line
->next
)
8608 struct cmd_list_element
*cmd
;
8610 QUIT
; /* allow user to bail out with ^C */
8611 actionline
= line
->action
;
8612 while (isspace ((int) *actionline
))
8615 fprintf (fp
, "%s%s\n", indent
, actionline
);
8616 if (*actionline
!= '#') /* skip for comment lines */
8618 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
8620 error (_("Bad action list item: %s"), actionline
);
8621 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
8623 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
8629 do_cleanups (cleanup
);
8631 printf_filtered (_("Tracepoints saved to file '%s'.\n"), args
);
8635 /* Create a vector of all tracepoints. */
8640 VEC(breakpoint_p
) *tp_vec
= 0;
8641 struct breakpoint
*tp
;
8643 ALL_TRACEPOINTS (tp
)
8645 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
8652 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8653 It is defined as a macro to prevent duplication.
8654 COMMAND should be a string constant containing the name of the command. */
8655 #define BREAK_ARGS_HELP(command) \
8656 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8657 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8658 If a line number is specified, break at start of code for that line.\n\
8659 If a function is specified, break at start of code for that function.\n\
8660 If an address is specified, break at that exact address.\n\
8661 With no LOCATION, uses current execution address of selected stack frame.\n\
8662 This is useful for breaking on return to a stack frame.\n\
8664 THREADNUM is the number from \"info threads\".\n\
8665 CONDITION is a boolean expression.\n\
8667 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8669 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8671 /* List of subcommands for "catch". */
8672 static struct cmd_list_element
*catch_cmdlist
;
8674 /* List of subcommands for "tcatch". */
8675 static struct cmd_list_element
*tcatch_cmdlist
;
8677 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
8678 lists, and pass some additional user data to the command function. */
8680 add_catch_command (char *name
, char *docstring
,
8681 void (*sfunc
) (char *args
, int from_tty
,
8682 struct cmd_list_element
*command
),
8683 void *user_data_catch
,
8684 void *user_data_tcatch
)
8686 struct cmd_list_element
*command
;
8688 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8690 set_cmd_sfunc (command
, sfunc
);
8691 set_cmd_context (command
, user_data_catch
);
8693 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8695 set_cmd_sfunc (command
, sfunc
);
8696 set_cmd_context (command
, user_data_tcatch
);
8700 _initialize_breakpoint (void)
8702 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8703 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8704 struct cmd_list_element
*c
;
8706 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8708 breakpoint_chain
= 0;
8709 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8710 before a breakpoint is set. */
8711 breakpoint_count
= 0;
8713 tracepoint_count
= 0;
8715 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8716 Set ignore-count of breakpoint number N to COUNT.\n\
8717 Usage is `ignore N COUNT'."));
8719 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8721 add_com ("commands", class_breakpoint
, commands_command
, _("\
8722 Set commands to be executed when a breakpoint is hit.\n\
8723 Give breakpoint number as argument after \"commands\".\n\
8724 With no argument, the targeted breakpoint is the last one set.\n\
8725 The commands themselves follow starting on the next line.\n\
8726 Type a line containing \"end\" to indicate the end of them.\n\
8727 Give \"silent\" as the first line to make the breakpoint silent;\n\
8728 then no output is printed when it is hit, except what the commands print."));
8730 add_com ("condition", class_breakpoint
, condition_command
, _("\
8731 Specify breakpoint number N to break only if COND is true.\n\
8732 Usage is `condition N COND', where N is an integer and COND is an\n\
8733 expression to be evaluated whenever breakpoint N is reached."));
8735 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8736 Set a temporary breakpoint.\n\
8737 Like \"break\" except the breakpoint is only temporary,\n\
8738 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8739 by using \"enable delete\" on the breakpoint number.\n\
8741 BREAK_ARGS_HELP ("tbreak")));
8742 set_cmd_completer (c
, location_completer
);
8744 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8745 Set a hardware assisted breakpoint.\n\
8746 Like \"break\" except the breakpoint requires hardware support,\n\
8747 some target hardware may not have this support.\n\
8749 BREAK_ARGS_HELP ("hbreak")));
8750 set_cmd_completer (c
, location_completer
);
8752 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8753 Set a temporary hardware assisted breakpoint.\n\
8754 Like \"hbreak\" except the breakpoint is only temporary,\n\
8755 so it will be deleted when hit.\n\
8757 BREAK_ARGS_HELP ("thbreak")));
8758 set_cmd_completer (c
, location_completer
);
8760 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8761 Enable some breakpoints.\n\
8762 Give breakpoint numbers (separated by spaces) as arguments.\n\
8763 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8764 This is used to cancel the effect of the \"disable\" command.\n\
8765 With a subcommand you can enable temporarily."),
8766 &enablelist
, "enable ", 1, &cmdlist
);
8768 add_com ("ab", class_breakpoint
, enable_command
, _("\
8769 Enable some breakpoints.\n\
8770 Give breakpoint numbers (separated by spaces) as arguments.\n\
8771 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8772 This is used to cancel the effect of the \"disable\" command.\n\
8773 With a subcommand you can enable temporarily."));
8775 add_com_alias ("en", "enable", class_breakpoint
, 1);
8777 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8778 Enable some breakpoints.\n\
8779 Give breakpoint numbers (separated by spaces) as arguments.\n\
8780 This is used to cancel the effect of the \"disable\" command.\n\
8781 May be abbreviated to simply \"enable\".\n"),
8782 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8784 add_cmd ("once", no_class
, enable_once_command
, _("\
8785 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8786 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8789 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8790 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8791 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8794 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8795 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8796 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8799 add_cmd ("once", no_class
, enable_once_command
, _("\
8800 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8801 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8804 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8805 Disable some breakpoints.\n\
8806 Arguments are breakpoint numbers with spaces in between.\n\
8807 To disable all breakpoints, give no argument.\n\
8808 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8809 &disablelist
, "disable ", 1, &cmdlist
);
8810 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8811 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8813 add_com ("sb", class_breakpoint
, disable_command
, _("\
8814 Disable some breakpoints.\n\
8815 Arguments are breakpoint numbers with spaces in between.\n\
8816 To disable all breakpoints, give no argument.\n\
8817 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8819 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8820 Disable some breakpoints.\n\
8821 Arguments are breakpoint numbers with spaces in between.\n\
8822 To disable all breakpoints, give no argument.\n\
8823 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8824 This command may be abbreviated \"disable\"."),
8827 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8828 Delete some breakpoints or auto-display expressions.\n\
8829 Arguments are breakpoint numbers with spaces in between.\n\
8830 To delete all breakpoints, give no argument.\n\
8832 Also a prefix command for deletion of other GDB objects.\n\
8833 The \"unset\" command is also an alias for \"delete\"."),
8834 &deletelist
, "delete ", 1, &cmdlist
);
8835 add_com_alias ("d", "delete", class_breakpoint
, 1);
8836 add_com_alias ("del", "delete", class_breakpoint
, 1);
8838 add_com ("db", class_breakpoint
, delete_command
, _("\
8839 Delete some breakpoints.\n\
8840 Arguments are breakpoint numbers with spaces in between.\n\
8841 To delete all breakpoints, give no argument.\n"));
8843 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8844 Delete some breakpoints or auto-display expressions.\n\
8845 Arguments are breakpoint numbers with spaces in between.\n\
8846 To delete all breakpoints, give no argument.\n\
8847 This command may be abbreviated \"delete\"."),
8850 add_com ("clear", class_breakpoint
, clear_command
, _("\
8851 Clear breakpoint at specified line or function.\n\
8852 Argument may be line number, function name, or \"*\" and an address.\n\
8853 If line number is specified, all breakpoints in that line are cleared.\n\
8854 If function is specified, breakpoints at beginning of function are cleared.\n\
8855 If an address is specified, breakpoints at that address are cleared.\n\
8857 With no argument, clears all breakpoints in the line that the selected frame\n\
8860 See also the \"delete\" command which clears breakpoints by number."));
8862 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8863 Set breakpoint at specified line or function.\n"
8864 BREAK_ARGS_HELP ("break")));
8865 set_cmd_completer (c
, location_completer
);
8867 add_com_alias ("b", "break", class_run
, 1);
8868 add_com_alias ("br", "break", class_run
, 1);
8869 add_com_alias ("bre", "break", class_run
, 1);
8870 add_com_alias ("brea", "break", class_run
, 1);
8873 add_com_alias ("ba", "break", class_breakpoint
, 1);
8877 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8878 Break in function/address or break at a line in the current file."),
8879 &stoplist
, "stop ", 1, &cmdlist
);
8880 add_cmd ("in", class_breakpoint
, stopin_command
,
8881 _("Break in function or address."), &stoplist
);
8882 add_cmd ("at", class_breakpoint
, stopat_command
,
8883 _("Break at a line in the current file."), &stoplist
);
8884 add_com ("status", class_info
, breakpoints_info
, _("\
8885 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8886 The \"Type\" column indicates one of:\n\
8887 \tbreakpoint - normal breakpoint\n\
8888 \twatchpoint - watchpoint\n\
8889 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8890 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8891 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8892 address and file/line number respectively.\n\
8894 Convenience variable \"$_\" and default examine address for \"x\"\n\
8895 are set to the address of the last breakpoint listed unless the command\n\
8896 is prefixed with \"server \".\n\n\
8897 Convenience variable \"$bpnum\" contains the number of the last\n\
8901 add_info ("breakpoints", breakpoints_info
, _("\
8902 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8903 The \"Type\" column indicates one of:\n\
8904 \tbreakpoint - normal breakpoint\n\
8905 \twatchpoint - watchpoint\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\
8918 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8919 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8920 The \"Type\" column indicates one of:\n\
8921 \tbreakpoint - normal breakpoint\n\
8922 \twatchpoint - watchpoint\n\
8923 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8924 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8925 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8926 address and file/line number respectively.\n\
8928 Convenience variable \"$_\" and default examine address for \"x\"\n\
8929 are set to the address of the last breakpoint listed unless the command\n\
8930 is prefixed with \"server \".\n\n\
8931 Convenience variable \"$bpnum\" contains the number of the last\n\
8934 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8935 Status of all breakpoints, or breakpoint number NUMBER.\n\
8936 The \"Type\" column indicates one of:\n\
8937 \tbreakpoint - normal breakpoint\n\
8938 \twatchpoint - watchpoint\n\
8939 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8940 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8941 \tuntil - internal breakpoint used by the \"until\" command\n\
8942 \tfinish - internal breakpoint used by the \"finish\" command\n\
8943 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8944 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8945 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8946 address and file/line number respectively.\n\
8948 Convenience variable \"$_\" and default examine address for \"x\"\n\
8949 are set to the address of the last breakpoint listed unless the command\n\
8950 is prefixed with \"server \".\n\n\
8951 Convenience variable \"$bpnum\" contains the number of the last\n\
8953 &maintenanceinfolist
);
8955 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
8956 Set catchpoints to catch events."),
8957 &catch_cmdlist
, "catch ",
8958 0/*allow-unknown*/, &cmdlist
);
8960 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
8961 Set temporary catchpoints to catch events."),
8962 &tcatch_cmdlist
, "tcatch ",
8963 0/*allow-unknown*/, &cmdlist
);
8965 /* Add catch and tcatch sub-commands. */
8966 add_catch_command ("catch", _("\
8967 Catch an exception, when caught.\n\
8968 With an argument, catch only exceptions with the given name."),
8969 catch_catch_command
,
8972 add_catch_command ("throw", _("\
8973 Catch an exception, when thrown.\n\
8974 With an argument, catch only exceptions with the given name."),
8975 catch_throw_command
,
8978 add_catch_command ("fork", _("Catch calls to fork."),
8979 catch_fork_command_1
,
8980 (void *) (uintptr_t) catch_fork_permanent
,
8981 (void *) (uintptr_t) catch_fork_temporary
);
8982 add_catch_command ("vfork", _("Catch calls to vfork."),
8983 catch_fork_command_1
,
8984 (void *) (uintptr_t) catch_vfork_permanent
,
8985 (void *) (uintptr_t) catch_vfork_temporary
);
8986 add_catch_command ("exec", _("Catch calls to exec."),
8987 catch_exec_command_1
,
8990 add_catch_command ("exception", _("\
8991 Catch Ada exceptions, when raised.\n\
8992 With an argument, catch only exceptions with the given name."),
8993 catch_ada_exception_command
,
8996 add_catch_command ("assert", _("\
8997 Catch failed Ada assertions, when raised.\n\
8998 With an argument, catch only exceptions with the given name."),
8999 catch_assert_command
,
9003 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
9004 Set a watchpoint for an expression.\n\
9005 A watchpoint stops execution of your program whenever the value of\n\
9006 an expression changes."));
9007 set_cmd_completer (c
, expression_completer
);
9009 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
9010 Set a read watchpoint for an expression.\n\
9011 A watchpoint stops execution of your program whenever the value of\n\
9012 an expression is read."));
9013 set_cmd_completer (c
, expression_completer
);
9015 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
9016 Set a watchpoint for an expression.\n\
9017 A watchpoint stops execution of your program whenever the value of\n\
9018 an expression is either read or written."));
9019 set_cmd_completer (c
, expression_completer
);
9021 add_info ("watchpoints", breakpoints_info
,
9022 _("Synonym for ``info breakpoints''."));
9025 /* XXX: cagney/2005-02-23: This should be a boolean, and should
9026 respond to changes - contrary to the description. */
9027 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
9028 &can_use_hw_watchpoints
, _("\
9029 Set debugger's willingness to use watchpoint hardware."), _("\
9030 Show debugger's willingness to use watchpoint hardware."), _("\
9031 If zero, gdb will not use hardware for new watchpoints, even if\n\
9032 such is available. (However, any hardware watchpoints that were\n\
9033 created before setting this to nonzero, will continue to use watchpoint\n\
9036 show_can_use_hw_watchpoints
,
9037 &setlist
, &showlist
);
9039 can_use_hw_watchpoints
= 1;
9041 /* Tracepoint manipulation commands. */
9043 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
9044 Set a tracepoint at specified line or function.\n\
9046 BREAK_ARGS_HELP ("trace") "\n\
9047 Do \"help tracepoints\" for info on other tracepoint commands."));
9048 set_cmd_completer (c
, location_completer
);
9050 add_com_alias ("tp", "trace", class_alias
, 0);
9051 add_com_alias ("tr", "trace", class_alias
, 1);
9052 add_com_alias ("tra", "trace", class_alias
, 1);
9053 add_com_alias ("trac", "trace", class_alias
, 1);
9055 add_info ("tracepoints", tracepoints_info
, _("\
9056 Status of tracepoints, or tracepoint number NUMBER.\n\
9057 Convenience variable \"$tpnum\" contains the number of the\n\
9058 last tracepoint set."));
9060 add_info_alias ("tp", "tracepoints", 1);
9062 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
9063 Delete specified tracepoints.\n\
9064 Arguments are tracepoint numbers, separated by spaces.\n\
9065 No argument means delete all tracepoints."),
9068 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
9069 Disable specified tracepoints.\n\
9070 Arguments are tracepoint numbers, separated by spaces.\n\
9071 No argument means disable all tracepoints."),
9073 deprecate_cmd (c
, "disable");
9075 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
9076 Enable specified tracepoints.\n\
9077 Arguments are tracepoint numbers, separated by spaces.\n\
9078 No argument means enable all tracepoints."),
9080 deprecate_cmd (c
, "enable");
9082 add_com ("passcount", class_trace
, trace_pass_command
, _("\
9083 Set the passcount for a tracepoint.\n\
9084 The trace will end when the tracepoint has been passed 'count' times.\n\
9085 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
9086 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
9088 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
9089 Save current tracepoint definitions as a script.\n\
9090 Use the 'source' command in another debug session to restore them."));
9091 set_cmd_completer (c
, filename_completer
);
9093 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
9094 Breakpoint specific settings\n\
9095 Configure various breakpoint-specific variables such as\n\
9096 pending breakpoint behavior"),
9097 &breakpoint_set_cmdlist
, "set breakpoint ",
9098 0/*allow-unknown*/, &setlist
);
9099 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
9100 Breakpoint specific settings\n\
9101 Configure various breakpoint-specific variables such as\n\
9102 pending breakpoint behavior"),
9103 &breakpoint_show_cmdlist
, "show breakpoint ",
9104 0/*allow-unknown*/, &showlist
);
9106 add_setshow_auto_boolean_cmd ("pending", no_class
,
9107 &pending_break_support
, _("\
9108 Set debugger's behavior regarding pending breakpoints."), _("\
9109 Show debugger's behavior regarding pending breakpoints."), _("\
9110 If on, an unrecognized breakpoint location will cause gdb to create a\n\
9111 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
9112 an error. If auto, an unrecognized breakpoint location results in a\n\
9113 user-query to see if a pending breakpoint should be created."),
9115 show_pending_break_support
,
9116 &breakpoint_set_cmdlist
,
9117 &breakpoint_show_cmdlist
);
9119 pending_break_support
= AUTO_BOOLEAN_AUTO
;
9121 add_setshow_boolean_cmd ("auto-hw", no_class
,
9122 &automatic_hardware_breakpoints
, _("\
9123 Set automatic usage of hardware breakpoints."), _("\
9124 Show automatic usage of hardware breakpoints."), _("\
9125 If set, the debugger will automatically use hardware breakpoints for\n\
9126 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
9127 a warning will be emitted for such breakpoints."),
9129 show_automatic_hardware_breakpoints
,
9130 &breakpoint_set_cmdlist
,
9131 &breakpoint_show_cmdlist
);
9133 add_setshow_enum_cmd ("always-inserted", class_support
,
9134 always_inserted_enums
, &always_inserted_mode
, _("\
9135 Set mode for inserting breakpoints."), _("\
9136 Show mode for inserting breakpoints."), _("\
9137 When this mode is off, breakpoints are inserted in inferior when it is\n\
9138 resumed, and removed when execution stops. When this mode is on,\n\
9139 breakpoints are inserted immediately and removed only when the user\n\
9140 deletes the breakpoint. When this mode is auto (which is the default),\n\
9141 the behaviour depends on the non-stop setting (see help set non-stop).\n\
9142 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
9143 behaves as if always-inserted mode is on; if gdb is controlling the\n\
9144 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
9146 &show_always_inserted_mode
,
9147 &breakpoint_set_cmdlist
,
9148 &breakpoint_show_cmdlist
);
9150 automatic_hardware_breakpoints
= 1;
9152 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);