1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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 void breakpoints_info (char *, int);
132 static void breakpoint_1 (int, int);
134 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
136 static int breakpoint_cond_eval (void *);
138 static void cleanup_executing_breakpoints (void *);
140 static void commands_command (char *, int);
142 static void condition_command (char *, int);
144 static int get_number_trailer (char **, int);
146 void set_breakpoint_count (int);
155 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
156 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
158 static enum print_stop_action
print_it_typical (bpstat
);
160 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
162 static int watchpoint_check (void *);
164 static void maintenance_info_breakpoints (char *, int);
166 static int hw_breakpoint_used_count (void);
168 static int hw_watchpoint_used_count (enum bptype
, int *);
170 static void hbreak_command (char *, int);
172 static void thbreak_command (char *, int);
174 static void watch_command_1 (char *, int, int);
176 static void rwatch_command (char *, int);
178 static void awatch_command (char *, int);
180 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
182 static void stop_command (char *arg
, int from_tty
);
184 static void stopin_command (char *arg
, int from_tty
);
186 static void stopat_command (char *arg
, int from_tty
);
188 static char *ep_parse_optional_if_clause (char **arg
);
190 static char *ep_parse_optional_filename (char **arg
);
192 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
193 char *arg
, int tempflag
, int from_tty
);
195 static void tcatch_command (char *arg
, int from_tty
);
197 static void ep_skip_leading_whitespace (char **s
);
199 static int single_step_breakpoint_inserted_here_p (struct address_space
*,
202 static void free_bp_location (struct bp_location
*loc
);
204 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
206 static void update_global_location_list (int);
208 static void update_global_location_list_nothrow (int);
210 static int is_hardware_watchpoint (struct breakpoint
*bpt
);
212 static void insert_breakpoint_locations (void);
214 static int syscall_catchpoint_p (struct breakpoint
*b
);
216 static void tracepoints_info (char *, int);
218 static void delete_trace_command (char *, int);
220 static void enable_trace_command (char *, int);
222 static void disable_trace_command (char *, int);
224 static void trace_pass_command (char *, int);
226 static void skip_prologue_sal (struct symtab_and_line
*sal
);
229 /* Flag indicating that a command has proceeded the inferior past the
230 current breakpoint. */
232 static int breakpoint_proceeded
;
235 bpdisp_text (enum bpdisp disp
)
237 /* NOTE: the following values are a part of MI protocol and represent
238 values of 'disp' field returned when inferior stops at a breakpoint. */
239 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
240 return bpdisps
[(int) disp
];
243 /* Prototypes for exported functions. */
244 /* If FALSE, gdb will not use hardware support for watchpoints, even
245 if such is available. */
246 static int can_use_hw_watchpoints
;
249 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
250 struct cmd_list_element
*c
,
253 fprintf_filtered (file
, _("\
254 Debugger's willingness to use watchpoint hardware is %s.\n"),
258 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
259 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
260 for unrecognized breakpoint locations.
261 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
262 static enum auto_boolean pending_break_support
;
264 show_pending_break_support (struct ui_file
*file
, int from_tty
,
265 struct cmd_list_element
*c
,
268 fprintf_filtered (file
, _("\
269 Debugger's behavior regarding pending breakpoints is %s.\n"),
273 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
274 set with "break" but falling in read-only memory.
275 If 0, gdb will warn about such breakpoints, but won't automatically
276 use hardware breakpoints. */
277 static int automatic_hardware_breakpoints
;
279 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
280 struct cmd_list_element
*c
,
283 fprintf_filtered (file
, _("\
284 Automatic usage of hardware breakpoints is %s.\n"),
288 /* If on, gdb will keep breakpoints inserted even as inferior is
289 stopped, and immediately insert any new breakpoints. If off, gdb
290 will insert breakpoints into inferior only when resuming it, and
291 will remove breakpoints upon stop. If auto, GDB will behave as ON
292 if in non-stop mode, and as OFF if all-stop mode.*/
294 static const char always_inserted_auto
[] = "auto";
295 static const char always_inserted_on
[] = "on";
296 static const char always_inserted_off
[] = "off";
297 static const char *always_inserted_enums
[] = {
298 always_inserted_auto
,
303 static const char *always_inserted_mode
= always_inserted_auto
;
305 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
306 struct cmd_list_element
*c
, const char *value
)
308 if (always_inserted_mode
== always_inserted_auto
)
309 fprintf_filtered (file
, _("\
310 Always inserted breakpoint mode is %s (currently %s).\n"),
312 breakpoints_always_inserted_mode () ? "on" : "off");
314 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
318 breakpoints_always_inserted_mode (void)
320 return (always_inserted_mode
== always_inserted_on
321 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
324 void _initialize_breakpoint (void);
326 /* Are we executing breakpoint commands? */
327 static int executing_breakpoint_commands
;
329 /* Are overlay event breakpoints enabled? */
330 static int overlay_events_enabled
;
332 /* Walk the following statement or block through all breakpoints.
333 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
336 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
338 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
339 for (B = breakpoint_chain; \
340 B ? (TMP=B->next, 1): 0; \
343 /* Similar iterator for the low-level breakpoints. SAFE variant is not
344 provided so update_global_location_list must not be called while executing
345 the block of ALL_BP_LOCATIONS. */
347 #define ALL_BP_LOCATIONS(B,BP_TMP) \
348 for (BP_TMP = bp_location; \
349 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
352 /* Iterator for tracepoints only. */
354 #define ALL_TRACEPOINTS(B) \
355 for (B = breakpoint_chain; B; B = B->next) \
356 if ((B)->type == bp_tracepoint)
358 /* Chains of all breakpoints defined. */
360 struct breakpoint
*breakpoint_chain
;
362 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
364 static struct bp_location
**bp_location
;
366 /* Number of elements of BP_LOCATION. */
368 static unsigned bp_location_count
;
370 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and ADDRESS
371 for the current elements of BP_LOCATION which get a valid result from
372 bp_location_has_shadow. You can use it for roughly limiting the subrange of
373 BP_LOCATION to scan for shadow bytes for an address you need to read. */
375 static CORE_ADDR bp_location_placed_address_before_address_max
;
377 /* Maximum offset plus alignment between
378 bp_target_info.PLACED_ADDRESS + bp_target_info.SHADOW_LEN and ADDRESS for
379 the current elements of BP_LOCATION which get a valid result from
380 bp_location_has_shadow. You can use it for roughly limiting the subrange of
381 BP_LOCATION to scan for shadow bytes for an address you need to read. */
383 static CORE_ADDR bp_location_shadow_len_after_address_max
;
385 /* The locations that no longer correspond to any breakpoint,
386 unlinked from bp_location array, but for which a hit
387 may still be reported by a target. */
388 VEC(bp_location_p
) *moribund_locations
= NULL
;
390 /* Number of last breakpoint made. */
392 int breakpoint_count
;
394 /* Number of last tracepoint made. */
396 int tracepoint_count
;
398 /* Return whether a breakpoint is an active enabled breakpoint. */
400 breakpoint_enabled (struct breakpoint
*b
)
402 return (b
->enable_state
== bp_enabled
);
405 /* Set breakpoint count to NUM. */
408 set_breakpoint_count (int num
)
410 breakpoint_count
= num
;
411 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
414 /* Used in run_command to zero the hit count when a new run starts. */
417 clear_breakpoint_hit_counts (void)
419 struct breakpoint
*b
;
425 /* Default address, symtab and line to put a breakpoint at
426 for "break" command with no arg.
427 if default_breakpoint_valid is zero, the other three are
428 not valid, and "break" with no arg is an error.
430 This set by print_stack_frame, which calls set_default_breakpoint. */
432 int default_breakpoint_valid
;
433 CORE_ADDR default_breakpoint_address
;
434 struct symtab
*default_breakpoint_symtab
;
435 int default_breakpoint_line
;
436 struct program_space
*default_breakpoint_pspace
;
439 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
440 Advance *PP after the string and any trailing whitespace.
442 Currently the string can either be a number or "$" followed by the name
443 of a convenience variable. Making it an expression wouldn't work well
444 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
446 If the string is a NULL pointer, that denotes the last breakpoint.
448 TRAILER is a character which can be found after the number; most
449 commonly this is `-'. If you don't want a trailer, use \0. */
451 get_number_trailer (char **pp
, int trailer
)
453 int retval
= 0; /* default */
457 /* Empty line means refer to the last breakpoint. */
458 return breakpoint_count
;
461 /* Make a copy of the name, so we can null-terminate it
462 to pass to lookup_internalvar(). */
467 while (isalnum (*p
) || *p
== '_')
469 varname
= (char *) alloca (p
- start
+ 1);
470 strncpy (varname
, start
, p
- start
);
471 varname
[p
- start
] = '\0';
472 if (get_internalvar_integer (lookup_internalvar (varname
), &val
))
476 printf_filtered (_("Convenience variable must have integer value.\n"));
484 while (*p
>= '0' && *p
<= '9')
487 /* There is no number here. (e.g. "cond a == b"). */
489 /* Skip non-numeric token */
490 while (*p
&& !isspace((int) *p
))
492 /* Return zero, which caller must interpret as error. */
498 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
500 /* Trailing junk: return 0 and let caller print error msg. */
501 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
512 /* Like get_number_trailer, but don't allow a trailer. */
514 get_number (char **pp
)
516 return get_number_trailer (pp
, '\0');
519 /* Parse a number or a range.
520 * A number will be of the form handled by get_number.
521 * A range will be of the form <number1> - <number2>, and
522 * will represent all the integers between number1 and number2,
525 * While processing a range, this fuction is called iteratively;
526 * At each call it will return the next value in the range.
528 * At the beginning of parsing a range, the char pointer PP will
529 * be advanced past <number1> and left pointing at the '-' token.
530 * Subsequent calls will not advance the pointer until the range
531 * is completed. The call that completes the range will advance
532 * pointer PP past <number2>.
536 get_number_or_range (char **pp
)
538 static int last_retval
, end_value
;
539 static char *end_ptr
;
540 static int in_range
= 0;
544 /* Default case: pp is pointing either to a solo number,
545 or to the first number of a range. */
546 last_retval
= get_number_trailer (pp
, '-');
551 /* This is the start of a range (<number1> - <number2>).
552 Skip the '-', parse and remember the second number,
553 and also remember the end of the final token. */
557 while (isspace ((int) *end_ptr
))
558 end_ptr
++; /* skip white space */
559 end_value
= get_number (temp
);
560 if (end_value
< last_retval
)
562 error (_("inverted range"));
564 else if (end_value
== last_retval
)
566 /* degenerate range (number1 == number2). Advance the
567 token pointer so that the range will be treated as a
576 error (_("negative value"));
579 /* pp points to the '-' that betokens a range. All
580 number-parsing has already been done. Return the next
581 integer value (one greater than the saved previous value).
582 Do not advance the token pointer 'pp' until the end of range
585 if (++last_retval
== end_value
)
587 /* End of range reached; advance token pointer. */
595 /* Return the breakpoint with the specified number, or NULL
596 if the number does not refer to an existing breakpoint. */
599 get_breakpoint (int num
)
601 struct breakpoint
*b
;
604 if (b
->number
== num
)
611 /* condition N EXP -- set break condition of breakpoint N to EXP. */
614 condition_command (char *arg
, int from_tty
)
616 struct breakpoint
*b
;
621 error_no_arg (_("breakpoint number"));
624 bnum
= get_number (&p
);
626 error (_("Bad breakpoint argument: '%s'"), arg
);
629 if (b
->number
== bnum
)
631 struct bp_location
*loc
= b
->loc
;
632 for (; loc
; loc
= loc
->next
)
640 if (b
->cond_string
!= NULL
)
641 xfree (b
->cond_string
);
645 b
->cond_string
= NULL
;
647 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
652 /* I don't know if it matters whether this is the string the user
653 typed in or the decompiled expression. */
654 b
->cond_string
= xstrdup (arg
);
655 b
->condition_not_parsed
= 0;
656 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
660 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
662 error (_("Junk at end of expression"));
665 breakpoints_changed ();
666 observer_notify_breakpoint_modified (b
->number
);
670 error (_("No breakpoint number %d."), bnum
);
673 /* Set the command list of B to COMMANDS. */
676 breakpoint_set_commands (struct breakpoint
*b
, struct command_line
*commands
)
678 free_command_lines (&b
->commands
);
679 b
->commands
= commands
;
680 breakpoints_changed ();
681 observer_notify_breakpoint_modified (b
->number
);
685 commands_command (char *arg
, int from_tty
)
687 struct breakpoint
*b
;
690 struct command_line
*l
;
692 /* If we allowed this, we would have problems with when to
693 free the storage, if we change the commands currently
696 if (executing_breakpoint_commands
)
697 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
700 bnum
= get_number (&p
);
703 error (_("Unexpected extra arguments following breakpoint number."));
706 if (b
->number
== bnum
)
708 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
710 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
711 l
= read_command_lines (tmpbuf
, from_tty
, 1);
712 do_cleanups (cleanups
);
713 breakpoint_set_commands (b
, l
);
716 error (_("No breakpoint number %d."), bnum
);
719 /* Like commands_command, but instead of reading the commands from
720 input stream, takes them from an already parsed command structure.
722 This is used by cli-script.c to DTRT with breakpoint commands
723 that are part of if and while bodies. */
724 enum command_control_type
725 commands_from_control_command (char *arg
, struct command_line
*cmd
)
727 struct breakpoint
*b
;
731 /* If we allowed this, we would have problems with when to
732 free the storage, if we change the commands currently
735 if (executing_breakpoint_commands
)
736 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
738 /* An empty string for the breakpoint number means the last
739 breakpoint, but get_number expects a NULL pointer. */
744 bnum
= get_number (&p
);
747 error (_("Unexpected extra arguments following breakpoint number."));
750 if (b
->number
== bnum
)
752 free_command_lines (&b
->commands
);
753 if (cmd
->body_count
!= 1)
754 error (_("Invalid \"commands\" block structure."));
755 /* We need to copy the commands because if/while will free the
756 list after it finishes execution. */
757 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
758 breakpoints_changed ();
759 observer_notify_breakpoint_modified (b
->number
);
760 return simple_control
;
762 error (_("No breakpoint number %d."), bnum
);
765 /* Return non-zero if BL->TARGET_INFO contains valid information. */
768 bp_location_has_shadow (struct bp_location
*bl
)
770 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
774 if (bl
->target_info
.shadow_len
== 0)
775 /* bp isn't valid, or doesn't shadow memory. */
780 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
781 by replacing any memory breakpoints with their shadowed contents.
783 The range of shadowed area by each bp_location is:
784 b->address - bp_location_placed_address_before_address_max
785 up to b->address + bp_location_shadow_len_after_address_max
786 The range we were requested to resolve shadows for is:
787 memaddr ... memaddr + len
788 Thus the safe cutoff boundaries for performance optimization are
789 memaddr + len <= b->address - bp_location_placed_address_before_address_max
791 b->address + bp_location_shadow_len_after_address_max <= memaddr */
794 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
796 /* Left boundary, right boundary and median element of our binary search. */
797 unsigned bc_l
, bc_r
, bc
;
799 /* Find BC_L which is a leftmost element which may affect BUF content. It is
800 safe to report lower value but a failure to report higher one. */
803 bc_r
= bp_location_count
;
804 while (bc_l
+ 1 < bc_r
)
806 struct bp_location
*b
;
808 bc
= (bc_l
+ bc_r
) / 2;
811 /* Check first B->ADDRESS will not overflow due to the added constant.
812 Then advance the left boundary only if we are sure the BC element can
813 in no way affect the BUF content (MEMADDR to MEMADDR + LEN range).
815 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety offset so that
816 we cannot miss a breakpoint with its shadow range tail still reaching
819 if (b
->address
+ bp_location_shadow_len_after_address_max
>= b
->address
820 && b
->address
+ bp_location_shadow_len_after_address_max
<= memaddr
)
826 /* Now do full processing of the found relevant range of elements. */
828 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
830 struct bp_location
*b
= bp_location
[bc
];
831 CORE_ADDR bp_addr
= 0;
835 if (b
->owner
->type
== bp_none
)
836 warning (_("reading through apparently deleted breakpoint #%d?"),
839 /* Performance optimization: any futher element can no longer affect BUF
842 if (b
->address
>= bp_location_placed_address_before_address_max
843 && memaddr
+ len
<= b
->address
844 - bp_location_placed_address_before_address_max
)
847 if (!bp_location_has_shadow (b
))
849 if (!breakpoint_address_match (b
->target_info
.placed_address_space
, 0,
850 current_program_space
->aspace
, 0))
853 /* Addresses and length of the part of the breakpoint that
855 bp_addr
= b
->target_info
.placed_address
;
856 bp_size
= b
->target_info
.shadow_len
;
858 if (bp_addr
+ bp_size
<= memaddr
)
859 /* The breakpoint is entirely before the chunk of memory we
863 if (bp_addr
>= memaddr
+ len
)
864 /* The breakpoint is entirely after the chunk of memory we are
868 /* Offset within shadow_contents. */
869 if (bp_addr
< memaddr
)
871 /* Only copy the second part of the breakpoint. */
872 bp_size
-= memaddr
- bp_addr
;
873 bptoffset
= memaddr
- bp_addr
;
877 if (bp_addr
+ bp_size
> memaddr
+ len
)
879 /* Only copy the first part of the breakpoint. */
880 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
883 memcpy (buf
+ bp_addr
- memaddr
,
884 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
889 /* A wrapper function for inserting catchpoints. */
891 insert_catchpoint (struct ui_out
*uo
, void *args
)
893 struct breakpoint
*b
= (struct breakpoint
*) args
;
896 gdb_assert (b
->type
== bp_catchpoint
);
897 gdb_assert (b
->ops
!= NULL
&& b
->ops
->insert
!= NULL
);
903 is_hardware_watchpoint (struct breakpoint
*bpt
)
905 return (bpt
->type
== bp_hardware_watchpoint
906 || bpt
->type
== bp_read_watchpoint
907 || bpt
->type
== bp_access_watchpoint
);
910 /* Find the current value of a watchpoint on EXP. Return the value in
911 *VALP and *RESULTP and the chain of intermediate and final values
912 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
915 If a memory error occurs while evaluating the expression, *RESULTP will
916 be set to NULL. *RESULTP may be a lazy value, if the result could
917 not be read from memory. It is used to determine whether a value
918 is user-specified (we should watch the whole value) or intermediate
919 (we should watch only the bit used to locate the final value).
921 If the final value, or any intermediate value, could not be read
922 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
923 set to any referenced values. *VALP will never be a lazy value.
924 This is the value which we store in struct breakpoint.
926 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
927 value chain. The caller must free the values individually. If
928 VAL_CHAIN is NULL, all generated values will be left on the value
932 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
933 struct value
**resultp
, struct value
**val_chain
)
935 struct value
*mark
, *new_mark
, *result
;
936 volatile struct gdb_exception ex
;
944 /* Evaluate the expression. */
945 mark
= value_mark ();
948 TRY_CATCH (ex
, RETURN_MASK_ALL
)
950 result
= evaluate_expression (exp
);
954 /* Ignore memory errors, we want watchpoints pointing at
955 inaccessible memory to still be created; otherwise, throw the
956 error to some higher catcher. */
962 throw_exception (ex
);
967 new_mark
= value_mark ();
968 if (mark
== new_mark
)
973 /* Make sure it's not lazy, so that after the target stops again we
974 have a non-lazy previous value to compare with. */
976 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
981 /* Return the chain of intermediate values. We use this to
982 decide which addresses to watch. */
983 *val_chain
= new_mark
;
984 value_release_to_mark (mark
);
988 /* Assuming that B is a watchpoint:
989 - Reparse watchpoint expression, if REPARSE is non-zero
990 - Evaluate expression and store the result in B->val
991 - Evaluate the condition if there is one, and store the result
993 - Update the list of values that must be watched in B->loc.
995 If the watchpoint disposition is disp_del_at_next_stop, then do nothing.
996 If this is local watchpoint that is out of scope, delete it. */
998 update_watchpoint (struct breakpoint
*b
, int reparse
)
1000 int within_current_scope
;
1001 struct frame_id saved_frame_id
;
1002 struct bp_location
*loc
;
1005 struct program_space
*frame_pspace
;
1007 /* We don't free locations. They are stored in bp_location array and
1008 update_global_locations will eventually delete them and remove
1009 breakpoints if needed. */
1012 if (b
->disposition
== disp_del_at_next_stop
)
1017 /* Determine if the watchpoint is within scope. */
1018 if (b
->exp_valid_block
== NULL
)
1019 within_current_scope
= 1;
1022 struct frame_info
*fi
;
1024 /* Save the current frame's ID so we can restore it after
1025 evaluating the watchpoint expression on its own frame. */
1026 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1027 took a frame parameter, so that we didn't have to change the
1030 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1032 fi
= frame_find_by_id (b
->watchpoint_frame
);
1033 within_current_scope
= (fi
!= NULL
);
1034 if (within_current_scope
)
1038 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1040 if (within_current_scope
&& reparse
)
1049 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1050 /* If the meaning of expression itself changed, the old value is
1051 no longer relevant. We don't want to report a watchpoint hit
1052 to the user when the old value and the new value may actually
1053 be completely different objects. */
1054 value_free (b
->val
);
1059 /* If we failed to parse the expression, for example because
1060 it refers to a global variable in a not-yet-loaded shared library,
1061 don't try to insert watchpoint. We don't automatically delete
1062 such watchpoint, though, since failure to parse expression
1063 is different from out-of-scope watchpoint. */
1064 if (within_current_scope
&& b
->exp
)
1066 struct value
*val_chain
, *v
, *result
, *next
;
1068 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
1070 /* Avoid setting b->val if it's already set. The meaning of
1071 b->val is 'the last value' user saw, and we should update
1072 it only if we reported that last value to user. As it
1073 happens, the code that reports it updates b->val directly. */
1080 /* Change the type of breakpoint between hardware assisted or an
1081 ordinary watchpoint depending on the hardware support and free
1082 hardware slots. REPARSE is set when the inferior is started. */
1083 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
1086 int i
, mem_cnt
, other_type_used
;
1088 i
= hw_watchpoint_used_count (bp_hardware_watchpoint
,
1090 mem_cnt
= can_use_hardware_watchpoint (val_chain
);
1093 b
->type
= bp_watchpoint
;
1096 int target_resources_ok
= target_can_use_hardware_watchpoint
1097 (bp_hardware_watchpoint
, i
+ mem_cnt
, other_type_used
);
1098 if (target_resources_ok
<= 0)
1099 b
->type
= bp_watchpoint
;
1101 b
->type
= bp_hardware_watchpoint
;
1105 /* Look at each value on the value chain. */
1106 for (v
= val_chain
; v
; v
= next
)
1108 /* If it's a memory location, and GDB actually needed
1109 its contents to evaluate the expression, then we
1110 must watch it. If the first value returned is
1111 still lazy, that means an error occurred reading it;
1112 watch it anyway in case it becomes readable. */
1113 if (VALUE_LVAL (v
) == lval_memory
1114 && (v
== val_chain
|| ! value_lazy (v
)))
1116 struct type
*vtype
= check_typedef (value_type (v
));
1118 /* We only watch structs and arrays if user asked
1119 for it explicitly, never if they just happen to
1120 appear in the middle of some value chain. */
1122 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1123 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1127 struct bp_location
*loc
, **tmp
;
1129 addr
= value_address (v
);
1130 len
= TYPE_LENGTH (value_type (v
));
1132 if (b
->type
== bp_read_watchpoint
)
1134 else if (b
->type
== bp_access_watchpoint
)
1137 loc
= allocate_bp_location (b
);
1138 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1141 loc
->gdbarch
= get_type_arch (value_type (v
));
1143 loc
->pspace
= frame_pspace
;
1144 loc
->address
= addr
;
1146 loc
->watchpoint_type
= type
;
1150 next
= value_next (v
);
1155 /* We just regenerated the list of breakpoint locations.
1156 The new location does not have its condition field set to anything
1157 and therefore, we must always reparse the cond_string, independently
1158 of the value of the reparse flag. */
1159 if (b
->cond_string
!= NULL
)
1161 char *s
= b
->cond_string
;
1162 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1165 else if (!within_current_scope
)
1167 printf_filtered (_("\
1168 Watchpoint %d deleted because the program has left the block \n\
1169 in which its expression is valid.\n"),
1171 if (b
->related_breakpoint
)
1172 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1173 b
->disposition
= disp_del_at_next_stop
;
1176 /* Restore the selected frame. */
1178 select_frame (frame_find_by_id (saved_frame_id
));
1182 /* Returns 1 iff breakpoint location should be
1183 inserted in the inferior. */
1185 should_be_inserted (struct bp_location
*bpt
)
1187 if (!breakpoint_enabled (bpt
->owner
))
1190 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
1193 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1196 /* This is set for example, when we're attached to the parent of a
1197 vfork, and have detached from the child. The child is running
1198 free, and we expect it to do an exec or exit, at which point the
1199 OS makes the parent schedulable again (and the target reports
1200 that the vfork is done). Until the child is done with the shared
1201 memory region, do not insert breakpoints in the parent, otherwise
1202 the child could still trip on the parent's breakpoints. Since
1203 the parent is blocked anyway, it won't miss any breakpoint. */
1204 if (bpt
->pspace
->breakpoints_not_allowed
)
1207 /* Tracepoints are inserted by the target at a time of its choosing,
1209 if (bpt
->owner
->type
== bp_tracepoint
)
1215 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1216 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1217 and HW_BREAKPOINT_ERROR are used to report problems.
1219 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1220 method for each breakpoint or catchpoint type. */
1222 insert_bp_location (struct bp_location
*bpt
,
1223 struct ui_file
*tmp_error_stream
,
1224 int *disabled_breaks
,
1225 int *hw_breakpoint_error
)
1229 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1232 /* Initialize the target-specific information. */
1233 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1234 bpt
->target_info
.placed_address
= bpt
->address
;
1235 bpt
->target_info
.placed_address_space
= bpt
->pspace
->aspace
;
1237 if (bpt
->loc_type
== bp_loc_software_breakpoint
1238 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1240 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1242 /* If the explicitly specified breakpoint type
1243 is not hardware breakpoint, check the memory map to see
1244 if the breakpoint address is in read only memory or not.
1245 Two important cases are:
1246 - location type is not hardware breakpoint, memory
1247 is readonly. We change the type of the location to
1248 hardware breakpoint.
1249 - location type is hardware breakpoint, memory is read-write.
1250 This means we've previously made the location hardware one, but
1251 then the memory map changed, so we undo.
1253 When breakpoints are removed, remove_breakpoints will
1254 use location types we've just set here, the only possible
1255 problem is that memory map has changed during running program,
1256 but it's not going to work anyway with current gdb. */
1257 struct mem_region
*mr
1258 = lookup_mem_region (bpt
->target_info
.placed_address
);
1262 if (automatic_hardware_breakpoints
)
1265 enum bp_loc_type new_type
;
1267 if (mr
->attrib
.mode
!= MEM_RW
)
1268 new_type
= bp_loc_hardware_breakpoint
;
1270 new_type
= bp_loc_software_breakpoint
;
1272 if (new_type
!= bpt
->loc_type
)
1274 static int said
= 0;
1275 bpt
->loc_type
= new_type
;
1278 fprintf_filtered (gdb_stdout
, _("\
1279 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1284 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1285 && mr
->attrib
.mode
!= MEM_RW
)
1286 warning (_("cannot set software breakpoint at readonly address %s"),
1287 paddress (bpt
->gdbarch
, bpt
->address
));
1291 /* First check to see if we have to handle an overlay. */
1292 if (overlay_debugging
== ovly_off
1293 || bpt
->section
== NULL
1294 || !(section_is_overlay (bpt
->section
)))
1296 /* No overlay handling: just set the breakpoint. */
1298 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1299 val
= target_insert_hw_breakpoint (bpt
->gdbarch
,
1302 val
= target_insert_breakpoint (bpt
->gdbarch
,
1307 /* This breakpoint is in an overlay section.
1308 Shall we set a breakpoint at the LMA? */
1309 if (!overlay_events_enabled
)
1311 /* Yes -- overlay event support is not active,
1312 so we must try to set a breakpoint at the LMA.
1313 This will not work for a hardware breakpoint. */
1314 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1315 warning (_("hardware breakpoint %d not supported in overlay!"),
1316 bpt
->owner
->number
);
1319 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1321 /* Set a software (trap) breakpoint at the LMA. */
1322 bpt
->overlay_target_info
= bpt
->target_info
;
1323 bpt
->overlay_target_info
.placed_address
= addr
;
1324 val
= target_insert_breakpoint (bpt
->gdbarch
,
1325 &bpt
->overlay_target_info
);
1327 fprintf_unfiltered (tmp_error_stream
,
1328 "Overlay breakpoint %d failed: in ROM?\n",
1329 bpt
->owner
->number
);
1332 /* Shall we set a breakpoint at the VMA? */
1333 if (section_is_mapped (bpt
->section
))
1335 /* Yes. This overlay section is mapped into memory. */
1336 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1337 val
= target_insert_hw_breakpoint (bpt
->gdbarch
,
1340 val
= target_insert_breakpoint (bpt
->gdbarch
,
1345 /* No. This breakpoint will not be inserted.
1346 No error, but do not mark the bp as 'inserted'. */
1353 /* Can't set the breakpoint. */
1354 if (solib_name_from_address (bpt
->pspace
, bpt
->address
))
1356 /* See also: disable_breakpoints_in_shlibs. */
1358 bpt
->shlib_disabled
= 1;
1359 if (!*disabled_breaks
)
1361 fprintf_unfiltered (tmp_error_stream
,
1362 "Cannot insert breakpoint %d.\n",
1363 bpt
->owner
->number
);
1364 fprintf_unfiltered (tmp_error_stream
,
1365 "Temporarily disabling shared library breakpoints:\n");
1367 *disabled_breaks
= 1;
1368 fprintf_unfiltered (tmp_error_stream
,
1369 "breakpoint #%d\n", bpt
->owner
->number
);
1373 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1375 *hw_breakpoint_error
= 1;
1376 fprintf_unfiltered (tmp_error_stream
,
1377 "Cannot insert hardware breakpoint %d.\n",
1378 bpt
->owner
->number
);
1382 fprintf_unfiltered (tmp_error_stream
,
1383 "Cannot insert breakpoint %d.\n",
1384 bpt
->owner
->number
);
1385 fprintf_filtered (tmp_error_stream
,
1386 "Error accessing memory address ");
1387 fputs_filtered (paddress (bpt
->gdbarch
, bpt
->address
),
1389 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1390 safe_strerror (val
));
1401 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1402 /* NOTE drow/2003-09-08: This state only exists for removing
1403 watchpoints. It's not clear that it's necessary... */
1404 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1406 val
= target_insert_watchpoint (bpt
->address
,
1408 bpt
->watchpoint_type
);
1409 bpt
->inserted
= (val
!= -1);
1412 else if (bpt
->owner
->type
== bp_catchpoint
)
1414 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1415 bpt
->owner
, RETURN_MASK_ERROR
);
1416 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1417 bpt
->owner
->number
);
1419 bpt
->owner
->enable_state
= bp_disabled
;
1423 /* We've already printed an error message if there was a problem
1424 inserting this catchpoint, and we've disabled the catchpoint,
1425 so just return success. */
1432 /* This function is called when program space PSPACE is about to be
1433 deleted. It takes care of updating breakpoints to not reference
1437 breakpoint_program_space_exit (struct program_space
*pspace
)
1439 struct breakpoint
*b
, *b_temp
;
1440 struct bp_location
*loc
, **loc_temp
;
1442 /* Remove any breakpoint that was set through this program space. */
1443 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1445 if (b
->pspace
== pspace
)
1446 delete_breakpoint (b
);
1449 /* Breakpoints set through other program spaces could have locations
1450 bound to PSPACE as well. Remove those. */
1451 ALL_BP_LOCATIONS (loc
, loc_temp
)
1453 struct bp_location
*tmp
;
1455 if (loc
->pspace
== pspace
)
1457 if (loc
->owner
->loc
== loc
)
1458 loc
->owner
->loc
= loc
->next
;
1460 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1461 if (tmp
->next
== loc
)
1463 tmp
->next
= loc
->next
;
1469 /* Now update the global location list to permanently delete the
1470 removed locations above. */
1471 update_global_location_list (0);
1474 /* Make sure all breakpoints are inserted in inferior.
1475 Throws exception on any error.
1476 A breakpoint that is already inserted won't be inserted
1477 again, so calling this function twice is safe. */
1479 insert_breakpoints (void)
1481 struct breakpoint
*bpt
;
1483 ALL_BREAKPOINTS (bpt
)
1484 if (is_hardware_watchpoint (bpt
))
1485 update_watchpoint (bpt
, 0 /* don't reparse. */);
1487 update_global_location_list (1);
1489 /* update_global_location_list does not insert breakpoints when
1490 always_inserted_mode is not enabled. Explicitly insert them
1492 if (!breakpoints_always_inserted_mode ())
1493 insert_breakpoint_locations ();
1496 /* insert_breakpoints is used when starting or continuing the program.
1497 remove_breakpoints is used when the program stops.
1498 Both return zero if successful,
1499 or an `errno' value if could not write the inferior. */
1502 insert_breakpoint_locations (void)
1504 struct breakpoint
*bpt
;
1505 struct bp_location
*b
, **bp_tmp
;
1508 int disabled_breaks
= 0;
1509 int hw_breakpoint_error
= 0;
1511 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1512 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1514 /* Explicitly mark the warning -- this will only be printed if
1515 there was an error. */
1516 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1518 save_current_space_and_thread ();
1520 ALL_BP_LOCATIONS (b
, bp_tmp
)
1522 struct thread_info
*tp
;
1523 CORE_ADDR last_addr
;
1525 if (!should_be_inserted (b
) || b
->inserted
)
1528 /* There is no point inserting thread-specific breakpoints if the
1529 thread no longer exists. */
1530 if (b
->owner
->thread
!= -1
1531 && !valid_thread_id (b
->owner
->thread
))
1534 switch_to_program_space_and_thread (b
->pspace
);
1536 /* For targets that support global breakpoints, there's no need
1537 to select an inferior to insert breakpoint to. In fact, even
1538 if we aren't attached to any process yet, we should still
1539 insert breakpoints. */
1540 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
1541 && ptid_equal (inferior_ptid
, null_ptid
))
1544 val
= insert_bp_location (b
, tmp_error_stream
,
1546 &hw_breakpoint_error
);
1551 /* If we failed to insert all locations of a watchpoint,
1552 remove them, as half-inserted watchpoint is of limited use. */
1553 ALL_BREAKPOINTS (bpt
)
1555 int some_failed
= 0;
1556 struct bp_location
*loc
;
1558 if (!is_hardware_watchpoint (bpt
))
1561 if (!breakpoint_enabled (bpt
))
1564 if (bpt
->disposition
== disp_del_at_next_stop
)
1567 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1568 if (!loc
->inserted
&& should_be_inserted (loc
))
1575 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1577 remove_breakpoint (loc
, mark_uninserted
);
1579 hw_breakpoint_error
= 1;
1580 fprintf_unfiltered (tmp_error_stream
,
1581 "Could not insert hardware watchpoint %d.\n",
1589 /* If a hardware breakpoint or watchpoint was inserted, add a
1590 message about possibly exhausted resources. */
1591 if (hw_breakpoint_error
)
1593 fprintf_unfiltered (tmp_error_stream
,
1594 "Could not insert hardware breakpoints:\n\
1595 You may have requested too many hardware breakpoints/watchpoints.\n");
1597 target_terminal_ours_for_output ();
1598 error_stream (tmp_error_stream
);
1601 do_cleanups (cleanups
);
1605 remove_breakpoints (void)
1607 struct bp_location
*b
, **bp_tmp
;
1610 ALL_BP_LOCATIONS (b
, bp_tmp
)
1613 val
|= remove_breakpoint (b
, mark_uninserted
);
1618 /* Remove breakpoints of process PID. */
1621 remove_breakpoints_pid (int pid
)
1623 struct bp_location
*b
, **b_tmp
;
1625 struct inferior
*inf
= find_inferior_pid (pid
);
1627 ALL_BP_LOCATIONS (b
, b_tmp
)
1629 if (b
->pspace
!= inf
->pspace
)
1634 val
= remove_breakpoint (b
, mark_uninserted
);
1643 remove_hw_watchpoints (void)
1645 struct bp_location
*b
, **bp_tmp
;
1648 ALL_BP_LOCATIONS (b
, bp_tmp
)
1650 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1651 val
|= remove_breakpoint (b
, mark_uninserted
);
1657 reattach_breakpoints (int pid
)
1659 struct cleanup
*old_chain
;
1660 struct bp_location
*b
, **bp_tmp
;
1662 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1663 int dummy1
= 0, dummy2
= 0;
1664 struct inferior
*inf
;
1665 struct thread_info
*tp
;
1667 tp
= any_live_thread_of_process (pid
);
1671 inf
= find_inferior_pid (pid
);
1672 old_chain
= save_inferior_ptid ();
1674 inferior_ptid
= tp
->ptid
;
1676 make_cleanup_ui_file_delete (tmp_error_stream
);
1678 ALL_BP_LOCATIONS (b
, bp_tmp
)
1680 if (b
->pspace
!= inf
->pspace
)
1686 val
= insert_bp_location (b
, tmp_error_stream
,
1690 do_cleanups (old_chain
);
1695 do_cleanups (old_chain
);
1699 static int internal_breakpoint_number
= -1;
1701 static struct breakpoint
*
1702 create_internal_breakpoint (struct gdbarch
*gdbarch
,
1703 CORE_ADDR address
, enum bptype type
)
1705 struct symtab_and_line sal
;
1706 struct breakpoint
*b
;
1708 init_sal (&sal
); /* initialize to zeroes */
1711 sal
.section
= find_pc_overlay (sal
.pc
);
1712 sal
.pspace
= current_program_space
;
1714 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
1715 b
->number
= internal_breakpoint_number
--;
1716 b
->disposition
= disp_donttouch
;
1722 create_overlay_event_breakpoint (char *func_name
)
1724 struct objfile
*objfile
;
1726 ALL_OBJFILES (objfile
)
1728 struct breakpoint
*b
;
1729 struct minimal_symbol
*m
;
1731 m
= lookup_minimal_symbol_text (func_name
, objfile
);
1735 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
1736 SYMBOL_VALUE_ADDRESS (m
),
1738 b
->addr_string
= xstrdup (func_name
);
1740 if (overlay_debugging
== ovly_auto
)
1742 b
->enable_state
= bp_enabled
;
1743 overlay_events_enabled
= 1;
1747 b
->enable_state
= bp_disabled
;
1748 overlay_events_enabled
= 0;
1751 update_global_location_list (1);
1755 create_longjmp_master_breakpoint (char *func_name
)
1757 struct program_space
*pspace
;
1758 struct objfile
*objfile
;
1759 struct cleanup
*old_chain
;
1761 old_chain
= save_current_program_space ();
1763 ALL_PSPACES (pspace
)
1764 ALL_OBJFILES (objfile
)
1766 struct breakpoint
*b
;
1767 struct minimal_symbol
*m
;
1769 if (!gdbarch_get_longjmp_target_p (get_objfile_arch (objfile
)))
1772 set_current_program_space (pspace
);
1774 m
= lookup_minimal_symbol_text (func_name
, objfile
);
1778 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
1779 SYMBOL_VALUE_ADDRESS (m
),
1781 b
->addr_string
= xstrdup (func_name
);
1782 b
->enable_state
= bp_disabled
;
1784 update_global_location_list (1);
1786 do_cleanups (old_chain
);
1790 update_breakpoints_after_exec (void)
1792 struct breakpoint
*b
;
1793 struct breakpoint
*temp
;
1794 struct bp_location
*bploc
, **bplocp_tmp
;
1796 /* We're about to delete breakpoints from GDB's lists. If the
1797 INSERTED flag is true, GDB will try to lift the breakpoints by
1798 writing the breakpoints' "shadow contents" back into memory. The
1799 "shadow contents" are NOT valid after an exec, so GDB should not
1800 do that. Instead, the target is responsible from marking
1801 breakpoints out as soon as it detects an exec. We don't do that
1802 here instead, because there may be other attempts to delete
1803 breakpoints after detecting an exec and before reaching here. */
1804 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
1805 if (bploc
->pspace
== current_program_space
)
1806 gdb_assert (!bploc
->inserted
);
1808 ALL_BREAKPOINTS_SAFE (b
, temp
)
1810 if (b
->pspace
!= current_program_space
)
1813 /* Solib breakpoints must be explicitly reset after an exec(). */
1814 if (b
->type
== bp_shlib_event
)
1816 delete_breakpoint (b
);
1820 /* JIT breakpoints must be explicitly reset after an exec(). */
1821 if (b
->type
== bp_jit_event
)
1823 delete_breakpoint (b
);
1827 /* Thread event breakpoints must be set anew after an exec(),
1828 as must overlay event and longjmp master breakpoints. */
1829 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
1830 || b
->type
== bp_longjmp_master
)
1832 delete_breakpoint (b
);
1836 /* Step-resume breakpoints are meaningless after an exec(). */
1837 if (b
->type
== bp_step_resume
)
1839 delete_breakpoint (b
);
1843 /* Longjmp and longjmp-resume breakpoints are also meaningless
1845 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
1847 delete_breakpoint (b
);
1851 if (b
->type
== bp_catchpoint
)
1853 /* For now, none of the bp_catchpoint breakpoints need to
1854 do anything at this point. In the future, if some of
1855 the catchpoints need to something, we will need to add
1856 a new method, and call this method from here. */
1860 /* bp_finish is a special case. The only way we ought to be able
1861 to see one of these when an exec() has happened, is if the user
1862 caught a vfork, and then said "finish". Ordinarily a finish just
1863 carries them to the call-site of the current callee, by setting
1864 a temporary bp there and resuming. But in this case, the finish
1865 will carry them entirely through the vfork & exec.
1867 We don't want to allow a bp_finish to remain inserted now. But
1868 we can't safely delete it, 'cause finish_command has a handle to
1869 the bp on a bpstat, and will later want to delete it. There's a
1870 chance (and I've seen it happen) that if we delete the bp_finish
1871 here, that its storage will get reused by the time finish_command
1872 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1873 We really must allow finish_command to delete a bp_finish.
1875 In the absense of a general solution for the "how do we know
1876 it's safe to delete something others may have handles to?"
1877 problem, what we'll do here is just uninsert the bp_finish, and
1878 let finish_command delete it.
1880 (We know the bp_finish is "doomed" in the sense that it's
1881 momentary, and will be deleted as soon as finish_command sees
1882 the inferior stopped. So it doesn't matter that the bp's
1883 address is probably bogus in the new a.out, unlike e.g., the
1884 solib breakpoints.) */
1886 if (b
->type
== bp_finish
)
1891 /* Without a symbolic address, we have little hope of the
1892 pre-exec() address meaning the same thing in the post-exec()
1894 if (b
->addr_string
== NULL
)
1896 delete_breakpoint (b
);
1900 /* FIXME what about longjmp breakpoints? Re-create them here? */
1901 create_overlay_event_breakpoint ("_ovly_debug_event");
1902 create_longjmp_master_breakpoint ("longjmp");
1903 create_longjmp_master_breakpoint ("_longjmp");
1904 create_longjmp_master_breakpoint ("siglongjmp");
1905 create_longjmp_master_breakpoint ("_siglongjmp");
1909 detach_breakpoints (int pid
)
1911 struct bp_location
*b
, **bp_tmp
;
1913 struct cleanup
*old_chain
= save_inferior_ptid ();
1914 struct inferior
*inf
= current_inferior ();
1916 if (pid
== PIDGET (inferior_ptid
))
1917 error (_("Cannot detach breakpoints of inferior_ptid"));
1919 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
1920 inferior_ptid
= pid_to_ptid (pid
);
1921 ALL_BP_LOCATIONS (b
, bp_tmp
)
1923 if (b
->pspace
!= inf
->pspace
)
1927 val
|= remove_breakpoint_1 (b
, mark_inserted
);
1929 do_cleanups (old_chain
);
1933 /* Remove the breakpoint location B from the current address space.
1934 Note that this is used to detach breakpoints from a child fork.
1935 When we get here, the child isn't in the inferior list, and neither
1936 do we have objects to represent its address space --- we should
1937 *not* look at b->pspace->aspace here. */
1940 remove_breakpoint_1 (struct bp_location
*b
, insertion_state_t is
)
1943 struct cleanup
*old_chain
;
1945 if (b
->owner
->enable_state
== bp_permanent
)
1946 /* Permanent breakpoints cannot be inserted or removed. */
1949 /* The type of none suggests that owner is actually deleted.
1950 This should not ever happen. */
1951 gdb_assert (b
->owner
->type
!= bp_none
);
1953 if (b
->loc_type
== bp_loc_software_breakpoint
1954 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1956 /* "Normal" instruction breakpoint: either the standard
1957 trap-instruction bp (bp_breakpoint), or a
1958 bp_hardware_breakpoint. */
1960 /* First check to see if we have to handle an overlay. */
1961 if (overlay_debugging
== ovly_off
1962 || b
->section
== NULL
1963 || !(section_is_overlay (b
->section
)))
1965 /* No overlay handling: just remove the breakpoint. */
1967 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1968 val
= target_remove_hw_breakpoint (b
->gdbarch
, &b
->target_info
);
1970 val
= target_remove_breakpoint (b
->gdbarch
, &b
->target_info
);
1974 /* This breakpoint is in an overlay section.
1975 Did we set a breakpoint at the LMA? */
1976 if (!overlay_events_enabled
)
1978 /* Yes -- overlay event support is not active, so we
1979 should have set a breakpoint at the LMA. Remove it.
1981 /* Ignore any failures: if the LMA is in ROM, we will
1982 have already warned when we failed to insert it. */
1983 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1984 target_remove_hw_breakpoint (b
->gdbarch
,
1985 &b
->overlay_target_info
);
1987 target_remove_breakpoint (b
->gdbarch
,
1988 &b
->overlay_target_info
);
1990 /* Did we set a breakpoint at the VMA?
1991 If so, we will have marked the breakpoint 'inserted'. */
1994 /* Yes -- remove it. Previously we did not bother to
1995 remove the breakpoint if the section had been
1996 unmapped, but let's not rely on that being safe. We
1997 don't know what the overlay manager might do. */
1998 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1999 val
= target_remove_hw_breakpoint (b
->gdbarch
,
2002 /* However, we should remove *software* breakpoints only
2003 if the section is still mapped, or else we overwrite
2004 wrong code with the saved shadow contents. */
2005 else if (section_is_mapped (b
->section
))
2006 val
= target_remove_breakpoint (b
->gdbarch
,
2013 /* No -- not inserted, so no need to remove. No error. */
2018 /* In some cases, we might not be able to remove a breakpoint
2019 in a shared library that has already been removed, but we
2020 have not yet processed the shlib unload event. */
2021 if (val
&& solib_name_from_address (b
->pspace
, b
->address
))
2026 b
->inserted
= (is
== mark_inserted
);
2028 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
2033 b
->inserted
= (is
== mark_inserted
);
2034 val
= target_remove_watchpoint (b
->address
, b
->length
,
2035 b
->watchpoint_type
);
2037 /* Failure to remove any of the hardware watchpoints comes here. */
2038 if ((is
== mark_uninserted
) && (b
->inserted
))
2039 warning (_("Could not remove hardware watchpoint %d."),
2042 else if (b
->owner
->type
== bp_catchpoint
2043 && breakpoint_enabled (b
->owner
)
2046 gdb_assert (b
->owner
->ops
!= NULL
&& b
->owner
->ops
->remove
!= NULL
);
2048 val
= b
->owner
->ops
->remove (b
->owner
);
2051 b
->inserted
= (is
== mark_inserted
);
2058 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
2061 struct cleanup
*old_chain
;
2063 if (b
->owner
->enable_state
== bp_permanent
)
2064 /* Permanent breakpoints cannot be inserted or removed. */
2067 /* The type of none suggests that owner is actually deleted.
2068 This should not ever happen. */
2069 gdb_assert (b
->owner
->type
!= bp_none
);
2071 old_chain
= save_current_space_and_thread ();
2073 switch_to_program_space_and_thread (b
->pspace
);
2075 ret
= remove_breakpoint_1 (b
, is
);
2077 do_cleanups (old_chain
);
2081 /* Clear the "inserted" flag in all breakpoints. */
2084 mark_breakpoints_out (void)
2086 struct bp_location
*bpt
, **bptp_tmp
;
2088 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2089 if (bpt
->pspace
== current_program_space
)
2093 /* Clear the "inserted" flag in all breakpoints and delete any
2094 breakpoints which should go away between runs of the program.
2096 Plus other such housekeeping that has to be done for breakpoints
2099 Note: this function gets called at the end of a run (by
2100 generic_mourn_inferior) and when a run begins (by
2101 init_wait_for_inferior). */
2106 breakpoint_init_inferior (enum inf_context context
)
2108 struct breakpoint
*b
, *temp
;
2109 struct bp_location
*bpt
, **bptp_tmp
;
2111 struct program_space
*pspace
= current_program_space
;
2113 /* If breakpoint locations are shared across processes, then there's
2115 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2118 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2120 if (bpt
->pspace
== pspace
2121 && bpt
->owner
->enable_state
!= bp_permanent
)
2125 ALL_BREAKPOINTS_SAFE (b
, temp
)
2127 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2133 case bp_watchpoint_scope
:
2135 /* If the call dummy breakpoint is at the entry point it will
2136 cause problems when the inferior is rerun, so we better
2139 Also get rid of scope breakpoints. */
2140 delete_breakpoint (b
);
2144 case bp_hardware_watchpoint
:
2145 case bp_read_watchpoint
:
2146 case bp_access_watchpoint
:
2148 /* Likewise for watchpoints on local expressions. */
2149 if (b
->exp_valid_block
!= NULL
)
2150 delete_breakpoint (b
);
2151 else if (context
== inf_starting
)
2153 /* Reset val field to force reread of starting value
2154 in insert_breakpoints. */
2156 value_free (b
->val
);
2166 /* Get rid of the moribund locations. */
2167 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bpt
); ++ix
)
2168 free_bp_location (bpt
);
2169 VEC_free (bp_location_p
, moribund_locations
);
2172 /* These functions concern about actual breakpoints inserted in the
2173 target --- to e.g. check if we need to do decr_pc adjustment or if
2174 we need to hop over the bkpt --- so we check for address space
2175 match, not program space. */
2177 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2178 exists at PC. It returns ordinary_breakpoint_here if it's an
2179 ordinary breakpoint, or permanent_breakpoint_here if it's a
2180 permanent breakpoint.
2181 - When continuing from a location with an ordinary breakpoint, we
2182 actually single step once before calling insert_breakpoints.
2183 - When continuing from a localion with a permanent breakpoint, we
2184 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2185 the target, to advance the PC past the breakpoint. */
2187 enum breakpoint_here
2188 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2190 struct bp_location
*bpt
, **bptp_tmp
;
2191 int any_breakpoint_here
= 0;
2193 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2195 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2196 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2199 if ((breakpoint_enabled (bpt
->owner
)
2200 || bpt
->owner
->enable_state
== bp_permanent
)
2201 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2204 if (overlay_debugging
2205 && section_is_overlay (bpt
->section
)
2206 && !section_is_mapped (bpt
->section
))
2207 continue; /* unmapped overlay -- can't be a match */
2208 else if (bpt
->owner
->enable_state
== bp_permanent
)
2209 return permanent_breakpoint_here
;
2211 any_breakpoint_here
= 1;
2215 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2218 /* Return true if there's a moribund breakpoint at PC. */
2221 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2223 struct bp_location
*loc
;
2226 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2227 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
2234 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2235 inserted using regular breakpoint_chain / bp_location array mechanism.
2236 This does not check for single-step breakpoints, which are
2237 inserted and removed using direct target manipulation. */
2240 regular_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2242 struct bp_location
*bpt
, **bptp_tmp
;
2244 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2246 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2247 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2251 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2254 if (overlay_debugging
2255 && section_is_overlay (bpt
->section
)
2256 && !section_is_mapped (bpt
->section
))
2257 continue; /* unmapped overlay -- can't be a match */
2265 /* Returns non-zero iff there's either regular breakpoint
2266 or a single step breakpoint inserted at PC. */
2269 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2271 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
2274 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2280 /* This function returns non-zero iff there is a software breakpoint
2284 software_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2286 struct bp_location
*bpt
, **bptp_tmp
;
2287 int any_breakpoint_here
= 0;
2289 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2291 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
2295 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2298 if (overlay_debugging
2299 && section_is_overlay (bpt
->section
)
2300 && !section_is_mapped (bpt
->section
))
2301 continue; /* unmapped overlay -- can't be a match */
2307 /* Also check for software single-step breakpoints. */
2308 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2314 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2315 PC is valid for process/thread PTID. */
2318 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
2321 struct bp_location
*bpt
, **bptp_tmp
;
2322 /* The thread and task IDs associated to PTID, computed lazily. */
2326 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2328 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2329 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2332 if (!breakpoint_enabled (bpt
->owner
)
2333 && bpt
->owner
->enable_state
!= bp_permanent
)
2336 if (!breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2340 if (bpt
->owner
->thread
!= -1)
2342 /* This is a thread-specific breakpoint. Check that ptid
2343 matches that thread. If thread hasn't been computed yet,
2344 it is now time to do so. */
2346 thread
= pid_to_thread_id (ptid
);
2347 if (bpt
->owner
->thread
!= thread
)
2351 if (bpt
->owner
->task
!= 0)
2353 /* This is a task-specific breakpoint. Check that ptid
2354 matches that task. If task hasn't been computed yet,
2355 it is now time to do so. */
2357 task
= ada_get_task_number (ptid
);
2358 if (bpt
->owner
->task
!= task
)
2362 if (overlay_debugging
2363 && section_is_overlay (bpt
->section
)
2364 && !section_is_mapped (bpt
->section
))
2365 continue; /* unmapped overlay -- can't be a match */
2374 /* bpstat stuff. External routines' interfaces are documented
2378 ep_is_catchpoint (struct breakpoint
*ep
)
2380 return (ep
->type
== bp_catchpoint
);
2384 bpstat_free (bpstat bs
)
2386 if (bs
->old_val
!= NULL
)
2387 value_free (bs
->old_val
);
2388 free_command_lines (&bs
->commands
);
2392 /* Clear a bpstat so that it says we are not at any breakpoint.
2393 Also free any storage that is part of a bpstat. */
2396 bpstat_clear (bpstat
*bsp
)
2413 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
2414 is part of the bpstat is copied as well. */
2417 bpstat_copy (bpstat bs
)
2421 bpstat retval
= NULL
;
2426 for (; bs
!= NULL
; bs
= bs
->next
)
2428 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
2429 memcpy (tmp
, bs
, sizeof (*tmp
));
2430 if (bs
->commands
!= NULL
)
2431 tmp
->commands
= copy_command_lines (bs
->commands
);
2432 if (bs
->old_val
!= NULL
)
2434 tmp
->old_val
= value_copy (bs
->old_val
);
2435 release_value (tmp
->old_val
);
2439 /* This is the first thing in the chain. */
2449 /* Find the bpstat associated with this breakpoint */
2452 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2457 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2459 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2465 /* Find a step_resume breakpoint associated with this bpstat.
2466 (If there are multiple step_resume bp's on the list, this function
2467 will arbitrarily pick one.)
2469 It is an error to use this function if BPSTAT doesn't contain a
2470 step_resume breakpoint.
2472 See wait_for_inferior's use of this function. */
2474 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2478 gdb_assert (bsp
!= NULL
);
2480 current_thread
= pid_to_thread_id (inferior_ptid
);
2482 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2484 if ((bsp
->breakpoint_at
!= NULL
)
2485 && (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
)
2486 && (bsp
->breakpoint_at
->owner
->thread
== current_thread
2487 || bsp
->breakpoint_at
->owner
->thread
== -1))
2488 return bsp
->breakpoint_at
->owner
;
2491 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2495 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2496 at. *BSP upon return is a bpstat which points to the remaining
2497 breakpoints stopped at (but which is not guaranteed to be good for
2498 anything but further calls to bpstat_num).
2499 Return 0 if passed a bpstat which does not indicate any breakpoints.
2500 Return -1 if stopped at a breakpoint that has been deleted since
2502 Return 1 otherwise. */
2505 bpstat_num (bpstat
*bsp
, int *num
)
2507 struct breakpoint
*b
;
2510 return 0; /* No more breakpoint values */
2512 /* We assume we'll never have several bpstats that
2513 correspond to a single breakpoint -- otherwise,
2514 this function might return the same number more
2515 than once and this will look ugly. */
2516 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2517 *bsp
= (*bsp
)->next
;
2519 return -1; /* breakpoint that's been deleted since */
2521 *num
= b
->number
; /* We have its number */
2525 /* Modify BS so that the actions will not be performed. */
2528 bpstat_clear_actions (bpstat bs
)
2530 for (; bs
!= NULL
; bs
= bs
->next
)
2532 free_command_lines (&bs
->commands
);
2533 if (bs
->old_val
!= NULL
)
2535 value_free (bs
->old_val
);
2541 /* Called when a command is about to proceed the inferior. */
2544 breakpoint_about_to_proceed (void)
2546 if (!ptid_equal (inferior_ptid
, null_ptid
))
2548 struct thread_info
*tp
= inferior_thread ();
2550 /* Allow inferior function calls in breakpoint commands to not
2551 interrupt the command list. When the call finishes
2552 successfully, the inferior will be standing at the same
2553 breakpoint as if nothing happened. */
2558 breakpoint_proceeded
= 1;
2561 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2563 cleanup_executing_breakpoints (void *ignore
)
2565 executing_breakpoint_commands
= 0;
2568 /* Execute all the commands associated with all the breakpoints at this
2569 location. Any of these commands could cause the process to proceed
2570 beyond this point, etc. We look out for such changes by checking
2571 the global "breakpoint_proceeded" after each command.
2573 Returns true if a breakpoint command resumed the inferior. In that
2574 case, it is the caller's responsibility to recall it again with the
2575 bpstat of the current thread. */
2578 bpstat_do_actions_1 (bpstat
*bsp
)
2581 struct cleanup
*old_chain
;
2584 /* Avoid endless recursion if a `source' command is contained
2586 if (executing_breakpoint_commands
)
2589 executing_breakpoint_commands
= 1;
2590 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2592 /* This pointer will iterate over the list of bpstat's. */
2595 breakpoint_proceeded
= 0;
2596 for (; bs
!= NULL
; bs
= bs
->next
)
2598 struct command_line
*cmd
;
2599 struct cleanup
*this_cmd_tree_chain
;
2601 /* Take ownership of the BSP's command tree, if it has one.
2603 The command tree could legitimately contain commands like
2604 'step' and 'next', which call clear_proceed_status, which
2605 frees stop_bpstat's command tree. To make sure this doesn't
2606 free the tree we're executing out from under us, we need to
2607 take ownership of the tree ourselves. Since a given bpstat's
2608 commands are only executed once, we don't need to copy it; we
2609 can clear the pointer in the bpstat, and make sure we free
2610 the tree when we're done. */
2613 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2617 execute_control_command (cmd
);
2619 if (breakpoint_proceeded
)
2625 /* We can free this command tree now. */
2626 do_cleanups (this_cmd_tree_chain
);
2628 if (breakpoint_proceeded
)
2630 if (target_can_async_p ())
2631 /* If we are in async mode, then the target might be still
2632 running, not stopped at any breakpoint, so nothing for
2633 us to do here -- just return to the event loop. */
2636 /* In sync mode, when execute_control_command returns
2637 we're already standing on the next breakpoint.
2638 Breakpoint commands for that stop were not run, since
2639 execute_command does not run breakpoint commands --
2640 only command_line_handler does, but that one is not
2641 involved in execution of breakpoint commands. So, we
2642 can now execute breakpoint commands. It should be
2643 noted that making execute_command do bpstat actions is
2644 not an option -- in this case we'll have recursive
2645 invocation of bpstat for each breakpoint with a
2646 command, and can easily blow up GDB stack. Instead, we
2647 return true, which will trigger the caller to recall us
2648 with the new stop_bpstat. */
2653 do_cleanups (old_chain
);
2658 bpstat_do_actions (void)
2660 /* Do any commands attached to breakpoint we are stopped at. */
2661 while (!ptid_equal (inferior_ptid
, null_ptid
)
2662 && target_has_execution
2663 && !is_exited (inferior_ptid
)
2664 && !is_executing (inferior_ptid
))
2665 /* Since in sync mode, bpstat_do_actions may resume the inferior,
2666 and only return when it is stopped at the next breakpoint, we
2667 keep doing breakpoint actions until it returns false to
2668 indicate the inferior was not resumed. */
2669 if (!bpstat_do_actions_1 (&inferior_thread ()->stop_bpstat
))
2673 /* Print out the (old or new) value associated with a watchpoint. */
2676 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2679 fprintf_unfiltered (stream
, _("<unreadable>"));
2682 struct value_print_options opts
;
2683 get_user_print_options (&opts
);
2684 value_print (val
, stream
, &opts
);
2688 /* This is the normal print function for a bpstat. In the future,
2689 much of this logic could (should?) be moved to bpstat_stop_status,
2690 by having it set different print_it values.
2692 Current scheme: When we stop, bpstat_print() is called. It loops
2693 through the bpstat list of things causing this stop, calling the
2694 print_bp_stop_message function on each one. The behavior of the
2695 print_bp_stop_message function depends on the print_it field of
2696 bpstat. If such field so indicates, call this function here.
2698 Return values from this routine (ultimately used by bpstat_print()
2699 and normal_stop() to decide what to do):
2700 PRINT_NOTHING: Means we already printed all we needed to print,
2701 don't print anything else.
2702 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2703 that something to be followed by a location.
2704 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2705 that something to be followed by a location.
2706 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2709 static enum print_stop_action
2710 print_it_typical (bpstat bs
)
2712 struct cleanup
*old_chain
;
2713 struct breakpoint
*b
;
2714 const struct bp_location
*bl
;
2715 struct ui_stream
*stb
;
2717 enum print_stop_action result
;
2719 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2720 which has since been deleted. */
2721 if (bs
->breakpoint_at
== NULL
)
2722 return PRINT_UNKNOWN
;
2723 bl
= bs
->breakpoint_at
;
2726 stb
= ui_out_stream_new (uiout
);
2727 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2732 case bp_hardware_breakpoint
:
2733 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2734 if (bl
->address
!= bl
->requested_address
)
2735 breakpoint_adjustment_warning (bl
->requested_address
,
2738 annotate_breakpoint (b
->number
);
2740 ui_out_text (uiout
, "\nTemporary breakpoint ");
2742 ui_out_text (uiout
, "\nBreakpoint ");
2743 if (ui_out_is_mi_like_p (uiout
))
2745 ui_out_field_string (uiout
, "reason",
2746 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2747 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2749 ui_out_field_int (uiout
, "bkptno", b
->number
);
2750 ui_out_text (uiout
, ", ");
2751 result
= PRINT_SRC_AND_LOC
;
2754 case bp_shlib_event
:
2755 /* Did we stop because the user set the stop_on_solib_events
2756 variable? (If so, we report this as a generic, "Stopped due
2757 to shlib event" message.) */
2758 printf_filtered (_("Stopped due to shared library event\n"));
2759 result
= PRINT_NOTHING
;
2762 case bp_thread_event
:
2763 /* Not sure how we will get here.
2764 GDB should not stop for these breakpoints. */
2765 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2766 result
= PRINT_NOTHING
;
2769 case bp_overlay_event
:
2770 /* By analogy with the thread event, GDB should not stop for these. */
2771 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2772 result
= PRINT_NOTHING
;
2775 case bp_longjmp_master
:
2776 /* These should never be enabled. */
2777 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
2778 result
= PRINT_NOTHING
;
2782 case bp_hardware_watchpoint
:
2783 annotate_watchpoint (b
->number
);
2784 if (ui_out_is_mi_like_p (uiout
))
2787 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2789 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2790 ui_out_text (uiout
, "\nOld value = ");
2791 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2792 ui_out_field_stream (uiout
, "old", stb
);
2793 ui_out_text (uiout
, "\nNew value = ");
2794 watchpoint_value_print (b
->val
, stb
->stream
);
2795 ui_out_field_stream (uiout
, "new", stb
);
2796 ui_out_text (uiout
, "\n");
2797 /* More than one watchpoint may have been triggered. */
2798 result
= PRINT_UNKNOWN
;
2801 case bp_read_watchpoint
:
2802 if (ui_out_is_mi_like_p (uiout
))
2805 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2807 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2808 ui_out_text (uiout
, "\nValue = ");
2809 watchpoint_value_print (b
->val
, stb
->stream
);
2810 ui_out_field_stream (uiout
, "value", stb
);
2811 ui_out_text (uiout
, "\n");
2812 result
= PRINT_UNKNOWN
;
2815 case bp_access_watchpoint
:
2816 if (bs
->old_val
!= NULL
)
2818 annotate_watchpoint (b
->number
);
2819 if (ui_out_is_mi_like_p (uiout
))
2822 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2824 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2825 ui_out_text (uiout
, "\nOld value = ");
2826 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2827 ui_out_field_stream (uiout
, "old", stb
);
2828 ui_out_text (uiout
, "\nNew value = ");
2833 if (ui_out_is_mi_like_p (uiout
))
2836 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2837 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2838 ui_out_text (uiout
, "\nValue = ");
2840 watchpoint_value_print (b
->val
, stb
->stream
);
2841 ui_out_field_stream (uiout
, "new", stb
);
2842 ui_out_text (uiout
, "\n");
2843 result
= PRINT_UNKNOWN
;
2846 /* Fall through, we don't deal with these types of breakpoints
2850 if (ui_out_is_mi_like_p (uiout
))
2853 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2854 result
= PRINT_UNKNOWN
;
2858 if (ui_out_is_mi_like_p (uiout
))
2861 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2862 result
= PRINT_UNKNOWN
;
2867 case bp_longjmp_resume
:
2868 case bp_step_resume
:
2869 case bp_watchpoint_scope
:
2874 result
= PRINT_UNKNOWN
;
2878 do_cleanups (old_chain
);
2882 /* Generic routine for printing messages indicating why we
2883 stopped. The behavior of this function depends on the value
2884 'print_it' in the bpstat structure. Under some circumstances we
2885 may decide not to print anything here and delegate the task to
2888 static enum print_stop_action
2889 print_bp_stop_message (bpstat bs
)
2891 switch (bs
->print_it
)
2894 /* Nothing should be printed for this bpstat entry. */
2895 return PRINT_UNKNOWN
;
2899 /* We still want to print the frame, but we already printed the
2900 relevant messages. */
2901 return PRINT_SRC_AND_LOC
;
2904 case print_it_normal
:
2906 const struct bp_location
*bl
= bs
->breakpoint_at
;
2907 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2909 /* Normal case. Call the breakpoint's print_it method, or
2910 print_it_typical. */
2911 /* FIXME: how breakpoint can ever be NULL here? */
2912 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2913 return b
->ops
->print_it (b
);
2915 return print_it_typical (bs
);
2920 internal_error (__FILE__
, __LINE__
,
2921 _("print_bp_stop_message: unrecognized enum value"));
2926 /* Print a message indicating what happened. This is called from
2927 normal_stop(). The input to this routine is the head of the bpstat
2928 list - a list of the eventpoints that caused this stop. This
2929 routine calls the generic print routine for printing a message
2930 about reasons for stopping. This will print (for example) the
2931 "Breakpoint n," part of the output. The return value of this
2934 PRINT_UNKNOWN: Means we printed nothing
2935 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2936 code to print the location. An example is
2937 "Breakpoint 1, " which should be followed by
2939 PRINT_SRC_ONLY: Means we printed something, but there is no need
2940 to also print the location part of the message.
2941 An example is the catch/throw messages, which
2942 don't require a location appended to the end.
2943 PRINT_NOTHING: We have done some printing and we don't need any
2944 further info to be printed.*/
2946 enum print_stop_action
2947 bpstat_print (bpstat bs
)
2951 /* Maybe another breakpoint in the chain caused us to stop.
2952 (Currently all watchpoints go on the bpstat whether hit or not.
2953 That probably could (should) be changed, provided care is taken
2954 with respect to bpstat_explains_signal). */
2955 for (; bs
; bs
= bs
->next
)
2957 val
= print_bp_stop_message (bs
);
2958 if (val
== PRINT_SRC_ONLY
2959 || val
== PRINT_SRC_AND_LOC
2960 || val
== PRINT_NOTHING
)
2964 /* We reached the end of the chain, or we got a null BS to start
2965 with and nothing was printed. */
2966 return PRINT_UNKNOWN
;
2969 /* Evaluate the expression EXP and return 1 if value is zero.
2970 This is used inside a catch_errors to evaluate the breakpoint condition.
2971 The argument is a "struct expression *" that has been cast to char * to
2972 make it pass through catch_errors. */
2975 breakpoint_cond_eval (void *exp
)
2977 struct value
*mark
= value_mark ();
2978 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2979 value_free_to_mark (mark
);
2983 /* Allocate a new bpstat and chain it to the current one. */
2986 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2990 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2992 bs
->breakpoint_at
= bl
;
2993 /* If the condition is false, etc., don't do the commands. */
2994 bs
->commands
= NULL
;
2996 bs
->print_it
= print_it_normal
;
3000 /* The target has stopped with waitstatus WS. Check if any hardware
3001 watchpoints have triggered, according to the target. */
3004 watchpoints_triggered (struct target_waitstatus
*ws
)
3006 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3008 struct breakpoint
*b
;
3010 if (!stopped_by_watchpoint
)
3012 /* We were not stopped by a watchpoint. Mark all watchpoints
3013 as not triggered. */
3015 if (b
->type
== bp_hardware_watchpoint
3016 || b
->type
== bp_read_watchpoint
3017 || b
->type
== bp_access_watchpoint
)
3018 b
->watchpoint_triggered
= watch_triggered_no
;
3023 if (!target_stopped_data_address (¤t_target
, &addr
))
3025 /* We were stopped by a watchpoint, but we don't know where.
3026 Mark all watchpoints as unknown. */
3028 if (b
->type
== bp_hardware_watchpoint
3029 || b
->type
== bp_read_watchpoint
3030 || b
->type
== bp_access_watchpoint
)
3031 b
->watchpoint_triggered
= watch_triggered_unknown
;
3033 return stopped_by_watchpoint
;
3036 /* The target could report the data address. Mark watchpoints
3037 affected by this data address as triggered, and all others as not
3041 if (b
->type
== bp_hardware_watchpoint
3042 || b
->type
== bp_read_watchpoint
3043 || b
->type
== bp_access_watchpoint
)
3045 struct bp_location
*loc
;
3048 b
->watchpoint_triggered
= watch_triggered_no
;
3049 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3050 /* Exact match not required. Within range is
3052 if (target_watchpoint_addr_within_range (¤t_target
,
3056 b
->watchpoint_triggered
= watch_triggered_yes
;
3064 /* Possible return values for watchpoint_check (this can't be an enum
3065 because of check_errors). */
3066 /* The watchpoint has been deleted. */
3067 #define WP_DELETED 1
3068 /* The value has changed. */
3069 #define WP_VALUE_CHANGED 2
3070 /* The value has not changed. */
3071 #define WP_VALUE_NOT_CHANGED 3
3073 #define BP_TEMPFLAG 1
3074 #define BP_HARDWAREFLAG 2
3076 /* Check watchpoint condition. */
3079 watchpoint_check (void *p
)
3081 bpstat bs
= (bpstat
) p
;
3082 struct breakpoint
*b
;
3083 struct frame_info
*fr
;
3084 int within_current_scope
;
3086 b
= bs
->breakpoint_at
->owner
;
3088 if (b
->exp_valid_block
== NULL
)
3089 within_current_scope
= 1;
3092 struct frame_info
*frame
= get_current_frame ();
3093 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3094 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3096 fr
= frame_find_by_id (b
->watchpoint_frame
);
3097 within_current_scope
= (fr
!= NULL
);
3099 /* If we've gotten confused in the unwinder, we might have
3100 returned a frame that can't describe this variable. */
3101 if (within_current_scope
)
3103 struct symbol
*function
;
3105 function
= get_frame_function (fr
);
3106 if (function
== NULL
3107 || !contained_in (b
->exp_valid_block
,
3108 SYMBOL_BLOCK_VALUE (function
)))
3109 within_current_scope
= 0;
3112 /* in_function_epilogue_p() returns a non-zero value if we're still
3113 in the function but the stack frame has already been invalidated.
3114 Since we can't rely on the values of local variables after the
3115 stack has been destroyed, we are treating the watchpoint in that
3116 state as `not changed' without further checking. Don't mark
3117 watchpoints as changed if the current frame is in an epilogue -
3118 even if they are in some other frame, our view of the stack
3119 is likely to be wrong. */
3120 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3121 return WP_VALUE_NOT_CHANGED
;
3123 if (within_current_scope
)
3124 /* If we end up stopping, the current frame will get selected
3125 in normal_stop. So this call to select_frame won't affect
3130 if (within_current_scope
)
3132 /* We use value_{,free_to_}mark because it could be a
3133 *long* time before we return to the command level and
3134 call free_all_values. We can't call free_all_values because
3135 we might be in the middle of evaluating a function call. */
3137 struct value
*mark
= value_mark ();
3138 struct value
*new_val
;
3140 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
3141 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3142 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
3144 if (new_val
!= NULL
)
3146 release_value (new_val
);
3147 value_free_to_mark (mark
);
3149 bs
->old_val
= b
->val
;
3152 /* We will stop here */
3153 return WP_VALUE_CHANGED
;
3157 /* Nothing changed, don't do anything. */
3158 value_free_to_mark (mark
);
3159 /* We won't stop here */
3160 return WP_VALUE_NOT_CHANGED
;
3165 /* This seems like the only logical thing to do because
3166 if we temporarily ignored the watchpoint, then when
3167 we reenter the block in which it is valid it contains
3168 garbage (in the case of a function, it may have two
3169 garbage values, one before and one after the prologue).
3170 So we can't even detect the first assignment to it and
3171 watch after that (since the garbage may or may not equal
3172 the first value assigned). */
3173 /* We print all the stop information in print_it_typical(), but
3174 in this case, by the time we call print_it_typical() this bp
3175 will be deleted already. So we have no choice but print the
3176 information here. */
3177 if (ui_out_is_mi_like_p (uiout
))
3179 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3180 ui_out_text (uiout
, "\nWatchpoint ");
3181 ui_out_field_int (uiout
, "wpnum", b
->number
);
3182 ui_out_text (uiout
, " deleted because the program has left the block in\n\
3183 which its expression is valid.\n");
3185 if (b
->related_breakpoint
)
3186 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3187 b
->disposition
= disp_del_at_next_stop
;
3193 /* Return true if it looks like target has stopped due to hitting
3194 breakpoint location BL. This function does not check if we
3195 should stop, only if BL explains the stop. */
3197 bpstat_check_location (const struct bp_location
*bl
,
3198 struct address_space
*aspace
, CORE_ADDR bp_addr
)
3200 struct breakpoint
*b
= bl
->owner
;
3202 if (b
->type
!= bp_watchpoint
3203 && b
->type
!= bp_hardware_watchpoint
3204 && b
->type
!= bp_read_watchpoint
3205 && b
->type
!= bp_access_watchpoint
3206 && b
->type
!= bp_hardware_breakpoint
3207 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
3209 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
3212 if (overlay_debugging
/* unmapped overlay section */
3213 && section_is_overlay (bl
->section
)
3214 && !section_is_mapped (bl
->section
))
3218 /* Continuable hardware watchpoints are treated as non-existent if the
3219 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3220 some data address). Otherwise gdb won't stop on a break instruction
3221 in the code (not from a breakpoint) when a hardware watchpoint has
3222 been defined. Also skip watchpoints which we know did not trigger
3223 (did not match the data address). */
3225 if ((b
->type
== bp_hardware_watchpoint
3226 || b
->type
== bp_read_watchpoint
3227 || b
->type
== bp_access_watchpoint
)
3228 && b
->watchpoint_triggered
== watch_triggered_no
)
3231 if (b
->type
== bp_hardware_breakpoint
)
3233 if (bl
->address
!= bp_addr
)
3235 if (overlay_debugging
/* unmapped overlay section */
3236 && section_is_overlay (bl
->section
)
3237 && !section_is_mapped (bl
->section
))
3241 if (b
->type
== bp_catchpoint
)
3243 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
3244 if (!b
->ops
->breakpoint_hit (b
))
3251 /* If BS refers to a watchpoint, determine if the watched values
3252 has actually changed, and we should stop. If not, set BS->stop
3255 bpstat_check_watchpoint (bpstat bs
)
3257 const struct bp_location
*bl
= bs
->breakpoint_at
;
3258 struct breakpoint
*b
= bl
->owner
;
3260 if (b
->type
== bp_watchpoint
3261 || b
->type
== bp_read_watchpoint
3262 || b
->type
== bp_access_watchpoint
3263 || b
->type
== bp_hardware_watchpoint
)
3267 int must_check_value
= 0;
3269 if (b
->type
== bp_watchpoint
)
3270 /* For a software watchpoint, we must always check the
3272 must_check_value
= 1;
3273 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3274 /* We have a hardware watchpoint (read, write, or access)
3275 and the target earlier reported an address watched by
3277 must_check_value
= 1;
3278 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3279 && b
->type
== bp_hardware_watchpoint
)
3280 /* We were stopped by a hardware watchpoint, but the target could
3281 not report the data address. We must check the watchpoint's
3282 value. Access and read watchpoints are out of luck; without
3283 a data address, we can't figure it out. */
3284 must_check_value
= 1;
3286 if (must_check_value
)
3288 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
3290 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3291 int e
= catch_errors (watchpoint_check
, bs
, message
,
3293 do_cleanups (cleanups
);
3297 /* We've already printed what needs to be printed. */
3298 bs
->print_it
= print_it_done
;
3301 case WP_VALUE_CHANGED
:
3302 if (b
->type
== bp_read_watchpoint
)
3304 /* Don't stop: read watchpoints shouldn't fire if
3305 the value has changed. This is for targets
3306 which cannot set read-only watchpoints. */
3307 bs
->print_it
= print_it_noop
;
3311 case WP_VALUE_NOT_CHANGED
:
3312 if (b
->type
== bp_hardware_watchpoint
3313 || b
->type
== bp_watchpoint
)
3315 /* Don't stop: write watchpoints shouldn't fire if
3316 the value hasn't changed. */
3317 bs
->print_it
= print_it_noop
;
3325 /* Error from catch_errors. */
3326 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
3327 if (b
->related_breakpoint
)
3328 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3329 b
->disposition
= disp_del_at_next_stop
;
3330 /* We've already printed what needs to be printed. */
3331 bs
->print_it
= print_it_done
;
3335 else /* must_check_value == 0 */
3337 /* This is a case where some watchpoint(s) triggered, but
3338 not at the address of this watchpoint, or else no
3339 watchpoint triggered after all. So don't print
3340 anything for this watchpoint. */
3341 bs
->print_it
= print_it_noop
;
3348 /* Check conditions (condition proper, frame, thread and ignore count)
3349 of breakpoint referred to by BS. If we should not stop for this
3350 breakpoint, set BS->stop to 0. */
3352 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
3354 int thread_id
= pid_to_thread_id (ptid
);
3355 const struct bp_location
*bl
= bs
->breakpoint_at
;
3356 struct breakpoint
*b
= bl
->owner
;
3358 if (frame_id_p (b
->frame_id
)
3359 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
3363 int value_is_zero
= 0;
3365 /* If this is a scope breakpoint, mark the associated
3366 watchpoint as triggered so that we will handle the
3367 out-of-scope event. We'll get to the watchpoint next
3369 if (b
->type
== bp_watchpoint_scope
)
3370 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
3372 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
3374 /* We use value_mark and value_free_to_mark because it could
3375 be a long time before we return to the command level and
3376 call free_all_values. We can't call free_all_values
3377 because we might be in the middle of evaluating a
3379 struct value
*mark
= value_mark ();
3381 /* Need to select the frame, with all that implies so that
3382 the conditions will have the right context. Because we
3383 use the frame, we will not see an inlined function's
3384 variables when we arrive at a breakpoint at the start
3385 of the inlined function; the current frame will be the
3387 select_frame (get_current_frame ());
3389 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
3390 "Error in testing breakpoint condition:\n",
3392 /* FIXME-someday, should give breakpoint # */
3393 value_free_to_mark (mark
);
3395 if (bl
->cond
&& value_is_zero
)
3399 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
3403 else if (b
->ignore_count
> 0)
3406 annotate_ignore_count_change ();
3408 /* Increase the hit count even though we don't
3416 /* Get a bpstat associated with having just stopped at address
3417 BP_ADDR in thread PTID.
3419 Determine whether we stopped at a breakpoint, etc, or whether we
3420 don't understand this stop. Result is a chain of bpstat's such that:
3422 if we don't understand the stop, the result is a null pointer.
3424 if we understand why we stopped, the result is not null.
3426 Each element of the chain refers to a particular breakpoint or
3427 watchpoint at which we have stopped. (We may have stopped for
3428 several reasons concurrently.)
3430 Each element of the chain has valid next, breakpoint_at,
3431 commands, FIXME??? fields. */
3434 bpstat_stop_status (struct address_space
*aspace
,
3435 CORE_ADDR bp_addr
, ptid_t ptid
)
3437 struct breakpoint
*b
= NULL
;
3438 struct bp_location
*bl
, **blp_tmp
;
3439 struct bp_location
*loc
;
3440 /* Root of the chain of bpstat's */
3441 struct bpstats root_bs
[1];
3442 /* Pointer to the last thing in the chain currently. */
3443 bpstat bs
= root_bs
;
3445 int need_remove_insert
, update_locations
= 0;
3447 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3451 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3454 /* For hardware watchpoints, we look only at the first location.
3455 The watchpoint_check function will work on entire expression,
3456 not the individual locations. For read watchopints, the
3457 watchpoints_triggered function have checked all locations
3459 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3462 if (!bpstat_check_location (bl
, aspace
, bp_addr
))
3465 /* Come here if it's a watchpoint, or if the break address matches */
3467 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3469 /* Assume we stop. Should we find watchpoint that is not actually
3470 triggered, or if condition of breakpoint is false, we'll reset
3475 bpstat_check_watchpoint (bs
);
3479 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3480 || b
->type
== bp_longjmp_master
)
3481 /* We do not stop for these. */
3484 bpstat_check_breakpoint_conditions (bs
, ptid
);
3488 if (b
->enable_state
!= bp_disabled
)
3491 /* We will stop here */
3492 if (b
->disposition
== disp_disable
)
3494 if (b
->enable_state
!= bp_permanent
)
3495 b
->enable_state
= bp_disabled
;
3496 update_locations
= 1;
3500 bs
->commands
= b
->commands
;
3502 && (strcmp ("silent", bs
->commands
->line
) == 0
3503 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3505 bs
->commands
= bs
->commands
->next
;
3508 bs
->commands
= copy_command_lines (bs
->commands
);
3511 /* Print nothing for this entry if we dont stop or if we dont print. */
3512 if (bs
->stop
== 0 || bs
->print
== 0)
3513 bs
->print_it
= print_it_noop
;
3516 /* Delay this call which would break the ALL_BP_LOCATIONS iteration above. */
3517 if (update_locations
)
3518 update_global_location_list (0);
3520 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
3522 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
3525 bs
= bpstat_alloc (loc
, bs
);
3526 /* For hits of moribund locations, we should just proceed. */
3529 bs
->print_it
= print_it_noop
;
3533 bs
->next
= NULL
; /* Terminate the chain */
3534 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3536 /* If we aren't stopping, the value of some hardware watchpoint may
3537 not have changed, but the intermediate memory locations we are
3538 watching may have. Don't bother if we're stopping; this will get
3540 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3544 need_remove_insert
= 0;
3546 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3548 && bs
->breakpoint_at
->owner
3549 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3550 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3551 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3553 /* remove/insert can invalidate bs->breakpoint_at, if this
3554 location is no longer used by the watchpoint. Prevent
3555 further code from trying to use it. */
3556 bs
->breakpoint_at
= NULL
;
3557 need_remove_insert
= 1;
3560 if (need_remove_insert
)
3562 remove_breakpoints ();
3563 insert_breakpoints ();
3566 return root_bs
->next
;
3569 /* Tell what to do about this bpstat. */
3571 bpstat_what (bpstat bs
)
3573 /* Classify each bpstat as one of the following. */
3576 /* This bpstat element has no effect on the main_action. */
3579 /* There was a watchpoint, stop but don't print. */
3582 /* There was a watchpoint, stop and print. */
3585 /* There was a breakpoint but we're not stopping. */
3588 /* There was a breakpoint, stop but don't print. */
3591 /* There was a breakpoint, stop and print. */
3594 /* We hit the longjmp breakpoint. */
3597 /* We hit the longjmp_resume breakpoint. */
3600 /* We hit the step_resume breakpoint. */
3603 /* We hit the shared library event breakpoint. */
3606 /* We hit the jit event breakpoint. */
3609 /* This is just used to count how many enums there are. */
3613 /* Here is the table which drives this routine. So that we can
3614 format it pretty, we define some abbreviations for the
3615 enum bpstat_what codes. */
3616 #define kc BPSTAT_WHAT_KEEP_CHECKING
3617 #define ss BPSTAT_WHAT_STOP_SILENT
3618 #define sn BPSTAT_WHAT_STOP_NOISY
3619 #define sgl BPSTAT_WHAT_SINGLE
3620 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3621 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3622 #define sr BPSTAT_WHAT_STEP_RESUME
3623 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3624 #define jit BPSTAT_WHAT_CHECK_JIT
3626 /* "Can't happen." Might want to print an error message.
3627 abort() is not out of the question, but chances are GDB is just
3628 a bit confused, not unusable. */
3629 #define err BPSTAT_WHAT_STOP_NOISY
3631 /* Given an old action and a class, come up with a new action. */
3632 /* One interesting property of this table is that wp_silent is the same
3633 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3634 after stopping, the check for whether to step over a breakpoint
3635 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3636 reference to how we stopped. We retain separate wp_silent and
3637 bp_silent codes in case we want to change that someday.
3639 Another possibly interesting property of this table is that
3640 there's a partial ordering, priority-like, of the actions. Once
3641 you've decided that some action is appropriate, you'll never go
3642 back and decide something of a lower priority is better. The
3645 kc < jit clr sgl shl slr sn sr ss
3646 sgl < jit shl slr sn sr ss
3647 slr < jit err shl sn sr ss
3648 clr < jit err shl sn sr ss
3655 What I think this means is that we don't need a damned table
3656 here. If you just put the rows and columns in the right order,
3657 it'd look awfully regular. We could simply walk the bpstat list
3658 and choose the highest priority action we find, with a little
3659 logic to handle the 'err' cases. */
3661 /* step_resume entries: a step resume breakpoint overrides another
3662 breakpoint of signal handling (see comment in wait_for_inferior
3663 at where we set the step_resume breakpoint). */
3665 static const enum bpstat_what_main_action
3666 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3669 /* kc ss sn sgl slr clr sr shl jit */
3670 /* no_effect */ {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
, jit
},
3671 /* wp_silent */ {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, jit
},
3672 /* wp_noisy */ {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, jit
},
3673 /* bp_nostop */ {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
, jit
},
3674 /* bp_silent */ {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, jit
},
3675 /* bp_noisy */ {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, jit
},
3676 /* long_jump */ {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
, jit
},
3677 /* long_resume */ {clr
, ss
, sn
, err
, err
, err
, sr
, shl
, jit
},
3678 /* step_resume */ {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3679 /* shlib */ {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shl
},
3680 /* jit_event */ {jit
, jit
, jit
, jit
, jit
, jit
, sr
, jit
, jit
}
3694 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3695 struct bpstat_what retval
;
3697 retval
.call_dummy
= 0;
3698 for (; bs
!= NULL
; bs
= bs
->next
)
3700 enum class bs_class
= no_effect
;
3701 if (bs
->breakpoint_at
== NULL
)
3702 /* I suspect this can happen if it was a momentary breakpoint
3703 which has since been deleted. */
3705 if (bs
->breakpoint_at
->owner
== NULL
)
3706 bs_class
= bp_nostop
;
3708 switch (bs
->breakpoint_at
->owner
->type
)
3714 case bp_hardware_breakpoint
:
3720 bs_class
= bp_noisy
;
3722 bs_class
= bp_silent
;
3725 bs_class
= bp_nostop
;
3728 case bp_hardware_watchpoint
:
3729 case bp_read_watchpoint
:
3730 case bp_access_watchpoint
:
3734 bs_class
= wp_noisy
;
3736 bs_class
= wp_silent
;
3739 /* There was a watchpoint, but we're not stopping.
3740 This requires no further action. */
3741 bs_class
= no_effect
;
3744 bs_class
= long_jump
;
3746 case bp_longjmp_resume
:
3747 bs_class
= long_resume
;
3749 case bp_step_resume
:
3752 bs_class
= step_resume
;
3755 /* It is for the wrong frame. */
3756 bs_class
= bp_nostop
;
3758 case bp_watchpoint_scope
:
3759 bs_class
= bp_nostop
;
3761 case bp_shlib_event
:
3762 bs_class
= shlib_event
;
3765 bs_class
= jit_event
;
3767 case bp_thread_event
:
3768 case bp_overlay_event
:
3769 case bp_longjmp_master
:
3770 bs_class
= bp_nostop
;
3776 bs_class
= bp_noisy
;
3778 bs_class
= bp_silent
;
3781 /* There was a catchpoint, but we're not stopping.
3782 This requires no further action. */
3783 bs_class
= no_effect
;
3786 /* Make sure the action is stop (silent or noisy),
3787 so infrun.c pops the dummy frame. */
3788 bs_class
= bp_silent
;
3789 retval
.call_dummy
= 1;
3792 /* Tracepoint hits should not be reported back to GDB, and
3793 if one got through somehow, it should have been filtered
3795 internal_error (__FILE__
, __LINE__
,
3796 _("bpstat_what: bp_tracepoint encountered"));
3799 current_action
= table
[(int) bs_class
][(int) current_action
];
3801 retval
.main_action
= current_action
;
3805 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3806 without hardware support). This isn't related to a specific bpstat,
3807 just to things like whether watchpoints are set. */
3810 bpstat_should_step (void)
3812 struct breakpoint
*b
;
3814 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
3820 bpstat_causes_stop (bpstat bs
)
3822 for (; bs
!= NULL
; bs
= bs
->next
)
3831 static void print_breakpoint_location (struct breakpoint
*b
,
3832 struct bp_location
*loc
,
3834 struct ui_stream
*stb
)
3836 struct cleanup
*old_chain
= save_current_program_space ();
3839 set_current_program_space (loc
->pspace
);
3844 = find_pc_sect_function (loc
->address
, loc
->section
);
3847 ui_out_text (uiout
, "in ");
3848 ui_out_field_string (uiout
, "func",
3849 SYMBOL_PRINT_NAME (sym
));
3850 ui_out_wrap_hint (uiout
, wrap_indent
);
3851 ui_out_text (uiout
, " at ");
3853 ui_out_field_string (uiout
, "file", b
->source_file
);
3854 ui_out_text (uiout
, ":");
3856 if (ui_out_is_mi_like_p (uiout
))
3858 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3859 char *fullname
= symtab_to_fullname (sal
.symtab
);
3862 ui_out_field_string (uiout
, "fullname", fullname
);
3865 ui_out_field_int (uiout
, "line", b
->line_number
);
3869 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3873 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3874 ui_out_field_stream (uiout
, "at", stb
);
3877 do_cleanups (old_chain
);
3880 /* Print B to gdb_stdout. */
3882 print_one_breakpoint_location (struct breakpoint
*b
,
3883 struct bp_location
*loc
,
3885 struct bp_location
**last_loc
,
3886 int print_address_bits
,
3889 struct command_line
*l
;
3891 struct ep_type_description
3896 static struct ep_type_description bptypes
[] =
3898 {bp_none
, "?deleted?"},
3899 {bp_breakpoint
, "breakpoint"},
3900 {bp_hardware_breakpoint
, "hw breakpoint"},
3901 {bp_until
, "until"},
3902 {bp_finish
, "finish"},
3903 {bp_watchpoint
, "watchpoint"},
3904 {bp_hardware_watchpoint
, "hw watchpoint"},
3905 {bp_read_watchpoint
, "read watchpoint"},
3906 {bp_access_watchpoint
, "acc watchpoint"},
3907 {bp_longjmp
, "longjmp"},
3908 {bp_longjmp_resume
, "longjmp resume"},
3909 {bp_step_resume
, "step resume"},
3910 {bp_watchpoint_scope
, "watchpoint scope"},
3911 {bp_call_dummy
, "call dummy"},
3912 {bp_shlib_event
, "shlib events"},
3913 {bp_thread_event
, "thread events"},
3914 {bp_overlay_event
, "overlay events"},
3915 {bp_longjmp_master
, "longjmp master"},
3916 {bp_catchpoint
, "catchpoint"},
3917 {bp_tracepoint
, "tracepoint"},
3918 {bp_jit_event
, "jit events"},
3921 static char bpenables
[] = "nynny";
3922 char wrap_indent
[80];
3923 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3924 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3925 struct cleanup
*bkpt_chain
;
3927 int header_of_multiple
= 0;
3928 int part_of_multiple
= (loc
!= NULL
);
3929 struct value_print_options opts
;
3931 get_user_print_options (&opts
);
3933 gdb_assert (!loc
|| loc_number
!= 0);
3934 /* See comment in print_one_breakpoint concerning
3935 treatment of breakpoints with single disabled
3939 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3940 header_of_multiple
= 1;
3945 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3949 if (part_of_multiple
)
3952 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3953 ui_out_field_string (uiout
, "number", formatted
);
3958 ui_out_field_int (uiout
, "number", b
->number
);
3963 if (part_of_multiple
)
3964 ui_out_field_skip (uiout
, "type");
3967 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3968 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3969 internal_error (__FILE__
, __LINE__
,
3970 _("bptypes table does not describe type #%d."),
3972 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3977 if (part_of_multiple
)
3978 ui_out_field_skip (uiout
, "disp");
3980 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3985 if (part_of_multiple
)
3986 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3988 ui_out_field_fmt (uiout
, "enabled", "%c",
3989 bpenables
[(int) b
->enable_state
]);
3990 ui_out_spaces (uiout
, 2);
3994 strcpy (wrap_indent
, " ");
3995 if (opts
.addressprint
)
3997 if (print_address_bits
<= 32)
3998 strcat (wrap_indent
, " ");
4000 strcat (wrap_indent
, " ");
4003 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4005 /* Although the print_one can possibly print
4006 all locations, calling it here is not likely
4007 to get any nice result. So, make sure there's
4008 just one location. */
4009 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4010 b
->ops
->print_one (b
, last_loc
);
4016 internal_error (__FILE__
, __LINE__
,
4017 _("print_one_breakpoint: bp_none encountered\n"));
4021 case bp_hardware_watchpoint
:
4022 case bp_read_watchpoint
:
4023 case bp_access_watchpoint
:
4024 /* Field 4, the address, is omitted (which makes the columns
4025 not line up too nicely with the headers, but the effect
4026 is relatively readable). */
4027 if (opts
.addressprint
)
4028 ui_out_field_skip (uiout
, "addr");
4030 ui_out_field_string (uiout
, "what", b
->exp_string
);
4034 case bp_hardware_breakpoint
:
4038 case bp_longjmp_resume
:
4039 case bp_step_resume
:
4040 case bp_watchpoint_scope
:
4042 case bp_shlib_event
:
4043 case bp_thread_event
:
4044 case bp_overlay_event
:
4045 case bp_longjmp_master
:
4048 if (opts
.addressprint
)
4051 if (header_of_multiple
)
4052 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4053 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4054 ui_out_field_string (uiout
, "addr", "<PENDING>");
4056 ui_out_field_core_addr (uiout
, "addr",
4057 loc
->gdbarch
, loc
->address
);
4060 if (!header_of_multiple
)
4061 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
4068 /* For backward compatibility, don't display inferiors unless there
4071 && !header_of_multiple
4073 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4074 && (number_of_program_spaces () > 1
4075 || number_of_inferiors () > 1)
4076 && loc
->owner
->type
!= bp_catchpoint
)))
4078 struct inferior
*inf
;
4081 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4083 if (inf
->pspace
== loc
->pspace
)
4088 ui_out_text (uiout
, " inf ");
4091 ui_out_text (uiout
, ", ");
4092 ui_out_text (uiout
, plongest (inf
->num
));
4097 if (!part_of_multiple
)
4099 if (b
->thread
!= -1)
4101 /* FIXME: This seems to be redundant and lost here; see the
4102 "stop only in" line a little further down. */
4103 ui_out_text (uiout
, " thread ");
4104 ui_out_field_int (uiout
, "thread", b
->thread
);
4106 else if (b
->task
!= 0)
4108 ui_out_text (uiout
, " task ");
4109 ui_out_field_int (uiout
, "task", b
->task
);
4113 ui_out_text (uiout
, "\n");
4115 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4118 ui_out_text (uiout
, "\tstop only in stack frame at ");
4119 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4121 ui_out_field_core_addr (uiout
, "frame",
4122 b
->gdbarch
, b
->frame_id
.stack_addr
);
4123 ui_out_text (uiout
, "\n");
4126 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
4128 /* We do not print the condition for Ada exception catchpoints
4129 because the condition is an internal implementation detail
4130 that we do not want to expose to the user. */
4132 if (b
->type
== bp_tracepoint
)
4133 ui_out_text (uiout
, "\ttrace only if ");
4135 ui_out_text (uiout
, "\tstop only if ");
4136 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4137 ui_out_text (uiout
, "\n");
4140 if (!part_of_multiple
&& b
->thread
!= -1)
4142 /* FIXME should make an annotation for this */
4143 ui_out_text (uiout
, "\tstop only in thread ");
4144 ui_out_field_int (uiout
, "thread", b
->thread
);
4145 ui_out_text (uiout
, "\n");
4148 if (!part_of_multiple
&& b
->hit_count
)
4150 /* FIXME should make an annotation for this */
4151 if (ep_is_catchpoint (b
))
4152 ui_out_text (uiout
, "\tcatchpoint");
4154 ui_out_text (uiout
, "\tbreakpoint");
4155 ui_out_text (uiout
, " already hit ");
4156 ui_out_field_int (uiout
, "times", b
->hit_count
);
4157 if (b
->hit_count
== 1)
4158 ui_out_text (uiout
, " time\n");
4160 ui_out_text (uiout
, " times\n");
4163 /* Output the count also if it is zero, but only if this is
4164 mi. FIXME: Should have a better test for this. */
4165 if (ui_out_is_mi_like_p (uiout
))
4166 if (!part_of_multiple
&& b
->hit_count
== 0)
4167 ui_out_field_int (uiout
, "times", b
->hit_count
);
4169 if (!part_of_multiple
&& b
->ignore_count
)
4172 ui_out_text (uiout
, "\tignore next ");
4173 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
4174 ui_out_text (uiout
, " hits\n");
4178 if (!part_of_multiple
&& l
)
4180 struct cleanup
*script_chain
;
4183 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
4184 print_command_lines (uiout
, l
, 4);
4185 do_cleanups (script_chain
);
4188 if (!part_of_multiple
&& b
->pass_count
)
4190 annotate_field (10);
4191 ui_out_text (uiout
, "\tpass count ");
4192 ui_out_field_int (uiout
, "pass", b
->pass_count
);
4193 ui_out_text (uiout
, " \n");
4196 if (!part_of_multiple
&& b
->step_count
)
4198 annotate_field (11);
4199 ui_out_text (uiout
, "\tstep count ");
4200 ui_out_field_int (uiout
, "step", b
->step_count
);
4201 ui_out_text (uiout
, " \n");
4204 if (!part_of_multiple
&& b
->actions
)
4206 struct action_line
*action
;
4207 annotate_field (12);
4208 for (action
= b
->actions
; action
; action
= action
->next
)
4210 ui_out_text (uiout
, " A\t");
4211 ui_out_text (uiout
, action
->action
);
4212 ui_out_text (uiout
, "\n");
4216 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
4219 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
4220 else if (b
->exp_string
)
4221 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
4224 do_cleanups (bkpt_chain
);
4225 do_cleanups (old_chain
);
4229 print_one_breakpoint (struct breakpoint
*b
,
4230 struct bp_location
**last_loc
, int print_address_bits
,
4233 print_one_breakpoint_location (b
, NULL
, 0, last_loc
,
4234 print_address_bits
, allflag
);
4236 /* If this breakpoint has custom print function,
4237 it's already printed. Otherwise, print individual
4238 locations, if any. */
4239 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
4241 /* If breakpoint has a single location that is
4242 disabled, we print it as if it had
4243 several locations, since otherwise it's hard to
4244 represent "breakpoint enabled, location disabled"
4246 Note that while hardware watchpoints have
4247 several locations internally, that's no a property
4250 && !is_hardware_watchpoint (b
)
4251 && (b
->loc
->next
|| !b
->loc
->enabled
)
4252 && !ui_out_is_mi_like_p (uiout
))
4254 struct bp_location
*loc
;
4256 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
4257 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
4258 print_address_bits
, allflag
);
4264 breakpoint_address_bits (struct breakpoint
*b
)
4266 int print_address_bits
= 0;
4267 struct bp_location
*loc
;
4269 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4271 int addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
4272 if (addr_bit
> print_address_bits
)
4273 print_address_bits
= addr_bit
;
4276 return print_address_bits
;
4279 struct captured_breakpoint_query_args
4285 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
4287 struct captured_breakpoint_query_args
*args
= data
;
4288 struct breakpoint
*b
;
4289 struct bp_location
*dummy_loc
= NULL
;
4292 if (args
->bnum
== b
->number
)
4294 int print_address_bits
= breakpoint_address_bits (b
);
4295 print_one_breakpoint (b
, &dummy_loc
, print_address_bits
, 0);
4303 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
4305 struct captured_breakpoint_query_args args
;
4307 /* For the moment we don't trust print_one_breakpoint() to not throw
4309 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
4310 error_message
, RETURN_MASK_ALL
) < 0)
4316 /* Return non-zero if B is user settable (breakpoints, watchpoints,
4317 catchpoints, et.al.). */
4320 user_settable_breakpoint (const struct breakpoint
*b
)
4322 return (b
->type
== bp_breakpoint
4323 || b
->type
== bp_catchpoint
4324 || b
->type
== bp_hardware_breakpoint
4325 || b
->type
== bp_tracepoint
4326 || b
->type
== bp_watchpoint
4327 || b
->type
== bp_read_watchpoint
4328 || b
->type
== bp_access_watchpoint
4329 || b
->type
== bp_hardware_watchpoint
);
4332 /* Print information on user settable breakpoint (watchpoint, etc)
4333 number BNUM. If BNUM is -1 print all user settable breakpoints.
4334 If ALLFLAG is non-zero, include non- user settable breakpoints. */
4337 breakpoint_1 (int bnum
, int allflag
)
4339 struct breakpoint
*b
;
4340 struct bp_location
*last_loc
= NULL
;
4341 int nr_printable_breakpoints
;
4342 struct cleanup
*bkpttbl_chain
;
4343 struct value_print_options opts
;
4344 int print_address_bits
= 0;
4346 get_user_print_options (&opts
);
4348 /* Compute the number of rows in the table, as well as the
4349 size required for address fields. */
4350 nr_printable_breakpoints
= 0;
4353 || bnum
== b
->number
)
4355 if (allflag
|| user_settable_breakpoint (b
))
4357 int addr_bit
= breakpoint_address_bits (b
);
4358 if (addr_bit
> print_address_bits
)
4359 print_address_bits
= addr_bit
;
4361 nr_printable_breakpoints
++;
4365 if (opts
.addressprint
)
4367 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
4371 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
4374 if (nr_printable_breakpoints
> 0)
4375 annotate_breakpoints_headers ();
4376 if (nr_printable_breakpoints
> 0)
4378 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
4379 if (nr_printable_breakpoints
> 0)
4381 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
4382 if (nr_printable_breakpoints
> 0)
4384 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
4385 if (nr_printable_breakpoints
> 0)
4387 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
4388 if (opts
.addressprint
)
4390 if (nr_printable_breakpoints
> 0)
4392 if (print_address_bits
<= 32)
4393 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
4395 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
4397 if (nr_printable_breakpoints
> 0)
4399 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
4400 ui_out_table_body (uiout
);
4401 if (nr_printable_breakpoints
> 0)
4402 annotate_breakpoints_table ();
4406 || bnum
== b
->number
)
4408 /* We only print out user settable breakpoints unless the
4410 if (allflag
|| user_settable_breakpoint (b
))
4411 print_one_breakpoint (b
, &last_loc
, print_address_bits
, allflag
);
4414 do_cleanups (bkpttbl_chain
);
4416 if (nr_printable_breakpoints
== 0)
4419 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
4421 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
4426 if (last_loc
&& !server_command
)
4427 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
4430 /* FIXME? Should this be moved up so that it is only called when
4431 there have been breakpoints? */
4432 annotate_breakpoints_table_end ();
4436 breakpoints_info (char *bnum_exp
, int from_tty
)
4441 bnum
= parse_and_eval_long (bnum_exp
);
4443 breakpoint_1 (bnum
, 0);
4447 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4452 bnum
= parse_and_eval_long (bnum_exp
);
4454 breakpoint_1 (bnum
, 1);
4458 breakpoint_has_pc (struct breakpoint
*b
,
4459 struct program_space
*pspace
,
4460 CORE_ADDR pc
, struct obj_section
*section
)
4462 struct bp_location
*bl
= b
->loc
;
4463 for (; bl
; bl
= bl
->next
)
4465 if (bl
->pspace
== pspace
4466 && bl
->address
== pc
4467 && (!overlay_debugging
|| bl
->section
== section
))
4473 /* Print a message describing any breakpoints set at PC. This
4474 concerns with logical breakpoints, so we match program spaces, not
4478 describe_other_breakpoints (struct gdbarch
*gdbarch
,
4479 struct program_space
*pspace
, CORE_ADDR pc
,
4480 struct obj_section
*section
, int thread
)
4483 struct breakpoint
*b
;
4486 others
+= breakpoint_has_pc (b
, pspace
, pc
, section
);
4490 printf_filtered (_("Note: breakpoint "));
4491 else /* if (others == ???) */
4492 printf_filtered (_("Note: breakpoints "));
4494 if (breakpoint_has_pc (b
, pspace
, pc
, section
))
4497 printf_filtered ("%d", b
->number
);
4498 if (b
->thread
== -1 && thread
!= -1)
4499 printf_filtered (" (all threads)");
4500 else if (b
->thread
!= -1)
4501 printf_filtered (" (thread %d)", b
->thread
);
4502 printf_filtered ("%s%s ",
4503 ((b
->enable_state
== bp_disabled
4504 || b
->enable_state
== bp_call_disabled
4505 || b
->enable_state
== bp_startup_disabled
)
4507 : b
->enable_state
== bp_permanent
4511 : ((others
== 1) ? " and" : ""));
4513 printf_filtered (_("also set at pc "));
4514 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
4515 printf_filtered (".\n");
4519 /* Set the default place to put a breakpoint
4520 for the `break' command with no arguments. */
4523 set_default_breakpoint (int valid
, struct program_space
*pspace
,
4524 CORE_ADDR addr
, struct symtab
*symtab
,
4527 default_breakpoint_valid
= valid
;
4528 default_breakpoint_pspace
= pspace
;
4529 default_breakpoint_address
= addr
;
4530 default_breakpoint_symtab
= symtab
;
4531 default_breakpoint_line
= line
;
4534 /* Return true iff it is meaningful to use the address member of
4535 BPT. For some breakpoint types, the address member is irrelevant
4536 and it makes no sense to attempt to compare it to other addresses
4537 (or use it for any other purpose either).
4539 More specifically, each of the following breakpoint types will always
4540 have a zero valued address and we don't want to mark breakpoints of any of
4541 these types to be a duplicate of an actual breakpoint at address zero:
4544 bp_hardware_watchpoint
4546 bp_access_watchpoint
4550 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4552 enum bptype type
= bpt
->type
;
4554 return (type
!= bp_watchpoint
4555 && type
!= bp_hardware_watchpoint
4556 && type
!= bp_read_watchpoint
4557 && type
!= bp_access_watchpoint
4558 && type
!= bp_catchpoint
);
4561 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
4562 same breakpoint location. In most targets, this can only be true
4563 if ASPACE1 matches ASPACE2. On targets that have global
4564 breakpoints, the address space doesn't really matter. */
4567 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
4568 struct address_space
*aspace2
, CORE_ADDR addr2
)
4570 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
4571 || aspace1
== aspace2
)
4576 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4577 int bnum
, int have_bnum
)
4582 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4583 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4585 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4586 bnum
, astr1
, astr2
);
4588 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4591 /* Adjust a breakpoint's address to account for architectural constraints
4592 on breakpoint placement. Return the adjusted address. Note: Very
4593 few targets require this kind of adjustment. For most targets,
4594 this function is simply the identity function. */
4597 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
4598 CORE_ADDR bpaddr
, enum bptype bptype
)
4600 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
4602 /* Very few targets need any kind of breakpoint adjustment. */
4605 else if (bptype
== bp_watchpoint
4606 || bptype
== bp_hardware_watchpoint
4607 || bptype
== bp_read_watchpoint
4608 || bptype
== bp_access_watchpoint
4609 || bptype
== bp_catchpoint
)
4611 /* Watchpoints and the various bp_catch_* eventpoints should not
4612 have their addresses modified. */
4617 CORE_ADDR adjusted_bpaddr
;
4619 /* Some targets have architectural constraints on the placement
4620 of breakpoint instructions. Obtain the adjusted address. */
4621 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
4623 /* An adjusted breakpoint address can significantly alter
4624 a user's expectations. Print a warning if an adjustment
4626 if (adjusted_bpaddr
!= bpaddr
)
4627 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4629 return adjusted_bpaddr
;
4633 /* Allocate a struct bp_location. */
4635 static struct bp_location
*
4636 allocate_bp_location (struct breakpoint
*bpt
)
4638 struct bp_location
*loc
, *loc_p
;
4640 loc
= xmalloc (sizeof (struct bp_location
));
4641 memset (loc
, 0, sizeof (*loc
));
4645 loc
->shlib_disabled
= 0;
4655 case bp_longjmp_resume
:
4656 case bp_step_resume
:
4657 case bp_watchpoint_scope
:
4659 case bp_shlib_event
:
4660 case bp_thread_event
:
4661 case bp_overlay_event
:
4663 case bp_longjmp_master
:
4664 loc
->loc_type
= bp_loc_software_breakpoint
;
4666 case bp_hardware_breakpoint
:
4667 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4669 case bp_hardware_watchpoint
:
4670 case bp_read_watchpoint
:
4671 case bp_access_watchpoint
:
4672 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4676 loc
->loc_type
= bp_loc_other
;
4679 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4685 static void free_bp_location (struct bp_location
*loc
)
4690 if (loc
->function_name
)
4691 xfree (loc
->function_name
);
4696 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4697 that has type BPTYPE and has no locations as yet. */
4698 /* This function is used in gdbtk sources and thus can not be made static. */
4700 static struct breakpoint
*
4701 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
4704 struct breakpoint
*b
, *b1
;
4706 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4707 memset (b
, 0, sizeof (*b
));
4710 b
->gdbarch
= gdbarch
;
4711 b
->language
= current_language
->la_language
;
4712 b
->input_radix
= input_radix
;
4714 b
->enable_state
= bp_enabled
;
4717 b
->ignore_count
= 0;
4719 b
->frame_id
= null_frame_id
;
4720 b
->forked_inferior_pid
= null_ptid
;
4721 b
->exec_pathname
= NULL
;
4722 b
->syscalls_to_be_caught
= NULL
;
4724 b
->condition_not_parsed
= 0;
4726 /* Add this breakpoint to the end of the chain
4727 so that a list of breakpoints will come out in order
4728 of increasing numbers. */
4730 b1
= breakpoint_chain
;
4732 breakpoint_chain
= b
;
4742 /* Initialize loc->function_name. */
4744 set_breakpoint_location_function (struct bp_location
*loc
)
4746 if (loc
->owner
->type
== bp_breakpoint
4747 || loc
->owner
->type
== bp_hardware_breakpoint
4748 || loc
->owner
->type
== bp_tracepoint
)
4750 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4752 if (loc
->function_name
)
4753 loc
->function_name
= xstrdup (loc
->function_name
);
4757 /* Attempt to determine architecture of location identified by SAL. */
4758 static struct gdbarch
*
4759 get_sal_arch (struct symtab_and_line sal
)
4762 return get_objfile_arch (sal
.section
->objfile
);
4764 return get_objfile_arch (sal
.symtab
->objfile
);
4769 /* set_raw_breakpoint is a low level routine for allocating and
4770 partially initializing a breakpoint of type BPTYPE. The newly
4771 created breakpoint's address, section, source file name, and line
4772 number are provided by SAL. The newly created and partially
4773 initialized breakpoint is added to the breakpoint chain and
4774 is also returned as the value of this function.
4776 It is expected that the caller will complete the initialization of
4777 the newly created breakpoint struct as well as output any status
4778 information regarding the creation of a new breakpoint. In
4779 particular, set_raw_breakpoint does NOT set the breakpoint
4780 number! Care should be taken to not allow an error to occur
4781 prior to completing the initialization of the breakpoint. If this
4782 should happen, a bogus breakpoint will be left on the chain. */
4785 set_raw_breakpoint (struct gdbarch
*gdbarch
,
4786 struct symtab_and_line sal
, enum bptype bptype
)
4788 struct breakpoint
*b
= set_raw_breakpoint_without_location (gdbarch
, bptype
);
4789 CORE_ADDR adjusted_address
;
4790 struct gdbarch
*loc_gdbarch
;
4792 loc_gdbarch
= get_sal_arch (sal
);
4794 loc_gdbarch
= b
->gdbarch
;
4796 if (bptype
!= bp_catchpoint
)
4797 gdb_assert (sal
.pspace
!= NULL
);
4799 /* Adjust the breakpoint's address prior to allocating a location.
4800 Once we call allocate_bp_location(), that mostly uninitialized
4801 location will be placed on the location chain. Adjustment of the
4802 breakpoint may cause target_read_memory() to be called and we do
4803 not want its scan of the location chain to find a breakpoint and
4804 location that's only been partially initialized. */
4805 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
, sal
.pc
, b
->type
);
4807 b
->loc
= allocate_bp_location (b
);
4808 b
->loc
->gdbarch
= loc_gdbarch
;
4809 b
->loc
->requested_address
= sal
.pc
;
4810 b
->loc
->address
= adjusted_address
;
4811 b
->loc
->pspace
= sal
.pspace
;
4813 /* Store the program space that was used to set the breakpoint, for
4814 breakpoint resetting. */
4815 b
->pspace
= sal
.pspace
;
4817 if (sal
.symtab
== NULL
)
4818 b
->source_file
= NULL
;
4820 b
->source_file
= xstrdup (sal
.symtab
->filename
);
4821 b
->loc
->section
= sal
.section
;
4822 b
->line_number
= sal
.line
;
4824 set_breakpoint_location_function (b
->loc
);
4826 breakpoints_changed ();
4832 /* Note that the breakpoint object B describes a permanent breakpoint
4833 instruction, hard-wired into the inferior's code. */
4835 make_breakpoint_permanent (struct breakpoint
*b
)
4837 struct bp_location
*bl
;
4838 b
->enable_state
= bp_permanent
;
4840 /* By definition, permanent breakpoints are already present in the code.
4841 Mark all locations as inserted. For now, make_breakpoint_permanent
4842 is called in just one place, so it's hard to say if it's reasonable
4843 to have permanent breakpoint with multiple locations or not,
4844 but it's easy to implmement. */
4845 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4849 /* Call this routine when stepping and nexting to enable a breakpoint
4850 if we do a longjmp() in THREAD. When we hit that breakpoint, call
4851 set_longjmp_resume_breakpoint() to figure out where we are going. */
4854 set_longjmp_breakpoint (int thread
)
4856 struct breakpoint
*b
, *temp
;
4858 /* To avoid having to rescan all objfile symbols at every step,
4859 we maintain a list of continually-inserted but always disabled
4860 longjmp "master" breakpoints. Here, we simply create momentary
4861 clones of those and enable them for the requested thread. */
4862 ALL_BREAKPOINTS_SAFE (b
, temp
)
4863 if (b
->pspace
== current_program_space
4864 && b
->type
== bp_longjmp_master
)
4866 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
4867 clone
->type
= bp_longjmp
;
4868 clone
->thread
= thread
;
4872 /* Delete all longjmp breakpoints from THREAD. */
4874 delete_longjmp_breakpoint (int thread
)
4876 struct breakpoint
*b
, *temp
;
4878 ALL_BREAKPOINTS_SAFE (b
, temp
)
4879 if (b
->type
== bp_longjmp
)
4881 if (b
->thread
== thread
)
4882 delete_breakpoint (b
);
4887 enable_overlay_breakpoints (void)
4889 struct breakpoint
*b
;
4892 if (b
->type
== bp_overlay_event
)
4894 b
->enable_state
= bp_enabled
;
4895 update_global_location_list (1);
4896 overlay_events_enabled
= 1;
4901 disable_overlay_breakpoints (void)
4903 struct breakpoint
*b
;
4906 if (b
->type
== bp_overlay_event
)
4908 b
->enable_state
= bp_disabled
;
4909 update_global_location_list (0);
4910 overlay_events_enabled
= 0;
4915 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
4917 struct breakpoint
*b
;
4919 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
);
4921 b
->enable_state
= bp_enabled
;
4922 /* addr_string has to be used or breakpoint_re_set will delete me. */
4924 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
4926 update_global_location_list_nothrow (1);
4932 remove_thread_event_breakpoints (void)
4934 struct breakpoint
*b
, *temp
;
4936 ALL_BREAKPOINTS_SAFE (b
, temp
)
4937 if (b
->type
== bp_thread_event
4938 && b
->loc
->pspace
== current_program_space
)
4939 delete_breakpoint (b
);
4942 struct captured_parse_breakpoint_args
4945 struct symtabs_and_lines
*sals_p
;
4946 char ***addr_string_p
;
4950 struct lang_and_radix
4956 /* Create a breakpoint for JIT code registration and unregistration. */
4959 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
4961 struct breakpoint
*b
;
4963 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
4964 update_global_location_list_nothrow (1);
4969 remove_solib_event_breakpoints (void)
4971 struct breakpoint
*b
, *temp
;
4973 ALL_BREAKPOINTS_SAFE (b
, temp
)
4974 if (b
->type
== bp_shlib_event
4975 && b
->loc
->pspace
== current_program_space
)
4976 delete_breakpoint (b
);
4980 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
4982 struct breakpoint
*b
;
4984 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
4985 update_global_location_list_nothrow (1);
4989 /* Disable any breakpoints that are on code in shared libraries. Only
4990 apply to enabled breakpoints, disabled ones can just stay disabled. */
4993 disable_breakpoints_in_shlibs (void)
4995 struct bp_location
*loc
, **locp_tmp
;
4997 ALL_BP_LOCATIONS (loc
, locp_tmp
)
4999 struct breakpoint
*b
= loc
->owner
;
5000 /* We apply the check to all breakpoints, including disabled
5001 for those with loc->duplicate set. This is so that when breakpoint
5002 becomes enabled, or the duplicate is removed, gdb will try to insert
5003 all breakpoints. If we don't set shlib_disabled here, we'll try
5004 to insert those breakpoints and fail. */
5005 if (((b
->type
== bp_breakpoint
)
5006 || (b
->type
== bp_hardware_breakpoint
)
5007 || (b
->type
== bp_tracepoint
))
5008 && loc
->pspace
== current_program_space
5009 && !loc
->shlib_disabled
5011 && PC_SOLIB (loc
->address
)
5013 && solib_name_from_address (loc
->pspace
, loc
->address
)
5017 loc
->shlib_disabled
= 1;
5022 /* Disable any breakpoints that are in in an unloaded shared library. Only
5023 apply to enabled breakpoints, disabled ones can just stay disabled. */
5026 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
5028 struct bp_location
*loc
, **locp_tmp
;
5029 int disabled_shlib_breaks
= 0;
5031 /* SunOS a.out shared libraries are always mapped, so do not
5032 disable breakpoints; they will only be reported as unloaded
5033 through clear_solib when GDB discards its shared library
5034 list. See clear_solib for more information. */
5035 if (exec_bfd
!= NULL
5036 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
5039 ALL_BP_LOCATIONS (loc
, locp_tmp
)
5041 struct breakpoint
*b
= loc
->owner
;
5042 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
5043 || loc
->loc_type
== bp_loc_software_breakpoint
)
5044 && solib
->pspace
== loc
->pspace
5045 && !loc
->shlib_disabled
5046 && (b
->type
== bp_breakpoint
|| b
->type
== bp_hardware_breakpoint
)
5047 && solib_contains_address_p (solib
, loc
->address
))
5049 loc
->shlib_disabled
= 1;
5050 /* At this point, we cannot rely on remove_breakpoint
5051 succeeding so we must mark the breakpoint as not inserted
5052 to prevent future errors occurring in remove_breakpoints. */
5054 if (!disabled_shlib_breaks
)
5056 target_terminal_ours_for_output ();
5057 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
5060 disabled_shlib_breaks
= 1;
5065 /* FORK & VFORK catchpoints. */
5067 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
5070 insert_catch_fork (struct breakpoint
*b
)
5072 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
5075 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
5078 remove_catch_fork (struct breakpoint
*b
)
5080 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
5083 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
5087 breakpoint_hit_catch_fork (struct breakpoint
*b
)
5089 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
5092 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
5094 static enum print_stop_action
5095 print_it_catch_fork (struct breakpoint
*b
)
5097 annotate_catchpoint (b
->number
);
5098 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
5099 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5100 return PRINT_SRC_AND_LOC
;
5103 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
5106 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5108 struct value_print_options opts
;
5110 get_user_print_options (&opts
);
5112 /* Field 4, the address, is omitted (which makes the columns
5113 not line up too nicely with the headers, but the effect
5114 is relatively readable). */
5115 if (opts
.addressprint
)
5116 ui_out_field_skip (uiout
, "addr");
5118 ui_out_text (uiout
, "fork");
5119 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
5121 ui_out_text (uiout
, ", process ");
5122 ui_out_field_int (uiout
, "what",
5123 ptid_get_pid (b
->forked_inferior_pid
));
5124 ui_out_spaces (uiout
, 1);
5128 /* Implement the "print_mention" breakpoint_ops method for fork
5132 print_mention_catch_fork (struct breakpoint
*b
)
5134 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
5137 /* The breakpoint_ops structure to be used in fork catchpoints. */
5139 static struct breakpoint_ops catch_fork_breakpoint_ops
=
5143 breakpoint_hit_catch_fork
,
5144 print_it_catch_fork
,
5145 print_one_catch_fork
,
5146 print_mention_catch_fork
5149 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
5152 insert_catch_vfork (struct breakpoint
*b
)
5154 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
5157 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
5160 remove_catch_vfork (struct breakpoint
*b
)
5162 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
5165 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
5169 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
5171 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
5174 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
5176 static enum print_stop_action
5177 print_it_catch_vfork (struct breakpoint
*b
)
5179 annotate_catchpoint (b
->number
);
5180 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
5181 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5182 return PRINT_SRC_AND_LOC
;
5185 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
5188 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5190 struct value_print_options opts
;
5192 get_user_print_options (&opts
);
5193 /* Field 4, the address, is omitted (which makes the columns
5194 not line up too nicely with the headers, but the effect
5195 is relatively readable). */
5196 if (opts
.addressprint
)
5197 ui_out_field_skip (uiout
, "addr");
5199 ui_out_text (uiout
, "vfork");
5200 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
5202 ui_out_text (uiout
, ", process ");
5203 ui_out_field_int (uiout
, "what",
5204 ptid_get_pid (b
->forked_inferior_pid
));
5205 ui_out_spaces (uiout
, 1);
5209 /* Implement the "print_mention" breakpoint_ops method for vfork
5213 print_mention_catch_vfork (struct breakpoint
*b
)
5215 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
5218 /* The breakpoint_ops structure to be used in vfork catchpoints. */
5220 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
5224 breakpoint_hit_catch_vfork
,
5225 print_it_catch_vfork
,
5226 print_one_catch_vfork
,
5227 print_mention_catch_vfork
5230 /* Implement the "insert" breakpoint_ops method for syscall
5234 insert_catch_syscall (struct breakpoint
*b
)
5236 struct inferior
*inf
= current_inferior ();
5238 ++inf
->total_syscalls_count
;
5239 if (!b
->syscalls_to_be_caught
)
5240 ++inf
->any_syscall_count
;
5245 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5249 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
5251 int old_size
= VEC_length (int, inf
->syscalls_counts
);
5252 uintptr_t vec_addr_offset
= old_size
* ((uintptr_t) sizeof (int));
5254 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
5255 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
5257 memset ((void *) vec_addr
, 0,
5258 (iter
+ 1 - old_size
) * sizeof (int));
5260 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
5261 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
5265 target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
5266 inf
->total_syscalls_count
!= 0,
5267 inf
->any_syscall_count
,
5268 VEC_length (int, inf
->syscalls_counts
),
5269 VEC_address (int, inf
->syscalls_counts
));
5272 /* Implement the "remove" breakpoint_ops method for syscall
5276 remove_catch_syscall (struct breakpoint
*b
)
5278 struct inferior
*inf
= current_inferior ();
5280 --inf
->total_syscalls_count
;
5281 if (!b
->syscalls_to_be_caught
)
5282 --inf
->any_syscall_count
;
5287 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5291 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
5292 /* Shouldn't happen. */
5294 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
5295 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
5299 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
5300 inf
->total_syscalls_count
!= 0,
5301 inf
->any_syscall_count
,
5302 VEC_length (int, inf
->syscalls_counts
),
5303 VEC_address (int, inf
->syscalls_counts
));
5306 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
5310 breakpoint_hit_catch_syscall (struct breakpoint
*b
)
5312 /* We must check if we are catching specific syscalls in this breakpoint.
5313 If we are, then we must guarantee that the called syscall is the same
5314 syscall we are catching. */
5315 int syscall_number
= 0;
5317 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
5320 /* Now, checking if the syscall is the same. */
5321 if (b
->syscalls_to_be_caught
)
5325 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5327 if (syscall_number
== iter
)
5337 /* Implement the "print_it" breakpoint_ops method for syscall
5340 static enum print_stop_action
5341 print_it_catch_syscall (struct breakpoint
*b
)
5343 /* These are needed because we want to know in which state a
5344 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
5345 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
5346 must print "called syscall" or "returned from syscall". */
5348 struct target_waitstatus last
;
5350 struct cleanup
*old_chain
;
5353 get_last_target_status (&ptid
, &last
);
5355 get_syscall_by_number (last
.value
.syscall_number
, &s
);
5357 annotate_catchpoint (b
->number
);
5360 syscall_id
= xstrprintf ("%d", last
.value
.syscall_number
);
5362 syscall_id
= xstrprintf ("'%s'", s
.name
);
5364 old_chain
= make_cleanup (xfree
, syscall_id
);
5366 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
5367 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
5368 b
->number
, syscall_id
);
5369 else if (last
.kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
5370 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
5371 b
->number
, syscall_id
);
5373 do_cleanups (old_chain
);
5375 return PRINT_SRC_AND_LOC
;
5378 /* Implement the "print_one" breakpoint_ops method for syscall
5382 print_one_catch_syscall (struct breakpoint
*b
,
5383 struct bp_location
**last_loc
)
5385 struct value_print_options opts
;
5387 get_user_print_options (&opts
);
5388 /* Field 4, the address, is omitted (which makes the columns
5389 not line up too nicely with the headers, but the effect
5390 is relatively readable). */
5391 if (opts
.addressprint
)
5392 ui_out_field_skip (uiout
, "addr");
5395 if (b
->syscalls_to_be_caught
5396 && VEC_length (int, b
->syscalls_to_be_caught
) > 1)
5397 ui_out_text (uiout
, "syscalls \"");
5399 ui_out_text (uiout
, "syscall \"");
5401 if (b
->syscalls_to_be_caught
)
5404 char *text
= xstrprintf ("%s", "");
5406 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5411 get_syscall_by_number (iter
, &s
);
5414 text
= xstrprintf ("%s%s, ", text
, s
.name
);
5416 text
= xstrprintf ("%s%d, ", text
, iter
);
5418 /* We have to xfree the last 'text' (now stored at 'x')
5419 because xstrprintf dinamically allocates new space for it
5423 /* Remove the last comma. */
5424 text
[strlen (text
) - 2] = '\0';
5425 ui_out_field_string (uiout
, "what", text
);
5428 ui_out_field_string (uiout
, "what", "<any syscall>");
5429 ui_out_text (uiout
, "\" ");
5432 /* Implement the "print_mention" breakpoint_ops method for syscall
5436 print_mention_catch_syscall (struct breakpoint
*b
)
5438 if (b
->syscalls_to_be_caught
)
5442 if (VEC_length (int, b
->syscalls_to_be_caught
) > 1)
5443 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
5445 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
5448 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5452 get_syscall_by_number (iter
, &s
);
5455 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
5457 printf_filtered (" %d", s
.number
);
5459 printf_filtered (")");
5462 printf_filtered (_("Catchpoint %d (any syscall)"),
5466 /* The breakpoint_ops structure to be used in syscall catchpoints. */
5468 static struct breakpoint_ops catch_syscall_breakpoint_ops
=
5470 insert_catch_syscall
,
5471 remove_catch_syscall
,
5472 breakpoint_hit_catch_syscall
,
5473 print_it_catch_syscall
,
5474 print_one_catch_syscall
,
5475 print_mention_catch_syscall
5478 /* Returns non-zero if 'b' is a syscall catchpoint. */
5481 syscall_catchpoint_p (struct breakpoint
*b
)
5483 return (b
->ops
== &catch_syscall_breakpoint_ops
);
5486 /* Create a new breakpoint of the bp_catchpoint kind and return it,
5487 but does NOT mention it nor update the global location list.
5488 This is useful if you need to fill more fields in the
5489 struct breakpoint before calling mention.
5491 If TEMPFLAG is non-zero, then make the breakpoint temporary.
5492 If COND_STRING is not NULL, then store it in the breakpoint.
5493 OPS, if not NULL, is the breakpoint_ops structure associated
5494 to the catchpoint. */
5496 static struct breakpoint
*
5497 create_catchpoint_without_mention (struct gdbarch
*gdbarch
, int tempflag
,
5499 struct breakpoint_ops
*ops
)
5501 struct symtab_and_line sal
;
5502 struct breakpoint
*b
;
5505 sal
.pspace
= current_program_space
;
5507 b
= set_raw_breakpoint (gdbarch
, sal
, bp_catchpoint
);
5508 set_breakpoint_count (breakpoint_count
+ 1);
5509 b
->number
= breakpoint_count
;
5511 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
5513 b
->addr_string
= NULL
;
5514 b
->enable_state
= bp_enabled
;
5515 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5521 /* Create a new breakpoint of the bp_catchpoint kind and return it.
5523 If TEMPFLAG is non-zero, then make the breakpoint temporary.
5524 If COND_STRING is not NULL, then store it in the breakpoint.
5525 OPS, if not NULL, is the breakpoint_ops structure associated
5526 to the catchpoint. */
5528 static struct breakpoint
*
5529 create_catchpoint (struct gdbarch
*gdbarch
, int tempflag
,
5530 char *cond_string
, struct breakpoint_ops
*ops
)
5532 struct breakpoint
*b
=
5533 create_catchpoint_without_mention (gdbarch
, tempflag
, cond_string
, ops
);
5536 update_global_location_list (1);
5542 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
5543 int tempflag
, char *cond_string
,
5544 struct breakpoint_ops
*ops
)
5546 struct breakpoint
*b
5547 = create_catchpoint (gdbarch
, tempflag
, cond_string
, ops
);
5549 /* FIXME: We should put this information in a breakpoint private data
5551 b
->forked_inferior_pid
= null_ptid
;
5554 /* Exec catchpoints. */
5557 insert_catch_exec (struct breakpoint
*b
)
5559 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
5563 remove_catch_exec (struct breakpoint
*b
)
5565 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
5569 breakpoint_hit_catch_exec (struct breakpoint
*b
)
5571 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
5574 static enum print_stop_action
5575 print_it_catch_exec (struct breakpoint
*b
)
5577 annotate_catchpoint (b
->number
);
5578 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
5580 return PRINT_SRC_AND_LOC
;
5584 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
5586 struct value_print_options opts
;
5588 get_user_print_options (&opts
);
5590 /* Field 4, the address, is omitted (which makes the columns
5591 not line up too nicely with the headers, but the effect
5592 is relatively readable). */
5593 if (opts
.addressprint
)
5594 ui_out_field_skip (uiout
, "addr");
5596 ui_out_text (uiout
, "exec");
5597 if (b
->exec_pathname
!= NULL
)
5599 ui_out_text (uiout
, ", program \"");
5600 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
5601 ui_out_text (uiout
, "\" ");
5606 print_mention_catch_exec (struct breakpoint
*b
)
5608 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
5611 static struct breakpoint_ops catch_exec_breakpoint_ops
=
5615 breakpoint_hit_catch_exec
,
5616 print_it_catch_exec
,
5617 print_one_catch_exec
,
5618 print_mention_catch_exec
5622 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
5623 struct breakpoint_ops
*ops
)
5625 struct gdbarch
*gdbarch
= get_current_arch ();
5626 struct breakpoint
*b
=
5627 create_catchpoint_without_mention (gdbarch
, tempflag
, NULL
, ops
);
5629 b
->syscalls_to_be_caught
= filter
;
5631 /* Now, we have to mention the breakpoint and update the global
5634 update_global_location_list (1);
5638 hw_breakpoint_used_count (void)
5640 struct breakpoint
*b
;
5645 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
5653 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
5655 struct breakpoint
*b
;
5658 *other_type_used
= 0;
5661 if (breakpoint_enabled (b
))
5663 if (b
->type
== type
)
5665 else if ((b
->type
== bp_hardware_watchpoint
5666 || b
->type
== bp_read_watchpoint
5667 || b
->type
== bp_access_watchpoint
))
5668 *other_type_used
= 1;
5675 disable_watchpoints_before_interactive_call_start (void)
5677 struct breakpoint
*b
;
5681 if (((b
->type
== bp_watchpoint
)
5682 || (b
->type
== bp_hardware_watchpoint
)
5683 || (b
->type
== bp_read_watchpoint
)
5684 || (b
->type
== bp_access_watchpoint
))
5685 && breakpoint_enabled (b
))
5687 b
->enable_state
= bp_call_disabled
;
5688 update_global_location_list (0);
5694 enable_watchpoints_after_interactive_call_stop (void)
5696 struct breakpoint
*b
;
5700 if (((b
->type
== bp_watchpoint
)
5701 || (b
->type
== bp_hardware_watchpoint
)
5702 || (b
->type
== bp_read_watchpoint
)
5703 || (b
->type
== bp_access_watchpoint
))
5704 && (b
->enable_state
== bp_call_disabled
))
5706 b
->enable_state
= bp_enabled
;
5707 update_global_location_list (1);
5713 disable_breakpoints_before_startup (void)
5715 struct breakpoint
*b
;
5720 if (b
->pspace
!= current_program_space
)
5723 if ((b
->type
== bp_breakpoint
5724 || b
->type
== bp_hardware_breakpoint
)
5725 && breakpoint_enabled (b
))
5727 b
->enable_state
= bp_startup_disabled
;
5733 update_global_location_list (0);
5735 current_program_space
->executing_startup
= 1;
5739 enable_breakpoints_after_startup (void)
5741 struct breakpoint
*b
;
5744 current_program_space
->executing_startup
= 0;
5748 if (b
->pspace
!= current_program_space
)
5751 if ((b
->type
== bp_breakpoint
5752 || b
->type
== bp_hardware_breakpoint
)
5753 && b
->enable_state
== bp_startup_disabled
)
5755 b
->enable_state
= bp_enabled
;
5761 breakpoint_re_set ();
5765 /* Set a breakpoint that will evaporate an end of command
5766 at address specified by SAL.
5767 Restrict it to frame FRAME if FRAME is nonzero. */
5770 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
5771 struct frame_id frame_id
, enum bptype type
)
5773 struct breakpoint
*b
;
5775 /* If FRAME_ID is valid, it should be a real frame, not an inlined
5777 gdb_assert (!frame_id_inlined_p (frame_id
));
5779 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
5780 b
->enable_state
= bp_enabled
;
5781 b
->disposition
= disp_donttouch
;
5782 b
->frame_id
= frame_id
;
5784 /* If we're debugging a multi-threaded program, then we
5785 want momentary breakpoints to be active in only a
5786 single thread of control. */
5787 if (in_thread_list (inferior_ptid
))
5788 b
->thread
= pid_to_thread_id (inferior_ptid
);
5790 update_global_location_list_nothrow (1);
5795 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
5799 clone_momentary_breakpoint (struct breakpoint
*orig
)
5801 struct breakpoint
*copy
;
5803 /* If there's nothing to clone, then return nothing. */
5807 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, orig
->type
);
5808 copy
->loc
= allocate_bp_location (copy
);
5809 set_breakpoint_location_function (copy
->loc
);
5811 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
5812 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
5813 copy
->loc
->address
= orig
->loc
->address
;
5814 copy
->loc
->section
= orig
->loc
->section
;
5815 copy
->loc
->pspace
= orig
->loc
->pspace
;
5817 if (orig
->source_file
== NULL
)
5818 copy
->source_file
= NULL
;
5820 copy
->source_file
= xstrdup (orig
->source_file
);
5822 copy
->line_number
= orig
->line_number
;
5823 copy
->frame_id
= orig
->frame_id
;
5824 copy
->thread
= orig
->thread
;
5825 copy
->pspace
= orig
->pspace
;
5827 copy
->enable_state
= bp_enabled
;
5828 copy
->disposition
= disp_donttouch
;
5829 copy
->number
= internal_breakpoint_number
--;
5831 update_global_location_list_nothrow (0);
5836 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
5839 struct symtab_and_line sal
;
5841 sal
= find_pc_line (pc
, 0);
5843 sal
.section
= find_pc_overlay (pc
);
5844 sal
.explicit_pc
= 1;
5846 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
5850 /* Tell the user we have just set a breakpoint B. */
5853 mention (struct breakpoint
*b
)
5856 struct cleanup
*ui_out_chain
;
5857 struct value_print_options opts
;
5859 get_user_print_options (&opts
);
5861 /* FIXME: This is misplaced; mention() is called by things (like
5862 hitting a watchpoint) other than breakpoint creation. It should
5863 be possible to clean this up and at the same time replace the
5864 random calls to breakpoint_changed with this hook. */
5865 observer_notify_breakpoint_created (b
->number
);
5867 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
5868 b
->ops
->print_mention (b
);
5873 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
5876 ui_out_text (uiout
, "Watchpoint ");
5877 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5878 ui_out_field_int (uiout
, "number", b
->number
);
5879 ui_out_text (uiout
, ": ");
5880 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5881 do_cleanups (ui_out_chain
);
5883 case bp_hardware_watchpoint
:
5884 ui_out_text (uiout
, "Hardware watchpoint ");
5885 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5886 ui_out_field_int (uiout
, "number", b
->number
);
5887 ui_out_text (uiout
, ": ");
5888 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5889 do_cleanups (ui_out_chain
);
5891 case bp_read_watchpoint
:
5892 ui_out_text (uiout
, "Hardware read watchpoint ");
5893 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
5894 ui_out_field_int (uiout
, "number", b
->number
);
5895 ui_out_text (uiout
, ": ");
5896 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5897 do_cleanups (ui_out_chain
);
5899 case bp_access_watchpoint
:
5900 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
5901 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
5902 ui_out_field_int (uiout
, "number", b
->number
);
5903 ui_out_text (uiout
, ": ");
5904 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5905 do_cleanups (ui_out_chain
);
5908 if (ui_out_is_mi_like_p (uiout
))
5913 if (b
->disposition
== disp_del
)
5914 printf_filtered (_("Temporary breakpoint"));
5916 printf_filtered (_("Breakpoint"));
5917 printf_filtered (_(" %d"), b
->number
);
5920 case bp_hardware_breakpoint
:
5921 if (ui_out_is_mi_like_p (uiout
))
5926 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
5930 if (ui_out_is_mi_like_p (uiout
))
5935 printf_filtered (_("Tracepoint"));
5936 printf_filtered (_(" %d"), b
->number
);
5943 case bp_longjmp_resume
:
5944 case bp_step_resume
:
5946 case bp_watchpoint_scope
:
5947 case bp_shlib_event
:
5948 case bp_thread_event
:
5949 case bp_overlay_event
:
5951 case bp_longjmp_master
:
5957 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5961 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5965 if (opts
.addressprint
|| b
->source_file
== NULL
)
5967 printf_filtered (" at ");
5968 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
5972 printf_filtered (": file %s, line %d.",
5973 b
->source_file
, b
->line_number
);
5977 struct bp_location
*loc
= b
->loc
;
5979 for (; loc
; loc
= loc
->next
)
5981 printf_filtered (" (%d locations)", n
);
5986 if (ui_out_is_mi_like_p (uiout
))
5988 printf_filtered ("\n");
5992 static struct bp_location
*
5993 add_location_to_breakpoint (struct breakpoint
*b
,
5994 const struct symtab_and_line
*sal
)
5996 struct bp_location
*loc
, **tmp
;
5998 loc
= allocate_bp_location (b
);
5999 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
6002 loc
->gdbarch
= get_sal_arch (*sal
);
6004 loc
->gdbarch
= b
->gdbarch
;
6005 loc
->requested_address
= sal
->pc
;
6006 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
6007 loc
->requested_address
, b
->type
);
6008 loc
->pspace
= sal
->pspace
;
6009 gdb_assert (loc
->pspace
!= NULL
);
6010 loc
->section
= sal
->section
;
6012 set_breakpoint_location_function (loc
);
6017 /* Return 1 if LOC is pointing to a permanent breakpoint,
6018 return 0 otherwise. */
6021 bp_loc_is_permanent (struct bp_location
*loc
)
6025 const gdb_byte
*brk
;
6026 gdb_byte
*target_mem
;
6027 struct cleanup
*cleanup
;
6030 gdb_assert (loc
!= NULL
);
6032 addr
= loc
->address
;
6033 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
6035 /* Software breakpoints unsupported? */
6039 target_mem
= alloca (len
);
6041 /* Enable the automatic memory restoration from breakpoints while
6042 we read the memory. Otherwise we could say about our temporary
6043 breakpoints they are permanent. */
6044 cleanup
= save_current_space_and_thread ();
6046 switch_to_program_space_and_thread (loc
->pspace
);
6047 make_show_memory_breakpoints_cleanup (0);
6049 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
6050 && memcmp (target_mem
, brk
, len
) == 0)
6053 do_cleanups (cleanup
);
6060 /* Create a breakpoint with SAL as location. Use ADDR_STRING
6061 as textual description of the location, and COND_STRING
6062 as condition expression. */
6065 create_breakpoint (struct gdbarch
*gdbarch
,
6066 struct symtabs_and_lines sals
, char *addr_string
,
6068 enum bptype type
, enum bpdisp disposition
,
6069 int thread
, int task
, int ignore_count
,
6070 struct breakpoint_ops
*ops
, int from_tty
, int enabled
)
6072 struct breakpoint
*b
= NULL
;
6075 if (type
== bp_hardware_breakpoint
)
6077 int i
= hw_breakpoint_used_count ();
6078 int target_resources_ok
=
6079 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
6081 if (target_resources_ok
== 0)
6082 error (_("No hardware breakpoint support in the target."));
6083 else if (target_resources_ok
< 0)
6084 error (_("Hardware breakpoints used exceeds limit."));
6087 gdb_assert (sals
.nelts
> 0);
6089 for (i
= 0; i
< sals
.nelts
; ++i
)
6091 struct symtab_and_line sal
= sals
.sals
[i
];
6092 struct bp_location
*loc
;
6096 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
6098 loc_gdbarch
= gdbarch
;
6100 describe_other_breakpoints (loc_gdbarch
,
6101 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
6106 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
6107 set_breakpoint_count (breakpoint_count
+ 1);
6108 b
->number
= breakpoint_count
;
6112 b
->cond_string
= cond_string
;
6113 b
->ignore_count
= ignore_count
;
6114 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
6115 b
->disposition
= disposition
;
6117 b
->pspace
= sals
.sals
[0].pspace
;
6119 if (enabled
&& b
->pspace
->executing_startup
6120 && (b
->type
== bp_breakpoint
6121 || b
->type
== bp_hardware_breakpoint
))
6122 b
->enable_state
= bp_startup_disabled
;
6128 loc
= add_location_to_breakpoint (b
, &sal
);
6131 if (bp_loc_is_permanent (loc
))
6132 make_breakpoint_permanent (b
);
6136 char *arg
= b
->cond_string
;
6137 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
6139 error (_("Garbage %s follows condition"), arg
);
6144 b
->addr_string
= addr_string
;
6146 /* addr_string has to be used or breakpoint_re_set will delete
6149 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
6155 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
6156 elements to fill the void space. */
6158 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
6160 int i
= index_to_remove
+1;
6161 int last_index
= sal
->nelts
-1;
6163 for (;i
<= last_index
; ++i
)
6164 sal
->sals
[i
-1] = sal
->sals
[i
];
6169 /* If appropriate, obtains all sals that correspond to the same file
6170 and line as SAL, in all program spaces. Users debugging with IDEs,
6171 will want to set a breakpoint at foo.c:line, and not really care
6172 about program spaces. This is done only if SAL does not have
6173 explicit PC and has line and file information. If we got just a
6174 single expanded sal, return the original.
6176 Otherwise, if SAL.explicit_line is not set, filter out all sals for
6177 which the name of enclosing function is different from SAL. This
6178 makes sure that if we have breakpoint originally set in template
6179 instantiation, say foo<int>(), we won't expand SAL to locations at
6180 the same line in all existing instantiations of 'foo'. */
6182 static struct symtabs_and_lines
6183 expand_line_sal_maybe (struct symtab_and_line sal
)
6185 struct symtabs_and_lines expanded
;
6186 CORE_ADDR original_pc
= sal
.pc
;
6187 char *original_function
= NULL
;
6190 struct cleanup
*old_chain
;
6192 /* If we have explicit pc, don't expand.
6193 If we have no line number, we can't expand. */
6194 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
6197 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6198 expanded
.sals
[0] = sal
;
6204 old_chain
= save_current_space_and_thread ();
6206 switch_to_program_space_and_thread (sal
.pspace
);
6208 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
6210 /* Note that expand_line_sal visits *all* program spaces. */
6211 expanded
= expand_line_sal (sal
);
6213 if (expanded
.nelts
== 1)
6215 /* We had one sal, we got one sal. Without futher
6216 processing, just return the original sal. */
6217 xfree (expanded
.sals
);
6219 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6220 sal
.pc
= original_pc
;
6221 expanded
.sals
[0] = sal
;
6222 do_cleanups (old_chain
);
6226 if (!sal
.explicit_line
)
6228 CORE_ADDR func_addr
, func_end
;
6229 for (i
= 0; i
< expanded
.nelts
; ++i
)
6231 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
6232 char *this_function
;
6234 /* We need to switch threads as well since we're about to
6236 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
6238 if (find_pc_partial_function (pc
, &this_function
,
6239 &func_addr
, &func_end
))
6242 && strcmp (this_function
, original_function
) != 0)
6244 remove_sal (&expanded
, i
);
6247 else if (func_addr
== pc
)
6249 /* We're at beginning of a function, and should
6251 struct symbol
*sym
= find_pc_function (pc
);
6253 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
6256 /* Since find_pc_partial_function returned true,
6257 we should really always find the section here. */
6258 struct obj_section
*section
= find_pc_section (pc
);
6261 struct gdbarch
*gdbarch
6262 = get_objfile_arch (section
->objfile
);
6264 = gdbarch_skip_prologue (gdbarch
, pc
);
6273 for (i
= 0; i
< expanded
.nelts
; ++i
)
6275 /* If this SAL corresponds to a breakpoint inserted using a
6276 line number, then skip the function prologue if necessary. */
6277 skip_prologue_sal (&expanded
.sals
[i
]);
6281 do_cleanups (old_chain
);
6283 if (expanded
.nelts
<= 1)
6285 /* This is un ugly workaround. If we get zero
6286 expanded sals then something is really wrong.
6287 Fix that by returnign the original sal. */
6288 xfree (expanded
.sals
);
6290 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6291 sal
.pc
= original_pc
;
6292 expanded
.sals
[0] = sal
;
6299 for (i
= 0; i
< expanded
.nelts
; ++i
)
6300 if (expanded
.sals
[i
].pc
== original_pc
)
6311 /* Add SALS.nelts breakpoints to the breakpoint table. For each
6312 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
6313 value. COND_STRING, if not NULL, specified the condition to be
6314 used for all breakpoints. Essentially the only case where
6315 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
6316 function. In that case, it's still not possible to specify
6317 separate conditions for different overloaded functions, so
6318 we take just a single condition string.
6320 NOTE: If the function succeeds, the caller is expected to cleanup
6321 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
6322 array contents). If the function fails (error() is called), the
6323 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
6324 COND and SALS arrays and each of those arrays contents. */
6327 create_breakpoints (struct gdbarch
*gdbarch
,
6328 struct symtabs_and_lines sals
, char **addr_string
,
6330 enum bptype type
, enum bpdisp disposition
,
6331 int thread
, int task
, int ignore_count
,
6332 struct breakpoint_ops
*ops
, int from_tty
,
6336 for (i
= 0; i
< sals
.nelts
; ++i
)
6338 struct symtabs_and_lines expanded
=
6339 expand_line_sal_maybe (sals
.sals
[i
]);
6341 create_breakpoint (gdbarch
, expanded
, addr_string
[i
],
6342 cond_string
, type
, disposition
,
6343 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
6347 /* Parse ARG which is assumed to be a SAL specification possibly
6348 followed by conditionals. On return, SALS contains an array of SAL
6349 addresses found. ADDR_STRING contains a vector of (canonical)
6350 address strings. ARG points to the end of the SAL. */
6353 parse_breakpoint_sals (char **address
,
6354 struct symtabs_and_lines
*sals
,
6355 char ***addr_string
,
6358 char *addr_start
= *address
;
6359 *addr_string
= NULL
;
6360 /* If no arg given, or if first arg is 'if ', use the default
6362 if ((*address
) == NULL
6363 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
6365 if (default_breakpoint_valid
)
6367 struct symtab_and_line sal
;
6368 init_sal (&sal
); /* initialize to zeroes */
6369 sals
->sals
= (struct symtab_and_line
*)
6370 xmalloc (sizeof (struct symtab_and_line
));
6371 sal
.pc
= default_breakpoint_address
;
6372 sal
.line
= default_breakpoint_line
;
6373 sal
.symtab
= default_breakpoint_symtab
;
6374 sal
.pspace
= default_breakpoint_pspace
;
6375 sal
.section
= find_pc_overlay (sal
.pc
);
6377 /* "break" without arguments is equivalent to "break *PC" where PC is
6378 the default_breakpoint_address. So make sure to set
6379 sal.explicit_pc to prevent GDB from trying to expand the list of
6380 sals to include all other instances with the same symtab and line.
6382 sal
.explicit_pc
= 1;
6384 sals
->sals
[0] = sal
;
6388 error (_("No default breakpoint address now."));
6392 /* Force almost all breakpoints to be in terms of the
6393 current_source_symtab (which is decode_line_1's default). This
6394 should produce the results we want almost all of the time while
6395 leaving default_breakpoint_* alone.
6396 ObjC: However, don't match an Objective-C method name which
6397 may have a '+' or '-' succeeded by a '[' */
6399 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
6401 if (default_breakpoint_valid
6403 || ((strchr ("+-", (*address
)[0]) != NULL
)
6404 && ((*address
)[1] != '['))))
6405 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
6406 default_breakpoint_line
, addr_string
,
6409 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
6410 addr_string
, not_found_ptr
);
6412 /* For any SAL that didn't have a canonical string, fill one in. */
6413 if (sals
->nelts
> 0 && *addr_string
== NULL
)
6414 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
6415 if (addr_start
!= (*address
))
6418 for (i
= 0; i
< sals
->nelts
; i
++)
6420 /* Add the string if not present. */
6421 if ((*addr_string
)[i
] == NULL
)
6422 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
6428 /* Convert each SAL into a real PC. Verify that the PC can be
6429 inserted as a breakpoint. If it can't throw an error. */
6432 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
6436 for (i
= 0; i
< sals
->nelts
; i
++)
6437 resolve_sal_pc (&sals
->sals
[i
]);
6441 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
6443 struct captured_parse_breakpoint_args
*args
= data
;
6445 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
6446 args
->not_found_ptr
);
6449 /* Given TOK, a string specification of condition and thread, as
6450 accepted by the 'break' command, extract the condition
6451 string and thread number and set *COND_STRING and *THREAD.
6452 PC identifies the context at which the condition should be parsed.
6453 If no condition is found, *COND_STRING is set to NULL.
6454 If no thread is found, *THREAD is set to -1. */
6456 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
6457 char **cond_string
, int *thread
, int *task
)
6459 *cond_string
= NULL
;
6465 char *cond_start
= NULL
;
6466 char *cond_end
= NULL
;
6467 while (*tok
== ' ' || *tok
== '\t')
6472 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
6475 toklen
= end_tok
- tok
;
6477 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
6479 struct expression
*expr
;
6481 tok
= cond_start
= end_tok
+ 1;
6482 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
6485 *cond_string
= savestring (cond_start
,
6486 cond_end
- cond_start
);
6488 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
6494 *thread
= strtol (tok
, &tok
, 0);
6496 error (_("Junk after thread keyword."));
6497 if (!valid_thread_id (*thread
))
6498 error (_("Unknown thread %d."), *thread
);
6500 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
6506 *task
= strtol (tok
, &tok
, 0);
6508 error (_("Junk after task keyword."));
6509 if (!valid_task_id (*task
))
6510 error (_("Unknown task %d\n"), *task
);
6513 error (_("Junk at end of arguments."));
6517 /* Set a breakpoint. This function is shared between
6518 CLI and MI functions for setting a breakpoint.
6519 This function has two major modes of operations,
6520 selected by the PARSE_CONDITION_AND_THREAD parameter.
6521 If non-zero, the function will parse arg, extracting
6522 breakpoint location, address and thread. Otherwise,
6523 ARG is just the location of breakpoint, with condition
6524 and thread specified by the COND_STRING and THREAD
6528 break_command_really (struct gdbarch
*gdbarch
,
6529 char *arg
, char *cond_string
, int thread
,
6530 int parse_condition_and_thread
,
6531 int tempflag
, int hardwareflag
, int traceflag
,
6533 enum auto_boolean pending_break_support
,
6534 struct breakpoint_ops
*ops
,
6538 struct gdb_exception e
;
6539 struct symtabs_and_lines sals
;
6540 struct symtab_and_line pending_sal
;
6543 char *addr_start
= arg
;
6545 struct cleanup
*old_chain
;
6546 struct cleanup
*bkpt_chain
= NULL
;
6547 struct captured_parse_breakpoint_args parse_args
;
6551 enum bptype type_wanted
;
6558 parse_args
.arg_p
= &arg
;
6559 parse_args
.sals_p
= &sals
;
6560 parse_args
.addr_string_p
= &addr_string
;
6561 parse_args
.not_found_ptr
= ¬_found
;
6563 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
6564 &parse_args
, RETURN_MASK_ALL
);
6566 /* If caller is interested in rc value from parse, set value. */
6570 throw_exception (e
);
6574 case NOT_FOUND_ERROR
:
6576 /* If pending breakpoint support is turned off, throw
6579 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
6580 throw_exception (e
);
6582 exception_print (gdb_stderr
, e
);
6584 /* If pending breakpoint support is auto query and the user
6585 selects no, then simply return the error code. */
6586 if (pending_break_support
== AUTO_BOOLEAN_AUTO
6587 && !nquery ("Make breakpoint pending on future shared library load? "))
6590 /* At this point, either the user was queried about setting
6591 a pending breakpoint and selected yes, or pending
6592 breakpoint behavior is on and thus a pending breakpoint
6593 is defaulted on behalf of the user. */
6594 copy_arg
= xstrdup (addr_start
);
6595 addr_string
= ©_arg
;
6597 sals
.sals
= &pending_sal
;
6602 throw_exception (e
);
6609 /* Create a chain of things that always need to be cleaned up. */
6610 old_chain
= make_cleanup (null_cleanup
, 0);
6614 /* Make sure that all storage allocated to SALS gets freed. */
6615 make_cleanup (xfree
, sals
.sals
);
6617 /* Cleanup the addr_string array but not its contents. */
6618 make_cleanup (xfree
, addr_string
);
6621 /* ----------------------------- SNIP -----------------------------
6622 Anything added to the cleanup chain beyond this point is assumed
6623 to be part of a breakpoint. If the breakpoint create succeeds
6624 then the memory is not reclaimed. */
6625 bkpt_chain
= make_cleanup (null_cleanup
, 0);
6627 /* Mark the contents of the addr_string for cleanup. These go on
6628 the bkpt_chain and only occur if the breakpoint create fails. */
6629 for (i
= 0; i
< sals
.nelts
; i
++)
6631 if (addr_string
[i
] != NULL
)
6632 make_cleanup (xfree
, addr_string
[i
]);
6635 /* Resolve all line numbers to PC's and verify that the addresses
6636 are ok for the target. */
6638 breakpoint_sals_to_pc (&sals
, addr_start
);
6640 type_wanted
= (traceflag
6642 : (hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
));
6644 /* Verify that condition can be parsed, before setting any
6645 breakpoints. Allocate a separate condition expression for each
6649 if (parse_condition_and_thread
)
6651 /* Here we only parse 'arg' to separate condition
6652 from thread number, so parsing in context of first
6653 sal is OK. When setting the breakpoint we'll
6654 re-parse it in context of each sal. */
6657 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
6660 make_cleanup (xfree
, cond_string
);
6664 /* Create a private copy of condition string. */
6667 cond_string
= xstrdup (cond_string
);
6668 make_cleanup (xfree
, cond_string
);
6671 create_breakpoints (gdbarch
, sals
, addr_string
, cond_string
, type_wanted
,
6672 tempflag
? disp_del
: disp_donttouch
,
6673 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
6677 struct symtab_and_line sal
= {0};
6678 struct breakpoint
*b
;
6680 make_cleanup (xfree
, copy_arg
);
6682 b
= set_raw_breakpoint_without_location (gdbarch
, type_wanted
);
6683 set_breakpoint_count (breakpoint_count
+ 1);
6684 b
->number
= breakpoint_count
;
6686 b
->addr_string
= addr_string
[0];
6687 b
->cond_string
= NULL
;
6688 b
->ignore_count
= ignore_count
;
6689 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6690 b
->condition_not_parsed
= 1;
6692 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
6693 b
->pspace
= current_program_space
;
6695 if (enabled
&& b
->pspace
->executing_startup
6696 && (b
->type
== bp_breakpoint
6697 || b
->type
== bp_hardware_breakpoint
))
6698 b
->enable_state
= bp_startup_disabled
;
6704 warning (_("Multiple breakpoints were set.\n"
6705 "Use the \"delete\" command to delete unwanted breakpoints."));
6706 /* That's it. Discard the cleanups for data inserted into the
6708 discard_cleanups (bkpt_chain
);
6709 /* But cleanup everything else. */
6710 do_cleanups (old_chain
);
6712 /* error call may happen here - have BKPT_CHAIN already discarded. */
6713 update_global_location_list (1);
6716 /* Set a breakpoint.
6717 ARG is a string describing breakpoint address,
6718 condition, and thread.
6719 FLAG specifies if a breakpoint is hardware on,
6720 and if breakpoint is temporary, using BP_HARDWARE_FLAG
6724 break_command_1 (char *arg
, int flag
, int from_tty
)
6726 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
6727 int tempflag
= flag
& BP_TEMPFLAG
;
6729 break_command_really (get_current_arch (),
6731 NULL
, 0, 1 /* parse arg */,
6732 tempflag
, hardwareflag
, 0 /* traceflag */,
6733 0 /* Ignore count */,
6734 pending_break_support
,
6735 NULL
/* breakpoint_ops */,
6742 set_breakpoint (struct gdbarch
*gdbarch
,
6743 char *address
, char *condition
,
6744 int hardwareflag
, int tempflag
,
6745 int thread
, int ignore_count
,
6746 int pending
, int enabled
)
6748 break_command_really (gdbarch
,
6749 address
, condition
, thread
,
6750 0 /* condition and thread are valid. */,
6751 tempflag
, hardwareflag
, 0 /* traceflag */,
6754 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
6758 /* Adjust SAL to the first instruction past the function prologue.
6759 The end of the prologue is determined using the line table from
6760 the debugging information. explicit_pc and explicit_line are
6763 If SAL is already past the prologue, then do nothing. */
6766 skip_prologue_sal (struct symtab_and_line
*sal
)
6769 struct symtab_and_line start_sal
;
6770 struct cleanup
*old_chain
;
6772 old_chain
= save_current_space_and_thread ();
6774 sym
= find_pc_function (sal
->pc
);
6777 start_sal
= find_function_start_sal (sym
, 1);
6778 if (sal
->pc
< start_sal
.pc
)
6780 start_sal
.explicit_line
= sal
->explicit_line
;
6781 start_sal
.explicit_pc
= sal
->explicit_pc
;
6786 do_cleanups (old_chain
);
6789 /* Helper function for break_command_1 and disassemble_command. */
6792 resolve_sal_pc (struct symtab_and_line
*sal
)
6796 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
6798 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
6799 error (_("No line %d in file \"%s\"."),
6800 sal
->line
, sal
->symtab
->filename
);
6803 /* If this SAL corresponds to a breakpoint inserted using
6804 a line number, then skip the function prologue if necessary. */
6805 if (sal
->explicit_line
)
6807 /* Preserve the original line number. */
6808 int saved_line
= sal
->line
;
6809 skip_prologue_sal (sal
);
6810 sal
->line
= saved_line
;
6814 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
6816 struct blockvector
*bv
;
6820 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
6823 sym
= block_linkage_function (b
);
6826 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
6827 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
6831 /* It really is worthwhile to have the section, so we'll just
6832 have to look harder. This case can be executed if we have
6833 line numbers but no functions (as can happen in assembly
6836 struct minimal_symbol
*msym
;
6837 struct cleanup
*old_chain
= save_current_space_and_thread ();
6839 switch_to_program_space_and_thread (sal
->pspace
);
6841 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
6843 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
6845 do_cleanups (old_chain
);
6852 break_command (char *arg
, int from_tty
)
6854 break_command_1 (arg
, 0, from_tty
);
6858 tbreak_command (char *arg
, int from_tty
)
6860 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
6864 hbreak_command (char *arg
, int from_tty
)
6866 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
6870 thbreak_command (char *arg
, int from_tty
)
6872 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
6876 stop_command (char *arg
, int from_tty
)
6878 printf_filtered (_("Specify the type of breakpoint to set.\n\
6879 Usage: stop in <function | address>\n\
6880 stop at <line>\n"));
6884 stopin_command (char *arg
, int from_tty
)
6888 if (arg
== (char *) NULL
)
6890 else if (*arg
!= '*')
6895 /* look for a ':'. If this is a line number specification, then
6896 say it is bad, otherwise, it should be an address or
6897 function/method name */
6898 while (*argptr
&& !hasColon
)
6900 hasColon
= (*argptr
== ':');
6905 badInput
= (*argptr
!= ':'); /* Not a class::method */
6907 badInput
= isdigit (*arg
); /* a simple line number */
6911 printf_filtered (_("Usage: stop in <function | address>\n"));
6913 break_command_1 (arg
, 0, from_tty
);
6917 stopat_command (char *arg
, int from_tty
)
6921 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
6928 /* look for a ':'. If there is a '::' then get out, otherwise
6929 it is probably a line number. */
6930 while (*argptr
&& !hasColon
)
6932 hasColon
= (*argptr
== ':');
6937 badInput
= (*argptr
== ':'); /* we have class::method */
6939 badInput
= !isdigit (*arg
); /* not a line number */
6943 printf_filtered (_("Usage: stop at <line>\n"));
6945 break_command_1 (arg
, 0, from_tty
);
6948 /* accessflag: hw_write: watch write,
6949 hw_read: watch read,
6950 hw_access: watch access (read or write) */
6952 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
6954 struct gdbarch
*gdbarch
= get_current_arch ();
6955 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
6956 struct symtab_and_line sal
;
6957 struct expression
*exp
;
6958 struct block
*exp_valid_block
;
6959 struct value
*val
, *mark
;
6960 struct frame_info
*frame
;
6961 char *exp_start
= NULL
;
6962 char *exp_end
= NULL
;
6963 char *tok
, *id_tok_start
, *end_tok
;
6965 char *cond_start
= NULL
;
6966 char *cond_end
= NULL
;
6967 struct expression
*cond
= NULL
;
6968 int i
, other_type_used
, target_resources_ok
= 0;
6969 enum bptype bp_type
;
6973 init_sal (&sal
); /* initialize to zeroes */
6975 /* Make sure that we actually have parameters to parse. */
6976 if (arg
!= NULL
&& arg
[0] != '\0')
6978 toklen
= strlen (arg
); /* Size of argument list. */
6980 /* Points tok to the end of the argument list. */
6981 tok
= arg
+ toklen
- 1;
6983 /* Go backwards in the parameters list. Skip the last parameter.
6984 If we're expecting a 'thread <thread_num>' parameter, this should
6985 be the thread identifier. */
6986 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6988 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6991 /* Points end_tok to the beginning of the last token. */
6992 id_tok_start
= tok
+ 1;
6994 /* Go backwards in the parameters list. Skip one more parameter.
6995 If we're expecting a 'thread <thread_num>' parameter, we should
6996 reach a "thread" token. */
6997 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
7002 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
7005 /* Move the pointer forward to skip the whitespace and
7006 calculate the length of the token. */
7008 toklen
= end_tok
- tok
;
7010 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7012 /* At this point we've found a "thread" token, which means
7013 the user is trying to set a watchpoint that triggers
7014 only in a specific thread. */
7017 /* Extract the thread ID from the next token. */
7018 thread
= strtol (id_tok_start
, &endp
, 0);
7020 /* Check if the user provided a valid numeric value for the
7022 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
7023 error (_("Invalid thread ID specification %s."), id_tok_start
);
7025 /* Check if the thread actually exists. */
7026 if (!valid_thread_id (thread
))
7027 error (_("Unknown thread %d."), thread
);
7029 /* Truncate the string and get rid of the thread <thread_num>
7030 parameter before the parameter list is parsed by the
7031 evaluate_expression() function. */
7036 sal
.pspace
= current_program_space
;
7038 /* Parse the rest of the arguments. */
7039 innermost_block
= NULL
;
7041 exp
= parse_exp_1 (&arg
, 0, 0);
7043 /* Remove trailing whitespace from the expression before saving it.
7044 This makes the eventual display of the expression string a bit
7046 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
7049 exp_valid_block
= innermost_block
;
7050 mark
= value_mark ();
7051 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
7053 release_value (val
);
7056 while (*tok
== ' ' || *tok
== '\t')
7060 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
7063 toklen
= end_tok
- tok
;
7064 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7066 tok
= cond_start
= end_tok
+ 1;
7067 cond
= parse_exp_1 (&tok
, 0, 0);
7071 error (_("Junk at end of command."));
7073 if (accessflag
== hw_read
)
7074 bp_type
= bp_read_watchpoint
;
7075 else if (accessflag
== hw_access
)
7076 bp_type
= bp_access_watchpoint
;
7078 bp_type
= bp_hardware_watchpoint
;
7080 mem_cnt
= can_use_hardware_watchpoint (val
);
7081 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
7082 error (_("Expression cannot be implemented with read/access watchpoint."));
7085 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
7086 target_resources_ok
=
7087 target_can_use_hardware_watchpoint (bp_type
, i
+ mem_cnt
,
7089 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
7090 error (_("Target does not support this type of hardware watchpoint."));
7092 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
7093 error (_("Target can only support one kind of HW watchpoint at a time."));
7096 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
7097 watchpoint could not be set. */
7098 if (!mem_cnt
|| target_resources_ok
<= 0)
7099 bp_type
= bp_watchpoint
;
7101 frame
= block_innermost_frame (exp_valid_block
);
7103 /* If the expression is "local", then set up a "watchpoint scope"
7104 breakpoint at the point where we've left the scope of the watchpoint
7105 expression. Create the scope breakpoint before the watchpoint, so
7106 that we will encounter it first in bpstat_stop_status. */
7107 if (innermost_block
&& frame
)
7109 if (frame_id_p (frame_unwind_caller_id (frame
)))
7112 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
7113 frame_unwind_caller_pc (frame
),
7114 bp_watchpoint_scope
);
7116 scope_breakpoint
->enable_state
= bp_enabled
;
7118 /* Automatically delete the breakpoint when it hits. */
7119 scope_breakpoint
->disposition
= disp_del
;
7121 /* Only break in the proper frame (help with recursion). */
7122 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
7124 /* Set the address at which we will stop. */
7125 scope_breakpoint
->loc
->gdbarch
7126 = frame_unwind_caller_arch (frame
);
7127 scope_breakpoint
->loc
->requested_address
7128 = frame_unwind_caller_pc (frame
);
7129 scope_breakpoint
->loc
->address
7130 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
7131 scope_breakpoint
->loc
->requested_address
,
7132 scope_breakpoint
->type
);
7136 /* Now set up the breakpoint. */
7137 b
= set_raw_breakpoint (gdbarch
, sal
, bp_type
);
7138 set_breakpoint_count (breakpoint_count
+ 1);
7139 b
->number
= breakpoint_count
;
7141 b
->disposition
= disp_donttouch
;
7143 b
->exp_valid_block
= exp_valid_block
;
7144 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
7147 b
->loc
->cond
= cond
;
7149 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
7154 b
->watchpoint_frame
= get_frame_id (frame
);
7156 b
->watchpoint_frame
= null_frame_id
;
7158 if (scope_breakpoint
!= NULL
)
7160 /* The scope breakpoint is related to the watchpoint. We will
7161 need to act on them together. */
7162 b
->related_breakpoint
= scope_breakpoint
;
7163 scope_breakpoint
->related_breakpoint
= b
;
7166 value_free_to_mark (mark
);
7168 update_global_location_list (1);
7171 /* Return count of locations need to be watched and can be handled
7172 in hardware. If the watchpoint can not be handled
7173 in hardware return zero. */
7176 can_use_hardware_watchpoint (struct value
*v
)
7178 int found_memory_cnt
= 0;
7179 struct value
*head
= v
;
7181 /* Did the user specifically forbid us to use hardware watchpoints? */
7182 if (!can_use_hw_watchpoints
)
7185 /* Make sure that the value of the expression depends only upon
7186 memory contents, and values computed from them within GDB. If we
7187 find any register references or function calls, we can't use a
7188 hardware watchpoint.
7190 The idea here is that evaluating an expression generates a series
7191 of values, one holding the value of every subexpression. (The
7192 expression a*b+c has five subexpressions: a, b, a*b, c, and
7193 a*b+c.) GDB's values hold almost enough information to establish
7194 the criteria given above --- they identify memory lvalues,
7195 register lvalues, computed values, etcetera. So we can evaluate
7196 the expression, and then scan the chain of values that leaves
7197 behind to decide whether we can detect any possible change to the
7198 expression's final value using only hardware watchpoints.
7200 However, I don't think that the values returned by inferior
7201 function calls are special in any way. So this function may not
7202 notice that an expression involving an inferior function call
7203 can't be watched with hardware watchpoints. FIXME. */
7204 for (; v
; v
= value_next (v
))
7206 if (VALUE_LVAL (v
) == lval_memory
)
7209 /* A lazy memory lvalue is one that GDB never needed to fetch;
7210 we either just used its address (e.g., `a' in `a.b') or
7211 we never needed it at all (e.g., `a' in `a,b'). */
7215 /* Ahh, memory we actually used! Check if we can cover
7216 it with hardware watchpoints. */
7217 struct type
*vtype
= check_typedef (value_type (v
));
7219 /* We only watch structs and arrays if user asked for it
7220 explicitly, never if they just happen to appear in a
7221 middle of some value chain. */
7223 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
7224 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
7226 CORE_ADDR vaddr
= value_address (v
);
7227 int len
= TYPE_LENGTH (value_type (v
));
7229 if (!target_region_ok_for_hw_watchpoint (vaddr
, len
))
7236 else if (VALUE_LVAL (v
) != not_lval
7237 && deprecated_value_modifiable (v
) == 0)
7238 return 0; /* ??? What does this represent? */
7239 else if (VALUE_LVAL (v
) == lval_register
)
7240 return 0; /* cannot watch a register with a HW watchpoint */
7243 /* The expression itself looks suitable for using a hardware
7244 watchpoint, but give the target machine a chance to reject it. */
7245 return found_memory_cnt
;
7249 watch_command_wrapper (char *arg
, int from_tty
)
7251 watch_command (arg
, from_tty
);
7255 watch_command (char *arg
, int from_tty
)
7257 watch_command_1 (arg
, hw_write
, from_tty
);
7261 rwatch_command_wrapper (char *arg
, int from_tty
)
7263 rwatch_command (arg
, from_tty
);
7267 rwatch_command (char *arg
, int from_tty
)
7269 watch_command_1 (arg
, hw_read
, from_tty
);
7273 awatch_command_wrapper (char *arg
, int from_tty
)
7275 awatch_command (arg
, from_tty
);
7279 awatch_command (char *arg
, int from_tty
)
7281 watch_command_1 (arg
, hw_access
, from_tty
);
7285 /* Helper routines for the until_command routine in infcmd.c. Here
7286 because it uses the mechanisms of breakpoints. */
7288 struct until_break_command_continuation_args
7290 struct breakpoint
*breakpoint
;
7291 struct breakpoint
*breakpoint2
;
7294 /* This function is called by fetch_inferior_event via the
7295 cmd_continuation pointer, to complete the until command. It takes
7296 care of cleaning up the temporary breakpoints set up by the until
7299 until_break_command_continuation (void *arg
)
7301 struct until_break_command_continuation_args
*a
= arg
;
7303 delete_breakpoint (a
->breakpoint
);
7305 delete_breakpoint (a
->breakpoint2
);
7309 until_break_command (char *arg
, int from_tty
, int anywhere
)
7311 struct symtabs_and_lines sals
;
7312 struct symtab_and_line sal
;
7313 struct frame_info
*frame
= get_selected_frame (NULL
);
7314 struct breakpoint
*breakpoint
;
7315 struct breakpoint
*breakpoint2
= NULL
;
7316 struct cleanup
*old_chain
;
7318 clear_proceed_status ();
7320 /* Set a breakpoint where the user wants it and at return from
7323 if (default_breakpoint_valid
)
7324 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
7325 default_breakpoint_line
, (char ***) NULL
, NULL
);
7327 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
7328 0, (char ***) NULL
, NULL
);
7330 if (sals
.nelts
!= 1)
7331 error (_("Couldn't get information on specified line."));
7334 xfree (sals
.sals
); /* malloc'd, so freed */
7337 error (_("Junk at end of arguments."));
7339 resolve_sal_pc (&sal
);
7342 /* If the user told us to continue until a specified location,
7343 we don't specify a frame at which we need to stop. */
7344 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
7345 null_frame_id
, bp_until
);
7347 /* Otherwise, specify the selected frame, because we want to stop only
7348 at the very same frame. */
7349 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
7350 get_stack_frame_id (frame
),
7353 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
7355 /* Keep within the current frame, or in frames called by the current
7358 if (frame_id_p (frame_unwind_caller_id (frame
)))
7360 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
7361 sal
.pc
= frame_unwind_caller_pc (frame
);
7362 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
7364 frame_unwind_caller_id (frame
),
7366 make_cleanup_delete_breakpoint (breakpoint2
);
7369 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
7371 /* If we are running asynchronously, and proceed call above has actually
7372 managed to start the target, arrange for breakpoints to be
7373 deleted when the target stops. Otherwise, we're already stopped and
7374 delete breakpoints via cleanup chain. */
7376 if (target_can_async_p () && is_running (inferior_ptid
))
7378 struct until_break_command_continuation_args
*args
;
7379 args
= xmalloc (sizeof (*args
));
7381 args
->breakpoint
= breakpoint
;
7382 args
->breakpoint2
= breakpoint2
;
7384 discard_cleanups (old_chain
);
7385 add_continuation (inferior_thread (),
7386 until_break_command_continuation
, args
,
7390 do_cleanups (old_chain
);
7394 ep_skip_leading_whitespace (char **s
)
7396 if ((s
== NULL
) || (*s
== NULL
))
7398 while (isspace (**s
))
7402 /* This function attempts to parse an optional "if <cond>" clause
7403 from the arg string. If one is not found, it returns NULL.
7405 Else, it returns a pointer to the condition string. (It does not
7406 attempt to evaluate the string against a particular block.) And,
7407 it updates arg to point to the first character following the parsed
7408 if clause in the arg string. */
7411 ep_parse_optional_if_clause (char **arg
)
7415 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
7418 /* Skip the "if" keyword. */
7421 /* Skip any extra leading whitespace, and record the start of the
7422 condition string. */
7423 ep_skip_leading_whitespace (arg
);
7426 /* Assume that the condition occupies the remainder of the arg string. */
7427 (*arg
) += strlen (cond_string
);
7432 /* This function attempts to parse an optional filename from the arg
7433 string. If one is not found, it returns NULL.
7435 Else, it returns a pointer to the parsed filename. (This function
7436 makes no attempt to verify that a file of that name exists, or is
7437 accessible.) And, it updates arg to point to the first character
7438 following the parsed filename in the arg string.
7440 Note that clients needing to preserve the returned filename for
7441 future access should copy it to their own buffers. */
7443 ep_parse_optional_filename (char **arg
)
7445 static char filename
[1024];
7450 if ((*arg_p
== '\0') || isspace (*arg_p
))
7468 /* Commands to deal with catching events, such as signals, exceptions,
7469 process start/exit, etc. */
7473 catch_fork_temporary
, catch_vfork_temporary
,
7474 catch_fork_permanent
, catch_vfork_permanent
7479 catch_fork_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7481 struct gdbarch
*gdbarch
= get_current_arch ();
7482 char *cond_string
= NULL
;
7483 catch_fork_kind fork_kind
;
7486 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
7487 tempflag
= (fork_kind
== catch_fork_temporary
7488 || fork_kind
== catch_vfork_temporary
);
7492 ep_skip_leading_whitespace (&arg
);
7494 /* The allowed syntax is:
7496 catch [v]fork if <cond>
7498 First, check if there's an if clause. */
7499 cond_string
= ep_parse_optional_if_clause (&arg
);
7501 if ((*arg
!= '\0') && !isspace (*arg
))
7502 error (_("Junk at end of arguments."));
7504 /* If this target supports it, create a fork or vfork catchpoint
7505 and enable reporting of such events. */
7508 case catch_fork_temporary
:
7509 case catch_fork_permanent
:
7510 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
7511 &catch_fork_breakpoint_ops
);
7513 case catch_vfork_temporary
:
7514 case catch_vfork_permanent
:
7515 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
7516 &catch_vfork_breakpoint_ops
);
7519 error (_("unsupported or unknown fork kind; cannot catch it"));
7525 catch_exec_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7527 struct gdbarch
*gdbarch
= get_current_arch ();
7529 char *cond_string
= NULL
;
7531 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7535 ep_skip_leading_whitespace (&arg
);
7537 /* The allowed syntax is:
7539 catch exec if <cond>
7541 First, check if there's an if clause. */
7542 cond_string
= ep_parse_optional_if_clause (&arg
);
7544 if ((*arg
!= '\0') && !isspace (*arg
))
7545 error (_("Junk at end of arguments."));
7547 /* If this target supports it, create an exec catchpoint
7548 and enable reporting of such events. */
7549 create_catchpoint (gdbarch
, tempflag
, cond_string
,
7550 &catch_exec_breakpoint_ops
);
7553 static enum print_stop_action
7554 print_exception_catchpoint (struct breakpoint
*b
)
7556 int bp_temp
, bp_throw
;
7558 annotate_catchpoint (b
->number
);
7560 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
7561 if (b
->loc
->address
!= b
->loc
->requested_address
)
7562 breakpoint_adjustment_warning (b
->loc
->requested_address
,
7565 bp_temp
= b
->disposition
== disp_del
;
7567 bp_temp
? "Temporary catchpoint "
7569 if (!ui_out_is_mi_like_p (uiout
))
7570 ui_out_field_int (uiout
, "bkptno", b
->number
);
7572 bp_throw
? " (exception thrown), "
7573 : " (exception caught), ");
7574 if (ui_out_is_mi_like_p (uiout
))
7576 ui_out_field_string (uiout
, "reason",
7577 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
7578 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
7579 ui_out_field_int (uiout
, "bkptno", b
->number
);
7581 return PRINT_SRC_AND_LOC
;
7585 print_one_exception_catchpoint (struct breakpoint
*b
, struct bp_location
**last_loc
)
7587 struct value_print_options opts
;
7588 get_user_print_options (&opts
);
7589 if (opts
.addressprint
)
7592 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
7593 ui_out_field_string (uiout
, "addr", "<PENDING>");
7595 ui_out_field_core_addr (uiout
, "addr",
7596 b
->loc
->gdbarch
, b
->loc
->address
);
7601 if (strstr (b
->addr_string
, "throw") != NULL
)
7602 ui_out_field_string (uiout
, "what", "exception throw");
7604 ui_out_field_string (uiout
, "what", "exception catch");
7608 print_mention_exception_catchpoint (struct breakpoint
*b
)
7613 bp_temp
= b
->disposition
== disp_del
;
7614 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
7615 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
7616 : _("Catchpoint "));
7617 ui_out_field_int (uiout
, "bkptno", b
->number
);
7618 ui_out_text (uiout
, bp_throw
? _(" (throw)")
7622 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
7625 NULL
, /* breakpoint_hit */
7626 print_exception_catchpoint
,
7627 print_one_exception_catchpoint
,
7628 print_mention_exception_catchpoint
7632 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
7633 enum exception_event_kind ex_event
, int from_tty
)
7635 char *trigger_func_name
;
7637 if (ex_event
== EX_EVENT_CATCH
)
7638 trigger_func_name
= "__cxa_begin_catch";
7640 trigger_func_name
= "__cxa_throw";
7642 break_command_really (get_current_arch (),
7643 trigger_func_name
, cond_string
, -1,
7644 0 /* condition and thread are valid. */,
7647 AUTO_BOOLEAN_TRUE
/* pending */,
7648 &gnu_v3_exception_catchpoint_ops
, from_tty
,
7654 /* Deal with "catch catch" and "catch throw" commands */
7657 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
7658 int tempflag
, int from_tty
)
7660 char *cond_string
= NULL
;
7661 struct symtab_and_line
*sal
= NULL
;
7665 ep_skip_leading_whitespace (&arg
);
7667 cond_string
= ep_parse_optional_if_clause (&arg
);
7669 if ((*arg
!= '\0') && !isspace (*arg
))
7670 error (_("Junk at end of arguments."));
7672 if (ex_event
!= EX_EVENT_THROW
7673 && ex_event
!= EX_EVENT_CATCH
)
7674 error (_("Unsupported or unknown exception event; cannot catch it"));
7676 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
7679 warning (_("Unsupported with this platform/compiler combination."));
7682 /* Implementation of "catch catch" command. */
7685 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7687 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7688 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
7691 /* Implementation of "catch throw" command. */
7694 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7696 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7697 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
7700 /* Create a breakpoint struct for Ada exception catchpoints. */
7703 create_ada_exception_breakpoint (struct gdbarch
*gdbarch
,
7704 struct symtab_and_line sal
,
7708 struct expression
*cond
,
7709 struct breakpoint_ops
*ops
,
7713 struct breakpoint
*b
;
7717 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
7719 loc_gdbarch
= gdbarch
;
7721 describe_other_breakpoints (loc_gdbarch
,
7722 sal
.pspace
, sal
.pc
, sal
.section
, -1);
7723 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
7724 version for exception catchpoints, because two catchpoints
7725 used for different exception names will use the same address.
7726 In this case, a "breakpoint ... also set at..." warning is
7727 unproductive. Besides. the warning phrasing is also a bit
7728 inapropriate, we should use the word catchpoint, and tell
7729 the user what type of catchpoint it is. The above is good
7730 enough for now, though. */
7733 b
= set_raw_breakpoint (gdbarch
, sal
, bp_breakpoint
);
7734 set_breakpoint_count (breakpoint_count
+ 1);
7736 b
->enable_state
= bp_enabled
;
7737 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
7738 b
->number
= breakpoint_count
;
7739 b
->ignore_count
= 0;
7740 b
->loc
->cond
= cond
;
7741 b
->addr_string
= addr_string
;
7742 b
->language
= language_ada
;
7743 b
->cond_string
= cond_string
;
7744 b
->exp_string
= exp_string
;
7749 update_global_location_list (1);
7752 /* Implement the "catch exception" command. */
7755 catch_ada_exception_command (char *arg
, int from_tty
,
7756 struct cmd_list_element
*command
)
7758 struct gdbarch
*gdbarch
= get_current_arch ();
7760 struct symtab_and_line sal
;
7762 char *addr_string
= NULL
;
7763 char *exp_string
= NULL
;
7764 char *cond_string
= NULL
;
7765 struct expression
*cond
= NULL
;
7766 struct breakpoint_ops
*ops
= NULL
;
7768 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7772 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
7773 &cond_string
, &cond
, &ops
);
7774 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, exp_string
,
7775 cond_string
, cond
, ops
, tempflag
,
7779 /* Cleanup function for a syscall filter list. */
7781 clean_up_filters (void *arg
)
7783 VEC(int) *iter
= *(VEC(int) **) arg
;
7784 VEC_free (int, iter
);
7787 /* Splits the argument using space as delimiter. Returns an xmalloc'd
7788 filter list, or NULL if no filtering is required. */
7790 catch_syscall_split_args (char *arg
)
7792 VEC(int) *result
= NULL
;
7793 struct cleanup
*cleanup
= make_cleanup (clean_up_filters
, &result
);
7795 while (*arg
!= '\0')
7797 int i
, syscall_number
;
7802 /* Skip whitespace. */
7803 while (isspace (*arg
))
7806 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
7807 cur_name
[i
] = arg
[i
];
7811 /* Check if the user provided a syscall name or a number. */
7812 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
7813 if (*endptr
== '\0')
7814 get_syscall_by_number (syscall_number
, &s
);
7817 /* We have a name. Let's check if it's valid and convert it
7819 get_syscall_by_name (cur_name
, &s
);
7821 if (s
.number
== UNKNOWN_SYSCALL
)
7822 /* Here we have to issue an error instead of a warning, because
7823 GDB cannot do anything useful if there's no syscall number to
7825 error (_("Unknown syscall name '%s'."), cur_name
);
7828 /* Ok, it's valid. */
7829 VEC_safe_push (int, result
, s
.number
);
7832 discard_cleanups (cleanup
);
7836 /* Implement the "catch syscall" command. */
7839 catch_syscall_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7844 struct gdbarch
*gdbarch
= get_current_arch ();
7846 /* Checking if the feature if supported. */
7847 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
7848 error (_("The feature 'catch syscall' is not supported on \
7849 this architeture yet."));
7851 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7853 ep_skip_leading_whitespace (&arg
);
7855 /* We need to do this first "dummy" translation in order
7856 to get the syscall XML file loaded or, most important,
7857 to display a warning to the user if there's no XML file
7858 for his/her architecture. */
7859 get_syscall_by_number (0, &s
);
7861 /* The allowed syntax is:
7863 catch syscall <name | number> [<name | number> ... <name | number>]
7865 Let's check if there's a syscall name. */
7868 filter
= catch_syscall_split_args (arg
);
7872 create_syscall_event_catchpoint (tempflag
, filter
,
7873 &catch_syscall_breakpoint_ops
);
7876 /* Implement the "catch assert" command. */
7879 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7881 struct gdbarch
*gdbarch
= get_current_arch ();
7883 struct symtab_and_line sal
;
7884 char *addr_string
= NULL
;
7885 struct breakpoint_ops
*ops
= NULL
;
7887 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7891 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
7892 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, NULL
, NULL
, NULL
,
7893 ops
, tempflag
, from_tty
);
7897 catch_command (char *arg
, int from_tty
)
7899 error (_("Catch requires an event name."));
7904 tcatch_command (char *arg
, int from_tty
)
7906 error (_("Catch requires an event name."));
7909 /* Delete breakpoints by address or line. */
7912 clear_command (char *arg
, int from_tty
)
7914 struct breakpoint
*b
;
7915 VEC(breakpoint_p
) *found
= 0;
7918 struct symtabs_and_lines sals
;
7919 struct symtab_and_line sal
;
7924 sals
= decode_line_spec (arg
, 1);
7929 sals
.sals
= (struct symtab_and_line
*)
7930 xmalloc (sizeof (struct symtab_and_line
));
7931 make_cleanup (xfree
, sals
.sals
);
7932 init_sal (&sal
); /* initialize to zeroes */
7933 sal
.line
= default_breakpoint_line
;
7934 sal
.symtab
= default_breakpoint_symtab
;
7935 sal
.pc
= default_breakpoint_address
;
7936 sal
.pspace
= default_breakpoint_pspace
;
7937 if (sal
.symtab
== 0)
7938 error (_("No source file specified."));
7946 /* We don't call resolve_sal_pc here. That's not
7947 as bad as it seems, because all existing breakpoints
7948 typically have both file/line and pc set. So, if
7949 clear is given file/line, we can match this to existing
7950 breakpoint without obtaining pc at all.
7952 We only support clearing given the address explicitly
7953 present in breakpoint table. Say, we've set breakpoint
7954 at file:line. There were several PC values for that file:line,
7955 due to optimization, all in one block.
7956 We've picked one PC value. If "clear" is issued with another
7957 PC corresponding to the same file:line, the breakpoint won't
7958 be cleared. We probably can still clear the breakpoint, but
7959 since the other PC value is never presented to user, user
7960 can only find it by guessing, and it does not seem important
7963 /* For each line spec given, delete bps which correspond
7964 to it. Do it in two passes, solely to preserve the current
7965 behavior that from_tty is forced true if we delete more than
7969 for (i
= 0; i
< sals
.nelts
; i
++)
7971 /* If exact pc given, clear bpts at that pc.
7972 If line given (pc == 0), clear all bpts on specified line.
7973 If defaulting, clear all bpts on default line
7976 defaulting sal.pc != 0 tests to do
7981 1 0 <can't happen> */
7985 /* Find all matching breakpoints and add them to
7990 /* Are we going to delete b? */
7991 if (b
->type
!= bp_none
7992 && b
->type
!= bp_watchpoint
7993 && b
->type
!= bp_hardware_watchpoint
7994 && b
->type
!= bp_read_watchpoint
7995 && b
->type
!= bp_access_watchpoint
)
7997 struct bp_location
*loc
= b
->loc
;
7998 for (; loc
; loc
= loc
->next
)
8000 int pc_match
= sal
.pc
8001 && (loc
->pspace
== sal
.pspace
)
8002 && (loc
->address
== sal
.pc
)
8003 && (!section_is_overlay (loc
->section
)
8004 || loc
->section
== sal
.section
);
8005 int line_match
= ((default_match
|| (0 == sal
.pc
))
8006 && b
->source_file
!= NULL
8007 && sal
.symtab
!= NULL
8008 && sal
.pspace
== loc
->pspace
8009 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
8010 && b
->line_number
== sal
.line
);
8011 if (pc_match
|| line_match
)
8020 VEC_safe_push(breakpoint_p
, found
, b
);
8023 /* Now go thru the 'found' chain and delete them. */
8024 if (VEC_empty(breakpoint_p
, found
))
8027 error (_("No breakpoint at %s."), arg
);
8029 error (_("No breakpoint at this line."));
8032 if (VEC_length(breakpoint_p
, found
) > 1)
8033 from_tty
= 1; /* Always report if deleted more than one */
8036 if (VEC_length(breakpoint_p
, found
) == 1)
8037 printf_unfiltered (_("Deleted breakpoint "));
8039 printf_unfiltered (_("Deleted breakpoints "));
8041 breakpoints_changed ();
8043 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
8046 printf_unfiltered ("%d ", b
->number
);
8047 delete_breakpoint (b
);
8050 putchar_unfiltered ('\n');
8053 /* Delete breakpoint in BS if they are `delete' breakpoints and
8054 all breakpoints that are marked for deletion, whether hit or not.
8055 This is called after any breakpoint is hit, or after errors. */
8058 breakpoint_auto_delete (bpstat bs
)
8060 struct breakpoint
*b
, *temp
;
8062 for (; bs
; bs
= bs
->next
)
8063 if (bs
->breakpoint_at
8064 && bs
->breakpoint_at
->owner
8065 && bs
->breakpoint_at
->owner
->disposition
== disp_del
8067 delete_breakpoint (bs
->breakpoint_at
->owner
);
8069 ALL_BREAKPOINTS_SAFE (b
, temp
)
8071 if (b
->disposition
== disp_del_at_next_stop
)
8072 delete_breakpoint (b
);
8076 /* A comparison function for bp_location A and B being interfaced to qsort.
8077 Sort elements primarily by their ADDRESS (no matter what does
8078 breakpoint_address_is_meaningful say for its OWNER), secondarily by ordering
8079 first bp_permanent OWNERed elements and terciarily just ensuring the array
8080 is sorted stable way despite qsort being an instable algorithm. */
8083 bp_location_compare (struct bp_location
*a
, struct bp_location
*b
)
8085 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
8086 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
8088 if (a
->address
!= b
->address
)
8089 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
8091 /* Sort permanent breakpoints first. */
8092 if (a_perm
!= b_perm
)
8093 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
8095 /* Make the user-visible order stable across GDB runs. Locations of the same
8096 breakpoint can be sorted in arbitrary order. */
8098 if (a
->owner
->number
!= b
->owner
->number
)
8099 return (a
->owner
->number
> b
->owner
->number
)
8100 - (a
->owner
->number
< b
->owner
->number
);
8102 return (a
> b
) - (a
< b
);
8105 /* Interface bp_location_compare as the COMPAR parameter of qsort function. */
8108 bp_location_compare_for_qsort (const void *ap
, const void *bp
)
8110 struct bp_location
*a
= *(void **) ap
;
8111 struct bp_location
*b
= *(void **) bp
;
8113 return bp_location_compare (a
, b
);
8116 /* Set bp_location_placed_address_before_address_max and
8117 bp_location_shadow_len_after_address_max according to the current content of
8118 the bp_location array. */
8121 bp_location_target_extensions_update (void)
8123 struct bp_location
*bl
, **blp_tmp
;
8125 bp_location_placed_address_before_address_max
= 0;
8126 bp_location_shadow_len_after_address_max
= 0;
8128 ALL_BP_LOCATIONS (bl
, blp_tmp
)
8130 CORE_ADDR start
, end
, addr
;
8132 if (!bp_location_has_shadow (bl
))
8135 start
= bl
->target_info
.placed_address
;
8136 end
= start
+ bl
->target_info
.shadow_len
;
8138 gdb_assert (bl
->address
>= start
);
8139 addr
= bl
->address
- start
;
8140 if (addr
> bp_location_placed_address_before_address_max
)
8141 bp_location_placed_address_before_address_max
= addr
;
8143 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
8145 gdb_assert (bl
->address
< end
);
8146 addr
= end
- bl
->address
;
8147 if (addr
> bp_location_shadow_len_after_address_max
)
8148 bp_location_shadow_len_after_address_max
= addr
;
8152 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
8153 into the inferior, only remove already-inserted locations that no
8154 longer should be inserted. Functions that delete a breakpoint or
8155 breakpoints should pass false, so that deleting a breakpoint
8156 doesn't have the side effect of inserting the locations of other
8157 breakpoints that are marked not-inserted, but should_be_inserted
8158 returns true on them.
8160 This behaviour is useful is situations close to tear-down -- e.g.,
8161 after an exec, while the target still has execution, but breakpoint
8162 shadows of the previous executable image should *NOT* be restored
8163 to the new image; or before detaching, where the target still has
8164 execution and wants to delete breakpoints from GDB's lists, and all
8165 breakpoints had already been removed from the inferior. */
8168 update_global_location_list (int should_insert
)
8170 struct breakpoint
*b
;
8171 struct bp_location
**locp
, *loc
;
8172 struct cleanup
*cleanups
;
8174 /* The first bp_location being the only one non-DUPLICATE for the current run
8175 of the same ADDRESS. */
8176 struct bp_location
*loc_first
;
8178 /* Saved former bp_location array which we compare against the newly built
8179 bp_location from the current state of ALL_BREAKPOINTS. */
8180 struct bp_location
**old_location
, **old_locp
;
8181 unsigned old_location_count
;
8183 old_location
= bp_location
;
8184 old_location_count
= bp_location_count
;
8186 bp_location_count
= 0;
8187 cleanups
= make_cleanup (xfree
, old_location
);
8190 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
8191 bp_location_count
++;
8193 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
8196 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
8198 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
8199 bp_location_compare_for_qsort
);
8201 bp_location_target_extensions_update ();
8203 /* Identify bp_location instances that are no longer present in the new
8204 list, and therefore should be freed. Note that it's not necessary that
8205 those locations should be removed from inferior -- if there's another
8206 location at the same address (previously marked as duplicate),
8207 we don't need to remove/insert the location.
8209 LOCP is kept in sync with OLD_LOCP, each pointing to the current and
8210 former bp_location array state respectively. */
8213 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
8216 struct bp_location
*old_loc
= *old_locp
;
8217 struct bp_location
**loc2p
;
8219 /* Tells if 'old_loc' is found amoung the new locations. If not, we
8221 int found_object
= 0;
8222 /* Tells if the location should remain inserted in the target. */
8223 int keep_in_target
= 0;
8226 /* Skip LOCP entries which will definitely never be needed. Stop either
8227 at or being the one matching OLD_LOC. */
8228 while (locp
< bp_location
+ bp_location_count
8229 && (*locp
)->address
< old_loc
->address
)
8233 (loc2p
< bp_location
+ bp_location_count
8234 && (*loc2p
)->address
== old_loc
->address
);
8237 if (*loc2p
== old_loc
)
8244 /* If this location is no longer present, and inserted, look if there's
8245 maybe a new location at the same address. If so, mark that one
8246 inserted, and don't remove this one. This is needed so that we
8247 don't have a time window where a breakpoint at certain location is not
8250 if (old_loc
->inserted
)
8252 /* If the location is inserted now, we might have to remove it. */
8254 if (found_object
&& should_be_inserted (old_loc
))
8256 /* The location is still present in the location list, and still
8257 should be inserted. Don't do anything. */
8262 /* The location is either no longer present, or got disabled.
8263 See if there's another location at the same address, in which
8264 case we don't need to remove this one from the target. */
8266 if (breakpoint_address_is_meaningful (old_loc
->owner
))
8269 (loc2p
< bp_location
+ bp_location_count
8270 && (*loc2p
)->address
== old_loc
->address
);
8273 struct bp_location
*loc2
= *loc2p
;
8275 if (breakpoint_address_match (loc2
->pspace
->aspace
,
8277 old_loc
->pspace
->aspace
,
8280 /* For the sake of should_be_inserted.
8281 Duplicates check below will fix up this later. */
8282 loc2
->duplicate
= 0;
8283 if (loc2
!= old_loc
&& should_be_inserted (loc2
))
8286 loc2
->target_info
= old_loc
->target_info
;
8295 if (!keep_in_target
)
8297 if (remove_breakpoint (old_loc
, mark_uninserted
))
8299 /* This is just about all we can do. We could keep this
8300 location on the global list, and try to remove it next
8301 time, but there's no particular reason why we will
8304 Note that at this point, old_loc->owner is still valid,
8305 as delete_breakpoint frees the breakpoint only
8306 after calling us. */
8307 printf_filtered (_("warning: Error removing breakpoint %d\n"),
8308 old_loc
->owner
->number
);
8316 if (removed
&& non_stop
8317 && breakpoint_address_is_meaningful (old_loc
->owner
)
8318 && !is_hardware_watchpoint (old_loc
->owner
))
8320 /* This location was removed from the target. In
8321 non-stop mode, a race condition is possible where
8322 we've removed a breakpoint, but stop events for that
8323 breakpoint are already queued and will arrive later.
8324 We apply an heuristic to be able to distinguish such
8325 SIGTRAPs from other random SIGTRAPs: we keep this
8326 breakpoint location for a bit, and will retire it
8327 after we see some number of events. The theory here
8328 is that reporting of events should, "on the average",
8329 be fair, so after a while we'll see events from all
8330 threads that have anything of interest, and no longer
8331 need to keep this breakpoint location around. We
8332 don't hold locations forever so to reduce chances of
8333 mistaking a non-breakpoint SIGTRAP for a breakpoint
8336 The heuristic failing can be disastrous on
8337 decr_pc_after_break targets.
8339 On decr_pc_after_break targets, like e.g., x86-linux,
8340 if we fail to recognize a late breakpoint SIGTRAP,
8341 because events_till_retirement has reached 0 too
8342 soon, we'll fail to do the PC adjustment, and report
8343 a random SIGTRAP to the user. When the user resumes
8344 the inferior, it will most likely immediately crash
8345 with SIGILL/SIGBUS/SEGSEGV, or worse, get silently
8346 corrupted, because of being resumed e.g., in the
8347 middle of a multi-byte instruction, or skipped a
8348 one-byte instruction. This was actually seen happen
8349 on native x86-linux, and should be less rare on
8350 targets that do not support new thread events, like
8351 remote, due to the heuristic depending on
8354 Mistaking a random SIGTRAP for a breakpoint trap
8355 causes similar symptoms (PC adjustment applied when
8356 it shouldn't), but then again, playing with SIGTRAPs
8357 behind the debugger's back is asking for trouble.
8359 Since hardware watchpoint traps are always
8360 distinguishable from other traps, so we don't need to
8361 apply keep hardware watchpoint moribund locations
8362 around. We simply always ignore hardware watchpoint
8363 traps we can no longer explain. */
8365 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
8366 old_loc
->owner
= NULL
;
8368 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
8371 free_bp_location (old_loc
);
8375 /* Rescan breakpoints at the same address and section,
8376 marking the first one as "first" and any others as "duplicates".
8377 This is so that the bpt instruction is only inserted once.
8378 If we have a permanent breakpoint at the same place as BPT, make
8379 that one the official one, and the rest as duplicates. Permanent
8380 breakpoints are sorted first for the same address. */
8383 ALL_BP_LOCATIONS (loc
, locp
)
8385 struct breakpoint
*b
= loc
->owner
;
8387 if (b
->enable_state
== bp_disabled
8388 || b
->enable_state
== bp_call_disabled
8389 || b
->enable_state
== bp_startup_disabled
8391 || loc
->shlib_disabled
8392 || !breakpoint_address_is_meaningful (b
))
8395 /* Permanent breakpoint should always be inserted. */
8396 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
8397 internal_error (__FILE__
, __LINE__
,
8398 _("allegedly permanent breakpoint is not "
8399 "actually inserted"));
8401 if (loc_first
== NULL
8402 || (overlay_debugging
&& loc
->section
!= loc_first
->section
)
8403 || !breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
8404 loc_first
->pspace
->aspace
,
8405 loc_first
->address
))
8414 if (loc_first
->owner
->enable_state
== bp_permanent
&& loc
->inserted
8415 && b
->enable_state
!= bp_permanent
)
8416 internal_error (__FILE__
, __LINE__
,
8417 _("another breakpoint was inserted on top of "
8418 "a permanent breakpoint"));
8421 if (breakpoints_always_inserted_mode () && should_insert
8422 && (have_live_inferiors ()
8423 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
8424 insert_breakpoint_locations ();
8426 do_cleanups (cleanups
);
8430 breakpoint_retire_moribund (void)
8432 struct bp_location
*loc
;
8435 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
8436 if (--(loc
->events_till_retirement
) == 0)
8438 free_bp_location (loc
);
8439 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
8445 update_global_location_list_nothrow (int inserting
)
8447 struct gdb_exception e
;
8448 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8449 update_global_location_list (inserting
);
8452 /* Clear BPT from a BPS. */
8454 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
8457 for (bs
= bps
; bs
; bs
= bs
->next
)
8458 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
8460 bs
->breakpoint_at
= NULL
;
8462 /* bs->commands will be freed later. */
8466 /* Callback for iterate_over_threads. */
8468 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
8470 struct breakpoint
*bpt
= data
;
8471 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
8475 /* Delete a breakpoint and clean up all traces of it in the data
8479 delete_breakpoint (struct breakpoint
*bpt
)
8481 struct breakpoint
*b
;
8482 struct bp_location
*loc
, *next
;
8484 gdb_assert (bpt
!= NULL
);
8486 /* Has this bp already been deleted? This can happen because multiple
8487 lists can hold pointers to bp's. bpstat lists are especial culprits.
8489 One example of this happening is a watchpoint's scope bp. When the
8490 scope bp triggers, we notice that the watchpoint is out of scope, and
8491 delete it. We also delete its scope bp. But the scope bp is marked
8492 "auto-deleting", and is already on a bpstat. That bpstat is then
8493 checked for auto-deleting bp's, which are deleted.
8495 A real solution to this problem might involve reference counts in bp's,
8496 and/or giving them pointers back to their referencing bpstat's, and
8497 teaching delete_breakpoint to only free a bp's storage when no more
8498 references were extent. A cheaper bandaid was chosen. */
8499 if (bpt
->type
== bp_none
)
8502 observer_notify_breakpoint_deleted (bpt
->number
);
8504 if (breakpoint_chain
== bpt
)
8505 breakpoint_chain
= bpt
->next
;
8510 b
->next
= bpt
->next
;
8514 free_command_lines (&bpt
->commands
);
8515 if (bpt
->cond_string
!= NULL
)
8516 xfree (bpt
->cond_string
);
8517 if (bpt
->addr_string
!= NULL
)
8518 xfree (bpt
->addr_string
);
8519 if (bpt
->exp
!= NULL
)
8521 if (bpt
->exp_string
!= NULL
)
8522 xfree (bpt
->exp_string
);
8523 if (bpt
->val
!= NULL
)
8524 value_free (bpt
->val
);
8525 if (bpt
->source_file
!= NULL
)
8526 xfree (bpt
->source_file
);
8527 if (bpt
->exec_pathname
!= NULL
)
8528 xfree (bpt
->exec_pathname
);
8529 clean_up_filters (&bpt
->syscalls_to_be_caught
);
8531 /* Be sure no bpstat's are pointing at it after it's been freed. */
8532 /* FIXME, how can we find all bpstat's?
8533 We just check stop_bpstat for now. Note that we cannot just
8534 remove bpstats pointing at bpt from the stop_bpstat list
8535 entirely, as breakpoint commands are associated with the bpstat;
8536 if we remove it here, then the later call to
8537 bpstat_do_actions (&stop_bpstat);
8538 in event-top.c won't do anything, and temporary breakpoints
8539 with commands won't work. */
8541 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
8543 /* Now that breakpoint is removed from breakpoint
8544 list, update the global location list. This
8545 will remove locations that used to belong to
8546 this breakpoint. Do this before freeing
8547 the breakpoint itself, since remove_breakpoint
8548 looks at location's owner. It might be better
8549 design to have location completely self-contained,
8550 but it's not the case now. */
8551 update_global_location_list (0);
8554 /* On the chance that someone will soon try again to delete this same
8555 bp, we mark it as deleted before freeing its storage. */
8556 bpt
->type
= bp_none
;
8562 do_delete_breakpoint_cleanup (void *b
)
8564 delete_breakpoint (b
);
8568 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
8570 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
8574 delete_command (char *arg
, int from_tty
)
8576 struct breakpoint
*b
, *temp
;
8582 int breaks_to_delete
= 0;
8584 /* Delete all breakpoints if no argument.
8585 Do not delete internal or call-dummy breakpoints, these
8586 have to be deleted with an explicit breakpoint number argument. */
8589 if (b
->type
!= bp_call_dummy
8590 && b
->type
!= bp_shlib_event
8591 && b
->type
!= bp_jit_event
8592 && b
->type
!= bp_thread_event
8593 && b
->type
!= bp_overlay_event
8594 && b
->type
!= bp_longjmp_master
8597 breaks_to_delete
= 1;
8602 /* Ask user only if there are some breakpoints to delete. */
8604 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
8606 ALL_BREAKPOINTS_SAFE (b
, temp
)
8608 if (b
->type
!= bp_call_dummy
8609 && b
->type
!= bp_shlib_event
8610 && b
->type
!= bp_thread_event
8611 && b
->type
!= bp_jit_event
8612 && b
->type
!= bp_overlay_event
8613 && b
->type
!= bp_longjmp_master
8615 delete_breakpoint (b
);
8620 map_breakpoint_numbers (arg
, delete_breakpoint
);
8624 all_locations_are_pending (struct bp_location
*loc
)
8626 for (; loc
; loc
= loc
->next
)
8627 if (!loc
->shlib_disabled
)
8632 /* Subroutine of update_breakpoint_locations to simplify it.
8633 Return non-zero if multiple fns in list LOC have the same name.
8634 Null names are ignored. */
8637 ambiguous_names_p (struct bp_location
*loc
)
8639 struct bp_location
*l
;
8640 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
8641 (int (*) (const void *, const void *)) streq
,
8642 NULL
, xcalloc
, xfree
);
8644 for (l
= loc
; l
!= NULL
; l
= l
->next
)
8647 const char *name
= l
->function_name
;
8649 /* Allow for some names to be NULL, ignore them. */
8653 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
8655 /* NOTE: We can assume slot != NULL here because xcalloc never returns
8670 update_breakpoint_locations (struct breakpoint
*b
,
8671 struct symtabs_and_lines sals
)
8675 struct bp_location
*existing_locations
= b
->loc
;
8677 /* If there's no new locations, and all existing locations
8678 are pending, don't do anything. This optimizes
8679 the common case where all locations are in the same
8680 shared library, that was unloaded. We'd like to
8681 retain the location, so that when the library
8682 is loaded again, we don't loose the enabled/disabled
8683 status of the individual locations. */
8684 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
8689 for (i
= 0; i
< sals
.nelts
; ++i
)
8691 struct bp_location
*new_loc
=
8692 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
8694 /* Reparse conditions, they might contain references to the
8696 if (b
->cond_string
!= NULL
)
8698 struct gdb_exception e
;
8701 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8703 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
8708 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
8709 b
->number
, e
.message
);
8710 new_loc
->enabled
= 0;
8714 if (b
->source_file
!= NULL
)
8715 xfree (b
->source_file
);
8716 if (sals
.sals
[i
].symtab
== NULL
)
8717 b
->source_file
= NULL
;
8719 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
8721 if (b
->line_number
== 0)
8722 b
->line_number
= sals
.sals
[i
].line
;
8725 /* Update locations of permanent breakpoints. */
8726 if (b
->enable_state
== bp_permanent
)
8727 make_breakpoint_permanent (b
);
8729 /* If possible, carry over 'disable' status from existing breakpoints. */
8731 struct bp_location
*e
= existing_locations
;
8732 /* If there are multiple breakpoints with the same function name,
8733 e.g. for inline functions, comparing function names won't work.
8734 Instead compare pc addresses; this is just a heuristic as things
8735 may have moved, but in practice it gives the correct answer
8736 often enough until a better solution is found. */
8737 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
8739 for (; e
; e
= e
->next
)
8741 if (!e
->enabled
&& e
->function_name
)
8743 struct bp_location
*l
= b
->loc
;
8744 if (have_ambiguous_names
)
8746 for (; l
; l
= l
->next
)
8747 if (breakpoint_address_match (e
->pspace
->aspace
, e
->address
,
8748 l
->pspace
->aspace
, l
->address
))
8756 for (; l
; l
= l
->next
)
8757 if (l
->function_name
8758 && strcmp (e
->function_name
, l
->function_name
) == 0)
8768 update_global_location_list (1);
8772 /* Reset a breakpoint given it's struct breakpoint * BINT.
8773 The value we return ends up being the return value from catch_errors.
8774 Unused in this case. */
8777 breakpoint_re_set_one (void *bint
)
8779 /* get past catch_errs */
8780 struct breakpoint
*b
= (struct breakpoint
*) bint
;
8784 int *not_found_ptr
= ¬_found
;
8785 struct symtabs_and_lines sals
= {0};
8786 struct symtabs_and_lines expanded
= {0};
8788 enum enable_state save_enable
;
8789 struct gdb_exception e
;
8790 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
8795 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
8799 case bp_hardware_breakpoint
:
8801 /* Do not attempt to re-set breakpoints disabled during startup. */
8802 if (b
->enable_state
== bp_startup_disabled
)
8805 if (b
->addr_string
== NULL
)
8807 /* Anything without a string can't be re-set. */
8808 delete_breakpoint (b
);
8812 set_language (b
->language
);
8813 input_radix
= b
->input_radix
;
8816 save_current_space_and_thread ();
8817 switch_to_program_space_and_thread (b
->pspace
);
8819 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8821 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
8826 int not_found_and_ok
= 0;
8827 /* For pending breakpoints, it's expected that parsing
8828 will fail until the right shared library is loaded.
8829 User has already told to create pending breakpoints and
8830 don't need extra messages. If breakpoint is in bp_shlib_disabled
8831 state, then user already saw the message about that breakpoint
8832 being disabled, and don't want to see more errors. */
8834 && (b
->condition_not_parsed
8835 || (b
->loc
&& b
->loc
->shlib_disabled
)
8836 || b
->enable_state
== bp_disabled
))
8837 not_found_and_ok
= 1;
8839 if (!not_found_and_ok
)
8841 /* We surely don't want to warn about the same breakpoint
8842 10 times. One solution, implemented here, is disable
8843 the breakpoint on error. Another solution would be to
8844 have separate 'warning emitted' flag. Since this
8845 happens only when a binary has changed, I don't know
8846 which approach is better. */
8847 b
->enable_state
= bp_disabled
;
8848 throw_exception (e
);
8854 gdb_assert (sals
.nelts
== 1);
8856 resolve_sal_pc (&sals
.sals
[0]);
8857 if (b
->condition_not_parsed
&& s
&& s
[0])
8859 char *cond_string
= 0;
8863 find_condition_and_thread (s
, sals
.sals
[0].pc
,
8864 &cond_string
, &thread
, &task
);
8866 b
->cond_string
= cond_string
;
8869 b
->condition_not_parsed
= 0;
8872 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
8875 make_cleanup (xfree
, sals
.sals
);
8876 update_breakpoint_locations (b
, expanded
);
8880 case bp_hardware_watchpoint
:
8881 case bp_read_watchpoint
:
8882 case bp_access_watchpoint
:
8883 /* Watchpoint can be either on expression using entirely global variables,
8884 or it can be on local variables.
8886 Watchpoints of the first kind are never auto-deleted, and even persist
8887 across program restarts. Since they can use variables from shared
8888 libraries, we need to reparse expression as libraries are loaded
8891 Watchpoints on local variables can also change meaning as result
8892 of solib event. For example, if a watchpoint uses both a local and
8893 a global variables in expression, it's a local watchpoint, but
8894 unloading of a shared library will make the expression invalid.
8895 This is not a very common use case, but we still re-evaluate
8896 expression, to avoid surprises to the user.
8898 Note that for local watchpoints, we re-evaluate it only if
8899 watchpoints frame id is still valid. If it's not, it means
8900 the watchpoint is out of scope and will be deleted soon. In fact,
8901 I'm not sure we'll ever be called in this case.
8903 If a local watchpoint's frame id is still valid, then
8904 b->exp_valid_block is likewise valid, and we can safely use it.
8906 Don't do anything about disabled watchpoints, since they will
8907 be reevaluated again when enabled. */
8908 update_watchpoint (b
, 1 /* reparse */);
8910 /* We needn't really do anything to reset these, since the mask
8911 that requests them is unaffected by e.g., new libraries being
8917 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
8919 /* Delete overlay event and longjmp master breakpoints; they will be
8920 reset later by breakpoint_re_set. */
8921 case bp_overlay_event
:
8922 case bp_longjmp_master
:
8923 delete_breakpoint (b
);
8926 /* This breakpoint is special, it's set up when the inferior
8927 starts and we really don't want to touch it. */
8928 case bp_shlib_event
:
8930 /* Like bp_shlib_event, this breakpoint type is special.
8931 Once it is set up, we do not want to touch it. */
8932 case bp_thread_event
:
8934 /* Keep temporary breakpoints, which can be encountered when we step
8935 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
8936 Otherwise these should have been blown away via the cleanup chain
8937 or by breakpoint_init_inferior when we rerun the executable. */
8940 case bp_watchpoint_scope
:
8942 case bp_step_resume
:
8944 case bp_longjmp_resume
:
8949 do_cleanups (cleanups
);
8953 /* Re-set all breakpoints after symbols have been re-loaded. */
8955 breakpoint_re_set (void)
8957 struct breakpoint
*b
, *temp
;
8958 enum language save_language
;
8959 int save_input_radix
;
8960 struct cleanup
*old_chain
;
8962 save_language
= current_language
->la_language
;
8963 save_input_radix
= input_radix
;
8964 old_chain
= save_current_program_space ();
8966 ALL_BREAKPOINTS_SAFE (b
, temp
)
8968 /* Format possible error msg */
8969 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
8971 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
8972 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
8973 do_cleanups (cleanups
);
8975 set_language (save_language
);
8976 input_radix
= save_input_radix
;
8978 jit_breakpoint_re_set ();
8980 do_cleanups (old_chain
);
8982 create_overlay_event_breakpoint ("_ovly_debug_event");
8983 create_longjmp_master_breakpoint ("longjmp");
8984 create_longjmp_master_breakpoint ("_longjmp");
8985 create_longjmp_master_breakpoint ("siglongjmp");
8986 create_longjmp_master_breakpoint ("_siglongjmp");
8989 /* Reset the thread number of this breakpoint:
8991 - If the breakpoint is for all threads, leave it as-is.
8992 - Else, reset it to the current thread for inferior_ptid. */
8994 breakpoint_re_set_thread (struct breakpoint
*b
)
8996 if (b
->thread
!= -1)
8998 if (in_thread_list (inferior_ptid
))
8999 b
->thread
= pid_to_thread_id (inferior_ptid
);
9001 /* We're being called after following a fork. The new fork is
9002 selected as current, and unless this was a vfork will have a
9003 different program space from the original thread. Reset that
9005 b
->loc
->pspace
= current_program_space
;
9009 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
9010 If from_tty is nonzero, it prints a message to that effect,
9011 which ends with a period (no newline). */
9014 set_ignore_count (int bptnum
, int count
, int from_tty
)
9016 struct breakpoint
*b
;
9022 if (b
->number
== bptnum
)
9024 b
->ignore_count
= count
;
9028 printf_filtered (_("Will stop next time breakpoint %d is reached."),
9030 else if (count
== 1)
9031 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
9034 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
9037 breakpoints_changed ();
9038 observer_notify_breakpoint_modified (b
->number
);
9042 error (_("No breakpoint number %d."), bptnum
);
9046 make_breakpoint_silent (struct breakpoint
*b
)
9048 /* Silence the breakpoint. */
9052 /* Command to set ignore-count of breakpoint N to COUNT. */
9055 ignore_command (char *args
, int from_tty
)
9061 error_no_arg (_("a breakpoint number"));
9063 num
= get_number (&p
);
9065 error (_("bad breakpoint number: '%s'"), args
);
9067 error (_("Second argument (specified ignore-count) is missing."));
9069 set_ignore_count (num
,
9070 longest_to_int (value_as_long (parse_and_eval (p
))),
9073 printf_filtered ("\n");
9076 /* Call FUNCTION on each of the breakpoints
9077 whose numbers are given in ARGS. */
9080 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
9085 struct breakpoint
*b
, *tmp
;
9089 error_no_arg (_("one or more breakpoint numbers"));
9096 num
= get_number_or_range (&p1
);
9099 warning (_("bad breakpoint number at or near '%s'"), p
);
9103 ALL_BREAKPOINTS_SAFE (b
, tmp
)
9104 if (b
->number
== num
)
9106 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
9109 if (related_breakpoint
)
9110 function (related_breakpoint
);
9114 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
9120 static struct bp_location
*
9121 find_location_by_number (char *number
)
9123 char *dot
= strchr (number
, '.');
9127 struct breakpoint
*b
;
9128 struct bp_location
*loc
;
9133 bp_num
= get_number_or_range (&p1
);
9135 error (_("Bad breakpoint number '%s'"), number
);
9138 if (b
->number
== bp_num
)
9143 if (!b
|| b
->number
!= bp_num
)
9144 error (_("Bad breakpoint number '%s'"), number
);
9147 loc_num
= get_number_or_range (&p1
);
9149 error (_("Bad breakpoint location number '%s'"), number
);
9153 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
9156 error (_("Bad breakpoint location number '%s'"), dot
+1);
9162 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
9163 If from_tty is nonzero, it prints a message to that effect,
9164 which ends with a period (no newline). */
9167 disable_breakpoint (struct breakpoint
*bpt
)
9169 /* Never disable a watchpoint scope breakpoint; we want to
9170 hit them when we leave scope so we can delete both the
9171 watchpoint and its scope breakpoint at that time. */
9172 if (bpt
->type
== bp_watchpoint_scope
)
9175 /* You can't disable permanent breakpoints. */
9176 if (bpt
->enable_state
== bp_permanent
)
9179 bpt
->enable_state
= bp_disabled
;
9181 update_global_location_list (0);
9183 observer_notify_breakpoint_modified (bpt
->number
);
9187 disable_command (char *args
, int from_tty
)
9189 struct breakpoint
*bpt
;
9191 ALL_BREAKPOINTS (bpt
)
9195 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
9201 case bp_hardware_breakpoint
:
9203 case bp_hardware_watchpoint
:
9204 case bp_read_watchpoint
:
9205 case bp_access_watchpoint
:
9206 disable_breakpoint (bpt
);
9210 else if (strchr (args
, '.'))
9212 struct bp_location
*loc
= find_location_by_number (args
);
9215 update_global_location_list (0);
9218 map_breakpoint_numbers (args
, disable_breakpoint
);
9222 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
9224 int target_resources_ok
, other_type_used
;
9227 if (bpt
->type
== bp_hardware_breakpoint
)
9230 i
= hw_breakpoint_used_count ();
9231 target_resources_ok
=
9232 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9234 if (target_resources_ok
== 0)
9235 error (_("No hardware breakpoint support in the target."));
9236 else if (target_resources_ok
< 0)
9237 error (_("Hardware breakpoints used exceeds limit."));
9240 if (bpt
->type
== bp_watchpoint
9241 || bpt
->type
== bp_hardware_watchpoint
9242 || bpt
->type
== bp_read_watchpoint
9243 || bpt
->type
== bp_access_watchpoint
)
9245 struct gdb_exception e
;
9247 TRY_CATCH (e
, RETURN_MASK_ALL
)
9249 update_watchpoint (bpt
, 1 /* reparse */);
9253 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
9259 if (bpt
->enable_state
!= bp_permanent
)
9260 bpt
->enable_state
= bp_enabled
;
9261 bpt
->disposition
= disposition
;
9262 update_global_location_list (1);
9263 breakpoints_changed ();
9265 observer_notify_breakpoint_modified (bpt
->number
);
9270 enable_breakpoint (struct breakpoint
*bpt
)
9272 do_enable_breakpoint (bpt
, bpt
->disposition
);
9275 /* The enable command enables the specified breakpoints (or all defined
9276 breakpoints) so they once again become (or continue to be) effective
9277 in stopping the inferior. */
9280 enable_command (char *args
, int from_tty
)
9282 struct breakpoint
*bpt
;
9284 ALL_BREAKPOINTS (bpt
)
9288 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
9294 case bp_hardware_breakpoint
:
9296 case bp_hardware_watchpoint
:
9297 case bp_read_watchpoint
:
9298 case bp_access_watchpoint
:
9299 enable_breakpoint (bpt
);
9303 else if (strchr (args
, '.'))
9305 struct bp_location
*loc
= find_location_by_number (args
);
9308 update_global_location_list (1);
9311 map_breakpoint_numbers (args
, enable_breakpoint
);
9315 enable_once_breakpoint (struct breakpoint
*bpt
)
9317 do_enable_breakpoint (bpt
, disp_disable
);
9321 enable_once_command (char *args
, int from_tty
)
9323 map_breakpoint_numbers (args
, enable_once_breakpoint
);
9327 enable_delete_breakpoint (struct breakpoint
*bpt
)
9329 do_enable_breakpoint (bpt
, disp_del
);
9333 enable_delete_command (char *args
, int from_tty
)
9335 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
9339 set_breakpoint_cmd (char *args
, int from_tty
)
9344 show_breakpoint_cmd (char *args
, int from_tty
)
9348 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
9350 struct symtabs_and_lines
9351 decode_line_spec_1 (char *string
, int funfirstline
)
9353 struct symtabs_and_lines sals
;
9355 error (_("Empty line specification."));
9356 if (default_breakpoint_valid
)
9357 sals
= decode_line_1 (&string
, funfirstline
,
9358 default_breakpoint_symtab
,
9359 default_breakpoint_line
,
9360 (char ***) NULL
, NULL
);
9362 sals
= decode_line_1 (&string
, funfirstline
,
9363 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
9365 error (_("Junk at end of line specification: %s"), string
);
9369 /* Create and insert a raw software breakpoint at PC. Return an
9370 identifier, which should be used to remove the breakpoint later.
9371 In general, places which call this should be using something on the
9372 breakpoint chain instead; this function should be eliminated
9376 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
9377 struct address_space
*aspace
, CORE_ADDR pc
)
9379 struct bp_target_info
*bp_tgt
;
9381 bp_tgt
= XZALLOC (struct bp_target_info
);
9383 bp_tgt
->placed_address_space
= aspace
;
9384 bp_tgt
->placed_address
= pc
;
9386 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
9388 /* Could not insert the breakpoint. */
9396 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
9399 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
9401 struct bp_target_info
*bp_tgt
= bp
;
9404 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
9410 /* One (or perhaps two) breakpoints used for software single stepping. */
9412 static void *single_step_breakpoints
[2];
9413 static struct gdbarch
*single_step_gdbarch
[2];
9415 /* Create and insert a breakpoint for software single step. */
9418 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
9419 struct address_space
*aspace
, CORE_ADDR next_pc
)
9423 if (single_step_breakpoints
[0] == NULL
)
9425 bpt_p
= &single_step_breakpoints
[0];
9426 single_step_gdbarch
[0] = gdbarch
;
9430 gdb_assert (single_step_breakpoints
[1] == NULL
);
9431 bpt_p
= &single_step_breakpoints
[1];
9432 single_step_gdbarch
[1] = gdbarch
;
9435 /* NOTE drow/2006-04-11: A future improvement to this function would be
9436 to only create the breakpoints once, and actually put them on the
9437 breakpoint chain. That would let us use set_raw_breakpoint. We could
9438 adjust the addresses each time they were needed. Doing this requires
9439 corresponding changes elsewhere where single step breakpoints are
9440 handled, however. So, for now, we use this. */
9442 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
9444 error (_("Could not insert single-step breakpoint at %s"),
9445 paddress (gdbarch
, next_pc
));
9448 /* Remove and delete any breakpoints used for software single step. */
9451 remove_single_step_breakpoints (void)
9453 gdb_assert (single_step_breakpoints
[0] != NULL
);
9455 /* See insert_single_step_breakpoint for more about this deprecated
9457 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
9458 single_step_breakpoints
[0]);
9459 single_step_gdbarch
[0] = NULL
;
9460 single_step_breakpoints
[0] = NULL
;
9462 if (single_step_breakpoints
[1] != NULL
)
9464 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
9465 single_step_breakpoints
[1]);
9466 single_step_gdbarch
[1] = NULL
;
9467 single_step_breakpoints
[1] = NULL
;
9471 /* Check whether a software single-step breakpoint is inserted at PC. */
9474 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
9478 for (i
= 0; i
< 2; i
++)
9480 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
9482 && breakpoint_address_match (bp_tgt
->placed_address_space
,
9483 bp_tgt
->placed_address
,
9491 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
9492 non-zero otherwise. */
9494 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
9496 if (syscall_catchpoint_p (bp
)
9497 && bp
->enable_state
!= bp_disabled
9498 && bp
->enable_state
!= bp_call_disabled
)
9505 catch_syscall_enabled (void)
9507 struct inferior
*inf
= current_inferior ();
9509 return inf
->total_syscalls_count
!= 0;
9513 catching_syscall_number (int syscall_number
)
9515 struct breakpoint
*bp
;
9517 ALL_BREAKPOINTS (bp
)
9518 if (is_syscall_catchpoint_enabled (bp
))
9520 if (bp
->syscalls_to_be_caught
)
9524 VEC_iterate (int, bp
->syscalls_to_be_caught
, i
, iter
);
9526 if (syscall_number
== iter
)
9536 /* Complete syscall names. Used by "catch syscall". */
9538 catch_syscall_completer (struct cmd_list_element
*cmd
,
9539 char *text
, char *word
)
9541 const char **list
= get_syscall_names ();
9542 return (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
9545 /* Tracepoint-specific operations. */
9547 /* Set tracepoint count to NUM. */
9549 set_tracepoint_count (int num
)
9551 tracepoint_count
= num
;
9552 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
9556 trace_command (char *arg
, int from_tty
)
9558 break_command_really (get_current_arch (),
9560 NULL
, 0, 1 /* parse arg */,
9561 0 /* tempflag */, 0 /* hardwareflag */,
9563 0 /* Ignore count */,
9564 pending_break_support
,
9568 set_tracepoint_count (breakpoint_count
);
9571 /* Print information on tracepoint number TPNUM_EXP, or all if
9575 tracepoints_info (char *tpnum_exp
, int from_tty
)
9577 struct breakpoint
*b
;
9578 int tps_to_list
= 0;
9580 /* In the no-arguments case, say "No tracepoints" if none found. */
9593 ui_out_message (uiout
, 0, "No tracepoints.\n");
9598 /* Otherwise be the same as "info break". */
9599 breakpoints_info (tpnum_exp
, from_tty
);
9602 /* The 'enable trace' command enables tracepoints.
9603 Not supported by all targets. */
9605 enable_trace_command (char *args
, int from_tty
)
9607 enable_command (args
, from_tty
);
9610 /* The 'disable trace' command disables tracepoints.
9611 Not supported by all targets. */
9613 disable_trace_command (char *args
, int from_tty
)
9615 disable_command (args
, from_tty
);
9618 /* Remove a tracepoint (or all if no argument) */
9620 delete_trace_command (char *arg
, int from_tty
)
9622 struct breakpoint
*b
, *temp
;
9628 int breaks_to_delete
= 0;
9630 /* Delete all breakpoints if no argument.
9631 Do not delete internal or call-dummy breakpoints, these
9632 have to be deleted with an explicit breakpoint number argument. */
9637 breaks_to_delete
= 1;
9642 /* Ask user only if there are some breakpoints to delete. */
9644 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
9646 ALL_BREAKPOINTS_SAFE (b
, temp
)
9648 if (b
->type
== bp_tracepoint
9650 delete_breakpoint (b
);
9655 map_breakpoint_numbers (arg
, delete_breakpoint
);
9658 /* Set passcount for tracepoint.
9660 First command argument is passcount, second is tracepoint number.
9661 If tracepoint number omitted, apply to most recently defined.
9662 Also accepts special argument "all". */
9665 trace_pass_command (char *args
, int from_tty
)
9667 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
9671 if (args
== 0 || *args
== 0)
9672 error (_("passcount command requires an argument (count + optional TP num)"));
9674 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
9676 while (*args
&& isspace ((int) *args
))
9679 if (*args
&& strncasecmp (args
, "all", 3) == 0)
9681 args
+= 3; /* Skip special argument "all". */
9684 error (_("Junk at end of arguments."));
9687 t1
= get_tracepoint_by_number (&args
, 1, 1);
9693 ALL_TRACEPOINTS (t2
)
9694 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
9696 t2
->pass_count
= count
;
9697 observer_notify_tracepoint_modified (t2
->number
);
9699 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
9703 t1
= get_tracepoint_by_number (&args
, 1, 0);
9710 get_tracepoint (int num
)
9712 struct breakpoint
*t
;
9715 if (t
->number
== num
)
9721 /* Utility: parse a tracepoint number and look it up in the list.
9722 If MULTI_P is true, there might be a range of tracepoints in ARG.
9723 if OPTIONAL_P is true, then if the argument is missing, the most
9724 recent tracepoint (tracepoint_count) is returned. */
9726 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
9728 extern int tracepoint_count
;
9729 struct breakpoint
*t
;
9731 char *instring
= arg
== NULL
? NULL
: *arg
;
9733 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
9736 tpnum
= tracepoint_count
;
9738 error_no_arg (_("tracepoint number"));
9741 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
9745 if (instring
&& *instring
)
9746 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
9749 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
9754 if (t
->number
== tpnum
)
9759 /* FIXME: if we are in the middle of a range we don't want to give
9760 a message. The current interface to get_number_or_range doesn't
9761 allow us to discover this. */
9762 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
9766 /* save-tracepoints command */
9768 tracepoint_save_command (char *args
, int from_tty
)
9770 struct breakpoint
*tp
;
9772 struct action_line
*line
;
9774 char *i1
= " ", *i2
= " ";
9775 char *indent
, *actionline
, *pathname
;
9777 struct cleanup
*cleanup
;
9779 if (args
== 0 || *args
== 0)
9780 error (_("Argument required (file name in which to save tracepoints)"));
9782 /* See if we have anything to save. */
9783 ALL_TRACEPOINTS (tp
)
9790 warning (_("save-tracepoints: no tracepoints to save."));
9794 pathname
= tilde_expand (args
);
9795 cleanup
= make_cleanup (xfree
, pathname
);
9796 fp
= fopen (pathname
, "w");
9798 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
9799 args
, safe_strerror (errno
));
9800 make_cleanup_fclose (fp
);
9802 ALL_TRACEPOINTS (tp
)
9804 if (tp
->addr_string
)
9805 fprintf (fp
, "trace %s\n", tp
->addr_string
);
9808 sprintf_vma (tmp
, tp
->loc
->address
);
9809 fprintf (fp
, "trace *0x%s\n", tmp
);
9813 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
9817 fprintf (fp
, " actions\n");
9819 for (line
= tp
->actions
; line
; line
= line
->next
)
9821 struct cmd_list_element
*cmd
;
9823 QUIT
; /* allow user to bail out with ^C */
9824 actionline
= line
->action
;
9825 while (isspace ((int) *actionline
))
9828 fprintf (fp
, "%s%s\n", indent
, actionline
);
9829 if (*actionline
!= '#') /* skip for comment lines */
9831 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
9833 error (_("Bad action list item: %s"), actionline
);
9834 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
9836 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
9842 do_cleanups (cleanup
);
9844 printf_filtered (_("Tracepoints saved to file '%s'.\n"), args
);
9848 /* Create a vector of all tracepoints. */
9853 VEC(breakpoint_p
) *tp_vec
= 0;
9854 struct breakpoint
*tp
;
9856 ALL_TRACEPOINTS (tp
)
9858 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
9865 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
9866 It is defined as a macro to prevent duplication.
9867 COMMAND should be a string constant containing the name of the command. */
9868 #define BREAK_ARGS_HELP(command) \
9869 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
9870 LOCATION may be a line number, function name, or \"*\" and an address.\n\
9871 If a line number is specified, break at start of code for that line.\n\
9872 If a function is specified, break at start of code for that function.\n\
9873 If an address is specified, break at that exact address.\n\
9874 With no LOCATION, uses current execution address of selected stack frame.\n\
9875 This is useful for breaking on return to a stack frame.\n\
9877 THREADNUM is the number from \"info threads\".\n\
9878 CONDITION is a boolean expression.\n\
9880 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
9882 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
9884 /* List of subcommands for "catch". */
9885 static struct cmd_list_element
*catch_cmdlist
;
9887 /* List of subcommands for "tcatch". */
9888 static struct cmd_list_element
*tcatch_cmdlist
;
9890 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
9891 lists, and pass some additional user data to the command function. */
9893 add_catch_command (char *name
, char *docstring
,
9894 void (*sfunc
) (char *args
, int from_tty
,
9895 struct cmd_list_element
*command
),
9896 char **(*completer
) (struct cmd_list_element
*cmd
,
9897 char *text
, char *word
),
9898 void *user_data_catch
,
9899 void *user_data_tcatch
)
9901 struct cmd_list_element
*command
;
9903 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
9905 set_cmd_sfunc (command
, sfunc
);
9906 set_cmd_context (command
, user_data_catch
);
9907 set_cmd_completer (command
, completer
);
9909 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
9911 set_cmd_sfunc (command
, sfunc
);
9912 set_cmd_context (command
, user_data_tcatch
);
9913 set_cmd_completer (command
, completer
);
9917 clear_syscall_counts (int pid
)
9919 struct inferior
*inf
= find_inferior_pid (pid
);
9921 inf
->total_syscalls_count
= 0;
9922 inf
->any_syscall_count
= 0;
9923 VEC_free (int, inf
->syscalls_counts
);
9927 _initialize_breakpoint (void)
9929 static struct cmd_list_element
*breakpoint_set_cmdlist
;
9930 static struct cmd_list_element
*breakpoint_show_cmdlist
;
9931 struct cmd_list_element
*c
;
9933 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
9934 observer_attach_inferior_exit (clear_syscall_counts
);
9936 breakpoint_chain
= 0;
9937 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
9938 before a breakpoint is set. */
9939 breakpoint_count
= 0;
9941 tracepoint_count
= 0;
9943 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
9944 Set ignore-count of breakpoint number N to COUNT.\n\
9945 Usage is `ignore N COUNT'."));
9947 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
9949 add_com ("commands", class_breakpoint
, commands_command
, _("\
9950 Set commands to be executed when a breakpoint is hit.\n\
9951 Give breakpoint number as argument after \"commands\".\n\
9952 With no argument, the targeted breakpoint is the last one set.\n\
9953 The commands themselves follow starting on the next line.\n\
9954 Type a line containing \"end\" to indicate the end of them.\n\
9955 Give \"silent\" as the first line to make the breakpoint silent;\n\
9956 then no output is printed when it is hit, except what the commands print."));
9958 add_com ("condition", class_breakpoint
, condition_command
, _("\
9959 Specify breakpoint number N to break only if COND is true.\n\
9960 Usage is `condition N COND', where N is an integer and COND is an\n\
9961 expression to be evaluated whenever breakpoint N is reached."));
9963 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
9964 Set a temporary breakpoint.\n\
9965 Like \"break\" except the breakpoint is only temporary,\n\
9966 so it will be deleted when hit. Equivalent to \"break\" followed\n\
9967 by using \"enable delete\" on the breakpoint number.\n\
9969 BREAK_ARGS_HELP ("tbreak")));
9970 set_cmd_completer (c
, location_completer
);
9972 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
9973 Set a hardware assisted breakpoint.\n\
9974 Like \"break\" except the breakpoint requires hardware support,\n\
9975 some target hardware may not have this support.\n\
9977 BREAK_ARGS_HELP ("hbreak")));
9978 set_cmd_completer (c
, location_completer
);
9980 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
9981 Set a temporary hardware assisted breakpoint.\n\
9982 Like \"hbreak\" except the breakpoint is only temporary,\n\
9983 so it will be deleted when hit.\n\
9985 BREAK_ARGS_HELP ("thbreak")));
9986 set_cmd_completer (c
, location_completer
);
9988 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
9989 Enable some breakpoints.\n\
9990 Give breakpoint numbers (separated by spaces) as arguments.\n\
9991 With no subcommand, breakpoints are enabled until you command otherwise.\n\
9992 This is used to cancel the effect of the \"disable\" command.\n\
9993 With a subcommand you can enable temporarily."),
9994 &enablelist
, "enable ", 1, &cmdlist
);
9996 add_com ("ab", class_breakpoint
, enable_command
, _("\
9997 Enable some breakpoints.\n\
9998 Give breakpoint numbers (separated by spaces) as arguments.\n\
9999 With no subcommand, breakpoints are enabled until you command otherwise.\n\
10000 This is used to cancel the effect of the \"disable\" command.\n\
10001 With a subcommand you can enable temporarily."));
10003 add_com_alias ("en", "enable", class_breakpoint
, 1);
10005 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
10006 Enable some breakpoints.\n\
10007 Give breakpoint numbers (separated by spaces) as arguments.\n\
10008 This is used to cancel the effect of the \"disable\" command.\n\
10009 May be abbreviated to simply \"enable\".\n"),
10010 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
10012 add_cmd ("once", no_class
, enable_once_command
, _("\
10013 Enable breakpoints for one hit. Give breakpoint numbers.\n\
10014 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
10017 add_cmd ("delete", no_class
, enable_delete_command
, _("\
10018 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
10019 If a breakpoint is hit while enabled in this fashion, it is deleted."),
10022 add_cmd ("delete", no_class
, enable_delete_command
, _("\
10023 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
10024 If a breakpoint is hit while enabled in this fashion, it is deleted."),
10027 add_cmd ("once", no_class
, enable_once_command
, _("\
10028 Enable breakpoints for one hit. Give breakpoint numbers.\n\
10029 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
10032 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
10033 Disable some breakpoints.\n\
10034 Arguments are breakpoint numbers with spaces in between.\n\
10035 To disable all breakpoints, give no argument.\n\
10036 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
10037 &disablelist
, "disable ", 1, &cmdlist
);
10038 add_com_alias ("dis", "disable", class_breakpoint
, 1);
10039 add_com_alias ("disa", "disable", class_breakpoint
, 1);
10041 add_com ("sb", class_breakpoint
, disable_command
, _("\
10042 Disable some breakpoints.\n\
10043 Arguments are breakpoint numbers with spaces in between.\n\
10044 To disable all breakpoints, give no argument.\n\
10045 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
10047 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
10048 Disable some breakpoints.\n\
10049 Arguments are breakpoint numbers with spaces in between.\n\
10050 To disable all breakpoints, give no argument.\n\
10051 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
10052 This command may be abbreviated \"disable\"."),
10055 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
10056 Delete some breakpoints or auto-display expressions.\n\
10057 Arguments are breakpoint numbers with spaces in between.\n\
10058 To delete all breakpoints, give no argument.\n\
10060 Also a prefix command for deletion of other GDB objects.\n\
10061 The \"unset\" command is also an alias for \"delete\"."),
10062 &deletelist
, "delete ", 1, &cmdlist
);
10063 add_com_alias ("d", "delete", class_breakpoint
, 1);
10064 add_com_alias ("del", "delete", class_breakpoint
, 1);
10066 add_com ("db", class_breakpoint
, delete_command
, _("\
10067 Delete some breakpoints.\n\
10068 Arguments are breakpoint numbers with spaces in between.\n\
10069 To delete all breakpoints, give no argument.\n"));
10071 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
10072 Delete some breakpoints or auto-display expressions.\n\
10073 Arguments are breakpoint numbers with spaces in between.\n\
10074 To delete all breakpoints, give no argument.\n\
10075 This command may be abbreviated \"delete\"."),
10078 add_com ("clear", class_breakpoint
, clear_command
, _("\
10079 Clear breakpoint at specified line or function.\n\
10080 Argument may be line number, function name, or \"*\" and an address.\n\
10081 If line number is specified, all breakpoints in that line are cleared.\n\
10082 If function is specified, breakpoints at beginning of function are cleared.\n\
10083 If an address is specified, breakpoints at that address are cleared.\n\
10085 With no argument, clears all breakpoints in the line that the selected frame\n\
10086 is executing in.\n\
10088 See also the \"delete\" command which clears breakpoints by number."));
10090 c
= add_com ("break", class_breakpoint
, break_command
, _("\
10091 Set breakpoint at specified line or function.\n"
10092 BREAK_ARGS_HELP ("break")));
10093 set_cmd_completer (c
, location_completer
);
10095 add_com_alias ("b", "break", class_run
, 1);
10096 add_com_alias ("br", "break", class_run
, 1);
10097 add_com_alias ("bre", "break", class_run
, 1);
10098 add_com_alias ("brea", "break", class_run
, 1);
10101 add_com_alias ("ba", "break", class_breakpoint
, 1);
10105 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
10106 Break in function/address or break at a line in the current file."),
10107 &stoplist
, "stop ", 1, &cmdlist
);
10108 add_cmd ("in", class_breakpoint
, stopin_command
,
10109 _("Break in function or address."), &stoplist
);
10110 add_cmd ("at", class_breakpoint
, stopat_command
,
10111 _("Break at a line in the current file."), &stoplist
);
10112 add_com ("status", class_info
, breakpoints_info
, _("\
10113 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10114 The \"Type\" column indicates one of:\n\
10115 \tbreakpoint - normal breakpoint\n\
10116 \twatchpoint - watchpoint\n\
10117 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10118 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10119 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10120 address and file/line number respectively.\n\
10122 Convenience variable \"$_\" and default examine address for \"x\"\n\
10123 are set to the address of the last breakpoint listed unless the command\n\
10124 is prefixed with \"server \".\n\n\
10125 Convenience variable \"$bpnum\" contains the number of the last\n\
10126 breakpoint set."));
10129 add_info ("breakpoints", breakpoints_info
, _("\
10130 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10131 The \"Type\" column indicates one of:\n\
10132 \tbreakpoint - normal breakpoint\n\
10133 \twatchpoint - watchpoint\n\
10134 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10135 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10136 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10137 address and file/line number respectively.\n\
10139 Convenience variable \"$_\" and default examine address for \"x\"\n\
10140 are set to the address of the last breakpoint listed unless the command\n\
10141 is prefixed with \"server \".\n\n\
10142 Convenience variable \"$bpnum\" contains the number of the last\n\
10143 breakpoint set."));
10146 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
10147 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10148 The \"Type\" column indicates one of:\n\
10149 \tbreakpoint - normal breakpoint\n\
10150 \twatchpoint - watchpoint\n\
10151 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10152 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10153 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10154 address and file/line number respectively.\n\
10156 Convenience variable \"$_\" and default examine address for \"x\"\n\
10157 are set to the address of the last breakpoint listed unless the command\n\
10158 is prefixed with \"server \".\n\n\
10159 Convenience variable \"$bpnum\" contains the number of the last\n\
10160 breakpoint set."));
10162 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
10163 Status of all breakpoints, or breakpoint number NUMBER.\n\
10164 The \"Type\" column indicates one of:\n\
10165 \tbreakpoint - normal breakpoint\n\
10166 \twatchpoint - watchpoint\n\
10167 \tlongjmp - internal breakpoint used to step through longjmp()\n\
10168 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
10169 \tuntil - internal breakpoint used by the \"until\" command\n\
10170 \tfinish - internal breakpoint used by the \"finish\" command\n\
10171 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10172 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10173 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10174 address and file/line number respectively.\n\
10176 Convenience variable \"$_\" and default examine address for \"x\"\n\
10177 are set to the address of the last breakpoint listed unless the command\n\
10178 is prefixed with \"server \".\n\n\
10179 Convenience variable \"$bpnum\" contains the number of the last\n\
10181 &maintenanceinfolist
);
10183 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
10184 Set catchpoints to catch events."),
10185 &catch_cmdlist
, "catch ",
10186 0/*allow-unknown*/, &cmdlist
);
10188 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
10189 Set temporary catchpoints to catch events."),
10190 &tcatch_cmdlist
, "tcatch ",
10191 0/*allow-unknown*/, &cmdlist
);
10193 /* Add catch and tcatch sub-commands. */
10194 add_catch_command ("catch", _("\
10195 Catch an exception, when caught.\n\
10196 With an argument, catch only exceptions with the given name."),
10197 catch_catch_command
,
10201 add_catch_command ("throw", _("\
10202 Catch an exception, when thrown.\n\
10203 With an argument, catch only exceptions with the given name."),
10204 catch_throw_command
,
10208 add_catch_command ("fork", _("Catch calls to fork."),
10209 catch_fork_command_1
,
10211 (void *) (uintptr_t) catch_fork_permanent
,
10212 (void *) (uintptr_t) catch_fork_temporary
);
10213 add_catch_command ("vfork", _("Catch calls to vfork."),
10214 catch_fork_command_1
,
10216 (void *) (uintptr_t) catch_vfork_permanent
,
10217 (void *) (uintptr_t) catch_vfork_temporary
);
10218 add_catch_command ("exec", _("Catch calls to exec."),
10219 catch_exec_command_1
,
10223 add_catch_command ("syscall", _("\
10224 Catch system calls by their names and/or numbers.\n\
10225 Arguments say which system calls to catch. If no arguments\n\
10226 are given, every system call will be caught.\n\
10227 Arguments, if given, should be one or more system call names\n\
10228 (if your system supports that), or system call numbers."),
10229 catch_syscall_command_1
,
10230 catch_syscall_completer
,
10233 add_catch_command ("exception", _("\
10234 Catch Ada exceptions, when raised.\n\
10235 With an argument, catch only exceptions with the given name."),
10236 catch_ada_exception_command
,
10240 add_catch_command ("assert", _("\
10241 Catch failed Ada assertions, when raised.\n\
10242 With an argument, catch only exceptions with the given name."),
10243 catch_assert_command
,
10248 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
10249 Set a watchpoint for an expression.\n\
10250 A watchpoint stops execution of your program whenever the value of\n\
10251 an expression changes."));
10252 set_cmd_completer (c
, expression_completer
);
10254 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
10255 Set a read watchpoint for an expression.\n\
10256 A watchpoint stops execution of your program whenever the value of\n\
10257 an expression is read."));
10258 set_cmd_completer (c
, expression_completer
);
10260 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
10261 Set a watchpoint for an expression.\n\
10262 A watchpoint stops execution of your program whenever the value of\n\
10263 an expression is either read or written."));
10264 set_cmd_completer (c
, expression_completer
);
10266 add_info ("watchpoints", breakpoints_info
,
10267 _("Synonym for ``info breakpoints''."));
10270 /* XXX: cagney/2005-02-23: This should be a boolean, and should
10271 respond to changes - contrary to the description. */
10272 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
10273 &can_use_hw_watchpoints
, _("\
10274 Set debugger's willingness to use watchpoint hardware."), _("\
10275 Show debugger's willingness to use watchpoint hardware."), _("\
10276 If zero, gdb will not use hardware for new watchpoints, even if\n\
10277 such is available. (However, any hardware watchpoints that were\n\
10278 created before setting this to nonzero, will continue to use watchpoint\n\
10281 show_can_use_hw_watchpoints
,
10282 &setlist
, &showlist
);
10284 can_use_hw_watchpoints
= 1;
10286 /* Tracepoint manipulation commands. */
10288 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
10289 Set a tracepoint at specified line or function.\n\
10291 BREAK_ARGS_HELP ("trace") "\n\
10292 Do \"help tracepoints\" for info on other tracepoint commands."));
10293 set_cmd_completer (c
, location_completer
);
10295 add_com_alias ("tp", "trace", class_alias
, 0);
10296 add_com_alias ("tr", "trace", class_alias
, 1);
10297 add_com_alias ("tra", "trace", class_alias
, 1);
10298 add_com_alias ("trac", "trace", class_alias
, 1);
10300 add_info ("tracepoints", tracepoints_info
, _("\
10301 Status of tracepoints, or tracepoint number NUMBER.\n\
10302 Convenience variable \"$tpnum\" contains the number of the\n\
10303 last tracepoint set."));
10305 add_info_alias ("tp", "tracepoints", 1);
10307 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
10308 Delete specified tracepoints.\n\
10309 Arguments are tracepoint numbers, separated by spaces.\n\
10310 No argument means delete all tracepoints."),
10313 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
10314 Disable specified tracepoints.\n\
10315 Arguments are tracepoint numbers, separated by spaces.\n\
10316 No argument means disable all tracepoints."),
10318 deprecate_cmd (c
, "disable");
10320 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
10321 Enable specified tracepoints.\n\
10322 Arguments are tracepoint numbers, separated by spaces.\n\
10323 No argument means enable all tracepoints."),
10325 deprecate_cmd (c
, "enable");
10327 add_com ("passcount", class_trace
, trace_pass_command
, _("\
10328 Set the passcount for a tracepoint.\n\
10329 The trace will end when the tracepoint has been passed 'count' times.\n\
10330 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
10331 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
10333 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
10334 Save current tracepoint definitions as a script.\n\
10335 Use the 'source' command in another debug session to restore them."));
10336 set_cmd_completer (c
, filename_completer
);
10338 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
10339 Breakpoint specific settings\n\
10340 Configure various breakpoint-specific variables such as\n\
10341 pending breakpoint behavior"),
10342 &breakpoint_set_cmdlist
, "set breakpoint ",
10343 0/*allow-unknown*/, &setlist
);
10344 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
10345 Breakpoint specific settings\n\
10346 Configure various breakpoint-specific variables such as\n\
10347 pending breakpoint behavior"),
10348 &breakpoint_show_cmdlist
, "show breakpoint ",
10349 0/*allow-unknown*/, &showlist
);
10351 add_setshow_auto_boolean_cmd ("pending", no_class
,
10352 &pending_break_support
, _("\
10353 Set debugger's behavior regarding pending breakpoints."), _("\
10354 Show debugger's behavior regarding pending breakpoints."), _("\
10355 If on, an unrecognized breakpoint location will cause gdb to create a\n\
10356 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
10357 an error. If auto, an unrecognized breakpoint location results in a\n\
10358 user-query to see if a pending breakpoint should be created."),
10360 show_pending_break_support
,
10361 &breakpoint_set_cmdlist
,
10362 &breakpoint_show_cmdlist
);
10364 pending_break_support
= AUTO_BOOLEAN_AUTO
;
10366 add_setshow_boolean_cmd ("auto-hw", no_class
,
10367 &automatic_hardware_breakpoints
, _("\
10368 Set automatic usage of hardware breakpoints."), _("\
10369 Show automatic usage of hardware breakpoints."), _("\
10370 If set, the debugger will automatically use hardware breakpoints for\n\
10371 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
10372 a warning will be emitted for such breakpoints."),
10374 show_automatic_hardware_breakpoints
,
10375 &breakpoint_set_cmdlist
,
10376 &breakpoint_show_cmdlist
);
10378 add_setshow_enum_cmd ("always-inserted", class_support
,
10379 always_inserted_enums
, &always_inserted_mode
, _("\
10380 Set mode for inserting breakpoints."), _("\
10381 Show mode for inserting breakpoints."), _("\
10382 When this mode is off, breakpoints are inserted in inferior when it is\n\
10383 resumed, and removed when execution stops. When this mode is on,\n\
10384 breakpoints are inserted immediately and removed only when the user\n\
10385 deletes the breakpoint. When this mode is auto (which is the default),\n\
10386 the behaviour depends on the non-stop setting (see help set non-stop).\n\
10387 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
10388 behaves as if always-inserted mode is on; if gdb is controlling the\n\
10389 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
10391 &show_always_inserted_mode
,
10392 &breakpoint_set_cmdlist
,
10393 &breakpoint_show_cmdlist
);
10395 automatic_hardware_breakpoints
= 1;
10397 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);