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
)
3821 static void print_breakpoint_location (struct breakpoint
*b
,
3822 struct bp_location
*loc
,
3824 struct ui_stream
*stb
)
3826 struct cleanup
*old_chain
= save_current_program_space ();
3829 set_current_program_space (loc
->pspace
);
3834 = find_pc_sect_function (loc
->address
, loc
->section
);
3837 ui_out_text (uiout
, "in ");
3838 ui_out_field_string (uiout
, "func",
3839 SYMBOL_PRINT_NAME (sym
));
3840 ui_out_wrap_hint (uiout
, wrap_indent
);
3841 ui_out_text (uiout
, " at ");
3843 ui_out_field_string (uiout
, "file", b
->source_file
);
3844 ui_out_text (uiout
, ":");
3846 if (ui_out_is_mi_like_p (uiout
))
3848 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3849 char *fullname
= symtab_to_fullname (sal
.symtab
);
3852 ui_out_field_string (uiout
, "fullname", fullname
);
3855 ui_out_field_int (uiout
, "line", b
->line_number
);
3859 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3863 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3864 ui_out_field_stream (uiout
, "at", stb
);
3867 do_cleanups (old_chain
);
3870 /* Print B to gdb_stdout. */
3872 print_one_breakpoint_location (struct breakpoint
*b
,
3873 struct bp_location
*loc
,
3875 struct bp_location
**last_loc
,
3876 int print_address_bits
,
3879 struct command_line
*l
;
3881 struct ep_type_description
3886 static struct ep_type_description bptypes
[] =
3888 {bp_none
, "?deleted?"},
3889 {bp_breakpoint
, "breakpoint"},
3890 {bp_hardware_breakpoint
, "hw breakpoint"},
3891 {bp_until
, "until"},
3892 {bp_finish
, "finish"},
3893 {bp_watchpoint
, "watchpoint"},
3894 {bp_hardware_watchpoint
, "hw watchpoint"},
3895 {bp_read_watchpoint
, "read watchpoint"},
3896 {bp_access_watchpoint
, "acc watchpoint"},
3897 {bp_longjmp
, "longjmp"},
3898 {bp_longjmp_resume
, "longjmp resume"},
3899 {bp_step_resume
, "step resume"},
3900 {bp_watchpoint_scope
, "watchpoint scope"},
3901 {bp_call_dummy
, "call dummy"},
3902 {bp_shlib_event
, "shlib events"},
3903 {bp_thread_event
, "thread events"},
3904 {bp_overlay_event
, "overlay events"},
3905 {bp_longjmp_master
, "longjmp master"},
3906 {bp_catchpoint
, "catchpoint"},
3907 {bp_tracepoint
, "tracepoint"},
3908 {bp_jit_event
, "jit events"},
3911 static char bpenables
[] = "nynny";
3912 char wrap_indent
[80];
3913 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3914 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3915 struct cleanup
*bkpt_chain
;
3917 int header_of_multiple
= 0;
3918 int part_of_multiple
= (loc
!= NULL
);
3919 struct value_print_options opts
;
3921 get_user_print_options (&opts
);
3923 gdb_assert (!loc
|| loc_number
!= 0);
3924 /* See comment in print_one_breakpoint concerning
3925 treatment of breakpoints with single disabled
3929 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3930 header_of_multiple
= 1;
3935 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3939 if (part_of_multiple
)
3942 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3943 ui_out_field_string (uiout
, "number", formatted
);
3948 ui_out_field_int (uiout
, "number", b
->number
);
3953 if (part_of_multiple
)
3954 ui_out_field_skip (uiout
, "type");
3957 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3958 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3959 internal_error (__FILE__
, __LINE__
,
3960 _("bptypes table does not describe type #%d."),
3962 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3967 if (part_of_multiple
)
3968 ui_out_field_skip (uiout
, "disp");
3970 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3975 if (part_of_multiple
)
3976 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3978 ui_out_field_fmt (uiout
, "enabled", "%c",
3979 bpenables
[(int) b
->enable_state
]);
3980 ui_out_spaces (uiout
, 2);
3984 strcpy (wrap_indent
, " ");
3985 if (opts
.addressprint
)
3987 if (print_address_bits
<= 32)
3988 strcat (wrap_indent
, " ");
3990 strcat (wrap_indent
, " ");
3993 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3995 /* Although the print_one can possibly print
3996 all locations, calling it here is not likely
3997 to get any nice result. So, make sure there's
3998 just one location. */
3999 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4000 b
->ops
->print_one (b
, last_loc
);
4006 internal_error (__FILE__
, __LINE__
,
4007 _("print_one_breakpoint: bp_none encountered\n"));
4011 case bp_hardware_watchpoint
:
4012 case bp_read_watchpoint
:
4013 case bp_access_watchpoint
:
4014 /* Field 4, the address, is omitted (which makes the columns
4015 not line up too nicely with the headers, but the effect
4016 is relatively readable). */
4017 if (opts
.addressprint
)
4018 ui_out_field_skip (uiout
, "addr");
4020 ui_out_field_string (uiout
, "what", b
->exp_string
);
4024 case bp_hardware_breakpoint
:
4028 case bp_longjmp_resume
:
4029 case bp_step_resume
:
4030 case bp_watchpoint_scope
:
4032 case bp_shlib_event
:
4033 case bp_thread_event
:
4034 case bp_overlay_event
:
4035 case bp_longjmp_master
:
4038 if (opts
.addressprint
)
4041 if (header_of_multiple
)
4042 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4043 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4044 ui_out_field_string (uiout
, "addr", "<PENDING>");
4046 ui_out_field_core_addr (uiout
, "addr",
4047 loc
->gdbarch
, loc
->address
);
4050 if (!header_of_multiple
)
4051 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
4058 /* For backward compatibility, don't display inferiors unless there
4061 && !header_of_multiple
4063 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4064 && (number_of_program_spaces () > 1
4065 || number_of_inferiors () > 1)
4066 && loc
->owner
->type
!= bp_catchpoint
)))
4068 struct inferior
*inf
;
4071 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4073 if (inf
->pspace
== loc
->pspace
)
4078 ui_out_text (uiout
, " inf ");
4081 ui_out_text (uiout
, ", ");
4082 ui_out_text (uiout
, plongest (inf
->num
));
4087 if (!part_of_multiple
)
4089 if (b
->thread
!= -1)
4091 /* FIXME: This seems to be redundant and lost here; see the
4092 "stop only in" line a little further down. */
4093 ui_out_text (uiout
, " thread ");
4094 ui_out_field_int (uiout
, "thread", b
->thread
);
4096 else if (b
->task
!= 0)
4098 ui_out_text (uiout
, " task ");
4099 ui_out_field_int (uiout
, "task", b
->task
);
4103 ui_out_text (uiout
, "\n");
4105 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4108 ui_out_text (uiout
, "\tstop only in stack frame at ");
4109 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4111 ui_out_field_core_addr (uiout
, "frame",
4112 b
->gdbarch
, b
->frame_id
.stack_addr
);
4113 ui_out_text (uiout
, "\n");
4116 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
4118 /* We do not print the condition for Ada exception catchpoints
4119 because the condition is an internal implementation detail
4120 that we do not want to expose to the user. */
4122 if (b
->type
== bp_tracepoint
)
4123 ui_out_text (uiout
, "\ttrace only if ");
4125 ui_out_text (uiout
, "\tstop only if ");
4126 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4127 ui_out_text (uiout
, "\n");
4130 if (!part_of_multiple
&& b
->thread
!= -1)
4132 /* FIXME should make an annotation for this */
4133 ui_out_text (uiout
, "\tstop only in thread ");
4134 ui_out_field_int (uiout
, "thread", b
->thread
);
4135 ui_out_text (uiout
, "\n");
4138 if (!part_of_multiple
&& b
->hit_count
)
4140 /* FIXME should make an annotation for this */
4141 if (ep_is_catchpoint (b
))
4142 ui_out_text (uiout
, "\tcatchpoint");
4144 ui_out_text (uiout
, "\tbreakpoint");
4145 ui_out_text (uiout
, " already hit ");
4146 ui_out_field_int (uiout
, "times", b
->hit_count
);
4147 if (b
->hit_count
== 1)
4148 ui_out_text (uiout
, " time\n");
4150 ui_out_text (uiout
, " times\n");
4153 /* Output the count also if it is zero, but only if this is
4154 mi. FIXME: Should have a better test for this. */
4155 if (ui_out_is_mi_like_p (uiout
))
4156 if (!part_of_multiple
&& b
->hit_count
== 0)
4157 ui_out_field_int (uiout
, "times", b
->hit_count
);
4159 if (!part_of_multiple
&& b
->ignore_count
)
4162 ui_out_text (uiout
, "\tignore next ");
4163 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
4164 ui_out_text (uiout
, " hits\n");
4168 if (!part_of_multiple
&& l
)
4170 struct cleanup
*script_chain
;
4173 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
4174 print_command_lines (uiout
, l
, 4);
4175 do_cleanups (script_chain
);
4178 if (!part_of_multiple
&& b
->pass_count
)
4180 annotate_field (10);
4181 ui_out_text (uiout
, "\tpass count ");
4182 ui_out_field_int (uiout
, "pass", b
->pass_count
);
4183 ui_out_text (uiout
, " \n");
4186 if (!part_of_multiple
&& b
->step_count
)
4188 annotate_field (11);
4189 ui_out_text (uiout
, "\tstep count ");
4190 ui_out_field_int (uiout
, "step", b
->step_count
);
4191 ui_out_text (uiout
, " \n");
4194 if (!part_of_multiple
&& b
->actions
)
4196 struct action_line
*action
;
4197 annotate_field (12);
4198 for (action
= b
->actions
; action
; action
= action
->next
)
4200 ui_out_text (uiout
, " A\t");
4201 ui_out_text (uiout
, action
->action
);
4202 ui_out_text (uiout
, "\n");
4206 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
4209 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
4210 else if (b
->exp_string
)
4211 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
4214 do_cleanups (bkpt_chain
);
4215 do_cleanups (old_chain
);
4219 print_one_breakpoint (struct breakpoint
*b
,
4220 struct bp_location
**last_loc
, int print_address_bits
,
4223 print_one_breakpoint_location (b
, NULL
, 0, last_loc
,
4224 print_address_bits
, allflag
);
4226 /* If this breakpoint has custom print function,
4227 it's already printed. Otherwise, print individual
4228 locations, if any. */
4229 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
4231 /* If breakpoint has a single location that is
4232 disabled, we print it as if it had
4233 several locations, since otherwise it's hard to
4234 represent "breakpoint enabled, location disabled"
4236 Note that while hardware watchpoints have
4237 several locations internally, that's no a property
4240 && !is_hardware_watchpoint (b
)
4241 && (b
->loc
->next
|| !b
->loc
->enabled
)
4242 && !ui_out_is_mi_like_p (uiout
))
4244 struct bp_location
*loc
;
4246 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
4247 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
4248 print_address_bits
, allflag
);
4254 breakpoint_address_bits (struct breakpoint
*b
)
4256 int print_address_bits
= 0;
4257 struct bp_location
*loc
;
4259 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4261 int addr_bit
= gdbarch_addr_bit (b
->gdbarch
);
4262 if (addr_bit
> print_address_bits
)
4263 print_address_bits
= addr_bit
;
4266 return print_address_bits
;
4269 struct captured_breakpoint_query_args
4275 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
4277 struct captured_breakpoint_query_args
*args
= data
;
4278 struct breakpoint
*b
;
4279 struct bp_location
*dummy_loc
= NULL
;
4282 if (args
->bnum
== b
->number
)
4284 int print_address_bits
= breakpoint_address_bits (b
);
4285 print_one_breakpoint (b
, &dummy_loc
, print_address_bits
, 0);
4293 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
4295 struct captured_breakpoint_query_args args
;
4297 /* For the moment we don't trust print_one_breakpoint() to not throw
4299 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
4300 error_message
, RETURN_MASK_ALL
) < 0)
4306 /* Return non-zero if B is user settable (breakpoints, watchpoints,
4307 catchpoints, et.al.). */
4310 user_settable_breakpoint (const struct breakpoint
*b
)
4312 return (b
->type
== bp_breakpoint
4313 || b
->type
== bp_catchpoint
4314 || b
->type
== bp_hardware_breakpoint
4315 || b
->type
== bp_tracepoint
4316 || b
->type
== bp_watchpoint
4317 || b
->type
== bp_read_watchpoint
4318 || b
->type
== bp_access_watchpoint
4319 || b
->type
== bp_hardware_watchpoint
);
4322 /* Print information on user settable breakpoint (watchpoint, etc)
4323 number BNUM. If BNUM is -1 print all user settable breakpoints.
4324 If ALLFLAG is non-zero, include non- user settable breakpoints. */
4327 breakpoint_1 (int bnum
, int allflag
)
4329 struct breakpoint
*b
;
4330 struct bp_location
*last_loc
= NULL
;
4331 int nr_printable_breakpoints
;
4332 struct cleanup
*bkpttbl_chain
;
4333 struct value_print_options opts
;
4334 int print_address_bits
= 0;
4336 get_user_print_options (&opts
);
4338 /* Compute the number of rows in the table, as well as the
4339 size required for address fields. */
4340 nr_printable_breakpoints
= 0;
4343 || bnum
== b
->number
)
4345 if (allflag
|| user_settable_breakpoint (b
))
4347 int addr_bit
= breakpoint_address_bits (b
);
4348 if (addr_bit
> print_address_bits
)
4349 print_address_bits
= addr_bit
;
4351 nr_printable_breakpoints
++;
4355 if (opts
.addressprint
)
4357 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
4361 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
4364 if (nr_printable_breakpoints
> 0)
4365 annotate_breakpoints_headers ();
4366 if (nr_printable_breakpoints
> 0)
4368 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
4369 if (nr_printable_breakpoints
> 0)
4371 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
4372 if (nr_printable_breakpoints
> 0)
4374 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
4375 if (nr_printable_breakpoints
> 0)
4377 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
4378 if (opts
.addressprint
)
4380 if (nr_printable_breakpoints
> 0)
4382 if (print_address_bits
<= 32)
4383 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
4385 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
4387 if (nr_printable_breakpoints
> 0)
4389 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
4390 ui_out_table_body (uiout
);
4391 if (nr_printable_breakpoints
> 0)
4392 annotate_breakpoints_table ();
4396 || bnum
== b
->number
)
4398 /* We only print out user settable breakpoints unless the
4400 if (allflag
|| user_settable_breakpoint (b
))
4401 print_one_breakpoint (b
, &last_loc
, print_address_bits
, allflag
);
4404 do_cleanups (bkpttbl_chain
);
4406 if (nr_printable_breakpoints
== 0)
4409 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
4411 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
4416 if (last_loc
&& !server_command
)
4417 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
4420 /* FIXME? Should this be moved up so that it is only called when
4421 there have been breakpoints? */
4422 annotate_breakpoints_table_end ();
4426 breakpoints_info (char *bnum_exp
, int from_tty
)
4431 bnum
= parse_and_eval_long (bnum_exp
);
4433 breakpoint_1 (bnum
, 0);
4437 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4442 bnum
= parse_and_eval_long (bnum_exp
);
4444 breakpoint_1 (bnum
, 1);
4448 breakpoint_has_pc (struct breakpoint
*b
,
4449 struct program_space
*pspace
,
4450 CORE_ADDR pc
, struct obj_section
*section
)
4452 struct bp_location
*bl
= b
->loc
;
4453 for (; bl
; bl
= bl
->next
)
4455 if (bl
->pspace
== pspace
4456 && bl
->address
== pc
4457 && (!overlay_debugging
|| bl
->section
== section
))
4463 /* Print a message describing any breakpoints set at PC. This
4464 concerns with logical breakpoints, so we match program spaces, not
4468 describe_other_breakpoints (struct gdbarch
*gdbarch
,
4469 struct program_space
*pspace
, CORE_ADDR pc
,
4470 struct obj_section
*section
, int thread
)
4473 struct breakpoint
*b
;
4476 others
+= breakpoint_has_pc (b
, pspace
, pc
, section
);
4480 printf_filtered (_("Note: breakpoint "));
4481 else /* if (others == ???) */
4482 printf_filtered (_("Note: breakpoints "));
4484 if (breakpoint_has_pc (b
, pspace
, pc
, section
))
4487 printf_filtered ("%d", b
->number
);
4488 if (b
->thread
== -1 && thread
!= -1)
4489 printf_filtered (" (all threads)");
4490 else if (b
->thread
!= -1)
4491 printf_filtered (" (thread %d)", b
->thread
);
4492 printf_filtered ("%s%s ",
4493 ((b
->enable_state
== bp_disabled
4494 || b
->enable_state
== bp_call_disabled
4495 || b
->enable_state
== bp_startup_disabled
)
4497 : b
->enable_state
== bp_permanent
4501 : ((others
== 1) ? " and" : ""));
4503 printf_filtered (_("also set at pc "));
4504 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
4505 printf_filtered (".\n");
4509 /* Set the default place to put a breakpoint
4510 for the `break' command with no arguments. */
4513 set_default_breakpoint (int valid
, struct program_space
*pspace
,
4514 CORE_ADDR addr
, struct symtab
*symtab
,
4517 default_breakpoint_valid
= valid
;
4518 default_breakpoint_pspace
= pspace
;
4519 default_breakpoint_address
= addr
;
4520 default_breakpoint_symtab
= symtab
;
4521 default_breakpoint_line
= line
;
4524 /* Return true iff it is meaningful to use the address member of
4525 BPT. For some breakpoint types, the address member is irrelevant
4526 and it makes no sense to attempt to compare it to other addresses
4527 (or use it for any other purpose either).
4529 More specifically, each of the following breakpoint types will always
4530 have a zero valued address and we don't want to mark breakpoints of any of
4531 these types to be a duplicate of an actual breakpoint at address zero:
4534 bp_hardware_watchpoint
4536 bp_access_watchpoint
4540 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4542 enum bptype type
= bpt
->type
;
4544 return (type
!= bp_watchpoint
4545 && type
!= bp_hardware_watchpoint
4546 && type
!= bp_read_watchpoint
4547 && type
!= bp_access_watchpoint
4548 && type
!= bp_catchpoint
);
4551 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
4552 same breakpoint location. In most targets, this can only be true
4553 if ASPACE1 matches ASPACE2. On targets that have global
4554 breakpoints, the address space doesn't really matter. */
4557 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
4558 struct address_space
*aspace2
, CORE_ADDR addr2
)
4560 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
4561 || aspace1
== aspace2
)
4566 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4567 int bnum
, int have_bnum
)
4572 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4573 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4575 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4576 bnum
, astr1
, astr2
);
4578 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4581 /* Adjust a breakpoint's address to account for architectural constraints
4582 on breakpoint placement. Return the adjusted address. Note: Very
4583 few targets require this kind of adjustment. For most targets,
4584 this function is simply the identity function. */
4587 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
4588 CORE_ADDR bpaddr
, enum bptype bptype
)
4590 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
4592 /* Very few targets need any kind of breakpoint adjustment. */
4595 else if (bptype
== bp_watchpoint
4596 || bptype
== bp_hardware_watchpoint
4597 || bptype
== bp_read_watchpoint
4598 || bptype
== bp_access_watchpoint
4599 || bptype
== bp_catchpoint
)
4601 /* Watchpoints and the various bp_catch_* eventpoints should not
4602 have their addresses modified. */
4607 CORE_ADDR adjusted_bpaddr
;
4609 /* Some targets have architectural constraints on the placement
4610 of breakpoint instructions. Obtain the adjusted address. */
4611 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
4613 /* An adjusted breakpoint address can significantly alter
4614 a user's expectations. Print a warning if an adjustment
4616 if (adjusted_bpaddr
!= bpaddr
)
4617 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4619 return adjusted_bpaddr
;
4623 /* Allocate a struct bp_location. */
4625 static struct bp_location
*
4626 allocate_bp_location (struct breakpoint
*bpt
)
4628 struct bp_location
*loc
, *loc_p
;
4630 loc
= xmalloc (sizeof (struct bp_location
));
4631 memset (loc
, 0, sizeof (*loc
));
4635 loc
->shlib_disabled
= 0;
4645 case bp_longjmp_resume
:
4646 case bp_step_resume
:
4647 case bp_watchpoint_scope
:
4649 case bp_shlib_event
:
4650 case bp_thread_event
:
4651 case bp_overlay_event
:
4653 case bp_longjmp_master
:
4654 loc
->loc_type
= bp_loc_software_breakpoint
;
4656 case bp_hardware_breakpoint
:
4657 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4659 case bp_hardware_watchpoint
:
4660 case bp_read_watchpoint
:
4661 case bp_access_watchpoint
:
4662 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4666 loc
->loc_type
= bp_loc_other
;
4669 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4675 static void free_bp_location (struct bp_location
*loc
)
4680 if (loc
->function_name
)
4681 xfree (loc
->function_name
);
4686 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4687 that has type BPTYPE and has no locations as yet. */
4688 /* This function is used in gdbtk sources and thus can not be made static. */
4690 static struct breakpoint
*
4691 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
4694 struct breakpoint
*b
, *b1
;
4696 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4697 memset (b
, 0, sizeof (*b
));
4700 b
->gdbarch
= gdbarch
;
4701 b
->language
= current_language
->la_language
;
4702 b
->input_radix
= input_radix
;
4704 b
->enable_state
= bp_enabled
;
4707 b
->ignore_count
= 0;
4709 b
->frame_id
= null_frame_id
;
4710 b
->forked_inferior_pid
= null_ptid
;
4711 b
->exec_pathname
= NULL
;
4712 b
->syscalls_to_be_caught
= NULL
;
4714 b
->condition_not_parsed
= 0;
4716 /* Add this breakpoint to the end of the chain
4717 so that a list of breakpoints will come out in order
4718 of increasing numbers. */
4720 b1
= breakpoint_chain
;
4722 breakpoint_chain
= b
;
4732 /* Initialize loc->function_name. */
4734 set_breakpoint_location_function (struct bp_location
*loc
)
4736 if (loc
->owner
->type
== bp_breakpoint
4737 || loc
->owner
->type
== bp_hardware_breakpoint
4738 || loc
->owner
->type
== bp_tracepoint
)
4740 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4742 if (loc
->function_name
)
4743 loc
->function_name
= xstrdup (loc
->function_name
);
4747 /* Attempt to determine architecture of location identified by SAL. */
4748 static struct gdbarch
*
4749 get_sal_arch (struct symtab_and_line sal
)
4752 return get_objfile_arch (sal
.section
->objfile
);
4754 return get_objfile_arch (sal
.symtab
->objfile
);
4759 /* set_raw_breakpoint is a low level routine for allocating and
4760 partially initializing a breakpoint of type BPTYPE. The newly
4761 created breakpoint's address, section, source file name, and line
4762 number are provided by SAL. The newly created and partially
4763 initialized breakpoint is added to the breakpoint chain and
4764 is also returned as the value of this function.
4766 It is expected that the caller will complete the initialization of
4767 the newly created breakpoint struct as well as output any status
4768 information regarding the creation of a new breakpoint. In
4769 particular, set_raw_breakpoint does NOT set the breakpoint
4770 number! Care should be taken to not allow an error to occur
4771 prior to completing the initialization of the breakpoint. If this
4772 should happen, a bogus breakpoint will be left on the chain. */
4775 set_raw_breakpoint (struct gdbarch
*gdbarch
,
4776 struct symtab_and_line sal
, enum bptype bptype
)
4778 struct breakpoint
*b
= set_raw_breakpoint_without_location (gdbarch
, bptype
);
4779 CORE_ADDR adjusted_address
;
4780 struct gdbarch
*loc_gdbarch
;
4782 loc_gdbarch
= get_sal_arch (sal
);
4784 loc_gdbarch
= b
->gdbarch
;
4786 if (bptype
!= bp_catchpoint
)
4787 gdb_assert (sal
.pspace
!= NULL
);
4789 /* Adjust the breakpoint's address prior to allocating a location.
4790 Once we call allocate_bp_location(), that mostly uninitialized
4791 location will be placed on the location chain. Adjustment of the
4792 breakpoint may cause target_read_memory() to be called and we do
4793 not want its scan of the location chain to find a breakpoint and
4794 location that's only been partially initialized. */
4795 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
, sal
.pc
, b
->type
);
4797 b
->loc
= allocate_bp_location (b
);
4798 b
->loc
->gdbarch
= loc_gdbarch
;
4799 b
->loc
->requested_address
= sal
.pc
;
4800 b
->loc
->address
= adjusted_address
;
4801 b
->loc
->pspace
= sal
.pspace
;
4803 /* Store the program space that was used to set the breakpoint, for
4804 breakpoint resetting. */
4805 b
->pspace
= sal
.pspace
;
4807 if (sal
.symtab
== NULL
)
4808 b
->source_file
= NULL
;
4810 b
->source_file
= xstrdup (sal
.symtab
->filename
);
4811 b
->loc
->section
= sal
.section
;
4812 b
->line_number
= sal
.line
;
4814 set_breakpoint_location_function (b
->loc
);
4816 breakpoints_changed ();
4822 /* Note that the breakpoint object B describes a permanent breakpoint
4823 instruction, hard-wired into the inferior's code. */
4825 make_breakpoint_permanent (struct breakpoint
*b
)
4827 struct bp_location
*bl
;
4828 b
->enable_state
= bp_permanent
;
4830 /* By definition, permanent breakpoints are already present in the code.
4831 Mark all locations as inserted. For now, make_breakpoint_permanent
4832 is called in just one place, so it's hard to say if it's reasonable
4833 to have permanent breakpoint with multiple locations or not,
4834 but it's easy to implmement. */
4835 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4839 /* Call this routine when stepping and nexting to enable a breakpoint
4840 if we do a longjmp() in THREAD. When we hit that breakpoint, call
4841 set_longjmp_resume_breakpoint() to figure out where we are going. */
4844 set_longjmp_breakpoint (int thread
)
4846 struct breakpoint
*b
, *temp
;
4848 /* To avoid having to rescan all objfile symbols at every step,
4849 we maintain a list of continually-inserted but always disabled
4850 longjmp "master" breakpoints. Here, we simply create momentary
4851 clones of those and enable them for the requested thread. */
4852 ALL_BREAKPOINTS_SAFE (b
, temp
)
4853 if (b
->pspace
== current_program_space
4854 && b
->type
== bp_longjmp_master
)
4856 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
4857 clone
->type
= bp_longjmp
;
4858 clone
->thread
= thread
;
4862 /* Delete all longjmp breakpoints from THREAD. */
4864 delete_longjmp_breakpoint (int thread
)
4866 struct breakpoint
*b
, *temp
;
4868 ALL_BREAKPOINTS_SAFE (b
, temp
)
4869 if (b
->type
== bp_longjmp
)
4871 if (b
->thread
== thread
)
4872 delete_breakpoint (b
);
4877 enable_overlay_breakpoints (void)
4879 struct breakpoint
*b
;
4882 if (b
->type
== bp_overlay_event
)
4884 b
->enable_state
= bp_enabled
;
4885 update_global_location_list (1);
4886 overlay_events_enabled
= 1;
4891 disable_overlay_breakpoints (void)
4893 struct breakpoint
*b
;
4896 if (b
->type
== bp_overlay_event
)
4898 b
->enable_state
= bp_disabled
;
4899 update_global_location_list (0);
4900 overlay_events_enabled
= 0;
4905 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
4907 struct breakpoint
*b
;
4909 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
);
4911 b
->enable_state
= bp_enabled
;
4912 /* addr_string has to be used or breakpoint_re_set will delete me. */
4914 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
4916 update_global_location_list_nothrow (1);
4922 remove_thread_event_breakpoints (void)
4924 struct breakpoint
*b
, *temp
;
4926 ALL_BREAKPOINTS_SAFE (b
, temp
)
4927 if (b
->type
== bp_thread_event
4928 && b
->loc
->pspace
== current_program_space
)
4929 delete_breakpoint (b
);
4932 struct captured_parse_breakpoint_args
4935 struct symtabs_and_lines
*sals_p
;
4936 char ***addr_string_p
;
4940 struct lang_and_radix
4946 /* Create a breakpoint for JIT code registration and unregistration. */
4949 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
4951 struct breakpoint
*b
;
4953 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
4954 update_global_location_list_nothrow (1);
4959 remove_solib_event_breakpoints (void)
4961 struct breakpoint
*b
, *temp
;
4963 ALL_BREAKPOINTS_SAFE (b
, temp
)
4964 if (b
->type
== bp_shlib_event
4965 && b
->loc
->pspace
== current_program_space
)
4966 delete_breakpoint (b
);
4970 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
4972 struct breakpoint
*b
;
4974 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
4975 update_global_location_list_nothrow (1);
4979 /* Disable any breakpoints that are on code in shared libraries. Only
4980 apply to enabled breakpoints, disabled ones can just stay disabled. */
4983 disable_breakpoints_in_shlibs (void)
4985 struct bp_location
*loc
, **locp_tmp
;
4987 ALL_BP_LOCATIONS (loc
, locp_tmp
)
4989 struct breakpoint
*b
= loc
->owner
;
4990 /* We apply the check to all breakpoints, including disabled
4991 for those with loc->duplicate set. This is so that when breakpoint
4992 becomes enabled, or the duplicate is removed, gdb will try to insert
4993 all breakpoints. If we don't set shlib_disabled here, we'll try
4994 to insert those breakpoints and fail. */
4995 if (((b
->type
== bp_breakpoint
)
4996 || (b
->type
== bp_hardware_breakpoint
)
4997 || (b
->type
== bp_tracepoint
))
4998 && loc
->pspace
== current_program_space
4999 && !loc
->shlib_disabled
5001 && PC_SOLIB (loc
->address
)
5003 && solib_name_from_address (loc
->pspace
, loc
->address
)
5007 loc
->shlib_disabled
= 1;
5012 /* Disable any breakpoints that are in in an unloaded shared library. Only
5013 apply to enabled breakpoints, disabled ones can just stay disabled. */
5016 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
5018 struct bp_location
*loc
, **locp_tmp
;
5019 int disabled_shlib_breaks
= 0;
5021 /* SunOS a.out shared libraries are always mapped, so do not
5022 disable breakpoints; they will only be reported as unloaded
5023 through clear_solib when GDB discards its shared library
5024 list. See clear_solib for more information. */
5025 if (exec_bfd
!= NULL
5026 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
5029 ALL_BP_LOCATIONS (loc
, locp_tmp
)
5031 struct breakpoint
*b
= loc
->owner
;
5032 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
5033 || loc
->loc_type
== bp_loc_software_breakpoint
)
5034 && solib
->pspace
== loc
->pspace
5035 && !loc
->shlib_disabled
5036 && (b
->type
== bp_breakpoint
|| b
->type
== bp_hardware_breakpoint
)
5037 && solib_contains_address_p (solib
, loc
->address
))
5039 loc
->shlib_disabled
= 1;
5040 /* At this point, we cannot rely on remove_breakpoint
5041 succeeding so we must mark the breakpoint as not inserted
5042 to prevent future errors occurring in remove_breakpoints. */
5044 if (!disabled_shlib_breaks
)
5046 target_terminal_ours_for_output ();
5047 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
5050 disabled_shlib_breaks
= 1;
5055 /* FORK & VFORK catchpoints. */
5057 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
5060 insert_catch_fork (struct breakpoint
*b
)
5062 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
5065 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
5068 remove_catch_fork (struct breakpoint
*b
)
5070 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
5073 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
5077 breakpoint_hit_catch_fork (struct breakpoint
*b
)
5079 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
5082 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
5084 static enum print_stop_action
5085 print_it_catch_fork (struct breakpoint
*b
)
5087 annotate_catchpoint (b
->number
);
5088 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
5089 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5090 return PRINT_SRC_AND_LOC
;
5093 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
5096 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5098 struct value_print_options opts
;
5100 get_user_print_options (&opts
);
5102 /* Field 4, the address, is omitted (which makes the columns
5103 not line up too nicely with the headers, but the effect
5104 is relatively readable). */
5105 if (opts
.addressprint
)
5106 ui_out_field_skip (uiout
, "addr");
5108 ui_out_text (uiout
, "fork");
5109 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
5111 ui_out_text (uiout
, ", process ");
5112 ui_out_field_int (uiout
, "what",
5113 ptid_get_pid (b
->forked_inferior_pid
));
5114 ui_out_spaces (uiout
, 1);
5118 /* Implement the "print_mention" breakpoint_ops method for fork
5122 print_mention_catch_fork (struct breakpoint
*b
)
5124 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
5127 /* The breakpoint_ops structure to be used in fork catchpoints. */
5129 static struct breakpoint_ops catch_fork_breakpoint_ops
=
5133 breakpoint_hit_catch_fork
,
5134 print_it_catch_fork
,
5135 print_one_catch_fork
,
5136 print_mention_catch_fork
5139 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
5142 insert_catch_vfork (struct breakpoint
*b
)
5144 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
5147 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
5150 remove_catch_vfork (struct breakpoint
*b
)
5152 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
5155 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
5159 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
5161 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
5164 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
5166 static enum print_stop_action
5167 print_it_catch_vfork (struct breakpoint
*b
)
5169 annotate_catchpoint (b
->number
);
5170 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
5171 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5172 return PRINT_SRC_AND_LOC
;
5175 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
5178 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5180 struct value_print_options opts
;
5182 get_user_print_options (&opts
);
5183 /* Field 4, the address, is omitted (which makes the columns
5184 not line up too nicely with the headers, but the effect
5185 is relatively readable). */
5186 if (opts
.addressprint
)
5187 ui_out_field_skip (uiout
, "addr");
5189 ui_out_text (uiout
, "vfork");
5190 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
5192 ui_out_text (uiout
, ", process ");
5193 ui_out_field_int (uiout
, "what",
5194 ptid_get_pid (b
->forked_inferior_pid
));
5195 ui_out_spaces (uiout
, 1);
5199 /* Implement the "print_mention" breakpoint_ops method for vfork
5203 print_mention_catch_vfork (struct breakpoint
*b
)
5205 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
5208 /* The breakpoint_ops structure to be used in vfork catchpoints. */
5210 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
5214 breakpoint_hit_catch_vfork
,
5215 print_it_catch_vfork
,
5216 print_one_catch_vfork
,
5217 print_mention_catch_vfork
5220 /* Implement the "insert" breakpoint_ops method for syscall
5224 insert_catch_syscall (struct breakpoint
*b
)
5226 struct inferior
*inf
= current_inferior ();
5228 ++inf
->total_syscalls_count
;
5229 if (!b
->syscalls_to_be_caught
)
5230 ++inf
->any_syscall_count
;
5235 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5239 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
5241 int old_size
= VEC_length (int, inf
->syscalls_counts
);
5242 uintptr_t vec_addr_offset
= old_size
* ((uintptr_t) sizeof (int));
5244 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
5245 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
5247 memset ((void *) vec_addr
, 0,
5248 (iter
+ 1 - old_size
) * sizeof (int));
5250 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
5251 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
5255 target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
5256 inf
->total_syscalls_count
!= 0,
5257 inf
->any_syscall_count
,
5258 VEC_length (int, inf
->syscalls_counts
),
5259 VEC_address (int, inf
->syscalls_counts
));
5262 /* Implement the "remove" breakpoint_ops method for syscall
5266 remove_catch_syscall (struct breakpoint
*b
)
5268 struct inferior
*inf
= current_inferior ();
5270 --inf
->total_syscalls_count
;
5271 if (!b
->syscalls_to_be_caught
)
5272 --inf
->any_syscall_count
;
5277 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5281 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
5282 /* Shouldn't happen. */
5284 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
5285 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
5289 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
5290 inf
->total_syscalls_count
!= 0,
5291 inf
->any_syscall_count
,
5292 VEC_length (int, inf
->syscalls_counts
),
5293 VEC_address (int, inf
->syscalls_counts
));
5296 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
5300 breakpoint_hit_catch_syscall (struct breakpoint
*b
)
5302 /* We must check if we are catching specific syscalls in this breakpoint.
5303 If we are, then we must guarantee that the called syscall is the same
5304 syscall we are catching. */
5305 int syscall_number
= 0;
5307 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
5310 /* Now, checking if the syscall is the same. */
5311 if (b
->syscalls_to_be_caught
)
5315 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5317 if (syscall_number
== iter
)
5327 /* Implement the "print_it" breakpoint_ops method for syscall
5330 static enum print_stop_action
5331 print_it_catch_syscall (struct breakpoint
*b
)
5333 /* These are needed because we want to know in which state a
5334 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
5335 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
5336 must print "called syscall" or "returned from syscall". */
5338 struct target_waitstatus last
;
5340 struct cleanup
*old_chain
;
5343 get_last_target_status (&ptid
, &last
);
5345 get_syscall_by_number (last
.value
.syscall_number
, &s
);
5347 annotate_catchpoint (b
->number
);
5350 syscall_id
= xstrprintf ("%d", last
.value
.syscall_number
);
5352 syscall_id
= xstrprintf ("'%s'", s
.name
);
5354 old_chain
= make_cleanup (xfree
, syscall_id
);
5356 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
5357 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
5358 b
->number
, syscall_id
);
5359 else if (last
.kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
5360 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
5361 b
->number
, syscall_id
);
5363 do_cleanups (old_chain
);
5365 return PRINT_SRC_AND_LOC
;
5368 /* Implement the "print_one" breakpoint_ops method for syscall
5372 print_one_catch_syscall (struct breakpoint
*b
,
5373 struct bp_location
**last_loc
)
5375 struct value_print_options opts
;
5377 get_user_print_options (&opts
);
5378 /* Field 4, the address, is omitted (which makes the columns
5379 not line up too nicely with the headers, but the effect
5380 is relatively readable). */
5381 if (opts
.addressprint
)
5382 ui_out_field_skip (uiout
, "addr");
5385 if (b
->syscalls_to_be_caught
5386 && VEC_length (int, b
->syscalls_to_be_caught
) > 1)
5387 ui_out_text (uiout
, "syscalls \"");
5389 ui_out_text (uiout
, "syscall \"");
5391 if (b
->syscalls_to_be_caught
)
5394 char *text
= xstrprintf ("%s", "");
5396 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5401 get_syscall_by_number (iter
, &s
);
5404 text
= xstrprintf ("%s%s, ", text
, s
.name
);
5406 text
= xstrprintf ("%s%d, ", text
, iter
);
5408 /* We have to xfree the last 'text' (now stored at 'x')
5409 because xstrprintf dinamically allocates new space for it
5413 /* Remove the last comma. */
5414 text
[strlen (text
) - 2] = '\0';
5415 ui_out_field_string (uiout
, "what", text
);
5418 ui_out_field_string (uiout
, "what", "<any syscall>");
5419 ui_out_text (uiout
, "\" ");
5422 /* Implement the "print_mention" breakpoint_ops method for syscall
5426 print_mention_catch_syscall (struct breakpoint
*b
)
5428 if (b
->syscalls_to_be_caught
)
5432 if (VEC_length (int, b
->syscalls_to_be_caught
) > 1)
5433 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
5435 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
5438 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5442 get_syscall_by_number (iter
, &s
);
5445 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
5447 printf_filtered (" %d", s
.number
);
5449 printf_filtered (")");
5452 printf_filtered (_("Catchpoint %d (any syscall)"),
5456 /* The breakpoint_ops structure to be used in syscall catchpoints. */
5458 static struct breakpoint_ops catch_syscall_breakpoint_ops
=
5460 insert_catch_syscall
,
5461 remove_catch_syscall
,
5462 breakpoint_hit_catch_syscall
,
5463 print_it_catch_syscall
,
5464 print_one_catch_syscall
,
5465 print_mention_catch_syscall
5468 /* Returns non-zero if 'b' is a syscall catchpoint. */
5471 syscall_catchpoint_p (struct breakpoint
*b
)
5473 return (b
->ops
== &catch_syscall_breakpoint_ops
);
5476 /* Create a new breakpoint of the bp_catchpoint kind and return it,
5477 but does NOT mention it nor update the global location list.
5478 This is useful if you need to fill more fields in the
5479 struct breakpoint before calling mention.
5481 If TEMPFLAG is non-zero, then make the breakpoint temporary.
5482 If COND_STRING is not NULL, then store it in the breakpoint.
5483 OPS, if not NULL, is the breakpoint_ops structure associated
5484 to the catchpoint. */
5486 static struct breakpoint
*
5487 create_catchpoint_without_mention (struct gdbarch
*gdbarch
, int tempflag
,
5489 struct breakpoint_ops
*ops
)
5491 struct symtab_and_line sal
;
5492 struct breakpoint
*b
;
5495 sal
.pspace
= current_program_space
;
5497 b
= set_raw_breakpoint (gdbarch
, sal
, bp_catchpoint
);
5498 set_breakpoint_count (breakpoint_count
+ 1);
5499 b
->number
= breakpoint_count
;
5501 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
5503 b
->addr_string
= NULL
;
5504 b
->enable_state
= bp_enabled
;
5505 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5511 /* Create a new breakpoint of the bp_catchpoint kind and return it.
5513 If TEMPFLAG is non-zero, then make the breakpoint temporary.
5514 If COND_STRING is not NULL, then store it in the breakpoint.
5515 OPS, if not NULL, is the breakpoint_ops structure associated
5516 to the catchpoint. */
5518 static struct breakpoint
*
5519 create_catchpoint (struct gdbarch
*gdbarch
, int tempflag
,
5520 char *cond_string
, struct breakpoint_ops
*ops
)
5522 struct breakpoint
*b
=
5523 create_catchpoint_without_mention (gdbarch
, tempflag
, cond_string
, ops
);
5526 update_global_location_list (1);
5532 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
5533 int tempflag
, char *cond_string
,
5534 struct breakpoint_ops
*ops
)
5536 struct breakpoint
*b
5537 = create_catchpoint (gdbarch
, tempflag
, cond_string
, ops
);
5539 /* FIXME: We should put this information in a breakpoint private data
5541 b
->forked_inferior_pid
= null_ptid
;
5544 /* Exec catchpoints. */
5547 insert_catch_exec (struct breakpoint
*b
)
5549 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
5553 remove_catch_exec (struct breakpoint
*b
)
5555 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
5559 breakpoint_hit_catch_exec (struct breakpoint
*b
)
5561 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
5564 static enum print_stop_action
5565 print_it_catch_exec (struct breakpoint
*b
)
5567 annotate_catchpoint (b
->number
);
5568 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
5570 return PRINT_SRC_AND_LOC
;
5574 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
5576 struct value_print_options opts
;
5578 get_user_print_options (&opts
);
5580 /* Field 4, the address, is omitted (which makes the columns
5581 not line up too nicely with the headers, but the effect
5582 is relatively readable). */
5583 if (opts
.addressprint
)
5584 ui_out_field_skip (uiout
, "addr");
5586 ui_out_text (uiout
, "exec");
5587 if (b
->exec_pathname
!= NULL
)
5589 ui_out_text (uiout
, ", program \"");
5590 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
5591 ui_out_text (uiout
, "\" ");
5596 print_mention_catch_exec (struct breakpoint
*b
)
5598 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
5601 static struct breakpoint_ops catch_exec_breakpoint_ops
=
5605 breakpoint_hit_catch_exec
,
5606 print_it_catch_exec
,
5607 print_one_catch_exec
,
5608 print_mention_catch_exec
5612 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
5613 struct breakpoint_ops
*ops
)
5615 struct gdbarch
*gdbarch
= get_current_arch ();
5616 struct breakpoint
*b
=
5617 create_catchpoint_without_mention (gdbarch
, tempflag
, NULL
, ops
);
5619 b
->syscalls_to_be_caught
= filter
;
5621 /* Now, we have to mention the breakpoint and update the global
5624 update_global_location_list (1);
5628 hw_breakpoint_used_count (void)
5630 struct breakpoint
*b
;
5635 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
5643 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
5645 struct breakpoint
*b
;
5648 *other_type_used
= 0;
5651 if (breakpoint_enabled (b
))
5653 if (b
->type
== type
)
5655 else if ((b
->type
== bp_hardware_watchpoint
5656 || b
->type
== bp_read_watchpoint
5657 || b
->type
== bp_access_watchpoint
))
5658 *other_type_used
= 1;
5665 disable_watchpoints_before_interactive_call_start (void)
5667 struct breakpoint
*b
;
5671 if (((b
->type
== bp_watchpoint
)
5672 || (b
->type
== bp_hardware_watchpoint
)
5673 || (b
->type
== bp_read_watchpoint
)
5674 || (b
->type
== bp_access_watchpoint
))
5675 && breakpoint_enabled (b
))
5677 b
->enable_state
= bp_call_disabled
;
5678 update_global_location_list (0);
5684 enable_watchpoints_after_interactive_call_stop (void)
5686 struct breakpoint
*b
;
5690 if (((b
->type
== bp_watchpoint
)
5691 || (b
->type
== bp_hardware_watchpoint
)
5692 || (b
->type
== bp_read_watchpoint
)
5693 || (b
->type
== bp_access_watchpoint
))
5694 && (b
->enable_state
== bp_call_disabled
))
5696 b
->enable_state
= bp_enabled
;
5697 update_global_location_list (1);
5703 disable_breakpoints_before_startup (void)
5705 struct breakpoint
*b
;
5710 if (b
->pspace
!= current_program_space
)
5713 if ((b
->type
== bp_breakpoint
5714 || b
->type
== bp_hardware_breakpoint
)
5715 && breakpoint_enabled (b
))
5717 b
->enable_state
= bp_startup_disabled
;
5723 update_global_location_list (0);
5725 current_program_space
->executing_startup
= 1;
5729 enable_breakpoints_after_startup (void)
5731 struct breakpoint
*b
;
5734 current_program_space
->executing_startup
= 0;
5738 if (b
->pspace
!= current_program_space
)
5741 if ((b
->type
== bp_breakpoint
5742 || b
->type
== bp_hardware_breakpoint
)
5743 && b
->enable_state
== bp_startup_disabled
)
5745 b
->enable_state
= bp_enabled
;
5751 breakpoint_re_set ();
5755 /* Set a breakpoint that will evaporate an end of command
5756 at address specified by SAL.
5757 Restrict it to frame FRAME if FRAME is nonzero. */
5760 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
5761 struct frame_id frame_id
, enum bptype type
)
5763 struct breakpoint
*b
;
5765 /* If FRAME_ID is valid, it should be a real frame, not an inlined
5767 gdb_assert (!frame_id_inlined_p (frame_id
));
5769 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
5770 b
->enable_state
= bp_enabled
;
5771 b
->disposition
= disp_donttouch
;
5772 b
->frame_id
= frame_id
;
5774 /* If we're debugging a multi-threaded program, then we
5775 want momentary breakpoints to be active in only a
5776 single thread of control. */
5777 if (in_thread_list (inferior_ptid
))
5778 b
->thread
= pid_to_thread_id (inferior_ptid
);
5780 update_global_location_list_nothrow (1);
5785 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
5789 clone_momentary_breakpoint (struct breakpoint
*orig
)
5791 struct breakpoint
*copy
;
5793 /* If there's nothing to clone, then return nothing. */
5797 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, orig
->type
);
5798 copy
->loc
= allocate_bp_location (copy
);
5799 set_breakpoint_location_function (copy
->loc
);
5801 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
5802 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
5803 copy
->loc
->address
= orig
->loc
->address
;
5804 copy
->loc
->section
= orig
->loc
->section
;
5805 copy
->loc
->pspace
= orig
->loc
->pspace
;
5807 if (orig
->source_file
== NULL
)
5808 copy
->source_file
= NULL
;
5810 copy
->source_file
= xstrdup (orig
->source_file
);
5812 copy
->line_number
= orig
->line_number
;
5813 copy
->frame_id
= orig
->frame_id
;
5814 copy
->thread
= orig
->thread
;
5815 copy
->pspace
= orig
->pspace
;
5817 copy
->enable_state
= bp_enabled
;
5818 copy
->disposition
= disp_donttouch
;
5819 copy
->number
= internal_breakpoint_number
--;
5821 update_global_location_list_nothrow (0);
5826 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
5829 struct symtab_and_line sal
;
5831 sal
= find_pc_line (pc
, 0);
5833 sal
.section
= find_pc_overlay (pc
);
5834 sal
.explicit_pc
= 1;
5836 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
5840 /* Tell the user we have just set a breakpoint B. */
5843 mention (struct breakpoint
*b
)
5846 struct cleanup
*ui_out_chain
;
5847 struct value_print_options opts
;
5849 get_user_print_options (&opts
);
5851 /* FIXME: This is misplaced; mention() is called by things (like
5852 hitting a watchpoint) other than breakpoint creation. It should
5853 be possible to clean this up and at the same time replace the
5854 random calls to breakpoint_changed with this hook. */
5855 observer_notify_breakpoint_created (b
->number
);
5857 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
5858 b
->ops
->print_mention (b
);
5863 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
5866 ui_out_text (uiout
, "Watchpoint ");
5867 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5868 ui_out_field_int (uiout
, "number", b
->number
);
5869 ui_out_text (uiout
, ": ");
5870 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5871 do_cleanups (ui_out_chain
);
5873 case bp_hardware_watchpoint
:
5874 ui_out_text (uiout
, "Hardware watchpoint ");
5875 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
5876 ui_out_field_int (uiout
, "number", b
->number
);
5877 ui_out_text (uiout
, ": ");
5878 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5879 do_cleanups (ui_out_chain
);
5881 case bp_read_watchpoint
:
5882 ui_out_text (uiout
, "Hardware read watchpoint ");
5883 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
5884 ui_out_field_int (uiout
, "number", b
->number
);
5885 ui_out_text (uiout
, ": ");
5886 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5887 do_cleanups (ui_out_chain
);
5889 case bp_access_watchpoint
:
5890 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
5891 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
5892 ui_out_field_int (uiout
, "number", b
->number
);
5893 ui_out_text (uiout
, ": ");
5894 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5895 do_cleanups (ui_out_chain
);
5898 if (ui_out_is_mi_like_p (uiout
))
5903 if (b
->disposition
== disp_del
)
5904 printf_filtered (_("Temporary breakpoint"));
5906 printf_filtered (_("Breakpoint"));
5907 printf_filtered (_(" %d"), b
->number
);
5910 case bp_hardware_breakpoint
:
5911 if (ui_out_is_mi_like_p (uiout
))
5916 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
5920 if (ui_out_is_mi_like_p (uiout
))
5925 printf_filtered (_("Tracepoint"));
5926 printf_filtered (_(" %d"), b
->number
);
5933 case bp_longjmp_resume
:
5934 case bp_step_resume
:
5936 case bp_watchpoint_scope
:
5937 case bp_shlib_event
:
5938 case bp_thread_event
:
5939 case bp_overlay_event
:
5941 case bp_longjmp_master
:
5947 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5951 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5955 if (opts
.addressprint
|| b
->source_file
== NULL
)
5957 printf_filtered (" at ");
5958 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
5962 printf_filtered (": file %s, line %d.",
5963 b
->source_file
, b
->line_number
);
5967 struct bp_location
*loc
= b
->loc
;
5969 for (; loc
; loc
= loc
->next
)
5971 printf_filtered (" (%d locations)", n
);
5976 if (ui_out_is_mi_like_p (uiout
))
5978 printf_filtered ("\n");
5982 static struct bp_location
*
5983 add_location_to_breakpoint (struct breakpoint
*b
,
5984 const struct symtab_and_line
*sal
)
5986 struct bp_location
*loc
, **tmp
;
5988 loc
= allocate_bp_location (b
);
5989 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5992 loc
->gdbarch
= get_sal_arch (*sal
);
5994 loc
->gdbarch
= b
->gdbarch
;
5995 loc
->requested_address
= sal
->pc
;
5996 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
5997 loc
->requested_address
, b
->type
);
5998 loc
->pspace
= sal
->pspace
;
5999 gdb_assert (loc
->pspace
!= NULL
);
6000 loc
->section
= sal
->section
;
6002 set_breakpoint_location_function (loc
);
6007 /* Return 1 if LOC is pointing to a permanent breakpoint,
6008 return 0 otherwise. */
6011 bp_loc_is_permanent (struct bp_location
*loc
)
6015 const gdb_byte
*brk
;
6016 gdb_byte
*target_mem
;
6017 struct cleanup
*cleanup
;
6020 gdb_assert (loc
!= NULL
);
6022 addr
= loc
->address
;
6023 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
6025 /* Software breakpoints unsupported? */
6029 target_mem
= alloca (len
);
6031 /* Enable the automatic memory restoration from breakpoints while
6032 we read the memory. Otherwise we could say about our temporary
6033 breakpoints they are permanent. */
6034 cleanup
= save_current_space_and_thread ();
6036 switch_to_program_space_and_thread (loc
->pspace
);
6037 make_show_memory_breakpoints_cleanup (0);
6039 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
6040 && memcmp (target_mem
, brk
, len
) == 0)
6043 do_cleanups (cleanup
);
6050 /* Create a breakpoint with SAL as location. Use ADDR_STRING
6051 as textual description of the location, and COND_STRING
6052 as condition expression. */
6055 create_breakpoint (struct gdbarch
*gdbarch
,
6056 struct symtabs_and_lines sals
, char *addr_string
,
6058 enum bptype type
, enum bpdisp disposition
,
6059 int thread
, int task
, int ignore_count
,
6060 struct breakpoint_ops
*ops
, int from_tty
, int enabled
)
6062 struct breakpoint
*b
= NULL
;
6065 if (type
== bp_hardware_breakpoint
)
6067 int i
= hw_breakpoint_used_count ();
6068 int target_resources_ok
=
6069 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
6071 if (target_resources_ok
== 0)
6072 error (_("No hardware breakpoint support in the target."));
6073 else if (target_resources_ok
< 0)
6074 error (_("Hardware breakpoints used exceeds limit."));
6077 gdb_assert (sals
.nelts
> 0);
6079 for (i
= 0; i
< sals
.nelts
; ++i
)
6081 struct symtab_and_line sal
= sals
.sals
[i
];
6082 struct bp_location
*loc
;
6086 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
6088 loc_gdbarch
= gdbarch
;
6090 describe_other_breakpoints (loc_gdbarch
,
6091 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
6096 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
6097 set_breakpoint_count (breakpoint_count
+ 1);
6098 b
->number
= breakpoint_count
;
6102 b
->cond_string
= cond_string
;
6103 b
->ignore_count
= ignore_count
;
6104 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
6105 b
->disposition
= disposition
;
6107 b
->pspace
= sals
.sals
[0].pspace
;
6109 if (enabled
&& b
->pspace
->executing_startup
6110 && (b
->type
== bp_breakpoint
6111 || b
->type
== bp_hardware_breakpoint
))
6112 b
->enable_state
= bp_startup_disabled
;
6118 loc
= add_location_to_breakpoint (b
, &sal
);
6121 if (bp_loc_is_permanent (loc
))
6122 make_breakpoint_permanent (b
);
6126 char *arg
= b
->cond_string
;
6127 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
6129 error (_("Garbage %s follows condition"), arg
);
6134 b
->addr_string
= addr_string
;
6136 /* addr_string has to be used or breakpoint_re_set will delete
6139 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
6145 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
6146 elements to fill the void space. */
6148 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
6150 int i
= index_to_remove
+1;
6151 int last_index
= sal
->nelts
-1;
6153 for (;i
<= last_index
; ++i
)
6154 sal
->sals
[i
-1] = sal
->sals
[i
];
6159 /* If appropriate, obtains all sals that correspond to the same file
6160 and line as SAL, in all program spaces. Users debugging with IDEs,
6161 will want to set a breakpoint at foo.c:line, and not really care
6162 about program spaces. This is done only if SAL does not have
6163 explicit PC and has line and file information. If we got just a
6164 single expanded sal, return the original.
6166 Otherwise, if SAL.explicit_line is not set, filter out all sals for
6167 which the name of enclosing function is different from SAL. This
6168 makes sure that if we have breakpoint originally set in template
6169 instantiation, say foo<int>(), we won't expand SAL to locations at
6170 the same line in all existing instantiations of 'foo'. */
6172 static struct symtabs_and_lines
6173 expand_line_sal_maybe (struct symtab_and_line sal
)
6175 struct symtabs_and_lines expanded
;
6176 CORE_ADDR original_pc
= sal
.pc
;
6177 char *original_function
= NULL
;
6180 struct cleanup
*old_chain
;
6182 /* If we have explicit pc, don't expand.
6183 If we have no line number, we can't expand. */
6184 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
6187 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6188 expanded
.sals
[0] = sal
;
6194 old_chain
= save_current_space_and_thread ();
6196 switch_to_program_space_and_thread (sal
.pspace
);
6198 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
6200 /* Note that expand_line_sal visits *all* program spaces. */
6201 expanded
= expand_line_sal (sal
);
6203 if (expanded
.nelts
== 1)
6205 /* We had one sal, we got one sal. Without futher
6206 processing, just return the original sal. */
6207 xfree (expanded
.sals
);
6209 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6210 sal
.pc
= original_pc
;
6211 expanded
.sals
[0] = sal
;
6212 do_cleanups (old_chain
);
6216 if (!sal
.explicit_line
)
6218 CORE_ADDR func_addr
, func_end
;
6219 for (i
= 0; i
< expanded
.nelts
; ++i
)
6221 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
6222 char *this_function
;
6224 /* We need to switch threads as well since we're about to
6226 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
6228 if (find_pc_partial_function (pc
, &this_function
,
6229 &func_addr
, &func_end
))
6232 && strcmp (this_function
, original_function
) != 0)
6234 remove_sal (&expanded
, i
);
6237 else if (func_addr
== pc
)
6239 /* We're at beginning of a function, and should
6241 struct symbol
*sym
= find_pc_function (pc
);
6243 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
6246 /* Since find_pc_partial_function returned true,
6247 we should really always find the section here. */
6248 struct obj_section
*section
= find_pc_section (pc
);
6251 struct gdbarch
*gdbarch
6252 = get_objfile_arch (section
->objfile
);
6254 = gdbarch_skip_prologue (gdbarch
, pc
);
6263 for (i
= 0; i
< expanded
.nelts
; ++i
)
6265 /* If this SAL corresponds to a breakpoint inserted using a
6266 line number, then skip the function prologue if necessary. */
6267 skip_prologue_sal (&expanded
.sals
[i
]);
6271 do_cleanups (old_chain
);
6273 if (expanded
.nelts
<= 1)
6275 /* This is un ugly workaround. If we get zero
6276 expanded sals then something is really wrong.
6277 Fix that by returnign the original sal. */
6278 xfree (expanded
.sals
);
6280 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6281 sal
.pc
= original_pc
;
6282 expanded
.sals
[0] = sal
;
6289 for (i
= 0; i
< expanded
.nelts
; ++i
)
6290 if (expanded
.sals
[i
].pc
== original_pc
)
6301 /* Add SALS.nelts breakpoints to the breakpoint table. For each
6302 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
6303 value. COND_STRING, if not NULL, specified the condition to be
6304 used for all breakpoints. Essentially the only case where
6305 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
6306 function. In that case, it's still not possible to specify
6307 separate conditions for different overloaded functions, so
6308 we take just a single condition string.
6310 NOTE: If the function succeeds, the caller is expected to cleanup
6311 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
6312 array contents). If the function fails (error() is called), the
6313 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
6314 COND and SALS arrays and each of those arrays contents. */
6317 create_breakpoints (struct gdbarch
*gdbarch
,
6318 struct symtabs_and_lines sals
, char **addr_string
,
6320 enum bptype type
, enum bpdisp disposition
,
6321 int thread
, int task
, int ignore_count
,
6322 struct breakpoint_ops
*ops
, int from_tty
,
6326 for (i
= 0; i
< sals
.nelts
; ++i
)
6328 struct symtabs_and_lines expanded
=
6329 expand_line_sal_maybe (sals
.sals
[i
]);
6331 create_breakpoint (gdbarch
, expanded
, addr_string
[i
],
6332 cond_string
, type
, disposition
,
6333 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
6337 /* Parse ARG which is assumed to be a SAL specification possibly
6338 followed by conditionals. On return, SALS contains an array of SAL
6339 addresses found. ADDR_STRING contains a vector of (canonical)
6340 address strings. ARG points to the end of the SAL. */
6343 parse_breakpoint_sals (char **address
,
6344 struct symtabs_and_lines
*sals
,
6345 char ***addr_string
,
6348 char *addr_start
= *address
;
6349 *addr_string
= NULL
;
6350 /* If no arg given, or if first arg is 'if ', use the default
6352 if ((*address
) == NULL
6353 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
6355 if (default_breakpoint_valid
)
6357 struct symtab_and_line sal
;
6358 init_sal (&sal
); /* initialize to zeroes */
6359 sals
->sals
= (struct symtab_and_line
*)
6360 xmalloc (sizeof (struct symtab_and_line
));
6361 sal
.pc
= default_breakpoint_address
;
6362 sal
.line
= default_breakpoint_line
;
6363 sal
.symtab
= default_breakpoint_symtab
;
6364 sal
.pspace
= default_breakpoint_pspace
;
6365 sal
.section
= find_pc_overlay (sal
.pc
);
6367 /* "break" without arguments is equivalent to "break *PC" where PC is
6368 the default_breakpoint_address. So make sure to set
6369 sal.explicit_pc to prevent GDB from trying to expand the list of
6370 sals to include all other instances with the same symtab and line.
6372 sal
.explicit_pc
= 1;
6374 sals
->sals
[0] = sal
;
6378 error (_("No default breakpoint address now."));
6382 /* Force almost all breakpoints to be in terms of the
6383 current_source_symtab (which is decode_line_1's default). This
6384 should produce the results we want almost all of the time while
6385 leaving default_breakpoint_* alone.
6386 ObjC: However, don't match an Objective-C method name which
6387 may have a '+' or '-' succeeded by a '[' */
6389 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
6391 if (default_breakpoint_valid
6393 || ((strchr ("+-", (*address
)[0]) != NULL
)
6394 && ((*address
)[1] != '['))))
6395 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
6396 default_breakpoint_line
, addr_string
,
6399 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
6400 addr_string
, not_found_ptr
);
6402 /* For any SAL that didn't have a canonical string, fill one in. */
6403 if (sals
->nelts
> 0 && *addr_string
== NULL
)
6404 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
6405 if (addr_start
!= (*address
))
6408 for (i
= 0; i
< sals
->nelts
; i
++)
6410 /* Add the string if not present. */
6411 if ((*addr_string
)[i
] == NULL
)
6412 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
6418 /* Convert each SAL into a real PC. Verify that the PC can be
6419 inserted as a breakpoint. If it can't throw an error. */
6422 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
6426 for (i
= 0; i
< sals
->nelts
; i
++)
6427 resolve_sal_pc (&sals
->sals
[i
]);
6431 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
6433 struct captured_parse_breakpoint_args
*args
= data
;
6435 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
6436 args
->not_found_ptr
);
6439 /* Given TOK, a string specification of condition and thread, as
6440 accepted by the 'break' command, extract the condition
6441 string and thread number and set *COND_STRING and *THREAD.
6442 PC identifies the context at which the condition should be parsed.
6443 If no condition is found, *COND_STRING is set to NULL.
6444 If no thread is found, *THREAD is set to -1. */
6446 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
6447 char **cond_string
, int *thread
, int *task
)
6449 *cond_string
= NULL
;
6455 char *cond_start
= NULL
;
6456 char *cond_end
= NULL
;
6457 while (*tok
== ' ' || *tok
== '\t')
6462 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
6465 toklen
= end_tok
- tok
;
6467 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
6469 struct expression
*expr
;
6471 tok
= cond_start
= end_tok
+ 1;
6472 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
6475 *cond_string
= savestring (cond_start
,
6476 cond_end
- cond_start
);
6478 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
6484 *thread
= strtol (tok
, &tok
, 0);
6486 error (_("Junk after thread keyword."));
6487 if (!valid_thread_id (*thread
))
6488 error (_("Unknown thread %d."), *thread
);
6490 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
6496 *task
= strtol (tok
, &tok
, 0);
6498 error (_("Junk after task keyword."));
6499 if (!valid_task_id (*task
))
6500 error (_("Unknown task %d\n"), *task
);
6503 error (_("Junk at end of arguments."));
6507 /* Set a breakpoint. This function is shared between
6508 CLI and MI functions for setting a breakpoint.
6509 This function has two major modes of operations,
6510 selected by the PARSE_CONDITION_AND_THREAD parameter.
6511 If non-zero, the function will parse arg, extracting
6512 breakpoint location, address and thread. Otherwise,
6513 ARG is just the location of breakpoint, with condition
6514 and thread specified by the COND_STRING and THREAD
6518 break_command_really (struct gdbarch
*gdbarch
,
6519 char *arg
, char *cond_string
, int thread
,
6520 int parse_condition_and_thread
,
6521 int tempflag
, int hardwareflag
, int traceflag
,
6523 enum auto_boolean pending_break_support
,
6524 struct breakpoint_ops
*ops
,
6528 struct gdb_exception e
;
6529 struct symtabs_and_lines sals
;
6530 struct symtab_and_line pending_sal
;
6533 char *addr_start
= arg
;
6535 struct cleanup
*old_chain
;
6536 struct cleanup
*bkpt_chain
= NULL
;
6537 struct captured_parse_breakpoint_args parse_args
;
6541 enum bptype type_wanted
;
6548 parse_args
.arg_p
= &arg
;
6549 parse_args
.sals_p
= &sals
;
6550 parse_args
.addr_string_p
= &addr_string
;
6551 parse_args
.not_found_ptr
= ¬_found
;
6553 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
6554 &parse_args
, RETURN_MASK_ALL
);
6556 /* If caller is interested in rc value from parse, set value. */
6560 throw_exception (e
);
6564 case NOT_FOUND_ERROR
:
6566 /* If pending breakpoint support is turned off, throw
6569 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
6570 throw_exception (e
);
6572 exception_print (gdb_stderr
, e
);
6574 /* If pending breakpoint support is auto query and the user
6575 selects no, then simply return the error code. */
6576 if (pending_break_support
== AUTO_BOOLEAN_AUTO
6577 && !nquery ("Make breakpoint pending on future shared library load? "))
6580 /* At this point, either the user was queried about setting
6581 a pending breakpoint and selected yes, or pending
6582 breakpoint behavior is on and thus a pending breakpoint
6583 is defaulted on behalf of the user. */
6584 copy_arg
= xstrdup (addr_start
);
6585 addr_string
= ©_arg
;
6587 sals
.sals
= &pending_sal
;
6592 throw_exception (e
);
6599 /* Create a chain of things that always need to be cleaned up. */
6600 old_chain
= make_cleanup (null_cleanup
, 0);
6604 /* Make sure that all storage allocated to SALS gets freed. */
6605 make_cleanup (xfree
, sals
.sals
);
6607 /* Cleanup the addr_string array but not its contents. */
6608 make_cleanup (xfree
, addr_string
);
6611 /* ----------------------------- SNIP -----------------------------
6612 Anything added to the cleanup chain beyond this point is assumed
6613 to be part of a breakpoint. If the breakpoint create succeeds
6614 then the memory is not reclaimed. */
6615 bkpt_chain
= make_cleanup (null_cleanup
, 0);
6617 /* Mark the contents of the addr_string for cleanup. These go on
6618 the bkpt_chain and only occur if the breakpoint create fails. */
6619 for (i
= 0; i
< sals
.nelts
; i
++)
6621 if (addr_string
[i
] != NULL
)
6622 make_cleanup (xfree
, addr_string
[i
]);
6625 /* Resolve all line numbers to PC's and verify that the addresses
6626 are ok for the target. */
6628 breakpoint_sals_to_pc (&sals
, addr_start
);
6630 type_wanted
= (traceflag
6632 : (hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
));
6634 /* Verify that condition can be parsed, before setting any
6635 breakpoints. Allocate a separate condition expression for each
6639 if (parse_condition_and_thread
)
6641 /* Here we only parse 'arg' to separate condition
6642 from thread number, so parsing in context of first
6643 sal is OK. When setting the breakpoint we'll
6644 re-parse it in context of each sal. */
6647 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
6650 make_cleanup (xfree
, cond_string
);
6654 /* Create a private copy of condition string. */
6657 cond_string
= xstrdup (cond_string
);
6658 make_cleanup (xfree
, cond_string
);
6661 create_breakpoints (gdbarch
, sals
, addr_string
, cond_string
, type_wanted
,
6662 tempflag
? disp_del
: disp_donttouch
,
6663 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
6667 struct symtab_and_line sal
= {0};
6668 struct breakpoint
*b
;
6670 make_cleanup (xfree
, copy_arg
);
6672 b
= set_raw_breakpoint_without_location (gdbarch
, type_wanted
);
6673 set_breakpoint_count (breakpoint_count
+ 1);
6674 b
->number
= breakpoint_count
;
6676 b
->addr_string
= addr_string
[0];
6677 b
->cond_string
= NULL
;
6678 b
->ignore_count
= ignore_count
;
6679 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6680 b
->condition_not_parsed
= 1;
6682 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
6683 b
->pspace
= current_program_space
;
6685 if (enabled
&& b
->pspace
->executing_startup
6686 && (b
->type
== bp_breakpoint
6687 || b
->type
== bp_hardware_breakpoint
))
6688 b
->enable_state
= bp_startup_disabled
;
6694 warning (_("Multiple breakpoints were set.\n"
6695 "Use the \"delete\" command to delete unwanted breakpoints."));
6696 /* That's it. Discard the cleanups for data inserted into the
6698 discard_cleanups (bkpt_chain
);
6699 /* But cleanup everything else. */
6700 do_cleanups (old_chain
);
6702 /* error call may happen here - have BKPT_CHAIN already discarded. */
6703 update_global_location_list (1);
6706 /* Set a breakpoint.
6707 ARG is a string describing breakpoint address,
6708 condition, and thread.
6709 FLAG specifies if a breakpoint is hardware on,
6710 and if breakpoint is temporary, using BP_HARDWARE_FLAG
6714 break_command_1 (char *arg
, int flag
, int from_tty
)
6716 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
6717 int tempflag
= flag
& BP_TEMPFLAG
;
6719 break_command_really (get_current_arch (),
6721 NULL
, 0, 1 /* parse arg */,
6722 tempflag
, hardwareflag
, 0 /* traceflag */,
6723 0 /* Ignore count */,
6724 pending_break_support
,
6725 NULL
/* breakpoint_ops */,
6732 set_breakpoint (struct gdbarch
*gdbarch
,
6733 char *address
, char *condition
,
6734 int hardwareflag
, int tempflag
,
6735 int thread
, int ignore_count
,
6736 int pending
, int enabled
)
6738 break_command_really (gdbarch
,
6739 address
, condition
, thread
,
6740 0 /* condition and thread are valid. */,
6741 tempflag
, hardwareflag
, 0 /* traceflag */,
6744 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
6748 /* Adjust SAL to the first instruction past the function prologue.
6749 The end of the prologue is determined using the line table from
6750 the debugging information. explicit_pc and explicit_line are
6753 If SAL is already past the prologue, then do nothing. */
6756 skip_prologue_sal (struct symtab_and_line
*sal
)
6759 struct symtab_and_line start_sal
;
6760 struct cleanup
*old_chain
;
6762 old_chain
= save_current_space_and_thread ();
6764 sym
= find_pc_function (sal
->pc
);
6767 start_sal
= find_function_start_sal (sym
, 1);
6768 if (sal
->pc
< start_sal
.pc
)
6770 start_sal
.explicit_line
= sal
->explicit_line
;
6771 start_sal
.explicit_pc
= sal
->explicit_pc
;
6776 do_cleanups (old_chain
);
6779 /* Helper function for break_command_1 and disassemble_command. */
6782 resolve_sal_pc (struct symtab_and_line
*sal
)
6786 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
6788 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
6789 error (_("No line %d in file \"%s\"."),
6790 sal
->line
, sal
->symtab
->filename
);
6793 /* If this SAL corresponds to a breakpoint inserted using
6794 a line number, then skip the function prologue if necessary. */
6795 if (sal
->explicit_line
)
6797 /* Preserve the original line number. */
6798 int saved_line
= sal
->line
;
6799 skip_prologue_sal (sal
);
6800 sal
->line
= saved_line
;
6804 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
6806 struct blockvector
*bv
;
6810 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
6813 sym
= block_linkage_function (b
);
6816 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
6817 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
6821 /* It really is worthwhile to have the section, so we'll just
6822 have to look harder. This case can be executed if we have
6823 line numbers but no functions (as can happen in assembly
6826 struct minimal_symbol
*msym
;
6827 struct cleanup
*old_chain
= save_current_space_and_thread ();
6829 switch_to_program_space_and_thread (sal
->pspace
);
6831 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
6833 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
6835 do_cleanups (old_chain
);
6842 break_command (char *arg
, int from_tty
)
6844 break_command_1 (arg
, 0, from_tty
);
6848 tbreak_command (char *arg
, int from_tty
)
6850 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
6854 hbreak_command (char *arg
, int from_tty
)
6856 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
6860 thbreak_command (char *arg
, int from_tty
)
6862 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
6866 stop_command (char *arg
, int from_tty
)
6868 printf_filtered (_("Specify the type of breakpoint to set.\n\
6869 Usage: stop in <function | address>\n\
6870 stop at <line>\n"));
6874 stopin_command (char *arg
, int from_tty
)
6878 if (arg
== (char *) NULL
)
6880 else if (*arg
!= '*')
6885 /* look for a ':'. If this is a line number specification, then
6886 say it is bad, otherwise, it should be an address or
6887 function/method name */
6888 while (*argptr
&& !hasColon
)
6890 hasColon
= (*argptr
== ':');
6895 badInput
= (*argptr
!= ':'); /* Not a class::method */
6897 badInput
= isdigit (*arg
); /* a simple line number */
6901 printf_filtered (_("Usage: stop in <function | address>\n"));
6903 break_command_1 (arg
, 0, from_tty
);
6907 stopat_command (char *arg
, int from_tty
)
6911 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
6918 /* look for a ':'. If there is a '::' then get out, otherwise
6919 it is probably a line number. */
6920 while (*argptr
&& !hasColon
)
6922 hasColon
= (*argptr
== ':');
6927 badInput
= (*argptr
== ':'); /* we have class::method */
6929 badInput
= !isdigit (*arg
); /* not a line number */
6933 printf_filtered (_("Usage: stop at <line>\n"));
6935 break_command_1 (arg
, 0, from_tty
);
6938 /* accessflag: hw_write: watch write,
6939 hw_read: watch read,
6940 hw_access: watch access (read or write) */
6942 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
6944 struct gdbarch
*gdbarch
= get_current_arch ();
6945 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
6946 struct symtab_and_line sal
;
6947 struct expression
*exp
;
6948 struct block
*exp_valid_block
;
6949 struct value
*val
, *mark
;
6950 struct frame_info
*frame
;
6951 char *exp_start
= NULL
;
6952 char *exp_end
= NULL
;
6953 char *tok
, *id_tok_start
, *end_tok
;
6955 char *cond_start
= NULL
;
6956 char *cond_end
= NULL
;
6957 struct expression
*cond
= NULL
;
6958 int i
, other_type_used
, target_resources_ok
= 0;
6959 enum bptype bp_type
;
6963 init_sal (&sal
); /* initialize to zeroes */
6965 /* Make sure that we actually have parameters to parse. */
6966 if (arg
!= NULL
&& arg
[0] != '\0')
6968 toklen
= strlen (arg
); /* Size of argument list. */
6970 /* Points tok to the end of the argument list. */
6971 tok
= arg
+ toklen
- 1;
6973 /* Go backwards in the parameters list. Skip the last parameter.
6974 If we're expecting a 'thread <thread_num>' parameter, this should
6975 be the thread identifier. */
6976 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6978 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6981 /* Points end_tok to the beginning of the last token. */
6982 id_tok_start
= tok
+ 1;
6984 /* Go backwards in the parameters list. Skip one more parameter.
6985 If we're expecting a 'thread <thread_num>' parameter, we should
6986 reach a "thread" token. */
6987 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6992 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6995 /* Move the pointer forward to skip the whitespace and
6996 calculate the length of the token. */
6998 toklen
= end_tok
- tok
;
7000 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7002 /* At this point we've found a "thread" token, which means
7003 the user is trying to set a watchpoint that triggers
7004 only in a specific thread. */
7007 /* Extract the thread ID from the next token. */
7008 thread
= strtol (id_tok_start
, &endp
, 0);
7010 /* Check if the user provided a valid numeric value for the
7012 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
7013 error (_("Invalid thread ID specification %s."), id_tok_start
);
7015 /* Check if the thread actually exists. */
7016 if (!valid_thread_id (thread
))
7017 error (_("Unknown thread %d."), thread
);
7019 /* Truncate the string and get rid of the thread <thread_num>
7020 parameter before the parameter list is parsed by the
7021 evaluate_expression() function. */
7026 sal
.pspace
= current_program_space
;
7028 /* Parse the rest of the arguments. */
7029 innermost_block
= NULL
;
7031 exp
= parse_exp_1 (&arg
, 0, 0);
7033 /* Remove trailing whitespace from the expression before saving it.
7034 This makes the eventual display of the expression string a bit
7036 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
7039 exp_valid_block
= innermost_block
;
7040 mark
= value_mark ();
7041 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
7043 release_value (val
);
7046 while (*tok
== ' ' || *tok
== '\t')
7050 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
7053 toklen
= end_tok
- tok
;
7054 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7056 tok
= cond_start
= end_tok
+ 1;
7057 cond
= parse_exp_1 (&tok
, 0, 0);
7061 error (_("Junk at end of command."));
7063 if (accessflag
== hw_read
)
7064 bp_type
= bp_read_watchpoint
;
7065 else if (accessflag
== hw_access
)
7066 bp_type
= bp_access_watchpoint
;
7068 bp_type
= bp_hardware_watchpoint
;
7070 mem_cnt
= can_use_hardware_watchpoint (val
);
7071 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
7072 error (_("Expression cannot be implemented with read/access watchpoint."));
7075 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
7076 target_resources_ok
=
7077 target_can_use_hardware_watchpoint (bp_type
, i
+ mem_cnt
,
7079 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
7080 error (_("Target does not support this type of hardware watchpoint."));
7082 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
7083 error (_("Target can only support one kind of HW watchpoint at a time."));
7086 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
7087 watchpoint could not be set. */
7088 if (!mem_cnt
|| target_resources_ok
<= 0)
7089 bp_type
= bp_watchpoint
;
7091 frame
= block_innermost_frame (exp_valid_block
);
7093 /* If the expression is "local", then set up a "watchpoint scope"
7094 breakpoint at the point where we've left the scope of the watchpoint
7095 expression. Create the scope breakpoint before the watchpoint, so
7096 that we will encounter it first in bpstat_stop_status. */
7097 if (innermost_block
&& frame
)
7099 if (frame_id_p (frame_unwind_caller_id (frame
)))
7102 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
7103 frame_unwind_caller_pc (frame
),
7104 bp_watchpoint_scope
);
7106 scope_breakpoint
->enable_state
= bp_enabled
;
7108 /* Automatically delete the breakpoint when it hits. */
7109 scope_breakpoint
->disposition
= disp_del
;
7111 /* Only break in the proper frame (help with recursion). */
7112 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
7114 /* Set the address at which we will stop. */
7115 scope_breakpoint
->loc
->gdbarch
7116 = frame_unwind_caller_arch (frame
);
7117 scope_breakpoint
->loc
->requested_address
7118 = frame_unwind_caller_pc (frame
);
7119 scope_breakpoint
->loc
->address
7120 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
7121 scope_breakpoint
->loc
->requested_address
,
7122 scope_breakpoint
->type
);
7126 /* Now set up the breakpoint. */
7127 b
= set_raw_breakpoint (gdbarch
, sal
, bp_type
);
7128 set_breakpoint_count (breakpoint_count
+ 1);
7129 b
->number
= breakpoint_count
;
7131 b
->disposition
= disp_donttouch
;
7133 b
->exp_valid_block
= exp_valid_block
;
7134 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
7137 b
->loc
->cond
= cond
;
7139 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
7144 b
->watchpoint_frame
= get_frame_id (frame
);
7146 b
->watchpoint_frame
= null_frame_id
;
7148 if (scope_breakpoint
!= NULL
)
7150 /* The scope breakpoint is related to the watchpoint. We will
7151 need to act on them together. */
7152 b
->related_breakpoint
= scope_breakpoint
;
7153 scope_breakpoint
->related_breakpoint
= b
;
7156 value_free_to_mark (mark
);
7158 update_global_location_list (1);
7161 /* Return count of locations need to be watched and can be handled
7162 in hardware. If the watchpoint can not be handled
7163 in hardware return zero. */
7166 can_use_hardware_watchpoint (struct value
*v
)
7168 int found_memory_cnt
= 0;
7169 struct value
*head
= v
;
7171 /* Did the user specifically forbid us to use hardware watchpoints? */
7172 if (!can_use_hw_watchpoints
)
7175 /* Make sure that the value of the expression depends only upon
7176 memory contents, and values computed from them within GDB. If we
7177 find any register references or function calls, we can't use a
7178 hardware watchpoint.
7180 The idea here is that evaluating an expression generates a series
7181 of values, one holding the value of every subexpression. (The
7182 expression a*b+c has five subexpressions: a, b, a*b, c, and
7183 a*b+c.) GDB's values hold almost enough information to establish
7184 the criteria given above --- they identify memory lvalues,
7185 register lvalues, computed values, etcetera. So we can evaluate
7186 the expression, and then scan the chain of values that leaves
7187 behind to decide whether we can detect any possible change to the
7188 expression's final value using only hardware watchpoints.
7190 However, I don't think that the values returned by inferior
7191 function calls are special in any way. So this function may not
7192 notice that an expression involving an inferior function call
7193 can't be watched with hardware watchpoints. FIXME. */
7194 for (; v
; v
= value_next (v
))
7196 if (VALUE_LVAL (v
) == lval_memory
)
7199 /* A lazy memory lvalue is one that GDB never needed to fetch;
7200 we either just used its address (e.g., `a' in `a.b') or
7201 we never needed it at all (e.g., `a' in `a,b'). */
7205 /* Ahh, memory we actually used! Check if we can cover
7206 it with hardware watchpoints. */
7207 struct type
*vtype
= check_typedef (value_type (v
));
7209 /* We only watch structs and arrays if user asked for it
7210 explicitly, never if they just happen to appear in a
7211 middle of some value chain. */
7213 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
7214 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
7216 CORE_ADDR vaddr
= value_address (v
);
7217 int len
= TYPE_LENGTH (value_type (v
));
7219 if (!target_region_ok_for_hw_watchpoint (vaddr
, len
))
7226 else if (VALUE_LVAL (v
) != not_lval
7227 && deprecated_value_modifiable (v
) == 0)
7228 return 0; /* ??? What does this represent? */
7229 else if (VALUE_LVAL (v
) == lval_register
)
7230 return 0; /* cannot watch a register with a HW watchpoint */
7233 /* The expression itself looks suitable for using a hardware
7234 watchpoint, but give the target machine a chance to reject it. */
7235 return found_memory_cnt
;
7239 watch_command_wrapper (char *arg
, int from_tty
)
7241 watch_command (arg
, from_tty
);
7245 watch_command (char *arg
, int from_tty
)
7247 watch_command_1 (arg
, hw_write
, from_tty
);
7251 rwatch_command_wrapper (char *arg
, int from_tty
)
7253 rwatch_command (arg
, from_tty
);
7257 rwatch_command (char *arg
, int from_tty
)
7259 watch_command_1 (arg
, hw_read
, from_tty
);
7263 awatch_command_wrapper (char *arg
, int from_tty
)
7265 awatch_command (arg
, from_tty
);
7269 awatch_command (char *arg
, int from_tty
)
7271 watch_command_1 (arg
, hw_access
, from_tty
);
7275 /* Helper routines for the until_command routine in infcmd.c. Here
7276 because it uses the mechanisms of breakpoints. */
7278 struct until_break_command_continuation_args
7280 struct breakpoint
*breakpoint
;
7281 struct breakpoint
*breakpoint2
;
7284 /* This function is called by fetch_inferior_event via the
7285 cmd_continuation pointer, to complete the until command. It takes
7286 care of cleaning up the temporary breakpoints set up by the until
7289 until_break_command_continuation (void *arg
)
7291 struct until_break_command_continuation_args
*a
= arg
;
7293 delete_breakpoint (a
->breakpoint
);
7295 delete_breakpoint (a
->breakpoint2
);
7299 until_break_command (char *arg
, int from_tty
, int anywhere
)
7301 struct symtabs_and_lines sals
;
7302 struct symtab_and_line sal
;
7303 struct frame_info
*frame
= get_selected_frame (NULL
);
7304 struct breakpoint
*breakpoint
;
7305 struct breakpoint
*breakpoint2
= NULL
;
7306 struct cleanup
*old_chain
;
7308 clear_proceed_status ();
7310 /* Set a breakpoint where the user wants it and at return from
7313 if (default_breakpoint_valid
)
7314 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
7315 default_breakpoint_line
, (char ***) NULL
, NULL
);
7317 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
7318 0, (char ***) NULL
, NULL
);
7320 if (sals
.nelts
!= 1)
7321 error (_("Couldn't get information on specified line."));
7324 xfree (sals
.sals
); /* malloc'd, so freed */
7327 error (_("Junk at end of arguments."));
7329 resolve_sal_pc (&sal
);
7332 /* If the user told us to continue until a specified location,
7333 we don't specify a frame at which we need to stop. */
7334 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
7335 null_frame_id
, bp_until
);
7337 /* Otherwise, specify the selected frame, because we want to stop only
7338 at the very same frame. */
7339 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
7340 get_stack_frame_id (frame
),
7343 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
7345 /* Keep within the current frame, or in frames called by the current
7348 if (frame_id_p (frame_unwind_caller_id (frame
)))
7350 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
7351 sal
.pc
= frame_unwind_caller_pc (frame
);
7352 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
7354 frame_unwind_caller_id (frame
),
7356 make_cleanup_delete_breakpoint (breakpoint2
);
7359 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
7361 /* If we are running asynchronously, and proceed call above has actually
7362 managed to start the target, arrange for breakpoints to be
7363 deleted when the target stops. Otherwise, we're already stopped and
7364 delete breakpoints via cleanup chain. */
7366 if (target_can_async_p () && is_running (inferior_ptid
))
7368 struct until_break_command_continuation_args
*args
;
7369 args
= xmalloc (sizeof (*args
));
7371 args
->breakpoint
= breakpoint
;
7372 args
->breakpoint2
= breakpoint2
;
7374 discard_cleanups (old_chain
);
7375 add_continuation (inferior_thread (),
7376 until_break_command_continuation
, args
,
7380 do_cleanups (old_chain
);
7384 ep_skip_leading_whitespace (char **s
)
7386 if ((s
== NULL
) || (*s
== NULL
))
7388 while (isspace (**s
))
7392 /* This function attempts to parse an optional "if <cond>" clause
7393 from the arg string. If one is not found, it returns NULL.
7395 Else, it returns a pointer to the condition string. (It does not
7396 attempt to evaluate the string against a particular block.) And,
7397 it updates arg to point to the first character following the parsed
7398 if clause in the arg string. */
7401 ep_parse_optional_if_clause (char **arg
)
7405 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
7408 /* Skip the "if" keyword. */
7411 /* Skip any extra leading whitespace, and record the start of the
7412 condition string. */
7413 ep_skip_leading_whitespace (arg
);
7416 /* Assume that the condition occupies the remainder of the arg string. */
7417 (*arg
) += strlen (cond_string
);
7422 /* This function attempts to parse an optional filename from the arg
7423 string. If one is not found, it returns NULL.
7425 Else, it returns a pointer to the parsed filename. (This function
7426 makes no attempt to verify that a file of that name exists, or is
7427 accessible.) And, it updates arg to point to the first character
7428 following the parsed filename in the arg string.
7430 Note that clients needing to preserve the returned filename for
7431 future access should copy it to their own buffers. */
7433 ep_parse_optional_filename (char **arg
)
7435 static char filename
[1024];
7440 if ((*arg_p
== '\0') || isspace (*arg_p
))
7458 /* Commands to deal with catching events, such as signals, exceptions,
7459 process start/exit, etc. */
7463 catch_fork_temporary
, catch_vfork_temporary
,
7464 catch_fork_permanent
, catch_vfork_permanent
7469 catch_fork_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7471 struct gdbarch
*gdbarch
= get_current_arch ();
7472 char *cond_string
= NULL
;
7473 catch_fork_kind fork_kind
;
7476 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
7477 tempflag
= (fork_kind
== catch_fork_temporary
7478 || fork_kind
== catch_vfork_temporary
);
7482 ep_skip_leading_whitespace (&arg
);
7484 /* The allowed syntax is:
7486 catch [v]fork if <cond>
7488 First, check if there's an if clause. */
7489 cond_string
= ep_parse_optional_if_clause (&arg
);
7491 if ((*arg
!= '\0') && !isspace (*arg
))
7492 error (_("Junk at end of arguments."));
7494 /* If this target supports it, create a fork or vfork catchpoint
7495 and enable reporting of such events. */
7498 case catch_fork_temporary
:
7499 case catch_fork_permanent
:
7500 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
7501 &catch_fork_breakpoint_ops
);
7503 case catch_vfork_temporary
:
7504 case catch_vfork_permanent
:
7505 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
7506 &catch_vfork_breakpoint_ops
);
7509 error (_("unsupported or unknown fork kind; cannot catch it"));
7515 catch_exec_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7517 struct gdbarch
*gdbarch
= get_current_arch ();
7519 char *cond_string
= NULL
;
7521 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7525 ep_skip_leading_whitespace (&arg
);
7527 /* The allowed syntax is:
7529 catch exec if <cond>
7531 First, check if there's an if clause. */
7532 cond_string
= ep_parse_optional_if_clause (&arg
);
7534 if ((*arg
!= '\0') && !isspace (*arg
))
7535 error (_("Junk at end of arguments."));
7537 /* If this target supports it, create an exec catchpoint
7538 and enable reporting of such events. */
7539 create_catchpoint (gdbarch
, tempflag
, cond_string
,
7540 &catch_exec_breakpoint_ops
);
7543 static enum print_stop_action
7544 print_exception_catchpoint (struct breakpoint
*b
)
7546 int bp_temp
, bp_throw
;
7548 annotate_catchpoint (b
->number
);
7550 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
7551 if (b
->loc
->address
!= b
->loc
->requested_address
)
7552 breakpoint_adjustment_warning (b
->loc
->requested_address
,
7555 bp_temp
= b
->disposition
== disp_del
;
7557 bp_temp
? "Temporary catchpoint "
7559 if (!ui_out_is_mi_like_p (uiout
))
7560 ui_out_field_int (uiout
, "bkptno", b
->number
);
7562 bp_throw
? " (exception thrown), "
7563 : " (exception caught), ");
7564 if (ui_out_is_mi_like_p (uiout
))
7566 ui_out_field_string (uiout
, "reason",
7567 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
7568 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
7569 ui_out_field_int (uiout
, "bkptno", b
->number
);
7571 return PRINT_SRC_AND_LOC
;
7575 print_one_exception_catchpoint (struct breakpoint
*b
, struct bp_location
**last_loc
)
7577 struct value_print_options opts
;
7578 get_user_print_options (&opts
);
7579 if (opts
.addressprint
)
7582 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
7583 ui_out_field_string (uiout
, "addr", "<PENDING>");
7585 ui_out_field_core_addr (uiout
, "addr",
7586 b
->loc
->gdbarch
, b
->loc
->address
);
7591 if (strstr (b
->addr_string
, "throw") != NULL
)
7592 ui_out_field_string (uiout
, "what", "exception throw");
7594 ui_out_field_string (uiout
, "what", "exception catch");
7598 print_mention_exception_catchpoint (struct breakpoint
*b
)
7603 bp_temp
= b
->disposition
== disp_del
;
7604 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
7605 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
7606 : _("Catchpoint "));
7607 ui_out_field_int (uiout
, "bkptno", b
->number
);
7608 ui_out_text (uiout
, bp_throw
? _(" (throw)")
7612 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
7615 NULL
, /* breakpoint_hit */
7616 print_exception_catchpoint
,
7617 print_one_exception_catchpoint
,
7618 print_mention_exception_catchpoint
7622 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
7623 enum exception_event_kind ex_event
, int from_tty
)
7625 char *trigger_func_name
;
7627 if (ex_event
== EX_EVENT_CATCH
)
7628 trigger_func_name
= "__cxa_begin_catch";
7630 trigger_func_name
= "__cxa_throw";
7632 break_command_really (get_current_arch (),
7633 trigger_func_name
, cond_string
, -1,
7634 0 /* condition and thread are valid. */,
7637 AUTO_BOOLEAN_TRUE
/* pending */,
7638 &gnu_v3_exception_catchpoint_ops
, from_tty
,
7644 /* Deal with "catch catch" and "catch throw" commands */
7647 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
7648 int tempflag
, int from_tty
)
7650 char *cond_string
= NULL
;
7651 struct symtab_and_line
*sal
= NULL
;
7655 ep_skip_leading_whitespace (&arg
);
7657 cond_string
= ep_parse_optional_if_clause (&arg
);
7659 if ((*arg
!= '\0') && !isspace (*arg
))
7660 error (_("Junk at end of arguments."));
7662 if (ex_event
!= EX_EVENT_THROW
7663 && ex_event
!= EX_EVENT_CATCH
)
7664 error (_("Unsupported or unknown exception event; cannot catch it"));
7666 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
7669 warning (_("Unsupported with this platform/compiler combination."));
7672 /* Implementation of "catch catch" command. */
7675 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7677 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7678 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
7681 /* Implementation of "catch throw" command. */
7684 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7686 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7687 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
7690 /* Create a breakpoint struct for Ada exception catchpoints. */
7693 create_ada_exception_breakpoint (struct gdbarch
*gdbarch
,
7694 struct symtab_and_line sal
,
7698 struct expression
*cond
,
7699 struct breakpoint_ops
*ops
,
7703 struct breakpoint
*b
;
7707 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
7709 loc_gdbarch
= gdbarch
;
7711 describe_other_breakpoints (loc_gdbarch
,
7712 sal
.pspace
, sal
.pc
, sal
.section
, -1);
7713 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
7714 version for exception catchpoints, because two catchpoints
7715 used for different exception names will use the same address.
7716 In this case, a "breakpoint ... also set at..." warning is
7717 unproductive. Besides. the warning phrasing is also a bit
7718 inapropriate, we should use the word catchpoint, and tell
7719 the user what type of catchpoint it is. The above is good
7720 enough for now, though. */
7723 b
= set_raw_breakpoint (gdbarch
, sal
, bp_breakpoint
);
7724 set_breakpoint_count (breakpoint_count
+ 1);
7726 b
->enable_state
= bp_enabled
;
7727 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
7728 b
->number
= breakpoint_count
;
7729 b
->ignore_count
= 0;
7730 b
->loc
->cond
= cond
;
7731 b
->addr_string
= addr_string
;
7732 b
->language
= language_ada
;
7733 b
->cond_string
= cond_string
;
7734 b
->exp_string
= exp_string
;
7739 update_global_location_list (1);
7742 /* Implement the "catch exception" command. */
7745 catch_ada_exception_command (char *arg
, int from_tty
,
7746 struct cmd_list_element
*command
)
7748 struct gdbarch
*gdbarch
= get_current_arch ();
7750 struct symtab_and_line sal
;
7752 char *addr_string
= NULL
;
7753 char *exp_string
= NULL
;
7754 char *cond_string
= NULL
;
7755 struct expression
*cond
= NULL
;
7756 struct breakpoint_ops
*ops
= NULL
;
7758 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7762 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
7763 &cond_string
, &cond
, &ops
);
7764 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, exp_string
,
7765 cond_string
, cond
, ops
, tempflag
,
7769 /* Cleanup function for a syscall filter list. */
7771 clean_up_filters (void *arg
)
7773 VEC(int) *iter
= *(VEC(int) **) arg
;
7774 VEC_free (int, iter
);
7777 /* Splits the argument using space as delimiter. Returns an xmalloc'd
7778 filter list, or NULL if no filtering is required. */
7780 catch_syscall_split_args (char *arg
)
7782 VEC(int) *result
= NULL
;
7783 struct cleanup
*cleanup
= make_cleanup (clean_up_filters
, &result
);
7785 while (*arg
!= '\0')
7787 int i
, syscall_number
;
7792 /* Skip whitespace. */
7793 while (isspace (*arg
))
7796 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
7797 cur_name
[i
] = arg
[i
];
7801 /* Check if the user provided a syscall name or a number. */
7802 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
7803 if (*endptr
== '\0')
7804 get_syscall_by_number (syscall_number
, &s
);
7807 /* We have a name. Let's check if it's valid and convert it
7809 get_syscall_by_name (cur_name
, &s
);
7811 if (s
.number
== UNKNOWN_SYSCALL
)
7812 /* Here we have to issue an error instead of a warning, because
7813 GDB cannot do anything useful if there's no syscall number to
7815 error (_("Unknown syscall name '%s'."), cur_name
);
7818 /* Ok, it's valid. */
7819 VEC_safe_push (int, result
, s
.number
);
7822 discard_cleanups (cleanup
);
7826 /* Implement the "catch syscall" command. */
7829 catch_syscall_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7834 struct gdbarch
*gdbarch
= get_current_arch ();
7836 /* Checking if the feature if supported. */
7837 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
7838 error (_("The feature 'catch syscall' is not supported on \
7839 this architeture yet."));
7841 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7843 ep_skip_leading_whitespace (&arg
);
7845 /* We need to do this first "dummy" translation in order
7846 to get the syscall XML file loaded or, most important,
7847 to display a warning to the user if there's no XML file
7848 for his/her architecture. */
7849 get_syscall_by_number (0, &s
);
7851 /* The allowed syntax is:
7853 catch syscall <name | number> [<name | number> ... <name | number>]
7855 Let's check if there's a syscall name. */
7858 filter
= catch_syscall_split_args (arg
);
7862 create_syscall_event_catchpoint (tempflag
, filter
,
7863 &catch_syscall_breakpoint_ops
);
7866 /* Implement the "catch assert" command. */
7869 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7871 struct gdbarch
*gdbarch
= get_current_arch ();
7873 struct symtab_and_line sal
;
7874 char *addr_string
= NULL
;
7875 struct breakpoint_ops
*ops
= NULL
;
7877 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7881 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
7882 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, NULL
, NULL
, NULL
,
7883 ops
, tempflag
, from_tty
);
7887 catch_command (char *arg
, int from_tty
)
7889 error (_("Catch requires an event name."));
7894 tcatch_command (char *arg
, int from_tty
)
7896 error (_("Catch requires an event name."));
7899 /* Delete breakpoints by address or line. */
7902 clear_command (char *arg
, int from_tty
)
7904 struct breakpoint
*b
;
7905 VEC(breakpoint_p
) *found
= 0;
7908 struct symtabs_and_lines sals
;
7909 struct symtab_and_line sal
;
7914 sals
= decode_line_spec (arg
, 1);
7919 sals
.sals
= (struct symtab_and_line
*)
7920 xmalloc (sizeof (struct symtab_and_line
));
7921 make_cleanup (xfree
, sals
.sals
);
7922 init_sal (&sal
); /* initialize to zeroes */
7923 sal
.line
= default_breakpoint_line
;
7924 sal
.symtab
= default_breakpoint_symtab
;
7925 sal
.pc
= default_breakpoint_address
;
7926 sal
.pspace
= default_breakpoint_pspace
;
7927 if (sal
.symtab
== 0)
7928 error (_("No source file specified."));
7936 /* We don't call resolve_sal_pc here. That's not
7937 as bad as it seems, because all existing breakpoints
7938 typically have both file/line and pc set. So, if
7939 clear is given file/line, we can match this to existing
7940 breakpoint without obtaining pc at all.
7942 We only support clearing given the address explicitly
7943 present in breakpoint table. Say, we've set breakpoint
7944 at file:line. There were several PC values for that file:line,
7945 due to optimization, all in one block.
7946 We've picked one PC value. If "clear" is issued with another
7947 PC corresponding to the same file:line, the breakpoint won't
7948 be cleared. We probably can still clear the breakpoint, but
7949 since the other PC value is never presented to user, user
7950 can only find it by guessing, and it does not seem important
7953 /* For each line spec given, delete bps which correspond
7954 to it. Do it in two passes, solely to preserve the current
7955 behavior that from_tty is forced true if we delete more than
7959 for (i
= 0; i
< sals
.nelts
; i
++)
7961 /* If exact pc given, clear bpts at that pc.
7962 If line given (pc == 0), clear all bpts on specified line.
7963 If defaulting, clear all bpts on default line
7966 defaulting sal.pc != 0 tests to do
7971 1 0 <can't happen> */
7975 /* Find all matching breakpoints and add them to
7980 /* Are we going to delete b? */
7981 if (b
->type
!= bp_none
7982 && b
->type
!= bp_watchpoint
7983 && b
->type
!= bp_hardware_watchpoint
7984 && b
->type
!= bp_read_watchpoint
7985 && b
->type
!= bp_access_watchpoint
)
7987 struct bp_location
*loc
= b
->loc
;
7988 for (; loc
; loc
= loc
->next
)
7990 int pc_match
= sal
.pc
7991 && (loc
->pspace
== sal
.pspace
)
7992 && (loc
->address
== sal
.pc
)
7993 && (!section_is_overlay (loc
->section
)
7994 || loc
->section
== sal
.section
);
7995 int line_match
= ((default_match
|| (0 == sal
.pc
))
7996 && b
->source_file
!= NULL
7997 && sal
.symtab
!= NULL
7998 && sal
.pspace
== loc
->pspace
7999 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
8000 && b
->line_number
== sal
.line
);
8001 if (pc_match
|| line_match
)
8010 VEC_safe_push(breakpoint_p
, found
, b
);
8013 /* Now go thru the 'found' chain and delete them. */
8014 if (VEC_empty(breakpoint_p
, found
))
8017 error (_("No breakpoint at %s."), arg
);
8019 error (_("No breakpoint at this line."));
8022 if (VEC_length(breakpoint_p
, found
) > 1)
8023 from_tty
= 1; /* Always report if deleted more than one */
8026 if (VEC_length(breakpoint_p
, found
) == 1)
8027 printf_unfiltered (_("Deleted breakpoint "));
8029 printf_unfiltered (_("Deleted breakpoints "));
8031 breakpoints_changed ();
8033 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
8036 printf_unfiltered ("%d ", b
->number
);
8037 delete_breakpoint (b
);
8040 putchar_unfiltered ('\n');
8043 /* Delete breakpoint in BS if they are `delete' breakpoints and
8044 all breakpoints that are marked for deletion, whether hit or not.
8045 This is called after any breakpoint is hit, or after errors. */
8048 breakpoint_auto_delete (bpstat bs
)
8050 struct breakpoint
*b
, *temp
;
8052 for (; bs
; bs
= bs
->next
)
8053 if (bs
->breakpoint_at
8054 && bs
->breakpoint_at
->owner
8055 && bs
->breakpoint_at
->owner
->disposition
== disp_del
8057 delete_breakpoint (bs
->breakpoint_at
->owner
);
8059 ALL_BREAKPOINTS_SAFE (b
, temp
)
8061 if (b
->disposition
== disp_del_at_next_stop
)
8062 delete_breakpoint (b
);
8066 /* A comparison function for bp_location A and B being interfaced to qsort.
8067 Sort elements primarily by their ADDRESS (no matter what does
8068 breakpoint_address_is_meaningful say for its OWNER), secondarily by ordering
8069 first bp_permanent OWNERed elements and terciarily just ensuring the array
8070 is sorted stable way despite qsort being an instable algorithm. */
8073 bp_location_compare (struct bp_location
*a
, struct bp_location
*b
)
8075 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
8076 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
8078 if (a
->address
!= b
->address
)
8079 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
8081 /* Sort permanent breakpoints first. */
8082 if (a_perm
!= b_perm
)
8083 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
8085 /* Make the user-visible order stable across GDB runs. Locations of the same
8086 breakpoint can be sorted in arbitrary order. */
8088 if (a
->owner
->number
!= b
->owner
->number
)
8089 return (a
->owner
->number
> b
->owner
->number
)
8090 - (a
->owner
->number
< b
->owner
->number
);
8092 return (a
> b
) - (a
< b
);
8095 /* Interface bp_location_compare as the COMPAR parameter of qsort function. */
8098 bp_location_compare_for_qsort (const void *ap
, const void *bp
)
8100 struct bp_location
*a
= *(void **) ap
;
8101 struct bp_location
*b
= *(void **) bp
;
8103 return bp_location_compare (a
, b
);
8106 /* Set bp_location_placed_address_before_address_max and
8107 bp_location_shadow_len_after_address_max according to the current content of
8108 the bp_location array. */
8111 bp_location_target_extensions_update (void)
8113 struct bp_location
*bl
, **blp_tmp
;
8115 bp_location_placed_address_before_address_max
= 0;
8116 bp_location_shadow_len_after_address_max
= 0;
8118 ALL_BP_LOCATIONS (bl
, blp_tmp
)
8120 CORE_ADDR start
, end
, addr
;
8122 if (!bp_location_has_shadow (bl
))
8125 start
= bl
->target_info
.placed_address
;
8126 end
= start
+ bl
->target_info
.shadow_len
;
8128 gdb_assert (bl
->address
>= start
);
8129 addr
= bl
->address
- start
;
8130 if (addr
> bp_location_placed_address_before_address_max
)
8131 bp_location_placed_address_before_address_max
= addr
;
8133 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
8135 gdb_assert (bl
->address
< end
);
8136 addr
= end
- bl
->address
;
8137 if (addr
> bp_location_shadow_len_after_address_max
)
8138 bp_location_shadow_len_after_address_max
= addr
;
8142 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
8143 into the inferior, only remove already-inserted locations that no
8144 longer should be inserted. Functions that delete a breakpoint or
8145 breakpoints should pass false, so that deleting a breakpoint
8146 doesn't have the side effect of inserting the locations of other
8147 breakpoints that are marked not-inserted, but should_be_inserted
8148 returns true on them.
8150 This behaviour is useful is situations close to tear-down -- e.g.,
8151 after an exec, while the target still has execution, but breakpoint
8152 shadows of the previous executable image should *NOT* be restored
8153 to the new image; or before detaching, where the target still has
8154 execution and wants to delete breakpoints from GDB's lists, and all
8155 breakpoints had already been removed from the inferior. */
8158 update_global_location_list (int should_insert
)
8160 struct breakpoint
*b
;
8161 struct bp_location
**locp
, *loc
;
8162 struct cleanup
*cleanups
;
8164 /* The first bp_location being the only one non-DUPLICATE for the current run
8165 of the same ADDRESS. */
8166 struct bp_location
*loc_first
;
8168 /* Saved former bp_location array which we compare against the newly built
8169 bp_location from the current state of ALL_BREAKPOINTS. */
8170 struct bp_location
**old_location
, **old_locp
;
8171 unsigned old_location_count
;
8173 old_location
= bp_location
;
8174 old_location_count
= bp_location_count
;
8176 bp_location_count
= 0;
8177 cleanups
= make_cleanup (xfree
, old_location
);
8180 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
8181 bp_location_count
++;
8183 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
8186 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
8188 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
8189 bp_location_compare_for_qsort
);
8191 bp_location_target_extensions_update ();
8193 /* Identify bp_location instances that are no longer present in the new
8194 list, and therefore should be freed. Note that it's not necessary that
8195 those locations should be removed from inferior -- if there's another
8196 location at the same address (previously marked as duplicate),
8197 we don't need to remove/insert the location.
8199 LOCP is kept in sync with OLD_LOCP, each pointing to the current and
8200 former bp_location array state respectively. */
8203 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
8206 struct bp_location
*old_loc
= *old_locp
;
8208 /* Tells if 'old_loc' is found amoung the new locations. If not, we
8211 /* Tells if the location should remain inserted in the target. */
8212 int keep_in_target
= 0;
8215 /* Skip LOCP entries which will definitely never be needed. Stop either
8216 at or being the one matching OLD_LOC. */
8217 while (locp
< bp_location
+ bp_location_count
8218 && bp_location_compare (*locp
, old_loc
) < 0)
8220 found_object
= locp
< bp_location
+ bp_location_count
&& *locp
== old_loc
;
8222 /* If this location is no longer present, and inserted, look if there's
8223 maybe a new location at the same address. If so, mark that one
8224 inserted, and don't remove this one. This is needed so that we
8225 don't have a time window where a breakpoint at certain location is not
8228 if (old_loc
->inserted
)
8230 /* If the location is inserted now, we might have to remove it. */
8232 if (found_object
&& should_be_inserted (old_loc
))
8234 /* The location is still present in the location list, and still
8235 should be inserted. Don't do anything. */
8240 /* The location is either no longer present, or got disabled.
8241 See if there's another location at the same address, in which
8242 case we don't need to remove this one from the target. */
8244 if (breakpoint_address_is_meaningful (old_loc
->owner
))
8246 struct bp_location
**loc2p
;
8249 loc2p
< bp_location
+ bp_location_count
8250 && breakpoint_address_match ((*loc2p
)->pspace
->aspace
,
8252 old_loc
->pspace
->aspace
,
8256 struct bp_location
*loc2
= *loc2p
;
8258 /* For the sake of should_be_inserted.
8259 Duplicates check below will fix up this later. */
8260 loc2
->duplicate
= 0;
8261 if (loc2
!= old_loc
&& should_be_inserted (loc2
))
8264 loc2
->target_info
= old_loc
->target_info
;
8272 if (!keep_in_target
)
8274 if (remove_breakpoint (old_loc
, mark_uninserted
))
8276 /* This is just about all we can do. We could keep this
8277 location on the global list, and try to remove it next
8278 time, but there's no particular reason why we will
8281 Note that at this point, old_loc->owner is still valid,
8282 as delete_breakpoint frees the breakpoint only
8283 after calling us. */
8284 printf_filtered (_("warning: Error removing breakpoint %d\n"),
8285 old_loc
->owner
->number
);
8293 if (removed
&& non_stop
)
8295 /* This location was removed from the targets. In non-stop mode,
8296 a race condition is possible where we've removed a breakpoint,
8297 but stop events for that breakpoint are already queued and will
8298 arrive later. To suppress spurious SIGTRAPs reported to user,
8299 we keep this breakpoint location for a bit, and will retire it
8300 after we see 3 * thread_count events.
8301 The theory here is that reporting of events should,
8302 "on the average", be fair, so after that many event we'll see
8303 events from all threads that have anything of interest, and no
8304 longer need to keep this breakpoint. This is just a
8305 heuristic, but if it's wrong, we'll report unexpected SIGTRAP,
8306 which is usability issue, but not a correctness problem. */
8307 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
8308 old_loc
->owner
= NULL
;
8310 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
8313 free_bp_location (old_loc
);
8317 /* Rescan breakpoints at the same address and section,
8318 marking the first one as "first" and any others as "duplicates".
8319 This is so that the bpt instruction is only inserted once.
8320 If we have a permanent breakpoint at the same place as BPT, make
8321 that one the official one, and the rest as duplicates. Permanent
8322 breakpoints are sorted first for the same address. */
8325 ALL_BP_LOCATIONS (loc
, locp
)
8327 struct breakpoint
*b
= loc
->owner
;
8329 if (b
->enable_state
== bp_disabled
8330 || b
->enable_state
== bp_call_disabled
8331 || b
->enable_state
== bp_startup_disabled
8333 || loc
->shlib_disabled
8334 || !breakpoint_address_is_meaningful (b
))
8337 /* Permanent breakpoint should always be inserted. */
8338 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
8339 internal_error (__FILE__
, __LINE__
,
8340 _("allegedly permanent breakpoint is not "
8341 "actually inserted"));
8343 if (loc_first
== NULL
8344 || (overlay_debugging
&& loc
->section
!= loc_first
->section
)
8345 || !breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
8346 loc_first
->pspace
->aspace
,
8347 loc_first
->address
))
8356 if (loc_first
->owner
->enable_state
== bp_permanent
&& loc
->inserted
8357 && b
->enable_state
!= bp_permanent
)
8358 internal_error (__FILE__
, __LINE__
,
8359 _("another breakpoint was inserted on top of "
8360 "a permanent breakpoint"));
8363 if (breakpoints_always_inserted_mode () && should_insert
8364 && (have_live_inferiors ()
8365 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
8366 insert_breakpoint_locations ();
8368 do_cleanups (cleanups
);
8372 breakpoint_retire_moribund (void)
8374 struct bp_location
*loc
;
8377 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
8378 if (--(loc
->events_till_retirement
) == 0)
8380 free_bp_location (loc
);
8381 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
8387 update_global_location_list_nothrow (int inserting
)
8389 struct gdb_exception e
;
8390 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8391 update_global_location_list (inserting
);
8394 /* Clear BPT from a BPS. */
8396 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
8399 for (bs
= bps
; bs
; bs
= bs
->next
)
8400 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
8402 bs
->breakpoint_at
= NULL
;
8404 /* bs->commands will be freed later. */
8408 /* Callback for iterate_over_threads. */
8410 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
8412 struct breakpoint
*bpt
= data
;
8413 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
8417 /* Delete a breakpoint and clean up all traces of it in the data
8421 delete_breakpoint (struct breakpoint
*bpt
)
8423 struct breakpoint
*b
;
8424 struct bp_location
*loc
, *next
;
8426 gdb_assert (bpt
!= NULL
);
8428 /* Has this bp already been deleted? This can happen because multiple
8429 lists can hold pointers to bp's. bpstat lists are especial culprits.
8431 One example of this happening is a watchpoint's scope bp. When the
8432 scope bp triggers, we notice that the watchpoint is out of scope, and
8433 delete it. We also delete its scope bp. But the scope bp is marked
8434 "auto-deleting", and is already on a bpstat. That bpstat is then
8435 checked for auto-deleting bp's, which are deleted.
8437 A real solution to this problem might involve reference counts in bp's,
8438 and/or giving them pointers back to their referencing bpstat's, and
8439 teaching delete_breakpoint to only free a bp's storage when no more
8440 references were extent. A cheaper bandaid was chosen. */
8441 if (bpt
->type
== bp_none
)
8444 observer_notify_breakpoint_deleted (bpt
->number
);
8446 if (breakpoint_chain
== bpt
)
8447 breakpoint_chain
= bpt
->next
;
8452 b
->next
= bpt
->next
;
8456 free_command_lines (&bpt
->commands
);
8457 if (bpt
->cond_string
!= NULL
)
8458 xfree (bpt
->cond_string
);
8459 if (bpt
->addr_string
!= NULL
)
8460 xfree (bpt
->addr_string
);
8461 if (bpt
->exp
!= NULL
)
8463 if (bpt
->exp_string
!= NULL
)
8464 xfree (bpt
->exp_string
);
8465 if (bpt
->val
!= NULL
)
8466 value_free (bpt
->val
);
8467 if (bpt
->source_file
!= NULL
)
8468 xfree (bpt
->source_file
);
8469 if (bpt
->exec_pathname
!= NULL
)
8470 xfree (bpt
->exec_pathname
);
8471 clean_up_filters (&bpt
->syscalls_to_be_caught
);
8473 /* Be sure no bpstat's are pointing at it after it's been freed. */
8474 /* FIXME, how can we find all bpstat's?
8475 We just check stop_bpstat for now. Note that we cannot just
8476 remove bpstats pointing at bpt from the stop_bpstat list
8477 entirely, as breakpoint commands are associated with the bpstat;
8478 if we remove it here, then the later call to
8479 bpstat_do_actions (&stop_bpstat);
8480 in event-top.c won't do anything, and temporary breakpoints
8481 with commands won't work. */
8483 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
8485 /* Now that breakpoint is removed from breakpoint
8486 list, update the global location list. This
8487 will remove locations that used to belong to
8488 this breakpoint. Do this before freeing
8489 the breakpoint itself, since remove_breakpoint
8490 looks at location's owner. It might be better
8491 design to have location completely self-contained,
8492 but it's not the case now. */
8493 update_global_location_list (0);
8496 /* On the chance that someone will soon try again to delete this same
8497 bp, we mark it as deleted before freeing its storage. */
8498 bpt
->type
= bp_none
;
8504 do_delete_breakpoint_cleanup (void *b
)
8506 delete_breakpoint (b
);
8510 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
8512 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
8516 delete_command (char *arg
, int from_tty
)
8518 struct breakpoint
*b
, *temp
;
8524 int breaks_to_delete
= 0;
8526 /* Delete all breakpoints if no argument.
8527 Do not delete internal or call-dummy breakpoints, these
8528 have to be deleted with an explicit breakpoint number argument. */
8531 if (b
->type
!= bp_call_dummy
8532 && b
->type
!= bp_shlib_event
8533 && b
->type
!= bp_jit_event
8534 && b
->type
!= bp_thread_event
8535 && b
->type
!= bp_overlay_event
8536 && b
->type
!= bp_longjmp_master
8539 breaks_to_delete
= 1;
8544 /* Ask user only if there are some breakpoints to delete. */
8546 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
8548 ALL_BREAKPOINTS_SAFE (b
, temp
)
8550 if (b
->type
!= bp_call_dummy
8551 && b
->type
!= bp_shlib_event
8552 && b
->type
!= bp_thread_event
8553 && b
->type
!= bp_jit_event
8554 && b
->type
!= bp_overlay_event
8555 && b
->type
!= bp_longjmp_master
8557 delete_breakpoint (b
);
8562 map_breakpoint_numbers (arg
, delete_breakpoint
);
8566 all_locations_are_pending (struct bp_location
*loc
)
8568 for (; loc
; loc
= loc
->next
)
8569 if (!loc
->shlib_disabled
)
8574 /* Subroutine of update_breakpoint_locations to simplify it.
8575 Return non-zero if multiple fns in list LOC have the same name.
8576 Null names are ignored. */
8579 ambiguous_names_p (struct bp_location
*loc
)
8581 struct bp_location
*l
;
8582 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
8583 (int (*) (const void *, const void *)) streq
,
8584 NULL
, xcalloc
, xfree
);
8586 for (l
= loc
; l
!= NULL
; l
= l
->next
)
8589 const char *name
= l
->function_name
;
8591 /* Allow for some names to be NULL, ignore them. */
8595 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
8597 /* NOTE: We can assume slot != NULL here because xcalloc never returns
8612 update_breakpoint_locations (struct breakpoint
*b
,
8613 struct symtabs_and_lines sals
)
8617 struct bp_location
*existing_locations
= b
->loc
;
8619 /* If there's no new locations, and all existing locations
8620 are pending, don't do anything. This optimizes
8621 the common case where all locations are in the same
8622 shared library, that was unloaded. We'd like to
8623 retain the location, so that when the library
8624 is loaded again, we don't loose the enabled/disabled
8625 status of the individual locations. */
8626 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
8631 for (i
= 0; i
< sals
.nelts
; ++i
)
8633 struct bp_location
*new_loc
=
8634 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
8636 /* Reparse conditions, they might contain references to the
8638 if (b
->cond_string
!= NULL
)
8640 struct gdb_exception e
;
8643 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8645 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
8650 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
8651 b
->number
, e
.message
);
8652 new_loc
->enabled
= 0;
8656 if (b
->source_file
!= NULL
)
8657 xfree (b
->source_file
);
8658 if (sals
.sals
[i
].symtab
== NULL
)
8659 b
->source_file
= NULL
;
8661 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
8663 if (b
->line_number
== 0)
8664 b
->line_number
= sals
.sals
[i
].line
;
8667 /* Update locations of permanent breakpoints. */
8668 if (b
->enable_state
== bp_permanent
)
8669 make_breakpoint_permanent (b
);
8671 /* If possible, carry over 'disable' status from existing breakpoints. */
8673 struct bp_location
*e
= existing_locations
;
8674 /* If there are multiple breakpoints with the same function name,
8675 e.g. for inline functions, comparing function names won't work.
8676 Instead compare pc addresses; this is just a heuristic as things
8677 may have moved, but in practice it gives the correct answer
8678 often enough until a better solution is found. */
8679 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
8681 for (; e
; e
= e
->next
)
8683 if (!e
->enabled
&& e
->function_name
)
8685 struct bp_location
*l
= b
->loc
;
8686 if (have_ambiguous_names
)
8688 for (; l
; l
= l
->next
)
8689 if (breakpoint_address_match (e
->pspace
->aspace
, e
->address
,
8690 l
->pspace
->aspace
, l
->address
))
8698 for (; l
; l
= l
->next
)
8699 if (l
->function_name
8700 && strcmp (e
->function_name
, l
->function_name
) == 0)
8710 update_global_location_list (1);
8714 /* Reset a breakpoint given it's struct breakpoint * BINT.
8715 The value we return ends up being the return value from catch_errors.
8716 Unused in this case. */
8719 breakpoint_re_set_one (void *bint
)
8721 /* get past catch_errs */
8722 struct breakpoint
*b
= (struct breakpoint
*) bint
;
8726 int *not_found_ptr
= ¬_found
;
8727 struct symtabs_and_lines sals
= {0};
8728 struct symtabs_and_lines expanded
= {0};
8730 enum enable_state save_enable
;
8731 struct gdb_exception e
;
8732 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
8737 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
8741 case bp_hardware_breakpoint
:
8743 /* Do not attempt to re-set breakpoints disabled during startup. */
8744 if (b
->enable_state
== bp_startup_disabled
)
8747 if (b
->addr_string
== NULL
)
8749 /* Anything without a string can't be re-set. */
8750 delete_breakpoint (b
);
8754 set_language (b
->language
);
8755 input_radix
= b
->input_radix
;
8758 save_current_space_and_thread ();
8759 switch_to_program_space_and_thread (b
->pspace
);
8761 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8763 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
8768 int not_found_and_ok
= 0;
8769 /* For pending breakpoints, it's expected that parsing
8770 will fail until the right shared library is loaded.
8771 User has already told to create pending breakpoints and
8772 don't need extra messages. If breakpoint is in bp_shlib_disabled
8773 state, then user already saw the message about that breakpoint
8774 being disabled, and don't want to see more errors. */
8776 && (b
->condition_not_parsed
8777 || (b
->loc
&& b
->loc
->shlib_disabled
)
8778 || b
->enable_state
== bp_disabled
))
8779 not_found_and_ok
= 1;
8781 if (!not_found_and_ok
)
8783 /* We surely don't want to warn about the same breakpoint
8784 10 times. One solution, implemented here, is disable
8785 the breakpoint on error. Another solution would be to
8786 have separate 'warning emitted' flag. Since this
8787 happens only when a binary has changed, I don't know
8788 which approach is better. */
8789 b
->enable_state
= bp_disabled
;
8790 throw_exception (e
);
8796 gdb_assert (sals
.nelts
== 1);
8798 resolve_sal_pc (&sals
.sals
[0]);
8799 if (b
->condition_not_parsed
&& s
&& s
[0])
8801 char *cond_string
= 0;
8805 find_condition_and_thread (s
, sals
.sals
[0].pc
,
8806 &cond_string
, &thread
, &task
);
8808 b
->cond_string
= cond_string
;
8811 b
->condition_not_parsed
= 0;
8814 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
8817 make_cleanup (xfree
, sals
.sals
);
8818 update_breakpoint_locations (b
, expanded
);
8822 case bp_hardware_watchpoint
:
8823 case bp_read_watchpoint
:
8824 case bp_access_watchpoint
:
8825 /* Watchpoint can be either on expression using entirely global variables,
8826 or it can be on local variables.
8828 Watchpoints of the first kind are never auto-deleted, and even persist
8829 across program restarts. Since they can use variables from shared
8830 libraries, we need to reparse expression as libraries are loaded
8833 Watchpoints on local variables can also change meaning as result
8834 of solib event. For example, if a watchpoint uses both a local and
8835 a global variables in expression, it's a local watchpoint, but
8836 unloading of a shared library will make the expression invalid.
8837 This is not a very common use case, but we still re-evaluate
8838 expression, to avoid surprises to the user.
8840 Note that for local watchpoints, we re-evaluate it only if
8841 watchpoints frame id is still valid. If it's not, it means
8842 the watchpoint is out of scope and will be deleted soon. In fact,
8843 I'm not sure we'll ever be called in this case.
8845 If a local watchpoint's frame id is still valid, then
8846 b->exp_valid_block is likewise valid, and we can safely use it.
8848 Don't do anything about disabled watchpoints, since they will
8849 be reevaluated again when enabled. */
8850 update_watchpoint (b
, 1 /* reparse */);
8852 /* We needn't really do anything to reset these, since the mask
8853 that requests them is unaffected by e.g., new libraries being
8859 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
8861 /* Delete overlay event and longjmp master breakpoints; they will be
8862 reset later by breakpoint_re_set. */
8863 case bp_overlay_event
:
8864 case bp_longjmp_master
:
8865 delete_breakpoint (b
);
8868 /* This breakpoint is special, it's set up when the inferior
8869 starts and we really don't want to touch it. */
8870 case bp_shlib_event
:
8872 /* Like bp_shlib_event, this breakpoint type is special.
8873 Once it is set up, we do not want to touch it. */
8874 case bp_thread_event
:
8876 /* Keep temporary breakpoints, which can be encountered when we step
8877 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
8878 Otherwise these should have been blown away via the cleanup chain
8879 or by breakpoint_init_inferior when we rerun the executable. */
8882 case bp_watchpoint_scope
:
8884 case bp_step_resume
:
8886 case bp_longjmp_resume
:
8891 do_cleanups (cleanups
);
8895 /* Re-set all breakpoints after symbols have been re-loaded. */
8897 breakpoint_re_set (void)
8899 struct breakpoint
*b
, *temp
;
8900 enum language save_language
;
8901 int save_input_radix
;
8902 struct cleanup
*old_chain
;
8904 save_language
= current_language
->la_language
;
8905 save_input_radix
= input_radix
;
8906 old_chain
= save_current_program_space ();
8908 ALL_BREAKPOINTS_SAFE (b
, temp
)
8910 /* Format possible error msg */
8911 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
8913 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
8914 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
8915 do_cleanups (cleanups
);
8917 set_language (save_language
);
8918 input_radix
= save_input_radix
;
8920 jit_breakpoint_re_set ();
8922 do_cleanups (old_chain
);
8924 create_overlay_event_breakpoint ("_ovly_debug_event");
8925 create_longjmp_master_breakpoint ("longjmp");
8926 create_longjmp_master_breakpoint ("_longjmp");
8927 create_longjmp_master_breakpoint ("siglongjmp");
8928 create_longjmp_master_breakpoint ("_siglongjmp");
8931 /* Reset the thread number of this breakpoint:
8933 - If the breakpoint is for all threads, leave it as-is.
8934 - Else, reset it to the current thread for inferior_ptid. */
8936 breakpoint_re_set_thread (struct breakpoint
*b
)
8938 if (b
->thread
!= -1)
8940 if (in_thread_list (inferior_ptid
))
8941 b
->thread
= pid_to_thread_id (inferior_ptid
);
8943 /* We're being called after following a fork. The new fork is
8944 selected as current, and unless this was a vfork will have a
8945 different program space from the original thread. Reset that
8947 b
->loc
->pspace
= current_program_space
;
8951 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
8952 If from_tty is nonzero, it prints a message to that effect,
8953 which ends with a period (no newline). */
8956 set_ignore_count (int bptnum
, int count
, int from_tty
)
8958 struct breakpoint
*b
;
8964 if (b
->number
== bptnum
)
8966 b
->ignore_count
= count
;
8970 printf_filtered (_("Will stop next time breakpoint %d is reached."),
8972 else if (count
== 1)
8973 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
8976 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
8979 breakpoints_changed ();
8980 observer_notify_breakpoint_modified (b
->number
);
8984 error (_("No breakpoint number %d."), bptnum
);
8988 make_breakpoint_silent (struct breakpoint
*b
)
8990 /* Silence the breakpoint. */
8994 /* Command to set ignore-count of breakpoint N to COUNT. */
8997 ignore_command (char *args
, int from_tty
)
9003 error_no_arg (_("a breakpoint number"));
9005 num
= get_number (&p
);
9007 error (_("bad breakpoint number: '%s'"), args
);
9009 error (_("Second argument (specified ignore-count) is missing."));
9011 set_ignore_count (num
,
9012 longest_to_int (value_as_long (parse_and_eval (p
))),
9015 printf_filtered ("\n");
9018 /* Call FUNCTION on each of the breakpoints
9019 whose numbers are given in ARGS. */
9022 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
9027 struct breakpoint
*b
, *tmp
;
9031 error_no_arg (_("one or more breakpoint numbers"));
9038 num
= get_number_or_range (&p1
);
9041 warning (_("bad breakpoint number at or near '%s'"), p
);
9045 ALL_BREAKPOINTS_SAFE (b
, tmp
)
9046 if (b
->number
== num
)
9048 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
9051 if (related_breakpoint
)
9052 function (related_breakpoint
);
9056 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
9062 static struct bp_location
*
9063 find_location_by_number (char *number
)
9065 char *dot
= strchr (number
, '.');
9069 struct breakpoint
*b
;
9070 struct bp_location
*loc
;
9075 bp_num
= get_number_or_range (&p1
);
9077 error (_("Bad breakpoint number '%s'"), number
);
9080 if (b
->number
== bp_num
)
9085 if (!b
|| b
->number
!= bp_num
)
9086 error (_("Bad breakpoint number '%s'"), number
);
9089 loc_num
= get_number_or_range (&p1
);
9091 error (_("Bad breakpoint location number '%s'"), number
);
9095 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
9098 error (_("Bad breakpoint location number '%s'"), dot
+1);
9104 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
9105 If from_tty is nonzero, it prints a message to that effect,
9106 which ends with a period (no newline). */
9109 disable_breakpoint (struct breakpoint
*bpt
)
9111 /* Never disable a watchpoint scope breakpoint; we want to
9112 hit them when we leave scope so we can delete both the
9113 watchpoint and its scope breakpoint at that time. */
9114 if (bpt
->type
== bp_watchpoint_scope
)
9117 /* You can't disable permanent breakpoints. */
9118 if (bpt
->enable_state
== bp_permanent
)
9121 bpt
->enable_state
= bp_disabled
;
9123 update_global_location_list (0);
9125 observer_notify_breakpoint_modified (bpt
->number
);
9129 disable_command (char *args
, int from_tty
)
9131 struct breakpoint
*bpt
;
9133 ALL_BREAKPOINTS (bpt
)
9137 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
9143 case bp_hardware_breakpoint
:
9145 case bp_hardware_watchpoint
:
9146 case bp_read_watchpoint
:
9147 case bp_access_watchpoint
:
9148 disable_breakpoint (bpt
);
9152 else if (strchr (args
, '.'))
9154 struct bp_location
*loc
= find_location_by_number (args
);
9157 update_global_location_list (0);
9160 map_breakpoint_numbers (args
, disable_breakpoint
);
9164 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
9166 int target_resources_ok
, other_type_used
;
9169 if (bpt
->type
== bp_hardware_breakpoint
)
9172 i
= hw_breakpoint_used_count ();
9173 target_resources_ok
=
9174 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9176 if (target_resources_ok
== 0)
9177 error (_("No hardware breakpoint support in the target."));
9178 else if (target_resources_ok
< 0)
9179 error (_("Hardware breakpoints used exceeds limit."));
9182 if (bpt
->type
== bp_watchpoint
9183 || bpt
->type
== bp_hardware_watchpoint
9184 || bpt
->type
== bp_read_watchpoint
9185 || bpt
->type
== bp_access_watchpoint
)
9187 struct gdb_exception e
;
9189 TRY_CATCH (e
, RETURN_MASK_ALL
)
9191 update_watchpoint (bpt
, 1 /* reparse */);
9195 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
9201 if (bpt
->enable_state
!= bp_permanent
)
9202 bpt
->enable_state
= bp_enabled
;
9203 bpt
->disposition
= disposition
;
9204 update_global_location_list (1);
9205 breakpoints_changed ();
9207 observer_notify_breakpoint_modified (bpt
->number
);
9212 enable_breakpoint (struct breakpoint
*bpt
)
9214 do_enable_breakpoint (bpt
, bpt
->disposition
);
9217 /* The enable command enables the specified breakpoints (or all defined
9218 breakpoints) so they once again become (or continue to be) effective
9219 in stopping the inferior. */
9222 enable_command (char *args
, int from_tty
)
9224 struct breakpoint
*bpt
;
9226 ALL_BREAKPOINTS (bpt
)
9230 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
9236 case bp_hardware_breakpoint
:
9238 case bp_hardware_watchpoint
:
9239 case bp_read_watchpoint
:
9240 case bp_access_watchpoint
:
9241 enable_breakpoint (bpt
);
9245 else if (strchr (args
, '.'))
9247 struct bp_location
*loc
= find_location_by_number (args
);
9250 update_global_location_list (1);
9253 map_breakpoint_numbers (args
, enable_breakpoint
);
9257 enable_once_breakpoint (struct breakpoint
*bpt
)
9259 do_enable_breakpoint (bpt
, disp_disable
);
9263 enable_once_command (char *args
, int from_tty
)
9265 map_breakpoint_numbers (args
, enable_once_breakpoint
);
9269 enable_delete_breakpoint (struct breakpoint
*bpt
)
9271 do_enable_breakpoint (bpt
, disp_del
);
9275 enable_delete_command (char *args
, int from_tty
)
9277 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
9281 set_breakpoint_cmd (char *args
, int from_tty
)
9286 show_breakpoint_cmd (char *args
, int from_tty
)
9290 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
9292 struct symtabs_and_lines
9293 decode_line_spec_1 (char *string
, int funfirstline
)
9295 struct symtabs_and_lines sals
;
9297 error (_("Empty line specification."));
9298 if (default_breakpoint_valid
)
9299 sals
= decode_line_1 (&string
, funfirstline
,
9300 default_breakpoint_symtab
,
9301 default_breakpoint_line
,
9302 (char ***) NULL
, NULL
);
9304 sals
= decode_line_1 (&string
, funfirstline
,
9305 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
9307 error (_("Junk at end of line specification: %s"), string
);
9311 /* Create and insert a raw software breakpoint at PC. Return an
9312 identifier, which should be used to remove the breakpoint later.
9313 In general, places which call this should be using something on the
9314 breakpoint chain instead; this function should be eliminated
9318 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
9319 struct address_space
*aspace
, CORE_ADDR pc
)
9321 struct bp_target_info
*bp_tgt
;
9323 bp_tgt
= XZALLOC (struct bp_target_info
);
9325 bp_tgt
->placed_address_space
= aspace
;
9326 bp_tgt
->placed_address
= pc
;
9328 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
9330 /* Could not insert the breakpoint. */
9338 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
9341 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
9343 struct bp_target_info
*bp_tgt
= bp
;
9346 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
9352 /* One (or perhaps two) breakpoints used for software single stepping. */
9354 static void *single_step_breakpoints
[2];
9355 static struct gdbarch
*single_step_gdbarch
[2];
9357 /* Create and insert a breakpoint for software single step. */
9360 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
9361 struct address_space
*aspace
, CORE_ADDR next_pc
)
9365 if (single_step_breakpoints
[0] == NULL
)
9367 bpt_p
= &single_step_breakpoints
[0];
9368 single_step_gdbarch
[0] = gdbarch
;
9372 gdb_assert (single_step_breakpoints
[1] == NULL
);
9373 bpt_p
= &single_step_breakpoints
[1];
9374 single_step_gdbarch
[1] = gdbarch
;
9377 /* NOTE drow/2006-04-11: A future improvement to this function would be
9378 to only create the breakpoints once, and actually put them on the
9379 breakpoint chain. That would let us use set_raw_breakpoint. We could
9380 adjust the addresses each time they were needed. Doing this requires
9381 corresponding changes elsewhere where single step breakpoints are
9382 handled, however. So, for now, we use this. */
9384 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
9386 error (_("Could not insert single-step breakpoint at %s"),
9387 paddress (gdbarch
, next_pc
));
9390 /* Remove and delete any breakpoints used for software single step. */
9393 remove_single_step_breakpoints (void)
9395 gdb_assert (single_step_breakpoints
[0] != NULL
);
9397 /* See insert_single_step_breakpoint for more about this deprecated
9399 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
9400 single_step_breakpoints
[0]);
9401 single_step_gdbarch
[0] = NULL
;
9402 single_step_breakpoints
[0] = NULL
;
9404 if (single_step_breakpoints
[1] != NULL
)
9406 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
9407 single_step_breakpoints
[1]);
9408 single_step_gdbarch
[1] = NULL
;
9409 single_step_breakpoints
[1] = NULL
;
9413 /* Check whether a software single-step breakpoint is inserted at PC. */
9416 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
9420 for (i
= 0; i
< 2; i
++)
9422 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
9424 && breakpoint_address_match (bp_tgt
->placed_address_space
,
9425 bp_tgt
->placed_address
,
9433 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
9434 non-zero otherwise. */
9436 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
9438 if (syscall_catchpoint_p (bp
)
9439 && bp
->enable_state
!= bp_disabled
9440 && bp
->enable_state
!= bp_call_disabled
)
9447 catch_syscall_enabled (void)
9449 struct inferior
*inf
= current_inferior ();
9451 return inf
->total_syscalls_count
!= 0;
9455 catching_syscall_number (int syscall_number
)
9457 struct breakpoint
*bp
;
9459 ALL_BREAKPOINTS (bp
)
9460 if (is_syscall_catchpoint_enabled (bp
))
9462 if (bp
->syscalls_to_be_caught
)
9466 VEC_iterate (int, bp
->syscalls_to_be_caught
, i
, iter
);
9468 if (syscall_number
== iter
)
9478 /* Complete syscall names. Used by "catch syscall". */
9480 catch_syscall_completer (struct cmd_list_element
*cmd
,
9481 char *text
, char *word
)
9483 const char **list
= get_syscall_names ();
9484 return (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
9487 /* Tracepoint-specific operations. */
9489 /* Set tracepoint count to NUM. */
9491 set_tracepoint_count (int num
)
9493 tracepoint_count
= num
;
9494 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
9498 trace_command (char *arg
, int from_tty
)
9500 break_command_really (get_current_arch (),
9502 NULL
, 0, 1 /* parse arg */,
9503 0 /* tempflag */, 0 /* hardwareflag */,
9505 0 /* Ignore count */,
9506 pending_break_support
,
9510 set_tracepoint_count (breakpoint_count
);
9513 /* Print information on tracepoint number TPNUM_EXP, or all if
9517 tracepoints_info (char *tpnum_exp
, int from_tty
)
9519 struct breakpoint
*b
;
9520 int tps_to_list
= 0;
9522 /* In the no-arguments case, say "No tracepoints" if none found. */
9535 ui_out_message (uiout
, 0, "No tracepoints.\n");
9540 /* Otherwise be the same as "info break". */
9541 breakpoints_info (tpnum_exp
, from_tty
);
9544 /* The 'enable trace' command enables tracepoints.
9545 Not supported by all targets. */
9547 enable_trace_command (char *args
, int from_tty
)
9549 enable_command (args
, from_tty
);
9552 /* The 'disable trace' command disables tracepoints.
9553 Not supported by all targets. */
9555 disable_trace_command (char *args
, int from_tty
)
9557 disable_command (args
, from_tty
);
9560 /* Remove a tracepoint (or all if no argument) */
9562 delete_trace_command (char *arg
, int from_tty
)
9564 struct breakpoint
*b
, *temp
;
9570 int breaks_to_delete
= 0;
9572 /* Delete all breakpoints if no argument.
9573 Do not delete internal or call-dummy breakpoints, these
9574 have to be deleted with an explicit breakpoint number argument. */
9579 breaks_to_delete
= 1;
9584 /* Ask user only if there are some breakpoints to delete. */
9586 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
9588 ALL_BREAKPOINTS_SAFE (b
, temp
)
9590 if (b
->type
== bp_tracepoint
9592 delete_breakpoint (b
);
9597 map_breakpoint_numbers (arg
, delete_breakpoint
);
9600 /* Set passcount for tracepoint.
9602 First command argument is passcount, second is tracepoint number.
9603 If tracepoint number omitted, apply to most recently defined.
9604 Also accepts special argument "all". */
9607 trace_pass_command (char *args
, int from_tty
)
9609 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
9613 if (args
== 0 || *args
== 0)
9614 error (_("passcount command requires an argument (count + optional TP num)"));
9616 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
9618 while (*args
&& isspace ((int) *args
))
9621 if (*args
&& strncasecmp (args
, "all", 3) == 0)
9623 args
+= 3; /* Skip special argument "all". */
9626 error (_("Junk at end of arguments."));
9629 t1
= get_tracepoint_by_number (&args
, 1, 1);
9635 ALL_TRACEPOINTS (t2
)
9636 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
9638 t2
->pass_count
= count
;
9639 observer_notify_tracepoint_modified (t2
->number
);
9641 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
9645 t1
= get_tracepoint_by_number (&args
, 1, 0);
9652 get_tracepoint (int num
)
9654 struct breakpoint
*t
;
9657 if (t
->number
== num
)
9663 /* Utility: parse a tracepoint number and look it up in the list.
9664 If MULTI_P is true, there might be a range of tracepoints in ARG.
9665 if OPTIONAL_P is true, then if the argument is missing, the most
9666 recent tracepoint (tracepoint_count) is returned. */
9668 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
9670 extern int tracepoint_count
;
9671 struct breakpoint
*t
;
9673 char *instring
= arg
== NULL
? NULL
: *arg
;
9675 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
9678 tpnum
= tracepoint_count
;
9680 error_no_arg (_("tracepoint number"));
9683 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
9687 if (instring
&& *instring
)
9688 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
9691 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
9696 if (t
->number
== tpnum
)
9701 /* FIXME: if we are in the middle of a range we don't want to give
9702 a message. The current interface to get_number_or_range doesn't
9703 allow us to discover this. */
9704 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
9708 /* save-tracepoints command */
9710 tracepoint_save_command (char *args
, int from_tty
)
9712 struct breakpoint
*tp
;
9714 struct action_line
*line
;
9716 char *i1
= " ", *i2
= " ";
9717 char *indent
, *actionline
, *pathname
;
9719 struct cleanup
*cleanup
;
9721 if (args
== 0 || *args
== 0)
9722 error (_("Argument required (file name in which to save tracepoints)"));
9724 /* See if we have anything to save. */
9725 ALL_TRACEPOINTS (tp
)
9732 warning (_("save-tracepoints: no tracepoints to save."));
9736 pathname
= tilde_expand (args
);
9737 cleanup
= make_cleanup (xfree
, pathname
);
9738 fp
= fopen (pathname
, "w");
9740 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
9741 args
, safe_strerror (errno
));
9742 make_cleanup_fclose (fp
);
9744 ALL_TRACEPOINTS (tp
)
9746 if (tp
->addr_string
)
9747 fprintf (fp
, "trace %s\n", tp
->addr_string
);
9750 sprintf_vma (tmp
, tp
->loc
->address
);
9751 fprintf (fp
, "trace *0x%s\n", tmp
);
9755 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
9759 fprintf (fp
, " actions\n");
9761 for (line
= tp
->actions
; line
; line
= line
->next
)
9763 struct cmd_list_element
*cmd
;
9765 QUIT
; /* allow user to bail out with ^C */
9766 actionline
= line
->action
;
9767 while (isspace ((int) *actionline
))
9770 fprintf (fp
, "%s%s\n", indent
, actionline
);
9771 if (*actionline
!= '#') /* skip for comment lines */
9773 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
9775 error (_("Bad action list item: %s"), actionline
);
9776 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
9778 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
9784 do_cleanups (cleanup
);
9786 printf_filtered (_("Tracepoints saved to file '%s'.\n"), args
);
9790 /* Create a vector of all tracepoints. */
9795 VEC(breakpoint_p
) *tp_vec
= 0;
9796 struct breakpoint
*tp
;
9798 ALL_TRACEPOINTS (tp
)
9800 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
9807 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
9808 It is defined as a macro to prevent duplication.
9809 COMMAND should be a string constant containing the name of the command. */
9810 #define BREAK_ARGS_HELP(command) \
9811 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
9812 LOCATION may be a line number, function name, or \"*\" and an address.\n\
9813 If a line number is specified, break at start of code for that line.\n\
9814 If a function is specified, break at start of code for that function.\n\
9815 If an address is specified, break at that exact address.\n\
9816 With no LOCATION, uses current execution address of selected stack frame.\n\
9817 This is useful for breaking on return to a stack frame.\n\
9819 THREADNUM is the number from \"info threads\".\n\
9820 CONDITION is a boolean expression.\n\
9822 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
9824 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
9826 /* List of subcommands for "catch". */
9827 static struct cmd_list_element
*catch_cmdlist
;
9829 /* List of subcommands for "tcatch". */
9830 static struct cmd_list_element
*tcatch_cmdlist
;
9832 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
9833 lists, and pass some additional user data to the command function. */
9835 add_catch_command (char *name
, char *docstring
,
9836 void (*sfunc
) (char *args
, int from_tty
,
9837 struct cmd_list_element
*command
),
9838 char **(*completer
) (struct cmd_list_element
*cmd
,
9839 char *text
, char *word
),
9840 void *user_data_catch
,
9841 void *user_data_tcatch
)
9843 struct cmd_list_element
*command
;
9845 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
9847 set_cmd_sfunc (command
, sfunc
);
9848 set_cmd_context (command
, user_data_catch
);
9849 set_cmd_completer (command
, completer
);
9851 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
9853 set_cmd_sfunc (command
, sfunc
);
9854 set_cmd_context (command
, user_data_tcatch
);
9855 set_cmd_completer (command
, completer
);
9859 clear_syscall_counts (int pid
)
9861 struct inferior
*inf
= find_inferior_pid (pid
);
9863 inf
->total_syscalls_count
= 0;
9864 inf
->any_syscall_count
= 0;
9865 VEC_free (int, inf
->syscalls_counts
);
9869 _initialize_breakpoint (void)
9871 static struct cmd_list_element
*breakpoint_set_cmdlist
;
9872 static struct cmd_list_element
*breakpoint_show_cmdlist
;
9873 struct cmd_list_element
*c
;
9875 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
9876 observer_attach_inferior_exit (clear_syscall_counts
);
9878 breakpoint_chain
= 0;
9879 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
9880 before a breakpoint is set. */
9881 breakpoint_count
= 0;
9883 tracepoint_count
= 0;
9885 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
9886 Set ignore-count of breakpoint number N to COUNT.\n\
9887 Usage is `ignore N COUNT'."));
9889 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
9891 add_com ("commands", class_breakpoint
, commands_command
, _("\
9892 Set commands to be executed when a breakpoint is hit.\n\
9893 Give breakpoint number as argument after \"commands\".\n\
9894 With no argument, the targeted breakpoint is the last one set.\n\
9895 The commands themselves follow starting on the next line.\n\
9896 Type a line containing \"end\" to indicate the end of them.\n\
9897 Give \"silent\" as the first line to make the breakpoint silent;\n\
9898 then no output is printed when it is hit, except what the commands print."));
9900 add_com ("condition", class_breakpoint
, condition_command
, _("\
9901 Specify breakpoint number N to break only if COND is true.\n\
9902 Usage is `condition N COND', where N is an integer and COND is an\n\
9903 expression to be evaluated whenever breakpoint N is reached."));
9905 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
9906 Set a temporary breakpoint.\n\
9907 Like \"break\" except the breakpoint is only temporary,\n\
9908 so it will be deleted when hit. Equivalent to \"break\" followed\n\
9909 by using \"enable delete\" on the breakpoint number.\n\
9911 BREAK_ARGS_HELP ("tbreak")));
9912 set_cmd_completer (c
, location_completer
);
9914 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
9915 Set a hardware assisted breakpoint.\n\
9916 Like \"break\" except the breakpoint requires hardware support,\n\
9917 some target hardware may not have this support.\n\
9919 BREAK_ARGS_HELP ("hbreak")));
9920 set_cmd_completer (c
, location_completer
);
9922 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
9923 Set a temporary hardware assisted breakpoint.\n\
9924 Like \"hbreak\" except the breakpoint is only temporary,\n\
9925 so it will be deleted when hit.\n\
9927 BREAK_ARGS_HELP ("thbreak")));
9928 set_cmd_completer (c
, location_completer
);
9930 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
9931 Enable some breakpoints.\n\
9932 Give breakpoint numbers (separated by spaces) as arguments.\n\
9933 With no subcommand, breakpoints are enabled until you command otherwise.\n\
9934 This is used to cancel the effect of the \"disable\" command.\n\
9935 With a subcommand you can enable temporarily."),
9936 &enablelist
, "enable ", 1, &cmdlist
);
9938 add_com ("ab", class_breakpoint
, enable_command
, _("\
9939 Enable some breakpoints.\n\
9940 Give breakpoint numbers (separated by spaces) as arguments.\n\
9941 With no subcommand, breakpoints are enabled until you command otherwise.\n\
9942 This is used to cancel the effect of the \"disable\" command.\n\
9943 With a subcommand you can enable temporarily."));
9945 add_com_alias ("en", "enable", class_breakpoint
, 1);
9947 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
9948 Enable some breakpoints.\n\
9949 Give breakpoint numbers (separated by spaces) as arguments.\n\
9950 This is used to cancel the effect of the \"disable\" command.\n\
9951 May be abbreviated to simply \"enable\".\n"),
9952 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
9954 add_cmd ("once", no_class
, enable_once_command
, _("\
9955 Enable breakpoints for one hit. Give breakpoint numbers.\n\
9956 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
9959 add_cmd ("delete", no_class
, enable_delete_command
, _("\
9960 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
9961 If a breakpoint is hit while enabled in this fashion, it is deleted."),
9964 add_cmd ("delete", no_class
, enable_delete_command
, _("\
9965 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
9966 If a breakpoint is hit while enabled in this fashion, it is deleted."),
9969 add_cmd ("once", no_class
, enable_once_command
, _("\
9970 Enable breakpoints for one hit. Give breakpoint numbers.\n\
9971 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
9974 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
9975 Disable some breakpoints.\n\
9976 Arguments are breakpoint numbers with spaces in between.\n\
9977 To disable all breakpoints, give no argument.\n\
9978 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
9979 &disablelist
, "disable ", 1, &cmdlist
);
9980 add_com_alias ("dis", "disable", class_breakpoint
, 1);
9981 add_com_alias ("disa", "disable", class_breakpoint
, 1);
9983 add_com ("sb", class_breakpoint
, disable_command
, _("\
9984 Disable some breakpoints.\n\
9985 Arguments are breakpoint numbers with spaces in between.\n\
9986 To disable all breakpoints, give no argument.\n\
9987 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
9989 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
9990 Disable some breakpoints.\n\
9991 Arguments are breakpoint numbers with spaces in between.\n\
9992 To disable all breakpoints, give no argument.\n\
9993 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
9994 This command may be abbreviated \"disable\"."),
9997 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
9998 Delete some breakpoints or auto-display expressions.\n\
9999 Arguments are breakpoint numbers with spaces in between.\n\
10000 To delete all breakpoints, give no argument.\n\
10002 Also a prefix command for deletion of other GDB objects.\n\
10003 The \"unset\" command is also an alias for \"delete\"."),
10004 &deletelist
, "delete ", 1, &cmdlist
);
10005 add_com_alias ("d", "delete", class_breakpoint
, 1);
10006 add_com_alias ("del", "delete", class_breakpoint
, 1);
10008 add_com ("db", class_breakpoint
, delete_command
, _("\
10009 Delete some breakpoints.\n\
10010 Arguments are breakpoint numbers with spaces in between.\n\
10011 To delete all breakpoints, give no argument.\n"));
10013 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
10014 Delete some breakpoints or auto-display expressions.\n\
10015 Arguments are breakpoint numbers with spaces in between.\n\
10016 To delete all breakpoints, give no argument.\n\
10017 This command may be abbreviated \"delete\"."),
10020 add_com ("clear", class_breakpoint
, clear_command
, _("\
10021 Clear breakpoint at specified line or function.\n\
10022 Argument may be line number, function name, or \"*\" and an address.\n\
10023 If line number is specified, all breakpoints in that line are cleared.\n\
10024 If function is specified, breakpoints at beginning of function are cleared.\n\
10025 If an address is specified, breakpoints at that address are cleared.\n\
10027 With no argument, clears all breakpoints in the line that the selected frame\n\
10028 is executing in.\n\
10030 See also the \"delete\" command which clears breakpoints by number."));
10032 c
= add_com ("break", class_breakpoint
, break_command
, _("\
10033 Set breakpoint at specified line or function.\n"
10034 BREAK_ARGS_HELP ("break")));
10035 set_cmd_completer (c
, location_completer
);
10037 add_com_alias ("b", "break", class_run
, 1);
10038 add_com_alias ("br", "break", class_run
, 1);
10039 add_com_alias ("bre", "break", class_run
, 1);
10040 add_com_alias ("brea", "break", class_run
, 1);
10043 add_com_alias ("ba", "break", class_breakpoint
, 1);
10047 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
10048 Break in function/address or break at a line in the current file."),
10049 &stoplist
, "stop ", 1, &cmdlist
);
10050 add_cmd ("in", class_breakpoint
, stopin_command
,
10051 _("Break in function or address."), &stoplist
);
10052 add_cmd ("at", class_breakpoint
, stopat_command
,
10053 _("Break at a line in the current file."), &stoplist
);
10054 add_com ("status", class_info
, breakpoints_info
, _("\
10055 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10056 The \"Type\" column indicates one of:\n\
10057 \tbreakpoint - normal breakpoint\n\
10058 \twatchpoint - watchpoint\n\
10059 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10060 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10061 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10062 address and file/line number respectively.\n\
10064 Convenience variable \"$_\" and default examine address for \"x\"\n\
10065 are set to the address of the last breakpoint listed unless the command\n\
10066 is prefixed with \"server \".\n\n\
10067 Convenience variable \"$bpnum\" contains the number of the last\n\
10068 breakpoint set."));
10071 add_info ("breakpoints", breakpoints_info
, _("\
10072 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10073 The \"Type\" column indicates one of:\n\
10074 \tbreakpoint - normal breakpoint\n\
10075 \twatchpoint - watchpoint\n\
10076 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10077 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10078 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10079 address and file/line number respectively.\n\
10081 Convenience variable \"$_\" and default examine address for \"x\"\n\
10082 are set to the address of the last breakpoint listed unless the command\n\
10083 is prefixed with \"server \".\n\n\
10084 Convenience variable \"$bpnum\" contains the number of the last\n\
10085 breakpoint set."));
10088 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
10089 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10090 The \"Type\" column indicates one of:\n\
10091 \tbreakpoint - normal breakpoint\n\
10092 \twatchpoint - watchpoint\n\
10093 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10094 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10095 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10096 address and file/line number respectively.\n\
10098 Convenience variable \"$_\" and default examine address for \"x\"\n\
10099 are set to the address of the last breakpoint listed unless the command\n\
10100 is prefixed with \"server \".\n\n\
10101 Convenience variable \"$bpnum\" contains the number of the last\n\
10102 breakpoint set."));
10104 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
10105 Status of all breakpoints, or breakpoint number NUMBER.\n\
10106 The \"Type\" column indicates one of:\n\
10107 \tbreakpoint - normal breakpoint\n\
10108 \twatchpoint - watchpoint\n\
10109 \tlongjmp - internal breakpoint used to step through longjmp()\n\
10110 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
10111 \tuntil - internal breakpoint used by the \"until\" command\n\
10112 \tfinish - internal breakpoint used by the \"finish\" command\n\
10113 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10114 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10115 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10116 address and file/line number respectively.\n\
10118 Convenience variable \"$_\" and default examine address for \"x\"\n\
10119 are set to the address of the last breakpoint listed unless the command\n\
10120 is prefixed with \"server \".\n\n\
10121 Convenience variable \"$bpnum\" contains the number of the last\n\
10123 &maintenanceinfolist
);
10125 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
10126 Set catchpoints to catch events."),
10127 &catch_cmdlist
, "catch ",
10128 0/*allow-unknown*/, &cmdlist
);
10130 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
10131 Set temporary catchpoints to catch events."),
10132 &tcatch_cmdlist
, "tcatch ",
10133 0/*allow-unknown*/, &cmdlist
);
10135 /* Add catch and tcatch sub-commands. */
10136 add_catch_command ("catch", _("\
10137 Catch an exception, when caught.\n\
10138 With an argument, catch only exceptions with the given name."),
10139 catch_catch_command
,
10143 add_catch_command ("throw", _("\
10144 Catch an exception, when thrown.\n\
10145 With an argument, catch only exceptions with the given name."),
10146 catch_throw_command
,
10150 add_catch_command ("fork", _("Catch calls to fork."),
10151 catch_fork_command_1
,
10153 (void *) (uintptr_t) catch_fork_permanent
,
10154 (void *) (uintptr_t) catch_fork_temporary
);
10155 add_catch_command ("vfork", _("Catch calls to vfork."),
10156 catch_fork_command_1
,
10158 (void *) (uintptr_t) catch_vfork_permanent
,
10159 (void *) (uintptr_t) catch_vfork_temporary
);
10160 add_catch_command ("exec", _("Catch calls to exec."),
10161 catch_exec_command_1
,
10165 add_catch_command ("syscall", _("\
10166 Catch system calls by their names and/or numbers.\n\
10167 Arguments say which system calls to catch. If no arguments\n\
10168 are given, every system call will be caught.\n\
10169 Arguments, if given, should be one or more system call names\n\
10170 (if your system supports that), or system call numbers."),
10171 catch_syscall_command_1
,
10172 catch_syscall_completer
,
10175 add_catch_command ("exception", _("\
10176 Catch Ada exceptions, when raised.\n\
10177 With an argument, catch only exceptions with the given name."),
10178 catch_ada_exception_command
,
10182 add_catch_command ("assert", _("\
10183 Catch failed Ada assertions, when raised.\n\
10184 With an argument, catch only exceptions with the given name."),
10185 catch_assert_command
,
10190 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
10191 Set a watchpoint for an expression.\n\
10192 A watchpoint stops execution of your program whenever the value of\n\
10193 an expression changes."));
10194 set_cmd_completer (c
, expression_completer
);
10196 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
10197 Set a read watchpoint for an expression.\n\
10198 A watchpoint stops execution of your program whenever the value of\n\
10199 an expression is read."));
10200 set_cmd_completer (c
, expression_completer
);
10202 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
10203 Set a watchpoint for an expression.\n\
10204 A watchpoint stops execution of your program whenever the value of\n\
10205 an expression is either read or written."));
10206 set_cmd_completer (c
, expression_completer
);
10208 add_info ("watchpoints", breakpoints_info
,
10209 _("Synonym for ``info breakpoints''."));
10212 /* XXX: cagney/2005-02-23: This should be a boolean, and should
10213 respond to changes - contrary to the description. */
10214 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
10215 &can_use_hw_watchpoints
, _("\
10216 Set debugger's willingness to use watchpoint hardware."), _("\
10217 Show debugger's willingness to use watchpoint hardware."), _("\
10218 If zero, gdb will not use hardware for new watchpoints, even if\n\
10219 such is available. (However, any hardware watchpoints that were\n\
10220 created before setting this to nonzero, will continue to use watchpoint\n\
10223 show_can_use_hw_watchpoints
,
10224 &setlist
, &showlist
);
10226 can_use_hw_watchpoints
= 1;
10228 /* Tracepoint manipulation commands. */
10230 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
10231 Set a tracepoint at specified line or function.\n\
10233 BREAK_ARGS_HELP ("trace") "\n\
10234 Do \"help tracepoints\" for info on other tracepoint commands."));
10235 set_cmd_completer (c
, location_completer
);
10237 add_com_alias ("tp", "trace", class_alias
, 0);
10238 add_com_alias ("tr", "trace", class_alias
, 1);
10239 add_com_alias ("tra", "trace", class_alias
, 1);
10240 add_com_alias ("trac", "trace", class_alias
, 1);
10242 add_info ("tracepoints", tracepoints_info
, _("\
10243 Status of tracepoints, or tracepoint number NUMBER.\n\
10244 Convenience variable \"$tpnum\" contains the number of the\n\
10245 last tracepoint set."));
10247 add_info_alias ("tp", "tracepoints", 1);
10249 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
10250 Delete specified tracepoints.\n\
10251 Arguments are tracepoint numbers, separated by spaces.\n\
10252 No argument means delete all tracepoints."),
10255 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
10256 Disable specified tracepoints.\n\
10257 Arguments are tracepoint numbers, separated by spaces.\n\
10258 No argument means disable all tracepoints."),
10260 deprecate_cmd (c
, "disable");
10262 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
10263 Enable specified tracepoints.\n\
10264 Arguments are tracepoint numbers, separated by spaces.\n\
10265 No argument means enable all tracepoints."),
10267 deprecate_cmd (c
, "enable");
10269 add_com ("passcount", class_trace
, trace_pass_command
, _("\
10270 Set the passcount for a tracepoint.\n\
10271 The trace will end when the tracepoint has been passed 'count' times.\n\
10272 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
10273 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
10275 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
10276 Save current tracepoint definitions as a script.\n\
10277 Use the 'source' command in another debug session to restore them."));
10278 set_cmd_completer (c
, filename_completer
);
10280 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
10281 Breakpoint specific settings\n\
10282 Configure various breakpoint-specific variables such as\n\
10283 pending breakpoint behavior"),
10284 &breakpoint_set_cmdlist
, "set breakpoint ",
10285 0/*allow-unknown*/, &setlist
);
10286 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
10287 Breakpoint specific settings\n\
10288 Configure various breakpoint-specific variables such as\n\
10289 pending breakpoint behavior"),
10290 &breakpoint_show_cmdlist
, "show breakpoint ",
10291 0/*allow-unknown*/, &showlist
);
10293 add_setshow_auto_boolean_cmd ("pending", no_class
,
10294 &pending_break_support
, _("\
10295 Set debugger's behavior regarding pending breakpoints."), _("\
10296 Show debugger's behavior regarding pending breakpoints."), _("\
10297 If on, an unrecognized breakpoint location will cause gdb to create a\n\
10298 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
10299 an error. If auto, an unrecognized breakpoint location results in a\n\
10300 user-query to see if a pending breakpoint should be created."),
10302 show_pending_break_support
,
10303 &breakpoint_set_cmdlist
,
10304 &breakpoint_show_cmdlist
);
10306 pending_break_support
= AUTO_BOOLEAN_AUTO
;
10308 add_setshow_boolean_cmd ("auto-hw", no_class
,
10309 &automatic_hardware_breakpoints
, _("\
10310 Set automatic usage of hardware breakpoints."), _("\
10311 Show automatic usage of hardware breakpoints."), _("\
10312 If set, the debugger will automatically use hardware breakpoints for\n\
10313 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
10314 a warning will be emitted for such breakpoints."),
10316 show_automatic_hardware_breakpoints
,
10317 &breakpoint_set_cmdlist
,
10318 &breakpoint_show_cmdlist
);
10320 add_setshow_enum_cmd ("always-inserted", class_support
,
10321 always_inserted_enums
, &always_inserted_mode
, _("\
10322 Set mode for inserting breakpoints."), _("\
10323 Show mode for inserting breakpoints."), _("\
10324 When this mode is off, breakpoints are inserted in inferior when it is\n\
10325 resumed, and removed when execution stops. When this mode is on,\n\
10326 breakpoints are inserted immediately and removed only when the user\n\
10327 deletes the breakpoint. When this mode is auto (which is the default),\n\
10328 the behaviour depends on the non-stop setting (see help set non-stop).\n\
10329 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
10330 behaves as if always-inserted mode is on; if gdb is controlling the\n\
10331 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
10333 &show_always_inserted_mode
,
10334 &breakpoint_set_cmdlist
,
10335 &breakpoint_show_cmdlist
);
10337 automatic_hardware_breakpoints
= 1;
10339 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);