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, 2010 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/>. */
23 #include "arch-utils.h"
28 #include "breakpoint.h"
29 #include "tracepoint.h"
31 #include "expression.h"
37 #include "gdbthread.h"
40 #include "gdb_string.h"
47 #include "completer.h"
50 #include "cli/cli-script.h"
51 #include "gdb_assert.h"
56 #include "exceptions.h"
63 #include "xml-syscall.h"
65 /* readline include files */
66 #include "readline/readline.h"
67 #include "readline/history.h"
69 /* readline defines this. */
72 #include "mi/mi-common.h"
74 /* Arguments to pass as context to some catch command handlers. */
75 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
76 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
78 /* Prototypes for local functions. */
80 static void enable_delete_command (char *, int);
82 static void enable_delete_breakpoint (struct breakpoint
*);
84 static void enable_once_command (char *, int);
86 static void enable_once_breakpoint (struct breakpoint
*);
88 static void disable_command (char *, int);
90 static void enable_command (char *, int);
92 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
94 static void ignore_command (char *, int);
96 static int breakpoint_re_set_one (void *);
98 static void clear_command (char *, int);
100 static void catch_command (char *, int);
102 static void watch_command (char *, int);
104 static int can_use_hardware_watchpoint (struct value
*);
106 static void break_command_1 (char *, int, int);
108 static void mention (struct breakpoint
*);
110 /* This function is used in gdbtk sources and thus can not be made static. */
111 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
112 struct symtab_and_line
,
115 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
117 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
121 static void describe_other_breakpoints (struct gdbarch
*,
122 struct program_space
*, CORE_ADDR
,
123 struct obj_section
*, int);
125 static int breakpoint_address_match (struct address_space
*aspace1
,
127 struct address_space
*aspace2
,
130 static int watchpoint_locations_match (struct bp_location
*loc1
,
131 struct bp_location
*loc2
);
133 static void breakpoints_info (char *, int);
135 static void breakpoint_1 (int, int);
137 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
139 static int breakpoint_cond_eval (void *);
141 static void cleanup_executing_breakpoints (void *);
143 static void commands_command (char *, int);
145 static void condition_command (char *, int);
147 static int get_number_trailer (char **, int);
149 void set_breakpoint_count (int);
158 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
159 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
161 static enum print_stop_action
print_it_typical (bpstat
);
163 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
165 static int watchpoint_check (void *);
167 static void maintenance_info_breakpoints (char *, int);
169 static int hw_breakpoint_used_count (void);
171 static int hw_watchpoint_used_count (enum bptype
, int *);
173 static void hbreak_command (char *, int);
175 static void thbreak_command (char *, int);
177 static void watch_command_1 (char *, int, int);
179 static void rwatch_command (char *, int);
181 static void awatch_command (char *, int);
183 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
185 static void stop_command (char *arg
, int from_tty
);
187 static void stopin_command (char *arg
, int from_tty
);
189 static void stopat_command (char *arg
, int from_tty
);
191 static char *ep_parse_optional_if_clause (char **arg
);
193 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
194 char *arg
, int tempflag
, int from_tty
);
196 static void tcatch_command (char *arg
, int from_tty
);
198 static void ep_skip_leading_whitespace (char **s
);
200 static int single_step_breakpoint_inserted_here_p (struct address_space
*,
203 static void free_bp_location (struct bp_location
*loc
);
205 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
207 static void update_global_location_list (int);
209 static void update_global_location_list_nothrow (int);
211 static int is_hardware_watchpoint (struct breakpoint
*bpt
);
213 static void insert_breakpoint_locations (void);
215 static int syscall_catchpoint_p (struct breakpoint
*b
);
217 static void tracepoints_info (char *, int);
219 static void delete_trace_command (char *, int);
221 static void enable_trace_command (char *, int);
223 static void disable_trace_command (char *, int);
225 static void trace_pass_command (char *, int);
227 static void skip_prologue_sal (struct symtab_and_line
*sal
);
230 /* Flag indicating that a command has proceeded the inferior past the
231 current breakpoint. */
233 static int breakpoint_proceeded
;
236 bpdisp_text (enum bpdisp disp
)
238 /* NOTE: the following values are a part of MI protocol and represent
239 values of 'disp' field returned when inferior stops at a breakpoint. */
240 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
241 return bpdisps
[(int) disp
];
244 /* Prototypes for exported functions. */
245 /* If FALSE, gdb will not use hardware support for watchpoints, even
246 if such is available. */
247 static int can_use_hw_watchpoints
;
250 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
251 struct cmd_list_element
*c
,
254 fprintf_filtered (file
, _("\
255 Debugger's willingness to use watchpoint hardware is %s.\n"),
259 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
260 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
261 for unrecognized breakpoint locations.
262 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
263 static enum auto_boolean pending_break_support
;
265 show_pending_break_support (struct ui_file
*file
, int from_tty
,
266 struct cmd_list_element
*c
,
269 fprintf_filtered (file
, _("\
270 Debugger's behavior regarding pending breakpoints is %s.\n"),
274 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
275 set with "break" but falling in read-only memory.
276 If 0, gdb will warn about such breakpoints, but won't automatically
277 use hardware breakpoints. */
278 static int automatic_hardware_breakpoints
;
280 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
281 struct cmd_list_element
*c
,
284 fprintf_filtered (file
, _("\
285 Automatic usage of hardware breakpoints is %s.\n"),
289 /* If on, gdb will keep breakpoints inserted even as inferior is
290 stopped, and immediately insert any new breakpoints. If off, gdb
291 will insert breakpoints into inferior only when resuming it, and
292 will remove breakpoints upon stop. If auto, GDB will behave as ON
293 if in non-stop mode, and as OFF if all-stop mode.*/
295 static const char always_inserted_auto
[] = "auto";
296 static const char always_inserted_on
[] = "on";
297 static const char always_inserted_off
[] = "off";
298 static const char *always_inserted_enums
[] = {
299 always_inserted_auto
,
304 static const char *always_inserted_mode
= always_inserted_auto
;
306 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
307 struct cmd_list_element
*c
, const char *value
)
309 if (always_inserted_mode
== always_inserted_auto
)
310 fprintf_filtered (file
, _("\
311 Always inserted breakpoint mode is %s (currently %s).\n"),
313 breakpoints_always_inserted_mode () ? "on" : "off");
315 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
319 breakpoints_always_inserted_mode (void)
321 return (always_inserted_mode
== always_inserted_on
322 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
325 void _initialize_breakpoint (void);
327 /* Are we executing breakpoint commands? */
328 static int executing_breakpoint_commands
;
330 /* Are overlay event breakpoints enabled? */
331 static int overlay_events_enabled
;
333 /* Walk the following statement or block through all breakpoints.
334 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
337 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
339 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
340 for (B = breakpoint_chain; \
341 B ? (TMP=B->next, 1): 0; \
344 /* Similar iterator for the low-level breakpoints. SAFE variant is not
345 provided so update_global_location_list must not be called while executing
346 the block of ALL_BP_LOCATIONS. */
348 #define ALL_BP_LOCATIONS(B,BP_TMP) \
349 for (BP_TMP = bp_location; \
350 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
353 /* Iterator for tracepoints only. */
355 #define ALL_TRACEPOINTS(B) \
356 for (B = breakpoint_chain; B; B = B->next) \
357 if (tracepoint_type (B))
359 /* Chains of all breakpoints defined. */
361 struct breakpoint
*breakpoint_chain
;
363 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
365 static struct bp_location
**bp_location
;
367 /* Number of elements of BP_LOCATION. */
369 static unsigned bp_location_count
;
371 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and ADDRESS
372 for the current elements of BP_LOCATION which get a valid result from
373 bp_location_has_shadow. You can use it for roughly limiting the subrange of
374 BP_LOCATION to scan for shadow bytes for an address you need to read. */
376 static CORE_ADDR bp_location_placed_address_before_address_max
;
378 /* Maximum offset plus alignment between
379 bp_target_info.PLACED_ADDRESS + bp_target_info.SHADOW_LEN and ADDRESS for
380 the current elements of BP_LOCATION which get a valid result from
381 bp_location_has_shadow. You can use it for roughly limiting the subrange of
382 BP_LOCATION to scan for shadow bytes for an address you need to read. */
384 static CORE_ADDR bp_location_shadow_len_after_address_max
;
386 /* The locations that no longer correspond to any breakpoint,
387 unlinked from bp_location array, but for which a hit
388 may still be reported by a target. */
389 VEC(bp_location_p
) *moribund_locations
= NULL
;
391 /* Number of last breakpoint made. */
393 int breakpoint_count
;
395 /* Number of last tracepoint made. */
397 int tracepoint_count
;
399 /* Return whether a breakpoint is an active enabled breakpoint. */
401 breakpoint_enabled (struct breakpoint
*b
)
403 return (b
->enable_state
== bp_enabled
);
406 /* Set breakpoint count to NUM. */
409 set_breakpoint_count (int num
)
411 breakpoint_count
= num
;
412 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
415 /* Used in run_command to zero the hit count when a new run starts. */
418 clear_breakpoint_hit_counts (void)
420 struct breakpoint
*b
;
426 /* Encapsulate tests for different types of tracepoints. */
429 tracepoint_type (const struct breakpoint
*b
)
431 return (b
->type
== bp_tracepoint
|| b
->type
== bp_fast_tracepoint
);
434 /* Default address, symtab and line to put a breakpoint at
435 for "break" command with no arg.
436 if default_breakpoint_valid is zero, the other three are
437 not valid, and "break" with no arg is an error.
439 This set by print_stack_frame, which calls set_default_breakpoint. */
441 int default_breakpoint_valid
;
442 CORE_ADDR default_breakpoint_address
;
443 struct symtab
*default_breakpoint_symtab
;
444 int default_breakpoint_line
;
445 struct program_space
*default_breakpoint_pspace
;
448 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
449 Advance *PP after the string and any trailing whitespace.
451 Currently the string can either be a number or "$" followed by the name
452 of a convenience variable. Making it an expression wouldn't work well
453 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
455 If the string is a NULL pointer, that denotes the last breakpoint.
457 TRAILER is a character which can be found after the number; most
458 commonly this is `-'. If you don't want a trailer, use \0. */
460 get_number_trailer (char **pp
, int trailer
)
462 int retval
= 0; /* default */
466 /* Empty line means refer to the last breakpoint. */
467 return breakpoint_count
;
470 /* Make a copy of the name, so we can null-terminate it
471 to pass to lookup_internalvar(). */
476 while (isalnum (*p
) || *p
== '_')
478 varname
= (char *) alloca (p
- start
+ 1);
479 strncpy (varname
, start
, p
- start
);
480 varname
[p
- start
] = '\0';
481 if (get_internalvar_integer (lookup_internalvar (varname
), &val
))
485 printf_filtered (_("Convenience variable must have integer value.\n"));
493 while (*p
>= '0' && *p
<= '9')
496 /* There is no number here. (e.g. "cond a == b"). */
498 /* Skip non-numeric token */
499 while (*p
&& !isspace((int) *p
))
501 /* Return zero, which caller must interpret as error. */
507 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
509 /* Trailing junk: return 0 and let caller print error msg. */
510 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
521 /* Like get_number_trailer, but don't allow a trailer. */
523 get_number (char **pp
)
525 return get_number_trailer (pp
, '\0');
528 /* Parse a number or a range.
529 * A number will be of the form handled by get_number.
530 * A range will be of the form <number1> - <number2>, and
531 * will represent all the integers between number1 and number2,
534 * While processing a range, this fuction is called iteratively;
535 * At each call it will return the next value in the range.
537 * At the beginning of parsing a range, the char pointer PP will
538 * be advanced past <number1> and left pointing at the '-' token.
539 * Subsequent calls will not advance the pointer until the range
540 * is completed. The call that completes the range will advance
541 * pointer PP past <number2>.
545 get_number_or_range (char **pp
)
547 static int last_retval
, end_value
;
548 static char *end_ptr
;
549 static int in_range
= 0;
553 /* Default case: pp is pointing either to a solo number,
554 or to the first number of a range. */
555 last_retval
= get_number_trailer (pp
, '-');
560 /* This is the start of a range (<number1> - <number2>).
561 Skip the '-', parse and remember the second number,
562 and also remember the end of the final token. */
566 while (isspace ((int) *end_ptr
))
567 end_ptr
++; /* skip white space */
568 end_value
= get_number (temp
);
569 if (end_value
< last_retval
)
571 error (_("inverted range"));
573 else if (end_value
== last_retval
)
575 /* degenerate range (number1 == number2). Advance the
576 token pointer so that the range will be treated as a
585 error (_("negative value"));
588 /* pp points to the '-' that betokens a range. All
589 number-parsing has already been done. Return the next
590 integer value (one greater than the saved previous value).
591 Do not advance the token pointer 'pp' until the end of range
594 if (++last_retval
== end_value
)
596 /* End of range reached; advance token pointer. */
604 /* Return the breakpoint with the specified number, or NULL
605 if the number does not refer to an existing breakpoint. */
608 get_breakpoint (int num
)
610 struct breakpoint
*b
;
613 if (b
->number
== num
)
620 /* condition N EXP -- set break condition of breakpoint N to EXP. */
623 condition_command (char *arg
, int from_tty
)
625 struct breakpoint
*b
;
630 error_no_arg (_("breakpoint number"));
633 bnum
= get_number (&p
);
635 error (_("Bad breakpoint argument: '%s'"), arg
);
638 if (b
->number
== bnum
)
640 struct bp_location
*loc
= b
->loc
;
641 for (; loc
; loc
= loc
->next
)
649 if (b
->cond_string
!= NULL
)
650 xfree (b
->cond_string
);
654 b
->cond_string
= NULL
;
656 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
661 /* I don't know if it matters whether this is the string the user
662 typed in or the decompiled expression. */
663 b
->cond_string
= xstrdup (arg
);
664 b
->condition_not_parsed
= 0;
665 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
669 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
671 error (_("Junk at end of expression"));
674 breakpoints_changed ();
675 observer_notify_breakpoint_modified (b
->number
);
679 error (_("No breakpoint number %d."), bnum
);
682 /* Set the command list of B to COMMANDS. */
685 breakpoint_set_commands (struct breakpoint
*b
, struct command_line
*commands
)
687 free_command_lines (&b
->commands
);
688 b
->commands
= commands
;
689 breakpoints_changed ();
690 observer_notify_breakpoint_modified (b
->number
);
694 commands_command (char *arg
, int from_tty
)
696 struct breakpoint
*b
;
699 struct command_line
*l
;
701 /* If we allowed this, we would have problems with when to
702 free the storage, if we change the commands currently
705 if (executing_breakpoint_commands
)
706 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
709 bnum
= get_number (&p
);
712 error (_("Unexpected extra arguments following breakpoint number."));
715 if (b
->number
== bnum
)
717 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
719 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
720 l
= read_command_lines (tmpbuf
, from_tty
, 1);
721 do_cleanups (cleanups
);
722 breakpoint_set_commands (b
, l
);
725 error (_("No breakpoint number %d."), bnum
);
728 /* Like commands_command, but instead of reading the commands from
729 input stream, takes them from an already parsed command structure.
731 This is used by cli-script.c to DTRT with breakpoint commands
732 that are part of if and while bodies. */
733 enum command_control_type
734 commands_from_control_command (char *arg
, struct command_line
*cmd
)
736 struct breakpoint
*b
;
740 /* If we allowed this, we would have problems with when to
741 free the storage, if we change the commands currently
744 if (executing_breakpoint_commands
)
745 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
747 /* An empty string for the breakpoint number means the last
748 breakpoint, but get_number expects a NULL pointer. */
753 bnum
= get_number (&p
);
756 error (_("Unexpected extra arguments following breakpoint number."));
759 if (b
->number
== bnum
)
761 free_command_lines (&b
->commands
);
762 if (cmd
->body_count
!= 1)
763 error (_("Invalid \"commands\" block structure."));
764 /* We need to copy the commands because if/while will free the
765 list after it finishes execution. */
766 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
767 breakpoints_changed ();
768 observer_notify_breakpoint_modified (b
->number
);
769 return simple_control
;
771 error (_("No breakpoint number %d."), bnum
);
774 /* Return non-zero if BL->TARGET_INFO contains valid information. */
777 bp_location_has_shadow (struct bp_location
*bl
)
779 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
783 if (bl
->target_info
.shadow_len
== 0)
784 /* bp isn't valid, or doesn't shadow memory. */
789 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
790 by replacing any memory breakpoints with their shadowed contents.
792 The range of shadowed area by each bp_location is:
793 b->address - bp_location_placed_address_before_address_max
794 up to b->address + bp_location_shadow_len_after_address_max
795 The range we were requested to resolve shadows for is:
796 memaddr ... memaddr + len
797 Thus the safe cutoff boundaries for performance optimization are
798 memaddr + len <= b->address - bp_location_placed_address_before_address_max
800 b->address + bp_location_shadow_len_after_address_max <= memaddr */
803 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
805 /* Left boundary, right boundary and median element of our binary search. */
806 unsigned bc_l
, bc_r
, bc
;
808 /* Find BC_L which is a leftmost element which may affect BUF content. It is
809 safe to report lower value but a failure to report higher one. */
812 bc_r
= bp_location_count
;
813 while (bc_l
+ 1 < bc_r
)
815 struct bp_location
*b
;
817 bc
= (bc_l
+ bc_r
) / 2;
820 /* Check first B->ADDRESS will not overflow due to the added constant.
821 Then advance the left boundary only if we are sure the BC element can
822 in no way affect the BUF content (MEMADDR to MEMADDR + LEN range).
824 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety offset so that
825 we cannot miss a breakpoint with its shadow range tail still reaching
828 if (b
->address
+ bp_location_shadow_len_after_address_max
>= b
->address
829 && b
->address
+ bp_location_shadow_len_after_address_max
<= memaddr
)
835 /* Now do full processing of the found relevant range of elements. */
837 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
839 struct bp_location
*b
= bp_location
[bc
];
840 CORE_ADDR bp_addr
= 0;
844 if (b
->owner
->type
== bp_none
)
845 warning (_("reading through apparently deleted breakpoint #%d?"),
848 /* Performance optimization: any futher element can no longer affect BUF
851 if (b
->address
>= bp_location_placed_address_before_address_max
852 && memaddr
+ len
<= b
->address
853 - bp_location_placed_address_before_address_max
)
856 if (!bp_location_has_shadow (b
))
858 if (!breakpoint_address_match (b
->target_info
.placed_address_space
, 0,
859 current_program_space
->aspace
, 0))
862 /* Addresses and length of the part of the breakpoint that
864 bp_addr
= b
->target_info
.placed_address
;
865 bp_size
= b
->target_info
.shadow_len
;
867 if (bp_addr
+ bp_size
<= memaddr
)
868 /* The breakpoint is entirely before the chunk of memory we
872 if (bp_addr
>= memaddr
+ len
)
873 /* The breakpoint is entirely after the chunk of memory we are
877 /* Offset within shadow_contents. */
878 if (bp_addr
< memaddr
)
880 /* Only copy the second part of the breakpoint. */
881 bp_size
-= memaddr
- bp_addr
;
882 bptoffset
= memaddr
- bp_addr
;
886 if (bp_addr
+ bp_size
> memaddr
+ len
)
888 /* Only copy the first part of the breakpoint. */
889 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
892 memcpy (buf
+ bp_addr
- memaddr
,
893 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
898 /* A wrapper function for inserting catchpoints. */
900 insert_catchpoint (struct ui_out
*uo
, void *args
)
902 struct breakpoint
*b
= (struct breakpoint
*) args
;
905 gdb_assert (b
->type
== bp_catchpoint
);
906 gdb_assert (b
->ops
!= NULL
&& b
->ops
->insert
!= NULL
);
912 is_hardware_watchpoint (struct breakpoint
*bpt
)
914 return (bpt
->type
== bp_hardware_watchpoint
915 || bpt
->type
== bp_read_watchpoint
916 || bpt
->type
== bp_access_watchpoint
);
919 /* Find the current value of a watchpoint on EXP. Return the value in
920 *VALP and *RESULTP and the chain of intermediate and final values
921 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
924 If a memory error occurs while evaluating the expression, *RESULTP will
925 be set to NULL. *RESULTP may be a lazy value, if the result could
926 not be read from memory. It is used to determine whether a value
927 is user-specified (we should watch the whole value) or intermediate
928 (we should watch only the bit used to locate the final value).
930 If the final value, or any intermediate value, could not be read
931 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
932 set to any referenced values. *VALP will never be a lazy value.
933 This is the value which we store in struct breakpoint.
935 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
936 value chain. The caller must free the values individually. If
937 VAL_CHAIN is NULL, all generated values will be left on the value
941 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
942 struct value
**resultp
, struct value
**val_chain
)
944 struct value
*mark
, *new_mark
, *result
;
945 volatile struct gdb_exception ex
;
953 /* Evaluate the expression. */
954 mark
= value_mark ();
957 TRY_CATCH (ex
, RETURN_MASK_ALL
)
959 result
= evaluate_expression (exp
);
963 /* Ignore memory errors, we want watchpoints pointing at
964 inaccessible memory to still be created; otherwise, throw the
965 error to some higher catcher. */
971 throw_exception (ex
);
976 new_mark
= value_mark ();
977 if (mark
== new_mark
)
982 /* Make sure it's not lazy, so that after the target stops again we
983 have a non-lazy previous value to compare with. */
985 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
990 /* Return the chain of intermediate values. We use this to
991 decide which addresses to watch. */
992 *val_chain
= new_mark
;
993 value_release_to_mark (mark
);
997 /* Assuming that B is a watchpoint: returns true if the current thread
998 and its running state are safe to evaluate or update watchpoint B.
999 Watchpoints on local expressions need to be evaluated in the
1000 context of the thread that was current when the watchpoint was
1001 created, and, that thread needs to be stopped to be able to select
1002 the correct frame context. Watchpoints on global expressions can
1003 be evaluated on any thread, and in any state. It is presently left
1004 to the target allowing memory accesses when threads are
1008 watchpoint_in_thread_scope (struct breakpoint
*b
)
1010 return (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1011 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1012 && !is_executing (inferior_ptid
)));
1015 /* Assuming that B is a watchpoint:
1016 - Reparse watchpoint expression, if REPARSE is non-zero
1017 - Evaluate expression and store the result in B->val
1018 - Evaluate the condition if there is one, and store the result
1020 - Update the list of values that must be watched in B->loc.
1022 If the watchpoint disposition is disp_del_at_next_stop, then do nothing.
1023 If this is local watchpoint that is out of scope, delete it.
1025 Even with `set breakpoint always-inserted on' the watchpoints are removed
1026 + inserted on each stop here. Normal breakpoints must never be removed
1027 because they might be missed by a running thread when debugging in non-stop
1028 mode. On the other hand, hardware watchpoints (is_hardware_watchpoint;
1029 processed here) are specific to each LWP since they are stored in each LWP's
1030 hardware debug registers. Therefore, such LWP must be stopped first in
1031 order to be able to modify its hardware watchpoints.
1033 Hardware watchpoints must be reset exactly once after being presented to the
1034 user. It cannot be done sooner, because it would reset the data used to
1035 present the watchpoint hit to the user. And it must not be done later
1036 because it could display the same single watchpoint hit during multiple GDB
1037 stops. Note that the latter is relevant only to the hardware watchpoint
1038 types bp_read_watchpoint and bp_access_watchpoint. False hit by
1039 bp_hardware_watchpoint is not user-visible - its hit is suppressed if the
1040 memory content has not changed.
1042 The following constraints influence the location where we can reset hardware
1045 * target_stopped_by_watchpoint and target_stopped_data_address are called
1046 several times when GDB stops.
1049 * Multiple hardware watchpoints can be hit at the same time, causing GDB to
1050 stop. GDB only presents one hardware watchpoint hit at a time as the
1051 reason for stopping, and all the other hits are presented later, one after
1052 the other, each time the user requests the execution to be resumed.
1053 Execution is not resumed for the threads still having pending hit event
1054 stored in LWP_INFO->STATUS. While the watchpoint is already removed from
1055 the inferior on the first stop the thread hit event is kept being reported
1056 from its cached value by linux_nat_stopped_data_address until the real
1057 thread resume happens after the watchpoint gets presented and thus its
1058 LWP_INFO->STATUS gets reset.
1060 Therefore the hardware watchpoint hit can get safely reset on the watchpoint
1061 removal from inferior. */
1064 update_watchpoint (struct breakpoint
*b
, int reparse
)
1066 int within_current_scope
;
1067 struct frame_id saved_frame_id
;
1068 struct bp_location
*loc
;
1072 /* If this is a local watchpoint, we only want to check if the
1073 watchpoint frame is in scope if the current thread is the thread
1074 that was used to create the watchpoint. */
1075 if (!watchpoint_in_thread_scope (b
))
1078 /* We don't free locations. They are stored in bp_location array and
1079 update_global_locations will eventually delete them and remove
1080 breakpoints if needed. */
1083 if (b
->disposition
== disp_del_at_next_stop
)
1088 /* Determine if the watchpoint is within scope. */
1089 if (b
->exp_valid_block
== NULL
)
1090 within_current_scope
= 1;
1093 struct frame_info
*fi
;
1095 /* Save the current frame's ID so we can restore it after
1096 evaluating the watchpoint expression on its own frame. */
1097 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1098 took a frame parameter, so that we didn't have to change the
1101 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1103 fi
= frame_find_by_id (b
->watchpoint_frame
);
1104 within_current_scope
= (fi
!= NULL
);
1105 if (within_current_scope
)
1109 if (within_current_scope
&& reparse
)
1118 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1119 /* If the meaning of expression itself changed, the old value is
1120 no longer relevant. We don't want to report a watchpoint hit
1121 to the user when the old value and the new value may actually
1122 be completely different objects. */
1123 value_free (b
->val
);
1128 /* If we failed to parse the expression, for example because
1129 it refers to a global variable in a not-yet-loaded shared library,
1130 don't try to insert watchpoint. We don't automatically delete
1131 such watchpoint, though, since failure to parse expression
1132 is different from out-of-scope watchpoint. */
1133 if ( !target_has_execution
)
1135 /* Without execution, memory can't change. No use to try and
1136 set watchpoint locations. The watchpoint will be reset when
1137 the target gains execution, through breakpoint_re_set. */
1139 else if (within_current_scope
&& b
->exp
)
1141 struct value
*val_chain
, *v
, *result
, *next
;
1142 struct program_space
*frame_pspace
;
1144 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
1146 /* Avoid setting b->val if it's already set. The meaning of
1147 b->val is 'the last value' user saw, and we should update
1148 it only if we reported that last value to user. As it
1149 happens, the code that reports it updates b->val directly. */
1156 /* Change the type of breakpoint between hardware assisted or an
1157 ordinary watchpoint depending on the hardware support and free
1158 hardware slots. REPARSE is set when the inferior is started. */
1159 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
1162 int i
, mem_cnt
, other_type_used
;
1164 /* We need to determine how many resources are already used
1165 for all other hardware watchpoints to see if we still have
1166 enough resources to also fit this watchpoint in as well.
1167 To avoid the hw_watchpoint_used_count call below from counting
1168 this watchpoint, make sure that it is marked as a software
1170 b
->type
= bp_watchpoint
;
1171 i
= hw_watchpoint_used_count (bp_hardware_watchpoint
,
1173 mem_cnt
= can_use_hardware_watchpoint (val_chain
);
1176 b
->type
= bp_watchpoint
;
1179 int target_resources_ok
= target_can_use_hardware_watchpoint
1180 (bp_hardware_watchpoint
, i
+ mem_cnt
, other_type_used
);
1181 if (target_resources_ok
<= 0)
1182 b
->type
= bp_watchpoint
;
1184 b
->type
= bp_hardware_watchpoint
;
1188 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1190 /* Look at each value on the value chain. */
1191 for (v
= val_chain
; v
; v
= next
)
1193 /* If it's a memory location, and GDB actually needed
1194 its contents to evaluate the expression, then we
1195 must watch it. If the first value returned is
1196 still lazy, that means an error occurred reading it;
1197 watch it anyway in case it becomes readable. */
1198 if (VALUE_LVAL (v
) == lval_memory
1199 && (v
== val_chain
|| ! value_lazy (v
)))
1201 struct type
*vtype
= check_typedef (value_type (v
));
1203 /* We only watch structs and arrays if user asked
1204 for it explicitly, never if they just happen to
1205 appear in the middle of some value chain. */
1207 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1208 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1212 struct bp_location
*loc
, **tmp
;
1214 addr
= value_address (v
);
1215 len
= TYPE_LENGTH (value_type (v
));
1217 if (b
->type
== bp_read_watchpoint
)
1219 else if (b
->type
== bp_access_watchpoint
)
1222 loc
= allocate_bp_location (b
);
1223 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1226 loc
->gdbarch
= get_type_arch (value_type (v
));
1228 loc
->pspace
= frame_pspace
;
1229 loc
->address
= addr
;
1231 loc
->watchpoint_type
= type
;
1235 next
= value_next (v
);
1240 /* If a software watchpoint is not watching any memory, then the
1241 above left it without any location set up. But,
1242 bpstat_stop_status requires a location to be able to report
1243 stops, so make sure there's at least a dummy one. */
1244 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
1246 b
->loc
= allocate_bp_location (b
);
1247 b
->loc
->pspace
= frame_pspace
;
1248 b
->loc
->address
= -1;
1249 b
->loc
->length
= -1;
1250 b
->loc
->watchpoint_type
= -1;
1253 /* We just regenerated the list of breakpoint locations.
1254 The new location does not have its condition field set to anything
1255 and therefore, we must always reparse the cond_string, independently
1256 of the value of the reparse flag. */
1257 if (b
->cond_string
!= NULL
)
1259 char *s
= b
->cond_string
;
1260 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1263 else if (!within_current_scope
)
1265 printf_filtered (_("\
1266 Watchpoint %d deleted because the program has left the block \n\
1267 in which its expression is valid.\n"),
1269 if (b
->related_breakpoint
)
1270 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1271 b
->disposition
= disp_del_at_next_stop
;
1274 /* Restore the selected frame. */
1276 select_frame (frame_find_by_id (saved_frame_id
));
1280 /* Returns 1 iff breakpoint location should be
1281 inserted in the inferior. */
1283 should_be_inserted (struct bp_location
*bpt
)
1285 if (!breakpoint_enabled (bpt
->owner
))
1288 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
1291 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1294 /* This is set for example, when we're attached to the parent of a
1295 vfork, and have detached from the child. The child is running
1296 free, and we expect it to do an exec or exit, at which point the
1297 OS makes the parent schedulable again (and the target reports
1298 that the vfork is done). Until the child is done with the shared
1299 memory region, do not insert breakpoints in the parent, otherwise
1300 the child could still trip on the parent's breakpoints. Since
1301 the parent is blocked anyway, it won't miss any breakpoint. */
1302 if (bpt
->pspace
->breakpoints_not_allowed
)
1305 /* Tracepoints are inserted by the target at a time of its choosing,
1307 if (tracepoint_type (bpt
->owner
))
1313 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1314 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1315 and HW_BREAKPOINT_ERROR are used to report problems.
1317 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1318 method for each breakpoint or catchpoint type. */
1320 insert_bp_location (struct bp_location
*bpt
,
1321 struct ui_file
*tmp_error_stream
,
1322 int *disabled_breaks
,
1323 int *hw_breakpoint_error
)
1327 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1330 /* Initialize the target-specific information. */
1331 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1332 bpt
->target_info
.placed_address
= bpt
->address
;
1333 bpt
->target_info
.placed_address_space
= bpt
->pspace
->aspace
;
1335 if (bpt
->loc_type
== bp_loc_software_breakpoint
1336 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1338 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1340 /* If the explicitly specified breakpoint type
1341 is not hardware breakpoint, check the memory map to see
1342 if the breakpoint address is in read only memory or not.
1343 Two important cases are:
1344 - location type is not hardware breakpoint, memory
1345 is readonly. We change the type of the location to
1346 hardware breakpoint.
1347 - location type is hardware breakpoint, memory is read-write.
1348 This means we've previously made the location hardware one, but
1349 then the memory map changed, so we undo.
1351 When breakpoints are removed, remove_breakpoints will
1352 use location types we've just set here, the only possible
1353 problem is that memory map has changed during running program,
1354 but it's not going to work anyway with current gdb. */
1355 struct mem_region
*mr
1356 = lookup_mem_region (bpt
->target_info
.placed_address
);
1360 if (automatic_hardware_breakpoints
)
1363 enum bp_loc_type new_type
;
1365 if (mr
->attrib
.mode
!= MEM_RW
)
1366 new_type
= bp_loc_hardware_breakpoint
;
1368 new_type
= bp_loc_software_breakpoint
;
1370 if (new_type
!= bpt
->loc_type
)
1372 static int said
= 0;
1373 bpt
->loc_type
= new_type
;
1376 fprintf_filtered (gdb_stdout
, _("\
1377 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1382 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1383 && mr
->attrib
.mode
!= MEM_RW
)
1384 warning (_("cannot set software breakpoint at readonly address %s"),
1385 paddress (bpt
->gdbarch
, bpt
->address
));
1389 /* First check to see if we have to handle an overlay. */
1390 if (overlay_debugging
== ovly_off
1391 || bpt
->section
== NULL
1392 || !(section_is_overlay (bpt
->section
)))
1394 /* No overlay handling: just set the breakpoint. */
1396 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1397 val
= target_insert_hw_breakpoint (bpt
->gdbarch
,
1400 val
= target_insert_breakpoint (bpt
->gdbarch
,
1405 /* This breakpoint is in an overlay section.
1406 Shall we set a breakpoint at the LMA? */
1407 if (!overlay_events_enabled
)
1409 /* Yes -- overlay event support is not active,
1410 so we must try to set a breakpoint at the LMA.
1411 This will not work for a hardware breakpoint. */
1412 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1413 warning (_("hardware breakpoint %d not supported in overlay!"),
1414 bpt
->owner
->number
);
1417 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1419 /* Set a software (trap) breakpoint at the LMA. */
1420 bpt
->overlay_target_info
= bpt
->target_info
;
1421 bpt
->overlay_target_info
.placed_address
= addr
;
1422 val
= target_insert_breakpoint (bpt
->gdbarch
,
1423 &bpt
->overlay_target_info
);
1425 fprintf_unfiltered (tmp_error_stream
,
1426 "Overlay breakpoint %d failed: in ROM?\n",
1427 bpt
->owner
->number
);
1430 /* Shall we set a breakpoint at the VMA? */
1431 if (section_is_mapped (bpt
->section
))
1433 /* Yes. This overlay section is mapped into memory. */
1434 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1435 val
= target_insert_hw_breakpoint (bpt
->gdbarch
,
1438 val
= target_insert_breakpoint (bpt
->gdbarch
,
1443 /* No. This breakpoint will not be inserted.
1444 No error, but do not mark the bp as 'inserted'. */
1451 /* Can't set the breakpoint. */
1452 if (solib_name_from_address (bpt
->pspace
, bpt
->address
))
1454 /* See also: disable_breakpoints_in_shlibs. */
1456 bpt
->shlib_disabled
= 1;
1457 if (!*disabled_breaks
)
1459 fprintf_unfiltered (tmp_error_stream
,
1460 "Cannot insert breakpoint %d.\n",
1461 bpt
->owner
->number
);
1462 fprintf_unfiltered (tmp_error_stream
,
1463 "Temporarily disabling shared library breakpoints:\n");
1465 *disabled_breaks
= 1;
1466 fprintf_unfiltered (tmp_error_stream
,
1467 "breakpoint #%d\n", bpt
->owner
->number
);
1471 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1473 *hw_breakpoint_error
= 1;
1474 fprintf_unfiltered (tmp_error_stream
,
1475 "Cannot insert hardware breakpoint %d.\n",
1476 bpt
->owner
->number
);
1480 fprintf_unfiltered (tmp_error_stream
,
1481 "Cannot insert breakpoint %d.\n",
1482 bpt
->owner
->number
);
1483 fprintf_filtered (tmp_error_stream
,
1484 "Error accessing memory address ");
1485 fputs_filtered (paddress (bpt
->gdbarch
, bpt
->address
),
1487 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1488 safe_strerror (val
));
1499 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1500 /* NOTE drow/2003-09-08: This state only exists for removing
1501 watchpoints. It's not clear that it's necessary... */
1502 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1504 val
= target_insert_watchpoint (bpt
->address
,
1506 bpt
->watchpoint_type
);
1508 /* If trying to set a read-watchpoint, and it turns out it's not
1509 supported, try emulating one with an access watchpoint. */
1510 if (val
== 1 && bpt
->watchpoint_type
== hw_read
)
1512 struct bp_location
*loc
, **loc_temp
;
1514 /* But don't try to insert it, if there's already another
1515 hw_access location that would be considered a duplicate
1517 ALL_BP_LOCATIONS (loc
, loc_temp
)
1519 && loc
->watchpoint_type
== hw_access
1520 && watchpoint_locations_match (bpt
, loc
))
1524 bpt
->target_info
= loc
->target_info
;
1525 bpt
->watchpoint_type
= hw_access
;
1532 val
= target_insert_watchpoint (bpt
->address
,
1536 bpt
->watchpoint_type
= hw_access
;
1540 bpt
->inserted
= (val
== 0);
1543 else if (bpt
->owner
->type
== bp_catchpoint
)
1545 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1546 bpt
->owner
, RETURN_MASK_ERROR
);
1547 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1548 bpt
->owner
->number
);
1550 bpt
->owner
->enable_state
= bp_disabled
;
1554 /* We've already printed an error message if there was a problem
1555 inserting this catchpoint, and we've disabled the catchpoint,
1556 so just return success. */
1563 /* This function is called when program space PSPACE is about to be
1564 deleted. It takes care of updating breakpoints to not reference
1568 breakpoint_program_space_exit (struct program_space
*pspace
)
1570 struct breakpoint
*b
, *b_temp
;
1571 struct bp_location
*loc
, **loc_temp
;
1573 /* Remove any breakpoint that was set through this program space. */
1574 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1576 if (b
->pspace
== pspace
)
1577 delete_breakpoint (b
);
1580 /* Breakpoints set through other program spaces could have locations
1581 bound to PSPACE as well. Remove those. */
1582 ALL_BP_LOCATIONS (loc
, loc_temp
)
1584 struct bp_location
*tmp
;
1586 if (loc
->pspace
== pspace
)
1588 if (loc
->owner
->loc
== loc
)
1589 loc
->owner
->loc
= loc
->next
;
1591 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1592 if (tmp
->next
== loc
)
1594 tmp
->next
= loc
->next
;
1600 /* Now update the global location list to permanently delete the
1601 removed locations above. */
1602 update_global_location_list (0);
1605 /* Make sure all breakpoints are inserted in inferior.
1606 Throws exception on any error.
1607 A breakpoint that is already inserted won't be inserted
1608 again, so calling this function twice is safe. */
1610 insert_breakpoints (void)
1612 struct breakpoint
*bpt
;
1614 ALL_BREAKPOINTS (bpt
)
1615 if (is_hardware_watchpoint (bpt
))
1616 update_watchpoint (bpt
, 0 /* don't reparse. */);
1618 update_global_location_list (1);
1620 /* update_global_location_list does not insert breakpoints when
1621 always_inserted_mode is not enabled. Explicitly insert them
1623 if (!breakpoints_always_inserted_mode ())
1624 insert_breakpoint_locations ();
1627 /* insert_breakpoints is used when starting or continuing the program.
1628 remove_breakpoints is used when the program stops.
1629 Both return zero if successful,
1630 or an `errno' value if could not write the inferior. */
1633 insert_breakpoint_locations (void)
1635 struct breakpoint
*bpt
;
1636 struct bp_location
*b
, **bp_tmp
;
1639 int disabled_breaks
= 0;
1640 int hw_breakpoint_error
= 0;
1642 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1643 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1645 /* Explicitly mark the warning -- this will only be printed if
1646 there was an error. */
1647 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1649 save_current_space_and_thread ();
1651 ALL_BP_LOCATIONS (b
, bp_tmp
)
1653 struct thread_info
*tp
;
1654 CORE_ADDR last_addr
;
1656 if (!should_be_inserted (b
) || b
->inserted
)
1659 /* There is no point inserting thread-specific breakpoints if the
1660 thread no longer exists. */
1661 if (b
->owner
->thread
!= -1
1662 && !valid_thread_id (b
->owner
->thread
))
1665 switch_to_program_space_and_thread (b
->pspace
);
1667 /* For targets that support global breakpoints, there's no need
1668 to select an inferior to insert breakpoint to. In fact, even
1669 if we aren't attached to any process yet, we should still
1670 insert breakpoints. */
1671 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
1672 && ptid_equal (inferior_ptid
, null_ptid
))
1675 val
= insert_bp_location (b
, tmp_error_stream
,
1677 &hw_breakpoint_error
);
1682 /* If we failed to insert all locations of a watchpoint,
1683 remove them, as half-inserted watchpoint is of limited use. */
1684 ALL_BREAKPOINTS (bpt
)
1686 int some_failed
= 0;
1687 struct bp_location
*loc
;
1689 if (!is_hardware_watchpoint (bpt
))
1692 if (!breakpoint_enabled (bpt
))
1695 if (bpt
->disposition
== disp_del_at_next_stop
)
1698 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1699 if (!loc
->inserted
&& should_be_inserted (loc
))
1706 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1708 remove_breakpoint (loc
, mark_uninserted
);
1710 hw_breakpoint_error
= 1;
1711 fprintf_unfiltered (tmp_error_stream
,
1712 "Could not insert hardware watchpoint %d.\n",
1720 /* If a hardware breakpoint or watchpoint was inserted, add a
1721 message about possibly exhausted resources. */
1722 if (hw_breakpoint_error
)
1724 fprintf_unfiltered (tmp_error_stream
,
1725 "Could not insert hardware breakpoints:\n\
1726 You may have requested too many hardware breakpoints/watchpoints.\n");
1728 target_terminal_ours_for_output ();
1729 error_stream (tmp_error_stream
);
1732 do_cleanups (cleanups
);
1736 remove_breakpoints (void)
1738 struct bp_location
*b
, **bp_tmp
;
1741 ALL_BP_LOCATIONS (b
, bp_tmp
)
1744 val
|= remove_breakpoint (b
, mark_uninserted
);
1749 /* Remove breakpoints of process PID. */
1752 remove_breakpoints_pid (int pid
)
1754 struct bp_location
*b
, **b_tmp
;
1756 struct inferior
*inf
= find_inferior_pid (pid
);
1758 ALL_BP_LOCATIONS (b
, b_tmp
)
1760 if (b
->pspace
!= inf
->pspace
)
1765 val
= remove_breakpoint (b
, mark_uninserted
);
1774 remove_hw_watchpoints (void)
1776 struct bp_location
*b
, **bp_tmp
;
1779 ALL_BP_LOCATIONS (b
, bp_tmp
)
1781 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1782 val
|= remove_breakpoint (b
, mark_uninserted
);
1788 reattach_breakpoints (int pid
)
1790 struct cleanup
*old_chain
;
1791 struct bp_location
*b
, **bp_tmp
;
1793 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1794 int dummy1
= 0, dummy2
= 0;
1795 struct inferior
*inf
;
1796 struct thread_info
*tp
;
1798 tp
= any_live_thread_of_process (pid
);
1802 inf
= find_inferior_pid (pid
);
1803 old_chain
= save_inferior_ptid ();
1805 inferior_ptid
= tp
->ptid
;
1807 make_cleanup_ui_file_delete (tmp_error_stream
);
1809 ALL_BP_LOCATIONS (b
, bp_tmp
)
1811 if (b
->pspace
!= inf
->pspace
)
1817 val
= insert_bp_location (b
, tmp_error_stream
,
1821 do_cleanups (old_chain
);
1826 do_cleanups (old_chain
);
1830 static int internal_breakpoint_number
= -1;
1832 static struct breakpoint
*
1833 create_internal_breakpoint (struct gdbarch
*gdbarch
,
1834 CORE_ADDR address
, enum bptype type
)
1836 struct symtab_and_line sal
;
1837 struct breakpoint
*b
;
1839 init_sal (&sal
); /* initialize to zeroes */
1842 sal
.section
= find_pc_overlay (sal
.pc
);
1843 sal
.pspace
= current_program_space
;
1845 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
1846 b
->number
= internal_breakpoint_number
--;
1847 b
->disposition
= disp_donttouch
;
1853 create_overlay_event_breakpoint (char *func_name
)
1855 struct objfile
*objfile
;
1857 ALL_OBJFILES (objfile
)
1859 struct breakpoint
*b
;
1860 struct minimal_symbol
*m
;
1862 m
= lookup_minimal_symbol_text (func_name
, objfile
);
1866 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
1867 SYMBOL_VALUE_ADDRESS (m
),
1869 b
->addr_string
= xstrdup (func_name
);
1871 if (overlay_debugging
== ovly_auto
)
1873 b
->enable_state
= bp_enabled
;
1874 overlay_events_enabled
= 1;
1878 b
->enable_state
= bp_disabled
;
1879 overlay_events_enabled
= 0;
1882 update_global_location_list (1);
1886 create_longjmp_master_breakpoint (char *func_name
)
1888 struct program_space
*pspace
;
1889 struct objfile
*objfile
;
1890 struct cleanup
*old_chain
;
1892 old_chain
= save_current_program_space ();
1894 ALL_PSPACES (pspace
)
1895 ALL_OBJFILES (objfile
)
1897 struct breakpoint
*b
;
1898 struct minimal_symbol
*m
;
1900 if (!gdbarch_get_longjmp_target_p (get_objfile_arch (objfile
)))
1903 set_current_program_space (pspace
);
1905 m
= lookup_minimal_symbol_text (func_name
, objfile
);
1909 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
1910 SYMBOL_VALUE_ADDRESS (m
),
1912 b
->addr_string
= xstrdup (func_name
);
1913 b
->enable_state
= bp_disabled
;
1915 update_global_location_list (1);
1917 do_cleanups (old_chain
);
1921 update_breakpoints_after_exec (void)
1923 struct breakpoint
*b
;
1924 struct breakpoint
*temp
;
1925 struct bp_location
*bploc
, **bplocp_tmp
;
1927 /* We're about to delete breakpoints from GDB's lists. If the
1928 INSERTED flag is true, GDB will try to lift the breakpoints by
1929 writing the breakpoints' "shadow contents" back into memory. The
1930 "shadow contents" are NOT valid after an exec, so GDB should not
1931 do that. Instead, the target is responsible from marking
1932 breakpoints out as soon as it detects an exec. We don't do that
1933 here instead, because there may be other attempts to delete
1934 breakpoints after detecting an exec and before reaching here. */
1935 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
1936 if (bploc
->pspace
== current_program_space
)
1937 gdb_assert (!bploc
->inserted
);
1939 ALL_BREAKPOINTS_SAFE (b
, temp
)
1941 if (b
->pspace
!= current_program_space
)
1944 /* Solib breakpoints must be explicitly reset after an exec(). */
1945 if (b
->type
== bp_shlib_event
)
1947 delete_breakpoint (b
);
1951 /* JIT breakpoints must be explicitly reset after an exec(). */
1952 if (b
->type
== bp_jit_event
)
1954 delete_breakpoint (b
);
1958 /* Thread event breakpoints must be set anew after an exec(),
1959 as must overlay event and longjmp master breakpoints. */
1960 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
1961 || b
->type
== bp_longjmp_master
)
1963 delete_breakpoint (b
);
1967 /* Step-resume breakpoints are meaningless after an exec(). */
1968 if (b
->type
== bp_step_resume
)
1970 delete_breakpoint (b
);
1974 /* Longjmp and longjmp-resume breakpoints are also meaningless
1976 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
1978 delete_breakpoint (b
);
1982 if (b
->type
== bp_catchpoint
)
1984 /* For now, none of the bp_catchpoint breakpoints need to
1985 do anything at this point. In the future, if some of
1986 the catchpoints need to something, we will need to add
1987 a new method, and call this method from here. */
1991 /* bp_finish is a special case. The only way we ought to be able
1992 to see one of these when an exec() has happened, is if the user
1993 caught a vfork, and then said "finish". Ordinarily a finish just
1994 carries them to the call-site of the current callee, by setting
1995 a temporary bp there and resuming. But in this case, the finish
1996 will carry them entirely through the vfork & exec.
1998 We don't want to allow a bp_finish to remain inserted now. But
1999 we can't safely delete it, 'cause finish_command has a handle to
2000 the bp on a bpstat, and will later want to delete it. There's a
2001 chance (and I've seen it happen) that if we delete the bp_finish
2002 here, that its storage will get reused by the time finish_command
2003 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2004 We really must allow finish_command to delete a bp_finish.
2006 In the absense of a general solution for the "how do we know
2007 it's safe to delete something others may have handles to?"
2008 problem, what we'll do here is just uninsert the bp_finish, and
2009 let finish_command delete it.
2011 (We know the bp_finish is "doomed" in the sense that it's
2012 momentary, and will be deleted as soon as finish_command sees
2013 the inferior stopped. So it doesn't matter that the bp's
2014 address is probably bogus in the new a.out, unlike e.g., the
2015 solib breakpoints.) */
2017 if (b
->type
== bp_finish
)
2022 /* Without a symbolic address, we have little hope of the
2023 pre-exec() address meaning the same thing in the post-exec()
2025 if (b
->addr_string
== NULL
)
2027 delete_breakpoint (b
);
2031 /* FIXME what about longjmp breakpoints? Re-create them here? */
2032 create_overlay_event_breakpoint ("_ovly_debug_event");
2033 create_longjmp_master_breakpoint ("longjmp");
2034 create_longjmp_master_breakpoint ("_longjmp");
2035 create_longjmp_master_breakpoint ("siglongjmp");
2036 create_longjmp_master_breakpoint ("_siglongjmp");
2040 detach_breakpoints (int pid
)
2042 struct bp_location
*b
, **bp_tmp
;
2044 struct cleanup
*old_chain
= save_inferior_ptid ();
2045 struct inferior
*inf
= current_inferior ();
2047 if (pid
== PIDGET (inferior_ptid
))
2048 error (_("Cannot detach breakpoints of inferior_ptid"));
2050 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2051 inferior_ptid
= pid_to_ptid (pid
);
2052 ALL_BP_LOCATIONS (b
, bp_tmp
)
2054 if (b
->pspace
!= inf
->pspace
)
2058 val
|= remove_breakpoint_1 (b
, mark_inserted
);
2060 do_cleanups (old_chain
);
2064 /* Remove the breakpoint location B from the current address space.
2065 Note that this is used to detach breakpoints from a child fork.
2066 When we get here, the child isn't in the inferior list, and neither
2067 do we have objects to represent its address space --- we should
2068 *not* look at b->pspace->aspace here. */
2071 remove_breakpoint_1 (struct bp_location
*b
, insertion_state_t is
)
2074 struct cleanup
*old_chain
;
2076 if (b
->owner
->enable_state
== bp_permanent
)
2077 /* Permanent breakpoints cannot be inserted or removed. */
2080 /* The type of none suggests that owner is actually deleted.
2081 This should not ever happen. */
2082 gdb_assert (b
->owner
->type
!= bp_none
);
2084 if (b
->loc_type
== bp_loc_software_breakpoint
2085 || b
->loc_type
== bp_loc_hardware_breakpoint
)
2087 /* "Normal" instruction breakpoint: either the standard
2088 trap-instruction bp (bp_breakpoint), or a
2089 bp_hardware_breakpoint. */
2091 /* First check to see if we have to handle an overlay. */
2092 if (overlay_debugging
== ovly_off
2093 || b
->section
== NULL
2094 || !(section_is_overlay (b
->section
)))
2096 /* No overlay handling: just remove the breakpoint. */
2098 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
2099 val
= target_remove_hw_breakpoint (b
->gdbarch
, &b
->target_info
);
2101 val
= target_remove_breakpoint (b
->gdbarch
, &b
->target_info
);
2105 /* This breakpoint is in an overlay section.
2106 Did we set a breakpoint at the LMA? */
2107 if (!overlay_events_enabled
)
2109 /* Yes -- overlay event support is not active, so we
2110 should have set a breakpoint at the LMA. Remove it.
2112 /* Ignore any failures: if the LMA is in ROM, we will
2113 have already warned when we failed to insert it. */
2114 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
2115 target_remove_hw_breakpoint (b
->gdbarch
,
2116 &b
->overlay_target_info
);
2118 target_remove_breakpoint (b
->gdbarch
,
2119 &b
->overlay_target_info
);
2121 /* Did we set a breakpoint at the VMA?
2122 If so, we will have marked the breakpoint 'inserted'. */
2125 /* Yes -- remove it. Previously we did not bother to
2126 remove the breakpoint if the section had been
2127 unmapped, but let's not rely on that being safe. We
2128 don't know what the overlay manager might do. */
2129 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
2130 val
= target_remove_hw_breakpoint (b
->gdbarch
,
2133 /* However, we should remove *software* breakpoints only
2134 if the section is still mapped, or else we overwrite
2135 wrong code with the saved shadow contents. */
2136 else if (section_is_mapped (b
->section
))
2137 val
= target_remove_breakpoint (b
->gdbarch
,
2144 /* No -- not inserted, so no need to remove. No error. */
2149 /* In some cases, we might not be able to remove a breakpoint
2150 in a shared library that has already been removed, but we
2151 have not yet processed the shlib unload event. */
2152 if (val
&& solib_name_from_address (b
->pspace
, b
->address
))
2157 b
->inserted
= (is
== mark_inserted
);
2159 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
2164 b
->inserted
= (is
== mark_inserted
);
2165 val
= target_remove_watchpoint (b
->address
, b
->length
,
2166 b
->watchpoint_type
);
2168 /* Failure to remove any of the hardware watchpoints comes here. */
2169 if ((is
== mark_uninserted
) && (b
->inserted
))
2170 warning (_("Could not remove hardware watchpoint %d."),
2173 else if (b
->owner
->type
== bp_catchpoint
2174 && breakpoint_enabled (b
->owner
)
2177 gdb_assert (b
->owner
->ops
!= NULL
&& b
->owner
->ops
->remove
!= NULL
);
2179 val
= b
->owner
->ops
->remove (b
->owner
);
2182 b
->inserted
= (is
== mark_inserted
);
2189 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
2192 struct cleanup
*old_chain
;
2194 if (b
->owner
->enable_state
== bp_permanent
)
2195 /* Permanent breakpoints cannot be inserted or removed. */
2198 /* The type of none suggests that owner is actually deleted.
2199 This should not ever happen. */
2200 gdb_assert (b
->owner
->type
!= bp_none
);
2202 old_chain
= save_current_space_and_thread ();
2204 switch_to_program_space_and_thread (b
->pspace
);
2206 ret
= remove_breakpoint_1 (b
, is
);
2208 do_cleanups (old_chain
);
2212 /* Clear the "inserted" flag in all breakpoints. */
2215 mark_breakpoints_out (void)
2217 struct bp_location
*bpt
, **bptp_tmp
;
2219 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2220 if (bpt
->pspace
== current_program_space
)
2224 /* Clear the "inserted" flag in all breakpoints and delete any
2225 breakpoints which should go away between runs of the program.
2227 Plus other such housekeeping that has to be done for breakpoints
2230 Note: this function gets called at the end of a run (by
2231 generic_mourn_inferior) and when a run begins (by
2232 init_wait_for_inferior). */
2237 breakpoint_init_inferior (enum inf_context context
)
2239 struct breakpoint
*b
, *temp
;
2240 struct bp_location
*bpt
, **bptp_tmp
;
2242 struct program_space
*pspace
= current_program_space
;
2244 /* If breakpoint locations are shared across processes, then there's
2246 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2249 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2251 if (bpt
->pspace
== pspace
2252 && bpt
->owner
->enable_state
!= bp_permanent
)
2256 ALL_BREAKPOINTS_SAFE (b
, temp
)
2258 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2265 /* If the call dummy breakpoint is at the entry point it will
2266 cause problems when the inferior is rerun, so we better get
2269 case bp_watchpoint_scope
:
2271 /* Also get rid of scope breakpoints. */
2273 case bp_shlib_event
:
2275 /* Also remove solib event breakpoints. Their addresses may
2276 have changed since the last time we ran the program.
2277 Actually we may now be debugging against different target;
2278 and so the solib backend that installed this breakpoint may
2279 not be used in by the target. E.g.,
2281 (gdb) file prog-linux
2282 (gdb) run # native linux target
2285 (gdb) file prog-win.exe
2286 (gdb) tar rem :9999 # remote Windows gdbserver.
2289 delete_breakpoint (b
);
2293 case bp_hardware_watchpoint
:
2294 case bp_read_watchpoint
:
2295 case bp_access_watchpoint
:
2297 /* Likewise for watchpoints on local expressions. */
2298 if (b
->exp_valid_block
!= NULL
)
2299 delete_breakpoint (b
);
2300 else if (context
== inf_starting
)
2302 /* Reset val field to force reread of starting value
2303 in insert_breakpoints. */
2305 value_free (b
->val
);
2315 /* Get rid of the moribund locations. */
2316 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bpt
); ++ix
)
2317 free_bp_location (bpt
);
2318 VEC_free (bp_location_p
, moribund_locations
);
2321 /* These functions concern about actual breakpoints inserted in the
2322 target --- to e.g. check if we need to do decr_pc adjustment or if
2323 we need to hop over the bkpt --- so we check for address space
2324 match, not program space. */
2326 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2327 exists at PC. It returns ordinary_breakpoint_here if it's an
2328 ordinary breakpoint, or permanent_breakpoint_here if it's a
2329 permanent breakpoint.
2330 - When continuing from a location with an ordinary breakpoint, we
2331 actually single step once before calling insert_breakpoints.
2332 - When continuing from a localion with a permanent breakpoint, we
2333 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2334 the target, to advance the PC past the breakpoint. */
2336 enum breakpoint_here
2337 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2339 struct bp_location
*bpt
, **bptp_tmp
;
2340 int any_breakpoint_here
= 0;
2342 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2344 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2345 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2348 if ((breakpoint_enabled (bpt
->owner
)
2349 || bpt
->owner
->enable_state
== bp_permanent
)
2350 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2353 if (overlay_debugging
2354 && section_is_overlay (bpt
->section
)
2355 && !section_is_mapped (bpt
->section
))
2356 continue; /* unmapped overlay -- can't be a match */
2357 else if (bpt
->owner
->enable_state
== bp_permanent
)
2358 return permanent_breakpoint_here
;
2360 any_breakpoint_here
= 1;
2364 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2367 /* Return true if there's a moribund breakpoint at PC. */
2370 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2372 struct bp_location
*loc
;
2375 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2376 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
2383 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2384 inserted using regular breakpoint_chain / bp_location array mechanism.
2385 This does not check for single-step breakpoints, which are
2386 inserted and removed using direct target manipulation. */
2389 regular_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2391 struct bp_location
*bpt
, **bptp_tmp
;
2393 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2395 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2396 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2400 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2403 if (overlay_debugging
2404 && section_is_overlay (bpt
->section
)
2405 && !section_is_mapped (bpt
->section
))
2406 continue; /* unmapped overlay -- can't be a match */
2414 /* Returns non-zero iff there's either regular breakpoint
2415 or a single step breakpoint inserted at PC. */
2418 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2420 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
2423 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2429 /* This function returns non-zero iff there is a software breakpoint
2433 software_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2435 struct bp_location
*bpt
, **bptp_tmp
;
2436 int any_breakpoint_here
= 0;
2438 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2440 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
2444 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2447 if (overlay_debugging
2448 && section_is_overlay (bpt
->section
)
2449 && !section_is_mapped (bpt
->section
))
2450 continue; /* unmapped overlay -- can't be a match */
2456 /* Also check for software single-step breakpoints. */
2457 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2464 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
2465 CORE_ADDR addr
, ULONGEST len
)
2467 struct breakpoint
*bpt
;
2469 ALL_BREAKPOINTS (bpt
)
2471 struct bp_location
*loc
;
2473 if (bpt
->type
!= bp_hardware_watchpoint
2474 && bpt
->type
!= bp_access_watchpoint
)
2477 if (!breakpoint_enabled (bpt
))
2480 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2481 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
2485 /* Check for intersection. */
2486 l
= max (loc
->address
, addr
);
2487 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
2495 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2496 PC is valid for process/thread PTID. */
2499 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
2502 struct bp_location
*bpt
, **bptp_tmp
;
2503 /* The thread and task IDs associated to PTID, computed lazily. */
2507 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2509 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2510 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2513 if (!breakpoint_enabled (bpt
->owner
)
2514 && bpt
->owner
->enable_state
!= bp_permanent
)
2517 if (!breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2521 if (bpt
->owner
->thread
!= -1)
2523 /* This is a thread-specific breakpoint. Check that ptid
2524 matches that thread. If thread hasn't been computed yet,
2525 it is now time to do so. */
2527 thread
= pid_to_thread_id (ptid
);
2528 if (bpt
->owner
->thread
!= thread
)
2532 if (bpt
->owner
->task
!= 0)
2534 /* This is a task-specific breakpoint. Check that ptid
2535 matches that task. If task hasn't been computed yet,
2536 it is now time to do so. */
2538 task
= ada_get_task_number (ptid
);
2539 if (bpt
->owner
->task
!= task
)
2543 if (overlay_debugging
2544 && section_is_overlay (bpt
->section
)
2545 && !section_is_mapped (bpt
->section
))
2546 continue; /* unmapped overlay -- can't be a match */
2555 /* bpstat stuff. External routines' interfaces are documented
2559 ep_is_catchpoint (struct breakpoint
*ep
)
2561 return (ep
->type
== bp_catchpoint
);
2565 bpstat_free (bpstat bs
)
2567 if (bs
->old_val
!= NULL
)
2568 value_free (bs
->old_val
);
2569 free_command_lines (&bs
->commands
);
2573 /* Clear a bpstat so that it says we are not at any breakpoint.
2574 Also free any storage that is part of a bpstat. */
2577 bpstat_clear (bpstat
*bsp
)
2594 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
2595 is part of the bpstat is copied as well. */
2598 bpstat_copy (bpstat bs
)
2602 bpstat retval
= NULL
;
2607 for (; bs
!= NULL
; bs
= bs
->next
)
2609 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
2610 memcpy (tmp
, bs
, sizeof (*tmp
));
2611 if (bs
->commands
!= NULL
)
2612 tmp
->commands
= copy_command_lines (bs
->commands
);
2613 if (bs
->old_val
!= NULL
)
2615 tmp
->old_val
= value_copy (bs
->old_val
);
2616 release_value (tmp
->old_val
);
2620 /* This is the first thing in the chain. */
2630 /* Find the bpstat associated with this breakpoint */
2633 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2638 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2640 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2646 /* Find a step_resume breakpoint associated with this bpstat.
2647 (If there are multiple step_resume bp's on the list, this function
2648 will arbitrarily pick one.)
2650 It is an error to use this function if BPSTAT doesn't contain a
2651 step_resume breakpoint.
2653 See wait_for_inferior's use of this function. */
2655 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2659 gdb_assert (bsp
!= NULL
);
2661 current_thread
= pid_to_thread_id (inferior_ptid
);
2663 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2665 if ((bsp
->breakpoint_at
!= NULL
)
2666 && (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
)
2667 && (bsp
->breakpoint_at
->owner
->thread
== current_thread
2668 || bsp
->breakpoint_at
->owner
->thread
== -1))
2669 return bsp
->breakpoint_at
->owner
;
2672 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2676 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2677 at. *BSP upon return is a bpstat which points to the remaining
2678 breakpoints stopped at (but which is not guaranteed to be good for
2679 anything but further calls to bpstat_num).
2680 Return 0 if passed a bpstat which does not indicate any breakpoints.
2681 Return -1 if stopped at a breakpoint that has been deleted since
2683 Return 1 otherwise. */
2686 bpstat_num (bpstat
*bsp
, int *num
)
2688 struct breakpoint
*b
;
2691 return 0; /* No more breakpoint values */
2693 /* We assume we'll never have several bpstats that
2694 correspond to a single breakpoint -- otherwise,
2695 this function might return the same number more
2696 than once and this will look ugly. */
2697 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2698 *bsp
= (*bsp
)->next
;
2700 return -1; /* breakpoint that's been deleted since */
2702 *num
= b
->number
; /* We have its number */
2706 /* Modify BS so that the actions will not be performed. */
2709 bpstat_clear_actions (bpstat bs
)
2711 for (; bs
!= NULL
; bs
= bs
->next
)
2713 free_command_lines (&bs
->commands
);
2714 if (bs
->old_val
!= NULL
)
2716 value_free (bs
->old_val
);
2722 /* Called when a command is about to proceed the inferior. */
2725 breakpoint_about_to_proceed (void)
2727 if (!ptid_equal (inferior_ptid
, null_ptid
))
2729 struct thread_info
*tp
= inferior_thread ();
2731 /* Allow inferior function calls in breakpoint commands to not
2732 interrupt the command list. When the call finishes
2733 successfully, the inferior will be standing at the same
2734 breakpoint as if nothing happened. */
2739 breakpoint_proceeded
= 1;
2742 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2744 cleanup_executing_breakpoints (void *ignore
)
2746 executing_breakpoint_commands
= 0;
2749 /* Execute all the commands associated with all the breakpoints at this
2750 location. Any of these commands could cause the process to proceed
2751 beyond this point, etc. We look out for such changes by checking
2752 the global "breakpoint_proceeded" after each command.
2754 Returns true if a breakpoint command resumed the inferior. In that
2755 case, it is the caller's responsibility to recall it again with the
2756 bpstat of the current thread. */
2759 bpstat_do_actions_1 (bpstat
*bsp
)
2762 struct cleanup
*old_chain
;
2765 /* Avoid endless recursion if a `source' command is contained
2767 if (executing_breakpoint_commands
)
2770 executing_breakpoint_commands
= 1;
2771 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2773 /* This pointer will iterate over the list of bpstat's. */
2776 breakpoint_proceeded
= 0;
2777 for (; bs
!= NULL
; bs
= bs
->next
)
2779 struct command_line
*cmd
;
2780 struct cleanup
*this_cmd_tree_chain
;
2782 /* Take ownership of the BSP's command tree, if it has one.
2784 The command tree could legitimately contain commands like
2785 'step' and 'next', which call clear_proceed_status, which
2786 frees stop_bpstat's command tree. To make sure this doesn't
2787 free the tree we're executing out from under us, we need to
2788 take ownership of the tree ourselves. Since a given bpstat's
2789 commands are only executed once, we don't need to copy it; we
2790 can clear the pointer in the bpstat, and make sure we free
2791 the tree when we're done. */
2794 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2798 execute_control_command (cmd
);
2800 if (breakpoint_proceeded
)
2806 /* We can free this command tree now. */
2807 do_cleanups (this_cmd_tree_chain
);
2809 if (breakpoint_proceeded
)
2811 if (target_can_async_p ())
2812 /* If we are in async mode, then the target might be still
2813 running, not stopped at any breakpoint, so nothing for
2814 us to do here -- just return to the event loop. */
2817 /* In sync mode, when execute_control_command returns
2818 we're already standing on the next breakpoint.
2819 Breakpoint commands for that stop were not run, since
2820 execute_command does not run breakpoint commands --
2821 only command_line_handler does, but that one is not
2822 involved in execution of breakpoint commands. So, we
2823 can now execute breakpoint commands. It should be
2824 noted that making execute_command do bpstat actions is
2825 not an option -- in this case we'll have recursive
2826 invocation of bpstat for each breakpoint with a
2827 command, and can easily blow up GDB stack. Instead, we
2828 return true, which will trigger the caller to recall us
2829 with the new stop_bpstat. */
2834 do_cleanups (old_chain
);
2839 bpstat_do_actions (void)
2841 /* Do any commands attached to breakpoint we are stopped at. */
2842 while (!ptid_equal (inferior_ptid
, null_ptid
)
2843 && target_has_execution
2844 && !is_exited (inferior_ptid
)
2845 && !is_executing (inferior_ptid
))
2846 /* Since in sync mode, bpstat_do_actions may resume the inferior,
2847 and only return when it is stopped at the next breakpoint, we
2848 keep doing breakpoint actions until it returns false to
2849 indicate the inferior was not resumed. */
2850 if (!bpstat_do_actions_1 (&inferior_thread ()->stop_bpstat
))
2854 /* Print out the (old or new) value associated with a watchpoint. */
2857 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2860 fprintf_unfiltered (stream
, _("<unreadable>"));
2863 struct value_print_options opts
;
2864 get_user_print_options (&opts
);
2865 value_print (val
, stream
, &opts
);
2869 /* This is the normal print function for a bpstat. In the future,
2870 much of this logic could (should?) be moved to bpstat_stop_status,
2871 by having it set different print_it values.
2873 Current scheme: When we stop, bpstat_print() is called. It loops
2874 through the bpstat list of things causing this stop, calling the
2875 print_bp_stop_message function on each one. The behavior of the
2876 print_bp_stop_message function depends on the print_it field of
2877 bpstat. If such field so indicates, call this function here.
2879 Return values from this routine (ultimately used by bpstat_print()
2880 and normal_stop() to decide what to do):
2881 PRINT_NOTHING: Means we already printed all we needed to print,
2882 don't print anything else.
2883 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2884 that something to be followed by a location.
2885 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2886 that something to be followed by a location.
2887 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2890 static enum print_stop_action
2891 print_it_typical (bpstat bs
)
2893 struct cleanup
*old_chain
;
2894 struct breakpoint
*b
;
2895 const struct bp_location
*bl
;
2896 struct ui_stream
*stb
;
2898 enum print_stop_action result
;
2900 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2901 which has since been deleted. */
2902 if (bs
->breakpoint_at
== NULL
)
2903 return PRINT_UNKNOWN
;
2904 bl
= bs
->breakpoint_at
;
2907 stb
= ui_out_stream_new (uiout
);
2908 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2913 case bp_hardware_breakpoint
:
2914 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2915 if (bl
->address
!= bl
->requested_address
)
2916 breakpoint_adjustment_warning (bl
->requested_address
,
2919 annotate_breakpoint (b
->number
);
2921 ui_out_text (uiout
, "\nTemporary breakpoint ");
2923 ui_out_text (uiout
, "\nBreakpoint ");
2924 if (ui_out_is_mi_like_p (uiout
))
2926 ui_out_field_string (uiout
, "reason",
2927 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2928 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2930 ui_out_field_int (uiout
, "bkptno", b
->number
);
2931 ui_out_text (uiout
, ", ");
2932 result
= PRINT_SRC_AND_LOC
;
2935 case bp_shlib_event
:
2936 /* Did we stop because the user set the stop_on_solib_events
2937 variable? (If so, we report this as a generic, "Stopped due
2938 to shlib event" message.) */
2939 printf_filtered (_("Stopped due to shared library event\n"));
2940 result
= PRINT_NOTHING
;
2943 case bp_thread_event
:
2944 /* Not sure how we will get here.
2945 GDB should not stop for these breakpoints. */
2946 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2947 result
= PRINT_NOTHING
;
2950 case bp_overlay_event
:
2951 /* By analogy with the thread event, GDB should not stop for these. */
2952 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2953 result
= PRINT_NOTHING
;
2956 case bp_longjmp_master
:
2957 /* These should never be enabled. */
2958 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
2959 result
= PRINT_NOTHING
;
2963 case bp_hardware_watchpoint
:
2964 annotate_watchpoint (b
->number
);
2965 if (ui_out_is_mi_like_p (uiout
))
2968 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2970 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2971 ui_out_text (uiout
, "\nOld value = ");
2972 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2973 ui_out_field_stream (uiout
, "old", stb
);
2974 ui_out_text (uiout
, "\nNew value = ");
2975 watchpoint_value_print (b
->val
, stb
->stream
);
2976 ui_out_field_stream (uiout
, "new", stb
);
2977 ui_out_text (uiout
, "\n");
2978 /* More than one watchpoint may have been triggered. */
2979 result
= PRINT_UNKNOWN
;
2982 case bp_read_watchpoint
:
2983 if (ui_out_is_mi_like_p (uiout
))
2986 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2988 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2989 ui_out_text (uiout
, "\nValue = ");
2990 watchpoint_value_print (b
->val
, stb
->stream
);
2991 ui_out_field_stream (uiout
, "value", stb
);
2992 ui_out_text (uiout
, "\n");
2993 result
= PRINT_UNKNOWN
;
2996 case bp_access_watchpoint
:
2997 if (bs
->old_val
!= NULL
)
2999 annotate_watchpoint (b
->number
);
3000 if (ui_out_is_mi_like_p (uiout
))
3003 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3005 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3006 ui_out_text (uiout
, "\nOld value = ");
3007 watchpoint_value_print (bs
->old_val
, stb
->stream
);
3008 ui_out_field_stream (uiout
, "old", stb
);
3009 ui_out_text (uiout
, "\nNew value = ");
3014 if (ui_out_is_mi_like_p (uiout
))
3017 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
3018 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
3019 ui_out_text (uiout
, "\nValue = ");
3021 watchpoint_value_print (b
->val
, stb
->stream
);
3022 ui_out_field_stream (uiout
, "new", stb
);
3023 ui_out_text (uiout
, "\n");
3024 result
= PRINT_UNKNOWN
;
3027 /* Fall through, we don't deal with these types of breakpoints
3031 if (ui_out_is_mi_like_p (uiout
))
3034 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
3035 result
= PRINT_UNKNOWN
;
3039 if (ui_out_is_mi_like_p (uiout
))
3042 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
3043 result
= PRINT_UNKNOWN
;
3048 case bp_longjmp_resume
:
3049 case bp_step_resume
:
3050 case bp_watchpoint_scope
:
3053 case bp_fast_tracepoint
:
3056 result
= PRINT_UNKNOWN
;
3060 do_cleanups (old_chain
);
3064 /* Generic routine for printing messages indicating why we
3065 stopped. The behavior of this function depends on the value
3066 'print_it' in the bpstat structure. Under some circumstances we
3067 may decide not to print anything here and delegate the task to
3070 static enum print_stop_action
3071 print_bp_stop_message (bpstat bs
)
3073 switch (bs
->print_it
)
3076 /* Nothing should be printed for this bpstat entry. */
3077 return PRINT_UNKNOWN
;
3081 /* We still want to print the frame, but we already printed the
3082 relevant messages. */
3083 return PRINT_SRC_AND_LOC
;
3086 case print_it_normal
:
3088 const struct bp_location
*bl
= bs
->breakpoint_at
;
3089 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
3091 /* Normal case. Call the breakpoint's print_it method, or
3092 print_it_typical. */
3093 /* FIXME: how breakpoint can ever be NULL here? */
3094 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
3095 return b
->ops
->print_it (b
);
3097 return print_it_typical (bs
);
3102 internal_error (__FILE__
, __LINE__
,
3103 _("print_bp_stop_message: unrecognized enum value"));
3108 /* Print a message indicating what happened. This is called from
3109 normal_stop(). The input to this routine is the head of the bpstat
3110 list - a list of the eventpoints that caused this stop. This
3111 routine calls the generic print routine for printing a message
3112 about reasons for stopping. This will print (for example) the
3113 "Breakpoint n," part of the output. The return value of this
3116 PRINT_UNKNOWN: Means we printed nothing
3117 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3118 code to print the location. An example is
3119 "Breakpoint 1, " which should be followed by
3121 PRINT_SRC_ONLY: Means we printed something, but there is no need
3122 to also print the location part of the message.
3123 An example is the catch/throw messages, which
3124 don't require a location appended to the end.
3125 PRINT_NOTHING: We have done some printing and we don't need any
3126 further info to be printed.*/
3128 enum print_stop_action
3129 bpstat_print (bpstat bs
)
3133 /* Maybe another breakpoint in the chain caused us to stop.
3134 (Currently all watchpoints go on the bpstat whether hit or not.
3135 That probably could (should) be changed, provided care is taken
3136 with respect to bpstat_explains_signal). */
3137 for (; bs
; bs
= bs
->next
)
3139 val
= print_bp_stop_message (bs
);
3140 if (val
== PRINT_SRC_ONLY
3141 || val
== PRINT_SRC_AND_LOC
3142 || val
== PRINT_NOTHING
)
3146 /* We reached the end of the chain, or we got a null BS to start
3147 with and nothing was printed. */
3148 return PRINT_UNKNOWN
;
3151 /* Evaluate the expression EXP and return 1 if value is zero.
3152 This is used inside a catch_errors to evaluate the breakpoint condition.
3153 The argument is a "struct expression *" that has been cast to char * to
3154 make it pass through catch_errors. */
3157 breakpoint_cond_eval (void *exp
)
3159 struct value
*mark
= value_mark ();
3160 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
3161 value_free_to_mark (mark
);
3165 /* Allocate a new bpstat and chain it to the current one. */
3168 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
3172 bs
= (bpstat
) xmalloc (sizeof (*bs
));
3174 bs
->breakpoint_at
= bl
;
3175 /* If the condition is false, etc., don't do the commands. */
3176 bs
->commands
= NULL
;
3178 bs
->print_it
= print_it_normal
;
3182 /* The target has stopped with waitstatus WS. Check if any hardware
3183 watchpoints have triggered, according to the target. */
3186 watchpoints_triggered (struct target_waitstatus
*ws
)
3188 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3190 struct breakpoint
*b
;
3192 if (!stopped_by_watchpoint
)
3194 /* We were not stopped by a watchpoint. Mark all watchpoints
3195 as not triggered. */
3197 if (b
->type
== bp_hardware_watchpoint
3198 || b
->type
== bp_read_watchpoint
3199 || b
->type
== bp_access_watchpoint
)
3200 b
->watchpoint_triggered
= watch_triggered_no
;
3205 if (!target_stopped_data_address (¤t_target
, &addr
))
3207 /* We were stopped by a watchpoint, but we don't know where.
3208 Mark all watchpoints as unknown. */
3210 if (b
->type
== bp_hardware_watchpoint
3211 || b
->type
== bp_read_watchpoint
3212 || b
->type
== bp_access_watchpoint
)
3213 b
->watchpoint_triggered
= watch_triggered_unknown
;
3215 return stopped_by_watchpoint
;
3218 /* The target could report the data address. Mark watchpoints
3219 affected by this data address as triggered, and all others as not
3223 if (b
->type
== bp_hardware_watchpoint
3224 || b
->type
== bp_read_watchpoint
3225 || b
->type
== bp_access_watchpoint
)
3227 struct bp_location
*loc
;
3230 b
->watchpoint_triggered
= watch_triggered_no
;
3231 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3232 /* Exact match not required. Within range is
3234 if (target_watchpoint_addr_within_range (¤t_target
,
3238 b
->watchpoint_triggered
= watch_triggered_yes
;
3246 /* Possible return values for watchpoint_check (this can't be an enum
3247 because of check_errors). */
3248 /* The watchpoint has been deleted. */
3249 #define WP_DELETED 1
3250 /* The value has changed. */
3251 #define WP_VALUE_CHANGED 2
3252 /* The value has not changed. */
3253 #define WP_VALUE_NOT_CHANGED 3
3255 #define BP_TEMPFLAG 1
3256 #define BP_HARDWAREFLAG 2
3258 /* Evaluate watchpoint condition expression and check if its value changed.
3260 P should be a pointer to struct bpstat, but is defined as a void *
3261 in order for this function to be usable with catch_errors. */
3264 watchpoint_check (void *p
)
3266 bpstat bs
= (bpstat
) p
;
3267 struct breakpoint
*b
;
3268 struct frame_info
*fr
;
3269 int within_current_scope
;
3271 b
= bs
->breakpoint_at
->owner
;
3273 /* If this is a local watchpoint, we only want to check if the
3274 watchpoint frame is in scope if the current thread is the thread
3275 that was used to create the watchpoint. */
3276 if (!watchpoint_in_thread_scope (b
))
3277 return WP_VALUE_NOT_CHANGED
;
3279 if (b
->exp_valid_block
== NULL
)
3280 within_current_scope
= 1;
3283 struct frame_info
*frame
= get_current_frame ();
3284 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3285 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3287 /* in_function_epilogue_p() returns a non-zero value if we're still
3288 in the function but the stack frame has already been invalidated.
3289 Since we can't rely on the values of local variables after the
3290 stack has been destroyed, we are treating the watchpoint in that
3291 state as `not changed' without further checking. Don't mark
3292 watchpoints as changed if the current frame is in an epilogue -
3293 even if they are in some other frame, our view of the stack
3294 is likely to be wrong and frame_find_by_id could error out. */
3295 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3296 return WP_VALUE_NOT_CHANGED
;
3298 fr
= frame_find_by_id (b
->watchpoint_frame
);
3299 within_current_scope
= (fr
!= NULL
);
3301 /* If we've gotten confused in the unwinder, we might have
3302 returned a frame that can't describe this variable. */
3303 if (within_current_scope
)
3305 struct symbol
*function
;
3307 function
= get_frame_function (fr
);
3308 if (function
== NULL
3309 || !contained_in (b
->exp_valid_block
,
3310 SYMBOL_BLOCK_VALUE (function
)))
3311 within_current_scope
= 0;
3314 if (within_current_scope
)
3315 /* If we end up stopping, the current frame will get selected
3316 in normal_stop. So this call to select_frame won't affect
3321 if (within_current_scope
)
3323 /* We use value_{,free_to_}mark because it could be a
3324 *long* time before we return to the command level and
3325 call free_all_values. We can't call free_all_values because
3326 we might be in the middle of evaluating a function call. */
3328 struct value
*mark
= value_mark ();
3329 struct value
*new_val
;
3331 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
3333 /* We use value_equal_contents instead of value_equal because the latter
3334 coerces an array to a pointer, thus comparing just the address of the
3335 array instead of its contents. This is not what we want. */
3336 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3337 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
3339 if (new_val
!= NULL
)
3341 release_value (new_val
);
3342 value_free_to_mark (mark
);
3344 bs
->old_val
= b
->val
;
3347 /* We will stop here */
3348 return WP_VALUE_CHANGED
;
3352 /* Nothing changed, don't do anything. */
3353 value_free_to_mark (mark
);
3354 /* We won't stop here */
3355 return WP_VALUE_NOT_CHANGED
;
3360 /* This seems like the only logical thing to do because
3361 if we temporarily ignored the watchpoint, then when
3362 we reenter the block in which it is valid it contains
3363 garbage (in the case of a function, it may have two
3364 garbage values, one before and one after the prologue).
3365 So we can't even detect the first assignment to it and
3366 watch after that (since the garbage may or may not equal
3367 the first value assigned). */
3368 /* We print all the stop information in print_it_typical(), but
3369 in this case, by the time we call print_it_typical() this bp
3370 will be deleted already. So we have no choice but print the
3371 information here. */
3372 if (ui_out_is_mi_like_p (uiout
))
3374 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3375 ui_out_text (uiout
, "\nWatchpoint ");
3376 ui_out_field_int (uiout
, "wpnum", b
->number
);
3377 ui_out_text (uiout
, " deleted because the program has left the block in\n\
3378 which its expression is valid.\n");
3380 if (b
->related_breakpoint
)
3381 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3382 b
->disposition
= disp_del_at_next_stop
;
3388 /* Return true if it looks like target has stopped due to hitting
3389 breakpoint location BL. This function does not check if we
3390 should stop, only if BL explains the stop. */
3392 bpstat_check_location (const struct bp_location
*bl
,
3393 struct address_space
*aspace
, CORE_ADDR bp_addr
)
3395 struct breakpoint
*b
= bl
->owner
;
3397 /* By definition, the inferior does not report stops at
3399 if (tracepoint_type (b
))
3402 if (b
->type
!= bp_watchpoint
3403 && b
->type
!= bp_hardware_watchpoint
3404 && b
->type
!= bp_read_watchpoint
3405 && b
->type
!= bp_access_watchpoint
3406 && b
->type
!= bp_hardware_breakpoint
3407 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
3409 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
3412 if (overlay_debugging
/* unmapped overlay section */
3413 && section_is_overlay (bl
->section
)
3414 && !section_is_mapped (bl
->section
))
3418 /* Continuable hardware watchpoints are treated as non-existent if the
3419 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3420 some data address). Otherwise gdb won't stop on a break instruction
3421 in the code (not from a breakpoint) when a hardware watchpoint has
3422 been defined. Also skip watchpoints which we know did not trigger
3423 (did not match the data address). */
3425 if ((b
->type
== bp_hardware_watchpoint
3426 || b
->type
== bp_read_watchpoint
3427 || b
->type
== bp_access_watchpoint
)
3428 && b
->watchpoint_triggered
== watch_triggered_no
)
3431 if (b
->type
== bp_hardware_breakpoint
)
3433 if (bl
->address
!= bp_addr
)
3435 if (overlay_debugging
/* unmapped overlay section */
3436 && section_is_overlay (bl
->section
)
3437 && !section_is_mapped (bl
->section
))
3441 if (b
->type
== bp_catchpoint
)
3443 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
3444 if (!b
->ops
->breakpoint_hit (b
))
3451 /* If BS refers to a watchpoint, determine if the watched values
3452 has actually changed, and we should stop. If not, set BS->stop
3455 bpstat_check_watchpoint (bpstat bs
)
3457 const struct bp_location
*bl
= bs
->breakpoint_at
;
3458 struct breakpoint
*b
= bl
->owner
;
3460 if (b
->type
== bp_watchpoint
3461 || b
->type
== bp_read_watchpoint
3462 || b
->type
== bp_access_watchpoint
3463 || b
->type
== bp_hardware_watchpoint
)
3467 int must_check_value
= 0;
3469 if (b
->type
== bp_watchpoint
)
3470 /* For a software watchpoint, we must always check the
3472 must_check_value
= 1;
3473 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3474 /* We have a hardware watchpoint (read, write, or access)
3475 and the target earlier reported an address watched by
3477 must_check_value
= 1;
3478 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3479 && b
->type
== bp_hardware_watchpoint
)
3480 /* We were stopped by a hardware watchpoint, but the target could
3481 not report the data address. We must check the watchpoint's
3482 value. Access and read watchpoints are out of luck; without
3483 a data address, we can't figure it out. */
3484 must_check_value
= 1;
3486 if (must_check_value
)
3488 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
3490 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3491 int e
= catch_errors (watchpoint_check
, bs
, message
,
3493 do_cleanups (cleanups
);
3497 /* We've already printed what needs to be printed. */
3498 bs
->print_it
= print_it_done
;
3501 case WP_VALUE_CHANGED
:
3502 if (b
->type
== bp_read_watchpoint
)
3504 /* There are two cases to consider here:
3506 1. we're watching the triggered memory for reads.
3507 In that case, trust the target, and always report
3508 the watchpoint hit to the user. Even though
3509 reads don't cause value changes, the value may
3510 have changed since the last time it was read, and
3511 since we're not trapping writes, we will not see
3512 those, and as such we should ignore our notion of
3515 2. we're watching the triggered memory for both
3516 reads and writes. There are two ways this may
3519 2.1. this is a target that can't break on data
3520 reads only, but can break on accesses (reads or
3521 writes), such as e.g., x86. We detect this case
3522 at the time we try to insert read watchpoints.
3524 2.2. otherwise, the target supports read
3525 watchpoints, but, the user set an access or write
3526 watchpoint watching the same memory as this read
3529 If we're watching memory writes as well as reads,
3530 ignore watchpoint hits when we find that the
3531 value hasn't changed, as reads don't cause
3532 changes. This still gives false positives when
3533 the program writes the same value to memory as
3534 what there was already in memory (we will confuse
3535 it for a read), but it's much better than
3538 int other_write_watchpoint
= 0;
3540 if (bl
->watchpoint_type
== hw_read
)
3542 struct breakpoint
*other_b
;
3544 ALL_BREAKPOINTS (other_b
)
3545 if ((other_b
->type
== bp_hardware_watchpoint
3546 || other_b
->type
== bp_access_watchpoint
)
3547 && (other_b
->watchpoint_triggered
3548 == watch_triggered_yes
))
3550 other_write_watchpoint
= 1;
3555 if (other_write_watchpoint
3556 || bl
->watchpoint_type
== hw_access
)
3558 /* We're watching the same memory for writes,
3559 and the value changed since the last time we
3560 updated it, so this trap must be for a write.
3562 bs
->print_it
= print_it_noop
;
3567 case WP_VALUE_NOT_CHANGED
:
3568 if (b
->type
== bp_hardware_watchpoint
3569 || b
->type
== bp_watchpoint
)
3571 /* Don't stop: write watchpoints shouldn't fire if
3572 the value hasn't changed. */
3573 bs
->print_it
= print_it_noop
;
3581 /* Error from catch_errors. */
3582 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
3583 if (b
->related_breakpoint
)
3584 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3585 b
->disposition
= disp_del_at_next_stop
;
3586 /* We've already printed what needs to be printed. */
3587 bs
->print_it
= print_it_done
;
3591 else /* must_check_value == 0 */
3593 /* This is a case where some watchpoint(s) triggered, but
3594 not at the address of this watchpoint, or else no
3595 watchpoint triggered after all. So don't print
3596 anything for this watchpoint. */
3597 bs
->print_it
= print_it_noop
;
3604 /* Check conditions (condition proper, frame, thread and ignore count)
3605 of breakpoint referred to by BS. If we should not stop for this
3606 breakpoint, set BS->stop to 0. */
3608 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
3610 int thread_id
= pid_to_thread_id (ptid
);
3611 const struct bp_location
*bl
= bs
->breakpoint_at
;
3612 struct breakpoint
*b
= bl
->owner
;
3614 if (frame_id_p (b
->frame_id
)
3615 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
3619 int value_is_zero
= 0;
3621 /* If this is a scope breakpoint, mark the associated
3622 watchpoint as triggered so that we will handle the
3623 out-of-scope event. We'll get to the watchpoint next
3625 if (b
->type
== bp_watchpoint_scope
)
3626 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
3628 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
3630 /* We use value_mark and value_free_to_mark because it could
3631 be a long time before we return to the command level and
3632 call free_all_values. We can't call free_all_values
3633 because we might be in the middle of evaluating a
3635 struct value
*mark
= value_mark ();
3637 /* Need to select the frame, with all that implies so that
3638 the conditions will have the right context. Because we
3639 use the frame, we will not see an inlined function's
3640 variables when we arrive at a breakpoint at the start
3641 of the inlined function; the current frame will be the
3643 select_frame (get_current_frame ());
3645 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
3646 "Error in testing breakpoint condition:\n",
3648 /* FIXME-someday, should give breakpoint # */
3649 value_free_to_mark (mark
);
3651 if (bl
->cond
&& value_is_zero
)
3655 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
3659 else if (b
->ignore_count
> 0)
3662 annotate_ignore_count_change ();
3664 /* Increase the hit count even though we don't
3672 /* Get a bpstat associated with having just stopped at address
3673 BP_ADDR in thread PTID.
3675 Determine whether we stopped at a breakpoint, etc, or whether we
3676 don't understand this stop. Result is a chain of bpstat's such that:
3678 if we don't understand the stop, the result is a null pointer.
3680 if we understand why we stopped, the result is not null.
3682 Each element of the chain refers to a particular breakpoint or
3683 watchpoint at which we have stopped. (We may have stopped for
3684 several reasons concurrently.)
3686 Each element of the chain has valid next, breakpoint_at,
3687 commands, FIXME??? fields. */
3690 bpstat_stop_status (struct address_space
*aspace
,
3691 CORE_ADDR bp_addr
, ptid_t ptid
)
3693 struct breakpoint
*b
= NULL
;
3694 struct bp_location
*bl
, **blp_tmp
;
3695 struct bp_location
*loc
;
3696 /* Root of the chain of bpstat's */
3697 struct bpstats root_bs
[1];
3698 /* Pointer to the last thing in the chain currently. */
3699 bpstat bs
= root_bs
;
3701 int need_remove_insert
;
3703 /* ALL_BP_LOCATIONS iteration would break across
3704 update_global_location_list possibly executed by
3705 bpstat_check_breakpoint_conditions's inferior call. */
3709 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3712 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
3714 /* For hardware watchpoints, we look only at the first location.
3715 The watchpoint_check function will work on entire expression,
3716 not the individual locations. For read watchopints, the
3717 watchpoints_triggered function have checked all locations
3719 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3722 if (bl
->shlib_disabled
)
3725 if (!bpstat_check_location (bl
, aspace
, bp_addr
))
3728 /* Come here if it's a watchpoint, or if the break address matches */
3730 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3732 /* Assume we stop. Should we find watchpoint that is not actually
3733 triggered, or if condition of breakpoint is false, we'll reset
3738 bpstat_check_watchpoint (bs
);
3742 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3743 || b
->type
== bp_longjmp_master
)
3744 /* We do not stop for these. */
3747 bpstat_check_breakpoint_conditions (bs
, ptid
);
3753 /* We will stop here */
3754 if (b
->disposition
== disp_disable
)
3756 if (b
->enable_state
!= bp_permanent
)
3757 b
->enable_state
= bp_disabled
;
3758 update_global_location_list (0);
3762 bs
->commands
= b
->commands
;
3764 && (strcmp ("silent", bs
->commands
->line
) == 0
3765 || (xdb_commands
&& strcmp ("Q",
3766 bs
->commands
->line
) == 0)))
3768 bs
->commands
= bs
->commands
->next
;
3771 bs
->commands
= copy_command_lines (bs
->commands
);
3774 /* Print nothing for this entry if we dont stop or dont print. */
3775 if (bs
->stop
== 0 || bs
->print
== 0)
3776 bs
->print_it
= print_it_noop
;
3780 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
3782 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
3785 bs
= bpstat_alloc (loc
, bs
);
3786 /* For hits of moribund locations, we should just proceed. */
3789 bs
->print_it
= print_it_noop
;
3793 bs
->next
= NULL
; /* Terminate the chain */
3795 /* If we aren't stopping, the value of some hardware watchpoint may
3796 not have changed, but the intermediate memory locations we are
3797 watching may have. Don't bother if we're stopping; this will get
3799 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3803 need_remove_insert
= 0;
3805 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3807 && bs
->breakpoint_at
->owner
3808 && is_hardware_watchpoint (bs
->breakpoint_at
->owner
))
3810 update_watchpoint (bs
->breakpoint_at
->owner
, 0 /* don't reparse. */);
3811 /* Updating watchpoints invalidates bs->breakpoint_at.
3812 Prevent further code from trying to use it. */
3813 bs
->breakpoint_at
= NULL
;
3814 need_remove_insert
= 1;
3817 if (need_remove_insert
)
3818 update_global_location_list (1);
3820 return root_bs
->next
;
3823 /* Tell what to do about this bpstat. */
3825 bpstat_what (bpstat bs
)
3827 /* Classify each bpstat as one of the following. */
3830 /* This bpstat element has no effect on the main_action. */
3833 /* There was a watchpoint, stop but don't print. */
3836 /* There was a watchpoint, stop and print. */
3839 /* There was a breakpoint but we're not stopping. */
3842 /* There was a breakpoint, stop but don't print. */
3845 /* There was a breakpoint, stop and print. */
3848 /* We hit the longjmp breakpoint. */
3851 /* We hit the longjmp_resume breakpoint. */
3854 /* We hit the step_resume breakpoint. */
3857 /* We hit the shared library event breakpoint. */
3860 /* We hit the jit event breakpoint. */
3863 /* This is just used to count how many enums there are. */
3867 /* Here is the table which drives this routine. So that we can
3868 format it pretty, we define some abbreviations for the
3869 enum bpstat_what codes. */
3870 #define kc BPSTAT_WHAT_KEEP_CHECKING
3871 #define ss BPSTAT_WHAT_STOP_SILENT
3872 #define sn BPSTAT_WHAT_STOP_NOISY
3873 #define sgl BPSTAT_WHAT_SINGLE
3874 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3875 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3876 #define sr BPSTAT_WHAT_STEP_RESUME
3877 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3878 #define jit BPSTAT_WHAT_CHECK_JIT
3880 /* "Can't happen." Might want to print an error message.
3881 abort() is not out of the question, but chances are GDB is just
3882 a bit confused, not unusable. */
3883 #define err BPSTAT_WHAT_STOP_NOISY
3885 /* Given an old action and a class, come up with a new action. */
3886 /* One interesting property of this table is that wp_silent is the same
3887 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3888 after stopping, the check for whether to step over a breakpoint
3889 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3890 reference to how we stopped. We retain separate wp_silent and
3891 bp_silent codes in case we want to change that someday.
3893 Another possibly interesting property of this table is that
3894 there's a partial ordering, priority-like, of the actions. Once
3895 you've decided that some action is appropriate, you'll never go
3896 back and decide something of a lower priority is better. The
3899 kc < jit clr sgl shl slr sn sr ss
3900 sgl < jit shl slr sn sr ss
3901 slr < jit err shl sn sr ss
3902 clr < jit err shl sn sr ss
3909 What I think this means is that we don't need a damned table
3910 here. If you just put the rows and columns in the right order,
3911 it'd look awfully regular. We could simply walk the bpstat list
3912 and choose the highest priority action we find, with a little
3913 logic to handle the 'err' cases. */
3915 /* step_resume entries: a step resume breakpoint overrides another
3916 breakpoint of signal handling (see comment in wait_for_inferior
3917 at where we set the step_resume breakpoint). */
3919 static const enum bpstat_what_main_action
3920 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3923 /* kc ss sn sgl slr clr sr shl jit */
3924 /* no_effect */ {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
, jit
},
3925 /* wp_silent */ {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, jit
},
3926 /* wp_noisy */ {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, jit
},
3927 /* bp_nostop */ {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
, jit
},
3928 /* bp_silent */ {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, jit
},
3929 /* bp_noisy */ {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, jit
},
3930 /* long_jump */ {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
, jit
},
3931 /* long_resume */ {clr
, ss
, sn
, err
, err
, err
, sr
, shl
, jit
},
3932 /* step_resume */ {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3933 /* shlib */ {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shl
},
3934 /* jit_event */ {jit
, jit
, jit
, jit
, jit
, jit
, sr
, jit
, jit
}
3948 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3949 struct bpstat_what retval
;
3951 retval
.call_dummy
= 0;
3952 for (; bs
!= NULL
; bs
= bs
->next
)
3954 enum class bs_class
= no_effect
;
3955 if (bs
->breakpoint_at
== NULL
)
3956 /* I suspect this can happen if it was a momentary breakpoint
3957 which has since been deleted. */
3959 if (bs
->breakpoint_at
->owner
== NULL
)
3960 bs_class
= bp_nostop
;
3962 switch (bs
->breakpoint_at
->owner
->type
)
3968 case bp_hardware_breakpoint
:
3974 bs_class
= bp_noisy
;
3976 bs_class
= bp_silent
;
3979 bs_class
= bp_nostop
;
3982 case bp_hardware_watchpoint
:
3983 case bp_read_watchpoint
:
3984 case bp_access_watchpoint
:
3988 bs_class
= wp_noisy
;
3990 bs_class
= wp_silent
;
3993 /* There was a watchpoint, but we're not stopping.
3994 This requires no further action. */
3995 bs_class
= no_effect
;
3998 bs_class
= long_jump
;
4000 case bp_longjmp_resume
:
4001 bs_class
= long_resume
;
4003 case bp_step_resume
:
4006 bs_class
= step_resume
;
4009 /* It is for the wrong frame. */
4010 bs_class
= bp_nostop
;
4012 case bp_watchpoint_scope
:
4013 bs_class
= bp_nostop
;
4015 case bp_shlib_event
:
4016 bs_class
= shlib_event
;
4019 bs_class
= jit_event
;
4021 case bp_thread_event
:
4022 case bp_overlay_event
:
4023 case bp_longjmp_master
:
4024 bs_class
= bp_nostop
;
4030 bs_class
= bp_noisy
;
4032 bs_class
= bp_silent
;
4035 /* There was a catchpoint, but we're not stopping.
4036 This requires no further action. */
4037 bs_class
= no_effect
;
4040 /* Make sure the action is stop (silent or noisy),
4041 so infrun.c pops the dummy frame. */
4042 bs_class
= bp_silent
;
4043 retval
.call_dummy
= 1;
4046 case bp_fast_tracepoint
:
4047 /* Tracepoint hits should not be reported back to GDB, and
4048 if one got through somehow, it should have been filtered
4050 internal_error (__FILE__
, __LINE__
,
4051 _("bpstat_what: tracepoint encountered"));
4054 current_action
= table
[(int) bs_class
][(int) current_action
];
4056 retval
.main_action
= current_action
;
4060 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4061 without hardware support). This isn't related to a specific bpstat,
4062 just to things like whether watchpoints are set. */
4065 bpstat_should_step (void)
4067 struct breakpoint
*b
;
4069 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
4075 bpstat_causes_stop (bpstat bs
)
4077 for (; bs
!= NULL
; bs
= bs
->next
)
4086 /* Print the LOC location out of the list of B->LOC locations. */
4088 static void print_breakpoint_location (struct breakpoint
*b
,
4089 struct bp_location
*loc
,
4091 struct ui_stream
*stb
)
4093 struct cleanup
*old_chain
= save_current_program_space ();
4095 if (loc
!= NULL
&& loc
->shlib_disabled
)
4099 set_current_program_space (loc
->pspace
);
4101 if (b
->source_file
&& loc
)
4104 = find_pc_sect_function (loc
->address
, loc
->section
);
4107 ui_out_text (uiout
, "in ");
4108 ui_out_field_string (uiout
, "func",
4109 SYMBOL_PRINT_NAME (sym
));
4110 ui_out_wrap_hint (uiout
, wrap_indent
);
4111 ui_out_text (uiout
, " at ");
4113 ui_out_field_string (uiout
, "file", b
->source_file
);
4114 ui_out_text (uiout
, ":");
4116 if (ui_out_is_mi_like_p (uiout
))
4118 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
4119 char *fullname
= symtab_to_fullname (sal
.symtab
);
4122 ui_out_field_string (uiout
, "fullname", fullname
);
4125 ui_out_field_int (uiout
, "line", b
->line_number
);
4129 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
->stream
,
4131 ui_out_field_stream (uiout
, "at", stb
);
4134 ui_out_field_string (uiout
, "pending", b
->addr_string
);
4136 do_cleanups (old_chain
);
4139 /* Print B to gdb_stdout. */
4141 print_one_breakpoint_location (struct breakpoint
*b
,
4142 struct bp_location
*loc
,
4144 struct bp_location
**last_loc
,
4145 int print_address_bits
,
4148 struct command_line
*l
;
4150 struct ep_type_description
4155 static struct ep_type_description bptypes
[] =
4157 {bp_none
, "?deleted?"},
4158 {bp_breakpoint
, "breakpoint"},
4159 {bp_hardware_breakpoint
, "hw breakpoint"},
4160 {bp_until
, "until"},
4161 {bp_finish
, "finish"},
4162 {bp_watchpoint
, "watchpoint"},
4163 {bp_hardware_watchpoint
, "hw watchpoint"},
4164 {bp_read_watchpoint
, "read watchpoint"},
4165 {bp_access_watchpoint
, "acc watchpoint"},
4166 {bp_longjmp
, "longjmp"},
4167 {bp_longjmp_resume
, "longjmp resume"},
4168 {bp_step_resume
, "step resume"},
4169 {bp_watchpoint_scope
, "watchpoint scope"},
4170 {bp_call_dummy
, "call dummy"},
4171 {bp_shlib_event
, "shlib events"},
4172 {bp_thread_event
, "thread events"},
4173 {bp_overlay_event
, "overlay events"},
4174 {bp_longjmp_master
, "longjmp master"},
4175 {bp_catchpoint
, "catchpoint"},
4176 {bp_tracepoint
, "tracepoint"},
4177 {bp_fast_tracepoint
, "fast tracepoint"},
4178 {bp_jit_event
, "jit events"},
4181 static char bpenables
[] = "nynny";
4182 char wrap_indent
[80];
4183 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4184 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4185 struct cleanup
*bkpt_chain
;
4187 int header_of_multiple
= 0;
4188 int part_of_multiple
= (loc
!= NULL
);
4189 struct value_print_options opts
;
4191 get_user_print_options (&opts
);
4193 gdb_assert (!loc
|| loc_number
!= 0);
4194 /* See comment in print_one_breakpoint concerning
4195 treatment of breakpoints with single disabled
4199 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
4200 header_of_multiple
= 1;
4205 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
4209 if (part_of_multiple
)
4212 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
4213 ui_out_field_string (uiout
, "number", formatted
);
4218 ui_out_field_int (uiout
, "number", b
->number
);
4223 if (part_of_multiple
)
4224 ui_out_field_skip (uiout
, "type");
4227 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
4228 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
4229 internal_error (__FILE__
, __LINE__
,
4230 _("bptypes table does not describe type #%d."),
4232 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
4237 if (part_of_multiple
)
4238 ui_out_field_skip (uiout
, "disp");
4240 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
4245 if (part_of_multiple
)
4246 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
4248 ui_out_field_fmt (uiout
, "enabled", "%c",
4249 bpenables
[(int) b
->enable_state
]);
4250 ui_out_spaces (uiout
, 2);
4254 strcpy (wrap_indent
, " ");
4255 if (opts
.addressprint
)
4257 if (print_address_bits
<= 32)
4258 strcat (wrap_indent
, " ");
4260 strcat (wrap_indent
, " ");
4263 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4265 /* Although the print_one can possibly print
4266 all locations, calling it here is not likely
4267 to get any nice result. So, make sure there's
4268 just one location. */
4269 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4270 b
->ops
->print_one (b
, last_loc
);
4276 internal_error (__FILE__
, __LINE__
,
4277 _("print_one_breakpoint: bp_none encountered\n"));
4281 case bp_hardware_watchpoint
:
4282 case bp_read_watchpoint
:
4283 case bp_access_watchpoint
:
4284 /* Field 4, the address, is omitted (which makes the columns
4285 not line up too nicely with the headers, but the effect
4286 is relatively readable). */
4287 if (opts
.addressprint
)
4288 ui_out_field_skip (uiout
, "addr");
4290 ui_out_field_string (uiout
, "what", b
->exp_string
);
4294 case bp_hardware_breakpoint
:
4298 case bp_longjmp_resume
:
4299 case bp_step_resume
:
4300 case bp_watchpoint_scope
:
4302 case bp_shlib_event
:
4303 case bp_thread_event
:
4304 case bp_overlay_event
:
4305 case bp_longjmp_master
:
4307 case bp_fast_tracepoint
:
4309 if (opts
.addressprint
)
4312 if (header_of_multiple
)
4313 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4314 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4315 ui_out_field_string (uiout
, "addr", "<PENDING>");
4317 ui_out_field_core_addr (uiout
, "addr",
4318 loc
->gdbarch
, loc
->address
);
4321 if (!header_of_multiple
)
4322 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
4329 /* For backward compatibility, don't display inferiors unless there
4332 && !header_of_multiple
4334 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4335 && (number_of_program_spaces () > 1
4336 || number_of_inferiors () > 1)
4337 && loc
->owner
->type
!= bp_catchpoint
)))
4339 struct inferior
*inf
;
4342 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4344 if (inf
->pspace
== loc
->pspace
)
4349 ui_out_text (uiout
, " inf ");
4352 ui_out_text (uiout
, ", ");
4353 ui_out_text (uiout
, plongest (inf
->num
));
4358 if (!part_of_multiple
)
4360 if (b
->thread
!= -1)
4362 /* FIXME: This seems to be redundant and lost here; see the
4363 "stop only in" line a little further down. */
4364 ui_out_text (uiout
, " thread ");
4365 ui_out_field_int (uiout
, "thread", b
->thread
);
4367 else if (b
->task
!= 0)
4369 ui_out_text (uiout
, " task ");
4370 ui_out_field_int (uiout
, "task", b
->task
);
4374 ui_out_text (uiout
, "\n");
4376 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4379 ui_out_text (uiout
, "\tstop only in stack frame at ");
4380 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4382 ui_out_field_core_addr (uiout
, "frame",
4383 b
->gdbarch
, b
->frame_id
.stack_addr
);
4384 ui_out_text (uiout
, "\n");
4387 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
4389 /* We do not print the condition for Ada exception catchpoints
4390 because the condition is an internal implementation detail
4391 that we do not want to expose to the user. */
4393 if (tracepoint_type (b
))
4394 ui_out_text (uiout
, "\ttrace only if ");
4396 ui_out_text (uiout
, "\tstop only if ");
4397 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4398 ui_out_text (uiout
, "\n");
4401 if (!part_of_multiple
&& b
->thread
!= -1)
4403 /* FIXME should make an annotation for this */
4404 ui_out_text (uiout
, "\tstop only in thread ");
4405 ui_out_field_int (uiout
, "thread", b
->thread
);
4406 ui_out_text (uiout
, "\n");
4409 if (!part_of_multiple
&& b
->hit_count
)
4411 /* FIXME should make an annotation for this */
4412 if (ep_is_catchpoint (b
))
4413 ui_out_text (uiout
, "\tcatchpoint");
4415 ui_out_text (uiout
, "\tbreakpoint");
4416 ui_out_text (uiout
, " already hit ");
4417 ui_out_field_int (uiout
, "times", b
->hit_count
);
4418 if (b
->hit_count
== 1)
4419 ui_out_text (uiout
, " time\n");
4421 ui_out_text (uiout
, " times\n");
4424 /* Output the count also if it is zero, but only if this is
4425 mi. FIXME: Should have a better test for this. */
4426 if (ui_out_is_mi_like_p (uiout
))
4427 if (!part_of_multiple
&& b
->hit_count
== 0)
4428 ui_out_field_int (uiout
, "times", b
->hit_count
);
4430 if (!part_of_multiple
&& b
->ignore_count
)
4433 ui_out_text (uiout
, "\tignore next ");
4434 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
4435 ui_out_text (uiout
, " hits\n");
4439 if (!part_of_multiple
&& l
)
4441 struct cleanup
*script_chain
;
4444 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
4445 print_command_lines (uiout
, l
, 4);
4446 do_cleanups (script_chain
);
4449 if (!part_of_multiple
&& b
->pass_count
)
4451 annotate_field (10);
4452 ui_out_text (uiout
, "\tpass count ");
4453 ui_out_field_int (uiout
, "pass", b
->pass_count
);
4454 ui_out_text (uiout
, " \n");
4457 if (!part_of_multiple
&& b
->step_count
)
4459 annotate_field (11);
4460 ui_out_text (uiout
, "\tstep count ");
4461 ui_out_field_int (uiout
, "step", b
->step_count
);
4462 ui_out_text (uiout
, " \n");
4465 if (!part_of_multiple
&& b
->actions
)
4467 struct action_line
*action
;
4468 annotate_field (12);
4469 for (action
= b
->actions
; action
; action
= action
->next
)
4471 ui_out_text (uiout
, " A\t");
4472 ui_out_text (uiout
, action
->action
);
4473 ui_out_text (uiout
, "\n");
4477 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
4480 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
4481 else if (b
->exp_string
)
4482 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
4485 do_cleanups (bkpt_chain
);
4486 do_cleanups (old_chain
);
4490 print_one_breakpoint (struct breakpoint
*b
,
4491 struct bp_location
**last_loc
, int print_address_bits
,
4494 print_one_breakpoint_location (b
, NULL
, 0, last_loc
,
4495 print_address_bits
, allflag
);
4497 /* If this breakpoint has custom print function,
4498 it's already printed. Otherwise, print individual
4499 locations, if any. */
4500 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
4502 /* If breakpoint has a single location that is
4503 disabled, we print it as if it had
4504 several locations, since otherwise it's hard to
4505 represent "breakpoint enabled, location disabled"
4507 Note that while hardware watchpoints have
4508 several locations internally, that's no a property
4511 && !is_hardware_watchpoint (b
)
4512 && (b
->loc
->next
|| !b
->loc
->enabled
)
4513 && !ui_out_is_mi_like_p (uiout
))
4515 struct bp_location
*loc
;
4517 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
4518 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
4519 print_address_bits
, allflag
);
4525 breakpoint_address_bits (struct breakpoint
*b
)
4527 int print_address_bits
= 0;
4528 struct bp_location
*loc
;
4530 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4534 /* Software watchpoints that aren't watching memory don't have
4535 an address to print. */
4536 if (b
->type
== bp_watchpoint
&& loc
->watchpoint_type
== -1)
4539 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
4540 if (addr_bit
> print_address_bits
)
4541 print_address_bits
= addr_bit
;
4544 return print_address_bits
;
4547 struct captured_breakpoint_query_args
4553 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
4555 struct captured_breakpoint_query_args
*args
= data
;
4556 struct breakpoint
*b
;
4557 struct bp_location
*dummy_loc
= NULL
;
4560 if (args
->bnum
== b
->number
)
4562 int print_address_bits
= breakpoint_address_bits (b
);
4563 print_one_breakpoint (b
, &dummy_loc
, print_address_bits
, 0);
4571 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
4573 struct captured_breakpoint_query_args args
;
4575 /* For the moment we don't trust print_one_breakpoint() to not throw
4577 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
4578 error_message
, RETURN_MASK_ALL
) < 0)
4584 /* Return non-zero if B is user settable (breakpoints, watchpoints,
4585 catchpoints, et.al.). */
4588 user_settable_breakpoint (const struct breakpoint
*b
)
4590 return (b
->type
== bp_breakpoint
4591 || b
->type
== bp_catchpoint
4592 || b
->type
== bp_hardware_breakpoint
4593 || tracepoint_type (b
)
4594 || b
->type
== bp_watchpoint
4595 || b
->type
== bp_read_watchpoint
4596 || b
->type
== bp_access_watchpoint
4597 || b
->type
== bp_hardware_watchpoint
);
4600 /* Print information on user settable breakpoint (watchpoint, etc)
4601 number BNUM. If BNUM is -1 print all user settable breakpoints.
4602 If ALLFLAG is non-zero, include non- user settable breakpoints. */
4605 breakpoint_1 (int bnum
, int allflag
)
4607 struct breakpoint
*b
;
4608 struct bp_location
*last_loc
= NULL
;
4609 int nr_printable_breakpoints
;
4610 struct cleanup
*bkpttbl_chain
;
4611 struct value_print_options opts
;
4612 int print_address_bits
= 0;
4614 get_user_print_options (&opts
);
4616 /* Compute the number of rows in the table, as well as the
4617 size required for address fields. */
4618 nr_printable_breakpoints
= 0;
4621 || bnum
== b
->number
)
4623 if (allflag
|| user_settable_breakpoint (b
))
4625 int addr_bit
= breakpoint_address_bits (b
);
4626 if (addr_bit
> print_address_bits
)
4627 print_address_bits
= addr_bit
;
4629 nr_printable_breakpoints
++;
4633 if (opts
.addressprint
)
4635 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
4639 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
4642 if (nr_printable_breakpoints
> 0)
4643 annotate_breakpoints_headers ();
4644 if (nr_printable_breakpoints
> 0)
4646 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
4647 if (nr_printable_breakpoints
> 0)
4649 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
4650 if (nr_printable_breakpoints
> 0)
4652 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
4653 if (nr_printable_breakpoints
> 0)
4655 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
4656 if (opts
.addressprint
)
4658 if (nr_printable_breakpoints
> 0)
4660 if (print_address_bits
<= 32)
4661 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
4663 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
4665 if (nr_printable_breakpoints
> 0)
4667 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
4668 ui_out_table_body (uiout
);
4669 if (nr_printable_breakpoints
> 0)
4670 annotate_breakpoints_table ();
4676 || bnum
== b
->number
)
4678 /* We only print out user settable breakpoints unless the
4680 if (allflag
|| user_settable_breakpoint (b
))
4681 print_one_breakpoint (b
, &last_loc
, print_address_bits
, allflag
);
4685 do_cleanups (bkpttbl_chain
);
4687 if (nr_printable_breakpoints
== 0)
4690 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
4692 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
4697 if (last_loc
&& !server_command
)
4698 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
4701 /* FIXME? Should this be moved up so that it is only called when
4702 there have been breakpoints? */
4703 annotate_breakpoints_table_end ();
4707 breakpoints_info (char *bnum_exp
, int from_tty
)
4712 bnum
= parse_and_eval_long (bnum_exp
);
4714 breakpoint_1 (bnum
, 0);
4718 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4723 bnum
= parse_and_eval_long (bnum_exp
);
4725 breakpoint_1 (bnum
, 1);
4729 breakpoint_has_pc (struct breakpoint
*b
,
4730 struct program_space
*pspace
,
4731 CORE_ADDR pc
, struct obj_section
*section
)
4733 struct bp_location
*bl
= b
->loc
;
4734 for (; bl
; bl
= bl
->next
)
4736 if (bl
->pspace
== pspace
4737 && bl
->address
== pc
4738 && (!overlay_debugging
|| bl
->section
== section
))
4744 /* Print a message describing any breakpoints set at PC. This
4745 concerns with logical breakpoints, so we match program spaces, not
4749 describe_other_breakpoints (struct gdbarch
*gdbarch
,
4750 struct program_space
*pspace
, CORE_ADDR pc
,
4751 struct obj_section
*section
, int thread
)
4754 struct breakpoint
*b
;
4757 others
+= breakpoint_has_pc (b
, pspace
, pc
, section
);
4761 printf_filtered (_("Note: breakpoint "));
4762 else /* if (others == ???) */
4763 printf_filtered (_("Note: breakpoints "));
4765 if (breakpoint_has_pc (b
, pspace
, pc
, section
))
4768 printf_filtered ("%d", b
->number
);
4769 if (b
->thread
== -1 && thread
!= -1)
4770 printf_filtered (" (all threads)");
4771 else if (b
->thread
!= -1)
4772 printf_filtered (" (thread %d)", b
->thread
);
4773 printf_filtered ("%s%s ",
4774 ((b
->enable_state
== bp_disabled
4775 || b
->enable_state
== bp_call_disabled
4776 || b
->enable_state
== bp_startup_disabled
)
4778 : b
->enable_state
== bp_permanent
4782 : ((others
== 1) ? " and" : ""));
4784 printf_filtered (_("also set at pc "));
4785 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
4786 printf_filtered (".\n");
4790 /* Set the default place to put a breakpoint
4791 for the `break' command with no arguments. */
4794 set_default_breakpoint (int valid
, struct program_space
*pspace
,
4795 CORE_ADDR addr
, struct symtab
*symtab
,
4798 default_breakpoint_valid
= valid
;
4799 default_breakpoint_pspace
= pspace
;
4800 default_breakpoint_address
= addr
;
4801 default_breakpoint_symtab
= symtab
;
4802 default_breakpoint_line
= line
;
4805 /* Return true iff it is meaningful to use the address member of
4806 BPT. For some breakpoint types, the address member is irrelevant
4807 and it makes no sense to attempt to compare it to other addresses
4808 (or use it for any other purpose either).
4810 More specifically, each of the following breakpoint types will always
4811 have a zero valued address and we don't want to mark breakpoints of any of
4812 these types to be a duplicate of an actual breakpoint at address zero:
4820 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4822 enum bptype type
= bpt
->type
;
4824 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
4827 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
4828 true if LOC1 and LOC2 represent the same watchpoint location. */
4831 watchpoint_locations_match (struct bp_location
*loc1
, struct bp_location
*loc2
)
4833 /* Note that this checks the owner's type, not the location's. In
4834 case the target does not support read watchpoints, but does
4835 support access watchpoints, we'll have bp_read_watchpoint
4836 watchpoints with hw_access locations. Those should be considered
4837 duplicates of hw_read locations. The hw_read locations will
4838 become hw_access locations later. */
4839 return (loc1
->owner
->type
== loc2
->owner
->type
4840 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
4841 && loc1
->address
== loc2
->address
4842 && loc1
->length
== loc2
->length
);
4845 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
4846 same breakpoint location. In most targets, this can only be true
4847 if ASPACE1 matches ASPACE2. On targets that have global
4848 breakpoints, the address space doesn't really matter. */
4851 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
4852 struct address_space
*aspace2
, CORE_ADDR addr2
)
4854 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
4855 || aspace1
== aspace2
)
4859 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
4860 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
4861 represent the same location. */
4864 breakpoint_locations_match (struct bp_location
*loc1
, struct bp_location
*loc2
)
4866 int hw_point1
= is_hardware_watchpoint (loc1
->owner
);
4867 int hw_point2
= is_hardware_watchpoint (loc2
->owner
);
4869 if (hw_point1
!= hw_point2
)
4872 return watchpoint_locations_match (loc1
, loc2
);
4874 return breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
4875 loc2
->pspace
->aspace
, loc2
->address
);
4879 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4880 int bnum
, int have_bnum
)
4885 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4886 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4888 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4889 bnum
, astr1
, astr2
);
4891 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4894 /* Adjust a breakpoint's address to account for architectural constraints
4895 on breakpoint placement. Return the adjusted address. Note: Very
4896 few targets require this kind of adjustment. For most targets,
4897 this function is simply the identity function. */
4900 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
4901 CORE_ADDR bpaddr
, enum bptype bptype
)
4903 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
4905 /* Very few targets need any kind of breakpoint adjustment. */
4908 else if (bptype
== bp_watchpoint
4909 || bptype
== bp_hardware_watchpoint
4910 || bptype
== bp_read_watchpoint
4911 || bptype
== bp_access_watchpoint
4912 || bptype
== bp_catchpoint
)
4914 /* Watchpoints and the various bp_catch_* eventpoints should not
4915 have their addresses modified. */
4920 CORE_ADDR adjusted_bpaddr
;
4922 /* Some targets have architectural constraints on the placement
4923 of breakpoint instructions. Obtain the adjusted address. */
4924 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
4926 /* An adjusted breakpoint address can significantly alter
4927 a user's expectations. Print a warning if an adjustment
4929 if (adjusted_bpaddr
!= bpaddr
)
4930 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4932 return adjusted_bpaddr
;
4936 /* Allocate a struct bp_location. */
4938 static struct bp_location
*
4939 allocate_bp_location (struct breakpoint
*bpt
)
4941 struct bp_location
*loc
, *loc_p
;
4943 loc
= xmalloc (sizeof (struct bp_location
));
4944 memset (loc
, 0, sizeof (*loc
));
4948 loc
->shlib_disabled
= 0;
4957 case bp_longjmp_resume
:
4958 case bp_step_resume
:
4959 case bp_watchpoint_scope
:
4961 case bp_shlib_event
:
4962 case bp_thread_event
:
4963 case bp_overlay_event
:
4965 case bp_longjmp_master
:
4966 loc
->loc_type
= bp_loc_software_breakpoint
;
4968 case bp_hardware_breakpoint
:
4969 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4971 case bp_hardware_watchpoint
:
4972 case bp_read_watchpoint
:
4973 case bp_access_watchpoint
:
4974 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4979 case bp_fast_tracepoint
:
4980 loc
->loc_type
= bp_loc_other
;
4983 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4989 static void free_bp_location (struct bp_location
*loc
)
4994 if (loc
->function_name
)
4995 xfree (loc
->function_name
);
5000 /* Helper to set_raw_breakpoint below. Creates a breakpoint
5001 that has type BPTYPE and has no locations as yet. */
5002 /* This function is used in gdbtk sources and thus can not be made static. */
5004 static struct breakpoint
*
5005 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
5008 struct breakpoint
*b
, *b1
;
5010 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
5011 memset (b
, 0, sizeof (*b
));
5014 b
->gdbarch
= gdbarch
;
5015 b
->language
= current_language
->la_language
;
5016 b
->input_radix
= input_radix
;
5018 b
->enable_state
= bp_enabled
;
5021 b
->ignore_count
= 0;
5023 b
->frame_id
= null_frame_id
;
5024 b
->forked_inferior_pid
= null_ptid
;
5025 b
->exec_pathname
= NULL
;
5026 b
->syscalls_to_be_caught
= NULL
;
5028 b
->condition_not_parsed
= 0;
5030 /* Add this breakpoint to the end of the chain
5031 so that a list of breakpoints will come out in order
5032 of increasing numbers. */
5034 b1
= breakpoint_chain
;
5036 breakpoint_chain
= b
;
5046 /* Initialize loc->function_name. */
5048 set_breakpoint_location_function (struct bp_location
*loc
)
5050 if (loc
->owner
->type
== bp_breakpoint
5051 || loc
->owner
->type
== bp_hardware_breakpoint
5052 || tracepoint_type (loc
->owner
))
5054 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
5056 if (loc
->function_name
)
5057 loc
->function_name
= xstrdup (loc
->function_name
);
5061 /* Attempt to determine architecture of location identified by SAL. */
5062 static struct gdbarch
*
5063 get_sal_arch (struct symtab_and_line sal
)
5066 return get_objfile_arch (sal
.section
->objfile
);
5068 return get_objfile_arch (sal
.symtab
->objfile
);
5073 /* set_raw_breakpoint is a low level routine for allocating and
5074 partially initializing a breakpoint of type BPTYPE. The newly
5075 created breakpoint's address, section, source file name, and line
5076 number are provided by SAL. The newly created and partially
5077 initialized breakpoint is added to the breakpoint chain and
5078 is also returned as the value of this function.
5080 It is expected that the caller will complete the initialization of
5081 the newly created breakpoint struct as well as output any status
5082 information regarding the creation of a new breakpoint. In
5083 particular, set_raw_breakpoint does NOT set the breakpoint
5084 number! Care should be taken to not allow an error to occur
5085 prior to completing the initialization of the breakpoint. If this
5086 should happen, a bogus breakpoint will be left on the chain. */
5089 set_raw_breakpoint (struct gdbarch
*gdbarch
,
5090 struct symtab_and_line sal
, enum bptype bptype
)
5092 struct breakpoint
*b
= set_raw_breakpoint_without_location (gdbarch
, bptype
);
5093 CORE_ADDR adjusted_address
;
5094 struct gdbarch
*loc_gdbarch
;
5096 loc_gdbarch
= get_sal_arch (sal
);
5098 loc_gdbarch
= b
->gdbarch
;
5100 if (bptype
!= bp_catchpoint
)
5101 gdb_assert (sal
.pspace
!= NULL
);
5103 /* Adjust the breakpoint's address prior to allocating a location.
5104 Once we call allocate_bp_location(), that mostly uninitialized
5105 location will be placed on the location chain. Adjustment of the
5106 breakpoint may cause target_read_memory() to be called and we do
5107 not want its scan of the location chain to find a breakpoint and
5108 location that's only been partially initialized. */
5109 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
, sal
.pc
, b
->type
);
5111 b
->loc
= allocate_bp_location (b
);
5112 b
->loc
->gdbarch
= loc_gdbarch
;
5113 b
->loc
->requested_address
= sal
.pc
;
5114 b
->loc
->address
= adjusted_address
;
5115 b
->loc
->pspace
= sal
.pspace
;
5117 /* Store the program space that was used to set the breakpoint, for
5118 breakpoint resetting. */
5119 b
->pspace
= sal
.pspace
;
5121 if (sal
.symtab
== NULL
)
5122 b
->source_file
= NULL
;
5124 b
->source_file
= xstrdup (sal
.symtab
->filename
);
5125 b
->loc
->section
= sal
.section
;
5126 b
->line_number
= sal
.line
;
5128 set_breakpoint_location_function (b
->loc
);
5130 breakpoints_changed ();
5136 /* Note that the breakpoint object B describes a permanent breakpoint
5137 instruction, hard-wired into the inferior's code. */
5139 make_breakpoint_permanent (struct breakpoint
*b
)
5141 struct bp_location
*bl
;
5142 b
->enable_state
= bp_permanent
;
5144 /* By definition, permanent breakpoints are already present in the code.
5145 Mark all locations as inserted. For now, make_breakpoint_permanent
5146 is called in just one place, so it's hard to say if it's reasonable
5147 to have permanent breakpoint with multiple locations or not,
5148 but it's easy to implmement. */
5149 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5153 /* Call this routine when stepping and nexting to enable a breakpoint
5154 if we do a longjmp() in THREAD. When we hit that breakpoint, call
5155 set_longjmp_resume_breakpoint() to figure out where we are going. */
5158 set_longjmp_breakpoint (int thread
)
5160 struct breakpoint
*b
, *temp
;
5162 /* To avoid having to rescan all objfile symbols at every step,
5163 we maintain a list of continually-inserted but always disabled
5164 longjmp "master" breakpoints. Here, we simply create momentary
5165 clones of those and enable them for the requested thread. */
5166 ALL_BREAKPOINTS_SAFE (b
, temp
)
5167 if (b
->pspace
== current_program_space
5168 && b
->type
== bp_longjmp_master
)
5170 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
5171 clone
->type
= bp_longjmp
;
5172 clone
->thread
= thread
;
5176 /* Delete all longjmp breakpoints from THREAD. */
5178 delete_longjmp_breakpoint (int thread
)
5180 struct breakpoint
*b
, *temp
;
5182 ALL_BREAKPOINTS_SAFE (b
, temp
)
5183 if (b
->type
== bp_longjmp
)
5185 if (b
->thread
== thread
)
5186 delete_breakpoint (b
);
5191 enable_overlay_breakpoints (void)
5193 struct breakpoint
*b
;
5196 if (b
->type
== bp_overlay_event
)
5198 b
->enable_state
= bp_enabled
;
5199 update_global_location_list (1);
5200 overlay_events_enabled
= 1;
5205 disable_overlay_breakpoints (void)
5207 struct breakpoint
*b
;
5210 if (b
->type
== bp_overlay_event
)
5212 b
->enable_state
= bp_disabled
;
5213 update_global_location_list (0);
5214 overlay_events_enabled
= 0;
5219 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5221 struct breakpoint
*b
;
5223 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
);
5225 b
->enable_state
= bp_enabled
;
5226 /* addr_string has to be used or breakpoint_re_set will delete me. */
5228 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
5230 update_global_location_list_nothrow (1);
5236 remove_thread_event_breakpoints (void)
5238 struct breakpoint
*b
, *temp
;
5240 ALL_BREAKPOINTS_SAFE (b
, temp
)
5241 if (b
->type
== bp_thread_event
5242 && b
->loc
->pspace
== current_program_space
)
5243 delete_breakpoint (b
);
5246 struct captured_parse_breakpoint_args
5249 struct symtabs_and_lines
*sals_p
;
5250 char ***addr_string_p
;
5254 struct lang_and_radix
5260 /* Create a breakpoint for JIT code registration and unregistration. */
5263 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5265 struct breakpoint
*b
;
5267 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
5268 update_global_location_list_nothrow (1);
5273 remove_solib_event_breakpoints (void)
5275 struct breakpoint
*b
, *temp
;
5277 ALL_BREAKPOINTS_SAFE (b
, temp
)
5278 if (b
->type
== bp_shlib_event
5279 && b
->loc
->pspace
== current_program_space
)
5280 delete_breakpoint (b
);
5284 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5286 struct breakpoint
*b
;
5288 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
5289 update_global_location_list_nothrow (1);
5293 /* Disable any breakpoints that are on code in shared libraries. Only
5294 apply to enabled breakpoints, disabled ones can just stay disabled. */
5297 disable_breakpoints_in_shlibs (void)
5299 struct bp_location
*loc
, **locp_tmp
;
5301 ALL_BP_LOCATIONS (loc
, locp_tmp
)
5303 struct breakpoint
*b
= loc
->owner
;
5304 /* We apply the check to all breakpoints, including disabled
5305 for those with loc->duplicate set. This is so that when breakpoint
5306 becomes enabled, or the duplicate is removed, gdb will try to insert
5307 all breakpoints. If we don't set shlib_disabled here, we'll try
5308 to insert those breakpoints and fail. */
5309 if (((b
->type
== bp_breakpoint
)
5310 || (b
->type
== bp_hardware_breakpoint
)
5311 || (tracepoint_type (b
)))
5312 && loc
->pspace
== current_program_space
5313 && !loc
->shlib_disabled
5315 && PC_SOLIB (loc
->address
)
5317 && solib_name_from_address (loc
->pspace
, loc
->address
)
5321 loc
->shlib_disabled
= 1;
5326 /* Disable any breakpoints that are in in an unloaded shared library. Only
5327 apply to enabled breakpoints, disabled ones can just stay disabled. */
5330 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
5332 struct bp_location
*loc
, **locp_tmp
;
5333 int disabled_shlib_breaks
= 0;
5335 /* SunOS a.out shared libraries are always mapped, so do not
5336 disable breakpoints; they will only be reported as unloaded
5337 through clear_solib when GDB discards its shared library
5338 list. See clear_solib for more information. */
5339 if (exec_bfd
!= NULL
5340 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
5343 ALL_BP_LOCATIONS (loc
, locp_tmp
)
5345 struct breakpoint
*b
= loc
->owner
;
5346 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
5347 || loc
->loc_type
== bp_loc_software_breakpoint
)
5348 && solib
->pspace
== loc
->pspace
5349 && !loc
->shlib_disabled
5350 && (b
->type
== bp_breakpoint
|| b
->type
== bp_hardware_breakpoint
)
5351 && solib_contains_address_p (solib
, loc
->address
))
5353 loc
->shlib_disabled
= 1;
5354 /* At this point, we cannot rely on remove_breakpoint
5355 succeeding so we must mark the breakpoint as not inserted
5356 to prevent future errors occurring in remove_breakpoints. */
5358 if (!disabled_shlib_breaks
)
5360 target_terminal_ours_for_output ();
5361 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
5364 disabled_shlib_breaks
= 1;
5369 /* FORK & VFORK catchpoints. */
5371 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
5374 insert_catch_fork (struct breakpoint
*b
)
5376 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
5379 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
5382 remove_catch_fork (struct breakpoint
*b
)
5384 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
5387 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
5391 breakpoint_hit_catch_fork (struct breakpoint
*b
)
5393 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
5396 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
5398 static enum print_stop_action
5399 print_it_catch_fork (struct breakpoint
*b
)
5401 annotate_catchpoint (b
->number
);
5402 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
5403 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5404 return PRINT_SRC_AND_LOC
;
5407 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
5410 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5412 struct value_print_options opts
;
5414 get_user_print_options (&opts
);
5416 /* Field 4, the address, is omitted (which makes the columns
5417 not line up too nicely with the headers, but the effect
5418 is relatively readable). */
5419 if (opts
.addressprint
)
5420 ui_out_field_skip (uiout
, "addr");
5422 ui_out_text (uiout
, "fork");
5423 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
5425 ui_out_text (uiout
, ", process ");
5426 ui_out_field_int (uiout
, "what",
5427 ptid_get_pid (b
->forked_inferior_pid
));
5428 ui_out_spaces (uiout
, 1);
5432 /* Implement the "print_mention" breakpoint_ops method for fork
5436 print_mention_catch_fork (struct breakpoint
*b
)
5438 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
5441 /* The breakpoint_ops structure to be used in fork catchpoints. */
5443 static struct breakpoint_ops catch_fork_breakpoint_ops
=
5447 breakpoint_hit_catch_fork
,
5448 print_it_catch_fork
,
5449 print_one_catch_fork
,
5450 print_mention_catch_fork
5453 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
5456 insert_catch_vfork (struct breakpoint
*b
)
5458 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
5461 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
5464 remove_catch_vfork (struct breakpoint
*b
)
5466 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
5469 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
5473 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
5475 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
5478 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
5480 static enum print_stop_action
5481 print_it_catch_vfork (struct breakpoint
*b
)
5483 annotate_catchpoint (b
->number
);
5484 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
5485 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5486 return PRINT_SRC_AND_LOC
;
5489 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
5492 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5494 struct value_print_options opts
;
5496 get_user_print_options (&opts
);
5497 /* Field 4, the address, is omitted (which makes the columns
5498 not line up too nicely with the headers, but the effect
5499 is relatively readable). */
5500 if (opts
.addressprint
)
5501 ui_out_field_skip (uiout
, "addr");
5503 ui_out_text (uiout
, "vfork");
5504 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
5506 ui_out_text (uiout
, ", process ");
5507 ui_out_field_int (uiout
, "what",
5508 ptid_get_pid (b
->forked_inferior_pid
));
5509 ui_out_spaces (uiout
, 1);
5513 /* Implement the "print_mention" breakpoint_ops method for vfork
5517 print_mention_catch_vfork (struct breakpoint
*b
)
5519 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
5522 /* The breakpoint_ops structure to be used in vfork catchpoints. */
5524 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
5528 breakpoint_hit_catch_vfork
,
5529 print_it_catch_vfork
,
5530 print_one_catch_vfork
,
5531 print_mention_catch_vfork
5534 /* Implement the "insert" breakpoint_ops method for syscall
5538 insert_catch_syscall (struct breakpoint
*b
)
5540 struct inferior
*inf
= current_inferior ();
5542 ++inf
->total_syscalls_count
;
5543 if (!b
->syscalls_to_be_caught
)
5544 ++inf
->any_syscall_count
;
5549 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5553 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
5555 int old_size
= VEC_length (int, inf
->syscalls_counts
);
5556 uintptr_t vec_addr_offset
= old_size
* ((uintptr_t) sizeof (int));
5558 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
5559 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
5561 memset ((void *) vec_addr
, 0,
5562 (iter
+ 1 - old_size
) * sizeof (int));
5564 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
5565 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
5569 target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
5570 inf
->total_syscalls_count
!= 0,
5571 inf
->any_syscall_count
,
5572 VEC_length (int, inf
->syscalls_counts
),
5573 VEC_address (int, inf
->syscalls_counts
));
5576 /* Implement the "remove" breakpoint_ops method for syscall
5580 remove_catch_syscall (struct breakpoint
*b
)
5582 struct inferior
*inf
= current_inferior ();
5584 --inf
->total_syscalls_count
;
5585 if (!b
->syscalls_to_be_caught
)
5586 --inf
->any_syscall_count
;
5591 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5595 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
5596 /* Shouldn't happen. */
5598 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
5599 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
5603 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
5604 inf
->total_syscalls_count
!= 0,
5605 inf
->any_syscall_count
,
5606 VEC_length (int, inf
->syscalls_counts
),
5607 VEC_address (int, inf
->syscalls_counts
));
5610 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
5614 breakpoint_hit_catch_syscall (struct breakpoint
*b
)
5616 /* We must check if we are catching specific syscalls in this breakpoint.
5617 If we are, then we must guarantee that the called syscall is the same
5618 syscall we are catching. */
5619 int syscall_number
= 0;
5621 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
5624 /* Now, checking if the syscall is the same. */
5625 if (b
->syscalls_to_be_caught
)
5629 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5631 if (syscall_number
== iter
)
5641 /* Implement the "print_it" breakpoint_ops method for syscall
5644 static enum print_stop_action
5645 print_it_catch_syscall (struct breakpoint
*b
)
5647 /* These are needed because we want to know in which state a
5648 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
5649 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
5650 must print "called syscall" or "returned from syscall". */
5652 struct target_waitstatus last
;
5654 struct cleanup
*old_chain
;
5657 get_last_target_status (&ptid
, &last
);
5659 get_syscall_by_number (last
.value
.syscall_number
, &s
);
5661 annotate_catchpoint (b
->number
);
5664 syscall_id
= xstrprintf ("%d", last
.value
.syscall_number
);
5666 syscall_id
= xstrprintf ("'%s'", s
.name
);
5668 old_chain
= make_cleanup (xfree
, syscall_id
);
5670 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
5671 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
5672 b
->number
, syscall_id
);
5673 else if (last
.kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
5674 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
5675 b
->number
, syscall_id
);
5677 do_cleanups (old_chain
);
5679 return PRINT_SRC_AND_LOC
;
5682 /* Implement the "print_one" breakpoint_ops method for syscall
5686 print_one_catch_syscall (struct breakpoint
*b
,
5687 struct bp_location
**last_loc
)
5689 struct value_print_options opts
;
5691 get_user_print_options (&opts
);
5692 /* Field 4, the address, is omitted (which makes the columns
5693 not line up too nicely with the headers, but the effect
5694 is relatively readable). */
5695 if (opts
.addressprint
)
5696 ui_out_field_skip (uiout
, "addr");
5699 if (b
->syscalls_to_be_caught
5700 && VEC_length (int, b
->syscalls_to_be_caught
) > 1)
5701 ui_out_text (uiout
, "syscalls \"");
5703 ui_out_text (uiout
, "syscall \"");
5705 if (b
->syscalls_to_be_caught
)
5708 char *text
= xstrprintf ("%s", "");
5710 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5715 get_syscall_by_number (iter
, &s
);
5718 text
= xstrprintf ("%s%s, ", text
, s
.name
);
5720 text
= xstrprintf ("%s%d, ", text
, iter
);
5722 /* We have to xfree the last 'text' (now stored at 'x')
5723 because xstrprintf dinamically allocates new space for it
5727 /* Remove the last comma. */
5728 text
[strlen (text
) - 2] = '\0';
5729 ui_out_field_string (uiout
, "what", text
);
5732 ui_out_field_string (uiout
, "what", "<any syscall>");
5733 ui_out_text (uiout
, "\" ");
5736 /* Implement the "print_mention" breakpoint_ops method for syscall
5740 print_mention_catch_syscall (struct breakpoint
*b
)
5742 if (b
->syscalls_to_be_caught
)
5746 if (VEC_length (int, b
->syscalls_to_be_caught
) > 1)
5747 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
5749 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
5752 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5756 get_syscall_by_number (iter
, &s
);
5759 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
5761 printf_filtered (" %d", s
.number
);
5763 printf_filtered (")");
5766 printf_filtered (_("Catchpoint %d (any syscall)"),
5770 /* The breakpoint_ops structure to be used in syscall catchpoints. */
5772 static struct breakpoint_ops catch_syscall_breakpoint_ops
=
5774 insert_catch_syscall
,
5775 remove_catch_syscall
,
5776 breakpoint_hit_catch_syscall
,
5777 print_it_catch_syscall
,
5778 print_one_catch_syscall
,
5779 print_mention_catch_syscall
5782 /* Returns non-zero if 'b' is a syscall catchpoint. */
5785 syscall_catchpoint_p (struct breakpoint
*b
)
5787 return (b
->ops
== &catch_syscall_breakpoint_ops
);
5790 /* Create a new breakpoint of the bp_catchpoint kind and return it,
5791 but does NOT mention it nor update the global location list.
5792 This is useful if you need to fill more fields in the
5793 struct breakpoint before calling mention.
5795 If TEMPFLAG is non-zero, then make the breakpoint temporary.
5796 If COND_STRING is not NULL, then store it in the breakpoint.
5797 OPS, if not NULL, is the breakpoint_ops structure associated
5798 to the catchpoint. */
5800 static struct breakpoint
*
5801 create_catchpoint_without_mention (struct gdbarch
*gdbarch
, int tempflag
,
5803 struct breakpoint_ops
*ops
)
5805 struct symtab_and_line sal
;
5806 struct breakpoint
*b
;
5809 sal
.pspace
= current_program_space
;
5811 b
= set_raw_breakpoint (gdbarch
, sal
, bp_catchpoint
);
5812 set_breakpoint_count (breakpoint_count
+ 1);
5813 b
->number
= breakpoint_count
;
5815 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
5817 b
->addr_string
= NULL
;
5818 b
->enable_state
= bp_enabled
;
5819 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5825 /* Create a new breakpoint of the bp_catchpoint kind and return it.
5827 If TEMPFLAG is non-zero, then make the breakpoint temporary.
5828 If COND_STRING is not NULL, then store it in the breakpoint.
5829 OPS, if not NULL, is the breakpoint_ops structure associated
5830 to the catchpoint. */
5832 static struct breakpoint
*
5833 create_catchpoint (struct gdbarch
*gdbarch
, int tempflag
,
5834 char *cond_string
, struct breakpoint_ops
*ops
)
5836 struct breakpoint
*b
=
5837 create_catchpoint_without_mention (gdbarch
, tempflag
, cond_string
, ops
);
5840 update_global_location_list (1);
5846 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
5847 int tempflag
, char *cond_string
,
5848 struct breakpoint_ops
*ops
)
5850 struct breakpoint
*b
5851 = create_catchpoint (gdbarch
, tempflag
, cond_string
, ops
);
5853 /* FIXME: We should put this information in a breakpoint private data
5855 b
->forked_inferior_pid
= null_ptid
;
5858 /* Exec catchpoints. */
5861 insert_catch_exec (struct breakpoint
*b
)
5863 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
5867 remove_catch_exec (struct breakpoint
*b
)
5869 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
5873 breakpoint_hit_catch_exec (struct breakpoint
*b
)
5875 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
5878 static enum print_stop_action
5879 print_it_catch_exec (struct breakpoint
*b
)
5881 annotate_catchpoint (b
->number
);
5882 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
5884 return PRINT_SRC_AND_LOC
;
5888 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
5890 struct value_print_options opts
;
5892 get_user_print_options (&opts
);
5894 /* Field 4, the address, is omitted (which makes the columns
5895 not line up too nicely with the headers, but the effect
5896 is relatively readable). */
5897 if (opts
.addressprint
)
5898 ui_out_field_skip (uiout
, "addr");
5900 ui_out_text (uiout
, "exec");
5901 if (b
->exec_pathname
!= NULL
)
5903 ui_out_text (uiout
, ", program \"");
5904 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
5905 ui_out_text (uiout
, "\" ");
5910 print_mention_catch_exec (struct breakpoint
*b
)
5912 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
5915 static struct breakpoint_ops catch_exec_breakpoint_ops
=
5919 breakpoint_hit_catch_exec
,
5920 print_it_catch_exec
,
5921 print_one_catch_exec
,
5922 print_mention_catch_exec
5926 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
5927 struct breakpoint_ops
*ops
)
5929 struct gdbarch
*gdbarch
= get_current_arch ();
5930 struct breakpoint
*b
=
5931 create_catchpoint_without_mention (gdbarch
, tempflag
, NULL
, ops
);
5933 b
->syscalls_to_be_caught
= filter
;
5935 /* Now, we have to mention the breakpoint and update the global
5938 update_global_location_list (1);
5942 hw_breakpoint_used_count (void)
5944 struct breakpoint
*b
;
5949 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
5957 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
5959 struct breakpoint
*b
;
5962 *other_type_used
= 0;
5965 if (breakpoint_enabled (b
))
5967 if (b
->type
== type
)
5969 else if ((b
->type
== bp_hardware_watchpoint
5970 || b
->type
== bp_read_watchpoint
5971 || b
->type
== bp_access_watchpoint
))
5972 *other_type_used
= 1;
5979 disable_watchpoints_before_interactive_call_start (void)
5981 struct breakpoint
*b
;
5985 if (((b
->type
== bp_watchpoint
)
5986 || (b
->type
== bp_hardware_watchpoint
)
5987 || (b
->type
== bp_read_watchpoint
)
5988 || (b
->type
== bp_access_watchpoint
))
5989 && breakpoint_enabled (b
))
5991 b
->enable_state
= bp_call_disabled
;
5992 update_global_location_list (0);
5998 enable_watchpoints_after_interactive_call_stop (void)
6000 struct breakpoint
*b
;
6004 if (((b
->type
== bp_watchpoint
)
6005 || (b
->type
== bp_hardware_watchpoint
)
6006 || (b
->type
== bp_read_watchpoint
)
6007 || (b
->type
== bp_access_watchpoint
))
6008 && (b
->enable_state
== bp_call_disabled
))
6010 b
->enable_state
= bp_enabled
;
6011 update_global_location_list (1);
6017 disable_breakpoints_before_startup (void)
6019 struct breakpoint
*b
;
6024 if (b
->pspace
!= current_program_space
)
6027 if ((b
->type
== bp_breakpoint
6028 || b
->type
== bp_hardware_breakpoint
)
6029 && breakpoint_enabled (b
))
6031 b
->enable_state
= bp_startup_disabled
;
6037 update_global_location_list (0);
6039 current_program_space
->executing_startup
= 1;
6043 enable_breakpoints_after_startup (void)
6045 struct breakpoint
*b
;
6048 current_program_space
->executing_startup
= 0;
6052 if (b
->pspace
!= current_program_space
)
6055 if ((b
->type
== bp_breakpoint
6056 || b
->type
== bp_hardware_breakpoint
)
6057 && b
->enable_state
== bp_startup_disabled
)
6059 b
->enable_state
= bp_enabled
;
6065 breakpoint_re_set ();
6069 /* Set a breakpoint that will evaporate an end of command
6070 at address specified by SAL.
6071 Restrict it to frame FRAME if FRAME is nonzero. */
6074 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
6075 struct frame_id frame_id
, enum bptype type
)
6077 struct breakpoint
*b
;
6079 /* If FRAME_ID is valid, it should be a real frame, not an inlined
6081 gdb_assert (!frame_id_inlined_p (frame_id
));
6083 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
6084 b
->enable_state
= bp_enabled
;
6085 b
->disposition
= disp_donttouch
;
6086 b
->frame_id
= frame_id
;
6088 /* If we're debugging a multi-threaded program, then we
6089 want momentary breakpoints to be active in only a
6090 single thread of control. */
6091 if (in_thread_list (inferior_ptid
))
6092 b
->thread
= pid_to_thread_id (inferior_ptid
);
6094 update_global_location_list_nothrow (1);
6099 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
6103 clone_momentary_breakpoint (struct breakpoint
*orig
)
6105 struct breakpoint
*copy
;
6107 /* If there's nothing to clone, then return nothing. */
6111 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, orig
->type
);
6112 copy
->loc
= allocate_bp_location (copy
);
6113 set_breakpoint_location_function (copy
->loc
);
6115 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
6116 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
6117 copy
->loc
->address
= orig
->loc
->address
;
6118 copy
->loc
->section
= orig
->loc
->section
;
6119 copy
->loc
->pspace
= orig
->loc
->pspace
;
6121 if (orig
->source_file
== NULL
)
6122 copy
->source_file
= NULL
;
6124 copy
->source_file
= xstrdup (orig
->source_file
);
6126 copy
->line_number
= orig
->line_number
;
6127 copy
->frame_id
= orig
->frame_id
;
6128 copy
->thread
= orig
->thread
;
6129 copy
->pspace
= orig
->pspace
;
6131 copy
->enable_state
= bp_enabled
;
6132 copy
->disposition
= disp_donttouch
;
6133 copy
->number
= internal_breakpoint_number
--;
6135 update_global_location_list_nothrow (0);
6140 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
6143 struct symtab_and_line sal
;
6145 sal
= find_pc_line (pc
, 0);
6147 sal
.section
= find_pc_overlay (pc
);
6148 sal
.explicit_pc
= 1;
6150 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
6154 /* Tell the user we have just set a breakpoint B. */
6157 mention (struct breakpoint
*b
)
6160 struct cleanup
*ui_out_chain
;
6161 struct value_print_options opts
;
6163 get_user_print_options (&opts
);
6165 /* FIXME: This is misplaced; mention() is called by things (like
6166 hitting a watchpoint) other than breakpoint creation. It should
6167 be possible to clean this up and at the same time replace the
6168 random calls to breakpoint_changed with this hook. */
6169 observer_notify_breakpoint_created (b
->number
);
6171 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
6172 b
->ops
->print_mention (b
);
6177 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
6180 ui_out_text (uiout
, "Watchpoint ");
6181 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
6182 ui_out_field_int (uiout
, "number", b
->number
);
6183 ui_out_text (uiout
, ": ");
6184 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6185 do_cleanups (ui_out_chain
);
6187 case bp_hardware_watchpoint
:
6188 ui_out_text (uiout
, "Hardware watchpoint ");
6189 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
6190 ui_out_field_int (uiout
, "number", b
->number
);
6191 ui_out_text (uiout
, ": ");
6192 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6193 do_cleanups (ui_out_chain
);
6195 case bp_read_watchpoint
:
6196 ui_out_text (uiout
, "Hardware read watchpoint ");
6197 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
6198 ui_out_field_int (uiout
, "number", b
->number
);
6199 ui_out_text (uiout
, ": ");
6200 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6201 do_cleanups (ui_out_chain
);
6203 case bp_access_watchpoint
:
6204 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
6205 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
6206 ui_out_field_int (uiout
, "number", b
->number
);
6207 ui_out_text (uiout
, ": ");
6208 ui_out_field_string (uiout
, "exp", b
->exp_string
);
6209 do_cleanups (ui_out_chain
);
6212 if (ui_out_is_mi_like_p (uiout
))
6217 if (b
->disposition
== disp_del
)
6218 printf_filtered (_("Temporary breakpoint"));
6220 printf_filtered (_("Breakpoint"));
6221 printf_filtered (_(" %d"), b
->number
);
6224 case bp_hardware_breakpoint
:
6225 if (ui_out_is_mi_like_p (uiout
))
6230 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
6234 if (ui_out_is_mi_like_p (uiout
))
6239 printf_filtered (_("Tracepoint"));
6240 printf_filtered (_(" %d"), b
->number
);
6243 case bp_fast_tracepoint
:
6244 if (ui_out_is_mi_like_p (uiout
))
6249 printf_filtered (_("Fast tracepoint"));
6250 printf_filtered (_(" %d"), b
->number
);
6257 case bp_longjmp_resume
:
6258 case bp_step_resume
:
6260 case bp_watchpoint_scope
:
6261 case bp_shlib_event
:
6262 case bp_thread_event
:
6263 case bp_overlay_event
:
6265 case bp_longjmp_master
:
6271 /* i18n: cagney/2005-02-11: Below needs to be merged into a
6275 printf_filtered (_(" (%s) pending."), b
->addr_string
);
6279 if (opts
.addressprint
|| b
->source_file
== NULL
)
6281 printf_filtered (" at ");
6282 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
6286 printf_filtered (": file %s, line %d.",
6287 b
->source_file
, b
->line_number
);
6291 struct bp_location
*loc
= b
->loc
;
6293 for (; loc
; loc
= loc
->next
)
6295 printf_filtered (" (%d locations)", n
);
6300 if (ui_out_is_mi_like_p (uiout
))
6302 printf_filtered ("\n");
6306 static struct bp_location
*
6307 add_location_to_breakpoint (struct breakpoint
*b
,
6308 const struct symtab_and_line
*sal
)
6310 struct bp_location
*loc
, **tmp
;
6312 loc
= allocate_bp_location (b
);
6313 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
6316 loc
->gdbarch
= get_sal_arch (*sal
);
6318 loc
->gdbarch
= b
->gdbarch
;
6319 loc
->requested_address
= sal
->pc
;
6320 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
6321 loc
->requested_address
, b
->type
);
6322 loc
->pspace
= sal
->pspace
;
6323 gdb_assert (loc
->pspace
!= NULL
);
6324 loc
->section
= sal
->section
;
6326 set_breakpoint_location_function (loc
);
6331 /* Return 1 if LOC is pointing to a permanent breakpoint,
6332 return 0 otherwise. */
6335 bp_loc_is_permanent (struct bp_location
*loc
)
6339 const gdb_byte
*brk
;
6340 gdb_byte
*target_mem
;
6341 struct cleanup
*cleanup
;
6344 gdb_assert (loc
!= NULL
);
6346 addr
= loc
->address
;
6347 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
6349 /* Software breakpoints unsupported? */
6353 target_mem
= alloca (len
);
6355 /* Enable the automatic memory restoration from breakpoints while
6356 we read the memory. Otherwise we could say about our temporary
6357 breakpoints they are permanent. */
6358 cleanup
= save_current_space_and_thread ();
6360 switch_to_program_space_and_thread (loc
->pspace
);
6361 make_show_memory_breakpoints_cleanup (0);
6363 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
6364 && memcmp (target_mem
, brk
, len
) == 0)
6367 do_cleanups (cleanup
);
6374 /* Create a breakpoint with SAL as location. Use ADDR_STRING
6375 as textual description of the location, and COND_STRING
6376 as condition expression. */
6379 create_breakpoint (struct gdbarch
*gdbarch
,
6380 struct symtabs_and_lines sals
, char *addr_string
,
6382 enum bptype type
, enum bpdisp disposition
,
6383 int thread
, int task
, int ignore_count
,
6384 struct breakpoint_ops
*ops
, int from_tty
, int enabled
)
6386 struct breakpoint
*b
= NULL
;
6389 if (type
== bp_hardware_breakpoint
)
6391 int i
= hw_breakpoint_used_count ();
6392 int target_resources_ok
=
6393 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
6395 if (target_resources_ok
== 0)
6396 error (_("No hardware breakpoint support in the target."));
6397 else if (target_resources_ok
< 0)
6398 error (_("Hardware breakpoints used exceeds limit."));
6401 gdb_assert (sals
.nelts
> 0);
6403 for (i
= 0; i
< sals
.nelts
; ++i
)
6405 struct symtab_and_line sal
= sals
.sals
[i
];
6406 struct bp_location
*loc
;
6410 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
6412 loc_gdbarch
= gdbarch
;
6414 describe_other_breakpoints (loc_gdbarch
,
6415 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
6420 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
6421 set_breakpoint_count (breakpoint_count
+ 1);
6422 b
->number
= breakpoint_count
;
6426 b
->cond_string
= cond_string
;
6427 b
->ignore_count
= ignore_count
;
6428 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
6429 b
->disposition
= disposition
;
6431 b
->pspace
= sals
.sals
[0].pspace
;
6433 if (enabled
&& b
->pspace
->executing_startup
6434 && (b
->type
== bp_breakpoint
6435 || b
->type
== bp_hardware_breakpoint
))
6436 b
->enable_state
= bp_startup_disabled
;
6442 loc
= add_location_to_breakpoint (b
, &sal
);
6445 if (bp_loc_is_permanent (loc
))
6446 make_breakpoint_permanent (b
);
6450 char *arg
= b
->cond_string
;
6451 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
6453 error (_("Garbage %s follows condition"), arg
);
6458 b
->addr_string
= addr_string
;
6460 /* addr_string has to be used or breakpoint_re_set will delete
6463 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
6469 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
6470 elements to fill the void space. */
6472 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
6474 int i
= index_to_remove
+1;
6475 int last_index
= sal
->nelts
-1;
6477 for (;i
<= last_index
; ++i
)
6478 sal
->sals
[i
-1] = sal
->sals
[i
];
6483 /* If appropriate, obtains all sals that correspond to the same file
6484 and line as SAL, in all program spaces. Users debugging with IDEs,
6485 will want to set a breakpoint at foo.c:line, and not really care
6486 about program spaces. This is done only if SAL does not have
6487 explicit PC and has line and file information. If we got just a
6488 single expanded sal, return the original.
6490 Otherwise, if SAL.explicit_line is not set, filter out all sals for
6491 which the name of enclosing function is different from SAL. This
6492 makes sure that if we have breakpoint originally set in template
6493 instantiation, say foo<int>(), we won't expand SAL to locations at
6494 the same line in all existing instantiations of 'foo'. */
6496 static struct symtabs_and_lines
6497 expand_line_sal_maybe (struct symtab_and_line sal
)
6499 struct symtabs_and_lines expanded
;
6500 CORE_ADDR original_pc
= sal
.pc
;
6501 char *original_function
= NULL
;
6504 struct cleanup
*old_chain
;
6506 /* If we have explicit pc, don't expand.
6507 If we have no line number, we can't expand. */
6508 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
6511 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6512 expanded
.sals
[0] = sal
;
6518 old_chain
= save_current_space_and_thread ();
6520 switch_to_program_space_and_thread (sal
.pspace
);
6522 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
6524 /* Note that expand_line_sal visits *all* program spaces. */
6525 expanded
= expand_line_sal (sal
);
6527 if (expanded
.nelts
== 1)
6529 /* We had one sal, we got one sal. Return that sal, adjusting it
6530 past the function prologue if necessary. */
6531 xfree (expanded
.sals
);
6533 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6534 sal
.pc
= original_pc
;
6535 expanded
.sals
[0] = sal
;
6536 skip_prologue_sal (&expanded
.sals
[0]);
6537 do_cleanups (old_chain
);
6541 if (!sal
.explicit_line
)
6543 CORE_ADDR func_addr
, func_end
;
6544 for (i
= 0; i
< expanded
.nelts
; ++i
)
6546 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
6547 char *this_function
;
6549 /* We need to switch threads as well since we're about to
6551 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
6553 if (find_pc_partial_function (pc
, &this_function
,
6554 &func_addr
, &func_end
))
6557 && strcmp (this_function
, original_function
) != 0)
6559 remove_sal (&expanded
, i
);
6562 else if (func_addr
== pc
)
6564 /* We're at beginning of a function, and should
6566 struct symbol
*sym
= find_pc_function (pc
);
6568 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
6571 /* Since find_pc_partial_function returned true,
6572 we should really always find the section here. */
6573 struct obj_section
*section
= find_pc_section (pc
);
6576 struct gdbarch
*gdbarch
6577 = get_objfile_arch (section
->objfile
);
6579 = gdbarch_skip_prologue (gdbarch
, pc
);
6588 for (i
= 0; i
< expanded
.nelts
; ++i
)
6590 /* If this SAL corresponds to a breakpoint inserted using a
6591 line number, then skip the function prologue if necessary. */
6592 skip_prologue_sal (&expanded
.sals
[i
]);
6596 do_cleanups (old_chain
);
6598 if (expanded
.nelts
<= 1)
6600 /* This is un ugly workaround. If we get zero
6601 expanded sals then something is really wrong.
6602 Fix that by returnign the original sal. */
6603 xfree (expanded
.sals
);
6605 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6606 sal
.pc
= original_pc
;
6607 expanded
.sals
[0] = sal
;
6614 for (i
= 0; i
< expanded
.nelts
; ++i
)
6615 if (expanded
.sals
[i
].pc
== original_pc
)
6626 /* Add SALS.nelts breakpoints to the breakpoint table. For each
6627 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
6628 value. COND_STRING, if not NULL, specified the condition to be
6629 used for all breakpoints. Essentially the only case where
6630 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
6631 function. In that case, it's still not possible to specify
6632 separate conditions for different overloaded functions, so
6633 we take just a single condition string.
6635 NOTE: If the function succeeds, the caller is expected to cleanup
6636 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
6637 array contents). If the function fails (error() is called), the
6638 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
6639 COND and SALS arrays and each of those arrays contents. */
6642 create_breakpoints (struct gdbarch
*gdbarch
,
6643 struct symtabs_and_lines sals
, char **addr_string
,
6645 enum bptype type
, enum bpdisp disposition
,
6646 int thread
, int task
, int ignore_count
,
6647 struct breakpoint_ops
*ops
, int from_tty
,
6651 for (i
= 0; i
< sals
.nelts
; ++i
)
6653 struct symtabs_and_lines expanded
=
6654 expand_line_sal_maybe (sals
.sals
[i
]);
6656 create_breakpoint (gdbarch
, expanded
, addr_string
[i
],
6657 cond_string
, type
, disposition
,
6658 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
6662 /* Parse ARG which is assumed to be a SAL specification possibly
6663 followed by conditionals. On return, SALS contains an array of SAL
6664 addresses found. ADDR_STRING contains a vector of (canonical)
6665 address strings. ARG points to the end of the SAL. */
6668 parse_breakpoint_sals (char **address
,
6669 struct symtabs_and_lines
*sals
,
6670 char ***addr_string
,
6673 char *addr_start
= *address
;
6674 *addr_string
= NULL
;
6675 /* If no arg given, or if first arg is 'if ', use the default
6677 if ((*address
) == NULL
6678 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
6680 if (default_breakpoint_valid
)
6682 struct symtab_and_line sal
;
6683 init_sal (&sal
); /* initialize to zeroes */
6684 sals
->sals
= (struct symtab_and_line
*)
6685 xmalloc (sizeof (struct symtab_and_line
));
6686 sal
.pc
= default_breakpoint_address
;
6687 sal
.line
= default_breakpoint_line
;
6688 sal
.symtab
= default_breakpoint_symtab
;
6689 sal
.pspace
= default_breakpoint_pspace
;
6690 sal
.section
= find_pc_overlay (sal
.pc
);
6692 /* "break" without arguments is equivalent to "break *PC" where PC is
6693 the default_breakpoint_address. So make sure to set
6694 sal.explicit_pc to prevent GDB from trying to expand the list of
6695 sals to include all other instances with the same symtab and line.
6697 sal
.explicit_pc
= 1;
6699 sals
->sals
[0] = sal
;
6703 error (_("No default breakpoint address now."));
6707 /* Force almost all breakpoints to be in terms of the
6708 current_source_symtab (which is decode_line_1's default). This
6709 should produce the results we want almost all of the time while
6710 leaving default_breakpoint_* alone.
6711 ObjC: However, don't match an Objective-C method name which
6712 may have a '+' or '-' succeeded by a '[' */
6714 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
6716 if (default_breakpoint_valid
6718 || ((strchr ("+-", (*address
)[0]) != NULL
)
6719 && ((*address
)[1] != '['))))
6720 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
6721 default_breakpoint_line
, addr_string
,
6724 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
6725 addr_string
, not_found_ptr
);
6727 /* For any SAL that didn't have a canonical string, fill one in. */
6728 if (sals
->nelts
> 0 && *addr_string
== NULL
)
6729 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
6730 if (addr_start
!= (*address
))
6733 for (i
= 0; i
< sals
->nelts
; i
++)
6735 /* Add the string if not present. */
6736 if ((*addr_string
)[i
] == NULL
)
6737 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
6743 /* Convert each SAL into a real PC. Verify that the PC can be
6744 inserted as a breakpoint. If it can't throw an error. */
6747 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
6751 for (i
= 0; i
< sals
->nelts
; i
++)
6752 resolve_sal_pc (&sals
->sals
[i
]);
6755 /* Fast tracepoints may have restrictions on valid locations. For
6756 instance, a fast tracepoint using a jump instead of a trap will
6757 likely have to overwrite more bytes than a trap would, and so can
6758 only be placed where the instruction is longer than the jump, or a
6759 multi-instruction sequence does not have a jump into the middle of
6763 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
6764 struct symtabs_and_lines
*sals
)
6767 struct symtab_and_line
*sal
;
6769 struct cleanup
*old_chain
;
6771 for (i
= 0; i
< sals
->nelts
; i
++)
6773 sal
= &sals
->sals
[i
];
6775 rslt
= gdbarch_fast_tracepoint_valid_at (gdbarch
, sal
->pc
,
6777 old_chain
= make_cleanup (xfree
, msg
);
6780 error (_("May not have a fast tracepoint at 0x%s%s"),
6781 paddress (gdbarch
, sal
->pc
), (msg
? msg
: ""));
6783 do_cleanups (old_chain
);
6788 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
6790 struct captured_parse_breakpoint_args
*args
= data
;
6792 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
6793 args
->not_found_ptr
);
6796 /* Given TOK, a string specification of condition and thread, as
6797 accepted by the 'break' command, extract the condition
6798 string and thread number and set *COND_STRING and *THREAD.
6799 PC identifies the context at which the condition should be parsed.
6800 If no condition is found, *COND_STRING is set to NULL.
6801 If no thread is found, *THREAD is set to -1. */
6803 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
6804 char **cond_string
, int *thread
, int *task
)
6806 *cond_string
= NULL
;
6812 char *cond_start
= NULL
;
6813 char *cond_end
= NULL
;
6814 while (*tok
== ' ' || *tok
== '\t')
6819 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
6822 toklen
= end_tok
- tok
;
6824 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
6826 struct expression
*expr
;
6828 tok
= cond_start
= end_tok
+ 1;
6829 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
6832 *cond_string
= savestring (cond_start
,
6833 cond_end
- cond_start
);
6835 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
6841 *thread
= strtol (tok
, &tok
, 0);
6843 error (_("Junk after thread keyword."));
6844 if (!valid_thread_id (*thread
))
6845 error (_("Unknown thread %d."), *thread
);
6847 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
6853 *task
= strtol (tok
, &tok
, 0);
6855 error (_("Junk after task keyword."));
6856 if (!valid_task_id (*task
))
6857 error (_("Unknown task %d."), *task
);
6860 error (_("Junk at end of arguments."));
6864 /* Set a breakpoint. This function is shared between CLI and MI
6865 functions for setting a breakpoint. This function has two major
6866 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
6867 parameter. If non-zero, the function will parse arg, extracting
6868 breakpoint location, address and thread. Otherwise, ARG is just the
6869 location of breakpoint, with condition and thread specified by the
6870 COND_STRING and THREAD parameters. Returns true if any breakpoint
6871 was created; false otherwise. */
6874 break_command_really (struct gdbarch
*gdbarch
,
6875 char *arg
, char *cond_string
, int thread
,
6876 int parse_condition_and_thread
,
6877 int tempflag
, int hardwareflag
, int traceflag
,
6879 enum auto_boolean pending_break_support
,
6880 struct breakpoint_ops
*ops
,
6884 struct gdb_exception e
;
6885 struct symtabs_and_lines sals
;
6886 struct symtab_and_line pending_sal
;
6889 char *addr_start
= arg
;
6891 struct cleanup
*old_chain
;
6892 struct cleanup
*bkpt_chain
= NULL
;
6893 struct captured_parse_breakpoint_args parse_args
;
6897 enum bptype type_wanted
;
6904 parse_args
.arg_p
= &arg
;
6905 parse_args
.sals_p
= &sals
;
6906 parse_args
.addr_string_p
= &addr_string
;
6907 parse_args
.not_found_ptr
= ¬_found
;
6909 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
6910 &parse_args
, RETURN_MASK_ALL
);
6912 /* If caller is interested in rc value from parse, set value. */
6916 throw_exception (e
);
6920 case NOT_FOUND_ERROR
:
6922 /* If pending breakpoint support is turned off, throw
6925 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
6926 throw_exception (e
);
6928 exception_print (gdb_stderr
, e
);
6930 /* If pending breakpoint support is auto query and the user
6931 selects no, then simply return the error code. */
6932 if (pending_break_support
== AUTO_BOOLEAN_AUTO
6933 && !nquery ("Make breakpoint pending on future shared library load? "))
6936 /* At this point, either the user was queried about setting
6937 a pending breakpoint and selected yes, or pending
6938 breakpoint behavior is on and thus a pending breakpoint
6939 is defaulted on behalf of the user. */
6940 copy_arg
= xstrdup (addr_start
);
6941 addr_string
= ©_arg
;
6943 sals
.sals
= &pending_sal
;
6948 throw_exception (e
);
6955 /* Create a chain of things that always need to be cleaned up. */
6956 old_chain
= make_cleanup (null_cleanup
, 0);
6960 /* Make sure that all storage allocated to SALS gets freed. */
6961 make_cleanup (xfree
, sals
.sals
);
6963 /* Cleanup the addr_string array but not its contents. */
6964 make_cleanup (xfree
, addr_string
);
6967 /* ----------------------------- SNIP -----------------------------
6968 Anything added to the cleanup chain beyond this point is assumed
6969 to be part of a breakpoint. If the breakpoint create succeeds
6970 then the memory is not reclaimed. */
6971 bkpt_chain
= make_cleanup (null_cleanup
, 0);
6973 /* Mark the contents of the addr_string for cleanup. These go on
6974 the bkpt_chain and only occur if the breakpoint create fails. */
6975 for (i
= 0; i
< sals
.nelts
; i
++)
6977 if (addr_string
[i
] != NULL
)
6978 make_cleanup (xfree
, addr_string
[i
]);
6981 /* Resolve all line numbers to PC's and verify that the addresses
6982 are ok for the target. */
6984 breakpoint_sals_to_pc (&sals
, addr_start
);
6986 type_wanted
= (traceflag
6987 ? (hardwareflag
? bp_fast_tracepoint
: bp_tracepoint
)
6988 : (hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
));
6990 /* Fast tracepoints may have additional restrictions on location. */
6991 if (type_wanted
== bp_fast_tracepoint
)
6992 check_fast_tracepoint_sals (gdbarch
, &sals
);
6994 /* Verify that condition can be parsed, before setting any
6995 breakpoints. Allocate a separate condition expression for each
6999 if (parse_condition_and_thread
)
7001 /* Here we only parse 'arg' to separate condition
7002 from thread number, so parsing in context of first
7003 sal is OK. When setting the breakpoint we'll
7004 re-parse it in context of each sal. */
7007 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
7010 make_cleanup (xfree
, cond_string
);
7014 /* Create a private copy of condition string. */
7017 cond_string
= xstrdup (cond_string
);
7018 make_cleanup (xfree
, cond_string
);
7021 create_breakpoints (gdbarch
, sals
, addr_string
, cond_string
, type_wanted
,
7022 tempflag
? disp_del
: disp_donttouch
,
7023 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
7027 struct symtab_and_line sal
= {0};
7028 struct breakpoint
*b
;
7030 make_cleanup (xfree
, copy_arg
);
7032 b
= set_raw_breakpoint_without_location (gdbarch
, type_wanted
);
7033 set_breakpoint_count (breakpoint_count
+ 1);
7034 b
->number
= breakpoint_count
;
7036 b
->addr_string
= addr_string
[0];
7037 b
->cond_string
= NULL
;
7038 b
->ignore_count
= ignore_count
;
7039 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
7040 b
->condition_not_parsed
= 1;
7042 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7043 b
->pspace
= current_program_space
;
7045 if (enabled
&& b
->pspace
->executing_startup
7046 && (b
->type
== bp_breakpoint
7047 || b
->type
== bp_hardware_breakpoint
))
7048 b
->enable_state
= bp_startup_disabled
;
7054 warning (_("Multiple breakpoints were set.\n"
7055 "Use the \"delete\" command to delete unwanted breakpoints."));
7056 /* That's it. Discard the cleanups for data inserted into the
7058 discard_cleanups (bkpt_chain
);
7059 /* But cleanup everything else. */
7060 do_cleanups (old_chain
);
7062 /* error call may happen here - have BKPT_CHAIN already discarded. */
7063 update_global_location_list (1);
7068 /* Set a breakpoint.
7069 ARG is a string describing breakpoint address,
7070 condition, and thread.
7071 FLAG specifies if a breakpoint is hardware on,
7072 and if breakpoint is temporary, using BP_HARDWARE_FLAG
7076 break_command_1 (char *arg
, int flag
, int from_tty
)
7078 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
7079 int tempflag
= flag
& BP_TEMPFLAG
;
7081 break_command_really (get_current_arch (),
7083 NULL
, 0, 1 /* parse arg */,
7084 tempflag
, hardwareflag
, 0 /* traceflag */,
7085 0 /* Ignore count */,
7086 pending_break_support
,
7087 NULL
/* breakpoint_ops */,
7094 set_breakpoint (struct gdbarch
*gdbarch
,
7095 char *address
, char *condition
,
7096 int hardwareflag
, int tempflag
,
7097 int thread
, int ignore_count
,
7098 int pending
, int enabled
)
7100 break_command_really (gdbarch
,
7101 address
, condition
, thread
,
7102 0 /* condition and thread are valid. */,
7103 tempflag
, hardwareflag
, 0 /* traceflag */,
7106 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
7110 /* Adjust SAL to the first instruction past the function prologue.
7111 The end of the prologue is determined using the line table from
7112 the debugging information. explicit_pc and explicit_line are
7115 If SAL is already past the prologue, then do nothing. */
7118 skip_prologue_sal (struct symtab_and_line
*sal
)
7121 struct symtab_and_line start_sal
;
7122 struct cleanup
*old_chain
;
7124 old_chain
= save_current_space_and_thread ();
7126 sym
= find_pc_function (sal
->pc
);
7129 start_sal
= find_function_start_sal (sym
, 1);
7130 if (sal
->pc
< start_sal
.pc
)
7132 start_sal
.explicit_line
= sal
->explicit_line
;
7133 start_sal
.explicit_pc
= sal
->explicit_pc
;
7138 do_cleanups (old_chain
);
7141 /* Helper function for break_command_1 and disassemble_command. */
7144 resolve_sal_pc (struct symtab_and_line
*sal
)
7148 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
7150 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
7151 error (_("No line %d in file \"%s\"."),
7152 sal
->line
, sal
->symtab
->filename
);
7155 /* If this SAL corresponds to a breakpoint inserted using
7156 a line number, then skip the function prologue if necessary. */
7157 if (sal
->explicit_line
)
7159 /* Preserve the original line number. */
7160 int saved_line
= sal
->line
;
7161 skip_prologue_sal (sal
);
7162 sal
->line
= saved_line
;
7166 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
7168 struct blockvector
*bv
;
7172 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
7175 sym
= block_linkage_function (b
);
7178 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
7179 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
7183 /* It really is worthwhile to have the section, so we'll just
7184 have to look harder. This case can be executed if we have
7185 line numbers but no functions (as can happen in assembly
7188 struct minimal_symbol
*msym
;
7189 struct cleanup
*old_chain
= save_current_space_and_thread ();
7191 switch_to_program_space_and_thread (sal
->pspace
);
7193 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
7195 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
7197 do_cleanups (old_chain
);
7204 break_command (char *arg
, int from_tty
)
7206 break_command_1 (arg
, 0, from_tty
);
7210 tbreak_command (char *arg
, int from_tty
)
7212 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
7216 hbreak_command (char *arg
, int from_tty
)
7218 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
7222 thbreak_command (char *arg
, int from_tty
)
7224 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
7228 stop_command (char *arg
, int from_tty
)
7230 printf_filtered (_("Specify the type of breakpoint to set.\n\
7231 Usage: stop in <function | address>\n\
7232 stop at <line>\n"));
7236 stopin_command (char *arg
, int from_tty
)
7240 if (arg
== (char *) NULL
)
7242 else if (*arg
!= '*')
7247 /* look for a ':'. If this is a line number specification, then
7248 say it is bad, otherwise, it should be an address or
7249 function/method name */
7250 while (*argptr
&& !hasColon
)
7252 hasColon
= (*argptr
== ':');
7257 badInput
= (*argptr
!= ':'); /* Not a class::method */
7259 badInput
= isdigit (*arg
); /* a simple line number */
7263 printf_filtered (_("Usage: stop in <function | address>\n"));
7265 break_command_1 (arg
, 0, from_tty
);
7269 stopat_command (char *arg
, int from_tty
)
7273 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
7280 /* look for a ':'. If there is a '::' then get out, otherwise
7281 it is probably a line number. */
7282 while (*argptr
&& !hasColon
)
7284 hasColon
= (*argptr
== ':');
7289 badInput
= (*argptr
== ':'); /* we have class::method */
7291 badInput
= !isdigit (*arg
); /* not a line number */
7295 printf_filtered (_("Usage: stop at <line>\n"));
7297 break_command_1 (arg
, 0, from_tty
);
7300 /* accessflag: hw_write: watch write,
7301 hw_read: watch read,
7302 hw_access: watch access (read or write) */
7304 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
7306 struct gdbarch
*gdbarch
= get_current_arch ();
7307 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
7308 struct expression
*exp
;
7309 struct block
*exp_valid_block
;
7310 struct value
*val
, *mark
;
7311 struct frame_info
*frame
;
7312 char *exp_start
= NULL
;
7313 char *exp_end
= NULL
;
7314 char *tok
, *id_tok_start
, *end_tok
;
7316 char *cond_start
= NULL
;
7317 char *cond_end
= NULL
;
7318 int i
, other_type_used
, target_resources_ok
= 0;
7319 enum bptype bp_type
;
7323 /* Make sure that we actually have parameters to parse. */
7324 if (arg
!= NULL
&& arg
[0] != '\0')
7326 toklen
= strlen (arg
); /* Size of argument list. */
7328 /* Points tok to the end of the argument list. */
7329 tok
= arg
+ toklen
- 1;
7331 /* Go backwards in the parameters list. Skip the last parameter.
7332 If we're expecting a 'thread <thread_num>' parameter, this should
7333 be the thread identifier. */
7334 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
7336 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
7339 /* Points end_tok to the beginning of the last token. */
7340 id_tok_start
= tok
+ 1;
7342 /* Go backwards in the parameters list. Skip one more parameter.
7343 If we're expecting a 'thread <thread_num>' parameter, we should
7344 reach a "thread" token. */
7345 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
7350 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
7353 /* Move the pointer forward to skip the whitespace and
7354 calculate the length of the token. */
7356 toklen
= end_tok
- tok
;
7358 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7360 /* At this point we've found a "thread" token, which means
7361 the user is trying to set a watchpoint that triggers
7362 only in a specific thread. */
7365 /* Extract the thread ID from the next token. */
7366 thread
= strtol (id_tok_start
, &endp
, 0);
7368 /* Check if the user provided a valid numeric value for the
7370 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
7371 error (_("Invalid thread ID specification %s."), id_tok_start
);
7373 /* Check if the thread actually exists. */
7374 if (!valid_thread_id (thread
))
7375 error (_("Unknown thread %d."), thread
);
7377 /* Truncate the string and get rid of the thread <thread_num>
7378 parameter before the parameter list is parsed by the
7379 evaluate_expression() function. */
7384 /* Parse the rest of the arguments. */
7385 innermost_block
= NULL
;
7387 exp
= parse_exp_1 (&arg
, 0, 0);
7389 /* Remove trailing whitespace from the expression before saving it.
7390 This makes the eventual display of the expression string a bit
7392 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
7395 exp_valid_block
= innermost_block
;
7396 mark
= value_mark ();
7397 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
7399 release_value (val
);
7402 while (*tok
== ' ' || *tok
== '\t')
7406 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
7409 toklen
= end_tok
- tok
;
7410 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7412 struct expression
*cond
;
7414 tok
= cond_start
= end_tok
+ 1;
7415 cond
= parse_exp_1 (&tok
, 0, 0);
7420 error (_("Junk at end of command."));
7422 if (accessflag
== hw_read
)
7423 bp_type
= bp_read_watchpoint
;
7424 else if (accessflag
== hw_access
)
7425 bp_type
= bp_access_watchpoint
;
7427 bp_type
= bp_hardware_watchpoint
;
7429 mem_cnt
= can_use_hardware_watchpoint (val
);
7430 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
7431 error (_("Expression cannot be implemented with read/access watchpoint."));
7434 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
7435 target_resources_ok
=
7436 target_can_use_hardware_watchpoint (bp_type
, i
+ mem_cnt
,
7438 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
7439 error (_("Target does not support this type of hardware watchpoint."));
7441 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
7442 error (_("Target can only support one kind of HW watchpoint at a time."));
7445 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
7446 watchpoint could not be set. */
7447 if (!mem_cnt
|| target_resources_ok
<= 0)
7448 bp_type
= bp_watchpoint
;
7450 frame
= block_innermost_frame (exp_valid_block
);
7452 /* If the expression is "local", then set up a "watchpoint scope"
7453 breakpoint at the point where we've left the scope of the watchpoint
7454 expression. Create the scope breakpoint before the watchpoint, so
7455 that we will encounter it first in bpstat_stop_status. */
7456 if (innermost_block
&& frame
)
7458 if (frame_id_p (frame_unwind_caller_id (frame
)))
7461 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
7462 frame_unwind_caller_pc (frame
),
7463 bp_watchpoint_scope
);
7465 scope_breakpoint
->enable_state
= bp_enabled
;
7467 /* Automatically delete the breakpoint when it hits. */
7468 scope_breakpoint
->disposition
= disp_del
;
7470 /* Only break in the proper frame (help with recursion). */
7471 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
7473 /* Set the address at which we will stop. */
7474 scope_breakpoint
->loc
->gdbarch
7475 = frame_unwind_caller_arch (frame
);
7476 scope_breakpoint
->loc
->requested_address
7477 = frame_unwind_caller_pc (frame
);
7478 scope_breakpoint
->loc
->address
7479 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
7480 scope_breakpoint
->loc
->requested_address
,
7481 scope_breakpoint
->type
);
7485 /* Now set up the breakpoint. */
7486 b
= set_raw_breakpoint_without_location (NULL
, bp_type
);
7487 set_breakpoint_count (breakpoint_count
+ 1);
7488 b
->number
= breakpoint_count
;
7490 b
->disposition
= disp_donttouch
;
7492 b
->exp_valid_block
= exp_valid_block
;
7493 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
7497 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
7503 b
->watchpoint_frame
= get_frame_id (frame
);
7504 b
->watchpoint_thread
= inferior_ptid
;
7508 b
->watchpoint_frame
= null_frame_id
;
7509 b
->watchpoint_thread
= null_ptid
;
7512 if (scope_breakpoint
!= NULL
)
7514 /* The scope breakpoint is related to the watchpoint. We will
7515 need to act on them together. */
7516 b
->related_breakpoint
= scope_breakpoint
;
7517 scope_breakpoint
->related_breakpoint
= b
;
7520 value_free_to_mark (mark
);
7522 /* Finally update the new watchpoint. This creates the locations
7523 that should be inserted. */
7524 update_watchpoint (b
, 1);
7527 update_global_location_list (1);
7530 /* Return count of locations need to be watched and can be handled
7531 in hardware. If the watchpoint can not be handled
7532 in hardware return zero. */
7535 can_use_hardware_watchpoint (struct value
*v
)
7537 int found_memory_cnt
= 0;
7538 struct value
*head
= v
;
7540 /* Did the user specifically forbid us to use hardware watchpoints? */
7541 if (!can_use_hw_watchpoints
)
7544 /* Make sure that the value of the expression depends only upon
7545 memory contents, and values computed from them within GDB. If we
7546 find any register references or function calls, we can't use a
7547 hardware watchpoint.
7549 The idea here is that evaluating an expression generates a series
7550 of values, one holding the value of every subexpression. (The
7551 expression a*b+c has five subexpressions: a, b, a*b, c, and
7552 a*b+c.) GDB's values hold almost enough information to establish
7553 the criteria given above --- they identify memory lvalues,
7554 register lvalues, computed values, etcetera. So we can evaluate
7555 the expression, and then scan the chain of values that leaves
7556 behind to decide whether we can detect any possible change to the
7557 expression's final value using only hardware watchpoints.
7559 However, I don't think that the values returned by inferior
7560 function calls are special in any way. So this function may not
7561 notice that an expression involving an inferior function call
7562 can't be watched with hardware watchpoints. FIXME. */
7563 for (; v
; v
= value_next (v
))
7565 if (VALUE_LVAL (v
) == lval_memory
)
7568 /* A lazy memory lvalue is one that GDB never needed to fetch;
7569 we either just used its address (e.g., `a' in `a.b') or
7570 we never needed it at all (e.g., `a' in `a,b'). */
7574 /* Ahh, memory we actually used! Check if we can cover
7575 it with hardware watchpoints. */
7576 struct type
*vtype
= check_typedef (value_type (v
));
7578 /* We only watch structs and arrays if user asked for it
7579 explicitly, never if they just happen to appear in a
7580 middle of some value chain. */
7582 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
7583 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
7585 CORE_ADDR vaddr
= value_address (v
);
7586 int len
= TYPE_LENGTH (value_type (v
));
7588 if (!target_region_ok_for_hw_watchpoint (vaddr
, len
))
7595 else if (VALUE_LVAL (v
) != not_lval
7596 && deprecated_value_modifiable (v
) == 0)
7597 return 0; /* ??? What does this represent? */
7598 else if (VALUE_LVAL (v
) == lval_register
)
7599 return 0; /* cannot watch a register with a HW watchpoint */
7602 /* The expression itself looks suitable for using a hardware
7603 watchpoint, but give the target machine a chance to reject it. */
7604 return found_memory_cnt
;
7608 watch_command_wrapper (char *arg
, int from_tty
)
7610 watch_command (arg
, from_tty
);
7614 watch_command (char *arg
, int from_tty
)
7616 watch_command_1 (arg
, hw_write
, from_tty
);
7620 rwatch_command_wrapper (char *arg
, int from_tty
)
7622 rwatch_command (arg
, from_tty
);
7626 rwatch_command (char *arg
, int from_tty
)
7628 watch_command_1 (arg
, hw_read
, from_tty
);
7632 awatch_command_wrapper (char *arg
, int from_tty
)
7634 awatch_command (arg
, from_tty
);
7638 awatch_command (char *arg
, int from_tty
)
7640 watch_command_1 (arg
, hw_access
, from_tty
);
7644 /* Helper routines for the until_command routine in infcmd.c. Here
7645 because it uses the mechanisms of breakpoints. */
7647 struct until_break_command_continuation_args
7649 struct breakpoint
*breakpoint
;
7650 struct breakpoint
*breakpoint2
;
7653 /* This function is called by fetch_inferior_event via the
7654 cmd_continuation pointer, to complete the until command. It takes
7655 care of cleaning up the temporary breakpoints set up by the until
7658 until_break_command_continuation (void *arg
)
7660 struct until_break_command_continuation_args
*a
= arg
;
7662 delete_breakpoint (a
->breakpoint
);
7664 delete_breakpoint (a
->breakpoint2
);
7668 until_break_command (char *arg
, int from_tty
, int anywhere
)
7670 struct symtabs_and_lines sals
;
7671 struct symtab_and_line sal
;
7672 struct frame_info
*frame
= get_selected_frame (NULL
);
7673 struct breakpoint
*breakpoint
;
7674 struct breakpoint
*breakpoint2
= NULL
;
7675 struct cleanup
*old_chain
;
7677 clear_proceed_status ();
7679 /* Set a breakpoint where the user wants it and at return from
7682 if (default_breakpoint_valid
)
7683 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
7684 default_breakpoint_line
, (char ***) NULL
, NULL
);
7686 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
7687 0, (char ***) NULL
, NULL
);
7689 if (sals
.nelts
!= 1)
7690 error (_("Couldn't get information on specified line."));
7693 xfree (sals
.sals
); /* malloc'd, so freed */
7696 error (_("Junk at end of arguments."));
7698 resolve_sal_pc (&sal
);
7701 /* If the user told us to continue until a specified location,
7702 we don't specify a frame at which we need to stop. */
7703 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
7704 null_frame_id
, bp_until
);
7706 /* Otherwise, specify the selected frame, because we want to stop only
7707 at the very same frame. */
7708 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
7709 get_stack_frame_id (frame
),
7712 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
7714 /* Keep within the current frame, or in frames called by the current
7717 if (frame_id_p (frame_unwind_caller_id (frame
)))
7719 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
7720 sal
.pc
= frame_unwind_caller_pc (frame
);
7721 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
7723 frame_unwind_caller_id (frame
),
7725 make_cleanup_delete_breakpoint (breakpoint2
);
7728 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
7730 /* If we are running asynchronously, and proceed call above has actually
7731 managed to start the target, arrange for breakpoints to be
7732 deleted when the target stops. Otherwise, we're already stopped and
7733 delete breakpoints via cleanup chain. */
7735 if (target_can_async_p () && is_running (inferior_ptid
))
7737 struct until_break_command_continuation_args
*args
;
7738 args
= xmalloc (sizeof (*args
));
7740 args
->breakpoint
= breakpoint
;
7741 args
->breakpoint2
= breakpoint2
;
7743 discard_cleanups (old_chain
);
7744 add_continuation (inferior_thread (),
7745 until_break_command_continuation
, args
,
7749 do_cleanups (old_chain
);
7753 ep_skip_leading_whitespace (char **s
)
7755 if ((s
== NULL
) || (*s
== NULL
))
7757 while (isspace (**s
))
7761 /* This function attempts to parse an optional "if <cond>" clause
7762 from the arg string. If one is not found, it returns NULL.
7764 Else, it returns a pointer to the condition string. (It does not
7765 attempt to evaluate the string against a particular block.) And,
7766 it updates arg to point to the first character following the parsed
7767 if clause in the arg string. */
7770 ep_parse_optional_if_clause (char **arg
)
7774 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
7777 /* Skip the "if" keyword. */
7780 /* Skip any extra leading whitespace, and record the start of the
7781 condition string. */
7782 ep_skip_leading_whitespace (arg
);
7785 /* Assume that the condition occupies the remainder of the arg string. */
7786 (*arg
) += strlen (cond_string
);
7791 /* Commands to deal with catching events, such as signals, exceptions,
7792 process start/exit, etc. */
7796 catch_fork_temporary
, catch_vfork_temporary
,
7797 catch_fork_permanent
, catch_vfork_permanent
7802 catch_fork_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7804 struct gdbarch
*gdbarch
= get_current_arch ();
7805 char *cond_string
= NULL
;
7806 catch_fork_kind fork_kind
;
7809 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
7810 tempflag
= (fork_kind
== catch_fork_temporary
7811 || fork_kind
== catch_vfork_temporary
);
7815 ep_skip_leading_whitespace (&arg
);
7817 /* The allowed syntax is:
7819 catch [v]fork if <cond>
7821 First, check if there's an if clause. */
7822 cond_string
= ep_parse_optional_if_clause (&arg
);
7824 if ((*arg
!= '\0') && !isspace (*arg
))
7825 error (_("Junk at end of arguments."));
7827 /* If this target supports it, create a fork or vfork catchpoint
7828 and enable reporting of such events. */
7831 case catch_fork_temporary
:
7832 case catch_fork_permanent
:
7833 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
7834 &catch_fork_breakpoint_ops
);
7836 case catch_vfork_temporary
:
7837 case catch_vfork_permanent
:
7838 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
7839 &catch_vfork_breakpoint_ops
);
7842 error (_("unsupported or unknown fork kind; cannot catch it"));
7848 catch_exec_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7850 struct gdbarch
*gdbarch
= get_current_arch ();
7852 char *cond_string
= NULL
;
7854 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7858 ep_skip_leading_whitespace (&arg
);
7860 /* The allowed syntax is:
7862 catch exec if <cond>
7864 First, check if there's an if clause. */
7865 cond_string
= ep_parse_optional_if_clause (&arg
);
7867 if ((*arg
!= '\0') && !isspace (*arg
))
7868 error (_("Junk at end of arguments."));
7870 /* If this target supports it, create an exec catchpoint
7871 and enable reporting of such events. */
7872 create_catchpoint (gdbarch
, tempflag
, cond_string
,
7873 &catch_exec_breakpoint_ops
);
7876 static enum print_stop_action
7877 print_exception_catchpoint (struct breakpoint
*b
)
7879 int bp_temp
, bp_throw
;
7881 annotate_catchpoint (b
->number
);
7883 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
7884 if (b
->loc
->address
!= b
->loc
->requested_address
)
7885 breakpoint_adjustment_warning (b
->loc
->requested_address
,
7888 bp_temp
= b
->disposition
== disp_del
;
7890 bp_temp
? "Temporary catchpoint "
7892 if (!ui_out_is_mi_like_p (uiout
))
7893 ui_out_field_int (uiout
, "bkptno", b
->number
);
7895 bp_throw
? " (exception thrown), "
7896 : " (exception caught), ");
7897 if (ui_out_is_mi_like_p (uiout
))
7899 ui_out_field_string (uiout
, "reason",
7900 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
7901 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
7902 ui_out_field_int (uiout
, "bkptno", b
->number
);
7904 return PRINT_SRC_AND_LOC
;
7908 print_one_exception_catchpoint (struct breakpoint
*b
, struct bp_location
**last_loc
)
7910 struct value_print_options opts
;
7911 get_user_print_options (&opts
);
7912 if (opts
.addressprint
)
7915 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
7916 ui_out_field_string (uiout
, "addr", "<PENDING>");
7918 ui_out_field_core_addr (uiout
, "addr",
7919 b
->loc
->gdbarch
, b
->loc
->address
);
7924 if (strstr (b
->addr_string
, "throw") != NULL
)
7925 ui_out_field_string (uiout
, "what", "exception throw");
7927 ui_out_field_string (uiout
, "what", "exception catch");
7931 print_mention_exception_catchpoint (struct breakpoint
*b
)
7936 bp_temp
= b
->disposition
== disp_del
;
7937 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
7938 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
7939 : _("Catchpoint "));
7940 ui_out_field_int (uiout
, "bkptno", b
->number
);
7941 ui_out_text (uiout
, bp_throw
? _(" (throw)")
7945 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
7948 NULL
, /* breakpoint_hit */
7949 print_exception_catchpoint
,
7950 print_one_exception_catchpoint
,
7951 print_mention_exception_catchpoint
7955 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
7956 enum exception_event_kind ex_event
, int from_tty
)
7958 char *trigger_func_name
;
7960 if (ex_event
== EX_EVENT_CATCH
)
7961 trigger_func_name
= "__cxa_begin_catch";
7963 trigger_func_name
= "__cxa_throw";
7965 break_command_really (get_current_arch (),
7966 trigger_func_name
, cond_string
, -1,
7967 0 /* condition and thread are valid. */,
7970 AUTO_BOOLEAN_TRUE
/* pending */,
7971 &gnu_v3_exception_catchpoint_ops
, from_tty
,
7977 /* Deal with "catch catch" and "catch throw" commands */
7980 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
7981 int tempflag
, int from_tty
)
7983 char *cond_string
= NULL
;
7984 struct symtab_and_line
*sal
= NULL
;
7988 ep_skip_leading_whitespace (&arg
);
7990 cond_string
= ep_parse_optional_if_clause (&arg
);
7992 if ((*arg
!= '\0') && !isspace (*arg
))
7993 error (_("Junk at end of arguments."));
7995 if (ex_event
!= EX_EVENT_THROW
7996 && ex_event
!= EX_EVENT_CATCH
)
7997 error (_("Unsupported or unknown exception event; cannot catch it"));
7999 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
8002 warning (_("Unsupported with this platform/compiler combination."));
8005 /* Implementation of "catch catch" command. */
8008 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
8010 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8011 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
8014 /* Implementation of "catch throw" command. */
8017 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
8019 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8020 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
8023 /* Create a breakpoint struct for Ada exception catchpoints. */
8026 create_ada_exception_breakpoint (struct gdbarch
*gdbarch
,
8027 struct symtab_and_line sal
,
8031 struct expression
*cond
,
8032 struct breakpoint_ops
*ops
,
8036 struct breakpoint
*b
;
8040 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8042 loc_gdbarch
= gdbarch
;
8044 describe_other_breakpoints (loc_gdbarch
,
8045 sal
.pspace
, sal
.pc
, sal
.section
, -1);
8046 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
8047 version for exception catchpoints, because two catchpoints
8048 used for different exception names will use the same address.
8049 In this case, a "breakpoint ... also set at..." warning is
8050 unproductive. Besides. the warning phrasing is also a bit
8051 inapropriate, we should use the word catchpoint, and tell
8052 the user what type of catchpoint it is. The above is good
8053 enough for now, though. */
8056 b
= set_raw_breakpoint (gdbarch
, sal
, bp_breakpoint
);
8057 set_breakpoint_count (breakpoint_count
+ 1);
8059 b
->enable_state
= bp_enabled
;
8060 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8061 b
->number
= breakpoint_count
;
8062 b
->ignore_count
= 0;
8063 b
->loc
->cond
= cond
;
8064 b
->addr_string
= addr_string
;
8065 b
->language
= language_ada
;
8066 b
->cond_string
= cond_string
;
8067 b
->exp_string
= exp_string
;
8072 update_global_location_list (1);
8075 /* Implement the "catch exception" command. */
8078 catch_ada_exception_command (char *arg
, int from_tty
,
8079 struct cmd_list_element
*command
)
8081 struct gdbarch
*gdbarch
= get_current_arch ();
8083 struct symtab_and_line sal
;
8085 char *addr_string
= NULL
;
8086 char *exp_string
= NULL
;
8087 char *cond_string
= NULL
;
8088 struct expression
*cond
= NULL
;
8089 struct breakpoint_ops
*ops
= NULL
;
8091 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8095 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
8096 &cond_string
, &cond
, &ops
);
8097 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, exp_string
,
8098 cond_string
, cond
, ops
, tempflag
,
8102 /* Cleanup function for a syscall filter list. */
8104 clean_up_filters (void *arg
)
8106 VEC(int) *iter
= *(VEC(int) **) arg
;
8107 VEC_free (int, iter
);
8110 /* Splits the argument using space as delimiter. Returns an xmalloc'd
8111 filter list, or NULL if no filtering is required. */
8113 catch_syscall_split_args (char *arg
)
8115 VEC(int) *result
= NULL
;
8116 struct cleanup
*cleanup
= make_cleanup (clean_up_filters
, &result
);
8118 while (*arg
!= '\0')
8120 int i
, syscall_number
;
8125 /* Skip whitespace. */
8126 while (isspace (*arg
))
8129 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
8130 cur_name
[i
] = arg
[i
];
8134 /* Check if the user provided a syscall name or a number. */
8135 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
8136 if (*endptr
== '\0')
8137 get_syscall_by_number (syscall_number
, &s
);
8140 /* We have a name. Let's check if it's valid and convert it
8142 get_syscall_by_name (cur_name
, &s
);
8144 if (s
.number
== UNKNOWN_SYSCALL
)
8145 /* Here we have to issue an error instead of a warning, because
8146 GDB cannot do anything useful if there's no syscall number to
8148 error (_("Unknown syscall name '%s'."), cur_name
);
8151 /* Ok, it's valid. */
8152 VEC_safe_push (int, result
, s
.number
);
8155 discard_cleanups (cleanup
);
8159 /* Implement the "catch syscall" command. */
8162 catch_syscall_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
8167 struct gdbarch
*gdbarch
= get_current_arch ();
8169 /* Checking if the feature if supported. */
8170 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
8171 error (_("The feature 'catch syscall' is not supported on \
8172 this architeture yet."));
8174 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8176 ep_skip_leading_whitespace (&arg
);
8178 /* We need to do this first "dummy" translation in order
8179 to get the syscall XML file loaded or, most important,
8180 to display a warning to the user if there's no XML file
8181 for his/her architecture. */
8182 get_syscall_by_number (0, &s
);
8184 /* The allowed syntax is:
8186 catch syscall <name | number> [<name | number> ... <name | number>]
8188 Let's check if there's a syscall name. */
8191 filter
= catch_syscall_split_args (arg
);
8195 create_syscall_event_catchpoint (tempflag
, filter
,
8196 &catch_syscall_breakpoint_ops
);
8199 /* Implement the "catch assert" command. */
8202 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
8204 struct gdbarch
*gdbarch
= get_current_arch ();
8206 struct symtab_and_line sal
;
8207 char *addr_string
= NULL
;
8208 struct breakpoint_ops
*ops
= NULL
;
8210 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8214 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
8215 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, NULL
, NULL
, NULL
,
8216 ops
, tempflag
, from_tty
);
8220 catch_command (char *arg
, int from_tty
)
8222 error (_("Catch requires an event name."));
8227 tcatch_command (char *arg
, int from_tty
)
8229 error (_("Catch requires an event name."));
8232 /* Delete breakpoints by address or line. */
8235 clear_command (char *arg
, int from_tty
)
8237 struct breakpoint
*b
;
8238 VEC(breakpoint_p
) *found
= 0;
8241 struct symtabs_and_lines sals
;
8242 struct symtab_and_line sal
;
8247 sals
= decode_line_spec (arg
, 1);
8252 sals
.sals
= (struct symtab_and_line
*)
8253 xmalloc (sizeof (struct symtab_and_line
));
8254 make_cleanup (xfree
, sals
.sals
);
8255 init_sal (&sal
); /* initialize to zeroes */
8256 sal
.line
= default_breakpoint_line
;
8257 sal
.symtab
= default_breakpoint_symtab
;
8258 sal
.pc
= default_breakpoint_address
;
8259 sal
.pspace
= default_breakpoint_pspace
;
8260 if (sal
.symtab
== 0)
8261 error (_("No source file specified."));
8269 /* We don't call resolve_sal_pc here. That's not
8270 as bad as it seems, because all existing breakpoints
8271 typically have both file/line and pc set. So, if
8272 clear is given file/line, we can match this to existing
8273 breakpoint without obtaining pc at all.
8275 We only support clearing given the address explicitly
8276 present in breakpoint table. Say, we've set breakpoint
8277 at file:line. There were several PC values for that file:line,
8278 due to optimization, all in one block.
8279 We've picked one PC value. If "clear" is issued with another
8280 PC corresponding to the same file:line, the breakpoint won't
8281 be cleared. We probably can still clear the breakpoint, but
8282 since the other PC value is never presented to user, user
8283 can only find it by guessing, and it does not seem important
8286 /* For each line spec given, delete bps which correspond
8287 to it. Do it in two passes, solely to preserve the current
8288 behavior that from_tty is forced true if we delete more than
8292 for (i
= 0; i
< sals
.nelts
; i
++)
8294 /* If exact pc given, clear bpts at that pc.
8295 If line given (pc == 0), clear all bpts on specified line.
8296 If defaulting, clear all bpts on default line
8299 defaulting sal.pc != 0 tests to do
8304 1 0 <can't happen> */
8308 /* Find all matching breakpoints and add them to
8313 /* Are we going to delete b? */
8314 if (b
->type
!= bp_none
8315 && b
->type
!= bp_watchpoint
8316 && b
->type
!= bp_hardware_watchpoint
8317 && b
->type
!= bp_read_watchpoint
8318 && b
->type
!= bp_access_watchpoint
)
8320 struct bp_location
*loc
= b
->loc
;
8321 for (; loc
; loc
= loc
->next
)
8323 int pc_match
= sal
.pc
8324 && (loc
->pspace
== sal
.pspace
)
8325 && (loc
->address
== sal
.pc
)
8326 && (!section_is_overlay (loc
->section
)
8327 || loc
->section
== sal
.section
);
8328 int line_match
= ((default_match
|| (0 == sal
.pc
))
8329 && b
->source_file
!= NULL
8330 && sal
.symtab
!= NULL
8331 && sal
.pspace
== loc
->pspace
8332 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
8333 && b
->line_number
== sal
.line
);
8334 if (pc_match
|| line_match
)
8343 VEC_safe_push(breakpoint_p
, found
, b
);
8346 /* Now go thru the 'found' chain and delete them. */
8347 if (VEC_empty(breakpoint_p
, found
))
8350 error (_("No breakpoint at %s."), arg
);
8352 error (_("No breakpoint at this line."));
8355 if (VEC_length(breakpoint_p
, found
) > 1)
8356 from_tty
= 1; /* Always report if deleted more than one */
8359 if (VEC_length(breakpoint_p
, found
) == 1)
8360 printf_unfiltered (_("Deleted breakpoint "));
8362 printf_unfiltered (_("Deleted breakpoints "));
8364 breakpoints_changed ();
8366 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
8369 printf_unfiltered ("%d ", b
->number
);
8370 delete_breakpoint (b
);
8373 putchar_unfiltered ('\n');
8376 /* Delete breakpoint in BS if they are `delete' breakpoints and
8377 all breakpoints that are marked for deletion, whether hit or not.
8378 This is called after any breakpoint is hit, or after errors. */
8381 breakpoint_auto_delete (bpstat bs
)
8383 struct breakpoint
*b
, *temp
;
8385 for (; bs
; bs
= bs
->next
)
8386 if (bs
->breakpoint_at
8387 && bs
->breakpoint_at
->owner
8388 && bs
->breakpoint_at
->owner
->disposition
== disp_del
8390 delete_breakpoint (bs
->breakpoint_at
->owner
);
8392 ALL_BREAKPOINTS_SAFE (b
, temp
)
8394 if (b
->disposition
== disp_del_at_next_stop
)
8395 delete_breakpoint (b
);
8399 /* A comparison function for bp_location AP and BP being interfaced to qsort.
8400 Sort elements primarily by their ADDRESS (no matter what does
8401 breakpoint_address_is_meaningful say for its OWNER), secondarily by ordering
8402 first bp_permanent OWNERed elements and terciarily just ensuring the array
8403 is sorted stable way despite qsort being an instable algorithm. */
8406 bp_location_compare (const void *ap
, const void *bp
)
8408 struct bp_location
*a
= *(void **) ap
;
8409 struct bp_location
*b
= *(void **) bp
;
8410 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
8411 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
8413 if (a
->address
!= b
->address
)
8414 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
8416 /* Sort permanent breakpoints first. */
8417 if (a_perm
!= b_perm
)
8418 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
8420 /* Make the user-visible order stable across GDB runs. Locations of the same
8421 breakpoint can be sorted in arbitrary order. */
8423 if (a
->owner
->number
!= b
->owner
->number
)
8424 return (a
->owner
->number
> b
->owner
->number
)
8425 - (a
->owner
->number
< b
->owner
->number
);
8427 return (a
> b
) - (a
< b
);
8430 /* Set bp_location_placed_address_before_address_max and
8431 bp_location_shadow_len_after_address_max according to the current content of
8432 the bp_location array. */
8435 bp_location_target_extensions_update (void)
8437 struct bp_location
*bl
, **blp_tmp
;
8439 bp_location_placed_address_before_address_max
= 0;
8440 bp_location_shadow_len_after_address_max
= 0;
8442 ALL_BP_LOCATIONS (bl
, blp_tmp
)
8444 CORE_ADDR start
, end
, addr
;
8446 if (!bp_location_has_shadow (bl
))
8449 start
= bl
->target_info
.placed_address
;
8450 end
= start
+ bl
->target_info
.shadow_len
;
8452 gdb_assert (bl
->address
>= start
);
8453 addr
= bl
->address
- start
;
8454 if (addr
> bp_location_placed_address_before_address_max
)
8455 bp_location_placed_address_before_address_max
= addr
;
8457 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
8459 gdb_assert (bl
->address
< end
);
8460 addr
= end
- bl
->address
;
8461 if (addr
> bp_location_shadow_len_after_address_max
)
8462 bp_location_shadow_len_after_address_max
= addr
;
8466 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
8467 into the inferior, only remove already-inserted locations that no
8468 longer should be inserted. Functions that delete a breakpoint or
8469 breakpoints should pass false, so that deleting a breakpoint
8470 doesn't have the side effect of inserting the locations of other
8471 breakpoints that are marked not-inserted, but should_be_inserted
8472 returns true on them.
8474 This behaviour is useful is situations close to tear-down -- e.g.,
8475 after an exec, while the target still has execution, but breakpoint
8476 shadows of the previous executable image should *NOT* be restored
8477 to the new image; or before detaching, where the target still has
8478 execution and wants to delete breakpoints from GDB's lists, and all
8479 breakpoints had already been removed from the inferior. */
8482 update_global_location_list (int should_insert
)
8484 struct breakpoint
*b
;
8485 struct bp_location
**locp
, *loc
;
8486 struct cleanup
*cleanups
;
8488 /* Used in the duplicates detection below. When iterating over all
8489 bp_locations, points to the first bp_location of a given address.
8490 Breakpoints and watchpoints of different types are never
8491 duplicates of each other. Keep one pointer for each type of
8492 breakpoint/watchpoint, so we only need to loop over all locations
8494 struct bp_location
*bp_loc_first
; /* breakpoint */
8495 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
8496 struct bp_location
*awp_loc_first
; /* access watchpoint */
8497 struct bp_location
*rwp_loc_first
; /* read watchpoint */
8499 /* Saved former bp_location array which we compare against the newly built
8500 bp_location from the current state of ALL_BREAKPOINTS. */
8501 struct bp_location
**old_location
, **old_locp
;
8502 unsigned old_location_count
;
8504 old_location
= bp_location
;
8505 old_location_count
= bp_location_count
;
8507 bp_location_count
= 0;
8508 cleanups
= make_cleanup (xfree
, old_location
);
8511 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
8512 bp_location_count
++;
8514 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
8517 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
8519 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
8520 bp_location_compare
);
8522 bp_location_target_extensions_update ();
8524 /* Identify bp_location instances that are no longer present in the new
8525 list, and therefore should be freed. Note that it's not necessary that
8526 those locations should be removed from inferior -- if there's another
8527 location at the same address (previously marked as duplicate),
8528 we don't need to remove/insert the location.
8530 LOCP is kept in sync with OLD_LOCP, each pointing to the current and
8531 former bp_location array state respectively. */
8534 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
8537 struct bp_location
*old_loc
= *old_locp
;
8538 struct bp_location
**loc2p
;
8540 /* Tells if 'old_loc' is found amoung the new locations. If not, we
8542 int found_object
= 0;
8543 /* Tells if the location should remain inserted in the target. */
8544 int keep_in_target
= 0;
8547 /* Skip LOCP entries which will definitely never be needed. Stop either
8548 at or being the one matching OLD_LOC. */
8549 while (locp
< bp_location
+ bp_location_count
8550 && (*locp
)->address
< old_loc
->address
)
8554 (loc2p
< bp_location
+ bp_location_count
8555 && (*loc2p
)->address
== old_loc
->address
);
8558 if (*loc2p
== old_loc
)
8565 /* If this location is no longer present, and inserted, look if there's
8566 maybe a new location at the same address. If so, mark that one
8567 inserted, and don't remove this one. This is needed so that we
8568 don't have a time window where a breakpoint at certain location is not
8571 if (old_loc
->inserted
)
8573 /* If the location is inserted now, we might have to remove it. */
8575 if (found_object
&& should_be_inserted (old_loc
))
8577 /* The location is still present in the location list, and still
8578 should be inserted. Don't do anything. */
8583 /* The location is either no longer present, or got disabled.
8584 See if there's another location at the same address, in which
8585 case we don't need to remove this one from the target. */
8587 if (breakpoint_address_is_meaningful (old_loc
->owner
))
8590 (loc2p
< bp_location
+ bp_location_count
8591 && (*loc2p
)->address
== old_loc
->address
);
8594 struct bp_location
*loc2
= *loc2p
;
8596 if (breakpoint_locations_match (loc2
, old_loc
))
8598 /* For the sake of should_be_inserted.
8599 Duplicates check below will fix up this later. */
8600 loc2
->duplicate
= 0;
8602 /* Read watchpoint locations are switched to
8603 access watchpoints, if the former are not
8604 supported, but the latter are. */
8605 if (is_hardware_watchpoint (old_loc
->owner
))
8607 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
8608 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
8611 if (loc2
!= old_loc
&& should_be_inserted (loc2
))
8614 loc2
->target_info
= old_loc
->target_info
;
8623 if (!keep_in_target
)
8625 if (remove_breakpoint (old_loc
, mark_uninserted
))
8627 /* This is just about all we can do. We could keep this
8628 location on the global list, and try to remove it next
8629 time, but there's no particular reason why we will
8632 Note that at this point, old_loc->owner is still valid,
8633 as delete_breakpoint frees the breakpoint only
8634 after calling us. */
8635 printf_filtered (_("warning: Error removing breakpoint %d\n"),
8636 old_loc
->owner
->number
);
8644 if (removed
&& non_stop
8645 && breakpoint_address_is_meaningful (old_loc
->owner
)
8646 && !is_hardware_watchpoint (old_loc
->owner
))
8648 /* This location was removed from the target. In
8649 non-stop mode, a race condition is possible where
8650 we've removed a breakpoint, but stop events for that
8651 breakpoint are already queued and will arrive later.
8652 We apply an heuristic to be able to distinguish such
8653 SIGTRAPs from other random SIGTRAPs: we keep this
8654 breakpoint location for a bit, and will retire it
8655 after we see some number of events. The theory here
8656 is that reporting of events should, "on the average",
8657 be fair, so after a while we'll see events from all
8658 threads that have anything of interest, and no longer
8659 need to keep this breakpoint location around. We
8660 don't hold locations forever so to reduce chances of
8661 mistaking a non-breakpoint SIGTRAP for a breakpoint
8664 The heuristic failing can be disastrous on
8665 decr_pc_after_break targets.
8667 On decr_pc_after_break targets, like e.g., x86-linux,
8668 if we fail to recognize a late breakpoint SIGTRAP,
8669 because events_till_retirement has reached 0 too
8670 soon, we'll fail to do the PC adjustment, and report
8671 a random SIGTRAP to the user. When the user resumes
8672 the inferior, it will most likely immediately crash
8673 with SIGILL/SIGBUS/SEGSEGV, or worse, get silently
8674 corrupted, because of being resumed e.g., in the
8675 middle of a multi-byte instruction, or skipped a
8676 one-byte instruction. This was actually seen happen
8677 on native x86-linux, and should be less rare on
8678 targets that do not support new thread events, like
8679 remote, due to the heuristic depending on
8682 Mistaking a random SIGTRAP for a breakpoint trap
8683 causes similar symptoms (PC adjustment applied when
8684 it shouldn't), but then again, playing with SIGTRAPs
8685 behind the debugger's back is asking for trouble.
8687 Since hardware watchpoint traps are always
8688 distinguishable from other traps, so we don't need to
8689 apply keep hardware watchpoint moribund locations
8690 around. We simply always ignore hardware watchpoint
8691 traps we can no longer explain. */
8693 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
8694 old_loc
->owner
= NULL
;
8696 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
8699 free_bp_location (old_loc
);
8703 /* Rescan breakpoints at the same address and section, marking the
8704 first one as "first" and any others as "duplicates". This is so
8705 that the bpt instruction is only inserted once. If we have a
8706 permanent breakpoint at the same place as BPT, make that one the
8707 official one, and the rest as duplicates. Permanent breakpoints
8708 are sorted first for the same address.
8710 Do the same for hardware watchpoints, but also considering the
8711 watchpoint's type (regular/access/read) and length. */
8713 bp_loc_first
= NULL
;
8714 wp_loc_first
= NULL
;
8715 awp_loc_first
= NULL
;
8716 rwp_loc_first
= NULL
;
8717 ALL_BP_LOCATIONS (loc
, locp
)
8719 struct breakpoint
*b
= loc
->owner
;
8720 struct bp_location
**loc_first_p
;
8722 if (b
->enable_state
== bp_disabled
8723 || b
->enable_state
== bp_call_disabled
8724 || b
->enable_state
== bp_startup_disabled
8726 || loc
->shlib_disabled
8727 || !breakpoint_address_is_meaningful (b
)
8728 || tracepoint_type (b
))
8731 /* Permanent breakpoint should always be inserted. */
8732 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
8733 internal_error (__FILE__
, __LINE__
,
8734 _("allegedly permanent breakpoint is not "
8735 "actually inserted"));
8737 if (b
->type
== bp_hardware_watchpoint
)
8738 loc_first_p
= &wp_loc_first
;
8739 else if (b
->type
== bp_read_watchpoint
)
8740 loc_first_p
= &rwp_loc_first
;
8741 else if (b
->type
== bp_access_watchpoint
)
8742 loc_first_p
= &awp_loc_first
;
8744 loc_first_p
= &bp_loc_first
;
8746 if (*loc_first_p
== NULL
8747 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
8748 || !breakpoint_locations_match (loc
, *loc_first_p
))
8757 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
8758 && b
->enable_state
!= bp_permanent
)
8759 internal_error (__FILE__
, __LINE__
,
8760 _("another breakpoint was inserted on top of "
8761 "a permanent breakpoint"));
8764 if (breakpoints_always_inserted_mode () && should_insert
8765 && (have_live_inferiors ()
8766 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
8767 insert_breakpoint_locations ();
8769 do_cleanups (cleanups
);
8773 breakpoint_retire_moribund (void)
8775 struct bp_location
*loc
;
8778 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
8779 if (--(loc
->events_till_retirement
) == 0)
8781 free_bp_location (loc
);
8782 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
8788 update_global_location_list_nothrow (int inserting
)
8790 struct gdb_exception e
;
8791 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8792 update_global_location_list (inserting
);
8795 /* Clear BPT from a BPS. */
8797 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
8800 for (bs
= bps
; bs
; bs
= bs
->next
)
8801 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
8803 bs
->breakpoint_at
= NULL
;
8805 /* bs->commands will be freed later. */
8809 /* Callback for iterate_over_threads. */
8811 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
8813 struct breakpoint
*bpt
= data
;
8814 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
8818 /* Delete a breakpoint and clean up all traces of it in the data
8822 delete_breakpoint (struct breakpoint
*bpt
)
8824 struct breakpoint
*b
;
8825 struct bp_location
*loc
, *next
;
8827 gdb_assert (bpt
!= NULL
);
8829 /* Has this bp already been deleted? This can happen because multiple
8830 lists can hold pointers to bp's. bpstat lists are especial culprits.
8832 One example of this happening is a watchpoint's scope bp. When the
8833 scope bp triggers, we notice that the watchpoint is out of scope, and
8834 delete it. We also delete its scope bp. But the scope bp is marked
8835 "auto-deleting", and is already on a bpstat. That bpstat is then
8836 checked for auto-deleting bp's, which are deleted.
8838 A real solution to this problem might involve reference counts in bp's,
8839 and/or giving them pointers back to their referencing bpstat's, and
8840 teaching delete_breakpoint to only free a bp's storage when no more
8841 references were extent. A cheaper bandaid was chosen. */
8842 if (bpt
->type
== bp_none
)
8845 /* At least avoid this stale reference until the reference counting of
8846 breakpoints gets resolved. */
8847 if (bpt
->related_breakpoint
!= NULL
)
8849 gdb_assert (bpt
->related_breakpoint
->related_breakpoint
== bpt
);
8850 bpt
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
8851 bpt
->related_breakpoint
->related_breakpoint
= NULL
;
8852 bpt
->related_breakpoint
= NULL
;
8855 observer_notify_breakpoint_deleted (bpt
->number
);
8857 if (breakpoint_chain
== bpt
)
8858 breakpoint_chain
= bpt
->next
;
8863 b
->next
= bpt
->next
;
8867 free_command_lines (&bpt
->commands
);
8868 if (bpt
->cond_string
!= NULL
)
8869 xfree (bpt
->cond_string
);
8870 if (bpt
->addr_string
!= NULL
)
8871 xfree (bpt
->addr_string
);
8872 if (bpt
->exp
!= NULL
)
8874 if (bpt
->exp_string
!= NULL
)
8875 xfree (bpt
->exp_string
);
8876 if (bpt
->val
!= NULL
)
8877 value_free (bpt
->val
);
8878 if (bpt
->source_file
!= NULL
)
8879 xfree (bpt
->source_file
);
8880 if (bpt
->exec_pathname
!= NULL
)
8881 xfree (bpt
->exec_pathname
);
8882 clean_up_filters (&bpt
->syscalls_to_be_caught
);
8884 /* Be sure no bpstat's are pointing at it after it's been freed. */
8885 /* FIXME, how can we find all bpstat's?
8886 We just check stop_bpstat for now. Note that we cannot just
8887 remove bpstats pointing at bpt from the stop_bpstat list
8888 entirely, as breakpoint commands are associated with the bpstat;
8889 if we remove it here, then the later call to
8890 bpstat_do_actions (&stop_bpstat);
8891 in event-top.c won't do anything, and temporary breakpoints
8892 with commands won't work. */
8894 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
8896 /* Now that breakpoint is removed from breakpoint
8897 list, update the global location list. This
8898 will remove locations that used to belong to
8899 this breakpoint. Do this before freeing
8900 the breakpoint itself, since remove_breakpoint
8901 looks at location's owner. It might be better
8902 design to have location completely self-contained,
8903 but it's not the case now. */
8904 update_global_location_list (0);
8907 /* On the chance that someone will soon try again to delete this same
8908 bp, we mark it as deleted before freeing its storage. */
8909 bpt
->type
= bp_none
;
8915 do_delete_breakpoint_cleanup (void *b
)
8917 delete_breakpoint (b
);
8921 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
8923 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
8927 delete_command (char *arg
, int from_tty
)
8929 struct breakpoint
*b
, *temp
;
8935 int breaks_to_delete
= 0;
8937 /* Delete all breakpoints if no argument.
8938 Do not delete internal or call-dummy breakpoints, these
8939 have to be deleted with an explicit breakpoint number argument. */
8942 if (b
->type
!= bp_call_dummy
8943 && b
->type
!= bp_shlib_event
8944 && b
->type
!= bp_jit_event
8945 && b
->type
!= bp_thread_event
8946 && b
->type
!= bp_overlay_event
8947 && b
->type
!= bp_longjmp_master
8950 breaks_to_delete
= 1;
8955 /* Ask user only if there are some breakpoints to delete. */
8957 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
8959 ALL_BREAKPOINTS_SAFE (b
, temp
)
8961 if (b
->type
!= bp_call_dummy
8962 && b
->type
!= bp_shlib_event
8963 && b
->type
!= bp_thread_event
8964 && b
->type
!= bp_jit_event
8965 && b
->type
!= bp_overlay_event
8966 && b
->type
!= bp_longjmp_master
8968 delete_breakpoint (b
);
8973 map_breakpoint_numbers (arg
, delete_breakpoint
);
8977 all_locations_are_pending (struct bp_location
*loc
)
8979 for (; loc
; loc
= loc
->next
)
8980 if (!loc
->shlib_disabled
)
8985 /* Subroutine of update_breakpoint_locations to simplify it.
8986 Return non-zero if multiple fns in list LOC have the same name.
8987 Null names are ignored. */
8990 ambiguous_names_p (struct bp_location
*loc
)
8992 struct bp_location
*l
;
8993 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
8994 (int (*) (const void *, const void *)) streq
,
8995 NULL
, xcalloc
, xfree
);
8997 for (l
= loc
; l
!= NULL
; l
= l
->next
)
9000 const char *name
= l
->function_name
;
9002 /* Allow for some names to be NULL, ignore them. */
9006 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
9008 /* NOTE: We can assume slot != NULL here because xcalloc never returns
9023 update_breakpoint_locations (struct breakpoint
*b
,
9024 struct symtabs_and_lines sals
)
9028 struct bp_location
*existing_locations
= b
->loc
;
9030 /* If there's no new locations, and all existing locations
9031 are pending, don't do anything. This optimizes
9032 the common case where all locations are in the same
9033 shared library, that was unloaded. We'd like to
9034 retain the location, so that when the library
9035 is loaded again, we don't loose the enabled/disabled
9036 status of the individual locations. */
9037 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
9042 for (i
= 0; i
< sals
.nelts
; ++i
)
9044 struct bp_location
*new_loc
=
9045 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
9047 /* Reparse conditions, they might contain references to the
9049 if (b
->cond_string
!= NULL
)
9051 struct gdb_exception e
;
9054 TRY_CATCH (e
, RETURN_MASK_ERROR
)
9056 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
9061 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
9062 b
->number
, e
.message
);
9063 new_loc
->enabled
= 0;
9067 if (b
->source_file
!= NULL
)
9068 xfree (b
->source_file
);
9069 if (sals
.sals
[i
].symtab
== NULL
)
9070 b
->source_file
= NULL
;
9072 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
9074 if (b
->line_number
== 0)
9075 b
->line_number
= sals
.sals
[i
].line
;
9078 /* Update locations of permanent breakpoints. */
9079 if (b
->enable_state
== bp_permanent
)
9080 make_breakpoint_permanent (b
);
9082 /* If possible, carry over 'disable' status from existing breakpoints. */
9084 struct bp_location
*e
= existing_locations
;
9085 /* If there are multiple breakpoints with the same function name,
9086 e.g. for inline functions, comparing function names won't work.
9087 Instead compare pc addresses; this is just a heuristic as things
9088 may have moved, but in practice it gives the correct answer
9089 often enough until a better solution is found. */
9090 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
9092 for (; e
; e
= e
->next
)
9094 if (!e
->enabled
&& e
->function_name
)
9096 struct bp_location
*l
= b
->loc
;
9097 if (have_ambiguous_names
)
9099 for (; l
; l
= l
->next
)
9100 if (breakpoint_address_match (e
->pspace
->aspace
, e
->address
,
9101 l
->pspace
->aspace
, l
->address
))
9109 for (; l
; l
= l
->next
)
9110 if (l
->function_name
9111 && strcmp (e
->function_name
, l
->function_name
) == 0)
9121 update_global_location_list (1);
9125 /* Reset a breakpoint given it's struct breakpoint * BINT.
9126 The value we return ends up being the return value from catch_errors.
9127 Unused in this case. */
9130 breakpoint_re_set_one (void *bint
)
9132 /* get past catch_errs */
9133 struct breakpoint
*b
= (struct breakpoint
*) bint
;
9137 int *not_found_ptr
= ¬_found
;
9138 struct symtabs_and_lines sals
= {0};
9139 struct symtabs_and_lines expanded
= {0};
9141 enum enable_state save_enable
;
9142 struct gdb_exception e
;
9143 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
9148 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
9152 case bp_hardware_breakpoint
:
9154 case bp_fast_tracepoint
:
9155 /* Do not attempt to re-set breakpoints disabled during startup. */
9156 if (b
->enable_state
== bp_startup_disabled
)
9159 if (b
->addr_string
== NULL
)
9161 /* Anything without a string can't be re-set. */
9162 delete_breakpoint (b
);
9166 set_language (b
->language
);
9167 input_radix
= b
->input_radix
;
9170 save_current_space_and_thread ();
9171 switch_to_program_space_and_thread (b
->pspace
);
9173 TRY_CATCH (e
, RETURN_MASK_ERROR
)
9175 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
9180 int not_found_and_ok
= 0;
9181 /* For pending breakpoints, it's expected that parsing
9182 will fail until the right shared library is loaded.
9183 User has already told to create pending breakpoints and
9184 don't need extra messages. If breakpoint is in bp_shlib_disabled
9185 state, then user already saw the message about that breakpoint
9186 being disabled, and don't want to see more errors. */
9188 && (b
->condition_not_parsed
9189 || (b
->loc
&& b
->loc
->shlib_disabled
)
9190 || b
->enable_state
== bp_disabled
))
9191 not_found_and_ok
= 1;
9193 if (!not_found_and_ok
)
9195 /* We surely don't want to warn about the same breakpoint
9196 10 times. One solution, implemented here, is disable
9197 the breakpoint on error. Another solution would be to
9198 have separate 'warning emitted' flag. Since this
9199 happens only when a binary has changed, I don't know
9200 which approach is better. */
9201 b
->enable_state
= bp_disabled
;
9202 throw_exception (e
);
9208 gdb_assert (sals
.nelts
== 1);
9210 resolve_sal_pc (&sals
.sals
[0]);
9211 if (b
->condition_not_parsed
&& s
&& s
[0])
9213 char *cond_string
= 0;
9217 find_condition_and_thread (s
, sals
.sals
[0].pc
,
9218 &cond_string
, &thread
, &task
);
9220 b
->cond_string
= cond_string
;
9223 b
->condition_not_parsed
= 0;
9226 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
9229 make_cleanup (xfree
, sals
.sals
);
9230 update_breakpoint_locations (b
, expanded
);
9234 case bp_hardware_watchpoint
:
9235 case bp_read_watchpoint
:
9236 case bp_access_watchpoint
:
9237 /* Watchpoint can be either on expression using entirely global variables,
9238 or it can be on local variables.
9240 Watchpoints of the first kind are never auto-deleted, and even persist
9241 across program restarts. Since they can use variables from shared
9242 libraries, we need to reparse expression as libraries are loaded
9245 Watchpoints on local variables can also change meaning as result
9246 of solib event. For example, if a watchpoint uses both a local and
9247 a global variables in expression, it's a local watchpoint, but
9248 unloading of a shared library will make the expression invalid.
9249 This is not a very common use case, but we still re-evaluate
9250 expression, to avoid surprises to the user.
9252 Note that for local watchpoints, we re-evaluate it only if
9253 watchpoints frame id is still valid. If it's not, it means
9254 the watchpoint is out of scope and will be deleted soon. In fact,
9255 I'm not sure we'll ever be called in this case.
9257 If a local watchpoint's frame id is still valid, then
9258 b->exp_valid_block is likewise valid, and we can safely use it.
9260 Don't do anything about disabled watchpoints, since they will
9261 be reevaluated again when enabled. */
9262 update_watchpoint (b
, 1 /* reparse */);
9264 /* We needn't really do anything to reset these, since the mask
9265 that requests them is unaffected by e.g., new libraries being
9271 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
9273 /* Delete overlay event and longjmp master breakpoints; they will be
9274 reset later by breakpoint_re_set. */
9275 case bp_overlay_event
:
9276 case bp_longjmp_master
:
9277 delete_breakpoint (b
);
9280 /* This breakpoint is special, it's set up when the inferior
9281 starts and we really don't want to touch it. */
9282 case bp_shlib_event
:
9284 /* Like bp_shlib_event, this breakpoint type is special.
9285 Once it is set up, we do not want to touch it. */
9286 case bp_thread_event
:
9288 /* Keep temporary breakpoints, which can be encountered when we step
9289 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
9290 Otherwise these should have been blown away via the cleanup chain
9291 or by breakpoint_init_inferior when we rerun the executable. */
9294 case bp_watchpoint_scope
:
9296 case bp_step_resume
:
9298 case bp_longjmp_resume
:
9303 do_cleanups (cleanups
);
9307 /* Re-set all breakpoints after symbols have been re-loaded. */
9309 breakpoint_re_set (void)
9311 struct breakpoint
*b
, *temp
;
9312 enum language save_language
;
9313 int save_input_radix
;
9314 struct cleanup
*old_chain
;
9316 save_language
= current_language
->la_language
;
9317 save_input_radix
= input_radix
;
9318 old_chain
= save_current_program_space ();
9320 ALL_BREAKPOINTS_SAFE (b
, temp
)
9322 /* Format possible error msg */
9323 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
9325 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
9326 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
9327 do_cleanups (cleanups
);
9329 set_language (save_language
);
9330 input_radix
= save_input_radix
;
9332 jit_breakpoint_re_set ();
9334 do_cleanups (old_chain
);
9336 create_overlay_event_breakpoint ("_ovly_debug_event");
9337 create_longjmp_master_breakpoint ("longjmp");
9338 create_longjmp_master_breakpoint ("_longjmp");
9339 create_longjmp_master_breakpoint ("siglongjmp");
9340 create_longjmp_master_breakpoint ("_siglongjmp");
9343 /* Reset the thread number of this breakpoint:
9345 - If the breakpoint is for all threads, leave it as-is.
9346 - Else, reset it to the current thread for inferior_ptid. */
9348 breakpoint_re_set_thread (struct breakpoint
*b
)
9350 if (b
->thread
!= -1)
9352 if (in_thread_list (inferior_ptid
))
9353 b
->thread
= pid_to_thread_id (inferior_ptid
);
9355 /* We're being called after following a fork. The new fork is
9356 selected as current, and unless this was a vfork will have a
9357 different program space from the original thread. Reset that
9359 b
->loc
->pspace
= current_program_space
;
9363 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
9364 If from_tty is nonzero, it prints a message to that effect,
9365 which ends with a period (no newline). */
9368 set_ignore_count (int bptnum
, int count
, int from_tty
)
9370 struct breakpoint
*b
;
9376 if (b
->number
== bptnum
)
9378 b
->ignore_count
= count
;
9382 printf_filtered (_("Will stop next time breakpoint %d is reached."),
9384 else if (count
== 1)
9385 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
9388 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
9391 breakpoints_changed ();
9392 observer_notify_breakpoint_modified (b
->number
);
9396 error (_("No breakpoint number %d."), bptnum
);
9400 make_breakpoint_silent (struct breakpoint
*b
)
9402 /* Silence the breakpoint. */
9406 /* Command to set ignore-count of breakpoint N to COUNT. */
9409 ignore_command (char *args
, int from_tty
)
9415 error_no_arg (_("a breakpoint number"));
9417 num
= get_number (&p
);
9419 error (_("bad breakpoint number: '%s'"), args
);
9421 error (_("Second argument (specified ignore-count) is missing."));
9423 set_ignore_count (num
,
9424 longest_to_int (value_as_long (parse_and_eval (p
))),
9427 printf_filtered ("\n");
9430 /* Call FUNCTION on each of the breakpoints
9431 whose numbers are given in ARGS. */
9434 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
9439 struct breakpoint
*b
, *tmp
;
9443 error_no_arg (_("one or more breakpoint numbers"));
9450 num
= get_number_or_range (&p1
);
9453 warning (_("bad breakpoint number at or near '%s'"), p
);
9457 ALL_BREAKPOINTS_SAFE (b
, tmp
)
9458 if (b
->number
== num
)
9460 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
9463 if (related_breakpoint
)
9464 function (related_breakpoint
);
9468 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
9474 static struct bp_location
*
9475 find_location_by_number (char *number
)
9477 char *dot
= strchr (number
, '.');
9481 struct breakpoint
*b
;
9482 struct bp_location
*loc
;
9487 bp_num
= get_number_or_range (&p1
);
9489 error (_("Bad breakpoint number '%s'"), number
);
9492 if (b
->number
== bp_num
)
9497 if (!b
|| b
->number
!= bp_num
)
9498 error (_("Bad breakpoint number '%s'"), number
);
9501 loc_num
= get_number_or_range (&p1
);
9503 error (_("Bad breakpoint location number '%s'"), number
);
9507 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
9510 error (_("Bad breakpoint location number '%s'"), dot
+1);
9516 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
9517 If from_tty is nonzero, it prints a message to that effect,
9518 which ends with a period (no newline). */
9521 disable_breakpoint (struct breakpoint
*bpt
)
9523 /* Never disable a watchpoint scope breakpoint; we want to
9524 hit them when we leave scope so we can delete both the
9525 watchpoint and its scope breakpoint at that time. */
9526 if (bpt
->type
== bp_watchpoint_scope
)
9529 /* You can't disable permanent breakpoints. */
9530 if (bpt
->enable_state
== bp_permanent
)
9533 bpt
->enable_state
= bp_disabled
;
9535 update_global_location_list (0);
9537 observer_notify_breakpoint_modified (bpt
->number
);
9541 disable_command (char *args
, int from_tty
)
9543 struct breakpoint
*bpt
;
9545 ALL_BREAKPOINTS (bpt
)
9549 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
9554 case bp_fast_tracepoint
:
9556 case bp_hardware_breakpoint
:
9558 case bp_hardware_watchpoint
:
9559 case bp_read_watchpoint
:
9560 case bp_access_watchpoint
:
9561 disable_breakpoint (bpt
);
9565 else if (strchr (args
, '.'))
9567 struct bp_location
*loc
= find_location_by_number (args
);
9570 update_global_location_list (0);
9573 map_breakpoint_numbers (args
, disable_breakpoint
);
9577 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
9579 int target_resources_ok
, other_type_used
;
9582 if (bpt
->type
== bp_hardware_breakpoint
)
9585 i
= hw_breakpoint_used_count ();
9586 target_resources_ok
=
9587 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9589 if (target_resources_ok
== 0)
9590 error (_("No hardware breakpoint support in the target."));
9591 else if (target_resources_ok
< 0)
9592 error (_("Hardware breakpoints used exceeds limit."));
9595 if (bpt
->type
== bp_watchpoint
9596 || bpt
->type
== bp_hardware_watchpoint
9597 || bpt
->type
== bp_read_watchpoint
9598 || bpt
->type
== bp_access_watchpoint
)
9600 struct gdb_exception e
;
9602 TRY_CATCH (e
, RETURN_MASK_ALL
)
9604 update_watchpoint (bpt
, 1 /* reparse */);
9608 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
9614 if (bpt
->enable_state
!= bp_permanent
)
9615 bpt
->enable_state
= bp_enabled
;
9616 bpt
->disposition
= disposition
;
9617 update_global_location_list (1);
9618 breakpoints_changed ();
9620 observer_notify_breakpoint_modified (bpt
->number
);
9625 enable_breakpoint (struct breakpoint
*bpt
)
9627 do_enable_breakpoint (bpt
, bpt
->disposition
);
9630 /* The enable command enables the specified breakpoints (or all defined
9631 breakpoints) so they once again become (or continue to be) effective
9632 in stopping the inferior. */
9635 enable_command (char *args
, int from_tty
)
9637 struct breakpoint
*bpt
;
9639 ALL_BREAKPOINTS (bpt
)
9643 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
9648 case bp_fast_tracepoint
:
9650 case bp_hardware_breakpoint
:
9652 case bp_hardware_watchpoint
:
9653 case bp_read_watchpoint
:
9654 case bp_access_watchpoint
:
9655 enable_breakpoint (bpt
);
9659 else if (strchr (args
, '.'))
9661 struct bp_location
*loc
= find_location_by_number (args
);
9664 update_global_location_list (1);
9667 map_breakpoint_numbers (args
, enable_breakpoint
);
9671 enable_once_breakpoint (struct breakpoint
*bpt
)
9673 do_enable_breakpoint (bpt
, disp_disable
);
9677 enable_once_command (char *args
, int from_tty
)
9679 map_breakpoint_numbers (args
, enable_once_breakpoint
);
9683 enable_delete_breakpoint (struct breakpoint
*bpt
)
9685 do_enable_breakpoint (bpt
, disp_del
);
9689 enable_delete_command (char *args
, int from_tty
)
9691 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
9695 set_breakpoint_cmd (char *args
, int from_tty
)
9700 show_breakpoint_cmd (char *args
, int from_tty
)
9704 /* Invalidate last known value of any hardware watchpoint if
9705 the memory which that value represents has been written to by
9709 invalidate_bp_value_on_memory_change (CORE_ADDR addr
, int len
,
9710 const bfd_byte
*data
)
9712 struct breakpoint
*bp
;
9714 ALL_BREAKPOINTS (bp
)
9715 if (bp
->enable_state
== bp_enabled
9716 && bp
->type
== bp_hardware_watchpoint
9717 && bp
->val_valid
&& bp
->val
)
9719 struct bp_location
*loc
;
9721 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
9722 if (loc
->loc_type
== bp_loc_hardware_watchpoint
9723 && loc
->address
+ loc
->length
> addr
9724 && addr
+ len
> loc
->address
)
9726 value_free (bp
->val
);
9733 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
9735 struct symtabs_and_lines
9736 decode_line_spec_1 (char *string
, int funfirstline
)
9738 struct symtabs_and_lines sals
;
9740 error (_("Empty line specification."));
9741 if (default_breakpoint_valid
)
9742 sals
= decode_line_1 (&string
, funfirstline
,
9743 default_breakpoint_symtab
,
9744 default_breakpoint_line
,
9745 (char ***) NULL
, NULL
);
9747 sals
= decode_line_1 (&string
, funfirstline
,
9748 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
9750 error (_("Junk at end of line specification: %s"), string
);
9754 /* Create and insert a raw software breakpoint at PC. Return an
9755 identifier, which should be used to remove the breakpoint later.
9756 In general, places which call this should be using something on the
9757 breakpoint chain instead; this function should be eliminated
9761 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
9762 struct address_space
*aspace
, CORE_ADDR pc
)
9764 struct bp_target_info
*bp_tgt
;
9766 bp_tgt
= XZALLOC (struct bp_target_info
);
9768 bp_tgt
->placed_address_space
= aspace
;
9769 bp_tgt
->placed_address
= pc
;
9771 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
9773 /* Could not insert the breakpoint. */
9781 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
9784 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
9786 struct bp_target_info
*bp_tgt
= bp
;
9789 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
9795 /* One (or perhaps two) breakpoints used for software single stepping. */
9797 static void *single_step_breakpoints
[2];
9798 static struct gdbarch
*single_step_gdbarch
[2];
9800 /* Create and insert a breakpoint for software single step. */
9803 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
9804 struct address_space
*aspace
, CORE_ADDR next_pc
)
9808 if (single_step_breakpoints
[0] == NULL
)
9810 bpt_p
= &single_step_breakpoints
[0];
9811 single_step_gdbarch
[0] = gdbarch
;
9815 gdb_assert (single_step_breakpoints
[1] == NULL
);
9816 bpt_p
= &single_step_breakpoints
[1];
9817 single_step_gdbarch
[1] = gdbarch
;
9820 /* NOTE drow/2006-04-11: A future improvement to this function would be
9821 to only create the breakpoints once, and actually put them on the
9822 breakpoint chain. That would let us use set_raw_breakpoint. We could
9823 adjust the addresses each time they were needed. Doing this requires
9824 corresponding changes elsewhere where single step breakpoints are
9825 handled, however. So, for now, we use this. */
9827 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
9829 error (_("Could not insert single-step breakpoint at %s"),
9830 paddress (gdbarch
, next_pc
));
9833 /* Remove and delete any breakpoints used for software single step. */
9836 remove_single_step_breakpoints (void)
9838 gdb_assert (single_step_breakpoints
[0] != NULL
);
9840 /* See insert_single_step_breakpoint for more about this deprecated
9842 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
9843 single_step_breakpoints
[0]);
9844 single_step_gdbarch
[0] = NULL
;
9845 single_step_breakpoints
[0] = NULL
;
9847 if (single_step_breakpoints
[1] != NULL
)
9849 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
9850 single_step_breakpoints
[1]);
9851 single_step_gdbarch
[1] = NULL
;
9852 single_step_breakpoints
[1] = NULL
;
9856 /* Check whether a software single-step breakpoint is inserted at PC. */
9859 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
9863 for (i
= 0; i
< 2; i
++)
9865 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
9867 && breakpoint_address_match (bp_tgt
->placed_address_space
,
9868 bp_tgt
->placed_address
,
9876 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
9877 non-zero otherwise. */
9879 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
9881 if (syscall_catchpoint_p (bp
)
9882 && bp
->enable_state
!= bp_disabled
9883 && bp
->enable_state
!= bp_call_disabled
)
9890 catch_syscall_enabled (void)
9892 struct inferior
*inf
= current_inferior ();
9894 return inf
->total_syscalls_count
!= 0;
9898 catching_syscall_number (int syscall_number
)
9900 struct breakpoint
*bp
;
9902 ALL_BREAKPOINTS (bp
)
9903 if (is_syscall_catchpoint_enabled (bp
))
9905 if (bp
->syscalls_to_be_caught
)
9909 VEC_iterate (int, bp
->syscalls_to_be_caught
, i
, iter
);
9911 if (syscall_number
== iter
)
9921 /* Complete syscall names. Used by "catch syscall". */
9923 catch_syscall_completer (struct cmd_list_element
*cmd
,
9924 char *text
, char *word
)
9926 const char **list
= get_syscall_names ();
9927 return (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
9930 /* Tracepoint-specific operations. */
9932 /* Set tracepoint count to NUM. */
9934 set_tracepoint_count (int num
)
9936 tracepoint_count
= num
;
9937 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
9941 trace_command (char *arg
, int from_tty
)
9943 if (break_command_really (get_current_arch (),
9945 NULL
, 0, 1 /* parse arg */,
9946 0 /* tempflag */, 0 /* hardwareflag */,
9948 0 /* Ignore count */,
9949 pending_break_support
,
9953 set_tracepoint_count (breakpoint_count
);
9957 ftrace_command (char *arg
, int from_tty
)
9959 if (break_command_really (get_current_arch (),
9961 NULL
, 0, 1 /* parse arg */,
9962 0 /* tempflag */, 1 /* hardwareflag */,
9964 0 /* Ignore count */,
9965 pending_break_support
,
9969 set_tracepoint_count (breakpoint_count
);
9972 /* Given information about a tracepoint as recorded on a target (which
9973 can be either a live system or a trace file), attempt to create an
9974 equivalent GDB tracepoint. This is not a reliable process, since
9975 the target does not necessarily have all the information used when
9976 the tracepoint was originally defined. */
9979 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
9982 struct breakpoint
*tp
;
9984 /* In the absence of a source location, fall back to raw address. */
9985 sprintf (buf
, "*%s", paddress (get_current_arch(), utp
->addr
));
9987 if (!break_command_really (get_current_arch (),
9989 NULL
, 0, 1 /* parse arg */,
9991 (utp
->type
== bp_fast_tracepoint
) /* hardwareflag */,
9993 0 /* Ignore count */,
9994 pending_break_support
,
9997 utp
->enabled
/* enabled */))
10000 set_tracepoint_count (breakpoint_count
);
10002 tp
= get_tracepoint (tracepoint_count
);
10003 gdb_assert (tp
!= NULL
);
10007 sprintf (buf
, "%d %d", utp
->pass
, tp
->number
);
10009 trace_pass_command (buf
, 0);
10014 printf_filtered ("Want to restore a condition\n");
10017 if (utp
->numactions
> 0)
10019 printf_filtered ("Want to restore action list\n");
10022 if (utp
->num_step_actions
> 0)
10024 printf_filtered ("Want to restore action list\n");
10030 /* Print information on tracepoint number TPNUM_EXP, or all if
10034 tracepoints_info (char *tpnum_exp
, int from_tty
)
10036 struct breakpoint
*b
;
10037 int tps_to_list
= 0;
10039 /* In the no-arguments case, say "No tracepoints" if none found. */
10040 if (tpnum_exp
== 0)
10042 ALL_TRACEPOINTS (b
)
10044 if (b
->number
>= 0)
10052 ui_out_message (uiout
, 0, "No tracepoints.\n");
10057 /* Otherwise be the same as "info break". */
10058 breakpoints_info (tpnum_exp
, from_tty
);
10061 /* The 'enable trace' command enables tracepoints.
10062 Not supported by all targets. */
10064 enable_trace_command (char *args
, int from_tty
)
10066 enable_command (args
, from_tty
);
10069 /* The 'disable trace' command disables tracepoints.
10070 Not supported by all targets. */
10072 disable_trace_command (char *args
, int from_tty
)
10074 disable_command (args
, from_tty
);
10077 /* Remove a tracepoint (or all if no argument) */
10079 delete_trace_command (char *arg
, int from_tty
)
10081 struct breakpoint
*b
, *temp
;
10087 int breaks_to_delete
= 0;
10089 /* Delete all breakpoints if no argument.
10090 Do not delete internal or call-dummy breakpoints, these
10091 have to be deleted with an explicit breakpoint number argument. */
10092 ALL_TRACEPOINTS (b
)
10094 if (b
->number
>= 0)
10096 breaks_to_delete
= 1;
10101 /* Ask user only if there are some breakpoints to delete. */
10103 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
10105 ALL_BREAKPOINTS_SAFE (b
, temp
)
10107 if (tracepoint_type (b
)
10109 delete_breakpoint (b
);
10114 map_breakpoint_numbers (arg
, delete_breakpoint
);
10117 /* Set passcount for tracepoint.
10119 First command argument is passcount, second is tracepoint number.
10120 If tracepoint number omitted, apply to most recently defined.
10121 Also accepts special argument "all". */
10124 trace_pass_command (char *args
, int from_tty
)
10126 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
10127 unsigned int count
;
10130 if (args
== 0 || *args
== 0)
10131 error (_("passcount command requires an argument (count + optional TP num)"));
10133 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
10135 while (*args
&& isspace ((int) *args
))
10138 if (*args
&& strncasecmp (args
, "all", 3) == 0)
10140 args
+= 3; /* Skip special argument "all". */
10143 error (_("Junk at end of arguments."));
10146 t1
= get_tracepoint_by_number (&args
, 1, 1);
10152 ALL_TRACEPOINTS (t2
)
10153 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
10155 t2
->pass_count
= count
;
10156 observer_notify_tracepoint_modified (t2
->number
);
10158 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
10159 t2
->number
, count
);
10161 if (! all
&& *args
)
10162 t1
= get_tracepoint_by_number (&args
, 1, 0);
10168 struct breakpoint
*
10169 get_tracepoint (int num
)
10171 struct breakpoint
*t
;
10173 ALL_TRACEPOINTS (t
)
10174 if (t
->number
== num
)
10180 /* Find the tracepoint with the given target-side number (which may be
10181 different from the tracepoint number after disconnecting and
10184 struct breakpoint
*
10185 get_tracepoint_by_number_on_target (int num
)
10187 struct breakpoint
*t
;
10189 ALL_TRACEPOINTS (t
)
10190 if (t
->number_on_target
== num
)
10196 /* Utility: parse a tracepoint number and look it up in the list.
10197 If MULTI_P is true, there might be a range of tracepoints in ARG.
10198 if OPTIONAL_P is true, then if the argument is missing, the most
10199 recent tracepoint (tracepoint_count) is returned. */
10200 struct breakpoint
*
10201 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
10203 extern int tracepoint_count
;
10204 struct breakpoint
*t
;
10206 char *instring
= arg
== NULL
? NULL
: *arg
;
10208 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
10211 tpnum
= tracepoint_count
;
10213 error_no_arg (_("tracepoint number"));
10216 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
10220 if (instring
&& *instring
)
10221 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
10224 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
10228 ALL_TRACEPOINTS (t
)
10229 if (t
->number
== tpnum
)
10234 /* FIXME: if we are in the middle of a range we don't want to give
10235 a message. The current interface to get_number_or_range doesn't
10236 allow us to discover this. */
10237 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
10241 /* save-tracepoints command */
10243 tracepoint_save_command (char *args
, int from_tty
)
10245 struct breakpoint
*tp
;
10247 struct action_line
*line
;
10249 char *i1
= " ", *i2
= " ";
10250 char *indent
, *actionline
, *pathname
;
10252 struct cleanup
*cleanup
;
10254 if (args
== 0 || *args
== 0)
10255 error (_("Argument required (file name in which to save tracepoints)"));
10257 /* See if we have anything to save. */
10258 ALL_TRACEPOINTS (tp
)
10265 warning (_("save-tracepoints: no tracepoints to save."));
10269 pathname
= tilde_expand (args
);
10270 cleanup
= make_cleanup (xfree
, pathname
);
10271 fp
= fopen (pathname
, "w");
10273 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
10274 args
, safe_strerror (errno
));
10275 make_cleanup_fclose (fp
);
10277 ALL_TRACEPOINTS (tp
)
10279 if (tp
->addr_string
)
10280 fprintf (fp
, "trace %s\n", tp
->addr_string
);
10283 sprintf_vma (tmp
, tp
->loc
->address
);
10284 fprintf (fp
, "trace *0x%s\n", tmp
);
10287 if (tp
->pass_count
)
10288 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
10292 fprintf (fp
, " actions\n");
10294 for (line
= tp
->actions
; line
; line
= line
->next
)
10296 struct cmd_list_element
*cmd
;
10298 QUIT
; /* allow user to bail out with ^C */
10299 actionline
= line
->action
;
10300 while (isspace ((int) *actionline
))
10303 fprintf (fp
, "%s%s\n", indent
, actionline
);
10304 if (*actionline
!= '#') /* skip for comment lines */
10306 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
10308 error (_("Bad action list item: %s"), actionline
);
10309 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
10311 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
10317 do_cleanups (cleanup
);
10319 printf_filtered (_("Tracepoints saved to file '%s'.\n"), args
);
10323 /* Create a vector of all tracepoints. */
10325 VEC(breakpoint_p
) *
10328 VEC(breakpoint_p
) *tp_vec
= 0;
10329 struct breakpoint
*tp
;
10331 ALL_TRACEPOINTS (tp
)
10333 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
10340 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
10341 It is defined as a macro to prevent duplication.
10342 COMMAND should be a string constant containing the name of the command. */
10343 #define BREAK_ARGS_HELP(command) \
10344 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
10345 LOCATION may be a line number, function name, or \"*\" and an address.\n\
10346 If a line number is specified, break at start of code for that line.\n\
10347 If a function is specified, break at start of code for that function.\n\
10348 If an address is specified, break at that exact address.\n\
10349 With no LOCATION, uses current execution address of selected stack frame.\n\
10350 This is useful for breaking on return to a stack frame.\n\
10352 THREADNUM is the number from \"info threads\".\n\
10353 CONDITION is a boolean expression.\n\
10355 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
10357 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
10359 /* List of subcommands for "catch". */
10360 static struct cmd_list_element
*catch_cmdlist
;
10362 /* List of subcommands for "tcatch". */
10363 static struct cmd_list_element
*tcatch_cmdlist
;
10365 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
10366 lists, and pass some additional user data to the command function. */
10368 add_catch_command (char *name
, char *docstring
,
10369 void (*sfunc
) (char *args
, int from_tty
,
10370 struct cmd_list_element
*command
),
10371 char **(*completer
) (struct cmd_list_element
*cmd
,
10372 char *text
, char *word
),
10373 void *user_data_catch
,
10374 void *user_data_tcatch
)
10376 struct cmd_list_element
*command
;
10378 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
10380 set_cmd_sfunc (command
, sfunc
);
10381 set_cmd_context (command
, user_data_catch
);
10382 set_cmd_completer (command
, completer
);
10384 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
10386 set_cmd_sfunc (command
, sfunc
);
10387 set_cmd_context (command
, user_data_tcatch
);
10388 set_cmd_completer (command
, completer
);
10392 clear_syscall_counts (struct inferior
*inf
)
10394 inf
->total_syscalls_count
= 0;
10395 inf
->any_syscall_count
= 0;
10396 VEC_free (int, inf
->syscalls_counts
);
10400 _initialize_breakpoint (void)
10402 static struct cmd_list_element
*breakpoint_set_cmdlist
;
10403 static struct cmd_list_element
*breakpoint_show_cmdlist
;
10404 struct cmd_list_element
*c
;
10406 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
10407 observer_attach_inferior_exit (clear_syscall_counts
);
10408 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
10410 breakpoint_chain
= 0;
10411 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
10412 before a breakpoint is set. */
10413 breakpoint_count
= 0;
10415 tracepoint_count
= 0;
10417 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
10418 Set ignore-count of breakpoint number N to COUNT.\n\
10419 Usage is `ignore N COUNT'."));
10421 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
10423 add_com ("commands", class_breakpoint
, commands_command
, _("\
10424 Set commands to be executed when a breakpoint is hit.\n\
10425 Give breakpoint number as argument after \"commands\".\n\
10426 With no argument, the targeted breakpoint is the last one set.\n\
10427 The commands themselves follow starting on the next line.\n\
10428 Type a line containing \"end\" to indicate the end of them.\n\
10429 Give \"silent\" as the first line to make the breakpoint silent;\n\
10430 then no output is printed when it is hit, except what the commands print."));
10432 add_com ("condition", class_breakpoint
, condition_command
, _("\
10433 Specify breakpoint number N to break only if COND is true.\n\
10434 Usage is `condition N COND', where N is an integer and COND is an\n\
10435 expression to be evaluated whenever breakpoint N is reached."));
10437 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
10438 Set a temporary breakpoint.\n\
10439 Like \"break\" except the breakpoint is only temporary,\n\
10440 so it will be deleted when hit. Equivalent to \"break\" followed\n\
10441 by using \"enable delete\" on the breakpoint number.\n\
10443 BREAK_ARGS_HELP ("tbreak")));
10444 set_cmd_completer (c
, location_completer
);
10446 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
10447 Set a hardware assisted breakpoint.\n\
10448 Like \"break\" except the breakpoint requires hardware support,\n\
10449 some target hardware may not have this support.\n\
10451 BREAK_ARGS_HELP ("hbreak")));
10452 set_cmd_completer (c
, location_completer
);
10454 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
10455 Set a temporary hardware assisted breakpoint.\n\
10456 Like \"hbreak\" except the breakpoint is only temporary,\n\
10457 so it will be deleted when hit.\n\
10459 BREAK_ARGS_HELP ("thbreak")));
10460 set_cmd_completer (c
, location_completer
);
10462 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
10463 Enable some breakpoints.\n\
10464 Give breakpoint numbers (separated by spaces) as arguments.\n\
10465 With no subcommand, breakpoints are enabled until you command otherwise.\n\
10466 This is used to cancel the effect of the \"disable\" command.\n\
10467 With a subcommand you can enable temporarily."),
10468 &enablelist
, "enable ", 1, &cmdlist
);
10470 add_com ("ab", class_breakpoint
, enable_command
, _("\
10471 Enable some breakpoints.\n\
10472 Give breakpoint numbers (separated by spaces) as arguments.\n\
10473 With no subcommand, breakpoints are enabled until you command otherwise.\n\
10474 This is used to cancel the effect of the \"disable\" command.\n\
10475 With a subcommand you can enable temporarily."));
10477 add_com_alias ("en", "enable", class_breakpoint
, 1);
10479 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
10480 Enable some breakpoints.\n\
10481 Give breakpoint numbers (separated by spaces) as arguments.\n\
10482 This is used to cancel the effect of the \"disable\" command.\n\
10483 May be abbreviated to simply \"enable\".\n"),
10484 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
10486 add_cmd ("once", no_class
, enable_once_command
, _("\
10487 Enable breakpoints for one hit. Give breakpoint numbers.\n\
10488 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
10491 add_cmd ("delete", no_class
, enable_delete_command
, _("\
10492 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
10493 If a breakpoint is hit while enabled in this fashion, it is deleted."),
10496 add_cmd ("delete", no_class
, enable_delete_command
, _("\
10497 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
10498 If a breakpoint is hit while enabled in this fashion, it is deleted."),
10501 add_cmd ("once", no_class
, enable_once_command
, _("\
10502 Enable breakpoints for one hit. Give breakpoint numbers.\n\
10503 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
10506 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
10507 Disable some breakpoints.\n\
10508 Arguments are breakpoint numbers with spaces in between.\n\
10509 To disable all breakpoints, give no argument.\n\
10510 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
10511 &disablelist
, "disable ", 1, &cmdlist
);
10512 add_com_alias ("dis", "disable", class_breakpoint
, 1);
10513 add_com_alias ("disa", "disable", class_breakpoint
, 1);
10515 add_com ("sb", class_breakpoint
, disable_command
, _("\
10516 Disable some breakpoints.\n\
10517 Arguments are breakpoint numbers with spaces in between.\n\
10518 To disable all breakpoints, give no argument.\n\
10519 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
10521 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
10522 Disable some breakpoints.\n\
10523 Arguments are breakpoint numbers with spaces in between.\n\
10524 To disable all breakpoints, give no argument.\n\
10525 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
10526 This command may be abbreviated \"disable\"."),
10529 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
10530 Delete some breakpoints or auto-display expressions.\n\
10531 Arguments are breakpoint numbers with spaces in between.\n\
10532 To delete all breakpoints, give no argument.\n\
10534 Also a prefix command for deletion of other GDB objects.\n\
10535 The \"unset\" command is also an alias for \"delete\"."),
10536 &deletelist
, "delete ", 1, &cmdlist
);
10537 add_com_alias ("d", "delete", class_breakpoint
, 1);
10538 add_com_alias ("del", "delete", class_breakpoint
, 1);
10540 add_com ("db", class_breakpoint
, delete_command
, _("\
10541 Delete some breakpoints.\n\
10542 Arguments are breakpoint numbers with spaces in between.\n\
10543 To delete all breakpoints, give no argument.\n"));
10545 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
10546 Delete some breakpoints or auto-display expressions.\n\
10547 Arguments are breakpoint numbers with spaces in between.\n\
10548 To delete all breakpoints, give no argument.\n\
10549 This command may be abbreviated \"delete\"."),
10552 add_com ("clear", class_breakpoint
, clear_command
, _("\
10553 Clear breakpoint at specified line or function.\n\
10554 Argument may be line number, function name, or \"*\" and an address.\n\
10555 If line number is specified, all breakpoints in that line are cleared.\n\
10556 If function is specified, breakpoints at beginning of function are cleared.\n\
10557 If an address is specified, breakpoints at that address are cleared.\n\
10559 With no argument, clears all breakpoints in the line that the selected frame\n\
10560 is executing in.\n\
10562 See also the \"delete\" command which clears breakpoints by number."));
10564 c
= add_com ("break", class_breakpoint
, break_command
, _("\
10565 Set breakpoint at specified line or function.\n"
10566 BREAK_ARGS_HELP ("break")));
10567 set_cmd_completer (c
, location_completer
);
10569 add_com_alias ("b", "break", class_run
, 1);
10570 add_com_alias ("br", "break", class_run
, 1);
10571 add_com_alias ("bre", "break", class_run
, 1);
10572 add_com_alias ("brea", "break", class_run
, 1);
10575 add_com_alias ("ba", "break", class_breakpoint
, 1);
10579 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
10580 Break in function/address or break at a line in the current file."),
10581 &stoplist
, "stop ", 1, &cmdlist
);
10582 add_cmd ("in", class_breakpoint
, stopin_command
,
10583 _("Break in function or address."), &stoplist
);
10584 add_cmd ("at", class_breakpoint
, stopat_command
,
10585 _("Break at a line in the current file."), &stoplist
);
10586 add_com ("status", class_info
, breakpoints_info
, _("\
10587 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10588 The \"Type\" column indicates one of:\n\
10589 \tbreakpoint - normal breakpoint\n\
10590 \twatchpoint - watchpoint\n\
10591 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10592 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10593 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10594 address and file/line number respectively.\n\
10596 Convenience variable \"$_\" and default examine address for \"x\"\n\
10597 are set to the address of the last breakpoint listed unless the command\n\
10598 is prefixed with \"server \".\n\n\
10599 Convenience variable \"$bpnum\" contains the number of the last\n\
10600 breakpoint set."));
10603 add_info ("breakpoints", breakpoints_info
, _("\
10604 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10605 The \"Type\" column indicates one of:\n\
10606 \tbreakpoint - normal breakpoint\n\
10607 \twatchpoint - watchpoint\n\
10608 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10609 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10610 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10611 address and file/line number respectively.\n\
10613 Convenience variable \"$_\" and default examine address for \"x\"\n\
10614 are set to the address of the last breakpoint listed unless the command\n\
10615 is prefixed with \"server \".\n\n\
10616 Convenience variable \"$bpnum\" contains the number of the last\n\
10617 breakpoint set."));
10619 add_info_alias ("b", "breakpoints", 1);
10622 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
10623 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10624 The \"Type\" column indicates one of:\n\
10625 \tbreakpoint - normal breakpoint\n\
10626 \twatchpoint - watchpoint\n\
10627 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10628 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10629 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10630 address and file/line number respectively.\n\
10632 Convenience variable \"$_\" and default examine address for \"x\"\n\
10633 are set to the address of the last breakpoint listed unless the command\n\
10634 is prefixed with \"server \".\n\n\
10635 Convenience variable \"$bpnum\" contains the number of the last\n\
10636 breakpoint set."));
10638 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
10639 Status of all breakpoints, or breakpoint number NUMBER.\n\
10640 The \"Type\" column indicates one of:\n\
10641 \tbreakpoint - normal breakpoint\n\
10642 \twatchpoint - watchpoint\n\
10643 \tlongjmp - internal breakpoint used to step through longjmp()\n\
10644 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
10645 \tuntil - internal breakpoint used by the \"until\" command\n\
10646 \tfinish - internal breakpoint used by the \"finish\" command\n\
10647 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10648 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10649 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10650 address and file/line number respectively.\n\
10652 Convenience variable \"$_\" and default examine address for \"x\"\n\
10653 are set to the address of the last breakpoint listed unless the command\n\
10654 is prefixed with \"server \".\n\n\
10655 Convenience variable \"$bpnum\" contains the number of the last\n\
10657 &maintenanceinfolist
);
10659 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
10660 Set catchpoints to catch events."),
10661 &catch_cmdlist
, "catch ",
10662 0/*allow-unknown*/, &cmdlist
);
10664 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
10665 Set temporary catchpoints to catch events."),
10666 &tcatch_cmdlist
, "tcatch ",
10667 0/*allow-unknown*/, &cmdlist
);
10669 /* Add catch and tcatch sub-commands. */
10670 add_catch_command ("catch", _("\
10671 Catch an exception, when caught.\n\
10672 With an argument, catch only exceptions with the given name."),
10673 catch_catch_command
,
10677 add_catch_command ("throw", _("\
10678 Catch an exception, when thrown.\n\
10679 With an argument, catch only exceptions with the given name."),
10680 catch_throw_command
,
10684 add_catch_command ("fork", _("Catch calls to fork."),
10685 catch_fork_command_1
,
10687 (void *) (uintptr_t) catch_fork_permanent
,
10688 (void *) (uintptr_t) catch_fork_temporary
);
10689 add_catch_command ("vfork", _("Catch calls to vfork."),
10690 catch_fork_command_1
,
10692 (void *) (uintptr_t) catch_vfork_permanent
,
10693 (void *) (uintptr_t) catch_vfork_temporary
);
10694 add_catch_command ("exec", _("Catch calls to exec."),
10695 catch_exec_command_1
,
10699 add_catch_command ("syscall", _("\
10700 Catch system calls by their names and/or numbers.\n\
10701 Arguments say which system calls to catch. If no arguments\n\
10702 are given, every system call will be caught.\n\
10703 Arguments, if given, should be one or more system call names\n\
10704 (if your system supports that), or system call numbers."),
10705 catch_syscall_command_1
,
10706 catch_syscall_completer
,
10709 add_catch_command ("exception", _("\
10710 Catch Ada exceptions, when raised.\n\
10711 With an argument, catch only exceptions with the given name."),
10712 catch_ada_exception_command
,
10716 add_catch_command ("assert", _("\
10717 Catch failed Ada assertions, when raised.\n\
10718 With an argument, catch only exceptions with the given name."),
10719 catch_assert_command
,
10724 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
10725 Set a watchpoint for an expression.\n\
10726 A watchpoint stops execution of your program whenever the value of\n\
10727 an expression changes."));
10728 set_cmd_completer (c
, expression_completer
);
10730 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
10731 Set a read watchpoint for an expression.\n\
10732 A watchpoint stops execution of your program whenever the value of\n\
10733 an expression is read."));
10734 set_cmd_completer (c
, expression_completer
);
10736 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
10737 Set a watchpoint for an expression.\n\
10738 A watchpoint stops execution of your program whenever the value of\n\
10739 an expression is either read or written."));
10740 set_cmd_completer (c
, expression_completer
);
10742 add_info ("watchpoints", breakpoints_info
,
10743 _("Synonym for ``info breakpoints''."));
10746 /* XXX: cagney/2005-02-23: This should be a boolean, and should
10747 respond to changes - contrary to the description. */
10748 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
10749 &can_use_hw_watchpoints
, _("\
10750 Set debugger's willingness to use watchpoint hardware."), _("\
10751 Show debugger's willingness to use watchpoint hardware."), _("\
10752 If zero, gdb will not use hardware for new watchpoints, even if\n\
10753 such is available. (However, any hardware watchpoints that were\n\
10754 created before setting this to nonzero, will continue to use watchpoint\n\
10757 show_can_use_hw_watchpoints
,
10758 &setlist
, &showlist
);
10760 can_use_hw_watchpoints
= 1;
10762 /* Tracepoint manipulation commands. */
10764 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
10765 Set a tracepoint at specified line or function.\n\
10767 BREAK_ARGS_HELP ("trace") "\n\
10768 Do \"help tracepoints\" for info on other tracepoint commands."));
10769 set_cmd_completer (c
, location_completer
);
10771 add_com_alias ("tp", "trace", class_alias
, 0);
10772 add_com_alias ("tr", "trace", class_alias
, 1);
10773 add_com_alias ("tra", "trace", class_alias
, 1);
10774 add_com_alias ("trac", "trace", class_alias
, 1);
10776 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
10777 Set a fast tracepoint at specified line or function.\n\
10779 BREAK_ARGS_HELP ("ftrace") "\n\
10780 Do \"help tracepoints\" for info on other tracepoint commands."));
10781 set_cmd_completer (c
, location_completer
);
10783 add_info ("tracepoints", tracepoints_info
, _("\
10784 Status of tracepoints, or tracepoint number NUMBER.\n\
10785 Convenience variable \"$tpnum\" contains the number of the\n\
10786 last tracepoint set."));
10788 add_info_alias ("tp", "tracepoints", 1);
10790 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
10791 Delete specified tracepoints.\n\
10792 Arguments are tracepoint numbers, separated by spaces.\n\
10793 No argument means delete all tracepoints."),
10796 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
10797 Disable specified tracepoints.\n\
10798 Arguments are tracepoint numbers, separated by spaces.\n\
10799 No argument means disable all tracepoints."),
10801 deprecate_cmd (c
, "disable");
10803 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
10804 Enable specified tracepoints.\n\
10805 Arguments are tracepoint numbers, separated by spaces.\n\
10806 No argument means enable all tracepoints."),
10808 deprecate_cmd (c
, "enable");
10810 add_com ("passcount", class_trace
, trace_pass_command
, _("\
10811 Set the passcount for a tracepoint.\n\
10812 The trace will end when the tracepoint has been passed 'count' times.\n\
10813 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
10814 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
10816 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
10817 Save current tracepoint definitions as a script.\n\
10818 Use the 'source' command in another debug session to restore them."));
10819 set_cmd_completer (c
, filename_completer
);
10821 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
10822 Breakpoint specific settings\n\
10823 Configure various breakpoint-specific variables such as\n\
10824 pending breakpoint behavior"),
10825 &breakpoint_set_cmdlist
, "set breakpoint ",
10826 0/*allow-unknown*/, &setlist
);
10827 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
10828 Breakpoint specific settings\n\
10829 Configure various breakpoint-specific variables such as\n\
10830 pending breakpoint behavior"),
10831 &breakpoint_show_cmdlist
, "show breakpoint ",
10832 0/*allow-unknown*/, &showlist
);
10834 add_setshow_auto_boolean_cmd ("pending", no_class
,
10835 &pending_break_support
, _("\
10836 Set debugger's behavior regarding pending breakpoints."), _("\
10837 Show debugger's behavior regarding pending breakpoints."), _("\
10838 If on, an unrecognized breakpoint location will cause gdb to create a\n\
10839 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
10840 an error. If auto, an unrecognized breakpoint location results in a\n\
10841 user-query to see if a pending breakpoint should be created."),
10843 show_pending_break_support
,
10844 &breakpoint_set_cmdlist
,
10845 &breakpoint_show_cmdlist
);
10847 pending_break_support
= AUTO_BOOLEAN_AUTO
;
10849 add_setshow_boolean_cmd ("auto-hw", no_class
,
10850 &automatic_hardware_breakpoints
, _("\
10851 Set automatic usage of hardware breakpoints."), _("\
10852 Show automatic usage of hardware breakpoints."), _("\
10853 If set, the debugger will automatically use hardware breakpoints for\n\
10854 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
10855 a warning will be emitted for such breakpoints."),
10857 show_automatic_hardware_breakpoints
,
10858 &breakpoint_set_cmdlist
,
10859 &breakpoint_show_cmdlist
);
10861 add_setshow_enum_cmd ("always-inserted", class_support
,
10862 always_inserted_enums
, &always_inserted_mode
, _("\
10863 Set mode for inserting breakpoints."), _("\
10864 Show mode for inserting breakpoints."), _("\
10865 When this mode is off, breakpoints are inserted in inferior when it is\n\
10866 resumed, and removed when execution stops. When this mode is on,\n\
10867 breakpoints are inserted immediately and removed only when the user\n\
10868 deletes the breakpoint. When this mode is auto (which is the default),\n\
10869 the behaviour depends on the non-stop setting (see help set non-stop).\n\
10870 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
10871 behaves as if always-inserted mode is on; if gdb is controlling the\n\
10872 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
10874 &show_always_inserted_mode
,
10875 &breakpoint_set_cmdlist
,
10876 &breakpoint_show_cmdlist
);
10878 automatic_hardware_breakpoints
= 1;
10880 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);