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 /* There is no current frame at this moment. If we're going to have
2776 any chance of handling watchpoints on local variables, we'll need
2777 the frame chain (so we can determine if we're in scope). */
2778 reinit_frame_cache ();
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
2785 && (block_linkage_function (b
->exp_valid_block
)
2786 != get_frame_function (fr
)))
2787 within_current_scope
= 0;
2789 /* in_function_epilogue_p() returns a non-zero value if we're still
2790 in the function but the stack frame has already been invalidated.
2791 Since we can't rely on the values of local variables after the
2792 stack has been destroyed, we are treating the watchpoint in that
2793 state as `not changed' without further checking.
2795 vinschen/2003-09-04: The former implementation left out the case
2796 that the watchpoint frame couldn't be found by frame_find_by_id()
2797 because the current PC is currently in an epilogue. Calling
2798 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2799 if (!within_current_scope
|| fr
== get_current_frame ())
2801 struct frame_info
*frame
= get_current_frame ();
2802 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
2803 CORE_ADDR frame_pc
= get_frame_pc (frame
);
2805 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
2806 return WP_VALUE_NOT_CHANGED
;
2808 if (fr
&& within_current_scope
)
2809 /* If we end up stopping, the current frame will get selected
2810 in normal_stop. So this call to select_frame won't affect
2815 if (within_current_scope
)
2817 /* We use value_{,free_to_}mark because it could be a
2818 *long* time before we return to the command level and
2819 call free_all_values. We can't call free_all_values because
2820 we might be in the middle of evaluating a function call. */
2822 struct value
*mark
= value_mark ();
2823 struct value
*new_val
;
2825 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2826 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2827 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2829 if (new_val
!= NULL
)
2831 release_value (new_val
);
2832 value_free_to_mark (mark
);
2834 bs
->old_val
= b
->val
;
2837 /* We will stop here */
2838 return WP_VALUE_CHANGED
;
2842 /* Nothing changed, don't do anything. */
2843 value_free_to_mark (mark
);
2844 /* We won't stop here */
2845 return WP_VALUE_NOT_CHANGED
;
2850 /* This seems like the only logical thing to do because
2851 if we temporarily ignored the watchpoint, then when
2852 we reenter the block in which it is valid it contains
2853 garbage (in the case of a function, it may have two
2854 garbage values, one before and one after the prologue).
2855 So we can't even detect the first assignment to it and
2856 watch after that (since the garbage may or may not equal
2857 the first value assigned). */
2858 /* We print all the stop information in print_it_typical(), but
2859 in this case, by the time we call print_it_typical() this bp
2860 will be deleted already. So we have no choice but print the
2861 information here. */
2862 if (ui_out_is_mi_like_p (uiout
))
2864 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2865 ui_out_text (uiout
, "\nWatchpoint ");
2866 ui_out_field_int (uiout
, "wpnum", b
->number
);
2867 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2868 which its expression is valid.\n");
2870 if (b
->related_breakpoint
)
2871 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2872 b
->disposition
= disp_del_at_next_stop
;
2878 /* Return true if it looks like target has stopped due to hitting
2879 breakpoint location BL. This function does not check if we
2880 should stop, only if BL explains the stop. */
2882 bpstat_check_location (const struct bp_location
*bl
, CORE_ADDR bp_addr
)
2884 struct breakpoint
*b
= bl
->owner
;
2886 if (b
->type
!= bp_watchpoint
2887 && b
->type
!= bp_hardware_watchpoint
2888 && b
->type
!= bp_read_watchpoint
2889 && b
->type
!= bp_access_watchpoint
2890 && b
->type
!= bp_hardware_breakpoint
2891 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
2893 if (bl
->address
!= bp_addr
) /* address doesn't match */
2895 if (overlay_debugging
/* unmapped overlay section */
2896 && section_is_overlay (bl
->section
)
2897 && !section_is_mapped (bl
->section
))
2901 /* Continuable hardware watchpoints are treated as non-existent if the
2902 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2903 some data address). Otherwise gdb won't stop on a break instruction
2904 in the code (not from a breakpoint) when a hardware watchpoint has
2905 been defined. Also skip watchpoints which we know did not trigger
2906 (did not match the data address). */
2908 if ((b
->type
== bp_hardware_watchpoint
2909 || b
->type
== bp_read_watchpoint
2910 || b
->type
== bp_access_watchpoint
)
2911 && b
->watchpoint_triggered
== watch_triggered_no
)
2914 if (b
->type
== bp_hardware_breakpoint
)
2916 if (bl
->address
!= bp_addr
)
2918 if (overlay_debugging
/* unmapped overlay section */
2919 && section_is_overlay (bl
->section
)
2920 && !section_is_mapped (bl
->section
))
2924 if (b
->type
== bp_catchpoint
)
2926 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
2927 if (!b
->ops
->breakpoint_hit (b
))
2934 /* If BS refers to a watchpoint, determine if the watched values
2935 has actually changed, and we should stop. If not, set BS->stop
2938 bpstat_check_watchpoint (bpstat bs
)
2940 const struct bp_location
*bl
= bs
->breakpoint_at
;
2941 struct breakpoint
*b
= bl
->owner
;
2943 if (b
->type
== bp_watchpoint
2944 || b
->type
== bp_read_watchpoint
2945 || b
->type
== bp_access_watchpoint
2946 || b
->type
== bp_hardware_watchpoint
)
2950 int must_check_value
= 0;
2952 if (b
->type
== bp_watchpoint
)
2953 /* For a software watchpoint, we must always check the
2955 must_check_value
= 1;
2956 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2957 /* We have a hardware watchpoint (read, write, or access)
2958 and the target earlier reported an address watched by
2960 must_check_value
= 1;
2961 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2962 && b
->type
== bp_hardware_watchpoint
)
2963 /* We were stopped by a hardware watchpoint, but the target could
2964 not report the data address. We must check the watchpoint's
2965 value. Access and read watchpoints are out of luck; without
2966 a data address, we can't figure it out. */
2967 must_check_value
= 1;
2969 if (must_check_value
)
2971 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2973 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2974 int e
= catch_errors (watchpoint_check
, bs
, message
,
2976 do_cleanups (cleanups
);
2980 /* We've already printed what needs to be printed. */
2981 bs
->print_it
= print_it_done
;
2984 case WP_VALUE_CHANGED
:
2985 if (b
->type
== bp_read_watchpoint
)
2987 /* Don't stop: read watchpoints shouldn't fire if
2988 the value has changed. This is for targets
2989 which cannot set read-only watchpoints. */
2990 bs
->print_it
= print_it_noop
;
2994 case WP_VALUE_NOT_CHANGED
:
2995 if (b
->type
== bp_hardware_watchpoint
2996 || b
->type
== bp_watchpoint
)
2998 /* Don't stop: write watchpoints shouldn't fire if
2999 the value hasn't changed. */
3000 bs
->print_it
= print_it_noop
;
3008 /* Error from catch_errors. */
3009 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
3010 if (b
->related_breakpoint
)
3011 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3012 b
->disposition
= disp_del_at_next_stop
;
3013 /* We've already printed what needs to be printed. */
3014 bs
->print_it
= print_it_done
;
3018 else /* must_check_value == 0 */
3020 /* This is a case where some watchpoint(s) triggered, but
3021 not at the address of this watchpoint, or else no
3022 watchpoint triggered after all. So don't print
3023 anything for this watchpoint. */
3024 bs
->print_it
= print_it_noop
;
3031 /* Check conditions (condition proper, frame, thread and ignore count)
3032 of breakpoint referred to by BS. If we should not stop for this
3033 breakpoint, set BS->stop to 0. */
3035 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
3037 int thread_id
= pid_to_thread_id (ptid
);
3038 const struct bp_location
*bl
= bs
->breakpoint_at
;
3039 struct breakpoint
*b
= bl
->owner
;
3041 if (frame_id_p (b
->frame_id
)
3042 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
3046 int value_is_zero
= 0;
3048 /* If this is a scope breakpoint, mark the associated
3049 watchpoint as triggered so that we will handle the
3050 out-of-scope event. We'll get to the watchpoint next
3052 if (b
->type
== bp_watchpoint_scope
)
3053 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
3055 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
3057 /* We use value_mark and value_free_to_mark because it could
3058 be a long time before we return to the command level and
3059 call free_all_values. We can't call free_all_values
3060 because we might be in the middle of evaluating a
3062 struct value
*mark
= value_mark ();
3064 /* Need to select the frame, with all that implies
3065 so that the conditions will have the right context. */
3066 select_frame (get_current_frame ());
3068 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
3069 "Error in testing breakpoint condition:\n",
3071 /* FIXME-someday, should give breakpoint # */
3072 value_free_to_mark (mark
);
3074 if (bl
->cond
&& value_is_zero
)
3078 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
3082 else if (b
->ignore_count
> 0)
3085 annotate_ignore_count_change ();
3087 /* Increase the hit count even though we don't
3095 /* Get a bpstat associated with having just stopped at address
3096 BP_ADDR in thread PTID.
3098 Determine whether we stopped at a breakpoint, etc, or whether we
3099 don't understand this stop. Result is a chain of bpstat's such that:
3101 if we don't understand the stop, the result is a null pointer.
3103 if we understand why we stopped, the result is not null.
3105 Each element of the chain refers to a particular breakpoint or
3106 watchpoint at which we have stopped. (We may have stopped for
3107 several reasons concurrently.)
3109 Each element of the chain has valid next, breakpoint_at,
3110 commands, FIXME??? fields. */
3113 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
3115 struct breakpoint
*b
= NULL
;
3116 const struct bp_location
*bl
;
3117 struct bp_location
*loc
;
3118 /* Root of the chain of bpstat's */
3119 struct bpstats root_bs
[1];
3120 /* Pointer to the last thing in the chain currently. */
3121 bpstat bs
= root_bs
;
3123 int need_remove_insert
;
3125 ALL_BP_LOCATIONS (bl
)
3129 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3132 /* For hardware watchpoints, we look only at the first location.
3133 The watchpoint_check function will work on entire expression,
3134 not the individual locations. For read watchopints, the
3135 watchpoints_triggered function have checked all locations
3138 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3141 if (!bpstat_check_location (bl
, bp_addr
))
3144 /* Come here if it's a watchpoint, or if the break address matches */
3146 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3148 /* Assume we stop. Should we find watchpoint that is not actually
3149 triggered, or if condition of breakpoint is false, we'll reset
3154 bpstat_check_watchpoint (bs
);
3158 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3159 || b
->type
== bp_longjmp_master
)
3160 /* We do not stop for these. */
3163 bpstat_check_breakpoint_conditions (bs
, ptid
);
3169 /* We will stop here */
3170 if (b
->disposition
== disp_disable
)
3172 if (b
->enable_state
!= bp_permanent
)
3173 b
->enable_state
= bp_disabled
;
3174 update_global_location_list (0);
3178 bs
->commands
= b
->commands
;
3180 && (strcmp ("silent", bs
->commands
->line
) == 0
3181 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3183 bs
->commands
= bs
->commands
->next
;
3186 bs
->commands
= copy_command_lines (bs
->commands
);
3189 /* Print nothing for this entry if we dont stop or if we dont print. */
3190 if (bs
->stop
== 0 || bs
->print
== 0)
3191 bs
->print_it
= print_it_noop
;
3194 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
3196 if (loc
->address
== bp_addr
)
3198 bs
= bpstat_alloc (loc
, bs
);
3199 /* For hits of moribund locations, we should just proceed. */
3202 bs
->print_it
= print_it_noop
;
3206 bs
->next
= NULL
; /* Terminate the chain */
3207 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3209 /* If we aren't stopping, the value of some hardware watchpoint may
3210 not have changed, but the intermediate memory locations we are
3211 watching may have. Don't bother if we're stopping; this will get
3213 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3217 need_remove_insert
= 0;
3219 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3221 && bs
->breakpoint_at
->owner
3222 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3223 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3224 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3226 /* remove/insert can invalidate bs->breakpoint_at, if this
3227 location is no longer used by the watchpoint. Prevent
3228 further code from trying to use it. */
3229 bs
->breakpoint_at
= NULL
;
3230 need_remove_insert
= 1;
3233 if (need_remove_insert
)
3235 remove_breakpoints ();
3236 insert_breakpoints ();
3239 return root_bs
->next
;
3242 /* Tell what to do about this bpstat. */
3244 bpstat_what (bpstat bs
)
3246 /* Classify each bpstat as one of the following. */
3249 /* This bpstat element has no effect on the main_action. */
3252 /* There was a watchpoint, stop but don't print. */
3255 /* There was a watchpoint, stop and print. */
3258 /* There was a breakpoint but we're not stopping. */
3261 /* There was a breakpoint, stop but don't print. */
3264 /* There was a breakpoint, stop and print. */
3267 /* We hit the longjmp breakpoint. */
3270 /* We hit the longjmp_resume breakpoint. */
3273 /* We hit the step_resume breakpoint. */
3276 /* We hit the shared library event breakpoint. */
3279 /* This is just used to count how many enums there are. */
3283 /* Here is the table which drives this routine. So that we can
3284 format it pretty, we define some abbreviations for the
3285 enum bpstat_what codes. */
3286 #define kc BPSTAT_WHAT_KEEP_CHECKING
3287 #define ss BPSTAT_WHAT_STOP_SILENT
3288 #define sn BPSTAT_WHAT_STOP_NOISY
3289 #define sgl BPSTAT_WHAT_SINGLE
3290 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3291 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3292 #define sr BPSTAT_WHAT_STEP_RESUME
3293 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3295 /* "Can't happen." Might want to print an error message.
3296 abort() is not out of the question, but chances are GDB is just
3297 a bit confused, not unusable. */
3298 #define err BPSTAT_WHAT_STOP_NOISY
3300 /* Given an old action and a class, come up with a new action. */
3301 /* One interesting property of this table is that wp_silent is the same
3302 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3303 after stopping, the check for whether to step over a breakpoint
3304 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3305 reference to how we stopped. We retain separate wp_silent and
3306 bp_silent codes in case we want to change that someday.
3308 Another possibly interesting property of this table is that
3309 there's a partial ordering, priority-like, of the actions. Once
3310 you've decided that some action is appropriate, you'll never go
3311 back and decide something of a lower priority is better. The
3314 kc < clr sgl shl slr sn sr ss
3315 sgl < shl slr sn sr ss
3316 slr < err shl sn sr ss
3317 clr < err shl sn sr ss
3323 What I think this means is that we don't need a damned table
3324 here. If you just put the rows and columns in the right order,
3325 it'd look awfully regular. We could simply walk the bpstat list
3326 and choose the highest priority action we find, with a little
3327 logic to handle the 'err' cases. */
3329 /* step_resume entries: a step resume breakpoint overrides another
3330 breakpoint of signal handling (see comment in wait_for_inferior
3331 at where we set the step_resume breakpoint). */
3333 static const enum bpstat_what_main_action
3334 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3337 /* kc ss sn sgl slr clr sr shl
3340 {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
},
3342 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3344 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3346 {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
},
3348 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3350 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3352 {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
},
3354 {clr
, ss
, sn
, err
, err
, err
, sr
, shl
},
3356 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3358 {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
}
3371 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3372 struct bpstat_what retval
;
3374 retval
.call_dummy
= 0;
3375 for (; bs
!= NULL
; bs
= bs
->next
)
3377 enum class bs_class
= no_effect
;
3378 if (bs
->breakpoint_at
== NULL
)
3379 /* I suspect this can happen if it was a momentary breakpoint
3380 which has since been deleted. */
3382 if (bs
->breakpoint_at
->owner
== NULL
)
3383 bs_class
= bp_nostop
;
3385 switch (bs
->breakpoint_at
->owner
->type
)
3391 case bp_hardware_breakpoint
:
3397 bs_class
= bp_noisy
;
3399 bs_class
= bp_silent
;
3402 bs_class
= bp_nostop
;
3405 case bp_hardware_watchpoint
:
3406 case bp_read_watchpoint
:
3407 case bp_access_watchpoint
:
3411 bs_class
= wp_noisy
;
3413 bs_class
= wp_silent
;
3416 /* There was a watchpoint, but we're not stopping.
3417 This requires no further action. */
3418 bs_class
= no_effect
;
3421 bs_class
= long_jump
;
3423 case bp_longjmp_resume
:
3424 bs_class
= long_resume
;
3426 case bp_step_resume
:
3429 bs_class
= step_resume
;
3432 /* It is for the wrong frame. */
3433 bs_class
= bp_nostop
;
3435 case bp_watchpoint_scope
:
3436 bs_class
= bp_nostop
;
3438 case bp_shlib_event
:
3439 bs_class
= shlib_event
;
3441 case bp_thread_event
:
3442 case bp_overlay_event
:
3443 case bp_longjmp_master
:
3444 bs_class
= bp_nostop
;
3450 bs_class
= bp_noisy
;
3452 bs_class
= bp_silent
;
3455 /* There was a catchpoint, but we're not stopping.
3456 This requires no further action. */
3457 bs_class
= no_effect
;
3460 /* Make sure the action is stop (silent or noisy),
3461 so infrun.c pops the dummy frame. */
3462 bs_class
= bp_silent
;
3463 retval
.call_dummy
= 1;
3466 /* Tracepoint hits should not be reported back to GDB, and
3467 if one got through somehow, it should have been filtered
3469 internal_error (__FILE__
, __LINE__
,
3470 _("bpstat_what: bp_tracepoint encountered"));
3473 current_action
= table
[(int) bs_class
][(int) current_action
];
3475 retval
.main_action
= current_action
;
3479 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3480 without hardware support). This isn't related to a specific bpstat,
3481 just to things like whether watchpoints are set. */
3484 bpstat_should_step (void)
3486 struct breakpoint
*b
;
3488 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
3495 static void print_breakpoint_location (struct breakpoint
*b
,
3496 struct bp_location
*loc
,
3498 struct ui_stream
*stb
)
3503 = find_pc_sect_function (loc
->address
, loc
->section
);
3506 ui_out_text (uiout
, "in ");
3507 ui_out_field_string (uiout
, "func",
3508 SYMBOL_PRINT_NAME (sym
));
3509 ui_out_wrap_hint (uiout
, wrap_indent
);
3510 ui_out_text (uiout
, " at ");
3512 ui_out_field_string (uiout
, "file", b
->source_file
);
3513 ui_out_text (uiout
, ":");
3515 if (ui_out_is_mi_like_p (uiout
))
3517 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3518 char *fullname
= symtab_to_fullname (sal
.symtab
);
3521 ui_out_field_string (uiout
, "fullname", fullname
);
3524 ui_out_field_int (uiout
, "line", b
->line_number
);
3528 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3532 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3533 ui_out_field_stream (uiout
, "at", stb
);
3537 /* Print B to gdb_stdout. */
3539 print_one_breakpoint_location (struct breakpoint
*b
,
3540 struct bp_location
*loc
,
3542 CORE_ADDR
*last_addr
)
3544 struct command_line
*l
;
3546 struct ep_type_description
3551 static struct ep_type_description bptypes
[] =
3553 {bp_none
, "?deleted?"},
3554 {bp_breakpoint
, "breakpoint"},
3555 {bp_hardware_breakpoint
, "hw breakpoint"},
3556 {bp_until
, "until"},
3557 {bp_finish
, "finish"},
3558 {bp_watchpoint
, "watchpoint"},
3559 {bp_hardware_watchpoint
, "hw watchpoint"},
3560 {bp_read_watchpoint
, "read watchpoint"},
3561 {bp_access_watchpoint
, "acc watchpoint"},
3562 {bp_longjmp
, "longjmp"},
3563 {bp_longjmp_resume
, "longjmp resume"},
3564 {bp_step_resume
, "step resume"},
3565 {bp_watchpoint_scope
, "watchpoint scope"},
3566 {bp_call_dummy
, "call dummy"},
3567 {bp_shlib_event
, "shlib events"},
3568 {bp_thread_event
, "thread events"},
3569 {bp_overlay_event
, "overlay events"},
3570 {bp_longjmp_master
, "longjmp master"},
3571 {bp_catchpoint
, "catchpoint"},
3572 {bp_tracepoint
, "tracepoint"},
3575 static char bpenables
[] = "nynny";
3576 char wrap_indent
[80];
3577 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3578 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3579 struct cleanup
*bkpt_chain
;
3581 int header_of_multiple
= 0;
3582 int part_of_multiple
= (loc
!= NULL
);
3583 struct value_print_options opts
;
3585 get_user_print_options (&opts
);
3587 gdb_assert (!loc
|| loc_number
!= 0);
3588 /* See comment in print_one_breakpoint concerning
3589 treatment of breakpoints with single disabled
3593 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3594 header_of_multiple
= 1;
3599 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3603 if (part_of_multiple
)
3606 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3607 ui_out_field_string (uiout
, "number", formatted
);
3612 ui_out_field_int (uiout
, "number", b
->number
);
3617 if (part_of_multiple
)
3618 ui_out_field_skip (uiout
, "type");
3621 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3622 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3623 internal_error (__FILE__
, __LINE__
,
3624 _("bptypes table does not describe type #%d."),
3626 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3631 if (part_of_multiple
)
3632 ui_out_field_skip (uiout
, "disp");
3634 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3639 if (part_of_multiple
)
3640 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3642 ui_out_field_fmt (uiout
, "enabled", "%c",
3643 bpenables
[(int) b
->enable_state
]);
3644 ui_out_spaces (uiout
, 2);
3648 strcpy (wrap_indent
, " ");
3649 if (opts
.addressprint
)
3651 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3652 strcat (wrap_indent
, " ");
3654 strcat (wrap_indent
, " ");
3657 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3659 /* Although the print_one can possibly print
3660 all locations, calling it here is not likely
3661 to get any nice result. So, make sure there's
3662 just one location. */
3663 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3664 b
->ops
->print_one (b
, last_addr
);
3670 internal_error (__FILE__
, __LINE__
,
3671 _("print_one_breakpoint: bp_none encountered\n"));
3675 case bp_hardware_watchpoint
:
3676 case bp_read_watchpoint
:
3677 case bp_access_watchpoint
:
3678 /* Field 4, the address, is omitted (which makes the columns
3679 not line up too nicely with the headers, but the effect
3680 is relatively readable). */
3681 if (opts
.addressprint
)
3682 ui_out_field_skip (uiout
, "addr");
3684 ui_out_field_string (uiout
, "what", b
->exp_string
);
3688 case bp_hardware_breakpoint
:
3692 case bp_longjmp_resume
:
3693 case bp_step_resume
:
3694 case bp_watchpoint_scope
:
3696 case bp_shlib_event
:
3697 case bp_thread_event
:
3698 case bp_overlay_event
:
3699 case bp_longjmp_master
:
3701 if (opts
.addressprint
)
3704 if (header_of_multiple
)
3705 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3706 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3707 ui_out_field_string (uiout
, "addr", "<PENDING>");
3709 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3712 if (!header_of_multiple
)
3713 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3715 *last_addr
= b
->loc
->address
;
3719 if (!part_of_multiple
)
3721 if (b
->thread
!= -1)
3723 /* FIXME: This seems to be redundant and lost here; see the
3724 "stop only in" line a little further down. */
3725 ui_out_text (uiout
, " thread ");
3726 ui_out_field_int (uiout
, "thread", b
->thread
);
3728 else if (b
->task
!= 0)
3730 ui_out_text (uiout
, " task ");
3731 ui_out_field_int (uiout
, "task", b
->task
);
3735 ui_out_text (uiout
, "\n");
3737 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3740 ui_out_text (uiout
, "\tstop only in stack frame at ");
3741 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3743 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3744 ui_out_text (uiout
, "\n");
3747 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3749 /* We do not print the condition for Ada exception catchpoints
3750 because the condition is an internal implementation detail
3751 that we do not want to expose to the user. */
3753 if (b
->type
== bp_tracepoint
)
3754 ui_out_text (uiout
, "\ttrace only if ");
3756 ui_out_text (uiout
, "\tstop only if ");
3757 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3758 ui_out_text (uiout
, "\n");
3761 if (!part_of_multiple
&& b
->thread
!= -1)
3763 /* FIXME should make an annotation for this */
3764 ui_out_text (uiout
, "\tstop only in thread ");
3765 ui_out_field_int (uiout
, "thread", b
->thread
);
3766 ui_out_text (uiout
, "\n");
3769 if (!part_of_multiple
&& b
->hit_count
)
3771 /* FIXME should make an annotation for this */
3772 if (ep_is_catchpoint (b
))
3773 ui_out_text (uiout
, "\tcatchpoint");
3775 ui_out_text (uiout
, "\tbreakpoint");
3776 ui_out_text (uiout
, " already hit ");
3777 ui_out_field_int (uiout
, "times", b
->hit_count
);
3778 if (b
->hit_count
== 1)
3779 ui_out_text (uiout
, " time\n");
3781 ui_out_text (uiout
, " times\n");
3784 /* Output the count also if it is zero, but only if this is
3785 mi. FIXME: Should have a better test for this. */
3786 if (ui_out_is_mi_like_p (uiout
))
3787 if (!part_of_multiple
&& b
->hit_count
== 0)
3788 ui_out_field_int (uiout
, "times", b
->hit_count
);
3790 if (!part_of_multiple
&& b
->ignore_count
)
3793 ui_out_text (uiout
, "\tignore next ");
3794 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3795 ui_out_text (uiout
, " hits\n");
3799 if (!part_of_multiple
&& l
)
3801 struct cleanup
*script_chain
;
3804 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3805 print_command_lines (uiout
, l
, 4);
3806 do_cleanups (script_chain
);
3809 if (!part_of_multiple
&& b
->pass_count
)
3811 annotate_field (10);
3812 ui_out_text (uiout
, "\tpass count ");
3813 ui_out_field_int (uiout
, "pass", b
->pass_count
);
3814 ui_out_text (uiout
, " \n");
3817 if (!part_of_multiple
&& b
->step_count
)
3819 annotate_field (11);
3820 ui_out_text (uiout
, "\tstep count ");
3821 ui_out_field_int (uiout
, "step", b
->step_count
);
3822 ui_out_text (uiout
, " \n");
3825 if (!part_of_multiple
&& b
->actions
)
3827 struct action_line
*action
;
3828 annotate_field (12);
3829 for (action
= b
->actions
; action
; action
= action
->next
)
3831 ui_out_text (uiout
, " A\t");
3832 ui_out_text (uiout
, action
->action
);
3833 ui_out_text (uiout
, "\n");
3837 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
3840 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
3841 else if (b
->exp_string
)
3842 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
3845 do_cleanups (bkpt_chain
);
3846 do_cleanups (old_chain
);
3850 print_one_breakpoint (struct breakpoint
*b
,
3851 CORE_ADDR
*last_addr
)
3853 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3855 /* If this breakpoint has custom print function,
3856 it's already printed. Otherwise, print individual
3857 locations, if any. */
3858 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3860 /* If breakpoint has a single location that is
3861 disabled, we print it as if it had
3862 several locations, since otherwise it's hard to
3863 represent "breakpoint enabled, location disabled"
3865 Note that while hardware watchpoints have
3866 several locations internally, that's no a property
3869 && !is_hardware_watchpoint (b
)
3870 && (b
->loc
->next
|| !b
->loc
->enabled
)
3871 && !ui_out_is_mi_like_p (uiout
))
3873 struct bp_location
*loc
;
3875 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3876 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3882 struct captured_breakpoint_query_args
3888 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3890 struct captured_breakpoint_query_args
*args
= data
;
3891 struct breakpoint
*b
;
3892 CORE_ADDR dummy_addr
= 0;
3895 if (args
->bnum
== b
->number
)
3897 print_one_breakpoint (b
, &dummy_addr
);
3905 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3907 struct captured_breakpoint_query_args args
;
3909 /* For the moment we don't trust print_one_breakpoint() to not throw
3911 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3912 error_message
, RETURN_MASK_ALL
) < 0)
3918 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3919 catchpoints, et.al.). */
3922 user_settable_breakpoint (const struct breakpoint
*b
)
3924 return (b
->type
== bp_breakpoint
3925 || b
->type
== bp_catchpoint
3926 || b
->type
== bp_hardware_breakpoint
3927 || b
->type
== bp_tracepoint
3928 || b
->type
== bp_watchpoint
3929 || b
->type
== bp_read_watchpoint
3930 || b
->type
== bp_access_watchpoint
3931 || b
->type
== bp_hardware_watchpoint
);
3934 /* Print information on user settable breakpoint (watchpoint, etc)
3935 number BNUM. If BNUM is -1 print all user settable breakpoints.
3936 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3939 breakpoint_1 (int bnum
, int allflag
)
3941 struct breakpoint
*b
;
3942 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3943 int nr_printable_breakpoints
;
3944 struct cleanup
*bkpttbl_chain
;
3945 struct value_print_options opts
;
3947 get_user_print_options (&opts
);
3949 /* Compute the number of rows in the table. */
3950 nr_printable_breakpoints
= 0;
3953 || bnum
== b
->number
)
3955 if (allflag
|| user_settable_breakpoint (b
))
3956 nr_printable_breakpoints
++;
3959 if (opts
.addressprint
)
3961 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3965 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3968 if (nr_printable_breakpoints
> 0)
3969 annotate_breakpoints_headers ();
3970 if (nr_printable_breakpoints
> 0)
3972 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3973 if (nr_printable_breakpoints
> 0)
3975 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3976 if (nr_printable_breakpoints
> 0)
3978 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3979 if (nr_printable_breakpoints
> 0)
3981 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3982 if (opts
.addressprint
)
3984 if (nr_printable_breakpoints
> 0)
3986 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3987 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3989 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3991 if (nr_printable_breakpoints
> 0)
3993 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3994 ui_out_table_body (uiout
);
3995 if (nr_printable_breakpoints
> 0)
3996 annotate_breakpoints_table ();
4000 || bnum
== b
->number
)
4002 /* We only print out user settable breakpoints unless the
4004 if (allflag
|| user_settable_breakpoint (b
))
4005 print_one_breakpoint (b
, &last_addr
);
4008 do_cleanups (bkpttbl_chain
);
4010 if (nr_printable_breakpoints
== 0)
4013 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
4015 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
4020 /* Compare against (CORE_ADDR)-1 in case some compiler decides
4021 that a comparison of an unsigned with -1 is always false. */
4022 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
4023 set_next_address (current_gdbarch
, last_addr
);
4026 /* FIXME? Should this be moved up so that it is only called when
4027 there have been breakpoints? */
4028 annotate_breakpoints_table_end ();
4032 breakpoints_info (char *bnum_exp
, int from_tty
)
4037 bnum
= parse_and_eval_long (bnum_exp
);
4039 breakpoint_1 (bnum
, 0);
4043 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4048 bnum
= parse_and_eval_long (bnum_exp
);
4050 breakpoint_1 (bnum
, 1);
4054 breakpoint_has_pc (struct breakpoint
*b
,
4055 CORE_ADDR pc
, struct obj_section
*section
)
4057 struct bp_location
*bl
= b
->loc
;
4058 for (; bl
; bl
= bl
->next
)
4060 if (bl
->address
== pc
4061 && (!overlay_debugging
|| bl
->section
== section
))
4067 /* Print a message describing any breakpoints set at PC. */
4070 describe_other_breakpoints (CORE_ADDR pc
, struct obj_section
*section
,
4074 struct breakpoint
*b
;
4077 others
+= breakpoint_has_pc (b
, pc
, section
);
4081 printf_filtered (_("Note: breakpoint "));
4082 else /* if (others == ???) */
4083 printf_filtered (_("Note: breakpoints "));
4085 if (breakpoint_has_pc (b
, pc
, section
))
4088 printf_filtered ("%d", b
->number
);
4089 if (b
->thread
== -1 && thread
!= -1)
4090 printf_filtered (" (all threads)");
4091 else if (b
->thread
!= -1)
4092 printf_filtered (" (thread %d)", b
->thread
);
4093 printf_filtered ("%s%s ",
4094 ((b
->enable_state
== bp_disabled
4095 || b
->enable_state
== bp_call_disabled
)
4097 : b
->enable_state
== bp_permanent
4101 : ((others
== 1) ? " and" : ""));
4103 printf_filtered (_("also set at pc "));
4104 fputs_filtered (paddress (pc
), gdb_stdout
);
4105 printf_filtered (".\n");
4109 /* Set the default place to put a breakpoint
4110 for the `break' command with no arguments. */
4113 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
4116 default_breakpoint_valid
= valid
;
4117 default_breakpoint_address
= addr
;
4118 default_breakpoint_symtab
= symtab
;
4119 default_breakpoint_line
= line
;
4122 /* Return true iff it is meaningful to use the address member of
4123 BPT. For some breakpoint types, the address member is irrelevant
4124 and it makes no sense to attempt to compare it to other addresses
4125 (or use it for any other purpose either).
4127 More specifically, each of the following breakpoint types will always
4128 have a zero valued address and we don't want check_duplicates() to mark
4129 breakpoints of any of these types to be a duplicate of an actual
4130 breakpoint at address zero:
4133 bp_hardware_watchpoint
4135 bp_access_watchpoint
4139 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4141 enum bptype type
= bpt
->type
;
4143 return (type
!= bp_watchpoint
4144 && type
!= bp_hardware_watchpoint
4145 && type
!= bp_read_watchpoint
4146 && type
!= bp_access_watchpoint
4147 && type
!= bp_catchpoint
);
4150 /* Rescan breakpoints at the same address and section as BPT,
4151 marking the first one as "first" and any others as "duplicates".
4152 This is so that the bpt instruction is only inserted once.
4153 If we have a permanent breakpoint at the same place as BPT, make
4154 that one the official one, and the rest as duplicates. */
4157 check_duplicates_for (CORE_ADDR address
, struct obj_section
*section
)
4159 struct bp_location
*b
;
4161 struct bp_location
*perm_bp
= 0;
4163 ALL_BP_LOCATIONS (b
)
4164 if (b
->owner
->enable_state
!= bp_disabled
4165 && b
->owner
->enable_state
!= bp_call_disabled
4167 && !b
->shlib_disabled
4168 && b
->address
== address
/* address / overlay match */
4169 && (!overlay_debugging
|| b
->section
== section
)
4170 && breakpoint_address_is_meaningful (b
->owner
))
4172 /* Have we found a permanent breakpoint? */
4173 if (b
->owner
->enable_state
== bp_permanent
)
4180 b
->duplicate
= count
> 1;
4183 /* If we found a permanent breakpoint at this address, go over the
4184 list again and declare all the other breakpoints there (except
4185 other permanent breakpoints) to be the duplicates. */
4188 perm_bp
->duplicate
= 0;
4190 /* Permanent breakpoint should always be inserted. */
4191 if (! perm_bp
->inserted
)
4192 internal_error (__FILE__
, __LINE__
,
4193 _("allegedly permanent breakpoint is not "
4194 "actually inserted"));
4196 ALL_BP_LOCATIONS (b
)
4199 if (b
->owner
->enable_state
!= bp_permanent
4200 && b
->owner
->enable_state
!= bp_disabled
4201 && b
->owner
->enable_state
!= bp_call_disabled
4202 && b
->enabled
&& !b
->shlib_disabled
4203 && b
->address
== address
/* address / overlay match */
4204 && (!overlay_debugging
|| b
->section
== section
)
4205 && breakpoint_address_is_meaningful (b
->owner
))
4208 internal_error (__FILE__
, __LINE__
,
4209 _("another breakpoint was inserted on top of "
4210 "a permanent breakpoint"));
4219 check_duplicates (struct breakpoint
*bpt
)
4221 struct bp_location
*bl
= bpt
->loc
;
4223 if (! breakpoint_address_is_meaningful (bpt
))
4226 for (; bl
; bl
= bl
->next
)
4227 check_duplicates_for (bl
->address
, bl
->section
);
4231 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4232 int bnum
, int have_bnum
)
4237 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4238 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4240 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4241 bnum
, astr1
, astr2
);
4243 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4246 /* Adjust a breakpoint's address to account for architectural constraints
4247 on breakpoint placement. Return the adjusted address. Note: Very
4248 few targets require this kind of adjustment. For most targets,
4249 this function is simply the identity function. */
4252 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
4254 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4256 /* Very few targets need any kind of breakpoint adjustment. */
4259 else if (bptype
== bp_watchpoint
4260 || bptype
== bp_hardware_watchpoint
4261 || bptype
== bp_read_watchpoint
4262 || bptype
== bp_access_watchpoint
4263 || bptype
== bp_catchpoint
)
4265 /* Watchpoints and the various bp_catch_* eventpoints should not
4266 have their addresses modified. */
4271 CORE_ADDR adjusted_bpaddr
;
4273 /* Some targets have architectural constraints on the placement
4274 of breakpoint instructions. Obtain the adjusted address. */
4275 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4278 /* An adjusted breakpoint address can significantly alter
4279 a user's expectations. Print a warning if an adjustment
4281 if (adjusted_bpaddr
!= bpaddr
)
4282 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4284 return adjusted_bpaddr
;
4288 /* Allocate a struct bp_location. */
4290 static struct bp_location
*
4291 allocate_bp_location (struct breakpoint
*bpt
)
4293 struct bp_location
*loc
, *loc_p
;
4295 loc
= xmalloc (sizeof (struct bp_location
));
4296 memset (loc
, 0, sizeof (*loc
));
4300 loc
->shlib_disabled
= 0;
4310 case bp_longjmp_resume
:
4311 case bp_step_resume
:
4312 case bp_watchpoint_scope
:
4314 case bp_shlib_event
:
4315 case bp_thread_event
:
4316 case bp_overlay_event
:
4317 case bp_longjmp_master
:
4318 loc
->loc_type
= bp_loc_software_breakpoint
;
4320 case bp_hardware_breakpoint
:
4321 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4323 case bp_hardware_watchpoint
:
4324 case bp_read_watchpoint
:
4325 case bp_access_watchpoint
:
4326 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4330 loc
->loc_type
= bp_loc_other
;
4333 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4339 static void free_bp_location (struct bp_location
*loc
)
4344 if (loc
->function_name
)
4345 xfree (loc
->function_name
);
4350 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4351 that has type BPTYPE and has no locations as yet. */
4353 static struct breakpoint
*
4354 set_raw_breakpoint_without_location (enum bptype bptype
)
4356 struct breakpoint
*b
, *b1
;
4358 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4359 memset (b
, 0, sizeof (*b
));
4362 b
->language
= current_language
->la_language
;
4363 b
->input_radix
= input_radix
;
4365 b
->enable_state
= bp_enabled
;
4368 b
->ignore_count
= 0;
4370 b
->frame_id
= null_frame_id
;
4371 b
->forked_inferior_pid
= null_ptid
;
4372 b
->exec_pathname
= NULL
;
4374 b
->condition_not_parsed
= 0;
4376 /* Add this breakpoint to the end of the chain
4377 so that a list of breakpoints will come out in order
4378 of increasing numbers. */
4380 b1
= breakpoint_chain
;
4382 breakpoint_chain
= b
;
4392 /* Initialize loc->function_name. */
4394 set_breakpoint_location_function (struct bp_location
*loc
)
4396 if (loc
->owner
->type
== bp_breakpoint
4397 || loc
->owner
->type
== bp_hardware_breakpoint
4398 || loc
->owner
->type
== bp_tracepoint
)
4400 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4402 if (loc
->function_name
)
4403 loc
->function_name
= xstrdup (loc
->function_name
);
4407 /* set_raw_breakpoint is a low level routine for allocating and
4408 partially initializing a breakpoint of type BPTYPE. The newly
4409 created breakpoint's address, section, source file name, and line
4410 number are provided by SAL. The newly created and partially
4411 initialized breakpoint is added to the breakpoint chain and
4412 is also returned as the value of this function.
4414 It is expected that the caller will complete the initialization of
4415 the newly created breakpoint struct as well as output any status
4416 information regarding the creation of a new breakpoint. In
4417 particular, set_raw_breakpoint does NOT set the breakpoint
4418 number! Care should be taken to not allow an error to occur
4419 prior to completing the initialization of the breakpoint. If this
4420 should happen, a bogus breakpoint will be left on the chain. */
4423 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4425 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4426 CORE_ADDR adjusted_address
;
4428 /* Adjust the breakpoint's address prior to allocating a location.
4429 Once we call allocate_bp_location(), that mostly uninitialized
4430 location will be placed on the location chain. Adjustment of the
4431 breakpoint may cause target_read_memory() to be called and we do
4432 not want its scan of the location chain to find a breakpoint and
4433 location that's only been partially initialized. */
4434 adjusted_address
= adjust_breakpoint_address (sal
.pc
, b
->type
);
4436 b
->loc
= allocate_bp_location (b
);
4437 b
->loc
->requested_address
= sal
.pc
;
4438 b
->loc
->address
= adjusted_address
;
4440 if (sal
.symtab
== NULL
)
4441 b
->source_file
= NULL
;
4443 b
->source_file
= xstrdup (sal
.symtab
->filename
);
4444 b
->loc
->section
= sal
.section
;
4445 b
->line_number
= sal
.line
;
4447 set_breakpoint_location_function (b
->loc
);
4449 breakpoints_changed ();
4455 /* Note that the breakpoint object B describes a permanent breakpoint
4456 instruction, hard-wired into the inferior's code. */
4458 make_breakpoint_permanent (struct breakpoint
*b
)
4460 struct bp_location
*bl
;
4461 b
->enable_state
= bp_permanent
;
4463 /* By definition, permanent breakpoints are already present in the code.
4464 Mark all locations as inserted. For now, make_breakpoint_permanent
4465 is called in just one place, so it's hard to say if it's reasonable
4466 to have permanent breakpoint with multiple locations or not,
4467 but it's easy to implmement. */
4468 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4472 /* Call this routine when stepping and nexting to enable a breakpoint
4473 if we do a longjmp() in THREAD. When we hit that breakpoint, call
4474 set_longjmp_resume_breakpoint() to figure out where we are going. */
4477 set_longjmp_breakpoint (int thread
)
4479 struct breakpoint
*b
, *temp
;
4481 /* To avoid having to rescan all objfile symbols at every step,
4482 we maintain a list of continually-inserted but always disabled
4483 longjmp "master" breakpoints. Here, we simply create momentary
4484 clones of those and enable them for the requested thread. */
4485 ALL_BREAKPOINTS_SAFE (b
, temp
)
4486 if (b
->type
== bp_longjmp_master
)
4488 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
4489 clone
->type
= bp_longjmp
;
4490 clone
->thread
= thread
;
4494 /* Delete all longjmp breakpoints from THREAD. */
4496 delete_longjmp_breakpoint (int thread
)
4498 struct breakpoint
*b
, *temp
;
4500 ALL_BREAKPOINTS_SAFE (b
, temp
)
4501 if (b
->type
== bp_longjmp
)
4503 if (b
->thread
== thread
)
4504 delete_breakpoint (b
);
4509 enable_overlay_breakpoints (void)
4511 struct breakpoint
*b
;
4514 if (b
->type
== bp_overlay_event
)
4516 b
->enable_state
= bp_enabled
;
4517 update_global_location_list (1);
4518 overlay_events_enabled
= 1;
4523 disable_overlay_breakpoints (void)
4525 struct breakpoint
*b
;
4528 if (b
->type
== bp_overlay_event
)
4530 b
->enable_state
= bp_disabled
;
4531 update_global_location_list (0);
4532 overlay_events_enabled
= 0;
4537 create_thread_event_breakpoint (CORE_ADDR address
)
4539 struct breakpoint
*b
;
4541 b
= create_internal_breakpoint (address
, bp_thread_event
);
4543 b
->enable_state
= bp_enabled
;
4544 /* addr_string has to be used or breakpoint_re_set will delete me. */
4545 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4547 update_global_location_list_nothrow (1);
4553 remove_thread_event_breakpoints (void)
4555 struct breakpoint
*b
, *temp
;
4557 ALL_BREAKPOINTS_SAFE (b
, temp
)
4558 if (b
->type
== bp_thread_event
)
4559 delete_breakpoint (b
);
4562 struct captured_parse_breakpoint_args
4565 struct symtabs_and_lines
*sals_p
;
4566 char ***addr_string_p
;
4570 struct lang_and_radix
4578 remove_solib_event_breakpoints (void)
4580 struct breakpoint
*b
, *temp
;
4582 ALL_BREAKPOINTS_SAFE (b
, temp
)
4583 if (b
->type
== bp_shlib_event
)
4584 delete_breakpoint (b
);
4588 create_solib_event_breakpoint (CORE_ADDR address
)
4590 struct breakpoint
*b
;
4592 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4593 update_global_location_list_nothrow (1);
4597 /* Disable any breakpoints that are on code in shared libraries. Only
4598 apply to enabled breakpoints, disabled ones can just stay disabled. */
4601 disable_breakpoints_in_shlibs (void)
4603 struct bp_location
*loc
;
4605 ALL_BP_LOCATIONS (loc
)
4607 struct breakpoint
*b
= loc
->owner
;
4608 /* We apply the check to all breakpoints, including disabled
4609 for those with loc->duplicate set. This is so that when breakpoint
4610 becomes enabled, or the duplicate is removed, gdb will try to insert
4611 all breakpoints. If we don't set shlib_disabled here, we'll try
4612 to insert those breakpoints and fail. */
4613 if (((b
->type
== bp_breakpoint
)
4614 || (b
->type
== bp_hardware_breakpoint
)
4615 || (b
->type
== bp_tracepoint
))
4616 && !loc
->shlib_disabled
4618 && PC_SOLIB (loc
->address
)
4620 && solib_name_from_address (loc
->address
)
4624 loc
->shlib_disabled
= 1;
4629 /* Disable any breakpoints that are in in an unloaded shared library. Only
4630 apply to enabled breakpoints, disabled ones can just stay disabled. */
4633 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4635 struct bp_location
*loc
;
4636 int disabled_shlib_breaks
= 0;
4638 /* SunOS a.out shared libraries are always mapped, so do not
4639 disable breakpoints; they will only be reported as unloaded
4640 through clear_solib when GDB discards its shared library
4641 list. See clear_solib for more information. */
4642 if (exec_bfd
!= NULL
4643 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
4646 ALL_BP_LOCATIONS (loc
)
4648 struct breakpoint
*b
= loc
->owner
;
4649 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4650 || loc
->loc_type
== bp_loc_software_breakpoint
)
4651 && !loc
->shlib_disabled
4652 && (b
->type
== bp_breakpoint
|| b
->type
== bp_hardware_breakpoint
)
4653 && solib_contains_address_p (solib
, loc
->address
))
4655 loc
->shlib_disabled
= 1;
4656 /* At this point, we cannot rely on remove_breakpoint
4657 succeeding so we must mark the breakpoint as not inserted
4658 to prevent future errors occurring in remove_breakpoints. */
4660 if (!disabled_shlib_breaks
)
4662 target_terminal_ours_for_output ();
4663 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4666 disabled_shlib_breaks
= 1;
4671 /* FORK & VFORK catchpoints. */
4673 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
4676 insert_catch_fork (struct breakpoint
*b
)
4678 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
4681 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
4684 remove_catch_fork (struct breakpoint
*b
)
4686 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
4689 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
4693 breakpoint_hit_catch_fork (struct breakpoint
*b
)
4695 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
4698 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
4700 static enum print_stop_action
4701 print_it_catch_fork (struct breakpoint
*b
)
4703 annotate_catchpoint (b
->number
);
4704 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
4705 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4706 return PRINT_SRC_AND_LOC
;
4709 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
4712 print_one_catch_fork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4714 struct value_print_options opts
;
4716 get_user_print_options (&opts
);
4718 /* Field 4, the address, is omitted (which makes the columns
4719 not line up too nicely with the headers, but the effect
4720 is relatively readable). */
4721 if (opts
.addressprint
)
4722 ui_out_field_skip (uiout
, "addr");
4724 ui_out_text (uiout
, "fork");
4725 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4727 ui_out_text (uiout
, ", process ");
4728 ui_out_field_int (uiout
, "what",
4729 ptid_get_pid (b
->forked_inferior_pid
));
4730 ui_out_spaces (uiout
, 1);
4734 /* Implement the "print_mention" breakpoint_ops method for fork
4738 print_mention_catch_fork (struct breakpoint
*b
)
4740 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
4743 /* The breakpoint_ops structure to be used in fork catchpoints. */
4745 static struct breakpoint_ops catch_fork_breakpoint_ops
=
4749 breakpoint_hit_catch_fork
,
4750 print_it_catch_fork
,
4751 print_one_catch_fork
,
4752 print_mention_catch_fork
4755 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
4758 insert_catch_vfork (struct breakpoint
*b
)
4760 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
4763 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
4766 remove_catch_vfork (struct breakpoint
*b
)
4768 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
4771 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
4775 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
4777 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
4780 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
4782 static enum print_stop_action
4783 print_it_catch_vfork (struct breakpoint
*b
)
4785 annotate_catchpoint (b
->number
);
4786 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
4787 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4788 return PRINT_SRC_AND_LOC
;
4791 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
4794 print_one_catch_vfork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4796 struct value_print_options opts
;
4798 get_user_print_options (&opts
);
4799 /* Field 4, the address, is omitted (which makes the columns
4800 not line up too nicely with the headers, but the effect
4801 is relatively readable). */
4802 if (opts
.addressprint
)
4803 ui_out_field_skip (uiout
, "addr");
4805 ui_out_text (uiout
, "vfork");
4806 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4808 ui_out_text (uiout
, ", process ");
4809 ui_out_field_int (uiout
, "what",
4810 ptid_get_pid (b
->forked_inferior_pid
));
4811 ui_out_spaces (uiout
, 1);
4815 /* Implement the "print_mention" breakpoint_ops method for vfork
4819 print_mention_catch_vfork (struct breakpoint
*b
)
4821 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
4824 /* The breakpoint_ops structure to be used in vfork catchpoints. */
4826 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
4830 breakpoint_hit_catch_vfork
,
4831 print_it_catch_vfork
,
4832 print_one_catch_vfork
,
4833 print_mention_catch_vfork
4836 /* Create a new breakpoint of the bp_catchpoint kind and return it.
4838 If TEMPFLAG is non-zero, then make the breakpoint temporary.
4839 If COND_STRING is not NULL, then store it in the breakpoint.
4840 OPS, if not NULL, is the breakpoint_ops structure associated
4841 to the catchpoint. */
4843 static struct breakpoint
*
4844 create_catchpoint (int tempflag
, char *cond_string
,
4845 struct breakpoint_ops
*ops
)
4847 struct symtab_and_line sal
;
4848 struct breakpoint
*b
;
4855 b
= set_raw_breakpoint (sal
, bp_catchpoint
);
4856 set_breakpoint_count (breakpoint_count
+ 1);
4857 b
->number
= breakpoint_count
;
4859 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
4861 b
->addr_string
= NULL
;
4862 b
->enable_state
= bp_enabled
;
4863 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4867 update_global_location_list (1);
4873 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4874 struct breakpoint_ops
*ops
)
4876 struct breakpoint
*b
= create_catchpoint (tempflag
, cond_string
, ops
);
4878 /* FIXME: We should put this information in a breakpoint private data
4880 b
->forked_inferior_pid
= null_ptid
;
4883 /* Exec catchpoints. */
4886 insert_catch_exec (struct breakpoint
*b
)
4888 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
4892 remove_catch_exec (struct breakpoint
*b
)
4894 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
4898 breakpoint_hit_catch_exec (struct breakpoint
*b
)
4900 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
4903 static enum print_stop_action
4904 print_it_catch_exec (struct breakpoint
*b
)
4906 annotate_catchpoint (b
->number
);
4907 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
4909 return PRINT_SRC_AND_LOC
;
4913 print_one_catch_exec (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4915 struct value_print_options opts
;
4917 get_user_print_options (&opts
);
4919 /* Field 4, the address, is omitted (which makes the columns
4920 not line up too nicely with the headers, but the effect
4921 is relatively readable). */
4922 if (opts
.addressprint
)
4923 ui_out_field_skip (uiout
, "addr");
4925 ui_out_text (uiout
, "exec");
4926 if (b
->exec_pathname
!= NULL
)
4928 ui_out_text (uiout
, ", program \"");
4929 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
4930 ui_out_text (uiout
, "\" ");
4935 print_mention_catch_exec (struct breakpoint
*b
)
4937 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
4940 static struct breakpoint_ops catch_exec_breakpoint_ops
=
4944 breakpoint_hit_catch_exec
,
4945 print_it_catch_exec
,
4946 print_one_catch_exec
,
4947 print_mention_catch_exec
4951 hw_breakpoint_used_count (void)
4953 struct breakpoint
*b
;
4958 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
4966 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4968 struct breakpoint
*b
;
4971 *other_type_used
= 0;
4974 if (breakpoint_enabled (b
))
4976 if (b
->type
== type
)
4978 else if ((b
->type
== bp_hardware_watchpoint
4979 || b
->type
== bp_read_watchpoint
4980 || b
->type
== bp_access_watchpoint
))
4981 *other_type_used
= 1;
4988 disable_watchpoints_before_interactive_call_start (void)
4990 struct breakpoint
*b
;
4994 if (((b
->type
== bp_watchpoint
)
4995 || (b
->type
== bp_hardware_watchpoint
)
4996 || (b
->type
== bp_read_watchpoint
)
4997 || (b
->type
== bp_access_watchpoint
))
4998 && breakpoint_enabled (b
))
5000 b
->enable_state
= bp_call_disabled
;
5001 update_global_location_list (0);
5007 enable_watchpoints_after_interactive_call_stop (void)
5009 struct breakpoint
*b
;
5013 if (((b
->type
== bp_watchpoint
)
5014 || (b
->type
== bp_hardware_watchpoint
)
5015 || (b
->type
== bp_read_watchpoint
)
5016 || (b
->type
== bp_access_watchpoint
))
5017 && (b
->enable_state
== bp_call_disabled
))
5019 b
->enable_state
= bp_enabled
;
5020 update_global_location_list (1);
5026 /* Set a breakpoint that will evaporate an end of command
5027 at address specified by SAL.
5028 Restrict it to frame FRAME if FRAME is nonzero. */
5031 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
5034 struct breakpoint
*b
;
5035 b
= set_raw_breakpoint (sal
, type
);
5036 b
->enable_state
= bp_enabled
;
5037 b
->disposition
= disp_donttouch
;
5038 b
->frame_id
= frame_id
;
5040 /* If we're debugging a multi-threaded program, then we
5041 want momentary breakpoints to be active in only a
5042 single thread of control. */
5043 if (in_thread_list (inferior_ptid
))
5044 b
->thread
= pid_to_thread_id (inferior_ptid
);
5046 update_global_location_list_nothrow (1);
5051 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
5055 clone_momentary_breakpoint (struct breakpoint
*orig
)
5057 struct breakpoint
*copy
;
5059 /* If there's nothing to clone, then return nothing. */
5063 copy
= set_raw_breakpoint_without_location (orig
->type
);
5064 copy
->loc
= allocate_bp_location (copy
);
5065 set_breakpoint_location_function (copy
->loc
);
5067 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
5068 copy
->loc
->address
= orig
->loc
->address
;
5069 copy
->loc
->section
= orig
->loc
->section
;
5071 if (orig
->source_file
== NULL
)
5072 copy
->source_file
= NULL
;
5074 copy
->source_file
= xstrdup (orig
->source_file
);
5076 copy
->line_number
= orig
->line_number
;
5077 copy
->frame_id
= orig
->frame_id
;
5078 copy
->thread
= orig
->thread
;
5080 copy
->enable_state
= bp_enabled
;
5081 copy
->disposition
= disp_donttouch
;
5082 copy
->number
= internal_breakpoint_number
--;
5084 update_global_location_list_nothrow (0);
5089 set_momentary_breakpoint_at_pc (CORE_ADDR pc
, enum bptype type
)
5091 struct symtab_and_line sal
;
5093 sal
= find_pc_line (pc
, 0);
5095 sal
.section
= find_pc_overlay (pc
);
5096 sal
.explicit_pc
= 1;
5098 return set_momentary_breakpoint (sal
, null_frame_id
, type
);
5102 /* Tell the user we have just set a breakpoint B. */
5105 mention (struct breakpoint
*b
)
5108 struct cleanup
*ui_out_chain
;
5109 struct value_print_options opts
;
5111 get_user_print_options (&opts
);
5113 /* FIXME: This is misplaced; mention() is called by things (like
5114 hitting a watchpoint) other than breakpoint creation. It should
5115 be possible to clean this up and at the same time replace the
5116 random calls to breakpoint_changed with this hook. */
5117 observer_notify_breakpoint_created (b
->number
);
5119 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
5120 b
->ops
->print_mention (b
);
5125 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
5128 ui_out_text (uiout
, "Watchpoint ");
5129 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5130 ui_out_field_int (uiout
, "number", b
->number
);
5131 ui_out_text (uiout
, ": ");
5132 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5133 do_cleanups (ui_out_chain
);
5135 case bp_hardware_watchpoint
:
5136 ui_out_text (uiout
, "Hardware watchpoint ");
5137 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5138 ui_out_field_int (uiout
, "number", b
->number
);
5139 ui_out_text (uiout
, ": ");
5140 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5141 do_cleanups (ui_out_chain
);
5143 case bp_read_watchpoint
:
5144 ui_out_text (uiout
, "Hardware read watchpoint ");
5145 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
5146 ui_out_field_int (uiout
, "number", b
->number
);
5147 ui_out_text (uiout
, ": ");
5148 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5149 do_cleanups (ui_out_chain
);
5151 case bp_access_watchpoint
:
5152 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
5153 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
5154 ui_out_field_int (uiout
, "number", b
->number
);
5155 ui_out_text (uiout
, ": ");
5156 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5157 do_cleanups (ui_out_chain
);
5160 if (ui_out_is_mi_like_p (uiout
))
5165 if (b
->disposition
== disp_del
)
5166 printf_filtered (_("Temporary breakpoint"));
5168 printf_filtered (_("Breakpoint"));
5169 printf_filtered (_(" %d"), b
->number
);
5172 case bp_hardware_breakpoint
:
5173 if (ui_out_is_mi_like_p (uiout
))
5178 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
5182 if (ui_out_is_mi_like_p (uiout
))
5187 printf_filtered (_("Tracepoint"));
5188 printf_filtered (_(" %d"), b
->number
);
5195 case bp_longjmp_resume
:
5196 case bp_step_resume
:
5198 case bp_watchpoint_scope
:
5199 case bp_shlib_event
:
5200 case bp_thread_event
:
5201 case bp_overlay_event
:
5202 case bp_longjmp_master
:
5208 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5212 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5216 if (opts
.addressprint
|| b
->source_file
== NULL
)
5218 printf_filtered (" at ");
5219 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
5222 printf_filtered (": file %s, line %d.",
5223 b
->source_file
, b
->line_number
);
5227 struct bp_location
*loc
= b
->loc
;
5229 for (; loc
; loc
= loc
->next
)
5231 printf_filtered (" (%d locations)", n
);
5236 if (ui_out_is_mi_like_p (uiout
))
5238 printf_filtered ("\n");
5242 static struct bp_location
*
5243 add_location_to_breakpoint (struct breakpoint
*b
,
5244 const struct symtab_and_line
*sal
)
5246 struct bp_location
*loc
, **tmp
;
5248 loc
= allocate_bp_location (b
);
5249 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5252 loc
->requested_address
= sal
->pc
;
5253 loc
->address
= adjust_breakpoint_address (loc
->requested_address
, b
->type
);
5254 loc
->section
= sal
->section
;
5256 set_breakpoint_location_function (loc
);
5261 /* Return 1 if LOC is pointing to a permanent breakpoint,
5262 return 0 otherwise. */
5265 bp_loc_is_permanent (struct bp_location
*loc
)
5269 const gdb_byte
*brk
;
5270 gdb_byte
*target_mem
;
5271 struct cleanup
*cleanup
;
5274 gdb_assert (loc
!= NULL
);
5276 addr
= loc
->address
;
5277 brk
= gdbarch_breakpoint_from_pc (current_gdbarch
, &addr
, &len
);
5279 /* Software breakpoints unsupported? */
5283 target_mem
= alloca (len
);
5285 /* Enable the automatic memory restoration from breakpoints while
5286 we read the memory. Otherwise we could say about our temporary
5287 breakpoints they are permanent. */
5288 cleanup
= make_show_memory_breakpoints_cleanup (0);
5290 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
5291 && memcmp (target_mem
, brk
, len
) == 0)
5294 do_cleanups (cleanup
);
5301 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5302 as textual description of the location, and COND_STRING
5303 as condition expression. */
5306 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5308 enum bptype type
, enum bpdisp disposition
,
5309 int thread
, int task
, int ignore_count
,
5310 struct breakpoint_ops
*ops
, int from_tty
, int enabled
)
5312 struct breakpoint
*b
= NULL
;
5315 if (type
== bp_hardware_breakpoint
)
5317 int i
= hw_breakpoint_used_count ();
5318 int target_resources_ok
=
5319 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
5321 if (target_resources_ok
== 0)
5322 error (_("No hardware breakpoint support in the target."));
5323 else if (target_resources_ok
< 0)
5324 error (_("Hardware breakpoints used exceeds limit."));
5327 for (i
= 0; i
< sals
.nelts
; ++i
)
5329 struct symtab_and_line sal
= sals
.sals
[i
];
5330 struct bp_location
*loc
;
5333 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5337 b
= set_raw_breakpoint (sal
, type
);
5338 set_breakpoint_count (breakpoint_count
+ 1);
5339 b
->number
= breakpoint_count
;
5343 b
->cond_string
= cond_string
;
5344 b
->ignore_count
= ignore_count
;
5345 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
5346 b
->disposition
= disposition
;
5352 loc
= add_location_to_breakpoint (b
, &sal
);
5355 if (bp_loc_is_permanent (loc
))
5356 make_breakpoint_permanent (b
);
5360 char *arg
= b
->cond_string
;
5361 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5363 error (_("Garbage %s follows condition"), arg
);
5368 b
->addr_string
= addr_string
;
5370 /* addr_string has to be used or breakpoint_re_set will delete
5372 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5378 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5379 elements to fill the void space. */
5381 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5383 int i
= index_to_remove
+1;
5384 int last_index
= sal
->nelts
-1;
5386 for (;i
<= last_index
; ++i
)
5387 sal
->sals
[i
-1] = sal
->sals
[i
];
5392 /* If appropriate, obtains all sals that correspond
5393 to the same file and line as SAL. This is done
5394 only if SAL does not have explicit PC and has
5395 line and file information. If we got just a single
5396 expanded sal, return the original.
5398 Otherwise, if SAL.explicit_line is not set, filter out
5399 all sals for which the name of enclosing function
5400 is different from SAL. This makes sure that if we have
5401 breakpoint originally set in template instantiation, say
5402 foo<int>(), we won't expand SAL to locations at the same
5403 line in all existing instantiations of 'foo'.
5406 static struct symtabs_and_lines
5407 expand_line_sal_maybe (struct symtab_and_line sal
)
5409 struct symtabs_and_lines expanded
;
5410 CORE_ADDR original_pc
= sal
.pc
;
5411 char *original_function
= NULL
;
5415 /* If we have explicit pc, don't expand.
5416 If we have no line number, we can't expand. */
5417 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5420 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5421 expanded
.sals
[0] = sal
;
5426 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5428 expanded
= expand_line_sal (sal
);
5429 if (expanded
.nelts
== 1)
5431 /* We had one sal, we got one sal. Without futher
5432 processing, just return the original sal. */
5433 xfree (expanded
.sals
);
5435 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5436 sal
.pc
= original_pc
;
5437 expanded
.sals
[0] = sal
;
5441 if (!sal
.explicit_line
)
5443 CORE_ADDR func_addr
, func_end
;
5444 for (i
= 0; i
< expanded
.nelts
; ++i
)
5446 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5447 char *this_function
;
5448 if (find_pc_partial_function (pc
, &this_function
,
5449 &func_addr
, &func_end
))
5452 && strcmp (this_function
, original_function
) != 0)
5454 remove_sal (&expanded
, i
);
5457 else if (func_addr
== pc
)
5459 /* We're at beginning of a function, and should
5461 struct symbol
*sym
= find_pc_function (pc
);
5463 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5466 /* Since find_pc_partial_function returned true,
5467 we should really always find the section here. */
5468 struct obj_section
*section
= find_pc_section (pc
);
5471 struct gdbarch
*gdbarch
5472 = get_objfile_arch (section
->objfile
);
5474 = gdbarch_skip_prologue (gdbarch
, pc
);
5483 for (i
= 0; i
< expanded
.nelts
; ++i
)
5485 /* If this SAL corresponds to a breakpoint inserted using a
5486 line number, then skip the function prologue if necessary. */
5487 skip_prologue_sal (&expanded
.sals
[i
]);
5492 if (expanded
.nelts
<= 1)
5494 /* This is un ugly workaround. If we get zero
5495 expanded sals then something is really wrong.
5496 Fix that by returnign the original sal. */
5497 xfree (expanded
.sals
);
5499 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5500 sal
.pc
= original_pc
;
5501 expanded
.sals
[0] = sal
;
5508 for (i
= 0; i
< expanded
.nelts
; ++i
)
5509 if (expanded
.sals
[i
].pc
== original_pc
)
5520 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5521 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5522 value. COND_STRING, if not NULL, specified the condition to be
5523 used for all breakpoints. Essentially the only case where
5524 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5525 function. In that case, it's still not possible to specify
5526 separate conditions for different overloaded functions, so
5527 we take just a single condition string.
5529 NOTE: If the function succeeds, the caller is expected to cleanup
5530 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5531 array contents). If the function fails (error() is called), the
5532 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5533 COND and SALS arrays and each of those arrays contents. */
5536 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5538 enum bptype type
, enum bpdisp disposition
,
5539 int thread
, int task
, int ignore_count
,
5540 struct breakpoint_ops
*ops
, int from_tty
,
5544 for (i
= 0; i
< sals
.nelts
; ++i
)
5546 struct symtabs_and_lines expanded
=
5547 expand_line_sal_maybe (sals
.sals
[i
]);
5549 create_breakpoint (expanded
, addr_string
[i
],
5550 cond_string
, type
, disposition
,
5551 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
5555 /* Parse ARG which is assumed to be a SAL specification possibly
5556 followed by conditionals. On return, SALS contains an array of SAL
5557 addresses found. ADDR_STRING contains a vector of (canonical)
5558 address strings. ARG points to the end of the SAL. */
5561 parse_breakpoint_sals (char **address
,
5562 struct symtabs_and_lines
*sals
,
5563 char ***addr_string
,
5566 char *addr_start
= *address
;
5567 *addr_string
= NULL
;
5568 /* If no arg given, or if first arg is 'if ', use the default
5570 if ((*address
) == NULL
5571 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5573 if (default_breakpoint_valid
)
5575 struct symtab_and_line sal
;
5576 init_sal (&sal
); /* initialize to zeroes */
5577 sals
->sals
= (struct symtab_and_line
*)
5578 xmalloc (sizeof (struct symtab_and_line
));
5579 sal
.pc
= default_breakpoint_address
;
5580 sal
.line
= default_breakpoint_line
;
5581 sal
.symtab
= default_breakpoint_symtab
;
5582 sal
.section
= find_pc_overlay (sal
.pc
);
5584 /* "break" without arguments is equivalent to "break *PC" where PC is
5585 the default_breakpoint_address. So make sure to set
5586 sal.explicit_pc to prevent GDB from trying to expand the list of
5587 sals to include all other instances with the same symtab and line.
5589 sal
.explicit_pc
= 1;
5591 sals
->sals
[0] = sal
;
5595 error (_("No default breakpoint address now."));
5599 /* Force almost all breakpoints to be in terms of the
5600 current_source_symtab (which is decode_line_1's default). This
5601 should produce the results we want almost all of the time while
5602 leaving default_breakpoint_* alone.
5603 ObjC: However, don't match an Objective-C method name which
5604 may have a '+' or '-' succeeded by a '[' */
5606 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5608 if (default_breakpoint_valid
5610 || ((strchr ("+-", (*address
)[0]) != NULL
)
5611 && ((*address
)[1] != '['))))
5612 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5613 default_breakpoint_line
, addr_string
,
5616 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5617 addr_string
, not_found_ptr
);
5619 /* For any SAL that didn't have a canonical string, fill one in. */
5620 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5621 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5622 if (addr_start
!= (*address
))
5625 for (i
= 0; i
< sals
->nelts
; i
++)
5627 /* Add the string if not present. */
5628 if ((*addr_string
)[i
] == NULL
)
5629 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5635 /* Convert each SAL into a real PC. Verify that the PC can be
5636 inserted as a breakpoint. If it can't throw an error. */
5639 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5643 for (i
= 0; i
< sals
->nelts
; i
++)
5644 resolve_sal_pc (&sals
->sals
[i
]);
5648 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5650 struct captured_parse_breakpoint_args
*args
= data
;
5652 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5653 args
->not_found_ptr
);
5656 /* Given TOK, a string specification of condition and thread, as
5657 accepted by the 'break' command, extract the condition
5658 string and thread number and set *COND_STRING and *THREAD.
5659 PC identifies the context at which the condition should be parsed.
5660 If no condition is found, *COND_STRING is set to NULL.
5661 If no thread is found, *THREAD is set to -1. */
5663 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5664 char **cond_string
, int *thread
, int *task
)
5666 *cond_string
= NULL
;
5672 char *cond_start
= NULL
;
5673 char *cond_end
= NULL
;
5674 while (*tok
== ' ' || *tok
== '\t')
5679 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5682 toklen
= end_tok
- tok
;
5684 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5686 struct expression
*expr
;
5688 tok
= cond_start
= end_tok
+ 1;
5689 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5692 *cond_string
= savestring (cond_start
,
5693 cond_end
- cond_start
);
5695 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5701 *thread
= strtol (tok
, &tok
, 0);
5703 error (_("Junk after thread keyword."));
5704 if (!valid_thread_id (*thread
))
5705 error (_("Unknown thread %d."), *thread
);
5707 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
5713 *task
= strtol (tok
, &tok
, 0);
5715 error (_("Junk after task keyword."));
5716 if (!valid_task_id (*task
))
5717 error (_("Unknown task %d\n"), *task
);
5720 error (_("Junk at end of arguments."));
5724 /* Set a breakpoint. This function is shared between
5725 CLI and MI functions for setting a breakpoint.
5726 This function has two major modes of operations,
5727 selected by the PARSE_CONDITION_AND_THREAD parameter.
5728 If non-zero, the function will parse arg, extracting
5729 breakpoint location, address and thread. Otherwise,
5730 ARG is just the location of breakpoint, with condition
5731 and thread specified by the COND_STRING and THREAD
5735 break_command_really (char *arg
, char *cond_string
, int thread
,
5736 int parse_condition_and_thread
,
5737 int tempflag
, int hardwareflag
, int traceflag
,
5739 enum auto_boolean pending_break_support
,
5740 struct breakpoint_ops
*ops
,
5744 struct gdb_exception e
;
5745 struct symtabs_and_lines sals
;
5746 struct symtab_and_line pending_sal
;
5749 char *addr_start
= arg
;
5751 struct cleanup
*old_chain
;
5752 struct cleanup
*bkpt_chain
= NULL
;
5753 struct captured_parse_breakpoint_args parse_args
;
5757 enum bptype type_wanted
;
5764 parse_args
.arg_p
= &arg
;
5765 parse_args
.sals_p
= &sals
;
5766 parse_args
.addr_string_p
= &addr_string
;
5767 parse_args
.not_found_ptr
= ¬_found
;
5769 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5770 &parse_args
, RETURN_MASK_ALL
);
5772 /* If caller is interested in rc value from parse, set value. */
5776 throw_exception (e
);
5780 case NOT_FOUND_ERROR
:
5782 /* If pending breakpoint support is turned off, throw
5785 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5786 throw_exception (e
);
5788 exception_print (gdb_stderr
, e
);
5790 /* If pending breakpoint support is auto query and the user
5791 selects no, then simply return the error code. */
5792 if (pending_break_support
== AUTO_BOOLEAN_AUTO
5793 && !nquery ("Make breakpoint pending on future shared library load? "))
5796 /* At this point, either the user was queried about setting
5797 a pending breakpoint and selected yes, or pending
5798 breakpoint behavior is on and thus a pending breakpoint
5799 is defaulted on behalf of the user. */
5800 copy_arg
= xstrdup (addr_start
);
5801 addr_string
= ©_arg
;
5803 sals
.sals
= &pending_sal
;
5808 throw_exception (e
);
5815 /* Create a chain of things that always need to be cleaned up. */
5816 old_chain
= make_cleanup (null_cleanup
, 0);
5820 /* Make sure that all storage allocated to SALS gets freed. */
5821 make_cleanup (xfree
, sals
.sals
);
5823 /* Cleanup the addr_string array but not its contents. */
5824 make_cleanup (xfree
, addr_string
);
5827 /* ----------------------------- SNIP -----------------------------
5828 Anything added to the cleanup chain beyond this point is assumed
5829 to be part of a breakpoint. If the breakpoint create succeeds
5830 then the memory is not reclaimed. */
5831 bkpt_chain
= make_cleanup (null_cleanup
, 0);
5833 /* Mark the contents of the addr_string for cleanup. These go on
5834 the bkpt_chain and only occur if the breakpoint create fails. */
5835 for (i
= 0; i
< sals
.nelts
; i
++)
5837 if (addr_string
[i
] != NULL
)
5838 make_cleanup (xfree
, addr_string
[i
]);
5841 /* Resolve all line numbers to PC's and verify that the addresses
5842 are ok for the target. */
5844 breakpoint_sals_to_pc (&sals
, addr_start
);
5846 type_wanted
= (traceflag
5848 : (hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
));
5850 /* Verify that condition can be parsed, before setting any
5851 breakpoints. Allocate a separate condition expression for each
5855 if (parse_condition_and_thread
)
5857 /* Here we only parse 'arg' to separate condition
5858 from thread number, so parsing in context of first
5859 sal is OK. When setting the breakpoint we'll
5860 re-parse it in context of each sal. */
5863 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
5866 make_cleanup (xfree
, cond_string
);
5870 /* Create a private copy of condition string. */
5873 cond_string
= xstrdup (cond_string
);
5874 make_cleanup (xfree
, cond_string
);
5877 create_breakpoints (sals
, addr_string
, cond_string
, type_wanted
,
5878 tempflag
? disp_del
: disp_donttouch
,
5879 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
5883 struct symtab_and_line sal
= {0};
5884 struct breakpoint
*b
;
5886 make_cleanup (xfree
, copy_arg
);
5888 b
= set_raw_breakpoint_without_location (type_wanted
);
5889 set_breakpoint_count (breakpoint_count
+ 1);
5890 b
->number
= breakpoint_count
;
5892 b
->addr_string
= addr_string
[0];
5893 b
->cond_string
= NULL
;
5894 b
->ignore_count
= ignore_count
;
5895 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5896 b
->condition_not_parsed
= 1;
5898 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
5904 warning (_("Multiple breakpoints were set.\n"
5905 "Use the \"delete\" command to delete unwanted breakpoints."));
5906 /* That's it. Discard the cleanups for data inserted into the
5908 discard_cleanups (bkpt_chain
);
5909 /* But cleanup everything else. */
5910 do_cleanups (old_chain
);
5912 /* error call may happen here - have BKPT_CHAIN already discarded. */
5913 update_global_location_list (1);
5916 /* Set a breakpoint.
5917 ARG is a string describing breakpoint address,
5918 condition, and thread.
5919 FLAG specifies if a breakpoint is hardware on,
5920 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5924 break_command_1 (char *arg
, int flag
, int from_tty
)
5926 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5927 int tempflag
= flag
& BP_TEMPFLAG
;
5929 break_command_really (arg
,
5930 NULL
, 0, 1 /* parse arg */,
5931 tempflag
, hardwareflag
, 0 /* traceflag */,
5932 0 /* Ignore count */,
5933 pending_break_support
,
5934 NULL
/* breakpoint_ops */,
5941 set_breakpoint (char *address
, char *condition
,
5942 int hardwareflag
, int tempflag
,
5943 int thread
, int ignore_count
,
5944 int pending
, int enabled
)
5946 break_command_really (address
, condition
, thread
,
5947 0 /* condition and thread are valid. */,
5948 tempflag
, hardwareflag
, 0 /* traceflag */,
5951 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5955 /* Adjust SAL to the first instruction past the function prologue.
5956 The end of the prologue is determined using the line table from
5957 the debugging information. explicit_pc and explicit_line are
5960 If SAL is already past the prologue, then do nothing. */
5963 skip_prologue_sal (struct symtab_and_line
*sal
)
5965 struct symbol
*sym
= find_pc_function (sal
->pc
);
5966 struct symtab_and_line start_sal
;
5971 start_sal
= find_function_start_sal (sym
, 1);
5972 if (sal
->pc
< start_sal
.pc
)
5974 start_sal
.explicit_line
= sal
->explicit_line
;
5975 start_sal
.explicit_pc
= sal
->explicit_pc
;
5980 /* Helper function for break_command_1 and disassemble_command. */
5983 resolve_sal_pc (struct symtab_and_line
*sal
)
5987 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5989 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5990 error (_("No line %d in file \"%s\"."),
5991 sal
->line
, sal
->symtab
->filename
);
5994 /* If this SAL corresponds to a breakpoint inserted using
5995 a line number, then skip the function prologue if necessary. */
5996 if (sal
->explicit_line
)
5998 /* Preserve the original line number. */
5999 int saved_line
= sal
->line
;
6000 skip_prologue_sal (sal
);
6001 sal
->line
= saved_line
;
6005 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
6007 struct blockvector
*bv
;
6011 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
6014 sym
= block_linkage_function (b
);
6017 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
6018 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
6022 /* It really is worthwhile to have the section, so we'll just
6023 have to look harder. This case can be executed if we have
6024 line numbers but no functions (as can happen in assembly
6027 struct minimal_symbol
*msym
;
6029 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
6031 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
6038 break_command (char *arg
, int from_tty
)
6040 break_command_1 (arg
, 0, from_tty
);
6044 tbreak_command (char *arg
, int from_tty
)
6046 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
6050 hbreak_command (char *arg
, int from_tty
)
6052 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
6056 thbreak_command (char *arg
, int from_tty
)
6058 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
6062 stop_command (char *arg
, int from_tty
)
6064 printf_filtered (_("Specify the type of breakpoint to set.\n\
6065 Usage: stop in <function | address>\n\
6066 stop at <line>\n"));
6070 stopin_command (char *arg
, int from_tty
)
6074 if (arg
== (char *) NULL
)
6076 else if (*arg
!= '*')
6081 /* look for a ':'. If this is a line number specification, then
6082 say it is bad, otherwise, it should be an address or
6083 function/method name */
6084 while (*argptr
&& !hasColon
)
6086 hasColon
= (*argptr
== ':');
6091 badInput
= (*argptr
!= ':'); /* Not a class::method */
6093 badInput
= isdigit (*arg
); /* a simple line number */
6097 printf_filtered (_("Usage: stop in <function | address>\n"));
6099 break_command_1 (arg
, 0, from_tty
);
6103 stopat_command (char *arg
, int from_tty
)
6107 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
6114 /* look for a ':'. If there is a '::' then get out, otherwise
6115 it is probably a line number. */
6116 while (*argptr
&& !hasColon
)
6118 hasColon
= (*argptr
== ':');
6123 badInput
= (*argptr
== ':'); /* we have class::method */
6125 badInput
= !isdigit (*arg
); /* not a line number */
6129 printf_filtered (_("Usage: stop at <line>\n"));
6131 break_command_1 (arg
, 0, from_tty
);
6134 /* accessflag: hw_write: watch write,
6135 hw_read: watch read,
6136 hw_access: watch access (read or write) */
6138 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
6140 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
6141 struct symtab_and_line sal
;
6142 struct expression
*exp
;
6143 struct block
*exp_valid_block
;
6144 struct value
*val
, *mark
;
6145 struct frame_info
*frame
;
6146 struct frame_info
*prev_frame
= NULL
;
6147 char *exp_start
= NULL
;
6148 char *exp_end
= NULL
;
6149 char *tok
, *id_tok_start
, *end_tok
;
6151 char *cond_start
= NULL
;
6152 char *cond_end
= NULL
;
6153 struct expression
*cond
= NULL
;
6154 int i
, other_type_used
, target_resources_ok
= 0;
6155 enum bptype bp_type
;
6159 init_sal (&sal
); /* initialize to zeroes */
6161 /* Make sure that we actually have parameters to parse. */
6162 if (arg
!= NULL
&& arg
[0] != '\0')
6164 toklen
= strlen (arg
); /* Size of argument list. */
6166 /* Points tok to the end of the argument list. */
6167 tok
= arg
+ toklen
- 1;
6169 /* Go backwards in the parameters list. Skip the last parameter.
6170 If we're expecting a 'thread <thread_num>' parameter, this should
6171 be the thread identifier. */
6172 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6174 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6177 /* Points end_tok to the beginning of the last token. */
6178 id_tok_start
= tok
+ 1;
6180 /* Go backwards in the parameters list. Skip one more parameter.
6181 If we're expecting a 'thread <thread_num>' parameter, we should
6182 reach a "thread" token. */
6183 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6188 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6191 /* Move the pointer forward to skip the whitespace and
6192 calculate the length of the token. */
6194 toklen
= end_tok
- tok
;
6196 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
6198 /* At this point we've found a "thread" token, which means
6199 the user is trying to set a watchpoint that triggers
6200 only in a specific thread. */
6203 /* Extract the thread ID from the next token. */
6204 thread
= strtol (id_tok_start
, &endp
, 0);
6206 /* Check if the user provided a valid numeric value for the
6208 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
6209 error (_("Invalid thread ID specification %s."), id_tok_start
);
6211 /* Check if the thread actually exists. */
6212 if (!valid_thread_id (thread
))
6213 error (_("Unknown thread %d."), thread
);
6215 /* Truncate the string and get rid of the thread <thread_num>
6216 parameter before the parameter list is parsed by the
6217 evaluate_expression() function. */
6222 /* Parse the rest of the arguments. */
6223 innermost_block
= NULL
;
6225 exp
= parse_exp_1 (&arg
, 0, 0);
6227 /* Remove trailing whitespace from the expression before saving it.
6228 This makes the eventual display of the expression string a bit
6230 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
6233 exp_valid_block
= innermost_block
;
6234 mark
= value_mark ();
6235 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
6237 release_value (val
);
6240 while (*tok
== ' ' || *tok
== '\t')
6244 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
6247 toklen
= end_tok
- tok
;
6248 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
6250 tok
= cond_start
= end_tok
+ 1;
6251 cond
= parse_exp_1 (&tok
, 0, 0);
6255 error (_("Junk at end of command."));
6257 if (accessflag
== hw_read
)
6258 bp_type
= bp_read_watchpoint
;
6259 else if (accessflag
== hw_access
)
6260 bp_type
= bp_access_watchpoint
;
6262 bp_type
= bp_hardware_watchpoint
;
6264 mem_cnt
= can_use_hardware_watchpoint (val
);
6265 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
6266 error (_("Expression cannot be implemented with read/access watchpoint."));
6269 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
6270 target_resources_ok
=
6271 target_can_use_hardware_watchpoint (bp_type
, i
+ mem_cnt
,
6273 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
6274 error (_("Target does not support this type of hardware watchpoint."));
6276 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
6277 error (_("Target can only support one kind of HW watchpoint at a time."));
6280 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
6281 watchpoint could not be set. */
6282 if (!mem_cnt
|| target_resources_ok
<= 0)
6283 bp_type
= bp_watchpoint
;
6285 frame
= block_innermost_frame (exp_valid_block
);
6287 prev_frame
= get_prev_frame (frame
);
6291 /* If the expression is "local", then set up a "watchpoint scope"
6292 breakpoint at the point where we've left the scope of the watchpoint
6293 expression. Create the scope breakpoint before the watchpoint, so
6294 that we will encounter it first in bpstat_stop_status. */
6295 if (innermost_block
&& prev_frame
)
6297 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
6298 bp_watchpoint_scope
);
6300 scope_breakpoint
->enable_state
= bp_enabled
;
6302 /* Automatically delete the breakpoint when it hits. */
6303 scope_breakpoint
->disposition
= disp_del
;
6305 /* Only break in the proper frame (help with recursion). */
6306 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
6308 /* Set the address at which we will stop. */
6309 scope_breakpoint
->loc
->requested_address
6310 = get_frame_pc (prev_frame
);
6311 scope_breakpoint
->loc
->address
6312 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
6313 scope_breakpoint
->type
);
6316 /* Now set up the breakpoint. */
6317 b
= set_raw_breakpoint (sal
, bp_type
);
6318 set_breakpoint_count (breakpoint_count
+ 1);
6319 b
->number
= breakpoint_count
;
6321 b
->disposition
= disp_donttouch
;
6323 b
->exp_valid_block
= exp_valid_block
;
6324 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
6327 b
->loc
->cond
= cond
;
6329 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
6334 b
->watchpoint_frame
= get_frame_id (frame
);
6336 b
->watchpoint_frame
= null_frame_id
;
6338 if (scope_breakpoint
!= NULL
)
6340 /* The scope breakpoint is related to the watchpoint. We will
6341 need to act on them together. */
6342 b
->related_breakpoint
= scope_breakpoint
;
6343 scope_breakpoint
->related_breakpoint
= b
;
6346 value_free_to_mark (mark
);
6348 update_global_location_list (1);
6351 /* Return count of locations need to be watched and can be handled
6352 in hardware. If the watchpoint can not be handled
6353 in hardware return zero. */
6356 can_use_hardware_watchpoint (struct value
*v
)
6358 int found_memory_cnt
= 0;
6359 struct value
*head
= v
;
6361 /* Did the user specifically forbid us to use hardware watchpoints? */
6362 if (!can_use_hw_watchpoints
)
6365 /* Make sure that the value of the expression depends only upon
6366 memory contents, and values computed from them within GDB. If we
6367 find any register references or function calls, we can't use a
6368 hardware watchpoint.
6370 The idea here is that evaluating an expression generates a series
6371 of values, one holding the value of every subexpression. (The
6372 expression a*b+c has five subexpressions: a, b, a*b, c, and
6373 a*b+c.) GDB's values hold almost enough information to establish
6374 the criteria given above --- they identify memory lvalues,
6375 register lvalues, computed values, etcetera. So we can evaluate
6376 the expression, and then scan the chain of values that leaves
6377 behind to decide whether we can detect any possible change to the
6378 expression's final value using only hardware watchpoints.
6380 However, I don't think that the values returned by inferior
6381 function calls are special in any way. So this function may not
6382 notice that an expression involving an inferior function call
6383 can't be watched with hardware watchpoints. FIXME. */
6384 for (; v
; v
= value_next (v
))
6386 if (VALUE_LVAL (v
) == lval_memory
)
6389 /* A lazy memory lvalue is one that GDB never needed to fetch;
6390 we either just used its address (e.g., `a' in `a.b') or
6391 we never needed it at all (e.g., `a' in `a,b'). */
6395 /* Ahh, memory we actually used! Check if we can cover
6396 it with hardware watchpoints. */
6397 struct type
*vtype
= check_typedef (value_type (v
));
6399 /* We only watch structs and arrays if user asked for it
6400 explicitly, never if they just happen to appear in a
6401 middle of some value chain. */
6403 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6404 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6406 CORE_ADDR vaddr
= value_address (v
);
6407 int len
= TYPE_LENGTH (value_type (v
));
6409 if (!target_region_ok_for_hw_watchpoint (vaddr
, len
))
6416 else if (VALUE_LVAL (v
) != not_lval
6417 && deprecated_value_modifiable (v
) == 0)
6418 return 0; /* ??? What does this represent? */
6419 else if (VALUE_LVAL (v
) == lval_register
)
6420 return 0; /* cannot watch a register with a HW watchpoint */
6423 /* The expression itself looks suitable for using a hardware
6424 watchpoint, but give the target machine a chance to reject it. */
6425 return found_memory_cnt
;
6429 watch_command_wrapper (char *arg
, int from_tty
)
6431 watch_command (arg
, from_tty
);
6435 watch_command (char *arg
, int from_tty
)
6437 watch_command_1 (arg
, hw_write
, from_tty
);
6441 rwatch_command_wrapper (char *arg
, int from_tty
)
6443 rwatch_command (arg
, from_tty
);
6447 rwatch_command (char *arg
, int from_tty
)
6449 watch_command_1 (arg
, hw_read
, from_tty
);
6453 awatch_command_wrapper (char *arg
, int from_tty
)
6455 awatch_command (arg
, from_tty
);
6459 awatch_command (char *arg
, int from_tty
)
6461 watch_command_1 (arg
, hw_access
, from_tty
);
6465 /* Helper routines for the until_command routine in infcmd.c. Here
6466 because it uses the mechanisms of breakpoints. */
6468 struct until_break_command_continuation_args
6470 struct breakpoint
*breakpoint
;
6471 struct breakpoint
*breakpoint2
;
6474 /* This function is called by fetch_inferior_event via the
6475 cmd_continuation pointer, to complete the until command. It takes
6476 care of cleaning up the temporary breakpoints set up by the until
6479 until_break_command_continuation (void *arg
)
6481 struct until_break_command_continuation_args
*a
= arg
;
6483 delete_breakpoint (a
->breakpoint
);
6485 delete_breakpoint (a
->breakpoint2
);
6489 until_break_command (char *arg
, int from_tty
, int anywhere
)
6491 struct symtabs_and_lines sals
;
6492 struct symtab_and_line sal
;
6493 struct frame_info
*frame
= get_selected_frame (NULL
);
6494 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6495 struct breakpoint
*breakpoint
;
6496 struct breakpoint
*breakpoint2
= NULL
;
6497 struct cleanup
*old_chain
;
6499 clear_proceed_status ();
6501 /* Set a breakpoint where the user wants it and at return from
6504 if (default_breakpoint_valid
)
6505 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6506 default_breakpoint_line
, (char ***) NULL
, NULL
);
6508 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6509 0, (char ***) NULL
, NULL
);
6511 if (sals
.nelts
!= 1)
6512 error (_("Couldn't get information on specified line."));
6515 xfree (sals
.sals
); /* malloc'd, so freed */
6518 error (_("Junk at end of arguments."));
6520 resolve_sal_pc (&sal
);
6523 /* If the user told us to continue until a specified location,
6524 we don't specify a frame at which we need to stop. */
6525 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6527 /* Otherwise, specify the current frame, because we want to stop only
6528 at the very same frame. */
6529 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6532 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6534 /* Keep within the current frame, or in frames called by the current
6538 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6539 sal
.pc
= get_frame_pc (prev_frame
);
6540 breakpoint2
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6542 make_cleanup_delete_breakpoint (breakpoint2
);
6545 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6547 /* If we are running asynchronously, and proceed call above has actually
6548 managed to start the target, arrange for breakpoints to be
6549 deleted when the target stops. Otherwise, we're already stopped and
6550 delete breakpoints via cleanup chain. */
6552 if (target_can_async_p () && is_running (inferior_ptid
))
6554 struct until_break_command_continuation_args
*args
;
6555 args
= xmalloc (sizeof (*args
));
6557 args
->breakpoint
= breakpoint
;
6558 args
->breakpoint2
= breakpoint2
;
6560 discard_cleanups (old_chain
);
6561 add_continuation (inferior_thread (),
6562 until_break_command_continuation
, args
,
6566 do_cleanups (old_chain
);
6570 ep_skip_leading_whitespace (char **s
)
6572 if ((s
== NULL
) || (*s
== NULL
))
6574 while (isspace (**s
))
6578 /* This function attempts to parse an optional "if <cond>" clause
6579 from the arg string. If one is not found, it returns NULL.
6581 Else, it returns a pointer to the condition string. (It does not
6582 attempt to evaluate the string against a particular block.) And,
6583 it updates arg to point to the first character following the parsed
6584 if clause in the arg string. */
6587 ep_parse_optional_if_clause (char **arg
)
6591 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6594 /* Skip the "if" keyword. */
6597 /* Skip any extra leading whitespace, and record the start of the
6598 condition string. */
6599 ep_skip_leading_whitespace (arg
);
6602 /* Assume that the condition occupies the remainder of the arg string. */
6603 (*arg
) += strlen (cond_string
);
6608 /* This function attempts to parse an optional filename from the arg
6609 string. If one is not found, it returns NULL.
6611 Else, it returns a pointer to the parsed filename. (This function
6612 makes no attempt to verify that a file of that name exists, or is
6613 accessible.) And, it updates arg to point to the first character
6614 following the parsed filename in the arg string.
6616 Note that clients needing to preserve the returned filename for
6617 future access should copy it to their own buffers. */
6619 ep_parse_optional_filename (char **arg
)
6621 static char filename
[1024];
6626 if ((*arg_p
== '\0') || isspace (*arg_p
))
6644 /* Commands to deal with catching events, such as signals, exceptions,
6645 process start/exit, etc. */
6649 catch_fork_temporary
, catch_vfork_temporary
,
6650 catch_fork_permanent
, catch_vfork_permanent
6655 catch_fork_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6657 char *cond_string
= NULL
;
6658 catch_fork_kind fork_kind
;
6661 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
6662 tempflag
= (fork_kind
== catch_fork_temporary
6663 || fork_kind
== catch_vfork_temporary
);
6667 ep_skip_leading_whitespace (&arg
);
6669 /* The allowed syntax is:
6671 catch [v]fork if <cond>
6673 First, check if there's an if clause. */
6674 cond_string
= ep_parse_optional_if_clause (&arg
);
6676 if ((*arg
!= '\0') && !isspace (*arg
))
6677 error (_("Junk at end of arguments."));
6679 /* If this target supports it, create a fork or vfork catchpoint
6680 and enable reporting of such events. */
6683 case catch_fork_temporary
:
6684 case catch_fork_permanent
:
6685 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6686 &catch_fork_breakpoint_ops
);
6688 case catch_vfork_temporary
:
6689 case catch_vfork_permanent
:
6690 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6691 &catch_vfork_breakpoint_ops
);
6694 error (_("unsupported or unknown fork kind; cannot catch it"));
6700 catch_exec_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6703 char *cond_string
= NULL
;
6705 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6709 ep_skip_leading_whitespace (&arg
);
6711 /* The allowed syntax is:
6713 catch exec if <cond>
6715 First, check if there's an if clause. */
6716 cond_string
= ep_parse_optional_if_clause (&arg
);
6718 if ((*arg
!= '\0') && !isspace (*arg
))
6719 error (_("Junk at end of arguments."));
6721 /* If this target supports it, create an exec catchpoint
6722 and enable reporting of such events. */
6723 create_catchpoint (tempflag
, cond_string
, &catch_exec_breakpoint_ops
);
6726 static enum print_stop_action
6727 print_exception_catchpoint (struct breakpoint
*b
)
6729 int bp_temp
, bp_throw
;
6731 annotate_catchpoint (b
->number
);
6733 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6734 if (b
->loc
->address
!= b
->loc
->requested_address
)
6735 breakpoint_adjustment_warning (b
->loc
->requested_address
,
6738 bp_temp
= b
->disposition
== disp_del
;
6740 bp_temp
? "Temporary catchpoint "
6742 if (!ui_out_is_mi_like_p (uiout
))
6743 ui_out_field_int (uiout
, "bkptno", b
->number
);
6745 bp_throw
? " (exception thrown), "
6746 : " (exception caught), ");
6747 if (ui_out_is_mi_like_p (uiout
))
6749 ui_out_field_string (uiout
, "reason",
6750 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
6751 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6752 ui_out_field_int (uiout
, "bkptno", b
->number
);
6754 return PRINT_SRC_AND_LOC
;
6758 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6760 struct value_print_options opts
;
6761 get_user_print_options (&opts
);
6762 if (opts
.addressprint
)
6765 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
6766 ui_out_field_string (uiout
, "addr", "<PENDING>");
6768 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6772 *last_addr
= b
->loc
->address
;
6773 if (strstr (b
->addr_string
, "throw") != NULL
)
6774 ui_out_field_string (uiout
, "what", "exception throw");
6776 ui_out_field_string (uiout
, "what", "exception catch");
6780 print_mention_exception_catchpoint (struct breakpoint
*b
)
6785 bp_temp
= b
->disposition
== disp_del
;
6786 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6787 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
6788 : _("Catchpoint "));
6789 ui_out_field_int (uiout
, "bkptno", b
->number
);
6790 ui_out_text (uiout
, bp_throw
? _(" (throw)")
6794 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6797 NULL
, /* breakpoint_hit */
6798 print_exception_catchpoint
,
6799 print_one_exception_catchpoint
,
6800 print_mention_exception_catchpoint
6804 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6805 enum exception_event_kind ex_event
, int from_tty
)
6807 char *trigger_func_name
;
6809 if (ex_event
== EX_EVENT_CATCH
)
6810 trigger_func_name
= "__cxa_begin_catch";
6812 trigger_func_name
= "__cxa_throw";
6814 break_command_really (trigger_func_name
, cond_string
, -1,
6815 0 /* condition and thread are valid. */,
6818 AUTO_BOOLEAN_TRUE
/* pending */,
6819 &gnu_v3_exception_catchpoint_ops
, from_tty
,
6825 /* Deal with "catch catch" and "catch throw" commands */
6828 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6829 int tempflag
, int from_tty
)
6831 char *cond_string
= NULL
;
6832 struct symtab_and_line
*sal
= NULL
;
6836 ep_skip_leading_whitespace (&arg
);
6838 cond_string
= ep_parse_optional_if_clause (&arg
);
6840 if ((*arg
!= '\0') && !isspace (*arg
))
6841 error (_("Junk at end of arguments."));
6843 if (ex_event
!= EX_EVENT_THROW
6844 && ex_event
!= EX_EVENT_CATCH
)
6845 error (_("Unsupported or unknown exception event; cannot catch it"));
6847 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6850 warning (_("Unsupported with this platform/compiler combination."));
6853 /* Implementation of "catch catch" command. */
6856 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6858 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6859 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
6862 /* Implementation of "catch throw" command. */
6865 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6867 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6868 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
6871 /* Create a breakpoint struct for Ada exception catchpoints. */
6874 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6878 struct expression
*cond
,
6879 struct breakpoint_ops
*ops
,
6883 struct breakpoint
*b
;
6887 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6888 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6889 version for exception catchpoints, because two catchpoints
6890 used for different exception names will use the same address.
6891 In this case, a "breakpoint ... also set at..." warning is
6892 unproductive. Besides. the warning phrasing is also a bit
6893 inapropriate, we should use the word catchpoint, and tell
6894 the user what type of catchpoint it is. The above is good
6895 enough for now, though. */
6898 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6899 set_breakpoint_count (breakpoint_count
+ 1);
6901 b
->enable_state
= bp_enabled
;
6902 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6903 b
->number
= breakpoint_count
;
6904 b
->ignore_count
= 0;
6905 b
->loc
->cond
= cond
;
6906 b
->addr_string
= addr_string
;
6907 b
->language
= language_ada
;
6908 b
->cond_string
= cond_string
;
6909 b
->exp_string
= exp_string
;
6914 update_global_location_list (1);
6917 /* Implement the "catch exception" command. */
6920 catch_ada_exception_command (char *arg
, int from_tty
,
6921 struct cmd_list_element
*command
)
6924 struct symtab_and_line sal
;
6926 char *addr_string
= NULL
;
6927 char *exp_string
= NULL
;
6928 char *cond_string
= NULL
;
6929 struct expression
*cond
= NULL
;
6930 struct breakpoint_ops
*ops
= NULL
;
6932 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6936 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6937 &cond_string
, &cond
, &ops
);
6938 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6939 cond_string
, cond
, ops
, tempflag
,
6943 /* Implement the "catch assert" command. */
6946 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6949 struct symtab_and_line sal
;
6950 char *addr_string
= NULL
;
6951 struct breakpoint_ops
*ops
= NULL
;
6953 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6957 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6958 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6959 tempflag
, from_tty
);
6963 catch_command (char *arg
, int from_tty
)
6965 error (_("Catch requires an event name."));
6970 tcatch_command (char *arg
, int from_tty
)
6972 error (_("Catch requires an event name."));
6975 /* Delete breakpoints by address or line. */
6978 clear_command (char *arg
, int from_tty
)
6980 struct breakpoint
*b
;
6981 VEC(breakpoint_p
) *found
= 0;
6984 struct symtabs_and_lines sals
;
6985 struct symtab_and_line sal
;
6990 sals
= decode_line_spec (arg
, 1);
6995 sals
.sals
= (struct symtab_and_line
*)
6996 xmalloc (sizeof (struct symtab_and_line
));
6997 make_cleanup (xfree
, sals
.sals
);
6998 init_sal (&sal
); /* initialize to zeroes */
6999 sal
.line
= default_breakpoint_line
;
7000 sal
.symtab
= default_breakpoint_symtab
;
7001 sal
.pc
= default_breakpoint_address
;
7002 if (sal
.symtab
== 0)
7003 error (_("No source file specified."));
7011 /* We don't call resolve_sal_pc here. That's not
7012 as bad as it seems, because all existing breakpoints
7013 typically have both file/line and pc set. So, if
7014 clear is given file/line, we can match this to existing
7015 breakpoint without obtaining pc at all.
7017 We only support clearing given the address explicitly
7018 present in breakpoint table. Say, we've set breakpoint
7019 at file:line. There were several PC values for that file:line,
7020 due to optimization, all in one block.
7021 We've picked one PC value. If "clear" is issued with another
7022 PC corresponding to the same file:line, the breakpoint won't
7023 be cleared. We probably can still clear the breakpoint, but
7024 since the other PC value is never presented to user, user
7025 can only find it by guessing, and it does not seem important
7028 /* For each line spec given, delete bps which correspond
7029 to it. Do it in two passes, solely to preserve the current
7030 behavior that from_tty is forced true if we delete more than
7034 for (i
= 0; i
< sals
.nelts
; i
++)
7036 /* If exact pc given, clear bpts at that pc.
7037 If line given (pc == 0), clear all bpts on specified line.
7038 If defaulting, clear all bpts on default line
7041 defaulting sal.pc != 0 tests to do
7046 1 0 <can't happen> */
7050 /* Find all matching breakpoints and add them to
7055 /* Are we going to delete b? */
7056 if (b
->type
!= bp_none
7057 && b
->type
!= bp_watchpoint
7058 && b
->type
!= bp_hardware_watchpoint
7059 && b
->type
!= bp_read_watchpoint
7060 && b
->type
!= bp_access_watchpoint
)
7062 struct bp_location
*loc
= b
->loc
;
7063 for (; loc
; loc
= loc
->next
)
7065 int pc_match
= sal
.pc
7066 && (loc
->address
== sal
.pc
)
7067 && (!section_is_overlay (loc
->section
)
7068 || loc
->section
== sal
.section
);
7069 int line_match
= ((default_match
|| (0 == sal
.pc
))
7070 && b
->source_file
!= NULL
7071 && sal
.symtab
!= NULL
7072 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
7073 && b
->line_number
== sal
.line
);
7074 if (pc_match
|| line_match
)
7083 VEC_safe_push(breakpoint_p
, found
, b
);
7086 /* Now go thru the 'found' chain and delete them. */
7087 if (VEC_empty(breakpoint_p
, found
))
7090 error (_("No breakpoint at %s."), arg
);
7092 error (_("No breakpoint at this line."));
7095 if (VEC_length(breakpoint_p
, found
) > 1)
7096 from_tty
= 1; /* Always report if deleted more than one */
7099 if (VEC_length(breakpoint_p
, found
) == 1)
7100 printf_unfiltered (_("Deleted breakpoint "));
7102 printf_unfiltered (_("Deleted breakpoints "));
7104 breakpoints_changed ();
7106 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
7109 printf_unfiltered ("%d ", b
->number
);
7110 delete_breakpoint (b
);
7113 putchar_unfiltered ('\n');
7116 /* Delete breakpoint in BS if they are `delete' breakpoints and
7117 all breakpoints that are marked for deletion, whether hit or not.
7118 This is called after any breakpoint is hit, or after errors. */
7121 breakpoint_auto_delete (bpstat bs
)
7123 struct breakpoint
*b
, *temp
;
7125 for (; bs
; bs
= bs
->next
)
7126 if (bs
->breakpoint_at
7127 && bs
->breakpoint_at
->owner
7128 && bs
->breakpoint_at
->owner
->disposition
== disp_del
7130 delete_breakpoint (bs
->breakpoint_at
->owner
);
7132 ALL_BREAKPOINTS_SAFE (b
, temp
)
7134 if (b
->disposition
== disp_del_at_next_stop
)
7135 delete_breakpoint (b
);
7139 /* A cleanup function which destroys a vector. */
7142 do_vec_free (void *p
)
7144 VEC(bp_location_p
) **vec
= p
;
7146 VEC_free (bp_location_p
, *vec
);
7149 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
7150 into the inferior, only remove already-inserted locations that no
7151 longer should be inserted. Functions that delete a breakpoint or
7152 breakpoints should pass false, so that deleting a breakpoint
7153 doesn't have the side effect of inserting the locations of other
7154 breakpoints that are marked not-inserted, but should_be_inserted
7155 returns true on them.
7157 This behaviour is useful is situations close to tear-down -- e.g.,
7158 after an exec, while the target still has execution, but breakpoint
7159 shadows of the previous executable image should *NOT* be restored
7160 to the new image; or before detaching, where the target still has
7161 execution and wants to delete breakpoints from GDB's lists, and all
7162 breakpoints had already been removed from the inferior. */
7165 update_global_location_list (int should_insert
)
7167 struct breakpoint
*b
;
7168 struct bp_location
**next
= &bp_location_chain
;
7169 struct bp_location
*loc
;
7170 struct bp_location
*loc2
;
7171 VEC(bp_location_p
) *old_locations
= NULL
;
7174 struct cleanup
*cleanups
;
7176 cleanups
= make_cleanup (do_vec_free
, &old_locations
);
7177 /* Store old locations for future reference. */
7178 for (loc
= bp_location_chain
; loc
; loc
= loc
->global_next
)
7179 VEC_safe_push (bp_location_p
, old_locations
, loc
);
7181 bp_location_chain
= NULL
;
7184 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
7187 next
= &(loc
->global_next
);
7192 /* Identify bp_location instances that are no longer present in the new
7193 list, and therefore should be freed. Note that it's not necessary that
7194 those locations should be removed from inferior -- if there's another
7195 location at the same address (previously marked as duplicate),
7196 we don't need to remove/insert the location. */
7197 for (ix
= 0; VEC_iterate(bp_location_p
, old_locations
, ix
, loc
); ++ix
)
7199 /* Tells if 'loc' is found amoung the new locations. If not, we
7201 int found_object
= 0;
7202 /* Tells if the location should remain inserted in the target. */
7203 int keep_in_target
= 0;
7205 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7212 /* If this location is no longer present, and inserted, look if there's
7213 maybe a new location at the same address. If so, mark that one
7214 inserted, and don't remove this one. This is needed so that we
7215 don't have a time window where a breakpoint at certain location is not
7220 /* If the location is inserted now, we might have to remove it. */
7222 if (found_object
&& should_be_inserted (loc
))
7224 /* The location is still present in the location list, and still
7225 should be inserted. Don't do anything. */
7230 /* The location is either no longer present, or got disabled.
7231 See if there's another location at the same address, in which
7232 case we don't need to remove this one from the target. */
7233 if (breakpoint_address_is_meaningful (loc
->owner
))
7234 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
7236 /* For the sake of should_insert_location. The
7237 call to check_duplicates will fix up this later. */
7238 loc2
->duplicate
= 0;
7239 if (should_be_inserted (loc2
)
7240 && loc2
!= loc
&& loc2
->address
== loc
->address
)
7243 loc2
->target_info
= loc
->target_info
;
7250 if (!keep_in_target
)
7252 if (remove_breakpoint (loc
, mark_uninserted
))
7254 /* This is just about all we can do. We could keep this
7255 location on the global list, and try to remove it next
7256 time, but there's no particular reason why we will
7259 Note that at this point, loc->owner is still valid,
7260 as delete_breakpoint frees the breakpoint only
7261 after calling us. */
7262 printf_filtered (_("warning: Error removing breakpoint %d\n"),
7263 loc
->owner
->number
);
7271 if (removed
&& non_stop
)
7273 /* This location was removed from the targets. In non-stop mode,
7274 a race condition is possible where we've removed a breakpoint,
7275 but stop events for that breakpoint are already queued and will
7276 arrive later. To suppress spurious SIGTRAPs reported to user,
7277 we keep this breakpoint location for a bit, and will retire it
7278 after we see 3 * thread_count events.
7279 The theory here is that reporting of events should,
7280 "on the average", be fair, so after that many event we'll see
7281 events from all threads that have anything of interest, and no
7282 longer need to keep this breakpoint. This is just a
7283 heuristic, but if it's wrong, we'll report unexpected SIGTRAP,
7284 which is usability issue, but not a correctness problem. */
7285 loc
->events_till_retirement
= 3 * (thread_count () + 1);
7288 VEC_safe_push (bp_location_p
, moribund_locations
, loc
);
7291 free_bp_location (loc
);
7297 check_duplicates (b
);
7300 if (breakpoints_always_inserted_mode () && should_insert
7301 && (have_live_inferiors ()
7302 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
7303 insert_breakpoint_locations ();
7305 do_cleanups (cleanups
);
7309 breakpoint_retire_moribund (void)
7311 struct bp_location
*loc
;
7314 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
7315 if (--(loc
->events_till_retirement
) == 0)
7317 free_bp_location (loc
);
7318 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
7324 update_global_location_list_nothrow (int inserting
)
7326 struct gdb_exception e
;
7327 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7328 update_global_location_list (inserting
);
7331 /* Clear BPT from a BPS. */
7333 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
7336 for (bs
= bps
; bs
; bs
= bs
->next
)
7337 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7339 bs
->breakpoint_at
= NULL
;
7341 /* bs->commands will be freed later. */
7345 /* Callback for iterate_over_threads. */
7347 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
7349 struct breakpoint
*bpt
= data
;
7350 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
7354 /* Delete a breakpoint and clean up all traces of it in the data
7358 delete_breakpoint (struct breakpoint
*bpt
)
7360 struct breakpoint
*b
;
7361 struct bp_location
*loc
, *next
;
7363 gdb_assert (bpt
!= NULL
);
7365 /* Has this bp already been deleted? This can happen because multiple
7366 lists can hold pointers to bp's. bpstat lists are especial culprits.
7368 One example of this happening is a watchpoint's scope bp. When the
7369 scope bp triggers, we notice that the watchpoint is out of scope, and
7370 delete it. We also delete its scope bp. But the scope bp is marked
7371 "auto-deleting", and is already on a bpstat. That bpstat is then
7372 checked for auto-deleting bp's, which are deleted.
7374 A real solution to this problem might involve reference counts in bp's,
7375 and/or giving them pointers back to their referencing bpstat's, and
7376 teaching delete_breakpoint to only free a bp's storage when no more
7377 references were extent. A cheaper bandaid was chosen. */
7378 if (bpt
->type
== bp_none
)
7381 observer_notify_breakpoint_deleted (bpt
->number
);
7383 if (breakpoint_chain
== bpt
)
7384 breakpoint_chain
= bpt
->next
;
7389 b
->next
= bpt
->next
;
7393 free_command_lines (&bpt
->commands
);
7394 if (bpt
->cond_string
!= NULL
)
7395 xfree (bpt
->cond_string
);
7396 if (bpt
->addr_string
!= NULL
)
7397 xfree (bpt
->addr_string
);
7398 if (bpt
->exp
!= NULL
)
7400 if (bpt
->exp_string
!= NULL
)
7401 xfree (bpt
->exp_string
);
7402 if (bpt
->val
!= NULL
)
7403 value_free (bpt
->val
);
7404 if (bpt
->source_file
!= NULL
)
7405 xfree (bpt
->source_file
);
7406 if (bpt
->exec_pathname
!= NULL
)
7407 xfree (bpt
->exec_pathname
);
7409 /* Be sure no bpstat's are pointing at it after it's been freed. */
7410 /* FIXME, how can we find all bpstat's?
7411 We just check stop_bpstat for now. Note that we cannot just
7412 remove bpstats pointing at bpt from the stop_bpstat list
7413 entirely, as breakpoint commands are associated with the bpstat;
7414 if we remove it here, then the later call to
7415 bpstat_do_actions (&stop_bpstat);
7416 in event-top.c won't do anything, and temporary breakpoints
7417 with commands won't work. */
7419 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
7421 /* Now that breakpoint is removed from breakpoint
7422 list, update the global location list. This
7423 will remove locations that used to belong to
7424 this breakpoint. Do this before freeing
7425 the breakpoint itself, since remove_breakpoint
7426 looks at location's owner. It might be better
7427 design to have location completely self-contained,
7428 but it's not the case now. */
7429 update_global_location_list (0);
7432 /* On the chance that someone will soon try again to delete this same
7433 bp, we mark it as deleted before freeing its storage. */
7434 bpt
->type
= bp_none
;
7440 do_delete_breakpoint_cleanup (void *b
)
7442 delete_breakpoint (b
);
7446 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7448 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7452 delete_command (char *arg
, int from_tty
)
7454 struct breakpoint
*b
, *temp
;
7460 int breaks_to_delete
= 0;
7462 /* Delete all breakpoints if no argument.
7463 Do not delete internal or call-dummy breakpoints, these
7464 have to be deleted with an explicit breakpoint number argument. */
7467 if (b
->type
!= bp_call_dummy
7468 && b
->type
!= bp_shlib_event
7469 && b
->type
!= bp_thread_event
7470 && b
->type
!= bp_overlay_event
7471 && b
->type
!= bp_longjmp_master
7474 breaks_to_delete
= 1;
7479 /* Ask user only if there are some breakpoints to delete. */
7481 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7483 ALL_BREAKPOINTS_SAFE (b
, temp
)
7485 if (b
->type
!= bp_call_dummy
7486 && b
->type
!= bp_shlib_event
7487 && b
->type
!= bp_thread_event
7488 && b
->type
!= bp_overlay_event
7489 && b
->type
!= bp_longjmp_master
7491 delete_breakpoint (b
);
7496 map_breakpoint_numbers (arg
, delete_breakpoint
);
7500 all_locations_are_pending (struct bp_location
*loc
)
7502 for (; loc
; loc
= loc
->next
)
7503 if (!loc
->shlib_disabled
)
7508 /* Subroutine of update_breakpoint_locations to simplify it.
7509 Return non-zero if multiple fns in list LOC have the same name.
7510 Null names are ignored. */
7513 ambiguous_names_p (struct bp_location
*loc
)
7515 struct bp_location
*l
;
7516 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7517 (int (*) (const void *, const void *)) streq
,
7518 NULL
, xcalloc
, xfree
);
7520 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7523 const char *name
= l
->function_name
;
7525 /* Allow for some names to be NULL, ignore them. */
7529 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7531 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7546 update_breakpoint_locations (struct breakpoint
*b
,
7547 struct symtabs_and_lines sals
)
7551 struct bp_location
*existing_locations
= b
->loc
;
7553 /* If there's no new locations, and all existing locations
7554 are pending, don't do anything. This optimizes
7555 the common case where all locations are in the same
7556 shared library, that was unloaded. We'd like to
7557 retain the location, so that when the library
7558 is loaded again, we don't loose the enabled/disabled
7559 status of the individual locations. */
7560 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7565 for (i
= 0; i
< sals
.nelts
; ++i
)
7567 struct bp_location
*new_loc
=
7568 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
7570 /* Reparse conditions, they might contain references to the
7572 if (b
->cond_string
!= NULL
)
7574 struct gdb_exception e
;
7577 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7579 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7584 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7585 b
->number
, e
.message
);
7586 new_loc
->enabled
= 0;
7590 if (b
->source_file
!= NULL
)
7591 xfree (b
->source_file
);
7592 if (sals
.sals
[i
].symtab
== NULL
)
7593 b
->source_file
= NULL
;
7595 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
7597 if (b
->line_number
== 0)
7598 b
->line_number
= sals
.sals
[i
].line
;
7601 /* Update locations of permanent breakpoints. */
7602 if (b
->enable_state
== bp_permanent
)
7603 make_breakpoint_permanent (b
);
7605 /* If possible, carry over 'disable' status from existing breakpoints. */
7607 struct bp_location
*e
= existing_locations
;
7608 /* If there are multiple breakpoints with the same function name,
7609 e.g. for inline functions, comparing function names won't work.
7610 Instead compare pc addresses; this is just a heuristic as things
7611 may have moved, but in practice it gives the correct answer
7612 often enough until a better solution is found. */
7613 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7615 for (; e
; e
= e
->next
)
7617 if (!e
->enabled
&& e
->function_name
)
7619 struct bp_location
*l
= b
->loc
;
7620 if (have_ambiguous_names
)
7622 for (; l
; l
= l
->next
)
7623 if (e
->address
== l
->address
)
7631 for (; l
; l
= l
->next
)
7632 if (l
->function_name
7633 && strcmp (e
->function_name
, l
->function_name
) == 0)
7643 update_global_location_list (1);
7647 /* Reset a breakpoint given it's struct breakpoint * BINT.
7648 The value we return ends up being the return value from catch_errors.
7649 Unused in this case. */
7652 breakpoint_re_set_one (void *bint
)
7654 /* get past catch_errs */
7655 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7659 int *not_found_ptr
= ¬_found
;
7660 struct symtabs_and_lines sals
= {};
7661 struct symtabs_and_lines expanded
;
7663 enum enable_state save_enable
;
7664 struct gdb_exception e
;
7665 struct cleanup
*cleanups
;
7670 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7674 case bp_hardware_breakpoint
:
7676 if (b
->addr_string
== NULL
)
7678 /* Anything without a string can't be re-set. */
7679 delete_breakpoint (b
);
7683 set_language (b
->language
);
7684 input_radix
= b
->input_radix
;
7686 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7688 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7693 int not_found_and_ok
= 0;
7694 /* For pending breakpoints, it's expected that parsing
7695 will fail until the right shared library is loaded.
7696 User has already told to create pending breakpoints and
7697 don't need extra messages. If breakpoint is in bp_shlib_disabled
7698 state, then user already saw the message about that breakpoint
7699 being disabled, and don't want to see more errors. */
7701 && (b
->condition_not_parsed
7702 || (b
->loc
&& b
->loc
->shlib_disabled
)
7703 || b
->enable_state
== bp_disabled
))
7704 not_found_and_ok
= 1;
7706 if (!not_found_and_ok
)
7708 /* We surely don't want to warn about the same breakpoint
7709 10 times. One solution, implemented here, is disable
7710 the breakpoint on error. Another solution would be to
7711 have separate 'warning emitted' flag. Since this
7712 happens only when a binary has changed, I don't know
7713 which approach is better. */
7714 b
->enable_state
= bp_disabled
;
7715 throw_exception (e
);
7722 gdb_assert (sals
.nelts
== 1);
7723 resolve_sal_pc (&sals
.sals
[0]);
7724 if (b
->condition_not_parsed
&& s
&& s
[0])
7726 char *cond_string
= 0;
7730 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7731 &cond_string
, &thread
, &task
);
7733 b
->cond_string
= cond_string
;
7736 b
->condition_not_parsed
= 0;
7738 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7739 cleanups
= make_cleanup (xfree
, sals
.sals
);
7740 update_breakpoint_locations (b
, expanded
);
7741 do_cleanups (cleanups
);
7745 case bp_hardware_watchpoint
:
7746 case bp_read_watchpoint
:
7747 case bp_access_watchpoint
:
7748 /* Watchpoint can be either on expression using entirely global variables,
7749 or it can be on local variables.
7751 Watchpoints of the first kind are never auto-deleted, and even persist
7752 across program restarts. Since they can use variables from shared
7753 libraries, we need to reparse expression as libraries are loaded
7756 Watchpoints on local variables can also change meaning as result
7757 of solib event. For example, if a watchpoint uses both a local and
7758 a global variables in expression, it's a local watchpoint, but
7759 unloading of a shared library will make the expression invalid.
7760 This is not a very common use case, but we still re-evaluate
7761 expression, to avoid surprises to the user.
7763 Note that for local watchpoints, we re-evaluate it only if
7764 watchpoints frame id is still valid. If it's not, it means
7765 the watchpoint is out of scope and will be deleted soon. In fact,
7766 I'm not sure we'll ever be called in this case.
7768 If a local watchpoint's frame id is still valid, then
7769 b->exp_valid_block is likewise valid, and we can safely use it.
7771 Don't do anything about disabled watchpoints, since they will
7772 be reevaluated again when enabled. */
7773 update_watchpoint (b
, 1 /* reparse */);
7775 /* We needn't really do anything to reset these, since the mask
7776 that requests them is unaffected by e.g., new libraries being
7782 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7784 /* Delete overlay event and longjmp master breakpoints; they will be
7785 reset later by breakpoint_re_set. */
7786 case bp_overlay_event
:
7787 case bp_longjmp_master
:
7788 delete_breakpoint (b
);
7791 /* This breakpoint is special, it's set up when the inferior
7792 starts and we really don't want to touch it. */
7793 case bp_shlib_event
:
7795 /* Like bp_shlib_event, this breakpoint type is special.
7796 Once it is set up, we do not want to touch it. */
7797 case bp_thread_event
:
7799 /* Keep temporary breakpoints, which can be encountered when we step
7800 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7801 Otherwise these should have been blown away via the cleanup chain
7802 or by breakpoint_init_inferior when we rerun the executable. */
7805 case bp_watchpoint_scope
:
7807 case bp_step_resume
:
7809 case bp_longjmp_resume
:
7816 /* Re-set all breakpoints after symbols have been re-loaded. */
7818 breakpoint_re_set (void)
7820 struct breakpoint
*b
, *temp
;
7821 enum language save_language
;
7822 int save_input_radix
;
7824 save_language
= current_language
->la_language
;
7825 save_input_radix
= input_radix
;
7826 ALL_BREAKPOINTS_SAFE (b
, temp
)
7828 /* Format possible error msg */
7829 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7831 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7832 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7833 do_cleanups (cleanups
);
7835 set_language (save_language
);
7836 input_radix
= save_input_radix
;
7838 create_overlay_event_breakpoint ("_ovly_debug_event");
7839 create_longjmp_master_breakpoint ("longjmp");
7840 create_longjmp_master_breakpoint ("_longjmp");
7841 create_longjmp_master_breakpoint ("siglongjmp");
7842 create_longjmp_master_breakpoint ("_siglongjmp");
7845 /* Reset the thread number of this breakpoint:
7847 - If the breakpoint is for all threads, leave it as-is.
7848 - Else, reset it to the current thread for inferior_ptid. */
7850 breakpoint_re_set_thread (struct breakpoint
*b
)
7852 if (b
->thread
!= -1)
7854 if (in_thread_list (inferior_ptid
))
7855 b
->thread
= pid_to_thread_id (inferior_ptid
);
7859 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7860 If from_tty is nonzero, it prints a message to that effect,
7861 which ends with a period (no newline). */
7864 set_ignore_count (int bptnum
, int count
, int from_tty
)
7866 struct breakpoint
*b
;
7872 if (b
->number
== bptnum
)
7874 b
->ignore_count
= count
;
7878 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7880 else if (count
== 1)
7881 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7884 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7887 breakpoints_changed ();
7888 observer_notify_breakpoint_modified (b
->number
);
7892 error (_("No breakpoint number %d."), bptnum
);
7896 make_breakpoint_silent (struct breakpoint
*b
)
7898 /* Silence the breakpoint. */
7902 /* Command to set ignore-count of breakpoint N to COUNT. */
7905 ignore_command (char *args
, int from_tty
)
7911 error_no_arg (_("a breakpoint number"));
7913 num
= get_number (&p
);
7915 error (_("bad breakpoint number: '%s'"), args
);
7917 error (_("Second argument (specified ignore-count) is missing."));
7919 set_ignore_count (num
,
7920 longest_to_int (value_as_long (parse_and_eval (p
))),
7923 printf_filtered ("\n");
7926 /* Call FUNCTION on each of the breakpoints
7927 whose numbers are given in ARGS. */
7930 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7935 struct breakpoint
*b
, *tmp
;
7939 error_no_arg (_("one or more breakpoint numbers"));
7946 num
= get_number_or_range (&p1
);
7949 warning (_("bad breakpoint number at or near '%s'"), p
);
7953 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7954 if (b
->number
== num
)
7956 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7959 if (related_breakpoint
)
7960 function (related_breakpoint
);
7964 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7970 static struct bp_location
*
7971 find_location_by_number (char *number
)
7973 char *dot
= strchr (number
, '.');
7977 struct breakpoint
*b
;
7978 struct bp_location
*loc
;
7983 bp_num
= get_number_or_range (&p1
);
7985 error (_("Bad breakpoint number '%s'"), number
);
7988 if (b
->number
== bp_num
)
7993 if (!b
|| b
->number
!= bp_num
)
7994 error (_("Bad breakpoint number '%s'"), number
);
7997 loc_num
= get_number_or_range (&p1
);
7999 error (_("Bad breakpoint location number '%s'"), number
);
8003 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
8006 error (_("Bad breakpoint location number '%s'"), dot
+1);
8012 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
8013 If from_tty is nonzero, it prints a message to that effect,
8014 which ends with a period (no newline). */
8017 disable_breakpoint (struct breakpoint
*bpt
)
8019 /* Never disable a watchpoint scope breakpoint; we want to
8020 hit them when we leave scope so we can delete both the
8021 watchpoint and its scope breakpoint at that time. */
8022 if (bpt
->type
== bp_watchpoint_scope
)
8025 /* You can't disable permanent breakpoints. */
8026 if (bpt
->enable_state
== bp_permanent
)
8029 bpt
->enable_state
= bp_disabled
;
8031 update_global_location_list (0);
8033 observer_notify_breakpoint_modified (bpt
->number
);
8037 disable_command (char *args
, int from_tty
)
8039 struct breakpoint
*bpt
;
8041 ALL_BREAKPOINTS (bpt
)
8045 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
8051 case bp_hardware_breakpoint
:
8053 case bp_hardware_watchpoint
:
8054 case bp_read_watchpoint
:
8055 case bp_access_watchpoint
:
8056 disable_breakpoint (bpt
);
8060 else if (strchr (args
, '.'))
8062 struct bp_location
*loc
= find_location_by_number (args
);
8065 update_global_location_list (0);
8068 map_breakpoint_numbers (args
, disable_breakpoint
);
8072 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
8074 int target_resources_ok
, other_type_used
;
8077 if (bpt
->type
== bp_hardware_breakpoint
)
8080 i
= hw_breakpoint_used_count ();
8081 target_resources_ok
=
8082 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8084 if (target_resources_ok
== 0)
8085 error (_("No hardware breakpoint support in the target."));
8086 else if (target_resources_ok
< 0)
8087 error (_("Hardware breakpoints used exceeds limit."));
8090 if (bpt
->type
== bp_watchpoint
8091 || bpt
->type
== bp_hardware_watchpoint
8092 || bpt
->type
== bp_read_watchpoint
8093 || bpt
->type
== bp_access_watchpoint
)
8095 struct gdb_exception e
;
8097 TRY_CATCH (e
, RETURN_MASK_ALL
)
8099 update_watchpoint (bpt
, 1 /* reparse */);
8103 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
8109 if (bpt
->enable_state
!= bp_permanent
)
8110 bpt
->enable_state
= bp_enabled
;
8111 bpt
->disposition
= disposition
;
8112 update_global_location_list (1);
8113 breakpoints_changed ();
8115 observer_notify_breakpoint_modified (bpt
->number
);
8120 enable_breakpoint (struct breakpoint
*bpt
)
8122 do_enable_breakpoint (bpt
, bpt
->disposition
);
8125 /* The enable command enables the specified breakpoints (or all defined
8126 breakpoints) so they once again become (or continue to be) effective
8127 in stopping the inferior. */
8130 enable_command (char *args
, int from_tty
)
8132 struct breakpoint
*bpt
;
8134 ALL_BREAKPOINTS (bpt
)
8138 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
8144 case bp_hardware_breakpoint
:
8146 case bp_hardware_watchpoint
:
8147 case bp_read_watchpoint
:
8148 case bp_access_watchpoint
:
8149 enable_breakpoint (bpt
);
8153 else if (strchr (args
, '.'))
8155 struct bp_location
*loc
= find_location_by_number (args
);
8158 update_global_location_list (1);
8161 map_breakpoint_numbers (args
, enable_breakpoint
);
8165 enable_once_breakpoint (struct breakpoint
*bpt
)
8167 do_enable_breakpoint (bpt
, disp_disable
);
8171 enable_once_command (char *args
, int from_tty
)
8173 map_breakpoint_numbers (args
, enable_once_breakpoint
);
8177 enable_delete_breakpoint (struct breakpoint
*bpt
)
8179 do_enable_breakpoint (bpt
, disp_del
);
8183 enable_delete_command (char *args
, int from_tty
)
8185 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
8189 set_breakpoint_cmd (char *args
, int from_tty
)
8194 show_breakpoint_cmd (char *args
, int from_tty
)
8198 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
8200 struct symtabs_and_lines
8201 decode_line_spec_1 (char *string
, int funfirstline
)
8203 struct symtabs_and_lines sals
;
8205 error (_("Empty line specification."));
8206 if (default_breakpoint_valid
)
8207 sals
= decode_line_1 (&string
, funfirstline
,
8208 default_breakpoint_symtab
,
8209 default_breakpoint_line
,
8210 (char ***) NULL
, NULL
);
8212 sals
= decode_line_1 (&string
, funfirstline
,
8213 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
8215 error (_("Junk at end of line specification: %s"), string
);
8219 /* Create and insert a raw software breakpoint at PC. Return an
8220 identifier, which should be used to remove the breakpoint later.
8221 In general, places which call this should be using something on the
8222 breakpoint chain instead; this function should be eliminated
8226 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
8228 struct bp_target_info
*bp_tgt
;
8230 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
8231 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
8233 bp_tgt
->placed_address
= pc
;
8234 if (target_insert_breakpoint (bp_tgt
) != 0)
8236 /* Could not insert the breakpoint. */
8244 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
8247 deprecated_remove_raw_breakpoint (void *bp
)
8249 struct bp_target_info
*bp_tgt
= bp
;
8252 ret
= target_remove_breakpoint (bp_tgt
);
8258 /* One (or perhaps two) breakpoints used for software single stepping. */
8260 static void *single_step_breakpoints
[2];
8262 /* Create and insert a breakpoint for software single step. */
8265 insert_single_step_breakpoint (CORE_ADDR next_pc
)
8269 if (single_step_breakpoints
[0] == NULL
)
8270 bpt_p
= &single_step_breakpoints
[0];
8273 gdb_assert (single_step_breakpoints
[1] == NULL
);
8274 bpt_p
= &single_step_breakpoints
[1];
8277 /* NOTE drow/2006-04-11: A future improvement to this function would be
8278 to only create the breakpoints once, and actually put them on the
8279 breakpoint chain. That would let us use set_raw_breakpoint. We could
8280 adjust the addresses each time they were needed. Doing this requires
8281 corresponding changes elsewhere where single step breakpoints are
8282 handled, however. So, for now, we use this. */
8284 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
8286 error (_("Could not insert single-step breakpoint at 0x%s"),
8287 paddr_nz (next_pc
));
8290 /* Remove and delete any breakpoints used for software single step. */
8293 remove_single_step_breakpoints (void)
8295 gdb_assert (single_step_breakpoints
[0] != NULL
);
8297 /* See insert_single_step_breakpoint for more about this deprecated
8299 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8300 single_step_breakpoints
[0] = NULL
;
8302 if (single_step_breakpoints
[1] != NULL
)
8304 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8305 single_step_breakpoints
[1] = NULL
;
8309 /* Check whether a software single-step breakpoint is inserted at PC. */
8312 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8316 for (i
= 0; i
< 2; i
++)
8318 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8319 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8326 /* Tracepoint-specific operations. */
8328 /* Set tracepoint count to NUM. */
8330 set_tracepoint_count (int num
)
8332 tracepoint_count
= num
;
8333 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
8337 trace_command (char *arg
, int from_tty
)
8339 break_command_really (arg
,
8340 NULL
, 0, 1 /* parse arg */,
8341 0 /* tempflag */, 0 /* hardwareflag */,
8343 0 /* Ignore count */,
8344 pending_break_support
,
8348 set_tracepoint_count (breakpoint_count
);
8351 /* Print information on tracepoint number TPNUM_EXP, or all if
8355 tracepoints_info (char *tpnum_exp
, int from_tty
)
8357 struct breakpoint
*b
;
8358 int tps_to_list
= 0;
8360 /* In the no-arguments case, say "No tracepoints" if none found. */
8373 ui_out_message (uiout
, 0, "No tracepoints.\n");
8378 /* Otherwise be the same as "info break". */
8379 breakpoints_info (tpnum_exp
, from_tty
);
8382 /* The 'enable trace' command enables tracepoints.
8383 Not supported by all targets. */
8385 enable_trace_command (char *args
, int from_tty
)
8387 enable_command (args
, from_tty
);
8390 /* The 'disable trace' command disables tracepoints.
8391 Not supported by all targets. */
8393 disable_trace_command (char *args
, int from_tty
)
8395 disable_command (args
, from_tty
);
8398 /* Remove a tracepoint (or all if no argument) */
8400 delete_trace_command (char *arg
, int from_tty
)
8402 struct breakpoint
*b
, *temp
;
8408 int breaks_to_delete
= 0;
8410 /* Delete all breakpoints if no argument.
8411 Do not delete internal or call-dummy breakpoints, these
8412 have to be deleted with an explicit breakpoint number argument. */
8417 breaks_to_delete
= 1;
8422 /* Ask user only if there are some breakpoints to delete. */
8424 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
8426 ALL_BREAKPOINTS_SAFE (b
, temp
)
8428 if (b
->type
== bp_tracepoint
8430 delete_breakpoint (b
);
8435 map_breakpoint_numbers (arg
, delete_breakpoint
);
8438 /* Set passcount for tracepoint.
8440 First command argument is passcount, second is tracepoint number.
8441 If tracepoint number omitted, apply to most recently defined.
8442 Also accepts special argument "all". */
8445 trace_pass_command (char *args
, int from_tty
)
8447 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
8451 if (args
== 0 || *args
== 0)
8452 error (_("passcount command requires an argument (count + optional TP num)"));
8454 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
8456 while (*args
&& isspace ((int) *args
))
8459 if (*args
&& strncasecmp (args
, "all", 3) == 0)
8461 args
+= 3; /* Skip special argument "all". */
8464 error (_("Junk at end of arguments."));
8467 t1
= get_tracepoint_by_number (&args
, 1, 1);
8473 ALL_TRACEPOINTS (t2
)
8474 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
8476 t2
->pass_count
= count
;
8477 observer_notify_tracepoint_modified (t2
->number
);
8479 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
8483 t1
= get_tracepoint_by_number (&args
, 1, 0);
8490 get_tracepoint (int num
)
8492 struct breakpoint
*t
;
8495 if (t
->number
== num
)
8501 /* Utility: parse a tracepoint number and look it up in the list.
8502 If MULTI_P is true, there might be a range of tracepoints in ARG.
8503 if OPTIONAL_P is true, then if the argument is missing, the most
8504 recent tracepoint (tracepoint_count) is returned. */
8506 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
8508 extern int tracepoint_count
;
8509 struct breakpoint
*t
;
8511 char *instring
= arg
== NULL
? NULL
: *arg
;
8513 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
8516 tpnum
= tracepoint_count
;
8518 error_no_arg (_("tracepoint number"));
8521 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
8525 if (instring
&& *instring
)
8526 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
8529 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
8534 if (t
->number
== tpnum
)
8539 /* FIXME: if we are in the middle of a range we don't want to give
8540 a message. The current interface to get_number_or_range doesn't
8541 allow us to discover this. */
8542 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
8546 /* save-tracepoints command */
8548 tracepoint_save_command (char *args
, int from_tty
)
8550 struct breakpoint
*tp
;
8552 struct action_line
*line
;
8554 char *i1
= " ", *i2
= " ";
8555 char *indent
, *actionline
, *pathname
;
8557 struct cleanup
*cleanup
;
8559 if (args
== 0 || *args
== 0)
8560 error (_("Argument required (file name in which to save tracepoints)"));
8562 /* See if we have anything to save. */
8563 ALL_TRACEPOINTS (tp
)
8570 warning (_("save-tracepoints: no tracepoints to save."));
8574 pathname
= tilde_expand (args
);
8575 cleanup
= make_cleanup (xfree
, pathname
);
8576 fp
= fopen (pathname
, "w");
8578 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
8579 args
, safe_strerror (errno
));
8580 make_cleanup_fclose (fp
);
8582 ALL_TRACEPOINTS (tp
)
8584 if (tp
->addr_string
)
8585 fprintf (fp
, "trace %s\n", tp
->addr_string
);
8588 sprintf_vma (tmp
, tp
->loc
->address
);
8589 fprintf (fp
, "trace *0x%s\n", tmp
);
8593 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
8597 fprintf (fp
, " actions\n");
8599 for (line
= tp
->actions
; line
; line
= line
->next
)
8601 struct cmd_list_element
*cmd
;
8603 QUIT
; /* allow user to bail out with ^C */
8604 actionline
= line
->action
;
8605 while (isspace ((int) *actionline
))
8608 fprintf (fp
, "%s%s\n", indent
, actionline
);
8609 if (*actionline
!= '#') /* skip for comment lines */
8611 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
8613 error (_("Bad action list item: %s"), actionline
);
8614 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
8616 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
8622 do_cleanups (cleanup
);
8624 printf_filtered (_("Tracepoints saved to file '%s'.\n"), args
);
8628 /* Create a vector of all tracepoints. */
8633 VEC(breakpoint_p
) *tp_vec
= 0;
8634 struct breakpoint
*tp
;
8636 ALL_TRACEPOINTS (tp
)
8638 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
8645 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8646 It is defined as a macro to prevent duplication.
8647 COMMAND should be a string constant containing the name of the command. */
8648 #define BREAK_ARGS_HELP(command) \
8649 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8650 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8651 If a line number is specified, break at start of code for that line.\n\
8652 If a function is specified, break at start of code for that function.\n\
8653 If an address is specified, break at that exact address.\n\
8654 With no LOCATION, uses current execution address of selected stack frame.\n\
8655 This is useful for breaking on return to a stack frame.\n\
8657 THREADNUM is the number from \"info threads\".\n\
8658 CONDITION is a boolean expression.\n\
8660 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8662 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8664 /* List of subcommands for "catch". */
8665 static struct cmd_list_element
*catch_cmdlist
;
8667 /* List of subcommands for "tcatch". */
8668 static struct cmd_list_element
*tcatch_cmdlist
;
8670 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
8671 lists, and pass some additional user data to the command function. */
8673 add_catch_command (char *name
, char *docstring
,
8674 void (*sfunc
) (char *args
, int from_tty
,
8675 struct cmd_list_element
*command
),
8676 void *user_data_catch
,
8677 void *user_data_tcatch
)
8679 struct cmd_list_element
*command
;
8681 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8683 set_cmd_sfunc (command
, sfunc
);
8684 set_cmd_context (command
, user_data_catch
);
8686 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8688 set_cmd_sfunc (command
, sfunc
);
8689 set_cmd_context (command
, user_data_tcatch
);
8693 _initialize_breakpoint (void)
8695 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8696 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8697 struct cmd_list_element
*c
;
8699 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8701 breakpoint_chain
= 0;
8702 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8703 before a breakpoint is set. */
8704 breakpoint_count
= 0;
8706 tracepoint_count
= 0;
8708 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8709 Set ignore-count of breakpoint number N to COUNT.\n\
8710 Usage is `ignore N COUNT'."));
8712 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8714 add_com ("commands", class_breakpoint
, commands_command
, _("\
8715 Set commands to be executed when a breakpoint is hit.\n\
8716 Give breakpoint number as argument after \"commands\".\n\
8717 With no argument, the targeted breakpoint is the last one set.\n\
8718 The commands themselves follow starting on the next line.\n\
8719 Type a line containing \"end\" to indicate the end of them.\n\
8720 Give \"silent\" as the first line to make the breakpoint silent;\n\
8721 then no output is printed when it is hit, except what the commands print."));
8723 add_com ("condition", class_breakpoint
, condition_command
, _("\
8724 Specify breakpoint number N to break only if COND is true.\n\
8725 Usage is `condition N COND', where N is an integer and COND is an\n\
8726 expression to be evaluated whenever breakpoint N is reached."));
8728 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8729 Set a temporary breakpoint.\n\
8730 Like \"break\" except the breakpoint is only temporary,\n\
8731 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8732 by using \"enable delete\" on the breakpoint number.\n\
8734 BREAK_ARGS_HELP ("tbreak")));
8735 set_cmd_completer (c
, location_completer
);
8737 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8738 Set a hardware assisted breakpoint.\n\
8739 Like \"break\" except the breakpoint requires hardware support,\n\
8740 some target hardware may not have this support.\n\
8742 BREAK_ARGS_HELP ("hbreak")));
8743 set_cmd_completer (c
, location_completer
);
8745 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8746 Set a temporary hardware assisted breakpoint.\n\
8747 Like \"hbreak\" except the breakpoint is only temporary,\n\
8748 so it will be deleted when hit.\n\
8750 BREAK_ARGS_HELP ("thbreak")));
8751 set_cmd_completer (c
, location_completer
);
8753 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8754 Enable some breakpoints.\n\
8755 Give breakpoint numbers (separated by spaces) as arguments.\n\
8756 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8757 This is used to cancel the effect of the \"disable\" command.\n\
8758 With a subcommand you can enable temporarily."),
8759 &enablelist
, "enable ", 1, &cmdlist
);
8761 add_com ("ab", class_breakpoint
, enable_command
, _("\
8762 Enable some breakpoints.\n\
8763 Give breakpoint numbers (separated by spaces) as arguments.\n\
8764 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8765 This is used to cancel the effect of the \"disable\" command.\n\
8766 With a subcommand you can enable temporarily."));
8768 add_com_alias ("en", "enable", class_breakpoint
, 1);
8770 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8771 Enable some breakpoints.\n\
8772 Give breakpoint numbers (separated by spaces) as arguments.\n\
8773 This is used to cancel the effect of the \"disable\" command.\n\
8774 May be abbreviated to simply \"enable\".\n"),
8775 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8777 add_cmd ("once", no_class
, enable_once_command
, _("\
8778 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8779 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8782 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8783 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8784 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8787 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8788 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8789 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8792 add_cmd ("once", no_class
, enable_once_command
, _("\
8793 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8794 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8797 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8798 Disable some breakpoints.\n\
8799 Arguments are breakpoint numbers with spaces in between.\n\
8800 To disable all breakpoints, give no argument.\n\
8801 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8802 &disablelist
, "disable ", 1, &cmdlist
);
8803 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8804 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8806 add_com ("sb", class_breakpoint
, disable_command
, _("\
8807 Disable some breakpoints.\n\
8808 Arguments are breakpoint numbers with spaces in between.\n\
8809 To disable all breakpoints, give no argument.\n\
8810 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8812 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8813 Disable some breakpoints.\n\
8814 Arguments are breakpoint numbers with spaces in between.\n\
8815 To disable all breakpoints, give no argument.\n\
8816 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8817 This command may be abbreviated \"disable\"."),
8820 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8821 Delete some breakpoints or auto-display expressions.\n\
8822 Arguments are breakpoint numbers with spaces in between.\n\
8823 To delete all breakpoints, give no argument.\n\
8825 Also a prefix command for deletion of other GDB objects.\n\
8826 The \"unset\" command is also an alias for \"delete\"."),
8827 &deletelist
, "delete ", 1, &cmdlist
);
8828 add_com_alias ("d", "delete", class_breakpoint
, 1);
8829 add_com_alias ("del", "delete", class_breakpoint
, 1);
8831 add_com ("db", class_breakpoint
, delete_command
, _("\
8832 Delete some breakpoints.\n\
8833 Arguments are breakpoint numbers with spaces in between.\n\
8834 To delete all breakpoints, give no argument.\n"));
8836 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8837 Delete some breakpoints or auto-display expressions.\n\
8838 Arguments are breakpoint numbers with spaces in between.\n\
8839 To delete all breakpoints, give no argument.\n\
8840 This command may be abbreviated \"delete\"."),
8843 add_com ("clear", class_breakpoint
, clear_command
, _("\
8844 Clear breakpoint at specified line or function.\n\
8845 Argument may be line number, function name, or \"*\" and an address.\n\
8846 If line number is specified, all breakpoints in that line are cleared.\n\
8847 If function is specified, breakpoints at beginning of function are cleared.\n\
8848 If an address is specified, breakpoints at that address are cleared.\n\
8850 With no argument, clears all breakpoints in the line that the selected frame\n\
8853 See also the \"delete\" command which clears breakpoints by number."));
8855 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8856 Set breakpoint at specified line or function.\n"
8857 BREAK_ARGS_HELP ("break")));
8858 set_cmd_completer (c
, location_completer
);
8860 add_com_alias ("b", "break", class_run
, 1);
8861 add_com_alias ("br", "break", class_run
, 1);
8862 add_com_alias ("bre", "break", class_run
, 1);
8863 add_com_alias ("brea", "break", class_run
, 1);
8866 add_com_alias ("ba", "break", class_breakpoint
, 1);
8870 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8871 Break in function/address or break at a line in the current file."),
8872 &stoplist
, "stop ", 1, &cmdlist
);
8873 add_cmd ("in", class_breakpoint
, stopin_command
,
8874 _("Break in function or address."), &stoplist
);
8875 add_cmd ("at", class_breakpoint
, stopat_command
,
8876 _("Break at a line in the current file."), &stoplist
);
8877 add_com ("status", class_info
, breakpoints_info
, _("\
8878 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8879 The \"Type\" column indicates one of:\n\
8880 \tbreakpoint - normal breakpoint\n\
8881 \twatchpoint - watchpoint\n\
8882 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8883 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8884 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8885 address and file/line number respectively.\n\
8887 Convenience variable \"$_\" and default examine address for \"x\"\n\
8888 are set to the address of the last breakpoint listed unless the command\n\
8889 is prefixed with \"server \".\n\n\
8890 Convenience variable \"$bpnum\" contains the number of the last\n\
8894 add_info ("breakpoints", breakpoints_info
, _("\
8895 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8896 The \"Type\" column indicates one of:\n\
8897 \tbreakpoint - normal breakpoint\n\
8898 \twatchpoint - watchpoint\n\
8899 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8900 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8901 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8902 address and file/line number respectively.\n\
8904 Convenience variable \"$_\" and default examine address for \"x\"\n\
8905 are set to the address of the last breakpoint listed unless the command\n\
8906 is prefixed with \"server \".\n\n\
8907 Convenience variable \"$bpnum\" contains the number of the last\n\
8911 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8912 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8913 The \"Type\" column indicates one of:\n\
8914 \tbreakpoint - normal breakpoint\n\
8915 \twatchpoint - watchpoint\n\
8916 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8917 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8918 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8919 address and file/line number respectively.\n\
8921 Convenience variable \"$_\" and default examine address for \"x\"\n\
8922 are set to the address of the last breakpoint listed unless the command\n\
8923 is prefixed with \"server \".\n\n\
8924 Convenience variable \"$bpnum\" contains the number of the last\n\
8927 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8928 Status of all breakpoints, or breakpoint number NUMBER.\n\
8929 The \"Type\" column indicates one of:\n\
8930 \tbreakpoint - normal breakpoint\n\
8931 \twatchpoint - watchpoint\n\
8932 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8933 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8934 \tuntil - internal breakpoint used by the \"until\" command\n\
8935 \tfinish - internal breakpoint used by the \"finish\" command\n\
8936 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8937 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8938 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8939 address and file/line number respectively.\n\
8941 Convenience variable \"$_\" and default examine address for \"x\"\n\
8942 are set to the address of the last breakpoint listed unless the command\n\
8943 is prefixed with \"server \".\n\n\
8944 Convenience variable \"$bpnum\" contains the number of the last\n\
8946 &maintenanceinfolist
);
8948 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
8949 Set catchpoints to catch events."),
8950 &catch_cmdlist
, "catch ",
8951 0/*allow-unknown*/, &cmdlist
);
8953 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
8954 Set temporary catchpoints to catch events."),
8955 &tcatch_cmdlist
, "tcatch ",
8956 0/*allow-unknown*/, &cmdlist
);
8958 /* Add catch and tcatch sub-commands. */
8959 add_catch_command ("catch", _("\
8960 Catch an exception, when caught.\n\
8961 With an argument, catch only exceptions with the given name."),
8962 catch_catch_command
,
8965 add_catch_command ("throw", _("\
8966 Catch an exception, when thrown.\n\
8967 With an argument, catch only exceptions with the given name."),
8968 catch_throw_command
,
8971 add_catch_command ("fork", _("Catch calls to fork."),
8972 catch_fork_command_1
,
8973 (void *) (uintptr_t) catch_fork_permanent
,
8974 (void *) (uintptr_t) catch_fork_temporary
);
8975 add_catch_command ("vfork", _("Catch calls to vfork."),
8976 catch_fork_command_1
,
8977 (void *) (uintptr_t) catch_vfork_permanent
,
8978 (void *) (uintptr_t) catch_vfork_temporary
);
8979 add_catch_command ("exec", _("Catch calls to exec."),
8980 catch_exec_command_1
,
8983 add_catch_command ("exception", _("\
8984 Catch Ada exceptions, when raised.\n\
8985 With an argument, catch only exceptions with the given name."),
8986 catch_ada_exception_command
,
8989 add_catch_command ("assert", _("\
8990 Catch failed Ada assertions, when raised.\n\
8991 With an argument, catch only exceptions with the given name."),
8992 catch_assert_command
,
8996 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8997 Set a watchpoint for an expression.\n\
8998 A watchpoint stops execution of your program whenever the value of\n\
8999 an expression changes."));
9000 set_cmd_completer (c
, expression_completer
);
9002 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
9003 Set a read watchpoint for an expression.\n\
9004 A watchpoint stops execution of your program whenever the value of\n\
9005 an expression is read."));
9006 set_cmd_completer (c
, expression_completer
);
9008 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
9009 Set a watchpoint for an expression.\n\
9010 A watchpoint stops execution of your program whenever the value of\n\
9011 an expression is either read or written."));
9012 set_cmd_completer (c
, expression_completer
);
9014 add_info ("watchpoints", breakpoints_info
,
9015 _("Synonym for ``info breakpoints''."));
9018 /* XXX: cagney/2005-02-23: This should be a boolean, and should
9019 respond to changes - contrary to the description. */
9020 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
9021 &can_use_hw_watchpoints
, _("\
9022 Set debugger's willingness to use watchpoint hardware."), _("\
9023 Show debugger's willingness to use watchpoint hardware."), _("\
9024 If zero, gdb will not use hardware for new watchpoints, even if\n\
9025 such is available. (However, any hardware watchpoints that were\n\
9026 created before setting this to nonzero, will continue to use watchpoint\n\
9029 show_can_use_hw_watchpoints
,
9030 &setlist
, &showlist
);
9032 can_use_hw_watchpoints
= 1;
9034 /* Tracepoint manipulation commands. */
9036 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
9037 Set a tracepoint at specified line or function.\n\
9039 BREAK_ARGS_HELP ("trace") "\n\
9040 Do \"help tracepoints\" for info on other tracepoint commands."));
9041 set_cmd_completer (c
, location_completer
);
9043 add_com_alias ("tp", "trace", class_alias
, 0);
9044 add_com_alias ("tr", "trace", class_alias
, 1);
9045 add_com_alias ("tra", "trace", class_alias
, 1);
9046 add_com_alias ("trac", "trace", class_alias
, 1);
9048 add_info ("tracepoints", tracepoints_info
, _("\
9049 Status of tracepoints, or tracepoint number NUMBER.\n\
9050 Convenience variable \"$tpnum\" contains the number of the\n\
9051 last tracepoint set."));
9053 add_info_alias ("tp", "tracepoints", 1);
9055 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
9056 Delete specified tracepoints.\n\
9057 Arguments are tracepoint numbers, separated by spaces.\n\
9058 No argument means delete all tracepoints."),
9061 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
9062 Disable specified tracepoints.\n\
9063 Arguments are tracepoint numbers, separated by spaces.\n\
9064 No argument means disable all tracepoints."),
9066 deprecate_cmd (c
, "disable");
9068 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
9069 Enable specified tracepoints.\n\
9070 Arguments are tracepoint numbers, separated by spaces.\n\
9071 No argument means enable all tracepoints."),
9073 deprecate_cmd (c
, "enable");
9075 add_com ("passcount", class_trace
, trace_pass_command
, _("\
9076 Set the passcount for a tracepoint.\n\
9077 The trace will end when the tracepoint has been passed 'count' times.\n\
9078 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
9079 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
9081 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
9082 Save current tracepoint definitions as a script.\n\
9083 Use the 'source' command in another debug session to restore them."));
9084 set_cmd_completer (c
, filename_completer
);
9086 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
9087 Breakpoint specific settings\n\
9088 Configure various breakpoint-specific variables such as\n\
9089 pending breakpoint behavior"),
9090 &breakpoint_set_cmdlist
, "set breakpoint ",
9091 0/*allow-unknown*/, &setlist
);
9092 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
9093 Breakpoint specific settings\n\
9094 Configure various breakpoint-specific variables such as\n\
9095 pending breakpoint behavior"),
9096 &breakpoint_show_cmdlist
, "show breakpoint ",
9097 0/*allow-unknown*/, &showlist
);
9099 add_setshow_auto_boolean_cmd ("pending", no_class
,
9100 &pending_break_support
, _("\
9101 Set debugger's behavior regarding pending breakpoints."), _("\
9102 Show debugger's behavior regarding pending breakpoints."), _("\
9103 If on, an unrecognized breakpoint location will cause gdb to create a\n\
9104 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
9105 an error. If auto, an unrecognized breakpoint location results in a\n\
9106 user-query to see if a pending breakpoint should be created."),
9108 show_pending_break_support
,
9109 &breakpoint_set_cmdlist
,
9110 &breakpoint_show_cmdlist
);
9112 pending_break_support
= AUTO_BOOLEAN_AUTO
;
9114 add_setshow_boolean_cmd ("auto-hw", no_class
,
9115 &automatic_hardware_breakpoints
, _("\
9116 Set automatic usage of hardware breakpoints."), _("\
9117 Show automatic usage of hardware breakpoints."), _("\
9118 If set, the debugger will automatically use hardware breakpoints for\n\
9119 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
9120 a warning will be emitted for such breakpoints."),
9122 show_automatic_hardware_breakpoints
,
9123 &breakpoint_set_cmdlist
,
9124 &breakpoint_show_cmdlist
);
9126 add_setshow_enum_cmd ("always-inserted", class_support
,
9127 always_inserted_enums
, &always_inserted_mode
, _("\
9128 Set mode for inserting breakpoints."), _("\
9129 Show mode for inserting breakpoints."), _("\
9130 When this mode is off, breakpoints are inserted in inferior when it is\n\
9131 resumed, and removed when execution stops. When this mode is on,\n\
9132 breakpoints are inserted immediately and removed only when the user\n\
9133 deletes the breakpoint. When this mode is auto (which is the default),\n\
9134 the behaviour depends on the non-stop setting (see help set non-stop).\n\
9135 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
9136 behaves as if always-inserted mode is on; if gdb is controlling the\n\
9137 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
9139 &show_always_inserted_mode
,
9140 &breakpoint_set_cmdlist
,
9141 &breakpoint_show_cmdlist
);
9143 automatic_hardware_breakpoints
= 1;
9145 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);