1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
26 #include "breakpoint.h"
27 #include "tracepoint.h"
29 #include "expression.h"
35 #include "gdbthread.h"
38 #include "gdb_string.h"
39 #include "gdb-demangle.h"
40 #include "filenames.h"
46 #include "completer.h"
49 #include "cli/cli-script.h"
50 #include "gdb_assert.h"
55 #include "exceptions.h"
62 #include "xml-syscall.h"
63 #include "parser-defs.h"
64 #include "cli/cli-utils.h"
65 #include "continuations.h"
70 /* readline include files */
71 #include "readline/readline.h"
72 #include "readline/history.h"
74 /* readline defines this. */
77 #include "mi/mi-common.h"
78 #include "python/python.h"
80 /* Prototypes for local functions. */
82 static void enable_delete_command (char *, int);
84 static void enable_once_command (char *, int);
86 static void disable_command (char *, int);
88 static void enable_command (char *, int);
90 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 breakpoint_re_set_default (struct breakpoint
*);
100 static void clear_command (char *, int);
102 static void catch_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 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
112 const struct breakpoint_ops
*);
113 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
114 const struct symtab_and_line
*);
116 /* This function is used in gdbtk sources and thus can not be made
118 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
119 struct symtab_and_line
,
121 const struct breakpoint_ops
*);
123 static struct breakpoint
*
124 momentary_breakpoint_from_master (struct breakpoint
*orig
,
126 const struct breakpoint_ops
*ops
);
128 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
130 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
134 static void describe_other_breakpoints (struct gdbarch
*,
135 struct program_space
*, CORE_ADDR
,
136 struct obj_section
*, int);
138 static int breakpoint_address_match (struct address_space
*aspace1
,
140 struct address_space
*aspace2
,
143 static int watchpoint_locations_match (struct bp_location
*loc1
,
144 struct bp_location
*loc2
);
146 static int breakpoint_location_address_match (struct bp_location
*bl
,
147 struct address_space
*aspace
,
150 static void breakpoints_info (char *, int);
152 static void watchpoints_info (char *, int);
154 static int breakpoint_1 (char *, int,
155 int (*) (const struct breakpoint
*));
157 static int breakpoint_cond_eval (void *);
159 static void cleanup_executing_breakpoints (void *);
161 static void commands_command (char *, int);
163 static void condition_command (char *, int);
172 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
173 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
175 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
177 static int watchpoint_check (void *);
179 static void maintenance_info_breakpoints (char *, int);
181 static int hw_breakpoint_used_count (void);
183 static int hw_watchpoint_use_count (struct breakpoint
*);
185 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
187 int *other_type_used
);
189 static void hbreak_command (char *, int);
191 static void thbreak_command (char *, int);
193 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
);
195 static void stop_command (char *arg
, int from_tty
);
197 static void stopin_command (char *arg
, int from_tty
);
199 static void stopat_command (char *arg
, int from_tty
);
201 static char *ep_parse_optional_if_clause (char **arg
);
203 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
204 char *arg
, int tempflag
, int from_tty
);
206 static void tcatch_command (char *arg
, int from_tty
);
208 static void detach_single_step_breakpoints (void);
210 static int single_step_breakpoint_inserted_here_p (struct address_space
*,
213 static void free_bp_location (struct bp_location
*loc
);
214 static void incref_bp_location (struct bp_location
*loc
);
215 static void decref_bp_location (struct bp_location
**loc
);
217 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
219 static void update_global_location_list (int);
221 static void update_global_location_list_nothrow (int);
223 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
225 static void insert_breakpoint_locations (void);
227 static int syscall_catchpoint_p (struct breakpoint
*b
);
229 static void tracepoints_info (char *, int);
231 static void delete_trace_command (char *, int);
233 static void enable_trace_command (char *, int);
235 static void disable_trace_command (char *, int);
237 static void trace_pass_command (char *, int);
239 static int is_masked_watchpoint (const struct breakpoint
*b
);
241 /* Assuming we're creating a static tracepoint, does S look like a
242 static tracepoint marker spec ("-m MARKER_ID")? */
243 #define is_marker_spec(s) \
244 (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
246 /* The abstract base class all breakpoint_ops structures inherit
248 static struct breakpoint_ops base_breakpoint_ops
;
250 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
251 that are implemented on top of software or hardware breakpoints
252 (user breakpoints, internal and momentary breakpoints, etc.). */
253 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
255 /* Internal breakpoints class type. */
256 static struct breakpoint_ops internal_breakpoint_ops
;
258 /* Momentary breakpoints class type. */
259 static struct breakpoint_ops momentary_breakpoint_ops
;
261 /* The breakpoint_ops structure to be used in regular user created
263 struct breakpoint_ops bkpt_breakpoint_ops
;
265 /* A reference-counted struct command_line. This lets multiple
266 breakpoints share a single command list. */
267 struct counted_command_line
269 /* The reference count. */
272 /* The command list. */
273 struct command_line
*commands
;
276 struct command_line
*
277 breakpoint_commands (struct breakpoint
*b
)
279 return b
->commands
? b
->commands
->commands
: NULL
;
282 /* Flag indicating that a command has proceeded the inferior past the
283 current breakpoint. */
285 static int breakpoint_proceeded
;
288 bpdisp_text (enum bpdisp disp
)
290 /* NOTE: the following values are a part of MI protocol and
291 represent values of 'disp' field returned when inferior stops at
293 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
295 return bpdisps
[(int) disp
];
298 /* Prototypes for exported functions. */
299 /* If FALSE, gdb will not use hardware support for watchpoints, even
300 if such is available. */
301 static int can_use_hw_watchpoints
;
304 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
305 struct cmd_list_element
*c
,
308 fprintf_filtered (file
,
309 _("Debugger's willingness to use "
310 "watchpoint hardware is %s.\n"),
314 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
315 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
316 for unrecognized breakpoint locations.
317 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
318 static enum auto_boolean pending_break_support
;
320 show_pending_break_support (struct ui_file
*file
, int from_tty
,
321 struct cmd_list_element
*c
,
324 fprintf_filtered (file
,
325 _("Debugger's behavior regarding "
326 "pending breakpoints is %s.\n"),
330 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
331 set with "break" but falling in read-only memory.
332 If 0, gdb will warn about such breakpoints, but won't automatically
333 use hardware breakpoints. */
334 static int automatic_hardware_breakpoints
;
336 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
337 struct cmd_list_element
*c
,
340 fprintf_filtered (file
,
341 _("Automatic usage of hardware breakpoints is %s.\n"),
345 /* If on, gdb will keep breakpoints inserted even as inferior is
346 stopped, and immediately insert any new breakpoints. If off, gdb
347 will insert breakpoints into inferior only when resuming it, and
348 will remove breakpoints upon stop. If auto, GDB will behave as ON
349 if in non-stop mode, and as OFF if all-stop mode.*/
351 static const char always_inserted_auto
[] = "auto";
352 static const char always_inserted_on
[] = "on";
353 static const char always_inserted_off
[] = "off";
354 static const char *always_inserted_enums
[] = {
355 always_inserted_auto
,
360 static const char *always_inserted_mode
= always_inserted_auto
;
362 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
363 struct cmd_list_element
*c
, const char *value
)
365 if (always_inserted_mode
== always_inserted_auto
)
366 fprintf_filtered (file
,
367 _("Always inserted breakpoint "
368 "mode is %s (currently %s).\n"),
370 breakpoints_always_inserted_mode () ? "on" : "off");
372 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
377 breakpoints_always_inserted_mode (void)
379 return ((always_inserted_mode
== always_inserted_on
380 || (always_inserted_mode
== always_inserted_auto
&& non_stop
))
384 void _initialize_breakpoint (void);
386 /* Are we executing breakpoint commands? */
387 static int executing_breakpoint_commands
;
389 /* Are overlay event breakpoints enabled? */
390 static int overlay_events_enabled
;
392 /* See description in breakpoint.h. */
393 int target_exact_watchpoints
= 0;
395 /* Walk the following statement or block through all breakpoints.
396 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
397 current breakpoint. */
399 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
401 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
402 for (B = breakpoint_chain; \
403 B ? (TMP=B->next, 1): 0; \
406 /* Similar iterator for the low-level breakpoints. SAFE variant is
407 not provided so update_global_location_list must not be called
408 while executing the block of ALL_BP_LOCATIONS. */
410 #define ALL_BP_LOCATIONS(B,BP_TMP) \
411 for (BP_TMP = bp_location; \
412 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
415 /* Iterator for tracepoints only. */
417 #define ALL_TRACEPOINTS(B) \
418 for (B = breakpoint_chain; B; B = B->next) \
419 if (is_tracepoint (B))
421 /* Chains of all breakpoints defined. */
423 struct breakpoint
*breakpoint_chain
;
425 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
427 static struct bp_location
**bp_location
;
429 /* Number of elements of BP_LOCATION. */
431 static unsigned bp_location_count
;
433 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
434 ADDRESS for the current elements of BP_LOCATION which get a valid
435 result from bp_location_has_shadow. You can use it for roughly
436 limiting the subrange of BP_LOCATION to scan for shadow bytes for
437 an address you need to read. */
439 static CORE_ADDR bp_location_placed_address_before_address_max
;
441 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
442 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
443 BP_LOCATION which get a valid result from bp_location_has_shadow.
444 You can use it for roughly limiting the subrange of BP_LOCATION to
445 scan for shadow bytes for an address you need to read. */
447 static CORE_ADDR bp_location_shadow_len_after_address_max
;
449 /* The locations that no longer correspond to any breakpoint, unlinked
450 from bp_location array, but for which a hit may still be reported
452 VEC(bp_location_p
) *moribund_locations
= NULL
;
454 /* Number of last breakpoint made. */
456 static int breakpoint_count
;
458 /* The value of `breakpoint_count' before the last command that
459 created breakpoints. If the last (break-like) command created more
460 than one breakpoint, then the difference between BREAKPOINT_COUNT
461 and PREV_BREAKPOINT_COUNT is more than one. */
462 static int prev_breakpoint_count
;
464 /* Number of last tracepoint made. */
466 static int tracepoint_count
;
468 static struct cmd_list_element
*breakpoint_set_cmdlist
;
469 static struct cmd_list_element
*breakpoint_show_cmdlist
;
470 struct cmd_list_element
*save_cmdlist
;
472 /* Return whether a breakpoint is an active enabled breakpoint. */
474 breakpoint_enabled (struct breakpoint
*b
)
476 return (b
->enable_state
== bp_enabled
);
479 /* Set breakpoint count to NUM. */
482 set_breakpoint_count (int num
)
484 prev_breakpoint_count
= breakpoint_count
;
485 breakpoint_count
= num
;
486 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
489 /* Used by `start_rbreak_breakpoints' below, to record the current
490 breakpoint count before "rbreak" creates any breakpoint. */
491 static int rbreak_start_breakpoint_count
;
493 /* Called at the start an "rbreak" command to record the first
497 start_rbreak_breakpoints (void)
499 rbreak_start_breakpoint_count
= breakpoint_count
;
502 /* Called at the end of an "rbreak" command to record the last
506 end_rbreak_breakpoints (void)
508 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
511 /* Used in run_command to zero the hit count when a new run starts. */
514 clear_breakpoint_hit_counts (void)
516 struct breakpoint
*b
;
522 /* Allocate a new counted_command_line with reference count of 1.
523 The new structure owns COMMANDS. */
525 static struct counted_command_line
*
526 alloc_counted_command_line (struct command_line
*commands
)
528 struct counted_command_line
*result
529 = xmalloc (sizeof (struct counted_command_line
));
532 result
->commands
= commands
;
536 /* Increment reference count. This does nothing if CMD is NULL. */
539 incref_counted_command_line (struct counted_command_line
*cmd
)
545 /* Decrement reference count. If the reference count reaches 0,
546 destroy the counted_command_line. Sets *CMDP to NULL. This does
547 nothing if *CMDP is NULL. */
550 decref_counted_command_line (struct counted_command_line
**cmdp
)
554 if (--(*cmdp
)->refc
== 0)
556 free_command_lines (&(*cmdp
)->commands
);
563 /* A cleanup function that calls decref_counted_command_line. */
566 do_cleanup_counted_command_line (void *arg
)
568 decref_counted_command_line (arg
);
571 /* Create a cleanup that calls decref_counted_command_line on the
574 static struct cleanup
*
575 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
577 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
581 /* Return the breakpoint with the specified number, or NULL
582 if the number does not refer to an existing breakpoint. */
585 get_breakpoint (int num
)
587 struct breakpoint
*b
;
590 if (b
->number
== num
)
599 set_breakpoint_condition (struct breakpoint
*b
, char *exp
,
602 xfree (b
->cond_string
);
603 b
->cond_string
= NULL
;
605 if (is_watchpoint (b
))
607 struct watchpoint
*w
= (struct watchpoint
*) b
;
614 struct bp_location
*loc
;
616 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
626 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
632 /* I don't know if it matters whether this is the string the user
633 typed in or the decompiled expression. */
634 b
->cond_string
= xstrdup (arg
);
635 b
->condition_not_parsed
= 0;
637 if (is_watchpoint (b
))
639 struct watchpoint
*w
= (struct watchpoint
*) b
;
641 innermost_block
= NULL
;
643 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0);
645 error (_("Junk at end of expression"));
646 w
->cond_exp_valid_block
= innermost_block
;
650 struct bp_location
*loc
;
652 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
656 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
658 error (_("Junk at end of expression"));
662 breakpoints_changed ();
663 observer_notify_breakpoint_modified (b
);
666 /* condition N EXP -- set break condition of breakpoint N to EXP. */
669 condition_command (char *arg
, int from_tty
)
671 struct breakpoint
*b
;
676 error_no_arg (_("breakpoint number"));
679 bnum
= get_number (&p
);
681 error (_("Bad breakpoint argument: '%s'"), arg
);
684 if (b
->number
== bnum
)
686 /* Check if this breakpoint has a Python object assigned to
687 it, and if it has a definition of the "stop"
688 method. This method and conditions entered into GDB from
689 the CLI are mutually exclusive. */
691 && gdbpy_breakpoint_has_py_cond (b
->py_bp_object
))
692 error (_("Cannot set a condition where a Python 'stop' "
693 "method has been defined in the breakpoint."));
694 set_breakpoint_condition (b
, p
, from_tty
);
698 error (_("No breakpoint number %d."), bnum
);
701 /* Check that COMMAND do not contain commands that are suitable
702 only for tracepoints and not suitable for ordinary breakpoints.
703 Throw if any such commands is found. */
706 check_no_tracepoint_commands (struct command_line
*commands
)
708 struct command_line
*c
;
710 for (c
= commands
; c
; c
= c
->next
)
714 if (c
->control_type
== while_stepping_control
)
715 error (_("The 'while-stepping' command can "
716 "only be used for tracepoints"));
718 for (i
= 0; i
< c
->body_count
; ++i
)
719 check_no_tracepoint_commands ((c
->body_list
)[i
]);
721 /* Not that command parsing removes leading whitespace and comment
722 lines and also empty lines. So, we only need to check for
724 if (strstr (c
->line
, "collect ") == c
->line
)
725 error (_("The 'collect' command can only be used for tracepoints"));
727 if (strstr (c
->line
, "teval ") == c
->line
)
728 error (_("The 'teval' command can only be used for tracepoints"));
732 /* Encapsulate tests for different types of tracepoints. */
735 is_tracepoint_type (enum bptype type
)
737 return (type
== bp_tracepoint
738 || type
== bp_fast_tracepoint
739 || type
== bp_static_tracepoint
);
743 is_tracepoint (const struct breakpoint
*b
)
745 return is_tracepoint_type (b
->type
);
748 /* A helper function that validates that COMMANDS are valid for a
749 breakpoint. This function will throw an exception if a problem is
753 validate_commands_for_breakpoint (struct breakpoint
*b
,
754 struct command_line
*commands
)
756 if (is_tracepoint (b
))
758 /* We need to verify that each top-level element of commands is
759 valid for tracepoints, that there's at most one
760 while-stepping element, and that while-stepping's body has
761 valid tracing commands excluding nested while-stepping. */
762 struct command_line
*c
;
763 struct command_line
*while_stepping
= 0;
764 for (c
= commands
; c
; c
= c
->next
)
766 if (c
->control_type
== while_stepping_control
)
768 if (b
->type
== bp_fast_tracepoint
)
769 error (_("The 'while-stepping' command "
770 "cannot be used for fast tracepoint"));
771 else if (b
->type
== bp_static_tracepoint
)
772 error (_("The 'while-stepping' command "
773 "cannot be used for static tracepoint"));
776 error (_("The 'while-stepping' command "
777 "can be used only once"));
784 struct command_line
*c2
;
786 gdb_assert (while_stepping
->body_count
== 1);
787 c2
= while_stepping
->body_list
[0];
788 for (; c2
; c2
= c2
->next
)
790 if (c2
->control_type
== while_stepping_control
)
791 error (_("The 'while-stepping' command cannot be nested"));
797 check_no_tracepoint_commands (commands
);
801 /* Return a vector of all the static tracepoints set at ADDR. The
802 caller is responsible for releasing the vector. */
805 static_tracepoints_here (CORE_ADDR addr
)
807 struct breakpoint
*b
;
808 VEC(breakpoint_p
) *found
= 0;
809 struct bp_location
*loc
;
812 if (b
->type
== bp_static_tracepoint
)
814 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
815 if (loc
->address
== addr
)
816 VEC_safe_push(breakpoint_p
, found
, b
);
822 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
823 validate that only allowed commands are included. */
826 breakpoint_set_commands (struct breakpoint
*b
,
827 struct command_line
*commands
)
829 validate_commands_for_breakpoint (b
, commands
);
831 decref_counted_command_line (&b
->commands
);
832 b
->commands
= alloc_counted_command_line (commands
);
833 breakpoints_changed ();
834 observer_notify_breakpoint_modified (b
);
837 /* Set the internal `silent' flag on the breakpoint. Note that this
838 is not the same as the "silent" that may appear in the breakpoint's
842 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
844 int old_silent
= b
->silent
;
847 if (old_silent
!= silent
)
848 observer_notify_breakpoint_modified (b
);
851 /* Set the thread for this breakpoint. If THREAD is -1, make the
852 breakpoint work for any thread. */
855 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
857 int old_thread
= b
->thread
;
860 if (old_thread
!= thread
)
861 observer_notify_breakpoint_modified (b
);
864 /* Set the task for this breakpoint. If TASK is 0, make the
865 breakpoint work for any task. */
868 breakpoint_set_task (struct breakpoint
*b
, int task
)
870 int old_task
= b
->task
;
873 if (old_task
!= task
)
874 observer_notify_breakpoint_modified (b
);
878 check_tracepoint_command (char *line
, void *closure
)
880 struct breakpoint
*b
= closure
;
882 validate_actionline (&line
, b
);
885 /* A structure used to pass information through
886 map_breakpoint_numbers. */
890 /* True if the command was typed at a tty. */
893 /* The breakpoint range spec. */
896 /* Non-NULL if the body of the commands are being read from this
897 already-parsed command. */
898 struct command_line
*control
;
900 /* The command lines read from the user, or NULL if they have not
902 struct counted_command_line
*cmd
;
905 /* A callback for map_breakpoint_numbers that sets the commands for
909 do_map_commands_command (struct breakpoint
*b
, void *data
)
911 struct commands_info
*info
= data
;
913 if (info
->cmd
== NULL
)
915 struct command_line
*l
;
917 if (info
->control
!= NULL
)
918 l
= copy_command_lines (info
->control
->body_list
[0]);
921 struct cleanup
*old_chain
;
924 str
= xstrprintf (_("Type commands for breakpoint(s) "
925 "%s, one per line."),
928 old_chain
= make_cleanup (xfree
, str
);
930 l
= read_command_lines (str
,
933 ? check_tracepoint_command
: 0),
936 do_cleanups (old_chain
);
939 info
->cmd
= alloc_counted_command_line (l
);
942 /* If a breakpoint was on the list more than once, we don't need to
944 if (b
->commands
!= info
->cmd
)
946 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
947 incref_counted_command_line (info
->cmd
);
948 decref_counted_command_line (&b
->commands
);
949 b
->commands
= info
->cmd
;
950 breakpoints_changed ();
951 observer_notify_breakpoint_modified (b
);
956 commands_command_1 (char *arg
, int from_tty
,
957 struct command_line
*control
)
959 struct cleanup
*cleanups
;
960 struct commands_info info
;
962 info
.from_tty
= from_tty
;
963 info
.control
= control
;
965 /* If we read command lines from the user, then `info' will hold an
966 extra reference to the commands that we must clean up. */
967 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
969 if (arg
== NULL
|| !*arg
)
971 if (breakpoint_count
- prev_breakpoint_count
> 1)
972 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1,
974 else if (breakpoint_count
> 0)
975 arg
= xstrprintf ("%d", breakpoint_count
);
978 /* So that we don't try to free the incoming non-NULL
979 argument in the cleanup below. Mapping breakpoint
980 numbers will fail in this case. */
985 /* The command loop has some static state, so we need to preserve
990 make_cleanup (xfree
, arg
);
994 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
996 if (info
.cmd
== NULL
)
997 error (_("No breakpoints specified."));
999 do_cleanups (cleanups
);
1003 commands_command (char *arg
, int from_tty
)
1005 commands_command_1 (arg
, from_tty
, NULL
);
1008 /* Like commands_command, but instead of reading the commands from
1009 input stream, takes them from an already parsed command structure.
1011 This is used by cli-script.c to DTRT with breakpoint commands
1012 that are part of if and while bodies. */
1013 enum command_control_type
1014 commands_from_control_command (char *arg
, struct command_line
*cmd
)
1016 commands_command_1 (arg
, 0, cmd
);
1017 return simple_control
;
1020 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1023 bp_location_has_shadow (struct bp_location
*bl
)
1025 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1029 if (bl
->target_info
.shadow_len
== 0)
1030 /* BL isn't valid, or doesn't shadow memory. */
1035 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1036 by replacing any memory breakpoints with their shadowed contents.
1038 The range of shadowed area by each bp_location is:
1039 bl->address - bp_location_placed_address_before_address_max
1040 up to bl->address + bp_location_shadow_len_after_address_max
1041 The range we were requested to resolve shadows for is:
1042 memaddr ... memaddr + len
1043 Thus the safe cutoff boundaries for performance optimization are
1044 memaddr + len <= (bl->address
1045 - bp_location_placed_address_before_address_max)
1047 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1050 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1051 const gdb_byte
*writebuf_org
,
1052 ULONGEST memaddr
, LONGEST len
)
1054 /* Left boundary, right boundary and median element of our binary
1056 unsigned bc_l
, bc_r
, bc
;
1058 /* Find BC_L which is a leftmost element which may affect BUF
1059 content. It is safe to report lower value but a failure to
1060 report higher one. */
1063 bc_r
= bp_location_count
;
1064 while (bc_l
+ 1 < bc_r
)
1066 struct bp_location
*bl
;
1068 bc
= (bc_l
+ bc_r
) / 2;
1069 bl
= bp_location
[bc
];
1071 /* Check first BL->ADDRESS will not overflow due to the added
1072 constant. Then advance the left boundary only if we are sure
1073 the BC element can in no way affect the BUF content (MEMADDR
1074 to MEMADDR + LEN range).
1076 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1077 offset so that we cannot miss a breakpoint with its shadow
1078 range tail still reaching MEMADDR. */
1080 if ((bl
->address
+ bp_location_shadow_len_after_address_max
1082 && (bl
->address
+ bp_location_shadow_len_after_address_max
1089 /* Due to the binary search above, we need to make sure we pick the
1090 first location that's at BC_L's address. E.g., if there are
1091 multiple locations at the same address, BC_L may end up pointing
1092 at a duplicate location, and miss the "master"/"inserted"
1093 location. Say, given locations L1, L2 and L3 at addresses A and
1096 L1@A, L2@A, L3@B, ...
1098 BC_L could end up pointing at location L2, while the "master"
1099 location could be L1. Since the `loc->inserted' flag is only set
1100 on "master" locations, we'd forget to restore the shadow of L1
1103 && bp_location
[bc_l
]->address
== bp_location
[bc_l
- 1]->address
)
1106 /* Now do full processing of the found relevant range of elements. */
1108 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1110 struct bp_location
*bl
= bp_location
[bc
];
1111 CORE_ADDR bp_addr
= 0;
1115 /* bp_location array has BL->OWNER always non-NULL. */
1116 if (bl
->owner
->type
== bp_none
)
1117 warning (_("reading through apparently deleted breakpoint #%d?"),
1120 /* Performance optimization: any further element can no longer affect BUF
1123 if (bl
->address
>= bp_location_placed_address_before_address_max
1124 && memaddr
+ len
<= (bl
->address
1125 - bp_location_placed_address_before_address_max
))
1128 if (!bp_location_has_shadow (bl
))
1130 if (!breakpoint_address_match (bl
->target_info
.placed_address_space
, 0,
1131 current_program_space
->aspace
, 0))
1134 /* Addresses and length of the part of the breakpoint that
1136 bp_addr
= bl
->target_info
.placed_address
;
1137 bp_size
= bl
->target_info
.shadow_len
;
1139 if (bp_addr
+ bp_size
<= memaddr
)
1140 /* The breakpoint is entirely before the chunk of memory we
1144 if (bp_addr
>= memaddr
+ len
)
1145 /* The breakpoint is entirely after the chunk of memory we are
1149 /* Offset within shadow_contents. */
1150 if (bp_addr
< memaddr
)
1152 /* Only copy the second part of the breakpoint. */
1153 bp_size
-= memaddr
- bp_addr
;
1154 bptoffset
= memaddr
- bp_addr
;
1158 if (bp_addr
+ bp_size
> memaddr
+ len
)
1160 /* Only copy the first part of the breakpoint. */
1161 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1164 if (readbuf
!= NULL
)
1166 /* Update the read buffer with this inserted breakpoint's
1168 memcpy (readbuf
+ bp_addr
- memaddr
,
1169 bl
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
1173 struct gdbarch
*gdbarch
= bl
->gdbarch
;
1174 const unsigned char *bp
;
1175 CORE_ADDR placed_address
= bl
->target_info
.placed_address
;
1176 unsigned placed_size
= bl
->target_info
.placed_size
;
1178 /* Update the shadow with what we want to write to memory. */
1179 memcpy (bl
->target_info
.shadow_contents
+ bptoffset
,
1180 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1182 /* Determine appropriate breakpoint contents and size for this
1184 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &placed_address
, &placed_size
);
1186 /* Update the final write buffer with this inserted
1187 breakpoint's INSN. */
1188 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1194 /* Return true if BPT is of any hardware watchpoint kind. */
1197 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1199 return (bpt
->type
== bp_hardware_watchpoint
1200 || bpt
->type
== bp_read_watchpoint
1201 || bpt
->type
== bp_access_watchpoint
);
1204 /* Return true if BPT is of any watchpoint kind, hardware or
1208 is_watchpoint (const struct breakpoint
*bpt
)
1210 return (is_hardware_watchpoint (bpt
)
1211 || bpt
->type
== bp_watchpoint
);
1214 /* Returns true if the current thread and its running state are safe
1215 to evaluate or update watchpoint B. Watchpoints on local
1216 expressions need to be evaluated in the context of the thread that
1217 was current when the watchpoint was created, and, that thread needs
1218 to be stopped to be able to select the correct frame context.
1219 Watchpoints on global expressions can be evaluated on any thread,
1220 and in any state. It is presently left to the target allowing
1221 memory accesses when threads are running. */
1224 watchpoint_in_thread_scope (struct watchpoint
*b
)
1226 return (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1227 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1228 && !is_executing (inferior_ptid
)));
1231 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1232 associated bp_watchpoint_scope breakpoint. */
1235 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1237 struct breakpoint
*b
= &w
->base
;
1239 if (b
->related_breakpoint
!= b
)
1241 gdb_assert (b
->related_breakpoint
->type
== bp_watchpoint_scope
);
1242 gdb_assert (b
->related_breakpoint
->related_breakpoint
== b
);
1243 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1244 b
->related_breakpoint
->related_breakpoint
= b
->related_breakpoint
;
1245 b
->related_breakpoint
= b
;
1247 b
->disposition
= disp_del_at_next_stop
;
1250 /* Assuming that B is a watchpoint:
1251 - Reparse watchpoint expression, if REPARSE is non-zero
1252 - Evaluate expression and store the result in B->val
1253 - Evaluate the condition if there is one, and store the result
1255 - Update the list of values that must be watched in B->loc.
1257 If the watchpoint disposition is disp_del_at_next_stop, then do
1258 nothing. If this is local watchpoint that is out of scope, delete
1261 Even with `set breakpoint always-inserted on' the watchpoints are
1262 removed + inserted on each stop here. Normal breakpoints must
1263 never be removed because they might be missed by a running thread
1264 when debugging in non-stop mode. On the other hand, hardware
1265 watchpoints (is_hardware_watchpoint; processed here) are specific
1266 to each LWP since they are stored in each LWP's hardware debug
1267 registers. Therefore, such LWP must be stopped first in order to
1268 be able to modify its hardware watchpoints.
1270 Hardware watchpoints must be reset exactly once after being
1271 presented to the user. It cannot be done sooner, because it would
1272 reset the data used to present the watchpoint hit to the user. And
1273 it must not be done later because it could display the same single
1274 watchpoint hit during multiple GDB stops. Note that the latter is
1275 relevant only to the hardware watchpoint types bp_read_watchpoint
1276 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1277 not user-visible - its hit is suppressed if the memory content has
1280 The following constraints influence the location where we can reset
1281 hardware watchpoints:
1283 * target_stopped_by_watchpoint and target_stopped_data_address are
1284 called several times when GDB stops.
1287 * Multiple hardware watchpoints can be hit at the same time,
1288 causing GDB to stop. GDB only presents one hardware watchpoint
1289 hit at a time as the reason for stopping, and all the other hits
1290 are presented later, one after the other, each time the user
1291 requests the execution to be resumed. Execution is not resumed
1292 for the threads still having pending hit event stored in
1293 LWP_INFO->STATUS. While the watchpoint is already removed from
1294 the inferior on the first stop the thread hit event is kept being
1295 reported from its cached value by linux_nat_stopped_data_address
1296 until the real thread resume happens after the watchpoint gets
1297 presented and thus its LWP_INFO->STATUS gets reset.
1299 Therefore the hardware watchpoint hit can get safely reset on the
1300 watchpoint removal from inferior. */
1303 update_watchpoint (struct watchpoint
*b
, int reparse
)
1305 int within_current_scope
;
1306 struct frame_id saved_frame_id
;
1309 /* If this is a local watchpoint, we only want to check if the
1310 watchpoint frame is in scope if the current thread is the thread
1311 that was used to create the watchpoint. */
1312 if (!watchpoint_in_thread_scope (b
))
1315 if (b
->base
.disposition
== disp_del_at_next_stop
)
1320 /* Determine if the watchpoint is within scope. */
1321 if (b
->exp_valid_block
== NULL
)
1322 within_current_scope
= 1;
1325 struct frame_info
*fi
= get_current_frame ();
1326 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1327 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1329 /* If we're in a function epilogue, unwinding may not work
1330 properly, so do not attempt to recreate locations at this
1331 point. See similar comments in watchpoint_check. */
1332 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
1335 /* Save the current frame's ID so we can restore it after
1336 evaluating the watchpoint expression on its own frame. */
1337 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1338 took a frame parameter, so that we didn't have to change the
1341 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1343 fi
= frame_find_by_id (b
->watchpoint_frame
);
1344 within_current_scope
= (fi
!= NULL
);
1345 if (within_current_scope
)
1349 /* We don't free locations. They are stored in the bp_location array
1350 and update_global_location_list will eventually delete them and
1351 remove breakpoints if needed. */
1354 if (within_current_scope
&& reparse
)
1363 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1364 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1365 /* If the meaning of expression itself changed, the old value is
1366 no longer relevant. We don't want to report a watchpoint hit
1367 to the user when the old value and the new value may actually
1368 be completely different objects. */
1369 value_free (b
->val
);
1373 /* Note that unlike with breakpoints, the watchpoint's condition
1374 expression is stored in the breakpoint object, not in the
1375 locations (re)created below. */
1376 if (b
->base
.cond_string
!= NULL
)
1378 if (b
->cond_exp
!= NULL
)
1380 xfree (b
->cond_exp
);
1384 s
= b
->base
.cond_string
;
1385 b
->cond_exp
= parse_exp_1 (&s
, b
->cond_exp_valid_block
, 0);
1389 /* If we failed to parse the expression, for example because
1390 it refers to a global variable in a not-yet-loaded shared library,
1391 don't try to insert watchpoint. We don't automatically delete
1392 such watchpoint, though, since failure to parse expression
1393 is different from out-of-scope watchpoint. */
1394 if ( !target_has_execution
)
1396 /* Without execution, memory can't change. No use to try and
1397 set watchpoint locations. The watchpoint will be reset when
1398 the target gains execution, through breakpoint_re_set. */
1400 else if (within_current_scope
&& b
->exp
)
1403 struct value
*val_chain
, *v
, *result
, *next
;
1404 struct program_space
*frame_pspace
;
1406 fetch_subexp_value (b
->exp
, &pc
, &v
, &result
, &val_chain
);
1408 /* Avoid setting b->val if it's already set. The meaning of
1409 b->val is 'the last value' user saw, and we should update
1410 it only if we reported that last value to user. As it
1411 happens, the code that reports it updates b->val directly.
1412 We don't keep track of the memory value for masked
1414 if (!b
->val_valid
&& !is_masked_watchpoint (&b
->base
))
1420 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1422 /* Look at each value on the value chain. */
1423 for (v
= val_chain
; v
; v
= value_next (v
))
1425 /* If it's a memory location, and GDB actually needed
1426 its contents to evaluate the expression, then we
1427 must watch it. If the first value returned is
1428 still lazy, that means an error occurred reading it;
1429 watch it anyway in case it becomes readable. */
1430 if (VALUE_LVAL (v
) == lval_memory
1431 && (v
== val_chain
|| ! value_lazy (v
)))
1433 struct type
*vtype
= check_typedef (value_type (v
));
1435 /* We only watch structs and arrays if user asked
1436 for it explicitly, never if they just happen to
1437 appear in the middle of some value chain. */
1439 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1440 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1444 struct bp_location
*loc
, **tmp
;
1446 addr
= value_address (v
);
1447 len
= TYPE_LENGTH (value_type (v
));
1449 if (b
->base
.type
== bp_read_watchpoint
)
1451 else if (b
->base
.type
== bp_access_watchpoint
)
1454 loc
= allocate_bp_location (&b
->base
);
1455 for (tmp
= &(b
->base
.loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1458 loc
->gdbarch
= get_type_arch (value_type (v
));
1460 loc
->pspace
= frame_pspace
;
1461 loc
->address
= addr
;
1463 loc
->watchpoint_type
= type
;
1468 /* Change the type of breakpoint between hardware assisted or
1469 an ordinary watchpoint depending on the hardware support
1470 and free hardware slots. REPARSE is set when the inferior
1475 enum bp_loc_type loc_type
;
1476 struct bp_location
*bl
;
1478 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
1482 int i
, target_resources_ok
, other_type_used
;
1485 /* Use an exact watchpoint when there's only one memory region to be
1486 watched, and only one debug register is needed to watch it. */
1487 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
1489 /* We need to determine how many resources are already
1490 used for all other hardware watchpoints plus this one
1491 to see if we still have enough resources to also fit
1492 this watchpoint in as well. */
1494 /* If this is a software watchpoint, we try to turn it
1495 to a hardware one -- count resources as if B was of
1496 hardware watchpoint type. */
1497 type
= b
->base
.type
;
1498 if (type
== bp_watchpoint
)
1499 type
= bp_hardware_watchpoint
;
1501 /* This watchpoint may or may not have been placed on
1502 the list yet at this point (it won't be in the list
1503 if we're trying to create it for the first time,
1504 through watch_command), so always account for it
1507 /* Count resources used by all watchpoints except B. */
1508 i
= hw_watchpoint_used_count_others (&b
->base
, type
, &other_type_used
);
1510 /* Add in the resources needed for B. */
1511 i
+= hw_watchpoint_use_count (&b
->base
);
1514 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
1515 if (target_resources_ok
<= 0)
1517 int sw_mode
= b
->base
.ops
->works_in_software_mode (&b
->base
);
1519 if (target_resources_ok
== 0 && !sw_mode
)
1520 error (_("Target does not support this type of "
1521 "hardware watchpoint."));
1522 else if (target_resources_ok
< 0 && !sw_mode
)
1523 error (_("There are not enough available hardware "
1524 "resources for this watchpoint."));
1526 /* Downgrade to software watchpoint. */
1527 b
->base
.type
= bp_watchpoint
;
1531 /* If this was a software watchpoint, we've just
1532 found we have enough resources to turn it to a
1533 hardware watchpoint. Otherwise, this is a
1535 b
->base
.type
= type
;
1538 else if (!b
->base
.ops
->works_in_software_mode (&b
->base
))
1539 error (_("Expression cannot be implemented with "
1540 "read/access watchpoint."));
1542 b
->base
.type
= bp_watchpoint
;
1544 loc_type
= (b
->base
.type
== bp_watchpoint
? bp_loc_other
1545 : bp_loc_hardware_watchpoint
);
1546 for (bl
= b
->base
.loc
; bl
; bl
= bl
->next
)
1547 bl
->loc_type
= loc_type
;
1550 for (v
= val_chain
; v
; v
= next
)
1552 next
= value_next (v
);
1557 /* If a software watchpoint is not watching any memory, then the
1558 above left it without any location set up. But,
1559 bpstat_stop_status requires a location to be able to report
1560 stops, so make sure there's at least a dummy one. */
1561 if (b
->base
.type
== bp_watchpoint
&& b
->base
.loc
== NULL
)
1563 struct breakpoint
*base
= &b
->base
;
1564 base
->loc
= allocate_bp_location (base
);
1565 base
->loc
->pspace
= frame_pspace
;
1566 base
->loc
->address
= -1;
1567 base
->loc
->length
= -1;
1568 base
->loc
->watchpoint_type
= -1;
1571 else if (!within_current_scope
)
1573 printf_filtered (_("\
1574 Watchpoint %d deleted because the program has left the block\n\
1575 in which its expression is valid.\n"),
1577 watchpoint_del_at_next_stop (b
);
1580 /* Restore the selected frame. */
1582 select_frame (frame_find_by_id (saved_frame_id
));
1586 /* Returns 1 iff breakpoint location should be
1587 inserted in the inferior. We don't differentiate the type of BL's owner
1588 (breakpoint vs. tracepoint), although insert_location in tracepoint's
1589 breakpoint_ops is not defined, because in insert_bp_location,
1590 tracepoint's insert_location will not be called. */
1592 should_be_inserted (struct bp_location
*bl
)
1594 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
1597 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
1600 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
1603 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
1606 /* This is set for example, when we're attached to the parent of a
1607 vfork, and have detached from the child. The child is running
1608 free, and we expect it to do an exec or exit, at which point the
1609 OS makes the parent schedulable again (and the target reports
1610 that the vfork is done). Until the child is done with the shared
1611 memory region, do not insert breakpoints in the parent, otherwise
1612 the child could still trip on the parent's breakpoints. Since
1613 the parent is blocked anyway, it won't miss any breakpoint. */
1614 if (bl
->pspace
->breakpoints_not_allowed
)
1620 /* Same as should_be_inserted but does the check assuming
1621 that the location is not duplicated. */
1624 unduplicated_should_be_inserted (struct bp_location
*bl
)
1627 const int save_duplicate
= bl
->duplicate
;
1630 result
= should_be_inserted (bl
);
1631 bl
->duplicate
= save_duplicate
;
1635 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
1636 location. Any error messages are printed to TMP_ERROR_STREAM; and
1637 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
1638 Returns 0 for success, 1 if the bp_location type is not supported or
1641 NOTE drow/2003-09-09: This routine could be broken down to an
1642 object-style method for each breakpoint or catchpoint type. */
1644 insert_bp_location (struct bp_location
*bl
,
1645 struct ui_file
*tmp_error_stream
,
1646 int *disabled_breaks
,
1647 int *hw_breakpoint_error
)
1651 if (!should_be_inserted (bl
) || bl
->inserted
)
1654 /* Initialize the target-specific information. */
1655 memset (&bl
->target_info
, 0, sizeof (bl
->target_info
));
1656 bl
->target_info
.placed_address
= bl
->address
;
1657 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
1658 bl
->target_info
.length
= bl
->length
;
1660 if (bl
->loc_type
== bp_loc_software_breakpoint
1661 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
1663 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
1665 /* If the explicitly specified breakpoint type
1666 is not hardware breakpoint, check the memory map to see
1667 if the breakpoint address is in read only memory or not.
1669 Two important cases are:
1670 - location type is not hardware breakpoint, memory
1671 is readonly. We change the type of the location to
1672 hardware breakpoint.
1673 - location type is hardware breakpoint, memory is
1674 read-write. This means we've previously made the
1675 location hardware one, but then the memory map changed,
1678 When breakpoints are removed, remove_breakpoints will use
1679 location types we've just set here, the only possible
1680 problem is that memory map has changed during running
1681 program, but it's not going to work anyway with current
1683 struct mem_region
*mr
1684 = lookup_mem_region (bl
->target_info
.placed_address
);
1688 if (automatic_hardware_breakpoints
)
1690 enum bp_loc_type new_type
;
1692 if (mr
->attrib
.mode
!= MEM_RW
)
1693 new_type
= bp_loc_hardware_breakpoint
;
1695 new_type
= bp_loc_software_breakpoint
;
1697 if (new_type
!= bl
->loc_type
)
1699 static int said
= 0;
1701 bl
->loc_type
= new_type
;
1704 fprintf_filtered (gdb_stdout
,
1705 _("Note: automatically using "
1706 "hardware breakpoints for "
1707 "read-only addresses.\n"));
1712 else if (bl
->loc_type
== bp_loc_software_breakpoint
1713 && mr
->attrib
.mode
!= MEM_RW
)
1714 warning (_("cannot set software breakpoint "
1715 "at readonly address %s"),
1716 paddress (bl
->gdbarch
, bl
->address
));
1720 /* First check to see if we have to handle an overlay. */
1721 if (overlay_debugging
== ovly_off
1722 || bl
->section
== NULL
1723 || !(section_is_overlay (bl
->section
)))
1725 /* No overlay handling: just set the breakpoint. */
1727 val
= bl
->owner
->ops
->insert_location (bl
);
1731 /* This breakpoint is in an overlay section.
1732 Shall we set a breakpoint at the LMA? */
1733 if (!overlay_events_enabled
)
1735 /* Yes -- overlay event support is not active,
1736 so we must try to set a breakpoint at the LMA.
1737 This will not work for a hardware breakpoint. */
1738 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1739 warning (_("hardware breakpoint %d not supported in overlay!"),
1743 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
1745 /* Set a software (trap) breakpoint at the LMA. */
1746 bl
->overlay_target_info
= bl
->target_info
;
1747 bl
->overlay_target_info
.placed_address
= addr
;
1748 val
= target_insert_breakpoint (bl
->gdbarch
,
1749 &bl
->overlay_target_info
);
1751 fprintf_unfiltered (tmp_error_stream
,
1752 "Overlay breakpoint %d "
1753 "failed: in ROM?\n",
1757 /* Shall we set a breakpoint at the VMA? */
1758 if (section_is_mapped (bl
->section
))
1760 /* Yes. This overlay section is mapped into memory. */
1761 val
= bl
->owner
->ops
->insert_location (bl
);
1765 /* No. This breakpoint will not be inserted.
1766 No error, but do not mark the bp as 'inserted'. */
1773 /* Can't set the breakpoint. */
1774 if (solib_name_from_address (bl
->pspace
, bl
->address
))
1776 /* See also: disable_breakpoints_in_shlibs. */
1778 bl
->shlib_disabled
= 1;
1779 observer_notify_breakpoint_modified (bl
->owner
);
1780 if (!*disabled_breaks
)
1782 fprintf_unfiltered (tmp_error_stream
,
1783 "Cannot insert breakpoint %d.\n",
1785 fprintf_unfiltered (tmp_error_stream
,
1786 "Temporarily disabling shared "
1787 "library breakpoints:\n");
1789 *disabled_breaks
= 1;
1790 fprintf_unfiltered (tmp_error_stream
,
1791 "breakpoint #%d\n", bl
->owner
->number
);
1795 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1797 *hw_breakpoint_error
= 1;
1798 fprintf_unfiltered (tmp_error_stream
,
1799 "Cannot insert hardware "
1805 fprintf_unfiltered (tmp_error_stream
,
1806 "Cannot insert breakpoint %d.\n",
1808 fprintf_filtered (tmp_error_stream
,
1809 "Error accessing memory address ");
1810 fputs_filtered (paddress (bl
->gdbarch
, bl
->address
),
1812 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1813 safe_strerror (val
));
1824 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
1825 /* NOTE drow/2003-09-08: This state only exists for removing
1826 watchpoints. It's not clear that it's necessary... */
1827 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
1829 gdb_assert (bl
->owner
->ops
!= NULL
1830 && bl
->owner
->ops
->insert_location
!= NULL
);
1832 val
= bl
->owner
->ops
->insert_location (bl
);
1834 /* If trying to set a read-watchpoint, and it turns out it's not
1835 supported, try emulating one with an access watchpoint. */
1836 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
1838 struct bp_location
*loc
, **loc_temp
;
1840 /* But don't try to insert it, if there's already another
1841 hw_access location that would be considered a duplicate
1843 ALL_BP_LOCATIONS (loc
, loc_temp
)
1845 && loc
->watchpoint_type
== hw_access
1846 && watchpoint_locations_match (bl
, loc
))
1850 bl
->target_info
= loc
->target_info
;
1851 bl
->watchpoint_type
= hw_access
;
1858 bl
->watchpoint_type
= hw_access
;
1859 val
= bl
->owner
->ops
->insert_location (bl
);
1862 /* Back to the original value. */
1863 bl
->watchpoint_type
= hw_read
;
1867 bl
->inserted
= (val
== 0);
1870 else if (bl
->owner
->type
== bp_catchpoint
)
1872 gdb_assert (bl
->owner
->ops
!= NULL
1873 && bl
->owner
->ops
->insert_location
!= NULL
);
1875 val
= bl
->owner
->ops
->insert_location (bl
);
1878 bl
->owner
->enable_state
= bp_disabled
;
1882 Error inserting catchpoint %d: Your system does not support this type\n\
1883 of catchpoint."), bl
->owner
->number
);
1885 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
1888 bl
->inserted
= (val
== 0);
1890 /* We've already printed an error message if there was a problem
1891 inserting this catchpoint, and we've disabled the catchpoint,
1892 so just return success. */
1899 /* This function is called when program space PSPACE is about to be
1900 deleted. It takes care of updating breakpoints to not reference
1904 breakpoint_program_space_exit (struct program_space
*pspace
)
1906 struct breakpoint
*b
, *b_temp
;
1907 struct bp_location
*loc
, **loc_temp
;
1909 /* Remove any breakpoint that was set through this program space. */
1910 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1912 if (b
->pspace
== pspace
)
1913 delete_breakpoint (b
);
1916 /* Breakpoints set through other program spaces could have locations
1917 bound to PSPACE as well. Remove those. */
1918 ALL_BP_LOCATIONS (loc
, loc_temp
)
1920 struct bp_location
*tmp
;
1922 if (loc
->pspace
== pspace
)
1924 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1925 if (loc
->owner
->loc
== loc
)
1926 loc
->owner
->loc
= loc
->next
;
1928 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1929 if (tmp
->next
== loc
)
1931 tmp
->next
= loc
->next
;
1937 /* Now update the global location list to permanently delete the
1938 removed locations above. */
1939 update_global_location_list (0);
1942 /* Make sure all breakpoints are inserted in inferior.
1943 Throws exception on any error.
1944 A breakpoint that is already inserted won't be inserted
1945 again, so calling this function twice is safe. */
1947 insert_breakpoints (void)
1949 struct breakpoint
*bpt
;
1951 ALL_BREAKPOINTS (bpt
)
1952 if (is_hardware_watchpoint (bpt
))
1954 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
1956 update_watchpoint (w
, 0 /* don't reparse. */);
1959 update_global_location_list (1);
1961 /* update_global_location_list does not insert breakpoints when
1962 always_inserted_mode is not enabled. Explicitly insert them
1964 if (!breakpoints_always_inserted_mode ())
1965 insert_breakpoint_locations ();
1968 /* Used when starting or continuing the program. */
1971 insert_breakpoint_locations (void)
1973 struct breakpoint
*bpt
;
1974 struct bp_location
*bl
, **blp_tmp
;
1977 int disabled_breaks
= 0;
1978 int hw_breakpoint_error
= 0;
1980 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1981 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1983 /* Explicitly mark the warning -- this will only be printed if
1984 there was an error. */
1985 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1987 save_current_space_and_thread ();
1989 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1991 if (!should_be_inserted (bl
) || bl
->inserted
)
1994 /* There is no point inserting thread-specific breakpoints if
1995 the thread no longer exists. ALL_BP_LOCATIONS bp_location
1996 has BL->OWNER always non-NULL. */
1997 if (bl
->owner
->thread
!= -1
1998 && !valid_thread_id (bl
->owner
->thread
))
2001 switch_to_program_space_and_thread (bl
->pspace
);
2003 /* For targets that support global breakpoints, there's no need
2004 to select an inferior to insert breakpoint to. In fact, even
2005 if we aren't attached to any process yet, we should still
2006 insert breakpoints. */
2007 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
2008 && ptid_equal (inferior_ptid
, null_ptid
))
2011 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
2012 &hw_breakpoint_error
);
2017 /* If we failed to insert all locations of a watchpoint, remove
2018 them, as half-inserted watchpoint is of limited use. */
2019 ALL_BREAKPOINTS (bpt
)
2021 int some_failed
= 0;
2022 struct bp_location
*loc
;
2024 if (!is_hardware_watchpoint (bpt
))
2027 if (!breakpoint_enabled (bpt
))
2030 if (bpt
->disposition
== disp_del_at_next_stop
)
2033 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2034 if (!loc
->inserted
&& should_be_inserted (loc
))
2041 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2043 remove_breakpoint (loc
, mark_uninserted
);
2045 hw_breakpoint_error
= 1;
2046 fprintf_unfiltered (tmp_error_stream
,
2047 "Could not insert hardware watchpoint %d.\n",
2055 /* If a hardware breakpoint or watchpoint was inserted, add a
2056 message about possibly exhausted resources. */
2057 if (hw_breakpoint_error
)
2059 fprintf_unfiltered (tmp_error_stream
,
2060 "Could not insert hardware breakpoints:\n\
2061 You may have requested too many hardware breakpoints/watchpoints.\n");
2063 target_terminal_ours_for_output ();
2064 error_stream (tmp_error_stream
);
2067 do_cleanups (cleanups
);
2070 /* Used when the program stops.
2071 Returns zero if successful, or non-zero if there was a problem
2072 removing a breakpoint location. */
2075 remove_breakpoints (void)
2077 struct bp_location
*bl
, **blp_tmp
;
2080 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2082 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
2083 val
|= remove_breakpoint (bl
, mark_uninserted
);
2088 /* Remove breakpoints of process PID. */
2091 remove_breakpoints_pid (int pid
)
2093 struct bp_location
*bl
, **blp_tmp
;
2095 struct inferior
*inf
= find_inferior_pid (pid
);
2097 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2099 if (bl
->pspace
!= inf
->pspace
)
2104 val
= remove_breakpoint (bl
, mark_uninserted
);
2113 reattach_breakpoints (int pid
)
2115 struct cleanup
*old_chain
;
2116 struct bp_location
*bl
, **blp_tmp
;
2118 struct ui_file
*tmp_error_stream
;
2119 int dummy1
= 0, dummy2
= 0;
2120 struct inferior
*inf
;
2121 struct thread_info
*tp
;
2123 tp
= any_live_thread_of_process (pid
);
2127 inf
= find_inferior_pid (pid
);
2128 old_chain
= save_inferior_ptid ();
2130 inferior_ptid
= tp
->ptid
;
2132 tmp_error_stream
= mem_fileopen ();
2133 make_cleanup_ui_file_delete (tmp_error_stream
);
2135 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2137 if (bl
->pspace
!= inf
->pspace
)
2143 val
= insert_bp_location (bl
, tmp_error_stream
, &dummy1
, &dummy2
);
2146 do_cleanups (old_chain
);
2151 do_cleanups (old_chain
);
2155 static int internal_breakpoint_number
= -1;
2157 /* Set the breakpoint number of B, depending on the value of INTERNAL.
2158 If INTERNAL is non-zero, the breakpoint number will be populated
2159 from internal_breakpoint_number and that variable decremented.
2160 Otherwise the breakpoint number will be populated from
2161 breakpoint_count and that value incremented. Internal breakpoints
2162 do not set the internal var bpnum. */
2164 set_breakpoint_number (int internal
, struct breakpoint
*b
)
2167 b
->number
= internal_breakpoint_number
--;
2170 set_breakpoint_count (breakpoint_count
+ 1);
2171 b
->number
= breakpoint_count
;
2175 static struct breakpoint
*
2176 create_internal_breakpoint (struct gdbarch
*gdbarch
,
2177 CORE_ADDR address
, enum bptype type
,
2178 const struct breakpoint_ops
*ops
)
2180 struct symtab_and_line sal
;
2181 struct breakpoint
*b
;
2183 init_sal (&sal
); /* Initialize to zeroes. */
2186 sal
.section
= find_pc_overlay (sal
.pc
);
2187 sal
.pspace
= current_program_space
;
2189 b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
2190 b
->number
= internal_breakpoint_number
--;
2191 b
->disposition
= disp_donttouch
;
2196 static const char *const longjmp_names
[] =
2198 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
2200 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
2202 /* Per-objfile data private to breakpoint.c. */
2203 struct breakpoint_objfile_data
2205 /* Minimal symbol for "_ovly_debug_event" (if any). */
2206 struct minimal_symbol
*overlay_msym
;
2208 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
2209 struct minimal_symbol
*longjmp_msym
[NUM_LONGJMP_NAMES
];
2211 /* Minimal symbol for "std::terminate()" (if any). */
2212 struct minimal_symbol
*terminate_msym
;
2214 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
2215 struct minimal_symbol
*exception_msym
;
2218 static const struct objfile_data
*breakpoint_objfile_key
;
2220 /* Minimal symbol not found sentinel. */
2221 static struct minimal_symbol msym_not_found
;
2223 /* Returns TRUE if MSYM point to the "not found" sentinel. */
2226 msym_not_found_p (const struct minimal_symbol
*msym
)
2228 return msym
== &msym_not_found
;
2231 /* Return per-objfile data needed by breakpoint.c.
2232 Allocate the data if necessary. */
2234 static struct breakpoint_objfile_data
*
2235 get_breakpoint_objfile_data (struct objfile
*objfile
)
2237 struct breakpoint_objfile_data
*bp_objfile_data
;
2239 bp_objfile_data
= objfile_data (objfile
, breakpoint_objfile_key
);
2240 if (bp_objfile_data
== NULL
)
2242 bp_objfile_data
= obstack_alloc (&objfile
->objfile_obstack
,
2243 sizeof (*bp_objfile_data
));
2245 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
2246 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
2248 return bp_objfile_data
;
2252 create_overlay_event_breakpoint (void)
2254 struct objfile
*objfile
;
2255 const char *const func_name
= "_ovly_debug_event";
2257 ALL_OBJFILES (objfile
)
2259 struct breakpoint
*b
;
2260 struct breakpoint_objfile_data
*bp_objfile_data
;
2263 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2265 if (msym_not_found_p (bp_objfile_data
->overlay_msym
))
2268 if (bp_objfile_data
->overlay_msym
== NULL
)
2270 struct minimal_symbol
*m
;
2272 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2275 /* Avoid future lookups in this objfile. */
2276 bp_objfile_data
->overlay_msym
= &msym_not_found
;
2279 bp_objfile_data
->overlay_msym
= m
;
2282 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
2283 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2285 &internal_breakpoint_ops
);
2286 b
->addr_string
= xstrdup (func_name
);
2288 if (overlay_debugging
== ovly_auto
)
2290 b
->enable_state
= bp_enabled
;
2291 overlay_events_enabled
= 1;
2295 b
->enable_state
= bp_disabled
;
2296 overlay_events_enabled
= 0;
2299 update_global_location_list (1);
2303 create_longjmp_master_breakpoint (void)
2305 struct program_space
*pspace
;
2306 struct cleanup
*old_chain
;
2308 old_chain
= save_current_program_space ();
2310 ALL_PSPACES (pspace
)
2312 struct objfile
*objfile
;
2314 set_current_program_space (pspace
);
2316 ALL_OBJFILES (objfile
)
2319 struct gdbarch
*gdbarch
;
2320 struct breakpoint_objfile_data
*bp_objfile_data
;
2322 gdbarch
= get_objfile_arch (objfile
);
2323 if (!gdbarch_get_longjmp_target_p (gdbarch
))
2326 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2328 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
2330 struct breakpoint
*b
;
2331 const char *func_name
;
2334 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
]))
2337 func_name
= longjmp_names
[i
];
2338 if (bp_objfile_data
->longjmp_msym
[i
] == NULL
)
2340 struct minimal_symbol
*m
;
2342 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2345 /* Prevent future lookups in this objfile. */
2346 bp_objfile_data
->longjmp_msym
[i
] = &msym_not_found
;
2349 bp_objfile_data
->longjmp_msym
[i
] = m
;
2352 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
2353 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
2354 &internal_breakpoint_ops
);
2355 b
->addr_string
= xstrdup (func_name
);
2356 b
->enable_state
= bp_disabled
;
2360 update_global_location_list (1);
2362 do_cleanups (old_chain
);
2365 /* Create a master std::terminate breakpoint. */
2367 create_std_terminate_master_breakpoint (void)
2369 struct program_space
*pspace
;
2370 struct cleanup
*old_chain
;
2371 const char *const func_name
= "std::terminate()";
2373 old_chain
= save_current_program_space ();
2375 ALL_PSPACES (pspace
)
2377 struct objfile
*objfile
;
2380 set_current_program_space (pspace
);
2382 ALL_OBJFILES (objfile
)
2384 struct breakpoint
*b
;
2385 struct breakpoint_objfile_data
*bp_objfile_data
;
2387 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2389 if (msym_not_found_p (bp_objfile_data
->terminate_msym
))
2392 if (bp_objfile_data
->terminate_msym
== NULL
)
2394 struct minimal_symbol
*m
;
2396 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2397 if (m
== NULL
|| (MSYMBOL_TYPE (m
) != mst_text
2398 && MSYMBOL_TYPE (m
) != mst_file_text
))
2400 /* Prevent future lookups in this objfile. */
2401 bp_objfile_data
->terminate_msym
= &msym_not_found
;
2404 bp_objfile_data
->terminate_msym
= m
;
2407 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
2408 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2409 bp_std_terminate_master
,
2410 &internal_breakpoint_ops
);
2411 b
->addr_string
= xstrdup (func_name
);
2412 b
->enable_state
= bp_disabled
;
2416 update_global_location_list (1);
2418 do_cleanups (old_chain
);
2421 /* Install a master breakpoint on the unwinder's debug hook. */
2424 create_exception_master_breakpoint (void)
2426 struct objfile
*objfile
;
2427 const char *const func_name
= "_Unwind_DebugHook";
2429 ALL_OBJFILES (objfile
)
2431 struct breakpoint
*b
;
2432 struct gdbarch
*gdbarch
;
2433 struct breakpoint_objfile_data
*bp_objfile_data
;
2436 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2438 if (msym_not_found_p (bp_objfile_data
->exception_msym
))
2441 gdbarch
= get_objfile_arch (objfile
);
2443 if (bp_objfile_data
->exception_msym
== NULL
)
2445 struct minimal_symbol
*debug_hook
;
2447 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2448 if (debug_hook
== NULL
)
2450 bp_objfile_data
->exception_msym
= &msym_not_found
;
2454 bp_objfile_data
->exception_msym
= debug_hook
;
2457 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
2458 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2460 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
2461 &internal_breakpoint_ops
);
2462 b
->addr_string
= xstrdup (func_name
);
2463 b
->enable_state
= bp_disabled
;
2466 update_global_location_list (1);
2470 update_breakpoints_after_exec (void)
2472 struct breakpoint
*b
, *b_tmp
;
2473 struct bp_location
*bploc
, **bplocp_tmp
;
2475 /* We're about to delete breakpoints from GDB's lists. If the
2476 INSERTED flag is true, GDB will try to lift the breakpoints by
2477 writing the breakpoints' "shadow contents" back into memory. The
2478 "shadow contents" are NOT valid after an exec, so GDB should not
2479 do that. Instead, the target is responsible from marking
2480 breakpoints out as soon as it detects an exec. We don't do that
2481 here instead, because there may be other attempts to delete
2482 breakpoints after detecting an exec and before reaching here. */
2483 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
2484 if (bploc
->pspace
== current_program_space
)
2485 gdb_assert (!bploc
->inserted
);
2487 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2489 if (b
->pspace
!= current_program_space
)
2492 /* Solib breakpoints must be explicitly reset after an exec(). */
2493 if (b
->type
== bp_shlib_event
)
2495 delete_breakpoint (b
);
2499 /* JIT breakpoints must be explicitly reset after an exec(). */
2500 if (b
->type
== bp_jit_event
)
2502 delete_breakpoint (b
);
2506 /* Thread event breakpoints must be set anew after an exec(),
2507 as must overlay event and longjmp master breakpoints. */
2508 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
2509 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
2510 || b
->type
== bp_exception_master
)
2512 delete_breakpoint (b
);
2516 /* Step-resume breakpoints are meaningless after an exec(). */
2517 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
2519 delete_breakpoint (b
);
2523 /* Longjmp and longjmp-resume breakpoints are also meaningless
2525 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
2526 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
2528 delete_breakpoint (b
);
2532 if (b
->type
== bp_catchpoint
)
2534 /* For now, none of the bp_catchpoint breakpoints need to
2535 do anything at this point. In the future, if some of
2536 the catchpoints need to something, we will need to add
2537 a new method, and call this method from here. */
2541 /* bp_finish is a special case. The only way we ought to be able
2542 to see one of these when an exec() has happened, is if the user
2543 caught a vfork, and then said "finish". Ordinarily a finish just
2544 carries them to the call-site of the current callee, by setting
2545 a temporary bp there and resuming. But in this case, the finish
2546 will carry them entirely through the vfork & exec.
2548 We don't want to allow a bp_finish to remain inserted now. But
2549 we can't safely delete it, 'cause finish_command has a handle to
2550 the bp on a bpstat, and will later want to delete it. There's a
2551 chance (and I've seen it happen) that if we delete the bp_finish
2552 here, that its storage will get reused by the time finish_command
2553 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2554 We really must allow finish_command to delete a bp_finish.
2556 In the absence of a general solution for the "how do we know
2557 it's safe to delete something others may have handles to?"
2558 problem, what we'll do here is just uninsert the bp_finish, and
2559 let finish_command delete it.
2561 (We know the bp_finish is "doomed" in the sense that it's
2562 momentary, and will be deleted as soon as finish_command sees
2563 the inferior stopped. So it doesn't matter that the bp's
2564 address is probably bogus in the new a.out, unlike e.g., the
2565 solib breakpoints.) */
2567 if (b
->type
== bp_finish
)
2572 /* Without a symbolic address, we have little hope of the
2573 pre-exec() address meaning the same thing in the post-exec()
2575 if (b
->addr_string
== NULL
)
2577 delete_breakpoint (b
);
2581 /* FIXME what about longjmp breakpoints? Re-create them here? */
2582 create_overlay_event_breakpoint ();
2583 create_longjmp_master_breakpoint ();
2584 create_std_terminate_master_breakpoint ();
2585 create_exception_master_breakpoint ();
2589 detach_breakpoints (int pid
)
2591 struct bp_location
*bl
, **blp_tmp
;
2593 struct cleanup
*old_chain
= save_inferior_ptid ();
2594 struct inferior
*inf
= current_inferior ();
2596 if (pid
== PIDGET (inferior_ptid
))
2597 error (_("Cannot detach breakpoints of inferior_ptid"));
2599 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2600 inferior_ptid
= pid_to_ptid (pid
);
2601 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2603 if (bl
->pspace
!= inf
->pspace
)
2607 val
|= remove_breakpoint_1 (bl
, mark_inserted
);
2610 /* Detach single-step breakpoints as well. */
2611 detach_single_step_breakpoints ();
2613 do_cleanups (old_chain
);
2617 /* Remove the breakpoint location BL from the current address space.
2618 Note that this is used to detach breakpoints from a child fork.
2619 When we get here, the child isn't in the inferior list, and neither
2620 do we have objects to represent its address space --- we should
2621 *not* look at bl->pspace->aspace here. */
2624 remove_breakpoint_1 (struct bp_location
*bl
, insertion_state_t is
)
2628 /* BL is never in moribund_locations by our callers. */
2629 gdb_assert (bl
->owner
!= NULL
);
2631 if (bl
->owner
->enable_state
== bp_permanent
)
2632 /* Permanent breakpoints cannot be inserted or removed. */
2635 /* The type of none suggests that owner is actually deleted.
2636 This should not ever happen. */
2637 gdb_assert (bl
->owner
->type
!= bp_none
);
2639 if (bl
->loc_type
== bp_loc_software_breakpoint
2640 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2642 /* "Normal" instruction breakpoint: either the standard
2643 trap-instruction bp (bp_breakpoint), or a
2644 bp_hardware_breakpoint. */
2646 /* First check to see if we have to handle an overlay. */
2647 if (overlay_debugging
== ovly_off
2648 || bl
->section
== NULL
2649 || !(section_is_overlay (bl
->section
)))
2651 /* No overlay handling: just remove the breakpoint. */
2652 val
= bl
->owner
->ops
->remove_location (bl
);
2656 /* This breakpoint is in an overlay section.
2657 Did we set a breakpoint at the LMA? */
2658 if (!overlay_events_enabled
)
2660 /* Yes -- overlay event support is not active, so we
2661 should have set a breakpoint at the LMA. Remove it.
2663 /* Ignore any failures: if the LMA is in ROM, we will
2664 have already warned when we failed to insert it. */
2665 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2666 target_remove_hw_breakpoint (bl
->gdbarch
,
2667 &bl
->overlay_target_info
);
2669 target_remove_breakpoint (bl
->gdbarch
,
2670 &bl
->overlay_target_info
);
2672 /* Did we set a breakpoint at the VMA?
2673 If so, we will have marked the breakpoint 'inserted'. */
2676 /* Yes -- remove it. Previously we did not bother to
2677 remove the breakpoint if the section had been
2678 unmapped, but let's not rely on that being safe. We
2679 don't know what the overlay manager might do. */
2681 /* However, we should remove *software* breakpoints only
2682 if the section is still mapped, or else we overwrite
2683 wrong code with the saved shadow contents. */
2684 if (bl
->loc_type
== bp_loc_hardware_breakpoint
2685 || section_is_mapped (bl
->section
))
2686 val
= bl
->owner
->ops
->remove_location (bl
);
2692 /* No -- not inserted, so no need to remove. No error. */
2697 /* In some cases, we might not be able to remove a breakpoint
2698 in a shared library that has already been removed, but we
2699 have not yet processed the shlib unload event. */
2700 if (val
&& solib_name_from_address (bl
->pspace
, bl
->address
))
2705 bl
->inserted
= (is
== mark_inserted
);
2707 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
2709 gdb_assert (bl
->owner
->ops
!= NULL
2710 && bl
->owner
->ops
->remove_location
!= NULL
);
2712 bl
->inserted
= (is
== mark_inserted
);
2713 bl
->owner
->ops
->remove_location (bl
);
2715 /* Failure to remove any of the hardware watchpoints comes here. */
2716 if ((is
== mark_uninserted
) && (bl
->inserted
))
2717 warning (_("Could not remove hardware watchpoint %d."),
2720 else if (bl
->owner
->type
== bp_catchpoint
2721 && breakpoint_enabled (bl
->owner
)
2724 gdb_assert (bl
->owner
->ops
!= NULL
2725 && bl
->owner
->ops
->remove_location
!= NULL
);
2727 val
= bl
->owner
->ops
->remove_location (bl
);
2731 bl
->inserted
= (is
== mark_inserted
);
2738 remove_breakpoint (struct bp_location
*bl
, insertion_state_t is
)
2741 struct cleanup
*old_chain
;
2743 /* BL is never in moribund_locations by our callers. */
2744 gdb_assert (bl
->owner
!= NULL
);
2746 if (bl
->owner
->enable_state
== bp_permanent
)
2747 /* Permanent breakpoints cannot be inserted or removed. */
2750 /* The type of none suggests that owner is actually deleted.
2751 This should not ever happen. */
2752 gdb_assert (bl
->owner
->type
!= bp_none
);
2754 old_chain
= save_current_space_and_thread ();
2756 switch_to_program_space_and_thread (bl
->pspace
);
2758 ret
= remove_breakpoint_1 (bl
, is
);
2760 do_cleanups (old_chain
);
2764 /* Clear the "inserted" flag in all breakpoints. */
2767 mark_breakpoints_out (void)
2769 struct bp_location
*bl
, **blp_tmp
;
2771 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2772 if (bl
->pspace
== current_program_space
)
2776 /* Clear the "inserted" flag in all breakpoints and delete any
2777 breakpoints which should go away between runs of the program.
2779 Plus other such housekeeping that has to be done for breakpoints
2782 Note: this function gets called at the end of a run (by
2783 generic_mourn_inferior) and when a run begins (by
2784 init_wait_for_inferior). */
2789 breakpoint_init_inferior (enum inf_context context
)
2791 struct breakpoint
*b
, *b_tmp
;
2792 struct bp_location
*bl
, **blp_tmp
;
2794 struct program_space
*pspace
= current_program_space
;
2796 /* If breakpoint locations are shared across processes, then there's
2798 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2801 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2803 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2804 if (bl
->pspace
== pspace
2805 && bl
->owner
->enable_state
!= bp_permanent
)
2809 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2811 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2818 /* If the call dummy breakpoint is at the entry point it will
2819 cause problems when the inferior is rerun, so we better get
2822 case bp_watchpoint_scope
:
2824 /* Also get rid of scope breakpoints. */
2826 case bp_shlib_event
:
2828 /* Also remove solib event breakpoints. Their addresses may
2829 have changed since the last time we ran the program.
2830 Actually we may now be debugging against different target;
2831 and so the solib backend that installed this breakpoint may
2832 not be used in by the target. E.g.,
2834 (gdb) file prog-linux
2835 (gdb) run # native linux target
2838 (gdb) file prog-win.exe
2839 (gdb) tar rem :9999 # remote Windows gdbserver.
2842 delete_breakpoint (b
);
2846 case bp_hardware_watchpoint
:
2847 case bp_read_watchpoint
:
2848 case bp_access_watchpoint
:
2850 struct watchpoint
*w
= (struct watchpoint
*) b
;
2852 /* Likewise for watchpoints on local expressions. */
2853 if (w
->exp_valid_block
!= NULL
)
2854 delete_breakpoint (b
);
2855 else if (context
== inf_starting
)
2857 /* Reset val field to force reread of starting value in
2858 insert_breakpoints. */
2860 value_free (w
->val
);
2871 /* Get rid of the moribund locations. */
2872 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
2873 decref_bp_location (&bl
);
2874 VEC_free (bp_location_p
, moribund_locations
);
2877 /* These functions concern about actual breakpoints inserted in the
2878 target --- to e.g. check if we need to do decr_pc adjustment or if
2879 we need to hop over the bkpt --- so we check for address space
2880 match, not program space. */
2882 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2883 exists at PC. It returns ordinary_breakpoint_here if it's an
2884 ordinary breakpoint, or permanent_breakpoint_here if it's a
2885 permanent breakpoint.
2886 - When continuing from a location with an ordinary breakpoint, we
2887 actually single step once before calling insert_breakpoints.
2888 - When continuing from a location with a permanent breakpoint, we
2889 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2890 the target, to advance the PC past the breakpoint. */
2892 enum breakpoint_here
2893 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2895 struct bp_location
*bl
, **blp_tmp
;
2896 int any_breakpoint_here
= 0;
2898 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2900 if (bl
->loc_type
!= bp_loc_software_breakpoint
2901 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2904 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2905 if ((breakpoint_enabled (bl
->owner
)
2906 || bl
->owner
->enable_state
== bp_permanent
)
2907 && breakpoint_location_address_match (bl
, aspace
, pc
))
2909 if (overlay_debugging
2910 && section_is_overlay (bl
->section
)
2911 && !section_is_mapped (bl
->section
))
2912 continue; /* unmapped overlay -- can't be a match */
2913 else if (bl
->owner
->enable_state
== bp_permanent
)
2914 return permanent_breakpoint_here
;
2916 any_breakpoint_here
= 1;
2920 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2923 /* Return true if there's a moribund breakpoint at PC. */
2926 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2928 struct bp_location
*loc
;
2931 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2932 if (breakpoint_location_address_match (loc
, aspace
, pc
))
2938 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2939 inserted using regular breakpoint_chain / bp_location array
2940 mechanism. This does not check for single-step breakpoints, which
2941 are inserted and removed using direct target manipulation. */
2944 regular_breakpoint_inserted_here_p (struct address_space
*aspace
,
2947 struct bp_location
*bl
, **blp_tmp
;
2949 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2951 if (bl
->loc_type
!= bp_loc_software_breakpoint
2952 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2956 && breakpoint_location_address_match (bl
, aspace
, pc
))
2958 if (overlay_debugging
2959 && section_is_overlay (bl
->section
)
2960 && !section_is_mapped (bl
->section
))
2961 continue; /* unmapped overlay -- can't be a match */
2969 /* Returns non-zero iff there's either regular breakpoint
2970 or a single step breakpoint inserted at PC. */
2973 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2975 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
2978 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2984 /* This function returns non-zero iff there is a software breakpoint
2988 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
2991 struct bp_location
*bl
, **blp_tmp
;
2993 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2995 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
2999 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
3002 if (overlay_debugging
3003 && section_is_overlay (bl
->section
)
3004 && !section_is_mapped (bl
->section
))
3005 continue; /* unmapped overlay -- can't be a match */
3011 /* Also check for software single-step breakpoints. */
3012 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
3019 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
3020 CORE_ADDR addr
, ULONGEST len
)
3022 struct breakpoint
*bpt
;
3024 ALL_BREAKPOINTS (bpt
)
3026 struct bp_location
*loc
;
3028 if (bpt
->type
!= bp_hardware_watchpoint
3029 && bpt
->type
!= bp_access_watchpoint
)
3032 if (!breakpoint_enabled (bpt
))
3035 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3036 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
3040 /* Check for intersection. */
3041 l
= max (loc
->address
, addr
);
3042 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
3050 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
3051 PC is valid for process/thread PTID. */
3054 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
3057 struct bp_location
*bl
, **blp_tmp
;
3058 /* The thread and task IDs associated to PTID, computed lazily. */
3062 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3064 if (bl
->loc_type
!= bp_loc_software_breakpoint
3065 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
3068 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
3069 if (!breakpoint_enabled (bl
->owner
)
3070 && bl
->owner
->enable_state
!= bp_permanent
)
3073 if (!breakpoint_location_address_match (bl
, aspace
, pc
))
3076 if (bl
->owner
->thread
!= -1)
3078 /* This is a thread-specific breakpoint. Check that ptid
3079 matches that thread. If thread hasn't been computed yet,
3080 it is now time to do so. */
3082 thread
= pid_to_thread_id (ptid
);
3083 if (bl
->owner
->thread
!= thread
)
3087 if (bl
->owner
->task
!= 0)
3089 /* This is a task-specific breakpoint. Check that ptid
3090 matches that task. If task hasn't been computed yet,
3091 it is now time to do so. */
3093 task
= ada_get_task_number (ptid
);
3094 if (bl
->owner
->task
!= task
)
3098 if (overlay_debugging
3099 && section_is_overlay (bl
->section
)
3100 && !section_is_mapped (bl
->section
))
3101 continue; /* unmapped overlay -- can't be a match */
3110 /* bpstat stuff. External routines' interfaces are documented
3114 ep_is_catchpoint (struct breakpoint
*ep
)
3116 return (ep
->type
== bp_catchpoint
);
3119 /* Frees any storage that is part of a bpstat. Does not walk the
3123 bpstat_free (bpstat bs
)
3125 if (bs
->old_val
!= NULL
)
3126 value_free (bs
->old_val
);
3127 decref_counted_command_line (&bs
->commands
);
3128 decref_bp_location (&bs
->bp_location_at
);
3132 /* Clear a bpstat so that it says we are not at any breakpoint.
3133 Also free any storage that is part of a bpstat. */
3136 bpstat_clear (bpstat
*bsp
)
3153 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
3154 is part of the bpstat is copied as well. */
3157 bpstat_copy (bpstat bs
)
3161 bpstat retval
= NULL
;
3166 for (; bs
!= NULL
; bs
= bs
->next
)
3168 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
3169 memcpy (tmp
, bs
, sizeof (*tmp
));
3170 incref_counted_command_line (tmp
->commands
);
3171 incref_bp_location (tmp
->bp_location_at
);
3172 if (bs
->old_val
!= NULL
)
3174 tmp
->old_val
= value_copy (bs
->old_val
);
3175 release_value (tmp
->old_val
);
3179 /* This is the first thing in the chain. */
3189 /* Find the bpstat associated with this breakpoint. */
3192 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
3197 for (; bsp
!= NULL
; bsp
= bsp
->next
)
3199 if (bsp
->breakpoint_at
== breakpoint
)
3205 /* Put in *NUM the breakpoint number of the first breakpoint we are
3206 stopped at. *BSP upon return is a bpstat which points to the
3207 remaining breakpoints stopped at (but which is not guaranteed to be
3208 good for anything but further calls to bpstat_num).
3210 Return 0 if passed a bpstat which does not indicate any breakpoints.
3211 Return -1 if stopped at a breakpoint that has been deleted since
3213 Return 1 otherwise. */
3216 bpstat_num (bpstat
*bsp
, int *num
)
3218 struct breakpoint
*b
;
3221 return 0; /* No more breakpoint values */
3223 /* We assume we'll never have several bpstats that correspond to a
3224 single breakpoint -- otherwise, this function might return the
3225 same number more than once and this will look ugly. */
3226 b
= (*bsp
)->breakpoint_at
;
3227 *bsp
= (*bsp
)->next
;
3229 return -1; /* breakpoint that's been deleted since */
3231 *num
= b
->number
; /* We have its number */
3235 /* See breakpoint.h. */
3238 bpstat_clear_actions (void)
3240 struct thread_info
*tp
;
3243 if (ptid_equal (inferior_ptid
, null_ptid
))
3246 tp
= find_thread_ptid (inferior_ptid
);
3250 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
3252 decref_counted_command_line (&bs
->commands
);
3254 if (bs
->old_val
!= NULL
)
3256 value_free (bs
->old_val
);
3262 /* Called when a command is about to proceed the inferior. */
3265 breakpoint_about_to_proceed (void)
3267 if (!ptid_equal (inferior_ptid
, null_ptid
))
3269 struct thread_info
*tp
= inferior_thread ();
3271 /* Allow inferior function calls in breakpoint commands to not
3272 interrupt the command list. When the call finishes
3273 successfully, the inferior will be standing at the same
3274 breakpoint as if nothing happened. */
3275 if (tp
->control
.in_infcall
)
3279 breakpoint_proceeded
= 1;
3282 /* Stub for cleaning up our state if we error-out of a breakpoint
3285 cleanup_executing_breakpoints (void *ignore
)
3287 executing_breakpoint_commands
= 0;
3290 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
3291 or its equivalent. */
3294 command_line_is_silent (struct command_line
*cmd
)
3296 return cmd
&& (strcmp ("silent", cmd
->line
) == 0
3297 || (xdb_commands
&& strcmp ("Q", cmd
->line
) == 0));
3300 /* Execute all the commands associated with all the breakpoints at
3301 this location. Any of these commands could cause the process to
3302 proceed beyond this point, etc. We look out for such changes by
3303 checking the global "breakpoint_proceeded" after each command.
3305 Returns true if a breakpoint command resumed the inferior. In that
3306 case, it is the caller's responsibility to recall it again with the
3307 bpstat of the current thread. */
3310 bpstat_do_actions_1 (bpstat
*bsp
)
3313 struct cleanup
*old_chain
;
3316 /* Avoid endless recursion if a `source' command is contained
3318 if (executing_breakpoint_commands
)
3321 executing_breakpoint_commands
= 1;
3322 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
3324 prevent_dont_repeat ();
3326 /* This pointer will iterate over the list of bpstat's. */
3329 breakpoint_proceeded
= 0;
3330 for (; bs
!= NULL
; bs
= bs
->next
)
3332 struct counted_command_line
*ccmd
;
3333 struct command_line
*cmd
;
3334 struct cleanup
*this_cmd_tree_chain
;
3336 /* Take ownership of the BSP's command tree, if it has one.
3338 The command tree could legitimately contain commands like
3339 'step' and 'next', which call clear_proceed_status, which
3340 frees stop_bpstat's command tree. To make sure this doesn't
3341 free the tree we're executing out from under us, we need to
3342 take ownership of the tree ourselves. Since a given bpstat's
3343 commands are only executed once, we don't need to copy it; we
3344 can clear the pointer in the bpstat, and make sure we free
3345 the tree when we're done. */
3346 ccmd
= bs
->commands
;
3347 bs
->commands
= NULL
;
3348 this_cmd_tree_chain
= make_cleanup_decref_counted_command_line (&ccmd
);
3349 cmd
= ccmd
? ccmd
->commands
: NULL
;
3350 if (command_line_is_silent (cmd
))
3352 /* The action has been already done by bpstat_stop_status. */
3358 execute_control_command (cmd
);
3360 if (breakpoint_proceeded
)
3366 /* We can free this command tree now. */
3367 do_cleanups (this_cmd_tree_chain
);
3369 if (breakpoint_proceeded
)
3371 if (target_can_async_p ())
3372 /* If we are in async mode, then the target might be still
3373 running, not stopped at any breakpoint, so nothing for
3374 us to do here -- just return to the event loop. */
3377 /* In sync mode, when execute_control_command returns
3378 we're already standing on the next breakpoint.
3379 Breakpoint commands for that stop were not run, since
3380 execute_command does not run breakpoint commands --
3381 only command_line_handler does, but that one is not
3382 involved in execution of breakpoint commands. So, we
3383 can now execute breakpoint commands. It should be
3384 noted that making execute_command do bpstat actions is
3385 not an option -- in this case we'll have recursive
3386 invocation of bpstat for each breakpoint with a
3387 command, and can easily blow up GDB stack. Instead, we
3388 return true, which will trigger the caller to recall us
3389 with the new stop_bpstat. */
3394 do_cleanups (old_chain
);
3399 bpstat_do_actions (void)
3401 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
3403 /* Do any commands attached to breakpoint we are stopped at. */
3404 while (!ptid_equal (inferior_ptid
, null_ptid
)
3405 && target_has_execution
3406 && !is_exited (inferior_ptid
)
3407 && !is_executing (inferior_ptid
))
3408 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3409 and only return when it is stopped at the next breakpoint, we
3410 keep doing breakpoint actions until it returns false to
3411 indicate the inferior was not resumed. */
3412 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
3415 discard_cleanups (cleanup_if_error
);
3418 /* Print out the (old or new) value associated with a watchpoint. */
3421 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
3424 fprintf_unfiltered (stream
, _("<unreadable>"));
3427 struct value_print_options opts
;
3428 get_user_print_options (&opts
);
3429 value_print (val
, stream
, &opts
);
3433 /* Generic routine for printing messages indicating why we
3434 stopped. The behavior of this function depends on the value
3435 'print_it' in the bpstat structure. Under some circumstances we
3436 may decide not to print anything here and delegate the task to
3439 static enum print_stop_action
3440 print_bp_stop_message (bpstat bs
)
3442 switch (bs
->print_it
)
3445 /* Nothing should be printed for this bpstat entry. */
3446 return PRINT_UNKNOWN
;
3450 /* We still want to print the frame, but we already printed the
3451 relevant messages. */
3452 return PRINT_SRC_AND_LOC
;
3455 case print_it_normal
:
3457 struct breakpoint
*b
= bs
->breakpoint_at
;
3459 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3460 which has since been deleted. */
3462 return PRINT_UNKNOWN
;
3464 /* Normal case. Call the breakpoint's print_it method. */
3465 return b
->ops
->print_it (bs
);
3470 internal_error (__FILE__
, __LINE__
,
3471 _("print_bp_stop_message: unrecognized enum value"));
3476 /* Print a message indicating what happened. This is called from
3477 normal_stop(). The input to this routine is the head of the bpstat
3478 list - a list of the eventpoints that caused this stop. KIND is
3479 the target_waitkind for the stopping event. This
3480 routine calls the generic print routine for printing a message
3481 about reasons for stopping. This will print (for example) the
3482 "Breakpoint n," part of the output. The return value of this
3485 PRINT_UNKNOWN: Means we printed nothing.
3486 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3487 code to print the location. An example is
3488 "Breakpoint 1, " which should be followed by
3490 PRINT_SRC_ONLY: Means we printed something, but there is no need
3491 to also print the location part of the message.
3492 An example is the catch/throw messages, which
3493 don't require a location appended to the end.
3494 PRINT_NOTHING: We have done some printing and we don't need any
3495 further info to be printed. */
3497 enum print_stop_action
3498 bpstat_print (bpstat bs
, int kind
)
3502 /* Maybe another breakpoint in the chain caused us to stop.
3503 (Currently all watchpoints go on the bpstat whether hit or not.
3504 That probably could (should) be changed, provided care is taken
3505 with respect to bpstat_explains_signal). */
3506 for (; bs
; bs
= bs
->next
)
3508 val
= print_bp_stop_message (bs
);
3509 if (val
== PRINT_SRC_ONLY
3510 || val
== PRINT_SRC_AND_LOC
3511 || val
== PRINT_NOTHING
)
3515 /* If we had hit a shared library event breakpoint,
3516 print_bp_stop_message would print out this message. If we hit an
3517 OS-level shared library event, do the same thing. */
3518 if (kind
== TARGET_WAITKIND_LOADED
)
3520 ui_out_text (current_uiout
, _("Stopped due to shared library event\n"));
3521 if (ui_out_is_mi_like_p (current_uiout
))
3522 ui_out_field_string (current_uiout
, "reason",
3523 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
3524 return PRINT_NOTHING
;
3527 /* We reached the end of the chain, or we got a null BS to start
3528 with and nothing was printed. */
3529 return PRINT_UNKNOWN
;
3532 /* Evaluate the expression EXP and return 1 if value is zero. This is
3533 used inside a catch_errors to evaluate the breakpoint condition.
3534 The argument is a "struct expression *" that has been cast to a
3535 "char *" to make it pass through catch_errors. */
3538 breakpoint_cond_eval (void *exp
)
3540 struct value
*mark
= value_mark ();
3541 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
3543 value_free_to_mark (mark
);
3547 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
3550 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
3554 bs
= (bpstat
) xmalloc (sizeof (*bs
));
3556 **bs_link_pointer
= bs
;
3557 *bs_link_pointer
= &bs
->next
;
3558 bs
->breakpoint_at
= bl
->owner
;
3559 bs
->bp_location_at
= bl
;
3560 incref_bp_location (bl
);
3561 /* If the condition is false, etc., don't do the commands. */
3562 bs
->commands
= NULL
;
3564 bs
->print_it
= print_it_normal
;
3568 /* The target has stopped with waitstatus WS. Check if any hardware
3569 watchpoints have triggered, according to the target. */
3572 watchpoints_triggered (struct target_waitstatus
*ws
)
3574 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3576 struct breakpoint
*b
;
3578 if (!stopped_by_watchpoint
)
3580 /* We were not stopped by a watchpoint. Mark all watchpoints
3581 as not triggered. */
3583 if (is_hardware_watchpoint (b
))
3585 struct watchpoint
*w
= (struct watchpoint
*) b
;
3587 w
->watchpoint_triggered
= watch_triggered_no
;
3593 if (!target_stopped_data_address (¤t_target
, &addr
))
3595 /* We were stopped by a watchpoint, but we don't know where.
3596 Mark all watchpoints as unknown. */
3598 if (is_hardware_watchpoint (b
))
3600 struct watchpoint
*w
= (struct watchpoint
*) b
;
3602 w
->watchpoint_triggered
= watch_triggered_unknown
;
3605 return stopped_by_watchpoint
;
3608 /* The target could report the data address. Mark watchpoints
3609 affected by this data address as triggered, and all others as not
3613 if (is_hardware_watchpoint (b
))
3615 struct watchpoint
*w
= (struct watchpoint
*) b
;
3616 struct bp_location
*loc
;
3618 w
->watchpoint_triggered
= watch_triggered_no
;
3619 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3621 if (is_masked_watchpoint (b
))
3623 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
3624 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
3626 if (newaddr
== start
)
3628 w
->watchpoint_triggered
= watch_triggered_yes
;
3632 /* Exact match not required. Within range is sufficient. */
3633 else if (target_watchpoint_addr_within_range (¤t_target
,
3637 w
->watchpoint_triggered
= watch_triggered_yes
;
3646 /* Possible return values for watchpoint_check (this can't be an enum
3647 because of check_errors). */
3648 /* The watchpoint has been deleted. */
3649 #define WP_DELETED 1
3650 /* The value has changed. */
3651 #define WP_VALUE_CHANGED 2
3652 /* The value has not changed. */
3653 #define WP_VALUE_NOT_CHANGED 3
3654 /* Ignore this watchpoint, no matter if the value changed or not. */
3657 #define BP_TEMPFLAG 1
3658 #define BP_HARDWAREFLAG 2
3660 /* Evaluate watchpoint condition expression and check if its value
3663 P should be a pointer to struct bpstat, but is defined as a void *
3664 in order for this function to be usable with catch_errors. */
3667 watchpoint_check (void *p
)
3669 bpstat bs
= (bpstat
) p
;
3670 struct watchpoint
*b
;
3671 struct frame_info
*fr
;
3672 int within_current_scope
;
3674 /* BS is built from an existing struct breakpoint. */
3675 gdb_assert (bs
->breakpoint_at
!= NULL
);
3676 b
= (struct watchpoint
*) bs
->breakpoint_at
;
3678 /* If this is a local watchpoint, we only want to check if the
3679 watchpoint frame is in scope if the current thread is the thread
3680 that was used to create the watchpoint. */
3681 if (!watchpoint_in_thread_scope (b
))
3684 if (b
->exp_valid_block
== NULL
)
3685 within_current_scope
= 1;
3688 struct frame_info
*frame
= get_current_frame ();
3689 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3690 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3692 /* in_function_epilogue_p() returns a non-zero value if we're
3693 still in the function but the stack frame has already been
3694 invalidated. Since we can't rely on the values of local
3695 variables after the stack has been destroyed, we are treating
3696 the watchpoint in that state as `not changed' without further
3697 checking. Don't mark watchpoints as changed if the current
3698 frame is in an epilogue - even if they are in some other
3699 frame, our view of the stack is likely to be wrong and
3700 frame_find_by_id could error out. */
3701 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3704 fr
= frame_find_by_id (b
->watchpoint_frame
);
3705 within_current_scope
= (fr
!= NULL
);
3707 /* If we've gotten confused in the unwinder, we might have
3708 returned a frame that can't describe this variable. */
3709 if (within_current_scope
)
3711 struct symbol
*function
;
3713 function
= get_frame_function (fr
);
3714 if (function
== NULL
3715 || !contained_in (b
->exp_valid_block
,
3716 SYMBOL_BLOCK_VALUE (function
)))
3717 within_current_scope
= 0;
3720 if (within_current_scope
)
3721 /* If we end up stopping, the current frame will get selected
3722 in normal_stop. So this call to select_frame won't affect
3727 if (within_current_scope
)
3729 /* We use value_{,free_to_}mark because it could be a *long*
3730 time before we return to the command level and call
3731 free_all_values. We can't call free_all_values because we
3732 might be in the middle of evaluating a function call. */
3736 struct value
*new_val
;
3738 if (is_masked_watchpoint (&b
->base
))
3739 /* Since we don't know the exact trigger address (from
3740 stopped_data_address), just tell the user we've triggered
3741 a mask watchpoint. */
3742 return WP_VALUE_CHANGED
;
3744 mark
= value_mark ();
3745 fetch_subexp_value (b
->exp
, &pc
, &new_val
, NULL
, NULL
);
3747 /* We use value_equal_contents instead of value_equal because
3748 the latter coerces an array to a pointer, thus comparing just
3749 the address of the array instead of its contents. This is
3750 not what we want. */
3751 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3752 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
3754 if (new_val
!= NULL
)
3756 release_value (new_val
);
3757 value_free_to_mark (mark
);
3759 bs
->old_val
= b
->val
;
3762 return WP_VALUE_CHANGED
;
3766 /* Nothing changed. */
3767 value_free_to_mark (mark
);
3768 return WP_VALUE_NOT_CHANGED
;
3773 struct ui_out
*uiout
= current_uiout
;
3775 /* This seems like the only logical thing to do because
3776 if we temporarily ignored the watchpoint, then when
3777 we reenter the block in which it is valid it contains
3778 garbage (in the case of a function, it may have two
3779 garbage values, one before and one after the prologue).
3780 So we can't even detect the first assignment to it and
3781 watch after that (since the garbage may or may not equal
3782 the first value assigned). */
3783 /* We print all the stop information in
3784 breakpoint_ops->print_it, but in this case, by the time we
3785 call breakpoint_ops->print_it this bp will be deleted
3786 already. So we have no choice but print the information
3788 if (ui_out_is_mi_like_p (uiout
))
3790 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3791 ui_out_text (uiout
, "\nWatchpoint ");
3792 ui_out_field_int (uiout
, "wpnum", b
->base
.number
);
3794 " deleted because the program has left the block in\n\
3795 which its expression is valid.\n");
3797 /* Make sure the watchpoint's commands aren't executed. */
3798 decref_counted_command_line (&b
->base
.commands
);
3799 watchpoint_del_at_next_stop (b
);
3805 /* Return true if it looks like target has stopped due to hitting
3806 breakpoint location BL. This function does not check if we should
3807 stop, only if BL explains the stop. */
3810 bpstat_check_location (const struct bp_location
*bl
,
3811 struct address_space
*aspace
, CORE_ADDR bp_addr
)
3813 struct breakpoint
*b
= bl
->owner
;
3815 /* BL is from an existing breakpoint. */
3816 gdb_assert (b
!= NULL
);
3818 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
);
3821 /* Determine if the watched values have actually changed, and we
3822 should stop. If not, set BS->stop to 0. */
3825 bpstat_check_watchpoint (bpstat bs
)
3827 const struct bp_location
*bl
;
3828 struct watchpoint
*b
;
3830 /* BS is built for existing struct breakpoint. */
3831 bl
= bs
->bp_location_at
;
3832 gdb_assert (bl
!= NULL
);
3833 b
= (struct watchpoint
*) bs
->breakpoint_at
;
3834 gdb_assert (b
!= NULL
);
3837 int must_check_value
= 0;
3839 if (b
->base
.type
== bp_watchpoint
)
3840 /* For a software watchpoint, we must always check the
3842 must_check_value
= 1;
3843 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3844 /* We have a hardware watchpoint (read, write, or access)
3845 and the target earlier reported an address watched by
3847 must_check_value
= 1;
3848 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3849 && b
->base
.type
== bp_hardware_watchpoint
)
3850 /* We were stopped by a hardware watchpoint, but the target could
3851 not report the data address. We must check the watchpoint's
3852 value. Access and read watchpoints are out of luck; without
3853 a data address, we can't figure it out. */
3854 must_check_value
= 1;
3856 if (must_check_value
)
3859 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3861 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3862 int e
= catch_errors (watchpoint_check
, bs
, message
,
3864 do_cleanups (cleanups
);
3868 /* We've already printed what needs to be printed. */
3869 bs
->print_it
= print_it_done
;
3873 bs
->print_it
= print_it_noop
;
3876 case WP_VALUE_CHANGED
:
3877 if (b
->base
.type
== bp_read_watchpoint
)
3879 /* There are two cases to consider here:
3881 1. We're watching the triggered memory for reads.
3882 In that case, trust the target, and always report
3883 the watchpoint hit to the user. Even though
3884 reads don't cause value changes, the value may
3885 have changed since the last time it was read, and
3886 since we're not trapping writes, we will not see
3887 those, and as such we should ignore our notion of
3890 2. We're watching the triggered memory for both
3891 reads and writes. There are two ways this may
3894 2.1. This is a target that can't break on data
3895 reads only, but can break on accesses (reads or
3896 writes), such as e.g., x86. We detect this case
3897 at the time we try to insert read watchpoints.
3899 2.2. Otherwise, the target supports read
3900 watchpoints, but, the user set an access or write
3901 watchpoint watching the same memory as this read
3904 If we're watching memory writes as well as reads,
3905 ignore watchpoint hits when we find that the
3906 value hasn't changed, as reads don't cause
3907 changes. This still gives false positives when
3908 the program writes the same value to memory as
3909 what there was already in memory (we will confuse
3910 it for a read), but it's much better than
3913 int other_write_watchpoint
= 0;
3915 if (bl
->watchpoint_type
== hw_read
)
3917 struct breakpoint
*other_b
;
3919 ALL_BREAKPOINTS (other_b
)
3920 if (other_b
->type
== bp_hardware_watchpoint
3921 || other_b
->type
== bp_access_watchpoint
)
3923 struct watchpoint
*other_w
=
3924 (struct watchpoint
*) other_b
;
3926 if (other_w
->watchpoint_triggered
3927 == watch_triggered_yes
)
3929 other_write_watchpoint
= 1;
3935 if (other_write_watchpoint
3936 || bl
->watchpoint_type
== hw_access
)
3938 /* We're watching the same memory for writes,
3939 and the value changed since the last time we
3940 updated it, so this trap must be for a write.
3942 bs
->print_it
= print_it_noop
;
3947 case WP_VALUE_NOT_CHANGED
:
3948 if (b
->base
.type
== bp_hardware_watchpoint
3949 || b
->base
.type
== bp_watchpoint
)
3951 /* Don't stop: write watchpoints shouldn't fire if
3952 the value hasn't changed. */
3953 bs
->print_it
= print_it_noop
;
3961 /* Error from catch_errors. */
3962 printf_filtered (_("Watchpoint %d deleted.\n"), b
->base
.number
);
3963 watchpoint_del_at_next_stop (b
);
3964 /* We've already printed what needs to be printed. */
3965 bs
->print_it
= print_it_done
;
3969 else /* must_check_value == 0 */
3971 /* This is a case where some watchpoint(s) triggered, but
3972 not at the address of this watchpoint, or else no
3973 watchpoint triggered after all. So don't print
3974 anything for this watchpoint. */
3975 bs
->print_it
= print_it_noop
;
3982 /* Check conditions (condition proper, frame, thread and ignore count)
3983 of breakpoint referred to by BS. If we should not stop for this
3984 breakpoint, set BS->stop to 0. */
3987 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
3989 int thread_id
= pid_to_thread_id (ptid
);
3990 const struct bp_location
*bl
;
3991 struct breakpoint
*b
;
3993 /* BS is built for existing struct breakpoint. */
3994 bl
= bs
->bp_location_at
;
3995 gdb_assert (bl
!= NULL
);
3996 b
= bs
->breakpoint_at
;
3997 gdb_assert (b
!= NULL
);
3999 if (frame_id_p (b
->frame_id
)
4000 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
4004 int value_is_zero
= 0;
4005 struct expression
*cond
;
4007 /* Evaluate Python breakpoints that have a "stop"
4008 method implemented. */
4009 if (b
->py_bp_object
)
4010 bs
->stop
= gdbpy_should_stop (b
->py_bp_object
);
4012 if (is_watchpoint (b
))
4014 struct watchpoint
*w
= (struct watchpoint
*) b
;
4021 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
4023 int within_current_scope
= 1;
4024 struct watchpoint
* w
;
4026 /* We use value_mark and value_free_to_mark because it could
4027 be a long time before we return to the command level and
4028 call free_all_values. We can't call free_all_values
4029 because we might be in the middle of evaluating a
4031 struct value
*mark
= value_mark ();
4033 if (is_watchpoint (b
))
4034 w
= (struct watchpoint
*) b
;
4038 /* Need to select the frame, with all that implies so that
4039 the conditions will have the right context. Because we
4040 use the frame, we will not see an inlined function's
4041 variables when we arrive at a breakpoint at the start
4042 of the inlined function; the current frame will be the
4044 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
4045 select_frame (get_current_frame ());
4048 struct frame_info
*frame
;
4050 /* For local watchpoint expressions, which particular
4051 instance of a local is being watched matters, so we
4052 keep track of the frame to evaluate the expression
4053 in. To evaluate the condition however, it doesn't
4054 really matter which instantiation of the function
4055 where the condition makes sense triggers the
4056 watchpoint. This allows an expression like "watch
4057 global if q > 10" set in `func', catch writes to
4058 global on all threads that call `func', or catch
4059 writes on all recursive calls of `func' by a single
4060 thread. We simply always evaluate the condition in
4061 the innermost frame that's executing where it makes
4062 sense to evaluate the condition. It seems
4064 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
4066 select_frame (frame
);
4068 within_current_scope
= 0;
4070 if (within_current_scope
)
4072 = catch_errors (breakpoint_cond_eval
, cond
,
4073 "Error in testing breakpoint condition:\n",
4077 warning (_("Watchpoint condition cannot be tested "
4078 "in the current scope"));
4079 /* If we failed to set the right context for this
4080 watchpoint, unconditionally report it. */
4083 /* FIXME-someday, should give breakpoint #. */
4084 value_free_to_mark (mark
);
4087 if (cond
&& value_is_zero
)
4091 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
4095 else if (b
->ignore_count
> 0)
4098 annotate_ignore_count_change ();
4100 /* Increase the hit count even though we don't stop. */
4102 observer_notify_breakpoint_modified (b
);
4108 /* Get a bpstat associated with having just stopped at address
4109 BP_ADDR in thread PTID.
4111 Determine whether we stopped at a breakpoint, etc, or whether we
4112 don't understand this stop. Result is a chain of bpstat's such
4115 if we don't understand the stop, the result is a null pointer.
4117 if we understand why we stopped, the result is not null.
4119 Each element of the chain refers to a particular breakpoint or
4120 watchpoint at which we have stopped. (We may have stopped for
4121 several reasons concurrently.)
4123 Each element of the chain has valid next, breakpoint_at,
4124 commands, FIXME??? fields. */
4127 bpstat_stop_status (struct address_space
*aspace
,
4128 CORE_ADDR bp_addr
, ptid_t ptid
)
4130 struct breakpoint
*b
= NULL
;
4131 struct bp_location
*bl
;
4132 struct bp_location
*loc
;
4133 /* First item of allocated bpstat's. */
4134 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
4135 /* Pointer to the last thing in the chain currently. */
4138 int need_remove_insert
;
4141 /* First, build the bpstat chain with locations that explain a
4142 target stop, while being careful to not set the target running,
4143 as that may invalidate locations (in particular watchpoint
4144 locations are recreated). Resuming will happen here with
4145 breakpoint conditions or watchpoint expressions that include
4146 inferior function calls. */
4150 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
4153 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
4155 /* For hardware watchpoints, we look only at the first
4156 location. The watchpoint_check function will work on the
4157 entire expression, not the individual locations. For
4158 read watchpoints, the watchpoints_triggered function has
4159 checked all locations already. */
4160 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
4163 if (bl
->shlib_disabled
)
4166 if (!bpstat_check_location (bl
, aspace
, bp_addr
))
4169 /* Come here if it's a watchpoint, or if the break address
4172 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
4175 /* Assume we stop. Should we find a watchpoint that is not
4176 actually triggered, or if the condition of the breakpoint
4177 evaluates as false, we'll reset 'stop' to 0. */
4181 /* If this is a scope breakpoint, mark the associated
4182 watchpoint as triggered so that we will handle the
4183 out-of-scope event. We'll get to the watchpoint next
4185 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
4187 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
4189 w
->watchpoint_triggered
= watch_triggered_yes
;
4194 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4196 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
))
4198 bs
= bpstat_alloc (loc
, &bs_link
);
4199 /* For hits of moribund locations, we should just proceed. */
4202 bs
->print_it
= print_it_noop
;
4206 /* Now go through the locations that caused the target to stop, and
4207 check whether we're interested in reporting this stop to higher
4208 layers, or whether we should resume the target transparently. */
4212 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4217 b
= bs
->breakpoint_at
;
4218 b
->ops
->check_status (bs
);
4221 bpstat_check_breakpoint_conditions (bs
, ptid
);
4226 observer_notify_breakpoint_modified (b
);
4228 /* We will stop here. */
4229 if (b
->disposition
== disp_disable
)
4231 if (b
->enable_state
!= bp_permanent
)
4232 b
->enable_state
= bp_disabled
;
4237 bs
->commands
= b
->commands
;
4238 incref_counted_command_line (bs
->commands
);
4239 if (command_line_is_silent (bs
->commands
4240 ? bs
->commands
->commands
: NULL
))
4244 /* Print nothing for this entry if we don't stop or don't print. */
4245 if (bs
->stop
== 0 || bs
->print
== 0)
4246 bs
->print_it
= print_it_noop
;
4250 /* If we aren't stopping, the value of some hardware watchpoint may
4251 not have changed, but the intermediate memory locations we are
4252 watching may have. Don't bother if we're stopping; this will get
4254 need_remove_insert
= 0;
4255 if (! bpstat_causes_stop (bs_head
))
4256 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4258 && bs
->breakpoint_at
4259 && is_hardware_watchpoint (bs
->breakpoint_at
))
4261 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
4263 update_watchpoint (w
, 0 /* don't reparse. */);
4264 need_remove_insert
= 1;
4267 if (need_remove_insert
)
4268 update_global_location_list (1);
4269 else if (removed_any
)
4270 update_global_location_list (0);
4276 handle_jit_event (void)
4278 struct frame_info
*frame
;
4279 struct gdbarch
*gdbarch
;
4281 /* Switch terminal for any messages produced by
4282 breakpoint_re_set. */
4283 target_terminal_ours_for_output ();
4285 frame
= get_current_frame ();
4286 gdbarch
= get_frame_arch (frame
);
4288 jit_event_handler (gdbarch
);
4290 target_terminal_inferior ();
4293 /* Prepare WHAT final decision for infrun. */
4295 /* Decide what infrun needs to do with this bpstat. */
4298 bpstat_what (bpstat bs_head
)
4300 struct bpstat_what retval
;
4301 /* We need to defer calling `solib_add', as adding new symbols
4302 resets breakpoints, which in turn deletes breakpoint locations,
4303 and hence may clear unprocessed entries in the BS chain. */
4304 int shlib_event
= 0;
4308 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4309 retval
.call_dummy
= STOP_NONE
;
4310 retval
.is_longjmp
= 0;
4312 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4314 /* Extract this BS's action. After processing each BS, we check
4315 if its action overrides all we've seem so far. */
4316 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4319 if (bs
->breakpoint_at
== NULL
)
4321 /* I suspect this can happen if it was a momentary
4322 breakpoint which has since been deleted. */
4326 bptype
= bs
->breakpoint_at
->type
;
4333 case bp_hardware_breakpoint
:
4339 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4341 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4344 this_action
= BPSTAT_WHAT_SINGLE
;
4347 case bp_hardware_watchpoint
:
4348 case bp_read_watchpoint
:
4349 case bp_access_watchpoint
:
4353 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4355 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4359 /* There was a watchpoint, but we're not stopping.
4360 This requires no further action. */
4365 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
4366 retval
.is_longjmp
= bptype
== bp_longjmp
;
4368 case bp_longjmp_resume
:
4369 case bp_exception_resume
:
4370 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
4371 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
4373 case bp_step_resume
:
4375 this_action
= BPSTAT_WHAT_STEP_RESUME
;
4378 /* It is for the wrong frame. */
4379 this_action
= BPSTAT_WHAT_SINGLE
;
4382 case bp_hp_step_resume
:
4384 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
4387 /* It is for the wrong frame. */
4388 this_action
= BPSTAT_WHAT_SINGLE
;
4391 case bp_watchpoint_scope
:
4392 case bp_thread_event
:
4393 case bp_overlay_event
:
4394 case bp_longjmp_master
:
4395 case bp_std_terminate_master
:
4396 case bp_exception_master
:
4397 this_action
= BPSTAT_WHAT_SINGLE
;
4403 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4405 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4409 /* There was a catchpoint, but we're not stopping.
4410 This requires no further action. */
4413 case bp_shlib_event
:
4416 /* If requested, stop when the dynamic linker notifies GDB
4417 of events. This allows the user to get control and place
4418 breakpoints in initializer routines for dynamically
4419 loaded objects (among other things). */
4420 if (stop_on_solib_events
)
4421 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4423 this_action
= BPSTAT_WHAT_SINGLE
;
4427 this_action
= BPSTAT_WHAT_SINGLE
;
4430 /* Make sure the action is stop (silent or noisy),
4431 so infrun.c pops the dummy frame. */
4432 retval
.call_dummy
= STOP_STACK_DUMMY
;
4433 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4435 case bp_std_terminate
:
4436 /* Make sure the action is stop (silent or noisy),
4437 so infrun.c pops the dummy frame. */
4438 retval
.call_dummy
= STOP_STD_TERMINATE
;
4439 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4442 case bp_fast_tracepoint
:
4443 case bp_static_tracepoint
:
4444 /* Tracepoint hits should not be reported back to GDB, and
4445 if one got through somehow, it should have been filtered
4447 internal_error (__FILE__
, __LINE__
,
4448 _("bpstat_what: tracepoint encountered"));
4450 case bp_gnu_ifunc_resolver
:
4451 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
4452 this_action
= BPSTAT_WHAT_SINGLE
;
4454 case bp_gnu_ifunc_resolver_return
:
4455 /* The breakpoint will be removed, execution will restart from the
4456 PC of the former breakpoint. */
4457 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4460 internal_error (__FILE__
, __LINE__
,
4461 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
4464 retval
.main_action
= max (retval
.main_action
, this_action
);
4467 /* These operations may affect the bs->breakpoint_at state so they are
4468 delayed after MAIN_ACTION is decided above. */
4473 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_shlib_event\n");
4475 /* Check for any newly added shared libraries if we're supposed
4476 to be adding them automatically. */
4478 /* Switch terminal for any messages produced by
4479 breakpoint_re_set. */
4480 target_terminal_ours_for_output ();
4483 SOLIB_ADD (NULL
, 0, ¤t_target
, auto_solib_add
);
4485 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
4488 target_terminal_inferior ();
4494 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_jit_event\n");
4496 handle_jit_event ();
4499 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4501 struct breakpoint
*b
= bs
->breakpoint_at
;
4507 case bp_gnu_ifunc_resolver
:
4508 gnu_ifunc_resolver_stop (b
);
4510 case bp_gnu_ifunc_resolver_return
:
4511 gnu_ifunc_resolver_return_stop (b
);
4519 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4520 without hardware support). This isn't related to a specific bpstat,
4521 just to things like whether watchpoints are set. */
4524 bpstat_should_step (void)
4526 struct breakpoint
*b
;
4529 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
4535 bpstat_causes_stop (bpstat bs
)
4537 for (; bs
!= NULL
; bs
= bs
->next
)
4546 /* Compute a string of spaces suitable to indent the next line
4547 so it starts at the position corresponding to the table column
4548 named COL_NAME in the currently active table of UIOUT. */
4551 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
4553 static char wrap_indent
[80];
4554 int i
, total_width
, width
, align
;
4558 for (i
= 1; ui_out_query_field (uiout
, i
, &width
, &align
, &text
); i
++)
4560 if (strcmp (text
, col_name
) == 0)
4562 gdb_assert (total_width
< sizeof wrap_indent
);
4563 memset (wrap_indent
, ' ', total_width
);
4564 wrap_indent
[total_width
] = 0;
4569 total_width
+= width
+ 1;
4575 /* Print the LOC location out of the list of B->LOC locations. */
4578 print_breakpoint_location (struct breakpoint
*b
,
4579 struct bp_location
*loc
)
4581 struct ui_out
*uiout
= current_uiout
;
4582 struct cleanup
*old_chain
= save_current_program_space ();
4584 if (loc
!= NULL
&& loc
->shlib_disabled
)
4588 set_current_program_space (loc
->pspace
);
4590 if (b
->display_canonical
)
4591 ui_out_field_string (uiout
, "what", b
->addr_string
);
4592 else if (loc
&& loc
->source_file
)
4595 = find_pc_sect_function (loc
->address
, loc
->section
);
4598 ui_out_text (uiout
, "in ");
4599 ui_out_field_string (uiout
, "func",
4600 SYMBOL_PRINT_NAME (sym
));
4601 ui_out_text (uiout
, " ");
4602 ui_out_wrap_hint (uiout
, wrap_indent_at_field (uiout
, "what"));
4603 ui_out_text (uiout
, "at ");
4605 ui_out_field_string (uiout
, "file", loc
->source_file
);
4606 ui_out_text (uiout
, ":");
4608 if (ui_out_is_mi_like_p (uiout
))
4610 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
4611 char *fullname
= symtab_to_fullname (sal
.symtab
);
4614 ui_out_field_string (uiout
, "fullname", fullname
);
4617 ui_out_field_int (uiout
, "line", loc
->line_number
);
4621 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4622 struct cleanup
*stb_chain
= make_cleanup_ui_out_stream_delete (stb
);
4624 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
->stream
,
4626 ui_out_field_stream (uiout
, "at", stb
);
4628 do_cleanups (stb_chain
);
4631 ui_out_field_string (uiout
, "pending", b
->addr_string
);
4633 do_cleanups (old_chain
);
4637 bptype_string (enum bptype type
)
4639 struct ep_type_description
4644 static struct ep_type_description bptypes
[] =
4646 {bp_none
, "?deleted?"},
4647 {bp_breakpoint
, "breakpoint"},
4648 {bp_hardware_breakpoint
, "hw breakpoint"},
4649 {bp_until
, "until"},
4650 {bp_finish
, "finish"},
4651 {bp_watchpoint
, "watchpoint"},
4652 {bp_hardware_watchpoint
, "hw watchpoint"},
4653 {bp_read_watchpoint
, "read watchpoint"},
4654 {bp_access_watchpoint
, "acc watchpoint"},
4655 {bp_longjmp
, "longjmp"},
4656 {bp_longjmp_resume
, "longjmp resume"},
4657 {bp_exception
, "exception"},
4658 {bp_exception_resume
, "exception resume"},
4659 {bp_step_resume
, "step resume"},
4660 {bp_hp_step_resume
, "high-priority step resume"},
4661 {bp_watchpoint_scope
, "watchpoint scope"},
4662 {bp_call_dummy
, "call dummy"},
4663 {bp_std_terminate
, "std::terminate"},
4664 {bp_shlib_event
, "shlib events"},
4665 {bp_thread_event
, "thread events"},
4666 {bp_overlay_event
, "overlay events"},
4667 {bp_longjmp_master
, "longjmp master"},
4668 {bp_std_terminate_master
, "std::terminate master"},
4669 {bp_exception_master
, "exception master"},
4670 {bp_catchpoint
, "catchpoint"},
4671 {bp_tracepoint
, "tracepoint"},
4672 {bp_fast_tracepoint
, "fast tracepoint"},
4673 {bp_static_tracepoint
, "static tracepoint"},
4674 {bp_jit_event
, "jit events"},
4675 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
4676 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
4679 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
4680 || ((int) type
!= bptypes
[(int) type
].type
))
4681 internal_error (__FILE__
, __LINE__
,
4682 _("bptypes table does not describe type #%d."),
4685 return bptypes
[(int) type
].description
;
4688 /* Print B to gdb_stdout. */
4691 print_one_breakpoint_location (struct breakpoint
*b
,
4692 struct bp_location
*loc
,
4694 struct bp_location
**last_loc
,
4697 struct command_line
*l
;
4698 static char bpenables
[] = "nynny";
4700 struct ui_out
*uiout
= current_uiout
;
4701 int header_of_multiple
= 0;
4702 int part_of_multiple
= (loc
!= NULL
);
4703 struct value_print_options opts
;
4705 get_user_print_options (&opts
);
4707 gdb_assert (!loc
|| loc_number
!= 0);
4708 /* See comment in print_one_breakpoint concerning treatment of
4709 breakpoints with single disabled location. */
4712 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
4713 header_of_multiple
= 1;
4721 if (part_of_multiple
)
4724 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
4725 ui_out_field_string (uiout
, "number", formatted
);
4730 ui_out_field_int (uiout
, "number", b
->number
);
4735 if (part_of_multiple
)
4736 ui_out_field_skip (uiout
, "type");
4738 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
4742 if (part_of_multiple
)
4743 ui_out_field_skip (uiout
, "disp");
4745 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
4750 if (part_of_multiple
)
4751 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
4753 ui_out_field_fmt (uiout
, "enabled", "%c",
4754 bpenables
[(int) b
->enable_state
]);
4755 ui_out_spaces (uiout
, 2);
4759 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4761 /* Although the print_one can possibly print all locations,
4762 calling it here is not likely to get any nice result. So,
4763 make sure there's just one location. */
4764 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4765 b
->ops
->print_one (b
, last_loc
);
4771 internal_error (__FILE__
, __LINE__
,
4772 _("print_one_breakpoint: bp_none encountered\n"));
4776 case bp_hardware_watchpoint
:
4777 case bp_read_watchpoint
:
4778 case bp_access_watchpoint
:
4780 struct watchpoint
*w
= (struct watchpoint
*) b
;
4782 /* Field 4, the address, is omitted (which makes the columns
4783 not line up too nicely with the headers, but the effect
4784 is relatively readable). */
4785 if (opts
.addressprint
)
4786 ui_out_field_skip (uiout
, "addr");
4788 ui_out_field_string (uiout
, "what", w
->exp_string
);
4793 case bp_hardware_breakpoint
:
4797 case bp_longjmp_resume
:
4799 case bp_exception_resume
:
4800 case bp_step_resume
:
4801 case bp_hp_step_resume
:
4802 case bp_watchpoint_scope
:
4804 case bp_std_terminate
:
4805 case bp_shlib_event
:
4806 case bp_thread_event
:
4807 case bp_overlay_event
:
4808 case bp_longjmp_master
:
4809 case bp_std_terminate_master
:
4810 case bp_exception_master
:
4812 case bp_fast_tracepoint
:
4813 case bp_static_tracepoint
:
4815 case bp_gnu_ifunc_resolver
:
4816 case bp_gnu_ifunc_resolver_return
:
4817 if (opts
.addressprint
)
4820 if (header_of_multiple
)
4821 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4822 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4823 ui_out_field_string (uiout
, "addr", "<PENDING>");
4825 ui_out_field_core_addr (uiout
, "addr",
4826 loc
->gdbarch
, loc
->address
);
4829 if (!header_of_multiple
)
4830 print_breakpoint_location (b
, loc
);
4837 /* For backward compatibility, don't display inferiors unless there
4840 && !header_of_multiple
4842 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4843 && (number_of_program_spaces () > 1
4844 || number_of_inferiors () > 1)
4845 /* LOC is for existing B, it cannot be in
4846 moribund_locations and thus having NULL OWNER. */
4847 && loc
->owner
->type
!= bp_catchpoint
)))
4849 struct inferior
*inf
;
4852 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4854 if (inf
->pspace
== loc
->pspace
)
4859 ui_out_text (uiout
, " inf ");
4862 ui_out_text (uiout
, ", ");
4863 ui_out_text (uiout
, plongest (inf
->num
));
4868 if (!part_of_multiple
)
4870 if (b
->thread
!= -1)
4872 /* FIXME: This seems to be redundant and lost here; see the
4873 "stop only in" line a little further down. */
4874 ui_out_text (uiout
, " thread ");
4875 ui_out_field_int (uiout
, "thread", b
->thread
);
4877 else if (b
->task
!= 0)
4879 ui_out_text (uiout
, " task ");
4880 ui_out_field_int (uiout
, "task", b
->task
);
4884 ui_out_text (uiout
, "\n");
4886 if (!part_of_multiple
)
4887 b
->ops
->print_one_detail (b
, uiout
);
4889 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4892 ui_out_text (uiout
, "\tstop only in stack frame at ");
4893 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
4895 ui_out_field_core_addr (uiout
, "frame",
4896 b
->gdbarch
, b
->frame_id
.stack_addr
);
4897 ui_out_text (uiout
, "\n");
4900 if (!part_of_multiple
&& b
->cond_string
)
4903 if (is_tracepoint (b
))
4904 ui_out_text (uiout
, "\ttrace only if ");
4906 ui_out_text (uiout
, "\tstop only if ");
4907 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4908 ui_out_text (uiout
, "\n");
4911 if (!part_of_multiple
&& b
->thread
!= -1)
4913 /* FIXME should make an annotation for this. */
4914 ui_out_text (uiout
, "\tstop only in thread ");
4915 ui_out_field_int (uiout
, "thread", b
->thread
);
4916 ui_out_text (uiout
, "\n");
4919 if (!part_of_multiple
&& b
->hit_count
)
4921 /* FIXME should make an annotation for this. */
4922 if (ep_is_catchpoint (b
))
4923 ui_out_text (uiout
, "\tcatchpoint");
4924 else if (is_tracepoint (b
))
4925 ui_out_text (uiout
, "\ttracepoint");
4927 ui_out_text (uiout
, "\tbreakpoint");
4928 ui_out_text (uiout
, " already hit ");
4929 ui_out_field_int (uiout
, "times", b
->hit_count
);
4930 if (b
->hit_count
== 1)
4931 ui_out_text (uiout
, " time\n");
4933 ui_out_text (uiout
, " times\n");
4936 /* Output the count also if it is zero, but only if this is mi.
4937 FIXME: Should have a better test for this. */
4938 if (ui_out_is_mi_like_p (uiout
))
4939 if (!part_of_multiple
&& b
->hit_count
== 0)
4940 ui_out_field_int (uiout
, "times", b
->hit_count
);
4942 if (!part_of_multiple
&& b
->ignore_count
)
4945 ui_out_text (uiout
, "\tignore next ");
4946 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
4947 ui_out_text (uiout
, " hits\n");
4950 if (!part_of_multiple
&& is_tracepoint (b
))
4952 struct tracepoint
*tp
= (struct tracepoint
*) b
;
4954 if (tp
->traceframe_usage
)
4956 ui_out_text (uiout
, "\ttrace buffer usage ");
4957 ui_out_field_int (uiout
, "traceframe-usage", tp
->traceframe_usage
);
4958 ui_out_text (uiout
, " bytes\n");
4962 l
= b
->commands
? b
->commands
->commands
: NULL
;
4963 if (!part_of_multiple
&& l
)
4965 struct cleanup
*script_chain
;
4968 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
4969 print_command_lines (uiout
, l
, 4);
4970 do_cleanups (script_chain
);
4973 if (is_tracepoint (b
))
4975 struct tracepoint
*t
= (struct tracepoint
*) b
;
4977 if (!part_of_multiple
&& t
->pass_count
)
4979 annotate_field (10);
4980 ui_out_text (uiout
, "\tpass count ");
4981 ui_out_field_int (uiout
, "pass", t
->pass_count
);
4982 ui_out_text (uiout
, " \n");
4986 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
4988 if (is_watchpoint (b
))
4990 struct watchpoint
*w
= (struct watchpoint
*) b
;
4992 ui_out_field_string (uiout
, "original-location", w
->exp_string
);
4994 else if (b
->addr_string
)
4995 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
5000 print_one_breakpoint (struct breakpoint
*b
,
5001 struct bp_location
**last_loc
,
5004 struct cleanup
*bkpt_chain
;
5005 struct ui_out
*uiout
= current_uiout
;
5007 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
5009 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
5010 do_cleanups (bkpt_chain
);
5012 /* If this breakpoint has custom print function,
5013 it's already printed. Otherwise, print individual
5014 locations, if any. */
5015 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
5017 /* If breakpoint has a single location that is disabled, we
5018 print it as if it had several locations, since otherwise it's
5019 hard to represent "breakpoint enabled, location disabled"
5022 Note that while hardware watchpoints have several locations
5023 internally, that's not a property exposed to user. */
5025 && !is_hardware_watchpoint (b
)
5026 && (b
->loc
->next
|| !b
->loc
->enabled
))
5028 struct bp_location
*loc
;
5031 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
5033 struct cleanup
*inner2
=
5034 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
5035 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
5036 do_cleanups (inner2
);
5043 breakpoint_address_bits (struct breakpoint
*b
)
5045 int print_address_bits
= 0;
5046 struct bp_location
*loc
;
5048 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
5052 /* Software watchpoints that aren't watching memory don't have
5053 an address to print. */
5054 if (b
->type
== bp_watchpoint
&& loc
->watchpoint_type
== -1)
5057 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
5058 if (addr_bit
> print_address_bits
)
5059 print_address_bits
= addr_bit
;
5062 return print_address_bits
;
5065 struct captured_breakpoint_query_args
5071 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
5073 struct captured_breakpoint_query_args
*args
= data
;
5074 struct breakpoint
*b
;
5075 struct bp_location
*dummy_loc
= NULL
;
5079 if (args
->bnum
== b
->number
)
5081 print_one_breakpoint (b
, &dummy_loc
, 0);
5089 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
5090 char **error_message
)
5092 struct captured_breakpoint_query_args args
;
5095 /* For the moment we don't trust print_one_breakpoint() to not throw
5097 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
5098 error_message
, RETURN_MASK_ALL
) < 0)
5104 /* Return true if this breakpoint was set by the user, false if it is
5105 internal or momentary. */
5108 user_breakpoint_p (struct breakpoint
*b
)
5110 return b
->number
> 0;
5113 /* Print information on user settable breakpoint (watchpoint, etc)
5114 number BNUM. If BNUM is -1 print all user-settable breakpoints.
5115 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
5116 FILTER is non-NULL, call it on each breakpoint and only include the
5117 ones for which it returns non-zero. Return the total number of
5118 breakpoints listed. */
5121 breakpoint_1 (char *args
, int allflag
,
5122 int (*filter
) (const struct breakpoint
*))
5124 struct breakpoint
*b
;
5125 struct bp_location
*last_loc
= NULL
;
5126 int nr_printable_breakpoints
;
5127 struct cleanup
*bkpttbl_chain
;
5128 struct value_print_options opts
;
5129 int print_address_bits
= 0;
5130 int print_type_col_width
= 14;
5131 struct ui_out
*uiout
= current_uiout
;
5133 get_user_print_options (&opts
);
5135 /* Compute the number of rows in the table, as well as the size
5136 required for address fields. */
5137 nr_printable_breakpoints
= 0;
5140 /* If we have a filter, only list the breakpoints it accepts. */
5141 if (filter
&& !filter (b
))
5144 /* If we have an "args" string, it is a list of breakpoints to
5145 accept. Skip the others. */
5146 if (args
!= NULL
&& *args
!= '\0')
5148 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
5150 if (!allflag
&& !number_is_in_list (args
, b
->number
))
5154 if (allflag
|| user_breakpoint_p (b
))
5156 int addr_bit
, type_len
;
5158 addr_bit
= breakpoint_address_bits (b
);
5159 if (addr_bit
> print_address_bits
)
5160 print_address_bits
= addr_bit
;
5162 type_len
= strlen (bptype_string (b
->type
));
5163 if (type_len
> print_type_col_width
)
5164 print_type_col_width
= type_len
;
5166 nr_printable_breakpoints
++;
5170 if (opts
.addressprint
)
5172 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
5173 nr_printable_breakpoints
,
5177 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
5178 nr_printable_breakpoints
,
5181 if (nr_printable_breakpoints
> 0)
5182 annotate_breakpoints_headers ();
5183 if (nr_printable_breakpoints
> 0)
5185 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
5186 if (nr_printable_breakpoints
> 0)
5188 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
5189 "type", "Type"); /* 2 */
5190 if (nr_printable_breakpoints
> 0)
5192 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
5193 if (nr_printable_breakpoints
> 0)
5195 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
5196 if (opts
.addressprint
)
5198 if (nr_printable_breakpoints
> 0)
5200 if (print_address_bits
<= 32)
5201 ui_out_table_header (uiout
, 10, ui_left
,
5202 "addr", "Address"); /* 5 */
5204 ui_out_table_header (uiout
, 18, ui_left
,
5205 "addr", "Address"); /* 5 */
5207 if (nr_printable_breakpoints
> 0)
5209 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
5210 ui_out_table_body (uiout
);
5211 if (nr_printable_breakpoints
> 0)
5212 annotate_breakpoints_table ();
5217 /* If we have a filter, only list the breakpoints it accepts. */
5218 if (filter
&& !filter (b
))
5221 /* If we have an "args" string, it is a list of breakpoints to
5222 accept. Skip the others. */
5224 if (args
!= NULL
&& *args
!= '\0')
5226 if (allflag
) /* maintenance info breakpoint */
5228 if (parse_and_eval_long (args
) != b
->number
)
5231 else /* all others */
5233 if (!number_is_in_list (args
, b
->number
))
5237 /* We only print out user settable breakpoints unless the
5239 if (allflag
|| user_breakpoint_p (b
))
5240 print_one_breakpoint (b
, &last_loc
, allflag
);
5243 do_cleanups (bkpttbl_chain
);
5245 if (nr_printable_breakpoints
== 0)
5247 /* If there's a filter, let the caller decide how to report
5251 if (args
== NULL
|| *args
== '\0')
5252 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
5254 ui_out_message (uiout
, 0,
5255 "No breakpoint or watchpoint matching '%s'.\n",
5261 if (last_loc
&& !server_command
)
5262 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
5265 /* FIXME? Should this be moved up so that it is only called when
5266 there have been breakpoints? */
5267 annotate_breakpoints_table_end ();
5269 return nr_printable_breakpoints
;
5272 /* Display the value of default-collect in a way that is generally
5273 compatible with the breakpoint list. */
5276 default_collect_info (void)
5278 struct ui_out
*uiout
= current_uiout
;
5280 /* If it has no value (which is frequently the case), say nothing; a
5281 message like "No default-collect." gets in user's face when it's
5283 if (!*default_collect
)
5286 /* The following phrase lines up nicely with per-tracepoint collect
5288 ui_out_text (uiout
, "default collect ");
5289 ui_out_field_string (uiout
, "default-collect", default_collect
);
5290 ui_out_text (uiout
, " \n");
5294 breakpoints_info (char *args
, int from_tty
)
5296 breakpoint_1 (args
, 0, NULL
);
5298 default_collect_info ();
5302 watchpoints_info (char *args
, int from_tty
)
5304 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
5305 struct ui_out
*uiout
= current_uiout
;
5307 if (num_printed
== 0)
5309 if (args
== NULL
|| *args
== '\0')
5310 ui_out_message (uiout
, 0, "No watchpoints.\n");
5312 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
5317 maintenance_info_breakpoints (char *args
, int from_tty
)
5319 breakpoint_1 (args
, 1, NULL
);
5321 default_collect_info ();
5325 breakpoint_has_pc (struct breakpoint
*b
,
5326 struct program_space
*pspace
,
5327 CORE_ADDR pc
, struct obj_section
*section
)
5329 struct bp_location
*bl
= b
->loc
;
5331 for (; bl
; bl
= bl
->next
)
5333 if (bl
->pspace
== pspace
5334 && bl
->address
== pc
5335 && (!overlay_debugging
|| bl
->section
== section
))
5341 /* Print a message describing any user-breakpoints set at PC. This
5342 concerns with logical breakpoints, so we match program spaces, not
5346 describe_other_breakpoints (struct gdbarch
*gdbarch
,
5347 struct program_space
*pspace
, CORE_ADDR pc
,
5348 struct obj_section
*section
, int thread
)
5351 struct breakpoint
*b
;
5354 others
+= (user_breakpoint_p (b
)
5355 && breakpoint_has_pc (b
, pspace
, pc
, section
));
5359 printf_filtered (_("Note: breakpoint "));
5360 else /* if (others == ???) */
5361 printf_filtered (_("Note: breakpoints "));
5363 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
5366 printf_filtered ("%d", b
->number
);
5367 if (b
->thread
== -1 && thread
!= -1)
5368 printf_filtered (" (all threads)");
5369 else if (b
->thread
!= -1)
5370 printf_filtered (" (thread %d)", b
->thread
);
5371 printf_filtered ("%s%s ",
5372 ((b
->enable_state
== bp_disabled
5373 || b
->enable_state
== bp_call_disabled
)
5375 : b
->enable_state
== bp_permanent
5379 : ((others
== 1) ? " and" : ""));
5381 printf_filtered (_("also set at pc "));
5382 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
5383 printf_filtered (".\n");
5388 /* Return true iff it is meaningful to use the address member of
5389 BPT. For some breakpoint types, the address member is irrelevant
5390 and it makes no sense to attempt to compare it to other addresses
5391 (or use it for any other purpose either).
5393 More specifically, each of the following breakpoint types will
5394 always have a zero valued address and we don't want to mark
5395 breakpoints of any of these types to be a duplicate of an actual
5396 breakpoint at address zero:
5404 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
5406 enum bptype type
= bpt
->type
;
5408 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
5411 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5412 true if LOC1 and LOC2 represent the same watchpoint location. */
5415 watchpoint_locations_match (struct bp_location
*loc1
,
5416 struct bp_location
*loc2
)
5418 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
5419 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
5421 /* Both of them must exist. */
5422 gdb_assert (w1
!= NULL
);
5423 gdb_assert (w2
!= NULL
);
5425 /* If the target can evaluate the condition expression in hardware,
5426 then we we need to insert both watchpoints even if they are at
5427 the same place. Otherwise the watchpoint will only trigger when
5428 the condition of whichever watchpoint was inserted evaluates to
5429 true, not giving a chance for GDB to check the condition of the
5430 other watchpoint. */
5432 && target_can_accel_watchpoint_condition (loc1
->address
,
5434 loc1
->watchpoint_type
,
5437 && target_can_accel_watchpoint_condition (loc2
->address
,
5439 loc2
->watchpoint_type
,
5443 /* Note that this checks the owner's type, not the location's. In
5444 case the target does not support read watchpoints, but does
5445 support access watchpoints, we'll have bp_read_watchpoint
5446 watchpoints with hw_access locations. Those should be considered
5447 duplicates of hw_read locations. The hw_read locations will
5448 become hw_access locations later. */
5449 return (loc1
->owner
->type
== loc2
->owner
->type
5450 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
5451 && loc1
->address
== loc2
->address
5452 && loc1
->length
== loc2
->length
);
5455 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5456 same breakpoint location. In most targets, this can only be true
5457 if ASPACE1 matches ASPACE2. On targets that have global
5458 breakpoints, the address space doesn't really matter. */
5461 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
5462 struct address_space
*aspace2
, CORE_ADDR addr2
)
5464 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5465 || aspace1
== aspace2
)
5469 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
5470 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
5471 matches ASPACE2. On targets that have global breakpoints, the address
5472 space doesn't really matter. */
5475 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
5476 int len1
, struct address_space
*aspace2
,
5479 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5480 || aspace1
== aspace2
)
5481 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
5484 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
5485 a ranged breakpoint. In most targets, a match happens only if ASPACE
5486 matches the breakpoint's address space. On targets that have global
5487 breakpoints, the address space doesn't really matter. */
5490 breakpoint_location_address_match (struct bp_location
*bl
,
5491 struct address_space
*aspace
,
5494 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
5497 && breakpoint_address_match_range (bl
->pspace
->aspace
,
5498 bl
->address
, bl
->length
,
5502 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
5503 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
5504 true, otherwise returns false. */
5507 tracepoint_locations_match (struct bp_location
*loc1
,
5508 struct bp_location
*loc2
)
5510 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
5511 /* Since tracepoint locations are never duplicated with others', tracepoint
5512 locations at the same address of different tracepoints are regarded as
5513 different locations. */
5514 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
5519 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5520 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5521 represent the same location. */
5524 breakpoint_locations_match (struct bp_location
*loc1
,
5525 struct bp_location
*loc2
)
5527 int hw_point1
, hw_point2
;
5529 /* Both of them must not be in moribund_locations. */
5530 gdb_assert (loc1
->owner
!= NULL
);
5531 gdb_assert (loc2
->owner
!= NULL
);
5533 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
5534 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
5536 if (hw_point1
!= hw_point2
)
5539 return watchpoint_locations_match (loc1
, loc2
);
5540 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
5541 return tracepoint_locations_match (loc1
, loc2
);
5543 /* We compare bp_location.length in order to cover ranged breakpoints. */
5544 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
5545 loc2
->pspace
->aspace
, loc2
->address
)
5546 && loc1
->length
== loc2
->length
);
5550 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
5551 int bnum
, int have_bnum
)
5553 /* The longest string possibly returned by hex_string_custom
5554 is 50 chars. These must be at least that big for safety. */
5558 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
5559 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
5561 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5562 bnum
, astr1
, astr2
);
5564 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
5567 /* Adjust a breakpoint's address to account for architectural
5568 constraints on breakpoint placement. Return the adjusted address.
5569 Note: Very few targets require this kind of adjustment. For most
5570 targets, this function is simply the identity function. */
5573 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
5574 CORE_ADDR bpaddr
, enum bptype bptype
)
5576 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
5578 /* Very few targets need any kind of breakpoint adjustment. */
5581 else if (bptype
== bp_watchpoint
5582 || bptype
== bp_hardware_watchpoint
5583 || bptype
== bp_read_watchpoint
5584 || bptype
== bp_access_watchpoint
5585 || bptype
== bp_catchpoint
)
5587 /* Watchpoints and the various bp_catch_* eventpoints should not
5588 have their addresses modified. */
5593 CORE_ADDR adjusted_bpaddr
;
5595 /* Some targets have architectural constraints on the placement
5596 of breakpoint instructions. Obtain the adjusted address. */
5597 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
5599 /* An adjusted breakpoint address can significantly alter
5600 a user's expectations. Print a warning if an adjustment
5602 if (adjusted_bpaddr
!= bpaddr
)
5603 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
5605 return adjusted_bpaddr
;
5610 init_bp_location (struct bp_location
*loc
, const struct bp_location_ops
*ops
,
5611 struct breakpoint
*owner
)
5613 memset (loc
, 0, sizeof (*loc
));
5615 gdb_assert (ops
!= NULL
);
5620 loc
->shlib_disabled
= 0;
5623 switch (owner
->type
)
5629 case bp_longjmp_resume
:
5631 case bp_exception_resume
:
5632 case bp_step_resume
:
5633 case bp_hp_step_resume
:
5634 case bp_watchpoint_scope
:
5636 case bp_std_terminate
:
5637 case bp_shlib_event
:
5638 case bp_thread_event
:
5639 case bp_overlay_event
:
5641 case bp_longjmp_master
:
5642 case bp_std_terminate_master
:
5643 case bp_exception_master
:
5644 case bp_gnu_ifunc_resolver
:
5645 case bp_gnu_ifunc_resolver_return
:
5646 loc
->loc_type
= bp_loc_software_breakpoint
;
5648 case bp_hardware_breakpoint
:
5649 loc
->loc_type
= bp_loc_hardware_breakpoint
;
5651 case bp_hardware_watchpoint
:
5652 case bp_read_watchpoint
:
5653 case bp_access_watchpoint
:
5654 loc
->loc_type
= bp_loc_hardware_watchpoint
;
5659 case bp_fast_tracepoint
:
5660 case bp_static_tracepoint
:
5661 loc
->loc_type
= bp_loc_other
;
5664 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
5670 /* Allocate a struct bp_location. */
5672 static struct bp_location
*
5673 allocate_bp_location (struct breakpoint
*bpt
)
5675 return bpt
->ops
->allocate_location (bpt
);
5679 free_bp_location (struct bp_location
*loc
)
5681 loc
->ops
->dtor (loc
);
5685 /* Increment reference count. */
5688 incref_bp_location (struct bp_location
*bl
)
5693 /* Decrement reference count. If the reference count reaches 0,
5694 destroy the bp_location. Sets *BLP to NULL. */
5697 decref_bp_location (struct bp_location
**blp
)
5699 gdb_assert ((*blp
)->refc
> 0);
5701 if (--(*blp
)->refc
== 0)
5702 free_bp_location (*blp
);
5706 /* Add breakpoint B at the end of the global breakpoint chain. */
5709 add_to_breakpoint_chain (struct breakpoint
*b
)
5711 struct breakpoint
*b1
;
5713 /* Add this breakpoint to the end of the chain so that a list of
5714 breakpoints will come out in order of increasing numbers. */
5716 b1
= breakpoint_chain
;
5718 breakpoint_chain
= b
;
5727 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
5730 init_raw_breakpoint_without_location (struct breakpoint
*b
,
5731 struct gdbarch
*gdbarch
,
5733 const struct breakpoint_ops
*ops
)
5735 memset (b
, 0, sizeof (*b
));
5737 gdb_assert (ops
!= NULL
);
5741 b
->gdbarch
= gdbarch
;
5742 b
->language
= current_language
->la_language
;
5743 b
->input_radix
= input_radix
;
5745 b
->enable_state
= bp_enabled
;
5748 b
->ignore_count
= 0;
5750 b
->frame_id
= null_frame_id
;
5751 b
->condition_not_parsed
= 0;
5752 b
->py_bp_object
= NULL
;
5753 b
->related_breakpoint
= b
;
5756 /* Helper to set_raw_breakpoint below. Creates a breakpoint
5757 that has type BPTYPE and has no locations as yet. */
5759 static struct breakpoint
*
5760 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
5762 const struct breakpoint_ops
*ops
)
5764 struct breakpoint
*b
= XNEW (struct breakpoint
);
5766 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
5767 add_to_breakpoint_chain (b
);
5771 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
5772 resolutions should be made as the user specified the location explicitly
5776 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
5778 gdb_assert (loc
->owner
!= NULL
);
5780 if (loc
->owner
->type
== bp_breakpoint
5781 || loc
->owner
->type
== bp_hardware_breakpoint
5782 || is_tracepoint (loc
->owner
))
5786 find_pc_partial_function_gnu_ifunc (loc
->address
, &loc
->function_name
,
5787 NULL
, NULL
, &is_gnu_ifunc
);
5789 if (is_gnu_ifunc
&& !explicit_loc
)
5791 struct breakpoint
*b
= loc
->owner
;
5793 gdb_assert (loc
->pspace
== current_program_space
);
5794 if (gnu_ifunc_resolve_name (loc
->function_name
,
5795 &loc
->requested_address
))
5797 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
5798 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
5799 loc
->requested_address
,
5802 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
5803 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
5805 /* Create only the whole new breakpoint of this type but do not
5806 mess more complicated breakpoints with multiple locations. */
5807 b
->type
= bp_gnu_ifunc_resolver
;
5811 if (loc
->function_name
)
5812 loc
->function_name
= xstrdup (loc
->function_name
);
5816 /* Attempt to determine architecture of location identified by SAL. */
5818 get_sal_arch (struct symtab_and_line sal
)
5821 return get_objfile_arch (sal
.section
->objfile
);
5823 return get_objfile_arch (sal
.symtab
->objfile
);
5828 /* Low level routine for partially initializing a breakpoint of type
5829 BPTYPE. The newly created breakpoint's address, section, source
5830 file name, and line number are provided by SAL.
5832 It is expected that the caller will complete the initialization of
5833 the newly created breakpoint struct as well as output any status
5834 information regarding the creation of a new breakpoint. */
5837 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
5838 struct symtab_and_line sal
, enum bptype bptype
,
5839 const struct breakpoint_ops
*ops
)
5841 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
5843 add_location_to_breakpoint (b
, &sal
);
5845 if (bptype
!= bp_catchpoint
)
5846 gdb_assert (sal
.pspace
!= NULL
);
5848 /* Store the program space that was used to set the breakpoint,
5849 except for ordinary breakpoints, which are independent of the
5851 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
5852 b
->pspace
= sal
.pspace
;
5854 breakpoints_changed ();
5857 /* set_raw_breakpoint is a low level routine for allocating and
5858 partially initializing a breakpoint of type BPTYPE. The newly
5859 created breakpoint's address, section, source file name, and line
5860 number are provided by SAL. The newly created and partially
5861 initialized breakpoint is added to the breakpoint chain and
5862 is also returned as the value of this function.
5864 It is expected that the caller will complete the initialization of
5865 the newly created breakpoint struct as well as output any status
5866 information regarding the creation of a new breakpoint. In
5867 particular, set_raw_breakpoint does NOT set the breakpoint
5868 number! Care should be taken to not allow an error to occur
5869 prior to completing the initialization of the breakpoint. If this
5870 should happen, a bogus breakpoint will be left on the chain. */
5873 set_raw_breakpoint (struct gdbarch
*gdbarch
,
5874 struct symtab_and_line sal
, enum bptype bptype
,
5875 const struct breakpoint_ops
*ops
)
5877 struct breakpoint
*b
= XNEW (struct breakpoint
);
5879 init_raw_breakpoint (b
, gdbarch
, sal
, bptype
, ops
);
5880 add_to_breakpoint_chain (b
);
5885 /* Note that the breakpoint object B describes a permanent breakpoint
5886 instruction, hard-wired into the inferior's code. */
5888 make_breakpoint_permanent (struct breakpoint
*b
)
5890 struct bp_location
*bl
;
5892 b
->enable_state
= bp_permanent
;
5894 /* By definition, permanent breakpoints are already present in the
5895 code. Mark all locations as inserted. For now,
5896 make_breakpoint_permanent is called in just one place, so it's
5897 hard to say if it's reasonable to have permanent breakpoint with
5898 multiple locations or not, but it's easy to implement. */
5899 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5903 /* Call this routine when stepping and nexting to enable a breakpoint
5904 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
5905 initiated the operation. */
5908 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
5910 struct breakpoint
*b
, *b_tmp
;
5911 int thread
= tp
->num
;
5913 /* To avoid having to rescan all objfile symbols at every step,
5914 we maintain a list of continually-inserted but always disabled
5915 longjmp "master" breakpoints. Here, we simply create momentary
5916 clones of those and enable them for the requested thread. */
5917 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5918 if (b
->pspace
== current_program_space
5919 && (b
->type
== bp_longjmp_master
5920 || b
->type
== bp_exception_master
))
5922 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
5923 struct breakpoint
*clone
;
5925 clone
= momentary_breakpoint_from_master (b
, type
,
5926 &momentary_breakpoint_ops
);
5927 clone
->thread
= thread
;
5930 tp
->initiating_frame
= frame
;
5933 /* Delete all longjmp breakpoints from THREAD. */
5935 delete_longjmp_breakpoint (int thread
)
5937 struct breakpoint
*b
, *b_tmp
;
5939 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5940 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
5942 if (b
->thread
== thread
)
5943 delete_breakpoint (b
);
5948 enable_overlay_breakpoints (void)
5950 struct breakpoint
*b
;
5953 if (b
->type
== bp_overlay_event
)
5955 b
->enable_state
= bp_enabled
;
5956 update_global_location_list (1);
5957 overlay_events_enabled
= 1;
5962 disable_overlay_breakpoints (void)
5964 struct breakpoint
*b
;
5967 if (b
->type
== bp_overlay_event
)
5969 b
->enable_state
= bp_disabled
;
5970 update_global_location_list (0);
5971 overlay_events_enabled
= 0;
5975 /* Set an active std::terminate breakpoint for each std::terminate
5976 master breakpoint. */
5978 set_std_terminate_breakpoint (void)
5980 struct breakpoint
*b
, *b_tmp
;
5982 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5983 if (b
->pspace
== current_program_space
5984 && b
->type
== bp_std_terminate_master
)
5986 momentary_breakpoint_from_master (b
, bp_std_terminate
,
5987 &momentary_breakpoint_ops
);
5991 /* Delete all the std::terminate breakpoints. */
5993 delete_std_terminate_breakpoint (void)
5995 struct breakpoint
*b
, *b_tmp
;
5997 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5998 if (b
->type
== bp_std_terminate
)
5999 delete_breakpoint (b
);
6003 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6005 struct breakpoint
*b
;
6007 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
6008 &internal_breakpoint_ops
);
6010 b
->enable_state
= bp_enabled
;
6011 /* addr_string has to be used or breakpoint_re_set will delete me. */
6013 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
6015 update_global_location_list_nothrow (1);
6021 remove_thread_event_breakpoints (void)
6023 struct breakpoint
*b
, *b_tmp
;
6025 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6026 if (b
->type
== bp_thread_event
6027 && b
->loc
->pspace
== current_program_space
)
6028 delete_breakpoint (b
);
6031 struct lang_and_radix
6037 /* Create a breakpoint for JIT code registration and unregistration. */
6040 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6042 struct breakpoint
*b
;
6044 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
6045 &internal_breakpoint_ops
);
6046 update_global_location_list_nothrow (1);
6050 /* Remove JIT code registration and unregistration breakpoint(s). */
6053 remove_jit_event_breakpoints (void)
6055 struct breakpoint
*b
, *b_tmp
;
6057 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6058 if (b
->type
== bp_jit_event
6059 && b
->loc
->pspace
== current_program_space
)
6060 delete_breakpoint (b
);
6064 remove_solib_event_breakpoints (void)
6066 struct breakpoint
*b
, *b_tmp
;
6068 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6069 if (b
->type
== bp_shlib_event
6070 && b
->loc
->pspace
== current_program_space
)
6071 delete_breakpoint (b
);
6075 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6077 struct breakpoint
*b
;
6079 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
6080 &internal_breakpoint_ops
);
6081 update_global_location_list_nothrow (1);
6085 /* Disable any breakpoints that are on code in shared libraries. Only
6086 apply to enabled breakpoints, disabled ones can just stay disabled. */
6089 disable_breakpoints_in_shlibs (void)
6091 struct bp_location
*loc
, **locp_tmp
;
6093 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6095 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6096 struct breakpoint
*b
= loc
->owner
;
6098 /* We apply the check to all breakpoints, including disabled for
6099 those with loc->duplicate set. This is so that when breakpoint
6100 becomes enabled, or the duplicate is removed, gdb will try to
6101 insert all breakpoints. If we don't set shlib_disabled here,
6102 we'll try to insert those breakpoints and fail. */
6103 if (((b
->type
== bp_breakpoint
)
6104 || (b
->type
== bp_jit_event
)
6105 || (b
->type
== bp_hardware_breakpoint
)
6106 || (is_tracepoint (b
)))
6107 && loc
->pspace
== current_program_space
6108 && !loc
->shlib_disabled
6110 && PC_SOLIB (loc
->address
)
6112 && solib_name_from_address (loc
->pspace
, loc
->address
)
6116 loc
->shlib_disabled
= 1;
6121 /* Disable any breakpoints and tracepoints that are in an unloaded shared
6122 library. Only apply to enabled breakpoints, disabled ones can just stay
6126 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
6128 struct bp_location
*loc
, **locp_tmp
;
6129 int disabled_shlib_breaks
= 0;
6131 /* SunOS a.out shared libraries are always mapped, so do not
6132 disable breakpoints; they will only be reported as unloaded
6133 through clear_solib when GDB discards its shared library
6134 list. See clear_solib for more information. */
6135 if (exec_bfd
!= NULL
6136 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
6139 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6141 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6142 struct breakpoint
*b
= loc
->owner
;
6144 if (solib
->pspace
== loc
->pspace
6145 && !loc
->shlib_disabled
6146 && (((b
->type
== bp_breakpoint
6147 || b
->type
== bp_jit_event
6148 || b
->type
== bp_hardware_breakpoint
)
6149 && (loc
->loc_type
== bp_loc_hardware_breakpoint
6150 || loc
->loc_type
== bp_loc_software_breakpoint
))
6151 || is_tracepoint (b
))
6152 && solib_contains_address_p (solib
, loc
->address
))
6154 loc
->shlib_disabled
= 1;
6155 /* At this point, we cannot rely on remove_breakpoint
6156 succeeding so we must mark the breakpoint as not inserted
6157 to prevent future errors occurring in remove_breakpoints. */
6160 /* This may cause duplicate notifications for the same breakpoint. */
6161 observer_notify_breakpoint_modified (b
);
6163 if (!disabled_shlib_breaks
)
6165 target_terminal_ours_for_output ();
6166 warning (_("Temporarily disabling breakpoints "
6167 "for unloaded shared library \"%s\""),
6170 disabled_shlib_breaks
= 1;
6175 /* FORK & VFORK catchpoints. */
6177 /* An instance of this type is used to represent a fork or vfork
6178 catchpoint. It includes a "struct breakpoint" as a kind of base
6179 class; users downcast to "struct breakpoint *" when needed. A
6180 breakpoint is really of this type iff its ops pointer points to
6181 CATCH_FORK_BREAKPOINT_OPS. */
6183 struct fork_catchpoint
6185 /* The base class. */
6186 struct breakpoint base
;
6188 /* Process id of a child process whose forking triggered this
6189 catchpoint. This field is only valid immediately after this
6190 catchpoint has triggered. */
6191 ptid_t forked_inferior_pid
;
6194 /* Implement the "insert" breakpoint_ops method for fork
6198 insert_catch_fork (struct bp_location
*bl
)
6200 return target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
6203 /* Implement the "remove" breakpoint_ops method for fork
6207 remove_catch_fork (struct bp_location
*bl
)
6209 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
6212 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6216 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
6217 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6219 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
6221 return inferior_has_forked (inferior_ptid
, &c
->forked_inferior_pid
);
6224 /* Implement the "print_it" breakpoint_ops method for fork
6227 static enum print_stop_action
6228 print_it_catch_fork (bpstat bs
)
6230 struct ui_out
*uiout
= current_uiout
;
6231 struct breakpoint
*b
= bs
->breakpoint_at
;
6232 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
6234 annotate_catchpoint (b
->number
);
6235 if (b
->disposition
== disp_del
)
6236 ui_out_text (uiout
, "\nTemporary catchpoint ");
6238 ui_out_text (uiout
, "\nCatchpoint ");
6239 if (ui_out_is_mi_like_p (uiout
))
6241 ui_out_field_string (uiout
, "reason",
6242 async_reason_lookup (EXEC_ASYNC_FORK
));
6243 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6245 ui_out_field_int (uiout
, "bkptno", b
->number
);
6246 ui_out_text (uiout
, " (forked process ");
6247 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
6248 ui_out_text (uiout
, "), ");
6249 return PRINT_SRC_AND_LOC
;
6252 /* Implement the "print_one" breakpoint_ops method for fork
6256 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6258 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6259 struct value_print_options opts
;
6260 struct ui_out
*uiout
= current_uiout
;
6262 get_user_print_options (&opts
);
6264 /* Field 4, the address, is omitted (which makes the columns not
6265 line up too nicely with the headers, but the effect is relatively
6267 if (opts
.addressprint
)
6268 ui_out_field_skip (uiout
, "addr");
6270 ui_out_text (uiout
, "fork");
6271 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
6273 ui_out_text (uiout
, ", process ");
6274 ui_out_field_int (uiout
, "what",
6275 ptid_get_pid (c
->forked_inferior_pid
));
6276 ui_out_spaces (uiout
, 1);
6280 /* Implement the "print_mention" breakpoint_ops method for fork
6284 print_mention_catch_fork (struct breakpoint
*b
)
6286 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
6289 /* Implement the "print_recreate" breakpoint_ops method for fork
6293 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
6295 fprintf_unfiltered (fp
, "catch fork");
6296 print_recreate_thread (b
, fp
);
6299 /* The breakpoint_ops structure to be used in fork catchpoints. */
6301 static struct breakpoint_ops catch_fork_breakpoint_ops
;
6303 /* Implement the "insert" breakpoint_ops method for vfork
6307 insert_catch_vfork (struct bp_location
*bl
)
6309 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
6312 /* Implement the "remove" breakpoint_ops method for vfork
6316 remove_catch_vfork (struct bp_location
*bl
)
6318 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
6321 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6325 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
6326 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6328 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
6330 return inferior_has_vforked (inferior_ptid
, &c
->forked_inferior_pid
);
6333 /* Implement the "print_it" breakpoint_ops method for vfork
6336 static enum print_stop_action
6337 print_it_catch_vfork (bpstat bs
)
6339 struct ui_out
*uiout
= current_uiout
;
6340 struct breakpoint
*b
= bs
->breakpoint_at
;
6341 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6343 annotate_catchpoint (b
->number
);
6344 if (b
->disposition
== disp_del
)
6345 ui_out_text (uiout
, "\nTemporary catchpoint ");
6347 ui_out_text (uiout
, "\nCatchpoint ");
6348 if (ui_out_is_mi_like_p (uiout
))
6350 ui_out_field_string (uiout
, "reason",
6351 async_reason_lookup (EXEC_ASYNC_VFORK
));
6352 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6354 ui_out_field_int (uiout
, "bkptno", b
->number
);
6355 ui_out_text (uiout
, " (vforked process ");
6356 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
6357 ui_out_text (uiout
, "), ");
6358 return PRINT_SRC_AND_LOC
;
6361 /* Implement the "print_one" breakpoint_ops method for vfork
6365 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6367 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6368 struct value_print_options opts
;
6369 struct ui_out
*uiout
= current_uiout
;
6371 get_user_print_options (&opts
);
6372 /* Field 4, the address, is omitted (which makes the columns not
6373 line up too nicely with the headers, but the effect is relatively
6375 if (opts
.addressprint
)
6376 ui_out_field_skip (uiout
, "addr");
6378 ui_out_text (uiout
, "vfork");
6379 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
6381 ui_out_text (uiout
, ", process ");
6382 ui_out_field_int (uiout
, "what",
6383 ptid_get_pid (c
->forked_inferior_pid
));
6384 ui_out_spaces (uiout
, 1);
6388 /* Implement the "print_mention" breakpoint_ops method for vfork
6392 print_mention_catch_vfork (struct breakpoint
*b
)
6394 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
6397 /* Implement the "print_recreate" breakpoint_ops method for vfork
6401 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
6403 fprintf_unfiltered (fp
, "catch vfork");
6404 print_recreate_thread (b
, fp
);
6407 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6409 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
6411 /* An instance of this type is used to represent a syscall catchpoint.
6412 It includes a "struct breakpoint" as a kind of base class; users
6413 downcast to "struct breakpoint *" when needed. A breakpoint is
6414 really of this type iff its ops pointer points to
6415 CATCH_SYSCALL_BREAKPOINT_OPS. */
6417 struct syscall_catchpoint
6419 /* The base class. */
6420 struct breakpoint base
;
6422 /* Syscall numbers used for the 'catch syscall' feature. If no
6423 syscall has been specified for filtering, its value is NULL.
6424 Otherwise, it holds a list of all syscalls to be caught. The
6425 list elements are allocated with xmalloc. */
6426 VEC(int) *syscalls_to_be_caught
;
6429 /* Implement the "dtor" breakpoint_ops method for syscall
6433 dtor_catch_syscall (struct breakpoint
*b
)
6435 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6437 VEC_free (int, c
->syscalls_to_be_caught
);
6439 base_breakpoint_ops
.dtor (b
);
6442 /* Implement the "insert" breakpoint_ops method for syscall
6446 insert_catch_syscall (struct bp_location
*bl
)
6448 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bl
->owner
;
6449 struct inferior
*inf
= current_inferior ();
6451 ++inf
->total_syscalls_count
;
6452 if (!c
->syscalls_to_be_caught
)
6453 ++inf
->any_syscall_count
;
6459 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6464 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6466 int old_size
= VEC_length (int, inf
->syscalls_counts
);
6467 uintptr_t vec_addr_offset
6468 = old_size
* ((uintptr_t) sizeof (int));
6470 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
6471 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
6473 memset ((void *) vec_addr
, 0,
6474 (iter
+ 1 - old_size
) * sizeof (int));
6476 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6477 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
6481 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6482 inf
->total_syscalls_count
!= 0,
6483 inf
->any_syscall_count
,
6484 VEC_length (int, inf
->syscalls_counts
),
6485 VEC_address (int, inf
->syscalls_counts
));
6488 /* Implement the "remove" breakpoint_ops method for syscall
6492 remove_catch_syscall (struct bp_location
*bl
)
6494 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bl
->owner
;
6495 struct inferior
*inf
= current_inferior ();
6497 --inf
->total_syscalls_count
;
6498 if (!c
->syscalls_to_be_caught
)
6499 --inf
->any_syscall_count
;
6505 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6509 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6510 /* Shouldn't happen. */
6512 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6513 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
6517 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6518 inf
->total_syscalls_count
!= 0,
6519 inf
->any_syscall_count
,
6520 VEC_length (int, inf
->syscalls_counts
),
6522 inf
->syscalls_counts
));
6525 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6529 breakpoint_hit_catch_syscall (const struct bp_location
*bl
,
6530 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6532 /* We must check if we are catching specific syscalls in this
6533 breakpoint. If we are, then we must guarantee that the called
6534 syscall is the same syscall we are catching. */
6535 int syscall_number
= 0;
6536 const struct syscall_catchpoint
*c
6537 = (const struct syscall_catchpoint
*) bl
->owner
;
6539 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
6542 /* Now, checking if the syscall is the same. */
6543 if (c
->syscalls_to_be_caught
)
6548 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6550 if (syscall_number
== iter
)
6560 /* Implement the "print_it" breakpoint_ops method for syscall
6563 static enum print_stop_action
6564 print_it_catch_syscall (bpstat bs
)
6566 struct ui_out
*uiout
= current_uiout
;
6567 struct breakpoint
*b
= bs
->breakpoint_at
;
6568 /* These are needed because we want to know in which state a
6569 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6570 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6571 must print "called syscall" or "returned from syscall". */
6573 struct target_waitstatus last
;
6577 get_last_target_status (&ptid
, &last
);
6579 get_syscall_by_number (last
.value
.syscall_number
, &s
);
6581 annotate_catchpoint (b
->number
);
6583 if (b
->disposition
== disp_del
)
6584 ui_out_text (uiout
, "\nTemporary catchpoint ");
6586 ui_out_text (uiout
, "\nCatchpoint ");
6587 if (ui_out_is_mi_like_p (uiout
))
6589 ui_out_field_string (uiout
, "reason",
6590 async_reason_lookup (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
6591 ? EXEC_ASYNC_SYSCALL_ENTRY
6592 : EXEC_ASYNC_SYSCALL_RETURN
));
6593 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6595 ui_out_field_int (uiout
, "bkptno", b
->number
);
6597 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
6598 ui_out_text (uiout
, " (call to syscall ");
6600 ui_out_text (uiout
, " (returned from syscall ");
6602 if (s
.name
== NULL
|| ui_out_is_mi_like_p (uiout
))
6603 ui_out_field_int (uiout
, "syscall-number", last
.value
.syscall_number
);
6605 ui_out_field_string (uiout
, "syscall-name", s
.name
);
6607 ui_out_text (uiout
, "), ");
6609 return PRINT_SRC_AND_LOC
;
6612 /* Implement the "print_one" breakpoint_ops method for syscall
6616 print_one_catch_syscall (struct breakpoint
*b
,
6617 struct bp_location
**last_loc
)
6619 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6620 struct value_print_options opts
;
6621 struct ui_out
*uiout
= current_uiout
;
6623 get_user_print_options (&opts
);
6624 /* Field 4, the address, is omitted (which makes the columns not
6625 line up too nicely with the headers, but the effect is relatively
6627 if (opts
.addressprint
)
6628 ui_out_field_skip (uiout
, "addr");
6631 if (c
->syscalls_to_be_caught
6632 && VEC_length (int, c
->syscalls_to_be_caught
) > 1)
6633 ui_out_text (uiout
, "syscalls \"");
6635 ui_out_text (uiout
, "syscall \"");
6637 if (c
->syscalls_to_be_caught
)
6640 char *text
= xstrprintf ("%s", "");
6643 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6648 get_syscall_by_number (iter
, &s
);
6651 text
= xstrprintf ("%s%s, ", text
, s
.name
);
6653 text
= xstrprintf ("%s%d, ", text
, iter
);
6655 /* We have to xfree the last 'text' (now stored at 'x')
6656 because xstrprintf dynamically allocates new space for it
6660 /* Remove the last comma. */
6661 text
[strlen (text
) - 2] = '\0';
6662 ui_out_field_string (uiout
, "what", text
);
6665 ui_out_field_string (uiout
, "what", "<any syscall>");
6666 ui_out_text (uiout
, "\" ");
6669 /* Implement the "print_mention" breakpoint_ops method for syscall
6673 print_mention_catch_syscall (struct breakpoint
*b
)
6675 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6677 if (c
->syscalls_to_be_caught
)
6681 if (VEC_length (int, c
->syscalls_to_be_caught
) > 1)
6682 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
6684 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
6687 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6691 get_syscall_by_number (iter
, &s
);
6694 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
6696 printf_filtered (" %d", s
.number
);
6698 printf_filtered (")");
6701 printf_filtered (_("Catchpoint %d (any syscall)"),
6705 /* Implement the "print_recreate" breakpoint_ops method for syscall
6709 print_recreate_catch_syscall (struct breakpoint
*b
, struct ui_file
*fp
)
6711 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6713 fprintf_unfiltered (fp
, "catch syscall");
6715 if (c
->syscalls_to_be_caught
)
6720 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6725 get_syscall_by_number (iter
, &s
);
6727 fprintf_unfiltered (fp
, " %s", s
.name
);
6729 fprintf_unfiltered (fp
, " %d", s
.number
);
6732 print_recreate_thread (b
, fp
);
6735 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6737 static struct breakpoint_ops catch_syscall_breakpoint_ops
;
6739 /* Returns non-zero if 'b' is a syscall catchpoint. */
6742 syscall_catchpoint_p (struct breakpoint
*b
)
6744 return (b
->ops
== &catch_syscall_breakpoint_ops
);
6747 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
6748 is non-zero, then make the breakpoint temporary. If COND_STRING is
6749 not NULL, then store it in the breakpoint. OPS, if not NULL, is
6750 the breakpoint_ops structure associated to the catchpoint. */
6753 init_catchpoint (struct breakpoint
*b
,
6754 struct gdbarch
*gdbarch
, int tempflag
,
6756 const struct breakpoint_ops
*ops
)
6758 struct symtab_and_line sal
;
6761 sal
.pspace
= current_program_space
;
6763 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
6765 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
6766 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6770 install_breakpoint (int internal
, struct breakpoint
*b
, int update_gll
)
6772 add_to_breakpoint_chain (b
);
6773 set_breakpoint_number (internal
, b
);
6776 observer_notify_breakpoint_created (b
);
6779 update_global_location_list (1);
6783 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
6784 int tempflag
, char *cond_string
,
6785 const struct breakpoint_ops
*ops
)
6787 struct fork_catchpoint
*c
= XNEW (struct fork_catchpoint
);
6789 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
, ops
);
6791 c
->forked_inferior_pid
= null_ptid
;
6793 install_breakpoint (0, &c
->base
, 1);
6796 /* Exec catchpoints. */
6798 /* An instance of this type is used to represent an exec catchpoint.
6799 It includes a "struct breakpoint" as a kind of base class; users
6800 downcast to "struct breakpoint *" when needed. A breakpoint is
6801 really of this type iff its ops pointer points to
6802 CATCH_EXEC_BREAKPOINT_OPS. */
6804 struct exec_catchpoint
6806 /* The base class. */
6807 struct breakpoint base
;
6809 /* Filename of a program whose exec triggered this catchpoint.
6810 This field is only valid immediately after this catchpoint has
6812 char *exec_pathname
;
6815 /* Implement the "dtor" breakpoint_ops method for exec
6819 dtor_catch_exec (struct breakpoint
*b
)
6821 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
6823 xfree (c
->exec_pathname
);
6825 base_breakpoint_ops
.dtor (b
);
6829 insert_catch_exec (struct bp_location
*bl
)
6831 return target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
6835 remove_catch_exec (struct bp_location
*bl
)
6837 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
6841 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
6842 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6844 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
6846 return inferior_has_execd (inferior_ptid
, &c
->exec_pathname
);
6849 static enum print_stop_action
6850 print_it_catch_exec (bpstat bs
)
6852 struct ui_out
*uiout
= current_uiout
;
6853 struct breakpoint
*b
= bs
->breakpoint_at
;
6854 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
6856 annotate_catchpoint (b
->number
);
6857 if (b
->disposition
== disp_del
)
6858 ui_out_text (uiout
, "\nTemporary catchpoint ");
6860 ui_out_text (uiout
, "\nCatchpoint ");
6861 if (ui_out_is_mi_like_p (uiout
))
6863 ui_out_field_string (uiout
, "reason",
6864 async_reason_lookup (EXEC_ASYNC_EXEC
));
6865 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6867 ui_out_field_int (uiout
, "bkptno", b
->number
);
6868 ui_out_text (uiout
, " (exec'd ");
6869 ui_out_field_string (uiout
, "new-exec", c
->exec_pathname
);
6870 ui_out_text (uiout
, "), ");
6872 return PRINT_SRC_AND_LOC
;
6876 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
6878 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
6879 struct value_print_options opts
;
6880 struct ui_out
*uiout
= current_uiout
;
6882 get_user_print_options (&opts
);
6884 /* Field 4, the address, is omitted (which makes the columns
6885 not line up too nicely with the headers, but the effect
6886 is relatively readable). */
6887 if (opts
.addressprint
)
6888 ui_out_field_skip (uiout
, "addr");
6890 ui_out_text (uiout
, "exec");
6891 if (c
->exec_pathname
!= NULL
)
6893 ui_out_text (uiout
, ", program \"");
6894 ui_out_field_string (uiout
, "what", c
->exec_pathname
);
6895 ui_out_text (uiout
, "\" ");
6900 print_mention_catch_exec (struct breakpoint
*b
)
6902 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
6905 /* Implement the "print_recreate" breakpoint_ops method for exec
6909 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
6911 fprintf_unfiltered (fp
, "catch exec");
6912 print_recreate_thread (b
, fp
);
6915 static struct breakpoint_ops catch_exec_breakpoint_ops
;
6918 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
6919 const struct breakpoint_ops
*ops
)
6921 struct syscall_catchpoint
*c
;
6922 struct gdbarch
*gdbarch
= get_current_arch ();
6924 c
= XNEW (struct syscall_catchpoint
);
6925 init_catchpoint (&c
->base
, gdbarch
, tempflag
, NULL
, ops
);
6926 c
->syscalls_to_be_caught
= filter
;
6928 install_breakpoint (0, &c
->base
, 1);
6932 hw_breakpoint_used_count (void)
6935 struct breakpoint
*b
;
6936 struct bp_location
*bl
;
6940 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
6941 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6943 /* Special types of hardware breakpoints may use more than
6945 i
+= b
->ops
->resources_needed (bl
);
6952 /* Returns the resources B would use if it were a hardware
6956 hw_watchpoint_use_count (struct breakpoint
*b
)
6959 struct bp_location
*bl
;
6961 if (!breakpoint_enabled (b
))
6964 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6966 /* Special types of hardware watchpoints may use more than
6968 i
+= b
->ops
->resources_needed (bl
);
6974 /* Returns the sum the used resources of all hardware watchpoints of
6975 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
6976 the sum of the used resources of all hardware watchpoints of other
6977 types _not_ TYPE. */
6980 hw_watchpoint_used_count_others (struct breakpoint
*except
,
6981 enum bptype type
, int *other_type_used
)
6984 struct breakpoint
*b
;
6986 *other_type_used
= 0;
6991 if (!breakpoint_enabled (b
))
6994 if (b
->type
== type
)
6995 i
+= hw_watchpoint_use_count (b
);
6996 else if (is_hardware_watchpoint (b
))
6997 *other_type_used
= 1;
7004 disable_watchpoints_before_interactive_call_start (void)
7006 struct breakpoint
*b
;
7010 if (is_watchpoint (b
) && breakpoint_enabled (b
))
7012 b
->enable_state
= bp_call_disabled
;
7013 update_global_location_list (0);
7019 enable_watchpoints_after_interactive_call_stop (void)
7021 struct breakpoint
*b
;
7025 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
7027 b
->enable_state
= bp_enabled
;
7028 update_global_location_list (1);
7034 disable_breakpoints_before_startup (void)
7036 current_program_space
->executing_startup
= 1;
7037 update_global_location_list (0);
7041 enable_breakpoints_after_startup (void)
7043 current_program_space
->executing_startup
= 0;
7044 breakpoint_re_set ();
7048 /* Set a breakpoint that will evaporate an end of command
7049 at address specified by SAL.
7050 Restrict it to frame FRAME if FRAME is nonzero. */
7053 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
7054 struct frame_id frame_id
, enum bptype type
)
7056 struct breakpoint
*b
;
7058 /* If FRAME_ID is valid, it should be a real frame, not an inlined
7060 gdb_assert (!frame_id_inlined_p (frame_id
));
7062 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
7063 b
->enable_state
= bp_enabled
;
7064 b
->disposition
= disp_donttouch
;
7065 b
->frame_id
= frame_id
;
7067 /* If we're debugging a multi-threaded program, then we want
7068 momentary breakpoints to be active in only a single thread of
7070 if (in_thread_list (inferior_ptid
))
7071 b
->thread
= pid_to_thread_id (inferior_ptid
);
7073 update_global_location_list_nothrow (1);
7078 /* Make a momentary breakpoint based on the master breakpoint ORIG.
7079 The new breakpoint will have type TYPE, and use OPS as it
7082 static struct breakpoint
*
7083 momentary_breakpoint_from_master (struct breakpoint
*orig
,
7085 const struct breakpoint_ops
*ops
)
7087 struct breakpoint
*copy
;
7089 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
7090 copy
->loc
= allocate_bp_location (copy
);
7091 set_breakpoint_location_function (copy
->loc
, 1);
7093 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
7094 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
7095 copy
->loc
->address
= orig
->loc
->address
;
7096 copy
->loc
->section
= orig
->loc
->section
;
7097 copy
->loc
->pspace
= orig
->loc
->pspace
;
7099 if (orig
->loc
->source_file
!= NULL
)
7100 copy
->loc
->source_file
= xstrdup (orig
->loc
->source_file
);
7102 copy
->loc
->line_number
= orig
->loc
->line_number
;
7103 copy
->frame_id
= orig
->frame_id
;
7104 copy
->thread
= orig
->thread
;
7105 copy
->pspace
= orig
->pspace
;
7107 copy
->enable_state
= bp_enabled
;
7108 copy
->disposition
= disp_donttouch
;
7109 copy
->number
= internal_breakpoint_number
--;
7111 update_global_location_list_nothrow (0);
7115 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
7119 clone_momentary_breakpoint (struct breakpoint
*orig
)
7121 /* If there's nothing to clone, then return nothing. */
7125 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
);
7129 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
7132 struct symtab_and_line sal
;
7134 sal
= find_pc_line (pc
, 0);
7136 sal
.section
= find_pc_overlay (pc
);
7137 sal
.explicit_pc
= 1;
7139 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
7143 /* Tell the user we have just set a breakpoint B. */
7146 mention (struct breakpoint
*b
)
7148 b
->ops
->print_mention (b
);
7149 if (ui_out_is_mi_like_p (current_uiout
))
7151 printf_filtered ("\n");
7155 static struct bp_location
*
7156 add_location_to_breakpoint (struct breakpoint
*b
,
7157 const struct symtab_and_line
*sal
)
7159 struct bp_location
*loc
, **tmp
;
7160 CORE_ADDR adjusted_address
;
7161 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
7163 if (loc_gdbarch
== NULL
)
7164 loc_gdbarch
= b
->gdbarch
;
7166 /* Adjust the breakpoint's address prior to allocating a location.
7167 Once we call allocate_bp_location(), that mostly uninitialized
7168 location will be placed on the location chain. Adjustment of the
7169 breakpoint may cause target_read_memory() to be called and we do
7170 not want its scan of the location chain to find a breakpoint and
7171 location that's only been partially initialized. */
7172 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
7175 loc
= allocate_bp_location (b
);
7176 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
7180 loc
->requested_address
= sal
->pc
;
7181 loc
->address
= adjusted_address
;
7182 loc
->pspace
= sal
->pspace
;
7183 gdb_assert (loc
->pspace
!= NULL
);
7184 loc
->section
= sal
->section
;
7185 loc
->gdbarch
= loc_gdbarch
;
7187 if (sal
->symtab
!= NULL
)
7188 loc
->source_file
= xstrdup (sal
->symtab
->filename
);
7189 loc
->line_number
= sal
->line
;
7191 set_breakpoint_location_function (loc
,
7192 sal
->explicit_pc
|| sal
->explicit_line
);
7197 /* Return 1 if LOC is pointing to a permanent breakpoint,
7198 return 0 otherwise. */
7201 bp_loc_is_permanent (struct bp_location
*loc
)
7205 const gdb_byte
*bpoint
;
7206 gdb_byte
*target_mem
;
7207 struct cleanup
*cleanup
;
7210 gdb_assert (loc
!= NULL
);
7212 addr
= loc
->address
;
7213 bpoint
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
7215 /* Software breakpoints unsupported? */
7219 target_mem
= alloca (len
);
7221 /* Enable the automatic memory restoration from breakpoints while
7222 we read the memory. Otherwise we could say about our temporary
7223 breakpoints they are permanent. */
7224 cleanup
= save_current_space_and_thread ();
7226 switch_to_program_space_and_thread (loc
->pspace
);
7227 make_show_memory_breakpoints_cleanup (0);
7229 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
7230 && memcmp (target_mem
, bpoint
, len
) == 0)
7233 do_cleanups (cleanup
);
7240 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7241 as textual description of the location, and COND_STRING
7242 as condition expression. */
7245 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7246 struct symtabs_and_lines sals
, char *addr_string
,
7247 char *filter
, char *cond_string
,
7248 enum bptype type
, enum bpdisp disposition
,
7249 int thread
, int task
, int ignore_count
,
7250 const struct breakpoint_ops
*ops
, int from_tty
,
7251 int enabled
, int internal
, int display_canonical
)
7255 if (type
== bp_hardware_breakpoint
)
7257 int target_resources_ok
;
7259 i
= hw_breakpoint_used_count ();
7260 target_resources_ok
=
7261 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
7263 if (target_resources_ok
== 0)
7264 error (_("No hardware breakpoint support in the target."));
7265 else if (target_resources_ok
< 0)
7266 error (_("Hardware breakpoints used exceeds limit."));
7269 gdb_assert (sals
.nelts
> 0);
7271 for (i
= 0; i
< sals
.nelts
; ++i
)
7273 struct symtab_and_line sal
= sals
.sals
[i
];
7274 struct bp_location
*loc
;
7278 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
7280 loc_gdbarch
= gdbarch
;
7282 describe_other_breakpoints (loc_gdbarch
,
7283 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
7288 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
7292 b
->cond_string
= cond_string
;
7293 b
->ignore_count
= ignore_count
;
7294 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7295 b
->disposition
= disposition
;
7297 if (type
== bp_static_tracepoint
)
7299 struct tracepoint
*t
= (struct tracepoint
*) b
;
7300 struct static_tracepoint_marker marker
;
7302 if (is_marker_spec (addr_string
))
7304 /* We already know the marker exists, otherwise, we
7305 wouldn't see a sal for it. */
7306 char *p
= &addr_string
[3];
7310 p
= skip_spaces (p
);
7312 endp
= skip_to_space (p
);
7314 marker_str
= savestring (p
, endp
- p
);
7315 t
->static_trace_marker_id
= marker_str
;
7317 printf_filtered (_("Probed static tracepoint "
7319 t
->static_trace_marker_id
);
7321 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
7323 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
7324 release_static_tracepoint_marker (&marker
);
7326 printf_filtered (_("Probed static tracepoint "
7328 t
->static_trace_marker_id
);
7331 warning (_("Couldn't determine the static "
7332 "tracepoint marker to probe"));
7339 loc
= add_location_to_breakpoint (b
, &sal
);
7342 if (bp_loc_is_permanent (loc
))
7343 make_breakpoint_permanent (b
);
7347 char *arg
= b
->cond_string
;
7348 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
7350 error (_("Garbage %s follows condition"), arg
);
7354 b
->display_canonical
= display_canonical
;
7356 b
->addr_string
= addr_string
;
7358 /* addr_string has to be used or breakpoint_re_set will delete
7361 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
7366 create_breakpoint_sal (struct gdbarch
*gdbarch
,
7367 struct symtabs_and_lines sals
, char *addr_string
,
7368 char *filter
, char *cond_string
,
7369 enum bptype type
, enum bpdisp disposition
,
7370 int thread
, int task
, int ignore_count
,
7371 const struct breakpoint_ops
*ops
, int from_tty
,
7372 int enabled
, int internal
, int display_canonical
)
7374 struct breakpoint
*b
;
7375 struct cleanup
*old_chain
;
7377 if (is_tracepoint_type (type
))
7379 struct tracepoint
*t
;
7381 t
= XCNEW (struct tracepoint
);
7385 b
= XNEW (struct breakpoint
);
7387 old_chain
= make_cleanup (xfree
, b
);
7389 init_breakpoint_sal (b
, gdbarch
,
7391 filter
, cond_string
,
7393 thread
, task
, ignore_count
,
7395 enabled
, internal
, display_canonical
);
7396 discard_cleanups (old_chain
);
7398 install_breakpoint (internal
, b
, 0);
7401 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7402 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7403 value. COND_STRING, if not NULL, specified the condition to be
7404 used for all breakpoints. Essentially the only case where
7405 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7406 function. In that case, it's still not possible to specify
7407 separate conditions for different overloaded functions, so
7408 we take just a single condition string.
7410 NOTE: If the function succeeds, the caller is expected to cleanup
7411 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7412 array contents). If the function fails (error() is called), the
7413 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7414 COND and SALS arrays and each of those arrays contents. */
7417 create_breakpoints_sal (struct gdbarch
*gdbarch
,
7418 struct linespec_result
*canonical
,
7420 enum bptype type
, enum bpdisp disposition
,
7421 int thread
, int task
, int ignore_count
,
7422 const struct breakpoint_ops
*ops
, int from_tty
,
7423 int enabled
, int internal
)
7426 struct linespec_sals
*lsal
;
7428 if (canonical
->pre_expanded
)
7429 gdb_assert (VEC_length (linespec_sals
, canonical
->sals
) == 1);
7431 for (i
= 0; VEC_iterate (linespec_sals
, canonical
->sals
, i
, lsal
); ++i
)
7433 /* Note that 'addr_string' can be NULL in the case of a plain
7434 'break', without arguments. */
7435 char *addr_string
= (canonical
->addr_string
7436 ? xstrdup (canonical
->addr_string
)
7438 char *filter_string
= lsal
->canonical
? xstrdup (lsal
->canonical
) : NULL
;
7439 struct cleanup
*inner
= make_cleanup (xfree
, addr_string
);
7441 make_cleanup (xfree
, filter_string
);
7442 create_breakpoint_sal (gdbarch
, lsal
->sals
,
7445 cond_string
, type
, disposition
,
7446 thread
, task
, ignore_count
, ops
,
7447 from_tty
, enabled
, internal
,
7448 canonical
->special_display
);
7449 discard_cleanups (inner
);
7453 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7454 followed by conditionals. On return, SALS contains an array of SAL
7455 addresses found. ADDR_STRING contains a vector of (canonical)
7456 address strings. ADDRESS points to the end of the SAL.
7458 The array and the line spec strings are allocated on the heap, it is
7459 the caller's responsibility to free them. */
7462 parse_breakpoint_sals (char **address
,
7463 struct linespec_result
*canonical
)
7465 char *addr_start
= *address
;
7467 /* If no arg given, or if first arg is 'if ', use the default
7469 if ((*address
) == NULL
7470 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
7472 /* The last displayed codepoint, if it's valid, is our default breakpoint
7474 if (last_displayed_sal_is_valid ())
7476 struct linespec_sals lsal
;
7477 struct symtab_and_line sal
;
7479 init_sal (&sal
); /* Initialize to zeroes. */
7480 lsal
.sals
.sals
= (struct symtab_and_line
*)
7481 xmalloc (sizeof (struct symtab_and_line
));
7483 /* Set sal's pspace, pc, symtab, and line to the values
7484 corresponding to the last call to print_frame_info. */
7485 get_last_displayed_sal (&sal
);
7486 sal
.section
= find_pc_overlay (sal
.pc
);
7488 /* "break" without arguments is equivalent to "break *PC"
7489 where PC is the last displayed codepoint's address. So
7490 make sure to set sal.explicit_pc to prevent GDB from
7491 trying to expand the list of sals to include all other
7492 instances with the same symtab and line. */
7493 sal
.explicit_pc
= 1;
7495 lsal
.sals
.sals
[0] = sal
;
7496 lsal
.sals
.nelts
= 1;
7497 lsal
.canonical
= NULL
;
7499 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
7502 error (_("No default breakpoint address now."));
7506 /* Force almost all breakpoints to be in terms of the
7507 current_source_symtab (which is decode_line_1's default).
7508 This should produce the results we want almost all of the
7509 time while leaving default_breakpoint_* alone. */
7510 if (last_displayed_sal_is_valid ())
7511 decode_line_full (address
, DECODE_LINE_FUNFIRSTLINE
,
7512 get_last_displayed_symtab (),
7513 get_last_displayed_line (),
7514 canonical
, NULL
, NULL
);
7516 decode_line_full (address
, DECODE_LINE_FUNFIRSTLINE
,
7517 (struct symtab
*) NULL
, 0,
7518 canonical
, NULL
, NULL
);
7523 /* Convert each SAL into a real PC. Verify that the PC can be
7524 inserted as a breakpoint. If it can't throw an error. */
7527 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
7531 for (i
= 0; i
< sals
->nelts
; i
++)
7532 resolve_sal_pc (&sals
->sals
[i
]);
7535 /* Fast tracepoints may have restrictions on valid locations. For
7536 instance, a fast tracepoint using a jump instead of a trap will
7537 likely have to overwrite more bytes than a trap would, and so can
7538 only be placed where the instruction is longer than the jump, or a
7539 multi-instruction sequence does not have a jump into the middle of
7543 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
7544 struct symtabs_and_lines
*sals
)
7547 struct symtab_and_line
*sal
;
7549 struct cleanup
*old_chain
;
7551 for (i
= 0; i
< sals
->nelts
; i
++)
7553 struct gdbarch
*sarch
;
7555 sal
= &sals
->sals
[i
];
7557 sarch
= get_sal_arch (*sal
);
7558 /* We fall back to GDBARCH if there is no architecture
7559 associated with SAL. */
7562 rslt
= gdbarch_fast_tracepoint_valid_at (sarch
, sal
->pc
,
7564 old_chain
= make_cleanup (xfree
, msg
);
7567 error (_("May not have a fast tracepoint at 0x%s%s"),
7568 paddress (sarch
, sal
->pc
), (msg
? msg
: ""));
7570 do_cleanups (old_chain
);
7574 /* Given TOK, a string specification of condition and thread, as
7575 accepted by the 'break' command, extract the condition
7576 string and thread number and set *COND_STRING and *THREAD.
7577 PC identifies the context at which the condition should be parsed.
7578 If no condition is found, *COND_STRING is set to NULL.
7579 If no thread is found, *THREAD is set to -1. */
7581 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
7582 char **cond_string
, int *thread
, int *task
)
7584 *cond_string
= NULL
;
7590 char *cond_start
= NULL
;
7591 char *cond_end
= NULL
;
7593 tok
= skip_spaces (tok
);
7595 end_tok
= skip_to_space (tok
);
7597 toklen
= end_tok
- tok
;
7599 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7601 struct expression
*expr
;
7603 tok
= cond_start
= end_tok
+ 1;
7604 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
7607 *cond_string
= savestring (cond_start
,
7608 cond_end
- cond_start
);
7610 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7616 *thread
= strtol (tok
, &tok
, 0);
7618 error (_("Junk after thread keyword."));
7619 if (!valid_thread_id (*thread
))
7620 error (_("Unknown thread %d."), *thread
);
7622 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
7628 *task
= strtol (tok
, &tok
, 0);
7630 error (_("Junk after task keyword."));
7631 if (!valid_task_id (*task
))
7632 error (_("Unknown task %d."), *task
);
7635 error (_("Junk at end of arguments."));
7639 /* Decode a static tracepoint marker spec. */
7641 static struct symtabs_and_lines
7642 decode_static_tracepoint_spec (char **arg_p
)
7644 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
7645 struct symtabs_and_lines sals
;
7646 struct symtab_and_line sal
;
7648 struct cleanup
*old_chain
;
7649 char *p
= &(*arg_p
)[3];
7654 p
= skip_spaces (p
);
7656 endp
= skip_to_space (p
);
7658 marker_str
= savestring (p
, endp
- p
);
7659 old_chain
= make_cleanup (xfree
, marker_str
);
7661 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
7662 if (VEC_empty(static_tracepoint_marker_p
, markers
))
7663 error (_("No known static tracepoint marker named %s"), marker_str
);
7665 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
7666 sals
.sals
= xmalloc (sizeof *sals
.sals
* sals
.nelts
);
7668 for (i
= 0; i
< sals
.nelts
; i
++)
7670 struct static_tracepoint_marker
*marker
;
7672 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
7674 init_sal (&sals
.sals
[i
]);
7676 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
7677 sals
.sals
[i
].pc
= marker
->address
;
7679 release_static_tracepoint_marker (marker
);
7682 do_cleanups (old_chain
);
7688 /* Set a breakpoint. This function is shared between CLI and MI
7689 functions for setting a breakpoint. This function has two major
7690 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7691 parameter. If non-zero, the function will parse arg, extracting
7692 breakpoint location, address and thread. Otherwise, ARG is just
7693 the location of breakpoint, with condition and thread specified by
7694 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
7695 the breakpoint number will be allocated from the internal
7696 breakpoint count. Returns true if any breakpoint was created;
7700 create_breakpoint (struct gdbarch
*gdbarch
,
7701 char *arg
, char *cond_string
, int thread
,
7702 int parse_condition_and_thread
,
7703 int tempflag
, enum bptype type_wanted
,
7705 enum auto_boolean pending_break_support
,
7706 const struct breakpoint_ops
*ops
,
7707 int from_tty
, int enabled
, int internal
)
7709 volatile struct gdb_exception e
;
7710 char *copy_arg
= NULL
;
7711 char *addr_start
= arg
;
7712 struct linespec_result canonical
;
7713 struct cleanup
*old_chain
;
7714 struct cleanup
*bkpt_chain
= NULL
;
7718 int prev_bkpt_count
= breakpoint_count
;
7720 gdb_assert (ops
!= NULL
);
7722 init_linespec_result (&canonical
);
7724 if (type_wanted
== bp_static_tracepoint
&& is_marker_spec (arg
))
7727 struct linespec_sals lsal
;
7729 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
7731 copy_arg
= savestring (addr_start
, arg
- addr_start
);
7733 canonical
.addr_string
= xstrdup (copy_arg
);
7734 lsal
.canonical
= xstrdup (copy_arg
);
7735 VEC_safe_push (linespec_sals
, canonical
.sals
, &lsal
);
7740 TRY_CATCH (e
, RETURN_MASK_ALL
)
7742 parse_breakpoint_sals (&arg
, &canonical
);
7745 /* If caller is interested in rc value from parse, set value. */
7749 throw_exception (e
);
7753 case NOT_FOUND_ERROR
:
7755 /* If pending breakpoint support is turned off, throw
7758 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
7759 throw_exception (e
);
7761 exception_print (gdb_stderr
, e
);
7763 /* If pending breakpoint support is auto query and the user
7764 selects no, then simply return the error code. */
7765 if (pending_break_support
== AUTO_BOOLEAN_AUTO
7766 && !nquery (_("Make %s pending on future shared library load? "),
7767 bptype_string (type_wanted
)))
7770 /* At this point, either the user was queried about setting
7771 a pending breakpoint and selected yes, or pending
7772 breakpoint behavior is on and thus a pending breakpoint
7773 is defaulted on behalf of the user. */
7775 struct linespec_sals lsal
;
7777 copy_arg
= xstrdup (addr_start
);
7778 lsal
.canonical
= xstrdup (copy_arg
);
7779 lsal
.sals
.nelts
= 1;
7780 lsal
.sals
.sals
= XNEW (struct symtab_and_line
);
7781 init_sal (&lsal
.sals
.sals
[0]);
7783 VEC_safe_push (linespec_sals
, canonical
.sals
, &lsal
);
7787 throw_exception (e
);
7791 if (VEC_empty (linespec_sals
, canonical
.sals
))
7797 /* Create a chain of things that always need to be cleaned up. */
7798 old_chain
= make_cleanup_destroy_linespec_result (&canonical
);
7800 /* ----------------------------- SNIP -----------------------------
7801 Anything added to the cleanup chain beyond this point is assumed
7802 to be part of a breakpoint. If the breakpoint create succeeds
7803 then the memory is not reclaimed. */
7804 bkpt_chain
= make_cleanup (null_cleanup
, 0);
7806 /* Resolve all line numbers to PC's and verify that the addresses
7807 are ok for the target. */
7811 struct linespec_sals
*iter
;
7813 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
7814 breakpoint_sals_to_pc (&iter
->sals
);
7817 /* Fast tracepoints may have additional restrictions on location. */
7818 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
7821 struct linespec_sals
*iter
;
7823 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
7824 check_fast_tracepoint_sals (gdbarch
, &iter
->sals
);
7827 /* Verify that condition can be parsed, before setting any
7828 breakpoints. Allocate a separate condition expression for each
7832 struct linespec_sals
*lsal
;
7834 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
7836 if (parse_condition_and_thread
)
7838 /* Here we only parse 'arg' to separate condition
7839 from thread number, so parsing in context of first
7840 sal is OK. When setting the breakpoint we'll
7841 re-parse it in context of each sal. */
7844 find_condition_and_thread (arg
, lsal
->sals
.sals
[0].pc
, &cond_string
,
7847 make_cleanup (xfree
, cond_string
);
7851 /* Create a private copy of condition string. */
7854 cond_string
= xstrdup (cond_string
);
7855 make_cleanup (xfree
, cond_string
);
7859 /* If the user is creating a static tracepoint by marker id
7860 (strace -m MARKER_ID), then store the sals index, so that
7861 breakpoint_re_set can try to match up which of the newly
7862 found markers corresponds to this one, and, don't try to
7863 expand multiple locations for each sal, given than SALS
7864 already should contain all sals for MARKER_ID. */
7865 if (type_wanted
== bp_static_tracepoint
7866 && is_marker_spec (copy_arg
))
7870 for (i
= 0; i
< lsal
->sals
.nelts
; ++i
)
7872 struct symtabs_and_lines expanded
;
7873 struct tracepoint
*tp
;
7874 struct cleanup
*old_chain
;
7878 expanded
.sals
= &lsal
->sals
.sals
[i
];
7880 addr_string
= xstrdup (canonical
.addr_string
);
7881 old_chain
= make_cleanup (xfree
, addr_string
);
7883 tp
= XCNEW (struct tracepoint
);
7884 init_breakpoint_sal (&tp
->base
, gdbarch
, expanded
,
7886 cond_string
, type_wanted
,
7887 tempflag
? disp_del
: disp_donttouch
,
7888 thread
, task
, ignore_count
, ops
,
7889 from_tty
, enabled
, internal
,
7890 canonical
.special_display
);
7891 /* Given that its possible to have multiple markers with
7892 the same string id, if the user is creating a static
7893 tracepoint by marker id ("strace -m MARKER_ID"), then
7894 store the sals index, so that breakpoint_re_set can
7895 try to match up which of the newly found markers
7896 corresponds to this one */
7897 tp
->static_trace_marker_id_idx
= i
;
7899 install_breakpoint (internal
, &tp
->base
, 0);
7901 discard_cleanups (old_chain
);
7905 create_breakpoints_sal (gdbarch
, &canonical
, cond_string
,
7907 tempflag
? disp_del
: disp_donttouch
,
7908 thread
, task
, ignore_count
, ops
, from_tty
,
7913 struct breakpoint
*b
;
7915 make_cleanup (xfree
, copy_arg
);
7917 if (is_tracepoint_type (type_wanted
))
7919 struct tracepoint
*t
;
7921 t
= XCNEW (struct tracepoint
);
7925 b
= XNEW (struct breakpoint
);
7927 init_raw_breakpoint_without_location (b
, gdbarch
, type_wanted
, ops
);
7929 b
->addr_string
= copy_arg
;
7930 b
->cond_string
= NULL
;
7931 b
->ignore_count
= ignore_count
;
7932 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
7933 b
->condition_not_parsed
= 1;
7934 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7935 if ((type_wanted
!= bp_breakpoint
7936 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
7937 b
->pspace
= current_program_space
;
7939 install_breakpoint (internal
, b
, 0);
7942 if (VEC_length (linespec_sals
, canonical
.sals
) > 1)
7944 warning (_("Multiple breakpoints were set.\nUse the "
7945 "\"delete\" command to delete unwanted breakpoints."));
7946 prev_breakpoint_count
= prev_bkpt_count
;
7949 /* That's it. Discard the cleanups for data inserted into the
7951 discard_cleanups (bkpt_chain
);
7952 /* But cleanup everything else. */
7953 do_cleanups (old_chain
);
7955 /* error call may happen here - have BKPT_CHAIN already discarded. */
7956 update_global_location_list (1);
7961 /* Set a breakpoint.
7962 ARG is a string describing breakpoint address,
7963 condition, and thread.
7964 FLAG specifies if a breakpoint is hardware on,
7965 and if breakpoint is temporary, using BP_HARDWARE_FLAG
7969 break_command_1 (char *arg
, int flag
, int from_tty
)
7971 int tempflag
= flag
& BP_TEMPFLAG
;
7972 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
7973 ? bp_hardware_breakpoint
7976 create_breakpoint (get_current_arch (),
7978 NULL
, 0, 1 /* parse arg */,
7979 tempflag
, type_wanted
,
7980 0 /* Ignore count */,
7981 pending_break_support
,
7982 &bkpt_breakpoint_ops
,
7988 /* Helper function for break_command_1 and disassemble_command. */
7991 resolve_sal_pc (struct symtab_and_line
*sal
)
7995 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
7997 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
7998 error (_("No line %d in file \"%s\"."),
7999 sal
->line
, sal
->symtab
->filename
);
8002 /* If this SAL corresponds to a breakpoint inserted using a line
8003 number, then skip the function prologue if necessary. */
8004 if (sal
->explicit_line
)
8005 skip_prologue_sal (sal
);
8008 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
8010 struct blockvector
*bv
;
8014 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
8017 sym
= block_linkage_function (b
);
8020 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
8021 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
8025 /* It really is worthwhile to have the section, so we'll
8026 just have to look harder. This case can be executed
8027 if we have line numbers but no functions (as can
8028 happen in assembly source). */
8030 struct minimal_symbol
*msym
;
8031 struct cleanup
*old_chain
= save_current_space_and_thread ();
8033 switch_to_program_space_and_thread (sal
->pspace
);
8035 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
8037 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
8039 do_cleanups (old_chain
);
8046 break_command (char *arg
, int from_tty
)
8048 break_command_1 (arg
, 0, from_tty
);
8052 tbreak_command (char *arg
, int from_tty
)
8054 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
8058 hbreak_command (char *arg
, int from_tty
)
8060 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
8064 thbreak_command (char *arg
, int from_tty
)
8066 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
8070 stop_command (char *arg
, int from_tty
)
8072 printf_filtered (_("Specify the type of breakpoint to set.\n\
8073 Usage: stop in <function | address>\n\
8074 stop at <line>\n"));
8078 stopin_command (char *arg
, int from_tty
)
8082 if (arg
== (char *) NULL
)
8084 else if (*arg
!= '*')
8089 /* Look for a ':'. If this is a line number specification, then
8090 say it is bad, otherwise, it should be an address or
8091 function/method name. */
8092 while (*argptr
&& !hasColon
)
8094 hasColon
= (*argptr
== ':');
8099 badInput
= (*argptr
!= ':'); /* Not a class::method */
8101 badInput
= isdigit (*arg
); /* a simple line number */
8105 printf_filtered (_("Usage: stop in <function | address>\n"));
8107 break_command_1 (arg
, 0, from_tty
);
8111 stopat_command (char *arg
, int from_tty
)
8115 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
8122 /* Look for a ':'. If there is a '::' then get out, otherwise
8123 it is probably a line number. */
8124 while (*argptr
&& !hasColon
)
8126 hasColon
= (*argptr
== ':');
8131 badInput
= (*argptr
== ':'); /* we have class::method */
8133 badInput
= !isdigit (*arg
); /* not a line number */
8137 printf_filtered (_("Usage: stop at <line>\n"));
8139 break_command_1 (arg
, 0, from_tty
);
8142 /* Implement the "breakpoint_hit" breakpoint_ops method for
8143 ranged breakpoints. */
8146 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
8147 struct address_space
*aspace
,
8150 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
8151 bl
->length
, aspace
, bp_addr
);
8154 /* Implement the "resources_needed" breakpoint_ops method for
8155 ranged breakpoints. */
8158 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
8160 return target_ranged_break_num_registers ();
8163 /* Implement the "print_it" breakpoint_ops method for
8164 ranged breakpoints. */
8166 static enum print_stop_action
8167 print_it_ranged_breakpoint (bpstat bs
)
8169 struct breakpoint
*b
= bs
->breakpoint_at
;
8170 struct bp_location
*bl
= b
->loc
;
8171 struct ui_out
*uiout
= current_uiout
;
8173 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8175 /* Ranged breakpoints have only one location. */
8176 gdb_assert (bl
&& bl
->next
== NULL
);
8178 annotate_breakpoint (b
->number
);
8179 if (b
->disposition
== disp_del
)
8180 ui_out_text (uiout
, "\nTemporary ranged breakpoint ");
8182 ui_out_text (uiout
, "\nRanged breakpoint ");
8183 if (ui_out_is_mi_like_p (uiout
))
8185 ui_out_field_string (uiout
, "reason",
8186 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
8187 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8189 ui_out_field_int (uiout
, "bkptno", b
->number
);
8190 ui_out_text (uiout
, ", ");
8192 return PRINT_SRC_AND_LOC
;
8195 /* Implement the "print_one" breakpoint_ops method for
8196 ranged breakpoints. */
8199 print_one_ranged_breakpoint (struct breakpoint
*b
,
8200 struct bp_location
**last_loc
)
8202 struct bp_location
*bl
= b
->loc
;
8203 struct value_print_options opts
;
8204 struct ui_out
*uiout
= current_uiout
;
8206 /* Ranged breakpoints have only one location. */
8207 gdb_assert (bl
&& bl
->next
== NULL
);
8209 get_user_print_options (&opts
);
8211 if (opts
.addressprint
)
8212 /* We don't print the address range here, it will be printed later
8213 by print_one_detail_ranged_breakpoint. */
8214 ui_out_field_skip (uiout
, "addr");
8216 print_breakpoint_location (b
, bl
);
8220 /* Implement the "print_one_detail" breakpoint_ops method for
8221 ranged breakpoints. */
8224 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
8225 struct ui_out
*uiout
)
8227 CORE_ADDR address_start
, address_end
;
8228 struct bp_location
*bl
= b
->loc
;
8229 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
8230 struct cleanup
*cleanup
= make_cleanup_ui_out_stream_delete (stb
);
8234 address_start
= bl
->address
;
8235 address_end
= address_start
+ bl
->length
- 1;
8237 ui_out_text (uiout
, "\taddress range: ");
8238 fprintf_unfiltered (stb
->stream
, "[%s, %s]",
8239 print_core_address (bl
->gdbarch
, address_start
),
8240 print_core_address (bl
->gdbarch
, address_end
));
8241 ui_out_field_stream (uiout
, "addr", stb
);
8242 ui_out_text (uiout
, "\n");
8244 do_cleanups (cleanup
);
8247 /* Implement the "print_mention" breakpoint_ops method for
8248 ranged breakpoints. */
8251 print_mention_ranged_breakpoint (struct breakpoint
*b
)
8253 struct bp_location
*bl
= b
->loc
;
8254 struct ui_out
*uiout
= current_uiout
;
8257 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8259 if (ui_out_is_mi_like_p (uiout
))
8262 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
8263 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
8264 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
8267 /* Implement the "print_recreate" breakpoint_ops method for
8268 ranged breakpoints. */
8271 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8273 fprintf_unfiltered (fp
, "break-range %s, %s", b
->addr_string
,
8274 b
->addr_string_range_end
);
8275 print_recreate_thread (b
, fp
);
8278 /* The breakpoint_ops structure to be used in ranged breakpoints. */
8280 static struct breakpoint_ops ranged_breakpoint_ops
;
8282 /* Find the address where the end of the breakpoint range should be
8283 placed, given the SAL of the end of the range. This is so that if
8284 the user provides a line number, the end of the range is set to the
8285 last instruction of the given line. */
8288 find_breakpoint_range_end (struct symtab_and_line sal
)
8292 /* If the user provided a PC value, use it. Otherwise,
8293 find the address of the end of the given location. */
8294 if (sal
.explicit_pc
)
8301 ret
= find_line_pc_range (sal
, &start
, &end
);
8303 error (_("Could not find location of the end of the range."));
8305 /* find_line_pc_range returns the start of the next line. */
8312 /* Implement the "break-range" CLI command. */
8315 break_range_command (char *arg
, int from_tty
)
8317 char *arg_start
, *addr_string_start
, *addr_string_end
;
8318 struct linespec_result canonical_start
, canonical_end
;
8319 int bp_count
, can_use_bp
, length
;
8321 struct breakpoint
*b
;
8322 struct symtab_and_line sal_start
, sal_end
;
8323 struct cleanup
*cleanup_bkpt
;
8324 struct linespec_sals
*lsal_start
, *lsal_end
;
8326 /* We don't support software ranged breakpoints. */
8327 if (target_ranged_break_num_registers () < 0)
8328 error (_("This target does not support hardware ranged breakpoints."));
8330 bp_count
= hw_breakpoint_used_count ();
8331 bp_count
+= target_ranged_break_num_registers ();
8332 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8335 error (_("Hardware breakpoints used exceeds limit."));
8337 arg
= skip_spaces (arg
);
8338 if (arg
== NULL
|| arg
[0] == '\0')
8339 error(_("No address range specified."));
8341 init_linespec_result (&canonical_start
);
8344 parse_breakpoint_sals (&arg
, &canonical_start
);
8346 cleanup_bkpt
= make_cleanup_destroy_linespec_result (&canonical_start
);
8349 error (_("Too few arguments."));
8350 else if (VEC_empty (linespec_sals
, canonical_start
.sals
))
8351 error (_("Could not find location of the beginning of the range."));
8353 lsal_start
= VEC_index (linespec_sals
, canonical_start
.sals
, 0);
8355 if (VEC_length (linespec_sals
, canonical_start
.sals
) > 1
8356 || lsal_start
->sals
.nelts
!= 1)
8357 error (_("Cannot create a ranged breakpoint with multiple locations."));
8359 sal_start
= lsal_start
->sals
.sals
[0];
8360 addr_string_start
= savestring (arg_start
, arg
- arg_start
);
8361 make_cleanup (xfree
, addr_string_start
);
8363 arg
++; /* Skip the comma. */
8364 arg
= skip_spaces (arg
);
8366 /* Parse the end location. */
8368 init_linespec_result (&canonical_end
);
8371 /* We call decode_line_full directly here instead of using
8372 parse_breakpoint_sals because we need to specify the start location's
8373 symtab and line as the default symtab and line for the end of the
8374 range. This makes it possible to have ranges like "foo.c:27, +14",
8375 where +14 means 14 lines from the start location. */
8376 decode_line_full (&arg
, DECODE_LINE_FUNFIRSTLINE
,
8377 sal_start
.symtab
, sal_start
.line
,
8378 &canonical_end
, NULL
, NULL
);
8380 make_cleanup_destroy_linespec_result (&canonical_end
);
8382 if (VEC_empty (linespec_sals
, canonical_end
.sals
))
8383 error (_("Could not find location of the end of the range."));
8385 lsal_end
= VEC_index (linespec_sals
, canonical_end
.sals
, 0);
8386 if (VEC_length (linespec_sals
, canonical_end
.sals
) > 1
8387 || lsal_end
->sals
.nelts
!= 1)
8388 error (_("Cannot create a ranged breakpoint with multiple locations."));
8390 sal_end
= lsal_end
->sals
.sals
[0];
8391 addr_string_end
= savestring (arg_start
, arg
- arg_start
);
8392 make_cleanup (xfree
, addr_string_end
);
8394 end
= find_breakpoint_range_end (sal_end
);
8395 if (sal_start
.pc
> end
)
8396 error (_("Invalid address range, end precedes start."));
8398 length
= end
- sal_start
.pc
+ 1;
8400 /* Length overflowed. */
8401 error (_("Address range too large."));
8402 else if (length
== 1)
8404 /* This range is simple enough to be handled by
8405 the `hbreak' command. */
8406 hbreak_command (addr_string_start
, 1);
8408 do_cleanups (cleanup_bkpt
);
8413 /* Now set up the breakpoint. */
8414 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
8415 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
8416 set_breakpoint_count (breakpoint_count
+ 1);
8417 b
->number
= breakpoint_count
;
8418 b
->disposition
= disp_donttouch
;
8419 b
->addr_string
= xstrdup (addr_string_start
);
8420 b
->addr_string_range_end
= xstrdup (addr_string_end
);
8421 b
->loc
->length
= length
;
8423 do_cleanups (cleanup_bkpt
);
8426 observer_notify_breakpoint_created (b
);
8427 update_global_location_list (1);
8430 /* Return non-zero if EXP is verified as constant. Returned zero
8431 means EXP is variable. Also the constant detection may fail for
8432 some constant expressions and in such case still falsely return
8435 watchpoint_exp_is_const (const struct expression
*exp
)
8443 /* We are only interested in the descriptor of each element. */
8444 operator_length (exp
, i
, &oplenp
, &argsp
);
8447 switch (exp
->elts
[i
].opcode
)
8457 case BINOP_LOGICAL_AND
:
8458 case BINOP_LOGICAL_OR
:
8459 case BINOP_BITWISE_AND
:
8460 case BINOP_BITWISE_IOR
:
8461 case BINOP_BITWISE_XOR
:
8463 case BINOP_NOTEQUAL
:
8479 case TERNOP_SLICE_COUNT
:
8491 case OP_OBJC_NSSTRING
:
8494 case UNOP_LOGICAL_NOT
:
8495 case UNOP_COMPLEMENT
:
8498 /* Unary, binary and ternary operators: We have to check
8499 their operands. If they are constant, then so is the
8500 result of that operation. For instance, if A and B are
8501 determined to be constants, then so is "A + B".
8503 UNOP_IND is one exception to the rule above, because the
8504 value of *ADDR is not necessarily a constant, even when
8509 /* Check whether the associated symbol is a constant.
8511 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8512 possible that a buggy compiler could mark a variable as
8513 constant even when it is not, and TYPE_CONST would return
8514 true in this case, while SYMBOL_CLASS wouldn't.
8516 We also have to check for function symbols because they
8517 are always constant. */
8519 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
8521 if (SYMBOL_CLASS (s
) != LOC_BLOCK
8522 && SYMBOL_CLASS (s
) != LOC_CONST
8523 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
8528 /* The default action is to return 0 because we are using
8529 the optimistic approach here: If we don't know something,
8530 then it is not a constant. */
8539 /* Implement the "dtor" breakpoint_ops method for watchpoints. */
8542 dtor_watchpoint (struct breakpoint
*self
)
8544 struct watchpoint
*w
= (struct watchpoint
*) self
;
8546 xfree (w
->cond_exp
);
8548 xfree (w
->exp_string
);
8549 xfree (w
->exp_string_reparse
);
8550 value_free (w
->val
);
8552 base_breakpoint_ops
.dtor (self
);
8555 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
8558 re_set_watchpoint (struct breakpoint
*b
)
8560 struct watchpoint
*w
= (struct watchpoint
*) b
;
8562 /* Watchpoint can be either on expression using entirely global
8563 variables, or it can be on local variables.
8565 Watchpoints of the first kind are never auto-deleted, and even
8566 persist across program restarts. Since they can use variables
8567 from shared libraries, we need to reparse expression as libraries
8568 are loaded and unloaded.
8570 Watchpoints on local variables can also change meaning as result
8571 of solib event. For example, if a watchpoint uses both a local
8572 and a global variables in expression, it's a local watchpoint,
8573 but unloading of a shared library will make the expression
8574 invalid. This is not a very common use case, but we still
8575 re-evaluate expression, to avoid surprises to the user.
8577 Note that for local watchpoints, we re-evaluate it only if
8578 watchpoints frame id is still valid. If it's not, it means the
8579 watchpoint is out of scope and will be deleted soon. In fact,
8580 I'm not sure we'll ever be called in this case.
8582 If a local watchpoint's frame id is still valid, then
8583 w->exp_valid_block is likewise valid, and we can safely use it.
8585 Don't do anything about disabled watchpoints, since they will be
8586 reevaluated again when enabled. */
8587 update_watchpoint (w
, 1 /* reparse */);
8590 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8593 insert_watchpoint (struct bp_location
*bl
)
8595 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8596 int length
= w
->exact
? 1 : bl
->length
;
8598 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8602 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8605 remove_watchpoint (struct bp_location
*bl
)
8607 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8608 int length
= w
->exact
? 1 : bl
->length
;
8610 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8615 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
8616 struct address_space
*aspace
, CORE_ADDR bp_addr
)
8618 struct breakpoint
*b
= bl
->owner
;
8619 struct watchpoint
*w
= (struct watchpoint
*) b
;
8621 /* Continuable hardware watchpoints are treated as non-existent if the
8622 reason we stopped wasn't a hardware watchpoint (we didn't stop on
8623 some data address). Otherwise gdb won't stop on a break instruction
8624 in the code (not from a breakpoint) when a hardware watchpoint has
8625 been defined. Also skip watchpoints which we know did not trigger
8626 (did not match the data address). */
8627 if (is_hardware_watchpoint (b
)
8628 && w
->watchpoint_triggered
== watch_triggered_no
)
8635 check_status_watchpoint (bpstat bs
)
8637 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
8639 bpstat_check_watchpoint (bs
);
8642 /* Implement the "resources_needed" breakpoint_ops method for
8643 hardware watchpoints. */
8646 resources_needed_watchpoint (const struct bp_location
*bl
)
8648 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8649 int length
= w
->exact
? 1 : bl
->length
;
8651 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
8654 /* Implement the "works_in_software_mode" breakpoint_ops method for
8655 hardware watchpoints. */
8658 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
8660 /* Read and access watchpoints only work with hardware support. */
8661 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
8664 static enum print_stop_action
8665 print_it_watchpoint (bpstat bs
)
8667 struct cleanup
*old_chain
;
8668 struct breakpoint
*b
;
8669 const struct bp_location
*bl
;
8670 struct ui_stream
*stb
;
8671 enum print_stop_action result
;
8672 struct watchpoint
*w
;
8673 struct ui_out
*uiout
= current_uiout
;
8675 gdb_assert (bs
->bp_location_at
!= NULL
);
8677 bl
= bs
->bp_location_at
;
8678 b
= bs
->breakpoint_at
;
8679 w
= (struct watchpoint
*) b
;
8681 stb
= ui_out_stream_new (uiout
);
8682 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
8687 case bp_hardware_watchpoint
:
8688 annotate_watchpoint (b
->number
);
8689 if (ui_out_is_mi_like_p (uiout
))
8692 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
8694 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8695 ui_out_text (uiout
, "\nOld value = ");
8696 watchpoint_value_print (bs
->old_val
, stb
->stream
);
8697 ui_out_field_stream (uiout
, "old", stb
);
8698 ui_out_text (uiout
, "\nNew value = ");
8699 watchpoint_value_print (w
->val
, stb
->stream
);
8700 ui_out_field_stream (uiout
, "new", stb
);
8701 ui_out_text (uiout
, "\n");
8702 /* More than one watchpoint may have been triggered. */
8703 result
= PRINT_UNKNOWN
;
8706 case bp_read_watchpoint
:
8707 if (ui_out_is_mi_like_p (uiout
))
8710 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
8712 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8713 ui_out_text (uiout
, "\nValue = ");
8714 watchpoint_value_print (w
->val
, stb
->stream
);
8715 ui_out_field_stream (uiout
, "value", stb
);
8716 ui_out_text (uiout
, "\n");
8717 result
= PRINT_UNKNOWN
;
8720 case bp_access_watchpoint
:
8721 if (bs
->old_val
!= NULL
)
8723 annotate_watchpoint (b
->number
);
8724 if (ui_out_is_mi_like_p (uiout
))
8727 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
8729 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8730 ui_out_text (uiout
, "\nOld value = ");
8731 watchpoint_value_print (bs
->old_val
, stb
->stream
);
8732 ui_out_field_stream (uiout
, "old", stb
);
8733 ui_out_text (uiout
, "\nNew value = ");
8738 if (ui_out_is_mi_like_p (uiout
))
8741 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
8742 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8743 ui_out_text (uiout
, "\nValue = ");
8745 watchpoint_value_print (w
->val
, stb
->stream
);
8746 ui_out_field_stream (uiout
, "new", stb
);
8747 ui_out_text (uiout
, "\n");
8748 result
= PRINT_UNKNOWN
;
8751 result
= PRINT_UNKNOWN
;
8754 do_cleanups (old_chain
);
8758 /* Implement the "print_mention" breakpoint_ops method for hardware
8762 print_mention_watchpoint (struct breakpoint
*b
)
8764 struct cleanup
*ui_out_chain
;
8765 struct watchpoint
*w
= (struct watchpoint
*) b
;
8766 struct ui_out
*uiout
= current_uiout
;
8771 ui_out_text (uiout
, "Watchpoint ");
8772 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
8774 case bp_hardware_watchpoint
:
8775 ui_out_text (uiout
, "Hardware watchpoint ");
8776 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
8778 case bp_read_watchpoint
:
8779 ui_out_text (uiout
, "Hardware read watchpoint ");
8780 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
8782 case bp_access_watchpoint
:
8783 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
8784 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
8787 internal_error (__FILE__
, __LINE__
,
8788 _("Invalid hardware watchpoint type."));
8791 ui_out_field_int (uiout
, "number", b
->number
);
8792 ui_out_text (uiout
, ": ");
8793 ui_out_field_string (uiout
, "exp", w
->exp_string
);
8794 do_cleanups (ui_out_chain
);
8797 /* Implement the "print_recreate" breakpoint_ops method for
8801 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8803 struct watchpoint
*w
= (struct watchpoint
*) b
;
8808 case bp_hardware_watchpoint
:
8809 fprintf_unfiltered (fp
, "watch");
8811 case bp_read_watchpoint
:
8812 fprintf_unfiltered (fp
, "rwatch");
8814 case bp_access_watchpoint
:
8815 fprintf_unfiltered (fp
, "awatch");
8818 internal_error (__FILE__
, __LINE__
,
8819 _("Invalid watchpoint type."));
8822 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
8823 print_recreate_thread (b
, fp
);
8826 /* The breakpoint_ops structure to be used in hardware watchpoints. */
8828 static struct breakpoint_ops watchpoint_breakpoint_ops
;
8830 /* Implement the "insert" breakpoint_ops method for
8831 masked hardware watchpoints. */
8834 insert_masked_watchpoint (struct bp_location
*bl
)
8836 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8838 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
8839 bl
->watchpoint_type
);
8842 /* Implement the "remove" breakpoint_ops method for
8843 masked hardware watchpoints. */
8846 remove_masked_watchpoint (struct bp_location
*bl
)
8848 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8850 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
8851 bl
->watchpoint_type
);
8854 /* Implement the "resources_needed" breakpoint_ops method for
8855 masked hardware watchpoints. */
8858 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
8860 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8862 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
8865 /* Implement the "works_in_software_mode" breakpoint_ops method for
8866 masked hardware watchpoints. */
8869 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
8874 /* Implement the "print_it" breakpoint_ops method for
8875 masked hardware watchpoints. */
8877 static enum print_stop_action
8878 print_it_masked_watchpoint (bpstat bs
)
8880 struct breakpoint
*b
= bs
->breakpoint_at
;
8881 struct ui_out
*uiout
= current_uiout
;
8883 /* Masked watchpoints have only one location. */
8884 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
8888 case bp_hardware_watchpoint
:
8889 annotate_watchpoint (b
->number
);
8890 if (ui_out_is_mi_like_p (uiout
))
8893 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
8896 case bp_read_watchpoint
:
8897 if (ui_out_is_mi_like_p (uiout
))
8900 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
8903 case bp_access_watchpoint
:
8904 if (ui_out_is_mi_like_p (uiout
))
8907 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
8910 internal_error (__FILE__
, __LINE__
,
8911 _("Invalid hardware watchpoint type."));
8915 ui_out_text (uiout
, _("\n\
8916 Check the underlying instruction at PC for the memory\n\
8917 address and value which triggered this watchpoint.\n"));
8918 ui_out_text (uiout
, "\n");
8920 /* More than one watchpoint may have been triggered. */
8921 return PRINT_UNKNOWN
;
8924 /* Implement the "print_one_detail" breakpoint_ops method for
8925 masked hardware watchpoints. */
8928 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
8929 struct ui_out
*uiout
)
8931 struct watchpoint
*w
= (struct watchpoint
*) b
;
8933 /* Masked watchpoints have only one location. */
8934 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
8936 ui_out_text (uiout
, "\tmask ");
8937 ui_out_field_core_addr (uiout
, "mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
8938 ui_out_text (uiout
, "\n");
8941 /* Implement the "print_mention" breakpoint_ops method for
8942 masked hardware watchpoints. */
8945 print_mention_masked_watchpoint (struct breakpoint
*b
)
8947 struct watchpoint
*w
= (struct watchpoint
*) b
;
8948 struct ui_out
*uiout
= current_uiout
;
8949 struct cleanup
*ui_out_chain
;
8953 case bp_hardware_watchpoint
:
8954 ui_out_text (uiout
, "Masked hardware watchpoint ");
8955 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
8957 case bp_read_watchpoint
:
8958 ui_out_text (uiout
, "Masked hardware read watchpoint ");
8959 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
8961 case bp_access_watchpoint
:
8962 ui_out_text (uiout
, "Masked hardware access (read/write) watchpoint ");
8963 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
8966 internal_error (__FILE__
, __LINE__
,
8967 _("Invalid hardware watchpoint type."));
8970 ui_out_field_int (uiout
, "number", b
->number
);
8971 ui_out_text (uiout
, ": ");
8972 ui_out_field_string (uiout
, "exp", w
->exp_string
);
8973 do_cleanups (ui_out_chain
);
8976 /* Implement the "print_recreate" breakpoint_ops method for
8977 masked hardware watchpoints. */
8980 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8982 struct watchpoint
*w
= (struct watchpoint
*) b
;
8987 case bp_hardware_watchpoint
:
8988 fprintf_unfiltered (fp
, "watch");
8990 case bp_read_watchpoint
:
8991 fprintf_unfiltered (fp
, "rwatch");
8993 case bp_access_watchpoint
:
8994 fprintf_unfiltered (fp
, "awatch");
8997 internal_error (__FILE__
, __LINE__
,
8998 _("Invalid hardware watchpoint type."));
9001 sprintf_vma (tmp
, w
->hw_wp_mask
);
9002 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
9003 print_recreate_thread (b
, fp
);
9006 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
9008 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
9010 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
9013 is_masked_watchpoint (const struct breakpoint
*b
)
9015 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
9018 /* accessflag: hw_write: watch write,
9019 hw_read: watch read,
9020 hw_access: watch access (read or write) */
9022 watch_command_1 (char *arg
, int accessflag
, int from_tty
,
9023 int just_location
, int internal
)
9025 volatile struct gdb_exception e
;
9026 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
9027 struct expression
*exp
;
9028 struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
9029 struct value
*val
, *mark
, *result
;
9030 struct frame_info
*frame
;
9031 char *exp_start
= NULL
;
9032 char *exp_end
= NULL
;
9033 char *tok
, *end_tok
;
9035 char *cond_start
= NULL
;
9036 char *cond_end
= NULL
;
9037 enum bptype bp_type
;
9040 /* Flag to indicate whether we are going to use masks for
9041 the hardware watchpoint. */
9044 struct watchpoint
*w
;
9046 /* Make sure that we actually have parameters to parse. */
9047 if (arg
!= NULL
&& arg
[0] != '\0')
9051 /* Look for "parameter value" pairs at the end
9052 of the arguments string. */
9053 for (tok
= arg
+ strlen (arg
) - 1; tok
> arg
; tok
--)
9055 /* Skip whitespace at the end of the argument list. */
9056 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
9059 /* Find the beginning of the last token.
9060 This is the value of the parameter. */
9061 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
9063 value_start
= tok
+ 1;
9065 /* Skip whitespace. */
9066 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
9071 /* Find the beginning of the second to last token.
9072 This is the parameter itself. */
9073 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
9076 toklen
= end_tok
- tok
+ 1;
9078 if (toklen
== 6 && !strncmp (tok
, "thread", 6))
9080 /* At this point we've found a "thread" token, which means
9081 the user is trying to set a watchpoint that triggers
9082 only in a specific thread. */
9086 error(_("You can specify only one thread."));
9088 /* Extract the thread ID from the next token. */
9089 thread
= strtol (value_start
, &endp
, 0);
9091 /* Check if the user provided a valid numeric value for the
9093 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
9094 error (_("Invalid thread ID specification %s."), value_start
);
9096 /* Check if the thread actually exists. */
9097 if (!valid_thread_id (thread
))
9098 error (_("Unknown thread %d."), thread
);
9100 else if (toklen
== 4 && !strncmp (tok
, "mask", 4))
9102 /* We've found a "mask" token, which means the user wants to
9103 create a hardware watchpoint that is going to have the mask
9105 struct value
*mask_value
, *mark
;
9108 error(_("You can specify only one mask."));
9110 use_mask
= just_location
= 1;
9112 mark
= value_mark ();
9113 mask_value
= parse_to_comma_and_eval (&value_start
);
9114 mask
= value_as_address (mask_value
);
9115 value_free_to_mark (mark
);
9118 /* We didn't recognize what we found. We should stop here. */
9121 /* Truncate the string and get rid of the "parameter value" pair before
9122 the arguments string is parsed by the parse_exp_1 function. */
9127 /* Parse the rest of the arguments. */
9128 innermost_block
= NULL
;
9130 exp
= parse_exp_1 (&arg
, 0, 0);
9132 /* Remove trailing whitespace from the expression before saving it.
9133 This makes the eventual display of the expression string a bit
9135 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
9138 /* Checking if the expression is not constant. */
9139 if (watchpoint_exp_is_const (exp
))
9143 len
= exp_end
- exp_start
;
9144 while (len
> 0 && isspace (exp_start
[len
- 1]))
9146 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
9149 exp_valid_block
= innermost_block
;
9150 mark
= value_mark ();
9151 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
);
9157 exp_valid_block
= NULL
;
9158 val
= value_addr (result
);
9159 release_value (val
);
9160 value_free_to_mark (mark
);
9164 ret
= target_masked_watch_num_registers (value_as_address (val
),
9167 error (_("This target does not support masked watchpoints."));
9169 error (_("Invalid mask or memory region."));
9172 else if (val
!= NULL
)
9173 release_value (val
);
9175 tok
= skip_spaces (arg
);
9176 end_tok
= skip_to_space (tok
);
9178 toklen
= end_tok
- tok
;
9179 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9181 struct expression
*cond
;
9183 innermost_block
= NULL
;
9184 tok
= cond_start
= end_tok
+ 1;
9185 cond
= parse_exp_1 (&tok
, 0, 0);
9187 /* The watchpoint expression may not be local, but the condition
9188 may still be. E.g.: `watch global if local > 0'. */
9189 cond_exp_valid_block
= innermost_block
;
9195 error (_("Junk at end of command."));
9197 if (accessflag
== hw_read
)
9198 bp_type
= bp_read_watchpoint
;
9199 else if (accessflag
== hw_access
)
9200 bp_type
= bp_access_watchpoint
;
9202 bp_type
= bp_hardware_watchpoint
;
9204 frame
= block_innermost_frame (exp_valid_block
);
9206 /* If the expression is "local", then set up a "watchpoint scope"
9207 breakpoint at the point where we've left the scope of the watchpoint
9208 expression. Create the scope breakpoint before the watchpoint, so
9209 that we will encounter it first in bpstat_stop_status. */
9210 if (exp_valid_block
&& frame
)
9212 if (frame_id_p (frame_unwind_caller_id (frame
)))
9215 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
9216 frame_unwind_caller_pc (frame
),
9217 bp_watchpoint_scope
,
9218 &momentary_breakpoint_ops
);
9220 scope_breakpoint
->enable_state
= bp_enabled
;
9222 /* Automatically delete the breakpoint when it hits. */
9223 scope_breakpoint
->disposition
= disp_del
;
9225 /* Only break in the proper frame (help with recursion). */
9226 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
9228 /* Set the address at which we will stop. */
9229 scope_breakpoint
->loc
->gdbarch
9230 = frame_unwind_caller_arch (frame
);
9231 scope_breakpoint
->loc
->requested_address
9232 = frame_unwind_caller_pc (frame
);
9233 scope_breakpoint
->loc
->address
9234 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
9235 scope_breakpoint
->loc
->requested_address
,
9236 scope_breakpoint
->type
);
9240 /* Now set up the breakpoint. */
9242 w
= XCNEW (struct watchpoint
);
9245 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
9246 &masked_watchpoint_breakpoint_ops
);
9248 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
9249 &watchpoint_breakpoint_ops
);
9251 b
->disposition
= disp_donttouch
;
9252 b
->pspace
= current_program_space
;
9254 w
->exp_valid_block
= exp_valid_block
;
9255 w
->cond_exp_valid_block
= cond_exp_valid_block
;
9258 struct type
*t
= value_type (val
);
9259 CORE_ADDR addr
= value_as_address (val
);
9262 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
9263 name
= type_to_string (t
);
9265 w
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
9266 core_addr_to_string (addr
));
9269 w
->exp_string
= xstrprintf ("-location %.*s",
9270 (int) (exp_end
- exp_start
), exp_start
);
9272 /* The above expression is in C. */
9273 b
->language
= language_c
;
9276 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
9280 w
->hw_wp_mask
= mask
;
9289 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9295 w
->watchpoint_frame
= get_frame_id (frame
);
9296 w
->watchpoint_thread
= inferior_ptid
;
9300 w
->watchpoint_frame
= null_frame_id
;
9301 w
->watchpoint_thread
= null_ptid
;
9304 if (scope_breakpoint
!= NULL
)
9306 /* The scope breakpoint is related to the watchpoint. We will
9307 need to act on them together. */
9308 b
->related_breakpoint
= scope_breakpoint
;
9309 scope_breakpoint
->related_breakpoint
= b
;
9313 value_free_to_mark (mark
);
9315 TRY_CATCH (e
, RETURN_MASK_ALL
)
9317 /* Finally update the new watchpoint. This creates the locations
9318 that should be inserted. */
9319 update_watchpoint (w
, 1);
9323 delete_breakpoint (b
);
9324 throw_exception (e
);
9327 install_breakpoint (internal
, b
, 1);
9330 /* Return count of debug registers needed to watch the given expression.
9331 If the watchpoint cannot be handled in hardware return zero. */
9334 can_use_hardware_watchpoint (struct value
*v
)
9336 int found_memory_cnt
= 0;
9337 struct value
*head
= v
;
9339 /* Did the user specifically forbid us to use hardware watchpoints? */
9340 if (!can_use_hw_watchpoints
)
9343 /* Make sure that the value of the expression depends only upon
9344 memory contents, and values computed from them within GDB. If we
9345 find any register references or function calls, we can't use a
9346 hardware watchpoint.
9348 The idea here is that evaluating an expression generates a series
9349 of values, one holding the value of every subexpression. (The
9350 expression a*b+c has five subexpressions: a, b, a*b, c, and
9351 a*b+c.) GDB's values hold almost enough information to establish
9352 the criteria given above --- they identify memory lvalues,
9353 register lvalues, computed values, etcetera. So we can evaluate
9354 the expression, and then scan the chain of values that leaves
9355 behind to decide whether we can detect any possible change to the
9356 expression's final value using only hardware watchpoints.
9358 However, I don't think that the values returned by inferior
9359 function calls are special in any way. So this function may not
9360 notice that an expression involving an inferior function call
9361 can't be watched with hardware watchpoints. FIXME. */
9362 for (; v
; v
= value_next (v
))
9364 if (VALUE_LVAL (v
) == lval_memory
)
9366 if (v
!= head
&& value_lazy (v
))
9367 /* A lazy memory lvalue in the chain is one that GDB never
9368 needed to fetch; we either just used its address (e.g.,
9369 `a' in `a.b') or we never needed it at all (e.g., `a'
9370 in `a,b'). This doesn't apply to HEAD; if that is
9371 lazy then it was not readable, but watch it anyway. */
9375 /* Ahh, memory we actually used! Check if we can cover
9376 it with hardware watchpoints. */
9377 struct type
*vtype
= check_typedef (value_type (v
));
9379 /* We only watch structs and arrays if user asked for it
9380 explicitly, never if they just happen to appear in a
9381 middle of some value chain. */
9383 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
9384 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
9386 CORE_ADDR vaddr
= value_address (v
);
9390 len
= (target_exact_watchpoints
9391 && is_scalar_type_recursive (vtype
))?
9392 1 : TYPE_LENGTH (value_type (v
));
9394 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
9398 found_memory_cnt
+= num_regs
;
9402 else if (VALUE_LVAL (v
) != not_lval
9403 && deprecated_value_modifiable (v
) == 0)
9404 return 0; /* These are values from the history (e.g., $1). */
9405 else if (VALUE_LVAL (v
) == lval_register
)
9406 return 0; /* Cannot watch a register with a HW watchpoint. */
9409 /* The expression itself looks suitable for using a hardware
9410 watchpoint, but give the target machine a chance to reject it. */
9411 return found_memory_cnt
;
9415 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
9417 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
9420 /* A helper function that looks for an argument at the start of a
9421 string. The argument must also either be at the end of the string,
9422 or be followed by whitespace. Returns 1 if it finds the argument,
9423 0 otherwise. If the argument is found, it updates *STR. */
9426 check_for_argument (char **str
, char *arg
, int arg_len
)
9428 if (strncmp (*str
, arg
, arg_len
) == 0
9429 && ((*str
)[arg_len
] == '\0' || isspace ((*str
)[arg_len
])))
9437 /* A helper function that looks for the "-location" argument and then
9438 calls watch_command_1. */
9441 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
9443 int just_location
= 0;
9446 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
9447 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
9449 arg
= skip_spaces (arg
);
9453 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
9457 watch_command (char *arg
, int from_tty
)
9459 watch_maybe_just_location (arg
, hw_write
, from_tty
);
9463 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9465 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
9469 rwatch_command (char *arg
, int from_tty
)
9471 watch_maybe_just_location (arg
, hw_read
, from_tty
);
9475 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9477 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
9481 awatch_command (char *arg
, int from_tty
)
9483 watch_maybe_just_location (arg
, hw_access
, from_tty
);
9487 /* Helper routines for the until_command routine in infcmd.c. Here
9488 because it uses the mechanisms of breakpoints. */
9490 struct until_break_command_continuation_args
9492 struct breakpoint
*breakpoint
;
9493 struct breakpoint
*breakpoint2
;
9497 /* This function is called by fetch_inferior_event via the
9498 cmd_continuation pointer, to complete the until command. It takes
9499 care of cleaning up the temporary breakpoints set up by the until
9502 until_break_command_continuation (void *arg
, int err
)
9504 struct until_break_command_continuation_args
*a
= arg
;
9506 delete_breakpoint (a
->breakpoint
);
9508 delete_breakpoint (a
->breakpoint2
);
9509 delete_longjmp_breakpoint (a
->thread_num
);
9513 until_break_command (char *arg
, int from_tty
, int anywhere
)
9515 struct symtabs_and_lines sals
;
9516 struct symtab_and_line sal
;
9517 struct frame_info
*frame
= get_selected_frame (NULL
);
9518 struct breakpoint
*breakpoint
;
9519 struct breakpoint
*breakpoint2
= NULL
;
9520 struct cleanup
*old_chain
;
9522 struct thread_info
*tp
;
9524 clear_proceed_status ();
9526 /* Set a breakpoint where the user wants it and at return from
9529 if (last_displayed_sal_is_valid ())
9530 sals
= decode_line_1 (&arg
, DECODE_LINE_FUNFIRSTLINE
,
9531 get_last_displayed_symtab (),
9532 get_last_displayed_line ());
9534 sals
= decode_line_1 (&arg
, DECODE_LINE_FUNFIRSTLINE
,
9535 (struct symtab
*) NULL
, 0);
9537 if (sals
.nelts
!= 1)
9538 error (_("Couldn't get information on specified line."));
9541 xfree (sals
.sals
); /* malloc'd, so freed. */
9544 error (_("Junk at end of arguments."));
9546 resolve_sal_pc (&sal
);
9549 /* If the user told us to continue until a specified location,
9550 we don't specify a frame at which we need to stop. */
9551 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9552 null_frame_id
, bp_until
);
9554 /* Otherwise, specify the selected frame, because we want to stop
9555 only at the very same frame. */
9556 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9557 get_stack_frame_id (frame
),
9560 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
9562 tp
= inferior_thread ();
9565 /* Keep within the current frame, or in frames called by the current
9568 if (frame_id_p (frame_unwind_caller_id (frame
)))
9570 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
9571 sal
.pc
= frame_unwind_caller_pc (frame
);
9572 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
9574 frame_unwind_caller_id (frame
),
9576 make_cleanup_delete_breakpoint (breakpoint2
);
9578 set_longjmp_breakpoint (tp
, frame_unwind_caller_id (frame
));
9579 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
9582 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
9584 /* If we are running asynchronously, and proceed call above has
9585 actually managed to start the target, arrange for breakpoints to
9586 be deleted when the target stops. Otherwise, we're already
9587 stopped and delete breakpoints via cleanup chain. */
9589 if (target_can_async_p () && is_running (inferior_ptid
))
9591 struct until_break_command_continuation_args
*args
;
9592 args
= xmalloc (sizeof (*args
));
9594 args
->breakpoint
= breakpoint
;
9595 args
->breakpoint2
= breakpoint2
;
9596 args
->thread_num
= thread
;
9598 discard_cleanups (old_chain
);
9599 add_continuation (inferior_thread (),
9600 until_break_command_continuation
, args
,
9604 do_cleanups (old_chain
);
9607 /* This function attempts to parse an optional "if <cond>" clause
9608 from the arg string. If one is not found, it returns NULL.
9610 Else, it returns a pointer to the condition string. (It does not
9611 attempt to evaluate the string against a particular block.) And,
9612 it updates arg to point to the first character following the parsed
9613 if clause in the arg string. */
9616 ep_parse_optional_if_clause (char **arg
)
9620 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
9623 /* Skip the "if" keyword. */
9626 /* Skip any extra leading whitespace, and record the start of the
9627 condition string. */
9628 *arg
= skip_spaces (*arg
);
9631 /* Assume that the condition occupies the remainder of the arg
9633 (*arg
) += strlen (cond_string
);
9638 /* Commands to deal with catching events, such as signals, exceptions,
9639 process start/exit, etc. */
9643 catch_fork_temporary
, catch_vfork_temporary
,
9644 catch_fork_permanent
, catch_vfork_permanent
9649 catch_fork_command_1 (char *arg
, int from_tty
,
9650 struct cmd_list_element
*command
)
9652 struct gdbarch
*gdbarch
= get_current_arch ();
9653 char *cond_string
= NULL
;
9654 catch_fork_kind fork_kind
;
9657 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
9658 tempflag
= (fork_kind
== catch_fork_temporary
9659 || fork_kind
== catch_vfork_temporary
);
9663 arg
= skip_spaces (arg
);
9665 /* The allowed syntax is:
9667 catch [v]fork if <cond>
9669 First, check if there's an if clause. */
9670 cond_string
= ep_parse_optional_if_clause (&arg
);
9672 if ((*arg
!= '\0') && !isspace (*arg
))
9673 error (_("Junk at end of arguments."));
9675 /* If this target supports it, create a fork or vfork catchpoint
9676 and enable reporting of such events. */
9679 case catch_fork_temporary
:
9680 case catch_fork_permanent
:
9681 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9682 &catch_fork_breakpoint_ops
);
9684 case catch_vfork_temporary
:
9685 case catch_vfork_permanent
:
9686 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9687 &catch_vfork_breakpoint_ops
);
9690 error (_("unsupported or unknown fork kind; cannot catch it"));
9696 catch_exec_command_1 (char *arg
, int from_tty
,
9697 struct cmd_list_element
*command
)
9699 struct exec_catchpoint
*c
;
9700 struct gdbarch
*gdbarch
= get_current_arch ();
9702 char *cond_string
= NULL
;
9704 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9708 arg
= skip_spaces (arg
);
9710 /* The allowed syntax is:
9712 catch exec if <cond>
9714 First, check if there's an if clause. */
9715 cond_string
= ep_parse_optional_if_clause (&arg
);
9717 if ((*arg
!= '\0') && !isspace (*arg
))
9718 error (_("Junk at end of arguments."));
9720 c
= XNEW (struct exec_catchpoint
);
9721 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
,
9722 &catch_exec_breakpoint_ops
);
9723 c
->exec_pathname
= NULL
;
9725 install_breakpoint (0, &c
->base
, 1);
9728 static enum print_stop_action
9729 print_it_exception_catchpoint (bpstat bs
)
9731 struct ui_out
*uiout
= current_uiout
;
9732 struct breakpoint
*b
= bs
->breakpoint_at
;
9733 int bp_temp
, bp_throw
;
9735 annotate_catchpoint (b
->number
);
9737 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9738 if (b
->loc
->address
!= b
->loc
->requested_address
)
9739 breakpoint_adjustment_warning (b
->loc
->requested_address
,
9742 bp_temp
= b
->disposition
== disp_del
;
9744 bp_temp
? "Temporary catchpoint "
9746 if (!ui_out_is_mi_like_p (uiout
))
9747 ui_out_field_int (uiout
, "bkptno", b
->number
);
9749 bp_throw
? " (exception thrown), "
9750 : " (exception caught), ");
9751 if (ui_out_is_mi_like_p (uiout
))
9753 ui_out_field_string (uiout
, "reason",
9754 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9755 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
9756 ui_out_field_int (uiout
, "bkptno", b
->number
);
9758 return PRINT_SRC_AND_LOC
;
9762 print_one_exception_catchpoint (struct breakpoint
*b
,
9763 struct bp_location
**last_loc
)
9765 struct value_print_options opts
;
9766 struct ui_out
*uiout
= current_uiout
;
9768 get_user_print_options (&opts
);
9769 if (opts
.addressprint
)
9772 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
9773 ui_out_field_string (uiout
, "addr", "<PENDING>");
9775 ui_out_field_core_addr (uiout
, "addr",
9776 b
->loc
->gdbarch
, b
->loc
->address
);
9781 if (strstr (b
->addr_string
, "throw") != NULL
)
9782 ui_out_field_string (uiout
, "what", "exception throw");
9784 ui_out_field_string (uiout
, "what", "exception catch");
9788 print_mention_exception_catchpoint (struct breakpoint
*b
)
9790 struct ui_out
*uiout
= current_uiout
;
9794 bp_temp
= b
->disposition
== disp_del
;
9795 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9796 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
9797 : _("Catchpoint "));
9798 ui_out_field_int (uiout
, "bkptno", b
->number
);
9799 ui_out_text (uiout
, bp_throw
? _(" (throw)")
9803 /* Implement the "print_recreate" breakpoint_ops method for throw and
9804 catch catchpoints. */
9807 print_recreate_exception_catchpoint (struct breakpoint
*b
,
9813 bp_temp
= b
->disposition
== disp_del
;
9814 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9815 fprintf_unfiltered (fp
, bp_temp
? "tcatch " : "catch ");
9816 fprintf_unfiltered (fp
, bp_throw
? "throw" : "catch");
9817 print_recreate_thread (b
, fp
);
9820 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
;
9823 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
9824 enum exception_event_kind ex_event
, int from_tty
)
9826 char *trigger_func_name
;
9828 if (ex_event
== EX_EVENT_CATCH
)
9829 trigger_func_name
= "__cxa_begin_catch";
9831 trigger_func_name
= "__cxa_throw";
9833 create_breakpoint (get_current_arch (),
9834 trigger_func_name
, cond_string
, -1,
9835 0 /* condition and thread are valid. */,
9836 tempflag
, bp_breakpoint
,
9838 AUTO_BOOLEAN_TRUE
/* pending */,
9839 &gnu_v3_exception_catchpoint_ops
, from_tty
,
9846 /* Deal with "catch catch" and "catch throw" commands. */
9849 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
9850 int tempflag
, int from_tty
)
9852 char *cond_string
= NULL
;
9856 arg
= skip_spaces (arg
);
9858 cond_string
= ep_parse_optional_if_clause (&arg
);
9860 if ((*arg
!= '\0') && !isspace (*arg
))
9861 error (_("Junk at end of arguments."));
9863 if (ex_event
!= EX_EVENT_THROW
9864 && ex_event
!= EX_EVENT_CATCH
)
9865 error (_("Unsupported or unknown exception event; cannot catch it"));
9867 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
9870 warning (_("Unsupported with this platform/compiler combination."));
9873 /* Implementation of "catch catch" command. */
9876 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9878 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9880 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
9883 /* Implementation of "catch throw" command. */
9886 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9888 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9890 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
9894 init_ada_exception_breakpoint (struct breakpoint
*b
,
9895 struct gdbarch
*gdbarch
,
9896 struct symtab_and_line sal
,
9898 const struct breakpoint_ops
*ops
,
9904 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9906 loc_gdbarch
= gdbarch
;
9908 describe_other_breakpoints (loc_gdbarch
,
9909 sal
.pspace
, sal
.pc
, sal
.section
, -1);
9910 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
9911 version for exception catchpoints, because two catchpoints
9912 used for different exception names will use the same address.
9913 In this case, a "breakpoint ... also set at..." warning is
9914 unproductive. Besides, the warning phrasing is also a bit
9915 inappropriate, we should use the word catchpoint, and tell
9916 the user what type of catchpoint it is. The above is good
9917 enough for now, though. */
9920 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
9922 b
->enable_state
= bp_enabled
;
9923 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9924 b
->addr_string
= addr_string
;
9925 b
->language
= language_ada
;
9928 /* Splits the argument using space as delimiter. Returns an xmalloc'd
9929 filter list, or NULL if no filtering is required. */
9931 catch_syscall_split_args (char *arg
)
9933 VEC(int) *result
= NULL
;
9934 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (int), &result
);
9936 while (*arg
!= '\0')
9938 int i
, syscall_number
;
9943 /* Skip whitespace. */
9944 while (isspace (*arg
))
9947 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
9948 cur_name
[i
] = arg
[i
];
9952 /* Check if the user provided a syscall name or a number. */
9953 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
9954 if (*endptr
== '\0')
9955 get_syscall_by_number (syscall_number
, &s
);
9958 /* We have a name. Let's check if it's valid and convert it
9960 get_syscall_by_name (cur_name
, &s
);
9962 if (s
.number
== UNKNOWN_SYSCALL
)
9963 /* Here we have to issue an error instead of a warning,
9964 because GDB cannot do anything useful if there's no
9965 syscall number to be caught. */
9966 error (_("Unknown syscall name '%s'."), cur_name
);
9969 /* Ok, it's valid. */
9970 VEC_safe_push (int, result
, s
.number
);
9973 discard_cleanups (cleanup
);
9977 /* Implement the "catch syscall" command. */
9980 catch_syscall_command_1 (char *arg
, int from_tty
,
9981 struct cmd_list_element
*command
)
9986 struct gdbarch
*gdbarch
= get_current_arch ();
9988 /* Checking if the feature if supported. */
9989 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
9990 error (_("The feature 'catch syscall' is not supported on \
9991 this architecture yet."));
9993 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9995 arg
= skip_spaces (arg
);
9997 /* We need to do this first "dummy" translation in order
9998 to get the syscall XML file loaded or, most important,
9999 to display a warning to the user if there's no XML file
10000 for his/her architecture. */
10001 get_syscall_by_number (0, &s
);
10003 /* The allowed syntax is:
10005 catch syscall <name | number> [<name | number> ... <name | number>]
10007 Let's check if there's a syscall name. */
10010 filter
= catch_syscall_split_args (arg
);
10014 create_syscall_event_catchpoint (tempflag
, filter
,
10015 &catch_syscall_breakpoint_ops
);
10019 catch_command (char *arg
, int from_tty
)
10021 error (_("Catch requires an event name."));
10026 tcatch_command (char *arg
, int from_tty
)
10028 error (_("Catch requires an event name."));
10031 /* A qsort comparison function that sorts breakpoints in order. */
10034 compare_breakpoints (const void *a
, const void *b
)
10036 const breakpoint_p
*ba
= a
;
10037 uintptr_t ua
= (uintptr_t) *ba
;
10038 const breakpoint_p
*bb
= b
;
10039 uintptr_t ub
= (uintptr_t) *bb
;
10041 if ((*ba
)->number
< (*bb
)->number
)
10043 else if ((*ba
)->number
> (*bb
)->number
)
10046 /* Now sort by address, in case we see, e..g, two breakpoints with
10050 return ub
> ub
? 1 : 0;
10053 /* Delete breakpoints by address or line. */
10056 clear_command (char *arg
, int from_tty
)
10058 struct breakpoint
*b
, *prev
;
10059 VEC(breakpoint_p
) *found
= 0;
10062 struct symtabs_and_lines sals
;
10063 struct symtab_and_line sal
;
10065 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
10069 sals
= decode_line_spec (arg
, (DECODE_LINE_FUNFIRSTLINE
10070 | DECODE_LINE_LIST_MODE
));
10075 sals
.sals
= (struct symtab_and_line
*)
10076 xmalloc (sizeof (struct symtab_and_line
));
10077 make_cleanup (xfree
, sals
.sals
);
10078 init_sal (&sal
); /* Initialize to zeroes. */
10080 /* Set sal's line, symtab, pc, and pspace to the values
10081 corresponding to the last call to print_frame_info. If the
10082 codepoint is not valid, this will set all the fields to 0. */
10083 get_last_displayed_sal (&sal
);
10084 if (sal
.symtab
== 0)
10085 error (_("No source file specified."));
10087 sals
.sals
[0] = sal
;
10093 /* We don't call resolve_sal_pc here. That's not as bad as it
10094 seems, because all existing breakpoints typically have both
10095 file/line and pc set. So, if clear is given file/line, we can
10096 match this to existing breakpoint without obtaining pc at all.
10098 We only support clearing given the address explicitly
10099 present in breakpoint table. Say, we've set breakpoint
10100 at file:line. There were several PC values for that file:line,
10101 due to optimization, all in one block.
10103 We've picked one PC value. If "clear" is issued with another
10104 PC corresponding to the same file:line, the breakpoint won't
10105 be cleared. We probably can still clear the breakpoint, but
10106 since the other PC value is never presented to user, user
10107 can only find it by guessing, and it does not seem important
10108 to support that. */
10110 /* For each line spec given, delete bps which correspond to it. Do
10111 it in two passes, solely to preserve the current behavior that
10112 from_tty is forced true if we delete more than one
10116 make_cleanup (VEC_cleanup (breakpoint_p
), &found
);
10117 for (i
= 0; i
< sals
.nelts
; i
++)
10119 /* If exact pc given, clear bpts at that pc.
10120 If line given (pc == 0), clear all bpts on specified line.
10121 If defaulting, clear all bpts on default line
10124 defaulting sal.pc != 0 tests to do
10129 1 0 <can't happen> */
10131 sal
= sals
.sals
[i
];
10133 /* Find all matching breakpoints and add them to 'found'. */
10134 ALL_BREAKPOINTS (b
)
10137 /* Are we going to delete b? */
10138 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
10140 struct bp_location
*loc
= b
->loc
;
10141 for (; loc
; loc
= loc
->next
)
10143 /* If the user specified file:line, don't allow a PC
10144 match. This matches historical gdb behavior. */
10145 int pc_match
= (!sal
.explicit_line
10147 && (loc
->pspace
== sal
.pspace
)
10148 && (loc
->address
== sal
.pc
)
10149 && (!section_is_overlay (loc
->section
)
10150 || loc
->section
== sal
.section
));
10151 int line_match
= ((default_match
|| sal
.explicit_line
)
10152 && loc
->source_file
!= NULL
10153 && sal
.symtab
!= NULL
10154 && sal
.pspace
== loc
->pspace
10155 && filename_cmp (loc
->source_file
,
10156 sal
.symtab
->filename
) == 0
10157 && loc
->line_number
== sal
.line
);
10158 if (pc_match
|| line_match
)
10167 VEC_safe_push(breakpoint_p
, found
, b
);
10171 /* Now go thru the 'found' chain and delete them. */
10172 if (VEC_empty(breakpoint_p
, found
))
10175 error (_("No breakpoint at %s."), arg
);
10177 error (_("No breakpoint at this line."));
10180 /* Remove duplicates from the vec. */
10181 qsort (VEC_address (breakpoint_p
, found
),
10182 VEC_length (breakpoint_p
, found
),
10183 sizeof (breakpoint_p
),
10184 compare_breakpoints
);
10185 prev
= VEC_index (breakpoint_p
, found
, 0);
10186 for (ix
= 1; VEC_iterate (breakpoint_p
, found
, ix
, b
); ++ix
)
10190 VEC_ordered_remove (breakpoint_p
, found
, ix
);
10195 if (VEC_length(breakpoint_p
, found
) > 1)
10196 from_tty
= 1; /* Always report if deleted more than one. */
10199 if (VEC_length(breakpoint_p
, found
) == 1)
10200 printf_unfiltered (_("Deleted breakpoint "));
10202 printf_unfiltered (_("Deleted breakpoints "));
10204 breakpoints_changed ();
10206 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
10209 printf_unfiltered ("%d ", b
->number
);
10210 delete_breakpoint (b
);
10213 putchar_unfiltered ('\n');
10215 do_cleanups (cleanups
);
10218 /* Delete breakpoint in BS if they are `delete' breakpoints and
10219 all breakpoints that are marked for deletion, whether hit or not.
10220 This is called after any breakpoint is hit, or after errors. */
10223 breakpoint_auto_delete (bpstat bs
)
10225 struct breakpoint
*b
, *b_tmp
;
10227 for (; bs
; bs
= bs
->next
)
10228 if (bs
->breakpoint_at
10229 && bs
->breakpoint_at
->disposition
== disp_del
10231 delete_breakpoint (bs
->breakpoint_at
);
10233 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10235 if (b
->disposition
== disp_del_at_next_stop
)
10236 delete_breakpoint (b
);
10240 /* A comparison function for bp_location AP and BP being interfaced to
10241 qsort. Sort elements primarily by their ADDRESS (no matter what
10242 does breakpoint_address_is_meaningful say for its OWNER),
10243 secondarily by ordering first bp_permanent OWNERed elements and
10244 terciarily just ensuring the array is sorted stable way despite
10245 qsort being an unstable algorithm. */
10248 bp_location_compare (const void *ap
, const void *bp
)
10250 struct bp_location
*a
= *(void **) ap
;
10251 struct bp_location
*b
= *(void **) bp
;
10252 /* A and B come from existing breakpoints having non-NULL OWNER. */
10253 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
10254 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
10256 if (a
->address
!= b
->address
)
10257 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
10259 /* Sort permanent breakpoints first. */
10260 if (a_perm
!= b_perm
)
10261 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
10263 /* Make the user-visible order stable across GDB runs. Locations of
10264 the same breakpoint can be sorted in arbitrary order. */
10266 if (a
->owner
->number
!= b
->owner
->number
)
10267 return (a
->owner
->number
> b
->owner
->number
)
10268 - (a
->owner
->number
< b
->owner
->number
);
10270 return (a
> b
) - (a
< b
);
10273 /* Set bp_location_placed_address_before_address_max and
10274 bp_location_shadow_len_after_address_max according to the current
10275 content of the bp_location array. */
10278 bp_location_target_extensions_update (void)
10280 struct bp_location
*bl
, **blp_tmp
;
10282 bp_location_placed_address_before_address_max
= 0;
10283 bp_location_shadow_len_after_address_max
= 0;
10285 ALL_BP_LOCATIONS (bl
, blp_tmp
)
10287 CORE_ADDR start
, end
, addr
;
10289 if (!bp_location_has_shadow (bl
))
10292 start
= bl
->target_info
.placed_address
;
10293 end
= start
+ bl
->target_info
.shadow_len
;
10295 gdb_assert (bl
->address
>= start
);
10296 addr
= bl
->address
- start
;
10297 if (addr
> bp_location_placed_address_before_address_max
)
10298 bp_location_placed_address_before_address_max
= addr
;
10300 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
10302 gdb_assert (bl
->address
< end
);
10303 addr
= end
- bl
->address
;
10304 if (addr
> bp_location_shadow_len_after_address_max
)
10305 bp_location_shadow_len_after_address_max
= addr
;
10309 /* Download tracepoint locations if they haven't been. */
10312 download_tracepoint_locations (void)
10314 struct bp_location
*bl
, **blp_tmp
;
10315 struct cleanup
*old_chain
;
10317 if (!target_can_download_tracepoint ())
10320 old_chain
= save_current_space_and_thread ();
10322 ALL_BP_LOCATIONS (bl
, blp_tmp
)
10324 struct tracepoint
*t
;
10326 if (!is_tracepoint (bl
->owner
))
10329 if ((bl
->owner
->type
== bp_fast_tracepoint
10330 ? !may_insert_fast_tracepoints
10331 : !may_insert_tracepoints
))
10334 /* In tracepoint, locations are _never_ duplicated, so
10335 should_be_inserted is equivalent to
10336 unduplicated_should_be_inserted. */
10337 if (!should_be_inserted (bl
) || bl
->inserted
)
10340 switch_to_program_space_and_thread (bl
->pspace
);
10342 target_download_tracepoint (bl
);
10345 t
= (struct tracepoint
*) bl
->owner
;
10346 t
->number_on_target
= bl
->owner
->number
;
10349 do_cleanups (old_chain
);
10352 /* Swap the insertion/duplication state between two locations. */
10355 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
10357 const int left_inserted
= left
->inserted
;
10358 const int left_duplicate
= left
->duplicate
;
10359 const struct bp_target_info left_target_info
= left
->target_info
;
10361 /* Locations of tracepoints can never be duplicated. */
10362 if (is_tracepoint (left
->owner
))
10363 gdb_assert (!left
->duplicate
);
10364 if (is_tracepoint (right
->owner
))
10365 gdb_assert (!right
->duplicate
);
10367 left
->inserted
= right
->inserted
;
10368 left
->duplicate
= right
->duplicate
;
10369 left
->target_info
= right
->target_info
;
10370 right
->inserted
= left_inserted
;
10371 right
->duplicate
= left_duplicate
;
10372 right
->target_info
= left_target_info
;
10375 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
10376 into the inferior, only remove already-inserted locations that no
10377 longer should be inserted. Functions that delete a breakpoint or
10378 breakpoints should pass false, so that deleting a breakpoint
10379 doesn't have the side effect of inserting the locations of other
10380 breakpoints that are marked not-inserted, but should_be_inserted
10381 returns true on them.
10383 This behaviour is useful is situations close to tear-down -- e.g.,
10384 after an exec, while the target still has execution, but breakpoint
10385 shadows of the previous executable image should *NOT* be restored
10386 to the new image; or before detaching, where the target still has
10387 execution and wants to delete breakpoints from GDB's lists, and all
10388 breakpoints had already been removed from the inferior. */
10391 update_global_location_list (int should_insert
)
10393 struct breakpoint
*b
;
10394 struct bp_location
**locp
, *loc
;
10395 struct cleanup
*cleanups
;
10397 /* Used in the duplicates detection below. When iterating over all
10398 bp_locations, points to the first bp_location of a given address.
10399 Breakpoints and watchpoints of different types are never
10400 duplicates of each other. Keep one pointer for each type of
10401 breakpoint/watchpoint, so we only need to loop over all locations
10403 struct bp_location
*bp_loc_first
; /* breakpoint */
10404 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
10405 struct bp_location
*awp_loc_first
; /* access watchpoint */
10406 struct bp_location
*rwp_loc_first
; /* read watchpoint */
10408 /* Saved former bp_location array which we compare against the newly
10409 built bp_location from the current state of ALL_BREAKPOINTS. */
10410 struct bp_location
**old_location
, **old_locp
;
10411 unsigned old_location_count
;
10413 old_location
= bp_location
;
10414 old_location_count
= bp_location_count
;
10415 bp_location
= NULL
;
10416 bp_location_count
= 0;
10417 cleanups
= make_cleanup (xfree
, old_location
);
10419 ALL_BREAKPOINTS (b
)
10420 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10421 bp_location_count
++;
10423 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
10424 locp
= bp_location
;
10425 ALL_BREAKPOINTS (b
)
10426 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10428 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
10429 bp_location_compare
);
10431 bp_location_target_extensions_update ();
10433 /* Identify bp_location instances that are no longer present in the
10434 new list, and therefore should be freed. Note that it's not
10435 necessary that those locations should be removed from inferior --
10436 if there's another location at the same address (previously
10437 marked as duplicate), we don't need to remove/insert the
10440 LOCP is kept in sync with OLD_LOCP, each pointing to the current
10441 and former bp_location array state respectively. */
10443 locp
= bp_location
;
10444 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
10447 struct bp_location
*old_loc
= *old_locp
;
10448 struct bp_location
**loc2p
;
10450 /* Tells if 'old_loc' is found among the new locations. If
10451 not, we have to free it. */
10452 int found_object
= 0;
10453 /* Tells if the location should remain inserted in the target. */
10454 int keep_in_target
= 0;
10457 /* Skip LOCP entries which will definitely never be needed.
10458 Stop either at or being the one matching OLD_LOC. */
10459 while (locp
< bp_location
+ bp_location_count
10460 && (*locp
)->address
< old_loc
->address
)
10464 (loc2p
< bp_location
+ bp_location_count
10465 && (*loc2p
)->address
== old_loc
->address
);
10468 if (*loc2p
== old_loc
)
10475 /* If this location is no longer present, and inserted, look if
10476 there's maybe a new location at the same address. If so,
10477 mark that one inserted, and don't remove this one. This is
10478 needed so that we don't have a time window where a breakpoint
10479 at certain location is not inserted. */
10481 if (old_loc
->inserted
)
10483 /* If the location is inserted now, we might have to remove
10486 if (found_object
&& should_be_inserted (old_loc
))
10488 /* The location is still present in the location list,
10489 and still should be inserted. Don't do anything. */
10490 keep_in_target
= 1;
10494 /* The location is either no longer present, or got
10495 disabled. See if there's another location at the
10496 same address, in which case we don't need to remove
10497 this one from the target. */
10499 /* OLD_LOC comes from existing struct breakpoint. */
10500 if (breakpoint_address_is_meaningful (old_loc
->owner
))
10503 (loc2p
< bp_location
+ bp_location_count
10504 && (*loc2p
)->address
== old_loc
->address
);
10507 struct bp_location
*loc2
= *loc2p
;
10509 if (breakpoint_locations_match (loc2
, old_loc
))
10511 /* Read watchpoint locations are switched to
10512 access watchpoints, if the former are not
10513 supported, but the latter are. */
10514 if (is_hardware_watchpoint (old_loc
->owner
))
10516 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
10517 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
10520 /* loc2 is a duplicated location. We need to check
10521 if it should be inserted in case it will be
10523 if (loc2
!= old_loc
10524 && unduplicated_should_be_inserted (loc2
))
10526 swap_insertion (old_loc
, loc2
);
10527 keep_in_target
= 1;
10535 if (!keep_in_target
)
10537 if (remove_breakpoint (old_loc
, mark_uninserted
))
10539 /* This is just about all we can do. We could keep
10540 this location on the global list, and try to
10541 remove it next time, but there's no particular
10542 reason why we will succeed next time.
10544 Note that at this point, old_loc->owner is still
10545 valid, as delete_breakpoint frees the breakpoint
10546 only after calling us. */
10547 printf_filtered (_("warning: Error removing "
10548 "breakpoint %d\n"),
10549 old_loc
->owner
->number
);
10557 if (removed
&& non_stop
10558 && breakpoint_address_is_meaningful (old_loc
->owner
)
10559 && !is_hardware_watchpoint (old_loc
->owner
))
10561 /* This location was removed from the target. In
10562 non-stop mode, a race condition is possible where
10563 we've removed a breakpoint, but stop events for that
10564 breakpoint are already queued and will arrive later.
10565 We apply an heuristic to be able to distinguish such
10566 SIGTRAPs from other random SIGTRAPs: we keep this
10567 breakpoint location for a bit, and will retire it
10568 after we see some number of events. The theory here
10569 is that reporting of events should, "on the average",
10570 be fair, so after a while we'll see events from all
10571 threads that have anything of interest, and no longer
10572 need to keep this breakpoint location around. We
10573 don't hold locations forever so to reduce chances of
10574 mistaking a non-breakpoint SIGTRAP for a breakpoint
10577 The heuristic failing can be disastrous on
10578 decr_pc_after_break targets.
10580 On decr_pc_after_break targets, like e.g., x86-linux,
10581 if we fail to recognize a late breakpoint SIGTRAP,
10582 because events_till_retirement has reached 0 too
10583 soon, we'll fail to do the PC adjustment, and report
10584 a random SIGTRAP to the user. When the user resumes
10585 the inferior, it will most likely immediately crash
10586 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
10587 corrupted, because of being resumed e.g., in the
10588 middle of a multi-byte instruction, or skipped a
10589 one-byte instruction. This was actually seen happen
10590 on native x86-linux, and should be less rare on
10591 targets that do not support new thread events, like
10592 remote, due to the heuristic depending on
10595 Mistaking a random SIGTRAP for a breakpoint trap
10596 causes similar symptoms (PC adjustment applied when
10597 it shouldn't), but then again, playing with SIGTRAPs
10598 behind the debugger's back is asking for trouble.
10600 Since hardware watchpoint traps are always
10601 distinguishable from other traps, so we don't need to
10602 apply keep hardware watchpoint moribund locations
10603 around. We simply always ignore hardware watchpoint
10604 traps we can no longer explain. */
10606 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
10607 old_loc
->owner
= NULL
;
10609 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
10613 old_loc
->owner
= NULL
;
10614 decref_bp_location (&old_loc
);
10619 /* Rescan breakpoints at the same address and section, marking the
10620 first one as "first" and any others as "duplicates". This is so
10621 that the bpt instruction is only inserted once. If we have a
10622 permanent breakpoint at the same place as BPT, make that one the
10623 official one, and the rest as duplicates. Permanent breakpoints
10624 are sorted first for the same address.
10626 Do the same for hardware watchpoints, but also considering the
10627 watchpoint's type (regular/access/read) and length. */
10629 bp_loc_first
= NULL
;
10630 wp_loc_first
= NULL
;
10631 awp_loc_first
= NULL
;
10632 rwp_loc_first
= NULL
;
10633 ALL_BP_LOCATIONS (loc
, locp
)
10635 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
10637 struct bp_location
**loc_first_p
;
10640 if (!should_be_inserted (loc
)
10641 || !breakpoint_address_is_meaningful (b
)
10642 /* Don't detect duplicate for tracepoint locations because they are
10643 never duplicated. See the comments in field `duplicate' of
10644 `struct bp_location'. */
10645 || is_tracepoint (b
))
10648 /* Permanent breakpoint should always be inserted. */
10649 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
10650 internal_error (__FILE__
, __LINE__
,
10651 _("allegedly permanent breakpoint is not "
10652 "actually inserted"));
10654 if (b
->type
== bp_hardware_watchpoint
)
10655 loc_first_p
= &wp_loc_first
;
10656 else if (b
->type
== bp_read_watchpoint
)
10657 loc_first_p
= &rwp_loc_first
;
10658 else if (b
->type
== bp_access_watchpoint
)
10659 loc_first_p
= &awp_loc_first
;
10661 loc_first_p
= &bp_loc_first
;
10663 if (*loc_first_p
== NULL
10664 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
10665 || !breakpoint_locations_match (loc
, *loc_first_p
))
10667 *loc_first_p
= loc
;
10668 loc
->duplicate
= 0;
10673 /* This and the above ensure the invariant that the first location
10674 is not duplicated, and is the inserted one.
10675 All following are marked as duplicated, and are not inserted. */
10677 swap_insertion (loc
, *loc_first_p
);
10678 loc
->duplicate
= 1;
10680 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
10681 && b
->enable_state
!= bp_permanent
)
10682 internal_error (__FILE__
, __LINE__
,
10683 _("another breakpoint was inserted on top of "
10684 "a permanent breakpoint"));
10687 if (breakpoints_always_inserted_mode () && should_insert
10688 && (have_live_inferiors ()
10689 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
10690 insert_breakpoint_locations ();
10693 download_tracepoint_locations ();
10695 do_cleanups (cleanups
);
10699 breakpoint_retire_moribund (void)
10701 struct bp_location
*loc
;
10704 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
10705 if (--(loc
->events_till_retirement
) == 0)
10707 decref_bp_location (&loc
);
10708 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
10714 update_global_location_list_nothrow (int inserting
)
10716 struct gdb_exception e
;
10718 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10719 update_global_location_list (inserting
);
10722 /* Clear BKP from a BPS. */
10725 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
10729 for (bs
= bps
; bs
; bs
= bs
->next
)
10730 if (bs
->breakpoint_at
== bpt
)
10732 bs
->breakpoint_at
= NULL
;
10733 bs
->old_val
= NULL
;
10734 /* bs->commands will be freed later. */
10738 /* Callback for iterate_over_threads. */
10740 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
10742 struct breakpoint
*bpt
= data
;
10744 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
10748 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
10752 say_where (struct breakpoint
*b
)
10754 struct ui_out
*uiout
= current_uiout
;
10755 struct value_print_options opts
;
10757 get_user_print_options (&opts
);
10759 /* i18n: cagney/2005-02-11: Below needs to be merged into a
10761 if (b
->loc
== NULL
)
10763 printf_filtered (_(" (%s) pending."), b
->addr_string
);
10767 if (opts
.addressprint
|| b
->loc
->source_file
== NULL
)
10769 printf_filtered (" at ");
10770 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
10773 if (b
->loc
->source_file
)
10775 /* If there is a single location, we can print the location
10777 if (b
->loc
->next
== NULL
)
10778 printf_filtered (": file %s, line %d.",
10779 b
->loc
->source_file
, b
->loc
->line_number
);
10781 /* This is not ideal, but each location may have a
10782 different file name, and this at least reflects the
10783 real situation somewhat. */
10784 printf_filtered (": %s.", b
->addr_string
);
10789 struct bp_location
*loc
= b
->loc
;
10791 for (; loc
; loc
= loc
->next
)
10793 printf_filtered (" (%d locations)", n
);
10798 /* Default bp_location_ops methods. */
10801 bp_location_dtor (struct bp_location
*self
)
10803 xfree (self
->cond
);
10804 xfree (self
->function_name
);
10805 xfree (self
->source_file
);
10808 static const struct bp_location_ops bp_location_ops
=
10813 /* Default breakpoint_ops methods all breakpoint_ops ultimately
10817 base_breakpoint_dtor (struct breakpoint
*self
)
10819 decref_counted_command_line (&self
->commands
);
10820 xfree (self
->cond_string
);
10821 xfree (self
->addr_string
);
10822 xfree (self
->filter
);
10823 xfree (self
->addr_string_range_end
);
10826 static struct bp_location
*
10827 base_breakpoint_allocate_location (struct breakpoint
*self
)
10829 struct bp_location
*loc
;
10831 loc
= XNEW (struct bp_location
);
10832 init_bp_location (loc
, &bp_location_ops
, self
);
10837 base_breakpoint_re_set (struct breakpoint
*b
)
10839 /* Nothing to re-set. */
10842 #define internal_error_pure_virtual_called() \
10843 gdb_assert_not_reached ("pure virtual function called")
10846 base_breakpoint_insert_location (struct bp_location
*bl
)
10848 internal_error_pure_virtual_called ();
10852 base_breakpoint_remove_location (struct bp_location
*bl
)
10854 internal_error_pure_virtual_called ();
10858 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
10859 struct address_space
*aspace
,
10862 internal_error_pure_virtual_called ();
10866 base_breakpoint_check_status (bpstat bs
)
10871 /* A "works_in_software_mode" breakpoint_ops method that just internal
10875 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
10877 internal_error_pure_virtual_called ();
10880 /* A "resources_needed" breakpoint_ops method that just internal
10884 base_breakpoint_resources_needed (const struct bp_location
*bl
)
10886 internal_error_pure_virtual_called ();
10889 static enum print_stop_action
10890 base_breakpoint_print_it (bpstat bs
)
10892 internal_error_pure_virtual_called ();
10896 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
10897 struct ui_out
*uiout
)
10903 base_breakpoint_print_mention (struct breakpoint
*b
)
10905 internal_error_pure_virtual_called ();
10909 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
10911 internal_error_pure_virtual_called ();
10914 static struct breakpoint_ops base_breakpoint_ops
=
10916 base_breakpoint_dtor
,
10917 base_breakpoint_allocate_location
,
10918 base_breakpoint_re_set
,
10919 base_breakpoint_insert_location
,
10920 base_breakpoint_remove_location
,
10921 base_breakpoint_breakpoint_hit
,
10922 base_breakpoint_check_status
,
10923 base_breakpoint_resources_needed
,
10924 base_breakpoint_works_in_software_mode
,
10925 base_breakpoint_print_it
,
10927 base_breakpoint_print_one_detail
,
10928 base_breakpoint_print_mention
,
10929 base_breakpoint_print_recreate
10932 /* Default breakpoint_ops methods. */
10935 bkpt_re_set (struct breakpoint
*b
)
10937 /* FIXME: is this still reachable? */
10938 if (b
->addr_string
== NULL
)
10940 /* Anything without a string can't be re-set. */
10941 delete_breakpoint (b
);
10945 breakpoint_re_set_default (b
);
10949 bkpt_insert_location (struct bp_location
*bl
)
10951 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
10952 return target_insert_hw_breakpoint (bl
->gdbarch
,
10955 return target_insert_breakpoint (bl
->gdbarch
,
10960 bkpt_remove_location (struct bp_location
*bl
)
10962 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
10963 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
10965 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
);
10969 bkpt_breakpoint_hit (const struct bp_location
*bl
,
10970 struct address_space
*aspace
, CORE_ADDR bp_addr
)
10972 struct breakpoint
*b
= bl
->owner
;
10974 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
10978 if (overlay_debugging
/* unmapped overlay section */
10979 && section_is_overlay (bl
->section
)
10980 && !section_is_mapped (bl
->section
))
10987 bkpt_resources_needed (const struct bp_location
*bl
)
10989 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
10994 static enum print_stop_action
10995 bkpt_print_it (bpstat bs
)
10997 struct breakpoint
*b
;
10998 const struct bp_location
*bl
;
11000 struct ui_out
*uiout
= current_uiout
;
11002 gdb_assert (bs
->bp_location_at
!= NULL
);
11004 bl
= bs
->bp_location_at
;
11005 b
= bs
->breakpoint_at
;
11007 bp_temp
= b
->disposition
== disp_del
;
11008 if (bl
->address
!= bl
->requested_address
)
11009 breakpoint_adjustment_warning (bl
->requested_address
,
11012 annotate_breakpoint (b
->number
);
11014 ui_out_text (uiout
, "\nTemporary breakpoint ");
11016 ui_out_text (uiout
, "\nBreakpoint ");
11017 if (ui_out_is_mi_like_p (uiout
))
11019 ui_out_field_string (uiout
, "reason",
11020 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
11021 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
11023 ui_out_field_int (uiout
, "bkptno", b
->number
);
11024 ui_out_text (uiout
, ", ");
11026 return PRINT_SRC_AND_LOC
;
11030 bkpt_print_mention (struct breakpoint
*b
)
11032 if (ui_out_is_mi_like_p (current_uiout
))
11037 case bp_breakpoint
:
11038 case bp_gnu_ifunc_resolver
:
11039 if (b
->disposition
== disp_del
)
11040 printf_filtered (_("Temporary breakpoint"));
11042 printf_filtered (_("Breakpoint"));
11043 printf_filtered (_(" %d"), b
->number
);
11044 if (b
->type
== bp_gnu_ifunc_resolver
)
11045 printf_filtered (_(" at gnu-indirect-function resolver"));
11047 case bp_hardware_breakpoint
:
11048 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
11056 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
11058 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
11059 fprintf_unfiltered (fp
, "tbreak");
11060 else if (tp
->type
== bp_breakpoint
)
11061 fprintf_unfiltered (fp
, "break");
11062 else if (tp
->type
== bp_hardware_breakpoint
11063 && tp
->disposition
== disp_del
)
11064 fprintf_unfiltered (fp
, "thbreak");
11065 else if (tp
->type
== bp_hardware_breakpoint
)
11066 fprintf_unfiltered (fp
, "hbreak");
11068 internal_error (__FILE__
, __LINE__
,
11069 _("unhandled breakpoint type %d"), (int) tp
->type
);
11071 fprintf_unfiltered (fp
, " %s", tp
->addr_string
);
11072 print_recreate_thread (tp
, fp
);
11075 /* Virtual table for internal breakpoints. */
11078 internal_bkpt_re_set (struct breakpoint
*b
)
11082 /* Delete overlay event and longjmp master breakpoints; they
11083 will be reset later by breakpoint_re_set. */
11084 case bp_overlay_event
:
11085 case bp_longjmp_master
:
11086 case bp_std_terminate_master
:
11087 case bp_exception_master
:
11088 delete_breakpoint (b
);
11091 /* This breakpoint is special, it's set up when the inferior
11092 starts and we really don't want to touch it. */
11093 case bp_shlib_event
:
11095 /* Like bp_shlib_event, this breakpoint type is special. Once
11096 it is set up, we do not want to touch it. */
11097 case bp_thread_event
:
11103 internal_bkpt_check_status (bpstat bs
)
11105 /* We do not stop for these. */
11109 static enum print_stop_action
11110 internal_bkpt_print_it (bpstat bs
)
11112 struct ui_out
*uiout
= current_uiout
;
11113 struct breakpoint
*b
;
11115 b
= bs
->breakpoint_at
;
11119 case bp_shlib_event
:
11120 /* Did we stop because the user set the stop_on_solib_events
11121 variable? (If so, we report this as a generic, "Stopped due
11122 to shlib event" message.) */
11123 ui_out_text (uiout
, _("Stopped due to shared library event\n"));
11124 if (ui_out_is_mi_like_p (uiout
))
11125 ui_out_field_string (uiout
, "reason",
11126 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
11129 case bp_thread_event
:
11130 /* Not sure how we will get here.
11131 GDB should not stop for these breakpoints. */
11132 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
11135 case bp_overlay_event
:
11136 /* By analogy with the thread event, GDB should not stop for these. */
11137 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
11140 case bp_longjmp_master
:
11141 /* These should never be enabled. */
11142 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
11145 case bp_std_terminate_master
:
11146 /* These should never be enabled. */
11147 printf_filtered (_("std::terminate Master Breakpoint: "
11148 "gdb should not stop!\n"));
11151 case bp_exception_master
:
11152 /* These should never be enabled. */
11153 printf_filtered (_("Exception Master Breakpoint: "
11154 "gdb should not stop!\n"));
11158 return PRINT_NOTHING
;
11162 internal_bkpt_print_mention (struct breakpoint
*b
)
11164 /* Nothing to mention. These breakpoints are internal. */
11167 /* Virtual table for momentary breakpoints */
11170 momentary_bkpt_re_set (struct breakpoint
*b
)
11172 /* Keep temporary breakpoints, which can be encountered when we step
11173 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
11174 Otherwise these should have been blown away via the cleanup chain
11175 or by breakpoint_init_inferior when we rerun the executable. */
11179 momentary_bkpt_check_status (bpstat bs
)
11181 /* Nothing. The point of these breakpoints is causing a stop. */
11184 static enum print_stop_action
11185 momentary_bkpt_print_it (bpstat bs
)
11187 struct ui_out
*uiout
= current_uiout
;
11189 if (ui_out_is_mi_like_p (uiout
))
11191 struct breakpoint
*b
= bs
->breakpoint_at
;
11196 ui_out_field_string
11198 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
11202 ui_out_field_string
11204 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
11209 return PRINT_UNKNOWN
;
11213 momentary_bkpt_print_mention (struct breakpoint
*b
)
11215 /* Nothing to mention. These breakpoints are internal. */
11218 /* The breakpoint_ops structure to be used in tracepoints. */
11221 tracepoint_re_set (struct breakpoint
*b
)
11223 breakpoint_re_set_default (b
);
11227 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
11228 struct address_space
*aspace
, CORE_ADDR bp_addr
)
11230 /* By definition, the inferior does not report stops at
11236 tracepoint_print_one_detail (const struct breakpoint
*self
,
11237 struct ui_out
*uiout
)
11239 struct tracepoint
*tp
= (struct tracepoint
*) self
;
11240 if (tp
->static_trace_marker_id
)
11242 gdb_assert (self
->type
== bp_static_tracepoint
);
11244 ui_out_text (uiout
, "\tmarker id is ");
11245 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
11246 tp
->static_trace_marker_id
);
11247 ui_out_text (uiout
, "\n");
11252 tracepoint_print_mention (struct breakpoint
*b
)
11254 if (ui_out_is_mi_like_p (current_uiout
))
11259 case bp_tracepoint
:
11260 printf_filtered (_("Tracepoint"));
11261 printf_filtered (_(" %d"), b
->number
);
11263 case bp_fast_tracepoint
:
11264 printf_filtered (_("Fast tracepoint"));
11265 printf_filtered (_(" %d"), b
->number
);
11267 case bp_static_tracepoint
:
11268 printf_filtered (_("Static tracepoint"));
11269 printf_filtered (_(" %d"), b
->number
);
11272 internal_error (__FILE__
, __LINE__
,
11273 _("unhandled tracepoint type %d"), (int) b
->type
);
11280 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
11282 struct tracepoint
*tp
= (struct tracepoint
*) self
;
11284 if (self
->type
== bp_fast_tracepoint
)
11285 fprintf_unfiltered (fp
, "ftrace");
11286 if (self
->type
== bp_static_tracepoint
)
11287 fprintf_unfiltered (fp
, "strace");
11288 else if (self
->type
== bp_tracepoint
)
11289 fprintf_unfiltered (fp
, "trace");
11291 internal_error (__FILE__
, __LINE__
,
11292 _("unhandled tracepoint type %d"), (int) self
->type
);
11294 fprintf_unfiltered (fp
, " %s", self
->addr_string
);
11295 print_recreate_thread (self
, fp
);
11297 if (tp
->pass_count
)
11298 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
11301 struct breakpoint_ops tracepoint_breakpoint_ops
;
11303 /* Delete a breakpoint and clean up all traces of it in the data
11307 delete_breakpoint (struct breakpoint
*bpt
)
11309 struct breakpoint
*b
;
11311 gdb_assert (bpt
!= NULL
);
11313 /* Has this bp already been deleted? This can happen because
11314 multiple lists can hold pointers to bp's. bpstat lists are
11317 One example of this happening is a watchpoint's scope bp. When
11318 the scope bp triggers, we notice that the watchpoint is out of
11319 scope, and delete it. We also delete its scope bp. But the
11320 scope bp is marked "auto-deleting", and is already on a bpstat.
11321 That bpstat is then checked for auto-deleting bp's, which are
11324 A real solution to this problem might involve reference counts in
11325 bp's, and/or giving them pointers back to their referencing
11326 bpstat's, and teaching delete_breakpoint to only free a bp's
11327 storage when no more references were extent. A cheaper bandaid
11329 if (bpt
->type
== bp_none
)
11332 /* At least avoid this stale reference until the reference counting
11333 of breakpoints gets resolved. */
11334 if (bpt
->related_breakpoint
!= bpt
)
11336 struct breakpoint
*related
;
11337 struct watchpoint
*w
;
11339 if (bpt
->type
== bp_watchpoint_scope
)
11340 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
11341 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
11342 w
= (struct watchpoint
*) bpt
;
11346 watchpoint_del_at_next_stop (w
);
11348 /* Unlink bpt from the bpt->related_breakpoint ring. */
11349 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
11350 related
= related
->related_breakpoint
);
11351 related
->related_breakpoint
= bpt
->related_breakpoint
;
11352 bpt
->related_breakpoint
= bpt
;
11355 /* watch_command_1 creates a watchpoint but only sets its number if
11356 update_watchpoint succeeds in creating its bp_locations. If there's
11357 a problem in that process, we'll be asked to delete the half-created
11358 watchpoint. In that case, don't announce the deletion. */
11360 observer_notify_breakpoint_deleted (bpt
);
11362 if (breakpoint_chain
== bpt
)
11363 breakpoint_chain
= bpt
->next
;
11365 ALL_BREAKPOINTS (b
)
11366 if (b
->next
== bpt
)
11368 b
->next
= bpt
->next
;
11372 /* Be sure no bpstat's are pointing at the breakpoint after it's
11374 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
11375 in all threads for now. Note that we cannot just remove bpstats
11376 pointing at bpt from the stop_bpstat list entirely, as breakpoint
11377 commands are associated with the bpstat; if we remove it here,
11378 then the later call to bpstat_do_actions (&stop_bpstat); in
11379 event-top.c won't do anything, and temporary breakpoints with
11380 commands won't work. */
11382 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
11384 /* Now that breakpoint is removed from breakpoint list, update the
11385 global location list. This will remove locations that used to
11386 belong to this breakpoint. Do this before freeing the breakpoint
11387 itself, since remove_breakpoint looks at location's owner. It
11388 might be better design to have location completely
11389 self-contained, but it's not the case now. */
11390 update_global_location_list (0);
11392 bpt
->ops
->dtor (bpt
);
11393 /* On the chance that someone will soon try again to delete this
11394 same bp, we mark it as deleted before freeing its storage. */
11395 bpt
->type
= bp_none
;
11400 do_delete_breakpoint_cleanup (void *b
)
11402 delete_breakpoint (b
);
11406 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
11408 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
11411 /* Iterator function to call a user-provided callback function once
11412 for each of B and its related breakpoints. */
11415 iterate_over_related_breakpoints (struct breakpoint
*b
,
11416 void (*function
) (struct breakpoint
*,
11420 struct breakpoint
*related
;
11425 struct breakpoint
*next
;
11427 /* FUNCTION may delete RELATED. */
11428 next
= related
->related_breakpoint
;
11430 if (next
== related
)
11432 /* RELATED is the last ring entry. */
11433 function (related
, data
);
11435 /* FUNCTION may have deleted it, so we'd never reach back to
11436 B. There's nothing left to do anyway, so just break
11441 function (related
, data
);
11445 while (related
!= b
);
11449 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
11451 delete_breakpoint (b
);
11454 /* A callback for map_breakpoint_numbers that calls
11455 delete_breakpoint. */
11458 do_map_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
11460 iterate_over_related_breakpoints (b
, do_delete_breakpoint
, NULL
);
11464 delete_command (char *arg
, int from_tty
)
11466 struct breakpoint
*b
, *b_tmp
;
11472 int breaks_to_delete
= 0;
11474 /* Delete all breakpoints if no argument. Do not delete
11475 internal breakpoints, these have to be deleted with an
11476 explicit breakpoint number argument. */
11477 ALL_BREAKPOINTS (b
)
11478 if (user_breakpoint_p (b
))
11480 breaks_to_delete
= 1;
11484 /* Ask user only if there are some breakpoints to delete. */
11486 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
11488 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11489 if (user_breakpoint_p (b
))
11490 delete_breakpoint (b
);
11494 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
11498 all_locations_are_pending (struct bp_location
*loc
)
11500 for (; loc
; loc
= loc
->next
)
11501 if (!loc
->shlib_disabled
11502 && !loc
->pspace
->executing_startup
)
11507 /* Subroutine of update_breakpoint_locations to simplify it.
11508 Return non-zero if multiple fns in list LOC have the same name.
11509 Null names are ignored. */
11512 ambiguous_names_p (struct bp_location
*loc
)
11514 struct bp_location
*l
;
11515 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
11516 (int (*) (const void *,
11517 const void *)) streq
,
11518 NULL
, xcalloc
, xfree
);
11520 for (l
= loc
; l
!= NULL
; l
= l
->next
)
11523 const char *name
= l
->function_name
;
11525 /* Allow for some names to be NULL, ignore them. */
11529 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
11531 /* NOTE: We can assume slot != NULL here because xcalloc never
11535 htab_delete (htab
);
11541 htab_delete (htab
);
11545 /* When symbols change, it probably means the sources changed as well,
11546 and it might mean the static tracepoint markers are no longer at
11547 the same address or line numbers they used to be at last we
11548 checked. Losing your static tracepoints whenever you rebuild is
11549 undesirable. This function tries to resync/rematch gdb static
11550 tracepoints with the markers on the target, for static tracepoints
11551 that have not been set by marker id. Static tracepoint that have
11552 been set by marker id are reset by marker id in breakpoint_re_set.
11555 1) For a tracepoint set at a specific address, look for a marker at
11556 the old PC. If one is found there, assume to be the same marker.
11557 If the name / string id of the marker found is different from the
11558 previous known name, assume that means the user renamed the marker
11559 in the sources, and output a warning.
11561 2) For a tracepoint set at a given line number, look for a marker
11562 at the new address of the old line number. If one is found there,
11563 assume to be the same marker. If the name / string id of the
11564 marker found is different from the previous known name, assume that
11565 means the user renamed the marker in the sources, and output a
11568 3) If a marker is no longer found at the same address or line, it
11569 may mean the marker no longer exists. But it may also just mean
11570 the code changed a bit. Maybe the user added a few lines of code
11571 that made the marker move up or down (in line number terms). Ask
11572 the target for info about the marker with the string id as we knew
11573 it. If found, update line number and address in the matching
11574 static tracepoint. This will get confused if there's more than one
11575 marker with the same ID (possible in UST, although unadvised
11576 precisely because it confuses tools). */
11578 static struct symtab_and_line
11579 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
11581 struct tracepoint
*tp
= (struct tracepoint
*) b
;
11582 struct static_tracepoint_marker marker
;
11588 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
11590 if (target_static_tracepoint_marker_at (pc
, &marker
))
11592 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
11593 warning (_("static tracepoint %d changed probed marker from %s to %s"),
11595 tp
->static_trace_marker_id
, marker
.str_id
);
11597 xfree (tp
->static_trace_marker_id
);
11598 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
11599 release_static_tracepoint_marker (&marker
);
11604 /* Old marker wasn't found on target at lineno. Try looking it up
11606 if (!sal
.explicit_pc
11608 && sal
.symtab
!= NULL
11609 && tp
->static_trace_marker_id
!= NULL
)
11611 VEC(static_tracepoint_marker_p
) *markers
;
11614 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
11616 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
11618 struct symtab_and_line sal2
;
11619 struct symbol
*sym
;
11620 struct static_tracepoint_marker
*tpmarker
;
11621 struct ui_out
*uiout
= current_uiout
;
11623 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
11625 xfree (tp
->static_trace_marker_id
);
11626 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
11628 warning (_("marker for static tracepoint %d (%s) not "
11629 "found at previous line number"),
11630 b
->number
, tp
->static_trace_marker_id
);
11634 sal2
.pc
= tpmarker
->address
;
11636 sal2
= find_pc_line (tpmarker
->address
, 0);
11637 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
11638 ui_out_text (uiout
, "Now in ");
11641 ui_out_field_string (uiout
, "func",
11642 SYMBOL_PRINT_NAME (sym
));
11643 ui_out_text (uiout
, " at ");
11645 ui_out_field_string (uiout
, "file", sal2
.symtab
->filename
);
11646 ui_out_text (uiout
, ":");
11648 if (ui_out_is_mi_like_p (uiout
))
11650 char *fullname
= symtab_to_fullname (sal2
.symtab
);
11653 ui_out_field_string (uiout
, "fullname", fullname
);
11656 ui_out_field_int (uiout
, "line", sal2
.line
);
11657 ui_out_text (uiout
, "\n");
11659 b
->loc
->line_number
= sal2
.line
;
11661 xfree (b
->loc
->source_file
);
11663 b
->loc
->source_file
= xstrdup (sal2
.symtab
->filename
);
11665 b
->loc
->source_file
= NULL
;
11667 xfree (b
->addr_string
);
11668 b
->addr_string
= xstrprintf ("%s:%d",
11669 sal2
.symtab
->filename
,
11670 b
->loc
->line_number
);
11672 /* Might be nice to check if function changed, and warn if
11675 release_static_tracepoint_marker (tpmarker
);
11681 /* Returns 1 iff locations A and B are sufficiently same that
11682 we don't need to report breakpoint as changed. */
11685 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
11689 if (a
->address
!= b
->address
)
11692 if (a
->shlib_disabled
!= b
->shlib_disabled
)
11695 if (a
->enabled
!= b
->enabled
)
11702 if ((a
== NULL
) != (b
== NULL
))
11708 /* Create new breakpoint locations for B (a hardware or software breakpoint)
11709 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
11710 a ranged breakpoint. */
11713 update_breakpoint_locations (struct breakpoint
*b
,
11714 struct symtabs_and_lines sals
,
11715 struct symtabs_and_lines sals_end
)
11718 struct bp_location
*existing_locations
= b
->loc
;
11720 if (sals_end
.nelts
!= 0 && (sals
.nelts
!= 1 || sals_end
.nelts
!= 1))
11722 /* Ranged breakpoints have only one start location and one end
11724 b
->enable_state
= bp_disabled
;
11725 update_global_location_list (1);
11726 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
11727 "multiple locations found\n"),
11732 /* If there's no new locations, and all existing locations are
11733 pending, don't do anything. This optimizes the common case where
11734 all locations are in the same shared library, that was unloaded.
11735 We'd like to retain the location, so that when the library is
11736 loaded again, we don't loose the enabled/disabled status of the
11737 individual locations. */
11738 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
11743 for (i
= 0; i
< sals
.nelts
; ++i
)
11745 struct bp_location
*new_loc
;
11747 switch_to_program_space_and_thread (sals
.sals
[i
].pspace
);
11749 new_loc
= add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
11751 /* Reparse conditions, they might contain references to the
11753 if (b
->cond_string
!= NULL
)
11756 struct gdb_exception e
;
11758 s
= b
->cond_string
;
11759 TRY_CATCH (e
, RETURN_MASK_ERROR
)
11761 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
11766 warning (_("failed to reevaluate condition "
11767 "for breakpoint %d: %s"),
11768 b
->number
, e
.message
);
11769 new_loc
->enabled
= 0;
11773 if (sals_end
.nelts
)
11775 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
11777 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
11781 /* Update locations of permanent breakpoints. */
11782 if (b
->enable_state
== bp_permanent
)
11783 make_breakpoint_permanent (b
);
11785 /* If possible, carry over 'disable' status from existing
11788 struct bp_location
*e
= existing_locations
;
11789 /* If there are multiple breakpoints with the same function name,
11790 e.g. for inline functions, comparing function names won't work.
11791 Instead compare pc addresses; this is just a heuristic as things
11792 may have moved, but in practice it gives the correct answer
11793 often enough until a better solution is found. */
11794 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
11796 for (; e
; e
= e
->next
)
11798 if (!e
->enabled
&& e
->function_name
)
11800 struct bp_location
*l
= b
->loc
;
11801 if (have_ambiguous_names
)
11803 for (; l
; l
= l
->next
)
11804 if (breakpoint_locations_match (e
, l
))
11812 for (; l
; l
= l
->next
)
11813 if (l
->function_name
11814 && strcmp (e
->function_name
, l
->function_name
) == 0)
11824 if (!locations_are_equal (existing_locations
, b
->loc
))
11825 observer_notify_breakpoint_modified (b
);
11827 update_global_location_list (1);
11830 /* Find the SaL locations corresponding to the given ADDR_STRING.
11831 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
11833 static struct symtabs_and_lines
11834 addr_string_to_sals (struct breakpoint
*b
, char *addr_string
, int *found
)
11838 struct symtabs_and_lines sals
= {0};
11839 volatile struct gdb_exception e
;
11842 marker_spec
= b
->type
== bp_static_tracepoint
&& is_marker_spec (s
);
11844 TRY_CATCH (e
, RETURN_MASK_ERROR
)
11848 struct tracepoint
*tp
= (struct tracepoint
*) b
;
11850 sals
= decode_static_tracepoint_spec (&s
);
11851 if (sals
.nelts
> tp
->static_trace_marker_id_idx
)
11853 sals
.sals
[0] = sals
.sals
[tp
->static_trace_marker_id_idx
];
11857 error (_("marker %s not found"), tp
->static_trace_marker_id
);
11861 struct linespec_result canonical
;
11863 init_linespec_result (&canonical
);
11864 decode_line_full (&s
, DECODE_LINE_FUNFIRSTLINE
,
11865 (struct symtab
*) NULL
, 0,
11866 &canonical
, multiple_symbols_all
,
11869 /* We should get 0 or 1 resulting SALs. */
11870 gdb_assert (VEC_length (linespec_sals
, canonical
.sals
) < 2);
11872 if (VEC_length (linespec_sals
, canonical
.sals
) > 0)
11874 struct linespec_sals
*lsal
;
11876 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
11878 /* Arrange it so the destructor does not free the
11880 lsal
->sals
.sals
= NULL
;
11883 destroy_linespec_result (&canonical
);
11888 int not_found_and_ok
= 0;
11889 /* For pending breakpoints, it's expected that parsing will
11890 fail until the right shared library is loaded. User has
11891 already told to create pending breakpoints and don't need
11892 extra messages. If breakpoint is in bp_shlib_disabled
11893 state, then user already saw the message about that
11894 breakpoint being disabled, and don't want to see more
11896 if (e
.error
== NOT_FOUND_ERROR
11897 && (b
->condition_not_parsed
11898 || (b
->loc
&& b
->loc
->shlib_disabled
)
11899 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
11900 || b
->enable_state
== bp_disabled
))
11901 not_found_and_ok
= 1;
11903 if (!not_found_and_ok
)
11905 /* We surely don't want to warn about the same breakpoint
11906 10 times. One solution, implemented here, is disable
11907 the breakpoint on error. Another solution would be to
11908 have separate 'warning emitted' flag. Since this
11909 happens only when a binary has changed, I don't know
11910 which approach is better. */
11911 b
->enable_state
= bp_disabled
;
11912 throw_exception (e
);
11916 if (e
.reason
== 0 || e
.error
!= NOT_FOUND_ERROR
)
11920 for (i
= 0; i
< sals
.nelts
; ++i
)
11921 resolve_sal_pc (&sals
.sals
[i
]);
11922 if (b
->condition_not_parsed
&& s
&& s
[0])
11924 char *cond_string
= 0;
11928 find_condition_and_thread (s
, sals
.sals
[0].pc
,
11929 &cond_string
, &thread
, &task
);
11931 b
->cond_string
= cond_string
;
11932 b
->thread
= thread
;
11934 b
->condition_not_parsed
= 0;
11937 if (b
->type
== bp_static_tracepoint
&& !marker_spec
)
11938 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
11948 /* The default re_set method, for typical hardware or software
11949 breakpoints. Reevaluate the breakpoint and recreate its
11953 breakpoint_re_set_default (struct breakpoint
*b
)
11956 struct symtabs_and_lines sals
, sals_end
;
11957 struct symtabs_and_lines expanded
= {0};
11958 struct symtabs_and_lines expanded_end
= {0};
11960 sals
= addr_string_to_sals (b
, b
->addr_string
, &found
);
11963 make_cleanup (xfree
, sals
.sals
);
11967 if (b
->addr_string_range_end
)
11969 sals_end
= addr_string_to_sals (b
, b
->addr_string_range_end
, &found
);
11972 make_cleanup (xfree
, sals_end
.sals
);
11973 expanded_end
= sals_end
;
11977 update_breakpoint_locations (b
, expanded
, expanded_end
);
11980 /* Prepare the global context for a re-set of breakpoint B. */
11982 static struct cleanup
*
11983 prepare_re_set_context (struct breakpoint
*b
)
11985 struct cleanup
*cleanups
;
11987 input_radix
= b
->input_radix
;
11988 cleanups
= save_current_space_and_thread ();
11989 if (b
->pspace
!= NULL
)
11990 switch_to_program_space_and_thread (b
->pspace
);
11991 set_language (b
->language
);
11996 /* Reset a breakpoint given it's struct breakpoint * BINT.
11997 The value we return ends up being the return value from catch_errors.
11998 Unused in this case. */
12001 breakpoint_re_set_one (void *bint
)
12003 /* Get past catch_errs. */
12004 struct breakpoint
*b
= (struct breakpoint
*) bint
;
12005 struct cleanup
*cleanups
;
12007 cleanups
= prepare_re_set_context (b
);
12008 b
->ops
->re_set (b
);
12009 do_cleanups (cleanups
);
12013 /* Re-set all breakpoints after symbols have been re-loaded. */
12015 breakpoint_re_set (void)
12017 struct breakpoint
*b
, *b_tmp
;
12018 enum language save_language
;
12019 int save_input_radix
;
12020 struct cleanup
*old_chain
;
12022 save_language
= current_language
->la_language
;
12023 save_input_radix
= input_radix
;
12024 old_chain
= save_current_program_space ();
12026 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12028 /* Format possible error msg. */
12029 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
12031 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
12032 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
12033 do_cleanups (cleanups
);
12035 set_language (save_language
);
12036 input_radix
= save_input_radix
;
12038 jit_breakpoint_re_set ();
12040 do_cleanups (old_chain
);
12042 create_overlay_event_breakpoint ();
12043 create_longjmp_master_breakpoint ();
12044 create_std_terminate_master_breakpoint ();
12045 create_exception_master_breakpoint ();
12047 /* While we're at it, reset the skip list too. */
12051 /* Reset the thread number of this breakpoint:
12053 - If the breakpoint is for all threads, leave it as-is.
12054 - Else, reset it to the current thread for inferior_ptid. */
12056 breakpoint_re_set_thread (struct breakpoint
*b
)
12058 if (b
->thread
!= -1)
12060 if (in_thread_list (inferior_ptid
))
12061 b
->thread
= pid_to_thread_id (inferior_ptid
);
12063 /* We're being called after following a fork. The new fork is
12064 selected as current, and unless this was a vfork will have a
12065 different program space from the original thread. Reset that
12067 b
->loc
->pspace
= current_program_space
;
12071 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
12072 If from_tty is nonzero, it prints a message to that effect,
12073 which ends with a period (no newline). */
12076 set_ignore_count (int bptnum
, int count
, int from_tty
)
12078 struct breakpoint
*b
;
12083 ALL_BREAKPOINTS (b
)
12084 if (b
->number
== bptnum
)
12086 if (is_tracepoint (b
))
12088 if (from_tty
&& count
!= 0)
12089 printf_filtered (_("Ignore count ignored for tracepoint %d."),
12094 b
->ignore_count
= count
;
12098 printf_filtered (_("Will stop next time "
12099 "breakpoint %d is reached."),
12101 else if (count
== 1)
12102 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
12105 printf_filtered (_("Will ignore next %d "
12106 "crossings of breakpoint %d."),
12109 breakpoints_changed ();
12110 observer_notify_breakpoint_modified (b
);
12114 error (_("No breakpoint number %d."), bptnum
);
12117 /* Command to set ignore-count of breakpoint N to COUNT. */
12120 ignore_command (char *args
, int from_tty
)
12126 error_no_arg (_("a breakpoint number"));
12128 num
= get_number (&p
);
12130 error (_("bad breakpoint number: '%s'"), args
);
12132 error (_("Second argument (specified ignore-count) is missing."));
12134 set_ignore_count (num
,
12135 longest_to_int (value_as_long (parse_and_eval (p
))),
12138 printf_filtered ("\n");
12141 /* Call FUNCTION on each of the breakpoints
12142 whose numbers are given in ARGS. */
12145 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
12150 struct breakpoint
*b
, *tmp
;
12152 struct get_number_or_range_state state
;
12155 error_no_arg (_("one or more breakpoint numbers"));
12157 init_number_or_range (&state
, args
);
12159 while (!state
.finished
)
12161 char *p
= state
.string
;
12165 num
= get_number_or_range (&state
);
12168 warning (_("bad breakpoint number at or near '%s'"), p
);
12172 ALL_BREAKPOINTS_SAFE (b
, tmp
)
12173 if (b
->number
== num
)
12176 function (b
, data
);
12180 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
12185 static struct bp_location
*
12186 find_location_by_number (char *number
)
12188 char *dot
= strchr (number
, '.');
12192 struct breakpoint
*b
;
12193 struct bp_location
*loc
;
12198 bp_num
= get_number (&p1
);
12200 error (_("Bad breakpoint number '%s'"), number
);
12202 ALL_BREAKPOINTS (b
)
12203 if (b
->number
== bp_num
)
12208 if (!b
|| b
->number
!= bp_num
)
12209 error (_("Bad breakpoint number '%s'"), number
);
12212 loc_num
= get_number (&p1
);
12214 error (_("Bad breakpoint location number '%s'"), number
);
12218 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
12221 error (_("Bad breakpoint location number '%s'"), dot
+1);
12227 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
12228 If from_tty is nonzero, it prints a message to that effect,
12229 which ends with a period (no newline). */
12232 disable_breakpoint (struct breakpoint
*bpt
)
12234 /* Never disable a watchpoint scope breakpoint; we want to
12235 hit them when we leave scope so we can delete both the
12236 watchpoint and its scope breakpoint at that time. */
12237 if (bpt
->type
== bp_watchpoint_scope
)
12240 /* You can't disable permanent breakpoints. */
12241 if (bpt
->enable_state
== bp_permanent
)
12244 bpt
->enable_state
= bp_disabled
;
12246 if (target_supports_enable_disable_tracepoint ()
12247 && current_trace_status ()->running
&& is_tracepoint (bpt
))
12249 struct bp_location
*location
;
12251 for (location
= bpt
->loc
; location
; location
= location
->next
)
12252 target_disable_tracepoint (location
);
12255 update_global_location_list (0);
12257 observer_notify_breakpoint_modified (bpt
);
12260 /* A callback for iterate_over_related_breakpoints. */
12263 do_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
12265 disable_breakpoint (b
);
12268 /* A callback for map_breakpoint_numbers that calls
12269 disable_breakpoint. */
12272 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
12274 iterate_over_related_breakpoints (b
, do_disable_breakpoint
, NULL
);
12278 disable_command (char *args
, int from_tty
)
12282 struct breakpoint
*bpt
;
12284 ALL_BREAKPOINTS (bpt
)
12285 if (user_breakpoint_p (bpt
))
12286 disable_breakpoint (bpt
);
12288 else if (strchr (args
, '.'))
12290 struct bp_location
*loc
= find_location_by_number (args
);
12294 if (target_supports_enable_disable_tracepoint ()
12295 && current_trace_status ()->running
&& loc
->owner
12296 && is_tracepoint (loc
->owner
))
12297 target_disable_tracepoint (loc
);
12299 update_global_location_list (0);
12302 map_breakpoint_numbers (args
, do_map_disable_breakpoint
, NULL
);
12306 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
)
12308 int target_resources_ok
;
12310 if (bpt
->type
== bp_hardware_breakpoint
)
12313 i
= hw_breakpoint_used_count ();
12314 target_resources_ok
=
12315 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
12317 if (target_resources_ok
== 0)
12318 error (_("No hardware breakpoint support in the target."));
12319 else if (target_resources_ok
< 0)
12320 error (_("Hardware breakpoints used exceeds limit."));
12323 if (is_watchpoint (bpt
))
12325 /* Initialize it just to avoid a GCC false warning. */
12326 enum enable_state orig_enable_state
= 0;
12327 struct gdb_exception e
;
12329 TRY_CATCH (e
, RETURN_MASK_ALL
)
12331 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
12333 orig_enable_state
= bpt
->enable_state
;
12334 bpt
->enable_state
= bp_enabled
;
12335 update_watchpoint (w
, 1 /* reparse */);
12339 bpt
->enable_state
= orig_enable_state
;
12340 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
12346 if (bpt
->enable_state
!= bp_permanent
)
12347 bpt
->enable_state
= bp_enabled
;
12349 if (target_supports_enable_disable_tracepoint ()
12350 && current_trace_status ()->running
&& is_tracepoint (bpt
))
12352 struct bp_location
*location
;
12354 for (location
= bpt
->loc
; location
; location
= location
->next
)
12355 target_enable_tracepoint (location
);
12358 bpt
->disposition
= disposition
;
12359 update_global_location_list (1);
12360 breakpoints_changed ();
12362 observer_notify_breakpoint_modified (bpt
);
12367 enable_breakpoint (struct breakpoint
*bpt
)
12369 enable_breakpoint_disp (bpt
, bpt
->disposition
);
12373 do_enable_breakpoint (struct breakpoint
*bpt
, void *arg
)
12375 enable_breakpoint (bpt
);
12378 /* A callback for map_breakpoint_numbers that calls
12379 enable_breakpoint. */
12382 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
12384 iterate_over_related_breakpoints (b
, do_enable_breakpoint
, NULL
);
12387 /* The enable command enables the specified breakpoints (or all defined
12388 breakpoints) so they once again become (or continue to be) effective
12389 in stopping the inferior. */
12392 enable_command (char *args
, int from_tty
)
12396 struct breakpoint
*bpt
;
12398 ALL_BREAKPOINTS (bpt
)
12399 if (user_breakpoint_p (bpt
))
12400 enable_breakpoint (bpt
);
12402 else if (strchr (args
, '.'))
12404 struct bp_location
*loc
= find_location_by_number (args
);
12408 if (target_supports_enable_disable_tracepoint ()
12409 && current_trace_status ()->running
&& loc
->owner
12410 && is_tracepoint (loc
->owner
))
12411 target_enable_tracepoint (loc
);
12413 update_global_location_list (1);
12416 map_breakpoint_numbers (args
, do_map_enable_breakpoint
, NULL
);
12420 do_enable_breakpoint_disp (struct breakpoint
*bpt
, void *arg
)
12422 enum bpdisp disp
= *(enum bpdisp
*) arg
;
12424 enable_breakpoint_disp (bpt
, disp
);
12428 do_map_enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
12430 enum bpdisp disp
= disp_disable
;
12432 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
12436 enable_once_command (char *args
, int from_tty
)
12438 map_breakpoint_numbers (args
, do_map_enable_once_breakpoint
, NULL
);
12442 do_map_enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
12444 enum bpdisp disp
= disp_del
;
12446 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
12450 enable_delete_command (char *args
, int from_tty
)
12452 map_breakpoint_numbers (args
, do_map_enable_delete_breakpoint
, NULL
);
12456 set_breakpoint_cmd (char *args
, int from_tty
)
12461 show_breakpoint_cmd (char *args
, int from_tty
)
12465 /* Invalidate last known value of any hardware watchpoint if
12466 the memory which that value represents has been written to by
12470 invalidate_bp_value_on_memory_change (CORE_ADDR addr
, int len
,
12471 const bfd_byte
*data
)
12473 struct breakpoint
*bp
;
12475 ALL_BREAKPOINTS (bp
)
12476 if (bp
->enable_state
== bp_enabled
12477 && bp
->type
== bp_hardware_watchpoint
)
12479 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
12481 if (wp
->val_valid
&& wp
->val
)
12483 struct bp_location
*loc
;
12485 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
12486 if (loc
->loc_type
== bp_loc_hardware_watchpoint
12487 && loc
->address
+ loc
->length
> addr
12488 && addr
+ len
> loc
->address
)
12490 value_free (wp
->val
);
12498 /* Use the last displayed codepoint's values, or nothing
12499 if they aren't valid. */
12501 struct symtabs_and_lines
12502 decode_line_spec_1 (char *string
, int flags
)
12504 struct symtabs_and_lines sals
;
12507 error (_("Empty line specification."));
12508 if (last_displayed_sal_is_valid ())
12509 sals
= decode_line_1 (&string
, flags
,
12510 get_last_displayed_symtab (),
12511 get_last_displayed_line ());
12513 sals
= decode_line_1 (&string
, flags
, (struct symtab
*) NULL
, 0);
12515 error (_("Junk at end of line specification: %s"), string
);
12519 /* Create and insert a raw software breakpoint at PC. Return an
12520 identifier, which should be used to remove the breakpoint later.
12521 In general, places which call this should be using something on the
12522 breakpoint chain instead; this function should be eliminated
12526 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
12527 struct address_space
*aspace
, CORE_ADDR pc
)
12529 struct bp_target_info
*bp_tgt
;
12531 bp_tgt
= XZALLOC (struct bp_target_info
);
12533 bp_tgt
->placed_address_space
= aspace
;
12534 bp_tgt
->placed_address
= pc
;
12536 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
12538 /* Could not insert the breakpoint. */
12546 /* Remove a breakpoint BP inserted by
12547 deprecated_insert_raw_breakpoint. */
12550 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
12552 struct bp_target_info
*bp_tgt
= bp
;
12555 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
12561 /* One (or perhaps two) breakpoints used for software single
12564 static void *single_step_breakpoints
[2];
12565 static struct gdbarch
*single_step_gdbarch
[2];
12567 /* Create and insert a breakpoint for software single step. */
12570 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
12571 struct address_space
*aspace
,
12576 if (single_step_breakpoints
[0] == NULL
)
12578 bpt_p
= &single_step_breakpoints
[0];
12579 single_step_gdbarch
[0] = gdbarch
;
12583 gdb_assert (single_step_breakpoints
[1] == NULL
);
12584 bpt_p
= &single_step_breakpoints
[1];
12585 single_step_gdbarch
[1] = gdbarch
;
12588 /* NOTE drow/2006-04-11: A future improvement to this function would
12589 be to only create the breakpoints once, and actually put them on
12590 the breakpoint chain. That would let us use set_raw_breakpoint.
12591 We could adjust the addresses each time they were needed. Doing
12592 this requires corresponding changes elsewhere where single step
12593 breakpoints are handled, however. So, for now, we use this. */
12595 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
12596 if (*bpt_p
== NULL
)
12597 error (_("Could not insert single-step breakpoint at %s"),
12598 paddress (gdbarch
, next_pc
));
12601 /* Check if the breakpoints used for software single stepping
12602 were inserted or not. */
12605 single_step_breakpoints_inserted (void)
12607 return (single_step_breakpoints
[0] != NULL
12608 || single_step_breakpoints
[1] != NULL
);
12611 /* Remove and delete any breakpoints used for software single step. */
12614 remove_single_step_breakpoints (void)
12616 gdb_assert (single_step_breakpoints
[0] != NULL
);
12618 /* See insert_single_step_breakpoint for more about this deprecated
12620 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
12621 single_step_breakpoints
[0]);
12622 single_step_gdbarch
[0] = NULL
;
12623 single_step_breakpoints
[0] = NULL
;
12625 if (single_step_breakpoints
[1] != NULL
)
12627 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
12628 single_step_breakpoints
[1]);
12629 single_step_gdbarch
[1] = NULL
;
12630 single_step_breakpoints
[1] = NULL
;
12634 /* Delete software single step breakpoints without removing them from
12635 the inferior. This is intended to be used if the inferior's address
12636 space where they were inserted is already gone, e.g. after exit or
12640 cancel_single_step_breakpoints (void)
12644 for (i
= 0; i
< 2; i
++)
12645 if (single_step_breakpoints
[i
])
12647 xfree (single_step_breakpoints
[i
]);
12648 single_step_breakpoints
[i
] = NULL
;
12649 single_step_gdbarch
[i
] = NULL
;
12653 /* Detach software single-step breakpoints from INFERIOR_PTID without
12657 detach_single_step_breakpoints (void)
12661 for (i
= 0; i
< 2; i
++)
12662 if (single_step_breakpoints
[i
])
12663 target_remove_breakpoint (single_step_gdbarch
[i
],
12664 single_step_breakpoints
[i
]);
12667 /* Check whether a software single-step breakpoint is inserted at
12671 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
12676 for (i
= 0; i
< 2; i
++)
12678 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
12680 && breakpoint_address_match (bp_tgt
->placed_address_space
,
12681 bp_tgt
->placed_address
,
12689 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
12690 non-zero otherwise. */
12692 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
12694 if (syscall_catchpoint_p (bp
)
12695 && bp
->enable_state
!= bp_disabled
12696 && bp
->enable_state
!= bp_call_disabled
)
12703 catch_syscall_enabled (void)
12705 struct inferior
*inf
= current_inferior ();
12707 return inf
->total_syscalls_count
!= 0;
12711 catching_syscall_number (int syscall_number
)
12713 struct breakpoint
*bp
;
12715 ALL_BREAKPOINTS (bp
)
12716 if (is_syscall_catchpoint_enabled (bp
))
12718 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bp
;
12720 if (c
->syscalls_to_be_caught
)
12724 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
12726 if (syscall_number
== iter
)
12736 /* Complete syscall names. Used by "catch syscall". */
12738 catch_syscall_completer (struct cmd_list_element
*cmd
,
12739 char *text
, char *word
)
12741 const char **list
= get_syscall_names ();
12743 = (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
12749 /* Tracepoint-specific operations. */
12751 /* Set tracepoint count to NUM. */
12753 set_tracepoint_count (int num
)
12755 tracepoint_count
= num
;
12756 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
12760 trace_command (char *arg
, int from_tty
)
12762 if (create_breakpoint (get_current_arch (),
12764 NULL
, 0, 1 /* parse arg */,
12766 bp_tracepoint
/* type_wanted */,
12767 0 /* Ignore count */,
12768 pending_break_support
,
12769 &tracepoint_breakpoint_ops
,
12773 set_tracepoint_count (breakpoint_count
);
12777 ftrace_command (char *arg
, int from_tty
)
12779 if (create_breakpoint (get_current_arch (),
12781 NULL
, 0, 1 /* parse arg */,
12783 bp_fast_tracepoint
/* type_wanted */,
12784 0 /* Ignore count */,
12785 pending_break_support
,
12786 &tracepoint_breakpoint_ops
,
12790 set_tracepoint_count (breakpoint_count
);
12793 /* strace command implementation. Creates a static tracepoint. */
12796 strace_command (char *arg
, int from_tty
)
12798 if (create_breakpoint (get_current_arch (),
12800 NULL
, 0, 1 /* parse arg */,
12802 bp_static_tracepoint
/* type_wanted */,
12803 0 /* Ignore count */,
12804 pending_break_support
,
12805 &tracepoint_breakpoint_ops
,
12809 set_tracepoint_count (breakpoint_count
);
12812 /* Set up a fake reader function that gets command lines from a linked
12813 list that was acquired during tracepoint uploading. */
12815 static struct uploaded_tp
*this_utp
;
12816 static int next_cmd
;
12819 read_uploaded_action (void)
12823 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
12830 /* Given information about a tracepoint as recorded on a target (which
12831 can be either a live system or a trace file), attempt to create an
12832 equivalent GDB tracepoint. This is not a reliable process, since
12833 the target does not necessarily have all the information used when
12834 the tracepoint was originally defined. */
12836 struct tracepoint
*
12837 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
12839 char *addr_str
, small_buf
[100];
12840 struct tracepoint
*tp
;
12842 if (utp
->at_string
)
12843 addr_str
= utp
->at_string
;
12846 /* In the absence of a source location, fall back to raw
12847 address. Since there is no way to confirm that the address
12848 means the same thing as when the trace was started, warn the
12850 warning (_("Uploaded tracepoint %d has no "
12851 "source location, using raw address"),
12853 sprintf (small_buf
, "*%s", hex_string (utp
->addr
));
12854 addr_str
= small_buf
;
12857 /* There's not much we can do with a sequence of bytecodes. */
12858 if (utp
->cond
&& !utp
->cond_string
)
12859 warning (_("Uploaded tracepoint %d condition "
12860 "has no source form, ignoring it"),
12863 if (!create_breakpoint (get_current_arch (),
12865 utp
->cond_string
, -1, 0 /* parse cond/thread */,
12867 utp
->type
/* type_wanted */,
12868 0 /* Ignore count */,
12869 pending_break_support
,
12870 &tracepoint_breakpoint_ops
,
12872 utp
->enabled
/* enabled */,
12876 set_tracepoint_count (breakpoint_count
);
12878 /* Get the tracepoint we just created. */
12879 tp
= get_tracepoint (tracepoint_count
);
12880 gdb_assert (tp
!= NULL
);
12884 sprintf (small_buf
, "%d %d", utp
->pass
, tp
->base
.number
);
12886 trace_pass_command (small_buf
, 0);
12889 /* If we have uploaded versions of the original commands, set up a
12890 special-purpose "reader" function and call the usual command line
12891 reader, then pass the result to the breakpoint command-setting
12893 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
12895 struct command_line
*cmd_list
;
12900 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
12902 breakpoint_set_commands (&tp
->base
, cmd_list
);
12904 else if (!VEC_empty (char_ptr
, utp
->actions
)
12905 || !VEC_empty (char_ptr
, utp
->step_actions
))
12906 warning (_("Uploaded tracepoint %d actions "
12907 "have no source form, ignoring them"),
12910 /* Copy any status information that might be available. */
12911 tp
->base
.hit_count
= utp
->hit_count
;
12912 tp
->traceframe_usage
= utp
->traceframe_usage
;
12917 /* Print information on tracepoint number TPNUM_EXP, or all if
12921 tracepoints_info (char *args
, int from_tty
)
12923 struct ui_out
*uiout
= current_uiout
;
12926 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
12928 if (num_printed
== 0)
12930 if (args
== NULL
|| *args
== '\0')
12931 ui_out_message (uiout
, 0, "No tracepoints.\n");
12933 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
12936 default_collect_info ();
12939 /* The 'enable trace' command enables tracepoints.
12940 Not supported by all targets. */
12942 enable_trace_command (char *args
, int from_tty
)
12944 enable_command (args
, from_tty
);
12947 /* The 'disable trace' command disables tracepoints.
12948 Not supported by all targets. */
12950 disable_trace_command (char *args
, int from_tty
)
12952 disable_command (args
, from_tty
);
12955 /* Remove a tracepoint (or all if no argument). */
12957 delete_trace_command (char *arg
, int from_tty
)
12959 struct breakpoint
*b
, *b_tmp
;
12965 int breaks_to_delete
= 0;
12967 /* Delete all breakpoints if no argument.
12968 Do not delete internal or call-dummy breakpoints, these
12969 have to be deleted with an explicit breakpoint number
12971 ALL_TRACEPOINTS (b
)
12972 if (is_tracepoint (b
) && user_breakpoint_p (b
))
12974 breaks_to_delete
= 1;
12978 /* Ask user only if there are some breakpoints to delete. */
12980 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
12982 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12983 if (is_tracepoint (b
) && user_breakpoint_p (b
))
12984 delete_breakpoint (b
);
12988 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
12991 /* Helper function for trace_pass_command. */
12994 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
12996 tp
->pass_count
= count
;
12997 observer_notify_tracepoint_modified (tp
->base
.number
);
12999 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
13000 tp
->base
.number
, count
);
13003 /* Set passcount for tracepoint.
13005 First command argument is passcount, second is tracepoint number.
13006 If tracepoint number omitted, apply to most recently defined.
13007 Also accepts special argument "all". */
13010 trace_pass_command (char *args
, int from_tty
)
13012 struct tracepoint
*t1
;
13013 unsigned int count
;
13015 if (args
== 0 || *args
== 0)
13016 error (_("passcount command requires an "
13017 "argument (count + optional TP num)"));
13019 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
13021 while (*args
&& isspace ((int) *args
))
13024 if (*args
&& strncasecmp (args
, "all", 3) == 0)
13026 struct breakpoint
*b
;
13028 args
+= 3; /* Skip special argument "all". */
13030 error (_("Junk at end of arguments."));
13032 ALL_TRACEPOINTS (b
)
13034 t1
= (struct tracepoint
*) b
;
13035 trace_pass_set_count (t1
, count
, from_tty
);
13038 else if (*args
== '\0')
13040 t1
= get_tracepoint_by_number (&args
, NULL
, 1);
13042 trace_pass_set_count (t1
, count
, from_tty
);
13046 struct get_number_or_range_state state
;
13048 init_number_or_range (&state
, args
);
13049 while (!state
.finished
)
13051 t1
= get_tracepoint_by_number (&args
, &state
, 1);
13053 trace_pass_set_count (t1
, count
, from_tty
);
13058 struct tracepoint
*
13059 get_tracepoint (int num
)
13061 struct breakpoint
*t
;
13063 ALL_TRACEPOINTS (t
)
13064 if (t
->number
== num
)
13065 return (struct tracepoint
*) t
;
13070 /* Find the tracepoint with the given target-side number (which may be
13071 different from the tracepoint number after disconnecting and
13074 struct tracepoint
*
13075 get_tracepoint_by_number_on_target (int num
)
13077 struct breakpoint
*b
;
13079 ALL_TRACEPOINTS (b
)
13081 struct tracepoint
*t
= (struct tracepoint
*) b
;
13083 if (t
->number_on_target
== num
)
13090 /* Utility: parse a tracepoint number and look it up in the list.
13091 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
13092 If OPTIONAL_P is true, then if the argument is missing, the most
13093 recent tracepoint (tracepoint_count) is returned. */
13094 struct tracepoint
*
13095 get_tracepoint_by_number (char **arg
,
13096 struct get_number_or_range_state
*state
,
13099 extern int tracepoint_count
;
13100 struct breakpoint
*t
;
13102 char *instring
= arg
== NULL
? NULL
: *arg
;
13106 gdb_assert (!state
->finished
);
13107 tpnum
= get_number_or_range (state
);
13109 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
13112 tpnum
= tracepoint_count
;
13114 error_no_arg (_("tracepoint number"));
13117 tpnum
= get_number (arg
);
13121 if (instring
&& *instring
)
13122 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
13125 printf_filtered (_("Tracepoint argument missing "
13126 "and no previous tracepoint\n"));
13130 ALL_TRACEPOINTS (t
)
13131 if (t
->number
== tpnum
)
13133 return (struct tracepoint
*) t
;
13136 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
13141 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
13143 if (b
->thread
!= -1)
13144 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
13147 fprintf_unfiltered (fp
, " task %d", b
->task
);
13149 fprintf_unfiltered (fp
, "\n");
13152 /* Save information on user settable breakpoints (watchpoints, etc) to
13153 a new script file named FILENAME. If FILTER is non-NULL, call it
13154 on each breakpoint and only include the ones for which it returns
13158 save_breakpoints (char *filename
, int from_tty
,
13159 int (*filter
) (const struct breakpoint
*))
13161 struct breakpoint
*tp
;
13164 struct cleanup
*cleanup
;
13165 struct ui_file
*fp
;
13166 int extra_trace_bits
= 0;
13168 if (filename
== 0 || *filename
== 0)
13169 error (_("Argument required (file name in which to save)"));
13171 /* See if we have anything to save. */
13172 ALL_BREAKPOINTS (tp
)
13174 /* Skip internal and momentary breakpoints. */
13175 if (!user_breakpoint_p (tp
))
13178 /* If we have a filter, only save the breakpoints it accepts. */
13179 if (filter
&& !filter (tp
))
13184 if (is_tracepoint (tp
))
13186 extra_trace_bits
= 1;
13188 /* We can stop searching. */
13195 warning (_("Nothing to save."));
13199 pathname
= tilde_expand (filename
);
13200 cleanup
= make_cleanup (xfree
, pathname
);
13201 fp
= gdb_fopen (pathname
, "w");
13203 error (_("Unable to open file '%s' for saving (%s)"),
13204 filename
, safe_strerror (errno
));
13205 make_cleanup_ui_file_delete (fp
);
13207 if (extra_trace_bits
)
13208 save_trace_state_variables (fp
);
13210 ALL_BREAKPOINTS (tp
)
13212 /* Skip internal and momentary breakpoints. */
13213 if (!user_breakpoint_p (tp
))
13216 /* If we have a filter, only save the breakpoints it accepts. */
13217 if (filter
&& !filter (tp
))
13220 tp
->ops
->print_recreate (tp
, fp
);
13222 /* Note, we can't rely on tp->number for anything, as we can't
13223 assume the recreated breakpoint numbers will match. Use $bpnum
13226 if (tp
->cond_string
)
13227 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
13229 if (tp
->ignore_count
)
13230 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
13234 volatile struct gdb_exception ex
;
13236 fprintf_unfiltered (fp
, " commands\n");
13238 ui_out_redirect (current_uiout
, fp
);
13239 TRY_CATCH (ex
, RETURN_MASK_ALL
)
13241 print_command_lines (current_uiout
, tp
->commands
->commands
, 2);
13243 ui_out_redirect (current_uiout
, NULL
);
13246 throw_exception (ex
);
13248 fprintf_unfiltered (fp
, " end\n");
13251 if (tp
->enable_state
== bp_disabled
)
13252 fprintf_unfiltered (fp
, "disable\n");
13254 /* If this is a multi-location breakpoint, check if the locations
13255 should be individually disabled. Watchpoint locations are
13256 special, and not user visible. */
13257 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
13259 struct bp_location
*loc
;
13262 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
13264 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
13268 if (extra_trace_bits
&& *default_collect
)
13269 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
13271 do_cleanups (cleanup
);
13273 printf_filtered (_("Saved to file '%s'.\n"), filename
);
13276 /* The `save breakpoints' command. */
13279 save_breakpoints_command (char *args
, int from_tty
)
13281 save_breakpoints (args
, from_tty
, NULL
);
13284 /* The `save tracepoints' command. */
13287 save_tracepoints_command (char *args
, int from_tty
)
13289 save_breakpoints (args
, from_tty
, is_tracepoint
);
13292 /* Create a vector of all tracepoints. */
13294 VEC(breakpoint_p
) *
13295 all_tracepoints (void)
13297 VEC(breakpoint_p
) *tp_vec
= 0;
13298 struct breakpoint
*tp
;
13300 ALL_TRACEPOINTS (tp
)
13302 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
13309 /* This help string is used for the break, hbreak, tbreak and thbreak
13310 commands. It is defined as a macro to prevent duplication.
13311 COMMAND should be a string constant containing the name of the
13313 #define BREAK_ARGS_HELP(command) \
13314 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
13315 LOCATION may be a line number, function name, or \"*\" and an address.\n\
13316 If a line number is specified, break at start of code for that line.\n\
13317 If a function is specified, break at start of code for that function.\n\
13318 If an address is specified, break at that exact address.\n\
13319 With no LOCATION, uses current execution address of the selected\n\
13320 stack frame. This is useful for breaking on return to a stack frame.\n\
13322 THREADNUM is the number from \"info threads\".\n\
13323 CONDITION is a boolean expression.\n\
13325 Multiple breakpoints at one place are permitted, and useful if their\n\
13326 conditions are different.\n\
13328 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
13330 /* List of subcommands for "catch". */
13331 static struct cmd_list_element
*catch_cmdlist
;
13333 /* List of subcommands for "tcatch". */
13334 static struct cmd_list_element
*tcatch_cmdlist
;
13337 add_catch_command (char *name
, char *docstring
,
13338 void (*sfunc
) (char *args
, int from_tty
,
13339 struct cmd_list_element
*command
),
13340 char **(*completer
) (struct cmd_list_element
*cmd
,
13341 char *text
, char *word
),
13342 void *user_data_catch
,
13343 void *user_data_tcatch
)
13345 struct cmd_list_element
*command
;
13347 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
13349 set_cmd_sfunc (command
, sfunc
);
13350 set_cmd_context (command
, user_data_catch
);
13351 set_cmd_completer (command
, completer
);
13353 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
13355 set_cmd_sfunc (command
, sfunc
);
13356 set_cmd_context (command
, user_data_tcatch
);
13357 set_cmd_completer (command
, completer
);
13361 clear_syscall_counts (struct inferior
*inf
)
13363 inf
->total_syscalls_count
= 0;
13364 inf
->any_syscall_count
= 0;
13365 VEC_free (int, inf
->syscalls_counts
);
13369 save_command (char *arg
, int from_tty
)
13371 printf_unfiltered (_("\"save\" must be followed by "
13372 "the name of a save subcommand.\n"));
13373 help_list (save_cmdlist
, "save ", -1, gdb_stdout
);
13376 struct breakpoint
*
13377 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
13380 struct breakpoint
*b
, *b_tmp
;
13382 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13384 if ((*callback
) (b
, data
))
13391 /* Zero if any of the breakpoint's locations could be a location where
13392 functions have been inlined, nonzero otherwise. */
13395 is_non_inline_function (struct breakpoint
*b
)
13397 /* The shared library event breakpoint is set on the address of a
13398 non-inline function. */
13399 if (b
->type
== bp_shlib_event
)
13405 /* Nonzero if the specified PC cannot be a location where functions
13406 have been inlined. */
13409 pc_at_non_inline_function (struct address_space
*aspace
, CORE_ADDR pc
)
13411 struct breakpoint
*b
;
13412 struct bp_location
*bl
;
13414 ALL_BREAKPOINTS (b
)
13416 if (!is_non_inline_function (b
))
13419 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
13421 if (!bl
->shlib_disabled
13422 && bpstat_check_location (bl
, aspace
, pc
))
13431 initialize_breakpoint_ops (void)
13433 static int initialized
= 0;
13435 struct breakpoint_ops
*ops
;
13441 /* The breakpoint_ops structure to be inherit by all kinds of
13442 breakpoints (real breakpoints, i.e., user "break" breakpoints,
13443 internal and momentary breakpoints, etc.). */
13444 ops
= &bkpt_base_breakpoint_ops
;
13445 *ops
= base_breakpoint_ops
;
13446 ops
->re_set
= bkpt_re_set
;
13447 ops
->insert_location
= bkpt_insert_location
;
13448 ops
->remove_location
= bkpt_remove_location
;
13449 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
13451 /* The breakpoint_ops structure to be used in regular breakpoints. */
13452 ops
= &bkpt_breakpoint_ops
;
13453 *ops
= bkpt_base_breakpoint_ops
;
13454 ops
->re_set
= bkpt_re_set
;
13455 ops
->resources_needed
= bkpt_resources_needed
;
13456 ops
->print_it
= bkpt_print_it
;
13457 ops
->print_mention
= bkpt_print_mention
;
13458 ops
->print_recreate
= bkpt_print_recreate
;
13460 /* Ranged breakpoints. */
13461 ops
= &ranged_breakpoint_ops
;
13462 *ops
= bkpt_breakpoint_ops
;
13463 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
13464 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
13465 ops
->print_it
= print_it_ranged_breakpoint
;
13466 ops
->print_one
= print_one_ranged_breakpoint
;
13467 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
13468 ops
->print_mention
= print_mention_ranged_breakpoint
;
13469 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
13471 /* Internal breakpoints. */
13472 ops
= &internal_breakpoint_ops
;
13473 *ops
= bkpt_base_breakpoint_ops
;
13474 ops
->re_set
= internal_bkpt_re_set
;
13475 ops
->check_status
= internal_bkpt_check_status
;
13476 ops
->print_it
= internal_bkpt_print_it
;
13477 ops
->print_mention
= internal_bkpt_print_mention
;
13479 /* Momentary breakpoints. */
13480 ops
= &momentary_breakpoint_ops
;
13481 *ops
= bkpt_base_breakpoint_ops
;
13482 ops
->re_set
= momentary_bkpt_re_set
;
13483 ops
->check_status
= momentary_bkpt_check_status
;
13484 ops
->print_it
= momentary_bkpt_print_it
;
13485 ops
->print_mention
= momentary_bkpt_print_mention
;
13487 /* GNU v3 exception catchpoints. */
13488 ops
= &gnu_v3_exception_catchpoint_ops
;
13489 *ops
= bkpt_breakpoint_ops
;
13490 ops
->print_it
= print_it_exception_catchpoint
;
13491 ops
->print_one
= print_one_exception_catchpoint
;
13492 ops
->print_mention
= print_mention_exception_catchpoint
;
13493 ops
->print_recreate
= print_recreate_exception_catchpoint
;
13496 ops
= &watchpoint_breakpoint_ops
;
13497 *ops
= base_breakpoint_ops
;
13498 ops
->dtor
= dtor_watchpoint
;
13499 ops
->re_set
= re_set_watchpoint
;
13500 ops
->insert_location
= insert_watchpoint
;
13501 ops
->remove_location
= remove_watchpoint
;
13502 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
13503 ops
->check_status
= check_status_watchpoint
;
13504 ops
->resources_needed
= resources_needed_watchpoint
;
13505 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
13506 ops
->print_it
= print_it_watchpoint
;
13507 ops
->print_mention
= print_mention_watchpoint
;
13508 ops
->print_recreate
= print_recreate_watchpoint
;
13510 /* Masked watchpoints. */
13511 ops
= &masked_watchpoint_breakpoint_ops
;
13512 *ops
= watchpoint_breakpoint_ops
;
13513 ops
->insert_location
= insert_masked_watchpoint
;
13514 ops
->remove_location
= remove_masked_watchpoint
;
13515 ops
->resources_needed
= resources_needed_masked_watchpoint
;
13516 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
13517 ops
->print_it
= print_it_masked_watchpoint
;
13518 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
13519 ops
->print_mention
= print_mention_masked_watchpoint
;
13520 ops
->print_recreate
= print_recreate_masked_watchpoint
;
13523 ops
= &tracepoint_breakpoint_ops
;
13524 *ops
= base_breakpoint_ops
;
13525 ops
->re_set
= tracepoint_re_set
;
13526 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
13527 ops
->print_one_detail
= tracepoint_print_one_detail
;
13528 ops
->print_mention
= tracepoint_print_mention
;
13529 ops
->print_recreate
= tracepoint_print_recreate
;
13531 /* Fork catchpoints. */
13532 ops
= &catch_fork_breakpoint_ops
;
13533 *ops
= base_breakpoint_ops
;
13534 ops
->insert_location
= insert_catch_fork
;
13535 ops
->remove_location
= remove_catch_fork
;
13536 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
13537 ops
->print_it
= print_it_catch_fork
;
13538 ops
->print_one
= print_one_catch_fork
;
13539 ops
->print_mention
= print_mention_catch_fork
;
13540 ops
->print_recreate
= print_recreate_catch_fork
;
13542 /* Vfork catchpoints. */
13543 ops
= &catch_vfork_breakpoint_ops
;
13544 *ops
= base_breakpoint_ops
;
13545 ops
->insert_location
= insert_catch_vfork
;
13546 ops
->remove_location
= remove_catch_vfork
;
13547 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
13548 ops
->print_it
= print_it_catch_vfork
;
13549 ops
->print_one
= print_one_catch_vfork
;
13550 ops
->print_mention
= print_mention_catch_vfork
;
13551 ops
->print_recreate
= print_recreate_catch_vfork
;
13553 /* Exec catchpoints. */
13554 ops
= &catch_exec_breakpoint_ops
;
13555 *ops
= base_breakpoint_ops
;
13556 ops
->dtor
= dtor_catch_exec
;
13557 ops
->insert_location
= insert_catch_exec
;
13558 ops
->remove_location
= remove_catch_exec
;
13559 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
13560 ops
->print_it
= print_it_catch_exec
;
13561 ops
->print_one
= print_one_catch_exec
;
13562 ops
->print_mention
= print_mention_catch_exec
;
13563 ops
->print_recreate
= print_recreate_catch_exec
;
13565 /* Syscall catchpoints. */
13566 ops
= &catch_syscall_breakpoint_ops
;
13567 *ops
= base_breakpoint_ops
;
13568 ops
->dtor
= dtor_catch_syscall
;
13569 ops
->insert_location
= insert_catch_syscall
;
13570 ops
->remove_location
= remove_catch_syscall
;
13571 ops
->breakpoint_hit
= breakpoint_hit_catch_syscall
;
13572 ops
->print_it
= print_it_catch_syscall
;
13573 ops
->print_one
= print_one_catch_syscall
;
13574 ops
->print_mention
= print_mention_catch_syscall
;
13575 ops
->print_recreate
= print_recreate_catch_syscall
;
13579 _initialize_breakpoint (void)
13581 struct cmd_list_element
*c
;
13583 initialize_breakpoint_ops ();
13585 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
13586 observer_attach_inferior_exit (clear_syscall_counts
);
13587 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
13589 breakpoint_objfile_key
= register_objfile_data ();
13591 breakpoint_chain
= 0;
13592 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
13593 before a breakpoint is set. */
13594 breakpoint_count
= 0;
13596 tracepoint_count
= 0;
13598 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
13599 Set ignore-count of breakpoint number N to COUNT.\n\
13600 Usage is `ignore N COUNT'."));
13602 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
13604 add_com ("commands", class_breakpoint
, commands_command
, _("\
13605 Set commands to be executed when a breakpoint is hit.\n\
13606 Give breakpoint number as argument after \"commands\".\n\
13607 With no argument, the targeted breakpoint is the last one set.\n\
13608 The commands themselves follow starting on the next line.\n\
13609 Type a line containing \"end\" to indicate the end of them.\n\
13610 Give \"silent\" as the first line to make the breakpoint silent;\n\
13611 then no output is printed when it is hit, except what the commands print."));
13613 add_com ("condition", class_breakpoint
, condition_command
, _("\
13614 Specify breakpoint number N to break only if COND is true.\n\
13615 Usage is `condition N COND', where N is an integer and COND is an\n\
13616 expression to be evaluated whenever breakpoint N is reached."));
13618 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
13619 Set a temporary breakpoint.\n\
13620 Like \"break\" except the breakpoint is only temporary,\n\
13621 so it will be deleted when hit. Equivalent to \"break\" followed\n\
13622 by using \"enable delete\" on the breakpoint number.\n\
13624 BREAK_ARGS_HELP ("tbreak")));
13625 set_cmd_completer (c
, location_completer
);
13627 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
13628 Set a hardware assisted breakpoint.\n\
13629 Like \"break\" except the breakpoint requires hardware support,\n\
13630 some target hardware may not have this support.\n\
13632 BREAK_ARGS_HELP ("hbreak")));
13633 set_cmd_completer (c
, location_completer
);
13635 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
13636 Set a temporary hardware assisted breakpoint.\n\
13637 Like \"hbreak\" except the breakpoint is only temporary,\n\
13638 so it will be deleted when hit.\n\
13640 BREAK_ARGS_HELP ("thbreak")));
13641 set_cmd_completer (c
, location_completer
);
13643 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
13644 Enable some breakpoints.\n\
13645 Give breakpoint numbers (separated by spaces) as arguments.\n\
13646 With no subcommand, breakpoints are enabled until you command otherwise.\n\
13647 This is used to cancel the effect of the \"disable\" command.\n\
13648 With a subcommand you can enable temporarily."),
13649 &enablelist
, "enable ", 1, &cmdlist
);
13651 add_com ("ab", class_breakpoint
, enable_command
, _("\
13652 Enable some breakpoints.\n\
13653 Give breakpoint numbers (separated by spaces) as arguments.\n\
13654 With no subcommand, breakpoints are enabled until you command otherwise.\n\
13655 This is used to cancel the effect of the \"disable\" command.\n\
13656 With a subcommand you can enable temporarily."));
13658 add_com_alias ("en", "enable", class_breakpoint
, 1);
13660 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
13661 Enable some breakpoints.\n\
13662 Give breakpoint numbers (separated by spaces) as arguments.\n\
13663 This is used to cancel the effect of the \"disable\" command.\n\
13664 May be abbreviated to simply \"enable\".\n"),
13665 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
13667 add_cmd ("once", no_class
, enable_once_command
, _("\
13668 Enable breakpoints for one hit. Give breakpoint numbers.\n\
13669 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
13672 add_cmd ("delete", no_class
, enable_delete_command
, _("\
13673 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
13674 If a breakpoint is hit while enabled in this fashion, it is deleted."),
13677 add_cmd ("delete", no_class
, enable_delete_command
, _("\
13678 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
13679 If a breakpoint is hit while enabled in this fashion, it is deleted."),
13682 add_cmd ("once", no_class
, enable_once_command
, _("\
13683 Enable breakpoints for one hit. Give breakpoint numbers.\n\
13684 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
13687 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
13688 Disable some breakpoints.\n\
13689 Arguments are breakpoint numbers with spaces in between.\n\
13690 To disable all breakpoints, give no argument.\n\
13691 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
13692 &disablelist
, "disable ", 1, &cmdlist
);
13693 add_com_alias ("dis", "disable", class_breakpoint
, 1);
13694 add_com_alias ("disa", "disable", class_breakpoint
, 1);
13696 add_com ("sb", class_breakpoint
, disable_command
, _("\
13697 Disable some breakpoints.\n\
13698 Arguments are breakpoint numbers with spaces in between.\n\
13699 To disable all breakpoints, give no argument.\n\
13700 A disabled breakpoint is not forgotten, but has no effect until re-enabled."));
13702 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
13703 Disable some breakpoints.\n\
13704 Arguments are breakpoint numbers with spaces in between.\n\
13705 To disable all breakpoints, give no argument.\n\
13706 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
13707 This command may be abbreviated \"disable\"."),
13710 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
13711 Delete some breakpoints or auto-display expressions.\n\
13712 Arguments are breakpoint numbers with spaces in between.\n\
13713 To delete all breakpoints, give no argument.\n\
13715 Also a prefix command for deletion of other GDB objects.\n\
13716 The \"unset\" command is also an alias for \"delete\"."),
13717 &deletelist
, "delete ", 1, &cmdlist
);
13718 add_com_alias ("d", "delete", class_breakpoint
, 1);
13719 add_com_alias ("del", "delete", class_breakpoint
, 1);
13721 add_com ("db", class_breakpoint
, delete_command
, _("\
13722 Delete some breakpoints.\n\
13723 Arguments are breakpoint numbers with spaces in between.\n\
13724 To delete all breakpoints, give no argument.\n"));
13726 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
13727 Delete some breakpoints or auto-display expressions.\n\
13728 Arguments are breakpoint numbers with spaces in between.\n\
13729 To delete all breakpoints, give no argument.\n\
13730 This command may be abbreviated \"delete\"."),
13733 add_com ("clear", class_breakpoint
, clear_command
, _("\
13734 Clear breakpoint at specified line or function.\n\
13735 Argument may be line number, function name, or \"*\" and an address.\n\
13736 If line number is specified, all breakpoints in that line are cleared.\n\
13737 If function is specified, breakpoints at beginning of function are cleared.\n\
13738 If an address is specified, breakpoints at that address are cleared.\n\
13740 With no argument, clears all breakpoints in the line that the selected frame\n\
13741 is executing in.\n\
13743 See also the \"delete\" command which clears breakpoints by number."));
13744 add_com_alias ("cl", "clear", class_breakpoint
, 1);
13746 c
= add_com ("break", class_breakpoint
, break_command
, _("\
13747 Set breakpoint at specified line or function.\n"
13748 BREAK_ARGS_HELP ("break")));
13749 set_cmd_completer (c
, location_completer
);
13751 add_com_alias ("b", "break", class_run
, 1);
13752 add_com_alias ("br", "break", class_run
, 1);
13753 add_com_alias ("bre", "break", class_run
, 1);
13754 add_com_alias ("brea", "break", class_run
, 1);
13757 add_com_alias ("ba", "break", class_breakpoint
, 1);
13761 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
13762 Break in function/address or break at a line in the current file."),
13763 &stoplist
, "stop ", 1, &cmdlist
);
13764 add_cmd ("in", class_breakpoint
, stopin_command
,
13765 _("Break in function or address."), &stoplist
);
13766 add_cmd ("at", class_breakpoint
, stopat_command
,
13767 _("Break at a line in the current file."), &stoplist
);
13768 add_com ("status", class_info
, breakpoints_info
, _("\
13769 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
13770 The \"Type\" column indicates one of:\n\
13771 \tbreakpoint - normal breakpoint\n\
13772 \twatchpoint - watchpoint\n\
13773 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13774 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13775 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13776 address and file/line number respectively.\n\
13778 Convenience variable \"$_\" and default examine address for \"x\"\n\
13779 are set to the address of the last breakpoint listed unless the command\n\
13780 is prefixed with \"server \".\n\n\
13781 Convenience variable \"$bpnum\" contains the number of the last\n\
13782 breakpoint set."));
13785 add_info ("breakpoints", breakpoints_info
, _("\
13786 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
13787 The \"Type\" column indicates one of:\n\
13788 \tbreakpoint - normal breakpoint\n\
13789 \twatchpoint - watchpoint\n\
13790 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13791 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13792 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13793 address and file/line number respectively.\n\
13795 Convenience variable \"$_\" and default examine address for \"x\"\n\
13796 are set to the address of the last breakpoint listed unless the command\n\
13797 is prefixed with \"server \".\n\n\
13798 Convenience variable \"$bpnum\" contains the number of the last\n\
13799 breakpoint set."));
13801 add_info_alias ("b", "breakpoints", 1);
13804 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
13805 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
13806 The \"Type\" column indicates one of:\n\
13807 \tbreakpoint - normal breakpoint\n\
13808 \twatchpoint - watchpoint\n\
13809 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13810 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13811 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13812 address and file/line number respectively.\n\
13814 Convenience variable \"$_\" and default examine address for \"x\"\n\
13815 are set to the address of the last breakpoint listed unless the command\n\
13816 is prefixed with \"server \".\n\n\
13817 Convenience variable \"$bpnum\" contains the number of the last\n\
13818 breakpoint set."));
13820 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
13821 Status of all breakpoints, or breakpoint number NUMBER.\n\
13822 The \"Type\" column indicates one of:\n\
13823 \tbreakpoint - normal breakpoint\n\
13824 \twatchpoint - watchpoint\n\
13825 \tlongjmp - internal breakpoint used to step through longjmp()\n\
13826 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
13827 \tuntil - internal breakpoint used by the \"until\" command\n\
13828 \tfinish - internal breakpoint used by the \"finish\" command\n\
13829 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13830 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13831 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13832 address and file/line number respectively.\n\
13834 Convenience variable \"$_\" and default examine address for \"x\"\n\
13835 are set to the address of the last breakpoint listed unless the command\n\
13836 is prefixed with \"server \".\n\n\
13837 Convenience variable \"$bpnum\" contains the number of the last\n\
13839 &maintenanceinfolist
);
13841 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
13842 Set catchpoints to catch events."),
13843 &catch_cmdlist
, "catch ",
13844 0/*allow-unknown*/, &cmdlist
);
13846 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
13847 Set temporary catchpoints to catch events."),
13848 &tcatch_cmdlist
, "tcatch ",
13849 0/*allow-unknown*/, &cmdlist
);
13851 /* Add catch and tcatch sub-commands. */
13852 add_catch_command ("catch", _("\
13853 Catch an exception, when caught.\n\
13854 With an argument, catch only exceptions with the given name."),
13855 catch_catch_command
,
13859 add_catch_command ("throw", _("\
13860 Catch an exception, when thrown.\n\
13861 With an argument, catch only exceptions with the given name."),
13862 catch_throw_command
,
13866 add_catch_command ("fork", _("Catch calls to fork."),
13867 catch_fork_command_1
,
13869 (void *) (uintptr_t) catch_fork_permanent
,
13870 (void *) (uintptr_t) catch_fork_temporary
);
13871 add_catch_command ("vfork", _("Catch calls to vfork."),
13872 catch_fork_command_1
,
13874 (void *) (uintptr_t) catch_vfork_permanent
,
13875 (void *) (uintptr_t) catch_vfork_temporary
);
13876 add_catch_command ("exec", _("Catch calls to exec."),
13877 catch_exec_command_1
,
13881 add_catch_command ("syscall", _("\
13882 Catch system calls by their names and/or numbers.\n\
13883 Arguments say which system calls to catch. If no arguments\n\
13884 are given, every system call will be caught.\n\
13885 Arguments, if given, should be one or more system call names\n\
13886 (if your system supports that), or system call numbers."),
13887 catch_syscall_command_1
,
13888 catch_syscall_completer
,
13892 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
13893 Set a watchpoint for an expression.\n\
13894 Usage: watch [-l|-location] EXPRESSION\n\
13895 A watchpoint stops execution of your program whenever the value of\n\
13896 an expression changes.\n\
13897 If -l or -location is given, this evaluates EXPRESSION and watches\n\
13898 the memory to which it refers."));
13899 set_cmd_completer (c
, expression_completer
);
13901 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
13902 Set a read watchpoint for an expression.\n\
13903 Usage: rwatch [-l|-location] EXPRESSION\n\
13904 A watchpoint stops execution of your program whenever the value of\n\
13905 an expression is read.\n\
13906 If -l or -location is given, this evaluates EXPRESSION and watches\n\
13907 the memory to which it refers."));
13908 set_cmd_completer (c
, expression_completer
);
13910 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
13911 Set a watchpoint for an expression.\n\
13912 Usage: awatch [-l|-location] EXPRESSION\n\
13913 A watchpoint stops execution of your program whenever the value of\n\
13914 an expression is either read or written.\n\
13915 If -l or -location is given, this evaluates EXPRESSION and watches\n\
13916 the memory to which it refers."));
13917 set_cmd_completer (c
, expression_completer
);
13919 add_info ("watchpoints", watchpoints_info
, _("\
13920 Status of specified watchpoints (all watchpoints if no argument)."));
13922 /* XXX: cagney/2005-02-23: This should be a boolean, and should
13923 respond to changes - contrary to the description. */
13924 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
13925 &can_use_hw_watchpoints
, _("\
13926 Set debugger's willingness to use watchpoint hardware."), _("\
13927 Show debugger's willingness to use watchpoint hardware."), _("\
13928 If zero, gdb will not use hardware for new watchpoints, even if\n\
13929 such is available. (However, any hardware watchpoints that were\n\
13930 created before setting this to nonzero, will continue to use watchpoint\n\
13933 show_can_use_hw_watchpoints
,
13934 &setlist
, &showlist
);
13936 can_use_hw_watchpoints
= 1;
13938 /* Tracepoint manipulation commands. */
13940 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
13941 Set a tracepoint at specified line or function.\n\
13943 BREAK_ARGS_HELP ("trace") "\n\
13944 Do \"help tracepoints\" for info on other tracepoint commands."));
13945 set_cmd_completer (c
, location_completer
);
13947 add_com_alias ("tp", "trace", class_alias
, 0);
13948 add_com_alias ("tr", "trace", class_alias
, 1);
13949 add_com_alias ("tra", "trace", class_alias
, 1);
13950 add_com_alias ("trac", "trace", class_alias
, 1);
13952 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
13953 Set a fast tracepoint at specified line or function.\n\
13955 BREAK_ARGS_HELP ("ftrace") "\n\
13956 Do \"help tracepoints\" for info on other tracepoint commands."));
13957 set_cmd_completer (c
, location_completer
);
13959 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
13960 Set a static tracepoint at specified line, function or marker.\n\
13962 strace [LOCATION] [if CONDITION]\n\
13963 LOCATION may be a line number, function name, \"*\" and an address,\n\
13964 or -m MARKER_ID.\n\
13965 If a line number is specified, probe the marker at start of code\n\
13966 for that line. If a function is specified, probe the marker at start\n\
13967 of code for that function. If an address is specified, probe the marker\n\
13968 at that exact address. If a marker id is specified, probe the marker\n\
13969 with that name. With no LOCATION, uses current execution address of\n\
13970 the selected stack frame.\n\
13971 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
13972 This collects arbitrary user data passed in the probe point call to the\n\
13973 tracing library. You can inspect it when analyzing the trace buffer,\n\
13974 by printing the $_sdata variable like any other convenience variable.\n\
13976 CONDITION is a boolean expression.\n\
13978 Multiple tracepoints at one place are permitted, and useful if their\n\
13979 conditions are different.\n\
13981 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
13982 Do \"help tracepoints\" for info on other tracepoint commands."));
13983 set_cmd_completer (c
, location_completer
);
13985 add_info ("tracepoints", tracepoints_info
, _("\
13986 Status of specified tracepoints (all tracepoints if no argument).\n\
13987 Convenience variable \"$tpnum\" contains the number of the\n\
13988 last tracepoint set."));
13990 add_info_alias ("tp", "tracepoints", 1);
13992 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
13993 Delete specified tracepoints.\n\
13994 Arguments are tracepoint numbers, separated by spaces.\n\
13995 No argument means delete all tracepoints."),
13998 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
13999 Disable specified tracepoints.\n\
14000 Arguments are tracepoint numbers, separated by spaces.\n\
14001 No argument means disable all tracepoints."),
14003 deprecate_cmd (c
, "disable");
14005 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
14006 Enable specified tracepoints.\n\
14007 Arguments are tracepoint numbers, separated by spaces.\n\
14008 No argument means enable all tracepoints."),
14010 deprecate_cmd (c
, "enable");
14012 add_com ("passcount", class_trace
, trace_pass_command
, _("\
14013 Set the passcount for a tracepoint.\n\
14014 The trace will end when the tracepoint has been passed 'count' times.\n\
14015 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
14016 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
14018 add_prefix_cmd ("save", class_breakpoint
, save_command
,
14019 _("Save breakpoint definitions as a script."),
14020 &save_cmdlist
, "save ",
14021 0/*allow-unknown*/, &cmdlist
);
14023 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
14024 Save current breakpoint definitions as a script.\n\
14025 This includes all types of breakpoints (breakpoints, watchpoints,\n\
14026 catchpoints, tracepoints). Use the 'source' command in another debug\n\
14027 session to restore them."),
14029 set_cmd_completer (c
, filename_completer
);
14031 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
14032 Save current tracepoint definitions as a script.\n\
14033 Use the 'source' command in another debug session to restore them."),
14035 set_cmd_completer (c
, filename_completer
);
14037 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
14038 deprecate_cmd (c
, "save tracepoints");
14040 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
14041 Breakpoint specific settings\n\
14042 Configure various breakpoint-specific variables such as\n\
14043 pending breakpoint behavior"),
14044 &breakpoint_set_cmdlist
, "set breakpoint ",
14045 0/*allow-unknown*/, &setlist
);
14046 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
14047 Breakpoint specific settings\n\
14048 Configure various breakpoint-specific variables such as\n\
14049 pending breakpoint behavior"),
14050 &breakpoint_show_cmdlist
, "show breakpoint ",
14051 0/*allow-unknown*/, &showlist
);
14053 add_setshow_auto_boolean_cmd ("pending", no_class
,
14054 &pending_break_support
, _("\
14055 Set debugger's behavior regarding pending breakpoints."), _("\
14056 Show debugger's behavior regarding pending breakpoints."), _("\
14057 If on, an unrecognized breakpoint location will cause gdb to create a\n\
14058 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
14059 an error. If auto, an unrecognized breakpoint location results in a\n\
14060 user-query to see if a pending breakpoint should be created."),
14062 show_pending_break_support
,
14063 &breakpoint_set_cmdlist
,
14064 &breakpoint_show_cmdlist
);
14066 pending_break_support
= AUTO_BOOLEAN_AUTO
;
14068 add_setshow_boolean_cmd ("auto-hw", no_class
,
14069 &automatic_hardware_breakpoints
, _("\
14070 Set automatic usage of hardware breakpoints."), _("\
14071 Show automatic usage of hardware breakpoints."), _("\
14072 If set, the debugger will automatically use hardware breakpoints for\n\
14073 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
14074 a warning will be emitted for such breakpoints."),
14076 show_automatic_hardware_breakpoints
,
14077 &breakpoint_set_cmdlist
,
14078 &breakpoint_show_cmdlist
);
14080 add_setshow_enum_cmd ("always-inserted", class_support
,
14081 always_inserted_enums
, &always_inserted_mode
, _("\
14082 Set mode for inserting breakpoints."), _("\
14083 Show mode for inserting breakpoints."), _("\
14084 When this mode is off, breakpoints are inserted in inferior when it is\n\
14085 resumed, and removed when execution stops. When this mode is on,\n\
14086 breakpoints are inserted immediately and removed only when the user\n\
14087 deletes the breakpoint. When this mode is auto (which is the default),\n\
14088 the behaviour depends on the non-stop setting (see help set non-stop).\n\
14089 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
14090 behaves as if always-inserted mode is on; if gdb is controlling the\n\
14091 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
14093 &show_always_inserted_mode
,
14094 &breakpoint_set_cmdlist
,
14095 &breakpoint_show_cmdlist
);
14097 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
14098 Set a breakpoint for an address range.\n\
14099 break-range START-LOCATION, END-LOCATION\n\
14100 where START-LOCATION and END-LOCATION can be one of the following:\n\
14101 LINENUM, for that line in the current file,\n\
14102 FILE:LINENUM, for that line in that file,\n\
14103 +OFFSET, for that number of lines after the current line\n\
14104 or the start of the range\n\
14105 FUNCTION, for the first line in that function,\n\
14106 FILE:FUNCTION, to distinguish among like-named static functions.\n\
14107 *ADDRESS, for the instruction at that address.\n\
14109 The breakpoint will stop execution of the inferior whenever it executes\n\
14110 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
14111 range (including START-LOCATION and END-LOCATION)."));
14113 automatic_hardware_breakpoints
= 1;
14115 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);