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 /* Tracepoints are inserted by the target at a time of its choosing,
1198 if (bpt
->owner
->type
== bp_tracepoint
)
1204 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1205 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1206 and HW_BREAKPOINT_ERROR are used to report problems.
1208 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1209 method for each breakpoint or catchpoint type. */
1211 insert_bp_location (struct bp_location
*bpt
,
1212 struct ui_file
*tmp_error_stream
,
1213 int *disabled_breaks
,
1214 int *hw_breakpoint_error
)
1218 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1221 /* Initialize the target-specific information. */
1222 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1223 bpt
->target_info
.placed_address
= bpt
->address
;
1224 bpt
->target_info
.placed_address_space
= bpt
->pspace
->aspace
;
1226 if (bpt
->loc_type
== bp_loc_software_breakpoint
1227 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1229 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1231 /* If the explicitly specified breakpoint type
1232 is not hardware breakpoint, check the memory map to see
1233 if the breakpoint address is in read only memory or not.
1234 Two important cases are:
1235 - location type is not hardware breakpoint, memory
1236 is readonly. We change the type of the location to
1237 hardware breakpoint.
1238 - location type is hardware breakpoint, memory is read-write.
1239 This means we've previously made the location hardware one, but
1240 then the memory map changed, so we undo.
1242 When breakpoints are removed, remove_breakpoints will
1243 use location types we've just set here, the only possible
1244 problem is that memory map has changed during running program,
1245 but it's not going to work anyway with current gdb. */
1246 struct mem_region
*mr
1247 = lookup_mem_region (bpt
->target_info
.placed_address
);
1251 if (automatic_hardware_breakpoints
)
1254 enum bp_loc_type new_type
;
1256 if (mr
->attrib
.mode
!= MEM_RW
)
1257 new_type
= bp_loc_hardware_breakpoint
;
1259 new_type
= bp_loc_software_breakpoint
;
1261 if (new_type
!= bpt
->loc_type
)
1263 static int said
= 0;
1264 bpt
->loc_type
= new_type
;
1267 fprintf_filtered (gdb_stdout
, _("\
1268 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1273 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1274 && mr
->attrib
.mode
!= MEM_RW
)
1275 warning (_("cannot set software breakpoint at readonly address %s"),
1276 paddress (bpt
->gdbarch
, bpt
->address
));
1280 /* First check to see if we have to handle an overlay. */
1281 if (overlay_debugging
== ovly_off
1282 || bpt
->section
== NULL
1283 || !(section_is_overlay (bpt
->section
)))
1285 /* No overlay handling: just set the breakpoint. */
1287 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1288 val
= target_insert_hw_breakpoint (bpt
->gdbarch
,
1291 val
= target_insert_breakpoint (bpt
->gdbarch
,
1296 /* This breakpoint is in an overlay section.
1297 Shall we set a breakpoint at the LMA? */
1298 if (!overlay_events_enabled
)
1300 /* Yes -- overlay event support is not active,
1301 so we must try to set a breakpoint at the LMA.
1302 This will not work for a hardware breakpoint. */
1303 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1304 warning (_("hardware breakpoint %d not supported in overlay!"),
1305 bpt
->owner
->number
);
1308 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1310 /* Set a software (trap) breakpoint at the LMA. */
1311 bpt
->overlay_target_info
= bpt
->target_info
;
1312 bpt
->overlay_target_info
.placed_address
= addr
;
1313 val
= target_insert_breakpoint (bpt
->gdbarch
,
1314 &bpt
->overlay_target_info
);
1316 fprintf_unfiltered (tmp_error_stream
,
1317 "Overlay breakpoint %d failed: in ROM?\n",
1318 bpt
->owner
->number
);
1321 /* Shall we set a breakpoint at the VMA? */
1322 if (section_is_mapped (bpt
->section
))
1324 /* Yes. This overlay section is mapped into memory. */
1325 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1326 val
= target_insert_hw_breakpoint (bpt
->gdbarch
,
1329 val
= target_insert_breakpoint (bpt
->gdbarch
,
1334 /* No. This breakpoint will not be inserted.
1335 No error, but do not mark the bp as 'inserted'. */
1342 /* Can't set the breakpoint. */
1343 if (solib_name_from_address (bpt
->pspace
, bpt
->address
))
1345 /* See also: disable_breakpoints_in_shlibs. */
1347 bpt
->shlib_disabled
= 1;
1348 if (!*disabled_breaks
)
1350 fprintf_unfiltered (tmp_error_stream
,
1351 "Cannot insert breakpoint %d.\n",
1352 bpt
->owner
->number
);
1353 fprintf_unfiltered (tmp_error_stream
,
1354 "Temporarily disabling shared library breakpoints:\n");
1356 *disabled_breaks
= 1;
1357 fprintf_unfiltered (tmp_error_stream
,
1358 "breakpoint #%d\n", bpt
->owner
->number
);
1362 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1364 *hw_breakpoint_error
= 1;
1365 fprintf_unfiltered (tmp_error_stream
,
1366 "Cannot insert hardware breakpoint %d.\n",
1367 bpt
->owner
->number
);
1371 fprintf_unfiltered (tmp_error_stream
,
1372 "Cannot insert breakpoint %d.\n",
1373 bpt
->owner
->number
);
1374 fprintf_filtered (tmp_error_stream
,
1375 "Error accessing memory address ");
1376 fputs_filtered (paddress (bpt
->gdbarch
, bpt
->address
),
1378 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1379 safe_strerror (val
));
1390 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1391 /* NOTE drow/2003-09-08: This state only exists for removing
1392 watchpoints. It's not clear that it's necessary... */
1393 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1395 val
= target_insert_watchpoint (bpt
->address
,
1397 bpt
->watchpoint_type
);
1398 bpt
->inserted
= (val
!= -1);
1401 else if (bpt
->owner
->type
== bp_catchpoint
)
1403 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1404 bpt
->owner
, RETURN_MASK_ERROR
);
1405 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1406 bpt
->owner
->number
);
1408 bpt
->owner
->enable_state
= bp_disabled
;
1412 /* We've already printed an error message if there was a problem
1413 inserting this catchpoint, and we've disabled the catchpoint,
1414 so just return success. */
1421 /* This function is called when program space PSPACE is about to be
1422 deleted. It takes care of updating breakpoints to not reference
1426 breakpoint_program_space_exit (struct program_space
*pspace
)
1428 struct breakpoint
*b
, *b_temp
;
1429 struct bp_location
*loc
, **loc_temp
;
1431 /* Remove any breakpoint that was set through this program space. */
1432 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1434 if (b
->pspace
== pspace
)
1435 delete_breakpoint (b
);
1438 /* Breakpoints set through other program spaces could have locations
1439 bound to PSPACE as well. Remove those. */
1440 ALL_BP_LOCATIONS (loc
, loc_temp
)
1442 struct bp_location
*tmp
;
1444 if (loc
->pspace
== pspace
)
1446 if (loc
->owner
->loc
== loc
)
1447 loc
->owner
->loc
= loc
->next
;
1449 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1450 if (tmp
->next
== loc
)
1452 tmp
->next
= loc
->next
;
1458 /* Now update the global location list to permanently delete the
1459 removed locations above. */
1460 update_global_location_list (0);
1463 /* Make sure all breakpoints are inserted in inferior.
1464 Throws exception on any error.
1465 A breakpoint that is already inserted won't be inserted
1466 again, so calling this function twice is safe. */
1468 insert_breakpoints (void)
1470 struct breakpoint
*bpt
;
1472 ALL_BREAKPOINTS (bpt
)
1473 if (is_hardware_watchpoint (bpt
))
1474 update_watchpoint (bpt
, 0 /* don't reparse. */);
1476 update_global_location_list (1);
1478 /* update_global_location_list does not insert breakpoints when
1479 always_inserted_mode is not enabled. Explicitly insert them
1481 if (!breakpoints_always_inserted_mode ())
1482 insert_breakpoint_locations ();
1485 /* insert_breakpoints is used when starting or continuing the program.
1486 remove_breakpoints is used when the program stops.
1487 Both return zero if successful,
1488 or an `errno' value if could not write the inferior. */
1491 insert_breakpoint_locations (void)
1493 struct breakpoint
*bpt
;
1494 struct bp_location
*b
, **bp_tmp
;
1497 int disabled_breaks
= 0;
1498 int hw_breakpoint_error
= 0;
1500 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1501 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1503 /* Explicitly mark the warning -- this will only be printed if
1504 there was an error. */
1505 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1507 save_current_space_and_thread ();
1509 ALL_BP_LOCATIONS (b
, bp_tmp
)
1511 struct thread_info
*tp
;
1512 CORE_ADDR last_addr
;
1514 if (!should_be_inserted (b
) || b
->inserted
)
1517 /* There is no point inserting thread-specific breakpoints if the
1518 thread no longer exists. */
1519 if (b
->owner
->thread
!= -1
1520 && !valid_thread_id (b
->owner
->thread
))
1523 switch_to_program_space_and_thread (b
->pspace
);
1525 /* For targets that support global breakpoints, there's no need
1526 to select an inferior to insert breakpoint to. In fact, even
1527 if we aren't attached to any process yet, we should still
1528 insert breakpoints. */
1529 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
1530 && ptid_equal (inferior_ptid
, null_ptid
))
1533 if (!ptid_equal (inferior_ptid
, null_ptid
))
1535 struct inferior
*inf
= current_inferior ();
1536 if (inf
->waiting_for_vfork_done
)
1538 /* This is set when we're attached to the parent of the
1539 vfork, and have detached from the child. The child
1540 is running free, and we expect it to do an exec or
1541 exit, at which point the OS makes the parent
1542 schedulable again (and the target reports that the
1543 vfork is done). Until the child is done with the
1544 shared memory region, do not insert breakpoints in
1545 parent, otherwise the child could still trip on the
1546 parent's breakpoints. Since the parent is blocked
1547 anyway, it won't miss any breakpoint. */
1552 val
= insert_bp_location (b
, tmp_error_stream
,
1554 &hw_breakpoint_error
);
1559 /* If we failed to insert all locations of a watchpoint,
1560 remove them, as half-inserted watchpoint is of limited use. */
1561 ALL_BREAKPOINTS (bpt
)
1563 int some_failed
= 0;
1564 struct bp_location
*loc
;
1566 if (!is_hardware_watchpoint (bpt
))
1569 if (!breakpoint_enabled (bpt
))
1572 if (bpt
->disposition
== disp_del_at_next_stop
)
1575 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1583 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1585 remove_breakpoint (loc
, mark_uninserted
);
1587 hw_breakpoint_error
= 1;
1588 fprintf_unfiltered (tmp_error_stream
,
1589 "Could not insert hardware watchpoint %d.\n",
1597 /* If a hardware breakpoint or watchpoint was inserted, add a
1598 message about possibly exhausted resources. */
1599 if (hw_breakpoint_error
)
1601 fprintf_unfiltered (tmp_error_stream
,
1602 "Could not insert hardware breakpoints:\n\
1603 You may have requested too many hardware breakpoints/watchpoints.\n");
1605 target_terminal_ours_for_output ();
1606 error_stream (tmp_error_stream
);
1609 do_cleanups (cleanups
);
1613 remove_breakpoints (void)
1615 struct bp_location
*b
, **bp_tmp
;
1618 ALL_BP_LOCATIONS (b
, bp_tmp
)
1621 val
|= remove_breakpoint (b
, mark_uninserted
);
1626 /* Remove breakpoints of process PID. */
1629 remove_breakpoints_pid (int pid
)
1631 struct bp_location
*b
, **b_tmp
;
1633 struct inferior
*inf
= find_inferior_pid (pid
);
1635 ALL_BP_LOCATIONS (b
, b_tmp
)
1637 if (b
->pspace
!= inf
->pspace
)
1642 val
= remove_breakpoint (b
, mark_uninserted
);
1651 remove_hw_watchpoints (void)
1653 struct bp_location
*b
, **bp_tmp
;
1656 ALL_BP_LOCATIONS (b
, bp_tmp
)
1658 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1659 val
|= remove_breakpoint (b
, mark_uninserted
);
1665 reattach_breakpoints (int pid
)
1667 struct cleanup
*old_chain
;
1668 struct bp_location
*b
, **bp_tmp
;
1670 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1671 int dummy1
= 0, dummy2
= 0;
1672 struct inferior
*inf
;
1673 struct thread_info
*tp
;
1675 tp
= any_live_thread_of_process (pid
);
1679 inf
= find_inferior_pid (pid
);
1680 old_chain
= save_inferior_ptid ();
1682 inferior_ptid
= tp
->ptid
;
1684 make_cleanup_ui_file_delete (tmp_error_stream
);
1686 ALL_BP_LOCATIONS (b
, bp_tmp
)
1688 if (b
->pspace
!= inf
->pspace
)
1694 val
= insert_bp_location (b
, tmp_error_stream
,
1698 do_cleanups (old_chain
);
1703 do_cleanups (old_chain
);
1707 static int internal_breakpoint_number
= -1;
1709 static struct breakpoint
*
1710 create_internal_breakpoint (struct gdbarch
*gdbarch
,
1711 CORE_ADDR address
, enum bptype type
)
1713 struct symtab_and_line sal
;
1714 struct breakpoint
*b
;
1716 init_sal (&sal
); /* initialize to zeroes */
1719 sal
.section
= find_pc_overlay (sal
.pc
);
1720 sal
.pspace
= current_program_space
;
1722 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
1723 b
->number
= internal_breakpoint_number
--;
1724 b
->disposition
= disp_donttouch
;
1730 create_overlay_event_breakpoint (char *func_name
)
1732 struct objfile
*objfile
;
1734 ALL_OBJFILES (objfile
)
1736 struct breakpoint
*b
;
1737 struct minimal_symbol
*m
;
1739 m
= lookup_minimal_symbol_text (func_name
, objfile
);
1743 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
1744 SYMBOL_VALUE_ADDRESS (m
),
1746 b
->addr_string
= xstrdup (func_name
);
1748 if (overlay_debugging
== ovly_auto
)
1750 b
->enable_state
= bp_enabled
;
1751 overlay_events_enabled
= 1;
1755 b
->enable_state
= bp_disabled
;
1756 overlay_events_enabled
= 0;
1759 update_global_location_list (1);
1763 create_longjmp_master_breakpoint (char *func_name
)
1765 struct program_space
*pspace
;
1766 struct objfile
*objfile
;
1767 struct cleanup
*old_chain
;
1769 old_chain
= save_current_program_space ();
1771 ALL_PSPACES (pspace
)
1772 ALL_OBJFILES (objfile
)
1774 struct breakpoint
*b
;
1775 struct minimal_symbol
*m
;
1777 if (!gdbarch_get_longjmp_target_p (get_objfile_arch (objfile
)))
1780 set_current_program_space (pspace
);
1782 m
= lookup_minimal_symbol_text (func_name
, objfile
);
1786 b
= create_internal_breakpoint (get_objfile_arch (objfile
),
1787 SYMBOL_VALUE_ADDRESS (m
),
1789 b
->addr_string
= xstrdup (func_name
);
1790 b
->enable_state
= bp_disabled
;
1792 update_global_location_list (1);
1794 do_cleanups (old_chain
);
1798 update_breakpoints_after_exec (void)
1800 struct breakpoint
*b
;
1801 struct breakpoint
*temp
;
1802 struct bp_location
*bploc
, **bplocp_tmp
;
1804 /* We're about to delete breakpoints from GDB's lists. If the
1805 INSERTED flag is true, GDB will try to lift the breakpoints by
1806 writing the breakpoints' "shadow contents" back into memory. The
1807 "shadow contents" are NOT valid after an exec, so GDB should not
1808 do that. Instead, the target is responsible from marking
1809 breakpoints out as soon as it detects an exec. We don't do that
1810 here instead, because there may be other attempts to delete
1811 breakpoints after detecting an exec and before reaching here. */
1812 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
1813 if (bploc
->pspace
== current_program_space
)
1814 gdb_assert (!bploc
->inserted
);
1816 ALL_BREAKPOINTS_SAFE (b
, temp
)
1818 if (b
->pspace
!= current_program_space
)
1821 /* Solib breakpoints must be explicitly reset after an exec(). */
1822 if (b
->type
== bp_shlib_event
)
1824 delete_breakpoint (b
);
1828 /* JIT breakpoints must be explicitly reset after an exec(). */
1829 if (b
->type
== bp_jit_event
)
1831 delete_breakpoint (b
);
1835 /* Thread event breakpoints must be set anew after an exec(),
1836 as must overlay event and longjmp master breakpoints. */
1837 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
1838 || b
->type
== bp_longjmp_master
)
1840 delete_breakpoint (b
);
1844 /* Step-resume breakpoints are meaningless after an exec(). */
1845 if (b
->type
== bp_step_resume
)
1847 delete_breakpoint (b
);
1851 /* Longjmp and longjmp-resume breakpoints are also meaningless
1853 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
1855 delete_breakpoint (b
);
1859 if (b
->type
== bp_catchpoint
)
1861 /* For now, none of the bp_catchpoint breakpoints need to
1862 do anything at this point. In the future, if some of
1863 the catchpoints need to something, we will need to add
1864 a new method, and call this method from here. */
1868 /* bp_finish is a special case. The only way we ought to be able
1869 to see one of these when an exec() has happened, is if the user
1870 caught a vfork, and then said "finish". Ordinarily a finish just
1871 carries them to the call-site of the current callee, by setting
1872 a temporary bp there and resuming. But in this case, the finish
1873 will carry them entirely through the vfork & exec.
1875 We don't want to allow a bp_finish to remain inserted now. But
1876 we can't safely delete it, 'cause finish_command has a handle to
1877 the bp on a bpstat, and will later want to delete it. There's a
1878 chance (and I've seen it happen) that if we delete the bp_finish
1879 here, that its storage will get reused by the time finish_command
1880 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1881 We really must allow finish_command to delete a bp_finish.
1883 In the absense of a general solution for the "how do we know
1884 it's safe to delete something others may have handles to?"
1885 problem, what we'll do here is just uninsert the bp_finish, and
1886 let finish_command delete it.
1888 (We know the bp_finish is "doomed" in the sense that it's
1889 momentary, and will be deleted as soon as finish_command sees
1890 the inferior stopped. So it doesn't matter that the bp's
1891 address is probably bogus in the new a.out, unlike e.g., the
1892 solib breakpoints.) */
1894 if (b
->type
== bp_finish
)
1899 /* Without a symbolic address, we have little hope of the
1900 pre-exec() address meaning the same thing in the post-exec()
1902 if (b
->addr_string
== NULL
)
1904 delete_breakpoint (b
);
1908 /* FIXME what about longjmp breakpoints? Re-create them here? */
1909 create_overlay_event_breakpoint ("_ovly_debug_event");
1910 create_longjmp_master_breakpoint ("longjmp");
1911 create_longjmp_master_breakpoint ("_longjmp");
1912 create_longjmp_master_breakpoint ("siglongjmp");
1913 create_longjmp_master_breakpoint ("_siglongjmp");
1917 detach_breakpoints (int pid
)
1919 struct bp_location
*b
, **bp_tmp
;
1921 struct cleanup
*old_chain
= save_inferior_ptid ();
1922 struct inferior
*inf
= current_inferior ();
1924 if (pid
== PIDGET (inferior_ptid
))
1925 error (_("Cannot detach breakpoints of inferior_ptid"));
1927 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
1928 inferior_ptid
= pid_to_ptid (pid
);
1929 ALL_BP_LOCATIONS (b
, bp_tmp
)
1931 if (b
->pspace
!= inf
->pspace
)
1935 val
|= remove_breakpoint_1 (b
, mark_inserted
);
1937 do_cleanups (old_chain
);
1941 /* Remove the breakpoint location B from the current address space.
1942 Note that this is used to detach breakpoints from a child fork.
1943 When we get here, the child isn't in the inferior list, and neither
1944 do we have objects to represent its address space --- we should
1945 *not* look at b->pspace->aspace here. */
1948 remove_breakpoint_1 (struct bp_location
*b
, insertion_state_t is
)
1951 struct cleanup
*old_chain
;
1953 if (b
->owner
->enable_state
== bp_permanent
)
1954 /* Permanent breakpoints cannot be inserted or removed. */
1957 /* The type of none suggests that owner is actually deleted.
1958 This should not ever happen. */
1959 gdb_assert (b
->owner
->type
!= bp_none
);
1961 if (b
->loc_type
== bp_loc_software_breakpoint
1962 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1964 /* "Normal" instruction breakpoint: either the standard
1965 trap-instruction bp (bp_breakpoint), or a
1966 bp_hardware_breakpoint. */
1968 /* First check to see if we have to handle an overlay. */
1969 if (overlay_debugging
== ovly_off
1970 || b
->section
== NULL
1971 || !(section_is_overlay (b
->section
)))
1973 /* No overlay handling: just remove the breakpoint. */
1975 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1976 val
= target_remove_hw_breakpoint (b
->gdbarch
, &b
->target_info
);
1978 val
= target_remove_breakpoint (b
->gdbarch
, &b
->target_info
);
1982 /* This breakpoint is in an overlay section.
1983 Did we set a breakpoint at the LMA? */
1984 if (!overlay_events_enabled
)
1986 /* Yes -- overlay event support is not active, so we
1987 should have set a breakpoint at the LMA. Remove it.
1989 /* Ignore any failures: if the LMA is in ROM, we will
1990 have already warned when we failed to insert it. */
1991 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1992 target_remove_hw_breakpoint (b
->gdbarch
,
1993 &b
->overlay_target_info
);
1995 target_remove_breakpoint (b
->gdbarch
,
1996 &b
->overlay_target_info
);
1998 /* Did we set a breakpoint at the VMA?
1999 If so, we will have marked the breakpoint 'inserted'. */
2002 /* Yes -- remove it. Previously we did not bother to
2003 remove the breakpoint if the section had been
2004 unmapped, but let's not rely on that being safe. We
2005 don't know what the overlay manager might do. */
2006 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
2007 val
= target_remove_hw_breakpoint (b
->gdbarch
,
2010 /* However, we should remove *software* breakpoints only
2011 if the section is still mapped, or else we overwrite
2012 wrong code with the saved shadow contents. */
2013 else if (section_is_mapped (b
->section
))
2014 val
= target_remove_breakpoint (b
->gdbarch
,
2021 /* No -- not inserted, so no need to remove. No error. */
2026 /* In some cases, we might not be able to remove a breakpoint
2027 in a shared library that has already been removed, but we
2028 have not yet processed the shlib unload event. */
2029 if (val
&& solib_name_from_address (b
->pspace
, b
->address
))
2034 b
->inserted
= (is
== mark_inserted
);
2036 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
2041 b
->inserted
= (is
== mark_inserted
);
2042 val
= target_remove_watchpoint (b
->address
, b
->length
,
2043 b
->watchpoint_type
);
2045 /* Failure to remove any of the hardware watchpoints comes here. */
2046 if ((is
== mark_uninserted
) && (b
->inserted
))
2047 warning (_("Could not remove hardware watchpoint %d."),
2050 else if (b
->owner
->type
== bp_catchpoint
2051 && breakpoint_enabled (b
->owner
)
2054 gdb_assert (b
->owner
->ops
!= NULL
&& b
->owner
->ops
->remove
!= NULL
);
2056 val
= b
->owner
->ops
->remove (b
->owner
);
2059 b
->inserted
= (is
== mark_inserted
);
2066 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
2069 struct cleanup
*old_chain
;
2071 if (b
->owner
->enable_state
== bp_permanent
)
2072 /* Permanent breakpoints cannot be inserted or removed. */
2075 /* The type of none suggests that owner is actually deleted.
2076 This should not ever happen. */
2077 gdb_assert (b
->owner
->type
!= bp_none
);
2079 old_chain
= save_current_space_and_thread ();
2081 switch_to_program_space_and_thread (b
->pspace
);
2083 ret
= remove_breakpoint_1 (b
, is
);
2085 do_cleanups (old_chain
);
2089 /* Clear the "inserted" flag in all breakpoints. */
2092 mark_breakpoints_out (void)
2094 struct bp_location
*bpt
, **bptp_tmp
;
2096 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2097 if (bpt
->pspace
== current_program_space
)
2101 /* Clear the "inserted" flag in all breakpoints and delete any
2102 breakpoints which should go away between runs of the program.
2104 Plus other such housekeeping that has to be done for breakpoints
2107 Note: this function gets called at the end of a run (by
2108 generic_mourn_inferior) and when a run begins (by
2109 init_wait_for_inferior). */
2114 breakpoint_init_inferior (enum inf_context context
)
2116 struct breakpoint
*b
, *temp
;
2117 struct bp_location
*bpt
, **bptp_tmp
;
2119 struct program_space
*pspace
= current_program_space
;
2121 /* If breakpoint locations are shared across processes, then there's
2123 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2126 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2128 if (bpt
->pspace
== pspace
2129 && bpt
->owner
->enable_state
!= bp_permanent
)
2133 ALL_BREAKPOINTS_SAFE (b
, temp
)
2135 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2141 case bp_watchpoint_scope
:
2143 /* If the call dummy breakpoint is at the entry point it will
2144 cause problems when the inferior is rerun, so we better
2147 Also get rid of scope breakpoints. */
2148 delete_breakpoint (b
);
2152 case bp_hardware_watchpoint
:
2153 case bp_read_watchpoint
:
2154 case bp_access_watchpoint
:
2156 /* Likewise for watchpoints on local expressions. */
2157 if (b
->exp_valid_block
!= NULL
)
2158 delete_breakpoint (b
);
2159 else if (context
== inf_starting
)
2161 /* Reset val field to force reread of starting value
2162 in insert_breakpoints. */
2164 value_free (b
->val
);
2174 /* Get rid of the moribund locations. */
2175 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bpt
); ++ix
)
2176 free_bp_location (bpt
);
2177 VEC_free (bp_location_p
, moribund_locations
);
2180 /* These functions concern about actual breakpoints inserted in the
2181 target --- to e.g. check if we need to do decr_pc adjustment or if
2182 we need to hop over the bkpt --- so we check for address space
2183 match, not program space. */
2185 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2186 exists at PC. It returns ordinary_breakpoint_here if it's an
2187 ordinary breakpoint, or permanent_breakpoint_here if it's a
2188 permanent breakpoint.
2189 - When continuing from a location with an ordinary breakpoint, we
2190 actually single step once before calling insert_breakpoints.
2191 - When continuing from a localion with a permanent breakpoint, we
2192 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2193 the target, to advance the PC past the breakpoint. */
2195 enum breakpoint_here
2196 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2198 struct bp_location
*bpt
, **bptp_tmp
;
2199 int any_breakpoint_here
= 0;
2201 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2203 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2204 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2207 if ((breakpoint_enabled (bpt
->owner
)
2208 || bpt
->owner
->enable_state
== bp_permanent
)
2209 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2212 if (overlay_debugging
2213 && section_is_overlay (bpt
->section
)
2214 && !section_is_mapped (bpt
->section
))
2215 continue; /* unmapped overlay -- can't be a match */
2216 else if (bpt
->owner
->enable_state
== bp_permanent
)
2217 return permanent_breakpoint_here
;
2219 any_breakpoint_here
= 1;
2223 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2226 /* Return true if there's a moribund breakpoint at PC. */
2229 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2231 struct bp_location
*loc
;
2234 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2235 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
2242 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2243 inserted using regular breakpoint_chain / bp_location array mechanism.
2244 This does not check for single-step breakpoints, which are
2245 inserted and removed using direct target manipulation. */
2248 regular_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2250 struct bp_location
*bpt
, **bptp_tmp
;
2252 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2254 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2255 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2259 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2262 if (overlay_debugging
2263 && section_is_overlay (bpt
->section
)
2264 && !section_is_mapped (bpt
->section
))
2265 continue; /* unmapped overlay -- can't be a match */
2273 /* Returns non-zero iff there's either regular breakpoint
2274 or a single step breakpoint inserted at PC. */
2277 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2279 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
2282 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2288 /* This function returns non-zero iff there is a software breakpoint
2292 software_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2294 struct bp_location
*bpt
, **bptp_tmp
;
2295 int any_breakpoint_here
= 0;
2297 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2299 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
2303 && breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2306 if (overlay_debugging
2307 && section_is_overlay (bpt
->section
)
2308 && !section_is_mapped (bpt
->section
))
2309 continue; /* unmapped overlay -- can't be a match */
2315 /* Also check for software single-step breakpoints. */
2316 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2322 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2323 PC is valid for process/thread PTID. */
2326 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
2329 struct bp_location
*bpt
, **bptp_tmp
;
2330 /* The thread and task IDs associated to PTID, computed lazily. */
2334 ALL_BP_LOCATIONS (bpt
, bptp_tmp
)
2336 if (bpt
->loc_type
!= bp_loc_software_breakpoint
2337 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
2340 if (!breakpoint_enabled (bpt
->owner
)
2341 && bpt
->owner
->enable_state
!= bp_permanent
)
2344 if (!breakpoint_address_match (bpt
->pspace
->aspace
, bpt
->address
,
2348 if (bpt
->owner
->thread
!= -1)
2350 /* This is a thread-specific breakpoint. Check that ptid
2351 matches that thread. If thread hasn't been computed yet,
2352 it is now time to do so. */
2354 thread
= pid_to_thread_id (ptid
);
2355 if (bpt
->owner
->thread
!= thread
)
2359 if (bpt
->owner
->task
!= 0)
2361 /* This is a task-specific breakpoint. Check that ptid
2362 matches that task. If task hasn't been computed yet,
2363 it is now time to do so. */
2365 task
= ada_get_task_number (ptid
);
2366 if (bpt
->owner
->task
!= task
)
2370 if (overlay_debugging
2371 && section_is_overlay (bpt
->section
)
2372 && !section_is_mapped (bpt
->section
))
2373 continue; /* unmapped overlay -- can't be a match */
2382 /* bpstat stuff. External routines' interfaces are documented
2386 ep_is_catchpoint (struct breakpoint
*ep
)
2388 return (ep
->type
== bp_catchpoint
);
2392 bpstat_free (bpstat bs
)
2394 if (bs
->old_val
!= NULL
)
2395 value_free (bs
->old_val
);
2396 free_command_lines (&bs
->commands
);
2400 /* Clear a bpstat so that it says we are not at any breakpoint.
2401 Also free any storage that is part of a bpstat. */
2404 bpstat_clear (bpstat
*bsp
)
2421 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
2422 is part of the bpstat is copied as well. */
2425 bpstat_copy (bpstat bs
)
2429 bpstat retval
= NULL
;
2434 for (; bs
!= NULL
; bs
= bs
->next
)
2436 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
2437 memcpy (tmp
, bs
, sizeof (*tmp
));
2438 if (bs
->commands
!= NULL
)
2439 tmp
->commands
= copy_command_lines (bs
->commands
);
2440 if (bs
->old_val
!= NULL
)
2442 tmp
->old_val
= value_copy (bs
->old_val
);
2443 release_value (tmp
->old_val
);
2447 /* This is the first thing in the chain. */
2457 /* Find the bpstat associated with this breakpoint */
2460 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
2465 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2467 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
2473 /* Find a step_resume breakpoint associated with this bpstat.
2474 (If there are multiple step_resume bp's on the list, this function
2475 will arbitrarily pick one.)
2477 It is an error to use this function if BPSTAT doesn't contain a
2478 step_resume breakpoint.
2480 See wait_for_inferior's use of this function. */
2482 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2486 gdb_assert (bsp
!= NULL
);
2488 current_thread
= pid_to_thread_id (inferior_ptid
);
2490 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2492 if ((bsp
->breakpoint_at
!= NULL
)
2493 && (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
)
2494 && (bsp
->breakpoint_at
->owner
->thread
== current_thread
2495 || bsp
->breakpoint_at
->owner
->thread
== -1))
2496 return bsp
->breakpoint_at
->owner
;
2499 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2503 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2504 at. *BSP upon return is a bpstat which points to the remaining
2505 breakpoints stopped at (but which is not guaranteed to be good for
2506 anything but further calls to bpstat_num).
2507 Return 0 if passed a bpstat which does not indicate any breakpoints.
2508 Return -1 if stopped at a breakpoint that has been deleted since
2510 Return 1 otherwise. */
2513 bpstat_num (bpstat
*bsp
, int *num
)
2515 struct breakpoint
*b
;
2518 return 0; /* No more breakpoint values */
2520 /* We assume we'll never have several bpstats that
2521 correspond to a single breakpoint -- otherwise,
2522 this function might return the same number more
2523 than once and this will look ugly. */
2524 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2525 *bsp
= (*bsp
)->next
;
2527 return -1; /* breakpoint that's been deleted since */
2529 *num
= b
->number
; /* We have its number */
2533 /* Modify BS so that the actions will not be performed. */
2536 bpstat_clear_actions (bpstat bs
)
2538 for (; bs
!= NULL
; bs
= bs
->next
)
2540 free_command_lines (&bs
->commands
);
2541 if (bs
->old_val
!= NULL
)
2543 value_free (bs
->old_val
);
2549 /* Called when a command is about to proceed the inferior. */
2552 breakpoint_about_to_proceed (void)
2554 if (!ptid_equal (inferior_ptid
, null_ptid
))
2556 struct thread_info
*tp
= inferior_thread ();
2558 /* Allow inferior function calls in breakpoint commands to not
2559 interrupt the command list. When the call finishes
2560 successfully, the inferior will be standing at the same
2561 breakpoint as if nothing happened. */
2566 breakpoint_proceeded
= 1;
2569 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2571 cleanup_executing_breakpoints (void *ignore
)
2573 executing_breakpoint_commands
= 0;
2576 /* Execute all the commands associated with all the breakpoints at this
2577 location. Any of these commands could cause the process to proceed
2578 beyond this point, etc. We look out for such changes by checking
2579 the global "breakpoint_proceeded" after each command.
2581 Returns true if a breakpoint command resumed the inferior. In that
2582 case, it is the caller's responsibility to recall it again with the
2583 bpstat of the current thread. */
2586 bpstat_do_actions_1 (bpstat
*bsp
)
2589 struct cleanup
*old_chain
;
2592 /* Avoid endless recursion if a `source' command is contained
2594 if (executing_breakpoint_commands
)
2597 executing_breakpoint_commands
= 1;
2598 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2600 /* This pointer will iterate over the list of bpstat's. */
2603 breakpoint_proceeded
= 0;
2604 for (; bs
!= NULL
; bs
= bs
->next
)
2606 struct command_line
*cmd
;
2607 struct cleanup
*this_cmd_tree_chain
;
2609 /* Take ownership of the BSP's command tree, if it has one.
2611 The command tree could legitimately contain commands like
2612 'step' and 'next', which call clear_proceed_status, which
2613 frees stop_bpstat's command tree. To make sure this doesn't
2614 free the tree we're executing out from under us, we need to
2615 take ownership of the tree ourselves. Since a given bpstat's
2616 commands are only executed once, we don't need to copy it; we
2617 can clear the pointer in the bpstat, and make sure we free
2618 the tree when we're done. */
2621 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2625 execute_control_command (cmd
);
2627 if (breakpoint_proceeded
)
2633 /* We can free this command tree now. */
2634 do_cleanups (this_cmd_tree_chain
);
2636 if (breakpoint_proceeded
)
2638 if (target_can_async_p ())
2639 /* If we are in async mode, then the target might be still
2640 running, not stopped at any breakpoint, so nothing for
2641 us to do here -- just return to the event loop. */
2644 /* In sync mode, when execute_control_command returns
2645 we're already standing on the next breakpoint.
2646 Breakpoint commands for that stop were not run, since
2647 execute_command does not run breakpoint commands --
2648 only command_line_handler does, but that one is not
2649 involved in execution of breakpoint commands. So, we
2650 can now execute breakpoint commands. It should be
2651 noted that making execute_command do bpstat actions is
2652 not an option -- in this case we'll have recursive
2653 invocation of bpstat for each breakpoint with a
2654 command, and can easily blow up GDB stack. Instead, we
2655 return true, which will trigger the caller to recall us
2656 with the new stop_bpstat. */
2661 do_cleanups (old_chain
);
2666 bpstat_do_actions (void)
2668 /* Do any commands attached to breakpoint we are stopped at. */
2669 while (!ptid_equal (inferior_ptid
, null_ptid
)
2670 && target_has_execution
2671 && !is_exited (inferior_ptid
)
2672 && !is_executing (inferior_ptid
))
2673 /* Since in sync mode, bpstat_do_actions may resume the inferior,
2674 and only return when it is stopped at the next breakpoint, we
2675 keep doing breakpoint actions until it returns false to
2676 indicate the inferior was not resumed. */
2677 if (!bpstat_do_actions_1 (&inferior_thread ()->stop_bpstat
))
2681 /* Print out the (old or new) value associated with a watchpoint. */
2684 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2687 fprintf_unfiltered (stream
, _("<unreadable>"));
2690 struct value_print_options opts
;
2691 get_user_print_options (&opts
);
2692 value_print (val
, stream
, &opts
);
2696 /* This is the normal print function for a bpstat. In the future,
2697 much of this logic could (should?) be moved to bpstat_stop_status,
2698 by having it set different print_it values.
2700 Current scheme: When we stop, bpstat_print() is called. It loops
2701 through the bpstat list of things causing this stop, calling the
2702 print_bp_stop_message function on each one. The behavior of the
2703 print_bp_stop_message function depends on the print_it field of
2704 bpstat. If such field so indicates, call this function here.
2706 Return values from this routine (ultimately used by bpstat_print()
2707 and normal_stop() to decide what to do):
2708 PRINT_NOTHING: Means we already printed all we needed to print,
2709 don't print anything else.
2710 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2711 that something to be followed by a location.
2712 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2713 that something to be followed by a location.
2714 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2717 static enum print_stop_action
2718 print_it_typical (bpstat bs
)
2720 struct cleanup
*old_chain
;
2721 struct breakpoint
*b
;
2722 const struct bp_location
*bl
;
2723 struct ui_stream
*stb
;
2725 enum print_stop_action result
;
2727 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2728 which has since been deleted. */
2729 if (bs
->breakpoint_at
== NULL
)
2730 return PRINT_UNKNOWN
;
2731 bl
= bs
->breakpoint_at
;
2734 stb
= ui_out_stream_new (uiout
);
2735 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2740 case bp_hardware_breakpoint
:
2741 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2742 if (bl
->address
!= bl
->requested_address
)
2743 breakpoint_adjustment_warning (bl
->requested_address
,
2746 annotate_breakpoint (b
->number
);
2748 ui_out_text (uiout
, "\nTemporary breakpoint ");
2750 ui_out_text (uiout
, "\nBreakpoint ");
2751 if (ui_out_is_mi_like_p (uiout
))
2753 ui_out_field_string (uiout
, "reason",
2754 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2755 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2757 ui_out_field_int (uiout
, "bkptno", b
->number
);
2758 ui_out_text (uiout
, ", ");
2759 result
= PRINT_SRC_AND_LOC
;
2762 case bp_shlib_event
:
2763 /* Did we stop because the user set the stop_on_solib_events
2764 variable? (If so, we report this as a generic, "Stopped due
2765 to shlib event" message.) */
2766 printf_filtered (_("Stopped due to shared library event\n"));
2767 result
= PRINT_NOTHING
;
2770 case bp_thread_event
:
2771 /* Not sure how we will get here.
2772 GDB should not stop for these breakpoints. */
2773 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2774 result
= PRINT_NOTHING
;
2777 case bp_overlay_event
:
2778 /* By analogy with the thread event, GDB should not stop for these. */
2779 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2780 result
= PRINT_NOTHING
;
2783 case bp_longjmp_master
:
2784 /* These should never be enabled. */
2785 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
2786 result
= PRINT_NOTHING
;
2790 case bp_hardware_watchpoint
:
2791 annotate_watchpoint (b
->number
);
2792 if (ui_out_is_mi_like_p (uiout
))
2795 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2797 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2798 ui_out_text (uiout
, "\nOld value = ");
2799 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2800 ui_out_field_stream (uiout
, "old", stb
);
2801 ui_out_text (uiout
, "\nNew value = ");
2802 watchpoint_value_print (b
->val
, stb
->stream
);
2803 ui_out_field_stream (uiout
, "new", stb
);
2804 ui_out_text (uiout
, "\n");
2805 /* More than one watchpoint may have been triggered. */
2806 result
= PRINT_UNKNOWN
;
2809 case bp_read_watchpoint
:
2810 if (ui_out_is_mi_like_p (uiout
))
2813 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2815 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2816 ui_out_text (uiout
, "\nValue = ");
2817 watchpoint_value_print (b
->val
, stb
->stream
);
2818 ui_out_field_stream (uiout
, "value", stb
);
2819 ui_out_text (uiout
, "\n");
2820 result
= PRINT_UNKNOWN
;
2823 case bp_access_watchpoint
:
2824 if (bs
->old_val
!= NULL
)
2826 annotate_watchpoint (b
->number
);
2827 if (ui_out_is_mi_like_p (uiout
))
2830 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2832 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2833 ui_out_text (uiout
, "\nOld value = ");
2834 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2835 ui_out_field_stream (uiout
, "old", stb
);
2836 ui_out_text (uiout
, "\nNew value = ");
2841 if (ui_out_is_mi_like_p (uiout
))
2844 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2845 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2846 ui_out_text (uiout
, "\nValue = ");
2848 watchpoint_value_print (b
->val
, stb
->stream
);
2849 ui_out_field_stream (uiout
, "new", stb
);
2850 ui_out_text (uiout
, "\n");
2851 result
= PRINT_UNKNOWN
;
2854 /* Fall through, we don't deal with these types of breakpoints
2858 if (ui_out_is_mi_like_p (uiout
))
2861 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2862 result
= PRINT_UNKNOWN
;
2866 if (ui_out_is_mi_like_p (uiout
))
2869 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2870 result
= PRINT_UNKNOWN
;
2875 case bp_longjmp_resume
:
2876 case bp_step_resume
:
2877 case bp_watchpoint_scope
:
2882 result
= PRINT_UNKNOWN
;
2886 do_cleanups (old_chain
);
2890 /* Generic routine for printing messages indicating why we
2891 stopped. The behavior of this function depends on the value
2892 'print_it' in the bpstat structure. Under some circumstances we
2893 may decide not to print anything here and delegate the task to
2896 static enum print_stop_action
2897 print_bp_stop_message (bpstat bs
)
2899 switch (bs
->print_it
)
2902 /* Nothing should be printed for this bpstat entry. */
2903 return PRINT_UNKNOWN
;
2907 /* We still want to print the frame, but we already printed the
2908 relevant messages. */
2909 return PRINT_SRC_AND_LOC
;
2912 case print_it_normal
:
2914 const struct bp_location
*bl
= bs
->breakpoint_at
;
2915 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2917 /* Normal case. Call the breakpoint's print_it method, or
2918 print_it_typical. */
2919 /* FIXME: how breakpoint can ever be NULL here? */
2920 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2921 return b
->ops
->print_it (b
);
2923 return print_it_typical (bs
);
2928 internal_error (__FILE__
, __LINE__
,
2929 _("print_bp_stop_message: unrecognized enum value"));
2934 /* Print a message indicating what happened. This is called from
2935 normal_stop(). The input to this routine is the head of the bpstat
2936 list - a list of the eventpoints that caused this stop. This
2937 routine calls the generic print routine for printing a message
2938 about reasons for stopping. This will print (for example) the
2939 "Breakpoint n," part of the output. The return value of this
2942 PRINT_UNKNOWN: Means we printed nothing
2943 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2944 code to print the location. An example is
2945 "Breakpoint 1, " which should be followed by
2947 PRINT_SRC_ONLY: Means we printed something, but there is no need
2948 to also print the location part of the message.
2949 An example is the catch/throw messages, which
2950 don't require a location appended to the end.
2951 PRINT_NOTHING: We have done some printing and we don't need any
2952 further info to be printed.*/
2954 enum print_stop_action
2955 bpstat_print (bpstat bs
)
2959 /* Maybe another breakpoint in the chain caused us to stop.
2960 (Currently all watchpoints go on the bpstat whether hit or not.
2961 That probably could (should) be changed, provided care is taken
2962 with respect to bpstat_explains_signal). */
2963 for (; bs
; bs
= bs
->next
)
2965 val
= print_bp_stop_message (bs
);
2966 if (val
== PRINT_SRC_ONLY
2967 || val
== PRINT_SRC_AND_LOC
2968 || val
== PRINT_NOTHING
)
2972 /* We reached the end of the chain, or we got a null BS to start
2973 with and nothing was printed. */
2974 return PRINT_UNKNOWN
;
2977 /* Evaluate the expression EXP and return 1 if value is zero.
2978 This is used inside a catch_errors to evaluate the breakpoint condition.
2979 The argument is a "struct expression *" that has been cast to char * to
2980 make it pass through catch_errors. */
2983 breakpoint_cond_eval (void *exp
)
2985 struct value
*mark
= value_mark ();
2986 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2987 value_free_to_mark (mark
);
2991 /* Allocate a new bpstat and chain it to the current one. */
2994 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2998 bs
= (bpstat
) xmalloc (sizeof (*bs
));
3000 bs
->breakpoint_at
= bl
;
3001 /* If the condition is false, etc., don't do the commands. */
3002 bs
->commands
= NULL
;
3004 bs
->print_it
= print_it_normal
;
3008 /* The target has stopped with waitstatus WS. Check if any hardware
3009 watchpoints have triggered, according to the target. */
3012 watchpoints_triggered (struct target_waitstatus
*ws
)
3014 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3016 struct breakpoint
*b
;
3018 if (!stopped_by_watchpoint
)
3020 /* We were not stopped by a watchpoint. Mark all watchpoints
3021 as not triggered. */
3023 if (b
->type
== bp_hardware_watchpoint
3024 || b
->type
== bp_read_watchpoint
3025 || b
->type
== bp_access_watchpoint
)
3026 b
->watchpoint_triggered
= watch_triggered_no
;
3031 if (!target_stopped_data_address (¤t_target
, &addr
))
3033 /* We were stopped by a watchpoint, but we don't know where.
3034 Mark all watchpoints as unknown. */
3036 if (b
->type
== bp_hardware_watchpoint
3037 || b
->type
== bp_read_watchpoint
3038 || b
->type
== bp_access_watchpoint
)
3039 b
->watchpoint_triggered
= watch_triggered_unknown
;
3041 return stopped_by_watchpoint
;
3044 /* The target could report the data address. Mark watchpoints
3045 affected by this data address as triggered, and all others as not
3049 if (b
->type
== bp_hardware_watchpoint
3050 || b
->type
== bp_read_watchpoint
3051 || b
->type
== bp_access_watchpoint
)
3053 struct bp_location
*loc
;
3056 b
->watchpoint_triggered
= watch_triggered_no
;
3057 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3058 /* Exact match not required. Within range is
3060 if (target_watchpoint_addr_within_range (¤t_target
,
3064 b
->watchpoint_triggered
= watch_triggered_yes
;
3072 /* Possible return values for watchpoint_check (this can't be an enum
3073 because of check_errors). */
3074 /* The watchpoint has been deleted. */
3075 #define WP_DELETED 1
3076 /* The value has changed. */
3077 #define WP_VALUE_CHANGED 2
3078 /* The value has not changed. */
3079 #define WP_VALUE_NOT_CHANGED 3
3081 #define BP_TEMPFLAG 1
3082 #define BP_HARDWAREFLAG 2
3084 /* Check watchpoint condition. */
3087 watchpoint_check (void *p
)
3089 bpstat bs
= (bpstat
) p
;
3090 struct breakpoint
*b
;
3091 struct frame_info
*fr
;
3092 int within_current_scope
;
3094 b
= bs
->breakpoint_at
->owner
;
3096 if (b
->exp_valid_block
== NULL
)
3097 within_current_scope
= 1;
3100 struct frame_info
*frame
= get_current_frame ();
3101 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3102 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3104 fr
= frame_find_by_id (b
->watchpoint_frame
);
3105 within_current_scope
= (fr
!= NULL
);
3107 /* If we've gotten confused in the unwinder, we might have
3108 returned a frame that can't describe this variable. */
3109 if (within_current_scope
)
3111 struct symbol
*function
;
3113 function
= get_frame_function (fr
);
3114 if (function
== NULL
3115 || !contained_in (b
->exp_valid_block
,
3116 SYMBOL_BLOCK_VALUE (function
)))
3117 within_current_scope
= 0;
3120 /* in_function_epilogue_p() returns a non-zero value if we're still
3121 in the function but the stack frame has already been invalidated.
3122 Since we can't rely on the values of local variables after the
3123 stack has been destroyed, we are treating the watchpoint in that
3124 state as `not changed' without further checking. Don't mark
3125 watchpoints as changed if the current frame is in an epilogue -
3126 even if they are in some other frame, our view of the stack
3127 is likely to be wrong. */
3128 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3129 return WP_VALUE_NOT_CHANGED
;
3131 if (within_current_scope
)
3132 /* If we end up stopping, the current frame will get selected
3133 in normal_stop. So this call to select_frame won't affect
3138 if (within_current_scope
)
3140 /* We use value_{,free_to_}mark because it could be a
3141 *long* time before we return to the command level and
3142 call free_all_values. We can't call free_all_values because
3143 we might be in the middle of evaluating a function call. */
3145 struct value
*mark
= value_mark ();
3146 struct value
*new_val
;
3148 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
3149 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3150 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
3152 if (new_val
!= NULL
)
3154 release_value (new_val
);
3155 value_free_to_mark (mark
);
3157 bs
->old_val
= b
->val
;
3160 /* We will stop here */
3161 return WP_VALUE_CHANGED
;
3165 /* Nothing changed, don't do anything. */
3166 value_free_to_mark (mark
);
3167 /* We won't stop here */
3168 return WP_VALUE_NOT_CHANGED
;
3173 /* This seems like the only logical thing to do because
3174 if we temporarily ignored the watchpoint, then when
3175 we reenter the block in which it is valid it contains
3176 garbage (in the case of a function, it may have two
3177 garbage values, one before and one after the prologue).
3178 So we can't even detect the first assignment to it and
3179 watch after that (since the garbage may or may not equal
3180 the first value assigned). */
3181 /* We print all the stop information in print_it_typical(), but
3182 in this case, by the time we call print_it_typical() this bp
3183 will be deleted already. So we have no choice but print the
3184 information here. */
3185 if (ui_out_is_mi_like_p (uiout
))
3187 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3188 ui_out_text (uiout
, "\nWatchpoint ");
3189 ui_out_field_int (uiout
, "wpnum", b
->number
);
3190 ui_out_text (uiout
, " deleted because the program has left the block in\n\
3191 which its expression is valid.\n");
3193 if (b
->related_breakpoint
)
3194 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3195 b
->disposition
= disp_del_at_next_stop
;
3201 /* Return true if it looks like target has stopped due to hitting
3202 breakpoint location BL. This function does not check if we
3203 should stop, only if BL explains the stop. */
3205 bpstat_check_location (const struct bp_location
*bl
,
3206 struct address_space
*aspace
, CORE_ADDR bp_addr
)
3208 struct breakpoint
*b
= bl
->owner
;
3210 if (b
->type
!= bp_watchpoint
3211 && b
->type
!= bp_hardware_watchpoint
3212 && b
->type
!= bp_read_watchpoint
3213 && b
->type
!= bp_access_watchpoint
3214 && b
->type
!= bp_hardware_breakpoint
3215 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
3217 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
3220 if (overlay_debugging
/* unmapped overlay section */
3221 && section_is_overlay (bl
->section
)
3222 && !section_is_mapped (bl
->section
))
3226 /* Continuable hardware watchpoints are treated as non-existent if the
3227 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3228 some data address). Otherwise gdb won't stop on a break instruction
3229 in the code (not from a breakpoint) when a hardware watchpoint has
3230 been defined. Also skip watchpoints which we know did not trigger
3231 (did not match the data address). */
3233 if ((b
->type
== bp_hardware_watchpoint
3234 || b
->type
== bp_read_watchpoint
3235 || b
->type
== bp_access_watchpoint
)
3236 && b
->watchpoint_triggered
== watch_triggered_no
)
3239 if (b
->type
== bp_hardware_breakpoint
)
3241 if (bl
->address
!= bp_addr
)
3243 if (overlay_debugging
/* unmapped overlay section */
3244 && section_is_overlay (bl
->section
)
3245 && !section_is_mapped (bl
->section
))
3249 if (b
->type
== bp_catchpoint
)
3251 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
3252 if (!b
->ops
->breakpoint_hit (b
))
3259 /* If BS refers to a watchpoint, determine if the watched values
3260 has actually changed, and we should stop. If not, set BS->stop
3263 bpstat_check_watchpoint (bpstat bs
)
3265 const struct bp_location
*bl
= bs
->breakpoint_at
;
3266 struct breakpoint
*b
= bl
->owner
;
3268 if (b
->type
== bp_watchpoint
3269 || b
->type
== bp_read_watchpoint
3270 || b
->type
== bp_access_watchpoint
3271 || b
->type
== bp_hardware_watchpoint
)
3275 int must_check_value
= 0;
3277 if (b
->type
== bp_watchpoint
)
3278 /* For a software watchpoint, we must always check the
3280 must_check_value
= 1;
3281 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3282 /* We have a hardware watchpoint (read, write, or access)
3283 and the target earlier reported an address watched by
3285 must_check_value
= 1;
3286 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3287 && b
->type
== bp_hardware_watchpoint
)
3288 /* We were stopped by a hardware watchpoint, but the target could
3289 not report the data address. We must check the watchpoint's
3290 value. Access and read watchpoints are out of luck; without
3291 a data address, we can't figure it out. */
3292 must_check_value
= 1;
3294 if (must_check_value
)
3296 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
3298 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3299 int e
= catch_errors (watchpoint_check
, bs
, message
,
3301 do_cleanups (cleanups
);
3305 /* We've already printed what needs to be printed. */
3306 bs
->print_it
= print_it_done
;
3309 case WP_VALUE_CHANGED
:
3310 if (b
->type
== bp_read_watchpoint
)
3312 /* Don't stop: read watchpoints shouldn't fire if
3313 the value has changed. This is for targets
3314 which cannot set read-only watchpoints. */
3315 bs
->print_it
= print_it_noop
;
3319 case WP_VALUE_NOT_CHANGED
:
3320 if (b
->type
== bp_hardware_watchpoint
3321 || b
->type
== bp_watchpoint
)
3323 /* Don't stop: write watchpoints shouldn't fire if
3324 the value hasn't changed. */
3325 bs
->print_it
= print_it_noop
;
3333 /* Error from catch_errors. */
3334 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
3335 if (b
->related_breakpoint
)
3336 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
3337 b
->disposition
= disp_del_at_next_stop
;
3338 /* We've already printed what needs to be printed. */
3339 bs
->print_it
= print_it_done
;
3343 else /* must_check_value == 0 */
3345 /* This is a case where some watchpoint(s) triggered, but
3346 not at the address of this watchpoint, or else no
3347 watchpoint triggered after all. So don't print
3348 anything for this watchpoint. */
3349 bs
->print_it
= print_it_noop
;
3356 /* Check conditions (condition proper, frame, thread and ignore count)
3357 of breakpoint referred to by BS. If we should not stop for this
3358 breakpoint, set BS->stop to 0. */
3360 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
3362 int thread_id
= pid_to_thread_id (ptid
);
3363 const struct bp_location
*bl
= bs
->breakpoint_at
;
3364 struct breakpoint
*b
= bl
->owner
;
3366 if (frame_id_p (b
->frame_id
)
3367 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
3371 int value_is_zero
= 0;
3373 /* If this is a scope breakpoint, mark the associated
3374 watchpoint as triggered so that we will handle the
3375 out-of-scope event. We'll get to the watchpoint next
3377 if (b
->type
== bp_watchpoint_scope
)
3378 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
3380 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
3382 /* We use value_mark and value_free_to_mark because it could
3383 be a long time before we return to the command level and
3384 call free_all_values. We can't call free_all_values
3385 because we might be in the middle of evaluating a
3387 struct value
*mark
= value_mark ();
3389 /* Need to select the frame, with all that implies so that
3390 the conditions will have the right context. Because we
3391 use the frame, we will not see an inlined function's
3392 variables when we arrive at a breakpoint at the start
3393 of the inlined function; the current frame will be the
3395 select_frame (get_current_frame ());
3397 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
3398 "Error in testing breakpoint condition:\n",
3400 /* FIXME-someday, should give breakpoint # */
3401 value_free_to_mark (mark
);
3403 if (bl
->cond
&& value_is_zero
)
3407 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
3411 else if (b
->ignore_count
> 0)
3414 annotate_ignore_count_change ();
3416 /* Increase the hit count even though we don't
3424 /* Get a bpstat associated with having just stopped at address
3425 BP_ADDR in thread PTID.
3427 Determine whether we stopped at a breakpoint, etc, or whether we
3428 don't understand this stop. Result is a chain of bpstat's such that:
3430 if we don't understand the stop, the result is a null pointer.
3432 if we understand why we stopped, the result is not null.
3434 Each element of the chain refers to a particular breakpoint or
3435 watchpoint at which we have stopped. (We may have stopped for
3436 several reasons concurrently.)
3438 Each element of the chain has valid next, breakpoint_at,
3439 commands, FIXME??? fields. */
3442 bpstat_stop_status (struct address_space
*aspace
,
3443 CORE_ADDR bp_addr
, ptid_t ptid
)
3445 struct breakpoint
*b
= NULL
;
3446 struct bp_location
*bl
, **blp_tmp
;
3447 struct bp_location
*loc
;
3448 /* Root of the chain of bpstat's */
3449 struct bpstats root_bs
[1];
3450 /* Pointer to the last thing in the chain currently. */
3451 bpstat bs
= root_bs
;
3453 int need_remove_insert
, update_locations
= 0;
3455 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3459 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
3462 /* For hardware watchpoints, we look only at the first location.
3463 The watchpoint_check function will work on entire expression,
3464 not the individual locations. For read watchopints, the
3465 watchpoints_triggered function have checked all locations
3467 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
3470 if (!bpstat_check_location (bl
, aspace
, bp_addr
))
3473 /* Come here if it's a watchpoint, or if the break address matches */
3475 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
3477 /* Assume we stop. Should we find watchpoint that is not actually
3478 triggered, or if condition of breakpoint is false, we'll reset
3483 bpstat_check_watchpoint (bs
);
3487 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3488 || b
->type
== bp_longjmp_master
)
3489 /* We do not stop for these. */
3492 bpstat_check_breakpoint_conditions (bs
, ptid
);
3496 if (b
->enable_state
!= bp_disabled
)
3499 /* We will stop here */
3500 if (b
->disposition
== disp_disable
)
3502 if (b
->enable_state
!= bp_permanent
)
3503 b
->enable_state
= bp_disabled
;
3504 update_locations
= 1;
3508 bs
->commands
= b
->commands
;
3510 && (strcmp ("silent", bs
->commands
->line
) == 0
3511 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
3513 bs
->commands
= bs
->commands
->next
;
3516 bs
->commands
= copy_command_lines (bs
->commands
);
3519 /* Print nothing for this entry if we dont stop or if we dont print. */
3520 if (bs
->stop
== 0 || bs
->print
== 0)
3521 bs
->print_it
= print_it_noop
;
3524 /* Delay this call which would break the ALL_BP_LOCATIONS iteration above. */
3525 if (update_locations
)
3526 update_global_location_list (0);
3528 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
3530 if (breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
3533 bs
= bpstat_alloc (loc
, bs
);
3534 /* For hits of moribund locations, we should just proceed. */
3537 bs
->print_it
= print_it_noop
;
3541 bs
->next
= NULL
; /* Terminate the chain */
3542 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3544 /* If we aren't stopping, the value of some hardware watchpoint may
3545 not have changed, but the intermediate memory locations we are
3546 watching may have. Don't bother if we're stopping; this will get
3548 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3552 need_remove_insert
= 0;
3554 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3556 && bs
->breakpoint_at
->owner
3557 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3558 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3559 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3561 /* remove/insert can invalidate bs->breakpoint_at, if this
3562 location is no longer used by the watchpoint. Prevent
3563 further code from trying to use it. */
3564 bs
->breakpoint_at
= NULL
;
3565 need_remove_insert
= 1;
3568 if (need_remove_insert
)
3570 remove_breakpoints ();
3571 insert_breakpoints ();
3574 return root_bs
->next
;
3577 /* Tell what to do about this bpstat. */
3579 bpstat_what (bpstat bs
)
3581 /* Classify each bpstat as one of the following. */
3584 /* This bpstat element has no effect on the main_action. */
3587 /* There was a watchpoint, stop but don't print. */
3590 /* There was a watchpoint, stop and print. */
3593 /* There was a breakpoint but we're not stopping. */
3596 /* There was a breakpoint, stop but don't print. */
3599 /* There was a breakpoint, stop and print. */
3602 /* We hit the longjmp breakpoint. */
3605 /* We hit the longjmp_resume breakpoint. */
3608 /* We hit the step_resume breakpoint. */
3611 /* We hit the shared library event breakpoint. */
3614 /* We hit the jit event breakpoint. */
3617 /* This is just used to count how many enums there are. */
3621 /* Here is the table which drives this routine. So that we can
3622 format it pretty, we define some abbreviations for the
3623 enum bpstat_what codes. */
3624 #define kc BPSTAT_WHAT_KEEP_CHECKING
3625 #define ss BPSTAT_WHAT_STOP_SILENT
3626 #define sn BPSTAT_WHAT_STOP_NOISY
3627 #define sgl BPSTAT_WHAT_SINGLE
3628 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3629 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3630 #define sr BPSTAT_WHAT_STEP_RESUME
3631 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3632 #define jit BPSTAT_WHAT_CHECK_JIT
3634 /* "Can't happen." Might want to print an error message.
3635 abort() is not out of the question, but chances are GDB is just
3636 a bit confused, not unusable. */
3637 #define err BPSTAT_WHAT_STOP_NOISY
3639 /* Given an old action and a class, come up with a new action. */
3640 /* One interesting property of this table is that wp_silent is the same
3641 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3642 after stopping, the check for whether to step over a breakpoint
3643 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3644 reference to how we stopped. We retain separate wp_silent and
3645 bp_silent codes in case we want to change that someday.
3647 Another possibly interesting property of this table is that
3648 there's a partial ordering, priority-like, of the actions. Once
3649 you've decided that some action is appropriate, you'll never go
3650 back and decide something of a lower priority is better. The
3653 kc < jit clr sgl shl slr sn sr ss
3654 sgl < jit shl slr sn sr ss
3655 slr < jit err shl sn sr ss
3656 clr < jit err shl sn sr ss
3663 What I think this means is that we don't need a damned table
3664 here. If you just put the rows and columns in the right order,
3665 it'd look awfully regular. We could simply walk the bpstat list
3666 and choose the highest priority action we find, with a little
3667 logic to handle the 'err' cases. */
3669 /* step_resume entries: a step resume breakpoint overrides another
3670 breakpoint of signal handling (see comment in wait_for_inferior
3671 at where we set the step_resume breakpoint). */
3673 static const enum bpstat_what_main_action
3674 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3677 /* kc ss sn sgl slr clr sr shl jit */
3678 /* no_effect */ {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
, jit
},
3679 /* wp_silent */ {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, jit
},
3680 /* wp_noisy */ {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, jit
},
3681 /* bp_nostop */ {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
, jit
},
3682 /* bp_silent */ {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
, jit
},
3683 /* bp_noisy */ {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
, jit
},
3684 /* long_jump */ {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
, jit
},
3685 /* long_resume */ {clr
, ss
, sn
, err
, err
, err
, sr
, shl
, jit
},
3686 /* step_resume */ {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3687 /* shlib */ {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
, shl
},
3688 /* jit_event */ {jit
, jit
, jit
, jit
, jit
, jit
, sr
, jit
, jit
}
3702 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3703 struct bpstat_what retval
;
3705 retval
.call_dummy
= 0;
3706 for (; bs
!= NULL
; bs
= bs
->next
)
3708 enum class bs_class
= no_effect
;
3709 if (bs
->breakpoint_at
== NULL
)
3710 /* I suspect this can happen if it was a momentary breakpoint
3711 which has since been deleted. */
3713 if (bs
->breakpoint_at
->owner
== NULL
)
3714 bs_class
= bp_nostop
;
3716 switch (bs
->breakpoint_at
->owner
->type
)
3722 case bp_hardware_breakpoint
:
3728 bs_class
= bp_noisy
;
3730 bs_class
= bp_silent
;
3733 bs_class
= bp_nostop
;
3736 case bp_hardware_watchpoint
:
3737 case bp_read_watchpoint
:
3738 case bp_access_watchpoint
:
3742 bs_class
= wp_noisy
;
3744 bs_class
= wp_silent
;
3747 /* There was a watchpoint, but we're not stopping.
3748 This requires no further action. */
3749 bs_class
= no_effect
;
3752 bs_class
= long_jump
;
3754 case bp_longjmp_resume
:
3755 bs_class
= long_resume
;
3757 case bp_step_resume
:
3760 bs_class
= step_resume
;
3763 /* It is for the wrong frame. */
3764 bs_class
= bp_nostop
;
3766 case bp_watchpoint_scope
:
3767 bs_class
= bp_nostop
;
3769 case bp_shlib_event
:
3770 bs_class
= shlib_event
;
3773 bs_class
= jit_event
;
3775 case bp_thread_event
:
3776 case bp_overlay_event
:
3777 case bp_longjmp_master
:
3778 bs_class
= bp_nostop
;
3784 bs_class
= bp_noisy
;
3786 bs_class
= bp_silent
;
3789 /* There was a catchpoint, but we're not stopping.
3790 This requires no further action. */
3791 bs_class
= no_effect
;
3794 /* Make sure the action is stop (silent or noisy),
3795 so infrun.c pops the dummy frame. */
3796 bs_class
= bp_silent
;
3797 retval
.call_dummy
= 1;
3800 /* Tracepoint hits should not be reported back to GDB, and
3801 if one got through somehow, it should have been filtered
3803 internal_error (__FILE__
, __LINE__
,
3804 _("bpstat_what: bp_tracepoint encountered"));
3807 current_action
= table
[(int) bs_class
][(int) current_action
];
3809 retval
.main_action
= current_action
;
3813 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3814 without hardware support). This isn't related to a specific bpstat,
3815 just to things like whether watchpoints are set. */
3818 bpstat_should_step (void)
3820 struct breakpoint
*b
;
3822 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
3829 static void print_breakpoint_location (struct breakpoint
*b
,
3830 struct bp_location
*loc
,
3832 struct ui_stream
*stb
)
3834 struct cleanup
*old_chain
= save_current_program_space ();
3837 set_current_program_space (loc
->pspace
);
3842 = find_pc_sect_function (loc
->address
, loc
->section
);
3845 ui_out_text (uiout
, "in ");
3846 ui_out_field_string (uiout
, "func",
3847 SYMBOL_PRINT_NAME (sym
));
3848 ui_out_wrap_hint (uiout
, wrap_indent
);
3849 ui_out_text (uiout
, " at ");
3851 ui_out_field_string (uiout
, "file", b
->source_file
);
3852 ui_out_text (uiout
, ":");
3854 if (ui_out_is_mi_like_p (uiout
))
3856 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3857 char *fullname
= symtab_to_fullname (sal
.symtab
);
3860 ui_out_field_string (uiout
, "fullname", fullname
);
3863 ui_out_field_int (uiout
, "line", b
->line_number
);
3867 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3871 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3872 ui_out_field_stream (uiout
, "at", stb
);
3875 do_cleanups (old_chain
);
3878 /* Print B to gdb_stdout. */
3880 print_one_breakpoint_location (struct breakpoint
*b
,
3881 struct bp_location
*loc
,
3883 struct bp_location
**last_loc
,
3884 int print_address_bits
,
3887 struct command_line
*l
;
3889 struct ep_type_description
3894 static struct ep_type_description bptypes
[] =
3896 {bp_none
, "?deleted?"},
3897 {bp_breakpoint
, "breakpoint"},
3898 {bp_hardware_breakpoint
, "hw breakpoint"},
3899 {bp_until
, "until"},
3900 {bp_finish
, "finish"},
3901 {bp_watchpoint
, "watchpoint"},
3902 {bp_hardware_watchpoint
, "hw watchpoint"},
3903 {bp_read_watchpoint
, "read watchpoint"},
3904 {bp_access_watchpoint
, "acc watchpoint"},
3905 {bp_longjmp
, "longjmp"},
3906 {bp_longjmp_resume
, "longjmp resume"},
3907 {bp_step_resume
, "step resume"},
3908 {bp_watchpoint_scope
, "watchpoint scope"},
3909 {bp_call_dummy
, "call dummy"},
3910 {bp_shlib_event
, "shlib events"},
3911 {bp_thread_event
, "thread events"},
3912 {bp_overlay_event
, "overlay events"},
3913 {bp_longjmp_master
, "longjmp master"},
3914 {bp_catchpoint
, "catchpoint"},
3915 {bp_tracepoint
, "tracepoint"},
3916 {bp_jit_event
, "jit events"},
3919 static char bpenables
[] = "nynny";
3920 char wrap_indent
[80];
3921 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3922 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3923 struct cleanup
*bkpt_chain
;
3925 int header_of_multiple
= 0;
3926 int part_of_multiple
= (loc
!= NULL
);
3927 struct value_print_options opts
;
3929 get_user_print_options (&opts
);
3931 gdb_assert (!loc
|| loc_number
!= 0);
3932 /* See comment in print_one_breakpoint concerning
3933 treatment of breakpoints with single disabled
3937 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3938 header_of_multiple
= 1;
3943 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3947 if (part_of_multiple
)
3950 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3951 ui_out_field_string (uiout
, "number", formatted
);
3956 ui_out_field_int (uiout
, "number", b
->number
);
3961 if (part_of_multiple
)
3962 ui_out_field_skip (uiout
, "type");
3965 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3966 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3967 internal_error (__FILE__
, __LINE__
,
3968 _("bptypes table does not describe type #%d."),
3970 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3975 if (part_of_multiple
)
3976 ui_out_field_skip (uiout
, "disp");
3978 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3983 if (part_of_multiple
)
3984 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3986 ui_out_field_fmt (uiout
, "enabled", "%c",
3987 bpenables
[(int) b
->enable_state
]);
3988 ui_out_spaces (uiout
, 2);
3992 strcpy (wrap_indent
, " ");
3993 if (opts
.addressprint
)
3995 if (print_address_bits
<= 32)
3996 strcat (wrap_indent
, " ");
3998 strcat (wrap_indent
, " ");
4001 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4003 /* Although the print_one can possibly print
4004 all locations, calling it here is not likely
4005 to get any nice result. So, make sure there's
4006 just one location. */
4007 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4008 b
->ops
->print_one (b
, last_loc
);
4014 internal_error (__FILE__
, __LINE__
,
4015 _("print_one_breakpoint: bp_none encountered\n"));
4019 case bp_hardware_watchpoint
:
4020 case bp_read_watchpoint
:
4021 case bp_access_watchpoint
:
4022 /* Field 4, the address, is omitted (which makes the columns
4023 not line up too nicely with the headers, but the effect
4024 is relatively readable). */
4025 if (opts
.addressprint
)
4026 ui_out_field_skip (uiout
, "addr");
4028 ui_out_field_string (uiout
, "what", b
->exp_string
);
4032 case bp_hardware_breakpoint
:
4036 case bp_longjmp_resume
:
4037 case bp_step_resume
:
4038 case bp_watchpoint_scope
:
4040 case bp_shlib_event
:
4041 case bp_thread_event
:
4042 case bp_overlay_event
:
4043 case bp_longjmp_master
:
4046 if (opts
.addressprint
)
4049 if (header_of_multiple
)
4050 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4051 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4052 ui_out_field_string (uiout
, "addr", "<PENDING>");
4054 ui_out_field_core_addr (uiout
, "addr",
4055 loc
->gdbarch
, loc
->address
);
4058 if (!header_of_multiple
)
4059 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
4066 /* For backward compatibility, don't display inferiors unless there
4069 && !header_of_multiple
4071 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4072 && (number_of_program_spaces () > 1
4073 || number_of_inferiors () > 1)
4074 && loc
->owner
->type
!= bp_catchpoint
)))
4076 struct inferior
*inf
;
4079 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4081 if (inf
->pspace
== loc
->pspace
)
4086 ui_out_text (uiout
, " inf ");
4089 ui_out_text (uiout
, ", ");
4090 ui_out_text (uiout
, plongest (inf
->num
));
4095 if (!part_of_multiple
)
4097 if (b
->thread
!= -1)
4099 /* FIXME: This seems to be redundant and lost here; see the
4100 "stop only in" line a little further down. */
4101 ui_out_text (uiout
, " thread ");
4102 ui_out_field_int (uiout
, "thread", b
->thread
);
4104 else if (b
->task
!= 0)
4106 ui_out_text (uiout
, " task ");
4107 ui_out_field_int (uiout
, "task", b
->task
);
4111 ui_out_text (uiout
, "\n");
4113 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4116 ui_out_text (uiout
, "\tstop only in stack frame at ");
4117 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4119 ui_out_field_core_addr (uiout
, "frame",
4120 b
->gdbarch
, b
->frame_id
.stack_addr
);
4121 ui_out_text (uiout
, "\n");
4124 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
4126 /* We do not print the condition for Ada exception catchpoints
4127 because the condition is an internal implementation detail
4128 that we do not want to expose to the user. */
4130 if (b
->type
== bp_tracepoint
)
4131 ui_out_text (uiout
, "\ttrace only if ");
4133 ui_out_text (uiout
, "\tstop only if ");
4134 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4135 ui_out_text (uiout
, "\n");
4138 if (!part_of_multiple
&& b
->thread
!= -1)
4140 /* FIXME should make an annotation for this */
4141 ui_out_text (uiout
, "\tstop only in thread ");
4142 ui_out_field_int (uiout
, "thread", b
->thread
);
4143 ui_out_text (uiout
, "\n");
4146 if (!part_of_multiple
&& b
->hit_count
)
4148 /* FIXME should make an annotation for this */
4149 if (ep_is_catchpoint (b
))
4150 ui_out_text (uiout
, "\tcatchpoint");
4152 ui_out_text (uiout
, "\tbreakpoint");
4153 ui_out_text (uiout
, " already hit ");
4154 ui_out_field_int (uiout
, "times", b
->hit_count
);
4155 if (b
->hit_count
== 1)
4156 ui_out_text (uiout
, " time\n");
4158 ui_out_text (uiout
, " times\n");
4161 /* Output the count also if it is zero, but only if this is
4162 mi. FIXME: Should have a better test for this. */
4163 if (ui_out_is_mi_like_p (uiout
))
4164 if (!part_of_multiple
&& b
->hit_count
== 0)
4165 ui_out_field_int (uiout
, "times", b
->hit_count
);
4167 if (!part_of_multiple
&& b
->ignore_count
)
4170 ui_out_text (uiout
, "\tignore next ");
4171 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
4172 ui_out_text (uiout
, " hits\n");
4176 if (!part_of_multiple
&& l
)
4178 struct cleanup
*script_chain
;
4181 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
4182 print_command_lines (uiout
, l
, 4);
4183 do_cleanups (script_chain
);
4186 if (!part_of_multiple
&& b
->pass_count
)
4188 annotate_field (10);
4189 ui_out_text (uiout
, "\tpass count ");
4190 ui_out_field_int (uiout
, "pass", b
->pass_count
);
4191 ui_out_text (uiout
, " \n");
4194 if (!part_of_multiple
&& b
->step_count
)
4196 annotate_field (11);
4197 ui_out_text (uiout
, "\tstep count ");
4198 ui_out_field_int (uiout
, "step", b
->step_count
);
4199 ui_out_text (uiout
, " \n");
4202 if (!part_of_multiple
&& b
->actions
)
4204 struct action_line
*action
;
4205 annotate_field (12);
4206 for (action
= b
->actions
; action
; action
= action
->next
)
4208 ui_out_text (uiout
, " A\t");
4209 ui_out_text (uiout
, action
->action
);
4210 ui_out_text (uiout
, "\n");
4214 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
4217 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
4218 else if (b
->exp_string
)
4219 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
4222 do_cleanups (bkpt_chain
);
4223 do_cleanups (old_chain
);
4227 print_one_breakpoint (struct breakpoint
*b
,
4228 struct bp_location
**last_loc
, int print_address_bits
,
4231 print_one_breakpoint_location (b
, NULL
, 0, last_loc
,
4232 print_address_bits
, allflag
);
4234 /* If this breakpoint has custom print function,
4235 it's already printed. Otherwise, print individual
4236 locations, if any. */
4237 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
4239 /* If breakpoint has a single location that is
4240 disabled, we print it as if it had
4241 several locations, since otherwise it's hard to
4242 represent "breakpoint enabled, location disabled"
4244 Note that while hardware watchpoints have
4245 several locations internally, that's no a property
4248 && !is_hardware_watchpoint (b
)
4249 && (b
->loc
->next
|| !b
->loc
->enabled
)
4250 && !ui_out_is_mi_like_p (uiout
))
4252 struct bp_location
*loc
;
4254 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
4255 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
4256 print_address_bits
, allflag
);
4262 breakpoint_address_bits (struct breakpoint
*b
)
4264 int print_address_bits
= 0;
4265 struct bp_location
*loc
;
4267 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4269 int addr_bit
= gdbarch_addr_bit (b
->gdbarch
);
4270 if (addr_bit
> print_address_bits
)
4271 print_address_bits
= addr_bit
;
4274 return print_address_bits
;
4277 struct captured_breakpoint_query_args
4283 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
4285 struct captured_breakpoint_query_args
*args
= data
;
4286 struct breakpoint
*b
;
4287 struct bp_location
*dummy_loc
= NULL
;
4290 if (args
->bnum
== b
->number
)
4292 int print_address_bits
= breakpoint_address_bits (b
);
4293 print_one_breakpoint (b
, &dummy_loc
, print_address_bits
, 0);
4301 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
4303 struct captured_breakpoint_query_args args
;
4305 /* For the moment we don't trust print_one_breakpoint() to not throw
4307 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
4308 error_message
, RETURN_MASK_ALL
) < 0)
4314 /* Return non-zero if B is user settable (breakpoints, watchpoints,
4315 catchpoints, et.al.). */
4318 user_settable_breakpoint (const struct breakpoint
*b
)
4320 return (b
->type
== bp_breakpoint
4321 || b
->type
== bp_catchpoint
4322 || b
->type
== bp_hardware_breakpoint
4323 || b
->type
== bp_tracepoint
4324 || b
->type
== bp_watchpoint
4325 || b
->type
== bp_read_watchpoint
4326 || b
->type
== bp_access_watchpoint
4327 || b
->type
== bp_hardware_watchpoint
);
4330 /* Print information on user settable breakpoint (watchpoint, etc)
4331 number BNUM. If BNUM is -1 print all user settable breakpoints.
4332 If ALLFLAG is non-zero, include non- user settable breakpoints. */
4335 breakpoint_1 (int bnum
, int allflag
)
4337 struct breakpoint
*b
;
4338 struct bp_location
*last_loc
= NULL
;
4339 int nr_printable_breakpoints
;
4340 struct cleanup
*bkpttbl_chain
;
4341 struct value_print_options opts
;
4342 int print_address_bits
= 0;
4344 get_user_print_options (&opts
);
4346 /* Compute the number of rows in the table, as well as the
4347 size required for address fields. */
4348 nr_printable_breakpoints
= 0;
4351 || bnum
== b
->number
)
4353 if (allflag
|| user_settable_breakpoint (b
))
4355 int addr_bit
= breakpoint_address_bits (b
);
4356 if (addr_bit
> print_address_bits
)
4357 print_address_bits
= addr_bit
;
4359 nr_printable_breakpoints
++;
4363 if (opts
.addressprint
)
4365 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
4369 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
4372 if (nr_printable_breakpoints
> 0)
4373 annotate_breakpoints_headers ();
4374 if (nr_printable_breakpoints
> 0)
4376 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
4377 if (nr_printable_breakpoints
> 0)
4379 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
4380 if (nr_printable_breakpoints
> 0)
4382 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
4383 if (nr_printable_breakpoints
> 0)
4385 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
4386 if (opts
.addressprint
)
4388 if (nr_printable_breakpoints
> 0)
4390 if (print_address_bits
<= 32)
4391 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
4393 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
4395 if (nr_printable_breakpoints
> 0)
4397 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
4398 ui_out_table_body (uiout
);
4399 if (nr_printable_breakpoints
> 0)
4400 annotate_breakpoints_table ();
4404 || bnum
== b
->number
)
4406 /* We only print out user settable breakpoints unless the
4408 if (allflag
|| user_settable_breakpoint (b
))
4409 print_one_breakpoint (b
, &last_loc
, print_address_bits
, allflag
);
4412 do_cleanups (bkpttbl_chain
);
4414 if (nr_printable_breakpoints
== 0)
4417 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
4419 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
4424 if (last_loc
&& !server_command
)
4425 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
4428 /* FIXME? Should this be moved up so that it is only called when
4429 there have been breakpoints? */
4430 annotate_breakpoints_table_end ();
4434 breakpoints_info (char *bnum_exp
, int from_tty
)
4439 bnum
= parse_and_eval_long (bnum_exp
);
4441 breakpoint_1 (bnum
, 0);
4445 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
4450 bnum
= parse_and_eval_long (bnum_exp
);
4452 breakpoint_1 (bnum
, 1);
4456 breakpoint_has_pc (struct breakpoint
*b
,
4457 struct program_space
*pspace
,
4458 CORE_ADDR pc
, struct obj_section
*section
)
4460 struct bp_location
*bl
= b
->loc
;
4461 for (; bl
; bl
= bl
->next
)
4463 if (bl
->pspace
== pspace
4464 && bl
->address
== pc
4465 && (!overlay_debugging
|| bl
->section
== section
))
4471 /* Print a message describing any breakpoints set at PC. This
4472 concerns with logical breakpoints, so we match program spaces, not
4476 describe_other_breakpoints (struct gdbarch
*gdbarch
,
4477 struct program_space
*pspace
, CORE_ADDR pc
,
4478 struct obj_section
*section
, int thread
)
4481 struct breakpoint
*b
;
4484 others
+= breakpoint_has_pc (b
, pspace
, pc
, section
);
4488 printf_filtered (_("Note: breakpoint "));
4489 else /* if (others == ???) */
4490 printf_filtered (_("Note: breakpoints "));
4492 if (breakpoint_has_pc (b
, pspace
, pc
, section
))
4495 printf_filtered ("%d", b
->number
);
4496 if (b
->thread
== -1 && thread
!= -1)
4497 printf_filtered (" (all threads)");
4498 else if (b
->thread
!= -1)
4499 printf_filtered (" (thread %d)", b
->thread
);
4500 printf_filtered ("%s%s ",
4501 ((b
->enable_state
== bp_disabled
4502 || b
->enable_state
== bp_call_disabled
4503 || b
->enable_state
== bp_startup_disabled
)
4505 : b
->enable_state
== bp_permanent
4509 : ((others
== 1) ? " and" : ""));
4511 printf_filtered (_("also set at pc "));
4512 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
4513 printf_filtered (".\n");
4517 /* Set the default place to put a breakpoint
4518 for the `break' command with no arguments. */
4521 set_default_breakpoint (int valid
, struct program_space
*pspace
,
4522 CORE_ADDR addr
, struct symtab
*symtab
,
4525 default_breakpoint_valid
= valid
;
4526 default_breakpoint_pspace
= pspace
;
4527 default_breakpoint_address
= addr
;
4528 default_breakpoint_symtab
= symtab
;
4529 default_breakpoint_line
= line
;
4532 /* Return true iff it is meaningful to use the address member of
4533 BPT. For some breakpoint types, the address member is irrelevant
4534 and it makes no sense to attempt to compare it to other addresses
4535 (or use it for any other purpose either).
4537 More specifically, each of the following breakpoint types will always
4538 have a zero valued address and we don't want to mark breakpoints of any of
4539 these types to be a duplicate of an actual breakpoint at address zero:
4542 bp_hardware_watchpoint
4544 bp_access_watchpoint
4548 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
4550 enum bptype type
= bpt
->type
;
4552 return (type
!= bp_watchpoint
4553 && type
!= bp_hardware_watchpoint
4554 && type
!= bp_read_watchpoint
4555 && type
!= bp_access_watchpoint
4556 && type
!= bp_catchpoint
);
4559 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
4560 same breakpoint location. In most targets, this can only be true
4561 if ASPACE1 matches ASPACE2. On targets that have global
4562 breakpoints, the address space doesn't really matter. */
4565 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
4566 struct address_space
*aspace2
, CORE_ADDR addr2
)
4568 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
4569 || aspace1
== aspace2
)
4574 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
4575 int bnum
, int have_bnum
)
4580 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
4581 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
4583 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
4584 bnum
, astr1
, astr2
);
4586 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
4589 /* Adjust a breakpoint's address to account for architectural constraints
4590 on breakpoint placement. Return the adjusted address. Note: Very
4591 few targets require this kind of adjustment. For most targets,
4592 this function is simply the identity function. */
4595 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
4596 CORE_ADDR bpaddr
, enum bptype bptype
)
4598 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
4600 /* Very few targets need any kind of breakpoint adjustment. */
4603 else if (bptype
== bp_watchpoint
4604 || bptype
== bp_hardware_watchpoint
4605 || bptype
== bp_read_watchpoint
4606 || bptype
== bp_access_watchpoint
4607 || bptype
== bp_catchpoint
)
4609 /* Watchpoints and the various bp_catch_* eventpoints should not
4610 have their addresses modified. */
4615 CORE_ADDR adjusted_bpaddr
;
4617 /* Some targets have architectural constraints on the placement
4618 of breakpoint instructions. Obtain the adjusted address. */
4619 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
4621 /* An adjusted breakpoint address can significantly alter
4622 a user's expectations. Print a warning if an adjustment
4624 if (adjusted_bpaddr
!= bpaddr
)
4625 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4627 return adjusted_bpaddr
;
4631 /* Allocate a struct bp_location. */
4633 static struct bp_location
*
4634 allocate_bp_location (struct breakpoint
*bpt
)
4636 struct bp_location
*loc
, *loc_p
;
4638 loc
= xmalloc (sizeof (struct bp_location
));
4639 memset (loc
, 0, sizeof (*loc
));
4643 loc
->shlib_disabled
= 0;
4653 case bp_longjmp_resume
:
4654 case bp_step_resume
:
4655 case bp_watchpoint_scope
:
4657 case bp_shlib_event
:
4658 case bp_thread_event
:
4659 case bp_overlay_event
:
4661 case bp_longjmp_master
:
4662 loc
->loc_type
= bp_loc_software_breakpoint
;
4664 case bp_hardware_breakpoint
:
4665 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4667 case bp_hardware_watchpoint
:
4668 case bp_read_watchpoint
:
4669 case bp_access_watchpoint
:
4670 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4674 loc
->loc_type
= bp_loc_other
;
4677 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4683 static void free_bp_location (struct bp_location
*loc
)
4688 if (loc
->function_name
)
4689 xfree (loc
->function_name
);
4694 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4695 that has type BPTYPE and has no locations as yet. */
4696 /* This function is used in gdbtk sources and thus can not be made static. */
4698 static struct breakpoint
*
4699 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
4702 struct breakpoint
*b
, *b1
;
4704 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4705 memset (b
, 0, sizeof (*b
));
4708 b
->gdbarch
= gdbarch
;
4709 b
->language
= current_language
->la_language
;
4710 b
->input_radix
= input_radix
;
4712 b
->enable_state
= bp_enabled
;
4715 b
->ignore_count
= 0;
4717 b
->frame_id
= null_frame_id
;
4718 b
->forked_inferior_pid
= null_ptid
;
4719 b
->exec_pathname
= NULL
;
4720 b
->syscalls_to_be_caught
= NULL
;
4722 b
->condition_not_parsed
= 0;
4724 /* Add this breakpoint to the end of the chain
4725 so that a list of breakpoints will come out in order
4726 of increasing numbers. */
4728 b1
= breakpoint_chain
;
4730 breakpoint_chain
= b
;
4740 /* Initialize loc->function_name. */
4742 set_breakpoint_location_function (struct bp_location
*loc
)
4744 if (loc
->owner
->type
== bp_breakpoint
4745 || loc
->owner
->type
== bp_hardware_breakpoint
4746 || loc
->owner
->type
== bp_tracepoint
)
4748 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4750 if (loc
->function_name
)
4751 loc
->function_name
= xstrdup (loc
->function_name
);
4755 /* Attempt to determine architecture of location identified by SAL. */
4756 static struct gdbarch
*
4757 get_sal_arch (struct symtab_and_line sal
)
4760 return get_objfile_arch (sal
.section
->objfile
);
4762 return get_objfile_arch (sal
.symtab
->objfile
);
4767 /* set_raw_breakpoint is a low level routine for allocating and
4768 partially initializing a breakpoint of type BPTYPE. The newly
4769 created breakpoint's address, section, source file name, and line
4770 number are provided by SAL. The newly created and partially
4771 initialized breakpoint is added to the breakpoint chain and
4772 is also returned as the value of this function.
4774 It is expected that the caller will complete the initialization of
4775 the newly created breakpoint struct as well as output any status
4776 information regarding the creation of a new breakpoint. In
4777 particular, set_raw_breakpoint does NOT set the breakpoint
4778 number! Care should be taken to not allow an error to occur
4779 prior to completing the initialization of the breakpoint. If this
4780 should happen, a bogus breakpoint will be left on the chain. */
4783 set_raw_breakpoint (struct gdbarch
*gdbarch
,
4784 struct symtab_and_line sal
, enum bptype bptype
)
4786 struct breakpoint
*b
= set_raw_breakpoint_without_location (gdbarch
, bptype
);
4787 CORE_ADDR adjusted_address
;
4788 struct gdbarch
*loc_gdbarch
;
4790 loc_gdbarch
= get_sal_arch (sal
);
4792 loc_gdbarch
= b
->gdbarch
;
4794 if (bptype
!= bp_catchpoint
)
4795 gdb_assert (sal
.pspace
!= NULL
);
4797 /* Adjust the breakpoint's address prior to allocating a location.
4798 Once we call allocate_bp_location(), that mostly uninitialized
4799 location will be placed on the location chain. Adjustment of the
4800 breakpoint may cause target_read_memory() to be called and we do
4801 not want its scan of the location chain to find a breakpoint and
4802 location that's only been partially initialized. */
4803 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
, sal
.pc
, b
->type
);
4805 b
->loc
= allocate_bp_location (b
);
4806 b
->loc
->gdbarch
= loc_gdbarch
;
4807 b
->loc
->requested_address
= sal
.pc
;
4808 b
->loc
->address
= adjusted_address
;
4809 b
->loc
->pspace
= sal
.pspace
;
4811 /* Store the program space that was used to set the breakpoint, for
4812 breakpoint resetting. */
4813 b
->pspace
= sal
.pspace
;
4815 if (sal
.symtab
== NULL
)
4816 b
->source_file
= NULL
;
4818 b
->source_file
= xstrdup (sal
.symtab
->filename
);
4819 b
->loc
->section
= sal
.section
;
4820 b
->line_number
= sal
.line
;
4822 set_breakpoint_location_function (b
->loc
);
4824 breakpoints_changed ();
4830 /* Note that the breakpoint object B describes a permanent breakpoint
4831 instruction, hard-wired into the inferior's code. */
4833 make_breakpoint_permanent (struct breakpoint
*b
)
4835 struct bp_location
*bl
;
4836 b
->enable_state
= bp_permanent
;
4838 /* By definition, permanent breakpoints are already present in the code.
4839 Mark all locations as inserted. For now, make_breakpoint_permanent
4840 is called in just one place, so it's hard to say if it's reasonable
4841 to have permanent breakpoint with multiple locations or not,
4842 but it's easy to implmement. */
4843 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4847 /* Call this routine when stepping and nexting to enable a breakpoint
4848 if we do a longjmp() in THREAD. When we hit that breakpoint, call
4849 set_longjmp_resume_breakpoint() to figure out where we are going. */
4852 set_longjmp_breakpoint (int thread
)
4854 struct breakpoint
*b
, *temp
;
4856 /* To avoid having to rescan all objfile symbols at every step,
4857 we maintain a list of continually-inserted but always disabled
4858 longjmp "master" breakpoints. Here, we simply create momentary
4859 clones of those and enable them for the requested thread. */
4860 ALL_BREAKPOINTS_SAFE (b
, temp
)
4861 if (b
->pspace
== current_program_space
4862 && b
->type
== bp_longjmp_master
)
4864 struct breakpoint
*clone
= clone_momentary_breakpoint (b
);
4865 clone
->type
= bp_longjmp
;
4866 clone
->thread
= thread
;
4870 /* Delete all longjmp breakpoints from THREAD. */
4872 delete_longjmp_breakpoint (int thread
)
4874 struct breakpoint
*b
, *temp
;
4876 ALL_BREAKPOINTS_SAFE (b
, temp
)
4877 if (b
->type
== bp_longjmp
)
4879 if (b
->thread
== thread
)
4880 delete_breakpoint (b
);
4885 enable_overlay_breakpoints (void)
4887 struct breakpoint
*b
;
4890 if (b
->type
== bp_overlay_event
)
4892 b
->enable_state
= bp_enabled
;
4893 update_global_location_list (1);
4894 overlay_events_enabled
= 1;
4899 disable_overlay_breakpoints (void)
4901 struct breakpoint
*b
;
4904 if (b
->type
== bp_overlay_event
)
4906 b
->enable_state
= bp_disabled
;
4907 update_global_location_list (0);
4908 overlay_events_enabled
= 0;
4913 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
4915 struct breakpoint
*b
;
4917 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
);
4919 b
->enable_state
= bp_enabled
;
4920 /* addr_string has to be used or breakpoint_re_set will delete me. */
4922 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
4924 update_global_location_list_nothrow (1);
4930 remove_thread_event_breakpoints (void)
4932 struct breakpoint
*b
, *temp
;
4934 ALL_BREAKPOINTS_SAFE (b
, temp
)
4935 if (b
->type
== bp_thread_event
4936 && b
->loc
->pspace
== current_program_space
)
4937 delete_breakpoint (b
);
4940 struct captured_parse_breakpoint_args
4943 struct symtabs_and_lines
*sals_p
;
4944 char ***addr_string_p
;
4948 struct lang_and_radix
4954 /* Create a breakpoint for JIT code registration and unregistration. */
4957 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
4959 struct breakpoint
*b
;
4961 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
4962 update_global_location_list_nothrow (1);
4967 remove_solib_event_breakpoints (void)
4969 struct breakpoint
*b
, *temp
;
4971 ALL_BREAKPOINTS_SAFE (b
, temp
)
4972 if (b
->type
== bp_shlib_event
4973 && b
->loc
->pspace
== current_program_space
)
4974 delete_breakpoint (b
);
4978 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
4980 struct breakpoint
*b
;
4982 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
4983 update_global_location_list_nothrow (1);
4987 /* Disable any breakpoints that are on code in shared libraries. Only
4988 apply to enabled breakpoints, disabled ones can just stay disabled. */
4991 disable_breakpoints_in_shlibs (void)
4993 struct bp_location
*loc
, **locp_tmp
;
4995 ALL_BP_LOCATIONS (loc
, locp_tmp
)
4997 struct breakpoint
*b
= loc
->owner
;
4998 /* We apply the check to all breakpoints, including disabled
4999 for those with loc->duplicate set. This is so that when breakpoint
5000 becomes enabled, or the duplicate is removed, gdb will try to insert
5001 all breakpoints. If we don't set shlib_disabled here, we'll try
5002 to insert those breakpoints and fail. */
5003 if (((b
->type
== bp_breakpoint
)
5004 || (b
->type
== bp_hardware_breakpoint
)
5005 || (b
->type
== bp_tracepoint
))
5006 && loc
->pspace
== current_program_space
5007 && !loc
->shlib_disabled
5009 && PC_SOLIB (loc
->address
)
5011 && solib_name_from_address (loc
->pspace
, loc
->address
)
5015 loc
->shlib_disabled
= 1;
5020 /* Disable any breakpoints that are in in an unloaded shared library. Only
5021 apply to enabled breakpoints, disabled ones can just stay disabled. */
5024 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
5026 struct bp_location
*loc
, **locp_tmp
;
5027 int disabled_shlib_breaks
= 0;
5029 /* SunOS a.out shared libraries are always mapped, so do not
5030 disable breakpoints; they will only be reported as unloaded
5031 through clear_solib when GDB discards its shared library
5032 list. See clear_solib for more information. */
5033 if (exec_bfd
!= NULL
5034 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
5037 ALL_BP_LOCATIONS (loc
, locp_tmp
)
5039 struct breakpoint
*b
= loc
->owner
;
5040 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
5041 || loc
->loc_type
== bp_loc_software_breakpoint
)
5042 && solib
->pspace
== loc
->pspace
5043 && !loc
->shlib_disabled
5044 && (b
->type
== bp_breakpoint
|| b
->type
== bp_hardware_breakpoint
)
5045 && solib_contains_address_p (solib
, loc
->address
))
5047 loc
->shlib_disabled
= 1;
5048 /* At this point, we cannot rely on remove_breakpoint
5049 succeeding so we must mark the breakpoint as not inserted
5050 to prevent future errors occurring in remove_breakpoints. */
5052 if (!disabled_shlib_breaks
)
5054 target_terminal_ours_for_output ();
5055 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
5058 disabled_shlib_breaks
= 1;
5063 /* FORK & VFORK catchpoints. */
5065 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
5068 insert_catch_fork (struct breakpoint
*b
)
5070 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
5073 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
5076 remove_catch_fork (struct breakpoint
*b
)
5078 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
5081 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
5085 breakpoint_hit_catch_fork (struct breakpoint
*b
)
5087 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
5090 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
5092 static enum print_stop_action
5093 print_it_catch_fork (struct breakpoint
*b
)
5095 annotate_catchpoint (b
->number
);
5096 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
5097 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5098 return PRINT_SRC_AND_LOC
;
5101 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
5104 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5106 struct value_print_options opts
;
5108 get_user_print_options (&opts
);
5110 /* Field 4, the address, is omitted (which makes the columns
5111 not line up too nicely with the headers, but the effect
5112 is relatively readable). */
5113 if (opts
.addressprint
)
5114 ui_out_field_skip (uiout
, "addr");
5116 ui_out_text (uiout
, "fork");
5117 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
5119 ui_out_text (uiout
, ", process ");
5120 ui_out_field_int (uiout
, "what",
5121 ptid_get_pid (b
->forked_inferior_pid
));
5122 ui_out_spaces (uiout
, 1);
5126 /* Implement the "print_mention" breakpoint_ops method for fork
5130 print_mention_catch_fork (struct breakpoint
*b
)
5132 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
5135 /* The breakpoint_ops structure to be used in fork catchpoints. */
5137 static struct breakpoint_ops catch_fork_breakpoint_ops
=
5141 breakpoint_hit_catch_fork
,
5142 print_it_catch_fork
,
5143 print_one_catch_fork
,
5144 print_mention_catch_fork
5147 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
5150 insert_catch_vfork (struct breakpoint
*b
)
5152 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
5155 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
5158 remove_catch_vfork (struct breakpoint
*b
)
5160 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
5163 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
5167 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
5169 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
5172 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
5174 static enum print_stop_action
5175 print_it_catch_vfork (struct breakpoint
*b
)
5177 annotate_catchpoint (b
->number
);
5178 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
5179 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
5180 return PRINT_SRC_AND_LOC
;
5183 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
5186 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
5188 struct value_print_options opts
;
5190 get_user_print_options (&opts
);
5191 /* Field 4, the address, is omitted (which makes the columns
5192 not line up too nicely with the headers, but the effect
5193 is relatively readable). */
5194 if (opts
.addressprint
)
5195 ui_out_field_skip (uiout
, "addr");
5197 ui_out_text (uiout
, "vfork");
5198 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
5200 ui_out_text (uiout
, ", process ");
5201 ui_out_field_int (uiout
, "what",
5202 ptid_get_pid (b
->forked_inferior_pid
));
5203 ui_out_spaces (uiout
, 1);
5207 /* Implement the "print_mention" breakpoint_ops method for vfork
5211 print_mention_catch_vfork (struct breakpoint
*b
)
5213 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
5216 /* The breakpoint_ops structure to be used in vfork catchpoints. */
5218 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
5222 breakpoint_hit_catch_vfork
,
5223 print_it_catch_vfork
,
5224 print_one_catch_vfork
,
5225 print_mention_catch_vfork
5228 /* Implement the "insert" breakpoint_ops method for syscall
5232 insert_catch_syscall (struct breakpoint
*b
)
5234 struct inferior
*inf
= current_inferior ();
5236 ++inf
->total_syscalls_count
;
5237 if (!b
->syscalls_to_be_caught
)
5238 ++inf
->any_syscall_count
;
5243 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5247 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
5249 int old_size
= VEC_length (int, inf
->syscalls_counts
);
5250 uintptr_t vec_addr_offset
= old_size
* ((uintptr_t) sizeof (int));
5252 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
5253 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
5255 memset ((void *) vec_addr
, 0,
5256 (iter
+ 1 - old_size
) * sizeof (int));
5258 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
5259 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
5263 target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
5264 inf
->total_syscalls_count
!= 0,
5265 inf
->any_syscall_count
,
5266 VEC_length (int, inf
->syscalls_counts
),
5267 VEC_address (int, inf
->syscalls_counts
));
5270 /* Implement the "remove" breakpoint_ops method for syscall
5274 remove_catch_syscall (struct breakpoint
*b
)
5276 struct inferior
*inf
= current_inferior ();
5278 --inf
->total_syscalls_count
;
5279 if (!b
->syscalls_to_be_caught
)
5280 --inf
->any_syscall_count
;
5285 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5289 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
5290 /* Shouldn't happen. */
5292 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
5293 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
5297 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
5298 inf
->total_syscalls_count
!= 0,
5299 inf
->any_syscall_count
,
5300 VEC_length (int, inf
->syscalls_counts
),
5301 VEC_address (int, inf
->syscalls_counts
));
5304 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
5308 breakpoint_hit_catch_syscall (struct breakpoint
*b
)
5310 /* We must check if we are catching specific syscalls in this breakpoint.
5311 If we are, then we must guarantee that the called syscall is the same
5312 syscall we are catching. */
5313 int syscall_number
= 0;
5315 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
5318 /* Now, checking if the syscall is the same. */
5319 if (b
->syscalls_to_be_caught
)
5323 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5325 if (syscall_number
== iter
)
5335 /* Implement the "print_it" breakpoint_ops method for syscall
5338 static enum print_stop_action
5339 print_it_catch_syscall (struct breakpoint
*b
)
5341 /* These are needed because we want to know in which state a
5342 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
5343 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
5344 must print "called syscall" or "returned from syscall". */
5346 struct target_waitstatus last
;
5348 struct cleanup
*old_chain
;
5351 get_last_target_status (&ptid
, &last
);
5353 get_syscall_by_number (last
.value
.syscall_number
, &s
);
5355 annotate_catchpoint (b
->number
);
5358 syscall_id
= xstrprintf ("%d", last
.value
.syscall_number
);
5360 syscall_id
= xstrprintf ("'%s'", s
.name
);
5362 old_chain
= make_cleanup (xfree
, syscall_id
);
5364 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
5365 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
5366 b
->number
, syscall_id
);
5367 else if (last
.kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
5368 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
5369 b
->number
, syscall_id
);
5371 do_cleanups (old_chain
);
5373 return PRINT_SRC_AND_LOC
;
5376 /* Implement the "print_one" breakpoint_ops method for syscall
5380 print_one_catch_syscall (struct breakpoint
*b
,
5381 struct bp_location
**last_loc
)
5383 struct value_print_options opts
;
5385 get_user_print_options (&opts
);
5386 /* Field 4, the address, is omitted (which makes the columns
5387 not line up too nicely with the headers, but the effect
5388 is relatively readable). */
5389 if (opts
.addressprint
)
5390 ui_out_field_skip (uiout
, "addr");
5393 if (b
->syscalls_to_be_caught
5394 && VEC_length (int, b
->syscalls_to_be_caught
) > 1)
5395 ui_out_text (uiout
, "syscalls \"");
5397 ui_out_text (uiout
, "syscall \"");
5399 if (b
->syscalls_to_be_caught
)
5402 char *text
= xstrprintf ("%s", "");
5404 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5409 get_syscall_by_number (iter
, &s
);
5412 text
= xstrprintf ("%s%s, ", text
, s
.name
);
5414 text
= xstrprintf ("%s%d, ", text
, iter
);
5416 /* We have to xfree the last 'text' (now stored at 'x')
5417 because xstrprintf dinamically allocates new space for it
5421 /* Remove the last comma. */
5422 text
[strlen (text
) - 2] = '\0';
5423 ui_out_field_string (uiout
, "what", text
);
5426 ui_out_field_string (uiout
, "what", "<any syscall>");
5427 ui_out_text (uiout
, "\" ");
5430 /* Implement the "print_mention" breakpoint_ops method for syscall
5434 print_mention_catch_syscall (struct breakpoint
*b
)
5436 if (b
->syscalls_to_be_caught
)
5440 if (VEC_length (int, b
->syscalls_to_be_caught
) > 1)
5441 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
5443 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
5446 VEC_iterate (int, b
->syscalls_to_be_caught
, i
, iter
);
5450 get_syscall_by_number (iter
, &s
);
5453 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
5455 printf_filtered (" %d", s
.number
);
5457 printf_filtered (")");
5460 printf_filtered (_("Catchpoint %d (any syscall)"),
5464 /* The breakpoint_ops structure to be used in syscall catchpoints. */
5466 static struct breakpoint_ops catch_syscall_breakpoint_ops
=
5468 insert_catch_syscall
,
5469 remove_catch_syscall
,
5470 breakpoint_hit_catch_syscall
,
5471 print_it_catch_syscall
,
5472 print_one_catch_syscall
,
5473 print_mention_catch_syscall
5476 /* Returns non-zero if 'b' is a syscall catchpoint. */
5479 syscall_catchpoint_p (struct breakpoint
*b
)
5481 return (b
->ops
== &catch_syscall_breakpoint_ops
);
5484 /* Create a new breakpoint of the bp_catchpoint kind and return it,
5485 but does NOT mention it nor update the global location list.
5486 This is useful if you need to fill more fields in the
5487 struct breakpoint before calling mention.
5489 If TEMPFLAG is non-zero, then make the breakpoint temporary.
5490 If COND_STRING is not NULL, then store it in the breakpoint.
5491 OPS, if not NULL, is the breakpoint_ops structure associated
5492 to the catchpoint. */
5494 static struct breakpoint
*
5495 create_catchpoint_without_mention (struct gdbarch
*gdbarch
, int tempflag
,
5497 struct breakpoint_ops
*ops
)
5499 struct symtab_and_line sal
;
5500 struct breakpoint
*b
;
5503 sal
.pspace
= current_program_space
;
5505 b
= set_raw_breakpoint (gdbarch
, sal
, bp_catchpoint
);
5506 set_breakpoint_count (breakpoint_count
+ 1);
5507 b
->number
= breakpoint_count
;
5509 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
5511 b
->addr_string
= NULL
;
5512 b
->enable_state
= bp_enabled
;
5513 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5519 /* Create a new breakpoint of the bp_catchpoint kind and return it.
5521 If TEMPFLAG is non-zero, then make the breakpoint temporary.
5522 If COND_STRING is not NULL, then store it in the breakpoint.
5523 OPS, if not NULL, is the breakpoint_ops structure associated
5524 to the catchpoint. */
5526 static struct breakpoint
*
5527 create_catchpoint (struct gdbarch
*gdbarch
, int tempflag
,
5528 char *cond_string
, struct breakpoint_ops
*ops
)
5530 struct breakpoint
*b
=
5531 create_catchpoint_without_mention (gdbarch
, tempflag
, cond_string
, ops
);
5534 update_global_location_list (1);
5540 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
5541 int tempflag
, char *cond_string
,
5542 struct breakpoint_ops
*ops
)
5544 struct breakpoint
*b
5545 = create_catchpoint (gdbarch
, tempflag
, cond_string
, ops
);
5547 /* FIXME: We should put this information in a breakpoint private data
5549 b
->forked_inferior_pid
= null_ptid
;
5552 /* Exec catchpoints. */
5555 insert_catch_exec (struct breakpoint
*b
)
5557 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
5561 remove_catch_exec (struct breakpoint
*b
)
5563 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
5567 breakpoint_hit_catch_exec (struct breakpoint
*b
)
5569 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
5572 static enum print_stop_action
5573 print_it_catch_exec (struct breakpoint
*b
)
5575 annotate_catchpoint (b
->number
);
5576 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
5578 return PRINT_SRC_AND_LOC
;
5582 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
5584 struct value_print_options opts
;
5586 get_user_print_options (&opts
);
5588 /* Field 4, the address, is omitted (which makes the columns
5589 not line up too nicely with the headers, but the effect
5590 is relatively readable). */
5591 if (opts
.addressprint
)
5592 ui_out_field_skip (uiout
, "addr");
5594 ui_out_text (uiout
, "exec");
5595 if (b
->exec_pathname
!= NULL
)
5597 ui_out_text (uiout
, ", program \"");
5598 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
5599 ui_out_text (uiout
, "\" ");
5604 print_mention_catch_exec (struct breakpoint
*b
)
5606 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
5609 static struct breakpoint_ops catch_exec_breakpoint_ops
=
5613 breakpoint_hit_catch_exec
,
5614 print_it_catch_exec
,
5615 print_one_catch_exec
,
5616 print_mention_catch_exec
5620 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
5621 struct breakpoint_ops
*ops
)
5623 struct gdbarch
*gdbarch
= get_current_arch ();
5624 struct breakpoint
*b
=
5625 create_catchpoint_without_mention (gdbarch
, tempflag
, NULL
, ops
);
5627 b
->syscalls_to_be_caught
= filter
;
5629 /* Now, we have to mention the breakpoint and update the global
5632 update_global_location_list (1);
5636 hw_breakpoint_used_count (void)
5638 struct breakpoint
*b
;
5643 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
5651 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
5653 struct breakpoint
*b
;
5656 *other_type_used
= 0;
5659 if (breakpoint_enabled (b
))
5661 if (b
->type
== type
)
5663 else if ((b
->type
== bp_hardware_watchpoint
5664 || b
->type
== bp_read_watchpoint
5665 || b
->type
== bp_access_watchpoint
))
5666 *other_type_used
= 1;
5673 disable_watchpoints_before_interactive_call_start (void)
5675 struct breakpoint
*b
;
5679 if (((b
->type
== bp_watchpoint
)
5680 || (b
->type
== bp_hardware_watchpoint
)
5681 || (b
->type
== bp_read_watchpoint
)
5682 || (b
->type
== bp_access_watchpoint
))
5683 && breakpoint_enabled (b
))
5685 b
->enable_state
= bp_call_disabled
;
5686 update_global_location_list (0);
5692 enable_watchpoints_after_interactive_call_stop (void)
5694 struct breakpoint
*b
;
5698 if (((b
->type
== bp_watchpoint
)
5699 || (b
->type
== bp_hardware_watchpoint
)
5700 || (b
->type
== bp_read_watchpoint
)
5701 || (b
->type
== bp_access_watchpoint
))
5702 && (b
->enable_state
== bp_call_disabled
))
5704 b
->enable_state
= bp_enabled
;
5705 update_global_location_list (1);
5711 disable_breakpoints_before_startup (void)
5713 struct breakpoint
*b
;
5718 if (b
->pspace
!= current_program_space
)
5721 if ((b
->type
== bp_breakpoint
5722 || b
->type
== bp_hardware_breakpoint
)
5723 && breakpoint_enabled (b
))
5725 b
->enable_state
= bp_startup_disabled
;
5731 update_global_location_list (0);
5733 current_program_space
->executing_startup
= 1;
5737 enable_breakpoints_after_startup (void)
5739 struct breakpoint
*b
;
5742 current_program_space
->executing_startup
= 0;
5746 if (b
->pspace
!= current_program_space
)
5749 if ((b
->type
== bp_breakpoint
5750 || b
->type
== bp_hardware_breakpoint
)
5751 && b
->enable_state
== bp_startup_disabled
)
5753 b
->enable_state
= bp_enabled
;
5759 breakpoint_re_set ();
5763 /* Set a breakpoint that will evaporate an end of command
5764 at address specified by SAL.
5765 Restrict it to frame FRAME if FRAME is nonzero. */
5768 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
5769 struct frame_id frame_id
, enum bptype type
)
5771 struct breakpoint
*b
;
5773 /* If FRAME_ID is valid, it should be a real frame, not an inlined
5775 gdb_assert (!frame_id_inlined_p (frame_id
));
5777 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
5778 b
->enable_state
= bp_enabled
;
5779 b
->disposition
= disp_donttouch
;
5780 b
->frame_id
= frame_id
;
5782 /* If we're debugging a multi-threaded program, then we
5783 want momentary breakpoints to be active in only a
5784 single thread of control. */
5785 if (in_thread_list (inferior_ptid
))
5786 b
->thread
= pid_to_thread_id (inferior_ptid
);
5788 update_global_location_list_nothrow (1);
5793 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
5797 clone_momentary_breakpoint (struct breakpoint
*orig
)
5799 struct breakpoint
*copy
;
5801 /* If there's nothing to clone, then return nothing. */
5805 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, orig
->type
);
5806 copy
->loc
= allocate_bp_location (copy
);
5807 set_breakpoint_location_function (copy
->loc
);
5809 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
5810 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
5811 copy
->loc
->address
= orig
->loc
->address
;
5812 copy
->loc
->section
= orig
->loc
->section
;
5813 copy
->loc
->pspace
= orig
->loc
->pspace
;
5815 if (orig
->source_file
== NULL
)
5816 copy
->source_file
= NULL
;
5818 copy
->source_file
= xstrdup (orig
->source_file
);
5820 copy
->line_number
= orig
->line_number
;
5821 copy
->frame_id
= orig
->frame_id
;
5822 copy
->thread
= orig
->thread
;
5823 copy
->pspace
= orig
->pspace
;
5825 copy
->enable_state
= bp_enabled
;
5826 copy
->disposition
= disp_donttouch
;
5827 copy
->number
= internal_breakpoint_number
--;
5829 update_global_location_list_nothrow (0);
5834 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
5837 struct symtab_and_line sal
;
5839 sal
= find_pc_line (pc
, 0);
5841 sal
.section
= find_pc_overlay (pc
);
5842 sal
.explicit_pc
= 1;
5844 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
5848 /* Tell the user we have just set a breakpoint B. */
5851 mention (struct breakpoint
*b
)
5854 struct cleanup
*ui_out_chain
;
5855 struct value_print_options opts
;
5857 get_user_print_options (&opts
);
5859 /* FIXME: This is misplaced; mention() is called by things (like
5860 hitting a watchpoint) other than breakpoint creation. It should
5861 be possible to clean this up and at the same time replace the
5862 random calls to breakpoint_changed with this hook. */
5863 observer_notify_breakpoint_created (b
->number
);
5865 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
5866 b
->ops
->print_mention (b
);
5871 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
5874 ui_out_text (uiout
, "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_hardware_watchpoint
:
5882 ui_out_text (uiout
, "Hardware watchpoint ");
5883 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
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_read_watchpoint
:
5890 ui_out_text (uiout
, "Hardware read watchpoint ");
5891 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
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
);
5897 case bp_access_watchpoint
:
5898 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
5899 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
5900 ui_out_field_int (uiout
, "number", b
->number
);
5901 ui_out_text (uiout
, ": ");
5902 ui_out_field_string (uiout
, "exp", b
->exp_string
);
5903 do_cleanups (ui_out_chain
);
5906 if (ui_out_is_mi_like_p (uiout
))
5911 if (b
->disposition
== disp_del
)
5912 printf_filtered (_("Temporary breakpoint"));
5914 printf_filtered (_("Breakpoint"));
5915 printf_filtered (_(" %d"), b
->number
);
5918 case bp_hardware_breakpoint
:
5919 if (ui_out_is_mi_like_p (uiout
))
5924 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
5928 if (ui_out_is_mi_like_p (uiout
))
5933 printf_filtered (_("Tracepoint"));
5934 printf_filtered (_(" %d"), b
->number
);
5941 case bp_longjmp_resume
:
5942 case bp_step_resume
:
5944 case bp_watchpoint_scope
:
5945 case bp_shlib_event
:
5946 case bp_thread_event
:
5947 case bp_overlay_event
:
5949 case bp_longjmp_master
:
5955 /* i18n: cagney/2005-02-11: Below needs to be merged into a
5959 printf_filtered (_(" (%s) pending."), b
->addr_string
);
5963 if (opts
.addressprint
|| b
->source_file
== NULL
)
5965 printf_filtered (" at ");
5966 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
5970 printf_filtered (": file %s, line %d.",
5971 b
->source_file
, b
->line_number
);
5975 struct bp_location
*loc
= b
->loc
;
5977 for (; loc
; loc
= loc
->next
)
5979 printf_filtered (" (%d locations)", n
);
5984 if (ui_out_is_mi_like_p (uiout
))
5986 printf_filtered ("\n");
5990 static struct bp_location
*
5991 add_location_to_breakpoint (struct breakpoint
*b
,
5992 const struct symtab_and_line
*sal
)
5994 struct bp_location
*loc
, **tmp
;
5996 loc
= allocate_bp_location (b
);
5997 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
6000 loc
->gdbarch
= get_sal_arch (*sal
);
6002 loc
->gdbarch
= b
->gdbarch
;
6003 loc
->requested_address
= sal
->pc
;
6004 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
6005 loc
->requested_address
, b
->type
);
6006 loc
->pspace
= sal
->pspace
;
6007 gdb_assert (loc
->pspace
!= NULL
);
6008 loc
->section
= sal
->section
;
6010 set_breakpoint_location_function (loc
);
6015 /* Return 1 if LOC is pointing to a permanent breakpoint,
6016 return 0 otherwise. */
6019 bp_loc_is_permanent (struct bp_location
*loc
)
6023 const gdb_byte
*brk
;
6024 gdb_byte
*target_mem
;
6025 struct cleanup
*cleanup
;
6028 gdb_assert (loc
!= NULL
);
6030 addr
= loc
->address
;
6031 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
6033 /* Software breakpoints unsupported? */
6037 target_mem
= alloca (len
);
6039 /* Enable the automatic memory restoration from breakpoints while
6040 we read the memory. Otherwise we could say about our temporary
6041 breakpoints they are permanent. */
6042 cleanup
= save_current_space_and_thread ();
6044 switch_to_program_space_and_thread (loc
->pspace
);
6045 make_show_memory_breakpoints_cleanup (0);
6047 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
6048 && memcmp (target_mem
, brk
, len
) == 0)
6051 do_cleanups (cleanup
);
6058 /* Create a breakpoint with SAL as location. Use ADDR_STRING
6059 as textual description of the location, and COND_STRING
6060 as condition expression. */
6063 create_breakpoint (struct gdbarch
*gdbarch
,
6064 struct symtabs_and_lines sals
, char *addr_string
,
6066 enum bptype type
, enum bpdisp disposition
,
6067 int thread
, int task
, int ignore_count
,
6068 struct breakpoint_ops
*ops
, int from_tty
, int enabled
)
6070 struct breakpoint
*b
= NULL
;
6073 if (type
== bp_hardware_breakpoint
)
6075 int i
= hw_breakpoint_used_count ();
6076 int target_resources_ok
=
6077 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
6079 if (target_resources_ok
== 0)
6080 error (_("No hardware breakpoint support in the target."));
6081 else if (target_resources_ok
< 0)
6082 error (_("Hardware breakpoints used exceeds limit."));
6085 gdb_assert (sals
.nelts
> 0);
6087 for (i
= 0; i
< sals
.nelts
; ++i
)
6089 struct symtab_and_line sal
= sals
.sals
[i
];
6090 struct bp_location
*loc
;
6094 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
6096 loc_gdbarch
= gdbarch
;
6098 describe_other_breakpoints (loc_gdbarch
,
6099 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
6104 b
= set_raw_breakpoint (gdbarch
, sal
, type
);
6105 set_breakpoint_count (breakpoint_count
+ 1);
6106 b
->number
= breakpoint_count
;
6110 b
->cond_string
= cond_string
;
6111 b
->ignore_count
= ignore_count
;
6112 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
6113 b
->disposition
= disposition
;
6115 b
->pspace
= sals
.sals
[0].pspace
;
6117 if (enabled
&& b
->pspace
->executing_startup
6118 && (b
->type
== bp_breakpoint
6119 || b
->type
== bp_hardware_breakpoint
))
6120 b
->enable_state
= bp_startup_disabled
;
6126 loc
= add_location_to_breakpoint (b
, &sal
);
6129 if (bp_loc_is_permanent (loc
))
6130 make_breakpoint_permanent (b
);
6134 char *arg
= b
->cond_string
;
6135 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
6137 error (_("Garbage %s follows condition"), arg
);
6142 b
->addr_string
= addr_string
;
6144 /* addr_string has to be used or breakpoint_re_set will delete
6147 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
6153 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
6154 elements to fill the void space. */
6156 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
6158 int i
= index_to_remove
+1;
6159 int last_index
= sal
->nelts
-1;
6161 for (;i
<= last_index
; ++i
)
6162 sal
->sals
[i
-1] = sal
->sals
[i
];
6167 /* If appropriate, obtains all sals that correspond to the same file
6168 and line as SAL, in all program spaces. Users debugging with IDEs,
6169 will want to set a breakpoint at foo.c:line, and not really care
6170 about program spaces. This is done only if SAL does not have
6171 explicit PC and has line and file information. If we got just a
6172 single expanded sal, return the original.
6174 Otherwise, if SAL.explicit_line is not set, filter out all sals for
6175 which the name of enclosing function is different from SAL. This
6176 makes sure that if we have breakpoint originally set in template
6177 instantiation, say foo<int>(), we won't expand SAL to locations at
6178 the same line in all existing instantiations of 'foo'. */
6180 static struct symtabs_and_lines
6181 expand_line_sal_maybe (struct symtab_and_line sal
)
6183 struct symtabs_and_lines expanded
;
6184 CORE_ADDR original_pc
= sal
.pc
;
6185 char *original_function
= NULL
;
6188 struct cleanup
*old_chain
;
6190 /* If we have explicit pc, don't expand.
6191 If we have no line number, we can't expand. */
6192 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
6195 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6196 expanded
.sals
[0] = sal
;
6202 old_chain
= save_current_space_and_thread ();
6204 switch_to_program_space_and_thread (sal
.pspace
);
6206 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
6208 /* Note that expand_line_sal visits *all* program spaces. */
6209 expanded
= expand_line_sal (sal
);
6211 if (expanded
.nelts
== 1)
6213 /* We had one sal, we got one sal. Without futher
6214 processing, just return the original sal. */
6215 xfree (expanded
.sals
);
6217 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6218 sal
.pc
= original_pc
;
6219 expanded
.sals
[0] = sal
;
6220 do_cleanups (old_chain
);
6224 if (!sal
.explicit_line
)
6226 CORE_ADDR func_addr
, func_end
;
6227 for (i
= 0; i
< expanded
.nelts
; ++i
)
6229 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
6230 char *this_function
;
6232 /* We need to switch threads as well since we're about to
6234 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
6236 if (find_pc_partial_function (pc
, &this_function
,
6237 &func_addr
, &func_end
))
6240 && strcmp (this_function
, original_function
) != 0)
6242 remove_sal (&expanded
, i
);
6245 else if (func_addr
== pc
)
6247 /* We're at beginning of a function, and should
6249 struct symbol
*sym
= find_pc_function (pc
);
6251 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
6254 /* Since find_pc_partial_function returned true,
6255 we should really always find the section here. */
6256 struct obj_section
*section
= find_pc_section (pc
);
6259 struct gdbarch
*gdbarch
6260 = get_objfile_arch (section
->objfile
);
6262 = gdbarch_skip_prologue (gdbarch
, pc
);
6271 for (i
= 0; i
< expanded
.nelts
; ++i
)
6273 /* If this SAL corresponds to a breakpoint inserted using a
6274 line number, then skip the function prologue if necessary. */
6275 skip_prologue_sal (&expanded
.sals
[i
]);
6279 do_cleanups (old_chain
);
6281 if (expanded
.nelts
<= 1)
6283 /* This is un ugly workaround. If we get zero
6284 expanded sals then something is really wrong.
6285 Fix that by returnign the original sal. */
6286 xfree (expanded
.sals
);
6288 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
6289 sal
.pc
= original_pc
;
6290 expanded
.sals
[0] = sal
;
6297 for (i
= 0; i
< expanded
.nelts
; ++i
)
6298 if (expanded
.sals
[i
].pc
== original_pc
)
6309 /* Add SALS.nelts breakpoints to the breakpoint table. For each
6310 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
6311 value. COND_STRING, if not NULL, specified the condition to be
6312 used for all breakpoints. Essentially the only case where
6313 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
6314 function. In that case, it's still not possible to specify
6315 separate conditions for different overloaded functions, so
6316 we take just a single condition string.
6318 NOTE: If the function succeeds, the caller is expected to cleanup
6319 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
6320 array contents). If the function fails (error() is called), the
6321 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
6322 COND and SALS arrays and each of those arrays contents. */
6325 create_breakpoints (struct gdbarch
*gdbarch
,
6326 struct symtabs_and_lines sals
, char **addr_string
,
6328 enum bptype type
, enum bpdisp disposition
,
6329 int thread
, int task
, int ignore_count
,
6330 struct breakpoint_ops
*ops
, int from_tty
,
6334 for (i
= 0; i
< sals
.nelts
; ++i
)
6336 struct symtabs_and_lines expanded
=
6337 expand_line_sal_maybe (sals
.sals
[i
]);
6339 create_breakpoint (gdbarch
, expanded
, addr_string
[i
],
6340 cond_string
, type
, disposition
,
6341 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
6345 /* Parse ARG which is assumed to be a SAL specification possibly
6346 followed by conditionals. On return, SALS contains an array of SAL
6347 addresses found. ADDR_STRING contains a vector of (canonical)
6348 address strings. ARG points to the end of the SAL. */
6351 parse_breakpoint_sals (char **address
,
6352 struct symtabs_and_lines
*sals
,
6353 char ***addr_string
,
6356 char *addr_start
= *address
;
6357 *addr_string
= NULL
;
6358 /* If no arg given, or if first arg is 'if ', use the default
6360 if ((*address
) == NULL
6361 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
6363 if (default_breakpoint_valid
)
6365 struct symtab_and_line sal
;
6366 init_sal (&sal
); /* initialize to zeroes */
6367 sals
->sals
= (struct symtab_and_line
*)
6368 xmalloc (sizeof (struct symtab_and_line
));
6369 sal
.pc
= default_breakpoint_address
;
6370 sal
.line
= default_breakpoint_line
;
6371 sal
.symtab
= default_breakpoint_symtab
;
6372 sal
.pspace
= default_breakpoint_pspace
;
6373 sal
.section
= find_pc_overlay (sal
.pc
);
6375 /* "break" without arguments is equivalent to "break *PC" where PC is
6376 the default_breakpoint_address. So make sure to set
6377 sal.explicit_pc to prevent GDB from trying to expand the list of
6378 sals to include all other instances with the same symtab and line.
6380 sal
.explicit_pc
= 1;
6382 sals
->sals
[0] = sal
;
6386 error (_("No default breakpoint address now."));
6390 /* Force almost all breakpoints to be in terms of the
6391 current_source_symtab (which is decode_line_1's default). This
6392 should produce the results we want almost all of the time while
6393 leaving default_breakpoint_* alone.
6394 ObjC: However, don't match an Objective-C method name which
6395 may have a '+' or '-' succeeded by a '[' */
6397 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
6399 if (default_breakpoint_valid
6401 || ((strchr ("+-", (*address
)[0]) != NULL
)
6402 && ((*address
)[1] != '['))))
6403 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
6404 default_breakpoint_line
, addr_string
,
6407 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
6408 addr_string
, not_found_ptr
);
6410 /* For any SAL that didn't have a canonical string, fill one in. */
6411 if (sals
->nelts
> 0 && *addr_string
== NULL
)
6412 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
6413 if (addr_start
!= (*address
))
6416 for (i
= 0; i
< sals
->nelts
; i
++)
6418 /* Add the string if not present. */
6419 if ((*addr_string
)[i
] == NULL
)
6420 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
6426 /* Convert each SAL into a real PC. Verify that the PC can be
6427 inserted as a breakpoint. If it can't throw an error. */
6430 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
6434 for (i
= 0; i
< sals
->nelts
; i
++)
6435 resolve_sal_pc (&sals
->sals
[i
]);
6439 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
6441 struct captured_parse_breakpoint_args
*args
= data
;
6443 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
6444 args
->not_found_ptr
);
6447 /* Given TOK, a string specification of condition and thread, as
6448 accepted by the 'break' command, extract the condition
6449 string and thread number and set *COND_STRING and *THREAD.
6450 PC identifies the context at which the condition should be parsed.
6451 If no condition is found, *COND_STRING is set to NULL.
6452 If no thread is found, *THREAD is set to -1. */
6454 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
6455 char **cond_string
, int *thread
, int *task
)
6457 *cond_string
= NULL
;
6463 char *cond_start
= NULL
;
6464 char *cond_end
= NULL
;
6465 while (*tok
== ' ' || *tok
== '\t')
6470 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
6473 toklen
= end_tok
- tok
;
6475 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
6477 struct expression
*expr
;
6479 tok
= cond_start
= end_tok
+ 1;
6480 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
6483 *cond_string
= savestring (cond_start
,
6484 cond_end
- cond_start
);
6486 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
6492 *thread
= strtol (tok
, &tok
, 0);
6494 error (_("Junk after thread keyword."));
6495 if (!valid_thread_id (*thread
))
6496 error (_("Unknown thread %d."), *thread
);
6498 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
6504 *task
= strtol (tok
, &tok
, 0);
6506 error (_("Junk after task keyword."));
6507 if (!valid_task_id (*task
))
6508 error (_("Unknown task %d\n"), *task
);
6511 error (_("Junk at end of arguments."));
6515 /* Set a breakpoint. This function is shared between
6516 CLI and MI functions for setting a breakpoint.
6517 This function has two major modes of operations,
6518 selected by the PARSE_CONDITION_AND_THREAD parameter.
6519 If non-zero, the function will parse arg, extracting
6520 breakpoint location, address and thread. Otherwise,
6521 ARG is just the location of breakpoint, with condition
6522 and thread specified by the COND_STRING and THREAD
6526 break_command_really (struct gdbarch
*gdbarch
,
6527 char *arg
, char *cond_string
, int thread
,
6528 int parse_condition_and_thread
,
6529 int tempflag
, int hardwareflag
, int traceflag
,
6531 enum auto_boolean pending_break_support
,
6532 struct breakpoint_ops
*ops
,
6536 struct gdb_exception e
;
6537 struct symtabs_and_lines sals
;
6538 struct symtab_and_line pending_sal
;
6541 char *addr_start
= arg
;
6543 struct cleanup
*old_chain
;
6544 struct cleanup
*bkpt_chain
= NULL
;
6545 struct captured_parse_breakpoint_args parse_args
;
6549 enum bptype type_wanted
;
6556 parse_args
.arg_p
= &arg
;
6557 parse_args
.sals_p
= &sals
;
6558 parse_args
.addr_string_p
= &addr_string
;
6559 parse_args
.not_found_ptr
= ¬_found
;
6561 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
6562 &parse_args
, RETURN_MASK_ALL
);
6564 /* If caller is interested in rc value from parse, set value. */
6568 throw_exception (e
);
6572 case NOT_FOUND_ERROR
:
6574 /* If pending breakpoint support is turned off, throw
6577 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
6578 throw_exception (e
);
6580 exception_print (gdb_stderr
, e
);
6582 /* If pending breakpoint support is auto query and the user
6583 selects no, then simply return the error code. */
6584 if (pending_break_support
== AUTO_BOOLEAN_AUTO
6585 && !nquery ("Make breakpoint pending on future shared library load? "))
6588 /* At this point, either the user was queried about setting
6589 a pending breakpoint and selected yes, or pending
6590 breakpoint behavior is on and thus a pending breakpoint
6591 is defaulted on behalf of the user. */
6592 copy_arg
= xstrdup (addr_start
);
6593 addr_string
= ©_arg
;
6595 sals
.sals
= &pending_sal
;
6600 throw_exception (e
);
6607 /* Create a chain of things that always need to be cleaned up. */
6608 old_chain
= make_cleanup (null_cleanup
, 0);
6612 /* Make sure that all storage allocated to SALS gets freed. */
6613 make_cleanup (xfree
, sals
.sals
);
6615 /* Cleanup the addr_string array but not its contents. */
6616 make_cleanup (xfree
, addr_string
);
6619 /* ----------------------------- SNIP -----------------------------
6620 Anything added to the cleanup chain beyond this point is assumed
6621 to be part of a breakpoint. If the breakpoint create succeeds
6622 then the memory is not reclaimed. */
6623 bkpt_chain
= make_cleanup (null_cleanup
, 0);
6625 /* Mark the contents of the addr_string for cleanup. These go on
6626 the bkpt_chain and only occur if the breakpoint create fails. */
6627 for (i
= 0; i
< sals
.nelts
; i
++)
6629 if (addr_string
[i
] != NULL
)
6630 make_cleanup (xfree
, addr_string
[i
]);
6633 /* Resolve all line numbers to PC's and verify that the addresses
6634 are ok for the target. */
6636 breakpoint_sals_to_pc (&sals
, addr_start
);
6638 type_wanted
= (traceflag
6640 : (hardwareflag
? bp_hardware_breakpoint
: bp_breakpoint
));
6642 /* Verify that condition can be parsed, before setting any
6643 breakpoints. Allocate a separate condition expression for each
6647 if (parse_condition_and_thread
)
6649 /* Here we only parse 'arg' to separate condition
6650 from thread number, so parsing in context of first
6651 sal is OK. When setting the breakpoint we'll
6652 re-parse it in context of each sal. */
6655 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
6658 make_cleanup (xfree
, cond_string
);
6662 /* Create a private copy of condition string. */
6665 cond_string
= xstrdup (cond_string
);
6666 make_cleanup (xfree
, cond_string
);
6669 create_breakpoints (gdbarch
, sals
, addr_string
, cond_string
, type_wanted
,
6670 tempflag
? disp_del
: disp_donttouch
,
6671 thread
, task
, ignore_count
, ops
, from_tty
, enabled
);
6675 struct symtab_and_line sal
= {0};
6676 struct breakpoint
*b
;
6678 make_cleanup (xfree
, copy_arg
);
6680 b
= set_raw_breakpoint_without_location (gdbarch
, type_wanted
);
6681 set_breakpoint_count (breakpoint_count
+ 1);
6682 b
->number
= breakpoint_count
;
6684 b
->addr_string
= addr_string
[0];
6685 b
->cond_string
= NULL
;
6686 b
->ignore_count
= ignore_count
;
6687 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6688 b
->condition_not_parsed
= 1;
6690 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
6691 b
->pspace
= current_program_space
;
6693 if (enabled
&& b
->pspace
->executing_startup
6694 && (b
->type
== bp_breakpoint
6695 || b
->type
== bp_hardware_breakpoint
))
6696 b
->enable_state
= bp_startup_disabled
;
6702 warning (_("Multiple breakpoints were set.\n"
6703 "Use the \"delete\" command to delete unwanted breakpoints."));
6704 /* That's it. Discard the cleanups for data inserted into the
6706 discard_cleanups (bkpt_chain
);
6707 /* But cleanup everything else. */
6708 do_cleanups (old_chain
);
6710 /* error call may happen here - have BKPT_CHAIN already discarded. */
6711 update_global_location_list (1);
6714 /* Set a breakpoint.
6715 ARG is a string describing breakpoint address,
6716 condition, and thread.
6717 FLAG specifies if a breakpoint is hardware on,
6718 and if breakpoint is temporary, using BP_HARDWARE_FLAG
6722 break_command_1 (char *arg
, int flag
, int from_tty
)
6724 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
6725 int tempflag
= flag
& BP_TEMPFLAG
;
6727 break_command_really (get_current_arch (),
6729 NULL
, 0, 1 /* parse arg */,
6730 tempflag
, hardwareflag
, 0 /* traceflag */,
6731 0 /* Ignore count */,
6732 pending_break_support
,
6733 NULL
/* breakpoint_ops */,
6740 set_breakpoint (struct gdbarch
*gdbarch
,
6741 char *address
, char *condition
,
6742 int hardwareflag
, int tempflag
,
6743 int thread
, int ignore_count
,
6744 int pending
, int enabled
)
6746 break_command_really (gdbarch
,
6747 address
, condition
, thread
,
6748 0 /* condition and thread are valid. */,
6749 tempflag
, hardwareflag
, 0 /* traceflag */,
6752 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
6756 /* Adjust SAL to the first instruction past the function prologue.
6757 The end of the prologue is determined using the line table from
6758 the debugging information. explicit_pc and explicit_line are
6761 If SAL is already past the prologue, then do nothing. */
6764 skip_prologue_sal (struct symtab_and_line
*sal
)
6767 struct symtab_and_line start_sal
;
6768 struct cleanup
*old_chain
;
6770 old_chain
= save_current_space_and_thread ();
6772 sym
= find_pc_function (sal
->pc
);
6775 start_sal
= find_function_start_sal (sym
, 1);
6776 if (sal
->pc
< start_sal
.pc
)
6778 start_sal
.explicit_line
= sal
->explicit_line
;
6779 start_sal
.explicit_pc
= sal
->explicit_pc
;
6784 do_cleanups (old_chain
);
6787 /* Helper function for break_command_1 and disassemble_command. */
6790 resolve_sal_pc (struct symtab_and_line
*sal
)
6794 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
6796 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
6797 error (_("No line %d in file \"%s\"."),
6798 sal
->line
, sal
->symtab
->filename
);
6801 /* If this SAL corresponds to a breakpoint inserted using
6802 a line number, then skip the function prologue if necessary. */
6803 if (sal
->explicit_line
)
6805 /* Preserve the original line number. */
6806 int saved_line
= sal
->line
;
6807 skip_prologue_sal (sal
);
6808 sal
->line
= saved_line
;
6812 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
6814 struct blockvector
*bv
;
6818 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
6821 sym
= block_linkage_function (b
);
6824 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
6825 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
6829 /* It really is worthwhile to have the section, so we'll just
6830 have to look harder. This case can be executed if we have
6831 line numbers but no functions (as can happen in assembly
6834 struct minimal_symbol
*msym
;
6835 struct cleanup
*old_chain
= save_current_space_and_thread ();
6837 switch_to_program_space_and_thread (sal
->pspace
);
6839 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
6841 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
6843 do_cleanups (old_chain
);
6850 break_command (char *arg
, int from_tty
)
6852 break_command_1 (arg
, 0, from_tty
);
6856 tbreak_command (char *arg
, int from_tty
)
6858 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
6862 hbreak_command (char *arg
, int from_tty
)
6864 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
6868 thbreak_command (char *arg
, int from_tty
)
6870 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
6874 stop_command (char *arg
, int from_tty
)
6876 printf_filtered (_("Specify the type of breakpoint to set.\n\
6877 Usage: stop in <function | address>\n\
6878 stop at <line>\n"));
6882 stopin_command (char *arg
, int from_tty
)
6886 if (arg
== (char *) NULL
)
6888 else if (*arg
!= '*')
6893 /* look for a ':'. If this is a line number specification, then
6894 say it is bad, otherwise, it should be an address or
6895 function/method name */
6896 while (*argptr
&& !hasColon
)
6898 hasColon
= (*argptr
== ':');
6903 badInput
= (*argptr
!= ':'); /* Not a class::method */
6905 badInput
= isdigit (*arg
); /* a simple line number */
6909 printf_filtered (_("Usage: stop in <function | address>\n"));
6911 break_command_1 (arg
, 0, from_tty
);
6915 stopat_command (char *arg
, int from_tty
)
6919 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
6926 /* look for a ':'. If there is a '::' then get out, otherwise
6927 it is probably a line number. */
6928 while (*argptr
&& !hasColon
)
6930 hasColon
= (*argptr
== ':');
6935 badInput
= (*argptr
== ':'); /* we have class::method */
6937 badInput
= !isdigit (*arg
); /* not a line number */
6941 printf_filtered (_("Usage: stop at <line>\n"));
6943 break_command_1 (arg
, 0, from_tty
);
6946 /* accessflag: hw_write: watch write,
6947 hw_read: watch read,
6948 hw_access: watch access (read or write) */
6950 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
6952 struct gdbarch
*gdbarch
= get_current_arch ();
6953 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
6954 struct symtab_and_line sal
;
6955 struct expression
*exp
;
6956 struct block
*exp_valid_block
;
6957 struct value
*val
, *mark
;
6958 struct frame_info
*frame
;
6959 char *exp_start
= NULL
;
6960 char *exp_end
= NULL
;
6961 char *tok
, *id_tok_start
, *end_tok
;
6963 char *cond_start
= NULL
;
6964 char *cond_end
= NULL
;
6965 struct expression
*cond
= NULL
;
6966 int i
, other_type_used
, target_resources_ok
= 0;
6967 enum bptype bp_type
;
6971 init_sal (&sal
); /* initialize to zeroes */
6973 /* Make sure that we actually have parameters to parse. */
6974 if (arg
!= NULL
&& arg
[0] != '\0')
6976 toklen
= strlen (arg
); /* Size of argument list. */
6978 /* Points tok to the end of the argument list. */
6979 tok
= arg
+ toklen
- 1;
6981 /* Go backwards in the parameters list. Skip the last parameter.
6982 If we're expecting a 'thread <thread_num>' parameter, this should
6983 be the thread identifier. */
6984 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
6986 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
6989 /* Points end_tok to the beginning of the last token. */
6990 id_tok_start
= tok
+ 1;
6992 /* Go backwards in the parameters list. Skip one more parameter.
6993 If we're expecting a 'thread <thread_num>' parameter, we should
6994 reach a "thread" token. */
6995 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
7000 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
7003 /* Move the pointer forward to skip the whitespace and
7004 calculate the length of the token. */
7006 toklen
= end_tok
- tok
;
7008 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7010 /* At this point we've found a "thread" token, which means
7011 the user is trying to set a watchpoint that triggers
7012 only in a specific thread. */
7015 /* Extract the thread ID from the next token. */
7016 thread
= strtol (id_tok_start
, &endp
, 0);
7018 /* Check if the user provided a valid numeric value for the
7020 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
7021 error (_("Invalid thread ID specification %s."), id_tok_start
);
7023 /* Check if the thread actually exists. */
7024 if (!valid_thread_id (thread
))
7025 error (_("Unknown thread %d."), thread
);
7027 /* Truncate the string and get rid of the thread <thread_num>
7028 parameter before the parameter list is parsed by the
7029 evaluate_expression() function. */
7034 sal
.pspace
= current_program_space
;
7036 /* Parse the rest of the arguments. */
7037 innermost_block
= NULL
;
7039 exp
= parse_exp_1 (&arg
, 0, 0);
7041 /* Remove trailing whitespace from the expression before saving it.
7042 This makes the eventual display of the expression string a bit
7044 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
7047 exp_valid_block
= innermost_block
;
7048 mark
= value_mark ();
7049 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
7051 release_value (val
);
7054 while (*tok
== ' ' || *tok
== '\t')
7058 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
7061 toklen
= end_tok
- tok
;
7062 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7064 tok
= cond_start
= end_tok
+ 1;
7065 cond
= parse_exp_1 (&tok
, 0, 0);
7069 error (_("Junk at end of command."));
7071 if (accessflag
== hw_read
)
7072 bp_type
= bp_read_watchpoint
;
7073 else if (accessflag
== hw_access
)
7074 bp_type
= bp_access_watchpoint
;
7076 bp_type
= bp_hardware_watchpoint
;
7078 mem_cnt
= can_use_hardware_watchpoint (val
);
7079 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
7080 error (_("Expression cannot be implemented with read/access watchpoint."));
7083 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
7084 target_resources_ok
=
7085 target_can_use_hardware_watchpoint (bp_type
, i
+ mem_cnt
,
7087 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
7088 error (_("Target does not support this type of hardware watchpoint."));
7090 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
7091 error (_("Target can only support one kind of HW watchpoint at a time."));
7094 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
7095 watchpoint could not be set. */
7096 if (!mem_cnt
|| target_resources_ok
<= 0)
7097 bp_type
= bp_watchpoint
;
7099 frame
= block_innermost_frame (exp_valid_block
);
7101 /* If the expression is "local", then set up a "watchpoint scope"
7102 breakpoint at the point where we've left the scope of the watchpoint
7103 expression. Create the scope breakpoint before the watchpoint, so
7104 that we will encounter it first in bpstat_stop_status. */
7105 if (innermost_block
&& frame
)
7107 if (frame_id_p (frame_unwind_caller_id (frame
)))
7110 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
7111 frame_unwind_caller_pc (frame
),
7112 bp_watchpoint_scope
);
7114 scope_breakpoint
->enable_state
= bp_enabled
;
7116 /* Automatically delete the breakpoint when it hits. */
7117 scope_breakpoint
->disposition
= disp_del
;
7119 /* Only break in the proper frame (help with recursion). */
7120 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
7122 /* Set the address at which we will stop. */
7123 scope_breakpoint
->loc
->gdbarch
7124 = frame_unwind_caller_arch (frame
);
7125 scope_breakpoint
->loc
->requested_address
7126 = frame_unwind_caller_pc (frame
);
7127 scope_breakpoint
->loc
->address
7128 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
7129 scope_breakpoint
->loc
->requested_address
,
7130 scope_breakpoint
->type
);
7134 /* Now set up the breakpoint. */
7135 b
= set_raw_breakpoint (gdbarch
, sal
, bp_type
);
7136 set_breakpoint_count (breakpoint_count
+ 1);
7137 b
->number
= breakpoint_count
;
7139 b
->disposition
= disp_donttouch
;
7141 b
->exp_valid_block
= exp_valid_block
;
7142 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
7145 b
->loc
->cond
= cond
;
7147 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
7152 b
->watchpoint_frame
= get_frame_id (frame
);
7154 b
->watchpoint_frame
= null_frame_id
;
7156 if (scope_breakpoint
!= NULL
)
7158 /* The scope breakpoint is related to the watchpoint. We will
7159 need to act on them together. */
7160 b
->related_breakpoint
= scope_breakpoint
;
7161 scope_breakpoint
->related_breakpoint
= b
;
7164 value_free_to_mark (mark
);
7166 update_global_location_list (1);
7169 /* Return count of locations need to be watched and can be handled
7170 in hardware. If the watchpoint can not be handled
7171 in hardware return zero. */
7174 can_use_hardware_watchpoint (struct value
*v
)
7176 int found_memory_cnt
= 0;
7177 struct value
*head
= v
;
7179 /* Did the user specifically forbid us to use hardware watchpoints? */
7180 if (!can_use_hw_watchpoints
)
7183 /* Make sure that the value of the expression depends only upon
7184 memory contents, and values computed from them within GDB. If we
7185 find any register references or function calls, we can't use a
7186 hardware watchpoint.
7188 The idea here is that evaluating an expression generates a series
7189 of values, one holding the value of every subexpression. (The
7190 expression a*b+c has five subexpressions: a, b, a*b, c, and
7191 a*b+c.) GDB's values hold almost enough information to establish
7192 the criteria given above --- they identify memory lvalues,
7193 register lvalues, computed values, etcetera. So we can evaluate
7194 the expression, and then scan the chain of values that leaves
7195 behind to decide whether we can detect any possible change to the
7196 expression's final value using only hardware watchpoints.
7198 However, I don't think that the values returned by inferior
7199 function calls are special in any way. So this function may not
7200 notice that an expression involving an inferior function call
7201 can't be watched with hardware watchpoints. FIXME. */
7202 for (; v
; v
= value_next (v
))
7204 if (VALUE_LVAL (v
) == lval_memory
)
7207 /* A lazy memory lvalue is one that GDB never needed to fetch;
7208 we either just used its address (e.g., `a' in `a.b') or
7209 we never needed it at all (e.g., `a' in `a,b'). */
7213 /* Ahh, memory we actually used! Check if we can cover
7214 it with hardware watchpoints. */
7215 struct type
*vtype
= check_typedef (value_type (v
));
7217 /* We only watch structs and arrays if user asked for it
7218 explicitly, never if they just happen to appear in a
7219 middle of some value chain. */
7221 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
7222 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
7224 CORE_ADDR vaddr
= value_address (v
);
7225 int len
= TYPE_LENGTH (value_type (v
));
7227 if (!target_region_ok_for_hw_watchpoint (vaddr
, len
))
7234 else if (VALUE_LVAL (v
) != not_lval
7235 && deprecated_value_modifiable (v
) == 0)
7236 return 0; /* ??? What does this represent? */
7237 else if (VALUE_LVAL (v
) == lval_register
)
7238 return 0; /* cannot watch a register with a HW watchpoint */
7241 /* The expression itself looks suitable for using a hardware
7242 watchpoint, but give the target machine a chance to reject it. */
7243 return found_memory_cnt
;
7247 watch_command_wrapper (char *arg
, int from_tty
)
7249 watch_command (arg
, from_tty
);
7253 watch_command (char *arg
, int from_tty
)
7255 watch_command_1 (arg
, hw_write
, from_tty
);
7259 rwatch_command_wrapper (char *arg
, int from_tty
)
7261 rwatch_command (arg
, from_tty
);
7265 rwatch_command (char *arg
, int from_tty
)
7267 watch_command_1 (arg
, hw_read
, from_tty
);
7271 awatch_command_wrapper (char *arg
, int from_tty
)
7273 awatch_command (arg
, from_tty
);
7277 awatch_command (char *arg
, int from_tty
)
7279 watch_command_1 (arg
, hw_access
, from_tty
);
7283 /* Helper routines for the until_command routine in infcmd.c. Here
7284 because it uses the mechanisms of breakpoints. */
7286 struct until_break_command_continuation_args
7288 struct breakpoint
*breakpoint
;
7289 struct breakpoint
*breakpoint2
;
7292 /* This function is called by fetch_inferior_event via the
7293 cmd_continuation pointer, to complete the until command. It takes
7294 care of cleaning up the temporary breakpoints set up by the until
7297 until_break_command_continuation (void *arg
)
7299 struct until_break_command_continuation_args
*a
= arg
;
7301 delete_breakpoint (a
->breakpoint
);
7303 delete_breakpoint (a
->breakpoint2
);
7307 until_break_command (char *arg
, int from_tty
, int anywhere
)
7309 struct symtabs_and_lines sals
;
7310 struct symtab_and_line sal
;
7311 struct frame_info
*frame
= get_selected_frame (NULL
);
7312 struct breakpoint
*breakpoint
;
7313 struct breakpoint
*breakpoint2
= NULL
;
7314 struct cleanup
*old_chain
;
7316 clear_proceed_status ();
7318 /* Set a breakpoint where the user wants it and at return from
7321 if (default_breakpoint_valid
)
7322 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
7323 default_breakpoint_line
, (char ***) NULL
, NULL
);
7325 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
7326 0, (char ***) NULL
, NULL
);
7328 if (sals
.nelts
!= 1)
7329 error (_("Couldn't get information on specified line."));
7332 xfree (sals
.sals
); /* malloc'd, so freed */
7335 error (_("Junk at end of arguments."));
7337 resolve_sal_pc (&sal
);
7340 /* If the user told us to continue until a specified location,
7341 we don't specify a frame at which we need to stop. */
7342 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
7343 null_frame_id
, bp_until
);
7345 /* Otherwise, specify the selected frame, because we want to stop only
7346 at the very same frame. */
7347 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
7348 get_stack_frame_id (frame
),
7351 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
7353 /* Keep within the current frame, or in frames called by the current
7356 if (frame_id_p (frame_unwind_caller_id (frame
)))
7358 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
7359 sal
.pc
= frame_unwind_caller_pc (frame
);
7360 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
7362 frame_unwind_caller_id (frame
),
7364 make_cleanup_delete_breakpoint (breakpoint2
);
7367 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
7369 /* If we are running asynchronously, and proceed call above has actually
7370 managed to start the target, arrange for breakpoints to be
7371 deleted when the target stops. Otherwise, we're already stopped and
7372 delete breakpoints via cleanup chain. */
7374 if (target_can_async_p () && is_running (inferior_ptid
))
7376 struct until_break_command_continuation_args
*args
;
7377 args
= xmalloc (sizeof (*args
));
7379 args
->breakpoint
= breakpoint
;
7380 args
->breakpoint2
= breakpoint2
;
7382 discard_cleanups (old_chain
);
7383 add_continuation (inferior_thread (),
7384 until_break_command_continuation
, args
,
7388 do_cleanups (old_chain
);
7392 ep_skip_leading_whitespace (char **s
)
7394 if ((s
== NULL
) || (*s
== NULL
))
7396 while (isspace (**s
))
7400 /* This function attempts to parse an optional "if <cond>" clause
7401 from the arg string. If one is not found, it returns NULL.
7403 Else, it returns a pointer to the condition string. (It does not
7404 attempt to evaluate the string against a particular block.) And,
7405 it updates arg to point to the first character following the parsed
7406 if clause in the arg string. */
7409 ep_parse_optional_if_clause (char **arg
)
7413 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
7416 /* Skip the "if" keyword. */
7419 /* Skip any extra leading whitespace, and record the start of the
7420 condition string. */
7421 ep_skip_leading_whitespace (arg
);
7424 /* Assume that the condition occupies the remainder of the arg string. */
7425 (*arg
) += strlen (cond_string
);
7430 /* This function attempts to parse an optional filename from the arg
7431 string. If one is not found, it returns NULL.
7433 Else, it returns a pointer to the parsed filename. (This function
7434 makes no attempt to verify that a file of that name exists, or is
7435 accessible.) And, it updates arg to point to the first character
7436 following the parsed filename in the arg string.
7438 Note that clients needing to preserve the returned filename for
7439 future access should copy it to their own buffers. */
7441 ep_parse_optional_filename (char **arg
)
7443 static char filename
[1024];
7448 if ((*arg_p
== '\0') || isspace (*arg_p
))
7466 /* Commands to deal with catching events, such as signals, exceptions,
7467 process start/exit, etc. */
7471 catch_fork_temporary
, catch_vfork_temporary
,
7472 catch_fork_permanent
, catch_vfork_permanent
7477 catch_fork_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7479 struct gdbarch
*gdbarch
= get_current_arch ();
7480 char *cond_string
= NULL
;
7481 catch_fork_kind fork_kind
;
7484 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
7485 tempflag
= (fork_kind
== catch_fork_temporary
7486 || fork_kind
== catch_vfork_temporary
);
7490 ep_skip_leading_whitespace (&arg
);
7492 /* The allowed syntax is:
7494 catch [v]fork if <cond>
7496 First, check if there's an if clause. */
7497 cond_string
= ep_parse_optional_if_clause (&arg
);
7499 if ((*arg
!= '\0') && !isspace (*arg
))
7500 error (_("Junk at end of arguments."));
7502 /* If this target supports it, create a fork or vfork catchpoint
7503 and enable reporting of such events. */
7506 case catch_fork_temporary
:
7507 case catch_fork_permanent
:
7508 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
7509 &catch_fork_breakpoint_ops
);
7511 case catch_vfork_temporary
:
7512 case catch_vfork_permanent
:
7513 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
7514 &catch_vfork_breakpoint_ops
);
7517 error (_("unsupported or unknown fork kind; cannot catch it"));
7523 catch_exec_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7525 struct gdbarch
*gdbarch
= get_current_arch ();
7527 char *cond_string
= NULL
;
7529 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7533 ep_skip_leading_whitespace (&arg
);
7535 /* The allowed syntax is:
7537 catch exec if <cond>
7539 First, check if there's an if clause. */
7540 cond_string
= ep_parse_optional_if_clause (&arg
);
7542 if ((*arg
!= '\0') && !isspace (*arg
))
7543 error (_("Junk at end of arguments."));
7545 /* If this target supports it, create an exec catchpoint
7546 and enable reporting of such events. */
7547 create_catchpoint (gdbarch
, tempflag
, cond_string
,
7548 &catch_exec_breakpoint_ops
);
7551 static enum print_stop_action
7552 print_exception_catchpoint (struct breakpoint
*b
)
7554 int bp_temp
, bp_throw
;
7556 annotate_catchpoint (b
->number
);
7558 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
7559 if (b
->loc
->address
!= b
->loc
->requested_address
)
7560 breakpoint_adjustment_warning (b
->loc
->requested_address
,
7563 bp_temp
= b
->disposition
== disp_del
;
7565 bp_temp
? "Temporary catchpoint "
7567 if (!ui_out_is_mi_like_p (uiout
))
7568 ui_out_field_int (uiout
, "bkptno", b
->number
);
7570 bp_throw
? " (exception thrown), "
7571 : " (exception caught), ");
7572 if (ui_out_is_mi_like_p (uiout
))
7574 ui_out_field_string (uiout
, "reason",
7575 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
7576 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
7577 ui_out_field_int (uiout
, "bkptno", b
->number
);
7579 return PRINT_SRC_AND_LOC
;
7583 print_one_exception_catchpoint (struct breakpoint
*b
, struct bp_location
**last_loc
)
7585 struct value_print_options opts
;
7586 get_user_print_options (&opts
);
7587 if (opts
.addressprint
)
7590 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
7591 ui_out_field_string (uiout
, "addr", "<PENDING>");
7593 ui_out_field_core_addr (uiout
, "addr",
7594 b
->loc
->gdbarch
, b
->loc
->address
);
7599 if (strstr (b
->addr_string
, "throw") != NULL
)
7600 ui_out_field_string (uiout
, "what", "exception throw");
7602 ui_out_field_string (uiout
, "what", "exception catch");
7606 print_mention_exception_catchpoint (struct breakpoint
*b
)
7611 bp_temp
= b
->disposition
== disp_del
;
7612 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
7613 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
7614 : _("Catchpoint "));
7615 ui_out_field_int (uiout
, "bkptno", b
->number
);
7616 ui_out_text (uiout
, bp_throw
? _(" (throw)")
7620 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
7623 NULL
, /* breakpoint_hit */
7624 print_exception_catchpoint
,
7625 print_one_exception_catchpoint
,
7626 print_mention_exception_catchpoint
7630 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
7631 enum exception_event_kind ex_event
, int from_tty
)
7633 char *trigger_func_name
;
7635 if (ex_event
== EX_EVENT_CATCH
)
7636 trigger_func_name
= "__cxa_begin_catch";
7638 trigger_func_name
= "__cxa_throw";
7640 break_command_really (get_current_arch (),
7641 trigger_func_name
, cond_string
, -1,
7642 0 /* condition and thread are valid. */,
7645 AUTO_BOOLEAN_TRUE
/* pending */,
7646 &gnu_v3_exception_catchpoint_ops
, from_tty
,
7652 /* Deal with "catch catch" and "catch throw" commands */
7655 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
7656 int tempflag
, int from_tty
)
7658 char *cond_string
= NULL
;
7659 struct symtab_and_line
*sal
= NULL
;
7663 ep_skip_leading_whitespace (&arg
);
7665 cond_string
= ep_parse_optional_if_clause (&arg
);
7667 if ((*arg
!= '\0') && !isspace (*arg
))
7668 error (_("Junk at end of arguments."));
7670 if (ex_event
!= EX_EVENT_THROW
7671 && ex_event
!= EX_EVENT_CATCH
)
7672 error (_("Unsupported or unknown exception event; cannot catch it"));
7674 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
7677 warning (_("Unsupported with this platform/compiler combination."));
7680 /* Implementation of "catch catch" command. */
7683 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7685 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7686 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
7689 /* Implementation of "catch throw" command. */
7692 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7694 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7695 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
7698 /* Create a breakpoint struct for Ada exception catchpoints. */
7701 create_ada_exception_breakpoint (struct gdbarch
*gdbarch
,
7702 struct symtab_and_line sal
,
7706 struct expression
*cond
,
7707 struct breakpoint_ops
*ops
,
7711 struct breakpoint
*b
;
7715 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
7717 loc_gdbarch
= gdbarch
;
7719 describe_other_breakpoints (loc_gdbarch
,
7720 sal
.pspace
, sal
.pc
, sal
.section
, -1);
7721 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
7722 version for exception catchpoints, because two catchpoints
7723 used for different exception names will use the same address.
7724 In this case, a "breakpoint ... also set at..." warning is
7725 unproductive. Besides. the warning phrasing is also a bit
7726 inapropriate, we should use the word catchpoint, and tell
7727 the user what type of catchpoint it is. The above is good
7728 enough for now, though. */
7731 b
= set_raw_breakpoint (gdbarch
, sal
, bp_breakpoint
);
7732 set_breakpoint_count (breakpoint_count
+ 1);
7734 b
->enable_state
= bp_enabled
;
7735 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
7736 b
->number
= breakpoint_count
;
7737 b
->ignore_count
= 0;
7738 b
->loc
->cond
= cond
;
7739 b
->addr_string
= addr_string
;
7740 b
->language
= language_ada
;
7741 b
->cond_string
= cond_string
;
7742 b
->exp_string
= exp_string
;
7747 update_global_location_list (1);
7750 /* Implement the "catch exception" command. */
7753 catch_ada_exception_command (char *arg
, int from_tty
,
7754 struct cmd_list_element
*command
)
7756 struct gdbarch
*gdbarch
= get_current_arch ();
7758 struct symtab_and_line sal
;
7760 char *addr_string
= NULL
;
7761 char *exp_string
= NULL
;
7762 char *cond_string
= NULL
;
7763 struct expression
*cond
= NULL
;
7764 struct breakpoint_ops
*ops
= NULL
;
7766 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7770 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
7771 &cond_string
, &cond
, &ops
);
7772 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, exp_string
,
7773 cond_string
, cond
, ops
, tempflag
,
7777 /* Cleanup function for a syscall filter list. */
7779 clean_up_filters (void *arg
)
7781 VEC(int) *iter
= *(VEC(int) **) arg
;
7782 VEC_free (int, iter
);
7785 /* Splits the argument using space as delimiter. Returns an xmalloc'd
7786 filter list, or NULL if no filtering is required. */
7788 catch_syscall_split_args (char *arg
)
7790 VEC(int) *result
= NULL
;
7791 struct cleanup
*cleanup
= make_cleanup (clean_up_filters
, &result
);
7793 while (*arg
!= '\0')
7795 int i
, syscall_number
;
7800 /* Skip whitespace. */
7801 while (isspace (*arg
))
7804 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
7805 cur_name
[i
] = arg
[i
];
7809 /* Check if the user provided a syscall name or a number. */
7810 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
7811 if (*endptr
== '\0')
7812 get_syscall_by_number (syscall_number
, &s
);
7815 /* We have a name. Let's check if it's valid and convert it
7817 get_syscall_by_name (cur_name
, &s
);
7819 if (s
.number
== UNKNOWN_SYSCALL
)
7820 /* Here we have to issue an error instead of a warning, because
7821 GDB cannot do anything useful if there's no syscall number to
7823 error (_("Unknown syscall name '%s'."), cur_name
);
7826 /* Ok, it's valid. */
7827 VEC_safe_push (int, result
, s
.number
);
7830 discard_cleanups (cleanup
);
7834 /* Implement the "catch syscall" command. */
7837 catch_syscall_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7842 struct gdbarch
*gdbarch
= get_current_arch ();
7844 /* Checking if the feature if supported. */
7845 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
7846 error (_("The feature 'catch syscall' is not supported on \
7847 this architeture yet."));
7849 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7851 ep_skip_leading_whitespace (&arg
);
7853 /* We need to do this first "dummy" translation in order
7854 to get the syscall XML file loaded or, most important,
7855 to display a warning to the user if there's no XML file
7856 for his/her architecture. */
7857 get_syscall_by_number (0, &s
);
7859 /* The allowed syntax is:
7861 catch syscall <name | number> [<name | number> ... <name | number>]
7863 Let's check if there's a syscall name. */
7866 filter
= catch_syscall_split_args (arg
);
7870 create_syscall_event_catchpoint (tempflag
, filter
,
7871 &catch_syscall_breakpoint_ops
);
7874 /* Implement the "catch assert" command. */
7877 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
7879 struct gdbarch
*gdbarch
= get_current_arch ();
7881 struct symtab_and_line sal
;
7882 char *addr_string
= NULL
;
7883 struct breakpoint_ops
*ops
= NULL
;
7885 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
7889 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
7890 create_ada_exception_breakpoint (gdbarch
, sal
, addr_string
, NULL
, NULL
, NULL
,
7891 ops
, tempflag
, from_tty
);
7895 catch_command (char *arg
, int from_tty
)
7897 error (_("Catch requires an event name."));
7902 tcatch_command (char *arg
, int from_tty
)
7904 error (_("Catch requires an event name."));
7907 /* Delete breakpoints by address or line. */
7910 clear_command (char *arg
, int from_tty
)
7912 struct breakpoint
*b
;
7913 VEC(breakpoint_p
) *found
= 0;
7916 struct symtabs_and_lines sals
;
7917 struct symtab_and_line sal
;
7922 sals
= decode_line_spec (arg
, 1);
7927 sals
.sals
= (struct symtab_and_line
*)
7928 xmalloc (sizeof (struct symtab_and_line
));
7929 make_cleanup (xfree
, sals
.sals
);
7930 init_sal (&sal
); /* initialize to zeroes */
7931 sal
.line
= default_breakpoint_line
;
7932 sal
.symtab
= default_breakpoint_symtab
;
7933 sal
.pc
= default_breakpoint_address
;
7934 sal
.pspace
= default_breakpoint_pspace
;
7935 if (sal
.symtab
== 0)
7936 error (_("No source file specified."));
7944 /* We don't call resolve_sal_pc here. That's not
7945 as bad as it seems, because all existing breakpoints
7946 typically have both file/line and pc set. So, if
7947 clear is given file/line, we can match this to existing
7948 breakpoint without obtaining pc at all.
7950 We only support clearing given the address explicitly
7951 present in breakpoint table. Say, we've set breakpoint
7952 at file:line. There were several PC values for that file:line,
7953 due to optimization, all in one block.
7954 We've picked one PC value. If "clear" is issued with another
7955 PC corresponding to the same file:line, the breakpoint won't
7956 be cleared. We probably can still clear the breakpoint, but
7957 since the other PC value is never presented to user, user
7958 can only find it by guessing, and it does not seem important
7961 /* For each line spec given, delete bps which correspond
7962 to it. Do it in two passes, solely to preserve the current
7963 behavior that from_tty is forced true if we delete more than
7967 for (i
= 0; i
< sals
.nelts
; i
++)
7969 /* If exact pc given, clear bpts at that pc.
7970 If line given (pc == 0), clear all bpts on specified line.
7971 If defaulting, clear all bpts on default line
7974 defaulting sal.pc != 0 tests to do
7979 1 0 <can't happen> */
7983 /* Find all matching breakpoints and add them to
7988 /* Are we going to delete b? */
7989 if (b
->type
!= bp_none
7990 && b
->type
!= bp_watchpoint
7991 && b
->type
!= bp_hardware_watchpoint
7992 && b
->type
!= bp_read_watchpoint
7993 && b
->type
!= bp_access_watchpoint
)
7995 struct bp_location
*loc
= b
->loc
;
7996 for (; loc
; loc
= loc
->next
)
7998 int pc_match
= sal
.pc
7999 && (loc
->pspace
== sal
.pspace
)
8000 && (loc
->address
== sal
.pc
)
8001 && (!section_is_overlay (loc
->section
)
8002 || loc
->section
== sal
.section
);
8003 int line_match
= ((default_match
|| (0 == sal
.pc
))
8004 && b
->source_file
!= NULL
8005 && sal
.symtab
!= NULL
8006 && sal
.pspace
== loc
->pspace
8007 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
8008 && b
->line_number
== sal
.line
);
8009 if (pc_match
|| line_match
)
8018 VEC_safe_push(breakpoint_p
, found
, b
);
8021 /* Now go thru the 'found' chain and delete them. */
8022 if (VEC_empty(breakpoint_p
, found
))
8025 error (_("No breakpoint at %s."), arg
);
8027 error (_("No breakpoint at this line."));
8030 if (VEC_length(breakpoint_p
, found
) > 1)
8031 from_tty
= 1; /* Always report if deleted more than one */
8034 if (VEC_length(breakpoint_p
, found
) == 1)
8035 printf_unfiltered (_("Deleted breakpoint "));
8037 printf_unfiltered (_("Deleted breakpoints "));
8039 breakpoints_changed ();
8041 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
8044 printf_unfiltered ("%d ", b
->number
);
8045 delete_breakpoint (b
);
8048 putchar_unfiltered ('\n');
8051 /* Delete breakpoint in BS if they are `delete' breakpoints and
8052 all breakpoints that are marked for deletion, whether hit or not.
8053 This is called after any breakpoint is hit, or after errors. */
8056 breakpoint_auto_delete (bpstat bs
)
8058 struct breakpoint
*b
, *temp
;
8060 for (; bs
; bs
= bs
->next
)
8061 if (bs
->breakpoint_at
8062 && bs
->breakpoint_at
->owner
8063 && bs
->breakpoint_at
->owner
->disposition
== disp_del
8065 delete_breakpoint (bs
->breakpoint_at
->owner
);
8067 ALL_BREAKPOINTS_SAFE (b
, temp
)
8069 if (b
->disposition
== disp_del_at_next_stop
)
8070 delete_breakpoint (b
);
8074 /* A comparison function for bp_location A and B being interfaced to qsort.
8075 Sort elements primarily by their ADDRESS (no matter what does
8076 breakpoint_address_is_meaningful say for its OWNER), secondarily by ordering
8077 first bp_permanent OWNERed elements and terciarily just ensuring the array
8078 is sorted stable way despite qsort being an instable algorithm. */
8081 bp_location_compare (struct bp_location
*a
, struct bp_location
*b
)
8083 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
8084 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
8086 if (a
->address
!= b
->address
)
8087 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
8089 /* Sort permanent breakpoints first. */
8090 if (a_perm
!= b_perm
)
8091 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
8093 /* Make the user-visible order stable across GDB runs. Locations of the same
8094 breakpoint can be sorted in arbitrary order. */
8096 if (a
->owner
->number
!= b
->owner
->number
)
8097 return (a
->owner
->number
> b
->owner
->number
)
8098 - (a
->owner
->number
< b
->owner
->number
);
8100 return (a
> b
) - (a
< b
);
8103 /* Interface bp_location_compare as the COMPAR parameter of qsort function. */
8106 bp_location_compare_for_qsort (const void *ap
, const void *bp
)
8108 struct bp_location
*a
= *(void **) ap
;
8109 struct bp_location
*b
= *(void **) bp
;
8111 return bp_location_compare (a
, b
);
8114 /* Set bp_location_placed_address_before_address_max and
8115 bp_location_shadow_len_after_address_max according to the current content of
8116 the bp_location array. */
8119 bp_location_target_extensions_update (void)
8121 struct bp_location
*bl
, **blp_tmp
;
8123 bp_location_placed_address_before_address_max
= 0;
8124 bp_location_shadow_len_after_address_max
= 0;
8126 ALL_BP_LOCATIONS (bl
, blp_tmp
)
8128 CORE_ADDR start
, end
, addr
;
8130 if (!bp_location_has_shadow (bl
))
8133 start
= bl
->target_info
.placed_address
;
8134 end
= start
+ bl
->target_info
.shadow_len
;
8136 gdb_assert (bl
->address
>= start
);
8137 addr
= bl
->address
- start
;
8138 if (addr
> bp_location_placed_address_before_address_max
)
8139 bp_location_placed_address_before_address_max
= addr
;
8141 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
8143 gdb_assert (bl
->address
< end
);
8144 addr
= end
- bl
->address
;
8145 if (addr
> bp_location_shadow_len_after_address_max
)
8146 bp_location_shadow_len_after_address_max
= addr
;
8150 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
8151 into the inferior, only remove already-inserted locations that no
8152 longer should be inserted. Functions that delete a breakpoint or
8153 breakpoints should pass false, so that deleting a breakpoint
8154 doesn't have the side effect of inserting the locations of other
8155 breakpoints that are marked not-inserted, but should_be_inserted
8156 returns true on them.
8158 This behaviour is useful is situations close to tear-down -- e.g.,
8159 after an exec, while the target still has execution, but breakpoint
8160 shadows of the previous executable image should *NOT* be restored
8161 to the new image; or before detaching, where the target still has
8162 execution and wants to delete breakpoints from GDB's lists, and all
8163 breakpoints had already been removed from the inferior. */
8166 update_global_location_list (int should_insert
)
8168 struct breakpoint
*b
;
8169 struct bp_location
**locp
, *loc
;
8170 struct cleanup
*cleanups
;
8172 /* The first bp_location being the only one non-DUPLICATE for the current run
8173 of the same ADDRESS. */
8174 struct bp_location
*loc_first
;
8176 /* Saved former bp_location array which we compare against the newly built
8177 bp_location from the current state of ALL_BREAKPOINTS. */
8178 struct bp_location
**old_location
, **old_locp
;
8179 unsigned old_location_count
;
8181 old_location
= bp_location
;
8182 old_location_count
= bp_location_count
;
8184 bp_location_count
= 0;
8185 cleanups
= make_cleanup (xfree
, old_location
);
8188 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
8189 bp_location_count
++;
8191 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
8194 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
8196 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
8197 bp_location_compare_for_qsort
);
8199 bp_location_target_extensions_update ();
8201 /* Identify bp_location instances that are no longer present in the new
8202 list, and therefore should be freed. Note that it's not necessary that
8203 those locations should be removed from inferior -- if there's another
8204 location at the same address (previously marked as duplicate),
8205 we don't need to remove/insert the location.
8207 LOCP is kept in sync with OLD_LOCP, each pointing to the current and
8208 former bp_location array state respectively. */
8211 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
8214 struct bp_location
*old_loc
= *old_locp
;
8216 /* Tells if 'old_loc' is found amoung the new locations. If not, we
8219 /* Tells if the location should remain inserted in the target. */
8220 int keep_in_target
= 0;
8223 /* Skip LOCP entries which will definitely never be needed. Stop either
8224 at or being the one matching OLD_LOC. */
8225 while (locp
< bp_location
+ bp_location_count
8226 && bp_location_compare (*locp
, old_loc
) < 0)
8228 found_object
= locp
< bp_location
+ bp_location_count
&& *locp
== old_loc
;
8230 /* If this location is no longer present, and inserted, look if there's
8231 maybe a new location at the same address. If so, mark that one
8232 inserted, and don't remove this one. This is needed so that we
8233 don't have a time window where a breakpoint at certain location is not
8236 if (old_loc
->inserted
)
8238 /* If the location is inserted now, we might have to remove it. */
8240 if (found_object
&& should_be_inserted (old_loc
))
8242 /* The location is still present in the location list, and still
8243 should be inserted. Don't do anything. */
8248 /* The location is either no longer present, or got disabled.
8249 See if there's another location at the same address, in which
8250 case we don't need to remove this one from the target. */
8252 if (breakpoint_address_is_meaningful (old_loc
->owner
))
8254 struct bp_location
**loc2p
;
8257 loc2p
< bp_location
+ bp_location_count
8258 && breakpoint_address_match ((*loc2p
)->pspace
->aspace
,
8260 old_loc
->pspace
->aspace
,
8264 struct bp_location
*loc2
= *loc2p
;
8266 /* For the sake of should_be_inserted.
8267 Duplicates check below will fix up this later. */
8268 loc2
->duplicate
= 0;
8269 if (loc2
!= old_loc
&& should_be_inserted (loc2
))
8272 loc2
->target_info
= old_loc
->target_info
;
8280 if (!keep_in_target
)
8282 if (remove_breakpoint (old_loc
, mark_uninserted
))
8284 /* This is just about all we can do. We could keep this
8285 location on the global list, and try to remove it next
8286 time, but there's no particular reason why we will
8289 Note that at this point, old_loc->owner is still valid,
8290 as delete_breakpoint frees the breakpoint only
8291 after calling us. */
8292 printf_filtered (_("warning: Error removing breakpoint %d\n"),
8293 old_loc
->owner
->number
);
8301 if (removed
&& non_stop
)
8303 /* This location was removed from the targets. In non-stop mode,
8304 a race condition is possible where we've removed a breakpoint,
8305 but stop events for that breakpoint are already queued and will
8306 arrive later. To suppress spurious SIGTRAPs reported to user,
8307 we keep this breakpoint location for a bit, and will retire it
8308 after we see 3 * thread_count events.
8309 The theory here is that reporting of events should,
8310 "on the average", be fair, so after that many event we'll see
8311 events from all threads that have anything of interest, and no
8312 longer need to keep this breakpoint. This is just a
8313 heuristic, but if it's wrong, we'll report unexpected SIGTRAP,
8314 which is usability issue, but not a correctness problem. */
8315 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
8316 old_loc
->owner
= NULL
;
8318 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
8321 free_bp_location (old_loc
);
8325 /* Rescan breakpoints at the same address and section,
8326 marking the first one as "first" and any others as "duplicates".
8327 This is so that the bpt instruction is only inserted once.
8328 If we have a permanent breakpoint at the same place as BPT, make
8329 that one the official one, and the rest as duplicates. Permanent
8330 breakpoints are sorted first for the same address. */
8333 ALL_BP_LOCATIONS (loc
, locp
)
8335 struct breakpoint
*b
= loc
->owner
;
8337 if (b
->enable_state
== bp_disabled
8338 || b
->enable_state
== bp_call_disabled
8339 || b
->enable_state
== bp_startup_disabled
8341 || loc
->shlib_disabled
8342 || !breakpoint_address_is_meaningful (b
))
8345 /* Permanent breakpoint should always be inserted. */
8346 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
8347 internal_error (__FILE__
, __LINE__
,
8348 _("allegedly permanent breakpoint is not "
8349 "actually inserted"));
8351 if (loc_first
== NULL
8352 || (overlay_debugging
&& loc
->section
!= loc_first
->section
)
8353 || !breakpoint_address_match (loc
->pspace
->aspace
, loc
->address
,
8354 loc_first
->pspace
->aspace
,
8355 loc_first
->address
))
8364 if (loc_first
->owner
->enable_state
== bp_permanent
&& loc
->inserted
8365 && b
->enable_state
!= bp_permanent
)
8366 internal_error (__FILE__
, __LINE__
,
8367 _("another breakpoint was inserted on top of "
8368 "a permanent breakpoint"));
8371 if (breakpoints_always_inserted_mode () && should_insert
8372 && (have_live_inferiors ()
8373 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
8374 insert_breakpoint_locations ();
8376 do_cleanups (cleanups
);
8380 breakpoint_retire_moribund (void)
8382 struct bp_location
*loc
;
8385 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
8386 if (--(loc
->events_till_retirement
) == 0)
8388 free_bp_location (loc
);
8389 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
8395 update_global_location_list_nothrow (int inserting
)
8397 struct gdb_exception e
;
8398 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8399 update_global_location_list (inserting
);
8402 /* Clear BPT from a BPS. */
8404 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
8407 for (bs
= bps
; bs
; bs
= bs
->next
)
8408 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
8410 bs
->breakpoint_at
= NULL
;
8412 /* bs->commands will be freed later. */
8416 /* Callback for iterate_over_threads. */
8418 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
8420 struct breakpoint
*bpt
= data
;
8421 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
8425 /* Delete a breakpoint and clean up all traces of it in the data
8429 delete_breakpoint (struct breakpoint
*bpt
)
8431 struct breakpoint
*b
;
8432 struct bp_location
*loc
, *next
;
8434 gdb_assert (bpt
!= NULL
);
8436 /* Has this bp already been deleted? This can happen because multiple
8437 lists can hold pointers to bp's. bpstat lists are especial culprits.
8439 One example of this happening is a watchpoint's scope bp. When the
8440 scope bp triggers, we notice that the watchpoint is out of scope, and
8441 delete it. We also delete its scope bp. But the scope bp is marked
8442 "auto-deleting", and is already on a bpstat. That bpstat is then
8443 checked for auto-deleting bp's, which are deleted.
8445 A real solution to this problem might involve reference counts in bp's,
8446 and/or giving them pointers back to their referencing bpstat's, and
8447 teaching delete_breakpoint to only free a bp's storage when no more
8448 references were extent. A cheaper bandaid was chosen. */
8449 if (bpt
->type
== bp_none
)
8452 observer_notify_breakpoint_deleted (bpt
->number
);
8454 if (breakpoint_chain
== bpt
)
8455 breakpoint_chain
= bpt
->next
;
8460 b
->next
= bpt
->next
;
8464 free_command_lines (&bpt
->commands
);
8465 if (bpt
->cond_string
!= NULL
)
8466 xfree (bpt
->cond_string
);
8467 if (bpt
->addr_string
!= NULL
)
8468 xfree (bpt
->addr_string
);
8469 if (bpt
->exp
!= NULL
)
8471 if (bpt
->exp_string
!= NULL
)
8472 xfree (bpt
->exp_string
);
8473 if (bpt
->val
!= NULL
)
8474 value_free (bpt
->val
);
8475 if (bpt
->source_file
!= NULL
)
8476 xfree (bpt
->source_file
);
8477 if (bpt
->exec_pathname
!= NULL
)
8478 xfree (bpt
->exec_pathname
);
8479 clean_up_filters (&bpt
->syscalls_to_be_caught
);
8481 /* Be sure no bpstat's are pointing at it after it's been freed. */
8482 /* FIXME, how can we find all bpstat's?
8483 We just check stop_bpstat for now. Note that we cannot just
8484 remove bpstats pointing at bpt from the stop_bpstat list
8485 entirely, as breakpoint commands are associated with the bpstat;
8486 if we remove it here, then the later call to
8487 bpstat_do_actions (&stop_bpstat);
8488 in event-top.c won't do anything, and temporary breakpoints
8489 with commands won't work. */
8491 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
8493 /* Now that breakpoint is removed from breakpoint
8494 list, update the global location list. This
8495 will remove locations that used to belong to
8496 this breakpoint. Do this before freeing
8497 the breakpoint itself, since remove_breakpoint
8498 looks at location's owner. It might be better
8499 design to have location completely self-contained,
8500 but it's not the case now. */
8501 update_global_location_list (0);
8504 /* On the chance that someone will soon try again to delete this same
8505 bp, we mark it as deleted before freeing its storage. */
8506 bpt
->type
= bp_none
;
8512 do_delete_breakpoint_cleanup (void *b
)
8514 delete_breakpoint (b
);
8518 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
8520 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
8524 delete_command (char *arg
, int from_tty
)
8526 struct breakpoint
*b
, *temp
;
8532 int breaks_to_delete
= 0;
8534 /* Delete all breakpoints if no argument.
8535 Do not delete internal or call-dummy breakpoints, these
8536 have to be deleted with an explicit breakpoint number argument. */
8539 if (b
->type
!= bp_call_dummy
8540 && b
->type
!= bp_shlib_event
8541 && b
->type
!= bp_jit_event
8542 && b
->type
!= bp_thread_event
8543 && b
->type
!= bp_overlay_event
8544 && b
->type
!= bp_longjmp_master
8547 breaks_to_delete
= 1;
8552 /* Ask user only if there are some breakpoints to delete. */
8554 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
8556 ALL_BREAKPOINTS_SAFE (b
, temp
)
8558 if (b
->type
!= bp_call_dummy
8559 && b
->type
!= bp_shlib_event
8560 && b
->type
!= bp_thread_event
8561 && b
->type
!= bp_jit_event
8562 && b
->type
!= bp_overlay_event
8563 && b
->type
!= bp_longjmp_master
8565 delete_breakpoint (b
);
8570 map_breakpoint_numbers (arg
, delete_breakpoint
);
8574 all_locations_are_pending (struct bp_location
*loc
)
8576 for (; loc
; loc
= loc
->next
)
8577 if (!loc
->shlib_disabled
)
8582 /* Subroutine of update_breakpoint_locations to simplify it.
8583 Return non-zero if multiple fns in list LOC have the same name.
8584 Null names are ignored. */
8587 ambiguous_names_p (struct bp_location
*loc
)
8589 struct bp_location
*l
;
8590 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
8591 (int (*) (const void *, const void *)) streq
,
8592 NULL
, xcalloc
, xfree
);
8594 for (l
= loc
; l
!= NULL
; l
= l
->next
)
8597 const char *name
= l
->function_name
;
8599 /* Allow for some names to be NULL, ignore them. */
8603 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
8605 /* NOTE: We can assume slot != NULL here because xcalloc never returns
8620 update_breakpoint_locations (struct breakpoint
*b
,
8621 struct symtabs_and_lines sals
)
8625 struct bp_location
*existing_locations
= b
->loc
;
8627 /* If there's no new locations, and all existing locations
8628 are pending, don't do anything. This optimizes
8629 the common case where all locations are in the same
8630 shared library, that was unloaded. We'd like to
8631 retain the location, so that when the library
8632 is loaded again, we don't loose the enabled/disabled
8633 status of the individual locations. */
8634 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
8639 for (i
= 0; i
< sals
.nelts
; ++i
)
8641 struct bp_location
*new_loc
=
8642 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
8644 /* Reparse conditions, they might contain references to the
8646 if (b
->cond_string
!= NULL
)
8648 struct gdb_exception e
;
8651 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8653 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
8658 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
8659 b
->number
, e
.message
);
8660 new_loc
->enabled
= 0;
8664 if (b
->source_file
!= NULL
)
8665 xfree (b
->source_file
);
8666 if (sals
.sals
[i
].symtab
== NULL
)
8667 b
->source_file
= NULL
;
8669 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
8671 if (b
->line_number
== 0)
8672 b
->line_number
= sals
.sals
[i
].line
;
8675 /* Update locations of permanent breakpoints. */
8676 if (b
->enable_state
== bp_permanent
)
8677 make_breakpoint_permanent (b
);
8679 /* If possible, carry over 'disable' status from existing breakpoints. */
8681 struct bp_location
*e
= existing_locations
;
8682 /* If there are multiple breakpoints with the same function name,
8683 e.g. for inline functions, comparing function names won't work.
8684 Instead compare pc addresses; this is just a heuristic as things
8685 may have moved, but in practice it gives the correct answer
8686 often enough until a better solution is found. */
8687 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
8689 for (; e
; e
= e
->next
)
8691 if (!e
->enabled
&& e
->function_name
)
8693 struct bp_location
*l
= b
->loc
;
8694 if (have_ambiguous_names
)
8696 for (; l
; l
= l
->next
)
8697 if (breakpoint_address_match (e
->pspace
->aspace
, e
->address
,
8698 l
->pspace
->aspace
, l
->address
))
8706 for (; l
; l
= l
->next
)
8707 if (l
->function_name
8708 && strcmp (e
->function_name
, l
->function_name
) == 0)
8718 update_global_location_list (1);
8722 /* Reset a breakpoint given it's struct breakpoint * BINT.
8723 The value we return ends up being the return value from catch_errors.
8724 Unused in this case. */
8727 breakpoint_re_set_one (void *bint
)
8729 /* get past catch_errs */
8730 struct breakpoint
*b
= (struct breakpoint
*) bint
;
8734 int *not_found_ptr
= ¬_found
;
8735 struct symtabs_and_lines sals
= {0};
8736 struct symtabs_and_lines expanded
= {0};
8738 enum enable_state save_enable
;
8739 struct gdb_exception e
;
8740 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
8745 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
8749 case bp_hardware_breakpoint
:
8751 /* Do not attempt to re-set breakpoints disabled during startup. */
8752 if (b
->enable_state
== bp_startup_disabled
)
8755 if (b
->addr_string
== NULL
)
8757 /* Anything without a string can't be re-set. */
8758 delete_breakpoint (b
);
8762 set_language (b
->language
);
8763 input_radix
= b
->input_radix
;
8766 save_current_space_and_thread ();
8767 switch_to_program_space_and_thread (b
->pspace
);
8769 TRY_CATCH (e
, RETURN_MASK_ERROR
)
8771 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
8776 int not_found_and_ok
= 0;
8777 /* For pending breakpoints, it's expected that parsing
8778 will fail until the right shared library is loaded.
8779 User has already told to create pending breakpoints and
8780 don't need extra messages. If breakpoint is in bp_shlib_disabled
8781 state, then user already saw the message about that breakpoint
8782 being disabled, and don't want to see more errors. */
8784 && (b
->condition_not_parsed
8785 || (b
->loc
&& b
->loc
->shlib_disabled
)
8786 || b
->enable_state
== bp_disabled
))
8787 not_found_and_ok
= 1;
8789 if (!not_found_and_ok
)
8791 /* We surely don't want to warn about the same breakpoint
8792 10 times. One solution, implemented here, is disable
8793 the breakpoint on error. Another solution would be to
8794 have separate 'warning emitted' flag. Since this
8795 happens only when a binary has changed, I don't know
8796 which approach is better. */
8797 b
->enable_state
= bp_disabled
;
8798 throw_exception (e
);
8804 gdb_assert (sals
.nelts
== 1);
8806 resolve_sal_pc (&sals
.sals
[0]);
8807 if (b
->condition_not_parsed
&& s
&& s
[0])
8809 char *cond_string
= 0;
8813 find_condition_and_thread (s
, sals
.sals
[0].pc
,
8814 &cond_string
, &thread
, &task
);
8816 b
->cond_string
= cond_string
;
8819 b
->condition_not_parsed
= 0;
8822 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
8825 make_cleanup (xfree
, sals
.sals
);
8826 update_breakpoint_locations (b
, expanded
);
8830 case bp_hardware_watchpoint
:
8831 case bp_read_watchpoint
:
8832 case bp_access_watchpoint
:
8833 /* Watchpoint can be either on expression using entirely global variables,
8834 or it can be on local variables.
8836 Watchpoints of the first kind are never auto-deleted, and even persist
8837 across program restarts. Since they can use variables from shared
8838 libraries, we need to reparse expression as libraries are loaded
8841 Watchpoints on local variables can also change meaning as result
8842 of solib event. For example, if a watchpoint uses both a local and
8843 a global variables in expression, it's a local watchpoint, but
8844 unloading of a shared library will make the expression invalid.
8845 This is not a very common use case, but we still re-evaluate
8846 expression, to avoid surprises to the user.
8848 Note that for local watchpoints, we re-evaluate it only if
8849 watchpoints frame id is still valid. If it's not, it means
8850 the watchpoint is out of scope and will be deleted soon. In fact,
8851 I'm not sure we'll ever be called in this case.
8853 If a local watchpoint's frame id is still valid, then
8854 b->exp_valid_block is likewise valid, and we can safely use it.
8856 Don't do anything about disabled watchpoints, since they will
8857 be reevaluated again when enabled. */
8858 update_watchpoint (b
, 1 /* reparse */);
8860 /* We needn't really do anything to reset these, since the mask
8861 that requests them is unaffected by e.g., new libraries being
8867 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
8869 /* Delete overlay event and longjmp master breakpoints; they will be
8870 reset later by breakpoint_re_set. */
8871 case bp_overlay_event
:
8872 case bp_longjmp_master
:
8873 delete_breakpoint (b
);
8876 /* This breakpoint is special, it's set up when the inferior
8877 starts and we really don't want to touch it. */
8878 case bp_shlib_event
:
8880 /* Like bp_shlib_event, this breakpoint type is special.
8881 Once it is set up, we do not want to touch it. */
8882 case bp_thread_event
:
8884 /* Keep temporary breakpoints, which can be encountered when we step
8885 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
8886 Otherwise these should have been blown away via the cleanup chain
8887 or by breakpoint_init_inferior when we rerun the executable. */
8890 case bp_watchpoint_scope
:
8892 case bp_step_resume
:
8894 case bp_longjmp_resume
:
8899 do_cleanups (cleanups
);
8903 /* Re-set all breakpoints after symbols have been re-loaded. */
8905 breakpoint_re_set (void)
8907 struct breakpoint
*b
, *temp
;
8908 enum language save_language
;
8909 int save_input_radix
;
8910 struct cleanup
*old_chain
;
8912 save_language
= current_language
->la_language
;
8913 save_input_radix
= input_radix
;
8914 old_chain
= save_current_program_space ();
8916 ALL_BREAKPOINTS_SAFE (b
, temp
)
8918 /* Format possible error msg */
8919 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
8921 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
8922 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
8923 do_cleanups (cleanups
);
8925 set_language (save_language
);
8926 input_radix
= save_input_radix
;
8928 jit_breakpoint_re_set ();
8930 do_cleanups (old_chain
);
8932 create_overlay_event_breakpoint ("_ovly_debug_event");
8933 create_longjmp_master_breakpoint ("longjmp");
8934 create_longjmp_master_breakpoint ("_longjmp");
8935 create_longjmp_master_breakpoint ("siglongjmp");
8936 create_longjmp_master_breakpoint ("_siglongjmp");
8939 /* Reset the thread number of this breakpoint:
8941 - If the breakpoint is for all threads, leave it as-is.
8942 - Else, reset it to the current thread for inferior_ptid. */
8944 breakpoint_re_set_thread (struct breakpoint
*b
)
8946 if (b
->thread
!= -1)
8948 if (in_thread_list (inferior_ptid
))
8949 b
->thread
= pid_to_thread_id (inferior_ptid
);
8951 /* We're being called after following a fork. The new fork is
8952 selected as current, and unless this was a vfork will have a
8953 different program space from the original thread. Reset that
8955 b
->loc
->pspace
= current_program_space
;
8959 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
8960 If from_tty is nonzero, it prints a message to that effect,
8961 which ends with a period (no newline). */
8964 set_ignore_count (int bptnum
, int count
, int from_tty
)
8966 struct breakpoint
*b
;
8972 if (b
->number
== bptnum
)
8974 b
->ignore_count
= count
;
8978 printf_filtered (_("Will stop next time breakpoint %d is reached."),
8980 else if (count
== 1)
8981 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
8984 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
8987 breakpoints_changed ();
8988 observer_notify_breakpoint_modified (b
->number
);
8992 error (_("No breakpoint number %d."), bptnum
);
8996 make_breakpoint_silent (struct breakpoint
*b
)
8998 /* Silence the breakpoint. */
9002 /* Command to set ignore-count of breakpoint N to COUNT. */
9005 ignore_command (char *args
, int from_tty
)
9011 error_no_arg (_("a breakpoint number"));
9013 num
= get_number (&p
);
9015 error (_("bad breakpoint number: '%s'"), args
);
9017 error (_("Second argument (specified ignore-count) is missing."));
9019 set_ignore_count (num
,
9020 longest_to_int (value_as_long (parse_and_eval (p
))),
9023 printf_filtered ("\n");
9026 /* Call FUNCTION on each of the breakpoints
9027 whose numbers are given in ARGS. */
9030 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
9035 struct breakpoint
*b
, *tmp
;
9039 error_no_arg (_("one or more breakpoint numbers"));
9046 num
= get_number_or_range (&p1
);
9049 warning (_("bad breakpoint number at or near '%s'"), p
);
9053 ALL_BREAKPOINTS_SAFE (b
, tmp
)
9054 if (b
->number
== num
)
9056 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
9059 if (related_breakpoint
)
9060 function (related_breakpoint
);
9064 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
9070 static struct bp_location
*
9071 find_location_by_number (char *number
)
9073 char *dot
= strchr (number
, '.');
9077 struct breakpoint
*b
;
9078 struct bp_location
*loc
;
9083 bp_num
= get_number_or_range (&p1
);
9085 error (_("Bad breakpoint number '%s'"), number
);
9088 if (b
->number
== bp_num
)
9093 if (!b
|| b
->number
!= bp_num
)
9094 error (_("Bad breakpoint number '%s'"), number
);
9097 loc_num
= get_number_or_range (&p1
);
9099 error (_("Bad breakpoint location number '%s'"), number
);
9103 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
9106 error (_("Bad breakpoint location number '%s'"), dot
+1);
9112 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
9113 If from_tty is nonzero, it prints a message to that effect,
9114 which ends with a period (no newline). */
9117 disable_breakpoint (struct breakpoint
*bpt
)
9119 /* Never disable a watchpoint scope breakpoint; we want to
9120 hit them when we leave scope so we can delete both the
9121 watchpoint and its scope breakpoint at that time. */
9122 if (bpt
->type
== bp_watchpoint_scope
)
9125 /* You can't disable permanent breakpoints. */
9126 if (bpt
->enable_state
== bp_permanent
)
9129 bpt
->enable_state
= bp_disabled
;
9131 update_global_location_list (0);
9133 observer_notify_breakpoint_modified (bpt
->number
);
9137 disable_command (char *args
, int from_tty
)
9139 struct breakpoint
*bpt
;
9141 ALL_BREAKPOINTS (bpt
)
9145 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
9151 case bp_hardware_breakpoint
:
9153 case bp_hardware_watchpoint
:
9154 case bp_read_watchpoint
:
9155 case bp_access_watchpoint
:
9156 disable_breakpoint (bpt
);
9160 else if (strchr (args
, '.'))
9162 struct bp_location
*loc
= find_location_by_number (args
);
9165 update_global_location_list (0);
9168 map_breakpoint_numbers (args
, disable_breakpoint
);
9172 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
9174 int target_resources_ok
, other_type_used
;
9177 if (bpt
->type
== bp_hardware_breakpoint
)
9180 i
= hw_breakpoint_used_count ();
9181 target_resources_ok
=
9182 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9184 if (target_resources_ok
== 0)
9185 error (_("No hardware breakpoint support in the target."));
9186 else if (target_resources_ok
< 0)
9187 error (_("Hardware breakpoints used exceeds limit."));
9190 if (bpt
->type
== bp_watchpoint
9191 || bpt
->type
== bp_hardware_watchpoint
9192 || bpt
->type
== bp_read_watchpoint
9193 || bpt
->type
== bp_access_watchpoint
)
9195 struct gdb_exception e
;
9197 TRY_CATCH (e
, RETURN_MASK_ALL
)
9199 update_watchpoint (bpt
, 1 /* reparse */);
9203 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
9209 if (bpt
->enable_state
!= bp_permanent
)
9210 bpt
->enable_state
= bp_enabled
;
9211 bpt
->disposition
= disposition
;
9212 update_global_location_list (1);
9213 breakpoints_changed ();
9215 observer_notify_breakpoint_modified (bpt
->number
);
9220 enable_breakpoint (struct breakpoint
*bpt
)
9222 do_enable_breakpoint (bpt
, bpt
->disposition
);
9225 /* The enable command enables the specified breakpoints (or all defined
9226 breakpoints) so they once again become (or continue to be) effective
9227 in stopping the inferior. */
9230 enable_command (char *args
, int from_tty
)
9232 struct breakpoint
*bpt
;
9234 ALL_BREAKPOINTS (bpt
)
9238 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
9244 case bp_hardware_breakpoint
:
9246 case bp_hardware_watchpoint
:
9247 case bp_read_watchpoint
:
9248 case bp_access_watchpoint
:
9249 enable_breakpoint (bpt
);
9253 else if (strchr (args
, '.'))
9255 struct bp_location
*loc
= find_location_by_number (args
);
9258 update_global_location_list (1);
9261 map_breakpoint_numbers (args
, enable_breakpoint
);
9265 enable_once_breakpoint (struct breakpoint
*bpt
)
9267 do_enable_breakpoint (bpt
, disp_disable
);
9271 enable_once_command (char *args
, int from_tty
)
9273 map_breakpoint_numbers (args
, enable_once_breakpoint
);
9277 enable_delete_breakpoint (struct breakpoint
*bpt
)
9279 do_enable_breakpoint (bpt
, disp_del
);
9283 enable_delete_command (char *args
, int from_tty
)
9285 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
9289 set_breakpoint_cmd (char *args
, int from_tty
)
9294 show_breakpoint_cmd (char *args
, int from_tty
)
9298 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
9300 struct symtabs_and_lines
9301 decode_line_spec_1 (char *string
, int funfirstline
)
9303 struct symtabs_and_lines sals
;
9305 error (_("Empty line specification."));
9306 if (default_breakpoint_valid
)
9307 sals
= decode_line_1 (&string
, funfirstline
,
9308 default_breakpoint_symtab
,
9309 default_breakpoint_line
,
9310 (char ***) NULL
, NULL
);
9312 sals
= decode_line_1 (&string
, funfirstline
,
9313 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
9315 error (_("Junk at end of line specification: %s"), string
);
9319 /* Create and insert a raw software breakpoint at PC. Return an
9320 identifier, which should be used to remove the breakpoint later.
9321 In general, places which call this should be using something on the
9322 breakpoint chain instead; this function should be eliminated
9326 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
9327 struct address_space
*aspace
, CORE_ADDR pc
)
9329 struct bp_target_info
*bp_tgt
;
9331 bp_tgt
= XZALLOC (struct bp_target_info
);
9333 bp_tgt
->placed_address_space
= aspace
;
9334 bp_tgt
->placed_address
= pc
;
9336 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
9338 /* Could not insert the breakpoint. */
9346 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
9349 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
9351 struct bp_target_info
*bp_tgt
= bp
;
9354 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
9360 /* One (or perhaps two) breakpoints used for software single stepping. */
9362 static void *single_step_breakpoints
[2];
9363 static struct gdbarch
*single_step_gdbarch
[2];
9365 /* Create and insert a breakpoint for software single step. */
9368 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
9369 struct address_space
*aspace
, CORE_ADDR next_pc
)
9373 if (single_step_breakpoints
[0] == NULL
)
9375 bpt_p
= &single_step_breakpoints
[0];
9376 single_step_gdbarch
[0] = gdbarch
;
9380 gdb_assert (single_step_breakpoints
[1] == NULL
);
9381 bpt_p
= &single_step_breakpoints
[1];
9382 single_step_gdbarch
[1] = gdbarch
;
9385 /* NOTE drow/2006-04-11: A future improvement to this function would be
9386 to only create the breakpoints once, and actually put them on the
9387 breakpoint chain. That would let us use set_raw_breakpoint. We could
9388 adjust the addresses each time they were needed. Doing this requires
9389 corresponding changes elsewhere where single step breakpoints are
9390 handled, however. So, for now, we use this. */
9392 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
9394 error (_("Could not insert single-step breakpoint at %s"),
9395 paddress (gdbarch
, next_pc
));
9398 /* Remove and delete any breakpoints used for software single step. */
9401 remove_single_step_breakpoints (void)
9403 gdb_assert (single_step_breakpoints
[0] != NULL
);
9405 /* See insert_single_step_breakpoint for more about this deprecated
9407 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
9408 single_step_breakpoints
[0]);
9409 single_step_gdbarch
[0] = NULL
;
9410 single_step_breakpoints
[0] = NULL
;
9412 if (single_step_breakpoints
[1] != NULL
)
9414 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
9415 single_step_breakpoints
[1]);
9416 single_step_gdbarch
[1] = NULL
;
9417 single_step_breakpoints
[1] = NULL
;
9421 /* Check whether a software single-step breakpoint is inserted at PC. */
9424 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
9428 for (i
= 0; i
< 2; i
++)
9430 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
9432 && breakpoint_address_match (bp_tgt
->placed_address_space
,
9433 bp_tgt
->placed_address
,
9441 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
9442 non-zero otherwise. */
9444 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
9446 if (syscall_catchpoint_p (bp
)
9447 && bp
->enable_state
!= bp_disabled
9448 && bp
->enable_state
!= bp_call_disabled
)
9455 catch_syscall_enabled (void)
9457 struct inferior
*inf
= current_inferior ();
9459 return inf
->total_syscalls_count
!= 0;
9463 catching_syscall_number (int syscall_number
)
9465 struct breakpoint
*bp
;
9467 ALL_BREAKPOINTS (bp
)
9468 if (is_syscall_catchpoint_enabled (bp
))
9470 if (bp
->syscalls_to_be_caught
)
9474 VEC_iterate (int, bp
->syscalls_to_be_caught
, i
, iter
);
9476 if (syscall_number
== iter
)
9486 /* Complete syscall names. Used by "catch syscall". */
9488 catch_syscall_completer (struct cmd_list_element
*cmd
,
9489 char *text
, char *word
)
9491 const char **list
= get_syscall_names ();
9492 return (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
9495 /* Tracepoint-specific operations. */
9497 /* Set tracepoint count to NUM. */
9499 set_tracepoint_count (int num
)
9501 tracepoint_count
= num
;
9502 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
9506 trace_command (char *arg
, int from_tty
)
9508 break_command_really (get_current_arch (),
9510 NULL
, 0, 1 /* parse arg */,
9511 0 /* tempflag */, 0 /* hardwareflag */,
9513 0 /* Ignore count */,
9514 pending_break_support
,
9518 set_tracepoint_count (breakpoint_count
);
9521 /* Print information on tracepoint number TPNUM_EXP, or all if
9525 tracepoints_info (char *tpnum_exp
, int from_tty
)
9527 struct breakpoint
*b
;
9528 int tps_to_list
= 0;
9530 /* In the no-arguments case, say "No tracepoints" if none found. */
9543 ui_out_message (uiout
, 0, "No tracepoints.\n");
9548 /* Otherwise be the same as "info break". */
9549 breakpoints_info (tpnum_exp
, from_tty
);
9552 /* The 'enable trace' command enables tracepoints.
9553 Not supported by all targets. */
9555 enable_trace_command (char *args
, int from_tty
)
9557 enable_command (args
, from_tty
);
9560 /* The 'disable trace' command disables tracepoints.
9561 Not supported by all targets. */
9563 disable_trace_command (char *args
, int from_tty
)
9565 disable_command (args
, from_tty
);
9568 /* Remove a tracepoint (or all if no argument) */
9570 delete_trace_command (char *arg
, int from_tty
)
9572 struct breakpoint
*b
, *temp
;
9578 int breaks_to_delete
= 0;
9580 /* Delete all breakpoints if no argument.
9581 Do not delete internal or call-dummy breakpoints, these
9582 have to be deleted with an explicit breakpoint number argument. */
9587 breaks_to_delete
= 1;
9592 /* Ask user only if there are some breakpoints to delete. */
9594 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
9596 ALL_BREAKPOINTS_SAFE (b
, temp
)
9598 if (b
->type
== bp_tracepoint
9600 delete_breakpoint (b
);
9605 map_breakpoint_numbers (arg
, delete_breakpoint
);
9608 /* Set passcount for tracepoint.
9610 First command argument is passcount, second is tracepoint number.
9611 If tracepoint number omitted, apply to most recently defined.
9612 Also accepts special argument "all". */
9615 trace_pass_command (char *args
, int from_tty
)
9617 struct breakpoint
*t1
= (struct breakpoint
*) -1, *t2
;
9621 if (args
== 0 || *args
== 0)
9622 error (_("passcount command requires an argument (count + optional TP num)"));
9624 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
9626 while (*args
&& isspace ((int) *args
))
9629 if (*args
&& strncasecmp (args
, "all", 3) == 0)
9631 args
+= 3; /* Skip special argument "all". */
9634 error (_("Junk at end of arguments."));
9637 t1
= get_tracepoint_by_number (&args
, 1, 1);
9643 ALL_TRACEPOINTS (t2
)
9644 if (t1
== (struct breakpoint
*) -1 || t1
== t2
)
9646 t2
->pass_count
= count
;
9647 observer_notify_tracepoint_modified (t2
->number
);
9649 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
9653 t1
= get_tracepoint_by_number (&args
, 1, 0);
9660 get_tracepoint (int num
)
9662 struct breakpoint
*t
;
9665 if (t
->number
== num
)
9671 /* Utility: parse a tracepoint number and look it up in the list.
9672 If MULTI_P is true, there might be a range of tracepoints in ARG.
9673 if OPTIONAL_P is true, then if the argument is missing, the most
9674 recent tracepoint (tracepoint_count) is returned. */
9676 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
9678 extern int tracepoint_count
;
9679 struct breakpoint
*t
;
9681 char *instring
= arg
== NULL
? NULL
: *arg
;
9683 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
9686 tpnum
= tracepoint_count
;
9688 error_no_arg (_("tracepoint number"));
9691 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
9695 if (instring
&& *instring
)
9696 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
9699 printf_filtered (_("Tracepoint argument missing and no previous tracepoint\n"));
9704 if (t
->number
== tpnum
)
9709 /* FIXME: if we are in the middle of a range we don't want to give
9710 a message. The current interface to get_number_or_range doesn't
9711 allow us to discover this. */
9712 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
9716 /* save-tracepoints command */
9718 tracepoint_save_command (char *args
, int from_tty
)
9720 struct breakpoint
*tp
;
9722 struct action_line
*line
;
9724 char *i1
= " ", *i2
= " ";
9725 char *indent
, *actionline
, *pathname
;
9727 struct cleanup
*cleanup
;
9729 if (args
== 0 || *args
== 0)
9730 error (_("Argument required (file name in which to save tracepoints)"));
9732 /* See if we have anything to save. */
9733 ALL_TRACEPOINTS (tp
)
9740 warning (_("save-tracepoints: no tracepoints to save."));
9744 pathname
= tilde_expand (args
);
9745 cleanup
= make_cleanup (xfree
, pathname
);
9746 fp
= fopen (pathname
, "w");
9748 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
9749 args
, safe_strerror (errno
));
9750 make_cleanup_fclose (fp
);
9752 ALL_TRACEPOINTS (tp
)
9754 if (tp
->addr_string
)
9755 fprintf (fp
, "trace %s\n", tp
->addr_string
);
9758 sprintf_vma (tmp
, tp
->loc
->address
);
9759 fprintf (fp
, "trace *0x%s\n", tmp
);
9763 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
9767 fprintf (fp
, " actions\n");
9769 for (line
= tp
->actions
; line
; line
= line
->next
)
9771 struct cmd_list_element
*cmd
;
9773 QUIT
; /* allow user to bail out with ^C */
9774 actionline
= line
->action
;
9775 while (isspace ((int) *actionline
))
9778 fprintf (fp
, "%s%s\n", indent
, actionline
);
9779 if (*actionline
!= '#') /* skip for comment lines */
9781 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
9783 error (_("Bad action list item: %s"), actionline
);
9784 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
9786 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
9792 do_cleanups (cleanup
);
9794 printf_filtered (_("Tracepoints saved to file '%s'.\n"), args
);
9798 /* Create a vector of all tracepoints. */
9803 VEC(breakpoint_p
) *tp_vec
= 0;
9804 struct breakpoint
*tp
;
9806 ALL_TRACEPOINTS (tp
)
9808 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
9815 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
9816 It is defined as a macro to prevent duplication.
9817 COMMAND should be a string constant containing the name of the command. */
9818 #define BREAK_ARGS_HELP(command) \
9819 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
9820 LOCATION may be a line number, function name, or \"*\" and an address.\n\
9821 If a line number is specified, break at start of code for that line.\n\
9822 If a function is specified, break at start of code for that function.\n\
9823 If an address is specified, break at that exact address.\n\
9824 With no LOCATION, uses current execution address of selected stack frame.\n\
9825 This is useful for breaking on return to a stack frame.\n\
9827 THREADNUM is the number from \"info threads\".\n\
9828 CONDITION is a boolean expression.\n\
9830 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
9832 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
9834 /* List of subcommands for "catch". */
9835 static struct cmd_list_element
*catch_cmdlist
;
9837 /* List of subcommands for "tcatch". */
9838 static struct cmd_list_element
*tcatch_cmdlist
;
9840 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
9841 lists, and pass some additional user data to the command function. */
9843 add_catch_command (char *name
, char *docstring
,
9844 void (*sfunc
) (char *args
, int from_tty
,
9845 struct cmd_list_element
*command
),
9846 char **(*completer
) (struct cmd_list_element
*cmd
,
9847 char *text
, char *word
),
9848 void *user_data_catch
,
9849 void *user_data_tcatch
)
9851 struct cmd_list_element
*command
;
9853 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
9855 set_cmd_sfunc (command
, sfunc
);
9856 set_cmd_context (command
, user_data_catch
);
9857 set_cmd_completer (command
, completer
);
9859 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
9861 set_cmd_sfunc (command
, sfunc
);
9862 set_cmd_context (command
, user_data_tcatch
);
9863 set_cmd_completer (command
, completer
);
9867 clear_syscall_counts (int pid
)
9869 struct inferior
*inf
= find_inferior_pid (pid
);
9871 inf
->total_syscalls_count
= 0;
9872 inf
->any_syscall_count
= 0;
9873 VEC_free (int, inf
->syscalls_counts
);
9877 _initialize_breakpoint (void)
9879 static struct cmd_list_element
*breakpoint_set_cmdlist
;
9880 static struct cmd_list_element
*breakpoint_show_cmdlist
;
9881 struct cmd_list_element
*c
;
9883 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
9884 observer_attach_inferior_exit (clear_syscall_counts
);
9886 breakpoint_chain
= 0;
9887 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
9888 before a breakpoint is set. */
9889 breakpoint_count
= 0;
9891 tracepoint_count
= 0;
9893 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
9894 Set ignore-count of breakpoint number N to COUNT.\n\
9895 Usage is `ignore N COUNT'."));
9897 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
9899 add_com ("commands", class_breakpoint
, commands_command
, _("\
9900 Set commands to be executed when a breakpoint is hit.\n\
9901 Give breakpoint number as argument after \"commands\".\n\
9902 With no argument, the targeted breakpoint is the last one set.\n\
9903 The commands themselves follow starting on the next line.\n\
9904 Type a line containing \"end\" to indicate the end of them.\n\
9905 Give \"silent\" as the first line to make the breakpoint silent;\n\
9906 then no output is printed when it is hit, except what the commands print."));
9908 add_com ("condition", class_breakpoint
, condition_command
, _("\
9909 Specify breakpoint number N to break only if COND is true.\n\
9910 Usage is `condition N COND', where N is an integer and COND is an\n\
9911 expression to be evaluated whenever breakpoint N is reached."));
9913 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
9914 Set a temporary breakpoint.\n\
9915 Like \"break\" except the breakpoint is only temporary,\n\
9916 so it will be deleted when hit. Equivalent to \"break\" followed\n\
9917 by using \"enable delete\" on the breakpoint number.\n\
9919 BREAK_ARGS_HELP ("tbreak")));
9920 set_cmd_completer (c
, location_completer
);
9922 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
9923 Set a hardware assisted breakpoint.\n\
9924 Like \"break\" except the breakpoint requires hardware support,\n\
9925 some target hardware may not have this support.\n\
9927 BREAK_ARGS_HELP ("hbreak")));
9928 set_cmd_completer (c
, location_completer
);
9930 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
9931 Set a temporary hardware assisted breakpoint.\n\
9932 Like \"hbreak\" except the breakpoint is only temporary,\n\
9933 so it will be deleted when hit.\n\
9935 BREAK_ARGS_HELP ("thbreak")));
9936 set_cmd_completer (c
, location_completer
);
9938 add_prefix_cmd ("enable", 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."),
9944 &enablelist
, "enable ", 1, &cmdlist
);
9946 add_com ("ab", class_breakpoint
, enable_command
, _("\
9947 Enable some breakpoints.\n\
9948 Give breakpoint numbers (separated by spaces) as arguments.\n\
9949 With no subcommand, breakpoints are enabled until you command otherwise.\n\
9950 This is used to cancel the effect of the \"disable\" command.\n\
9951 With a subcommand you can enable temporarily."));
9953 add_com_alias ("en", "enable", class_breakpoint
, 1);
9955 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
9956 Enable some breakpoints.\n\
9957 Give breakpoint numbers (separated by spaces) as arguments.\n\
9958 This is used to cancel the effect of the \"disable\" command.\n\
9959 May be abbreviated to simply \"enable\".\n"),
9960 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
9962 add_cmd ("once", no_class
, enable_once_command
, _("\
9963 Enable breakpoints for one hit. Give breakpoint numbers.\n\
9964 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
9967 add_cmd ("delete", no_class
, enable_delete_command
, _("\
9968 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
9969 If a breakpoint is hit while enabled in this fashion, it is deleted."),
9972 add_cmd ("delete", no_class
, enable_delete_command
, _("\
9973 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
9974 If a breakpoint is hit while enabled in this fashion, it is deleted."),
9977 add_cmd ("once", no_class
, enable_once_command
, _("\
9978 Enable breakpoints for one hit. Give breakpoint numbers.\n\
9979 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
9982 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
9983 Disable some breakpoints.\n\
9984 Arguments are breakpoint numbers with spaces in between.\n\
9985 To disable all breakpoints, give no argument.\n\
9986 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
9987 &disablelist
, "disable ", 1, &cmdlist
);
9988 add_com_alias ("dis", "disable", class_breakpoint
, 1);
9989 add_com_alias ("disa", "disable", class_breakpoint
, 1);
9991 add_com ("sb", class_breakpoint
, disable_command
, _("\
9992 Disable some breakpoints.\n\
9993 Arguments are breakpoint numbers with spaces in between.\n\
9994 To disable all breakpoints, give no argument.\n\
9995 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
9997 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
9998 Disable some breakpoints.\n\
9999 Arguments are breakpoint numbers with spaces in between.\n\
10000 To disable all breakpoints, give no argument.\n\
10001 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
10002 This command may be abbreviated \"disable\"."),
10005 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
10006 Delete some breakpoints or auto-display expressions.\n\
10007 Arguments are breakpoint numbers with spaces in between.\n\
10008 To delete all breakpoints, give no argument.\n\
10010 Also a prefix command for deletion of other GDB objects.\n\
10011 The \"unset\" command is also an alias for \"delete\"."),
10012 &deletelist
, "delete ", 1, &cmdlist
);
10013 add_com_alias ("d", "delete", class_breakpoint
, 1);
10014 add_com_alias ("del", "delete", class_breakpoint
, 1);
10016 add_com ("db", class_breakpoint
, delete_command
, _("\
10017 Delete some breakpoints.\n\
10018 Arguments are breakpoint numbers with spaces in between.\n\
10019 To delete all breakpoints, give no argument.\n"));
10021 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
10022 Delete some breakpoints or auto-display expressions.\n\
10023 Arguments are breakpoint numbers with spaces in between.\n\
10024 To delete all breakpoints, give no argument.\n\
10025 This command may be abbreviated \"delete\"."),
10028 add_com ("clear", class_breakpoint
, clear_command
, _("\
10029 Clear breakpoint at specified line or function.\n\
10030 Argument may be line number, function name, or \"*\" and an address.\n\
10031 If line number is specified, all breakpoints in that line are cleared.\n\
10032 If function is specified, breakpoints at beginning of function are cleared.\n\
10033 If an address is specified, breakpoints at that address are cleared.\n\
10035 With no argument, clears all breakpoints in the line that the selected frame\n\
10036 is executing in.\n\
10038 See also the \"delete\" command which clears breakpoints by number."));
10040 c
= add_com ("break", class_breakpoint
, break_command
, _("\
10041 Set breakpoint at specified line or function.\n"
10042 BREAK_ARGS_HELP ("break")));
10043 set_cmd_completer (c
, location_completer
);
10045 add_com_alias ("b", "break", class_run
, 1);
10046 add_com_alias ("br", "break", class_run
, 1);
10047 add_com_alias ("bre", "break", class_run
, 1);
10048 add_com_alias ("brea", "break", class_run
, 1);
10051 add_com_alias ("ba", "break", class_breakpoint
, 1);
10055 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
10056 Break in function/address or break at a line in the current file."),
10057 &stoplist
, "stop ", 1, &cmdlist
);
10058 add_cmd ("in", class_breakpoint
, stopin_command
,
10059 _("Break in function or address."), &stoplist
);
10060 add_cmd ("at", class_breakpoint
, stopat_command
,
10061 _("Break at a line in the current file."), &stoplist
);
10062 add_com ("status", class_info
, breakpoints_info
, _("\
10063 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10064 The \"Type\" column indicates one of:\n\
10065 \tbreakpoint - normal breakpoint\n\
10066 \twatchpoint - watchpoint\n\
10067 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10068 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10069 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10070 address and file/line number respectively.\n\
10072 Convenience variable \"$_\" and default examine address for \"x\"\n\
10073 are set to the address of the last breakpoint listed unless the command\n\
10074 is prefixed with \"server \".\n\n\
10075 Convenience variable \"$bpnum\" contains the number of the last\n\
10076 breakpoint set."));
10079 add_info ("breakpoints", breakpoints_info
, _("\
10080 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10081 The \"Type\" column indicates one of:\n\
10082 \tbreakpoint - normal breakpoint\n\
10083 \twatchpoint - watchpoint\n\
10084 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10085 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10086 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10087 address and file/line number respectively.\n\
10089 Convenience variable \"$_\" and default examine address for \"x\"\n\
10090 are set to the address of the last breakpoint listed unless the command\n\
10091 is prefixed with \"server \".\n\n\
10092 Convenience variable \"$bpnum\" contains the number of the last\n\
10093 breakpoint set."));
10096 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
10097 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
10098 The \"Type\" column indicates one of:\n\
10099 \tbreakpoint - normal breakpoint\n\
10100 \twatchpoint - watchpoint\n\
10101 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10102 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10103 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10104 address and file/line number respectively.\n\
10106 Convenience variable \"$_\" and default examine address for \"x\"\n\
10107 are set to the address of the last breakpoint listed unless the command\n\
10108 is prefixed with \"server \".\n\n\
10109 Convenience variable \"$bpnum\" contains the number of the last\n\
10110 breakpoint set."));
10112 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
10113 Status of all breakpoints, or breakpoint number NUMBER.\n\
10114 The \"Type\" column indicates one of:\n\
10115 \tbreakpoint - normal breakpoint\n\
10116 \twatchpoint - watchpoint\n\
10117 \tlongjmp - internal breakpoint used to step through longjmp()\n\
10118 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
10119 \tuntil - internal breakpoint used by the \"until\" command\n\
10120 \tfinish - internal breakpoint used by the \"finish\" command\n\
10121 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
10122 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
10123 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
10124 address and file/line number respectively.\n\
10126 Convenience variable \"$_\" and default examine address for \"x\"\n\
10127 are set to the address of the last breakpoint listed unless the command\n\
10128 is prefixed with \"server \".\n\n\
10129 Convenience variable \"$bpnum\" contains the number of the last\n\
10131 &maintenanceinfolist
);
10133 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
10134 Set catchpoints to catch events."),
10135 &catch_cmdlist
, "catch ",
10136 0/*allow-unknown*/, &cmdlist
);
10138 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
10139 Set temporary catchpoints to catch events."),
10140 &tcatch_cmdlist
, "tcatch ",
10141 0/*allow-unknown*/, &cmdlist
);
10143 /* Add catch and tcatch sub-commands. */
10144 add_catch_command ("catch", _("\
10145 Catch an exception, when caught.\n\
10146 With an argument, catch only exceptions with the given name."),
10147 catch_catch_command
,
10151 add_catch_command ("throw", _("\
10152 Catch an exception, when thrown.\n\
10153 With an argument, catch only exceptions with the given name."),
10154 catch_throw_command
,
10158 add_catch_command ("fork", _("Catch calls to fork."),
10159 catch_fork_command_1
,
10161 (void *) (uintptr_t) catch_fork_permanent
,
10162 (void *) (uintptr_t) catch_fork_temporary
);
10163 add_catch_command ("vfork", _("Catch calls to vfork."),
10164 catch_fork_command_1
,
10166 (void *) (uintptr_t) catch_vfork_permanent
,
10167 (void *) (uintptr_t) catch_vfork_temporary
);
10168 add_catch_command ("exec", _("Catch calls to exec."),
10169 catch_exec_command_1
,
10173 add_catch_command ("syscall", _("\
10174 Catch system calls by their names and/or numbers.\n\
10175 Arguments say which system calls to catch. If no arguments\n\
10176 are given, every system call will be caught.\n\
10177 Arguments, if given, should be one or more system call names\n\
10178 (if your system supports that), or system call numbers."),
10179 catch_syscall_command_1
,
10180 catch_syscall_completer
,
10183 add_catch_command ("exception", _("\
10184 Catch Ada exceptions, when raised.\n\
10185 With an argument, catch only exceptions with the given name."),
10186 catch_ada_exception_command
,
10190 add_catch_command ("assert", _("\
10191 Catch failed Ada assertions, when raised.\n\
10192 With an argument, catch only exceptions with the given name."),
10193 catch_assert_command
,
10198 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
10199 Set a watchpoint for an expression.\n\
10200 A watchpoint stops execution of your program whenever the value of\n\
10201 an expression changes."));
10202 set_cmd_completer (c
, expression_completer
);
10204 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
10205 Set a read watchpoint for an expression.\n\
10206 A watchpoint stops execution of your program whenever the value of\n\
10207 an expression is read."));
10208 set_cmd_completer (c
, expression_completer
);
10210 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
10211 Set a watchpoint for an expression.\n\
10212 A watchpoint stops execution of your program whenever the value of\n\
10213 an expression is either read or written."));
10214 set_cmd_completer (c
, expression_completer
);
10216 add_info ("watchpoints", breakpoints_info
,
10217 _("Synonym for ``info breakpoints''."));
10220 /* XXX: cagney/2005-02-23: This should be a boolean, and should
10221 respond to changes - contrary to the description. */
10222 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
10223 &can_use_hw_watchpoints
, _("\
10224 Set debugger's willingness to use watchpoint hardware."), _("\
10225 Show debugger's willingness to use watchpoint hardware."), _("\
10226 If zero, gdb will not use hardware for new watchpoints, even if\n\
10227 such is available. (However, any hardware watchpoints that were\n\
10228 created before setting this to nonzero, will continue to use watchpoint\n\
10231 show_can_use_hw_watchpoints
,
10232 &setlist
, &showlist
);
10234 can_use_hw_watchpoints
= 1;
10236 /* Tracepoint manipulation commands. */
10238 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
10239 Set a tracepoint at specified line or function.\n\
10241 BREAK_ARGS_HELP ("trace") "\n\
10242 Do \"help tracepoints\" for info on other tracepoint commands."));
10243 set_cmd_completer (c
, location_completer
);
10245 add_com_alias ("tp", "trace", class_alias
, 0);
10246 add_com_alias ("tr", "trace", class_alias
, 1);
10247 add_com_alias ("tra", "trace", class_alias
, 1);
10248 add_com_alias ("trac", "trace", class_alias
, 1);
10250 add_info ("tracepoints", tracepoints_info
, _("\
10251 Status of tracepoints, or tracepoint number NUMBER.\n\
10252 Convenience variable \"$tpnum\" contains the number of the\n\
10253 last tracepoint set."));
10255 add_info_alias ("tp", "tracepoints", 1);
10257 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
10258 Delete specified tracepoints.\n\
10259 Arguments are tracepoint numbers, separated by spaces.\n\
10260 No argument means delete all tracepoints."),
10263 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
10264 Disable specified tracepoints.\n\
10265 Arguments are tracepoint numbers, separated by spaces.\n\
10266 No argument means disable all tracepoints."),
10268 deprecate_cmd (c
, "disable");
10270 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
10271 Enable specified tracepoints.\n\
10272 Arguments are tracepoint numbers, separated by spaces.\n\
10273 No argument means enable all tracepoints."),
10275 deprecate_cmd (c
, "enable");
10277 add_com ("passcount", class_trace
, trace_pass_command
, _("\
10278 Set the passcount for a tracepoint.\n\
10279 The trace will end when the tracepoint has been passed 'count' times.\n\
10280 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
10281 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
10283 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
10284 Save current tracepoint definitions as a script.\n\
10285 Use the 'source' command in another debug session to restore them."));
10286 set_cmd_completer (c
, filename_completer
);
10288 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
10289 Breakpoint specific settings\n\
10290 Configure various breakpoint-specific variables such as\n\
10291 pending breakpoint behavior"),
10292 &breakpoint_set_cmdlist
, "set breakpoint ",
10293 0/*allow-unknown*/, &setlist
);
10294 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
10295 Breakpoint specific settings\n\
10296 Configure various breakpoint-specific variables such as\n\
10297 pending breakpoint behavior"),
10298 &breakpoint_show_cmdlist
, "show breakpoint ",
10299 0/*allow-unknown*/, &showlist
);
10301 add_setshow_auto_boolean_cmd ("pending", no_class
,
10302 &pending_break_support
, _("\
10303 Set debugger's behavior regarding pending breakpoints."), _("\
10304 Show debugger's behavior regarding pending breakpoints."), _("\
10305 If on, an unrecognized breakpoint location will cause gdb to create a\n\
10306 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
10307 an error. If auto, an unrecognized breakpoint location results in a\n\
10308 user-query to see if a pending breakpoint should be created."),
10310 show_pending_break_support
,
10311 &breakpoint_set_cmdlist
,
10312 &breakpoint_show_cmdlist
);
10314 pending_break_support
= AUTO_BOOLEAN_AUTO
;
10316 add_setshow_boolean_cmd ("auto-hw", no_class
,
10317 &automatic_hardware_breakpoints
, _("\
10318 Set automatic usage of hardware breakpoints."), _("\
10319 Show automatic usage of hardware breakpoints."), _("\
10320 If set, the debugger will automatically use hardware breakpoints for\n\
10321 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
10322 a warning will be emitted for such breakpoints."),
10324 show_automatic_hardware_breakpoints
,
10325 &breakpoint_set_cmdlist
,
10326 &breakpoint_show_cmdlist
);
10328 add_setshow_enum_cmd ("always-inserted", class_support
,
10329 always_inserted_enums
, &always_inserted_mode
, _("\
10330 Set mode for inserting breakpoints."), _("\
10331 Show mode for inserting breakpoints."), _("\
10332 When this mode is off, breakpoints are inserted in inferior when it is\n\
10333 resumed, and removed when execution stops. When this mode is on,\n\
10334 breakpoints are inserted immediately and removed only when the user\n\
10335 deletes the breakpoint. When this mode is auto (which is the default),\n\
10336 the behaviour depends on the non-stop setting (see help set non-stop).\n\
10337 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
10338 behaves as if always-inserted mode is on; if gdb is controlling the\n\
10339 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
10341 &show_always_inserted_mode
,
10342 &breakpoint_set_cmdlist
,
10343 &breakpoint_show_cmdlist
);
10345 automatic_hardware_breakpoints
= 1;
10347 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);