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
;
8218 /* Tells if 'old_loc' is found amoung the new locations. If not, we
8221 /* Tells if the location should remain inserted in the target. */
8222 int keep_in_target
= 0;
8225 /* Skip LOCP entries which will definitely never be needed. Stop either
8226 at or being the one matching OLD_LOC. */
8227 while (locp
< bp_location
+ bp_location_count
8228 && bp_location_compare (*locp
, old_loc
) < 0)
8230 found_object
= locp
< bp_location
+ bp_location_count
&& *locp
== old_loc
;
8232 /* If this location is no longer present, and inserted, look if there's
8233 maybe a new location at the same address. If so, mark that one
8234 inserted, and don't remove this one. This is needed so that we
8235 don't have a time window where a breakpoint at certain location is not
8238 if (old_loc
->inserted
)
8240 /* If the location is inserted now, we might have to remove it. */
8242 if (found_object
&& should_be_inserted (old_loc
))
8244 /* The location is still present in the location list, and still
8245 should be inserted. Don't do anything. */
8250 /* The location is either no longer present, or got disabled.
8251 See if there's another location at the same address, in which
8252 case we don't need to remove this one from the target. */
8254 if (breakpoint_address_is_meaningful (old_loc
->owner
))
8256 struct bp_location
**loc2p
;
8259 loc2p
< bp_location
+ bp_location_count
8260 && breakpoint_address_match ((*loc2p
)->pspace
->aspace
,
8262 old_loc
->pspace
->aspace
,
8266 struct bp_location
*loc2
= *loc2p
;
8268 /* For the sake of should_be_inserted.
8269 Duplicates check below will fix up this later. */
8270 loc2
->duplicate
= 0;
8271 if (loc2
!= old_loc
&& should_be_inserted (loc2
))
8274 loc2
->target_info
= old_loc
->target_info
;
8282 if (!keep_in_target
)
8284 if (remove_breakpoint (old_loc
, mark_uninserted
))
8286 /* This is just about all we can do. We could keep this
8287 location on the global list, and try to remove it next
8288 time, but there's no particular reason why we will
8291 Note that at this point, old_loc->owner is still valid,
8292 as delete_breakpoint frees the breakpoint only
8293 after calling us. */
8294 printf_filtered (_("warning: Error removing breakpoint %d\n"),
8295 old_loc
->owner
->number
);
8303 if (removed
&& non_stop
)
8305 /* This location was removed from the targets. In non-stop mode,
8306 a race condition is possible where we've removed a breakpoint,
8307 but stop events for that breakpoint are already queued and will
8308 arrive later. To suppress spurious SIGTRAPs reported to user,
8309 we keep this breakpoint location for a bit, and will retire it
8310 after we see 3 * thread_count events.
8311 The theory here is that reporting of events should,
8312 "on the average", be fair, so after that many event we'll see
8313 events from all threads that have anything of interest, and no
8314 longer need to keep this breakpoint. This is just a
8315 heuristic, but if it's wrong, we'll report unexpected SIGTRAP,
8316 which is usability issue, but not a correctness problem. */
8317 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
8318 old_loc
->owner
= NULL
;
8320 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
8323 free_bp_location (old_loc
);
8327 /* Rescan breakpoints at the same address and section,
8328 marking the first one as "first" and any others as "duplicates".
8329 This is so that the bpt instruction is only inserted once.
8330 If we have a permanent breakpoint at the same place as BPT, make
8331 that one the official one, and the rest as duplicates. Permanent
8332 breakpoints are sorted first for the same address. */
8335 ALL_BP_LOCATIONS (loc
, locp
)
8337 struct breakpoint
*b
= loc
->owner
;
8339 if (b
->enable_state
== bp_disabled
8340 || b
->enable_state
== bp_call_disabled
8341 || b
->enable_state
== bp_startup_disabled
8343 || loc
->shlib_disabled
8344 || !breakpoint_address_is_meaningful (b
))
8347 /* Permanent breakpoint should always be inserted. */
8348 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
8349 internal_error (__FILE__
, __LINE__
,
8350 _("allegedly permanent breakpoint is not "
8351 "actually inserted"));
8353 if (loc_first
== NULL
8354 || (overlay_debugging
&& loc
->section
!= loc_first
->section
)
8355 || !breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
8356 loc_first
->pspace
->aspace
,
8357 loc_first
->address
))
8366 if (loc_first
->owner
->enable_state
== bp_permanent
&& loc
->inserted
8367 && b
->enable_state
!= bp_permanent
)
8368 internal_error (__FILE__
, __LINE__
,
8369 _("another breakpoint was inserted on top of "
8370 "a permanent breakpoint"));
8373 if (breakpoints_always_inserted_mode () && should_insert
8374 && (have_live_inferiors ()
8375 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
8376 insert_breakpoint_locations ();
8378 do_cleanups (cleanups
);
8382 breakpoint_retire_moribund (void)
8384 struct bp_location
*loc
;
8387 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
8388 if (--(loc
->events_till_retirement
) == 0)
8390 free_bp_location (loc
);
8391 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
8397 update_global_location_list_nothrow (int inserting
)
8399 struct gdb_exception e
;
8400 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8401 update_global_location_list (inserting
);
8404 /* Clear BPT from a BPS. */
8406 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
8409 for (bs
= bps
; bs
; bs
= bs
->next
)
8410 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
8412 bs
->breakpoint_at
= NULL
;
8414 /* bs->commands will be freed later. */
8418 /* Callback for iterate_over_threads. */
8420 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
8422 struct breakpoint
*bpt
= data
;
8423 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
8427 /* Delete a breakpoint and clean up all traces of it in the data
8431 delete_breakpoint (struct breakpoint
*bpt
)
8433 struct breakpoint
*b
;
8434 struct bp_location
*loc
, *next
;
8436 gdb_assert (bpt
!= NULL
);
8438 /* Has this bp already been deleted? This can happen because multiple
8439 lists can hold pointers to bp's. bpstat lists are especial culprits.
8441 One example of this happening is a watchpoint's scope bp. When the
8442 scope bp triggers, we notice that the watchpoint is out of scope, and
8443 delete it. We also delete its scope bp. But the scope bp is marked
8444 "auto-deleting", and is already on a bpstat. That bpstat is then
8445 checked for auto-deleting bp's, which are deleted.
8447 A real solution to this problem might involve reference counts in bp's,
8448 and/or giving them pointers back to their referencing bpstat's, and
8449 teaching delete_breakpoint to only free a bp's storage when no more
8450 references were extent. A cheaper bandaid was chosen. */
8451 if (bpt
->type
== bp_none
)
8454 observer_notify_breakpoint_deleted (bpt
->number
);
8456 if (breakpoint_chain
== bpt
)
8457 breakpoint_chain
= bpt
->next
;
8462 b
->next
= bpt
->next
;
8466 free_command_lines (&bpt
->commands
);
8467 if (bpt
->cond_string
!= NULL
)
8468 xfree (bpt
->cond_string
);
8469 if (bpt
->addr_string
!= NULL
)
8470 xfree (bpt
->addr_string
);
8471 if (bpt
->exp
!= NULL
)
8473 if (bpt
->exp_string
!= NULL
)
8474 xfree (bpt
->exp_string
);
8475 if (bpt
->val
!= NULL
)
8476 value_free (bpt
->val
);
8477 if (bpt
->source_file
!= NULL
)
8478 xfree (bpt
->source_file
);
8479 if (bpt
->exec_pathname
!= NULL
)
8480 xfree (bpt
->exec_pathname
);
8481 clean_up_filters (&bpt
->syscalls_to_be_caught
);
8483 /* Be sure no bpstat's are pointing at it after it's been freed. */
8484 /* FIXME, how can we find all bpstat's?
8485 We just check stop_bpstat for now. Note that we cannot just
8486 remove bpstats pointing at bpt from the stop_bpstat list
8487 entirely, as breakpoint commands are associated with the bpstat;
8488 if we remove it here, then the later call to
8489 bpstat_do_actions (&stop_bpstat);
8490 in event-top.c won't do anything, and temporary breakpoints
8491 with commands won't work. */
8493 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
8495 /* Now that breakpoint is removed from breakpoint
8496 list, update the global location list. This
8497 will remove locations that used to belong to
8498 this breakpoint. Do this before freeing
8499 the breakpoint itself, since remove_breakpoint
8500 looks at location's owner. It might be better
8501 design to have location completely self-contained,
8502 but it's not the case now. */
8503 update_global_location_list (0);
8506 /* On the chance that someone will soon try again to delete this same
8507 bp, we mark it as deleted before freeing its storage. */
8508 bpt
->type
= bp_none
;
8514 do_delete_breakpoint_cleanup (void *b
)
8516 delete_breakpoint (b
);
8520 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
8522 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
8526 delete_command (char *arg
, int from_tty
)
8528 struct breakpoint
*b
, *temp
;
8534 int breaks_to_delete
= 0;
8536 /* Delete all breakpoints if no argument.
8537 Do not delete internal or call-dummy breakpoints, these
8538 have to be deleted with an explicit breakpoint number argument. */
8541 if (b
->type
!= bp_call_dummy
8542 && b
->type
!= bp_shlib_event
8543 && b
->type
!= bp_jit_event
8544 && b
->type
!= bp_thread_event
8545 && b
->type
!= bp_overlay_event
8546 && b
->type
!= bp_longjmp_master
8549 breaks_to_delete
= 1;
8554 /* Ask user only if there are some breakpoints to delete. */
8556 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
8558 ALL_BREAKPOINTS_SAFE (b
, temp
)
8560 if (b
->type
!= bp_call_dummy
8561 && b
->type
!= bp_shlib_event
8562 && b
->type
!= bp_thread_event
8563 && b
->type
!= bp_jit_event
8564 && b
->type
!= bp_overlay_event
8565 && b
->type
!= bp_longjmp_master
8567 delete_breakpoint (b
);
8572 map_breakpoint_numbers (arg
, delete_breakpoint
);
8576 all_locations_are_pending (struct bp_location
*loc
)
8578 for (; loc
; loc
= loc
->next
)
8579 if (!loc
->shlib_disabled
)
8584 /* Subroutine of update_breakpoint_locations to simplify it.
8585 Return non-zero if multiple fns in list LOC have the same name.
8586 Null names are ignored. */
8589 ambiguous_names_p (struct bp_location
*loc
)
8591 struct bp_location
*l
;
8592 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
8593 (int (*) (const void *, const void *)) streq
,
8594 NULL
, xcalloc
, xfree
);
8596 for (l
= loc
; l
!= NULL
; l
= l
->next
)
8599 const char *name
= l
->function_name
;
8601 /* Allow for some names to be NULL, ignore them. */
8605 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
8607 /* NOTE: We can assume slot != NULL here because xcalloc never returns
8622 update_breakpoint_locations (struct breakpoint
*b
,
8623 struct symtabs_and_lines sals
)
8627 struct bp_location
*existing_locations
= b
->loc
;
8629 /* If there's no new locations, and all existing locations
8630 are pending, don't do anything. This optimizes
8631 the common case where all locations are in the same
8632 shared library, that was unloaded. We'd like to
8633 retain the location, so that when the library
8634 is loaded again, we don't loose the enabled/disabled
8635 status of the individual locations. */
8636 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
8641 for (i
= 0; i
< sals
.nelts
; ++i
)
8643 struct bp_location
*new_loc
=
8644 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
8646 /* Reparse conditions, they might contain references to the
8648 if (b
->cond_string
!= NULL
)
8650 struct gdb_exception e
;
8653 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8655 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
8660 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
8661 b
->number
, e
.message
);
8662 new_loc
->enabled
= 0;
8666 if (b
->source_file
!= NULL
)
8667 xfree (b
->source_file
);
8668 if (sals
.sals
[i
].symtab
== NULL
)
8669 b
->source_file
= NULL
;
8671 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
8673 if (b
->line_number
== 0)
8674 b
->line_number
= sals
.sals
[i
].line
;
8677 /* Update locations of permanent breakpoints. */
8678 if (b
->enable_state
== bp_permanent
)
8679 make_breakpoint_permanent (b
);
8681 /* If possible, carry over 'disable' status from existing breakpoints. */
8683 struct bp_location
*e
= existing_locations
;
8684 /* If there are multiple breakpoints with the same function name,
8685 e.g. for inline functions, comparing function names won't work.
8686 Instead compare pc addresses; this is just a heuristic as things
8687 may have moved, but in practice it gives the correct answer
8688 often enough until a better solution is found. */
8689 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
8691 for (; e
; e
= e
->next
)
8693 if (!e
->enabled
&& e
->function_name
)
8695 struct bp_location
*l
= b
->loc
;
8696 if (have_ambiguous_names
)
8698 for (; l
; l
= l
->next
)
8699 if (breakpoint_address_match (e
->pspace
->aspace
, e
->address
,
8700 l
->pspace
->aspace
, l
->address
))
8708 for (; l
; l
= l
->next
)
8709 if (l
->function_name
8710 && strcmp (e
->function_name
, l
->function_name
) == 0)
8720 update_global_location_list (1);
8724 /* Reset a breakpoint given it's struct breakpoint * BINT.
8725 The value we return ends up being the return value from catch_errors.
8726 Unused in this case. */
8729 breakpoint_re_set_one (void *bint
)
8731 /* get past catch_errs */
8732 struct breakpoint
*b
= (struct breakpoint
*) bint
;
8736 int *not_found_ptr
= ¬_found
;
8737 struct symtabs_and_lines sals
= {0};
8738 struct symtabs_and_lines expanded
= {0};
8740 enum enable_state save_enable
;
8741 struct gdb_exception e
;
8742 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
8747 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
8751 case bp_hardware_breakpoint
:
8753 /* Do not attempt to re-set breakpoints disabled during startup. */
8754 if (b
->enable_state
== bp_startup_disabled
)
8757 if (b
->addr_string
== NULL
)
8759 /* Anything without a string can't be re-set. */
8760 delete_breakpoint (b
);
8764 set_language (b
->language
);
8765 input_radix
= b
->input_radix
;
8768 save_current_space_and_thread ();
8769 switch_to_program_space_and_thread (b
->pspace
);
8771 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8773 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
8778 int not_found_and_ok
= 0;
8779 /* For pending breakpoints, it's expected that parsing
8780 will fail until the right shared library is loaded.
8781 User has already told to create pending breakpoints and
8782 don't need extra messages. If breakpoint is in bp_shlib_disabled
8783 state, then user already saw the message about that breakpoint
8784 being disabled, and don't want to see more errors. */
8786 && (b
->condition_not_parsed
8787 || (b
->loc
&& b
->loc
->shlib_disabled
)
8788 || b
->enable_state
== bp_disabled
))
8789 not_found_and_ok
= 1;
8791 if (!not_found_and_ok
)
8793 /* We surely don't want to warn about the same breakpoint
8794 10 times. One solution, implemented here, is disable
8795 the breakpoint on error. Another solution would be to
8796 have separate 'warning emitted' flag. Since this
8797 happens only when a binary has changed, I don't know
8798 which approach is better. */
8799 b
->enable_state
= bp_disabled
;
8800 throw_exception (e
);
8806 gdb_assert (sals
.nelts
== 1);
8808 resolve_sal_pc (&sals
.sals
[0]);
8809 if (b
->condition_not_parsed
&& s
&& s
[0])
8811 char *cond_string
= 0;
8815 find_condition_and_thread (s
, sals
.sals
[0].pc
,
8816 &cond_string
, &thread
, &task
);
8818 b
->cond_string
= cond_string
;
8821 b
->condition_not_parsed
= 0;
8824 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
8827 make_cleanup (xfree
, sals
.sals
);
8828 update_breakpoint_locations (b
, expanded
);
8832 case bp_hardware_watchpoint
:
8833 case bp_read_watchpoint
:
8834 case bp_access_watchpoint
:
8835 /* Watchpoint can be either on expression using entirely global variables,
8836 or it can be on local variables.
8838 Watchpoints of the first kind are never auto-deleted, and even persist
8839 across program restarts. Since they can use variables from shared
8840 libraries, we need to reparse expression as libraries are loaded
8843 Watchpoints on local variables can also change meaning as result
8844 of solib event. For example, if a watchpoint uses both a local and
8845 a global variables in expression, it's a local watchpoint, but
8846 unloading of a shared library will make the expression invalid.
8847 This is not a very common use case, but we still re-evaluate
8848 expression, to avoid surprises to the user.
8850 Note that for local watchpoints, we re-evaluate it only if
8851 watchpoints frame id is still valid. If it's not, it means
8852 the watchpoint is out of scope and will be deleted soon. In fact,
8853 I'm not sure we'll ever be called in this case.
8855 If a local watchpoint's frame id is still valid, then
8856 b->exp_valid_block is likewise valid, and we can safely use it.
8858 Don't do anything about disabled watchpoints, since they will
8859 be reevaluated again when enabled. */
8860 update_watchpoint (b
, 1 /* reparse */);
8862 /* We needn't really do anything to reset these, since the mask
8863 that requests them is unaffected by e.g., new libraries being
8869 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
8871 /* Delete overlay event and longjmp master breakpoints; they will be
8872 reset later by breakpoint_re_set. */
8873 case bp_overlay_event
:
8874 case bp_longjmp_master
:
8875 delete_breakpoint (b
);
8878 /* This breakpoint is special, it's set up when the inferior
8879 starts and we really don't want to touch it. */
8880 case bp_shlib_event
:
8882 /* Like bp_shlib_event, this breakpoint type is special.
8883 Once it is set up, we do not want to touch it. */
8884 case bp_thread_event
:
8886 /* Keep temporary breakpoints, which can be encountered when we step
8887 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
8888 Otherwise these should have been blown away via the cleanup chain
8889 or by breakpoint_init_inferior when we rerun the executable. */
8892 case bp_watchpoint_scope
:
8894 case bp_step_resume
:
8896 case bp_longjmp_resume
:
8901 do_cleanups (cleanups
);
8905 /* Re-set all breakpoints after symbols have been re-loaded. */
8907 breakpoint_re_set (void)
8909 struct breakpoint
*b
, *temp
;
8910 enum language save_language
;
8911 int save_input_radix
;
8912 struct cleanup
*old_chain
;
8914 save_language
= current_language
->la_language
;
8915 save_input_radix
= input_radix
;
8916 old_chain
= save_current_program_space ();
8918 ALL_BREAKPOINTS_SAFE (b
, temp
)
8920 /* Format possible error msg */
8921 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
8923 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
8924 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
8925 do_cleanups (cleanups
);
8927 set_language (save_language
);
8928 input_radix
= save_input_radix
;
8930 jit_breakpoint_re_set ();
8932 do_cleanups (old_chain
);
8934 create_overlay_event_breakpoint ("_ovly_debug_event");
8935 create_longjmp_master_breakpoint ("longjmp");
8936 create_longjmp_master_breakpoint ("_longjmp");
8937 create_longjmp_master_breakpoint ("siglongjmp");
8938 create_longjmp_master_breakpoint ("_siglongjmp");
8941 /* Reset the thread number of this breakpoint:
8943 - If the breakpoint is for all threads, leave it as-is.
8944 - Else, reset it to the current thread for inferior_ptid. */
8946 breakpoint_re_set_thread (struct breakpoint
*b
)
8948 if (b
->thread
!= -1)
8950 if (in_thread_list (inferior_ptid
))
8951 b
->thread
= pid_to_thread_id (inferior_ptid
);
8953 /* We're being called after following a fork. The new fork is
8954 selected as current, and unless this was a vfork will have a
8955 different program space from the original thread. Reset that
8957 b
->loc
->pspace
= current_program_space
;
8961 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
8962 If from_tty is nonzero, it prints a message to that effect,
8963 which ends with a period (no newline). */
8966 set_ignore_count (int bptnum
, int count
, int from_tty
)
8968 struct breakpoint
*b
;
8974 if (b
->number
== bptnum
)
8976 b
->ignore_count
= count
;
8980 printf_filtered (_("Will stop next time breakpoint %d is reached."),
8982 else if (count
== 1)
8983 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
8986 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
8989 breakpoints_changed ();
8990 observer_notify_breakpoint_modified (b
->number
);
8994 error (_("No breakpoint number %d."), bptnum
);
8998 make_breakpoint_silent (struct breakpoint
*b
)
9000 /* Silence the breakpoint. */
9004 /* Command to set ignore-count of breakpoint N to COUNT. */
9007 ignore_command (char *args
, int from_tty
)
9013 error_no_arg (_("a breakpoint number"));
9015 num
= get_number (&p
);
9017 error (_("bad breakpoint number: '%s'"), args
);
9019 error (_("Second argument (specified ignore-count) is missing."));
9021 set_ignore_count (num
,
9022 longest_to_int (value_as_long (parse_and_eval (p
))),
9025 printf_filtered ("\n");
9028 /* Call FUNCTION on each of the breakpoints
9029 whose numbers are given in ARGS. */
9032 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
9037 struct breakpoint
*b
, *tmp
;
9041 error_no_arg (_("one or more breakpoint numbers"));
9048 num
= get_number_or_range (&p1
);
9051 warning (_("bad breakpoint number at or near '%s'"), p
);
9055 ALL_BREAKPOINTS_SAFE (b
, tmp
)
9056 if (b
->number
== num
)
9058 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
9061 if (related_breakpoint
)
9062 function (related_breakpoint
);
9066 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
9072 static struct bp_location
*
9073 find_location_by_number (char *number
)
9075 char *dot
= strchr (number
, '.');
9079 struct breakpoint
*b
;
9080 struct bp_location
*loc
;
9085 bp_num
= get_number_or_range (&p1
);
9087 error (_("Bad breakpoint number '%s'"), number
);
9090 if (b
->number
== bp_num
)
9095 if (!b
|| b
->number
!= bp_num
)
9096 error (_("Bad breakpoint number '%s'"), number
);
9099 loc_num
= get_number_or_range (&p1
);
9101 error (_("Bad breakpoint location number '%s'"), number
);
9105 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
9108 error (_("Bad breakpoint location number '%s'"), dot
+1);
9114 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
9115 If from_tty is nonzero, it prints a message to that effect,
9116 which ends with a period (no newline). */
9119 disable_breakpoint (struct breakpoint
*bpt
)
9121 /* Never disable a watchpoint scope breakpoint; we want to
9122 hit them when we leave scope so we can delete both the
9123 watchpoint and its scope breakpoint at that time. */
9124 if (bpt
->type
== bp_watchpoint_scope
)
9127 /* You can't disable permanent breakpoints. */
9128 if (bpt
->enable_state
== bp_permanent
)
9131 bpt
->enable_state
= bp_disabled
;
9133 update_global_location_list (0);
9135 observer_notify_breakpoint_modified (bpt
->number
);
9139 disable_command (char *args
, int from_tty
)
9141 struct breakpoint
*bpt
;
9143 ALL_BREAKPOINTS (bpt
)
9147 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
9153 case bp_hardware_breakpoint
:
9155 case bp_hardware_watchpoint
:
9156 case bp_read_watchpoint
:
9157 case bp_access_watchpoint
:
9158 disable_breakpoint (bpt
);
9162 else if (strchr (args
, '.'))
9164 struct bp_location
*loc
= find_location_by_number (args
);
9167 update_global_location_list (0);
9170 map_breakpoint_numbers (args
, disable_breakpoint
);
9174 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
9176 int target_resources_ok
, other_type_used
;
9179 if (bpt
->type
== bp_hardware_breakpoint
)
9182 i
= hw_breakpoint_used_count ();
9183 target_resources_ok
=
9184 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9186 if (target_resources_ok
== 0)
9187 error (_("No hardware breakpoint support in the target."));
9188 else if (target_resources_ok
< 0)
9189 error (_("Hardware breakpoints used exceeds limit."));
9192 if (bpt
->type
== bp_watchpoint
9193 || bpt
->type
== bp_hardware_watchpoint
9194 || bpt
->type
== bp_read_watchpoint
9195 || bpt
->type
== bp_access_watchpoint
)
9197 struct gdb_exception e
;
9199 TRY_CATCH (e
, RETURN_MASK_ALL
)
9201 update_watchpoint (bpt
, 1 /* reparse */);
9205 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
9211 if (bpt
->enable_state
!= bp_permanent
)
9212 bpt
->enable_state
= bp_enabled
;
9213 bpt
->disposition
= disposition
;
9214 update_global_location_list (1);
9215 breakpoints_changed ();
9217 observer_notify_breakpoint_modified (bpt
->number
);
9222 enable_breakpoint (struct breakpoint
*bpt
)
9224 do_enable_breakpoint (bpt
, bpt
->disposition
);
9227 /* The enable command enables the specified breakpoints (or all defined
9228 breakpoints) so they once again become (or continue to be) effective
9229 in stopping the inferior. */
9232 enable_command (char *args
, int from_tty
)
9234 struct breakpoint
*bpt
;
9236 ALL_BREAKPOINTS (bpt
)
9240 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
9246 case bp_hardware_breakpoint
:
9248 case bp_hardware_watchpoint
:
9249 case bp_read_watchpoint
:
9250 case bp_access_watchpoint
:
9251 enable_breakpoint (bpt
);
9255 else if (strchr (args
, '.'))
9257 struct bp_location
*loc
= find_location_by_number (args
);
9260 update_global_location_list (1);
9263 map_breakpoint_numbers (args
, enable_breakpoint
);
9267 enable_once_breakpoint (struct breakpoint
*bpt
)
9269 do_enable_breakpoint (bpt
, disp_disable
);
9273 enable_once_command (char *args
, int from_tty
)
9275 map_breakpoint_numbers (args
, enable_once_breakpoint
);
9279 enable_delete_breakpoint (struct breakpoint
*bpt
)
9281 do_enable_breakpoint (bpt
, disp_del
);
9285 enable_delete_command (char *args
, int from_tty
)
9287 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
9291 set_breakpoint_cmd (char *args
, int from_tty
)
9296 show_breakpoint_cmd (char *args
, int from_tty
)
9300 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
9302 struct symtabs_and_lines
9303 decode_line_spec_1 (char *string
, int funfirstline
)
9305 struct symtabs_and_lines sals
;
9307 error (_("Empty line specification."));
9308 if (default_breakpoint_valid
)
9309 sals
= decode_line_1 (&string
, funfirstline
,
9310 default_breakpoint_symtab
,
9311 default_breakpoint_line
,
9312 (char ***) NULL
, NULL
);
9314 sals
= decode_line_1 (&string
, funfirstline
,
9315 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
9317 error (_("Junk at end of line specification: %s"), string
);
9321 /* Create and insert a raw software breakpoint at PC. Return an
9322 identifier, which should be used to remove the breakpoint later.
9323 In general, places which call this should be using something on the
9324 breakpoint chain instead; this function should be eliminated
9328 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
9329 struct address_space
*aspace
, CORE_ADDR pc
)
9331 struct bp_target_info
*bp_tgt
;
9333 bp_tgt
= XZALLOC (struct bp_target_info
);
9335 bp_tgt
->placed_address_space
= aspace
;
9336 bp_tgt
->placed_address
= pc
;
9338 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
9340 /* Could not insert the breakpoint. */
9348 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
9351 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
9353 struct bp_target_info
*bp_tgt
= bp
;
9356 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
9362 /* One (or perhaps two) breakpoints used for software single stepping. */
9364 static void *single_step_breakpoints
[2];
9365 static struct gdbarch
*single_step_gdbarch
[2];
9367 /* Create and insert a breakpoint for software single step. */
9370 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
9371 struct address_space
*aspace
, CORE_ADDR next_pc
)
9375 if (single_step_breakpoints
[0] == NULL
)
9377 bpt_p
= &single_step_breakpoints
[0];
9378 single_step_gdbarch
[0] = gdbarch
;
9382 gdb_assert (single_step_breakpoints
[1] == NULL
);
9383 bpt_p
= &single_step_breakpoints
[1];
9384 single_step_gdbarch
[1] = gdbarch
;
9387 /* NOTE drow/2006-04-11: A future improvement to this function would be
9388 to only create the breakpoints once, and actually put them on the
9389 breakpoint chain. That would let us use set_raw_breakpoint. We could
9390 adjust the addresses each time they were needed. Doing this requires
9391 corresponding changes elsewhere where single step breakpoints are
9392 handled, however. So, for now, we use this. */
9394 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
9396 error (_("Could not insert single-step breakpoint at %s"),
9397 paddress (gdbarch
, next_pc
));
9400 /* Remove and delete any breakpoints used for software single step. */
9403 remove_single_step_breakpoints (void)
9405 gdb_assert (single_step_breakpoints
[0] != NULL
);
9407 /* See insert_single_step_breakpoint for more about this deprecated
9409 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
9410 single_step_breakpoints
[0]);
9411 single_step_gdbarch
[0] = NULL
;
9412 single_step_breakpoints
[0] = NULL
;
9414 if (single_step_breakpoints
[1] != NULL
)
9416 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
9417 single_step_breakpoints
[1]);
9418 single_step_gdbarch
[1] = NULL
;
9419 single_step_breakpoints
[1] = NULL
;
9423 /* Check whether a software single-step breakpoint is inserted at PC. */
9426 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
9430 for (i
= 0; i
< 2; i
++)
9432 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
9434 && breakpoint_address_match (bp_tgt
->placed_address_space
,
9435 bp_tgt
->placed_address
,
9443 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
9444 non-zero otherwise. */
9446 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
9448 if (syscall_catchpoint_p (bp
)
9449 && bp
->enable_state
!= bp_disabled
9450 && bp
->enable_state
!= bp_call_disabled
)
9457 catch_syscall_enabled (void)
9459 struct inferior
*inf
= current_inferior ();
9461 return inf
->total_syscalls_count
!= 0;
9465 catching_syscall_number (int syscall_number
)
9467 struct breakpoint
*bp
;
9469 ALL_BREAKPOINTS (bp
)
9470 if (is_syscall_catchpoint_enabled (bp
))
9472 if (bp
->syscalls_to_be_caught
)
9476 VEC_iterate (int, bp
->syscalls_to_be_caught
, i
, iter
);
9478 if (syscall_number
== iter
)
9488 /* Complete syscall names. Used by "catch syscall". */
9490 catch_syscall_completer (struct cmd_list_element
*cmd
,
9491 char *text
, char *word
)
9493 const char **list
= get_syscall_names ();
9494 return (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
9497 /* Tracepoint-specific operations. */
9499 /* Set tracepoint count to NUM. */
9501 set_tracepoint_count (int num
)
9503 tracepoint_count
= num
;
9504 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
9508 trace_command (char *arg
, int from_tty
)
9510 break_command_really (get_current_arch (),
9512 NULL
, 0, 1 /* parse arg */,
9513 0 /* tempflag */, 0 /* hardwareflag */,
9515 0 /* Ignore count */,
9516 pending_break_support
,
9520 set_tracepoint_count (breakpoint_count
);
9523 /* Print information on tracepoint number TPNUM_EXP, or all if
9527 tracepoints_info (char *tpnum_exp
, int from_tty
)
9529 struct breakpoint
*b
;
9530 int tps_to_list
= 0;
9532 /* In the no-arguments case, say "No tracepoints" if none found. */
9545 ui_out_message (uiout
, 0, "No tracepoints.\n");
9550 /* Otherwise be the same as "info break". */
9551 breakpoints_info (tpnum_exp
, from_tty
);
9554 /* The 'enable trace' command enables tracepoints.
9555 Not supported by all targets. */
9557 enable_trace_command (char *args
, int from_tty
)
9559 enable_command (args
, from_tty
);
9562 /* The 'disable trace' command disables tracepoints.
9563 Not supported by all targets. */
9565 disable_trace_command (char *args
, int from_tty
)
9567 disable_command (args
, from_tty
);
9570 /* Remove a tracepoint (or all if no argument) */
9572 delete_trace_command (char *arg
, int from_tty
)
9574 struct breakpoint
*b
, *temp
;
9580 int breaks_to_delete
= 0;
9582 /* Delete all breakpoints if no argument.
9583 Do not delete internal or call-dummy breakpoints, these
9584 have to be deleted with an explicit breakpoint number argument. */
9589 breaks_to_delete
= 1;
9594 /* Ask user only if there are some breakpoints to delete. */
9596 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
9598 ALL_BREAKPOINTS_SAFE (b
, temp
)
9600 if (b
->type
== bp_tracepoint
9602 delete_breakpoint (b
);
9607 map_breakpoint_numbers (arg
, delete_breakpoint
);
9610 /* Set passcount for tracepoint.
9612 First command argument is passcount, second is tracepoint number.
9613 If tracepoint number omitted, apply to most recently defined.
9614 Also accepts special argument "all". */
9617 trace_pass_command (char *args
, int from_tty
)
9619 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
9623 if (args
== 0 || *args
== 0)
9624 error (_("passcount command requires an argument (count + optional TP num)"));
9626 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
9628 while (*args
&& isspace ((int) *args
))
9631 if (*args
&& strncasecmp (args
, "all", 3) == 0)
9633 args
+= 3; /* Skip special argument "all". */
9636 error (_("Junk at end of arguments."));
9639 t1
= get_tracepoint_by_number (&args
, 1, 1);
9645 ALL_TRACEPOINTS (t2
)
9646 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
9648 t2
->pass_count
= count
;
9649 observer_notify_tracepoint_modified (t2
->number
);
9651 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
9655 t1
= get_tracepoint_by_number (&args
, 1, 0);
9662 get_tracepoint (int num
)
9664 struct breakpoint
*t
;
9667 if (t
->number
== num
)
9673 /* Utility: parse a tracepoint number and look it up in the list.
9674 If MULTI_P is true, there might be a range of tracepoints in ARG.
9675 if OPTIONAL_P is true, then if the argument is missing, the most
9676 recent tracepoint (tracepoint_count) is returned. */
9678 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
9680 extern int tracepoint_count
;
9681 struct breakpoint
*t
;
9683 char *instring
= arg
== NULL
? NULL
: *arg
;
9685 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
9688 tpnum
= tracepoint_count
;
9690 error_no_arg (_("tracepoint number"));
9693 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
9697 if (instring
&& *instring
)
9698 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
9701 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
9706 if (t
->number
== tpnum
)
9711 /* FIXME: if we are in the middle of a range we don't want to give
9712 a message. The current interface to get_number_or_range doesn't
9713 allow us to discover this. */
9714 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
9718 /* save-tracepoints command */
9720 tracepoint_save_command (char *args
, int from_tty
)
9722 struct breakpoint
*tp
;
9724 struct action_line
*line
;
9726 char *i1
= " ", *i2
= " ";
9727 char *indent
, *actionline
, *pathname
;
9729 struct cleanup
*cleanup
;
9731 if (args
== 0 || *args
== 0)
9732 error (_("Argument required (file name in which to save tracepoints)"));
9734 /* See if we have anything to save. */
9735 ALL_TRACEPOINTS (tp
)
9742 warning (_("save-tracepoints: no tracepoints to save."));
9746 pathname
= tilde_expand (args
);
9747 cleanup
= make_cleanup (xfree
, pathname
);
9748 fp
= fopen (pathname
, "w");
9750 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
9751 args
, safe_strerror (errno
));
9752 make_cleanup_fclose (fp
);
9754 ALL_TRACEPOINTS (tp
)
9756 if (tp
->addr_string
)
9757 fprintf (fp
, "trace %s\n", tp
->addr_string
);
9760 sprintf_vma (tmp
, tp
->loc
->address
);
9761 fprintf (fp
, "trace *0x%s\n", tmp
);
9765 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
9769 fprintf (fp
, " actions\n");
9771 for (line
= tp
->actions
; line
; line
= line
->next
)
9773 struct cmd_list_element
*cmd
;
9775 QUIT
; /* allow user to bail out with ^C */
9776 actionline
= line
->action
;
9777 while (isspace ((int) *actionline
))
9780 fprintf (fp
, "%s%s\n", indent
, actionline
);
9781 if (*actionline
!= '#') /* skip for comment lines */
9783 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
9785 error (_("Bad action list item: %s"), actionline
);
9786 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
9788 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
9794 do_cleanups (cleanup
);
9796 printf_filtered (_("Tracepoints saved to file '%s'.\n"), args
);
9800 /* Create a vector of all tracepoints. */
9805 VEC(breakpoint_p
) *tp_vec
= 0;
9806 struct breakpoint
*tp
;
9808 ALL_TRACEPOINTS (tp
)
9810 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
9817 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
9818 It is defined as a macro to prevent duplication.
9819 COMMAND should be a string constant containing the name of the command. */
9820 #define BREAK_ARGS_HELP(command) \
9821 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
9822 LOCATION may be a line number, function name, or \"*\" and an address.\n\
9823 If a line number is specified, break at start of code for that line.\n\
9824 If a function is specified, break at start of code for that function.\n\
9825 If an address is specified, break at that exact address.\n\
9826 With no LOCATION, uses current execution address of selected stack frame.\n\
9827 This is useful for breaking on return to a stack frame.\n\
9829 THREADNUM is the number from \"info threads\".\n\
9830 CONDITION is a boolean expression.\n\
9832 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
9834 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
9836 /* List of subcommands for "catch". */
9837 static struct cmd_list_element
*catch_cmdlist
;
9839 /* List of subcommands for "tcatch". */
9840 static struct cmd_list_element
*tcatch_cmdlist
;
9842 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
9843 lists, and pass some additional user data to the command function. */
9845 add_catch_command (char *name
, char *docstring
,
9846 void (*sfunc
) (char *args
, int from_tty
,
9847 struct cmd_list_element
*command
),
9848 char **(*completer
) (struct cmd_list_element
*cmd
,
9849 char *text
, char *word
),
9850 void *user_data_catch
,
9851 void *user_data_tcatch
)
9853 struct cmd_list_element
*command
;
9855 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
9857 set_cmd_sfunc (command
, sfunc
);
9858 set_cmd_context (command
, user_data_catch
);
9859 set_cmd_completer (command
, completer
);
9861 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
9863 set_cmd_sfunc (command
, sfunc
);
9864 set_cmd_context (command
, user_data_tcatch
);
9865 set_cmd_completer (command
, completer
);
9869 clear_syscall_counts (int pid
)
9871 struct inferior
*inf
= find_inferior_pid (pid
);
9873 inf
->total_syscalls_count
= 0;
9874 inf
->any_syscall_count
= 0;
9875 VEC_free (int, inf
->syscalls_counts
);
9879 _initialize_breakpoint (void)
9881 static struct cmd_list_element
*breakpoint_set_cmdlist
;
9882 static struct cmd_list_element
*breakpoint_show_cmdlist
;
9883 struct cmd_list_element
*c
;
9885 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
9886 observer_attach_inferior_exit (clear_syscall_counts
);
9888 breakpoint_chain
= 0;
9889 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
9890 before a breakpoint is set. */
9891 breakpoint_count
= 0;
9893 tracepoint_count
= 0;
9895 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
9896 Set ignore-count of breakpoint number N to COUNT.\n\
9897 Usage is `ignore N COUNT'."));
9899 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
9901 add_com ("commands", class_breakpoint
, commands_command
, _("\
9902 Set commands to be executed when a breakpoint is hit.\n\
9903 Give breakpoint number as argument after \"commands\".\n\
9904 With no argument, the targeted breakpoint is the last one set.\n\
9905 The commands themselves follow starting on the next line.\n\
9906 Type a line containing \"end\" to indicate the end of them.\n\
9907 Give \"silent\" as the first line to make the breakpoint silent;\n\
9908 then no output is printed when it is hit, except what the commands print."));
9910 add_com ("condition", class_breakpoint
, condition_command
, _("\
9911 Specify breakpoint number N to break only if COND is true.\n\
9912 Usage is `condition N COND', where N is an integer and COND is an\n\
9913 expression to be evaluated whenever breakpoint N is reached."));
9915 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
9916 Set a temporary breakpoint.\n\
9917 Like \"break\" except the breakpoint is only temporary,\n\
9918 so it will be deleted when hit. Equivalent to \"break\" followed\n\
9919 by using \"enable delete\" on the breakpoint number.\n\
9921 BREAK_ARGS_HELP ("tbreak")));
9922 set_cmd_completer (c
, location_completer
);
9924 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
9925 Set a hardware assisted breakpoint.\n\
9926 Like \"break\" except the breakpoint requires hardware support,\n\
9927 some target hardware may not have this support.\n\
9929 BREAK_ARGS_HELP ("hbreak")));
9930 set_cmd_completer (c
, location_completer
);
9932 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
9933 Set a temporary hardware assisted breakpoint.\n\
9934 Like \"hbreak\" except the breakpoint is only temporary,\n\
9935 so it will be deleted when hit.\n\
9937 BREAK_ARGS_HELP ("thbreak")));
9938 set_cmd_completer (c
, location_completer
);
9940 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
9941 Enable some breakpoints.\n\
9942 Give breakpoint numbers (separated by spaces) as arguments.\n\
9943 With no subcommand, breakpoints are enabled until you command otherwise.\n\
9944 This is used to cancel the effect of the \"disable\" command.\n\
9945 With a subcommand you can enable temporarily."),
9946 &enablelist
, "enable ", 1, &cmdlist
);
9948 add_com ("ab", class_breakpoint
, enable_command
, _("\
9949 Enable some breakpoints.\n\
9950 Give breakpoint numbers (separated by spaces) as arguments.\n\
9951 With no subcommand, breakpoints are enabled until you command otherwise.\n\
9952 This is used to cancel the effect of the \"disable\" command.\n\
9953 With a subcommand you can enable temporarily."));
9955 add_com_alias ("en", "enable", class_breakpoint
, 1);
9957 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
9958 Enable some breakpoints.\n\
9959 Give breakpoint numbers (separated by spaces) as arguments.\n\
9960 This is used to cancel the effect of the \"disable\" command.\n\
9961 May be abbreviated to simply \"enable\".\n"),
9962 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
9964 add_cmd ("once", no_class
, enable_once_command
, _("\
9965 Enable breakpoints for one hit. Give breakpoint numbers.\n\
9966 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
9969 add_cmd ("delete", no_class
, enable_delete_command
, _("\
9970 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
9971 If a breakpoint is hit while enabled in this fashion, it is deleted."),
9974 add_cmd ("delete", no_class
, enable_delete_command
, _("\
9975 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
9976 If a breakpoint is hit while enabled in this fashion, it is deleted."),
9979 add_cmd ("once", no_class
, enable_once_command
, _("\
9980 Enable breakpoints for one hit. Give breakpoint numbers.\n\
9981 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
9984 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
9985 Disable some breakpoints.\n\
9986 Arguments are breakpoint numbers with spaces in between.\n\
9987 To disable all breakpoints, give no argument.\n\
9988 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
9989 &disablelist
, "disable ", 1, &cmdlist
);
9990 add_com_alias ("dis", "disable", class_breakpoint
, 1);
9991 add_com_alias ("disa", "disable", class_breakpoint
, 1);
9993 add_com ("sb", class_breakpoint
, disable_command
, _("\
9994 Disable some breakpoints.\n\
9995 Arguments are breakpoint numbers with spaces in between.\n\
9996 To disable all breakpoints, give no argument.\n\
9997 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
9999 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
10000 Disable some breakpoints.\n\
10001 Arguments are breakpoint numbers with spaces in between.\n\
10002 To disable all breakpoints, give no argument.\n\
10003 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
10004 This command may be abbreviated \"disable\"."),
10007 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
10008 Delete some breakpoints or auto-display expressions.\n\
10009 Arguments are breakpoint numbers with spaces in between.\n\
10010 To delete all breakpoints, give no argument.\n\
10012 Also a prefix command for deletion of other GDB objects.\n\
10013 The \"unset\" command is also an alias for \"delete\"."),
10014 &deletelist
, "delete ", 1, &cmdlist
);
10015 add_com_alias ("d", "delete", class_breakpoint
, 1);
10016 add_com_alias ("del", "delete", class_breakpoint
, 1);
10018 add_com ("db", class_breakpoint
, delete_command
, _("\
10019 Delete some breakpoints.\n\
10020 Arguments are breakpoint numbers with spaces in between.\n\
10021 To delete all breakpoints, give no argument.\n"));
10023 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
10024 Delete some breakpoints or auto-display expressions.\n\
10025 Arguments are breakpoint numbers with spaces in between.\n\
10026 To delete all breakpoints, give no argument.\n\
10027 This command may be abbreviated \"delete\"."),
10030 add_com ("clear", class_breakpoint
, clear_command
, _("\
10031 Clear breakpoint at specified line or function.\n\
10032 Argument may be line number, function name, or \"*\" and an address.\n\
10033 If line number is specified, all breakpoints in that line are cleared.\n\
10034 If function is specified, breakpoints at beginning of function are cleared.\n\
10035 If an address is specified, breakpoints at that address are cleared.\n\
10037 With no argument, clears all breakpoints in the line that the selected frame\n\
10038 is executing in.\n\
10040 See also the \"delete\" command which clears breakpoints by number."));
10042 c
= add_com ("break", class_breakpoint
, break_command
, _("\
10043 Set breakpoint at specified line or function.\n"
10044 BREAK_ARGS_HELP ("break")));
10045 set_cmd_completer (c
, location_completer
);
10047 add_com_alias ("b", "break", class_run
, 1);
10048 add_com_alias ("br", "break", class_run
, 1);
10049 add_com_alias ("bre", "break", class_run
, 1);
10050 add_com_alias ("brea", "break", class_run
, 1);
10053 add_com_alias ("ba", "break", class_breakpoint
, 1);
10057 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
10058 Break in function/address or break at a line in the current file."),
10059 &stoplist
, "stop ", 1, &cmdlist
);
10060 add_cmd ("in", class_breakpoint
, stopin_command
,
10061 _("Break in function or address."), &stoplist
);
10062 add_cmd ("at", class_breakpoint
, stopat_command
,
10063 _("Break at a line in the current file."), &stoplist
);
10064 add_com ("status", class_info
, breakpoints_info
, _("\
10065 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10066 The \"Type\" column indicates one of:\n\
10067 \tbreakpoint - normal breakpoint\n\
10068 \twatchpoint - watchpoint\n\
10069 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10070 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10071 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10072 address and file/line number respectively.\n\
10074 Convenience variable \"$_\" and default examine address for \"x\"\n\
10075 are set to the address of the last breakpoint listed unless the command\n\
10076 is prefixed with \"server \".\n\n\
10077 Convenience variable \"$bpnum\" contains the number of the last\n\
10078 breakpoint set."));
10081 add_info ("breakpoints", breakpoints_info
, _("\
10082 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10083 The \"Type\" column indicates one of:\n\
10084 \tbreakpoint - normal breakpoint\n\
10085 \twatchpoint - watchpoint\n\
10086 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10087 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10088 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10089 address and file/line number respectively.\n\
10091 Convenience variable \"$_\" and default examine address for \"x\"\n\
10092 are set to the address of the last breakpoint listed unless the command\n\
10093 is prefixed with \"server \".\n\n\
10094 Convenience variable \"$bpnum\" contains the number of the last\n\
10095 breakpoint set."));
10098 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
10099 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10100 The \"Type\" column indicates one of:\n\
10101 \tbreakpoint - normal breakpoint\n\
10102 \twatchpoint - watchpoint\n\
10103 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10104 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10105 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10106 address and file/line number respectively.\n\
10108 Convenience variable \"$_\" and default examine address for \"x\"\n\
10109 are set to the address of the last breakpoint listed unless the command\n\
10110 is prefixed with \"server \".\n\n\
10111 Convenience variable \"$bpnum\" contains the number of the last\n\
10112 breakpoint set."));
10114 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
10115 Status of all breakpoints, or breakpoint number NUMBER.\n\
10116 The \"Type\" column indicates one of:\n\
10117 \tbreakpoint - normal breakpoint\n\
10118 \twatchpoint - watchpoint\n\
10119 \tlongjmp - internal breakpoint used to step through longjmp()\n\
10120 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
10121 \tuntil - internal breakpoint used by the \"until\" command\n\
10122 \tfinish - internal breakpoint used by the \"finish\" command\n\
10123 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10124 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10125 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10126 address and file/line number respectively.\n\
10128 Convenience variable \"$_\" and default examine address for \"x\"\n\
10129 are set to the address of the last breakpoint listed unless the command\n\
10130 is prefixed with \"server \".\n\n\
10131 Convenience variable \"$bpnum\" contains the number of the last\n\
10133 &maintenanceinfolist
);
10135 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
10136 Set catchpoints to catch events."),
10137 &catch_cmdlist
, "catch ",
10138 0/*allow-unknown*/, &cmdlist
);
10140 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
10141 Set temporary catchpoints to catch events."),
10142 &tcatch_cmdlist
, "tcatch ",
10143 0/*allow-unknown*/, &cmdlist
);
10145 /* Add catch and tcatch sub-commands. */
10146 add_catch_command ("catch", _("\
10147 Catch an exception, when caught.\n\
10148 With an argument, catch only exceptions with the given name."),
10149 catch_catch_command
,
10153 add_catch_command ("throw", _("\
10154 Catch an exception, when thrown.\n\
10155 With an argument, catch only exceptions with the given name."),
10156 catch_throw_command
,
10160 add_catch_command ("fork", _("Catch calls to fork."),
10161 catch_fork_command_1
,
10163 (void *) (uintptr_t) catch_fork_permanent
,
10164 (void *) (uintptr_t) catch_fork_temporary
);
10165 add_catch_command ("vfork", _("Catch calls to vfork."),
10166 catch_fork_command_1
,
10168 (void *) (uintptr_t) catch_vfork_permanent
,
10169 (void *) (uintptr_t) catch_vfork_temporary
);
10170 add_catch_command ("exec", _("Catch calls to exec."),
10171 catch_exec_command_1
,
10175 add_catch_command ("syscall", _("\
10176 Catch system calls by their names and/or numbers.\n\
10177 Arguments say which system calls to catch. If no arguments\n\
10178 are given, every system call will be caught.\n\
10179 Arguments, if given, should be one or more system call names\n\
10180 (if your system supports that), or system call numbers."),
10181 catch_syscall_command_1
,
10182 catch_syscall_completer
,
10185 add_catch_command ("exception", _("\
10186 Catch Ada exceptions, when raised.\n\
10187 With an argument, catch only exceptions with the given name."),
10188 catch_ada_exception_command
,
10192 add_catch_command ("assert", _("\
10193 Catch failed Ada assertions, when raised.\n\
10194 With an argument, catch only exceptions with the given name."),
10195 catch_assert_command
,
10200 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
10201 Set a watchpoint for an expression.\n\
10202 A watchpoint stops execution of your program whenever the value of\n\
10203 an expression changes."));
10204 set_cmd_completer (c
, expression_completer
);
10206 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
10207 Set a read watchpoint for an expression.\n\
10208 A watchpoint stops execution of your program whenever the value of\n\
10209 an expression is read."));
10210 set_cmd_completer (c
, expression_completer
);
10212 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
10213 Set a watchpoint for an expression.\n\
10214 A watchpoint stops execution of your program whenever the value of\n\
10215 an expression is either read or written."));
10216 set_cmd_completer (c
, expression_completer
);
10218 add_info ("watchpoints", breakpoints_info
,
10219 _("Synonym for ``info breakpoints''."));
10222 /* XXX: cagney/2005-02-23: This should be a boolean, and should
10223 respond to changes - contrary to the description. */
10224 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
10225 &can_use_hw_watchpoints
, _("\
10226 Set debugger's willingness to use watchpoint hardware."), _("\
10227 Show debugger's willingness to use watchpoint hardware."), _("\
10228 If zero, gdb will not use hardware for new watchpoints, even if\n\
10229 such is available. (However, any hardware watchpoints that were\n\
10230 created before setting this to nonzero, will continue to use watchpoint\n\
10233 show_can_use_hw_watchpoints
,
10234 &setlist
, &showlist
);
10236 can_use_hw_watchpoints
= 1;
10238 /* Tracepoint manipulation commands. */
10240 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
10241 Set a tracepoint at specified line or function.\n\
10243 BREAK_ARGS_HELP ("trace") "\n\
10244 Do \"help tracepoints\" for info on other tracepoint commands."));
10245 set_cmd_completer (c
, location_completer
);
10247 add_com_alias ("tp", "trace", class_alias
, 0);
10248 add_com_alias ("tr", "trace", class_alias
, 1);
10249 add_com_alias ("tra", "trace", class_alias
, 1);
10250 add_com_alias ("trac", "trace", class_alias
, 1);
10252 add_info ("tracepoints", tracepoints_info
, _("\
10253 Status of tracepoints, or tracepoint number NUMBER.\n\
10254 Convenience variable \"$tpnum\" contains the number of the\n\
10255 last tracepoint set."));
10257 add_info_alias ("tp", "tracepoints", 1);
10259 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
10260 Delete specified tracepoints.\n\
10261 Arguments are tracepoint numbers, separated by spaces.\n\
10262 No argument means delete all tracepoints."),
10265 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
10266 Disable specified tracepoints.\n\
10267 Arguments are tracepoint numbers, separated by spaces.\n\
10268 No argument means disable all tracepoints."),
10270 deprecate_cmd (c
, "disable");
10272 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
10273 Enable specified tracepoints.\n\
10274 Arguments are tracepoint numbers, separated by spaces.\n\
10275 No argument means enable all tracepoints."),
10277 deprecate_cmd (c
, "enable");
10279 add_com ("passcount", class_trace
, trace_pass_command
, _("\
10280 Set the passcount for a tracepoint.\n\
10281 The trace will end when the tracepoint has been passed 'count' times.\n\
10282 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
10283 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
10285 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
10286 Save current tracepoint definitions as a script.\n\
10287 Use the 'source' command in another debug session to restore them."));
10288 set_cmd_completer (c
, filename_completer
);
10290 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
10291 Breakpoint specific settings\n\
10292 Configure various breakpoint-specific variables such as\n\
10293 pending breakpoint behavior"),
10294 &breakpoint_set_cmdlist
, "set breakpoint ",
10295 0/*allow-unknown*/, &setlist
);
10296 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
10297 Breakpoint specific settings\n\
10298 Configure various breakpoint-specific variables such as\n\
10299 pending breakpoint behavior"),
10300 &breakpoint_show_cmdlist
, "show breakpoint ",
10301 0/*allow-unknown*/, &showlist
);
10303 add_setshow_auto_boolean_cmd ("pending", no_class
,
10304 &pending_break_support
, _("\
10305 Set debugger's behavior regarding pending breakpoints."), _("\
10306 Show debugger's behavior regarding pending breakpoints."), _("\
10307 If on, an unrecognized breakpoint location will cause gdb to create a\n\
10308 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
10309 an error. If auto, an unrecognized breakpoint location results in a\n\
10310 user-query to see if a pending breakpoint should be created."),
10312 show_pending_break_support
,
10313 &breakpoint_set_cmdlist
,
10314 &breakpoint_show_cmdlist
);
10316 pending_break_support
= AUTO_BOOLEAN_AUTO
;
10318 add_setshow_boolean_cmd ("auto-hw", no_class
,
10319 &automatic_hardware_breakpoints
, _("\
10320 Set automatic usage of hardware breakpoints."), _("\
10321 Show automatic usage of hardware breakpoints."), _("\
10322 If set, the debugger will automatically use hardware breakpoints for\n\
10323 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
10324 a warning will be emitted for such breakpoints."),
10326 show_automatic_hardware_breakpoints
,
10327 &breakpoint_set_cmdlist
,
10328 &breakpoint_show_cmdlist
);
10330 add_setshow_enum_cmd ("always-inserted", class_support
,
10331 always_inserted_enums
, &always_inserted_mode
, _("\
10332 Set mode for inserting breakpoints."), _("\
10333 Show mode for inserting breakpoints."), _("\
10334 When this mode is off, breakpoints are inserted in inferior when it is\n\
10335 resumed, and removed when execution stops. When this mode is on,\n\
10336 breakpoints are inserted immediately and removed only when the user\n\
10337 deletes the breakpoint. When this mode is auto (which is the default),\n\
10338 the behaviour depends on the non-stop setting (see help set non-stop).\n\
10339 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
10340 behaves as if always-inserted mode is on; if gdb is controlling the\n\
10341 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
10343 &show_always_inserted_mode
,
10344 &breakpoint_set_cmdlist
,
10345 &breakpoint_show_cmdlist
);
10347 automatic_hardware_breakpoints
= 1;
10349 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);