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"
61 #include "xml-syscall.h"
62 #include "parser-defs.h"
63 #include "cli/cli-utils.h"
64 #include "continuations.h"
68 #include "gdb_regex.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 create_sals_from_address_default (char **,
101 struct linespec_result
*,
105 static void create_breakpoints_sal_default (struct gdbarch
*,
106 struct linespec_result
*,
107 struct linespec_sals
*,
109 enum bpdisp
, int, int,
111 const struct breakpoint_ops
*,
114 static void decode_linespec_default (struct breakpoint
*, char **,
115 struct symtabs_and_lines
*);
117 static void clear_command (char *, int);
119 static void catch_command (char *, int);
121 static int can_use_hardware_watchpoint (struct value
*);
123 static void break_command_1 (char *, int, int);
125 static void mention (struct breakpoint
*);
127 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
129 const struct breakpoint_ops
*);
130 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
131 const struct symtab_and_line
*);
133 /* This function is used in gdbtk sources and thus can not be made
135 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
136 struct symtab_and_line
,
138 const struct breakpoint_ops
*);
140 static struct breakpoint
*
141 momentary_breakpoint_from_master (struct breakpoint
*orig
,
143 const struct breakpoint_ops
*ops
);
145 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
147 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
151 static void describe_other_breakpoints (struct gdbarch
*,
152 struct program_space
*, CORE_ADDR
,
153 struct obj_section
*, int);
155 static int breakpoint_address_match (struct address_space
*aspace1
,
157 struct address_space
*aspace2
,
160 static int watchpoint_locations_match (struct bp_location
*loc1
,
161 struct bp_location
*loc2
);
163 static int breakpoint_location_address_match (struct bp_location
*bl
,
164 struct address_space
*aspace
,
167 static void breakpoints_info (char *, int);
169 static void watchpoints_info (char *, int);
171 static int breakpoint_1 (char *, int,
172 int (*) (const struct breakpoint
*));
174 static int breakpoint_cond_eval (void *);
176 static void cleanup_executing_breakpoints (void *);
178 static void commands_command (char *, int);
180 static void condition_command (char *, int);
189 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
190 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
192 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
194 static int watchpoint_check (void *);
196 static void maintenance_info_breakpoints (char *, int);
198 static int hw_breakpoint_used_count (void);
200 static int hw_watchpoint_use_count (struct breakpoint
*);
202 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
204 int *other_type_used
);
206 static void hbreak_command (char *, int);
208 static void thbreak_command (char *, int);
210 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
);
212 static void stop_command (char *arg
, int from_tty
);
214 static void stopin_command (char *arg
, int from_tty
);
216 static void stopat_command (char *arg
, int from_tty
);
218 static char *ep_parse_optional_if_clause (char **arg
);
220 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
221 char *arg
, int tempflag
, int from_tty
);
223 static void tcatch_command (char *arg
, int from_tty
);
225 static void detach_single_step_breakpoints (void);
227 static int single_step_breakpoint_inserted_here_p (struct address_space
*,
230 static void free_bp_location (struct bp_location
*loc
);
231 static void incref_bp_location (struct bp_location
*loc
);
232 static void decref_bp_location (struct bp_location
**loc
);
234 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
236 static void update_global_location_list (int);
238 static void update_global_location_list_nothrow (int);
240 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
242 static void insert_breakpoint_locations (void);
244 static int syscall_catchpoint_p (struct breakpoint
*b
);
246 static void tracepoints_info (char *, int);
248 static void delete_trace_command (char *, int);
250 static void enable_trace_command (char *, int);
252 static void disable_trace_command (char *, int);
254 static void trace_pass_command (char *, int);
256 static int is_masked_watchpoint (const struct breakpoint
*b
);
258 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
261 static int strace_marker_p (struct breakpoint
*b
);
263 static void init_catchpoint (struct breakpoint
*b
,
264 struct gdbarch
*gdbarch
, int tempflag
,
266 const struct breakpoint_ops
*ops
);
268 /* The abstract base class all breakpoint_ops structures inherit
270 static struct breakpoint_ops base_breakpoint_ops
;
272 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
273 that are implemented on top of software or hardware breakpoints
274 (user breakpoints, internal and momentary breakpoints, etc.). */
275 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
277 /* Internal breakpoints class type. */
278 static struct breakpoint_ops internal_breakpoint_ops
;
280 /* Momentary breakpoints class type. */
281 static struct breakpoint_ops momentary_breakpoint_ops
;
283 /* The breakpoint_ops structure to be used in regular user created
285 struct breakpoint_ops bkpt_breakpoint_ops
;
287 /* A reference-counted struct command_line. This lets multiple
288 breakpoints share a single command list. */
289 struct counted_command_line
291 /* The reference count. */
294 /* The command list. */
295 struct command_line
*commands
;
298 struct command_line
*
299 breakpoint_commands (struct breakpoint
*b
)
301 return b
->commands
? b
->commands
->commands
: NULL
;
304 /* Flag indicating that a command has proceeded the inferior past the
305 current breakpoint. */
307 static int breakpoint_proceeded
;
310 bpdisp_text (enum bpdisp disp
)
312 /* NOTE: the following values are a part of MI protocol and
313 represent values of 'disp' field returned when inferior stops at
315 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
317 return bpdisps
[(int) disp
];
320 /* Prototypes for exported functions. */
321 /* If FALSE, gdb will not use hardware support for watchpoints, even
322 if such is available. */
323 static int can_use_hw_watchpoints
;
326 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
327 struct cmd_list_element
*c
,
330 fprintf_filtered (file
,
331 _("Debugger's willingness to use "
332 "watchpoint hardware is %s.\n"),
336 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
337 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
338 for unrecognized breakpoint locations.
339 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
340 static enum auto_boolean pending_break_support
;
342 show_pending_break_support (struct ui_file
*file
, int from_tty
,
343 struct cmd_list_element
*c
,
346 fprintf_filtered (file
,
347 _("Debugger's behavior regarding "
348 "pending breakpoints is %s.\n"),
352 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
353 set with "break" but falling in read-only memory.
354 If 0, gdb will warn about such breakpoints, but won't automatically
355 use hardware breakpoints. */
356 static int automatic_hardware_breakpoints
;
358 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
359 struct cmd_list_element
*c
,
362 fprintf_filtered (file
,
363 _("Automatic usage of hardware breakpoints is %s.\n"),
367 /* If on, gdb will keep breakpoints inserted even as inferior is
368 stopped, and immediately insert any new breakpoints. If off, gdb
369 will insert breakpoints into inferior only when resuming it, and
370 will remove breakpoints upon stop. If auto, GDB will behave as ON
371 if in non-stop mode, and as OFF if all-stop mode.*/
373 static const char always_inserted_auto
[] = "auto";
374 static const char always_inserted_on
[] = "on";
375 static const char always_inserted_off
[] = "off";
376 static const char *const always_inserted_enums
[] = {
377 always_inserted_auto
,
382 static const char *always_inserted_mode
= always_inserted_auto
;
384 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
385 struct cmd_list_element
*c
, const char *value
)
387 if (always_inserted_mode
== always_inserted_auto
)
388 fprintf_filtered (file
,
389 _("Always inserted breakpoint "
390 "mode is %s (currently %s).\n"),
392 breakpoints_always_inserted_mode () ? "on" : "off");
394 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
399 breakpoints_always_inserted_mode (void)
401 return ((always_inserted_mode
== always_inserted_on
402 || (always_inserted_mode
== always_inserted_auto
&& non_stop
))
406 void _initialize_breakpoint (void);
408 /* Are we executing breakpoint commands? */
409 static int executing_breakpoint_commands
;
411 /* Are overlay event breakpoints enabled? */
412 static int overlay_events_enabled
;
414 /* See description in breakpoint.h. */
415 int target_exact_watchpoints
= 0;
417 /* Walk the following statement or block through all breakpoints.
418 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
419 current breakpoint. */
421 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
423 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
424 for (B = breakpoint_chain; \
425 B ? (TMP=B->next, 1): 0; \
428 /* Similar iterator for the low-level breakpoints. SAFE variant is
429 not provided so update_global_location_list must not be called
430 while executing the block of ALL_BP_LOCATIONS. */
432 #define ALL_BP_LOCATIONS(B,BP_TMP) \
433 for (BP_TMP = bp_location; \
434 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
437 /* Iterator for tracepoints only. */
439 #define ALL_TRACEPOINTS(B) \
440 for (B = breakpoint_chain; B; B = B->next) \
441 if (is_tracepoint (B))
443 /* Chains of all breakpoints defined. */
445 struct breakpoint
*breakpoint_chain
;
447 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
449 static struct bp_location
**bp_location
;
451 /* Number of elements of BP_LOCATION. */
453 static unsigned bp_location_count
;
455 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
456 ADDRESS for the current elements of BP_LOCATION which get a valid
457 result from bp_location_has_shadow. You can use it for roughly
458 limiting the subrange of BP_LOCATION to scan for shadow bytes for
459 an address you need to read. */
461 static CORE_ADDR bp_location_placed_address_before_address_max
;
463 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
464 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
465 BP_LOCATION which get a valid result from bp_location_has_shadow.
466 You can use it for roughly limiting the subrange of BP_LOCATION to
467 scan for shadow bytes for an address you need to read. */
469 static CORE_ADDR bp_location_shadow_len_after_address_max
;
471 /* The locations that no longer correspond to any breakpoint, unlinked
472 from bp_location array, but for which a hit may still be reported
474 VEC(bp_location_p
) *moribund_locations
= NULL
;
476 /* Number of last breakpoint made. */
478 static int breakpoint_count
;
480 /* The value of `breakpoint_count' before the last command that
481 created breakpoints. If the last (break-like) command created more
482 than one breakpoint, then the difference between BREAKPOINT_COUNT
483 and PREV_BREAKPOINT_COUNT is more than one. */
484 static int prev_breakpoint_count
;
486 /* Number of last tracepoint made. */
488 static int tracepoint_count
;
490 static struct cmd_list_element
*breakpoint_set_cmdlist
;
491 static struct cmd_list_element
*breakpoint_show_cmdlist
;
492 struct cmd_list_element
*save_cmdlist
;
494 /* Return whether a breakpoint is an active enabled breakpoint. */
496 breakpoint_enabled (struct breakpoint
*b
)
498 return (b
->enable_state
== bp_enabled
);
501 /* Set breakpoint count to NUM. */
504 set_breakpoint_count (int num
)
506 prev_breakpoint_count
= breakpoint_count
;
507 breakpoint_count
= num
;
508 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
511 /* Used by `start_rbreak_breakpoints' below, to record the current
512 breakpoint count before "rbreak" creates any breakpoint. */
513 static int rbreak_start_breakpoint_count
;
515 /* Called at the start an "rbreak" command to record the first
519 start_rbreak_breakpoints (void)
521 rbreak_start_breakpoint_count
= breakpoint_count
;
524 /* Called at the end of an "rbreak" command to record the last
528 end_rbreak_breakpoints (void)
530 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
533 /* Used in run_command to zero the hit count when a new run starts. */
536 clear_breakpoint_hit_counts (void)
538 struct breakpoint
*b
;
544 /* Allocate a new counted_command_line with reference count of 1.
545 The new structure owns COMMANDS. */
547 static struct counted_command_line
*
548 alloc_counted_command_line (struct command_line
*commands
)
550 struct counted_command_line
*result
551 = xmalloc (sizeof (struct counted_command_line
));
554 result
->commands
= commands
;
558 /* Increment reference count. This does nothing if CMD is NULL. */
561 incref_counted_command_line (struct counted_command_line
*cmd
)
567 /* Decrement reference count. If the reference count reaches 0,
568 destroy the counted_command_line. Sets *CMDP to NULL. This does
569 nothing if *CMDP is NULL. */
572 decref_counted_command_line (struct counted_command_line
**cmdp
)
576 if (--(*cmdp
)->refc
== 0)
578 free_command_lines (&(*cmdp
)->commands
);
585 /* A cleanup function that calls decref_counted_command_line. */
588 do_cleanup_counted_command_line (void *arg
)
590 decref_counted_command_line (arg
);
593 /* Create a cleanup that calls decref_counted_command_line on the
596 static struct cleanup
*
597 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
599 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
603 /* Return the breakpoint with the specified number, or NULL
604 if the number does not refer to an existing breakpoint. */
607 get_breakpoint (int num
)
609 struct breakpoint
*b
;
612 if (b
->number
== num
)
621 set_breakpoint_condition (struct breakpoint
*b
, char *exp
,
624 xfree (b
->cond_string
);
625 b
->cond_string
= NULL
;
627 if (is_watchpoint (b
))
629 struct watchpoint
*w
= (struct watchpoint
*) b
;
636 struct bp_location
*loc
;
638 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
648 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
654 /* I don't know if it matters whether this is the string the user
655 typed in or the decompiled expression. */
656 b
->cond_string
= xstrdup (arg
);
657 b
->condition_not_parsed
= 0;
659 if (is_watchpoint (b
))
661 struct watchpoint
*w
= (struct watchpoint
*) b
;
663 innermost_block
= NULL
;
665 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0);
667 error (_("Junk at end of expression"));
668 w
->cond_exp_valid_block
= innermost_block
;
672 struct bp_location
*loc
;
674 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
678 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
680 error (_("Junk at end of expression"));
684 breakpoints_changed ();
685 observer_notify_breakpoint_modified (b
);
688 /* condition N EXP -- set break condition of breakpoint N to EXP. */
691 condition_command (char *arg
, int from_tty
)
693 struct breakpoint
*b
;
698 error_no_arg (_("breakpoint number"));
701 bnum
= get_number (&p
);
703 error (_("Bad breakpoint argument: '%s'"), arg
);
706 if (b
->number
== bnum
)
708 /* Check if this breakpoint has a Python object assigned to
709 it, and if it has a definition of the "stop"
710 method. This method and conditions entered into GDB from
711 the CLI are mutually exclusive. */
713 && gdbpy_breakpoint_has_py_cond (b
->py_bp_object
))
714 error (_("Cannot set a condition where a Python 'stop' "
715 "method has been defined in the breakpoint."));
716 set_breakpoint_condition (b
, p
, from_tty
);
720 error (_("No breakpoint number %d."), bnum
);
723 /* Check that COMMAND do not contain commands that are suitable
724 only for tracepoints and not suitable for ordinary breakpoints.
725 Throw if any such commands is found. */
728 check_no_tracepoint_commands (struct command_line
*commands
)
730 struct command_line
*c
;
732 for (c
= commands
; c
; c
= c
->next
)
736 if (c
->control_type
== while_stepping_control
)
737 error (_("The 'while-stepping' command can "
738 "only be used for tracepoints"));
740 for (i
= 0; i
< c
->body_count
; ++i
)
741 check_no_tracepoint_commands ((c
->body_list
)[i
]);
743 /* Not that command parsing removes leading whitespace and comment
744 lines and also empty lines. So, we only need to check for
746 if (strstr (c
->line
, "collect ") == c
->line
)
747 error (_("The 'collect' command can only be used for tracepoints"));
749 if (strstr (c
->line
, "teval ") == c
->line
)
750 error (_("The 'teval' command can only be used for tracepoints"));
754 /* Encapsulate tests for different types of tracepoints. */
757 is_tracepoint_type (enum bptype type
)
759 return (type
== bp_tracepoint
760 || type
== bp_fast_tracepoint
761 || type
== bp_static_tracepoint
);
765 is_tracepoint (const struct breakpoint
*b
)
767 return is_tracepoint_type (b
->type
);
770 /* A helper function that validates that COMMANDS are valid for a
771 breakpoint. This function will throw an exception if a problem is
775 validate_commands_for_breakpoint (struct breakpoint
*b
,
776 struct command_line
*commands
)
778 if (is_tracepoint (b
))
780 /* We need to verify that each top-level element of commands is
781 valid for tracepoints, that there's at most one
782 while-stepping element, and that while-stepping's body has
783 valid tracing commands excluding nested while-stepping. */
784 struct command_line
*c
;
785 struct command_line
*while_stepping
= 0;
786 for (c
= commands
; c
; c
= c
->next
)
788 if (c
->control_type
== while_stepping_control
)
790 if (b
->type
== bp_fast_tracepoint
)
791 error (_("The 'while-stepping' command "
792 "cannot be used for fast tracepoint"));
793 else if (b
->type
== bp_static_tracepoint
)
794 error (_("The 'while-stepping' command "
795 "cannot be used for static tracepoint"));
798 error (_("The 'while-stepping' command "
799 "can be used only once"));
806 struct command_line
*c2
;
808 gdb_assert (while_stepping
->body_count
== 1);
809 c2
= while_stepping
->body_list
[0];
810 for (; c2
; c2
= c2
->next
)
812 if (c2
->control_type
== while_stepping_control
)
813 error (_("The 'while-stepping' command cannot be nested"));
819 check_no_tracepoint_commands (commands
);
823 /* Return a vector of all the static tracepoints set at ADDR. The
824 caller is responsible for releasing the vector. */
827 static_tracepoints_here (CORE_ADDR addr
)
829 struct breakpoint
*b
;
830 VEC(breakpoint_p
) *found
= 0;
831 struct bp_location
*loc
;
834 if (b
->type
== bp_static_tracepoint
)
836 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
837 if (loc
->address
== addr
)
838 VEC_safe_push(breakpoint_p
, found
, b
);
844 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
845 validate that only allowed commands are included. */
848 breakpoint_set_commands (struct breakpoint
*b
,
849 struct command_line
*commands
)
851 validate_commands_for_breakpoint (b
, commands
);
853 decref_counted_command_line (&b
->commands
);
854 b
->commands
= alloc_counted_command_line (commands
);
855 breakpoints_changed ();
856 observer_notify_breakpoint_modified (b
);
859 /* Set the internal `silent' flag on the breakpoint. Note that this
860 is not the same as the "silent" that may appear in the breakpoint's
864 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
866 int old_silent
= b
->silent
;
869 if (old_silent
!= silent
)
870 observer_notify_breakpoint_modified (b
);
873 /* Set the thread for this breakpoint. If THREAD is -1, make the
874 breakpoint work for any thread. */
877 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
879 int old_thread
= b
->thread
;
882 if (old_thread
!= thread
)
883 observer_notify_breakpoint_modified (b
);
886 /* Set the task for this breakpoint. If TASK is 0, make the
887 breakpoint work for any task. */
890 breakpoint_set_task (struct breakpoint
*b
, int task
)
892 int old_task
= b
->task
;
895 if (old_task
!= task
)
896 observer_notify_breakpoint_modified (b
);
900 check_tracepoint_command (char *line
, void *closure
)
902 struct breakpoint
*b
= closure
;
904 validate_actionline (&line
, b
);
907 /* A structure used to pass information through
908 map_breakpoint_numbers. */
912 /* True if the command was typed at a tty. */
915 /* The breakpoint range spec. */
918 /* Non-NULL if the body of the commands are being read from this
919 already-parsed command. */
920 struct command_line
*control
;
922 /* The command lines read from the user, or NULL if they have not
924 struct counted_command_line
*cmd
;
927 /* A callback for map_breakpoint_numbers that sets the commands for
931 do_map_commands_command (struct breakpoint
*b
, void *data
)
933 struct commands_info
*info
= data
;
935 if (info
->cmd
== NULL
)
937 struct command_line
*l
;
939 if (info
->control
!= NULL
)
940 l
= copy_command_lines (info
->control
->body_list
[0]);
943 struct cleanup
*old_chain
;
946 str
= xstrprintf (_("Type commands for breakpoint(s) "
947 "%s, one per line."),
950 old_chain
= make_cleanup (xfree
, str
);
952 l
= read_command_lines (str
,
955 ? check_tracepoint_command
: 0),
958 do_cleanups (old_chain
);
961 info
->cmd
= alloc_counted_command_line (l
);
964 /* If a breakpoint was on the list more than once, we don't need to
966 if (b
->commands
!= info
->cmd
)
968 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
969 incref_counted_command_line (info
->cmd
);
970 decref_counted_command_line (&b
->commands
);
971 b
->commands
= info
->cmd
;
972 breakpoints_changed ();
973 observer_notify_breakpoint_modified (b
);
978 commands_command_1 (char *arg
, int from_tty
,
979 struct command_line
*control
)
981 struct cleanup
*cleanups
;
982 struct commands_info info
;
984 info
.from_tty
= from_tty
;
985 info
.control
= control
;
987 /* If we read command lines from the user, then `info' will hold an
988 extra reference to the commands that we must clean up. */
989 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
991 if (arg
== NULL
|| !*arg
)
993 if (breakpoint_count
- prev_breakpoint_count
> 1)
994 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1,
996 else if (breakpoint_count
> 0)
997 arg
= xstrprintf ("%d", breakpoint_count
);
1000 /* So that we don't try to free the incoming non-NULL
1001 argument in the cleanup below. Mapping breakpoint
1002 numbers will fail in this case. */
1007 /* The command loop has some static state, so we need to preserve
1009 arg
= xstrdup (arg
);
1012 make_cleanup (xfree
, arg
);
1016 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
1018 if (info
.cmd
== NULL
)
1019 error (_("No breakpoints specified."));
1021 do_cleanups (cleanups
);
1025 commands_command (char *arg
, int from_tty
)
1027 commands_command_1 (arg
, from_tty
, NULL
);
1030 /* Like commands_command, but instead of reading the commands from
1031 input stream, takes them from an already parsed command structure.
1033 This is used by cli-script.c to DTRT with breakpoint commands
1034 that are part of if and while bodies. */
1035 enum command_control_type
1036 commands_from_control_command (char *arg
, struct command_line
*cmd
)
1038 commands_command_1 (arg
, 0, cmd
);
1039 return simple_control
;
1042 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1045 bp_location_has_shadow (struct bp_location
*bl
)
1047 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1051 if (bl
->target_info
.shadow_len
== 0)
1052 /* BL isn't valid, or doesn't shadow memory. */
1057 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1058 by replacing any memory breakpoints with their shadowed contents.
1060 The range of shadowed area by each bp_location is:
1061 bl->address - bp_location_placed_address_before_address_max
1062 up to bl->address + bp_location_shadow_len_after_address_max
1063 The range we were requested to resolve shadows for is:
1064 memaddr ... memaddr + len
1065 Thus the safe cutoff boundaries for performance optimization are
1066 memaddr + len <= (bl->address
1067 - bp_location_placed_address_before_address_max)
1069 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1072 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1073 const gdb_byte
*writebuf_org
,
1074 ULONGEST memaddr
, LONGEST len
)
1076 /* Left boundary, right boundary and median element of our binary
1078 unsigned bc_l
, bc_r
, bc
;
1080 /* Find BC_L which is a leftmost element which may affect BUF
1081 content. It is safe to report lower value but a failure to
1082 report higher one. */
1085 bc_r
= bp_location_count
;
1086 while (bc_l
+ 1 < bc_r
)
1088 struct bp_location
*bl
;
1090 bc
= (bc_l
+ bc_r
) / 2;
1091 bl
= bp_location
[bc
];
1093 /* Check first BL->ADDRESS will not overflow due to the added
1094 constant. Then advance the left boundary only if we are sure
1095 the BC element can in no way affect the BUF content (MEMADDR
1096 to MEMADDR + LEN range).
1098 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1099 offset so that we cannot miss a breakpoint with its shadow
1100 range tail still reaching MEMADDR. */
1102 if ((bl
->address
+ bp_location_shadow_len_after_address_max
1104 && (bl
->address
+ bp_location_shadow_len_after_address_max
1111 /* Due to the binary search above, we need to make sure we pick the
1112 first location that's at BC_L's address. E.g., if there are
1113 multiple locations at the same address, BC_L may end up pointing
1114 at a duplicate location, and miss the "master"/"inserted"
1115 location. Say, given locations L1, L2 and L3 at addresses A and
1118 L1@A, L2@A, L3@B, ...
1120 BC_L could end up pointing at location L2, while the "master"
1121 location could be L1. Since the `loc->inserted' flag is only set
1122 on "master" locations, we'd forget to restore the shadow of L1
1125 && bp_location
[bc_l
]->address
== bp_location
[bc_l
- 1]->address
)
1128 /* Now do full processing of the found relevant range of elements. */
1130 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1132 struct bp_location
*bl
= bp_location
[bc
];
1133 CORE_ADDR bp_addr
= 0;
1137 /* bp_location array has BL->OWNER always non-NULL. */
1138 if (bl
->owner
->type
== bp_none
)
1139 warning (_("reading through apparently deleted breakpoint #%d?"),
1142 /* Performance optimization: any further element can no longer affect BUF
1145 if (bl
->address
>= bp_location_placed_address_before_address_max
1146 && memaddr
+ len
<= (bl
->address
1147 - bp_location_placed_address_before_address_max
))
1150 if (!bp_location_has_shadow (bl
))
1152 if (!breakpoint_address_match (bl
->target_info
.placed_address_space
, 0,
1153 current_program_space
->aspace
, 0))
1156 /* Addresses and length of the part of the breakpoint that
1158 bp_addr
= bl
->target_info
.placed_address
;
1159 bp_size
= bl
->target_info
.shadow_len
;
1161 if (bp_addr
+ bp_size
<= memaddr
)
1162 /* The breakpoint is entirely before the chunk of memory we
1166 if (bp_addr
>= memaddr
+ len
)
1167 /* The breakpoint is entirely after the chunk of memory we are
1171 /* Offset within shadow_contents. */
1172 if (bp_addr
< memaddr
)
1174 /* Only copy the second part of the breakpoint. */
1175 bp_size
-= memaddr
- bp_addr
;
1176 bptoffset
= memaddr
- bp_addr
;
1180 if (bp_addr
+ bp_size
> memaddr
+ len
)
1182 /* Only copy the first part of the breakpoint. */
1183 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1186 if (readbuf
!= NULL
)
1188 /* Update the read buffer with this inserted breakpoint's
1190 memcpy (readbuf
+ bp_addr
- memaddr
,
1191 bl
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
1195 struct gdbarch
*gdbarch
= bl
->gdbarch
;
1196 const unsigned char *bp
;
1197 CORE_ADDR placed_address
= bl
->target_info
.placed_address
;
1198 unsigned placed_size
= bl
->target_info
.placed_size
;
1200 /* Update the shadow with what we want to write to memory. */
1201 memcpy (bl
->target_info
.shadow_contents
+ bptoffset
,
1202 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1204 /* Determine appropriate breakpoint contents and size for this
1206 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &placed_address
, &placed_size
);
1208 /* Update the final write buffer with this inserted
1209 breakpoint's INSN. */
1210 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1216 /* Return true if BPT is of any hardware watchpoint kind. */
1219 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1221 return (bpt
->type
== bp_hardware_watchpoint
1222 || bpt
->type
== bp_read_watchpoint
1223 || bpt
->type
== bp_access_watchpoint
);
1226 /* Return true if BPT is of any watchpoint kind, hardware or
1230 is_watchpoint (const struct breakpoint
*bpt
)
1232 return (is_hardware_watchpoint (bpt
)
1233 || bpt
->type
== bp_watchpoint
);
1236 /* Returns true if the current thread and its running state are safe
1237 to evaluate or update watchpoint B. Watchpoints on local
1238 expressions need to be evaluated in the context of the thread that
1239 was current when the watchpoint was created, and, that thread needs
1240 to be stopped to be able to select the correct frame context.
1241 Watchpoints on global expressions can be evaluated on any thread,
1242 and in any state. It is presently left to the target allowing
1243 memory accesses when threads are running. */
1246 watchpoint_in_thread_scope (struct watchpoint
*b
)
1248 return (b
->base
.pspace
== current_program_space
1249 && (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1250 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1251 && !is_executing (inferior_ptid
))));
1254 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1255 associated bp_watchpoint_scope breakpoint. */
1258 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1260 struct breakpoint
*b
= &w
->base
;
1262 if (b
->related_breakpoint
!= b
)
1264 gdb_assert (b
->related_breakpoint
->type
== bp_watchpoint_scope
);
1265 gdb_assert (b
->related_breakpoint
->related_breakpoint
== b
);
1266 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1267 b
->related_breakpoint
->related_breakpoint
= b
->related_breakpoint
;
1268 b
->related_breakpoint
= b
;
1270 b
->disposition
= disp_del_at_next_stop
;
1273 /* Assuming that B is a watchpoint:
1274 - Reparse watchpoint expression, if REPARSE is non-zero
1275 - Evaluate expression and store the result in B->val
1276 - Evaluate the condition if there is one, and store the result
1278 - Update the list of values that must be watched in B->loc.
1280 If the watchpoint disposition is disp_del_at_next_stop, then do
1281 nothing. If this is local watchpoint that is out of scope, delete
1284 Even with `set breakpoint always-inserted on' the watchpoints are
1285 removed + inserted on each stop here. Normal breakpoints must
1286 never be removed because they might be missed by a running thread
1287 when debugging in non-stop mode. On the other hand, hardware
1288 watchpoints (is_hardware_watchpoint; processed here) are specific
1289 to each LWP since they are stored in each LWP's hardware debug
1290 registers. Therefore, such LWP must be stopped first in order to
1291 be able to modify its hardware watchpoints.
1293 Hardware watchpoints must be reset exactly once after being
1294 presented to the user. It cannot be done sooner, because it would
1295 reset the data used to present the watchpoint hit to the user. And
1296 it must not be done later because it could display the same single
1297 watchpoint hit during multiple GDB stops. Note that the latter is
1298 relevant only to the hardware watchpoint types bp_read_watchpoint
1299 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1300 not user-visible - its hit is suppressed if the memory content has
1303 The following constraints influence the location where we can reset
1304 hardware watchpoints:
1306 * target_stopped_by_watchpoint and target_stopped_data_address are
1307 called several times when GDB stops.
1310 * Multiple hardware watchpoints can be hit at the same time,
1311 causing GDB to stop. GDB only presents one hardware watchpoint
1312 hit at a time as the reason for stopping, and all the other hits
1313 are presented later, one after the other, each time the user
1314 requests the execution to be resumed. Execution is not resumed
1315 for the threads still having pending hit event stored in
1316 LWP_INFO->STATUS. While the watchpoint is already removed from
1317 the inferior on the first stop the thread hit event is kept being
1318 reported from its cached value by linux_nat_stopped_data_address
1319 until the real thread resume happens after the watchpoint gets
1320 presented and thus its LWP_INFO->STATUS gets reset.
1322 Therefore the hardware watchpoint hit can get safely reset on the
1323 watchpoint removal from inferior. */
1326 update_watchpoint (struct watchpoint
*b
, int reparse
)
1328 int within_current_scope
;
1329 struct frame_id saved_frame_id
;
1332 /* If this is a local watchpoint, we only want to check if the
1333 watchpoint frame is in scope if the current thread is the thread
1334 that was used to create the watchpoint. */
1335 if (!watchpoint_in_thread_scope (b
))
1338 if (b
->base
.disposition
== disp_del_at_next_stop
)
1343 /* Determine if the watchpoint is within scope. */
1344 if (b
->exp_valid_block
== NULL
)
1345 within_current_scope
= 1;
1348 struct frame_info
*fi
= get_current_frame ();
1349 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1350 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1352 /* If we're in a function epilogue, unwinding may not work
1353 properly, so do not attempt to recreate locations at this
1354 point. See similar comments in watchpoint_check. */
1355 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
1358 /* Save the current frame's ID so we can restore it after
1359 evaluating the watchpoint expression on its own frame. */
1360 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1361 took a frame parameter, so that we didn't have to change the
1364 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1366 fi
= frame_find_by_id (b
->watchpoint_frame
);
1367 within_current_scope
= (fi
!= NULL
);
1368 if (within_current_scope
)
1372 /* We don't free locations. They are stored in the bp_location array
1373 and update_global_location_list will eventually delete them and
1374 remove breakpoints if needed. */
1377 if (within_current_scope
&& reparse
)
1386 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1387 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1388 /* If the meaning of expression itself changed, the old value is
1389 no longer relevant. We don't want to report a watchpoint hit
1390 to the user when the old value and the new value may actually
1391 be completely different objects. */
1392 value_free (b
->val
);
1396 /* Note that unlike with breakpoints, the watchpoint's condition
1397 expression is stored in the breakpoint object, not in the
1398 locations (re)created below. */
1399 if (b
->base
.cond_string
!= NULL
)
1401 if (b
->cond_exp
!= NULL
)
1403 xfree (b
->cond_exp
);
1407 s
= b
->base
.cond_string
;
1408 b
->cond_exp
= parse_exp_1 (&s
, b
->cond_exp_valid_block
, 0);
1412 /* If we failed to parse the expression, for example because
1413 it refers to a global variable in a not-yet-loaded shared library,
1414 don't try to insert watchpoint. We don't automatically delete
1415 such watchpoint, though, since failure to parse expression
1416 is different from out-of-scope watchpoint. */
1417 if ( !target_has_execution
)
1419 /* Without execution, memory can't change. No use to try and
1420 set watchpoint locations. The watchpoint will be reset when
1421 the target gains execution, through breakpoint_re_set. */
1423 else if (within_current_scope
&& b
->exp
)
1426 struct value
*val_chain
, *v
, *result
, *next
;
1427 struct program_space
*frame_pspace
;
1429 fetch_subexp_value (b
->exp
, &pc
, &v
, &result
, &val_chain
);
1431 /* Avoid setting b->val if it's already set. The meaning of
1432 b->val is 'the last value' user saw, and we should update
1433 it only if we reported that last value to user. As it
1434 happens, the code that reports it updates b->val directly.
1435 We don't keep track of the memory value for masked
1437 if (!b
->val_valid
&& !is_masked_watchpoint (&b
->base
))
1443 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1445 /* Look at each value on the value chain. */
1446 for (v
= val_chain
; v
; v
= value_next (v
))
1448 /* If it's a memory location, and GDB actually needed
1449 its contents to evaluate the expression, then we
1450 must watch it. If the first value returned is
1451 still lazy, that means an error occurred reading it;
1452 watch it anyway in case it becomes readable. */
1453 if (VALUE_LVAL (v
) == lval_memory
1454 && (v
== val_chain
|| ! value_lazy (v
)))
1456 struct type
*vtype
= check_typedef (value_type (v
));
1458 /* We only watch structs and arrays if user asked
1459 for it explicitly, never if they just happen to
1460 appear in the middle of some value chain. */
1462 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1463 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1467 struct bp_location
*loc
, **tmp
;
1469 addr
= value_address (v
);
1470 len
= TYPE_LENGTH (value_type (v
));
1472 if (b
->base
.type
== bp_read_watchpoint
)
1474 else if (b
->base
.type
== bp_access_watchpoint
)
1477 loc
= allocate_bp_location (&b
->base
);
1478 for (tmp
= &(b
->base
.loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1481 loc
->gdbarch
= get_type_arch (value_type (v
));
1483 loc
->pspace
= frame_pspace
;
1484 loc
->address
= addr
;
1486 loc
->watchpoint_type
= type
;
1491 /* Change the type of breakpoint between hardware assisted or
1492 an ordinary watchpoint depending on the hardware support
1493 and free hardware slots. REPARSE is set when the inferior
1498 enum bp_loc_type loc_type
;
1499 struct bp_location
*bl
;
1501 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
1505 int i
, target_resources_ok
, other_type_used
;
1508 /* Use an exact watchpoint when there's only one memory region to be
1509 watched, and only one debug register is needed to watch it. */
1510 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
1512 /* We need to determine how many resources are already
1513 used for all other hardware watchpoints plus this one
1514 to see if we still have enough resources to also fit
1515 this watchpoint in as well. */
1517 /* If this is a software watchpoint, we try to turn it
1518 to a hardware one -- count resources as if B was of
1519 hardware watchpoint type. */
1520 type
= b
->base
.type
;
1521 if (type
== bp_watchpoint
)
1522 type
= bp_hardware_watchpoint
;
1524 /* This watchpoint may or may not have been placed on
1525 the list yet at this point (it won't be in the list
1526 if we're trying to create it for the first time,
1527 through watch_command), so always account for it
1530 /* Count resources used by all watchpoints except B. */
1531 i
= hw_watchpoint_used_count_others (&b
->base
, type
, &other_type_used
);
1533 /* Add in the resources needed for B. */
1534 i
+= hw_watchpoint_use_count (&b
->base
);
1537 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
1538 if (target_resources_ok
<= 0)
1540 int sw_mode
= b
->base
.ops
->works_in_software_mode (&b
->base
);
1542 if (target_resources_ok
== 0 && !sw_mode
)
1543 error (_("Target does not support this type of "
1544 "hardware watchpoint."));
1545 else if (target_resources_ok
< 0 && !sw_mode
)
1546 error (_("There are not enough available hardware "
1547 "resources for this watchpoint."));
1549 /* Downgrade to software watchpoint. */
1550 b
->base
.type
= bp_watchpoint
;
1554 /* If this was a software watchpoint, we've just
1555 found we have enough resources to turn it to a
1556 hardware watchpoint. Otherwise, this is a
1558 b
->base
.type
= type
;
1561 else if (!b
->base
.ops
->works_in_software_mode (&b
->base
))
1562 error (_("Expression cannot be implemented with "
1563 "read/access watchpoint."));
1565 b
->base
.type
= bp_watchpoint
;
1567 loc_type
= (b
->base
.type
== bp_watchpoint
? bp_loc_other
1568 : bp_loc_hardware_watchpoint
);
1569 for (bl
= b
->base
.loc
; bl
; bl
= bl
->next
)
1570 bl
->loc_type
= loc_type
;
1573 for (v
= val_chain
; v
; v
= next
)
1575 next
= value_next (v
);
1580 /* If a software watchpoint is not watching any memory, then the
1581 above left it without any location set up. But,
1582 bpstat_stop_status requires a location to be able to report
1583 stops, so make sure there's at least a dummy one. */
1584 if (b
->base
.type
== bp_watchpoint
&& b
->base
.loc
== NULL
)
1586 struct breakpoint
*base
= &b
->base
;
1587 base
->loc
= allocate_bp_location (base
);
1588 base
->loc
->pspace
= frame_pspace
;
1589 base
->loc
->address
= -1;
1590 base
->loc
->length
= -1;
1591 base
->loc
->watchpoint_type
= -1;
1594 else if (!within_current_scope
)
1596 printf_filtered (_("\
1597 Watchpoint %d deleted because the program has left the block\n\
1598 in which its expression is valid.\n"),
1600 watchpoint_del_at_next_stop (b
);
1603 /* Restore the selected frame. */
1605 select_frame (frame_find_by_id (saved_frame_id
));
1609 /* Returns 1 iff breakpoint location should be
1610 inserted in the inferior. We don't differentiate the type of BL's owner
1611 (breakpoint vs. tracepoint), although insert_location in tracepoint's
1612 breakpoint_ops is not defined, because in insert_bp_location,
1613 tracepoint's insert_location will not be called. */
1615 should_be_inserted (struct bp_location
*bl
)
1617 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
1620 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
1623 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
1626 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
1629 /* This is set for example, when we're attached to the parent of a
1630 vfork, and have detached from the child. The child is running
1631 free, and we expect it to do an exec or exit, at which point the
1632 OS makes the parent schedulable again (and the target reports
1633 that the vfork is done). Until the child is done with the shared
1634 memory region, do not insert breakpoints in the parent, otherwise
1635 the child could still trip on the parent's breakpoints. Since
1636 the parent is blocked anyway, it won't miss any breakpoint. */
1637 if (bl
->pspace
->breakpoints_not_allowed
)
1643 /* Same as should_be_inserted but does the check assuming
1644 that the location is not duplicated. */
1647 unduplicated_should_be_inserted (struct bp_location
*bl
)
1650 const int save_duplicate
= bl
->duplicate
;
1653 result
= should_be_inserted (bl
);
1654 bl
->duplicate
= save_duplicate
;
1658 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
1659 location. Any error messages are printed to TMP_ERROR_STREAM; and
1660 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
1661 Returns 0 for success, 1 if the bp_location type is not supported or
1664 NOTE drow/2003-09-09: This routine could be broken down to an
1665 object-style method for each breakpoint or catchpoint type. */
1667 insert_bp_location (struct bp_location
*bl
,
1668 struct ui_file
*tmp_error_stream
,
1669 int *disabled_breaks
,
1670 int *hw_breakpoint_error
)
1674 if (!should_be_inserted (bl
) || bl
->inserted
)
1677 /* Initialize the target-specific information. */
1678 memset (&bl
->target_info
, 0, sizeof (bl
->target_info
));
1679 bl
->target_info
.placed_address
= bl
->address
;
1680 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
1681 bl
->target_info
.length
= bl
->length
;
1683 if (bl
->loc_type
== bp_loc_software_breakpoint
1684 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
1686 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
1688 /* If the explicitly specified breakpoint type
1689 is not hardware breakpoint, check the memory map to see
1690 if the breakpoint address is in read only memory or not.
1692 Two important cases are:
1693 - location type is not hardware breakpoint, memory
1694 is readonly. We change the type of the location to
1695 hardware breakpoint.
1696 - location type is hardware breakpoint, memory is
1697 read-write. This means we've previously made the
1698 location hardware one, but then the memory map changed,
1701 When breakpoints are removed, remove_breakpoints will use
1702 location types we've just set here, the only possible
1703 problem is that memory map has changed during running
1704 program, but it's not going to work anyway with current
1706 struct mem_region
*mr
1707 = lookup_mem_region (bl
->target_info
.placed_address
);
1711 if (automatic_hardware_breakpoints
)
1713 enum bp_loc_type new_type
;
1715 if (mr
->attrib
.mode
!= MEM_RW
)
1716 new_type
= bp_loc_hardware_breakpoint
;
1718 new_type
= bp_loc_software_breakpoint
;
1720 if (new_type
!= bl
->loc_type
)
1722 static int said
= 0;
1724 bl
->loc_type
= new_type
;
1727 fprintf_filtered (gdb_stdout
,
1728 _("Note: automatically using "
1729 "hardware breakpoints for "
1730 "read-only addresses.\n"));
1735 else if (bl
->loc_type
== bp_loc_software_breakpoint
1736 && mr
->attrib
.mode
!= MEM_RW
)
1737 warning (_("cannot set software breakpoint "
1738 "at readonly address %s"),
1739 paddress (bl
->gdbarch
, bl
->address
));
1743 /* First check to see if we have to handle an overlay. */
1744 if (overlay_debugging
== ovly_off
1745 || bl
->section
== NULL
1746 || !(section_is_overlay (bl
->section
)))
1748 /* No overlay handling: just set the breakpoint. */
1750 val
= bl
->owner
->ops
->insert_location (bl
);
1754 /* This breakpoint is in an overlay section.
1755 Shall we set a breakpoint at the LMA? */
1756 if (!overlay_events_enabled
)
1758 /* Yes -- overlay event support is not active,
1759 so we must try to set a breakpoint at the LMA.
1760 This will not work for a hardware breakpoint. */
1761 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1762 warning (_("hardware breakpoint %d not supported in overlay!"),
1766 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
1768 /* Set a software (trap) breakpoint at the LMA. */
1769 bl
->overlay_target_info
= bl
->target_info
;
1770 bl
->overlay_target_info
.placed_address
= addr
;
1771 val
= target_insert_breakpoint (bl
->gdbarch
,
1772 &bl
->overlay_target_info
);
1774 fprintf_unfiltered (tmp_error_stream
,
1775 "Overlay breakpoint %d "
1776 "failed: in ROM?\n",
1780 /* Shall we set a breakpoint at the VMA? */
1781 if (section_is_mapped (bl
->section
))
1783 /* Yes. This overlay section is mapped into memory. */
1784 val
= bl
->owner
->ops
->insert_location (bl
);
1788 /* No. This breakpoint will not be inserted.
1789 No error, but do not mark the bp as 'inserted'. */
1796 /* Can't set the breakpoint. */
1797 if (solib_name_from_address (bl
->pspace
, bl
->address
))
1799 /* See also: disable_breakpoints_in_shlibs. */
1801 bl
->shlib_disabled
= 1;
1802 observer_notify_breakpoint_modified (bl
->owner
);
1803 if (!*disabled_breaks
)
1805 fprintf_unfiltered (tmp_error_stream
,
1806 "Cannot insert breakpoint %d.\n",
1808 fprintf_unfiltered (tmp_error_stream
,
1809 "Temporarily disabling shared "
1810 "library breakpoints:\n");
1812 *disabled_breaks
= 1;
1813 fprintf_unfiltered (tmp_error_stream
,
1814 "breakpoint #%d\n", bl
->owner
->number
);
1818 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1820 *hw_breakpoint_error
= 1;
1821 fprintf_unfiltered (tmp_error_stream
,
1822 "Cannot insert hardware "
1828 fprintf_unfiltered (tmp_error_stream
,
1829 "Cannot insert breakpoint %d.\n",
1831 fprintf_filtered (tmp_error_stream
,
1832 "Error accessing memory address ");
1833 fputs_filtered (paddress (bl
->gdbarch
, bl
->address
),
1835 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1836 safe_strerror (val
));
1847 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
1848 /* NOTE drow/2003-09-08: This state only exists for removing
1849 watchpoints. It's not clear that it's necessary... */
1850 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
1852 gdb_assert (bl
->owner
->ops
!= NULL
1853 && bl
->owner
->ops
->insert_location
!= NULL
);
1855 val
= bl
->owner
->ops
->insert_location (bl
);
1857 /* If trying to set a read-watchpoint, and it turns out it's not
1858 supported, try emulating one with an access watchpoint. */
1859 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
1861 struct bp_location
*loc
, **loc_temp
;
1863 /* But don't try to insert it, if there's already another
1864 hw_access location that would be considered a duplicate
1866 ALL_BP_LOCATIONS (loc
, loc_temp
)
1868 && loc
->watchpoint_type
== hw_access
1869 && watchpoint_locations_match (bl
, loc
))
1873 bl
->target_info
= loc
->target_info
;
1874 bl
->watchpoint_type
= hw_access
;
1881 bl
->watchpoint_type
= hw_access
;
1882 val
= bl
->owner
->ops
->insert_location (bl
);
1885 /* Back to the original value. */
1886 bl
->watchpoint_type
= hw_read
;
1890 bl
->inserted
= (val
== 0);
1893 else if (bl
->owner
->type
== bp_catchpoint
)
1895 gdb_assert (bl
->owner
->ops
!= NULL
1896 && bl
->owner
->ops
->insert_location
!= NULL
);
1898 val
= bl
->owner
->ops
->insert_location (bl
);
1901 bl
->owner
->enable_state
= bp_disabled
;
1905 Error inserting catchpoint %d: Your system does not support this type\n\
1906 of catchpoint."), bl
->owner
->number
);
1908 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
1911 bl
->inserted
= (val
== 0);
1913 /* We've already printed an error message if there was a problem
1914 inserting this catchpoint, and we've disabled the catchpoint,
1915 so just return success. */
1922 /* This function is called when program space PSPACE is about to be
1923 deleted. It takes care of updating breakpoints to not reference
1927 breakpoint_program_space_exit (struct program_space
*pspace
)
1929 struct breakpoint
*b
, *b_temp
;
1930 struct bp_location
*loc
, **loc_temp
;
1932 /* Remove any breakpoint that was set through this program space. */
1933 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1935 if (b
->pspace
== pspace
)
1936 delete_breakpoint (b
);
1939 /* Breakpoints set through other program spaces could have locations
1940 bound to PSPACE as well. Remove those. */
1941 ALL_BP_LOCATIONS (loc
, loc_temp
)
1943 struct bp_location
*tmp
;
1945 if (loc
->pspace
== pspace
)
1947 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1948 if (loc
->owner
->loc
== loc
)
1949 loc
->owner
->loc
= loc
->next
;
1951 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1952 if (tmp
->next
== loc
)
1954 tmp
->next
= loc
->next
;
1960 /* Now update the global location list to permanently delete the
1961 removed locations above. */
1962 update_global_location_list (0);
1965 /* Make sure all breakpoints are inserted in inferior.
1966 Throws exception on any error.
1967 A breakpoint that is already inserted won't be inserted
1968 again, so calling this function twice is safe. */
1970 insert_breakpoints (void)
1972 struct breakpoint
*bpt
;
1974 ALL_BREAKPOINTS (bpt
)
1975 if (is_hardware_watchpoint (bpt
))
1977 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
1979 update_watchpoint (w
, 0 /* don't reparse. */);
1982 update_global_location_list (1);
1984 /* update_global_location_list does not insert breakpoints when
1985 always_inserted_mode is not enabled. Explicitly insert them
1987 if (!breakpoints_always_inserted_mode ())
1988 insert_breakpoint_locations ();
1991 /* Used when starting or continuing the program. */
1994 insert_breakpoint_locations (void)
1996 struct breakpoint
*bpt
;
1997 struct bp_location
*bl
, **blp_tmp
;
2000 int disabled_breaks
= 0;
2001 int hw_breakpoint_error
= 0;
2003 struct ui_file
*tmp_error_stream
= mem_fileopen ();
2004 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
2006 /* Explicitly mark the warning -- this will only be printed if
2007 there was an error. */
2008 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
2010 save_current_space_and_thread ();
2012 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2014 if (!should_be_inserted (bl
) || bl
->inserted
)
2017 /* There is no point inserting thread-specific breakpoints if
2018 the thread no longer exists. ALL_BP_LOCATIONS bp_location
2019 has BL->OWNER always non-NULL. */
2020 if (bl
->owner
->thread
!= -1
2021 && !valid_thread_id (bl
->owner
->thread
))
2024 switch_to_program_space_and_thread (bl
->pspace
);
2026 /* For targets that support global breakpoints, there's no need
2027 to select an inferior to insert breakpoint to. In fact, even
2028 if we aren't attached to any process yet, we should still
2029 insert breakpoints. */
2030 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
2031 && ptid_equal (inferior_ptid
, null_ptid
))
2034 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
2035 &hw_breakpoint_error
);
2040 /* If we failed to insert all locations of a watchpoint, remove
2041 them, as half-inserted watchpoint is of limited use. */
2042 ALL_BREAKPOINTS (bpt
)
2044 int some_failed
= 0;
2045 struct bp_location
*loc
;
2047 if (!is_hardware_watchpoint (bpt
))
2050 if (!breakpoint_enabled (bpt
))
2053 if (bpt
->disposition
== disp_del_at_next_stop
)
2056 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2057 if (!loc
->inserted
&& should_be_inserted (loc
))
2064 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2066 remove_breakpoint (loc
, mark_uninserted
);
2068 hw_breakpoint_error
= 1;
2069 fprintf_unfiltered (tmp_error_stream
,
2070 "Could not insert hardware watchpoint %d.\n",
2078 /* If a hardware breakpoint or watchpoint was inserted, add a
2079 message about possibly exhausted resources. */
2080 if (hw_breakpoint_error
)
2082 fprintf_unfiltered (tmp_error_stream
,
2083 "Could not insert hardware breakpoints:\n\
2084 You may have requested too many hardware breakpoints/watchpoints.\n");
2086 target_terminal_ours_for_output ();
2087 error_stream (tmp_error_stream
);
2090 do_cleanups (cleanups
);
2093 /* Used when the program stops.
2094 Returns zero if successful, or non-zero if there was a problem
2095 removing a breakpoint location. */
2098 remove_breakpoints (void)
2100 struct bp_location
*bl
, **blp_tmp
;
2103 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2105 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
2106 val
|= remove_breakpoint (bl
, mark_uninserted
);
2111 /* Remove breakpoints of process PID. */
2114 remove_breakpoints_pid (int pid
)
2116 struct bp_location
*bl
, **blp_tmp
;
2118 struct inferior
*inf
= find_inferior_pid (pid
);
2120 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2122 if (bl
->pspace
!= inf
->pspace
)
2127 val
= remove_breakpoint (bl
, mark_uninserted
);
2136 reattach_breakpoints (int pid
)
2138 struct cleanup
*old_chain
;
2139 struct bp_location
*bl
, **blp_tmp
;
2141 struct ui_file
*tmp_error_stream
;
2142 int dummy1
= 0, dummy2
= 0;
2143 struct inferior
*inf
;
2144 struct thread_info
*tp
;
2146 tp
= any_live_thread_of_process (pid
);
2150 inf
= find_inferior_pid (pid
);
2151 old_chain
= save_inferior_ptid ();
2153 inferior_ptid
= tp
->ptid
;
2155 tmp_error_stream
= mem_fileopen ();
2156 make_cleanup_ui_file_delete (tmp_error_stream
);
2158 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2160 if (bl
->pspace
!= inf
->pspace
)
2166 val
= insert_bp_location (bl
, tmp_error_stream
, &dummy1
, &dummy2
);
2169 do_cleanups (old_chain
);
2174 do_cleanups (old_chain
);
2178 static int internal_breakpoint_number
= -1;
2180 /* Set the breakpoint number of B, depending on the value of INTERNAL.
2181 If INTERNAL is non-zero, the breakpoint number will be populated
2182 from internal_breakpoint_number and that variable decremented.
2183 Otherwise the breakpoint number will be populated from
2184 breakpoint_count and that value incremented. Internal breakpoints
2185 do not set the internal var bpnum. */
2187 set_breakpoint_number (int internal
, struct breakpoint
*b
)
2190 b
->number
= internal_breakpoint_number
--;
2193 set_breakpoint_count (breakpoint_count
+ 1);
2194 b
->number
= breakpoint_count
;
2198 static struct breakpoint
*
2199 create_internal_breakpoint (struct gdbarch
*gdbarch
,
2200 CORE_ADDR address
, enum bptype type
,
2201 const struct breakpoint_ops
*ops
)
2203 struct symtab_and_line sal
;
2204 struct breakpoint
*b
;
2206 init_sal (&sal
); /* Initialize to zeroes. */
2209 sal
.section
= find_pc_overlay (sal
.pc
);
2210 sal
.pspace
= current_program_space
;
2212 b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
2213 b
->number
= internal_breakpoint_number
--;
2214 b
->disposition
= disp_donttouch
;
2219 static const char *const longjmp_names
[] =
2221 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
2223 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
2225 /* Per-objfile data private to breakpoint.c. */
2226 struct breakpoint_objfile_data
2228 /* Minimal symbol for "_ovly_debug_event" (if any). */
2229 struct minimal_symbol
*overlay_msym
;
2231 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
2232 struct minimal_symbol
*longjmp_msym
[NUM_LONGJMP_NAMES
];
2234 /* Minimal symbol for "std::terminate()" (if any). */
2235 struct minimal_symbol
*terminate_msym
;
2237 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
2238 struct minimal_symbol
*exception_msym
;
2241 static const struct objfile_data
*breakpoint_objfile_key
;
2243 /* Minimal symbol not found sentinel. */
2244 static struct minimal_symbol msym_not_found
;
2246 /* Returns TRUE if MSYM point to the "not found" sentinel. */
2249 msym_not_found_p (const struct minimal_symbol
*msym
)
2251 return msym
== &msym_not_found
;
2254 /* Return per-objfile data needed by breakpoint.c.
2255 Allocate the data if necessary. */
2257 static struct breakpoint_objfile_data
*
2258 get_breakpoint_objfile_data (struct objfile
*objfile
)
2260 struct breakpoint_objfile_data
*bp_objfile_data
;
2262 bp_objfile_data
= objfile_data (objfile
, breakpoint_objfile_key
);
2263 if (bp_objfile_data
== NULL
)
2265 bp_objfile_data
= obstack_alloc (&objfile
->objfile_obstack
,
2266 sizeof (*bp_objfile_data
));
2268 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
2269 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
2271 return bp_objfile_data
;
2275 create_overlay_event_breakpoint (void)
2277 struct objfile
*objfile
;
2278 const char *const func_name
= "_ovly_debug_event";
2280 ALL_OBJFILES (objfile
)
2282 struct breakpoint
*b
;
2283 struct breakpoint_objfile_data
*bp_objfile_data
;
2286 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2288 if (msym_not_found_p (bp_objfile_data
->overlay_msym
))
2291 if (bp_objfile_data
->overlay_msym
== NULL
)
2293 struct minimal_symbol
*m
;
2295 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2298 /* Avoid future lookups in this objfile. */
2299 bp_objfile_data
->overlay_msym
= &msym_not_found
;
2302 bp_objfile_data
->overlay_msym
= m
;
2305 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
2306 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2308 &internal_breakpoint_ops
);
2309 b
->addr_string
= xstrdup (func_name
);
2311 if (overlay_debugging
== ovly_auto
)
2313 b
->enable_state
= bp_enabled
;
2314 overlay_events_enabled
= 1;
2318 b
->enable_state
= bp_disabled
;
2319 overlay_events_enabled
= 0;
2322 update_global_location_list (1);
2326 create_longjmp_master_breakpoint (void)
2328 struct program_space
*pspace
;
2329 struct cleanup
*old_chain
;
2331 old_chain
= save_current_program_space ();
2333 ALL_PSPACES (pspace
)
2335 struct objfile
*objfile
;
2337 set_current_program_space (pspace
);
2339 ALL_OBJFILES (objfile
)
2342 struct gdbarch
*gdbarch
;
2343 struct breakpoint_objfile_data
*bp_objfile_data
;
2345 gdbarch
= get_objfile_arch (objfile
);
2346 if (!gdbarch_get_longjmp_target_p (gdbarch
))
2349 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2351 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
2353 struct breakpoint
*b
;
2354 const char *func_name
;
2357 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
]))
2360 func_name
= longjmp_names
[i
];
2361 if (bp_objfile_data
->longjmp_msym
[i
] == NULL
)
2363 struct minimal_symbol
*m
;
2365 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2368 /* Prevent future lookups in this objfile. */
2369 bp_objfile_data
->longjmp_msym
[i
] = &msym_not_found
;
2372 bp_objfile_data
->longjmp_msym
[i
] = m
;
2375 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
2376 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
2377 &internal_breakpoint_ops
);
2378 b
->addr_string
= xstrdup (func_name
);
2379 b
->enable_state
= bp_disabled
;
2383 update_global_location_list (1);
2385 do_cleanups (old_chain
);
2388 /* Create a master std::terminate breakpoint. */
2390 create_std_terminate_master_breakpoint (void)
2392 struct program_space
*pspace
;
2393 struct cleanup
*old_chain
;
2394 const char *const func_name
= "std::terminate()";
2396 old_chain
= save_current_program_space ();
2398 ALL_PSPACES (pspace
)
2400 struct objfile
*objfile
;
2403 set_current_program_space (pspace
);
2405 ALL_OBJFILES (objfile
)
2407 struct breakpoint
*b
;
2408 struct breakpoint_objfile_data
*bp_objfile_data
;
2410 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2412 if (msym_not_found_p (bp_objfile_data
->terminate_msym
))
2415 if (bp_objfile_data
->terminate_msym
== NULL
)
2417 struct minimal_symbol
*m
;
2419 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2420 if (m
== NULL
|| (MSYMBOL_TYPE (m
) != mst_text
2421 && MSYMBOL_TYPE (m
) != mst_file_text
))
2423 /* Prevent future lookups in this objfile. */
2424 bp_objfile_data
->terminate_msym
= &msym_not_found
;
2427 bp_objfile_data
->terminate_msym
= m
;
2430 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
2431 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2432 bp_std_terminate_master
,
2433 &internal_breakpoint_ops
);
2434 b
->addr_string
= xstrdup (func_name
);
2435 b
->enable_state
= bp_disabled
;
2439 update_global_location_list (1);
2441 do_cleanups (old_chain
);
2444 /* Install a master breakpoint on the unwinder's debug hook. */
2447 create_exception_master_breakpoint (void)
2449 struct objfile
*objfile
;
2450 const char *const func_name
= "_Unwind_DebugHook";
2452 ALL_OBJFILES (objfile
)
2454 struct breakpoint
*b
;
2455 struct gdbarch
*gdbarch
;
2456 struct breakpoint_objfile_data
*bp_objfile_data
;
2459 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2461 if (msym_not_found_p (bp_objfile_data
->exception_msym
))
2464 gdbarch
= get_objfile_arch (objfile
);
2466 if (bp_objfile_data
->exception_msym
== NULL
)
2468 struct minimal_symbol
*debug_hook
;
2470 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2471 if (debug_hook
== NULL
)
2473 bp_objfile_data
->exception_msym
= &msym_not_found
;
2477 bp_objfile_data
->exception_msym
= debug_hook
;
2480 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
2481 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2483 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
2484 &internal_breakpoint_ops
);
2485 b
->addr_string
= xstrdup (func_name
);
2486 b
->enable_state
= bp_disabled
;
2489 update_global_location_list (1);
2493 update_breakpoints_after_exec (void)
2495 struct breakpoint
*b
, *b_tmp
;
2496 struct bp_location
*bploc
, **bplocp_tmp
;
2498 /* We're about to delete breakpoints from GDB's lists. If the
2499 INSERTED flag is true, GDB will try to lift the breakpoints by
2500 writing the breakpoints' "shadow contents" back into memory. The
2501 "shadow contents" are NOT valid after an exec, so GDB should not
2502 do that. Instead, the target is responsible from marking
2503 breakpoints out as soon as it detects an exec. We don't do that
2504 here instead, because there may be other attempts to delete
2505 breakpoints after detecting an exec and before reaching here. */
2506 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
2507 if (bploc
->pspace
== current_program_space
)
2508 gdb_assert (!bploc
->inserted
);
2510 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2512 if (b
->pspace
!= current_program_space
)
2515 /* Solib breakpoints must be explicitly reset after an exec(). */
2516 if (b
->type
== bp_shlib_event
)
2518 delete_breakpoint (b
);
2522 /* JIT breakpoints must be explicitly reset after an exec(). */
2523 if (b
->type
== bp_jit_event
)
2525 delete_breakpoint (b
);
2529 /* Thread event breakpoints must be set anew after an exec(),
2530 as must overlay event and longjmp master breakpoints. */
2531 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
2532 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
2533 || b
->type
== bp_exception_master
)
2535 delete_breakpoint (b
);
2539 /* Step-resume breakpoints are meaningless after an exec(). */
2540 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
2542 delete_breakpoint (b
);
2546 /* Longjmp and longjmp-resume breakpoints are also meaningless
2548 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
2549 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
2551 delete_breakpoint (b
);
2555 if (b
->type
== bp_catchpoint
)
2557 /* For now, none of the bp_catchpoint breakpoints need to
2558 do anything at this point. In the future, if some of
2559 the catchpoints need to something, we will need to add
2560 a new method, and call this method from here. */
2564 /* bp_finish is a special case. The only way we ought to be able
2565 to see one of these when an exec() has happened, is if the user
2566 caught a vfork, and then said "finish". Ordinarily a finish just
2567 carries them to the call-site of the current callee, by setting
2568 a temporary bp there and resuming. But in this case, the finish
2569 will carry them entirely through the vfork & exec.
2571 We don't want to allow a bp_finish to remain inserted now. But
2572 we can't safely delete it, 'cause finish_command has a handle to
2573 the bp on a bpstat, and will later want to delete it. There's a
2574 chance (and I've seen it happen) that if we delete the bp_finish
2575 here, that its storage will get reused by the time finish_command
2576 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2577 We really must allow finish_command to delete a bp_finish.
2579 In the absence of a general solution for the "how do we know
2580 it's safe to delete something others may have handles to?"
2581 problem, what we'll do here is just uninsert the bp_finish, and
2582 let finish_command delete it.
2584 (We know the bp_finish is "doomed" in the sense that it's
2585 momentary, and will be deleted as soon as finish_command sees
2586 the inferior stopped. So it doesn't matter that the bp's
2587 address is probably bogus in the new a.out, unlike e.g., the
2588 solib breakpoints.) */
2590 if (b
->type
== bp_finish
)
2595 /* Without a symbolic address, we have little hope of the
2596 pre-exec() address meaning the same thing in the post-exec()
2598 if (b
->addr_string
== NULL
)
2600 delete_breakpoint (b
);
2604 /* FIXME what about longjmp breakpoints? Re-create them here? */
2605 create_overlay_event_breakpoint ();
2606 create_longjmp_master_breakpoint ();
2607 create_std_terminate_master_breakpoint ();
2608 create_exception_master_breakpoint ();
2612 detach_breakpoints (int pid
)
2614 struct bp_location
*bl
, **blp_tmp
;
2616 struct cleanup
*old_chain
= save_inferior_ptid ();
2617 struct inferior
*inf
= current_inferior ();
2619 if (pid
== PIDGET (inferior_ptid
))
2620 error (_("Cannot detach breakpoints of inferior_ptid"));
2622 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2623 inferior_ptid
= pid_to_ptid (pid
);
2624 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2626 if (bl
->pspace
!= inf
->pspace
)
2630 val
|= remove_breakpoint_1 (bl
, mark_inserted
);
2633 /* Detach single-step breakpoints as well. */
2634 detach_single_step_breakpoints ();
2636 do_cleanups (old_chain
);
2640 /* Remove the breakpoint location BL from the current address space.
2641 Note that this is used to detach breakpoints from a child fork.
2642 When we get here, the child isn't in the inferior list, and neither
2643 do we have objects to represent its address space --- we should
2644 *not* look at bl->pspace->aspace here. */
2647 remove_breakpoint_1 (struct bp_location
*bl
, insertion_state_t is
)
2651 /* BL is never in moribund_locations by our callers. */
2652 gdb_assert (bl
->owner
!= NULL
);
2654 if (bl
->owner
->enable_state
== bp_permanent
)
2655 /* Permanent breakpoints cannot be inserted or removed. */
2658 /* The type of none suggests that owner is actually deleted.
2659 This should not ever happen. */
2660 gdb_assert (bl
->owner
->type
!= bp_none
);
2662 if (bl
->loc_type
== bp_loc_software_breakpoint
2663 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2665 /* "Normal" instruction breakpoint: either the standard
2666 trap-instruction bp (bp_breakpoint), or a
2667 bp_hardware_breakpoint. */
2669 /* First check to see if we have to handle an overlay. */
2670 if (overlay_debugging
== ovly_off
2671 || bl
->section
== NULL
2672 || !(section_is_overlay (bl
->section
)))
2674 /* No overlay handling: just remove the breakpoint. */
2675 val
= bl
->owner
->ops
->remove_location (bl
);
2679 /* This breakpoint is in an overlay section.
2680 Did we set a breakpoint at the LMA? */
2681 if (!overlay_events_enabled
)
2683 /* Yes -- overlay event support is not active, so we
2684 should have set a breakpoint at the LMA. Remove it.
2686 /* Ignore any failures: if the LMA is in ROM, we will
2687 have already warned when we failed to insert it. */
2688 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2689 target_remove_hw_breakpoint (bl
->gdbarch
,
2690 &bl
->overlay_target_info
);
2692 target_remove_breakpoint (bl
->gdbarch
,
2693 &bl
->overlay_target_info
);
2695 /* Did we set a breakpoint at the VMA?
2696 If so, we will have marked the breakpoint 'inserted'. */
2699 /* Yes -- remove it. Previously we did not bother to
2700 remove the breakpoint if the section had been
2701 unmapped, but let's not rely on that being safe. We
2702 don't know what the overlay manager might do. */
2704 /* However, we should remove *software* breakpoints only
2705 if the section is still mapped, or else we overwrite
2706 wrong code with the saved shadow contents. */
2707 if (bl
->loc_type
== bp_loc_hardware_breakpoint
2708 || section_is_mapped (bl
->section
))
2709 val
= bl
->owner
->ops
->remove_location (bl
);
2715 /* No -- not inserted, so no need to remove. No error. */
2720 /* In some cases, we might not be able to remove a breakpoint
2721 in a shared library that has already been removed, but we
2722 have not yet processed the shlib unload event. */
2723 if (val
&& solib_name_from_address (bl
->pspace
, bl
->address
))
2728 bl
->inserted
= (is
== mark_inserted
);
2730 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
2732 gdb_assert (bl
->owner
->ops
!= NULL
2733 && bl
->owner
->ops
->remove_location
!= NULL
);
2735 bl
->inserted
= (is
== mark_inserted
);
2736 bl
->owner
->ops
->remove_location (bl
);
2738 /* Failure to remove any of the hardware watchpoints comes here. */
2739 if ((is
== mark_uninserted
) && (bl
->inserted
))
2740 warning (_("Could not remove hardware watchpoint %d."),
2743 else if (bl
->owner
->type
== bp_catchpoint
2744 && breakpoint_enabled (bl
->owner
)
2747 gdb_assert (bl
->owner
->ops
!= NULL
2748 && bl
->owner
->ops
->remove_location
!= NULL
);
2750 val
= bl
->owner
->ops
->remove_location (bl
);
2754 bl
->inserted
= (is
== mark_inserted
);
2761 remove_breakpoint (struct bp_location
*bl
, insertion_state_t is
)
2764 struct cleanup
*old_chain
;
2766 /* BL is never in moribund_locations by our callers. */
2767 gdb_assert (bl
->owner
!= NULL
);
2769 if (bl
->owner
->enable_state
== bp_permanent
)
2770 /* Permanent breakpoints cannot be inserted or removed. */
2773 /* The type of none suggests that owner is actually deleted.
2774 This should not ever happen. */
2775 gdb_assert (bl
->owner
->type
!= bp_none
);
2777 old_chain
= save_current_space_and_thread ();
2779 switch_to_program_space_and_thread (bl
->pspace
);
2781 ret
= remove_breakpoint_1 (bl
, is
);
2783 do_cleanups (old_chain
);
2787 /* Clear the "inserted" flag in all breakpoints. */
2790 mark_breakpoints_out (void)
2792 struct bp_location
*bl
, **blp_tmp
;
2794 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2795 if (bl
->pspace
== current_program_space
)
2799 /* Clear the "inserted" flag in all breakpoints and delete any
2800 breakpoints which should go away between runs of the program.
2802 Plus other such housekeeping that has to be done for breakpoints
2805 Note: this function gets called at the end of a run (by
2806 generic_mourn_inferior) and when a run begins (by
2807 init_wait_for_inferior). */
2812 breakpoint_init_inferior (enum inf_context context
)
2814 struct breakpoint
*b
, *b_tmp
;
2815 struct bp_location
*bl
, **blp_tmp
;
2817 struct program_space
*pspace
= current_program_space
;
2819 /* If breakpoint locations are shared across processes, then there's
2821 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2824 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2826 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2827 if (bl
->pspace
== pspace
2828 && bl
->owner
->enable_state
!= bp_permanent
)
2832 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2834 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2841 /* If the call dummy breakpoint is at the entry point it will
2842 cause problems when the inferior is rerun, so we better get
2845 case bp_watchpoint_scope
:
2847 /* Also get rid of scope breakpoints. */
2849 case bp_shlib_event
:
2851 /* Also remove solib event breakpoints. Their addresses may
2852 have changed since the last time we ran the program.
2853 Actually we may now be debugging against different target;
2854 and so the solib backend that installed this breakpoint may
2855 not be used in by the target. E.g.,
2857 (gdb) file prog-linux
2858 (gdb) run # native linux target
2861 (gdb) file prog-win.exe
2862 (gdb) tar rem :9999 # remote Windows gdbserver.
2865 delete_breakpoint (b
);
2869 case bp_hardware_watchpoint
:
2870 case bp_read_watchpoint
:
2871 case bp_access_watchpoint
:
2873 struct watchpoint
*w
= (struct watchpoint
*) b
;
2875 /* Likewise for watchpoints on local expressions. */
2876 if (w
->exp_valid_block
!= NULL
)
2877 delete_breakpoint (b
);
2878 else if (context
== inf_starting
)
2880 /* Reset val field to force reread of starting value in
2881 insert_breakpoints. */
2883 value_free (w
->val
);
2894 /* Get rid of the moribund locations. */
2895 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
2896 decref_bp_location (&bl
);
2897 VEC_free (bp_location_p
, moribund_locations
);
2900 /* These functions concern about actual breakpoints inserted in the
2901 target --- to e.g. check if we need to do decr_pc adjustment or if
2902 we need to hop over the bkpt --- so we check for address space
2903 match, not program space. */
2905 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2906 exists at PC. It returns ordinary_breakpoint_here if it's an
2907 ordinary breakpoint, or permanent_breakpoint_here if it's a
2908 permanent breakpoint.
2909 - When continuing from a location with an ordinary breakpoint, we
2910 actually single step once before calling insert_breakpoints.
2911 - When continuing from a location with a permanent breakpoint, we
2912 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2913 the target, to advance the PC past the breakpoint. */
2915 enum breakpoint_here
2916 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2918 struct bp_location
*bl
, **blp_tmp
;
2919 int any_breakpoint_here
= 0;
2921 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2923 if (bl
->loc_type
!= bp_loc_software_breakpoint
2924 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2927 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2928 if ((breakpoint_enabled (bl
->owner
)
2929 || bl
->owner
->enable_state
== bp_permanent
)
2930 && breakpoint_location_address_match (bl
, aspace
, pc
))
2932 if (overlay_debugging
2933 && section_is_overlay (bl
->section
)
2934 && !section_is_mapped (bl
->section
))
2935 continue; /* unmapped overlay -- can't be a match */
2936 else if (bl
->owner
->enable_state
== bp_permanent
)
2937 return permanent_breakpoint_here
;
2939 any_breakpoint_here
= 1;
2943 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2946 /* Return true if there's a moribund breakpoint at PC. */
2949 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2951 struct bp_location
*loc
;
2954 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2955 if (breakpoint_location_address_match (loc
, aspace
, pc
))
2961 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2962 inserted using regular breakpoint_chain / bp_location array
2963 mechanism. This does not check for single-step breakpoints, which
2964 are inserted and removed using direct target manipulation. */
2967 regular_breakpoint_inserted_here_p (struct address_space
*aspace
,
2970 struct bp_location
*bl
, **blp_tmp
;
2972 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2974 if (bl
->loc_type
!= bp_loc_software_breakpoint
2975 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2979 && breakpoint_location_address_match (bl
, aspace
, pc
))
2981 if (overlay_debugging
2982 && section_is_overlay (bl
->section
)
2983 && !section_is_mapped (bl
->section
))
2984 continue; /* unmapped overlay -- can't be a match */
2992 /* Returns non-zero iff there's either regular breakpoint
2993 or a single step breakpoint inserted at PC. */
2996 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2998 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
3001 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
3007 /* This function returns non-zero iff there is a software breakpoint
3011 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
3014 struct bp_location
*bl
, **blp_tmp
;
3016 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3018 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
3022 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
3025 if (overlay_debugging
3026 && section_is_overlay (bl
->section
)
3027 && !section_is_mapped (bl
->section
))
3028 continue; /* unmapped overlay -- can't be a match */
3034 /* Also check for software single-step breakpoints. */
3035 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
3042 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
3043 CORE_ADDR addr
, ULONGEST len
)
3045 struct breakpoint
*bpt
;
3047 ALL_BREAKPOINTS (bpt
)
3049 struct bp_location
*loc
;
3051 if (bpt
->type
!= bp_hardware_watchpoint
3052 && bpt
->type
!= bp_access_watchpoint
)
3055 if (!breakpoint_enabled (bpt
))
3058 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3059 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
3063 /* Check for intersection. */
3064 l
= max (loc
->address
, addr
);
3065 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
3073 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
3074 PC is valid for process/thread PTID. */
3077 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
3080 struct bp_location
*bl
, **blp_tmp
;
3081 /* The thread and task IDs associated to PTID, computed lazily. */
3085 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3087 if (bl
->loc_type
!= bp_loc_software_breakpoint
3088 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
3091 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
3092 if (!breakpoint_enabled (bl
->owner
)
3093 && bl
->owner
->enable_state
!= bp_permanent
)
3096 if (!breakpoint_location_address_match (bl
, aspace
, pc
))
3099 if (bl
->owner
->thread
!= -1)
3101 /* This is a thread-specific breakpoint. Check that ptid
3102 matches that thread. If thread hasn't been computed yet,
3103 it is now time to do so. */
3105 thread
= pid_to_thread_id (ptid
);
3106 if (bl
->owner
->thread
!= thread
)
3110 if (bl
->owner
->task
!= 0)
3112 /* This is a task-specific breakpoint. Check that ptid
3113 matches that task. If task hasn't been computed yet,
3114 it is now time to do so. */
3116 task
= ada_get_task_number (ptid
);
3117 if (bl
->owner
->task
!= task
)
3121 if (overlay_debugging
3122 && section_is_overlay (bl
->section
)
3123 && !section_is_mapped (bl
->section
))
3124 continue; /* unmapped overlay -- can't be a match */
3133 /* bpstat stuff. External routines' interfaces are documented
3137 ep_is_catchpoint (struct breakpoint
*ep
)
3139 return (ep
->type
== bp_catchpoint
);
3142 /* Frees any storage that is part of a bpstat. Does not walk the
3146 bpstat_free (bpstat bs
)
3148 if (bs
->old_val
!= NULL
)
3149 value_free (bs
->old_val
);
3150 decref_counted_command_line (&bs
->commands
);
3151 decref_bp_location (&bs
->bp_location_at
);
3155 /* Clear a bpstat so that it says we are not at any breakpoint.
3156 Also free any storage that is part of a bpstat. */
3159 bpstat_clear (bpstat
*bsp
)
3176 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
3177 is part of the bpstat is copied as well. */
3180 bpstat_copy (bpstat bs
)
3184 bpstat retval
= NULL
;
3189 for (; bs
!= NULL
; bs
= bs
->next
)
3191 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
3192 memcpy (tmp
, bs
, sizeof (*tmp
));
3193 incref_counted_command_line (tmp
->commands
);
3194 incref_bp_location (tmp
->bp_location_at
);
3195 if (bs
->old_val
!= NULL
)
3197 tmp
->old_val
= value_copy (bs
->old_val
);
3198 release_value (tmp
->old_val
);
3202 /* This is the first thing in the chain. */
3212 /* Find the bpstat associated with this breakpoint. */
3215 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
3220 for (; bsp
!= NULL
; bsp
= bsp
->next
)
3222 if (bsp
->breakpoint_at
== breakpoint
)
3228 /* Put in *NUM the breakpoint number of the first breakpoint we are
3229 stopped at. *BSP upon return is a bpstat which points to the
3230 remaining breakpoints stopped at (but which is not guaranteed to be
3231 good for anything but further calls to bpstat_num).
3233 Return 0 if passed a bpstat which does not indicate any breakpoints.
3234 Return -1 if stopped at a breakpoint that has been deleted since
3236 Return 1 otherwise. */
3239 bpstat_num (bpstat
*bsp
, int *num
)
3241 struct breakpoint
*b
;
3244 return 0; /* No more breakpoint values */
3246 /* We assume we'll never have several bpstats that correspond to a
3247 single breakpoint -- otherwise, this function might return the
3248 same number more than once and this will look ugly. */
3249 b
= (*bsp
)->breakpoint_at
;
3250 *bsp
= (*bsp
)->next
;
3252 return -1; /* breakpoint that's been deleted since */
3254 *num
= b
->number
; /* We have its number */
3258 /* See breakpoint.h. */
3261 bpstat_clear_actions (void)
3263 struct thread_info
*tp
;
3266 if (ptid_equal (inferior_ptid
, null_ptid
))
3269 tp
= find_thread_ptid (inferior_ptid
);
3273 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
3275 decref_counted_command_line (&bs
->commands
);
3277 if (bs
->old_val
!= NULL
)
3279 value_free (bs
->old_val
);
3285 /* Called when a command is about to proceed the inferior. */
3288 breakpoint_about_to_proceed (void)
3290 if (!ptid_equal (inferior_ptid
, null_ptid
))
3292 struct thread_info
*tp
= inferior_thread ();
3294 /* Allow inferior function calls in breakpoint commands to not
3295 interrupt the command list. When the call finishes
3296 successfully, the inferior will be standing at the same
3297 breakpoint as if nothing happened. */
3298 if (tp
->control
.in_infcall
)
3302 breakpoint_proceeded
= 1;
3305 /* Stub for cleaning up our state if we error-out of a breakpoint
3308 cleanup_executing_breakpoints (void *ignore
)
3310 executing_breakpoint_commands
= 0;
3313 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
3314 or its equivalent. */
3317 command_line_is_silent (struct command_line
*cmd
)
3319 return cmd
&& (strcmp ("silent", cmd
->line
) == 0
3320 || (xdb_commands
&& strcmp ("Q", cmd
->line
) == 0));
3323 /* Execute all the commands associated with all the breakpoints at
3324 this location. Any of these commands could cause the process to
3325 proceed beyond this point, etc. We look out for such changes by
3326 checking the global "breakpoint_proceeded" after each command.
3328 Returns true if a breakpoint command resumed the inferior. In that
3329 case, it is the caller's responsibility to recall it again with the
3330 bpstat of the current thread. */
3333 bpstat_do_actions_1 (bpstat
*bsp
)
3336 struct cleanup
*old_chain
;
3339 /* Avoid endless recursion if a `source' command is contained
3341 if (executing_breakpoint_commands
)
3344 executing_breakpoint_commands
= 1;
3345 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
3347 prevent_dont_repeat ();
3349 /* This pointer will iterate over the list of bpstat's. */
3352 breakpoint_proceeded
= 0;
3353 for (; bs
!= NULL
; bs
= bs
->next
)
3355 struct counted_command_line
*ccmd
;
3356 struct command_line
*cmd
;
3357 struct cleanup
*this_cmd_tree_chain
;
3359 /* Take ownership of the BSP's command tree, if it has one.
3361 The command tree could legitimately contain commands like
3362 'step' and 'next', which call clear_proceed_status, which
3363 frees stop_bpstat's command tree. To make sure this doesn't
3364 free the tree we're executing out from under us, we need to
3365 take ownership of the tree ourselves. Since a given bpstat's
3366 commands are only executed once, we don't need to copy it; we
3367 can clear the pointer in the bpstat, and make sure we free
3368 the tree when we're done. */
3369 ccmd
= bs
->commands
;
3370 bs
->commands
= NULL
;
3371 this_cmd_tree_chain
= make_cleanup_decref_counted_command_line (&ccmd
);
3372 cmd
= ccmd
? ccmd
->commands
: NULL
;
3373 if (command_line_is_silent (cmd
))
3375 /* The action has been already done by bpstat_stop_status. */
3381 execute_control_command (cmd
);
3383 if (breakpoint_proceeded
)
3389 /* We can free this command tree now. */
3390 do_cleanups (this_cmd_tree_chain
);
3392 if (breakpoint_proceeded
)
3394 if (target_can_async_p ())
3395 /* If we are in async mode, then the target might be still
3396 running, not stopped at any breakpoint, so nothing for
3397 us to do here -- just return to the event loop. */
3400 /* In sync mode, when execute_control_command returns
3401 we're already standing on the next breakpoint.
3402 Breakpoint commands for that stop were not run, since
3403 execute_command does not run breakpoint commands --
3404 only command_line_handler does, but that one is not
3405 involved in execution of breakpoint commands. So, we
3406 can now execute breakpoint commands. It should be
3407 noted that making execute_command do bpstat actions is
3408 not an option -- in this case we'll have recursive
3409 invocation of bpstat for each breakpoint with a
3410 command, and can easily blow up GDB stack. Instead, we
3411 return true, which will trigger the caller to recall us
3412 with the new stop_bpstat. */
3417 do_cleanups (old_chain
);
3422 bpstat_do_actions (void)
3424 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
3426 /* Do any commands attached to breakpoint we are stopped at. */
3427 while (!ptid_equal (inferior_ptid
, null_ptid
)
3428 && target_has_execution
3429 && !is_exited (inferior_ptid
)
3430 && !is_executing (inferior_ptid
))
3431 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3432 and only return when it is stopped at the next breakpoint, we
3433 keep doing breakpoint actions until it returns false to
3434 indicate the inferior was not resumed. */
3435 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
3438 discard_cleanups (cleanup_if_error
);
3441 /* Print out the (old or new) value associated with a watchpoint. */
3444 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
3447 fprintf_unfiltered (stream
, _("<unreadable>"));
3450 struct value_print_options opts
;
3451 get_user_print_options (&opts
);
3452 value_print (val
, stream
, &opts
);
3456 /* Generic routine for printing messages indicating why we
3457 stopped. The behavior of this function depends on the value
3458 'print_it' in the bpstat structure. Under some circumstances we
3459 may decide not to print anything here and delegate the task to
3462 static enum print_stop_action
3463 print_bp_stop_message (bpstat bs
)
3465 switch (bs
->print_it
)
3468 /* Nothing should be printed for this bpstat entry. */
3469 return PRINT_UNKNOWN
;
3473 /* We still want to print the frame, but we already printed the
3474 relevant messages. */
3475 return PRINT_SRC_AND_LOC
;
3478 case print_it_normal
:
3480 struct breakpoint
*b
= bs
->breakpoint_at
;
3482 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3483 which has since been deleted. */
3485 return PRINT_UNKNOWN
;
3487 /* Normal case. Call the breakpoint's print_it method. */
3488 return b
->ops
->print_it (bs
);
3493 internal_error (__FILE__
, __LINE__
,
3494 _("print_bp_stop_message: unrecognized enum value"));
3499 /* A helper function that prints a shared library stopped event. */
3502 print_solib_event (int is_catchpoint
)
3505 = !VEC_empty (char_ptr
, current_program_space
->deleted_solibs
);
3507 = !VEC_empty (so_list_ptr
, current_program_space
->added_solibs
);
3511 if (any_added
|| any_deleted
)
3512 ui_out_text (current_uiout
,
3513 _("Stopped due to shared library event:\n"));
3515 ui_out_text (current_uiout
,
3516 _("Stopped due to shared library event (no "
3517 "libraries added or removed)\n"));
3520 if (ui_out_is_mi_like_p (current_uiout
))
3521 ui_out_field_string (current_uiout
, "reason",
3522 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
3526 struct cleanup
*cleanup
;
3530 ui_out_text (current_uiout
, _(" Inferior unloaded "));
3531 cleanup
= make_cleanup_ui_out_list_begin_end (current_uiout
,
3534 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
3539 ui_out_text (current_uiout
, " ");
3540 ui_out_field_string (current_uiout
, "library", name
);
3541 ui_out_text (current_uiout
, "\n");
3544 do_cleanups (cleanup
);
3549 struct so_list
*iter
;
3551 struct cleanup
*cleanup
;
3553 ui_out_text (current_uiout
, _(" Inferior loaded "));
3554 cleanup
= make_cleanup_ui_out_list_begin_end (current_uiout
,
3557 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
3562 ui_out_text (current_uiout
, " ");
3563 ui_out_field_string (current_uiout
, "library", iter
->so_name
);
3564 ui_out_text (current_uiout
, "\n");
3567 do_cleanups (cleanup
);
3571 /* Print a message indicating what happened. This is called from
3572 normal_stop(). The input to this routine is the head of the bpstat
3573 list - a list of the eventpoints that caused this stop. KIND is
3574 the target_waitkind for the stopping event. This
3575 routine calls the generic print routine for printing a message
3576 about reasons for stopping. This will print (for example) the
3577 "Breakpoint n," part of the output. The return value of this
3580 PRINT_UNKNOWN: Means we printed nothing.
3581 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3582 code to print the location. An example is
3583 "Breakpoint 1, " which should be followed by
3585 PRINT_SRC_ONLY: Means we printed something, but there is no need
3586 to also print the location part of the message.
3587 An example is the catch/throw messages, which
3588 don't require a location appended to the end.
3589 PRINT_NOTHING: We have done some printing and we don't need any
3590 further info to be printed. */
3592 enum print_stop_action
3593 bpstat_print (bpstat bs
, int kind
)
3597 /* Maybe another breakpoint in the chain caused us to stop.
3598 (Currently all watchpoints go on the bpstat whether hit or not.
3599 That probably could (should) be changed, provided care is taken
3600 with respect to bpstat_explains_signal). */
3601 for (; bs
; bs
= bs
->next
)
3603 val
= print_bp_stop_message (bs
);
3604 if (val
== PRINT_SRC_ONLY
3605 || val
== PRINT_SRC_AND_LOC
3606 || val
== PRINT_NOTHING
)
3610 /* If we had hit a shared library event breakpoint,
3611 print_bp_stop_message would print out this message. If we hit an
3612 OS-level shared library event, do the same thing. */
3613 if (kind
== TARGET_WAITKIND_LOADED
)
3615 print_solib_event (0);
3616 return PRINT_NOTHING
;
3619 /* We reached the end of the chain, or we got a null BS to start
3620 with and nothing was printed. */
3621 return PRINT_UNKNOWN
;
3624 /* Evaluate the expression EXP and return 1 if value is zero. This is
3625 used inside a catch_errors to evaluate the breakpoint condition.
3626 The argument is a "struct expression *" that has been cast to a
3627 "char *" to make it pass through catch_errors. */
3630 breakpoint_cond_eval (void *exp
)
3632 struct value
*mark
= value_mark ();
3633 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
3635 value_free_to_mark (mark
);
3639 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
3642 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
3646 bs
= (bpstat
) xmalloc (sizeof (*bs
));
3648 **bs_link_pointer
= bs
;
3649 *bs_link_pointer
= &bs
->next
;
3650 bs
->breakpoint_at
= bl
->owner
;
3651 bs
->bp_location_at
= bl
;
3652 incref_bp_location (bl
);
3653 /* If the condition is false, etc., don't do the commands. */
3654 bs
->commands
= NULL
;
3656 bs
->print_it
= print_it_normal
;
3660 /* The target has stopped with waitstatus WS. Check if any hardware
3661 watchpoints have triggered, according to the target. */
3664 watchpoints_triggered (struct target_waitstatus
*ws
)
3666 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3668 struct breakpoint
*b
;
3670 if (!stopped_by_watchpoint
)
3672 /* We were not stopped by a watchpoint. Mark all watchpoints
3673 as not triggered. */
3675 if (is_hardware_watchpoint (b
))
3677 struct watchpoint
*w
= (struct watchpoint
*) b
;
3679 w
->watchpoint_triggered
= watch_triggered_no
;
3685 if (!target_stopped_data_address (¤t_target
, &addr
))
3687 /* We were stopped by a watchpoint, but we don't know where.
3688 Mark all watchpoints as unknown. */
3690 if (is_hardware_watchpoint (b
))
3692 struct watchpoint
*w
= (struct watchpoint
*) b
;
3694 w
->watchpoint_triggered
= watch_triggered_unknown
;
3697 return stopped_by_watchpoint
;
3700 /* The target could report the data address. Mark watchpoints
3701 affected by this data address as triggered, and all others as not
3705 if (is_hardware_watchpoint (b
))
3707 struct watchpoint
*w
= (struct watchpoint
*) b
;
3708 struct bp_location
*loc
;
3710 w
->watchpoint_triggered
= watch_triggered_no
;
3711 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3713 if (is_masked_watchpoint (b
))
3715 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
3716 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
3718 if (newaddr
== start
)
3720 w
->watchpoint_triggered
= watch_triggered_yes
;
3724 /* Exact match not required. Within range is sufficient. */
3725 else if (target_watchpoint_addr_within_range (¤t_target
,
3729 w
->watchpoint_triggered
= watch_triggered_yes
;
3738 /* Possible return values for watchpoint_check (this can't be an enum
3739 because of check_errors). */
3740 /* The watchpoint has been deleted. */
3741 #define WP_DELETED 1
3742 /* The value has changed. */
3743 #define WP_VALUE_CHANGED 2
3744 /* The value has not changed. */
3745 #define WP_VALUE_NOT_CHANGED 3
3746 /* Ignore this watchpoint, no matter if the value changed or not. */
3749 #define BP_TEMPFLAG 1
3750 #define BP_HARDWAREFLAG 2
3752 /* Evaluate watchpoint condition expression and check if its value
3755 P should be a pointer to struct bpstat, but is defined as a void *
3756 in order for this function to be usable with catch_errors. */
3759 watchpoint_check (void *p
)
3761 bpstat bs
= (bpstat
) p
;
3762 struct watchpoint
*b
;
3763 struct frame_info
*fr
;
3764 int within_current_scope
;
3766 /* BS is built from an existing struct breakpoint. */
3767 gdb_assert (bs
->breakpoint_at
!= NULL
);
3768 b
= (struct watchpoint
*) bs
->breakpoint_at
;
3770 /* If this is a local watchpoint, we only want to check if the
3771 watchpoint frame is in scope if the current thread is the thread
3772 that was used to create the watchpoint. */
3773 if (!watchpoint_in_thread_scope (b
))
3776 if (b
->exp_valid_block
== NULL
)
3777 within_current_scope
= 1;
3780 struct frame_info
*frame
= get_current_frame ();
3781 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3782 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3784 /* in_function_epilogue_p() returns a non-zero value if we're
3785 still in the function but the stack frame has already been
3786 invalidated. Since we can't rely on the values of local
3787 variables after the stack has been destroyed, we are treating
3788 the watchpoint in that state as `not changed' without further
3789 checking. Don't mark watchpoints as changed if the current
3790 frame is in an epilogue - even if they are in some other
3791 frame, our view of the stack is likely to be wrong and
3792 frame_find_by_id could error out. */
3793 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3796 fr
= frame_find_by_id (b
->watchpoint_frame
);
3797 within_current_scope
= (fr
!= NULL
);
3799 /* If we've gotten confused in the unwinder, we might have
3800 returned a frame that can't describe this variable. */
3801 if (within_current_scope
)
3803 struct symbol
*function
;
3805 function
= get_frame_function (fr
);
3806 if (function
== NULL
3807 || !contained_in (b
->exp_valid_block
,
3808 SYMBOL_BLOCK_VALUE (function
)))
3809 within_current_scope
= 0;
3812 if (within_current_scope
)
3813 /* If we end up stopping, the current frame will get selected
3814 in normal_stop. So this call to select_frame won't affect
3819 if (within_current_scope
)
3821 /* We use value_{,free_to_}mark because it could be a *long*
3822 time before we return to the command level and call
3823 free_all_values. We can't call free_all_values because we
3824 might be in the middle of evaluating a function call. */
3828 struct value
*new_val
;
3830 if (is_masked_watchpoint (&b
->base
))
3831 /* Since we don't know the exact trigger address (from
3832 stopped_data_address), just tell the user we've triggered
3833 a mask watchpoint. */
3834 return WP_VALUE_CHANGED
;
3836 mark
= value_mark ();
3837 fetch_subexp_value (b
->exp
, &pc
, &new_val
, NULL
, NULL
);
3839 /* We use value_equal_contents instead of value_equal because
3840 the latter coerces an array to a pointer, thus comparing just
3841 the address of the array instead of its contents. This is
3842 not what we want. */
3843 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3844 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
3846 if (new_val
!= NULL
)
3848 release_value (new_val
);
3849 value_free_to_mark (mark
);
3851 bs
->old_val
= b
->val
;
3854 return WP_VALUE_CHANGED
;
3858 /* Nothing changed. */
3859 value_free_to_mark (mark
);
3860 return WP_VALUE_NOT_CHANGED
;
3865 struct ui_out
*uiout
= current_uiout
;
3867 /* This seems like the only logical thing to do because
3868 if we temporarily ignored the watchpoint, then when
3869 we reenter the block in which it is valid it contains
3870 garbage (in the case of a function, it may have two
3871 garbage values, one before and one after the prologue).
3872 So we can't even detect the first assignment to it and
3873 watch after that (since the garbage may or may not equal
3874 the first value assigned). */
3875 /* We print all the stop information in
3876 breakpoint_ops->print_it, but in this case, by the time we
3877 call breakpoint_ops->print_it this bp will be deleted
3878 already. So we have no choice but print the information
3880 if (ui_out_is_mi_like_p (uiout
))
3882 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3883 ui_out_text (uiout
, "\nWatchpoint ");
3884 ui_out_field_int (uiout
, "wpnum", b
->base
.number
);
3886 " deleted because the program has left the block in\n\
3887 which its expression is valid.\n");
3889 /* Make sure the watchpoint's commands aren't executed. */
3890 decref_counted_command_line (&b
->base
.commands
);
3891 watchpoint_del_at_next_stop (b
);
3897 /* Return true if it looks like target has stopped due to hitting
3898 breakpoint location BL. This function does not check if we should
3899 stop, only if BL explains the stop. */
3902 bpstat_check_location (const struct bp_location
*bl
,
3903 struct address_space
*aspace
, CORE_ADDR bp_addr
,
3904 const struct target_waitstatus
*ws
)
3906 struct breakpoint
*b
= bl
->owner
;
3908 /* BL is from an existing breakpoint. */
3909 gdb_assert (b
!= NULL
);
3911 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
3914 /* Determine if the watched values have actually changed, and we
3915 should stop. If not, set BS->stop to 0. */
3918 bpstat_check_watchpoint (bpstat bs
)
3920 const struct bp_location
*bl
;
3921 struct watchpoint
*b
;
3923 /* BS is built for existing struct breakpoint. */
3924 bl
= bs
->bp_location_at
;
3925 gdb_assert (bl
!= NULL
);
3926 b
= (struct watchpoint
*) bs
->breakpoint_at
;
3927 gdb_assert (b
!= NULL
);
3930 int must_check_value
= 0;
3932 if (b
->base
.type
== bp_watchpoint
)
3933 /* For a software watchpoint, we must always check the
3935 must_check_value
= 1;
3936 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3937 /* We have a hardware watchpoint (read, write, or access)
3938 and the target earlier reported an address watched by
3940 must_check_value
= 1;
3941 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3942 && b
->base
.type
== bp_hardware_watchpoint
)
3943 /* We were stopped by a hardware watchpoint, but the target could
3944 not report the data address. We must check the watchpoint's
3945 value. Access and read watchpoints are out of luck; without
3946 a data address, we can't figure it out. */
3947 must_check_value
= 1;
3949 if (must_check_value
)
3952 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3954 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3955 int e
= catch_errors (watchpoint_check
, bs
, message
,
3957 do_cleanups (cleanups
);
3961 /* We've already printed what needs to be printed. */
3962 bs
->print_it
= print_it_done
;
3966 bs
->print_it
= print_it_noop
;
3969 case WP_VALUE_CHANGED
:
3970 if (b
->base
.type
== bp_read_watchpoint
)
3972 /* There are two cases to consider here:
3974 1. We're watching the triggered memory for reads.
3975 In that case, trust the target, and always report
3976 the watchpoint hit to the user. Even though
3977 reads don't cause value changes, the value may
3978 have changed since the last time it was read, and
3979 since we're not trapping writes, we will not see
3980 those, and as such we should ignore our notion of
3983 2. We're watching the triggered memory for both
3984 reads and writes. There are two ways this may
3987 2.1. This is a target that can't break on data
3988 reads only, but can break on accesses (reads or
3989 writes), such as e.g., x86. We detect this case
3990 at the time we try to insert read watchpoints.
3992 2.2. Otherwise, the target supports read
3993 watchpoints, but, the user set an access or write
3994 watchpoint watching the same memory as this read
3997 If we're watching memory writes as well as reads,
3998 ignore watchpoint hits when we find that the
3999 value hasn't changed, as reads don't cause
4000 changes. This still gives false positives when
4001 the program writes the same value to memory as
4002 what there was already in memory (we will confuse
4003 it for a read), but it's much better than
4006 int other_write_watchpoint
= 0;
4008 if (bl
->watchpoint_type
== hw_read
)
4010 struct breakpoint
*other_b
;
4012 ALL_BREAKPOINTS (other_b
)
4013 if (other_b
->type
== bp_hardware_watchpoint
4014 || other_b
->type
== bp_access_watchpoint
)
4016 struct watchpoint
*other_w
=
4017 (struct watchpoint
*) other_b
;
4019 if (other_w
->watchpoint_triggered
4020 == watch_triggered_yes
)
4022 other_write_watchpoint
= 1;
4028 if (other_write_watchpoint
4029 || bl
->watchpoint_type
== hw_access
)
4031 /* We're watching the same memory for writes,
4032 and the value changed since the last time we
4033 updated it, so this trap must be for a write.
4035 bs
->print_it
= print_it_noop
;
4040 case WP_VALUE_NOT_CHANGED
:
4041 if (b
->base
.type
== bp_hardware_watchpoint
4042 || b
->base
.type
== bp_watchpoint
)
4044 /* Don't stop: write watchpoints shouldn't fire if
4045 the value hasn't changed. */
4046 bs
->print_it
= print_it_noop
;
4054 /* Error from catch_errors. */
4055 printf_filtered (_("Watchpoint %d deleted.\n"), b
->base
.number
);
4056 watchpoint_del_at_next_stop (b
);
4057 /* We've already printed what needs to be printed. */
4058 bs
->print_it
= print_it_done
;
4062 else /* must_check_value == 0 */
4064 /* This is a case where some watchpoint(s) triggered, but
4065 not at the address of this watchpoint, or else no
4066 watchpoint triggered after all. So don't print
4067 anything for this watchpoint. */
4068 bs
->print_it
= print_it_noop
;
4075 /* Check conditions (condition proper, frame, thread and ignore count)
4076 of breakpoint referred to by BS. If we should not stop for this
4077 breakpoint, set BS->stop to 0. */
4080 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
4082 int thread_id
= pid_to_thread_id (ptid
);
4083 const struct bp_location
*bl
;
4084 struct breakpoint
*b
;
4086 /* BS is built for existing struct breakpoint. */
4087 bl
= bs
->bp_location_at
;
4088 gdb_assert (bl
!= NULL
);
4089 b
= bs
->breakpoint_at
;
4090 gdb_assert (b
!= NULL
);
4092 if (frame_id_p (b
->frame_id
)
4093 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
4097 int value_is_zero
= 0;
4098 struct expression
*cond
;
4100 /* Evaluate Python breakpoints that have a "stop"
4101 method implemented. */
4102 if (b
->py_bp_object
)
4103 bs
->stop
= gdbpy_should_stop (b
->py_bp_object
);
4105 if (is_watchpoint (b
))
4107 struct watchpoint
*w
= (struct watchpoint
*) b
;
4114 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
4116 int within_current_scope
= 1;
4117 struct watchpoint
* w
;
4119 /* We use value_mark and value_free_to_mark because it could
4120 be a long time before we return to the command level and
4121 call free_all_values. We can't call free_all_values
4122 because we might be in the middle of evaluating a
4124 struct value
*mark
= value_mark ();
4126 if (is_watchpoint (b
))
4127 w
= (struct watchpoint
*) b
;
4131 /* Need to select the frame, with all that implies so that
4132 the conditions will have the right context. Because we
4133 use the frame, we will not see an inlined function's
4134 variables when we arrive at a breakpoint at the start
4135 of the inlined function; the current frame will be the
4137 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
4138 select_frame (get_current_frame ());
4141 struct frame_info
*frame
;
4143 /* For local watchpoint expressions, which particular
4144 instance of a local is being watched matters, so we
4145 keep track of the frame to evaluate the expression
4146 in. To evaluate the condition however, it doesn't
4147 really matter which instantiation of the function
4148 where the condition makes sense triggers the
4149 watchpoint. This allows an expression like "watch
4150 global if q > 10" set in `func', catch writes to
4151 global on all threads that call `func', or catch
4152 writes on all recursive calls of `func' by a single
4153 thread. We simply always evaluate the condition in
4154 the innermost frame that's executing where it makes
4155 sense to evaluate the condition. It seems
4157 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
4159 select_frame (frame
);
4161 within_current_scope
= 0;
4163 if (within_current_scope
)
4165 = catch_errors (breakpoint_cond_eval
, cond
,
4166 "Error in testing breakpoint condition:\n",
4170 warning (_("Watchpoint condition cannot be tested "
4171 "in the current scope"));
4172 /* If we failed to set the right context for this
4173 watchpoint, unconditionally report it. */
4176 /* FIXME-someday, should give breakpoint #. */
4177 value_free_to_mark (mark
);
4180 if (cond
&& value_is_zero
)
4184 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
4188 else if (b
->ignore_count
> 0)
4191 annotate_ignore_count_change ();
4193 /* Increase the hit count even though we don't stop. */
4195 observer_notify_breakpoint_modified (b
);
4201 /* Get a bpstat associated with having just stopped at address
4202 BP_ADDR in thread PTID.
4204 Determine whether we stopped at a breakpoint, etc, or whether we
4205 don't understand this stop. Result is a chain of bpstat's such
4208 if we don't understand the stop, the result is a null pointer.
4210 if we understand why we stopped, the result is not null.
4212 Each element of the chain refers to a particular breakpoint or
4213 watchpoint at which we have stopped. (We may have stopped for
4214 several reasons concurrently.)
4216 Each element of the chain has valid next, breakpoint_at,
4217 commands, FIXME??? fields. */
4220 bpstat_stop_status (struct address_space
*aspace
,
4221 CORE_ADDR bp_addr
, ptid_t ptid
,
4222 const struct target_waitstatus
*ws
)
4224 struct breakpoint
*b
= NULL
;
4225 struct bp_location
*bl
;
4226 struct bp_location
*loc
;
4227 /* First item of allocated bpstat's. */
4228 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
4229 /* Pointer to the last thing in the chain currently. */
4232 int need_remove_insert
;
4235 /* First, build the bpstat chain with locations that explain a
4236 target stop, while being careful to not set the target running,
4237 as that may invalidate locations (in particular watchpoint
4238 locations are recreated). Resuming will happen here with
4239 breakpoint conditions or watchpoint expressions that include
4240 inferior function calls. */
4244 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
4247 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
4249 /* For hardware watchpoints, we look only at the first
4250 location. The watchpoint_check function will work on the
4251 entire expression, not the individual locations. For
4252 read watchpoints, the watchpoints_triggered function has
4253 checked all locations already. */
4254 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
4257 if (bl
->shlib_disabled
)
4260 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
4263 /* Come here if it's a watchpoint, or if the break address
4266 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
4269 /* Assume we stop. Should we find a watchpoint that is not
4270 actually triggered, or if the condition of the breakpoint
4271 evaluates as false, we'll reset 'stop' to 0. */
4275 /* If this is a scope breakpoint, mark the associated
4276 watchpoint as triggered so that we will handle the
4277 out-of-scope event. We'll get to the watchpoint next
4279 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
4281 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
4283 w
->watchpoint_triggered
= watch_triggered_yes
;
4288 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4290 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
))
4292 bs
= bpstat_alloc (loc
, &bs_link
);
4293 /* For hits of moribund locations, we should just proceed. */
4296 bs
->print_it
= print_it_noop
;
4300 /* A bit of special processing for shlib breakpoints. We need to
4301 process solib loading here, so that the lists of loaded and
4302 unloaded libraries are correct before we handle "catch load" and
4304 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4306 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
4308 handle_solib_event ();
4313 /* Now go through the locations that caused the target to stop, and
4314 check whether we're interested in reporting this stop to higher
4315 layers, or whether we should resume the target transparently. */
4319 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4324 b
= bs
->breakpoint_at
;
4325 b
->ops
->check_status (bs
);
4328 bpstat_check_breakpoint_conditions (bs
, ptid
);
4333 observer_notify_breakpoint_modified (b
);
4335 /* We will stop here. */
4336 if (b
->disposition
== disp_disable
)
4338 if (b
->enable_state
!= bp_permanent
)
4339 b
->enable_state
= bp_disabled
;
4344 bs
->commands
= b
->commands
;
4345 incref_counted_command_line (bs
->commands
);
4346 if (command_line_is_silent (bs
->commands
4347 ? bs
->commands
->commands
: NULL
))
4353 /* Print nothing for this entry if we don't stop or don't
4355 if (!bs
->stop
|| !bs
->print
)
4356 bs
->print_it
= print_it_noop
;
4359 /* If we aren't stopping, the value of some hardware watchpoint may
4360 not have changed, but the intermediate memory locations we are
4361 watching may have. Don't bother if we're stopping; this will get
4363 need_remove_insert
= 0;
4364 if (! bpstat_causes_stop (bs_head
))
4365 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4367 && bs
->breakpoint_at
4368 && is_hardware_watchpoint (bs
->breakpoint_at
))
4370 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
4372 update_watchpoint (w
, 0 /* don't reparse. */);
4373 need_remove_insert
= 1;
4376 if (need_remove_insert
)
4377 update_global_location_list (1);
4378 else if (removed_any
)
4379 update_global_location_list (0);
4385 handle_jit_event (void)
4387 struct frame_info
*frame
;
4388 struct gdbarch
*gdbarch
;
4390 /* Switch terminal for any messages produced by
4391 breakpoint_re_set. */
4392 target_terminal_ours_for_output ();
4394 frame
= get_current_frame ();
4395 gdbarch
= get_frame_arch (frame
);
4397 jit_event_handler (gdbarch
);
4399 target_terminal_inferior ();
4402 /* Handle an solib event by calling solib_add. */
4405 handle_solib_event (void)
4407 clear_program_space_solib_cache (current_inferior ()->pspace
);
4409 /* Check for any newly added shared libraries if we're supposed to
4410 be adding them automatically. Switch terminal for any messages
4411 produced by breakpoint_re_set. */
4412 target_terminal_ours_for_output ();
4414 SOLIB_ADD (NULL
, 0, ¤t_target
, auto_solib_add
);
4416 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
4418 target_terminal_inferior ();
4421 /* Prepare WHAT final decision for infrun. */
4423 /* Decide what infrun needs to do with this bpstat. */
4426 bpstat_what (bpstat bs_head
)
4428 struct bpstat_what retval
;
4432 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4433 retval
.call_dummy
= STOP_NONE
;
4434 retval
.is_longjmp
= 0;
4436 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4438 /* Extract this BS's action. After processing each BS, we check
4439 if its action overrides all we've seem so far. */
4440 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4443 if (bs
->breakpoint_at
== NULL
)
4445 /* I suspect this can happen if it was a momentary
4446 breakpoint which has since been deleted. */
4450 bptype
= bs
->breakpoint_at
->type
;
4457 case bp_hardware_breakpoint
:
4460 case bp_shlib_event
:
4464 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4466 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4469 this_action
= BPSTAT_WHAT_SINGLE
;
4472 case bp_hardware_watchpoint
:
4473 case bp_read_watchpoint
:
4474 case bp_access_watchpoint
:
4478 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4480 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4484 /* There was a watchpoint, but we're not stopping.
4485 This requires no further action. */
4490 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
4491 retval
.is_longjmp
= bptype
== bp_longjmp
;
4493 case bp_longjmp_resume
:
4494 case bp_exception_resume
:
4495 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
4496 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
4498 case bp_step_resume
:
4500 this_action
= BPSTAT_WHAT_STEP_RESUME
;
4503 /* It is for the wrong frame. */
4504 this_action
= BPSTAT_WHAT_SINGLE
;
4507 case bp_hp_step_resume
:
4509 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
4512 /* It is for the wrong frame. */
4513 this_action
= BPSTAT_WHAT_SINGLE
;
4516 case bp_watchpoint_scope
:
4517 case bp_thread_event
:
4518 case bp_overlay_event
:
4519 case bp_longjmp_master
:
4520 case bp_std_terminate_master
:
4521 case bp_exception_master
:
4522 this_action
= BPSTAT_WHAT_SINGLE
;
4528 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4530 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4534 /* There was a catchpoint, but we're not stopping.
4535 This requires no further action. */
4540 this_action
= BPSTAT_WHAT_SINGLE
;
4543 /* Make sure the action is stop (silent or noisy),
4544 so infrun.c pops the dummy frame. */
4545 retval
.call_dummy
= STOP_STACK_DUMMY
;
4546 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4548 case bp_std_terminate
:
4549 /* Make sure the action is stop (silent or noisy),
4550 so infrun.c pops the dummy frame. */
4551 retval
.call_dummy
= STOP_STD_TERMINATE
;
4552 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4555 case bp_fast_tracepoint
:
4556 case bp_static_tracepoint
:
4557 /* Tracepoint hits should not be reported back to GDB, and
4558 if one got through somehow, it should have been filtered
4560 internal_error (__FILE__
, __LINE__
,
4561 _("bpstat_what: tracepoint encountered"));
4563 case bp_gnu_ifunc_resolver
:
4564 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
4565 this_action
= BPSTAT_WHAT_SINGLE
;
4567 case bp_gnu_ifunc_resolver_return
:
4568 /* The breakpoint will be removed, execution will restart from the
4569 PC of the former breakpoint. */
4570 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4573 internal_error (__FILE__
, __LINE__
,
4574 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
4577 retval
.main_action
= max (retval
.main_action
, this_action
);
4580 /* These operations may affect the bs->breakpoint_at state so they are
4581 delayed after MAIN_ACTION is decided above. */
4586 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_jit_event\n");
4588 handle_jit_event ();
4591 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4593 struct breakpoint
*b
= bs
->breakpoint_at
;
4599 case bp_gnu_ifunc_resolver
:
4600 gnu_ifunc_resolver_stop (b
);
4602 case bp_gnu_ifunc_resolver_return
:
4603 gnu_ifunc_resolver_return_stop (b
);
4611 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4612 without hardware support). This isn't related to a specific bpstat,
4613 just to things like whether watchpoints are set. */
4616 bpstat_should_step (void)
4618 struct breakpoint
*b
;
4621 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
4627 bpstat_causes_stop (bpstat bs
)
4629 for (; bs
!= NULL
; bs
= bs
->next
)
4638 /* Compute a string of spaces suitable to indent the next line
4639 so it starts at the position corresponding to the table column
4640 named COL_NAME in the currently active table of UIOUT. */
4643 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
4645 static char wrap_indent
[80];
4646 int i
, total_width
, width
, align
;
4650 for (i
= 1; ui_out_query_field (uiout
, i
, &width
, &align
, &text
); i
++)
4652 if (strcmp (text
, col_name
) == 0)
4654 gdb_assert (total_width
< sizeof wrap_indent
);
4655 memset (wrap_indent
, ' ', total_width
);
4656 wrap_indent
[total_width
] = 0;
4661 total_width
+= width
+ 1;
4667 /* Print the LOC location out of the list of B->LOC locations. */
4670 print_breakpoint_location (struct breakpoint
*b
,
4671 struct bp_location
*loc
)
4673 struct ui_out
*uiout
= current_uiout
;
4674 struct cleanup
*old_chain
= save_current_program_space ();
4676 if (loc
!= NULL
&& loc
->shlib_disabled
)
4680 set_current_program_space (loc
->pspace
);
4682 if (b
->display_canonical
)
4683 ui_out_field_string (uiout
, "what", b
->addr_string
);
4684 else if (loc
&& loc
->source_file
)
4687 = find_pc_sect_function (loc
->address
, loc
->section
);
4690 ui_out_text (uiout
, "in ");
4691 ui_out_field_string (uiout
, "func",
4692 SYMBOL_PRINT_NAME (sym
));
4693 ui_out_text (uiout
, " ");
4694 ui_out_wrap_hint (uiout
, wrap_indent_at_field (uiout
, "what"));
4695 ui_out_text (uiout
, "at ");
4697 ui_out_field_string (uiout
, "file", loc
->source_file
);
4698 ui_out_text (uiout
, ":");
4700 if (ui_out_is_mi_like_p (uiout
))
4702 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
4703 char *fullname
= symtab_to_fullname (sal
.symtab
);
4706 ui_out_field_string (uiout
, "fullname", fullname
);
4709 ui_out_field_int (uiout
, "line", loc
->line_number
);
4713 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4714 struct cleanup
*stb_chain
= make_cleanup_ui_out_stream_delete (stb
);
4716 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
->stream
,
4718 ui_out_field_stream (uiout
, "at", stb
);
4720 do_cleanups (stb_chain
);
4723 ui_out_field_string (uiout
, "pending", b
->addr_string
);
4725 do_cleanups (old_chain
);
4729 bptype_string (enum bptype type
)
4731 struct ep_type_description
4736 static struct ep_type_description bptypes
[] =
4738 {bp_none
, "?deleted?"},
4739 {bp_breakpoint
, "breakpoint"},
4740 {bp_hardware_breakpoint
, "hw breakpoint"},
4741 {bp_until
, "until"},
4742 {bp_finish
, "finish"},
4743 {bp_watchpoint
, "watchpoint"},
4744 {bp_hardware_watchpoint
, "hw watchpoint"},
4745 {bp_read_watchpoint
, "read watchpoint"},
4746 {bp_access_watchpoint
, "acc watchpoint"},
4747 {bp_longjmp
, "longjmp"},
4748 {bp_longjmp_resume
, "longjmp resume"},
4749 {bp_exception
, "exception"},
4750 {bp_exception_resume
, "exception resume"},
4751 {bp_step_resume
, "step resume"},
4752 {bp_hp_step_resume
, "high-priority step resume"},
4753 {bp_watchpoint_scope
, "watchpoint scope"},
4754 {bp_call_dummy
, "call dummy"},
4755 {bp_std_terminate
, "std::terminate"},
4756 {bp_shlib_event
, "shlib events"},
4757 {bp_thread_event
, "thread events"},
4758 {bp_overlay_event
, "overlay events"},
4759 {bp_longjmp_master
, "longjmp master"},
4760 {bp_std_terminate_master
, "std::terminate master"},
4761 {bp_exception_master
, "exception master"},
4762 {bp_catchpoint
, "catchpoint"},
4763 {bp_tracepoint
, "tracepoint"},
4764 {bp_fast_tracepoint
, "fast tracepoint"},
4765 {bp_static_tracepoint
, "static tracepoint"},
4766 {bp_jit_event
, "jit events"},
4767 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
4768 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
4771 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
4772 || ((int) type
!= bptypes
[(int) type
].type
))
4773 internal_error (__FILE__
, __LINE__
,
4774 _("bptypes table does not describe type #%d."),
4777 return bptypes
[(int) type
].description
;
4780 /* Print B to gdb_stdout. */
4783 print_one_breakpoint_location (struct breakpoint
*b
,
4784 struct bp_location
*loc
,
4786 struct bp_location
**last_loc
,
4789 struct command_line
*l
;
4790 static char bpenables
[] = "nynny";
4792 struct ui_out
*uiout
= current_uiout
;
4793 int header_of_multiple
= 0;
4794 int part_of_multiple
= (loc
!= NULL
);
4795 struct value_print_options opts
;
4797 get_user_print_options (&opts
);
4799 gdb_assert (!loc
|| loc_number
!= 0);
4800 /* See comment in print_one_breakpoint concerning treatment of
4801 breakpoints with single disabled location. */
4804 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
4805 header_of_multiple
= 1;
4813 if (part_of_multiple
)
4816 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
4817 ui_out_field_string (uiout
, "number", formatted
);
4822 ui_out_field_int (uiout
, "number", b
->number
);
4827 if (part_of_multiple
)
4828 ui_out_field_skip (uiout
, "type");
4830 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
4834 if (part_of_multiple
)
4835 ui_out_field_skip (uiout
, "disp");
4837 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
4842 if (part_of_multiple
)
4843 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
4845 ui_out_field_fmt (uiout
, "enabled", "%c",
4846 bpenables
[(int) b
->enable_state
]);
4847 ui_out_spaces (uiout
, 2);
4851 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4853 /* Although the print_one can possibly print all locations,
4854 calling it here is not likely to get any nice result. So,
4855 make sure there's just one location. */
4856 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4857 b
->ops
->print_one (b
, last_loc
);
4863 internal_error (__FILE__
, __LINE__
,
4864 _("print_one_breakpoint: bp_none encountered\n"));
4868 case bp_hardware_watchpoint
:
4869 case bp_read_watchpoint
:
4870 case bp_access_watchpoint
:
4872 struct watchpoint
*w
= (struct watchpoint
*) b
;
4874 /* Field 4, the address, is omitted (which makes the columns
4875 not line up too nicely with the headers, but the effect
4876 is relatively readable). */
4877 if (opts
.addressprint
)
4878 ui_out_field_skip (uiout
, "addr");
4880 ui_out_field_string (uiout
, "what", w
->exp_string
);
4885 case bp_hardware_breakpoint
:
4889 case bp_longjmp_resume
:
4891 case bp_exception_resume
:
4892 case bp_step_resume
:
4893 case bp_hp_step_resume
:
4894 case bp_watchpoint_scope
:
4896 case bp_std_terminate
:
4897 case bp_shlib_event
:
4898 case bp_thread_event
:
4899 case bp_overlay_event
:
4900 case bp_longjmp_master
:
4901 case bp_std_terminate_master
:
4902 case bp_exception_master
:
4904 case bp_fast_tracepoint
:
4905 case bp_static_tracepoint
:
4907 case bp_gnu_ifunc_resolver
:
4908 case bp_gnu_ifunc_resolver_return
:
4909 if (opts
.addressprint
)
4912 if (header_of_multiple
)
4913 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4914 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4915 ui_out_field_string (uiout
, "addr", "<PENDING>");
4917 ui_out_field_core_addr (uiout
, "addr",
4918 loc
->gdbarch
, loc
->address
);
4921 if (!header_of_multiple
)
4922 print_breakpoint_location (b
, loc
);
4929 /* For backward compatibility, don't display inferiors unless there
4932 && !header_of_multiple
4934 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4935 && (number_of_program_spaces () > 1
4936 || number_of_inferiors () > 1)
4937 /* LOC is for existing B, it cannot be in
4938 moribund_locations and thus having NULL OWNER. */
4939 && loc
->owner
->type
!= bp_catchpoint
)))
4941 struct inferior
*inf
;
4944 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4946 if (inf
->pspace
== loc
->pspace
)
4951 ui_out_text (uiout
, " inf ");
4954 ui_out_text (uiout
, ", ");
4955 ui_out_text (uiout
, plongest (inf
->num
));
4960 if (!part_of_multiple
)
4962 if (b
->thread
!= -1)
4964 /* FIXME: This seems to be redundant and lost here; see the
4965 "stop only in" line a little further down. */
4966 ui_out_text (uiout
, " thread ");
4967 ui_out_field_int (uiout
, "thread", b
->thread
);
4969 else if (b
->task
!= 0)
4971 ui_out_text (uiout
, " task ");
4972 ui_out_field_int (uiout
, "task", b
->task
);
4976 ui_out_text (uiout
, "\n");
4978 if (!part_of_multiple
)
4979 b
->ops
->print_one_detail (b
, uiout
);
4981 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4984 ui_out_text (uiout
, "\tstop only in stack frame at ");
4985 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
4987 ui_out_field_core_addr (uiout
, "frame",
4988 b
->gdbarch
, b
->frame_id
.stack_addr
);
4989 ui_out_text (uiout
, "\n");
4992 if (!part_of_multiple
&& b
->cond_string
)
4995 if (is_tracepoint (b
))
4996 ui_out_text (uiout
, "\ttrace only if ");
4998 ui_out_text (uiout
, "\tstop only if ");
4999 ui_out_field_string (uiout
, "cond", b
->cond_string
);
5000 ui_out_text (uiout
, "\n");
5003 if (!part_of_multiple
&& b
->thread
!= -1)
5005 /* FIXME should make an annotation for this. */
5006 ui_out_text (uiout
, "\tstop only in thread ");
5007 ui_out_field_int (uiout
, "thread", b
->thread
);
5008 ui_out_text (uiout
, "\n");
5011 if (!part_of_multiple
&& b
->hit_count
)
5013 /* FIXME should make an annotation for this. */
5014 if (ep_is_catchpoint (b
))
5015 ui_out_text (uiout
, "\tcatchpoint");
5016 else if (is_tracepoint (b
))
5017 ui_out_text (uiout
, "\ttracepoint");
5019 ui_out_text (uiout
, "\tbreakpoint");
5020 ui_out_text (uiout
, " already hit ");
5021 ui_out_field_int (uiout
, "times", b
->hit_count
);
5022 if (b
->hit_count
== 1)
5023 ui_out_text (uiout
, " time\n");
5025 ui_out_text (uiout
, " times\n");
5028 /* Output the count also if it is zero, but only if this is mi.
5029 FIXME: Should have a better test for this. */
5030 if (ui_out_is_mi_like_p (uiout
))
5031 if (!part_of_multiple
&& b
->hit_count
== 0)
5032 ui_out_field_int (uiout
, "times", b
->hit_count
);
5034 if (!part_of_multiple
&& b
->ignore_count
)
5037 ui_out_text (uiout
, "\tignore next ");
5038 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
5039 ui_out_text (uiout
, " hits\n");
5042 if (!part_of_multiple
&& is_tracepoint (b
))
5044 struct tracepoint
*tp
= (struct tracepoint
*) b
;
5046 if (tp
->traceframe_usage
)
5048 ui_out_text (uiout
, "\ttrace buffer usage ");
5049 ui_out_field_int (uiout
, "traceframe-usage", tp
->traceframe_usage
);
5050 ui_out_text (uiout
, " bytes\n");
5054 l
= b
->commands
? b
->commands
->commands
: NULL
;
5055 if (!part_of_multiple
&& l
)
5057 struct cleanup
*script_chain
;
5060 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
5061 print_command_lines (uiout
, l
, 4);
5062 do_cleanups (script_chain
);
5065 if (is_tracepoint (b
))
5067 struct tracepoint
*t
= (struct tracepoint
*) b
;
5069 if (!part_of_multiple
&& t
->pass_count
)
5071 annotate_field (10);
5072 ui_out_text (uiout
, "\tpass count ");
5073 ui_out_field_int (uiout
, "pass", t
->pass_count
);
5074 ui_out_text (uiout
, " \n");
5078 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
5080 if (is_watchpoint (b
))
5082 struct watchpoint
*w
= (struct watchpoint
*) b
;
5084 ui_out_field_string (uiout
, "original-location", w
->exp_string
);
5086 else if (b
->addr_string
)
5087 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
5092 print_one_breakpoint (struct breakpoint
*b
,
5093 struct bp_location
**last_loc
,
5096 struct cleanup
*bkpt_chain
;
5097 struct ui_out
*uiout
= current_uiout
;
5099 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
5101 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
5102 do_cleanups (bkpt_chain
);
5104 /* If this breakpoint has custom print function,
5105 it's already printed. Otherwise, print individual
5106 locations, if any. */
5107 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
5109 /* If breakpoint has a single location that is disabled, we
5110 print it as if it had several locations, since otherwise it's
5111 hard to represent "breakpoint enabled, location disabled"
5114 Note that while hardware watchpoints have several locations
5115 internally, that's not a property exposed to user. */
5117 && !is_hardware_watchpoint (b
)
5118 && (b
->loc
->next
|| !b
->loc
->enabled
))
5120 struct bp_location
*loc
;
5123 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
5125 struct cleanup
*inner2
=
5126 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
5127 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
5128 do_cleanups (inner2
);
5135 breakpoint_address_bits (struct breakpoint
*b
)
5137 int print_address_bits
= 0;
5138 struct bp_location
*loc
;
5140 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
5144 /* Software watchpoints that aren't watching memory don't have
5145 an address to print. */
5146 if (b
->type
== bp_watchpoint
&& loc
->watchpoint_type
== -1)
5149 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
5150 if (addr_bit
> print_address_bits
)
5151 print_address_bits
= addr_bit
;
5154 return print_address_bits
;
5157 struct captured_breakpoint_query_args
5163 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
5165 struct captured_breakpoint_query_args
*args
= data
;
5166 struct breakpoint
*b
;
5167 struct bp_location
*dummy_loc
= NULL
;
5171 if (args
->bnum
== b
->number
)
5173 print_one_breakpoint (b
, &dummy_loc
, 0);
5181 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
5182 char **error_message
)
5184 struct captured_breakpoint_query_args args
;
5187 /* For the moment we don't trust print_one_breakpoint() to not throw
5189 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
5190 error_message
, RETURN_MASK_ALL
) < 0)
5196 /* Return true if this breakpoint was set by the user, false if it is
5197 internal or momentary. */
5200 user_breakpoint_p (struct breakpoint
*b
)
5202 return b
->number
> 0;
5205 /* Print information on user settable breakpoint (watchpoint, etc)
5206 number BNUM. If BNUM is -1 print all user-settable breakpoints.
5207 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
5208 FILTER is non-NULL, call it on each breakpoint and only include the
5209 ones for which it returns non-zero. Return the total number of
5210 breakpoints listed. */
5213 breakpoint_1 (char *args
, int allflag
,
5214 int (*filter
) (const struct breakpoint
*))
5216 struct breakpoint
*b
;
5217 struct bp_location
*last_loc
= NULL
;
5218 int nr_printable_breakpoints
;
5219 struct cleanup
*bkpttbl_chain
;
5220 struct value_print_options opts
;
5221 int print_address_bits
= 0;
5222 int print_type_col_width
= 14;
5223 struct ui_out
*uiout
= current_uiout
;
5225 get_user_print_options (&opts
);
5227 /* Compute the number of rows in the table, as well as the size
5228 required for address fields. */
5229 nr_printable_breakpoints
= 0;
5232 /* If we have a filter, only list the breakpoints it accepts. */
5233 if (filter
&& !filter (b
))
5236 /* If we have an "args" string, it is a list of breakpoints to
5237 accept. Skip the others. */
5238 if (args
!= NULL
&& *args
!= '\0')
5240 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
5242 if (!allflag
&& !number_is_in_list (args
, b
->number
))
5246 if (allflag
|| user_breakpoint_p (b
))
5248 int addr_bit
, type_len
;
5250 addr_bit
= breakpoint_address_bits (b
);
5251 if (addr_bit
> print_address_bits
)
5252 print_address_bits
= addr_bit
;
5254 type_len
= strlen (bptype_string (b
->type
));
5255 if (type_len
> print_type_col_width
)
5256 print_type_col_width
= type_len
;
5258 nr_printable_breakpoints
++;
5262 if (opts
.addressprint
)
5264 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
5265 nr_printable_breakpoints
,
5269 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
5270 nr_printable_breakpoints
,
5273 if (nr_printable_breakpoints
> 0)
5274 annotate_breakpoints_headers ();
5275 if (nr_printable_breakpoints
> 0)
5277 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
5278 if (nr_printable_breakpoints
> 0)
5280 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
5281 "type", "Type"); /* 2 */
5282 if (nr_printable_breakpoints
> 0)
5284 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
5285 if (nr_printable_breakpoints
> 0)
5287 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
5288 if (opts
.addressprint
)
5290 if (nr_printable_breakpoints
> 0)
5292 if (print_address_bits
<= 32)
5293 ui_out_table_header (uiout
, 10, ui_left
,
5294 "addr", "Address"); /* 5 */
5296 ui_out_table_header (uiout
, 18, ui_left
,
5297 "addr", "Address"); /* 5 */
5299 if (nr_printable_breakpoints
> 0)
5301 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
5302 ui_out_table_body (uiout
);
5303 if (nr_printable_breakpoints
> 0)
5304 annotate_breakpoints_table ();
5309 /* If we have a filter, only list the breakpoints it accepts. */
5310 if (filter
&& !filter (b
))
5313 /* If we have an "args" string, it is a list of breakpoints to
5314 accept. Skip the others. */
5316 if (args
!= NULL
&& *args
!= '\0')
5318 if (allflag
) /* maintenance info breakpoint */
5320 if (parse_and_eval_long (args
) != b
->number
)
5323 else /* all others */
5325 if (!number_is_in_list (args
, b
->number
))
5329 /* We only print out user settable breakpoints unless the
5331 if (allflag
|| user_breakpoint_p (b
))
5332 print_one_breakpoint (b
, &last_loc
, allflag
);
5335 do_cleanups (bkpttbl_chain
);
5337 if (nr_printable_breakpoints
== 0)
5339 /* If there's a filter, let the caller decide how to report
5343 if (args
== NULL
|| *args
== '\0')
5344 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
5346 ui_out_message (uiout
, 0,
5347 "No breakpoint or watchpoint matching '%s'.\n",
5353 if (last_loc
&& !server_command
)
5354 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
5357 /* FIXME? Should this be moved up so that it is only called when
5358 there have been breakpoints? */
5359 annotate_breakpoints_table_end ();
5361 return nr_printable_breakpoints
;
5364 /* Display the value of default-collect in a way that is generally
5365 compatible with the breakpoint list. */
5368 default_collect_info (void)
5370 struct ui_out
*uiout
= current_uiout
;
5372 /* If it has no value (which is frequently the case), say nothing; a
5373 message like "No default-collect." gets in user's face when it's
5375 if (!*default_collect
)
5378 /* The following phrase lines up nicely with per-tracepoint collect
5380 ui_out_text (uiout
, "default collect ");
5381 ui_out_field_string (uiout
, "default-collect", default_collect
);
5382 ui_out_text (uiout
, " \n");
5386 breakpoints_info (char *args
, int from_tty
)
5388 breakpoint_1 (args
, 0, NULL
);
5390 default_collect_info ();
5394 watchpoints_info (char *args
, int from_tty
)
5396 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
5397 struct ui_out
*uiout
= current_uiout
;
5399 if (num_printed
== 0)
5401 if (args
== NULL
|| *args
== '\0')
5402 ui_out_message (uiout
, 0, "No watchpoints.\n");
5404 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
5409 maintenance_info_breakpoints (char *args
, int from_tty
)
5411 breakpoint_1 (args
, 1, NULL
);
5413 default_collect_info ();
5417 breakpoint_has_pc (struct breakpoint
*b
,
5418 struct program_space
*pspace
,
5419 CORE_ADDR pc
, struct obj_section
*section
)
5421 struct bp_location
*bl
= b
->loc
;
5423 for (; bl
; bl
= bl
->next
)
5425 if (bl
->pspace
== pspace
5426 && bl
->address
== pc
5427 && (!overlay_debugging
|| bl
->section
== section
))
5433 /* Print a message describing any user-breakpoints set at PC. This
5434 concerns with logical breakpoints, so we match program spaces, not
5438 describe_other_breakpoints (struct gdbarch
*gdbarch
,
5439 struct program_space
*pspace
, CORE_ADDR pc
,
5440 struct obj_section
*section
, int thread
)
5443 struct breakpoint
*b
;
5446 others
+= (user_breakpoint_p (b
)
5447 && breakpoint_has_pc (b
, pspace
, pc
, section
));
5451 printf_filtered (_("Note: breakpoint "));
5452 else /* if (others == ???) */
5453 printf_filtered (_("Note: breakpoints "));
5455 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
5458 printf_filtered ("%d", b
->number
);
5459 if (b
->thread
== -1 && thread
!= -1)
5460 printf_filtered (" (all threads)");
5461 else if (b
->thread
!= -1)
5462 printf_filtered (" (thread %d)", b
->thread
);
5463 printf_filtered ("%s%s ",
5464 ((b
->enable_state
== bp_disabled
5465 || b
->enable_state
== bp_call_disabled
)
5467 : b
->enable_state
== bp_permanent
5471 : ((others
== 1) ? " and" : ""));
5473 printf_filtered (_("also set at pc "));
5474 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
5475 printf_filtered (".\n");
5480 /* Return true iff it is meaningful to use the address member of
5481 BPT. For some breakpoint types, the address member is irrelevant
5482 and it makes no sense to attempt to compare it to other addresses
5483 (or use it for any other purpose either).
5485 More specifically, each of the following breakpoint types will
5486 always have a zero valued address and we don't want to mark
5487 breakpoints of any of these types to be a duplicate of an actual
5488 breakpoint at address zero:
5496 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
5498 enum bptype type
= bpt
->type
;
5500 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
5503 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5504 true if LOC1 and LOC2 represent the same watchpoint location. */
5507 watchpoint_locations_match (struct bp_location
*loc1
,
5508 struct bp_location
*loc2
)
5510 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
5511 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
5513 /* Both of them must exist. */
5514 gdb_assert (w1
!= NULL
);
5515 gdb_assert (w2
!= NULL
);
5517 /* If the target can evaluate the condition expression in hardware,
5518 then we we need to insert both watchpoints even if they are at
5519 the same place. Otherwise the watchpoint will only trigger when
5520 the condition of whichever watchpoint was inserted evaluates to
5521 true, not giving a chance for GDB to check the condition of the
5522 other watchpoint. */
5524 && target_can_accel_watchpoint_condition (loc1
->address
,
5526 loc1
->watchpoint_type
,
5529 && target_can_accel_watchpoint_condition (loc2
->address
,
5531 loc2
->watchpoint_type
,
5535 /* Note that this checks the owner's type, not the location's. In
5536 case the target does not support read watchpoints, but does
5537 support access watchpoints, we'll have bp_read_watchpoint
5538 watchpoints with hw_access locations. Those should be considered
5539 duplicates of hw_read locations. The hw_read locations will
5540 become hw_access locations later. */
5541 return (loc1
->owner
->type
== loc2
->owner
->type
5542 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
5543 && loc1
->address
== loc2
->address
5544 && loc1
->length
== loc2
->length
);
5547 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5548 same breakpoint location. In most targets, this can only be true
5549 if ASPACE1 matches ASPACE2. On targets that have global
5550 breakpoints, the address space doesn't really matter. */
5553 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
5554 struct address_space
*aspace2
, CORE_ADDR addr2
)
5556 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5557 || aspace1
== aspace2
)
5561 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
5562 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
5563 matches ASPACE2. On targets that have global breakpoints, the address
5564 space doesn't really matter. */
5567 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
5568 int len1
, struct address_space
*aspace2
,
5571 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5572 || aspace1
== aspace2
)
5573 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
5576 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
5577 a ranged breakpoint. In most targets, a match happens only if ASPACE
5578 matches the breakpoint's address space. On targets that have global
5579 breakpoints, the address space doesn't really matter. */
5582 breakpoint_location_address_match (struct bp_location
*bl
,
5583 struct address_space
*aspace
,
5586 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
5589 && breakpoint_address_match_range (bl
->pspace
->aspace
,
5590 bl
->address
, bl
->length
,
5594 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
5595 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
5596 true, otherwise returns false. */
5599 tracepoint_locations_match (struct bp_location
*loc1
,
5600 struct bp_location
*loc2
)
5602 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
5603 /* Since tracepoint locations are never duplicated with others', tracepoint
5604 locations at the same address of different tracepoints are regarded as
5605 different locations. */
5606 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
5611 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5612 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5613 represent the same location. */
5616 breakpoint_locations_match (struct bp_location
*loc1
,
5617 struct bp_location
*loc2
)
5619 int hw_point1
, hw_point2
;
5621 /* Both of them must not be in moribund_locations. */
5622 gdb_assert (loc1
->owner
!= NULL
);
5623 gdb_assert (loc2
->owner
!= NULL
);
5625 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
5626 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
5628 if (hw_point1
!= hw_point2
)
5631 return watchpoint_locations_match (loc1
, loc2
);
5632 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
5633 return tracepoint_locations_match (loc1
, loc2
);
5635 /* We compare bp_location.length in order to cover ranged breakpoints. */
5636 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
5637 loc2
->pspace
->aspace
, loc2
->address
)
5638 && loc1
->length
== loc2
->length
);
5642 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
5643 int bnum
, int have_bnum
)
5645 /* The longest string possibly returned by hex_string_custom
5646 is 50 chars. These must be at least that big for safety. */
5650 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
5651 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
5653 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5654 bnum
, astr1
, astr2
);
5656 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
5659 /* Adjust a breakpoint's address to account for architectural
5660 constraints on breakpoint placement. Return the adjusted address.
5661 Note: Very few targets require this kind of adjustment. For most
5662 targets, this function is simply the identity function. */
5665 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
5666 CORE_ADDR bpaddr
, enum bptype bptype
)
5668 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
5670 /* Very few targets need any kind of breakpoint adjustment. */
5673 else if (bptype
== bp_watchpoint
5674 || bptype
== bp_hardware_watchpoint
5675 || bptype
== bp_read_watchpoint
5676 || bptype
== bp_access_watchpoint
5677 || bptype
== bp_catchpoint
)
5679 /* Watchpoints and the various bp_catch_* eventpoints should not
5680 have their addresses modified. */
5685 CORE_ADDR adjusted_bpaddr
;
5687 /* Some targets have architectural constraints on the placement
5688 of breakpoint instructions. Obtain the adjusted address. */
5689 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
5691 /* An adjusted breakpoint address can significantly alter
5692 a user's expectations. Print a warning if an adjustment
5694 if (adjusted_bpaddr
!= bpaddr
)
5695 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
5697 return adjusted_bpaddr
;
5702 init_bp_location (struct bp_location
*loc
, const struct bp_location_ops
*ops
,
5703 struct breakpoint
*owner
)
5705 memset (loc
, 0, sizeof (*loc
));
5707 gdb_assert (ops
!= NULL
);
5712 loc
->shlib_disabled
= 0;
5715 switch (owner
->type
)
5721 case bp_longjmp_resume
:
5723 case bp_exception_resume
:
5724 case bp_step_resume
:
5725 case bp_hp_step_resume
:
5726 case bp_watchpoint_scope
:
5728 case bp_std_terminate
:
5729 case bp_shlib_event
:
5730 case bp_thread_event
:
5731 case bp_overlay_event
:
5733 case bp_longjmp_master
:
5734 case bp_std_terminate_master
:
5735 case bp_exception_master
:
5736 case bp_gnu_ifunc_resolver
:
5737 case bp_gnu_ifunc_resolver_return
:
5738 loc
->loc_type
= bp_loc_software_breakpoint
;
5740 case bp_hardware_breakpoint
:
5741 loc
->loc_type
= bp_loc_hardware_breakpoint
;
5743 case bp_hardware_watchpoint
:
5744 case bp_read_watchpoint
:
5745 case bp_access_watchpoint
:
5746 loc
->loc_type
= bp_loc_hardware_watchpoint
;
5751 case bp_fast_tracepoint
:
5752 case bp_static_tracepoint
:
5753 loc
->loc_type
= bp_loc_other
;
5756 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
5762 /* Allocate a struct bp_location. */
5764 static struct bp_location
*
5765 allocate_bp_location (struct breakpoint
*bpt
)
5767 return bpt
->ops
->allocate_location (bpt
);
5771 free_bp_location (struct bp_location
*loc
)
5773 loc
->ops
->dtor (loc
);
5777 /* Increment reference count. */
5780 incref_bp_location (struct bp_location
*bl
)
5785 /* Decrement reference count. If the reference count reaches 0,
5786 destroy the bp_location. Sets *BLP to NULL. */
5789 decref_bp_location (struct bp_location
**blp
)
5791 gdb_assert ((*blp
)->refc
> 0);
5793 if (--(*blp
)->refc
== 0)
5794 free_bp_location (*blp
);
5798 /* Add breakpoint B at the end of the global breakpoint chain. */
5801 add_to_breakpoint_chain (struct breakpoint
*b
)
5803 struct breakpoint
*b1
;
5805 /* Add this breakpoint to the end of the chain so that a list of
5806 breakpoints will come out in order of increasing numbers. */
5808 b1
= breakpoint_chain
;
5810 breakpoint_chain
= b
;
5819 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
5822 init_raw_breakpoint_without_location (struct breakpoint
*b
,
5823 struct gdbarch
*gdbarch
,
5825 const struct breakpoint_ops
*ops
)
5827 memset (b
, 0, sizeof (*b
));
5829 gdb_assert (ops
!= NULL
);
5833 b
->gdbarch
= gdbarch
;
5834 b
->language
= current_language
->la_language
;
5835 b
->input_radix
= input_radix
;
5837 b
->enable_state
= bp_enabled
;
5840 b
->ignore_count
= 0;
5842 b
->frame_id
= null_frame_id
;
5843 b
->condition_not_parsed
= 0;
5844 b
->py_bp_object
= NULL
;
5845 b
->related_breakpoint
= b
;
5848 /* Helper to set_raw_breakpoint below. Creates a breakpoint
5849 that has type BPTYPE and has no locations as yet. */
5851 static struct breakpoint
*
5852 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
5854 const struct breakpoint_ops
*ops
)
5856 struct breakpoint
*b
= XNEW (struct breakpoint
);
5858 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
5859 add_to_breakpoint_chain (b
);
5863 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
5864 resolutions should be made as the user specified the location explicitly
5868 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
5870 gdb_assert (loc
->owner
!= NULL
);
5872 if (loc
->owner
->type
== bp_breakpoint
5873 || loc
->owner
->type
== bp_hardware_breakpoint
5874 || is_tracepoint (loc
->owner
))
5878 find_pc_partial_function_gnu_ifunc (loc
->address
, &loc
->function_name
,
5879 NULL
, NULL
, &is_gnu_ifunc
);
5881 if (is_gnu_ifunc
&& !explicit_loc
)
5883 struct breakpoint
*b
= loc
->owner
;
5885 gdb_assert (loc
->pspace
== current_program_space
);
5886 if (gnu_ifunc_resolve_name (loc
->function_name
,
5887 &loc
->requested_address
))
5889 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
5890 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
5891 loc
->requested_address
,
5894 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
5895 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
5897 /* Create only the whole new breakpoint of this type but do not
5898 mess more complicated breakpoints with multiple locations. */
5899 b
->type
= bp_gnu_ifunc_resolver
;
5903 if (loc
->function_name
)
5904 loc
->function_name
= xstrdup (loc
->function_name
);
5908 /* Attempt to determine architecture of location identified by SAL. */
5910 get_sal_arch (struct symtab_and_line sal
)
5913 return get_objfile_arch (sal
.section
->objfile
);
5915 return get_objfile_arch (sal
.symtab
->objfile
);
5920 /* Low level routine for partially initializing a breakpoint of type
5921 BPTYPE. The newly created breakpoint's address, section, source
5922 file name, and line number are provided by SAL.
5924 It is expected that the caller will complete the initialization of
5925 the newly created breakpoint struct as well as output any status
5926 information regarding the creation of a new breakpoint. */
5929 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
5930 struct symtab_and_line sal
, enum bptype bptype
,
5931 const struct breakpoint_ops
*ops
)
5933 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
5935 add_location_to_breakpoint (b
, &sal
);
5937 if (bptype
!= bp_catchpoint
)
5938 gdb_assert (sal
.pspace
!= NULL
);
5940 /* Store the program space that was used to set the breakpoint,
5941 except for ordinary breakpoints, which are independent of the
5943 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
5944 b
->pspace
= sal
.pspace
;
5946 breakpoints_changed ();
5949 /* set_raw_breakpoint is a low level routine for allocating and
5950 partially initializing a breakpoint of type BPTYPE. The newly
5951 created breakpoint's address, section, source file name, and line
5952 number are provided by SAL. The newly created and partially
5953 initialized breakpoint is added to the breakpoint chain and
5954 is also returned as the value of this function.
5956 It is expected that the caller will complete the initialization of
5957 the newly created breakpoint struct as well as output any status
5958 information regarding the creation of a new breakpoint. In
5959 particular, set_raw_breakpoint does NOT set the breakpoint
5960 number! Care should be taken to not allow an error to occur
5961 prior to completing the initialization of the breakpoint. If this
5962 should happen, a bogus breakpoint will be left on the chain. */
5965 set_raw_breakpoint (struct gdbarch
*gdbarch
,
5966 struct symtab_and_line sal
, enum bptype bptype
,
5967 const struct breakpoint_ops
*ops
)
5969 struct breakpoint
*b
= XNEW (struct breakpoint
);
5971 init_raw_breakpoint (b
, gdbarch
, sal
, bptype
, ops
);
5972 add_to_breakpoint_chain (b
);
5977 /* Note that the breakpoint object B describes a permanent breakpoint
5978 instruction, hard-wired into the inferior's code. */
5980 make_breakpoint_permanent (struct breakpoint
*b
)
5982 struct bp_location
*bl
;
5984 b
->enable_state
= bp_permanent
;
5986 /* By definition, permanent breakpoints are already present in the
5987 code. Mark all locations as inserted. For now,
5988 make_breakpoint_permanent is called in just one place, so it's
5989 hard to say if it's reasonable to have permanent breakpoint with
5990 multiple locations or not, but it's easy to implement. */
5991 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5995 /* Call this routine when stepping and nexting to enable a breakpoint
5996 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
5997 initiated the operation. */
6000 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
6002 struct breakpoint
*b
, *b_tmp
;
6003 int thread
= tp
->num
;
6005 /* To avoid having to rescan all objfile symbols at every step,
6006 we maintain a list of continually-inserted but always disabled
6007 longjmp "master" breakpoints. Here, we simply create momentary
6008 clones of those and enable them for the requested thread. */
6009 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6010 if (b
->pspace
== current_program_space
6011 && (b
->type
== bp_longjmp_master
6012 || b
->type
== bp_exception_master
))
6014 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
6015 struct breakpoint
*clone
;
6017 clone
= momentary_breakpoint_from_master (b
, type
,
6018 &momentary_breakpoint_ops
);
6019 clone
->thread
= thread
;
6022 tp
->initiating_frame
= frame
;
6025 /* Delete all longjmp breakpoints from THREAD. */
6027 delete_longjmp_breakpoint (int thread
)
6029 struct breakpoint
*b
, *b_tmp
;
6031 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6032 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
6034 if (b
->thread
== thread
)
6035 delete_breakpoint (b
);
6040 enable_overlay_breakpoints (void)
6042 struct breakpoint
*b
;
6045 if (b
->type
== bp_overlay_event
)
6047 b
->enable_state
= bp_enabled
;
6048 update_global_location_list (1);
6049 overlay_events_enabled
= 1;
6054 disable_overlay_breakpoints (void)
6056 struct breakpoint
*b
;
6059 if (b
->type
== bp_overlay_event
)
6061 b
->enable_state
= bp_disabled
;
6062 update_global_location_list (0);
6063 overlay_events_enabled
= 0;
6067 /* Set an active std::terminate breakpoint for each std::terminate
6068 master breakpoint. */
6070 set_std_terminate_breakpoint (void)
6072 struct breakpoint
*b
, *b_tmp
;
6074 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6075 if (b
->pspace
== current_program_space
6076 && b
->type
== bp_std_terminate_master
)
6078 momentary_breakpoint_from_master (b
, bp_std_terminate
,
6079 &momentary_breakpoint_ops
);
6083 /* Delete all the std::terminate breakpoints. */
6085 delete_std_terminate_breakpoint (void)
6087 struct breakpoint
*b
, *b_tmp
;
6089 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6090 if (b
->type
== bp_std_terminate
)
6091 delete_breakpoint (b
);
6095 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6097 struct breakpoint
*b
;
6099 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
6100 &internal_breakpoint_ops
);
6102 b
->enable_state
= bp_enabled
;
6103 /* addr_string has to be used or breakpoint_re_set will delete me. */
6105 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
6107 update_global_location_list_nothrow (1);
6113 remove_thread_event_breakpoints (void)
6115 struct breakpoint
*b
, *b_tmp
;
6117 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6118 if (b
->type
== bp_thread_event
6119 && b
->loc
->pspace
== current_program_space
)
6120 delete_breakpoint (b
);
6123 struct lang_and_radix
6129 /* Create a breakpoint for JIT code registration and unregistration. */
6132 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6134 struct breakpoint
*b
;
6136 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
6137 &internal_breakpoint_ops
);
6138 update_global_location_list_nothrow (1);
6142 /* Remove JIT code registration and unregistration breakpoint(s). */
6145 remove_jit_event_breakpoints (void)
6147 struct breakpoint
*b
, *b_tmp
;
6149 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6150 if (b
->type
== bp_jit_event
6151 && b
->loc
->pspace
== current_program_space
)
6152 delete_breakpoint (b
);
6156 remove_solib_event_breakpoints (void)
6158 struct breakpoint
*b
, *b_tmp
;
6160 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6161 if (b
->type
== bp_shlib_event
6162 && b
->loc
->pspace
== current_program_space
)
6163 delete_breakpoint (b
);
6167 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6169 struct breakpoint
*b
;
6171 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
6172 &internal_breakpoint_ops
);
6173 update_global_location_list_nothrow (1);
6177 /* Disable any breakpoints that are on code in shared libraries. Only
6178 apply to enabled breakpoints, disabled ones can just stay disabled. */
6181 disable_breakpoints_in_shlibs (void)
6183 struct bp_location
*loc
, **locp_tmp
;
6185 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6187 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6188 struct breakpoint
*b
= loc
->owner
;
6190 /* We apply the check to all breakpoints, including disabled for
6191 those with loc->duplicate set. This is so that when breakpoint
6192 becomes enabled, or the duplicate is removed, gdb will try to
6193 insert all breakpoints. If we don't set shlib_disabled here,
6194 we'll try to insert those breakpoints and fail. */
6195 if (((b
->type
== bp_breakpoint
)
6196 || (b
->type
== bp_jit_event
)
6197 || (b
->type
== bp_hardware_breakpoint
)
6198 || (is_tracepoint (b
)))
6199 && loc
->pspace
== current_program_space
6200 && !loc
->shlib_disabled
6202 && PC_SOLIB (loc
->address
)
6204 && solib_name_from_address (loc
->pspace
, loc
->address
)
6208 loc
->shlib_disabled
= 1;
6213 /* Disable any breakpoints and tracepoints that are in an unloaded shared
6214 library. Only apply to enabled breakpoints, disabled ones can just stay
6218 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
6220 struct bp_location
*loc
, **locp_tmp
;
6221 int disabled_shlib_breaks
= 0;
6223 /* SunOS a.out shared libraries are always mapped, so do not
6224 disable breakpoints; they will only be reported as unloaded
6225 through clear_solib when GDB discards its shared library
6226 list. See clear_solib for more information. */
6227 if (exec_bfd
!= NULL
6228 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
6231 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6233 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6234 struct breakpoint
*b
= loc
->owner
;
6236 if (solib
->pspace
== loc
->pspace
6237 && !loc
->shlib_disabled
6238 && (((b
->type
== bp_breakpoint
6239 || b
->type
== bp_jit_event
6240 || b
->type
== bp_hardware_breakpoint
)
6241 && (loc
->loc_type
== bp_loc_hardware_breakpoint
6242 || loc
->loc_type
== bp_loc_software_breakpoint
))
6243 || is_tracepoint (b
))
6244 && solib_contains_address_p (solib
, loc
->address
))
6246 loc
->shlib_disabled
= 1;
6247 /* At this point, we cannot rely on remove_breakpoint
6248 succeeding so we must mark the breakpoint as not inserted
6249 to prevent future errors occurring in remove_breakpoints. */
6252 /* This may cause duplicate notifications for the same breakpoint. */
6253 observer_notify_breakpoint_modified (b
);
6255 if (!disabled_shlib_breaks
)
6257 target_terminal_ours_for_output ();
6258 warning (_("Temporarily disabling breakpoints "
6259 "for unloaded shared library \"%s\""),
6262 disabled_shlib_breaks
= 1;
6267 /* FORK & VFORK catchpoints. */
6269 /* An instance of this type is used to represent a fork or vfork
6270 catchpoint. It includes a "struct breakpoint" as a kind of base
6271 class; users downcast to "struct breakpoint *" when needed. A
6272 breakpoint is really of this type iff its ops pointer points to
6273 CATCH_FORK_BREAKPOINT_OPS. */
6275 struct fork_catchpoint
6277 /* The base class. */
6278 struct breakpoint base
;
6280 /* Process id of a child process whose forking triggered this
6281 catchpoint. This field is only valid immediately after this
6282 catchpoint has triggered. */
6283 ptid_t forked_inferior_pid
;
6286 /* Implement the "insert" breakpoint_ops method for fork
6290 insert_catch_fork (struct bp_location
*bl
)
6292 return target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
6295 /* Implement the "remove" breakpoint_ops method for fork
6299 remove_catch_fork (struct bp_location
*bl
)
6301 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
6304 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6308 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
6309 struct address_space
*aspace
, CORE_ADDR bp_addr
,
6310 const struct target_waitstatus
*ws
)
6312 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
6314 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
6317 c
->forked_inferior_pid
= ws
->value
.related_pid
;
6321 /* Implement the "print_it" breakpoint_ops method for fork
6324 static enum print_stop_action
6325 print_it_catch_fork (bpstat bs
)
6327 struct ui_out
*uiout
= current_uiout
;
6328 struct breakpoint
*b
= bs
->breakpoint_at
;
6329 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
6331 annotate_catchpoint (b
->number
);
6332 if (b
->disposition
== disp_del
)
6333 ui_out_text (uiout
, "\nTemporary catchpoint ");
6335 ui_out_text (uiout
, "\nCatchpoint ");
6336 if (ui_out_is_mi_like_p (uiout
))
6338 ui_out_field_string (uiout
, "reason",
6339 async_reason_lookup (EXEC_ASYNC_FORK
));
6340 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6342 ui_out_field_int (uiout
, "bkptno", b
->number
);
6343 ui_out_text (uiout
, " (forked process ");
6344 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
6345 ui_out_text (uiout
, "), ");
6346 return PRINT_SRC_AND_LOC
;
6349 /* Implement the "print_one" breakpoint_ops method for fork
6353 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6355 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6356 struct value_print_options opts
;
6357 struct ui_out
*uiout
= current_uiout
;
6359 get_user_print_options (&opts
);
6361 /* Field 4, the address, is omitted (which makes the columns not
6362 line up too nicely with the headers, but the effect is relatively
6364 if (opts
.addressprint
)
6365 ui_out_field_skip (uiout
, "addr");
6367 ui_out_text (uiout
, "fork");
6368 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
6370 ui_out_text (uiout
, ", process ");
6371 ui_out_field_int (uiout
, "what",
6372 ptid_get_pid (c
->forked_inferior_pid
));
6373 ui_out_spaces (uiout
, 1);
6377 /* Implement the "print_mention" breakpoint_ops method for fork
6381 print_mention_catch_fork (struct breakpoint
*b
)
6383 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
6386 /* Implement the "print_recreate" breakpoint_ops method for fork
6390 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
6392 fprintf_unfiltered (fp
, "catch fork");
6393 print_recreate_thread (b
, fp
);
6396 /* The breakpoint_ops structure to be used in fork catchpoints. */
6398 static struct breakpoint_ops catch_fork_breakpoint_ops
;
6400 /* Implement the "insert" breakpoint_ops method for vfork
6404 insert_catch_vfork (struct bp_location
*bl
)
6406 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
6409 /* Implement the "remove" breakpoint_ops method for vfork
6413 remove_catch_vfork (struct bp_location
*bl
)
6415 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
6418 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6422 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
6423 struct address_space
*aspace
, CORE_ADDR bp_addr
,
6424 const struct target_waitstatus
*ws
)
6426 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
6428 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
6431 c
->forked_inferior_pid
= ws
->value
.related_pid
;
6435 /* Implement the "print_it" breakpoint_ops method for vfork
6438 static enum print_stop_action
6439 print_it_catch_vfork (bpstat bs
)
6441 struct ui_out
*uiout
= current_uiout
;
6442 struct breakpoint
*b
= bs
->breakpoint_at
;
6443 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6445 annotate_catchpoint (b
->number
);
6446 if (b
->disposition
== disp_del
)
6447 ui_out_text (uiout
, "\nTemporary catchpoint ");
6449 ui_out_text (uiout
, "\nCatchpoint ");
6450 if (ui_out_is_mi_like_p (uiout
))
6452 ui_out_field_string (uiout
, "reason",
6453 async_reason_lookup (EXEC_ASYNC_VFORK
));
6454 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6456 ui_out_field_int (uiout
, "bkptno", b
->number
);
6457 ui_out_text (uiout
, " (vforked process ");
6458 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
6459 ui_out_text (uiout
, "), ");
6460 return PRINT_SRC_AND_LOC
;
6463 /* Implement the "print_one" breakpoint_ops method for vfork
6467 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6469 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6470 struct value_print_options opts
;
6471 struct ui_out
*uiout
= current_uiout
;
6473 get_user_print_options (&opts
);
6474 /* Field 4, the address, is omitted (which makes the columns not
6475 line up too nicely with the headers, but the effect is relatively
6477 if (opts
.addressprint
)
6478 ui_out_field_skip (uiout
, "addr");
6480 ui_out_text (uiout
, "vfork");
6481 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
6483 ui_out_text (uiout
, ", process ");
6484 ui_out_field_int (uiout
, "what",
6485 ptid_get_pid (c
->forked_inferior_pid
));
6486 ui_out_spaces (uiout
, 1);
6490 /* Implement the "print_mention" breakpoint_ops method for vfork
6494 print_mention_catch_vfork (struct breakpoint
*b
)
6496 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
6499 /* Implement the "print_recreate" breakpoint_ops method for vfork
6503 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
6505 fprintf_unfiltered (fp
, "catch vfork");
6506 print_recreate_thread (b
, fp
);
6509 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6511 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
6513 /* An instance of this type is used to represent an solib catchpoint.
6514 It includes a "struct breakpoint" as a kind of base class; users
6515 downcast to "struct breakpoint *" when needed. A breakpoint is
6516 really of this type iff its ops pointer points to
6517 CATCH_SOLIB_BREAKPOINT_OPS. */
6519 struct solib_catchpoint
6521 /* The base class. */
6522 struct breakpoint base
;
6524 /* True for "catch load", false for "catch unload". */
6525 unsigned char is_load
;
6527 /* Regular expression to match, if any. COMPILED is only valid when
6528 REGEX is non-NULL. */
6534 dtor_catch_solib (struct breakpoint
*b
)
6536 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
6539 regfree (&self
->compiled
);
6540 xfree (self
->regex
);
6542 base_breakpoint_ops
.dtor (b
);
6546 insert_catch_solib (struct bp_location
*ignore
)
6552 remove_catch_solib (struct bp_location
*ignore
)
6558 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
6559 struct address_space
*aspace
,
6561 const struct target_waitstatus
*ws
)
6563 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
6564 struct breakpoint
*other
;
6566 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
6569 ALL_BREAKPOINTS (other
)
6571 struct bp_location
*other_bl
;
6573 if (other
== bl
->owner
)
6576 if (other
->type
!= bp_shlib_event
)
6579 if (self
->base
.pspace
!= NULL
&& other
->pspace
!= self
->base
.pspace
)
6582 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
6584 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
6593 check_status_catch_solib (struct bpstats
*bs
)
6595 struct solib_catchpoint
*self
6596 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
6601 struct so_list
*iter
;
6604 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
6609 || regexec (&self
->compiled
, iter
->so_name
, 0, NULL
, 0) == 0)
6618 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
6623 || regexec (&self
->compiled
, iter
, 0, NULL
, 0) == 0)
6629 bs
->print_it
= print_it_noop
;
6632 static enum print_stop_action
6633 print_it_catch_solib (bpstat bs
)
6635 struct breakpoint
*b
= bs
->breakpoint_at
;
6636 struct ui_out
*uiout
= current_uiout
;
6638 annotate_catchpoint (b
->number
);
6639 if (b
->disposition
== disp_del
)
6640 ui_out_text (uiout
, "\nTemporary catchpoint ");
6642 ui_out_text (uiout
, "\nCatchpoint ");
6643 ui_out_field_int (uiout
, "bkptno", b
->number
);
6644 ui_out_text (uiout
, "\n");
6645 if (ui_out_is_mi_like_p (uiout
))
6646 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6647 print_solib_event (1);
6648 return PRINT_SRC_AND_LOC
;
6652 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
6654 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
6655 struct value_print_options opts
;
6656 struct ui_out
*uiout
= current_uiout
;
6659 get_user_print_options (&opts
);
6660 /* Field 4, the address, is omitted (which makes the columns not
6661 line up too nicely with the headers, but the effect is relatively
6663 if (opts
.addressprint
)
6666 ui_out_field_skip (uiout
, "addr");
6673 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
6675 msg
= xstrdup (_("load of library"));
6680 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
6682 msg
= xstrdup (_("unload of library"));
6684 ui_out_field_string (uiout
, "what", msg
);
6689 print_mention_catch_solib (struct breakpoint
*b
)
6691 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
6693 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
6694 self
->is_load
? "load" : "unload");
6698 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
6700 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
6702 fprintf_unfiltered (fp
, "%s %s",
6703 b
->disposition
== disp_del
? "tcatch" : "catch",
6704 self
->is_load
? "load" : "unload");
6706 fprintf_unfiltered (fp
, " %s", self
->regex
);
6707 fprintf_unfiltered (fp
, "\n");
6710 static struct breakpoint_ops catch_solib_breakpoint_ops
;
6712 /* A helper function that does all the work for "catch load" and
6716 catch_load_or_unload (char *arg
, int from_tty
, int is_load
,
6717 struct cmd_list_element
*command
)
6719 struct solib_catchpoint
*c
;
6720 struct gdbarch
*gdbarch
= get_current_arch ();
6723 struct cleanup
*cleanup
;
6725 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6729 arg
= skip_spaces (arg
);
6731 c
= XCNEW (struct solib_catchpoint
);
6732 cleanup
= make_cleanup (xfree
, c
);
6738 errcode
= regcomp (&c
->compiled
, arg
, REG_NOSUB
);
6741 char *err
= get_regcomp_error (errcode
, &c
->compiled
);
6743 make_cleanup (xfree
, err
);
6744 error (_("Invalid regexp (%s): %s"), err
, arg
);
6746 c
->regex
= xstrdup (arg
);
6749 c
->is_load
= is_load
;
6750 init_catchpoint (&c
->base
, gdbarch
, tempflag
, NULL
,
6751 &catch_solib_breakpoint_ops
);
6753 discard_cleanups (cleanup
);
6754 install_breakpoint (0, &c
->base
, 1);
6758 catch_load_command_1 (char *arg
, int from_tty
,
6759 struct cmd_list_element
*command
)
6761 catch_load_or_unload (arg
, from_tty
, 1, command
);
6765 catch_unload_command_1 (char *arg
, int from_tty
,
6766 struct cmd_list_element
*command
)
6768 catch_load_or_unload (arg
, from_tty
, 0, command
);
6771 /* An instance of this type is used to represent a syscall catchpoint.
6772 It includes a "struct breakpoint" as a kind of base class; users
6773 downcast to "struct breakpoint *" when needed. A breakpoint is
6774 really of this type iff its ops pointer points to
6775 CATCH_SYSCALL_BREAKPOINT_OPS. */
6777 struct syscall_catchpoint
6779 /* The base class. */
6780 struct breakpoint base
;
6782 /* Syscall numbers used for the 'catch syscall' feature. If no
6783 syscall has been specified for filtering, its value is NULL.
6784 Otherwise, it holds a list of all syscalls to be caught. The
6785 list elements are allocated with xmalloc. */
6786 VEC(int) *syscalls_to_be_caught
;
6789 /* Implement the "dtor" breakpoint_ops method for syscall
6793 dtor_catch_syscall (struct breakpoint
*b
)
6795 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6797 VEC_free (int, c
->syscalls_to_be_caught
);
6799 base_breakpoint_ops
.dtor (b
);
6802 /* Implement the "insert" breakpoint_ops method for syscall
6806 insert_catch_syscall (struct bp_location
*bl
)
6808 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bl
->owner
;
6809 struct inferior
*inf
= current_inferior ();
6811 ++inf
->total_syscalls_count
;
6812 if (!c
->syscalls_to_be_caught
)
6813 ++inf
->any_syscall_count
;
6819 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6824 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6826 int old_size
= VEC_length (int, inf
->syscalls_counts
);
6827 uintptr_t vec_addr_offset
6828 = old_size
* ((uintptr_t) sizeof (int));
6830 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
6831 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
6833 memset ((void *) vec_addr
, 0,
6834 (iter
+ 1 - old_size
) * sizeof (int));
6836 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6837 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
6841 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6842 inf
->total_syscalls_count
!= 0,
6843 inf
->any_syscall_count
,
6844 VEC_length (int, inf
->syscalls_counts
),
6845 VEC_address (int, inf
->syscalls_counts
));
6848 /* Implement the "remove" breakpoint_ops method for syscall
6852 remove_catch_syscall (struct bp_location
*bl
)
6854 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bl
->owner
;
6855 struct inferior
*inf
= current_inferior ();
6857 --inf
->total_syscalls_count
;
6858 if (!c
->syscalls_to_be_caught
)
6859 --inf
->any_syscall_count
;
6865 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6869 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6870 /* Shouldn't happen. */
6872 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6873 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
6877 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6878 inf
->total_syscalls_count
!= 0,
6879 inf
->any_syscall_count
,
6880 VEC_length (int, inf
->syscalls_counts
),
6882 inf
->syscalls_counts
));
6885 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6889 breakpoint_hit_catch_syscall (const struct bp_location
*bl
,
6890 struct address_space
*aspace
, CORE_ADDR bp_addr
,
6891 const struct target_waitstatus
*ws
)
6893 /* We must check if we are catching specific syscalls in this
6894 breakpoint. If we are, then we must guarantee that the called
6895 syscall is the same syscall we are catching. */
6896 int syscall_number
= 0;
6897 const struct syscall_catchpoint
*c
6898 = (const struct syscall_catchpoint
*) bl
->owner
;
6900 if (ws
->kind
!= TARGET_WAITKIND_SYSCALL_ENTRY
6901 && ws
->kind
!= TARGET_WAITKIND_SYSCALL_RETURN
)
6904 syscall_number
= ws
->value
.syscall_number
;
6906 /* Now, checking if the syscall is the same. */
6907 if (c
->syscalls_to_be_caught
)
6912 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6914 if (syscall_number
== iter
)
6924 /* Implement the "print_it" breakpoint_ops method for syscall
6927 static enum print_stop_action
6928 print_it_catch_syscall (bpstat bs
)
6930 struct ui_out
*uiout
= current_uiout
;
6931 struct breakpoint
*b
= bs
->breakpoint_at
;
6932 /* These are needed because we want to know in which state a
6933 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6934 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6935 must print "called syscall" or "returned from syscall". */
6937 struct target_waitstatus last
;
6941 get_last_target_status (&ptid
, &last
);
6943 get_syscall_by_number (last
.value
.syscall_number
, &s
);
6945 annotate_catchpoint (b
->number
);
6947 if (b
->disposition
== disp_del
)
6948 ui_out_text (uiout
, "\nTemporary catchpoint ");
6950 ui_out_text (uiout
, "\nCatchpoint ");
6951 if (ui_out_is_mi_like_p (uiout
))
6953 ui_out_field_string (uiout
, "reason",
6954 async_reason_lookup (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
6955 ? EXEC_ASYNC_SYSCALL_ENTRY
6956 : EXEC_ASYNC_SYSCALL_RETURN
));
6957 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6959 ui_out_field_int (uiout
, "bkptno", b
->number
);
6961 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
6962 ui_out_text (uiout
, " (call to syscall ");
6964 ui_out_text (uiout
, " (returned from syscall ");
6966 if (s
.name
== NULL
|| ui_out_is_mi_like_p (uiout
))
6967 ui_out_field_int (uiout
, "syscall-number", last
.value
.syscall_number
);
6969 ui_out_field_string (uiout
, "syscall-name", s
.name
);
6971 ui_out_text (uiout
, "), ");
6973 return PRINT_SRC_AND_LOC
;
6976 /* Implement the "print_one" breakpoint_ops method for syscall
6980 print_one_catch_syscall (struct breakpoint
*b
,
6981 struct bp_location
**last_loc
)
6983 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6984 struct value_print_options opts
;
6985 struct ui_out
*uiout
= current_uiout
;
6987 get_user_print_options (&opts
);
6988 /* Field 4, the address, is omitted (which makes the columns not
6989 line up too nicely with the headers, but the effect is relatively
6991 if (opts
.addressprint
)
6992 ui_out_field_skip (uiout
, "addr");
6995 if (c
->syscalls_to_be_caught
6996 && VEC_length (int, c
->syscalls_to_be_caught
) > 1)
6997 ui_out_text (uiout
, "syscalls \"");
6999 ui_out_text (uiout
, "syscall \"");
7001 if (c
->syscalls_to_be_caught
)
7004 char *text
= xstrprintf ("%s", "");
7007 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
7012 get_syscall_by_number (iter
, &s
);
7015 text
= xstrprintf ("%s%s, ", text
, s
.name
);
7017 text
= xstrprintf ("%s%d, ", text
, iter
);
7019 /* We have to xfree the last 'text' (now stored at 'x')
7020 because xstrprintf dynamically allocates new space for it
7024 /* Remove the last comma. */
7025 text
[strlen (text
) - 2] = '\0';
7026 ui_out_field_string (uiout
, "what", text
);
7029 ui_out_field_string (uiout
, "what", "<any syscall>");
7030 ui_out_text (uiout
, "\" ");
7033 /* Implement the "print_mention" breakpoint_ops method for syscall
7037 print_mention_catch_syscall (struct breakpoint
*b
)
7039 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
7041 if (c
->syscalls_to_be_caught
)
7045 if (VEC_length (int, c
->syscalls_to_be_caught
) > 1)
7046 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
7048 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
7051 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
7055 get_syscall_by_number (iter
, &s
);
7058 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
7060 printf_filtered (" %d", s
.number
);
7062 printf_filtered (")");
7065 printf_filtered (_("Catchpoint %d (any syscall)"),
7069 /* Implement the "print_recreate" breakpoint_ops method for syscall
7073 print_recreate_catch_syscall (struct breakpoint
*b
, struct ui_file
*fp
)
7075 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
7077 fprintf_unfiltered (fp
, "catch syscall");
7079 if (c
->syscalls_to_be_caught
)
7084 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
7089 get_syscall_by_number (iter
, &s
);
7091 fprintf_unfiltered (fp
, " %s", s
.name
);
7093 fprintf_unfiltered (fp
, " %d", s
.number
);
7096 print_recreate_thread (b
, fp
);
7099 /* The breakpoint_ops structure to be used in syscall catchpoints. */
7101 static struct breakpoint_ops catch_syscall_breakpoint_ops
;
7103 /* Returns non-zero if 'b' is a syscall catchpoint. */
7106 syscall_catchpoint_p (struct breakpoint
*b
)
7108 return (b
->ops
== &catch_syscall_breakpoint_ops
);
7111 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
7112 is non-zero, then make the breakpoint temporary. If COND_STRING is
7113 not NULL, then store it in the breakpoint. OPS, if not NULL, is
7114 the breakpoint_ops structure associated to the catchpoint. */
7117 init_catchpoint (struct breakpoint
*b
,
7118 struct gdbarch
*gdbarch
, int tempflag
,
7120 const struct breakpoint_ops
*ops
)
7122 struct symtab_and_line sal
;
7125 sal
.pspace
= current_program_space
;
7127 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
7129 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
7130 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
7134 install_breakpoint (int internal
, struct breakpoint
*b
, int update_gll
)
7136 add_to_breakpoint_chain (b
);
7137 set_breakpoint_number (internal
, b
);
7140 observer_notify_breakpoint_created (b
);
7143 update_global_location_list (1);
7147 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
7148 int tempflag
, char *cond_string
,
7149 const struct breakpoint_ops
*ops
)
7151 struct fork_catchpoint
*c
= XNEW (struct fork_catchpoint
);
7153 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
, ops
);
7155 c
->forked_inferior_pid
= null_ptid
;
7157 install_breakpoint (0, &c
->base
, 1);
7160 /* Exec catchpoints. */
7162 /* An instance of this type is used to represent an exec catchpoint.
7163 It includes a "struct breakpoint" as a kind of base class; users
7164 downcast to "struct breakpoint *" when needed. A breakpoint is
7165 really of this type iff its ops pointer points to
7166 CATCH_EXEC_BREAKPOINT_OPS. */
7168 struct exec_catchpoint
7170 /* The base class. */
7171 struct breakpoint base
;
7173 /* Filename of a program whose exec triggered this catchpoint.
7174 This field is only valid immediately after this catchpoint has
7176 char *exec_pathname
;
7179 /* Implement the "dtor" breakpoint_ops method for exec
7183 dtor_catch_exec (struct breakpoint
*b
)
7185 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
7187 xfree (c
->exec_pathname
);
7189 base_breakpoint_ops
.dtor (b
);
7193 insert_catch_exec (struct bp_location
*bl
)
7195 return target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
7199 remove_catch_exec (struct bp_location
*bl
)
7201 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
7205 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
7206 struct address_space
*aspace
, CORE_ADDR bp_addr
,
7207 const struct target_waitstatus
*ws
)
7209 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
7211 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
7214 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
7218 static enum print_stop_action
7219 print_it_catch_exec (bpstat bs
)
7221 struct ui_out
*uiout
= current_uiout
;
7222 struct breakpoint
*b
= bs
->breakpoint_at
;
7223 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
7225 annotate_catchpoint (b
->number
);
7226 if (b
->disposition
== disp_del
)
7227 ui_out_text (uiout
, "\nTemporary catchpoint ");
7229 ui_out_text (uiout
, "\nCatchpoint ");
7230 if (ui_out_is_mi_like_p (uiout
))
7232 ui_out_field_string (uiout
, "reason",
7233 async_reason_lookup (EXEC_ASYNC_EXEC
));
7234 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
7236 ui_out_field_int (uiout
, "bkptno", b
->number
);
7237 ui_out_text (uiout
, " (exec'd ");
7238 ui_out_field_string (uiout
, "new-exec", c
->exec_pathname
);
7239 ui_out_text (uiout
, "), ");
7241 return PRINT_SRC_AND_LOC
;
7245 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
7247 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
7248 struct value_print_options opts
;
7249 struct ui_out
*uiout
= current_uiout
;
7251 get_user_print_options (&opts
);
7253 /* Field 4, the address, is omitted (which makes the columns
7254 not line up too nicely with the headers, but the effect
7255 is relatively readable). */
7256 if (opts
.addressprint
)
7257 ui_out_field_skip (uiout
, "addr");
7259 ui_out_text (uiout
, "exec");
7260 if (c
->exec_pathname
!= NULL
)
7262 ui_out_text (uiout
, ", program \"");
7263 ui_out_field_string (uiout
, "what", c
->exec_pathname
);
7264 ui_out_text (uiout
, "\" ");
7269 print_mention_catch_exec (struct breakpoint
*b
)
7271 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
7274 /* Implement the "print_recreate" breakpoint_ops method for exec
7278 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
7280 fprintf_unfiltered (fp
, "catch exec");
7281 print_recreate_thread (b
, fp
);
7284 static struct breakpoint_ops catch_exec_breakpoint_ops
;
7287 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
7288 const struct breakpoint_ops
*ops
)
7290 struct syscall_catchpoint
*c
;
7291 struct gdbarch
*gdbarch
= get_current_arch ();
7293 c
= XNEW (struct syscall_catchpoint
);
7294 init_catchpoint (&c
->base
, gdbarch
, tempflag
, NULL
, ops
);
7295 c
->syscalls_to_be_caught
= filter
;
7297 install_breakpoint (0, &c
->base
, 1);
7301 hw_breakpoint_used_count (void)
7304 struct breakpoint
*b
;
7305 struct bp_location
*bl
;
7309 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
7310 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
7312 /* Special types of hardware breakpoints may use more than
7314 i
+= b
->ops
->resources_needed (bl
);
7321 /* Returns the resources B would use if it were a hardware
7325 hw_watchpoint_use_count (struct breakpoint
*b
)
7328 struct bp_location
*bl
;
7330 if (!breakpoint_enabled (b
))
7333 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
7335 /* Special types of hardware watchpoints may use more than
7337 i
+= b
->ops
->resources_needed (bl
);
7343 /* Returns the sum the used resources of all hardware watchpoints of
7344 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
7345 the sum of the used resources of all hardware watchpoints of other
7346 types _not_ TYPE. */
7349 hw_watchpoint_used_count_others (struct breakpoint
*except
,
7350 enum bptype type
, int *other_type_used
)
7353 struct breakpoint
*b
;
7355 *other_type_used
= 0;
7360 if (!breakpoint_enabled (b
))
7363 if (b
->type
== type
)
7364 i
+= hw_watchpoint_use_count (b
);
7365 else if (is_hardware_watchpoint (b
))
7366 *other_type_used
= 1;
7373 disable_watchpoints_before_interactive_call_start (void)
7375 struct breakpoint
*b
;
7379 if (is_watchpoint (b
) && breakpoint_enabled (b
))
7381 b
->enable_state
= bp_call_disabled
;
7382 update_global_location_list (0);
7388 enable_watchpoints_after_interactive_call_stop (void)
7390 struct breakpoint
*b
;
7394 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
7396 b
->enable_state
= bp_enabled
;
7397 update_global_location_list (1);
7403 disable_breakpoints_before_startup (void)
7405 current_program_space
->executing_startup
= 1;
7406 update_global_location_list (0);
7410 enable_breakpoints_after_startup (void)
7412 current_program_space
->executing_startup
= 0;
7413 breakpoint_re_set ();
7417 /* Set a breakpoint that will evaporate an end of command
7418 at address specified by SAL.
7419 Restrict it to frame FRAME if FRAME is nonzero. */
7422 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
7423 struct frame_id frame_id
, enum bptype type
)
7425 struct breakpoint
*b
;
7427 /* If FRAME_ID is valid, it should be a real frame, not an inlined
7429 gdb_assert (!frame_id_inlined_p (frame_id
));
7431 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
7432 b
->enable_state
= bp_enabled
;
7433 b
->disposition
= disp_donttouch
;
7434 b
->frame_id
= frame_id
;
7436 /* If we're debugging a multi-threaded program, then we want
7437 momentary breakpoints to be active in only a single thread of
7439 if (in_thread_list (inferior_ptid
))
7440 b
->thread
= pid_to_thread_id (inferior_ptid
);
7442 update_global_location_list_nothrow (1);
7447 /* Make a momentary breakpoint based on the master breakpoint ORIG.
7448 The new breakpoint will have type TYPE, and use OPS as it
7451 static struct breakpoint
*
7452 momentary_breakpoint_from_master (struct breakpoint
*orig
,
7454 const struct breakpoint_ops
*ops
)
7456 struct breakpoint
*copy
;
7458 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
7459 copy
->loc
= allocate_bp_location (copy
);
7460 set_breakpoint_location_function (copy
->loc
, 1);
7462 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
7463 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
7464 copy
->loc
->address
= orig
->loc
->address
;
7465 copy
->loc
->section
= orig
->loc
->section
;
7466 copy
->loc
->pspace
= orig
->loc
->pspace
;
7468 if (orig
->loc
->source_file
!= NULL
)
7469 copy
->loc
->source_file
= xstrdup (orig
->loc
->source_file
);
7471 copy
->loc
->line_number
= orig
->loc
->line_number
;
7472 copy
->frame_id
= orig
->frame_id
;
7473 copy
->thread
= orig
->thread
;
7474 copy
->pspace
= orig
->pspace
;
7476 copy
->enable_state
= bp_enabled
;
7477 copy
->disposition
= disp_donttouch
;
7478 copy
->number
= internal_breakpoint_number
--;
7480 update_global_location_list_nothrow (0);
7484 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
7488 clone_momentary_breakpoint (struct breakpoint
*orig
)
7490 /* If there's nothing to clone, then return nothing. */
7494 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
);
7498 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
7501 struct symtab_and_line sal
;
7503 sal
= find_pc_line (pc
, 0);
7505 sal
.section
= find_pc_overlay (pc
);
7506 sal
.explicit_pc
= 1;
7508 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
7512 /* Tell the user we have just set a breakpoint B. */
7515 mention (struct breakpoint
*b
)
7517 b
->ops
->print_mention (b
);
7518 if (ui_out_is_mi_like_p (current_uiout
))
7520 printf_filtered ("\n");
7524 static struct bp_location
*
7525 add_location_to_breakpoint (struct breakpoint
*b
,
7526 const struct symtab_and_line
*sal
)
7528 struct bp_location
*loc
, **tmp
;
7529 CORE_ADDR adjusted_address
;
7530 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
7532 if (loc_gdbarch
== NULL
)
7533 loc_gdbarch
= b
->gdbarch
;
7535 /* Adjust the breakpoint's address prior to allocating a location.
7536 Once we call allocate_bp_location(), that mostly uninitialized
7537 location will be placed on the location chain. Adjustment of the
7538 breakpoint may cause target_read_memory() to be called and we do
7539 not want its scan of the location chain to find a breakpoint and
7540 location that's only been partially initialized. */
7541 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
7544 loc
= allocate_bp_location (b
);
7545 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
7549 loc
->requested_address
= sal
->pc
;
7550 loc
->address
= adjusted_address
;
7551 loc
->pspace
= sal
->pspace
;
7552 gdb_assert (loc
->pspace
!= NULL
);
7553 loc
->section
= sal
->section
;
7554 loc
->gdbarch
= loc_gdbarch
;
7556 if (sal
->symtab
!= NULL
)
7557 loc
->source_file
= xstrdup (sal
->symtab
->filename
);
7558 loc
->line_number
= sal
->line
;
7560 set_breakpoint_location_function (loc
,
7561 sal
->explicit_pc
|| sal
->explicit_line
);
7566 /* Return 1 if LOC is pointing to a permanent breakpoint,
7567 return 0 otherwise. */
7570 bp_loc_is_permanent (struct bp_location
*loc
)
7574 const gdb_byte
*bpoint
;
7575 gdb_byte
*target_mem
;
7576 struct cleanup
*cleanup
;
7579 gdb_assert (loc
!= NULL
);
7581 addr
= loc
->address
;
7582 bpoint
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
7584 /* Software breakpoints unsupported? */
7588 target_mem
= alloca (len
);
7590 /* Enable the automatic memory restoration from breakpoints while
7591 we read the memory. Otherwise we could say about our temporary
7592 breakpoints they are permanent. */
7593 cleanup
= save_current_space_and_thread ();
7595 switch_to_program_space_and_thread (loc
->pspace
);
7596 make_show_memory_breakpoints_cleanup (0);
7598 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
7599 && memcmp (target_mem
, bpoint
, len
) == 0)
7602 do_cleanups (cleanup
);
7609 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7610 as textual description of the location, and COND_STRING
7611 as condition expression. */
7614 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7615 struct symtabs_and_lines sals
, char *addr_string
,
7616 char *filter
, char *cond_string
,
7617 enum bptype type
, enum bpdisp disposition
,
7618 int thread
, int task
, int ignore_count
,
7619 const struct breakpoint_ops
*ops
, int from_tty
,
7620 int enabled
, int internal
, int display_canonical
)
7624 if (type
== bp_hardware_breakpoint
)
7626 int target_resources_ok
;
7628 i
= hw_breakpoint_used_count ();
7629 target_resources_ok
=
7630 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
7632 if (target_resources_ok
== 0)
7633 error (_("No hardware breakpoint support in the target."));
7634 else if (target_resources_ok
< 0)
7635 error (_("Hardware breakpoints used exceeds limit."));
7638 gdb_assert (sals
.nelts
> 0);
7640 for (i
= 0; i
< sals
.nelts
; ++i
)
7642 struct symtab_and_line sal
= sals
.sals
[i
];
7643 struct bp_location
*loc
;
7647 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
7649 loc_gdbarch
= gdbarch
;
7651 describe_other_breakpoints (loc_gdbarch
,
7652 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
7657 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
7661 b
->cond_string
= cond_string
;
7662 b
->ignore_count
= ignore_count
;
7663 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7664 b
->disposition
= disposition
;
7666 if (type
== bp_static_tracepoint
)
7668 struct tracepoint
*t
= (struct tracepoint
*) b
;
7669 struct static_tracepoint_marker marker
;
7671 if (strace_marker_p (b
))
7673 /* We already know the marker exists, otherwise, we
7674 wouldn't see a sal for it. */
7675 char *p
= &addr_string
[3];
7679 p
= skip_spaces (p
);
7681 endp
= skip_to_space (p
);
7683 marker_str
= savestring (p
, endp
- p
);
7684 t
->static_trace_marker_id
= marker_str
;
7686 printf_filtered (_("Probed static tracepoint "
7688 t
->static_trace_marker_id
);
7690 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
7692 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
7693 release_static_tracepoint_marker (&marker
);
7695 printf_filtered (_("Probed static tracepoint "
7697 t
->static_trace_marker_id
);
7700 warning (_("Couldn't determine the static "
7701 "tracepoint marker to probe"));
7708 loc
= add_location_to_breakpoint (b
, &sal
);
7711 if (bp_loc_is_permanent (loc
))
7712 make_breakpoint_permanent (b
);
7716 char *arg
= b
->cond_string
;
7717 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
7719 error (_("Garbage %s follows condition"), arg
);
7723 b
->display_canonical
= display_canonical
;
7725 b
->addr_string
= addr_string
;
7727 /* addr_string has to be used or breakpoint_re_set will delete
7730 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
7735 create_breakpoint_sal (struct gdbarch
*gdbarch
,
7736 struct symtabs_and_lines sals
, char *addr_string
,
7737 char *filter
, char *cond_string
,
7738 enum bptype type
, enum bpdisp disposition
,
7739 int thread
, int task
, int ignore_count
,
7740 const struct breakpoint_ops
*ops
, int from_tty
,
7741 int enabled
, int internal
, int display_canonical
)
7743 struct breakpoint
*b
;
7744 struct cleanup
*old_chain
;
7746 if (is_tracepoint_type (type
))
7748 struct tracepoint
*t
;
7750 t
= XCNEW (struct tracepoint
);
7754 b
= XNEW (struct breakpoint
);
7756 old_chain
= make_cleanup (xfree
, b
);
7758 init_breakpoint_sal (b
, gdbarch
,
7760 filter
, cond_string
,
7762 thread
, task
, ignore_count
,
7764 enabled
, internal
, display_canonical
);
7765 discard_cleanups (old_chain
);
7767 install_breakpoint (internal
, b
, 0);
7770 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7771 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7772 value. COND_STRING, if not NULL, specified the condition to be
7773 used for all breakpoints. Essentially the only case where
7774 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7775 function. In that case, it's still not possible to specify
7776 separate conditions for different overloaded functions, so
7777 we take just a single condition string.
7779 NOTE: If the function succeeds, the caller is expected to cleanup
7780 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7781 array contents). If the function fails (error() is called), the
7782 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7783 COND and SALS arrays and each of those arrays contents. */
7786 create_breakpoints_sal (struct gdbarch
*gdbarch
,
7787 struct linespec_result
*canonical
,
7789 enum bptype type
, enum bpdisp disposition
,
7790 int thread
, int task
, int ignore_count
,
7791 const struct breakpoint_ops
*ops
, int from_tty
,
7792 int enabled
, int internal
)
7795 struct linespec_sals
*lsal
;
7797 if (canonical
->pre_expanded
)
7798 gdb_assert (VEC_length (linespec_sals
, canonical
->sals
) == 1);
7800 for (i
= 0; VEC_iterate (linespec_sals
, canonical
->sals
, i
, lsal
); ++i
)
7802 /* Note that 'addr_string' can be NULL in the case of a plain
7803 'break', without arguments. */
7804 char *addr_string
= (canonical
->addr_string
7805 ? xstrdup (canonical
->addr_string
)
7807 char *filter_string
= lsal
->canonical
? xstrdup (lsal
->canonical
) : NULL
;
7808 struct cleanup
*inner
= make_cleanup (xfree
, addr_string
);
7810 make_cleanup (xfree
, filter_string
);
7811 create_breakpoint_sal (gdbarch
, lsal
->sals
,
7814 cond_string
, type
, disposition
,
7815 thread
, task
, ignore_count
, ops
,
7816 from_tty
, enabled
, internal
,
7817 canonical
->special_display
);
7818 discard_cleanups (inner
);
7822 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7823 followed by conditionals. On return, SALS contains an array of SAL
7824 addresses found. ADDR_STRING contains a vector of (canonical)
7825 address strings. ADDRESS points to the end of the SAL.
7827 The array and the line spec strings are allocated on the heap, it is
7828 the caller's responsibility to free them. */
7831 parse_breakpoint_sals (char **address
,
7832 struct linespec_result
*canonical
)
7834 char *addr_start
= *address
;
7836 /* If no arg given, or if first arg is 'if ', use the default
7838 if ((*address
) == NULL
7839 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
7841 /* The last displayed codepoint, if it's valid, is our default breakpoint
7843 if (last_displayed_sal_is_valid ())
7845 struct linespec_sals lsal
;
7846 struct symtab_and_line sal
;
7848 init_sal (&sal
); /* Initialize to zeroes. */
7849 lsal
.sals
.sals
= (struct symtab_and_line
*)
7850 xmalloc (sizeof (struct symtab_and_line
));
7852 /* Set sal's pspace, pc, symtab, and line to the values
7853 corresponding to the last call to print_frame_info. */
7854 get_last_displayed_sal (&sal
);
7855 sal
.section
= find_pc_overlay (sal
.pc
);
7857 /* "break" without arguments is equivalent to "break *PC"
7858 where PC is the last displayed codepoint's address. So
7859 make sure to set sal.explicit_pc to prevent GDB from
7860 trying to expand the list of sals to include all other
7861 instances with the same symtab and line. */
7862 sal
.explicit_pc
= 1;
7864 lsal
.sals
.sals
[0] = sal
;
7865 lsal
.sals
.nelts
= 1;
7866 lsal
.canonical
= NULL
;
7868 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
7871 error (_("No default breakpoint address now."));
7875 /* Force almost all breakpoints to be in terms of the
7876 current_source_symtab (which is decode_line_1's default).
7877 This should produce the results we want almost all of the
7878 time while leaving default_breakpoint_* alone. */
7879 if (last_displayed_sal_is_valid ())
7880 decode_line_full (address
, DECODE_LINE_FUNFIRSTLINE
,
7881 get_last_displayed_symtab (),
7882 get_last_displayed_line (),
7883 canonical
, NULL
, NULL
);
7885 decode_line_full (address
, DECODE_LINE_FUNFIRSTLINE
,
7886 (struct symtab
*) NULL
, 0,
7887 canonical
, NULL
, NULL
);
7892 /* Convert each SAL into a real PC. Verify that the PC can be
7893 inserted as a breakpoint. If it can't throw an error. */
7896 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
7900 for (i
= 0; i
< sals
->nelts
; i
++)
7901 resolve_sal_pc (&sals
->sals
[i
]);
7904 /* Fast tracepoints may have restrictions on valid locations. For
7905 instance, a fast tracepoint using a jump instead of a trap will
7906 likely have to overwrite more bytes than a trap would, and so can
7907 only be placed where the instruction is longer than the jump, or a
7908 multi-instruction sequence does not have a jump into the middle of
7912 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
7913 struct symtabs_and_lines
*sals
)
7916 struct symtab_and_line
*sal
;
7918 struct cleanup
*old_chain
;
7920 for (i
= 0; i
< sals
->nelts
; i
++)
7922 struct gdbarch
*sarch
;
7924 sal
= &sals
->sals
[i
];
7926 sarch
= get_sal_arch (*sal
);
7927 /* We fall back to GDBARCH if there is no architecture
7928 associated with SAL. */
7931 rslt
= gdbarch_fast_tracepoint_valid_at (sarch
, sal
->pc
,
7933 old_chain
= make_cleanup (xfree
, msg
);
7936 error (_("May not have a fast tracepoint at 0x%s%s"),
7937 paddress (sarch
, sal
->pc
), (msg
? msg
: ""));
7939 do_cleanups (old_chain
);
7943 /* Given TOK, a string specification of condition and thread, as
7944 accepted by the 'break' command, extract the condition
7945 string and thread number and set *COND_STRING and *THREAD.
7946 PC identifies the context at which the condition should be parsed.
7947 If no condition is found, *COND_STRING is set to NULL.
7948 If no thread is found, *THREAD is set to -1. */
7950 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
7951 char **cond_string
, int *thread
, int *task
)
7953 *cond_string
= NULL
;
7959 char *cond_start
= NULL
;
7960 char *cond_end
= NULL
;
7962 tok
= skip_spaces (tok
);
7964 end_tok
= skip_to_space (tok
);
7966 toklen
= end_tok
- tok
;
7968 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7970 struct expression
*expr
;
7972 tok
= cond_start
= end_tok
+ 1;
7973 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
7976 *cond_string
= savestring (cond_start
,
7977 cond_end
- cond_start
);
7979 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7985 *thread
= strtol (tok
, &tok
, 0);
7987 error (_("Junk after thread keyword."));
7988 if (!valid_thread_id (*thread
))
7989 error (_("Unknown thread %d."), *thread
);
7991 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
7997 *task
= strtol (tok
, &tok
, 0);
7999 error (_("Junk after task keyword."));
8000 if (!valid_task_id (*task
))
8001 error (_("Unknown task %d."), *task
);
8004 error (_("Junk at end of arguments."));
8008 /* Decode a static tracepoint marker spec. */
8010 static struct symtabs_and_lines
8011 decode_static_tracepoint_spec (char **arg_p
)
8013 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
8014 struct symtabs_and_lines sals
;
8015 struct symtab_and_line sal
;
8017 struct cleanup
*old_chain
;
8018 char *p
= &(*arg_p
)[3];
8023 p
= skip_spaces (p
);
8025 endp
= skip_to_space (p
);
8027 marker_str
= savestring (p
, endp
- p
);
8028 old_chain
= make_cleanup (xfree
, marker_str
);
8030 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
8031 if (VEC_empty(static_tracepoint_marker_p
, markers
))
8032 error (_("No known static tracepoint marker named %s"), marker_str
);
8034 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
8035 sals
.sals
= xmalloc (sizeof *sals
.sals
* sals
.nelts
);
8037 for (i
= 0; i
< sals
.nelts
; i
++)
8039 struct static_tracepoint_marker
*marker
;
8041 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
8043 init_sal (&sals
.sals
[i
]);
8045 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
8046 sals
.sals
[i
].pc
= marker
->address
;
8048 release_static_tracepoint_marker (marker
);
8051 do_cleanups (old_chain
);
8057 /* Set a breakpoint. This function is shared between CLI and MI
8058 functions for setting a breakpoint. This function has two major
8059 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
8060 parameter. If non-zero, the function will parse arg, extracting
8061 breakpoint location, address and thread. Otherwise, ARG is just
8062 the location of breakpoint, with condition and thread specified by
8063 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
8064 the breakpoint number will be allocated from the internal
8065 breakpoint count. Returns true if any breakpoint was created;
8069 create_breakpoint (struct gdbarch
*gdbarch
,
8070 char *arg
, char *cond_string
, int thread
,
8071 int parse_condition_and_thread
,
8072 int tempflag
, enum bptype type_wanted
,
8074 enum auto_boolean pending_break_support
,
8075 const struct breakpoint_ops
*ops
,
8076 int from_tty
, int enabled
, int internal
)
8078 volatile struct gdb_exception e
;
8079 char *copy_arg
= NULL
;
8080 char *addr_start
= arg
;
8081 struct linespec_result canonical
;
8082 struct cleanup
*old_chain
;
8083 struct cleanup
*bkpt_chain
= NULL
;
8087 int prev_bkpt_count
= breakpoint_count
;
8089 gdb_assert (ops
!= NULL
);
8091 init_linespec_result (&canonical
);
8093 TRY_CATCH (e
, RETURN_MASK_ALL
)
8095 ops
->create_sals_from_address (&arg
, &canonical
, type_wanted
,
8096 addr_start
, ©_arg
);
8099 /* If caller is interested in rc value from parse, set value. */
8103 if (VEC_empty (linespec_sals
, canonical
.sals
))
8109 case NOT_FOUND_ERROR
:
8111 /* If pending breakpoint support is turned off, throw
8114 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
8115 throw_exception (e
);
8117 exception_print (gdb_stderr
, e
);
8119 /* If pending breakpoint support is auto query and the user
8120 selects no, then simply return the error code. */
8121 if (pending_break_support
== AUTO_BOOLEAN_AUTO
8122 && !nquery (_("Make %s pending on future shared library load? "),
8123 bptype_string (type_wanted
)))
8126 /* At this point, either the user was queried about setting
8127 a pending breakpoint and selected yes, or pending
8128 breakpoint behavior is on and thus a pending breakpoint
8129 is defaulted on behalf of the user. */
8131 struct linespec_sals lsal
;
8133 copy_arg
= xstrdup (addr_start
);
8134 lsal
.canonical
= xstrdup (copy_arg
);
8135 lsal
.sals
.nelts
= 1;
8136 lsal
.sals
.sals
= XNEW (struct symtab_and_line
);
8137 init_sal (&lsal
.sals
.sals
[0]);
8139 VEC_safe_push (linespec_sals
, canonical
.sals
, &lsal
);
8143 throw_exception (e
);
8147 throw_exception (e
);
8150 /* Create a chain of things that always need to be cleaned up. */
8151 old_chain
= make_cleanup_destroy_linespec_result (&canonical
);
8153 /* ----------------------------- SNIP -----------------------------
8154 Anything added to the cleanup chain beyond this point is assumed
8155 to be part of a breakpoint. If the breakpoint create succeeds
8156 then the memory is not reclaimed. */
8157 bkpt_chain
= make_cleanup (null_cleanup
, 0);
8159 /* Resolve all line numbers to PC's and verify that the addresses
8160 are ok for the target. */
8164 struct linespec_sals
*iter
;
8166 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
8167 breakpoint_sals_to_pc (&iter
->sals
);
8170 /* Fast tracepoints may have additional restrictions on location. */
8171 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
8174 struct linespec_sals
*iter
;
8176 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
8177 check_fast_tracepoint_sals (gdbarch
, &iter
->sals
);
8180 /* Verify that condition can be parsed, before setting any
8181 breakpoints. Allocate a separate condition expression for each
8185 struct linespec_sals
*lsal
;
8187 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
8189 if (parse_condition_and_thread
)
8191 /* Here we only parse 'arg' to separate condition
8192 from thread number, so parsing in context of first
8193 sal is OK. When setting the breakpoint we'll
8194 re-parse it in context of each sal. */
8197 find_condition_and_thread (arg
, lsal
->sals
.sals
[0].pc
, &cond_string
,
8200 make_cleanup (xfree
, cond_string
);
8204 /* Create a private copy of condition string. */
8207 cond_string
= xstrdup (cond_string
);
8208 make_cleanup (xfree
, cond_string
);
8212 ops
->create_breakpoints_sal (gdbarch
, &canonical
, lsal
,
8213 cond_string
, type_wanted
,
8214 tempflag
? disp_del
: disp_donttouch
,
8215 thread
, task
, ignore_count
, ops
,
8216 from_tty
, enabled
, internal
);
8220 struct breakpoint
*b
;
8222 make_cleanup (xfree
, copy_arg
);
8224 if (is_tracepoint_type (type_wanted
))
8226 struct tracepoint
*t
;
8228 t
= XCNEW (struct tracepoint
);
8232 b
= XNEW (struct breakpoint
);
8234 init_raw_breakpoint_without_location (b
, gdbarch
, type_wanted
, ops
);
8236 b
->addr_string
= copy_arg
;
8237 b
->cond_string
= NULL
;
8238 b
->ignore_count
= ignore_count
;
8239 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8240 b
->condition_not_parsed
= 1;
8241 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8242 if ((type_wanted
!= bp_breakpoint
8243 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
8244 b
->pspace
= current_program_space
;
8246 install_breakpoint (internal
, b
, 0);
8249 if (VEC_length (linespec_sals
, canonical
.sals
) > 1)
8251 warning (_("Multiple breakpoints were set.\nUse the "
8252 "\"delete\" command to delete unwanted breakpoints."));
8253 prev_breakpoint_count
= prev_bkpt_count
;
8256 /* That's it. Discard the cleanups for data inserted into the
8258 discard_cleanups (bkpt_chain
);
8259 /* But cleanup everything else. */
8260 do_cleanups (old_chain
);
8262 /* error call may happen here - have BKPT_CHAIN already discarded. */
8263 update_global_location_list (1);
8268 /* Set a breakpoint.
8269 ARG is a string describing breakpoint address,
8270 condition, and thread.
8271 FLAG specifies if a breakpoint is hardware on,
8272 and if breakpoint is temporary, using BP_HARDWARE_FLAG
8276 break_command_1 (char *arg
, int flag
, int from_tty
)
8278 int tempflag
= flag
& BP_TEMPFLAG
;
8279 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
8280 ? bp_hardware_breakpoint
8283 create_breakpoint (get_current_arch (),
8285 NULL
, 0, 1 /* parse arg */,
8286 tempflag
, type_wanted
,
8287 0 /* Ignore count */,
8288 pending_break_support
,
8289 &bkpt_breakpoint_ops
,
8295 /* Helper function for break_command_1 and disassemble_command. */
8298 resolve_sal_pc (struct symtab_and_line
*sal
)
8302 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
8304 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
8305 error (_("No line %d in file \"%s\"."),
8306 sal
->line
, sal
->symtab
->filename
);
8309 /* If this SAL corresponds to a breakpoint inserted using a line
8310 number, then skip the function prologue if necessary. */
8311 if (sal
->explicit_line
)
8312 skip_prologue_sal (sal
);
8315 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
8317 struct blockvector
*bv
;
8321 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
8324 sym
= block_linkage_function (b
);
8327 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
8328 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
8332 /* It really is worthwhile to have the section, so we'll
8333 just have to look harder. This case can be executed
8334 if we have line numbers but no functions (as can
8335 happen in assembly source). */
8337 struct minimal_symbol
*msym
;
8338 struct cleanup
*old_chain
= save_current_space_and_thread ();
8340 switch_to_program_space_and_thread (sal
->pspace
);
8342 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
8344 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
8346 do_cleanups (old_chain
);
8353 break_command (char *arg
, int from_tty
)
8355 break_command_1 (arg
, 0, from_tty
);
8359 tbreak_command (char *arg
, int from_tty
)
8361 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
8365 hbreak_command (char *arg
, int from_tty
)
8367 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
8371 thbreak_command (char *arg
, int from_tty
)
8373 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
8377 stop_command (char *arg
, int from_tty
)
8379 printf_filtered (_("Specify the type of breakpoint to set.\n\
8380 Usage: stop in <function | address>\n\
8381 stop at <line>\n"));
8385 stopin_command (char *arg
, int from_tty
)
8389 if (arg
== (char *) NULL
)
8391 else if (*arg
!= '*')
8396 /* Look for a ':'. If this is a line number specification, then
8397 say it is bad, otherwise, it should be an address or
8398 function/method name. */
8399 while (*argptr
&& !hasColon
)
8401 hasColon
= (*argptr
== ':');
8406 badInput
= (*argptr
!= ':'); /* Not a class::method */
8408 badInput
= isdigit (*arg
); /* a simple line number */
8412 printf_filtered (_("Usage: stop in <function | address>\n"));
8414 break_command_1 (arg
, 0, from_tty
);
8418 stopat_command (char *arg
, int from_tty
)
8422 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
8429 /* Look for a ':'. If there is a '::' then get out, otherwise
8430 it is probably a line number. */
8431 while (*argptr
&& !hasColon
)
8433 hasColon
= (*argptr
== ':');
8438 badInput
= (*argptr
== ':'); /* we have class::method */
8440 badInput
= !isdigit (*arg
); /* not a line number */
8444 printf_filtered (_("Usage: stop at <line>\n"));
8446 break_command_1 (arg
, 0, from_tty
);
8449 /* Implement the "breakpoint_hit" breakpoint_ops method for
8450 ranged breakpoints. */
8453 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
8454 struct address_space
*aspace
,
8456 const struct target_waitstatus
*ws
)
8458 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
8459 || ws
->value
.sig
!= TARGET_SIGNAL_TRAP
)
8462 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
8463 bl
->length
, aspace
, bp_addr
);
8466 /* Implement the "resources_needed" breakpoint_ops method for
8467 ranged breakpoints. */
8470 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
8472 return target_ranged_break_num_registers ();
8475 /* Implement the "print_it" breakpoint_ops method for
8476 ranged breakpoints. */
8478 static enum print_stop_action
8479 print_it_ranged_breakpoint (bpstat bs
)
8481 struct breakpoint
*b
= bs
->breakpoint_at
;
8482 struct bp_location
*bl
= b
->loc
;
8483 struct ui_out
*uiout
= current_uiout
;
8485 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8487 /* Ranged breakpoints have only one location. */
8488 gdb_assert (bl
&& bl
->next
== NULL
);
8490 annotate_breakpoint (b
->number
);
8491 if (b
->disposition
== disp_del
)
8492 ui_out_text (uiout
, "\nTemporary ranged breakpoint ");
8494 ui_out_text (uiout
, "\nRanged breakpoint ");
8495 if (ui_out_is_mi_like_p (uiout
))
8497 ui_out_field_string (uiout
, "reason",
8498 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
8499 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8501 ui_out_field_int (uiout
, "bkptno", b
->number
);
8502 ui_out_text (uiout
, ", ");
8504 return PRINT_SRC_AND_LOC
;
8507 /* Implement the "print_one" breakpoint_ops method for
8508 ranged breakpoints. */
8511 print_one_ranged_breakpoint (struct breakpoint
*b
,
8512 struct bp_location
**last_loc
)
8514 struct bp_location
*bl
= b
->loc
;
8515 struct value_print_options opts
;
8516 struct ui_out
*uiout
= current_uiout
;
8518 /* Ranged breakpoints have only one location. */
8519 gdb_assert (bl
&& bl
->next
== NULL
);
8521 get_user_print_options (&opts
);
8523 if (opts
.addressprint
)
8524 /* We don't print the address range here, it will be printed later
8525 by print_one_detail_ranged_breakpoint. */
8526 ui_out_field_skip (uiout
, "addr");
8528 print_breakpoint_location (b
, bl
);
8532 /* Implement the "print_one_detail" breakpoint_ops method for
8533 ranged breakpoints. */
8536 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
8537 struct ui_out
*uiout
)
8539 CORE_ADDR address_start
, address_end
;
8540 struct bp_location
*bl
= b
->loc
;
8541 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
8542 struct cleanup
*cleanup
= make_cleanup_ui_out_stream_delete (stb
);
8546 address_start
= bl
->address
;
8547 address_end
= address_start
+ bl
->length
- 1;
8549 ui_out_text (uiout
, "\taddress range: ");
8550 fprintf_unfiltered (stb
->stream
, "[%s, %s]",
8551 print_core_address (bl
->gdbarch
, address_start
),
8552 print_core_address (bl
->gdbarch
, address_end
));
8553 ui_out_field_stream (uiout
, "addr", stb
);
8554 ui_out_text (uiout
, "\n");
8556 do_cleanups (cleanup
);
8559 /* Implement the "print_mention" breakpoint_ops method for
8560 ranged breakpoints. */
8563 print_mention_ranged_breakpoint (struct breakpoint
*b
)
8565 struct bp_location
*bl
= b
->loc
;
8566 struct ui_out
*uiout
= current_uiout
;
8569 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8571 if (ui_out_is_mi_like_p (uiout
))
8574 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
8575 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
8576 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
8579 /* Implement the "print_recreate" breakpoint_ops method for
8580 ranged breakpoints. */
8583 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8585 fprintf_unfiltered (fp
, "break-range %s, %s", b
->addr_string
,
8586 b
->addr_string_range_end
);
8587 print_recreate_thread (b
, fp
);
8590 /* The breakpoint_ops structure to be used in ranged breakpoints. */
8592 static struct breakpoint_ops ranged_breakpoint_ops
;
8594 /* Find the address where the end of the breakpoint range should be
8595 placed, given the SAL of the end of the range. This is so that if
8596 the user provides a line number, the end of the range is set to the
8597 last instruction of the given line. */
8600 find_breakpoint_range_end (struct symtab_and_line sal
)
8604 /* If the user provided a PC value, use it. Otherwise,
8605 find the address of the end of the given location. */
8606 if (sal
.explicit_pc
)
8613 ret
= find_line_pc_range (sal
, &start
, &end
);
8615 error (_("Could not find location of the end of the range."));
8617 /* find_line_pc_range returns the start of the next line. */
8624 /* Implement the "break-range" CLI command. */
8627 break_range_command (char *arg
, int from_tty
)
8629 char *arg_start
, *addr_string_start
, *addr_string_end
;
8630 struct linespec_result canonical_start
, canonical_end
;
8631 int bp_count
, can_use_bp
, length
;
8633 struct breakpoint
*b
;
8634 struct symtab_and_line sal_start
, sal_end
;
8635 struct cleanup
*cleanup_bkpt
;
8636 struct linespec_sals
*lsal_start
, *lsal_end
;
8638 /* We don't support software ranged breakpoints. */
8639 if (target_ranged_break_num_registers () < 0)
8640 error (_("This target does not support hardware ranged breakpoints."));
8642 bp_count
= hw_breakpoint_used_count ();
8643 bp_count
+= target_ranged_break_num_registers ();
8644 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8647 error (_("Hardware breakpoints used exceeds limit."));
8649 arg
= skip_spaces (arg
);
8650 if (arg
== NULL
|| arg
[0] == '\0')
8651 error(_("No address range specified."));
8653 init_linespec_result (&canonical_start
);
8656 parse_breakpoint_sals (&arg
, &canonical_start
);
8658 cleanup_bkpt
= make_cleanup_destroy_linespec_result (&canonical_start
);
8661 error (_("Too few arguments."));
8662 else if (VEC_empty (linespec_sals
, canonical_start
.sals
))
8663 error (_("Could not find location of the beginning of the range."));
8665 lsal_start
= VEC_index (linespec_sals
, canonical_start
.sals
, 0);
8667 if (VEC_length (linespec_sals
, canonical_start
.sals
) > 1
8668 || lsal_start
->sals
.nelts
!= 1)
8669 error (_("Cannot create a ranged breakpoint with multiple locations."));
8671 sal_start
= lsal_start
->sals
.sals
[0];
8672 addr_string_start
= savestring (arg_start
, arg
- arg_start
);
8673 make_cleanup (xfree
, addr_string_start
);
8675 arg
++; /* Skip the comma. */
8676 arg
= skip_spaces (arg
);
8678 /* Parse the end location. */
8680 init_linespec_result (&canonical_end
);
8683 /* We call decode_line_full directly here instead of using
8684 parse_breakpoint_sals because we need to specify the start location's
8685 symtab and line as the default symtab and line for the end of the
8686 range. This makes it possible to have ranges like "foo.c:27, +14",
8687 where +14 means 14 lines from the start location. */
8688 decode_line_full (&arg
, DECODE_LINE_FUNFIRSTLINE
,
8689 sal_start
.symtab
, sal_start
.line
,
8690 &canonical_end
, NULL
, NULL
);
8692 make_cleanup_destroy_linespec_result (&canonical_end
);
8694 if (VEC_empty (linespec_sals
, canonical_end
.sals
))
8695 error (_("Could not find location of the end of the range."));
8697 lsal_end
= VEC_index (linespec_sals
, canonical_end
.sals
, 0);
8698 if (VEC_length (linespec_sals
, canonical_end
.sals
) > 1
8699 || lsal_end
->sals
.nelts
!= 1)
8700 error (_("Cannot create a ranged breakpoint with multiple locations."));
8702 sal_end
= lsal_end
->sals
.sals
[0];
8703 addr_string_end
= savestring (arg_start
, arg
- arg_start
);
8704 make_cleanup (xfree
, addr_string_end
);
8706 end
= find_breakpoint_range_end (sal_end
);
8707 if (sal_start
.pc
> end
)
8708 error (_("Invalid address range, end precedes start."));
8710 length
= end
- sal_start
.pc
+ 1;
8712 /* Length overflowed. */
8713 error (_("Address range too large."));
8714 else if (length
== 1)
8716 /* This range is simple enough to be handled by
8717 the `hbreak' command. */
8718 hbreak_command (addr_string_start
, 1);
8720 do_cleanups (cleanup_bkpt
);
8725 /* Now set up the breakpoint. */
8726 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
8727 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
8728 set_breakpoint_count (breakpoint_count
+ 1);
8729 b
->number
= breakpoint_count
;
8730 b
->disposition
= disp_donttouch
;
8731 b
->addr_string
= xstrdup (addr_string_start
);
8732 b
->addr_string_range_end
= xstrdup (addr_string_end
);
8733 b
->loc
->length
= length
;
8735 do_cleanups (cleanup_bkpt
);
8738 observer_notify_breakpoint_created (b
);
8739 update_global_location_list (1);
8742 /* Return non-zero if EXP is verified as constant. Returned zero
8743 means EXP is variable. Also the constant detection may fail for
8744 some constant expressions and in such case still falsely return
8747 watchpoint_exp_is_const (const struct expression
*exp
)
8755 /* We are only interested in the descriptor of each element. */
8756 operator_length (exp
, i
, &oplenp
, &argsp
);
8759 switch (exp
->elts
[i
].opcode
)
8769 case BINOP_LOGICAL_AND
:
8770 case BINOP_LOGICAL_OR
:
8771 case BINOP_BITWISE_AND
:
8772 case BINOP_BITWISE_IOR
:
8773 case BINOP_BITWISE_XOR
:
8775 case BINOP_NOTEQUAL
:
8791 case TERNOP_SLICE_COUNT
:
8803 case OP_OBJC_NSSTRING
:
8806 case UNOP_LOGICAL_NOT
:
8807 case UNOP_COMPLEMENT
:
8810 /* Unary, binary and ternary operators: We have to check
8811 their operands. If they are constant, then so is the
8812 result of that operation. For instance, if A and B are
8813 determined to be constants, then so is "A + B".
8815 UNOP_IND is one exception to the rule above, because the
8816 value of *ADDR is not necessarily a constant, even when
8821 /* Check whether the associated symbol is a constant.
8823 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8824 possible that a buggy compiler could mark a variable as
8825 constant even when it is not, and TYPE_CONST would return
8826 true in this case, while SYMBOL_CLASS wouldn't.
8828 We also have to check for function symbols because they
8829 are always constant. */
8831 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
8833 if (SYMBOL_CLASS (s
) != LOC_BLOCK
8834 && SYMBOL_CLASS (s
) != LOC_CONST
8835 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
8840 /* The default action is to return 0 because we are using
8841 the optimistic approach here: If we don't know something,
8842 then it is not a constant. */
8851 /* Implement the "dtor" breakpoint_ops method for watchpoints. */
8854 dtor_watchpoint (struct breakpoint
*self
)
8856 struct watchpoint
*w
= (struct watchpoint
*) self
;
8858 xfree (w
->cond_exp
);
8860 xfree (w
->exp_string
);
8861 xfree (w
->exp_string_reparse
);
8862 value_free (w
->val
);
8864 base_breakpoint_ops
.dtor (self
);
8867 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
8870 re_set_watchpoint (struct breakpoint
*b
)
8872 struct watchpoint
*w
= (struct watchpoint
*) b
;
8874 /* Watchpoint can be either on expression using entirely global
8875 variables, or it can be on local variables.
8877 Watchpoints of the first kind are never auto-deleted, and even
8878 persist across program restarts. Since they can use variables
8879 from shared libraries, we need to reparse expression as libraries
8880 are loaded and unloaded.
8882 Watchpoints on local variables can also change meaning as result
8883 of solib event. For example, if a watchpoint uses both a local
8884 and a global variables in expression, it's a local watchpoint,
8885 but unloading of a shared library will make the expression
8886 invalid. This is not a very common use case, but we still
8887 re-evaluate expression, to avoid surprises to the user.
8889 Note that for local watchpoints, we re-evaluate it only if
8890 watchpoints frame id is still valid. If it's not, it means the
8891 watchpoint is out of scope and will be deleted soon. In fact,
8892 I'm not sure we'll ever be called in this case.
8894 If a local watchpoint's frame id is still valid, then
8895 w->exp_valid_block is likewise valid, and we can safely use it.
8897 Don't do anything about disabled watchpoints, since they will be
8898 reevaluated again when enabled. */
8899 update_watchpoint (w
, 1 /* reparse */);
8902 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8905 insert_watchpoint (struct bp_location
*bl
)
8907 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8908 int length
= w
->exact
? 1 : bl
->length
;
8910 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8914 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8917 remove_watchpoint (struct bp_location
*bl
)
8919 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8920 int length
= w
->exact
? 1 : bl
->length
;
8922 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8927 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
8928 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8929 const struct target_waitstatus
*ws
)
8931 struct breakpoint
*b
= bl
->owner
;
8932 struct watchpoint
*w
= (struct watchpoint
*) b
;
8934 /* Continuable hardware watchpoints are treated as non-existent if the
8935 reason we stopped wasn't a hardware watchpoint (we didn't stop on
8936 some data address). Otherwise gdb won't stop on a break instruction
8937 in the code (not from a breakpoint) when a hardware watchpoint has
8938 been defined. Also skip watchpoints which we know did not trigger
8939 (did not match the data address). */
8940 if (is_hardware_watchpoint (b
)
8941 && w
->watchpoint_triggered
== watch_triggered_no
)
8948 check_status_watchpoint (bpstat bs
)
8950 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
8952 bpstat_check_watchpoint (bs
);
8955 /* Implement the "resources_needed" breakpoint_ops method for
8956 hardware watchpoints. */
8959 resources_needed_watchpoint (const struct bp_location
*bl
)
8961 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8962 int length
= w
->exact
? 1 : bl
->length
;
8964 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
8967 /* Implement the "works_in_software_mode" breakpoint_ops method for
8968 hardware watchpoints. */
8971 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
8973 /* Read and access watchpoints only work with hardware support. */
8974 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
8977 static enum print_stop_action
8978 print_it_watchpoint (bpstat bs
)
8980 struct cleanup
*old_chain
;
8981 struct breakpoint
*b
;
8982 const struct bp_location
*bl
;
8983 struct ui_stream
*stb
;
8984 enum print_stop_action result
;
8985 struct watchpoint
*w
;
8986 struct ui_out
*uiout
= current_uiout
;
8988 gdb_assert (bs
->bp_location_at
!= NULL
);
8990 bl
= bs
->bp_location_at
;
8991 b
= bs
->breakpoint_at
;
8992 w
= (struct watchpoint
*) b
;
8994 stb
= ui_out_stream_new (uiout
);
8995 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
9000 case bp_hardware_watchpoint
:
9001 annotate_watchpoint (b
->number
);
9002 if (ui_out_is_mi_like_p (uiout
))
9005 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
9007 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
9008 ui_out_text (uiout
, "\nOld value = ");
9009 watchpoint_value_print (bs
->old_val
, stb
->stream
);
9010 ui_out_field_stream (uiout
, "old", stb
);
9011 ui_out_text (uiout
, "\nNew value = ");
9012 watchpoint_value_print (w
->val
, stb
->stream
);
9013 ui_out_field_stream (uiout
, "new", stb
);
9014 ui_out_text (uiout
, "\n");
9015 /* More than one watchpoint may have been triggered. */
9016 result
= PRINT_UNKNOWN
;
9019 case bp_read_watchpoint
:
9020 if (ui_out_is_mi_like_p (uiout
))
9023 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
9025 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
9026 ui_out_text (uiout
, "\nValue = ");
9027 watchpoint_value_print (w
->val
, stb
->stream
);
9028 ui_out_field_stream (uiout
, "value", stb
);
9029 ui_out_text (uiout
, "\n");
9030 result
= PRINT_UNKNOWN
;
9033 case bp_access_watchpoint
:
9034 if (bs
->old_val
!= NULL
)
9036 annotate_watchpoint (b
->number
);
9037 if (ui_out_is_mi_like_p (uiout
))
9040 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
9042 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
9043 ui_out_text (uiout
, "\nOld value = ");
9044 watchpoint_value_print (bs
->old_val
, stb
->stream
);
9045 ui_out_field_stream (uiout
, "old", stb
);
9046 ui_out_text (uiout
, "\nNew value = ");
9051 if (ui_out_is_mi_like_p (uiout
))
9054 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
9055 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
9056 ui_out_text (uiout
, "\nValue = ");
9058 watchpoint_value_print (w
->val
, stb
->stream
);
9059 ui_out_field_stream (uiout
, "new", stb
);
9060 ui_out_text (uiout
, "\n");
9061 result
= PRINT_UNKNOWN
;
9064 result
= PRINT_UNKNOWN
;
9067 do_cleanups (old_chain
);
9071 /* Implement the "print_mention" breakpoint_ops method for hardware
9075 print_mention_watchpoint (struct breakpoint
*b
)
9077 struct cleanup
*ui_out_chain
;
9078 struct watchpoint
*w
= (struct watchpoint
*) b
;
9079 struct ui_out
*uiout
= current_uiout
;
9084 ui_out_text (uiout
, "Watchpoint ");
9085 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
9087 case bp_hardware_watchpoint
:
9088 ui_out_text (uiout
, "Hardware watchpoint ");
9089 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
9091 case bp_read_watchpoint
:
9092 ui_out_text (uiout
, "Hardware read watchpoint ");
9093 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
9095 case bp_access_watchpoint
:
9096 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
9097 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
9100 internal_error (__FILE__
, __LINE__
,
9101 _("Invalid hardware watchpoint type."));
9104 ui_out_field_int (uiout
, "number", b
->number
);
9105 ui_out_text (uiout
, ": ");
9106 ui_out_field_string (uiout
, "exp", w
->exp_string
);
9107 do_cleanups (ui_out_chain
);
9110 /* Implement the "print_recreate" breakpoint_ops method for
9114 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9116 struct watchpoint
*w
= (struct watchpoint
*) b
;
9121 case bp_hardware_watchpoint
:
9122 fprintf_unfiltered (fp
, "watch");
9124 case bp_read_watchpoint
:
9125 fprintf_unfiltered (fp
, "rwatch");
9127 case bp_access_watchpoint
:
9128 fprintf_unfiltered (fp
, "awatch");
9131 internal_error (__FILE__
, __LINE__
,
9132 _("Invalid watchpoint type."));
9135 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
9136 print_recreate_thread (b
, fp
);
9139 /* The breakpoint_ops structure to be used in hardware watchpoints. */
9141 static struct breakpoint_ops watchpoint_breakpoint_ops
;
9143 /* Implement the "insert" breakpoint_ops method for
9144 masked hardware watchpoints. */
9147 insert_masked_watchpoint (struct bp_location
*bl
)
9149 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
9151 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
9152 bl
->watchpoint_type
);
9155 /* Implement the "remove" breakpoint_ops method for
9156 masked hardware watchpoints. */
9159 remove_masked_watchpoint (struct bp_location
*bl
)
9161 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
9163 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
9164 bl
->watchpoint_type
);
9167 /* Implement the "resources_needed" breakpoint_ops method for
9168 masked hardware watchpoints. */
9171 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
9173 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
9175 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
9178 /* Implement the "works_in_software_mode" breakpoint_ops method for
9179 masked hardware watchpoints. */
9182 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
9187 /* Implement the "print_it" breakpoint_ops method for
9188 masked hardware watchpoints. */
9190 static enum print_stop_action
9191 print_it_masked_watchpoint (bpstat bs
)
9193 struct breakpoint
*b
= bs
->breakpoint_at
;
9194 struct ui_out
*uiout
= current_uiout
;
9196 /* Masked watchpoints have only one location. */
9197 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
9201 case bp_hardware_watchpoint
:
9202 annotate_watchpoint (b
->number
);
9203 if (ui_out_is_mi_like_p (uiout
))
9206 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
9209 case bp_read_watchpoint
:
9210 if (ui_out_is_mi_like_p (uiout
))
9213 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
9216 case bp_access_watchpoint
:
9217 if (ui_out_is_mi_like_p (uiout
))
9220 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
9223 internal_error (__FILE__
, __LINE__
,
9224 _("Invalid hardware watchpoint type."));
9228 ui_out_text (uiout
, _("\n\
9229 Check the underlying instruction at PC for the memory\n\
9230 address and value which triggered this watchpoint.\n"));
9231 ui_out_text (uiout
, "\n");
9233 /* More than one watchpoint may have been triggered. */
9234 return PRINT_UNKNOWN
;
9237 /* Implement the "print_one_detail" breakpoint_ops method for
9238 masked hardware watchpoints. */
9241 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
9242 struct ui_out
*uiout
)
9244 struct watchpoint
*w
= (struct watchpoint
*) b
;
9246 /* Masked watchpoints have only one location. */
9247 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
9249 ui_out_text (uiout
, "\tmask ");
9250 ui_out_field_core_addr (uiout
, "mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
9251 ui_out_text (uiout
, "\n");
9254 /* Implement the "print_mention" breakpoint_ops method for
9255 masked hardware watchpoints. */
9258 print_mention_masked_watchpoint (struct breakpoint
*b
)
9260 struct watchpoint
*w
= (struct watchpoint
*) b
;
9261 struct ui_out
*uiout
= current_uiout
;
9262 struct cleanup
*ui_out_chain
;
9266 case bp_hardware_watchpoint
:
9267 ui_out_text (uiout
, "Masked hardware watchpoint ");
9268 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
9270 case bp_read_watchpoint
:
9271 ui_out_text (uiout
, "Masked hardware read watchpoint ");
9272 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
9274 case bp_access_watchpoint
:
9275 ui_out_text (uiout
, "Masked hardware access (read/write) watchpoint ");
9276 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
9279 internal_error (__FILE__
, __LINE__
,
9280 _("Invalid hardware watchpoint type."));
9283 ui_out_field_int (uiout
, "number", b
->number
);
9284 ui_out_text (uiout
, ": ");
9285 ui_out_field_string (uiout
, "exp", w
->exp_string
);
9286 do_cleanups (ui_out_chain
);
9289 /* Implement the "print_recreate" breakpoint_ops method for
9290 masked hardware watchpoints. */
9293 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9295 struct watchpoint
*w
= (struct watchpoint
*) b
;
9300 case bp_hardware_watchpoint
:
9301 fprintf_unfiltered (fp
, "watch");
9303 case bp_read_watchpoint
:
9304 fprintf_unfiltered (fp
, "rwatch");
9306 case bp_access_watchpoint
:
9307 fprintf_unfiltered (fp
, "awatch");
9310 internal_error (__FILE__
, __LINE__
,
9311 _("Invalid hardware watchpoint type."));
9314 sprintf_vma (tmp
, w
->hw_wp_mask
);
9315 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
9316 print_recreate_thread (b
, fp
);
9319 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
9321 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
9323 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
9326 is_masked_watchpoint (const struct breakpoint
*b
)
9328 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
9331 /* accessflag: hw_write: watch write,
9332 hw_read: watch read,
9333 hw_access: watch access (read or write) */
9335 watch_command_1 (char *arg
, int accessflag
, int from_tty
,
9336 int just_location
, int internal
)
9338 volatile struct gdb_exception e
;
9339 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
9340 struct expression
*exp
;
9341 struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
9342 struct value
*val
, *mark
, *result
;
9343 struct frame_info
*frame
;
9344 char *exp_start
= NULL
;
9345 char *exp_end
= NULL
;
9346 char *tok
, *end_tok
;
9348 char *cond_start
= NULL
;
9349 char *cond_end
= NULL
;
9350 enum bptype bp_type
;
9353 /* Flag to indicate whether we are going to use masks for
9354 the hardware watchpoint. */
9357 struct watchpoint
*w
;
9359 /* Make sure that we actually have parameters to parse. */
9360 if (arg
!= NULL
&& arg
[0] != '\0')
9364 /* Look for "parameter value" pairs at the end
9365 of the arguments string. */
9366 for (tok
= arg
+ strlen (arg
) - 1; tok
> arg
; tok
--)
9368 /* Skip whitespace at the end of the argument list. */
9369 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
9372 /* Find the beginning of the last token.
9373 This is the value of the parameter. */
9374 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
9376 value_start
= tok
+ 1;
9378 /* Skip whitespace. */
9379 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
9384 /* Find the beginning of the second to last token.
9385 This is the parameter itself. */
9386 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
9389 toklen
= end_tok
- tok
+ 1;
9391 if (toklen
== 6 && !strncmp (tok
, "thread", 6))
9393 /* At this point we've found a "thread" token, which means
9394 the user is trying to set a watchpoint that triggers
9395 only in a specific thread. */
9399 error(_("You can specify only one thread."));
9401 /* Extract the thread ID from the next token. */
9402 thread
= strtol (value_start
, &endp
, 0);
9404 /* Check if the user provided a valid numeric value for the
9406 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
9407 error (_("Invalid thread ID specification %s."), value_start
);
9409 /* Check if the thread actually exists. */
9410 if (!valid_thread_id (thread
))
9411 error (_("Unknown thread %d."), thread
);
9413 else if (toklen
== 4 && !strncmp (tok
, "mask", 4))
9415 /* We've found a "mask" token, which means the user wants to
9416 create a hardware watchpoint that is going to have the mask
9418 struct value
*mask_value
, *mark
;
9421 error(_("You can specify only one mask."));
9423 use_mask
= just_location
= 1;
9425 mark
= value_mark ();
9426 mask_value
= parse_to_comma_and_eval (&value_start
);
9427 mask
= value_as_address (mask_value
);
9428 value_free_to_mark (mark
);
9431 /* We didn't recognize what we found. We should stop here. */
9434 /* Truncate the string and get rid of the "parameter value" pair before
9435 the arguments string is parsed by the parse_exp_1 function. */
9440 /* Parse the rest of the arguments. */
9441 innermost_block
= NULL
;
9443 exp
= parse_exp_1 (&arg
, 0, 0);
9445 /* Remove trailing whitespace from the expression before saving it.
9446 This makes the eventual display of the expression string a bit
9448 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
9451 /* Checking if the expression is not constant. */
9452 if (watchpoint_exp_is_const (exp
))
9456 len
= exp_end
- exp_start
;
9457 while (len
> 0 && isspace (exp_start
[len
- 1]))
9459 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
9462 exp_valid_block
= innermost_block
;
9463 mark
= value_mark ();
9464 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
);
9470 exp_valid_block
= NULL
;
9471 val
= value_addr (result
);
9472 release_value (val
);
9473 value_free_to_mark (mark
);
9477 ret
= target_masked_watch_num_registers (value_as_address (val
),
9480 error (_("This target does not support masked watchpoints."));
9482 error (_("Invalid mask or memory region."));
9485 else if (val
!= NULL
)
9486 release_value (val
);
9488 tok
= skip_spaces (arg
);
9489 end_tok
= skip_to_space (tok
);
9491 toklen
= end_tok
- tok
;
9492 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9494 struct expression
*cond
;
9496 innermost_block
= NULL
;
9497 tok
= cond_start
= end_tok
+ 1;
9498 cond
= parse_exp_1 (&tok
, 0, 0);
9500 /* The watchpoint expression may not be local, but the condition
9501 may still be. E.g.: `watch global if local > 0'. */
9502 cond_exp_valid_block
= innermost_block
;
9508 error (_("Junk at end of command."));
9510 if (accessflag
== hw_read
)
9511 bp_type
= bp_read_watchpoint
;
9512 else if (accessflag
== hw_access
)
9513 bp_type
= bp_access_watchpoint
;
9515 bp_type
= bp_hardware_watchpoint
;
9517 frame
= block_innermost_frame (exp_valid_block
);
9519 /* If the expression is "local", then set up a "watchpoint scope"
9520 breakpoint at the point where we've left the scope of the watchpoint
9521 expression. Create the scope breakpoint before the watchpoint, so
9522 that we will encounter it first in bpstat_stop_status. */
9523 if (exp_valid_block
&& frame
)
9525 if (frame_id_p (frame_unwind_caller_id (frame
)))
9528 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
9529 frame_unwind_caller_pc (frame
),
9530 bp_watchpoint_scope
,
9531 &momentary_breakpoint_ops
);
9533 scope_breakpoint
->enable_state
= bp_enabled
;
9535 /* Automatically delete the breakpoint when it hits. */
9536 scope_breakpoint
->disposition
= disp_del
;
9538 /* Only break in the proper frame (help with recursion). */
9539 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
9541 /* Set the address at which we will stop. */
9542 scope_breakpoint
->loc
->gdbarch
9543 = frame_unwind_caller_arch (frame
);
9544 scope_breakpoint
->loc
->requested_address
9545 = frame_unwind_caller_pc (frame
);
9546 scope_breakpoint
->loc
->address
9547 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
9548 scope_breakpoint
->loc
->requested_address
,
9549 scope_breakpoint
->type
);
9553 /* Now set up the breakpoint. */
9555 w
= XCNEW (struct watchpoint
);
9558 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
9559 &masked_watchpoint_breakpoint_ops
);
9561 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
9562 &watchpoint_breakpoint_ops
);
9564 b
->disposition
= disp_donttouch
;
9565 b
->pspace
= current_program_space
;
9567 w
->exp_valid_block
= exp_valid_block
;
9568 w
->cond_exp_valid_block
= cond_exp_valid_block
;
9571 struct type
*t
= value_type (val
);
9572 CORE_ADDR addr
= value_as_address (val
);
9575 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
9576 name
= type_to_string (t
);
9578 w
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
9579 core_addr_to_string (addr
));
9582 w
->exp_string
= xstrprintf ("-location %.*s",
9583 (int) (exp_end
- exp_start
), exp_start
);
9585 /* The above expression is in C. */
9586 b
->language
= language_c
;
9589 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
9593 w
->hw_wp_mask
= mask
;
9602 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9608 w
->watchpoint_frame
= get_frame_id (frame
);
9609 w
->watchpoint_thread
= inferior_ptid
;
9613 w
->watchpoint_frame
= null_frame_id
;
9614 w
->watchpoint_thread
= null_ptid
;
9617 if (scope_breakpoint
!= NULL
)
9619 /* The scope breakpoint is related to the watchpoint. We will
9620 need to act on them together. */
9621 b
->related_breakpoint
= scope_breakpoint
;
9622 scope_breakpoint
->related_breakpoint
= b
;
9626 value_free_to_mark (mark
);
9628 TRY_CATCH (e
, RETURN_MASK_ALL
)
9630 /* Finally update the new watchpoint. This creates the locations
9631 that should be inserted. */
9632 update_watchpoint (w
, 1);
9636 delete_breakpoint (b
);
9637 throw_exception (e
);
9640 install_breakpoint (internal
, b
, 1);
9643 /* Return count of debug registers needed to watch the given expression.
9644 If the watchpoint cannot be handled in hardware return zero. */
9647 can_use_hardware_watchpoint (struct value
*v
)
9649 int found_memory_cnt
= 0;
9650 struct value
*head
= v
;
9652 /* Did the user specifically forbid us to use hardware watchpoints? */
9653 if (!can_use_hw_watchpoints
)
9656 /* Make sure that the value of the expression depends only upon
9657 memory contents, and values computed from them within GDB. If we
9658 find any register references or function calls, we can't use a
9659 hardware watchpoint.
9661 The idea here is that evaluating an expression generates a series
9662 of values, one holding the value of every subexpression. (The
9663 expression a*b+c has five subexpressions: a, b, a*b, c, and
9664 a*b+c.) GDB's values hold almost enough information to establish
9665 the criteria given above --- they identify memory lvalues,
9666 register lvalues, computed values, etcetera. So we can evaluate
9667 the expression, and then scan the chain of values that leaves
9668 behind to decide whether we can detect any possible change to the
9669 expression's final value using only hardware watchpoints.
9671 However, I don't think that the values returned by inferior
9672 function calls are special in any way. So this function may not
9673 notice that an expression involving an inferior function call
9674 can't be watched with hardware watchpoints. FIXME. */
9675 for (; v
; v
= value_next (v
))
9677 if (VALUE_LVAL (v
) == lval_memory
)
9679 if (v
!= head
&& value_lazy (v
))
9680 /* A lazy memory lvalue in the chain is one that GDB never
9681 needed to fetch; we either just used its address (e.g.,
9682 `a' in `a.b') or we never needed it at all (e.g., `a'
9683 in `a,b'). This doesn't apply to HEAD; if that is
9684 lazy then it was not readable, but watch it anyway. */
9688 /* Ahh, memory we actually used! Check if we can cover
9689 it with hardware watchpoints. */
9690 struct type
*vtype
= check_typedef (value_type (v
));
9692 /* We only watch structs and arrays if user asked for it
9693 explicitly, never if they just happen to appear in a
9694 middle of some value chain. */
9696 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
9697 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
9699 CORE_ADDR vaddr
= value_address (v
);
9703 len
= (target_exact_watchpoints
9704 && is_scalar_type_recursive (vtype
))?
9705 1 : TYPE_LENGTH (value_type (v
));
9707 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
9711 found_memory_cnt
+= num_regs
;
9715 else if (VALUE_LVAL (v
) != not_lval
9716 && deprecated_value_modifiable (v
) == 0)
9717 return 0; /* These are values from the history (e.g., $1). */
9718 else if (VALUE_LVAL (v
) == lval_register
)
9719 return 0; /* Cannot watch a register with a HW watchpoint. */
9722 /* The expression itself looks suitable for using a hardware
9723 watchpoint, but give the target machine a chance to reject it. */
9724 return found_memory_cnt
;
9728 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
9730 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
9733 /* A helper function that looks for an argument at the start of a
9734 string. The argument must also either be at the end of the string,
9735 or be followed by whitespace. Returns 1 if it finds the argument,
9736 0 otherwise. If the argument is found, it updates *STR. */
9739 check_for_argument (char **str
, char *arg
, int arg_len
)
9741 if (strncmp (*str
, arg
, arg_len
) == 0
9742 && ((*str
)[arg_len
] == '\0' || isspace ((*str
)[arg_len
])))
9750 /* A helper function that looks for the "-location" argument and then
9751 calls watch_command_1. */
9754 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
9756 int just_location
= 0;
9759 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
9760 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
9762 arg
= skip_spaces (arg
);
9766 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
9770 watch_command (char *arg
, int from_tty
)
9772 watch_maybe_just_location (arg
, hw_write
, from_tty
);
9776 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9778 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
9782 rwatch_command (char *arg
, int from_tty
)
9784 watch_maybe_just_location (arg
, hw_read
, from_tty
);
9788 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9790 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
9794 awatch_command (char *arg
, int from_tty
)
9796 watch_maybe_just_location (arg
, hw_access
, from_tty
);
9800 /* Helper routines for the until_command routine in infcmd.c. Here
9801 because it uses the mechanisms of breakpoints. */
9803 struct until_break_command_continuation_args
9805 struct breakpoint
*breakpoint
;
9806 struct breakpoint
*breakpoint2
;
9810 /* This function is called by fetch_inferior_event via the
9811 cmd_continuation pointer, to complete the until command. It takes
9812 care of cleaning up the temporary breakpoints set up by the until
9815 until_break_command_continuation (void *arg
, int err
)
9817 struct until_break_command_continuation_args
*a
= arg
;
9819 delete_breakpoint (a
->breakpoint
);
9821 delete_breakpoint (a
->breakpoint2
);
9822 delete_longjmp_breakpoint (a
->thread_num
);
9826 until_break_command (char *arg
, int from_tty
, int anywhere
)
9828 struct symtabs_and_lines sals
;
9829 struct symtab_and_line sal
;
9830 struct frame_info
*frame
= get_selected_frame (NULL
);
9831 struct breakpoint
*breakpoint
;
9832 struct breakpoint
*breakpoint2
= NULL
;
9833 struct cleanup
*old_chain
;
9835 struct thread_info
*tp
;
9837 clear_proceed_status ();
9839 /* Set a breakpoint where the user wants it and at return from
9842 if (last_displayed_sal_is_valid ())
9843 sals
= decode_line_1 (&arg
, DECODE_LINE_FUNFIRSTLINE
,
9844 get_last_displayed_symtab (),
9845 get_last_displayed_line ());
9847 sals
= decode_line_1 (&arg
, DECODE_LINE_FUNFIRSTLINE
,
9848 (struct symtab
*) NULL
, 0);
9850 if (sals
.nelts
!= 1)
9851 error (_("Couldn't get information on specified line."));
9854 xfree (sals
.sals
); /* malloc'd, so freed. */
9857 error (_("Junk at end of arguments."));
9859 resolve_sal_pc (&sal
);
9862 /* If the user told us to continue until a specified location,
9863 we don't specify a frame at which we need to stop. */
9864 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9865 null_frame_id
, bp_until
);
9867 /* Otherwise, specify the selected frame, because we want to stop
9868 only at the very same frame. */
9869 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9870 get_stack_frame_id (frame
),
9873 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
9875 tp
= inferior_thread ();
9878 /* Keep within the current frame, or in frames called by the current
9881 if (frame_id_p (frame_unwind_caller_id (frame
)))
9883 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
9884 sal
.pc
= frame_unwind_caller_pc (frame
);
9885 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
9887 frame_unwind_caller_id (frame
),
9889 make_cleanup_delete_breakpoint (breakpoint2
);
9891 set_longjmp_breakpoint (tp
, frame_unwind_caller_id (frame
));
9892 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
9895 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
9897 /* If we are running asynchronously, and proceed call above has
9898 actually managed to start the target, arrange for breakpoints to
9899 be deleted when the target stops. Otherwise, we're already
9900 stopped and delete breakpoints via cleanup chain. */
9902 if (target_can_async_p () && is_running (inferior_ptid
))
9904 struct until_break_command_continuation_args
*args
;
9905 args
= xmalloc (sizeof (*args
));
9907 args
->breakpoint
= breakpoint
;
9908 args
->breakpoint2
= breakpoint2
;
9909 args
->thread_num
= thread
;
9911 discard_cleanups (old_chain
);
9912 add_continuation (inferior_thread (),
9913 until_break_command_continuation
, args
,
9917 do_cleanups (old_chain
);
9920 /* This function attempts to parse an optional "if <cond>" clause
9921 from the arg string. If one is not found, it returns NULL.
9923 Else, it returns a pointer to the condition string. (It does not
9924 attempt to evaluate the string against a particular block.) And,
9925 it updates arg to point to the first character following the parsed
9926 if clause in the arg string. */
9929 ep_parse_optional_if_clause (char **arg
)
9933 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
9936 /* Skip the "if" keyword. */
9939 /* Skip any extra leading whitespace, and record the start of the
9940 condition string. */
9941 *arg
= skip_spaces (*arg
);
9944 /* Assume that the condition occupies the remainder of the arg
9946 (*arg
) += strlen (cond_string
);
9951 /* Commands to deal with catching events, such as signals, exceptions,
9952 process start/exit, etc. */
9956 catch_fork_temporary
, catch_vfork_temporary
,
9957 catch_fork_permanent
, catch_vfork_permanent
9962 catch_fork_command_1 (char *arg
, int from_tty
,
9963 struct cmd_list_element
*command
)
9965 struct gdbarch
*gdbarch
= get_current_arch ();
9966 char *cond_string
= NULL
;
9967 catch_fork_kind fork_kind
;
9970 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
9971 tempflag
= (fork_kind
== catch_fork_temporary
9972 || fork_kind
== catch_vfork_temporary
);
9976 arg
= skip_spaces (arg
);
9978 /* The allowed syntax is:
9980 catch [v]fork if <cond>
9982 First, check if there's an if clause. */
9983 cond_string
= ep_parse_optional_if_clause (&arg
);
9985 if ((*arg
!= '\0') && !isspace (*arg
))
9986 error (_("Junk at end of arguments."));
9988 /* If this target supports it, create a fork or vfork catchpoint
9989 and enable reporting of such events. */
9992 case catch_fork_temporary
:
9993 case catch_fork_permanent
:
9994 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9995 &catch_fork_breakpoint_ops
);
9997 case catch_vfork_temporary
:
9998 case catch_vfork_permanent
:
9999 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
10000 &catch_vfork_breakpoint_ops
);
10003 error (_("unsupported or unknown fork kind; cannot catch it"));
10009 catch_exec_command_1 (char *arg
, int from_tty
,
10010 struct cmd_list_element
*command
)
10012 struct exec_catchpoint
*c
;
10013 struct gdbarch
*gdbarch
= get_current_arch ();
10015 char *cond_string
= NULL
;
10017 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
10021 arg
= skip_spaces (arg
);
10023 /* The allowed syntax is:
10025 catch exec if <cond>
10027 First, check if there's an if clause. */
10028 cond_string
= ep_parse_optional_if_clause (&arg
);
10030 if ((*arg
!= '\0') && !isspace (*arg
))
10031 error (_("Junk at end of arguments."));
10033 c
= XNEW (struct exec_catchpoint
);
10034 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
,
10035 &catch_exec_breakpoint_ops
);
10036 c
->exec_pathname
= NULL
;
10038 install_breakpoint (0, &c
->base
, 1);
10041 static enum print_stop_action
10042 print_it_exception_catchpoint (bpstat bs
)
10044 struct ui_out
*uiout
= current_uiout
;
10045 struct breakpoint
*b
= bs
->breakpoint_at
;
10046 int bp_temp
, bp_throw
;
10048 annotate_catchpoint (b
->number
);
10050 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
10051 if (b
->loc
->address
!= b
->loc
->requested_address
)
10052 breakpoint_adjustment_warning (b
->loc
->requested_address
,
10055 bp_temp
= b
->disposition
== disp_del
;
10056 ui_out_text (uiout
,
10057 bp_temp
? "Temporary catchpoint "
10059 if (!ui_out_is_mi_like_p (uiout
))
10060 ui_out_field_int (uiout
, "bkptno", b
->number
);
10061 ui_out_text (uiout
,
10062 bp_throw
? " (exception thrown), "
10063 : " (exception caught), ");
10064 if (ui_out_is_mi_like_p (uiout
))
10066 ui_out_field_string (uiout
, "reason",
10067 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
10068 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
10069 ui_out_field_int (uiout
, "bkptno", b
->number
);
10071 return PRINT_SRC_AND_LOC
;
10075 print_one_exception_catchpoint (struct breakpoint
*b
,
10076 struct bp_location
**last_loc
)
10078 struct value_print_options opts
;
10079 struct ui_out
*uiout
= current_uiout
;
10081 get_user_print_options (&opts
);
10082 if (opts
.addressprint
)
10084 annotate_field (4);
10085 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
10086 ui_out_field_string (uiout
, "addr", "<PENDING>");
10088 ui_out_field_core_addr (uiout
, "addr",
10089 b
->loc
->gdbarch
, b
->loc
->address
);
10091 annotate_field (5);
10093 *last_loc
= b
->loc
;
10094 if (strstr (b
->addr_string
, "throw") != NULL
)
10095 ui_out_field_string (uiout
, "what", "exception throw");
10097 ui_out_field_string (uiout
, "what", "exception catch");
10101 print_mention_exception_catchpoint (struct breakpoint
*b
)
10103 struct ui_out
*uiout
= current_uiout
;
10107 bp_temp
= b
->disposition
== disp_del
;
10108 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
10109 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
10110 : _("Catchpoint "));
10111 ui_out_field_int (uiout
, "bkptno", b
->number
);
10112 ui_out_text (uiout
, bp_throw
? _(" (throw)")
10116 /* Implement the "print_recreate" breakpoint_ops method for throw and
10117 catch catchpoints. */
10120 print_recreate_exception_catchpoint (struct breakpoint
*b
,
10121 struct ui_file
*fp
)
10126 bp_temp
= b
->disposition
== disp_del
;
10127 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
10128 fprintf_unfiltered (fp
, bp_temp
? "tcatch " : "catch ");
10129 fprintf_unfiltered (fp
, bp_throw
? "throw" : "catch");
10130 print_recreate_thread (b
, fp
);
10133 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
;
10136 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
10137 enum exception_event_kind ex_event
, int from_tty
)
10139 char *trigger_func_name
;
10141 if (ex_event
== EX_EVENT_CATCH
)
10142 trigger_func_name
= "__cxa_begin_catch";
10144 trigger_func_name
= "__cxa_throw";
10146 create_breakpoint (get_current_arch (),
10147 trigger_func_name
, cond_string
, -1,
10148 0 /* condition and thread are valid. */,
10149 tempflag
, bp_breakpoint
,
10151 AUTO_BOOLEAN_TRUE
/* pending */,
10152 &gnu_v3_exception_catchpoint_ops
, from_tty
,
10159 /* Deal with "catch catch" and "catch throw" commands. */
10162 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
10163 int tempflag
, int from_tty
)
10165 char *cond_string
= NULL
;
10169 arg
= skip_spaces (arg
);
10171 cond_string
= ep_parse_optional_if_clause (&arg
);
10173 if ((*arg
!= '\0') && !isspace (*arg
))
10174 error (_("Junk at end of arguments."));
10176 if (ex_event
!= EX_EVENT_THROW
10177 && ex_event
!= EX_EVENT_CATCH
)
10178 error (_("Unsupported or unknown exception event; cannot catch it"));
10180 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
10183 warning (_("Unsupported with this platform/compiler combination."));
10186 /* Implementation of "catch catch" command. */
10189 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
10191 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
10193 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
10196 /* Implementation of "catch throw" command. */
10199 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
10201 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
10203 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
10207 init_ada_exception_breakpoint (struct breakpoint
*b
,
10208 struct gdbarch
*gdbarch
,
10209 struct symtab_and_line sal
,
10211 const struct breakpoint_ops
*ops
,
10217 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
10219 loc_gdbarch
= gdbarch
;
10221 describe_other_breakpoints (loc_gdbarch
,
10222 sal
.pspace
, sal
.pc
, sal
.section
, -1);
10223 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
10224 version for exception catchpoints, because two catchpoints
10225 used for different exception names will use the same address.
10226 In this case, a "breakpoint ... also set at..." warning is
10227 unproductive. Besides, the warning phrasing is also a bit
10228 inappropriate, we should use the word catchpoint, and tell
10229 the user what type of catchpoint it is. The above is good
10230 enough for now, though. */
10233 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
10235 b
->enable_state
= bp_enabled
;
10236 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
10237 b
->addr_string
= addr_string
;
10238 b
->language
= language_ada
;
10241 /* Splits the argument using space as delimiter. Returns an xmalloc'd
10242 filter list, or NULL if no filtering is required. */
10244 catch_syscall_split_args (char *arg
)
10246 VEC(int) *result
= NULL
;
10247 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (int), &result
);
10249 while (*arg
!= '\0')
10251 int i
, syscall_number
;
10253 char cur_name
[128];
10256 /* Skip whitespace. */
10257 while (isspace (*arg
))
10260 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
10261 cur_name
[i
] = arg
[i
];
10262 cur_name
[i
] = '\0';
10265 /* Check if the user provided a syscall name or a number. */
10266 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
10267 if (*endptr
== '\0')
10268 get_syscall_by_number (syscall_number
, &s
);
10271 /* We have a name. Let's check if it's valid and convert it
10273 get_syscall_by_name (cur_name
, &s
);
10275 if (s
.number
== UNKNOWN_SYSCALL
)
10276 /* Here we have to issue an error instead of a warning,
10277 because GDB cannot do anything useful if there's no
10278 syscall number to be caught. */
10279 error (_("Unknown syscall name '%s'."), cur_name
);
10282 /* Ok, it's valid. */
10283 VEC_safe_push (int, result
, s
.number
);
10286 discard_cleanups (cleanup
);
10290 /* Implement the "catch syscall" command. */
10293 catch_syscall_command_1 (char *arg
, int from_tty
,
10294 struct cmd_list_element
*command
)
10299 struct gdbarch
*gdbarch
= get_current_arch ();
10301 /* Checking if the feature if supported. */
10302 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
10303 error (_("The feature 'catch syscall' is not supported on \
10304 this architecture yet."));
10306 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
10308 arg
= skip_spaces (arg
);
10310 /* We need to do this first "dummy" translation in order
10311 to get the syscall XML file loaded or, most important,
10312 to display a warning to the user if there's no XML file
10313 for his/her architecture. */
10314 get_syscall_by_number (0, &s
);
10316 /* The allowed syntax is:
10318 catch syscall <name | number> [<name | number> ... <name | number>]
10320 Let's check if there's a syscall name. */
10323 filter
= catch_syscall_split_args (arg
);
10327 create_syscall_event_catchpoint (tempflag
, filter
,
10328 &catch_syscall_breakpoint_ops
);
10332 catch_command (char *arg
, int from_tty
)
10334 error (_("Catch requires an event name."));
10339 tcatch_command (char *arg
, int from_tty
)
10341 error (_("Catch requires an event name."));
10344 /* A qsort comparison function that sorts breakpoints in order. */
10347 compare_breakpoints (const void *a
, const void *b
)
10349 const breakpoint_p
*ba
= a
;
10350 uintptr_t ua
= (uintptr_t) *ba
;
10351 const breakpoint_p
*bb
= b
;
10352 uintptr_t ub
= (uintptr_t) *bb
;
10354 if ((*ba
)->number
< (*bb
)->number
)
10356 else if ((*ba
)->number
> (*bb
)->number
)
10359 /* Now sort by address, in case we see, e..g, two breakpoints with
10363 return ub
> ub
? 1 : 0;
10366 /* Delete breakpoints by address or line. */
10369 clear_command (char *arg
, int from_tty
)
10371 struct breakpoint
*b
, *prev
;
10372 VEC(breakpoint_p
) *found
= 0;
10375 struct symtabs_and_lines sals
;
10376 struct symtab_and_line sal
;
10378 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
10382 sals
= decode_line_spec (arg
, (DECODE_LINE_FUNFIRSTLINE
10383 | DECODE_LINE_LIST_MODE
));
10388 sals
.sals
= (struct symtab_and_line
*)
10389 xmalloc (sizeof (struct symtab_and_line
));
10390 make_cleanup (xfree
, sals
.sals
);
10391 init_sal (&sal
); /* Initialize to zeroes. */
10393 /* Set sal's line, symtab, pc, and pspace to the values
10394 corresponding to the last call to print_frame_info. If the
10395 codepoint is not valid, this will set all the fields to 0. */
10396 get_last_displayed_sal (&sal
);
10397 if (sal
.symtab
== 0)
10398 error (_("No source file specified."));
10400 sals
.sals
[0] = sal
;
10406 /* We don't call resolve_sal_pc here. That's not as bad as it
10407 seems, because all existing breakpoints typically have both
10408 file/line and pc set. So, if clear is given file/line, we can
10409 match this to existing breakpoint without obtaining pc at all.
10411 We only support clearing given the address explicitly
10412 present in breakpoint table. Say, we've set breakpoint
10413 at file:line. There were several PC values for that file:line,
10414 due to optimization, all in one block.
10416 We've picked one PC value. If "clear" is issued with another
10417 PC corresponding to the same file:line, the breakpoint won't
10418 be cleared. We probably can still clear the breakpoint, but
10419 since the other PC value is never presented to user, user
10420 can only find it by guessing, and it does not seem important
10421 to support that. */
10423 /* For each line spec given, delete bps which correspond to it. Do
10424 it in two passes, solely to preserve the current behavior that
10425 from_tty is forced true if we delete more than one
10429 make_cleanup (VEC_cleanup (breakpoint_p
), &found
);
10430 for (i
= 0; i
< sals
.nelts
; i
++)
10432 int is_abs
, sal_name_len
;
10434 /* If exact pc given, clear bpts at that pc.
10435 If line given (pc == 0), clear all bpts on specified line.
10436 If defaulting, clear all bpts on default line
10439 defaulting sal.pc != 0 tests to do
10444 1 0 <can't happen> */
10446 sal
= sals
.sals
[i
];
10447 is_abs
= sal
.symtab
== NULL
? 1 : IS_ABSOLUTE_PATH (sal
.symtab
->filename
);
10448 sal_name_len
= is_abs
? 0 : strlen (sal
.symtab
->filename
);
10450 /* Find all matching breakpoints and add them to 'found'. */
10451 ALL_BREAKPOINTS (b
)
10454 /* Are we going to delete b? */
10455 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
10457 struct bp_location
*loc
= b
->loc
;
10458 for (; loc
; loc
= loc
->next
)
10460 /* If the user specified file:line, don't allow a PC
10461 match. This matches historical gdb behavior. */
10462 int pc_match
= (!sal
.explicit_line
10464 && (loc
->pspace
== sal
.pspace
)
10465 && (loc
->address
== sal
.pc
)
10466 && (!section_is_overlay (loc
->section
)
10467 || loc
->section
== sal
.section
));
10468 int line_match
= 0;
10470 if ((default_match
|| sal
.explicit_line
)
10471 && loc
->source_file
!= NULL
10472 && sal
.symtab
!= NULL
10473 && sal
.pspace
== loc
->pspace
10474 && loc
->line_number
== sal
.line
)
10476 if (filename_cmp (loc
->source_file
,
10477 sal
.symtab
->filename
) == 0)
10479 else if (!IS_ABSOLUTE_PATH (sal
.symtab
->filename
)
10480 && compare_filenames_for_search (loc
->source_file
,
10481 sal
.symtab
->filename
,
10486 if (pc_match
|| line_match
)
10495 VEC_safe_push(breakpoint_p
, found
, b
);
10499 /* Now go thru the 'found' chain and delete them. */
10500 if (VEC_empty(breakpoint_p
, found
))
10503 error (_("No breakpoint at %s."), arg
);
10505 error (_("No breakpoint at this line."));
10508 /* Remove duplicates from the vec. */
10509 qsort (VEC_address (breakpoint_p
, found
),
10510 VEC_length (breakpoint_p
, found
),
10511 sizeof (breakpoint_p
),
10512 compare_breakpoints
);
10513 prev
= VEC_index (breakpoint_p
, found
, 0);
10514 for (ix
= 1; VEC_iterate (breakpoint_p
, found
, ix
, b
); ++ix
)
10518 VEC_ordered_remove (breakpoint_p
, found
, ix
);
10523 if (VEC_length(breakpoint_p
, found
) > 1)
10524 from_tty
= 1; /* Always report if deleted more than one. */
10527 if (VEC_length(breakpoint_p
, found
) == 1)
10528 printf_unfiltered (_("Deleted breakpoint "));
10530 printf_unfiltered (_("Deleted breakpoints "));
10532 breakpoints_changed ();
10534 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
10537 printf_unfiltered ("%d ", b
->number
);
10538 delete_breakpoint (b
);
10541 putchar_unfiltered ('\n');
10543 do_cleanups (cleanups
);
10546 /* Delete breakpoint in BS if they are `delete' breakpoints and
10547 all breakpoints that are marked for deletion, whether hit or not.
10548 This is called after any breakpoint is hit, or after errors. */
10551 breakpoint_auto_delete (bpstat bs
)
10553 struct breakpoint
*b
, *b_tmp
;
10555 for (; bs
; bs
= bs
->next
)
10556 if (bs
->breakpoint_at
10557 && bs
->breakpoint_at
->disposition
== disp_del
10559 delete_breakpoint (bs
->breakpoint_at
);
10561 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10563 if (b
->disposition
== disp_del_at_next_stop
)
10564 delete_breakpoint (b
);
10568 /* A comparison function for bp_location AP and BP being interfaced to
10569 qsort. Sort elements primarily by their ADDRESS (no matter what
10570 does breakpoint_address_is_meaningful say for its OWNER),
10571 secondarily by ordering first bp_permanent OWNERed elements and
10572 terciarily just ensuring the array is sorted stable way despite
10573 qsort being an unstable algorithm. */
10576 bp_location_compare (const void *ap
, const void *bp
)
10578 struct bp_location
*a
= *(void **) ap
;
10579 struct bp_location
*b
= *(void **) bp
;
10580 /* A and B come from existing breakpoints having non-NULL OWNER. */
10581 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
10582 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
10584 if (a
->address
!= b
->address
)
10585 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
10587 /* Sort permanent breakpoints first. */
10588 if (a_perm
!= b_perm
)
10589 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
10591 /* Make the user-visible order stable across GDB runs. Locations of
10592 the same breakpoint can be sorted in arbitrary order. */
10594 if (a
->owner
->number
!= b
->owner
->number
)
10595 return (a
->owner
->number
> b
->owner
->number
)
10596 - (a
->owner
->number
< b
->owner
->number
);
10598 return (a
> b
) - (a
< b
);
10601 /* Set bp_location_placed_address_before_address_max and
10602 bp_location_shadow_len_after_address_max according to the current
10603 content of the bp_location array. */
10606 bp_location_target_extensions_update (void)
10608 struct bp_location
*bl
, **blp_tmp
;
10610 bp_location_placed_address_before_address_max
= 0;
10611 bp_location_shadow_len_after_address_max
= 0;
10613 ALL_BP_LOCATIONS (bl
, blp_tmp
)
10615 CORE_ADDR start
, end
, addr
;
10617 if (!bp_location_has_shadow (bl
))
10620 start
= bl
->target_info
.placed_address
;
10621 end
= start
+ bl
->target_info
.shadow_len
;
10623 gdb_assert (bl
->address
>= start
);
10624 addr
= bl
->address
- start
;
10625 if (addr
> bp_location_placed_address_before_address_max
)
10626 bp_location_placed_address_before_address_max
= addr
;
10628 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
10630 gdb_assert (bl
->address
< end
);
10631 addr
= end
- bl
->address
;
10632 if (addr
> bp_location_shadow_len_after_address_max
)
10633 bp_location_shadow_len_after_address_max
= addr
;
10637 /* Download tracepoint locations if they haven't been. */
10640 download_tracepoint_locations (void)
10642 struct bp_location
*bl
, **blp_tmp
;
10643 struct cleanup
*old_chain
;
10645 if (!target_can_download_tracepoint ())
10648 old_chain
= save_current_space_and_thread ();
10650 ALL_BP_LOCATIONS (bl
, blp_tmp
)
10652 struct tracepoint
*t
;
10654 if (!is_tracepoint (bl
->owner
))
10657 if ((bl
->owner
->type
== bp_fast_tracepoint
10658 ? !may_insert_fast_tracepoints
10659 : !may_insert_tracepoints
))
10662 /* In tracepoint, locations are _never_ duplicated, so
10663 should_be_inserted is equivalent to
10664 unduplicated_should_be_inserted. */
10665 if (!should_be_inserted (bl
) || bl
->inserted
)
10668 switch_to_program_space_and_thread (bl
->pspace
);
10670 target_download_tracepoint (bl
);
10673 t
= (struct tracepoint
*) bl
->owner
;
10674 t
->number_on_target
= bl
->owner
->number
;
10677 do_cleanups (old_chain
);
10680 /* Swap the insertion/duplication state between two locations. */
10683 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
10685 const int left_inserted
= left
->inserted
;
10686 const int left_duplicate
= left
->duplicate
;
10687 const struct bp_target_info left_target_info
= left
->target_info
;
10689 /* Locations of tracepoints can never be duplicated. */
10690 if (is_tracepoint (left
->owner
))
10691 gdb_assert (!left
->duplicate
);
10692 if (is_tracepoint (right
->owner
))
10693 gdb_assert (!right
->duplicate
);
10695 left
->inserted
= right
->inserted
;
10696 left
->duplicate
= right
->duplicate
;
10697 left
->target_info
= right
->target_info
;
10698 right
->inserted
= left_inserted
;
10699 right
->duplicate
= left_duplicate
;
10700 right
->target_info
= left_target_info
;
10703 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
10704 into the inferior, only remove already-inserted locations that no
10705 longer should be inserted. Functions that delete a breakpoint or
10706 breakpoints should pass false, so that deleting a breakpoint
10707 doesn't have the side effect of inserting the locations of other
10708 breakpoints that are marked not-inserted, but should_be_inserted
10709 returns true on them.
10711 This behaviour is useful is situations close to tear-down -- e.g.,
10712 after an exec, while the target still has execution, but breakpoint
10713 shadows of the previous executable image should *NOT* be restored
10714 to the new image; or before detaching, where the target still has
10715 execution and wants to delete breakpoints from GDB's lists, and all
10716 breakpoints had already been removed from the inferior. */
10719 update_global_location_list (int should_insert
)
10721 struct breakpoint
*b
;
10722 struct bp_location
**locp
, *loc
;
10723 struct cleanup
*cleanups
;
10725 /* Used in the duplicates detection below. When iterating over all
10726 bp_locations, points to the first bp_location of a given address.
10727 Breakpoints and watchpoints of different types are never
10728 duplicates of each other. Keep one pointer for each type of
10729 breakpoint/watchpoint, so we only need to loop over all locations
10731 struct bp_location
*bp_loc_first
; /* breakpoint */
10732 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
10733 struct bp_location
*awp_loc_first
; /* access watchpoint */
10734 struct bp_location
*rwp_loc_first
; /* read watchpoint */
10736 /* Saved former bp_location array which we compare against the newly
10737 built bp_location from the current state of ALL_BREAKPOINTS. */
10738 struct bp_location
**old_location
, **old_locp
;
10739 unsigned old_location_count
;
10741 old_location
= bp_location
;
10742 old_location_count
= bp_location_count
;
10743 bp_location
= NULL
;
10744 bp_location_count
= 0;
10745 cleanups
= make_cleanup (xfree
, old_location
);
10747 ALL_BREAKPOINTS (b
)
10748 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10749 bp_location_count
++;
10751 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
10752 locp
= bp_location
;
10753 ALL_BREAKPOINTS (b
)
10754 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10756 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
10757 bp_location_compare
);
10759 bp_location_target_extensions_update ();
10761 /* Identify bp_location instances that are no longer present in the
10762 new list, and therefore should be freed. Note that it's not
10763 necessary that those locations should be removed from inferior --
10764 if there's another location at the same address (previously
10765 marked as duplicate), we don't need to remove/insert the
10768 LOCP is kept in sync with OLD_LOCP, each pointing to the current
10769 and former bp_location array state respectively. */
10771 locp
= bp_location
;
10772 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
10775 struct bp_location
*old_loc
= *old_locp
;
10776 struct bp_location
**loc2p
;
10778 /* Tells if 'old_loc' is found among the new locations. If
10779 not, we have to free it. */
10780 int found_object
= 0;
10781 /* Tells if the location should remain inserted in the target. */
10782 int keep_in_target
= 0;
10785 /* Skip LOCP entries which will definitely never be needed.
10786 Stop either at or being the one matching OLD_LOC. */
10787 while (locp
< bp_location
+ bp_location_count
10788 && (*locp
)->address
< old_loc
->address
)
10792 (loc2p
< bp_location
+ bp_location_count
10793 && (*loc2p
)->address
== old_loc
->address
);
10796 if (*loc2p
== old_loc
)
10803 /* If this location is no longer present, and inserted, look if
10804 there's maybe a new location at the same address. If so,
10805 mark that one inserted, and don't remove this one. This is
10806 needed so that we don't have a time window where a breakpoint
10807 at certain location is not inserted. */
10809 if (old_loc
->inserted
)
10811 /* If the location is inserted now, we might have to remove
10814 if (found_object
&& should_be_inserted (old_loc
))
10816 /* The location is still present in the location list,
10817 and still should be inserted. Don't do anything. */
10818 keep_in_target
= 1;
10822 /* The location is either no longer present, or got
10823 disabled. See if there's another location at the
10824 same address, in which case we don't need to remove
10825 this one from the target. */
10827 /* OLD_LOC comes from existing struct breakpoint. */
10828 if (breakpoint_address_is_meaningful (old_loc
->owner
))
10831 (loc2p
< bp_location
+ bp_location_count
10832 && (*loc2p
)->address
== old_loc
->address
);
10835 struct bp_location
*loc2
= *loc2p
;
10837 if (breakpoint_locations_match (loc2
, old_loc
))
10839 /* Read watchpoint locations are switched to
10840 access watchpoints, if the former are not
10841 supported, but the latter are. */
10842 if (is_hardware_watchpoint (old_loc
->owner
))
10844 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
10845 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
10848 /* loc2 is a duplicated location. We need to check
10849 if it should be inserted in case it will be
10851 if (loc2
!= old_loc
10852 && unduplicated_should_be_inserted (loc2
))
10854 swap_insertion (old_loc
, loc2
);
10855 keep_in_target
= 1;
10863 if (!keep_in_target
)
10865 if (remove_breakpoint (old_loc
, mark_uninserted
))
10867 /* This is just about all we can do. We could keep
10868 this location on the global list, and try to
10869 remove it next time, but there's no particular
10870 reason why we will succeed next time.
10872 Note that at this point, old_loc->owner is still
10873 valid, as delete_breakpoint frees the breakpoint
10874 only after calling us. */
10875 printf_filtered (_("warning: Error removing "
10876 "breakpoint %d\n"),
10877 old_loc
->owner
->number
);
10885 if (removed
&& non_stop
10886 && breakpoint_address_is_meaningful (old_loc
->owner
)
10887 && !is_hardware_watchpoint (old_loc
->owner
))
10889 /* This location was removed from the target. In
10890 non-stop mode, a race condition is possible where
10891 we've removed a breakpoint, but stop events for that
10892 breakpoint are already queued and will arrive later.
10893 We apply an heuristic to be able to distinguish such
10894 SIGTRAPs from other random SIGTRAPs: we keep this
10895 breakpoint location for a bit, and will retire it
10896 after we see some number of events. The theory here
10897 is that reporting of events should, "on the average",
10898 be fair, so after a while we'll see events from all
10899 threads that have anything of interest, and no longer
10900 need to keep this breakpoint location around. We
10901 don't hold locations forever so to reduce chances of
10902 mistaking a non-breakpoint SIGTRAP for a breakpoint
10905 The heuristic failing can be disastrous on
10906 decr_pc_after_break targets.
10908 On decr_pc_after_break targets, like e.g., x86-linux,
10909 if we fail to recognize a late breakpoint SIGTRAP,
10910 because events_till_retirement has reached 0 too
10911 soon, we'll fail to do the PC adjustment, and report
10912 a random SIGTRAP to the user. When the user resumes
10913 the inferior, it will most likely immediately crash
10914 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
10915 corrupted, because of being resumed e.g., in the
10916 middle of a multi-byte instruction, or skipped a
10917 one-byte instruction. This was actually seen happen
10918 on native x86-linux, and should be less rare on
10919 targets that do not support new thread events, like
10920 remote, due to the heuristic depending on
10923 Mistaking a random SIGTRAP for a breakpoint trap
10924 causes similar symptoms (PC adjustment applied when
10925 it shouldn't), but then again, playing with SIGTRAPs
10926 behind the debugger's back is asking for trouble.
10928 Since hardware watchpoint traps are always
10929 distinguishable from other traps, so we don't need to
10930 apply keep hardware watchpoint moribund locations
10931 around. We simply always ignore hardware watchpoint
10932 traps we can no longer explain. */
10934 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
10935 old_loc
->owner
= NULL
;
10937 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
10941 old_loc
->owner
= NULL
;
10942 decref_bp_location (&old_loc
);
10947 /* Rescan breakpoints at the same address and section, marking the
10948 first one as "first" and any others as "duplicates". This is so
10949 that the bpt instruction is only inserted once. If we have a
10950 permanent breakpoint at the same place as BPT, make that one the
10951 official one, and the rest as duplicates. Permanent breakpoints
10952 are sorted first for the same address.
10954 Do the same for hardware watchpoints, but also considering the
10955 watchpoint's type (regular/access/read) and length. */
10957 bp_loc_first
= NULL
;
10958 wp_loc_first
= NULL
;
10959 awp_loc_first
= NULL
;
10960 rwp_loc_first
= NULL
;
10961 ALL_BP_LOCATIONS (loc
, locp
)
10963 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
10965 struct bp_location
**loc_first_p
;
10968 if (!should_be_inserted (loc
)
10969 || !breakpoint_address_is_meaningful (b
)
10970 /* Don't detect duplicate for tracepoint locations because they are
10971 never duplicated. See the comments in field `duplicate' of
10972 `struct bp_location'. */
10973 || is_tracepoint (b
))
10976 /* Permanent breakpoint should always be inserted. */
10977 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
10978 internal_error (__FILE__
, __LINE__
,
10979 _("allegedly permanent breakpoint is not "
10980 "actually inserted"));
10982 if (b
->type
== bp_hardware_watchpoint
)
10983 loc_first_p
= &wp_loc_first
;
10984 else if (b
->type
== bp_read_watchpoint
)
10985 loc_first_p
= &rwp_loc_first
;
10986 else if (b
->type
== bp_access_watchpoint
)
10987 loc_first_p
= &awp_loc_first
;
10989 loc_first_p
= &bp_loc_first
;
10991 if (*loc_first_p
== NULL
10992 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
10993 || !breakpoint_locations_match (loc
, *loc_first_p
))
10995 *loc_first_p
= loc
;
10996 loc
->duplicate
= 0;
11001 /* This and the above ensure the invariant that the first location
11002 is not duplicated, and is the inserted one.
11003 All following are marked as duplicated, and are not inserted. */
11005 swap_insertion (loc
, *loc_first_p
);
11006 loc
->duplicate
= 1;
11008 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
11009 && b
->enable_state
!= bp_permanent
)
11010 internal_error (__FILE__
, __LINE__
,
11011 _("another breakpoint was inserted on top of "
11012 "a permanent breakpoint"));
11015 if (breakpoints_always_inserted_mode () && should_insert
11016 && (have_live_inferiors ()
11017 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
11018 insert_breakpoint_locations ();
11021 download_tracepoint_locations ();
11023 do_cleanups (cleanups
);
11027 breakpoint_retire_moribund (void)
11029 struct bp_location
*loc
;
11032 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
11033 if (--(loc
->events_till_retirement
) == 0)
11035 decref_bp_location (&loc
);
11036 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
11042 update_global_location_list_nothrow (int inserting
)
11044 volatile struct gdb_exception e
;
11046 TRY_CATCH (e
, RETURN_MASK_ERROR
)
11047 update_global_location_list (inserting
);
11050 /* Clear BKP from a BPS. */
11053 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
11057 for (bs
= bps
; bs
; bs
= bs
->next
)
11058 if (bs
->breakpoint_at
== bpt
)
11060 bs
->breakpoint_at
= NULL
;
11061 bs
->old_val
= NULL
;
11062 /* bs->commands will be freed later. */
11066 /* Callback for iterate_over_threads. */
11068 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
11070 struct breakpoint
*bpt
= data
;
11072 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
11076 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
11080 say_where (struct breakpoint
*b
)
11082 struct ui_out
*uiout
= current_uiout
;
11083 struct value_print_options opts
;
11085 get_user_print_options (&opts
);
11087 /* i18n: cagney/2005-02-11: Below needs to be merged into a
11089 if (b
->loc
== NULL
)
11091 printf_filtered (_(" (%s) pending."), b
->addr_string
);
11095 if (opts
.addressprint
|| b
->loc
->source_file
== NULL
)
11097 printf_filtered (" at ");
11098 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
11101 if (b
->loc
->source_file
)
11103 /* If there is a single location, we can print the location
11105 if (b
->loc
->next
== NULL
)
11106 printf_filtered (": file %s, line %d.",
11107 b
->loc
->source_file
, b
->loc
->line_number
);
11109 /* This is not ideal, but each location may have a
11110 different file name, and this at least reflects the
11111 real situation somewhat. */
11112 printf_filtered (": %s.", b
->addr_string
);
11117 struct bp_location
*loc
= b
->loc
;
11119 for (; loc
; loc
= loc
->next
)
11121 printf_filtered (" (%d locations)", n
);
11126 /* Default bp_location_ops methods. */
11129 bp_location_dtor (struct bp_location
*self
)
11131 xfree (self
->cond
);
11132 xfree (self
->function_name
);
11133 xfree (self
->source_file
);
11136 static const struct bp_location_ops bp_location_ops
=
11141 /* Default breakpoint_ops methods all breakpoint_ops ultimately
11145 base_breakpoint_dtor (struct breakpoint
*self
)
11147 decref_counted_command_line (&self
->commands
);
11148 xfree (self
->cond_string
);
11149 xfree (self
->addr_string
);
11150 xfree (self
->filter
);
11151 xfree (self
->addr_string_range_end
);
11154 static struct bp_location
*
11155 base_breakpoint_allocate_location (struct breakpoint
*self
)
11157 struct bp_location
*loc
;
11159 loc
= XNEW (struct bp_location
);
11160 init_bp_location (loc
, &bp_location_ops
, self
);
11165 base_breakpoint_re_set (struct breakpoint
*b
)
11167 /* Nothing to re-set. */
11170 #define internal_error_pure_virtual_called() \
11171 gdb_assert_not_reached ("pure virtual function called")
11174 base_breakpoint_insert_location (struct bp_location
*bl
)
11176 internal_error_pure_virtual_called ();
11180 base_breakpoint_remove_location (struct bp_location
*bl
)
11182 internal_error_pure_virtual_called ();
11186 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
11187 struct address_space
*aspace
,
11189 const struct target_waitstatus
*ws
)
11191 internal_error_pure_virtual_called ();
11195 base_breakpoint_check_status (bpstat bs
)
11200 /* A "works_in_software_mode" breakpoint_ops method that just internal
11204 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
11206 internal_error_pure_virtual_called ();
11209 /* A "resources_needed" breakpoint_ops method that just internal
11213 base_breakpoint_resources_needed (const struct bp_location
*bl
)
11215 internal_error_pure_virtual_called ();
11218 static enum print_stop_action
11219 base_breakpoint_print_it (bpstat bs
)
11221 internal_error_pure_virtual_called ();
11225 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
11226 struct ui_out
*uiout
)
11232 base_breakpoint_print_mention (struct breakpoint
*b
)
11234 internal_error_pure_virtual_called ();
11238 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
11240 internal_error_pure_virtual_called ();
11244 base_breakpoint_create_sals_from_address (char **arg
,
11245 struct linespec_result
*canonical
,
11246 enum bptype type_wanted
,
11250 internal_error_pure_virtual_called ();
11254 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
11255 struct linespec_result
*c
,
11256 struct linespec_sals
*lsal
,
11258 enum bptype type_wanted
,
11259 enum bpdisp disposition
,
11261 int task
, int ignore_count
,
11262 const struct breakpoint_ops
*o
,
11263 int from_tty
, int enabled
,
11266 internal_error_pure_virtual_called ();
11270 base_breakpoint_decode_linespec (struct breakpoint
*b
, char **s
,
11271 struct symtabs_and_lines
*sals
)
11273 internal_error_pure_virtual_called ();
11276 static struct breakpoint_ops base_breakpoint_ops
=
11278 base_breakpoint_dtor
,
11279 base_breakpoint_allocate_location
,
11280 base_breakpoint_re_set
,
11281 base_breakpoint_insert_location
,
11282 base_breakpoint_remove_location
,
11283 base_breakpoint_breakpoint_hit
,
11284 base_breakpoint_check_status
,
11285 base_breakpoint_resources_needed
,
11286 base_breakpoint_works_in_software_mode
,
11287 base_breakpoint_print_it
,
11289 base_breakpoint_print_one_detail
,
11290 base_breakpoint_print_mention
,
11291 base_breakpoint_print_recreate
,
11292 base_breakpoint_create_sals_from_address
,
11293 base_breakpoint_create_breakpoints_sal
,
11294 base_breakpoint_decode_linespec
,
11297 /* Default breakpoint_ops methods. */
11300 bkpt_re_set (struct breakpoint
*b
)
11302 /* FIXME: is this still reachable? */
11303 if (b
->addr_string
== NULL
)
11305 /* Anything without a string can't be re-set. */
11306 delete_breakpoint (b
);
11310 breakpoint_re_set_default (b
);
11314 bkpt_insert_location (struct bp_location
*bl
)
11316 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
11317 return target_insert_hw_breakpoint (bl
->gdbarch
,
11320 return target_insert_breakpoint (bl
->gdbarch
,
11325 bkpt_remove_location (struct bp_location
*bl
)
11327 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
11328 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
11330 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
);
11334 bkpt_breakpoint_hit (const struct bp_location
*bl
,
11335 struct address_space
*aspace
, CORE_ADDR bp_addr
,
11336 const struct target_waitstatus
*ws
)
11338 struct breakpoint
*b
= bl
->owner
;
11340 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
11341 || ws
->value
.sig
!= TARGET_SIGNAL_TRAP
)
11344 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
11348 if (overlay_debugging
/* unmapped overlay section */
11349 && section_is_overlay (bl
->section
)
11350 && !section_is_mapped (bl
->section
))
11357 bkpt_resources_needed (const struct bp_location
*bl
)
11359 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
11364 static enum print_stop_action
11365 bkpt_print_it (bpstat bs
)
11367 struct breakpoint
*b
;
11368 const struct bp_location
*bl
;
11370 struct ui_out
*uiout
= current_uiout
;
11372 gdb_assert (bs
->bp_location_at
!= NULL
);
11374 bl
= bs
->bp_location_at
;
11375 b
= bs
->breakpoint_at
;
11377 bp_temp
= b
->disposition
== disp_del
;
11378 if (bl
->address
!= bl
->requested_address
)
11379 breakpoint_adjustment_warning (bl
->requested_address
,
11382 annotate_breakpoint (b
->number
);
11384 ui_out_text (uiout
, "\nTemporary breakpoint ");
11386 ui_out_text (uiout
, "\nBreakpoint ");
11387 if (ui_out_is_mi_like_p (uiout
))
11389 ui_out_field_string (uiout
, "reason",
11390 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
11391 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
11393 ui_out_field_int (uiout
, "bkptno", b
->number
);
11394 ui_out_text (uiout
, ", ");
11396 return PRINT_SRC_AND_LOC
;
11400 bkpt_print_mention (struct breakpoint
*b
)
11402 if (ui_out_is_mi_like_p (current_uiout
))
11407 case bp_breakpoint
:
11408 case bp_gnu_ifunc_resolver
:
11409 if (b
->disposition
== disp_del
)
11410 printf_filtered (_("Temporary breakpoint"));
11412 printf_filtered (_("Breakpoint"));
11413 printf_filtered (_(" %d"), b
->number
);
11414 if (b
->type
== bp_gnu_ifunc_resolver
)
11415 printf_filtered (_(" at gnu-indirect-function resolver"));
11417 case bp_hardware_breakpoint
:
11418 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
11426 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
11428 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
11429 fprintf_unfiltered (fp
, "tbreak");
11430 else if (tp
->type
== bp_breakpoint
)
11431 fprintf_unfiltered (fp
, "break");
11432 else if (tp
->type
== bp_hardware_breakpoint
11433 && tp
->disposition
== disp_del
)
11434 fprintf_unfiltered (fp
, "thbreak");
11435 else if (tp
->type
== bp_hardware_breakpoint
)
11436 fprintf_unfiltered (fp
, "hbreak");
11438 internal_error (__FILE__
, __LINE__
,
11439 _("unhandled breakpoint type %d"), (int) tp
->type
);
11441 fprintf_unfiltered (fp
, " %s", tp
->addr_string
);
11442 print_recreate_thread (tp
, fp
);
11446 bkpt_create_sals_from_address (char **arg
,
11447 struct linespec_result
*canonical
,
11448 enum bptype type_wanted
,
11449 char *addr_start
, char **copy_arg
)
11451 create_sals_from_address_default (arg
, canonical
, type_wanted
,
11452 addr_start
, copy_arg
);
11456 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
11457 struct linespec_result
*canonical
,
11458 struct linespec_sals
*lsal
,
11460 enum bptype type_wanted
,
11461 enum bpdisp disposition
,
11463 int task
, int ignore_count
,
11464 const struct breakpoint_ops
*ops
,
11465 int from_tty
, int enabled
,
11468 create_breakpoints_sal_default (gdbarch
, canonical
, lsal
,
11469 cond_string
, type_wanted
,
11470 disposition
, thread
, task
,
11471 ignore_count
, ops
, from_tty
,
11472 enabled
, internal
);
11476 bkpt_decode_linespec (struct breakpoint
*b
, char **s
,
11477 struct symtabs_and_lines
*sals
)
11479 decode_linespec_default (b
, s
, sals
);
11482 /* Virtual table for internal breakpoints. */
11485 internal_bkpt_re_set (struct breakpoint
*b
)
11489 /* Delete overlay event and longjmp master breakpoints; they
11490 will be reset later by breakpoint_re_set. */
11491 case bp_overlay_event
:
11492 case bp_longjmp_master
:
11493 case bp_std_terminate_master
:
11494 case bp_exception_master
:
11495 delete_breakpoint (b
);
11498 /* This breakpoint is special, it's set up when the inferior
11499 starts and we really don't want to touch it. */
11500 case bp_shlib_event
:
11502 /* Like bp_shlib_event, this breakpoint type is special. Once
11503 it is set up, we do not want to touch it. */
11504 case bp_thread_event
:
11510 internal_bkpt_check_status (bpstat bs
)
11512 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
11514 /* If requested, stop when the dynamic linker notifies GDB of
11515 events. This allows the user to get control and place
11516 breakpoints in initializer routines for dynamically loaded
11517 objects (among other things). */
11518 bs
->stop
= stop_on_solib_events
;
11519 bs
->print
= stop_on_solib_events
;
11525 static enum print_stop_action
11526 internal_bkpt_print_it (bpstat bs
)
11528 struct ui_out
*uiout
= current_uiout
;
11529 struct breakpoint
*b
;
11531 b
= bs
->breakpoint_at
;
11535 case bp_shlib_event
:
11536 /* Did we stop because the user set the stop_on_solib_events
11537 variable? (If so, we report this as a generic, "Stopped due
11538 to shlib event" message.) */
11539 print_solib_event (0);
11542 case bp_thread_event
:
11543 /* Not sure how we will get here.
11544 GDB should not stop for these breakpoints. */
11545 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
11548 case bp_overlay_event
:
11549 /* By analogy with the thread event, GDB should not stop for these. */
11550 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
11553 case bp_longjmp_master
:
11554 /* These should never be enabled. */
11555 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
11558 case bp_std_terminate_master
:
11559 /* These should never be enabled. */
11560 printf_filtered (_("std::terminate Master Breakpoint: "
11561 "gdb should not stop!\n"));
11564 case bp_exception_master
:
11565 /* These should never be enabled. */
11566 printf_filtered (_("Exception Master Breakpoint: "
11567 "gdb should not stop!\n"));
11571 return PRINT_NOTHING
;
11575 internal_bkpt_print_mention (struct breakpoint
*b
)
11577 /* Nothing to mention. These breakpoints are internal. */
11580 /* Virtual table for momentary breakpoints */
11583 momentary_bkpt_re_set (struct breakpoint
*b
)
11585 /* Keep temporary breakpoints, which can be encountered when we step
11586 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
11587 Otherwise these should have been blown away via the cleanup chain
11588 or by breakpoint_init_inferior when we rerun the executable. */
11592 momentary_bkpt_check_status (bpstat bs
)
11594 /* Nothing. The point of these breakpoints is causing a stop. */
11597 static enum print_stop_action
11598 momentary_bkpt_print_it (bpstat bs
)
11600 struct ui_out
*uiout
= current_uiout
;
11602 if (ui_out_is_mi_like_p (uiout
))
11604 struct breakpoint
*b
= bs
->breakpoint_at
;
11609 ui_out_field_string
11611 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
11615 ui_out_field_string
11617 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
11622 return PRINT_UNKNOWN
;
11626 momentary_bkpt_print_mention (struct breakpoint
*b
)
11628 /* Nothing to mention. These breakpoints are internal. */
11631 /* The breakpoint_ops structure to be used in tracepoints. */
11634 tracepoint_re_set (struct breakpoint
*b
)
11636 breakpoint_re_set_default (b
);
11640 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
11641 struct address_space
*aspace
, CORE_ADDR bp_addr
,
11642 const struct target_waitstatus
*ws
)
11644 /* By definition, the inferior does not report stops at
11650 tracepoint_print_one_detail (const struct breakpoint
*self
,
11651 struct ui_out
*uiout
)
11653 struct tracepoint
*tp
= (struct tracepoint
*) self
;
11654 if (tp
->static_trace_marker_id
)
11656 gdb_assert (self
->type
== bp_static_tracepoint
);
11658 ui_out_text (uiout
, "\tmarker id is ");
11659 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
11660 tp
->static_trace_marker_id
);
11661 ui_out_text (uiout
, "\n");
11666 tracepoint_print_mention (struct breakpoint
*b
)
11668 if (ui_out_is_mi_like_p (current_uiout
))
11673 case bp_tracepoint
:
11674 printf_filtered (_("Tracepoint"));
11675 printf_filtered (_(" %d"), b
->number
);
11677 case bp_fast_tracepoint
:
11678 printf_filtered (_("Fast tracepoint"));
11679 printf_filtered (_(" %d"), b
->number
);
11681 case bp_static_tracepoint
:
11682 printf_filtered (_("Static tracepoint"));
11683 printf_filtered (_(" %d"), b
->number
);
11686 internal_error (__FILE__
, __LINE__
,
11687 _("unhandled tracepoint type %d"), (int) b
->type
);
11694 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
11696 struct tracepoint
*tp
= (struct tracepoint
*) self
;
11698 if (self
->type
== bp_fast_tracepoint
)
11699 fprintf_unfiltered (fp
, "ftrace");
11700 if (self
->type
== bp_static_tracepoint
)
11701 fprintf_unfiltered (fp
, "strace");
11702 else if (self
->type
== bp_tracepoint
)
11703 fprintf_unfiltered (fp
, "trace");
11705 internal_error (__FILE__
, __LINE__
,
11706 _("unhandled tracepoint type %d"), (int) self
->type
);
11708 fprintf_unfiltered (fp
, " %s", self
->addr_string
);
11709 print_recreate_thread (self
, fp
);
11711 if (tp
->pass_count
)
11712 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
11716 tracepoint_create_sals_from_address (char **arg
,
11717 struct linespec_result
*canonical
,
11718 enum bptype type_wanted
,
11719 char *addr_start
, char **copy_arg
)
11721 create_sals_from_address_default (arg
, canonical
, type_wanted
,
11722 addr_start
, copy_arg
);
11726 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
11727 struct linespec_result
*canonical
,
11728 struct linespec_sals
*lsal
,
11730 enum bptype type_wanted
,
11731 enum bpdisp disposition
,
11733 int task
, int ignore_count
,
11734 const struct breakpoint_ops
*ops
,
11735 int from_tty
, int enabled
,
11738 create_breakpoints_sal_default (gdbarch
, canonical
, lsal
,
11739 cond_string
, type_wanted
,
11740 disposition
, thread
, task
,
11741 ignore_count
, ops
, from_tty
,
11742 enabled
, internal
);
11746 tracepoint_decode_linespec (struct breakpoint
*b
, char **s
,
11747 struct symtabs_and_lines
*sals
)
11749 decode_linespec_default (b
, s
, sals
);
11752 struct breakpoint_ops tracepoint_breakpoint_ops
;
11754 /* The breakpoint_ops structure to be used on static tracepoints with
11758 strace_marker_create_sals_from_address (char **arg
,
11759 struct linespec_result
*canonical
,
11760 enum bptype type_wanted
,
11761 char *addr_start
, char **copy_arg
)
11763 struct linespec_sals lsal
;
11765 lsal
.sals
= decode_static_tracepoint_spec (arg
);
11767 *copy_arg
= savestring (addr_start
, *arg
- addr_start
);
11769 canonical
->addr_string
= xstrdup (*copy_arg
);
11770 lsal
.canonical
= xstrdup (*copy_arg
);
11771 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
11775 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
11776 struct linespec_result
*canonical
,
11777 struct linespec_sals
*lsal
,
11779 enum bptype type_wanted
,
11780 enum bpdisp disposition
,
11782 int task
, int ignore_count
,
11783 const struct breakpoint_ops
*ops
,
11784 int from_tty
, int enabled
,
11789 /* If the user is creating a static tracepoint by marker id
11790 (strace -m MARKER_ID), then store the sals index, so that
11791 breakpoint_re_set can try to match up which of the newly
11792 found markers corresponds to this one, and, don't try to
11793 expand multiple locations for each sal, given than SALS
11794 already should contain all sals for MARKER_ID. */
11796 for (i
= 0; i
< lsal
->sals
.nelts
; ++i
)
11798 struct symtabs_and_lines expanded
;
11799 struct tracepoint
*tp
;
11800 struct cleanup
*old_chain
;
11803 expanded
.nelts
= 1;
11804 expanded
.sals
= &lsal
->sals
.sals
[i
];
11806 addr_string
= xstrdup (canonical
->addr_string
);
11807 old_chain
= make_cleanup (xfree
, addr_string
);
11809 tp
= XCNEW (struct tracepoint
);
11810 init_breakpoint_sal (&tp
->base
, gdbarch
, expanded
,
11812 cond_string
, type_wanted
, disposition
,
11813 thread
, task
, ignore_count
, ops
,
11814 from_tty
, enabled
, internal
,
11815 canonical
->special_display
);
11816 /* Given that its possible to have multiple markers with
11817 the same string id, if the user is creating a static
11818 tracepoint by marker id ("strace -m MARKER_ID"), then
11819 store the sals index, so that breakpoint_re_set can
11820 try to match up which of the newly found markers
11821 corresponds to this one */
11822 tp
->static_trace_marker_id_idx
= i
;
11824 install_breakpoint (internal
, &tp
->base
, 0);
11826 discard_cleanups (old_chain
);
11831 strace_marker_decode_linespec (struct breakpoint
*b
, char **s
,
11832 struct symtabs_and_lines
*sals
)
11834 struct tracepoint
*tp
= (struct tracepoint
*) b
;
11836 *sals
= decode_static_tracepoint_spec (s
);
11837 if (sals
->nelts
> tp
->static_trace_marker_id_idx
)
11839 sals
->sals
[0] = sals
->sals
[tp
->static_trace_marker_id_idx
];
11843 error (_("marker %s not found"), tp
->static_trace_marker_id
);
11846 static struct breakpoint_ops strace_marker_breakpoint_ops
;
11849 strace_marker_p (struct breakpoint
*b
)
11851 return b
->ops
== &strace_marker_breakpoint_ops
;
11854 /* Delete a breakpoint and clean up all traces of it in the data
11858 delete_breakpoint (struct breakpoint
*bpt
)
11860 struct breakpoint
*b
;
11862 gdb_assert (bpt
!= NULL
);
11864 /* Has this bp already been deleted? This can happen because
11865 multiple lists can hold pointers to bp's. bpstat lists are
11868 One example of this happening is a watchpoint's scope bp. When
11869 the scope bp triggers, we notice that the watchpoint is out of
11870 scope, and delete it. We also delete its scope bp. But the
11871 scope bp is marked "auto-deleting", and is already on a bpstat.
11872 That bpstat is then checked for auto-deleting bp's, which are
11875 A real solution to this problem might involve reference counts in
11876 bp's, and/or giving them pointers back to their referencing
11877 bpstat's, and teaching delete_breakpoint to only free a bp's
11878 storage when no more references were extent. A cheaper bandaid
11880 if (bpt
->type
== bp_none
)
11883 /* At least avoid this stale reference until the reference counting
11884 of breakpoints gets resolved. */
11885 if (bpt
->related_breakpoint
!= bpt
)
11887 struct breakpoint
*related
;
11888 struct watchpoint
*w
;
11890 if (bpt
->type
== bp_watchpoint_scope
)
11891 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
11892 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
11893 w
= (struct watchpoint
*) bpt
;
11897 watchpoint_del_at_next_stop (w
);
11899 /* Unlink bpt from the bpt->related_breakpoint ring. */
11900 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
11901 related
= related
->related_breakpoint
);
11902 related
->related_breakpoint
= bpt
->related_breakpoint
;
11903 bpt
->related_breakpoint
= bpt
;
11906 /* watch_command_1 creates a watchpoint but only sets its number if
11907 update_watchpoint succeeds in creating its bp_locations. If there's
11908 a problem in that process, we'll be asked to delete the half-created
11909 watchpoint. In that case, don't announce the deletion. */
11911 observer_notify_breakpoint_deleted (bpt
);
11913 if (breakpoint_chain
== bpt
)
11914 breakpoint_chain
= bpt
->next
;
11916 ALL_BREAKPOINTS (b
)
11917 if (b
->next
== bpt
)
11919 b
->next
= bpt
->next
;
11923 /* Be sure no bpstat's are pointing at the breakpoint after it's
11925 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
11926 in all threads for now. Note that we cannot just remove bpstats
11927 pointing at bpt from the stop_bpstat list entirely, as breakpoint
11928 commands are associated with the bpstat; if we remove it here,
11929 then the later call to bpstat_do_actions (&stop_bpstat); in
11930 event-top.c won't do anything, and temporary breakpoints with
11931 commands won't work. */
11933 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
11935 /* Now that breakpoint is removed from breakpoint list, update the
11936 global location list. This will remove locations that used to
11937 belong to this breakpoint. Do this before freeing the breakpoint
11938 itself, since remove_breakpoint looks at location's owner. It
11939 might be better design to have location completely
11940 self-contained, but it's not the case now. */
11941 update_global_location_list (0);
11943 bpt
->ops
->dtor (bpt
);
11944 /* On the chance that someone will soon try again to delete this
11945 same bp, we mark it as deleted before freeing its storage. */
11946 bpt
->type
= bp_none
;
11951 do_delete_breakpoint_cleanup (void *b
)
11953 delete_breakpoint (b
);
11957 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
11959 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
11962 /* Iterator function to call a user-provided callback function once
11963 for each of B and its related breakpoints. */
11966 iterate_over_related_breakpoints (struct breakpoint
*b
,
11967 void (*function
) (struct breakpoint
*,
11971 struct breakpoint
*related
;
11976 struct breakpoint
*next
;
11978 /* FUNCTION may delete RELATED. */
11979 next
= related
->related_breakpoint
;
11981 if (next
== related
)
11983 /* RELATED is the last ring entry. */
11984 function (related
, data
);
11986 /* FUNCTION may have deleted it, so we'd never reach back to
11987 B. There's nothing left to do anyway, so just break
11992 function (related
, data
);
11996 while (related
!= b
);
12000 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
12002 delete_breakpoint (b
);
12005 /* A callback for map_breakpoint_numbers that calls
12006 delete_breakpoint. */
12009 do_map_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
12011 iterate_over_related_breakpoints (b
, do_delete_breakpoint
, NULL
);
12015 delete_command (char *arg
, int from_tty
)
12017 struct breakpoint
*b
, *b_tmp
;
12023 int breaks_to_delete
= 0;
12025 /* Delete all breakpoints if no argument. Do not delete
12026 internal breakpoints, these have to be deleted with an
12027 explicit breakpoint number argument. */
12028 ALL_BREAKPOINTS (b
)
12029 if (user_breakpoint_p (b
))
12031 breaks_to_delete
= 1;
12035 /* Ask user only if there are some breakpoints to delete. */
12037 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
12039 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12040 if (user_breakpoint_p (b
))
12041 delete_breakpoint (b
);
12045 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
12049 all_locations_are_pending (struct bp_location
*loc
)
12051 for (; loc
; loc
= loc
->next
)
12052 if (!loc
->shlib_disabled
12053 && !loc
->pspace
->executing_startup
)
12058 /* Subroutine of update_breakpoint_locations to simplify it.
12059 Return non-zero if multiple fns in list LOC have the same name.
12060 Null names are ignored. */
12063 ambiguous_names_p (struct bp_location
*loc
)
12065 struct bp_location
*l
;
12066 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
12067 (int (*) (const void *,
12068 const void *)) streq
,
12069 NULL
, xcalloc
, xfree
);
12071 for (l
= loc
; l
!= NULL
; l
= l
->next
)
12074 const char *name
= l
->function_name
;
12076 /* Allow for some names to be NULL, ignore them. */
12080 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
12082 /* NOTE: We can assume slot != NULL here because xcalloc never
12086 htab_delete (htab
);
12092 htab_delete (htab
);
12096 /* When symbols change, it probably means the sources changed as well,
12097 and it might mean the static tracepoint markers are no longer at
12098 the same address or line numbers they used to be at last we
12099 checked. Losing your static tracepoints whenever you rebuild is
12100 undesirable. This function tries to resync/rematch gdb static
12101 tracepoints with the markers on the target, for static tracepoints
12102 that have not been set by marker id. Static tracepoint that have
12103 been set by marker id are reset by marker id in breakpoint_re_set.
12106 1) For a tracepoint set at a specific address, look for a marker at
12107 the old PC. If one is found there, assume to be the same marker.
12108 If the name / string id of the marker found is different from the
12109 previous known name, assume that means the user renamed the marker
12110 in the sources, and output a warning.
12112 2) For a tracepoint set at a given line number, look for a marker
12113 at the new address of the old line number. If one is found there,
12114 assume to be the same marker. If the name / string id of the
12115 marker found is different from the previous known name, assume that
12116 means the user renamed the marker in the sources, and output a
12119 3) If a marker is no longer found at the same address or line, it
12120 may mean the marker no longer exists. But it may also just mean
12121 the code changed a bit. Maybe the user added a few lines of code
12122 that made the marker move up or down (in line number terms). Ask
12123 the target for info about the marker with the string id as we knew
12124 it. If found, update line number and address in the matching
12125 static tracepoint. This will get confused if there's more than one
12126 marker with the same ID (possible in UST, although unadvised
12127 precisely because it confuses tools). */
12129 static struct symtab_and_line
12130 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
12132 struct tracepoint
*tp
= (struct tracepoint
*) b
;
12133 struct static_tracepoint_marker marker
;
12139 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
12141 if (target_static_tracepoint_marker_at (pc
, &marker
))
12143 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
12144 warning (_("static tracepoint %d changed probed marker from %s to %s"),
12146 tp
->static_trace_marker_id
, marker
.str_id
);
12148 xfree (tp
->static_trace_marker_id
);
12149 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
12150 release_static_tracepoint_marker (&marker
);
12155 /* Old marker wasn't found on target at lineno. Try looking it up
12157 if (!sal
.explicit_pc
12159 && sal
.symtab
!= NULL
12160 && tp
->static_trace_marker_id
!= NULL
)
12162 VEC(static_tracepoint_marker_p
) *markers
;
12165 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
12167 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
12169 struct symtab_and_line sal2
;
12170 struct symbol
*sym
;
12171 struct static_tracepoint_marker
*tpmarker
;
12172 struct ui_out
*uiout
= current_uiout
;
12174 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
12176 xfree (tp
->static_trace_marker_id
);
12177 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
12179 warning (_("marker for static tracepoint %d (%s) not "
12180 "found at previous line number"),
12181 b
->number
, tp
->static_trace_marker_id
);
12185 sal2
.pc
= tpmarker
->address
;
12187 sal2
= find_pc_line (tpmarker
->address
, 0);
12188 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
12189 ui_out_text (uiout
, "Now in ");
12192 ui_out_field_string (uiout
, "func",
12193 SYMBOL_PRINT_NAME (sym
));
12194 ui_out_text (uiout
, " at ");
12196 ui_out_field_string (uiout
, "file", sal2
.symtab
->filename
);
12197 ui_out_text (uiout
, ":");
12199 if (ui_out_is_mi_like_p (uiout
))
12201 char *fullname
= symtab_to_fullname (sal2
.symtab
);
12204 ui_out_field_string (uiout
, "fullname", fullname
);
12207 ui_out_field_int (uiout
, "line", sal2
.line
);
12208 ui_out_text (uiout
, "\n");
12210 b
->loc
->line_number
= sal2
.line
;
12212 xfree (b
->loc
->source_file
);
12214 b
->loc
->source_file
= xstrdup (sal2
.symtab
->filename
);
12216 b
->loc
->source_file
= NULL
;
12218 xfree (b
->addr_string
);
12219 b
->addr_string
= xstrprintf ("%s:%d",
12220 sal2
.symtab
->filename
,
12221 b
->loc
->line_number
);
12223 /* Might be nice to check if function changed, and warn if
12226 release_static_tracepoint_marker (tpmarker
);
12232 /* Returns 1 iff locations A and B are sufficiently same that
12233 we don't need to report breakpoint as changed. */
12236 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
12240 if (a
->address
!= b
->address
)
12243 if (a
->shlib_disabled
!= b
->shlib_disabled
)
12246 if (a
->enabled
!= b
->enabled
)
12253 if ((a
== NULL
) != (b
== NULL
))
12259 /* Create new breakpoint locations for B (a hardware or software breakpoint)
12260 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
12261 a ranged breakpoint. */
12264 update_breakpoint_locations (struct breakpoint
*b
,
12265 struct symtabs_and_lines sals
,
12266 struct symtabs_and_lines sals_end
)
12269 struct bp_location
*existing_locations
= b
->loc
;
12271 if (sals_end
.nelts
!= 0 && (sals
.nelts
!= 1 || sals_end
.nelts
!= 1))
12273 /* Ranged breakpoints have only one start location and one end
12275 b
->enable_state
= bp_disabled
;
12276 update_global_location_list (1);
12277 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
12278 "multiple locations found\n"),
12283 /* If there's no new locations, and all existing locations are
12284 pending, don't do anything. This optimizes the common case where
12285 all locations are in the same shared library, that was unloaded.
12286 We'd like to retain the location, so that when the library is
12287 loaded again, we don't loose the enabled/disabled status of the
12288 individual locations. */
12289 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
12294 for (i
= 0; i
< sals
.nelts
; ++i
)
12296 struct bp_location
*new_loc
;
12298 switch_to_program_space_and_thread (sals
.sals
[i
].pspace
);
12300 new_loc
= add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
12302 /* Reparse conditions, they might contain references to the
12304 if (b
->cond_string
!= NULL
)
12307 volatile struct gdb_exception e
;
12309 s
= b
->cond_string
;
12310 TRY_CATCH (e
, RETURN_MASK_ERROR
)
12312 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
12317 warning (_("failed to reevaluate condition "
12318 "for breakpoint %d: %s"),
12319 b
->number
, e
.message
);
12320 new_loc
->enabled
= 0;
12324 if (sals_end
.nelts
)
12326 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
12328 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
12332 /* Update locations of permanent breakpoints. */
12333 if (b
->enable_state
== bp_permanent
)
12334 make_breakpoint_permanent (b
);
12336 /* If possible, carry over 'disable' status from existing
12339 struct bp_location
*e
= existing_locations
;
12340 /* If there are multiple breakpoints with the same function name,
12341 e.g. for inline functions, comparing function names won't work.
12342 Instead compare pc addresses; this is just a heuristic as things
12343 may have moved, but in practice it gives the correct answer
12344 often enough until a better solution is found. */
12345 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
12347 for (; e
; e
= e
->next
)
12349 if (!e
->enabled
&& e
->function_name
)
12351 struct bp_location
*l
= b
->loc
;
12352 if (have_ambiguous_names
)
12354 for (; l
; l
= l
->next
)
12355 if (breakpoint_locations_match (e
, l
))
12363 for (; l
; l
= l
->next
)
12364 if (l
->function_name
12365 && strcmp (e
->function_name
, l
->function_name
) == 0)
12375 if (!locations_are_equal (existing_locations
, b
->loc
))
12376 observer_notify_breakpoint_modified (b
);
12378 update_global_location_list (1);
12381 /* Find the SaL locations corresponding to the given ADDR_STRING.
12382 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
12384 static struct symtabs_and_lines
12385 addr_string_to_sals (struct breakpoint
*b
, char *addr_string
, int *found
)
12388 struct symtabs_and_lines sals
= {0};
12389 volatile struct gdb_exception e
;
12391 gdb_assert (b
->ops
!= NULL
);
12394 TRY_CATCH (e
, RETURN_MASK_ERROR
)
12396 b
->ops
->decode_linespec (b
, &s
, &sals
);
12400 int not_found_and_ok
= 0;
12401 /* For pending breakpoints, it's expected that parsing will
12402 fail until the right shared library is loaded. User has
12403 already told to create pending breakpoints and don't need
12404 extra messages. If breakpoint is in bp_shlib_disabled
12405 state, then user already saw the message about that
12406 breakpoint being disabled, and don't want to see more
12408 if (e
.error
== NOT_FOUND_ERROR
12409 && (b
->condition_not_parsed
12410 || (b
->loc
&& b
->loc
->shlib_disabled
)
12411 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
12412 || b
->enable_state
== bp_disabled
))
12413 not_found_and_ok
= 1;
12415 if (!not_found_and_ok
)
12417 /* We surely don't want to warn about the same breakpoint
12418 10 times. One solution, implemented here, is disable
12419 the breakpoint on error. Another solution would be to
12420 have separate 'warning emitted' flag. Since this
12421 happens only when a binary has changed, I don't know
12422 which approach is better. */
12423 b
->enable_state
= bp_disabled
;
12424 throw_exception (e
);
12428 if (e
.reason
== 0 || e
.error
!= NOT_FOUND_ERROR
)
12432 for (i
= 0; i
< sals
.nelts
; ++i
)
12433 resolve_sal_pc (&sals
.sals
[i
]);
12434 if (b
->condition_not_parsed
&& s
&& s
[0])
12436 char *cond_string
= 0;
12440 find_condition_and_thread (s
, sals
.sals
[0].pc
,
12441 &cond_string
, &thread
, &task
);
12443 b
->cond_string
= cond_string
;
12444 b
->thread
= thread
;
12446 b
->condition_not_parsed
= 0;
12449 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
12450 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
12460 /* The default re_set method, for typical hardware or software
12461 breakpoints. Reevaluate the breakpoint and recreate its
12465 breakpoint_re_set_default (struct breakpoint
*b
)
12468 struct symtabs_and_lines sals
, sals_end
;
12469 struct symtabs_and_lines expanded
= {0};
12470 struct symtabs_and_lines expanded_end
= {0};
12472 sals
= addr_string_to_sals (b
, b
->addr_string
, &found
);
12475 make_cleanup (xfree
, sals
.sals
);
12479 if (b
->addr_string_range_end
)
12481 sals_end
= addr_string_to_sals (b
, b
->addr_string_range_end
, &found
);
12484 make_cleanup (xfree
, sals_end
.sals
);
12485 expanded_end
= sals_end
;
12489 update_breakpoint_locations (b
, expanded
, expanded_end
);
12492 /* Default method for creating SALs from an address string. It basically
12493 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
12496 create_sals_from_address_default (char **arg
,
12497 struct linespec_result
*canonical
,
12498 enum bptype type_wanted
,
12499 char *addr_start
, char **copy_arg
)
12501 parse_breakpoint_sals (arg
, canonical
);
12504 /* Call create_breakpoints_sal for the given arguments. This is the default
12505 function for the `create_breakpoints_sal' method of
12509 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
12510 struct linespec_result
*canonical
,
12511 struct linespec_sals
*lsal
,
12513 enum bptype type_wanted
,
12514 enum bpdisp disposition
,
12516 int task
, int ignore_count
,
12517 const struct breakpoint_ops
*ops
,
12518 int from_tty
, int enabled
,
12521 create_breakpoints_sal (gdbarch
, canonical
, cond_string
,
12522 type_wanted
, disposition
,
12523 thread
, task
, ignore_count
, ops
, from_tty
,
12524 enabled
, internal
);
12527 /* Decode the line represented by S by calling decode_line_full. This is the
12528 default function for the `decode_linespec' method of breakpoint_ops. */
12531 decode_linespec_default (struct breakpoint
*b
, char **s
,
12532 struct symtabs_and_lines
*sals
)
12534 struct linespec_result canonical
;
12536 init_linespec_result (&canonical
);
12537 decode_line_full (s
, DECODE_LINE_FUNFIRSTLINE
,
12538 (struct symtab
*) NULL
, 0,
12539 &canonical
, multiple_symbols_all
,
12542 /* We should get 0 or 1 resulting SALs. */
12543 gdb_assert (VEC_length (linespec_sals
, canonical
.sals
) < 2);
12545 if (VEC_length (linespec_sals
, canonical
.sals
) > 0)
12547 struct linespec_sals
*lsal
;
12549 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
12550 *sals
= lsal
->sals
;
12551 /* Arrange it so the destructor does not free the
12553 lsal
->sals
.sals
= NULL
;
12556 destroy_linespec_result (&canonical
);
12559 /* Prepare the global context for a re-set of breakpoint B. */
12561 static struct cleanup
*
12562 prepare_re_set_context (struct breakpoint
*b
)
12564 struct cleanup
*cleanups
;
12566 input_radix
= b
->input_radix
;
12567 cleanups
= save_current_space_and_thread ();
12568 if (b
->pspace
!= NULL
)
12569 switch_to_program_space_and_thread (b
->pspace
);
12570 set_language (b
->language
);
12575 /* Reset a breakpoint given it's struct breakpoint * BINT.
12576 The value we return ends up being the return value from catch_errors.
12577 Unused in this case. */
12580 breakpoint_re_set_one (void *bint
)
12582 /* Get past catch_errs. */
12583 struct breakpoint
*b
= (struct breakpoint
*) bint
;
12584 struct cleanup
*cleanups
;
12586 cleanups
= prepare_re_set_context (b
);
12587 b
->ops
->re_set (b
);
12588 do_cleanups (cleanups
);
12592 /* Re-set all breakpoints after symbols have been re-loaded. */
12594 breakpoint_re_set (void)
12596 struct breakpoint
*b
, *b_tmp
;
12597 enum language save_language
;
12598 int save_input_radix
;
12599 struct cleanup
*old_chain
;
12601 save_language
= current_language
->la_language
;
12602 save_input_radix
= input_radix
;
12603 old_chain
= save_current_program_space ();
12605 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12607 /* Format possible error msg. */
12608 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
12610 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
12611 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
12612 do_cleanups (cleanups
);
12614 set_language (save_language
);
12615 input_radix
= save_input_radix
;
12617 jit_breakpoint_re_set ();
12619 do_cleanups (old_chain
);
12621 create_overlay_event_breakpoint ();
12622 create_longjmp_master_breakpoint ();
12623 create_std_terminate_master_breakpoint ();
12624 create_exception_master_breakpoint ();
12626 /* While we're at it, reset the skip list too. */
12630 /* Reset the thread number of this breakpoint:
12632 - If the breakpoint is for all threads, leave it as-is.
12633 - Else, reset it to the current thread for inferior_ptid. */
12635 breakpoint_re_set_thread (struct breakpoint
*b
)
12637 if (b
->thread
!= -1)
12639 if (in_thread_list (inferior_ptid
))
12640 b
->thread
= pid_to_thread_id (inferior_ptid
);
12642 /* We're being called after following a fork. The new fork is
12643 selected as current, and unless this was a vfork will have a
12644 different program space from the original thread. Reset that
12646 b
->loc
->pspace
= current_program_space
;
12650 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
12651 If from_tty is nonzero, it prints a message to that effect,
12652 which ends with a period (no newline). */
12655 set_ignore_count (int bptnum
, int count
, int from_tty
)
12657 struct breakpoint
*b
;
12662 ALL_BREAKPOINTS (b
)
12663 if (b
->number
== bptnum
)
12665 if (is_tracepoint (b
))
12667 if (from_tty
&& count
!= 0)
12668 printf_filtered (_("Ignore count ignored for tracepoint %d."),
12673 b
->ignore_count
= count
;
12677 printf_filtered (_("Will stop next time "
12678 "breakpoint %d is reached."),
12680 else if (count
== 1)
12681 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
12684 printf_filtered (_("Will ignore next %d "
12685 "crossings of breakpoint %d."),
12688 breakpoints_changed ();
12689 observer_notify_breakpoint_modified (b
);
12693 error (_("No breakpoint number %d."), bptnum
);
12696 /* Command to set ignore-count of breakpoint N to COUNT. */
12699 ignore_command (char *args
, int from_tty
)
12705 error_no_arg (_("a breakpoint number"));
12707 num
= get_number (&p
);
12709 error (_("bad breakpoint number: '%s'"), args
);
12711 error (_("Second argument (specified ignore-count) is missing."));
12713 set_ignore_count (num
,
12714 longest_to_int (value_as_long (parse_and_eval (p
))),
12717 printf_filtered ("\n");
12720 /* Call FUNCTION on each of the breakpoints
12721 whose numbers are given in ARGS. */
12724 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
12729 struct breakpoint
*b
, *tmp
;
12731 struct get_number_or_range_state state
;
12734 error_no_arg (_("one or more breakpoint numbers"));
12736 init_number_or_range (&state
, args
);
12738 while (!state
.finished
)
12740 char *p
= state
.string
;
12744 num
= get_number_or_range (&state
);
12747 warning (_("bad breakpoint number at or near '%s'"), p
);
12751 ALL_BREAKPOINTS_SAFE (b
, tmp
)
12752 if (b
->number
== num
)
12755 function (b
, data
);
12759 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
12764 static struct bp_location
*
12765 find_location_by_number (char *number
)
12767 char *dot
= strchr (number
, '.');
12771 struct breakpoint
*b
;
12772 struct bp_location
*loc
;
12777 bp_num
= get_number (&p1
);
12779 error (_("Bad breakpoint number '%s'"), number
);
12781 ALL_BREAKPOINTS (b
)
12782 if (b
->number
== bp_num
)
12787 if (!b
|| b
->number
!= bp_num
)
12788 error (_("Bad breakpoint number '%s'"), number
);
12791 loc_num
= get_number (&p1
);
12793 error (_("Bad breakpoint location number '%s'"), number
);
12797 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
12800 error (_("Bad breakpoint location number '%s'"), dot
+1);
12806 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
12807 If from_tty is nonzero, it prints a message to that effect,
12808 which ends with a period (no newline). */
12811 disable_breakpoint (struct breakpoint
*bpt
)
12813 /* Never disable a watchpoint scope breakpoint; we want to
12814 hit them when we leave scope so we can delete both the
12815 watchpoint and its scope breakpoint at that time. */
12816 if (bpt
->type
== bp_watchpoint_scope
)
12819 /* You can't disable permanent breakpoints. */
12820 if (bpt
->enable_state
== bp_permanent
)
12823 bpt
->enable_state
= bp_disabled
;
12825 if (target_supports_enable_disable_tracepoint ()
12826 && current_trace_status ()->running
&& is_tracepoint (bpt
))
12828 struct bp_location
*location
;
12830 for (location
= bpt
->loc
; location
; location
= location
->next
)
12831 target_disable_tracepoint (location
);
12834 update_global_location_list (0);
12836 observer_notify_breakpoint_modified (bpt
);
12839 /* A callback for iterate_over_related_breakpoints. */
12842 do_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
12844 disable_breakpoint (b
);
12847 /* A callback for map_breakpoint_numbers that calls
12848 disable_breakpoint. */
12851 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
12853 iterate_over_related_breakpoints (b
, do_disable_breakpoint
, NULL
);
12857 disable_command (char *args
, int from_tty
)
12861 struct breakpoint
*bpt
;
12863 ALL_BREAKPOINTS (bpt
)
12864 if (user_breakpoint_p (bpt
))
12865 disable_breakpoint (bpt
);
12867 else if (strchr (args
, '.'))
12869 struct bp_location
*loc
= find_location_by_number (args
);
12873 if (target_supports_enable_disable_tracepoint ()
12874 && current_trace_status ()->running
&& loc
->owner
12875 && is_tracepoint (loc
->owner
))
12876 target_disable_tracepoint (loc
);
12878 update_global_location_list (0);
12881 map_breakpoint_numbers (args
, do_map_disable_breakpoint
, NULL
);
12885 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
)
12887 int target_resources_ok
;
12889 if (bpt
->type
== bp_hardware_breakpoint
)
12892 i
= hw_breakpoint_used_count ();
12893 target_resources_ok
=
12894 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
12896 if (target_resources_ok
== 0)
12897 error (_("No hardware breakpoint support in the target."));
12898 else if (target_resources_ok
< 0)
12899 error (_("Hardware breakpoints used exceeds limit."));
12902 if (is_watchpoint (bpt
))
12904 /* Initialize it just to avoid a GCC false warning. */
12905 enum enable_state orig_enable_state
= 0;
12906 volatile struct gdb_exception e
;
12908 TRY_CATCH (e
, RETURN_MASK_ALL
)
12910 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
12912 orig_enable_state
= bpt
->enable_state
;
12913 bpt
->enable_state
= bp_enabled
;
12914 update_watchpoint (w
, 1 /* reparse */);
12918 bpt
->enable_state
= orig_enable_state
;
12919 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
12925 if (bpt
->enable_state
!= bp_permanent
)
12926 bpt
->enable_state
= bp_enabled
;
12928 if (target_supports_enable_disable_tracepoint ()
12929 && current_trace_status ()->running
&& is_tracepoint (bpt
))
12931 struct bp_location
*location
;
12933 for (location
= bpt
->loc
; location
; location
= location
->next
)
12934 target_enable_tracepoint (location
);
12937 bpt
->disposition
= disposition
;
12938 update_global_location_list (1);
12939 breakpoints_changed ();
12941 observer_notify_breakpoint_modified (bpt
);
12946 enable_breakpoint (struct breakpoint
*bpt
)
12948 enable_breakpoint_disp (bpt
, bpt
->disposition
);
12952 do_enable_breakpoint (struct breakpoint
*bpt
, void *arg
)
12954 enable_breakpoint (bpt
);
12957 /* A callback for map_breakpoint_numbers that calls
12958 enable_breakpoint. */
12961 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
12963 iterate_over_related_breakpoints (b
, do_enable_breakpoint
, NULL
);
12966 /* The enable command enables the specified breakpoints (or all defined
12967 breakpoints) so they once again become (or continue to be) effective
12968 in stopping the inferior. */
12971 enable_command (char *args
, int from_tty
)
12975 struct breakpoint
*bpt
;
12977 ALL_BREAKPOINTS (bpt
)
12978 if (user_breakpoint_p (bpt
))
12979 enable_breakpoint (bpt
);
12981 else if (strchr (args
, '.'))
12983 struct bp_location
*loc
= find_location_by_number (args
);
12987 if (target_supports_enable_disable_tracepoint ()
12988 && current_trace_status ()->running
&& loc
->owner
12989 && is_tracepoint (loc
->owner
))
12990 target_enable_tracepoint (loc
);
12992 update_global_location_list (1);
12995 map_breakpoint_numbers (args
, do_map_enable_breakpoint
, NULL
);
12999 do_enable_breakpoint_disp (struct breakpoint
*bpt
, void *arg
)
13001 enum bpdisp disp
= *(enum bpdisp
*) arg
;
13003 enable_breakpoint_disp (bpt
, disp
);
13007 do_map_enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
13009 enum bpdisp disp
= disp_disable
;
13011 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
13015 enable_once_command (char *args
, int from_tty
)
13017 map_breakpoint_numbers (args
, do_map_enable_once_breakpoint
, NULL
);
13021 do_map_enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
13023 enum bpdisp disp
= disp_del
;
13025 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
13029 enable_delete_command (char *args
, int from_tty
)
13031 map_breakpoint_numbers (args
, do_map_enable_delete_breakpoint
, NULL
);
13035 set_breakpoint_cmd (char *args
, int from_tty
)
13040 show_breakpoint_cmd (char *args
, int from_tty
)
13044 /* Invalidate last known value of any hardware watchpoint if
13045 the memory which that value represents has been written to by
13049 invalidate_bp_value_on_memory_change (CORE_ADDR addr
, int len
,
13050 const bfd_byte
*data
)
13052 struct breakpoint
*bp
;
13054 ALL_BREAKPOINTS (bp
)
13055 if (bp
->enable_state
== bp_enabled
13056 && bp
->type
== bp_hardware_watchpoint
)
13058 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
13060 if (wp
->val_valid
&& wp
->val
)
13062 struct bp_location
*loc
;
13064 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
13065 if (loc
->loc_type
== bp_loc_hardware_watchpoint
13066 && loc
->address
+ loc
->length
> addr
13067 && addr
+ len
> loc
->address
)
13069 value_free (wp
->val
);
13077 /* Use the last displayed codepoint's values, or nothing
13078 if they aren't valid. */
13080 struct symtabs_and_lines
13081 decode_line_spec_1 (char *string
, int flags
)
13083 struct symtabs_and_lines sals
;
13086 error (_("Empty line specification."));
13087 if (last_displayed_sal_is_valid ())
13088 sals
= decode_line_1 (&string
, flags
,
13089 get_last_displayed_symtab (),
13090 get_last_displayed_line ());
13092 sals
= decode_line_1 (&string
, flags
, (struct symtab
*) NULL
, 0);
13094 error (_("Junk at end of line specification: %s"), string
);
13098 /* Create and insert a raw software breakpoint at PC. Return an
13099 identifier, which should be used to remove the breakpoint later.
13100 In general, places which call this should be using something on the
13101 breakpoint chain instead; this function should be eliminated
13105 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
13106 struct address_space
*aspace
, CORE_ADDR pc
)
13108 struct bp_target_info
*bp_tgt
;
13110 bp_tgt
= XZALLOC (struct bp_target_info
);
13112 bp_tgt
->placed_address_space
= aspace
;
13113 bp_tgt
->placed_address
= pc
;
13115 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
13117 /* Could not insert the breakpoint. */
13125 /* Remove a breakpoint BP inserted by
13126 deprecated_insert_raw_breakpoint. */
13129 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
13131 struct bp_target_info
*bp_tgt
= bp
;
13134 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
13140 /* One (or perhaps two) breakpoints used for software single
13143 static void *single_step_breakpoints
[2];
13144 static struct gdbarch
*single_step_gdbarch
[2];
13146 /* Create and insert a breakpoint for software single step. */
13149 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
13150 struct address_space
*aspace
,
13155 if (single_step_breakpoints
[0] == NULL
)
13157 bpt_p
= &single_step_breakpoints
[0];
13158 single_step_gdbarch
[0] = gdbarch
;
13162 gdb_assert (single_step_breakpoints
[1] == NULL
);
13163 bpt_p
= &single_step_breakpoints
[1];
13164 single_step_gdbarch
[1] = gdbarch
;
13167 /* NOTE drow/2006-04-11: A future improvement to this function would
13168 be to only create the breakpoints once, and actually put them on
13169 the breakpoint chain. That would let us use set_raw_breakpoint.
13170 We could adjust the addresses each time they were needed. Doing
13171 this requires corresponding changes elsewhere where single step
13172 breakpoints are handled, however. So, for now, we use this. */
13174 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
13175 if (*bpt_p
== NULL
)
13176 error (_("Could not insert single-step breakpoint at %s"),
13177 paddress (gdbarch
, next_pc
));
13180 /* Check if the breakpoints used for software single stepping
13181 were inserted or not. */
13184 single_step_breakpoints_inserted (void)
13186 return (single_step_breakpoints
[0] != NULL
13187 || single_step_breakpoints
[1] != NULL
);
13190 /* Remove and delete any breakpoints used for software single step. */
13193 remove_single_step_breakpoints (void)
13195 gdb_assert (single_step_breakpoints
[0] != NULL
);
13197 /* See insert_single_step_breakpoint for more about this deprecated
13199 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
13200 single_step_breakpoints
[0]);
13201 single_step_gdbarch
[0] = NULL
;
13202 single_step_breakpoints
[0] = NULL
;
13204 if (single_step_breakpoints
[1] != NULL
)
13206 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
13207 single_step_breakpoints
[1]);
13208 single_step_gdbarch
[1] = NULL
;
13209 single_step_breakpoints
[1] = NULL
;
13213 /* Delete software single step breakpoints without removing them from
13214 the inferior. This is intended to be used if the inferior's address
13215 space where they were inserted is already gone, e.g. after exit or
13219 cancel_single_step_breakpoints (void)
13223 for (i
= 0; i
< 2; i
++)
13224 if (single_step_breakpoints
[i
])
13226 xfree (single_step_breakpoints
[i
]);
13227 single_step_breakpoints
[i
] = NULL
;
13228 single_step_gdbarch
[i
] = NULL
;
13232 /* Detach software single-step breakpoints from INFERIOR_PTID without
13236 detach_single_step_breakpoints (void)
13240 for (i
= 0; i
< 2; i
++)
13241 if (single_step_breakpoints
[i
])
13242 target_remove_breakpoint (single_step_gdbarch
[i
],
13243 single_step_breakpoints
[i
]);
13246 /* Check whether a software single-step breakpoint is inserted at
13250 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
13255 for (i
= 0; i
< 2; i
++)
13257 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
13259 && breakpoint_address_match (bp_tgt
->placed_address_space
,
13260 bp_tgt
->placed_address
,
13268 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
13269 non-zero otherwise. */
13271 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
13273 if (syscall_catchpoint_p (bp
)
13274 && bp
->enable_state
!= bp_disabled
13275 && bp
->enable_state
!= bp_call_disabled
)
13282 catch_syscall_enabled (void)
13284 struct inferior
*inf
= current_inferior ();
13286 return inf
->total_syscalls_count
!= 0;
13290 catching_syscall_number (int syscall_number
)
13292 struct breakpoint
*bp
;
13294 ALL_BREAKPOINTS (bp
)
13295 if (is_syscall_catchpoint_enabled (bp
))
13297 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bp
;
13299 if (c
->syscalls_to_be_caught
)
13303 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
13305 if (syscall_number
== iter
)
13315 /* Complete syscall names. Used by "catch syscall". */
13317 catch_syscall_completer (struct cmd_list_element
*cmd
,
13318 char *text
, char *word
)
13320 const char **list
= get_syscall_names ();
13322 = (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
13328 /* Tracepoint-specific operations. */
13330 /* Set tracepoint count to NUM. */
13332 set_tracepoint_count (int num
)
13334 tracepoint_count
= num
;
13335 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
13339 trace_command (char *arg
, int from_tty
)
13341 if (create_breakpoint (get_current_arch (),
13343 NULL
, 0, 1 /* parse arg */,
13345 bp_tracepoint
/* type_wanted */,
13346 0 /* Ignore count */,
13347 pending_break_support
,
13348 &tracepoint_breakpoint_ops
,
13352 set_tracepoint_count (breakpoint_count
);
13356 ftrace_command (char *arg
, int from_tty
)
13358 if (create_breakpoint (get_current_arch (),
13360 NULL
, 0, 1 /* parse arg */,
13362 bp_fast_tracepoint
/* type_wanted */,
13363 0 /* Ignore count */,
13364 pending_break_support
,
13365 &tracepoint_breakpoint_ops
,
13369 set_tracepoint_count (breakpoint_count
);
13372 /* strace command implementation. Creates a static tracepoint. */
13375 strace_command (char *arg
, int from_tty
)
13377 struct breakpoint_ops
*ops
;
13379 /* Decide if we are dealing with a static tracepoint marker (`-m'),
13380 or with a normal static tracepoint. */
13381 if (arg
&& strncmp (arg
, "-m", 2) == 0 && isspace (arg
[2]))
13382 ops
= &strace_marker_breakpoint_ops
;
13384 ops
= &tracepoint_breakpoint_ops
;
13386 if (create_breakpoint (get_current_arch (),
13388 NULL
, 0, 1 /* parse arg */,
13390 bp_static_tracepoint
/* type_wanted */,
13391 0 /* Ignore count */,
13392 pending_break_support
,
13397 set_tracepoint_count (breakpoint_count
);
13400 /* Set up a fake reader function that gets command lines from a linked
13401 list that was acquired during tracepoint uploading. */
13403 static struct uploaded_tp
*this_utp
;
13404 static int next_cmd
;
13407 read_uploaded_action (void)
13411 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
13418 /* Given information about a tracepoint as recorded on a target (which
13419 can be either a live system or a trace file), attempt to create an
13420 equivalent GDB tracepoint. This is not a reliable process, since
13421 the target does not necessarily have all the information used when
13422 the tracepoint was originally defined. */
13424 struct tracepoint
*
13425 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
13427 char *addr_str
, small_buf
[100];
13428 struct tracepoint
*tp
;
13430 if (utp
->at_string
)
13431 addr_str
= utp
->at_string
;
13434 /* In the absence of a source location, fall back to raw
13435 address. Since there is no way to confirm that the address
13436 means the same thing as when the trace was started, warn the
13438 warning (_("Uploaded tracepoint %d has no "
13439 "source location, using raw address"),
13441 sprintf (small_buf
, "*%s", hex_string (utp
->addr
));
13442 addr_str
= small_buf
;
13445 /* There's not much we can do with a sequence of bytecodes. */
13446 if (utp
->cond
&& !utp
->cond_string
)
13447 warning (_("Uploaded tracepoint %d condition "
13448 "has no source form, ignoring it"),
13451 if (!create_breakpoint (get_current_arch (),
13453 utp
->cond_string
, -1, 0 /* parse cond/thread */,
13455 utp
->type
/* type_wanted */,
13456 0 /* Ignore count */,
13457 pending_break_support
,
13458 &tracepoint_breakpoint_ops
,
13460 utp
->enabled
/* enabled */,
13464 set_tracepoint_count (breakpoint_count
);
13466 /* Get the tracepoint we just created. */
13467 tp
= get_tracepoint (tracepoint_count
);
13468 gdb_assert (tp
!= NULL
);
13472 sprintf (small_buf
, "%d %d", utp
->pass
, tp
->base
.number
);
13474 trace_pass_command (small_buf
, 0);
13477 /* If we have uploaded versions of the original commands, set up a
13478 special-purpose "reader" function and call the usual command line
13479 reader, then pass the result to the breakpoint command-setting
13481 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
13483 struct command_line
*cmd_list
;
13488 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
13490 breakpoint_set_commands (&tp
->base
, cmd_list
);
13492 else if (!VEC_empty (char_ptr
, utp
->actions
)
13493 || !VEC_empty (char_ptr
, utp
->step_actions
))
13494 warning (_("Uploaded tracepoint %d actions "
13495 "have no source form, ignoring them"),
13498 /* Copy any status information that might be available. */
13499 tp
->base
.hit_count
= utp
->hit_count
;
13500 tp
->traceframe_usage
= utp
->traceframe_usage
;
13505 /* Print information on tracepoint number TPNUM_EXP, or all if
13509 tracepoints_info (char *args
, int from_tty
)
13511 struct ui_out
*uiout
= current_uiout
;
13514 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
13516 if (num_printed
== 0)
13518 if (args
== NULL
|| *args
== '\0')
13519 ui_out_message (uiout
, 0, "No tracepoints.\n");
13521 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
13524 default_collect_info ();
13527 /* The 'enable trace' command enables tracepoints.
13528 Not supported by all targets. */
13530 enable_trace_command (char *args
, int from_tty
)
13532 enable_command (args
, from_tty
);
13535 /* The 'disable trace' command disables tracepoints.
13536 Not supported by all targets. */
13538 disable_trace_command (char *args
, int from_tty
)
13540 disable_command (args
, from_tty
);
13543 /* Remove a tracepoint (or all if no argument). */
13545 delete_trace_command (char *arg
, int from_tty
)
13547 struct breakpoint
*b
, *b_tmp
;
13553 int breaks_to_delete
= 0;
13555 /* Delete all breakpoints if no argument.
13556 Do not delete internal or call-dummy breakpoints, these
13557 have to be deleted with an explicit breakpoint number
13559 ALL_TRACEPOINTS (b
)
13560 if (is_tracepoint (b
) && user_breakpoint_p (b
))
13562 breaks_to_delete
= 1;
13566 /* Ask user only if there are some breakpoints to delete. */
13568 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
13570 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13571 if (is_tracepoint (b
) && user_breakpoint_p (b
))
13572 delete_breakpoint (b
);
13576 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
13579 /* Helper function for trace_pass_command. */
13582 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
13584 tp
->pass_count
= count
;
13585 observer_notify_tracepoint_modified (tp
->base
.number
);
13587 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
13588 tp
->base
.number
, count
);
13591 /* Set passcount for tracepoint.
13593 First command argument is passcount, second is tracepoint number.
13594 If tracepoint number omitted, apply to most recently defined.
13595 Also accepts special argument "all". */
13598 trace_pass_command (char *args
, int from_tty
)
13600 struct tracepoint
*t1
;
13601 unsigned int count
;
13603 if (args
== 0 || *args
== 0)
13604 error (_("passcount command requires an "
13605 "argument (count + optional TP num)"));
13607 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
13609 while (*args
&& isspace ((int) *args
))
13612 if (*args
&& strncasecmp (args
, "all", 3) == 0)
13614 struct breakpoint
*b
;
13616 args
+= 3; /* Skip special argument "all". */
13618 error (_("Junk at end of arguments."));
13620 ALL_TRACEPOINTS (b
)
13622 t1
= (struct tracepoint
*) b
;
13623 trace_pass_set_count (t1
, count
, from_tty
);
13626 else if (*args
== '\0')
13628 t1
= get_tracepoint_by_number (&args
, NULL
, 1);
13630 trace_pass_set_count (t1
, count
, from_tty
);
13634 struct get_number_or_range_state state
;
13636 init_number_or_range (&state
, args
);
13637 while (!state
.finished
)
13639 t1
= get_tracepoint_by_number (&args
, &state
, 1);
13641 trace_pass_set_count (t1
, count
, from_tty
);
13646 struct tracepoint
*
13647 get_tracepoint (int num
)
13649 struct breakpoint
*t
;
13651 ALL_TRACEPOINTS (t
)
13652 if (t
->number
== num
)
13653 return (struct tracepoint
*) t
;
13658 /* Find the tracepoint with the given target-side number (which may be
13659 different from the tracepoint number after disconnecting and
13662 struct tracepoint
*
13663 get_tracepoint_by_number_on_target (int num
)
13665 struct breakpoint
*b
;
13667 ALL_TRACEPOINTS (b
)
13669 struct tracepoint
*t
= (struct tracepoint
*) b
;
13671 if (t
->number_on_target
== num
)
13678 /* Utility: parse a tracepoint number and look it up in the list.
13679 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
13680 If OPTIONAL_P is true, then if the argument is missing, the most
13681 recent tracepoint (tracepoint_count) is returned. */
13682 struct tracepoint
*
13683 get_tracepoint_by_number (char **arg
,
13684 struct get_number_or_range_state
*state
,
13687 extern int tracepoint_count
;
13688 struct breakpoint
*t
;
13690 char *instring
= arg
== NULL
? NULL
: *arg
;
13694 gdb_assert (!state
->finished
);
13695 tpnum
= get_number_or_range (state
);
13697 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
13700 tpnum
= tracepoint_count
;
13702 error_no_arg (_("tracepoint number"));
13705 tpnum
= get_number (arg
);
13709 if (instring
&& *instring
)
13710 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
13713 printf_filtered (_("Tracepoint argument missing "
13714 "and no previous tracepoint\n"));
13718 ALL_TRACEPOINTS (t
)
13719 if (t
->number
== tpnum
)
13721 return (struct tracepoint
*) t
;
13724 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
13729 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
13731 if (b
->thread
!= -1)
13732 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
13735 fprintf_unfiltered (fp
, " task %d", b
->task
);
13737 fprintf_unfiltered (fp
, "\n");
13740 /* Save information on user settable breakpoints (watchpoints, etc) to
13741 a new script file named FILENAME. If FILTER is non-NULL, call it
13742 on each breakpoint and only include the ones for which it returns
13746 save_breakpoints (char *filename
, int from_tty
,
13747 int (*filter
) (const struct breakpoint
*))
13749 struct breakpoint
*tp
;
13752 struct cleanup
*cleanup
;
13753 struct ui_file
*fp
;
13754 int extra_trace_bits
= 0;
13756 if (filename
== 0 || *filename
== 0)
13757 error (_("Argument required (file name in which to save)"));
13759 /* See if we have anything to save. */
13760 ALL_BREAKPOINTS (tp
)
13762 /* Skip internal and momentary breakpoints. */
13763 if (!user_breakpoint_p (tp
))
13766 /* If we have a filter, only save the breakpoints it accepts. */
13767 if (filter
&& !filter (tp
))
13772 if (is_tracepoint (tp
))
13774 extra_trace_bits
= 1;
13776 /* We can stop searching. */
13783 warning (_("Nothing to save."));
13787 pathname
= tilde_expand (filename
);
13788 cleanup
= make_cleanup (xfree
, pathname
);
13789 fp
= gdb_fopen (pathname
, "w");
13791 error (_("Unable to open file '%s' for saving (%s)"),
13792 filename
, safe_strerror (errno
));
13793 make_cleanup_ui_file_delete (fp
);
13795 if (extra_trace_bits
)
13796 save_trace_state_variables (fp
);
13798 ALL_BREAKPOINTS (tp
)
13800 /* Skip internal and momentary breakpoints. */
13801 if (!user_breakpoint_p (tp
))
13804 /* If we have a filter, only save the breakpoints it accepts. */
13805 if (filter
&& !filter (tp
))
13808 tp
->ops
->print_recreate (tp
, fp
);
13810 /* Note, we can't rely on tp->number for anything, as we can't
13811 assume the recreated breakpoint numbers will match. Use $bpnum
13814 if (tp
->cond_string
)
13815 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
13817 if (tp
->ignore_count
)
13818 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
13822 volatile struct gdb_exception ex
;
13824 fprintf_unfiltered (fp
, " commands\n");
13826 ui_out_redirect (current_uiout
, fp
);
13827 TRY_CATCH (ex
, RETURN_MASK_ALL
)
13829 print_command_lines (current_uiout
, tp
->commands
->commands
, 2);
13831 ui_out_redirect (current_uiout
, NULL
);
13834 throw_exception (ex
);
13836 fprintf_unfiltered (fp
, " end\n");
13839 if (tp
->enable_state
== bp_disabled
)
13840 fprintf_unfiltered (fp
, "disable\n");
13842 /* If this is a multi-location breakpoint, check if the locations
13843 should be individually disabled. Watchpoint locations are
13844 special, and not user visible. */
13845 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
13847 struct bp_location
*loc
;
13850 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
13852 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
13856 if (extra_trace_bits
&& *default_collect
)
13857 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
13859 do_cleanups (cleanup
);
13861 printf_filtered (_("Saved to file '%s'.\n"), filename
);
13864 /* The `save breakpoints' command. */
13867 save_breakpoints_command (char *args
, int from_tty
)
13869 save_breakpoints (args
, from_tty
, NULL
);
13872 /* The `save tracepoints' command. */
13875 save_tracepoints_command (char *args
, int from_tty
)
13877 save_breakpoints (args
, from_tty
, is_tracepoint
);
13880 /* Create a vector of all tracepoints. */
13882 VEC(breakpoint_p
) *
13883 all_tracepoints (void)
13885 VEC(breakpoint_p
) *tp_vec
= 0;
13886 struct breakpoint
*tp
;
13888 ALL_TRACEPOINTS (tp
)
13890 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
13897 /* This help string is used for the break, hbreak, tbreak and thbreak
13898 commands. It is defined as a macro to prevent duplication.
13899 COMMAND should be a string constant containing the name of the
13901 #define BREAK_ARGS_HELP(command) \
13902 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
13903 LOCATION may be a line number, function name, or \"*\" and an address.\n\
13904 If a line number is specified, break at start of code for that line.\n\
13905 If a function is specified, break at start of code for that function.\n\
13906 If an address is specified, break at that exact address.\n\
13907 With no LOCATION, uses current execution address of the selected\n\
13908 stack frame. This is useful for breaking on return to a stack frame.\n\
13910 THREADNUM is the number from \"info threads\".\n\
13911 CONDITION is a boolean expression.\n\
13913 Multiple breakpoints at one place are permitted, and useful if their\n\
13914 conditions are different.\n\
13916 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
13918 /* List of subcommands for "catch". */
13919 static struct cmd_list_element
*catch_cmdlist
;
13921 /* List of subcommands for "tcatch". */
13922 static struct cmd_list_element
*tcatch_cmdlist
;
13925 add_catch_command (char *name
, char *docstring
,
13926 void (*sfunc
) (char *args
, int from_tty
,
13927 struct cmd_list_element
*command
),
13928 char **(*completer
) (struct cmd_list_element
*cmd
,
13929 char *text
, char *word
),
13930 void *user_data_catch
,
13931 void *user_data_tcatch
)
13933 struct cmd_list_element
*command
;
13935 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
13937 set_cmd_sfunc (command
, sfunc
);
13938 set_cmd_context (command
, user_data_catch
);
13939 set_cmd_completer (command
, completer
);
13941 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
13943 set_cmd_sfunc (command
, sfunc
);
13944 set_cmd_context (command
, user_data_tcatch
);
13945 set_cmd_completer (command
, completer
);
13949 clear_syscall_counts (struct inferior
*inf
)
13951 inf
->total_syscalls_count
= 0;
13952 inf
->any_syscall_count
= 0;
13953 VEC_free (int, inf
->syscalls_counts
);
13957 save_command (char *arg
, int from_tty
)
13959 printf_unfiltered (_("\"save\" must be followed by "
13960 "the name of a save subcommand.\n"));
13961 help_list (save_cmdlist
, "save ", -1, gdb_stdout
);
13964 struct breakpoint
*
13965 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
13968 struct breakpoint
*b
, *b_tmp
;
13970 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13972 if ((*callback
) (b
, data
))
13979 /* Zero if any of the breakpoint's locations could be a location where
13980 functions have been inlined, nonzero otherwise. */
13983 is_non_inline_function (struct breakpoint
*b
)
13985 /* The shared library event breakpoint is set on the address of a
13986 non-inline function. */
13987 if (b
->type
== bp_shlib_event
)
13993 /* Nonzero if the specified PC cannot be a location where functions
13994 have been inlined. */
13997 pc_at_non_inline_function (struct address_space
*aspace
, CORE_ADDR pc
,
13998 const struct target_waitstatus
*ws
)
14000 struct breakpoint
*b
;
14001 struct bp_location
*bl
;
14003 ALL_BREAKPOINTS (b
)
14005 if (!is_non_inline_function (b
))
14008 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
14010 if (!bl
->shlib_disabled
14011 && bpstat_check_location (bl
, aspace
, pc
, ws
))
14020 initialize_breakpoint_ops (void)
14022 static int initialized
= 0;
14024 struct breakpoint_ops
*ops
;
14030 /* The breakpoint_ops structure to be inherit by all kinds of
14031 breakpoints (real breakpoints, i.e., user "break" breakpoints,
14032 internal and momentary breakpoints, etc.). */
14033 ops
= &bkpt_base_breakpoint_ops
;
14034 *ops
= base_breakpoint_ops
;
14035 ops
->re_set
= bkpt_re_set
;
14036 ops
->insert_location
= bkpt_insert_location
;
14037 ops
->remove_location
= bkpt_remove_location
;
14038 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
14039 ops
->create_sals_from_address
= bkpt_create_sals_from_address
;
14040 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
14041 ops
->decode_linespec
= bkpt_decode_linespec
;
14043 /* The breakpoint_ops structure to be used in regular breakpoints. */
14044 ops
= &bkpt_breakpoint_ops
;
14045 *ops
= bkpt_base_breakpoint_ops
;
14046 ops
->re_set
= bkpt_re_set
;
14047 ops
->resources_needed
= bkpt_resources_needed
;
14048 ops
->print_it
= bkpt_print_it
;
14049 ops
->print_mention
= bkpt_print_mention
;
14050 ops
->print_recreate
= bkpt_print_recreate
;
14052 /* Ranged breakpoints. */
14053 ops
= &ranged_breakpoint_ops
;
14054 *ops
= bkpt_breakpoint_ops
;
14055 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
14056 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
14057 ops
->print_it
= print_it_ranged_breakpoint
;
14058 ops
->print_one
= print_one_ranged_breakpoint
;
14059 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
14060 ops
->print_mention
= print_mention_ranged_breakpoint
;
14061 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
14063 /* Internal breakpoints. */
14064 ops
= &internal_breakpoint_ops
;
14065 *ops
= bkpt_base_breakpoint_ops
;
14066 ops
->re_set
= internal_bkpt_re_set
;
14067 ops
->check_status
= internal_bkpt_check_status
;
14068 ops
->print_it
= internal_bkpt_print_it
;
14069 ops
->print_mention
= internal_bkpt_print_mention
;
14071 /* Momentary breakpoints. */
14072 ops
= &momentary_breakpoint_ops
;
14073 *ops
= bkpt_base_breakpoint_ops
;
14074 ops
->re_set
= momentary_bkpt_re_set
;
14075 ops
->check_status
= momentary_bkpt_check_status
;
14076 ops
->print_it
= momentary_bkpt_print_it
;
14077 ops
->print_mention
= momentary_bkpt_print_mention
;
14079 /* GNU v3 exception catchpoints. */
14080 ops
= &gnu_v3_exception_catchpoint_ops
;
14081 *ops
= bkpt_breakpoint_ops
;
14082 ops
->print_it
= print_it_exception_catchpoint
;
14083 ops
->print_one
= print_one_exception_catchpoint
;
14084 ops
->print_mention
= print_mention_exception_catchpoint
;
14085 ops
->print_recreate
= print_recreate_exception_catchpoint
;
14088 ops
= &watchpoint_breakpoint_ops
;
14089 *ops
= base_breakpoint_ops
;
14090 ops
->dtor
= dtor_watchpoint
;
14091 ops
->re_set
= re_set_watchpoint
;
14092 ops
->insert_location
= insert_watchpoint
;
14093 ops
->remove_location
= remove_watchpoint
;
14094 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
14095 ops
->check_status
= check_status_watchpoint
;
14096 ops
->resources_needed
= resources_needed_watchpoint
;
14097 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
14098 ops
->print_it
= print_it_watchpoint
;
14099 ops
->print_mention
= print_mention_watchpoint
;
14100 ops
->print_recreate
= print_recreate_watchpoint
;
14102 /* Masked watchpoints. */
14103 ops
= &masked_watchpoint_breakpoint_ops
;
14104 *ops
= watchpoint_breakpoint_ops
;
14105 ops
->insert_location
= insert_masked_watchpoint
;
14106 ops
->remove_location
= remove_masked_watchpoint
;
14107 ops
->resources_needed
= resources_needed_masked_watchpoint
;
14108 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
14109 ops
->print_it
= print_it_masked_watchpoint
;
14110 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
14111 ops
->print_mention
= print_mention_masked_watchpoint
;
14112 ops
->print_recreate
= print_recreate_masked_watchpoint
;
14115 ops
= &tracepoint_breakpoint_ops
;
14116 *ops
= base_breakpoint_ops
;
14117 ops
->re_set
= tracepoint_re_set
;
14118 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
14119 ops
->print_one_detail
= tracepoint_print_one_detail
;
14120 ops
->print_mention
= tracepoint_print_mention
;
14121 ops
->print_recreate
= tracepoint_print_recreate
;
14122 ops
->create_sals_from_address
= tracepoint_create_sals_from_address
;
14123 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
14124 ops
->decode_linespec
= tracepoint_decode_linespec
;
14126 /* Static tracepoints with marker (`-m'). */
14127 ops
= &strace_marker_breakpoint_ops
;
14128 *ops
= tracepoint_breakpoint_ops
;
14129 ops
->create_sals_from_address
= strace_marker_create_sals_from_address
;
14130 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
14131 ops
->decode_linespec
= strace_marker_decode_linespec
;
14133 /* Fork catchpoints. */
14134 ops
= &catch_fork_breakpoint_ops
;
14135 *ops
= base_breakpoint_ops
;
14136 ops
->insert_location
= insert_catch_fork
;
14137 ops
->remove_location
= remove_catch_fork
;
14138 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
14139 ops
->print_it
= print_it_catch_fork
;
14140 ops
->print_one
= print_one_catch_fork
;
14141 ops
->print_mention
= print_mention_catch_fork
;
14142 ops
->print_recreate
= print_recreate_catch_fork
;
14144 /* Vfork catchpoints. */
14145 ops
= &catch_vfork_breakpoint_ops
;
14146 *ops
= base_breakpoint_ops
;
14147 ops
->insert_location
= insert_catch_vfork
;
14148 ops
->remove_location
= remove_catch_vfork
;
14149 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
14150 ops
->print_it
= print_it_catch_vfork
;
14151 ops
->print_one
= print_one_catch_vfork
;
14152 ops
->print_mention
= print_mention_catch_vfork
;
14153 ops
->print_recreate
= print_recreate_catch_vfork
;
14155 /* Exec catchpoints. */
14156 ops
= &catch_exec_breakpoint_ops
;
14157 *ops
= base_breakpoint_ops
;
14158 ops
->dtor
= dtor_catch_exec
;
14159 ops
->insert_location
= insert_catch_exec
;
14160 ops
->remove_location
= remove_catch_exec
;
14161 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
14162 ops
->print_it
= print_it_catch_exec
;
14163 ops
->print_one
= print_one_catch_exec
;
14164 ops
->print_mention
= print_mention_catch_exec
;
14165 ops
->print_recreate
= print_recreate_catch_exec
;
14167 /* Syscall catchpoints. */
14168 ops
= &catch_syscall_breakpoint_ops
;
14169 *ops
= base_breakpoint_ops
;
14170 ops
->dtor
= dtor_catch_syscall
;
14171 ops
->insert_location
= insert_catch_syscall
;
14172 ops
->remove_location
= remove_catch_syscall
;
14173 ops
->breakpoint_hit
= breakpoint_hit_catch_syscall
;
14174 ops
->print_it
= print_it_catch_syscall
;
14175 ops
->print_one
= print_one_catch_syscall
;
14176 ops
->print_mention
= print_mention_catch_syscall
;
14177 ops
->print_recreate
= print_recreate_catch_syscall
;
14179 /* Solib-related catchpoints. */
14180 ops
= &catch_solib_breakpoint_ops
;
14181 *ops
= base_breakpoint_ops
;
14182 ops
->dtor
= dtor_catch_solib
;
14183 ops
->insert_location
= insert_catch_solib
;
14184 ops
->remove_location
= remove_catch_solib
;
14185 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
14186 ops
->check_status
= check_status_catch_solib
;
14187 ops
->print_it
= print_it_catch_solib
;
14188 ops
->print_one
= print_one_catch_solib
;
14189 ops
->print_mention
= print_mention_catch_solib
;
14190 ops
->print_recreate
= print_recreate_catch_solib
;
14194 _initialize_breakpoint (void)
14196 struct cmd_list_element
*c
;
14198 initialize_breakpoint_ops ();
14200 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
14201 observer_attach_inferior_exit (clear_syscall_counts
);
14202 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
14204 breakpoint_objfile_key
= register_objfile_data ();
14206 breakpoint_chain
= 0;
14207 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
14208 before a breakpoint is set. */
14209 breakpoint_count
= 0;
14211 tracepoint_count
= 0;
14213 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
14214 Set ignore-count of breakpoint number N to COUNT.\n\
14215 Usage is `ignore N COUNT'."));
14217 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
14219 add_com ("commands", class_breakpoint
, commands_command
, _("\
14220 Set commands to be executed when a breakpoint is hit.\n\
14221 Give breakpoint number as argument after \"commands\".\n\
14222 With no argument, the targeted breakpoint is the last one set.\n\
14223 The commands themselves follow starting on the next line.\n\
14224 Type a line containing \"end\" to indicate the end of them.\n\
14225 Give \"silent\" as the first line to make the breakpoint silent;\n\
14226 then no output is printed when it is hit, except what the commands print."));
14228 add_com ("condition", class_breakpoint
, condition_command
, _("\
14229 Specify breakpoint number N to break only if COND is true.\n\
14230 Usage is `condition N COND', where N is an integer and COND is an\n\
14231 expression to be evaluated whenever breakpoint N is reached."));
14233 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
14234 Set a temporary breakpoint.\n\
14235 Like \"break\" except the breakpoint is only temporary,\n\
14236 so it will be deleted when hit. Equivalent to \"break\" followed\n\
14237 by using \"enable delete\" on the breakpoint number.\n\
14239 BREAK_ARGS_HELP ("tbreak")));
14240 set_cmd_completer (c
, location_completer
);
14242 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
14243 Set a hardware assisted breakpoint.\n\
14244 Like \"break\" except the breakpoint requires hardware support,\n\
14245 some target hardware may not have this support.\n\
14247 BREAK_ARGS_HELP ("hbreak")));
14248 set_cmd_completer (c
, location_completer
);
14250 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
14251 Set a temporary hardware assisted breakpoint.\n\
14252 Like \"hbreak\" except the breakpoint is only temporary,\n\
14253 so it will be deleted when hit.\n\
14255 BREAK_ARGS_HELP ("thbreak")));
14256 set_cmd_completer (c
, location_completer
);
14258 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
14259 Enable some breakpoints.\n\
14260 Give breakpoint numbers (separated by spaces) as arguments.\n\
14261 With no subcommand, breakpoints are enabled until you command otherwise.\n\
14262 This is used to cancel the effect of the \"disable\" command.\n\
14263 With a subcommand you can enable temporarily."),
14264 &enablelist
, "enable ", 1, &cmdlist
);
14266 add_com ("ab", class_breakpoint
, enable_command
, _("\
14267 Enable some breakpoints.\n\
14268 Give breakpoint numbers (separated by spaces) as arguments.\n\
14269 With no subcommand, breakpoints are enabled until you command otherwise.\n\
14270 This is used to cancel the effect of the \"disable\" command.\n\
14271 With a subcommand you can enable temporarily."));
14273 add_com_alias ("en", "enable", class_breakpoint
, 1);
14275 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
14276 Enable some breakpoints.\n\
14277 Give breakpoint numbers (separated by spaces) as arguments.\n\
14278 This is used to cancel the effect of the \"disable\" command.\n\
14279 May be abbreviated to simply \"enable\".\n"),
14280 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
14282 add_cmd ("once", no_class
, enable_once_command
, _("\
14283 Enable breakpoints for one hit. Give breakpoint numbers.\n\
14284 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
14287 add_cmd ("delete", no_class
, enable_delete_command
, _("\
14288 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
14289 If a breakpoint is hit while enabled in this fashion, it is deleted."),
14292 add_cmd ("delete", no_class
, enable_delete_command
, _("\
14293 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
14294 If a breakpoint is hit while enabled in this fashion, it is deleted."),
14297 add_cmd ("once", no_class
, enable_once_command
, _("\
14298 Enable breakpoints for one hit. Give breakpoint numbers.\n\
14299 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
14302 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
14303 Disable some breakpoints.\n\
14304 Arguments are breakpoint numbers with spaces in between.\n\
14305 To disable all breakpoints, give no argument.\n\
14306 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
14307 &disablelist
, "disable ", 1, &cmdlist
);
14308 add_com_alias ("dis", "disable", class_breakpoint
, 1);
14309 add_com_alias ("disa", "disable", class_breakpoint
, 1);
14311 add_com ("sb", class_breakpoint
, disable_command
, _("\
14312 Disable some breakpoints.\n\
14313 Arguments are breakpoint numbers with spaces in between.\n\
14314 To disable all breakpoints, give no argument.\n\
14315 A disabled breakpoint is not forgotten, but has no effect until re-enabled."));
14317 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
14318 Disable some breakpoints.\n\
14319 Arguments are breakpoint numbers with spaces in between.\n\
14320 To disable all breakpoints, give no argument.\n\
14321 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
14322 This command may be abbreviated \"disable\"."),
14325 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
14326 Delete some breakpoints or auto-display expressions.\n\
14327 Arguments are breakpoint numbers with spaces in between.\n\
14328 To delete all breakpoints, give no argument.\n\
14330 Also a prefix command for deletion of other GDB objects.\n\
14331 The \"unset\" command is also an alias for \"delete\"."),
14332 &deletelist
, "delete ", 1, &cmdlist
);
14333 add_com_alias ("d", "delete", class_breakpoint
, 1);
14334 add_com_alias ("del", "delete", class_breakpoint
, 1);
14336 add_com ("db", class_breakpoint
, delete_command
, _("\
14337 Delete some breakpoints.\n\
14338 Arguments are breakpoint numbers with spaces in between.\n\
14339 To delete all breakpoints, give no argument.\n"));
14341 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
14342 Delete some breakpoints or auto-display expressions.\n\
14343 Arguments are breakpoint numbers with spaces in between.\n\
14344 To delete all breakpoints, give no argument.\n\
14345 This command may be abbreviated \"delete\"."),
14348 add_com ("clear", class_breakpoint
, clear_command
, _("\
14349 Clear breakpoint at specified line or function.\n\
14350 Argument may be line number, function name, or \"*\" and an address.\n\
14351 If line number is specified, all breakpoints in that line are cleared.\n\
14352 If function is specified, breakpoints at beginning of function are cleared.\n\
14353 If an address is specified, breakpoints at that address are cleared.\n\
14355 With no argument, clears all breakpoints in the line that the selected frame\n\
14356 is executing in.\n\
14358 See also the \"delete\" command which clears breakpoints by number."));
14359 add_com_alias ("cl", "clear", class_breakpoint
, 1);
14361 c
= add_com ("break", class_breakpoint
, break_command
, _("\
14362 Set breakpoint at specified line or function.\n"
14363 BREAK_ARGS_HELP ("break")));
14364 set_cmd_completer (c
, location_completer
);
14366 add_com_alias ("b", "break", class_run
, 1);
14367 add_com_alias ("br", "break", class_run
, 1);
14368 add_com_alias ("bre", "break", class_run
, 1);
14369 add_com_alias ("brea", "break", class_run
, 1);
14372 add_com_alias ("ba", "break", class_breakpoint
, 1);
14376 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
14377 Break in function/address or break at a line in the current file."),
14378 &stoplist
, "stop ", 1, &cmdlist
);
14379 add_cmd ("in", class_breakpoint
, stopin_command
,
14380 _("Break in function or address."), &stoplist
);
14381 add_cmd ("at", class_breakpoint
, stopat_command
,
14382 _("Break at a line in the current file."), &stoplist
);
14383 add_com ("status", class_info
, breakpoints_info
, _("\
14384 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
14385 The \"Type\" column indicates one of:\n\
14386 \tbreakpoint - normal breakpoint\n\
14387 \twatchpoint - watchpoint\n\
14388 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
14389 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
14390 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
14391 address and file/line number respectively.\n\
14393 Convenience variable \"$_\" and default examine address for \"x\"\n\
14394 are set to the address of the last breakpoint listed unless the command\n\
14395 is prefixed with \"server \".\n\n\
14396 Convenience variable \"$bpnum\" contains the number of the last\n\
14397 breakpoint set."));
14400 add_info ("breakpoints", breakpoints_info
, _("\
14401 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
14402 The \"Type\" column indicates one of:\n\
14403 \tbreakpoint - normal breakpoint\n\
14404 \twatchpoint - watchpoint\n\
14405 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
14406 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
14407 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
14408 address and file/line number respectively.\n\
14410 Convenience variable \"$_\" and default examine address for \"x\"\n\
14411 are set to the address of the last breakpoint listed unless the command\n\
14412 is prefixed with \"server \".\n\n\
14413 Convenience variable \"$bpnum\" contains the number of the last\n\
14414 breakpoint set."));
14416 add_info_alias ("b", "breakpoints", 1);
14419 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
14420 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
14421 The \"Type\" column indicates one of:\n\
14422 \tbreakpoint - normal breakpoint\n\
14423 \twatchpoint - watchpoint\n\
14424 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
14425 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
14426 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
14427 address and file/line number respectively.\n\
14429 Convenience variable \"$_\" and default examine address for \"x\"\n\
14430 are set to the address of the last breakpoint listed unless the command\n\
14431 is prefixed with \"server \".\n\n\
14432 Convenience variable \"$bpnum\" contains the number of the last\n\
14433 breakpoint set."));
14435 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
14436 Status of all breakpoints, or breakpoint number NUMBER.\n\
14437 The \"Type\" column indicates one of:\n\
14438 \tbreakpoint - normal breakpoint\n\
14439 \twatchpoint - watchpoint\n\
14440 \tlongjmp - internal breakpoint used to step through longjmp()\n\
14441 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
14442 \tuntil - internal breakpoint used by the \"until\" command\n\
14443 \tfinish - internal breakpoint used by the \"finish\" command\n\
14444 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
14445 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
14446 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
14447 address and file/line number respectively.\n\
14449 Convenience variable \"$_\" and default examine address for \"x\"\n\
14450 are set to the address of the last breakpoint listed unless the command\n\
14451 is prefixed with \"server \".\n\n\
14452 Convenience variable \"$bpnum\" contains the number of the last\n\
14454 &maintenanceinfolist
);
14456 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
14457 Set catchpoints to catch events."),
14458 &catch_cmdlist
, "catch ",
14459 0/*allow-unknown*/, &cmdlist
);
14461 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
14462 Set temporary catchpoints to catch events."),
14463 &tcatch_cmdlist
, "tcatch ",
14464 0/*allow-unknown*/, &cmdlist
);
14466 /* Add catch and tcatch sub-commands. */
14467 add_catch_command ("catch", _("\
14468 Catch an exception, when caught."),
14469 catch_catch_command
,
14473 add_catch_command ("throw", _("\
14474 Catch an exception, when thrown."),
14475 catch_throw_command
,
14479 add_catch_command ("fork", _("Catch calls to fork."),
14480 catch_fork_command_1
,
14482 (void *) (uintptr_t) catch_fork_permanent
,
14483 (void *) (uintptr_t) catch_fork_temporary
);
14484 add_catch_command ("vfork", _("Catch calls to vfork."),
14485 catch_fork_command_1
,
14487 (void *) (uintptr_t) catch_vfork_permanent
,
14488 (void *) (uintptr_t) catch_vfork_temporary
);
14489 add_catch_command ("exec", _("Catch calls to exec."),
14490 catch_exec_command_1
,
14494 add_catch_command ("load", _("Catch loads of shared libraries.\n\
14495 Usage: catch load [REGEX]\n\
14496 If REGEX is given, only stop for libraries matching the regular expression."),
14497 catch_load_command_1
,
14501 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
14502 Usage: catch unload [REGEX]\n\
14503 If REGEX is given, only stop for libraries matching the regular expression."),
14504 catch_unload_command_1
,
14508 add_catch_command ("syscall", _("\
14509 Catch system calls by their names and/or numbers.\n\
14510 Arguments say which system calls to catch. If no arguments\n\
14511 are given, every system call will be caught.\n\
14512 Arguments, if given, should be one or more system call names\n\
14513 (if your system supports that), or system call numbers."),
14514 catch_syscall_command_1
,
14515 catch_syscall_completer
,
14519 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
14520 Set a watchpoint for an expression.\n\
14521 Usage: watch [-l|-location] EXPRESSION\n\
14522 A watchpoint stops execution of your program whenever the value of\n\
14523 an expression changes.\n\
14524 If -l or -location is given, this evaluates EXPRESSION and watches\n\
14525 the memory to which it refers."));
14526 set_cmd_completer (c
, expression_completer
);
14528 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
14529 Set a read watchpoint for an expression.\n\
14530 Usage: rwatch [-l|-location] EXPRESSION\n\
14531 A watchpoint stops execution of your program whenever the value of\n\
14532 an expression is read.\n\
14533 If -l or -location is given, this evaluates EXPRESSION and watches\n\
14534 the memory to which it refers."));
14535 set_cmd_completer (c
, expression_completer
);
14537 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
14538 Set a watchpoint for an expression.\n\
14539 Usage: awatch [-l|-location] EXPRESSION\n\
14540 A watchpoint stops execution of your program whenever the value of\n\
14541 an expression is either read or written.\n\
14542 If -l or -location is given, this evaluates EXPRESSION and watches\n\
14543 the memory to which it refers."));
14544 set_cmd_completer (c
, expression_completer
);
14546 add_info ("watchpoints", watchpoints_info
, _("\
14547 Status of specified watchpoints (all watchpoints if no argument)."));
14549 /* XXX: cagney/2005-02-23: This should be a boolean, and should
14550 respond to changes - contrary to the description. */
14551 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
14552 &can_use_hw_watchpoints
, _("\
14553 Set debugger's willingness to use watchpoint hardware."), _("\
14554 Show debugger's willingness to use watchpoint hardware."), _("\
14555 If zero, gdb will not use hardware for new watchpoints, even if\n\
14556 such is available. (However, any hardware watchpoints that were\n\
14557 created before setting this to nonzero, will continue to use watchpoint\n\
14560 show_can_use_hw_watchpoints
,
14561 &setlist
, &showlist
);
14563 can_use_hw_watchpoints
= 1;
14565 /* Tracepoint manipulation commands. */
14567 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
14568 Set a tracepoint at specified line or function.\n\
14570 BREAK_ARGS_HELP ("trace") "\n\
14571 Do \"help tracepoints\" for info on other tracepoint commands."));
14572 set_cmd_completer (c
, location_completer
);
14574 add_com_alias ("tp", "trace", class_alias
, 0);
14575 add_com_alias ("tr", "trace", class_alias
, 1);
14576 add_com_alias ("tra", "trace", class_alias
, 1);
14577 add_com_alias ("trac", "trace", class_alias
, 1);
14579 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
14580 Set a fast tracepoint at specified line or function.\n\
14582 BREAK_ARGS_HELP ("ftrace") "\n\
14583 Do \"help tracepoints\" for info on other tracepoint commands."));
14584 set_cmd_completer (c
, location_completer
);
14586 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
14587 Set a static tracepoint at specified line, function or marker.\n\
14589 strace [LOCATION] [if CONDITION]\n\
14590 LOCATION may be a line number, function name, \"*\" and an address,\n\
14591 or -m MARKER_ID.\n\
14592 If a line number is specified, probe the marker at start of code\n\
14593 for that line. If a function is specified, probe the marker at start\n\
14594 of code for that function. If an address is specified, probe the marker\n\
14595 at that exact address. If a marker id is specified, probe the marker\n\
14596 with that name. With no LOCATION, uses current execution address of\n\
14597 the selected stack frame.\n\
14598 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
14599 This collects arbitrary user data passed in the probe point call to the\n\
14600 tracing library. You can inspect it when analyzing the trace buffer,\n\
14601 by printing the $_sdata variable like any other convenience variable.\n\
14603 CONDITION is a boolean expression.\n\
14605 Multiple tracepoints at one place are permitted, and useful if their\n\
14606 conditions are different.\n\
14608 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
14609 Do \"help tracepoints\" for info on other tracepoint commands."));
14610 set_cmd_completer (c
, location_completer
);
14612 add_info ("tracepoints", tracepoints_info
, _("\
14613 Status of specified tracepoints (all tracepoints if no argument).\n\
14614 Convenience variable \"$tpnum\" contains the number of the\n\
14615 last tracepoint set."));
14617 add_info_alias ("tp", "tracepoints", 1);
14619 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
14620 Delete specified tracepoints.\n\
14621 Arguments are tracepoint numbers, separated by spaces.\n\
14622 No argument means delete all tracepoints."),
14625 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
14626 Disable specified tracepoints.\n\
14627 Arguments are tracepoint numbers, separated by spaces.\n\
14628 No argument means disable all tracepoints."),
14630 deprecate_cmd (c
, "disable");
14632 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
14633 Enable specified tracepoints.\n\
14634 Arguments are tracepoint numbers, separated by spaces.\n\
14635 No argument means enable all tracepoints."),
14637 deprecate_cmd (c
, "enable");
14639 add_com ("passcount", class_trace
, trace_pass_command
, _("\
14640 Set the passcount for a tracepoint.\n\
14641 The trace will end when the tracepoint has been passed 'count' times.\n\
14642 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
14643 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
14645 add_prefix_cmd ("save", class_breakpoint
, save_command
,
14646 _("Save breakpoint definitions as a script."),
14647 &save_cmdlist
, "save ",
14648 0/*allow-unknown*/, &cmdlist
);
14650 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
14651 Save current breakpoint definitions as a script.\n\
14652 This includes all types of breakpoints (breakpoints, watchpoints,\n\
14653 catchpoints, tracepoints). Use the 'source' command in another debug\n\
14654 session to restore them."),
14656 set_cmd_completer (c
, filename_completer
);
14658 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
14659 Save current tracepoint definitions as a script.\n\
14660 Use the 'source' command in another debug session to restore them."),
14662 set_cmd_completer (c
, filename_completer
);
14664 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
14665 deprecate_cmd (c
, "save tracepoints");
14667 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
14668 Breakpoint specific settings\n\
14669 Configure various breakpoint-specific variables such as\n\
14670 pending breakpoint behavior"),
14671 &breakpoint_set_cmdlist
, "set breakpoint ",
14672 0/*allow-unknown*/, &setlist
);
14673 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
14674 Breakpoint specific settings\n\
14675 Configure various breakpoint-specific variables such as\n\
14676 pending breakpoint behavior"),
14677 &breakpoint_show_cmdlist
, "show breakpoint ",
14678 0/*allow-unknown*/, &showlist
);
14680 add_setshow_auto_boolean_cmd ("pending", no_class
,
14681 &pending_break_support
, _("\
14682 Set debugger's behavior regarding pending breakpoints."), _("\
14683 Show debugger's behavior regarding pending breakpoints."), _("\
14684 If on, an unrecognized breakpoint location will cause gdb to create a\n\
14685 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
14686 an error. If auto, an unrecognized breakpoint location results in a\n\
14687 user-query to see if a pending breakpoint should be created."),
14689 show_pending_break_support
,
14690 &breakpoint_set_cmdlist
,
14691 &breakpoint_show_cmdlist
);
14693 pending_break_support
= AUTO_BOOLEAN_AUTO
;
14695 add_setshow_boolean_cmd ("auto-hw", no_class
,
14696 &automatic_hardware_breakpoints
, _("\
14697 Set automatic usage of hardware breakpoints."), _("\
14698 Show automatic usage of hardware breakpoints."), _("\
14699 If set, the debugger will automatically use hardware breakpoints for\n\
14700 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
14701 a warning will be emitted for such breakpoints."),
14703 show_automatic_hardware_breakpoints
,
14704 &breakpoint_set_cmdlist
,
14705 &breakpoint_show_cmdlist
);
14707 add_setshow_enum_cmd ("always-inserted", class_support
,
14708 always_inserted_enums
, &always_inserted_mode
, _("\
14709 Set mode for inserting breakpoints."), _("\
14710 Show mode for inserting breakpoints."), _("\
14711 When this mode is off, breakpoints are inserted in inferior when it is\n\
14712 resumed, and removed when execution stops. When this mode is on,\n\
14713 breakpoints are inserted immediately and removed only when the user\n\
14714 deletes the breakpoint. When this mode is auto (which is the default),\n\
14715 the behaviour depends on the non-stop setting (see help set non-stop).\n\
14716 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
14717 behaves as if always-inserted mode is on; if gdb is controlling the\n\
14718 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
14720 &show_always_inserted_mode
,
14721 &breakpoint_set_cmdlist
,
14722 &breakpoint_show_cmdlist
);
14724 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
14725 Set a breakpoint for an address range.\n\
14726 break-range START-LOCATION, END-LOCATION\n\
14727 where START-LOCATION and END-LOCATION can be one of the following:\n\
14728 LINENUM, for that line in the current file,\n\
14729 FILE:LINENUM, for that line in that file,\n\
14730 +OFFSET, for that number of lines after the current line\n\
14731 or the start of the range\n\
14732 FUNCTION, for the first line in that function,\n\
14733 FILE:FUNCTION, to distinguish among like-named static functions.\n\
14734 *ADDRESS, for the instruction at that address.\n\
14736 The breakpoint will stop execution of the inferior whenever it executes\n\
14737 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
14738 range (including START-LOCATION and END-LOCATION)."));
14740 automatic_hardware_breakpoints
= 1;
14742 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);