1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "breakpoint.h"
29 #include "tracepoint.h"
31 #include "expression.h"
37 #include "gdbthread.h"
40 #include "gdb_string.h"
42 #include "filenames.h"
48 #include "completer.h"
51 #include "cli/cli-script.h"
52 #include "gdb_assert.h"
57 #include "exceptions.h"
64 #include "xml-syscall.h"
65 #include "parser-defs.h"
66 #include "cli/cli-utils.h"
67 #include "continuations.h"
69 /* readline include files */
70 #include "readline/readline.h"
71 #include "readline/history.h"
73 /* readline defines this. */
76 #include "mi/mi-common.h"
77 #include "python/python.h"
79 /* Prototypes for local functions. */
81 static void enable_delete_command (char *, int);
83 static void enable_once_command (char *, int);
85 static void disable_command (char *, int);
87 static void enable_command (char *, int);
89 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint
*,
93 static void ignore_command (char *, int);
95 static int breakpoint_re_set_one (void *);
97 static void breakpoint_re_set_default (struct breakpoint
*);
99 static void clear_command (char *, int);
101 static void catch_command (char *, int);
103 static int can_use_hardware_watchpoint (struct value
*);
105 static void break_command_1 (char *, int, int);
107 static void mention (struct breakpoint
*);
109 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
111 const struct breakpoint_ops
*);
112 /* This function is used in gdbtk sources and thus can not be made
114 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
115 struct symtab_and_line
,
117 const struct breakpoint_ops
*);
119 static struct breakpoint
*
120 momentary_breakpoint_from_master (struct breakpoint
*orig
,
122 const struct breakpoint_ops
*ops
);
124 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
126 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
130 static void describe_other_breakpoints (struct gdbarch
*,
131 struct program_space
*, CORE_ADDR
,
132 struct obj_section
*, int);
134 static int breakpoint_address_match (struct address_space
*aspace1
,
136 struct address_space
*aspace2
,
139 static int watchpoint_locations_match (struct bp_location
*loc1
,
140 struct bp_location
*loc2
);
142 static int breakpoint_location_address_match (struct bp_location
*bl
,
143 struct address_space
*aspace
,
146 static void breakpoints_info (char *, int);
148 static void watchpoints_info (char *, int);
150 static int breakpoint_1 (char *, int,
151 int (*) (const struct breakpoint
*));
153 static int breakpoint_cond_eval (void *);
155 static void cleanup_executing_breakpoints (void *);
157 static void commands_command (char *, int);
159 static void condition_command (char *, int);
168 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
169 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
171 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
173 static int watchpoint_check (void *);
175 static void maintenance_info_breakpoints (char *, int);
177 static int hw_breakpoint_used_count (void);
179 static int hw_watchpoint_used_count (enum bptype
, int *);
181 static void hbreak_command (char *, int);
183 static void thbreak_command (char *, int);
185 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
);
187 static void stop_command (char *arg
, int from_tty
);
189 static void stopin_command (char *arg
, int from_tty
);
191 static void stopat_command (char *arg
, int from_tty
);
193 static char *ep_parse_optional_if_clause (char **arg
);
195 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
196 char *arg
, int tempflag
, int from_tty
);
198 static void tcatch_command (char *arg
, int from_tty
);
200 static void detach_single_step_breakpoints (void);
202 static int single_step_breakpoint_inserted_here_p (struct address_space
*,
205 static void free_bp_location (struct bp_location
*loc
);
206 static void incref_bp_location (struct bp_location
*loc
);
207 static void decref_bp_location (struct bp_location
**loc
);
209 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
211 static void update_global_location_list (int);
213 static void update_global_location_list_nothrow (int);
215 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
217 static void insert_breakpoint_locations (void);
219 static int syscall_catchpoint_p (struct breakpoint
*b
);
221 static void tracepoints_info (char *, int);
223 static void delete_trace_command (char *, int);
225 static void enable_trace_command (char *, int);
227 static void disable_trace_command (char *, int);
229 static void trace_pass_command (char *, int);
231 static int is_masked_watchpoint (const struct breakpoint
*b
);
233 /* Assuming we're creating a static tracepoint, does S look like a
234 static tracepoint marker spec ("-m MARKER_ID")? */
235 #define is_marker_spec(s) \
236 (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
238 /* The abstract base class all breakpoint_ops structures inherit
240 static struct breakpoint_ops base_breakpoint_ops
;
242 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
243 that are implemented on top of software or hardware breakpoints
244 (user breakpoints, internal and momentary breakpoints, etc.). */
245 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
247 /* Internal breakpoints class type. */
248 static struct breakpoint_ops internal_breakpoint_ops
;
250 /* Momentary breakpoints class type. */
251 static struct breakpoint_ops momentary_breakpoint_ops
;
253 /* The breakpoint_ops structure to be used in regular user created
255 struct breakpoint_ops bkpt_breakpoint_ops
;
257 /* A reference-counted struct command_line. This lets multiple
258 breakpoints share a single command list. */
259 struct counted_command_line
261 /* The reference count. */
264 /* The command list. */
265 struct command_line
*commands
;
268 struct command_line
*
269 breakpoint_commands (struct breakpoint
*b
)
271 return b
->commands
? b
->commands
->commands
: NULL
;
274 /* Flag indicating that a command has proceeded the inferior past the
275 current breakpoint. */
277 static int breakpoint_proceeded
;
280 bpdisp_text (enum bpdisp disp
)
282 /* NOTE: the following values are a part of MI protocol and
283 represent values of 'disp' field returned when inferior stops at
285 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
287 return bpdisps
[(int) disp
];
290 /* Prototypes for exported functions. */
291 /* If FALSE, gdb will not use hardware support for watchpoints, even
292 if such is available. */
293 static int can_use_hw_watchpoints
;
296 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
297 struct cmd_list_element
*c
,
300 fprintf_filtered (file
,
301 _("Debugger's willingness to use "
302 "watchpoint hardware is %s.\n"),
306 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
307 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
308 for unrecognized breakpoint locations.
309 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
310 static enum auto_boolean pending_break_support
;
312 show_pending_break_support (struct ui_file
*file
, int from_tty
,
313 struct cmd_list_element
*c
,
316 fprintf_filtered (file
,
317 _("Debugger's behavior regarding "
318 "pending breakpoints is %s.\n"),
322 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
323 set with "break" but falling in read-only memory.
324 If 0, gdb will warn about such breakpoints, but won't automatically
325 use hardware breakpoints. */
326 static int automatic_hardware_breakpoints
;
328 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
329 struct cmd_list_element
*c
,
332 fprintf_filtered (file
,
333 _("Automatic usage of hardware breakpoints is %s.\n"),
337 /* If on, gdb will keep breakpoints inserted even as inferior is
338 stopped, and immediately insert any new breakpoints. If off, gdb
339 will insert breakpoints into inferior only when resuming it, and
340 will remove breakpoints upon stop. If auto, GDB will behave as ON
341 if in non-stop mode, and as OFF if all-stop mode.*/
343 static const char always_inserted_auto
[] = "auto";
344 static const char always_inserted_on
[] = "on";
345 static const char always_inserted_off
[] = "off";
346 static const char *always_inserted_enums
[] = {
347 always_inserted_auto
,
352 static const char *always_inserted_mode
= always_inserted_auto
;
354 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
355 struct cmd_list_element
*c
, const char *value
)
357 if (always_inserted_mode
== always_inserted_auto
)
358 fprintf_filtered (file
,
359 _("Always inserted breakpoint "
360 "mode is %s (currently %s).\n"),
362 breakpoints_always_inserted_mode () ? "on" : "off");
364 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
369 breakpoints_always_inserted_mode (void)
371 return (always_inserted_mode
== always_inserted_on
372 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
375 void _initialize_breakpoint (void);
377 /* Are we executing breakpoint commands? */
378 static int executing_breakpoint_commands
;
380 /* Are overlay event breakpoints enabled? */
381 static int overlay_events_enabled
;
383 /* See description in breakpoint.h. */
384 int target_exact_watchpoints
= 0;
386 /* Walk the following statement or block through all breakpoints.
387 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
388 current breakpoint. */
390 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
392 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
393 for (B = breakpoint_chain; \
394 B ? (TMP=B->next, 1): 0; \
397 /* Similar iterator for the low-level breakpoints. SAFE variant is
398 not provided so update_global_location_list must not be called
399 while executing the block of ALL_BP_LOCATIONS. */
401 #define ALL_BP_LOCATIONS(B,BP_TMP) \
402 for (BP_TMP = bp_location; \
403 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
406 /* Iterator for tracepoints only. */
408 #define ALL_TRACEPOINTS(B) \
409 for (B = breakpoint_chain; B; B = B->next) \
410 if (is_tracepoint (B))
412 /* Chains of all breakpoints defined. */
414 struct breakpoint
*breakpoint_chain
;
416 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
418 static struct bp_location
**bp_location
;
420 /* Number of elements of BP_LOCATION. */
422 static unsigned bp_location_count
;
424 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
425 ADDRESS for the current elements of BP_LOCATION which get a valid
426 result from bp_location_has_shadow. You can use it for roughly
427 limiting the subrange of BP_LOCATION to scan for shadow bytes for
428 an address you need to read. */
430 static CORE_ADDR bp_location_placed_address_before_address_max
;
432 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
433 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
434 BP_LOCATION which get a valid result from bp_location_has_shadow.
435 You can use it for roughly limiting the subrange of BP_LOCATION to
436 scan for shadow bytes for an address you need to read. */
438 static CORE_ADDR bp_location_shadow_len_after_address_max
;
440 /* The locations that no longer correspond to any breakpoint, unlinked
441 from bp_location array, but for which a hit may still be reported
443 VEC(bp_location_p
) *moribund_locations
= NULL
;
445 /* Number of last breakpoint made. */
447 static int breakpoint_count
;
449 /* The value of `breakpoint_count' before the last command that
450 created breakpoints. If the last (break-like) command created more
451 than one breakpoint, then the difference between BREAKPOINT_COUNT
452 and PREV_BREAKPOINT_COUNT is more than one. */
453 static int prev_breakpoint_count
;
455 /* Number of last tracepoint made. */
457 static int tracepoint_count
;
459 static struct cmd_list_element
*breakpoint_set_cmdlist
;
460 static struct cmd_list_element
*breakpoint_show_cmdlist
;
461 struct cmd_list_element
*save_cmdlist
;
463 /* Return whether a breakpoint is an active enabled breakpoint. */
465 breakpoint_enabled (struct breakpoint
*b
)
467 return (b
->enable_state
== bp_enabled
);
470 /* Set breakpoint count to NUM. */
473 set_breakpoint_count (int num
)
475 prev_breakpoint_count
= breakpoint_count
;
476 breakpoint_count
= num
;
477 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
480 /* Used by `start_rbreak_breakpoints' below, to record the current
481 breakpoint count before "rbreak" creates any breakpoint. */
482 static int rbreak_start_breakpoint_count
;
484 /* Called at the start an "rbreak" command to record the first
488 start_rbreak_breakpoints (void)
490 rbreak_start_breakpoint_count
= breakpoint_count
;
493 /* Called at the end of an "rbreak" command to record the last
497 end_rbreak_breakpoints (void)
499 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
502 /* Used in run_command to zero the hit count when a new run starts. */
505 clear_breakpoint_hit_counts (void)
507 struct breakpoint
*b
;
513 /* Allocate a new counted_command_line with reference count of 1.
514 The new structure owns COMMANDS. */
516 static struct counted_command_line
*
517 alloc_counted_command_line (struct command_line
*commands
)
519 struct counted_command_line
*result
520 = xmalloc (sizeof (struct counted_command_line
));
523 result
->commands
= commands
;
527 /* Increment reference count. This does nothing if CMD is NULL. */
530 incref_counted_command_line (struct counted_command_line
*cmd
)
536 /* Decrement reference count. If the reference count reaches 0,
537 destroy the counted_command_line. Sets *CMDP to NULL. This does
538 nothing if *CMDP is NULL. */
541 decref_counted_command_line (struct counted_command_line
**cmdp
)
545 if (--(*cmdp
)->refc
== 0)
547 free_command_lines (&(*cmdp
)->commands
);
554 /* A cleanup function that calls decref_counted_command_line. */
557 do_cleanup_counted_command_line (void *arg
)
559 decref_counted_command_line (arg
);
562 /* Create a cleanup that calls decref_counted_command_line on the
565 static struct cleanup
*
566 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
568 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
571 /* Default address, symtab and line to put a breakpoint at
572 for "break" command with no arg.
573 If default_breakpoint_valid is zero, the other three are
574 not valid, and "break" with no arg is an error.
576 This set by print_stack_frame, which calls set_default_breakpoint. */
578 int default_breakpoint_valid
;
579 CORE_ADDR default_breakpoint_address
;
580 struct symtab
*default_breakpoint_symtab
;
581 int default_breakpoint_line
;
582 struct program_space
*default_breakpoint_pspace
;
585 /* Return the breakpoint with the specified number, or NULL
586 if the number does not refer to an existing breakpoint. */
589 get_breakpoint (int num
)
591 struct breakpoint
*b
;
594 if (b
->number
== num
)
603 set_breakpoint_condition (struct breakpoint
*b
, char *exp
,
606 xfree (b
->cond_string
);
607 b
->cond_string
= NULL
;
609 if (is_watchpoint (b
))
611 struct watchpoint
*w
= (struct watchpoint
*) b
;
618 struct bp_location
*loc
;
620 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
630 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
636 /* I don't know if it matters whether this is the string the user
637 typed in or the decompiled expression. */
638 b
->cond_string
= xstrdup (arg
);
639 b
->condition_not_parsed
= 0;
641 if (is_watchpoint (b
))
643 struct watchpoint
*w
= (struct watchpoint
*) b
;
645 innermost_block
= NULL
;
647 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0);
649 error (_("Junk at end of expression"));
650 w
->cond_exp_valid_block
= innermost_block
;
654 struct bp_location
*loc
;
656 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
660 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
662 error (_("Junk at end of expression"));
666 breakpoints_changed ();
667 observer_notify_breakpoint_modified (b
);
670 /* condition N EXP -- set break condition of breakpoint N to EXP. */
673 condition_command (char *arg
, int from_tty
)
675 struct breakpoint
*b
;
680 error_no_arg (_("breakpoint number"));
683 bnum
= get_number (&p
);
685 error (_("Bad breakpoint argument: '%s'"), arg
);
688 if (b
->number
== bnum
)
690 /* Check if this breakpoint has a Python object assigned to
691 it, and if it has a definition of the "stop"
692 method. This method and conditions entered into GDB from
693 the CLI are mutually exclusive. */
695 && gdbpy_breakpoint_has_py_cond (b
->py_bp_object
))
696 error (_("Cannot set a condition where a Python 'stop' "
697 "method has been defined in the breakpoint."));
698 set_breakpoint_condition (b
, p
, from_tty
);
702 error (_("No breakpoint number %d."), bnum
);
705 /* Check that COMMAND do not contain commands that are suitable
706 only for tracepoints and not suitable for ordinary breakpoints.
707 Throw if any such commands is found. */
710 check_no_tracepoint_commands (struct command_line
*commands
)
712 struct command_line
*c
;
714 for (c
= commands
; c
; c
= c
->next
)
718 if (c
->control_type
== while_stepping_control
)
719 error (_("The 'while-stepping' command can "
720 "only be used for tracepoints"));
722 for (i
= 0; i
< c
->body_count
; ++i
)
723 check_no_tracepoint_commands ((c
->body_list
)[i
]);
725 /* Not that command parsing removes leading whitespace and comment
726 lines and also empty lines. So, we only need to check for
728 if (strstr (c
->line
, "collect ") == c
->line
)
729 error (_("The 'collect' command can only be used for tracepoints"));
731 if (strstr (c
->line
, "teval ") == c
->line
)
732 error (_("The 'teval' command can only be used for tracepoints"));
736 /* Encapsulate tests for different types of tracepoints. */
739 is_tracepoint_type (enum bptype type
)
741 return (type
== bp_tracepoint
742 || type
== bp_fast_tracepoint
743 || type
== bp_static_tracepoint
);
747 is_tracepoint (const struct breakpoint
*b
)
749 return is_tracepoint_type (b
->type
);
752 /* A helper function that validates that COMMANDS are valid for a
753 breakpoint. This function will throw an exception if a problem is
757 validate_commands_for_breakpoint (struct breakpoint
*b
,
758 struct command_line
*commands
)
760 if (is_tracepoint (b
))
762 /* We need to verify that each top-level element of commands is
763 valid for tracepoints, that there's at most one
764 while-stepping element, and that while-stepping's body has
765 valid tracing commands excluding nested while-stepping. */
766 struct command_line
*c
;
767 struct command_line
*while_stepping
= 0;
768 for (c
= commands
; c
; c
= c
->next
)
770 if (c
->control_type
== while_stepping_control
)
772 if (b
->type
== bp_fast_tracepoint
)
773 error (_("The 'while-stepping' command "
774 "cannot be used for fast tracepoint"));
775 else if (b
->type
== bp_static_tracepoint
)
776 error (_("The 'while-stepping' command "
777 "cannot be used for static tracepoint"));
780 error (_("The 'while-stepping' command "
781 "can be used only once"));
788 struct command_line
*c2
;
790 gdb_assert (while_stepping
->body_count
== 1);
791 c2
= while_stepping
->body_list
[0];
792 for (; c2
; c2
= c2
->next
)
794 if (c2
->control_type
== while_stepping_control
)
795 error (_("The 'while-stepping' command cannot be nested"));
801 check_no_tracepoint_commands (commands
);
805 /* Return a vector of all the static tracepoints set at ADDR. The
806 caller is responsible for releasing the vector. */
809 static_tracepoints_here (CORE_ADDR addr
)
811 struct breakpoint
*b
;
812 VEC(breakpoint_p
) *found
= 0;
813 struct bp_location
*loc
;
816 if (b
->type
== bp_static_tracepoint
)
818 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
819 if (loc
->address
== addr
)
820 VEC_safe_push(breakpoint_p
, found
, b
);
826 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
827 validate that only allowed commands are included. */
830 breakpoint_set_commands (struct breakpoint
*b
,
831 struct command_line
*commands
)
833 validate_commands_for_breakpoint (b
, commands
);
835 decref_counted_command_line (&b
->commands
);
836 b
->commands
= alloc_counted_command_line (commands
);
837 breakpoints_changed ();
838 observer_notify_breakpoint_modified (b
);
841 /* Set the internal `silent' flag on the breakpoint. Note that this
842 is not the same as the "silent" that may appear in the breakpoint's
846 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
848 int old_silent
= b
->silent
;
851 if (old_silent
!= silent
)
852 observer_notify_breakpoint_modified (b
);
855 /* Set the thread for this breakpoint. If THREAD is -1, make the
856 breakpoint work for any thread. */
859 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
861 int old_thread
= b
->thread
;
864 if (old_thread
!= thread
)
865 observer_notify_breakpoint_modified (b
);
868 /* Set the task for this breakpoint. If TASK is 0, make the
869 breakpoint work for any task. */
872 breakpoint_set_task (struct breakpoint
*b
, int task
)
874 int old_task
= b
->task
;
877 if (old_task
!= task
)
878 observer_notify_breakpoint_modified (b
);
882 check_tracepoint_command (char *line
, void *closure
)
884 struct breakpoint
*b
= closure
;
886 validate_actionline (&line
, b
);
889 /* A structure used to pass information through
890 map_breakpoint_numbers. */
894 /* True if the command was typed at a tty. */
897 /* The breakpoint range spec. */
900 /* Non-NULL if the body of the commands are being read from this
901 already-parsed command. */
902 struct command_line
*control
;
904 /* The command lines read from the user, or NULL if they have not
906 struct counted_command_line
*cmd
;
909 /* A callback for map_breakpoint_numbers that sets the commands for
913 do_map_commands_command (struct breakpoint
*b
, void *data
)
915 struct commands_info
*info
= data
;
917 if (info
->cmd
== NULL
)
919 struct command_line
*l
;
921 if (info
->control
!= NULL
)
922 l
= copy_command_lines (info
->control
->body_list
[0]);
925 struct cleanup
*old_chain
;
928 str
= xstrprintf (_("Type commands for breakpoint(s) "
929 "%s, one per line."),
932 old_chain
= make_cleanup (xfree
, str
);
934 l
= read_command_lines (str
,
937 ? check_tracepoint_command
: 0),
940 do_cleanups (old_chain
);
943 info
->cmd
= alloc_counted_command_line (l
);
946 /* If a breakpoint was on the list more than once, we don't need to
948 if (b
->commands
!= info
->cmd
)
950 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
951 incref_counted_command_line (info
->cmd
);
952 decref_counted_command_line (&b
->commands
);
953 b
->commands
= info
->cmd
;
954 breakpoints_changed ();
955 observer_notify_breakpoint_modified (b
);
960 commands_command_1 (char *arg
, int from_tty
,
961 struct command_line
*control
)
963 struct cleanup
*cleanups
;
964 struct commands_info info
;
966 info
.from_tty
= from_tty
;
967 info
.control
= control
;
969 /* If we read command lines from the user, then `info' will hold an
970 extra reference to the commands that we must clean up. */
971 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
973 if (arg
== NULL
|| !*arg
)
975 if (breakpoint_count
- prev_breakpoint_count
> 1)
976 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1,
978 else if (breakpoint_count
> 0)
979 arg
= xstrprintf ("%d", breakpoint_count
);
982 /* So that we don't try to free the incoming non-NULL
983 argument in the cleanup below. Mapping breakpoint
984 numbers will fail in this case. */
989 /* The command loop has some static state, so we need to preserve
994 make_cleanup (xfree
, arg
);
998 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
1000 if (info
.cmd
== NULL
)
1001 error (_("No breakpoints specified."));
1003 do_cleanups (cleanups
);
1007 commands_command (char *arg
, int from_tty
)
1009 commands_command_1 (arg
, from_tty
, NULL
);
1012 /* Like commands_command, but instead of reading the commands from
1013 input stream, takes them from an already parsed command structure.
1015 This is used by cli-script.c to DTRT with breakpoint commands
1016 that are part of if and while bodies. */
1017 enum command_control_type
1018 commands_from_control_command (char *arg
, struct command_line
*cmd
)
1020 commands_command_1 (arg
, 0, cmd
);
1021 return simple_control
;
1024 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1027 bp_location_has_shadow (struct bp_location
*bl
)
1029 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1033 if (bl
->target_info
.shadow_len
== 0)
1034 /* BL isn't valid, or doesn't shadow memory. */
1039 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1040 by replacing any memory breakpoints with their shadowed contents.
1042 The range of shadowed area by each bp_location is:
1043 bl->address - bp_location_placed_address_before_address_max
1044 up to bl->address + bp_location_shadow_len_after_address_max
1045 The range we were requested to resolve shadows for is:
1046 memaddr ... memaddr + len
1047 Thus the safe cutoff boundaries for performance optimization are
1048 memaddr + len <= (bl->address
1049 - bp_location_placed_address_before_address_max)
1051 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1054 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
1056 /* Left boundary, right boundary and median element of our binary
1058 unsigned bc_l
, bc_r
, bc
;
1060 /* Find BC_L which is a leftmost element which may affect BUF
1061 content. It is safe to report lower value but a failure to
1062 report higher one. */
1065 bc_r
= bp_location_count
;
1066 while (bc_l
+ 1 < bc_r
)
1068 struct bp_location
*bl
;
1070 bc
= (bc_l
+ bc_r
) / 2;
1071 bl
= bp_location
[bc
];
1073 /* Check first BL->ADDRESS will not overflow due to the added
1074 constant. Then advance the left boundary only if we are sure
1075 the BC element can in no way affect the BUF content (MEMADDR
1076 to MEMADDR + LEN range).
1078 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1079 offset so that we cannot miss a breakpoint with its shadow
1080 range tail still reaching MEMADDR. */
1082 if ((bl
->address
+ bp_location_shadow_len_after_address_max
1084 && (bl
->address
+ bp_location_shadow_len_after_address_max
1091 /* Due to the binary search above, we need to make sure we pick the
1092 first location that's at BC_L's address. E.g., if there are
1093 multiple locations at the same address, BC_L may end up pointing
1094 at a duplicate location, and miss the "master"/"inserted"
1095 location. Say, given locations L1, L2 and L3 at addresses A and
1098 L1@A, L2@A, L3@B, ...
1100 BC_L could end up pointing at location L2, while the "master"
1101 location could be L1. Since the `loc->inserted' flag is only set
1102 on "master" locations, we'd forget to restore the shadow of L1
1105 && bp_location
[bc_l
]->address
== bp_location
[bc_l
- 1]->address
)
1108 /* Now do full processing of the found relevant range of elements. */
1110 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1112 struct bp_location
*bl
= bp_location
[bc
];
1113 CORE_ADDR bp_addr
= 0;
1117 /* bp_location array has BL->OWNER always non-NULL. */
1118 if (bl
->owner
->type
== bp_none
)
1119 warning (_("reading through apparently deleted breakpoint #%d?"),
1122 /* Performance optimization: any further element can no longer affect BUF
1125 if (bl
->address
>= bp_location_placed_address_before_address_max
1126 && memaddr
+ len
<= (bl
->address
1127 - bp_location_placed_address_before_address_max
))
1130 if (!bp_location_has_shadow (bl
))
1132 if (!breakpoint_address_match (bl
->target_info
.placed_address_space
, 0,
1133 current_program_space
->aspace
, 0))
1136 /* Addresses and length of the part of the breakpoint that
1138 bp_addr
= bl
->target_info
.placed_address
;
1139 bp_size
= bl
->target_info
.shadow_len
;
1141 if (bp_addr
+ bp_size
<= memaddr
)
1142 /* The breakpoint is entirely before the chunk of memory we
1146 if (bp_addr
>= memaddr
+ len
)
1147 /* The breakpoint is entirely after the chunk of memory we are
1151 /* Offset within shadow_contents. */
1152 if (bp_addr
< memaddr
)
1154 /* Only copy the second part of the breakpoint. */
1155 bp_size
-= memaddr
- bp_addr
;
1156 bptoffset
= memaddr
- bp_addr
;
1160 if (bp_addr
+ bp_size
> memaddr
+ len
)
1162 /* Only copy the first part of the breakpoint. */
1163 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1166 memcpy (buf
+ bp_addr
- memaddr
,
1167 bl
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
1172 /* Return true if BPT is of any hardware watchpoint kind. */
1175 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1177 return (bpt
->type
== bp_hardware_watchpoint
1178 || bpt
->type
== bp_read_watchpoint
1179 || bpt
->type
== bp_access_watchpoint
);
1182 /* Return true if BPT is of any watchpoint kind, hardware or
1186 is_watchpoint (const struct breakpoint
*bpt
)
1188 return (is_hardware_watchpoint (bpt
)
1189 || bpt
->type
== bp_watchpoint
);
1192 /* Returns true if the current thread and its running state are safe
1193 to evaluate or update watchpoint B. Watchpoints on local
1194 expressions need to be evaluated in the context of the thread that
1195 was current when the watchpoint was created, and, that thread needs
1196 to be stopped to be able to select the correct frame context.
1197 Watchpoints on global expressions can be evaluated on any thread,
1198 and in any state. It is presently left to the target allowing
1199 memory accesses when threads are running. */
1202 watchpoint_in_thread_scope (struct watchpoint
*b
)
1204 return (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1205 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1206 && !is_executing (inferior_ptid
)));
1209 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1210 associated bp_watchpoint_scope breakpoint. */
1213 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1215 struct breakpoint
*b
= &w
->base
;
1217 if (b
->related_breakpoint
!= b
)
1219 gdb_assert (b
->related_breakpoint
->type
== bp_watchpoint_scope
);
1220 gdb_assert (b
->related_breakpoint
->related_breakpoint
== b
);
1221 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1222 b
->related_breakpoint
->related_breakpoint
= b
->related_breakpoint
;
1223 b
->related_breakpoint
= b
;
1225 b
->disposition
= disp_del_at_next_stop
;
1228 /* Assuming that B is a watchpoint:
1229 - Reparse watchpoint expression, if REPARSE is non-zero
1230 - Evaluate expression and store the result in B->val
1231 - Evaluate the condition if there is one, and store the result
1233 - Update the list of values that must be watched in B->loc.
1235 If the watchpoint disposition is disp_del_at_next_stop, then do
1236 nothing. If this is local watchpoint that is out of scope, delete
1239 Even with `set breakpoint always-inserted on' the watchpoints are
1240 removed + inserted on each stop here. Normal breakpoints must
1241 never be removed because they might be missed by a running thread
1242 when debugging in non-stop mode. On the other hand, hardware
1243 watchpoints (is_hardware_watchpoint; processed here) are specific
1244 to each LWP since they are stored in each LWP's hardware debug
1245 registers. Therefore, such LWP must be stopped first in order to
1246 be able to modify its hardware watchpoints.
1248 Hardware watchpoints must be reset exactly once after being
1249 presented to the user. It cannot be done sooner, because it would
1250 reset the data used to present the watchpoint hit to the user. And
1251 it must not be done later because it could display the same single
1252 watchpoint hit during multiple GDB stops. Note that the latter is
1253 relevant only to the hardware watchpoint types bp_read_watchpoint
1254 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1255 not user-visible - its hit is suppressed if the memory content has
1258 The following constraints influence the location where we can reset
1259 hardware watchpoints:
1261 * target_stopped_by_watchpoint and target_stopped_data_address are
1262 called several times when GDB stops.
1265 * Multiple hardware watchpoints can be hit at the same time,
1266 causing GDB to stop. GDB only presents one hardware watchpoint
1267 hit at a time as the reason for stopping, and all the other hits
1268 are presented later, one after the other, each time the user
1269 requests the execution to be resumed. Execution is not resumed
1270 for the threads still having pending hit event stored in
1271 LWP_INFO->STATUS. While the watchpoint is already removed from
1272 the inferior on the first stop the thread hit event is kept being
1273 reported from its cached value by linux_nat_stopped_data_address
1274 until the real thread resume happens after the watchpoint gets
1275 presented and thus its LWP_INFO->STATUS gets reset.
1277 Therefore the hardware watchpoint hit can get safely reset on the
1278 watchpoint removal from inferior. */
1281 update_watchpoint (struct watchpoint
*b
, int reparse
)
1283 int within_current_scope
;
1284 struct frame_id saved_frame_id
;
1287 /* If this is a local watchpoint, we only want to check if the
1288 watchpoint frame is in scope if the current thread is the thread
1289 that was used to create the watchpoint. */
1290 if (!watchpoint_in_thread_scope (b
))
1293 if (b
->base
.disposition
== disp_del_at_next_stop
)
1298 /* Determine if the watchpoint is within scope. */
1299 if (b
->exp_valid_block
== NULL
)
1300 within_current_scope
= 1;
1303 struct frame_info
*fi
= get_current_frame ();
1304 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1305 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1307 /* If we're in a function epilogue, unwinding may not work
1308 properly, so do not attempt to recreate locations at this
1309 point. See similar comments in watchpoint_check. */
1310 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
1313 /* Save the current frame's ID so we can restore it after
1314 evaluating the watchpoint expression on its own frame. */
1315 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1316 took a frame parameter, so that we didn't have to change the
1319 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1321 fi
= frame_find_by_id (b
->watchpoint_frame
);
1322 within_current_scope
= (fi
!= NULL
);
1323 if (within_current_scope
)
1327 /* We don't free locations. They are stored in the bp_location array
1328 and update_global_location_list will eventually delete them and
1329 remove breakpoints if needed. */
1332 if (within_current_scope
&& reparse
)
1341 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1342 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1343 /* If the meaning of expression itself changed, the old value is
1344 no longer relevant. We don't want to report a watchpoint hit
1345 to the user when the old value and the new value may actually
1346 be completely different objects. */
1347 value_free (b
->val
);
1351 /* Note that unlike with breakpoints, the watchpoint's condition
1352 expression is stored in the breakpoint object, not in the
1353 locations (re)created below. */
1354 if (b
->base
.cond_string
!= NULL
)
1356 if (b
->cond_exp
!= NULL
)
1358 xfree (b
->cond_exp
);
1362 s
= b
->base
.cond_string
;
1363 b
->cond_exp
= parse_exp_1 (&s
, b
->cond_exp_valid_block
, 0);
1367 /* If we failed to parse the expression, for example because
1368 it refers to a global variable in a not-yet-loaded shared library,
1369 don't try to insert watchpoint. We don't automatically delete
1370 such watchpoint, though, since failure to parse expression
1371 is different from out-of-scope watchpoint. */
1372 if ( !target_has_execution
)
1374 /* Without execution, memory can't change. No use to try and
1375 set watchpoint locations. The watchpoint will be reset when
1376 the target gains execution, through breakpoint_re_set. */
1378 else if (within_current_scope
&& b
->exp
)
1381 struct value
*val_chain
, *v
, *result
, *next
;
1382 struct program_space
*frame_pspace
;
1384 fetch_subexp_value (b
->exp
, &pc
, &v
, &result
, &val_chain
);
1386 /* Avoid setting b->val if it's already set. The meaning of
1387 b->val is 'the last value' user saw, and we should update
1388 it only if we reported that last value to user. As it
1389 happens, the code that reports it updates b->val directly.
1390 We don't keep track of the memory value for masked
1392 if (!b
->val_valid
&& !is_masked_watchpoint (&b
->base
))
1398 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1400 /* Look at each value on the value chain. */
1401 for (v
= val_chain
; v
; v
= value_next (v
))
1403 /* If it's a memory location, and GDB actually needed
1404 its contents to evaluate the expression, then we
1405 must watch it. If the first value returned is
1406 still lazy, that means an error occurred reading it;
1407 watch it anyway in case it becomes readable. */
1408 if (VALUE_LVAL (v
) == lval_memory
1409 && (v
== val_chain
|| ! value_lazy (v
)))
1411 struct type
*vtype
= check_typedef (value_type (v
));
1413 /* We only watch structs and arrays if user asked
1414 for it explicitly, never if they just happen to
1415 appear in the middle of some value chain. */
1417 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1418 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1422 struct bp_location
*loc
, **tmp
;
1424 addr
= value_address (v
);
1425 len
= TYPE_LENGTH (value_type (v
));
1427 if (b
->base
.type
== bp_read_watchpoint
)
1429 else if (b
->base
.type
== bp_access_watchpoint
)
1432 loc
= allocate_bp_location (&b
->base
);
1433 for (tmp
= &(b
->base
.loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1436 loc
->gdbarch
= get_type_arch (value_type (v
));
1438 loc
->pspace
= frame_pspace
;
1439 loc
->address
= addr
;
1441 loc
->watchpoint_type
= type
;
1446 /* Change the type of breakpoint between hardware assisted or
1447 an ordinary watchpoint depending on the hardware support
1448 and free hardware slots. REPARSE is set when the inferior
1453 enum bp_loc_type loc_type
;
1454 struct bp_location
*bl
;
1456 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
1460 int i
, target_resources_ok
, other_type_used
;
1462 /* Use an exact watchpoint when there's only one memory region to be
1463 watched, and only one debug register is needed to watch it. */
1464 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
1466 /* We need to determine how many resources are already
1467 used for all other hardware watchpoints plus this one
1468 to see if we still have enough resources to also fit
1469 this watchpoint in as well. To guarantee the
1470 hw_watchpoint_used_count call below counts this
1471 watchpoint, make sure that it is marked as a hardware
1473 if (b
->base
.type
== bp_watchpoint
)
1474 b
->base
.type
= bp_hardware_watchpoint
;
1476 i
= hw_watchpoint_used_count (b
->base
.type
, &other_type_used
);
1477 target_resources_ok
= target_can_use_hardware_watchpoint
1478 (b
->base
.type
, i
, other_type_used
);
1479 if (target_resources_ok
<= 0)
1481 int sw_mode
= b
->base
.ops
->works_in_software_mode (&b
->base
);
1483 if (target_resources_ok
== 0 && !sw_mode
)
1484 error (_("Target does not support this type of "
1485 "hardware watchpoint."));
1486 else if (target_resources_ok
< 0 && !sw_mode
)
1487 error (_("There are not enough available hardware "
1488 "resources for this watchpoint."));
1490 b
->base
.type
= bp_watchpoint
;
1493 else if (!b
->base
.ops
->works_in_software_mode (&b
->base
))
1494 error (_("Expression cannot be implemented with "
1495 "read/access watchpoint."));
1497 b
->base
.type
= bp_watchpoint
;
1499 loc_type
= (b
->base
.type
== bp_watchpoint
? bp_loc_other
1500 : bp_loc_hardware_watchpoint
);
1501 for (bl
= b
->base
.loc
; bl
; bl
= bl
->next
)
1502 bl
->loc_type
= loc_type
;
1505 for (v
= val_chain
; v
; v
= next
)
1507 next
= value_next (v
);
1512 /* If a software watchpoint is not watching any memory, then the
1513 above left it without any location set up. But,
1514 bpstat_stop_status requires a location to be able to report
1515 stops, so make sure there's at least a dummy one. */
1516 if (b
->base
.type
== bp_watchpoint
&& b
->base
.loc
== NULL
)
1518 struct breakpoint
*base
= &b
->base
;
1519 base
->loc
= allocate_bp_location (base
);
1520 base
->loc
->pspace
= frame_pspace
;
1521 base
->loc
->address
= -1;
1522 base
->loc
->length
= -1;
1523 base
->loc
->watchpoint_type
= -1;
1526 else if (!within_current_scope
)
1528 printf_filtered (_("\
1529 Watchpoint %d deleted because the program has left the block\n\
1530 in which its expression is valid.\n"),
1532 watchpoint_del_at_next_stop (b
);
1535 /* Restore the selected frame. */
1537 select_frame (frame_find_by_id (saved_frame_id
));
1541 /* Returns 1 iff breakpoint location should be
1542 inserted in the inferior. */
1544 should_be_inserted (struct bp_location
*bl
)
1546 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
1549 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
1552 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
1555 /* This is set for example, when we're attached to the parent of a
1556 vfork, and have detached from the child. The child is running
1557 free, and we expect it to do an exec or exit, at which point the
1558 OS makes the parent schedulable again (and the target reports
1559 that the vfork is done). Until the child is done with the shared
1560 memory region, do not insert breakpoints in the parent, otherwise
1561 the child could still trip on the parent's breakpoints. Since
1562 the parent is blocked anyway, it won't miss any breakpoint. */
1563 if (bl
->pspace
->breakpoints_not_allowed
)
1566 /* Tracepoints are inserted by the target at a time of its choosing,
1568 if (is_tracepoint (bl
->owner
))
1574 /* Same as should_be_inserted but does the check assuming
1575 that the location is not duplicated. */
1578 unduplicated_should_be_inserted (struct bp_location
*bl
)
1581 const int save_duplicate
= bl
->duplicate
;
1584 result
= should_be_inserted (bl
);
1585 bl
->duplicate
= save_duplicate
;
1589 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
1590 location. Any error messages are printed to TMP_ERROR_STREAM; and
1591 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
1592 Returns 0 for success, 1 if the bp_location type is not supported or
1595 NOTE drow/2003-09-09: This routine could be broken down to an
1596 object-style method for each breakpoint or catchpoint type. */
1598 insert_bp_location (struct bp_location
*bl
,
1599 struct ui_file
*tmp_error_stream
,
1600 int *disabled_breaks
,
1601 int *hw_breakpoint_error
)
1605 if (!should_be_inserted (bl
) || bl
->inserted
)
1608 /* Initialize the target-specific information. */
1609 memset (&bl
->target_info
, 0, sizeof (bl
->target_info
));
1610 bl
->target_info
.placed_address
= bl
->address
;
1611 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
1612 bl
->target_info
.length
= bl
->length
;
1614 if (bl
->loc_type
== bp_loc_software_breakpoint
1615 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
1617 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
1619 /* If the explicitly specified breakpoint type
1620 is not hardware breakpoint, check the memory map to see
1621 if the breakpoint address is in read only memory or not.
1623 Two important cases are:
1624 - location type is not hardware breakpoint, memory
1625 is readonly. We change the type of the location to
1626 hardware breakpoint.
1627 - location type is hardware breakpoint, memory is
1628 read-write. This means we've previously made the
1629 location hardware one, but then the memory map changed,
1632 When breakpoints are removed, remove_breakpoints will use
1633 location types we've just set here, the only possible
1634 problem is that memory map has changed during running
1635 program, but it's not going to work anyway with current
1637 struct mem_region
*mr
1638 = lookup_mem_region (bl
->target_info
.placed_address
);
1642 if (automatic_hardware_breakpoints
)
1644 enum bp_loc_type new_type
;
1646 if (mr
->attrib
.mode
!= MEM_RW
)
1647 new_type
= bp_loc_hardware_breakpoint
;
1649 new_type
= bp_loc_software_breakpoint
;
1651 if (new_type
!= bl
->loc_type
)
1653 static int said
= 0;
1655 bl
->loc_type
= new_type
;
1658 fprintf_filtered (gdb_stdout
,
1659 _("Note: automatically using "
1660 "hardware breakpoints for "
1661 "read-only addresses.\n"));
1666 else if (bl
->loc_type
== bp_loc_software_breakpoint
1667 && mr
->attrib
.mode
!= MEM_RW
)
1668 warning (_("cannot set software breakpoint "
1669 "at readonly address %s"),
1670 paddress (bl
->gdbarch
, bl
->address
));
1674 /* First check to see if we have to handle an overlay. */
1675 if (overlay_debugging
== ovly_off
1676 || bl
->section
== NULL
1677 || !(section_is_overlay (bl
->section
)))
1679 /* No overlay handling: just set the breakpoint. */
1681 val
= bl
->owner
->ops
->insert_location (bl
);
1685 /* This breakpoint is in an overlay section.
1686 Shall we set a breakpoint at the LMA? */
1687 if (!overlay_events_enabled
)
1689 /* Yes -- overlay event support is not active,
1690 so we must try to set a breakpoint at the LMA.
1691 This will not work for a hardware breakpoint. */
1692 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1693 warning (_("hardware breakpoint %d not supported in overlay!"),
1697 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
1699 /* Set a software (trap) breakpoint at the LMA. */
1700 bl
->overlay_target_info
= bl
->target_info
;
1701 bl
->overlay_target_info
.placed_address
= addr
;
1702 val
= target_insert_breakpoint (bl
->gdbarch
,
1703 &bl
->overlay_target_info
);
1705 fprintf_unfiltered (tmp_error_stream
,
1706 "Overlay breakpoint %d "
1707 "failed: in ROM?\n",
1711 /* Shall we set a breakpoint at the VMA? */
1712 if (section_is_mapped (bl
->section
))
1714 /* Yes. This overlay section is mapped into memory. */
1715 val
= bl
->owner
->ops
->insert_location (bl
);
1719 /* No. This breakpoint will not be inserted.
1720 No error, but do not mark the bp as 'inserted'. */
1727 /* Can't set the breakpoint. */
1728 if (solib_name_from_address (bl
->pspace
, bl
->address
))
1730 /* See also: disable_breakpoints_in_shlibs. */
1732 bl
->shlib_disabled
= 1;
1733 observer_notify_breakpoint_modified (bl
->owner
);
1734 if (!*disabled_breaks
)
1736 fprintf_unfiltered (tmp_error_stream
,
1737 "Cannot insert breakpoint %d.\n",
1739 fprintf_unfiltered (tmp_error_stream
,
1740 "Temporarily disabling shared "
1741 "library breakpoints:\n");
1743 *disabled_breaks
= 1;
1744 fprintf_unfiltered (tmp_error_stream
,
1745 "breakpoint #%d\n", bl
->owner
->number
);
1749 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1751 *hw_breakpoint_error
= 1;
1752 fprintf_unfiltered (tmp_error_stream
,
1753 "Cannot insert hardware "
1759 fprintf_unfiltered (tmp_error_stream
,
1760 "Cannot insert breakpoint %d.\n",
1762 fprintf_filtered (tmp_error_stream
,
1763 "Error accessing memory address ");
1764 fputs_filtered (paddress (bl
->gdbarch
, bl
->address
),
1766 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1767 safe_strerror (val
));
1778 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
1779 /* NOTE drow/2003-09-08: This state only exists for removing
1780 watchpoints. It's not clear that it's necessary... */
1781 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
1783 gdb_assert (bl
->owner
->ops
!= NULL
1784 && bl
->owner
->ops
->insert_location
!= NULL
);
1786 val
= bl
->owner
->ops
->insert_location (bl
);
1788 /* If trying to set a read-watchpoint, and it turns out it's not
1789 supported, try emulating one with an access watchpoint. */
1790 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
1792 struct bp_location
*loc
, **loc_temp
;
1794 /* But don't try to insert it, if there's already another
1795 hw_access location that would be considered a duplicate
1797 ALL_BP_LOCATIONS (loc
, loc_temp
)
1799 && loc
->watchpoint_type
== hw_access
1800 && watchpoint_locations_match (bl
, loc
))
1804 bl
->target_info
= loc
->target_info
;
1805 bl
->watchpoint_type
= hw_access
;
1812 bl
->watchpoint_type
= hw_access
;
1813 val
= bl
->owner
->ops
->insert_location (bl
);
1816 /* Back to the original value. */
1817 bl
->watchpoint_type
= hw_read
;
1821 bl
->inserted
= (val
== 0);
1824 else if (bl
->owner
->type
== bp_catchpoint
)
1826 gdb_assert (bl
->owner
->ops
!= NULL
1827 && bl
->owner
->ops
->insert_location
!= NULL
);
1829 val
= bl
->owner
->ops
->insert_location (bl
);
1832 bl
->owner
->enable_state
= bp_disabled
;
1836 Error inserting catchpoint %d: Your system does not support this type\n\
1837 of catchpoint."), bl
->owner
->number
);
1839 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
1842 bl
->inserted
= (val
== 0);
1844 /* We've already printed an error message if there was a problem
1845 inserting this catchpoint, and we've disabled the catchpoint,
1846 so just return success. */
1853 /* This function is called when program space PSPACE is about to be
1854 deleted. It takes care of updating breakpoints to not reference
1858 breakpoint_program_space_exit (struct program_space
*pspace
)
1860 struct breakpoint
*b
, *b_temp
;
1861 struct bp_location
*loc
, **loc_temp
;
1863 /* Remove any breakpoint that was set through this program space. */
1864 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1866 if (b
->pspace
== pspace
)
1867 delete_breakpoint (b
);
1870 /* Breakpoints set through other program spaces could have locations
1871 bound to PSPACE as well. Remove those. */
1872 ALL_BP_LOCATIONS (loc
, loc_temp
)
1874 struct bp_location
*tmp
;
1876 if (loc
->pspace
== pspace
)
1878 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1879 if (loc
->owner
->loc
== loc
)
1880 loc
->owner
->loc
= loc
->next
;
1882 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1883 if (tmp
->next
== loc
)
1885 tmp
->next
= loc
->next
;
1891 /* Now update the global location list to permanently delete the
1892 removed locations above. */
1893 update_global_location_list (0);
1896 /* Make sure all breakpoints are inserted in inferior.
1897 Throws exception on any error.
1898 A breakpoint that is already inserted won't be inserted
1899 again, so calling this function twice is safe. */
1901 insert_breakpoints (void)
1903 struct breakpoint
*bpt
;
1905 ALL_BREAKPOINTS (bpt
)
1906 if (is_hardware_watchpoint (bpt
))
1908 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
1910 update_watchpoint (w
, 0 /* don't reparse. */);
1913 update_global_location_list (1);
1915 /* update_global_location_list does not insert breakpoints when
1916 always_inserted_mode is not enabled. Explicitly insert them
1918 if (!breakpoints_always_inserted_mode ())
1919 insert_breakpoint_locations ();
1922 /* Used when starting or continuing the program. */
1925 insert_breakpoint_locations (void)
1927 struct breakpoint
*bpt
;
1928 struct bp_location
*bl
, **blp_tmp
;
1931 int disabled_breaks
= 0;
1932 int hw_breakpoint_error
= 0;
1934 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1935 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1937 /* Explicitly mark the warning -- this will only be printed if
1938 there was an error. */
1939 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1941 save_current_space_and_thread ();
1943 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1945 if (!should_be_inserted (bl
) || bl
->inserted
)
1948 /* There is no point inserting thread-specific breakpoints if
1949 the thread no longer exists. ALL_BP_LOCATIONS bp_location
1950 has BL->OWNER always non-NULL. */
1951 if (bl
->owner
->thread
!= -1
1952 && !valid_thread_id (bl
->owner
->thread
))
1955 switch_to_program_space_and_thread (bl
->pspace
);
1957 /* For targets that support global breakpoints, there's no need
1958 to select an inferior to insert breakpoint to. In fact, even
1959 if we aren't attached to any process yet, we should still
1960 insert breakpoints. */
1961 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
1962 && ptid_equal (inferior_ptid
, null_ptid
))
1965 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
1966 &hw_breakpoint_error
);
1971 /* If we failed to insert all locations of a watchpoint, remove
1972 them, as half-inserted watchpoint is of limited use. */
1973 ALL_BREAKPOINTS (bpt
)
1975 int some_failed
= 0;
1976 struct bp_location
*loc
;
1978 if (!is_hardware_watchpoint (bpt
))
1981 if (!breakpoint_enabled (bpt
))
1984 if (bpt
->disposition
== disp_del_at_next_stop
)
1987 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1988 if (!loc
->inserted
&& should_be_inserted (loc
))
1995 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1997 remove_breakpoint (loc
, mark_uninserted
);
1999 hw_breakpoint_error
= 1;
2000 fprintf_unfiltered (tmp_error_stream
,
2001 "Could not insert hardware watchpoint %d.\n",
2009 /* If a hardware breakpoint or watchpoint was inserted, add a
2010 message about possibly exhausted resources. */
2011 if (hw_breakpoint_error
)
2013 fprintf_unfiltered (tmp_error_stream
,
2014 "Could not insert hardware breakpoints:\n\
2015 You may have requested too many hardware breakpoints/watchpoints.\n");
2017 target_terminal_ours_for_output ();
2018 error_stream (tmp_error_stream
);
2021 do_cleanups (cleanups
);
2024 /* Used when the program stops.
2025 Returns zero if successful, or non-zero if there was a problem
2026 removing a breakpoint location. */
2029 remove_breakpoints (void)
2031 struct bp_location
*bl
, **blp_tmp
;
2034 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2037 val
|= remove_breakpoint (bl
, mark_uninserted
);
2042 /* Remove breakpoints of process PID. */
2045 remove_breakpoints_pid (int pid
)
2047 struct bp_location
*bl
, **blp_tmp
;
2049 struct inferior
*inf
= find_inferior_pid (pid
);
2051 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2053 if (bl
->pspace
!= inf
->pspace
)
2058 val
= remove_breakpoint (bl
, mark_uninserted
);
2067 reattach_breakpoints (int pid
)
2069 struct cleanup
*old_chain
;
2070 struct bp_location
*bl
, **blp_tmp
;
2072 struct ui_file
*tmp_error_stream
;
2073 int dummy1
= 0, dummy2
= 0;
2074 struct inferior
*inf
;
2075 struct thread_info
*tp
;
2077 tp
= any_live_thread_of_process (pid
);
2081 inf
= find_inferior_pid (pid
);
2082 old_chain
= save_inferior_ptid ();
2084 inferior_ptid
= tp
->ptid
;
2086 tmp_error_stream
= mem_fileopen ();
2087 make_cleanup_ui_file_delete (tmp_error_stream
);
2089 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2091 if (bl
->pspace
!= inf
->pspace
)
2097 val
= insert_bp_location (bl
, tmp_error_stream
, &dummy1
, &dummy2
);
2100 do_cleanups (old_chain
);
2105 do_cleanups (old_chain
);
2109 static int internal_breakpoint_number
= -1;
2111 /* Set the breakpoint number of B, depending on the value of INTERNAL.
2112 If INTERNAL is non-zero, the breakpoint number will be populated
2113 from internal_breakpoint_number and that variable decremented.
2114 Otherwise the breakpoint number will be populated from
2115 breakpoint_count and that value incremented. Internal breakpoints
2116 do not set the internal var bpnum. */
2118 set_breakpoint_number (int internal
, struct breakpoint
*b
)
2121 b
->number
= internal_breakpoint_number
--;
2124 set_breakpoint_count (breakpoint_count
+ 1);
2125 b
->number
= breakpoint_count
;
2129 static struct breakpoint
*
2130 create_internal_breakpoint (struct gdbarch
*gdbarch
,
2131 CORE_ADDR address
, enum bptype type
,
2132 const struct breakpoint_ops
*ops
)
2134 struct symtab_and_line sal
;
2135 struct breakpoint
*b
;
2137 init_sal (&sal
); /* Initialize to zeroes. */
2140 sal
.section
= find_pc_overlay (sal
.pc
);
2141 sal
.pspace
= current_program_space
;
2143 b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
2144 b
->number
= internal_breakpoint_number
--;
2145 b
->disposition
= disp_donttouch
;
2150 static const char *const longjmp_names
[] =
2152 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
2154 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
2156 /* Per-objfile data private to breakpoint.c. */
2157 struct breakpoint_objfile_data
2159 /* Minimal symbol for "_ovly_debug_event" (if any). */
2160 struct minimal_symbol
*overlay_msym
;
2162 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
2163 struct minimal_symbol
*longjmp_msym
[NUM_LONGJMP_NAMES
];
2165 /* Minimal symbol for "std::terminate()" (if any). */
2166 struct minimal_symbol
*terminate_msym
;
2168 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
2169 struct minimal_symbol
*exception_msym
;
2172 static const struct objfile_data
*breakpoint_objfile_key
;
2174 /* Minimal symbol not found sentinel. */
2175 static struct minimal_symbol msym_not_found
;
2177 /* Returns TRUE if MSYM point to the "not found" sentinel. */
2180 msym_not_found_p (const struct minimal_symbol
*msym
)
2182 return msym
== &msym_not_found
;
2185 /* Return per-objfile data needed by breakpoint.c.
2186 Allocate the data if necessary. */
2188 static struct breakpoint_objfile_data
*
2189 get_breakpoint_objfile_data (struct objfile
*objfile
)
2191 struct breakpoint_objfile_data
*bp_objfile_data
;
2193 bp_objfile_data
= objfile_data (objfile
, breakpoint_objfile_key
);
2194 if (bp_objfile_data
== NULL
)
2196 bp_objfile_data
= obstack_alloc (&objfile
->objfile_obstack
,
2197 sizeof (*bp_objfile_data
));
2199 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
2200 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
2202 return bp_objfile_data
;
2206 create_overlay_event_breakpoint (void)
2208 struct objfile
*objfile
;
2209 const char *const func_name
= "_ovly_debug_event";
2211 ALL_OBJFILES (objfile
)
2213 struct breakpoint
*b
;
2214 struct breakpoint_objfile_data
*bp_objfile_data
;
2217 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2219 if (msym_not_found_p (bp_objfile_data
->overlay_msym
))
2222 if (bp_objfile_data
->overlay_msym
== NULL
)
2224 struct minimal_symbol
*m
;
2226 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2229 /* Avoid future lookups in this objfile. */
2230 bp_objfile_data
->overlay_msym
= &msym_not_found
;
2233 bp_objfile_data
->overlay_msym
= m
;
2236 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
2237 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2239 &internal_breakpoint_ops
);
2240 b
->addr_string
= xstrdup (func_name
);
2242 if (overlay_debugging
== ovly_auto
)
2244 b
->enable_state
= bp_enabled
;
2245 overlay_events_enabled
= 1;
2249 b
->enable_state
= bp_disabled
;
2250 overlay_events_enabled
= 0;
2253 update_global_location_list (1);
2257 create_longjmp_master_breakpoint (void)
2259 struct program_space
*pspace
;
2260 struct cleanup
*old_chain
;
2262 old_chain
= save_current_program_space ();
2264 ALL_PSPACES (pspace
)
2266 struct objfile
*objfile
;
2268 set_current_program_space (pspace
);
2270 ALL_OBJFILES (objfile
)
2273 struct gdbarch
*gdbarch
;
2274 struct breakpoint_objfile_data
*bp_objfile_data
;
2276 gdbarch
= get_objfile_arch (objfile
);
2277 if (!gdbarch_get_longjmp_target_p (gdbarch
))
2280 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2282 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
2284 struct breakpoint
*b
;
2285 const char *func_name
;
2288 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
]))
2291 func_name
= longjmp_names
[i
];
2292 if (bp_objfile_data
->longjmp_msym
[i
] == NULL
)
2294 struct minimal_symbol
*m
;
2296 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2299 /* Prevent future lookups in this objfile. */
2300 bp_objfile_data
->longjmp_msym
[i
] = &msym_not_found
;
2303 bp_objfile_data
->longjmp_msym
[i
] = m
;
2306 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
2307 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
2308 &internal_breakpoint_ops
);
2309 b
->addr_string
= xstrdup (func_name
);
2310 b
->enable_state
= bp_disabled
;
2314 update_global_location_list (1);
2316 do_cleanups (old_chain
);
2319 /* Create a master std::terminate breakpoint. */
2321 create_std_terminate_master_breakpoint (void)
2323 struct program_space
*pspace
;
2324 struct cleanup
*old_chain
;
2325 const char *const func_name
= "std::terminate()";
2327 old_chain
= save_current_program_space ();
2329 ALL_PSPACES (pspace
)
2331 struct objfile
*objfile
;
2334 set_current_program_space (pspace
);
2336 ALL_OBJFILES (objfile
)
2338 struct breakpoint
*b
;
2339 struct breakpoint_objfile_data
*bp_objfile_data
;
2341 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2343 if (msym_not_found_p (bp_objfile_data
->terminate_msym
))
2346 if (bp_objfile_data
->terminate_msym
== NULL
)
2348 struct minimal_symbol
*m
;
2350 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2351 if (m
== NULL
|| (MSYMBOL_TYPE (m
) != mst_text
2352 && MSYMBOL_TYPE (m
) != mst_file_text
))
2354 /* Prevent future lookups in this objfile. */
2355 bp_objfile_data
->terminate_msym
= &msym_not_found
;
2358 bp_objfile_data
->terminate_msym
= m
;
2361 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
2362 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2363 bp_std_terminate_master
,
2364 &internal_breakpoint_ops
);
2365 b
->addr_string
= xstrdup (func_name
);
2366 b
->enable_state
= bp_disabled
;
2370 update_global_location_list (1);
2372 do_cleanups (old_chain
);
2375 /* Install a master breakpoint on the unwinder's debug hook. */
2378 create_exception_master_breakpoint (void)
2380 struct objfile
*objfile
;
2381 const char *const func_name
= "_Unwind_DebugHook";
2383 ALL_OBJFILES (objfile
)
2385 struct breakpoint
*b
;
2386 struct gdbarch
*gdbarch
;
2387 struct breakpoint_objfile_data
*bp_objfile_data
;
2390 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2392 if (msym_not_found_p (bp_objfile_data
->exception_msym
))
2395 gdbarch
= get_objfile_arch (objfile
);
2397 if (bp_objfile_data
->exception_msym
== NULL
)
2399 struct minimal_symbol
*debug_hook
;
2401 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2402 if (debug_hook
== NULL
)
2404 bp_objfile_data
->exception_msym
= &msym_not_found
;
2408 bp_objfile_data
->exception_msym
= debug_hook
;
2411 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
2412 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2414 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
2415 &internal_breakpoint_ops
);
2416 b
->addr_string
= xstrdup (func_name
);
2417 b
->enable_state
= bp_disabled
;
2420 update_global_location_list (1);
2424 update_breakpoints_after_exec (void)
2426 struct breakpoint
*b
, *b_tmp
;
2427 struct bp_location
*bploc
, **bplocp_tmp
;
2429 /* We're about to delete breakpoints from GDB's lists. If the
2430 INSERTED flag is true, GDB will try to lift the breakpoints by
2431 writing the breakpoints' "shadow contents" back into memory. The
2432 "shadow contents" are NOT valid after an exec, so GDB should not
2433 do that. Instead, the target is responsible from marking
2434 breakpoints out as soon as it detects an exec. We don't do that
2435 here instead, because there may be other attempts to delete
2436 breakpoints after detecting an exec and before reaching here. */
2437 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
2438 if (bploc
->pspace
== current_program_space
)
2439 gdb_assert (!bploc
->inserted
);
2441 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2443 if (b
->pspace
!= current_program_space
)
2446 /* Solib breakpoints must be explicitly reset after an exec(). */
2447 if (b
->type
== bp_shlib_event
)
2449 delete_breakpoint (b
);
2453 /* JIT breakpoints must be explicitly reset after an exec(). */
2454 if (b
->type
== bp_jit_event
)
2456 delete_breakpoint (b
);
2460 /* Thread event breakpoints must be set anew after an exec(),
2461 as must overlay event and longjmp master breakpoints. */
2462 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
2463 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
2464 || b
->type
== bp_exception_master
)
2466 delete_breakpoint (b
);
2470 /* Step-resume breakpoints are meaningless after an exec(). */
2471 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
2473 delete_breakpoint (b
);
2477 /* Longjmp and longjmp-resume breakpoints are also meaningless
2479 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
2480 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
2482 delete_breakpoint (b
);
2486 if (b
->type
== bp_catchpoint
)
2488 /* For now, none of the bp_catchpoint breakpoints need to
2489 do anything at this point. In the future, if some of
2490 the catchpoints need to something, we will need to add
2491 a new method, and call this method from here. */
2495 /* bp_finish is a special case. The only way we ought to be able
2496 to see one of these when an exec() has happened, is if the user
2497 caught a vfork, and then said "finish". Ordinarily a finish just
2498 carries them to the call-site of the current callee, by setting
2499 a temporary bp there and resuming. But in this case, the finish
2500 will carry them entirely through the vfork & exec.
2502 We don't want to allow a bp_finish to remain inserted now. But
2503 we can't safely delete it, 'cause finish_command has a handle to
2504 the bp on a bpstat, and will later want to delete it. There's a
2505 chance (and I've seen it happen) that if we delete the bp_finish
2506 here, that its storage will get reused by the time finish_command
2507 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2508 We really must allow finish_command to delete a bp_finish.
2510 In the absence of a general solution for the "how do we know
2511 it's safe to delete something others may have handles to?"
2512 problem, what we'll do here is just uninsert the bp_finish, and
2513 let finish_command delete it.
2515 (We know the bp_finish is "doomed" in the sense that it's
2516 momentary, and will be deleted as soon as finish_command sees
2517 the inferior stopped. So it doesn't matter that the bp's
2518 address is probably bogus in the new a.out, unlike e.g., the
2519 solib breakpoints.) */
2521 if (b
->type
== bp_finish
)
2526 /* Without a symbolic address, we have little hope of the
2527 pre-exec() address meaning the same thing in the post-exec()
2529 if (b
->addr_string
== NULL
)
2531 delete_breakpoint (b
);
2535 /* FIXME what about longjmp breakpoints? Re-create them here? */
2536 create_overlay_event_breakpoint ();
2537 create_longjmp_master_breakpoint ();
2538 create_std_terminate_master_breakpoint ();
2539 create_exception_master_breakpoint ();
2543 detach_breakpoints (int pid
)
2545 struct bp_location
*bl
, **blp_tmp
;
2547 struct cleanup
*old_chain
= save_inferior_ptid ();
2548 struct inferior
*inf
= current_inferior ();
2550 if (pid
== PIDGET (inferior_ptid
))
2551 error (_("Cannot detach breakpoints of inferior_ptid"));
2553 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2554 inferior_ptid
= pid_to_ptid (pid
);
2555 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2557 if (bl
->pspace
!= inf
->pspace
)
2561 val
|= remove_breakpoint_1 (bl
, mark_inserted
);
2564 /* Detach single-step breakpoints as well. */
2565 detach_single_step_breakpoints ();
2567 do_cleanups (old_chain
);
2571 /* Remove the breakpoint location BL from the current address space.
2572 Note that this is used to detach breakpoints from a child fork.
2573 When we get here, the child isn't in the inferior list, and neither
2574 do we have objects to represent its address space --- we should
2575 *not* look at bl->pspace->aspace here. */
2578 remove_breakpoint_1 (struct bp_location
*bl
, insertion_state_t is
)
2582 /* BL is never in moribund_locations by our callers. */
2583 gdb_assert (bl
->owner
!= NULL
);
2585 if (bl
->owner
->enable_state
== bp_permanent
)
2586 /* Permanent breakpoints cannot be inserted or removed. */
2589 /* The type of none suggests that owner is actually deleted.
2590 This should not ever happen. */
2591 gdb_assert (bl
->owner
->type
!= bp_none
);
2593 if (bl
->loc_type
== bp_loc_software_breakpoint
2594 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2596 /* "Normal" instruction breakpoint: either the standard
2597 trap-instruction bp (bp_breakpoint), or a
2598 bp_hardware_breakpoint. */
2600 /* First check to see if we have to handle an overlay. */
2601 if (overlay_debugging
== ovly_off
2602 || bl
->section
== NULL
2603 || !(section_is_overlay (bl
->section
)))
2605 /* No overlay handling: just remove the breakpoint. */
2606 val
= bl
->owner
->ops
->remove_location (bl
);
2610 /* This breakpoint is in an overlay section.
2611 Did we set a breakpoint at the LMA? */
2612 if (!overlay_events_enabled
)
2614 /* Yes -- overlay event support is not active, so we
2615 should have set a breakpoint at the LMA. Remove it.
2617 /* Ignore any failures: if the LMA is in ROM, we will
2618 have already warned when we failed to insert it. */
2619 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2620 target_remove_hw_breakpoint (bl
->gdbarch
,
2621 &bl
->overlay_target_info
);
2623 target_remove_breakpoint (bl
->gdbarch
,
2624 &bl
->overlay_target_info
);
2626 /* Did we set a breakpoint at the VMA?
2627 If so, we will have marked the breakpoint 'inserted'. */
2630 /* Yes -- remove it. Previously we did not bother to
2631 remove the breakpoint if the section had been
2632 unmapped, but let's not rely on that being safe. We
2633 don't know what the overlay manager might do. */
2635 /* However, we should remove *software* breakpoints only
2636 if the section is still mapped, or else we overwrite
2637 wrong code with the saved shadow contents. */
2638 if (bl
->loc_type
== bp_loc_hardware_breakpoint
2639 || section_is_mapped (bl
->section
))
2640 val
= bl
->owner
->ops
->remove_location (bl
);
2646 /* No -- not inserted, so no need to remove. No error. */
2651 /* In some cases, we might not be able to remove a breakpoint
2652 in a shared library that has already been removed, but we
2653 have not yet processed the shlib unload event. */
2654 if (val
&& solib_name_from_address (bl
->pspace
, bl
->address
))
2659 bl
->inserted
= (is
== mark_inserted
);
2661 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
2663 gdb_assert (bl
->owner
->ops
!= NULL
2664 && bl
->owner
->ops
->remove_location
!= NULL
);
2666 bl
->inserted
= (is
== mark_inserted
);
2667 bl
->owner
->ops
->remove_location (bl
);
2669 /* Failure to remove any of the hardware watchpoints comes here. */
2670 if ((is
== mark_uninserted
) && (bl
->inserted
))
2671 warning (_("Could not remove hardware watchpoint %d."),
2674 else if (bl
->owner
->type
== bp_catchpoint
2675 && breakpoint_enabled (bl
->owner
)
2678 gdb_assert (bl
->owner
->ops
!= NULL
2679 && bl
->owner
->ops
->remove_location
!= NULL
);
2681 val
= bl
->owner
->ops
->remove_location (bl
);
2685 bl
->inserted
= (is
== mark_inserted
);
2692 remove_breakpoint (struct bp_location
*bl
, insertion_state_t is
)
2695 struct cleanup
*old_chain
;
2697 /* BL is never in moribund_locations by our callers. */
2698 gdb_assert (bl
->owner
!= NULL
);
2700 if (bl
->owner
->enable_state
== bp_permanent
)
2701 /* Permanent breakpoints cannot be inserted or removed. */
2704 /* The type of none suggests that owner is actually deleted.
2705 This should not ever happen. */
2706 gdb_assert (bl
->owner
->type
!= bp_none
);
2708 old_chain
= save_current_space_and_thread ();
2710 switch_to_program_space_and_thread (bl
->pspace
);
2712 ret
= remove_breakpoint_1 (bl
, is
);
2714 do_cleanups (old_chain
);
2718 /* Clear the "inserted" flag in all breakpoints. */
2721 mark_breakpoints_out (void)
2723 struct bp_location
*bl
, **blp_tmp
;
2725 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2726 if (bl
->pspace
== current_program_space
)
2730 /* Clear the "inserted" flag in all breakpoints and delete any
2731 breakpoints which should go away between runs of the program.
2733 Plus other such housekeeping that has to be done for breakpoints
2736 Note: this function gets called at the end of a run (by
2737 generic_mourn_inferior) and when a run begins (by
2738 init_wait_for_inferior). */
2743 breakpoint_init_inferior (enum inf_context context
)
2745 struct breakpoint
*b
, *b_tmp
;
2746 struct bp_location
*bl
, **blp_tmp
;
2748 struct program_space
*pspace
= current_program_space
;
2750 /* If breakpoint locations are shared across processes, then there's
2752 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2755 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2757 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2758 if (bl
->pspace
== pspace
2759 && bl
->owner
->enable_state
!= bp_permanent
)
2763 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2765 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2772 /* If the call dummy breakpoint is at the entry point it will
2773 cause problems when the inferior is rerun, so we better get
2776 case bp_watchpoint_scope
:
2778 /* Also get rid of scope breakpoints. */
2780 case bp_shlib_event
:
2782 /* Also remove solib event breakpoints. Their addresses may
2783 have changed since the last time we ran the program.
2784 Actually we may now be debugging against different target;
2785 and so the solib backend that installed this breakpoint may
2786 not be used in by the target. E.g.,
2788 (gdb) file prog-linux
2789 (gdb) run # native linux target
2792 (gdb) file prog-win.exe
2793 (gdb) tar rem :9999 # remote Windows gdbserver.
2796 delete_breakpoint (b
);
2800 case bp_hardware_watchpoint
:
2801 case bp_read_watchpoint
:
2802 case bp_access_watchpoint
:
2804 struct watchpoint
*w
= (struct watchpoint
*) b
;
2806 /* Likewise for watchpoints on local expressions. */
2807 if (w
->exp_valid_block
!= NULL
)
2808 delete_breakpoint (b
);
2809 else if (context
== inf_starting
)
2811 /* Reset val field to force reread of starting value in
2812 insert_breakpoints. */
2814 value_free (w
->val
);
2825 /* Get rid of the moribund locations. */
2826 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
2827 decref_bp_location (&bl
);
2828 VEC_free (bp_location_p
, moribund_locations
);
2831 /* These functions concern about actual breakpoints inserted in the
2832 target --- to e.g. check if we need to do decr_pc adjustment or if
2833 we need to hop over the bkpt --- so we check for address space
2834 match, not program space. */
2836 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2837 exists at PC. It returns ordinary_breakpoint_here if it's an
2838 ordinary breakpoint, or permanent_breakpoint_here if it's a
2839 permanent breakpoint.
2840 - When continuing from a location with an ordinary breakpoint, we
2841 actually single step once before calling insert_breakpoints.
2842 - When continuing from a location with a permanent breakpoint, we
2843 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2844 the target, to advance the PC past the breakpoint. */
2846 enum breakpoint_here
2847 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2849 struct bp_location
*bl
, **blp_tmp
;
2850 int any_breakpoint_here
= 0;
2852 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2854 if (bl
->loc_type
!= bp_loc_software_breakpoint
2855 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2858 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2859 if ((breakpoint_enabled (bl
->owner
)
2860 || bl
->owner
->enable_state
== bp_permanent
)
2861 && breakpoint_location_address_match (bl
, aspace
, pc
))
2863 if (overlay_debugging
2864 && section_is_overlay (bl
->section
)
2865 && !section_is_mapped (bl
->section
))
2866 continue; /* unmapped overlay -- can't be a match */
2867 else if (bl
->owner
->enable_state
== bp_permanent
)
2868 return permanent_breakpoint_here
;
2870 any_breakpoint_here
= 1;
2874 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2877 /* Return true if there's a moribund breakpoint at PC. */
2880 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2882 struct bp_location
*loc
;
2885 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2886 if (breakpoint_location_address_match (loc
, aspace
, pc
))
2892 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2893 inserted using regular breakpoint_chain / bp_location array
2894 mechanism. This does not check for single-step breakpoints, which
2895 are inserted and removed using direct target manipulation. */
2898 regular_breakpoint_inserted_here_p (struct address_space
*aspace
,
2901 struct bp_location
*bl
, **blp_tmp
;
2903 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2905 if (bl
->loc_type
!= bp_loc_software_breakpoint
2906 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2910 && breakpoint_location_address_match (bl
, aspace
, pc
))
2912 if (overlay_debugging
2913 && section_is_overlay (bl
->section
)
2914 && !section_is_mapped (bl
->section
))
2915 continue; /* unmapped overlay -- can't be a match */
2923 /* Returns non-zero iff there's either regular breakpoint
2924 or a single step breakpoint inserted at PC. */
2927 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2929 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
2932 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2938 /* This function returns non-zero iff there is a software breakpoint
2942 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
2945 struct bp_location
*bl
, **blp_tmp
;
2947 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2949 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
2953 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
2956 if (overlay_debugging
2957 && section_is_overlay (bl
->section
)
2958 && !section_is_mapped (bl
->section
))
2959 continue; /* unmapped overlay -- can't be a match */
2965 /* Also check for software single-step breakpoints. */
2966 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2973 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
2974 CORE_ADDR addr
, ULONGEST len
)
2976 struct breakpoint
*bpt
;
2978 ALL_BREAKPOINTS (bpt
)
2980 struct bp_location
*loc
;
2982 if (bpt
->type
!= bp_hardware_watchpoint
2983 && bpt
->type
!= bp_access_watchpoint
)
2986 if (!breakpoint_enabled (bpt
))
2989 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2990 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
2994 /* Check for intersection. */
2995 l
= max (loc
->address
, addr
);
2996 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
3004 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
3005 PC is valid for process/thread PTID. */
3008 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
3011 struct bp_location
*bl
, **blp_tmp
;
3012 /* The thread and task IDs associated to PTID, computed lazily. */
3016 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3018 if (bl
->loc_type
!= bp_loc_software_breakpoint
3019 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
3022 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
3023 if (!breakpoint_enabled (bl
->owner
)
3024 && bl
->owner
->enable_state
!= bp_permanent
)
3027 if (!breakpoint_location_address_match (bl
, aspace
, pc
))
3030 if (bl
->owner
->thread
!= -1)
3032 /* This is a thread-specific breakpoint. Check that ptid
3033 matches that thread. If thread hasn't been computed yet,
3034 it is now time to do so. */
3036 thread
= pid_to_thread_id (ptid
);
3037 if (bl
->owner
->thread
!= thread
)
3041 if (bl
->owner
->task
!= 0)
3043 /* This is a task-specific breakpoint. Check that ptid
3044 matches that task. If task hasn't been computed yet,
3045 it is now time to do so. */
3047 task
= ada_get_task_number (ptid
);
3048 if (bl
->owner
->task
!= task
)
3052 if (overlay_debugging
3053 && section_is_overlay (bl
->section
)
3054 && !section_is_mapped (bl
->section
))
3055 continue; /* unmapped overlay -- can't be a match */
3064 /* bpstat stuff. External routines' interfaces are documented
3068 ep_is_catchpoint (struct breakpoint
*ep
)
3070 return (ep
->type
== bp_catchpoint
);
3073 /* Frees any storage that is part of a bpstat. Does not walk the
3077 bpstat_free (bpstat bs
)
3079 if (bs
->old_val
!= NULL
)
3080 value_free (bs
->old_val
);
3081 decref_counted_command_line (&bs
->commands
);
3082 decref_bp_location (&bs
->bp_location_at
);
3086 /* Clear a bpstat so that it says we are not at any breakpoint.
3087 Also free any storage that is part of a bpstat. */
3090 bpstat_clear (bpstat
*bsp
)
3107 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
3108 is part of the bpstat is copied as well. */
3111 bpstat_copy (bpstat bs
)
3115 bpstat retval
= NULL
;
3120 for (; bs
!= NULL
; bs
= bs
->next
)
3122 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
3123 memcpy (tmp
, bs
, sizeof (*tmp
));
3124 incref_counted_command_line (tmp
->commands
);
3125 incref_bp_location (tmp
->bp_location_at
);
3126 if (bs
->old_val
!= NULL
)
3128 tmp
->old_val
= value_copy (bs
->old_val
);
3129 release_value (tmp
->old_val
);
3133 /* This is the first thing in the chain. */
3143 /* Find the bpstat associated with this breakpoint. */
3146 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
3151 for (; bsp
!= NULL
; bsp
= bsp
->next
)
3153 if (bsp
->breakpoint_at
== breakpoint
)
3159 /* Put in *NUM the breakpoint number of the first breakpoint we are
3160 stopped at. *BSP upon return is a bpstat which points to the
3161 remaining breakpoints stopped at (but which is not guaranteed to be
3162 good for anything but further calls to bpstat_num).
3164 Return 0 if passed a bpstat which does not indicate any breakpoints.
3165 Return -1 if stopped at a breakpoint that has been deleted since
3167 Return 1 otherwise. */
3170 bpstat_num (bpstat
*bsp
, int *num
)
3172 struct breakpoint
*b
;
3175 return 0; /* No more breakpoint values */
3177 /* We assume we'll never have several bpstats that correspond to a
3178 single breakpoint -- otherwise, this function might return the
3179 same number more than once and this will look ugly. */
3180 b
= (*bsp
)->breakpoint_at
;
3181 *bsp
= (*bsp
)->next
;
3183 return -1; /* breakpoint that's been deleted since */
3185 *num
= b
->number
; /* We have its number */
3189 /* See breakpoint.h. */
3192 bpstat_clear_actions (void)
3194 struct thread_info
*tp
;
3197 if (ptid_equal (inferior_ptid
, null_ptid
))
3200 tp
= find_thread_ptid (inferior_ptid
);
3204 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
3206 decref_counted_command_line (&bs
->commands
);
3208 if (bs
->old_val
!= NULL
)
3210 value_free (bs
->old_val
);
3216 /* Called when a command is about to proceed the inferior. */
3219 breakpoint_about_to_proceed (void)
3221 if (!ptid_equal (inferior_ptid
, null_ptid
))
3223 struct thread_info
*tp
= inferior_thread ();
3225 /* Allow inferior function calls in breakpoint commands to not
3226 interrupt the command list. When the call finishes
3227 successfully, the inferior will be standing at the same
3228 breakpoint as if nothing happened. */
3229 if (tp
->control
.in_infcall
)
3233 breakpoint_proceeded
= 1;
3236 /* Stub for cleaning up our state if we error-out of a breakpoint
3239 cleanup_executing_breakpoints (void *ignore
)
3241 executing_breakpoint_commands
= 0;
3244 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
3245 or its equivalent. */
3248 command_line_is_silent (struct command_line
*cmd
)
3250 return cmd
&& (strcmp ("silent", cmd
->line
) == 0
3251 || (xdb_commands
&& strcmp ("Q", cmd
->line
) == 0));
3254 /* Execute all the commands associated with all the breakpoints at
3255 this location. Any of these commands could cause the process to
3256 proceed beyond this point, etc. We look out for such changes by
3257 checking the global "breakpoint_proceeded" after each command.
3259 Returns true if a breakpoint command resumed the inferior. In that
3260 case, it is the caller's responsibility to recall it again with the
3261 bpstat of the current thread. */
3264 bpstat_do_actions_1 (bpstat
*bsp
)
3267 struct cleanup
*old_chain
;
3270 /* Avoid endless recursion if a `source' command is contained
3272 if (executing_breakpoint_commands
)
3275 executing_breakpoint_commands
= 1;
3276 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
3278 prevent_dont_repeat ();
3280 /* This pointer will iterate over the list of bpstat's. */
3283 breakpoint_proceeded
= 0;
3284 for (; bs
!= NULL
; bs
= bs
->next
)
3286 struct counted_command_line
*ccmd
;
3287 struct command_line
*cmd
;
3288 struct cleanup
*this_cmd_tree_chain
;
3290 /* Take ownership of the BSP's command tree, if it has one.
3292 The command tree could legitimately contain commands like
3293 'step' and 'next', which call clear_proceed_status, which
3294 frees stop_bpstat's command tree. To make sure this doesn't
3295 free the tree we're executing out from under us, we need to
3296 take ownership of the tree ourselves. Since a given bpstat's
3297 commands are only executed once, we don't need to copy it; we
3298 can clear the pointer in the bpstat, and make sure we free
3299 the tree when we're done. */
3300 ccmd
= bs
->commands
;
3301 bs
->commands
= NULL
;
3302 this_cmd_tree_chain
= make_cleanup_decref_counted_command_line (&ccmd
);
3303 cmd
= ccmd
? ccmd
->commands
: NULL
;
3304 if (command_line_is_silent (cmd
))
3306 /* The action has been already done by bpstat_stop_status. */
3312 execute_control_command (cmd
);
3314 if (breakpoint_proceeded
)
3320 /* We can free this command tree now. */
3321 do_cleanups (this_cmd_tree_chain
);
3323 if (breakpoint_proceeded
)
3325 if (target_can_async_p ())
3326 /* If we are in async mode, then the target might be still
3327 running, not stopped at any breakpoint, so nothing for
3328 us to do here -- just return to the event loop. */
3331 /* In sync mode, when execute_control_command returns
3332 we're already standing on the next breakpoint.
3333 Breakpoint commands for that stop were not run, since
3334 execute_command does not run breakpoint commands --
3335 only command_line_handler does, but that one is not
3336 involved in execution of breakpoint commands. So, we
3337 can now execute breakpoint commands. It should be
3338 noted that making execute_command do bpstat actions is
3339 not an option -- in this case we'll have recursive
3340 invocation of bpstat for each breakpoint with a
3341 command, and can easily blow up GDB stack. Instead, we
3342 return true, which will trigger the caller to recall us
3343 with the new stop_bpstat. */
3348 do_cleanups (old_chain
);
3353 bpstat_do_actions (void)
3355 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
3357 /* Do any commands attached to breakpoint we are stopped at. */
3358 while (!ptid_equal (inferior_ptid
, null_ptid
)
3359 && target_has_execution
3360 && !is_exited (inferior_ptid
)
3361 && !is_executing (inferior_ptid
))
3362 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3363 and only return when it is stopped at the next breakpoint, we
3364 keep doing breakpoint actions until it returns false to
3365 indicate the inferior was not resumed. */
3366 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
3369 discard_cleanups (cleanup_if_error
);
3372 /* Print out the (old or new) value associated with a watchpoint. */
3375 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
3378 fprintf_unfiltered (stream
, _("<unreadable>"));
3381 struct value_print_options opts
;
3382 get_user_print_options (&opts
);
3383 value_print (val
, stream
, &opts
);
3387 /* Generic routine for printing messages indicating why we
3388 stopped. The behavior of this function depends on the value
3389 'print_it' in the bpstat structure. Under some circumstances we
3390 may decide not to print anything here and delegate the task to
3393 static enum print_stop_action
3394 print_bp_stop_message (bpstat bs
)
3396 switch (bs
->print_it
)
3399 /* Nothing should be printed for this bpstat entry. */
3400 return PRINT_UNKNOWN
;
3404 /* We still want to print the frame, but we already printed the
3405 relevant messages. */
3406 return PRINT_SRC_AND_LOC
;
3409 case print_it_normal
:
3411 struct breakpoint
*b
= bs
->breakpoint_at
;
3413 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3414 which has since been deleted. */
3416 return PRINT_UNKNOWN
;
3418 /* Normal case. Call the breakpoint's print_it method. */
3419 return b
->ops
->print_it (bs
);
3424 internal_error (__FILE__
, __LINE__
,
3425 _("print_bp_stop_message: unrecognized enum value"));
3430 /* Print a message indicating what happened. This is called from
3431 normal_stop(). The input to this routine is the head of the bpstat
3432 list - a list of the eventpoints that caused this stop. This
3433 routine calls the generic print routine for printing a message
3434 about reasons for stopping. This will print (for example) the
3435 "Breakpoint n," part of the output. The return value of this
3438 PRINT_UNKNOWN: Means we printed nothing.
3439 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3440 code to print the location. An example is
3441 "Breakpoint 1, " which should be followed by
3443 PRINT_SRC_ONLY: Means we printed something, but there is no need
3444 to also print the location part of the message.
3445 An example is the catch/throw messages, which
3446 don't require a location appended to the end.
3447 PRINT_NOTHING: We have done some printing and we don't need any
3448 further info to be printed. */
3450 enum print_stop_action
3451 bpstat_print (bpstat bs
)
3455 /* Maybe another breakpoint in the chain caused us to stop.
3456 (Currently all watchpoints go on the bpstat whether hit or not.
3457 That probably could (should) be changed, provided care is taken
3458 with respect to bpstat_explains_signal). */
3459 for (; bs
; bs
= bs
->next
)
3461 val
= print_bp_stop_message (bs
);
3462 if (val
== PRINT_SRC_ONLY
3463 || val
== PRINT_SRC_AND_LOC
3464 || val
== PRINT_NOTHING
)
3468 /* We reached the end of the chain, or we got a null BS to start
3469 with and nothing was printed. */
3470 return PRINT_UNKNOWN
;
3473 /* Evaluate the expression EXP and return 1 if value is zero. This is
3474 used inside a catch_errors to evaluate the breakpoint condition.
3475 The argument is a "struct expression *" that has been cast to a
3476 "char *" to make it pass through catch_errors. */
3479 breakpoint_cond_eval (void *exp
)
3481 struct value
*mark
= value_mark ();
3482 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
3484 value_free_to_mark (mark
);
3488 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
3491 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
3495 bs
= (bpstat
) xmalloc (sizeof (*bs
));
3497 **bs_link_pointer
= bs
;
3498 *bs_link_pointer
= &bs
->next
;
3499 bs
->breakpoint_at
= bl
->owner
;
3500 bs
->bp_location_at
= bl
;
3501 incref_bp_location (bl
);
3502 /* If the condition is false, etc., don't do the commands. */
3503 bs
->commands
= NULL
;
3505 bs
->print_it
= print_it_normal
;
3509 /* The target has stopped with waitstatus WS. Check if any hardware
3510 watchpoints have triggered, according to the target. */
3513 watchpoints_triggered (struct target_waitstatus
*ws
)
3515 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3517 struct breakpoint
*b
;
3519 if (!stopped_by_watchpoint
)
3521 /* We were not stopped by a watchpoint. Mark all watchpoints
3522 as not triggered. */
3524 if (is_hardware_watchpoint (b
))
3526 struct watchpoint
*w
= (struct watchpoint
*) b
;
3528 w
->watchpoint_triggered
= watch_triggered_no
;
3534 if (!target_stopped_data_address (¤t_target
, &addr
))
3536 /* We were stopped by a watchpoint, but we don't know where.
3537 Mark all watchpoints as unknown. */
3539 if (is_hardware_watchpoint (b
))
3541 struct watchpoint
*w
= (struct watchpoint
*) b
;
3543 w
->watchpoint_triggered
= watch_triggered_unknown
;
3546 return stopped_by_watchpoint
;
3549 /* The target could report the data address. Mark watchpoints
3550 affected by this data address as triggered, and all others as not
3554 if (is_hardware_watchpoint (b
))
3556 struct watchpoint
*w
= (struct watchpoint
*) b
;
3557 struct bp_location
*loc
;
3559 w
->watchpoint_triggered
= watch_triggered_no
;
3560 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3562 if (is_masked_watchpoint (b
))
3564 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
3565 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
3567 if (newaddr
== start
)
3569 w
->watchpoint_triggered
= watch_triggered_yes
;
3573 /* Exact match not required. Within range is sufficient. */
3574 else if (target_watchpoint_addr_within_range (¤t_target
,
3578 w
->watchpoint_triggered
= watch_triggered_yes
;
3587 /* Possible return values for watchpoint_check (this can't be an enum
3588 because of check_errors). */
3589 /* The watchpoint has been deleted. */
3590 #define WP_DELETED 1
3591 /* The value has changed. */
3592 #define WP_VALUE_CHANGED 2
3593 /* The value has not changed. */
3594 #define WP_VALUE_NOT_CHANGED 3
3595 /* Ignore this watchpoint, no matter if the value changed or not. */
3598 #define BP_TEMPFLAG 1
3599 #define BP_HARDWAREFLAG 2
3601 /* Evaluate watchpoint condition expression and check if its value
3604 P should be a pointer to struct bpstat, but is defined as a void *
3605 in order for this function to be usable with catch_errors. */
3608 watchpoint_check (void *p
)
3610 bpstat bs
= (bpstat
) p
;
3611 struct watchpoint
*b
;
3612 struct frame_info
*fr
;
3613 int within_current_scope
;
3615 /* BS is built from an existing struct breakpoint. */
3616 gdb_assert (bs
->breakpoint_at
!= NULL
);
3617 b
= (struct watchpoint
*) bs
->breakpoint_at
;
3619 /* If this is a local watchpoint, we only want to check if the
3620 watchpoint frame is in scope if the current thread is the thread
3621 that was used to create the watchpoint. */
3622 if (!watchpoint_in_thread_scope (b
))
3625 if (b
->exp_valid_block
== NULL
)
3626 within_current_scope
= 1;
3629 struct frame_info
*frame
= get_current_frame ();
3630 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3631 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3633 /* in_function_epilogue_p() returns a non-zero value if we're
3634 still in the function but the stack frame has already been
3635 invalidated. Since we can't rely on the values of local
3636 variables after the stack has been destroyed, we are treating
3637 the watchpoint in that state as `not changed' without further
3638 checking. Don't mark watchpoints as changed if the current
3639 frame is in an epilogue - even if they are in some other
3640 frame, our view of the stack is likely to be wrong and
3641 frame_find_by_id could error out. */
3642 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3645 fr
= frame_find_by_id (b
->watchpoint_frame
);
3646 within_current_scope
= (fr
!= NULL
);
3648 /* If we've gotten confused in the unwinder, we might have
3649 returned a frame that can't describe this variable. */
3650 if (within_current_scope
)
3652 struct symbol
*function
;
3654 function
= get_frame_function (fr
);
3655 if (function
== NULL
3656 || !contained_in (b
->exp_valid_block
,
3657 SYMBOL_BLOCK_VALUE (function
)))
3658 within_current_scope
= 0;
3661 if (within_current_scope
)
3662 /* If we end up stopping, the current frame will get selected
3663 in normal_stop. So this call to select_frame won't affect
3668 if (within_current_scope
)
3670 /* We use value_{,free_to_}mark because it could be a *long*
3671 time before we return to the command level and call
3672 free_all_values. We can't call free_all_values because we
3673 might be in the middle of evaluating a function call. */
3677 struct value
*new_val
;
3679 if (is_masked_watchpoint (&b
->base
))
3680 /* Since we don't know the exact trigger address (from
3681 stopped_data_address), just tell the user we've triggered
3682 a mask watchpoint. */
3683 return WP_VALUE_CHANGED
;
3685 mark
= value_mark ();
3686 fetch_subexp_value (b
->exp
, &pc
, &new_val
, NULL
, NULL
);
3688 /* We use value_equal_contents instead of value_equal because
3689 the latter coerces an array to a pointer, thus comparing just
3690 the address of the array instead of its contents. This is
3691 not what we want. */
3692 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3693 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
3695 if (new_val
!= NULL
)
3697 release_value (new_val
);
3698 value_free_to_mark (mark
);
3700 bs
->old_val
= b
->val
;
3703 return WP_VALUE_CHANGED
;
3707 /* Nothing changed. */
3708 value_free_to_mark (mark
);
3709 return WP_VALUE_NOT_CHANGED
;
3714 struct ui_out
*uiout
= current_uiout
;
3716 /* This seems like the only logical thing to do because
3717 if we temporarily ignored the watchpoint, then when
3718 we reenter the block in which it is valid it contains
3719 garbage (in the case of a function, it may have two
3720 garbage values, one before and one after the prologue).
3721 So we can't even detect the first assignment to it and
3722 watch after that (since the garbage may or may not equal
3723 the first value assigned). */
3724 /* We print all the stop information in
3725 breakpoint_ops->print_it, but in this case, by the time we
3726 call breakpoint_ops->print_it this bp will be deleted
3727 already. So we have no choice but print the information
3729 if (ui_out_is_mi_like_p (uiout
))
3731 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3732 ui_out_text (uiout
, "\nWatchpoint ");
3733 ui_out_field_int (uiout
, "wpnum", b
->base
.number
);
3735 " deleted because the program has left the block in\n\
3736 which its expression is valid.\n");
3738 /* Make sure the watchpoint's commands aren't executed. */
3739 decref_counted_command_line (&b
->base
.commands
);
3740 watchpoint_del_at_next_stop (b
);
3746 /* Return true if it looks like target has stopped due to hitting
3747 breakpoint location BL. This function does not check if we should
3748 stop, only if BL explains the stop. */
3751 bpstat_check_location (const struct bp_location
*bl
,
3752 struct address_space
*aspace
, CORE_ADDR bp_addr
)
3754 struct breakpoint
*b
= bl
->owner
;
3756 /* BL is from an existing breakpoint. */
3757 gdb_assert (b
!= NULL
);
3759 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
);
3762 /* Determine if the watched values have actually changed, and we
3763 should stop. If not, set BS->stop to 0. */
3766 bpstat_check_watchpoint (bpstat bs
)
3768 const struct bp_location
*bl
;
3769 struct watchpoint
*b
;
3771 /* BS is built for existing struct breakpoint. */
3772 bl
= bs
->bp_location_at
;
3773 gdb_assert (bl
!= NULL
);
3774 b
= (struct watchpoint
*) bs
->breakpoint_at
;
3775 gdb_assert (b
!= NULL
);
3778 int must_check_value
= 0;
3780 if (b
->base
.type
== bp_watchpoint
)
3781 /* For a software watchpoint, we must always check the
3783 must_check_value
= 1;
3784 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3785 /* We have a hardware watchpoint (read, write, or access)
3786 and the target earlier reported an address watched by
3788 must_check_value
= 1;
3789 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3790 && b
->base
.type
== bp_hardware_watchpoint
)
3791 /* We were stopped by a hardware watchpoint, but the target could
3792 not report the data address. We must check the watchpoint's
3793 value. Access and read watchpoints are out of luck; without
3794 a data address, we can't figure it out. */
3795 must_check_value
= 1;
3797 if (must_check_value
)
3800 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3802 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3803 int e
= catch_errors (watchpoint_check
, bs
, message
,
3805 do_cleanups (cleanups
);
3809 /* We've already printed what needs to be printed. */
3810 bs
->print_it
= print_it_done
;
3814 bs
->print_it
= print_it_noop
;
3817 case WP_VALUE_CHANGED
:
3818 if (b
->base
.type
== bp_read_watchpoint
)
3820 /* There are two cases to consider here:
3822 1. We're watching the triggered memory for reads.
3823 In that case, trust the target, and always report
3824 the watchpoint hit to the user. Even though
3825 reads don't cause value changes, the value may
3826 have changed since the last time it was read, and
3827 since we're not trapping writes, we will not see
3828 those, and as such we should ignore our notion of
3831 2. We're watching the triggered memory for both
3832 reads and writes. There are two ways this may
3835 2.1. This is a target that can't break on data
3836 reads only, but can break on accesses (reads or
3837 writes), such as e.g., x86. We detect this case
3838 at the time we try to insert read watchpoints.
3840 2.2. Otherwise, the target supports read
3841 watchpoints, but, the user set an access or write
3842 watchpoint watching the same memory as this read
3845 If we're watching memory writes as well as reads,
3846 ignore watchpoint hits when we find that the
3847 value hasn't changed, as reads don't cause
3848 changes. This still gives false positives when
3849 the program writes the same value to memory as
3850 what there was already in memory (we will confuse
3851 it for a read), but it's much better than
3854 int other_write_watchpoint
= 0;
3856 if (bl
->watchpoint_type
== hw_read
)
3858 struct breakpoint
*other_b
;
3860 ALL_BREAKPOINTS (other_b
)
3861 if (other_b
->type
== bp_hardware_watchpoint
3862 || other_b
->type
== bp_access_watchpoint
)
3864 struct watchpoint
*other_w
=
3865 (struct watchpoint
*) other_b
;
3867 if (other_w
->watchpoint_triggered
3868 == watch_triggered_yes
)
3870 other_write_watchpoint
= 1;
3876 if (other_write_watchpoint
3877 || bl
->watchpoint_type
== hw_access
)
3879 /* We're watching the same memory for writes,
3880 and the value changed since the last time we
3881 updated it, so this trap must be for a write.
3883 bs
->print_it
= print_it_noop
;
3888 case WP_VALUE_NOT_CHANGED
:
3889 if (b
->base
.type
== bp_hardware_watchpoint
3890 || b
->base
.type
== bp_watchpoint
)
3892 /* Don't stop: write watchpoints shouldn't fire if
3893 the value hasn't changed. */
3894 bs
->print_it
= print_it_noop
;
3902 /* Error from catch_errors. */
3903 printf_filtered (_("Watchpoint %d deleted.\n"), b
->base
.number
);
3904 watchpoint_del_at_next_stop (b
);
3905 /* We've already printed what needs to be printed. */
3906 bs
->print_it
= print_it_done
;
3910 else /* must_check_value == 0 */
3912 /* This is a case where some watchpoint(s) triggered, but
3913 not at the address of this watchpoint, or else no
3914 watchpoint triggered after all. So don't print
3915 anything for this watchpoint. */
3916 bs
->print_it
= print_it_noop
;
3923 /* Check conditions (condition proper, frame, thread and ignore count)
3924 of breakpoint referred to by BS. If we should not stop for this
3925 breakpoint, set BS->stop to 0. */
3928 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
3930 int thread_id
= pid_to_thread_id (ptid
);
3931 const struct bp_location
*bl
;
3932 struct breakpoint
*b
;
3934 /* BS is built for existing struct breakpoint. */
3935 bl
= bs
->bp_location_at
;
3936 gdb_assert (bl
!= NULL
);
3937 b
= bs
->breakpoint_at
;
3938 gdb_assert (b
!= NULL
);
3940 if (frame_id_p (b
->frame_id
)
3941 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
3945 int value_is_zero
= 0;
3946 struct expression
*cond
;
3948 /* Evaluate Python breakpoints that have a "stop"
3949 method implemented. */
3950 if (b
->py_bp_object
)
3951 bs
->stop
= gdbpy_should_stop (b
->py_bp_object
);
3953 if (is_watchpoint (b
))
3955 struct watchpoint
*w
= (struct watchpoint
*) b
;
3962 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
3964 int within_current_scope
= 1;
3965 struct watchpoint
* w
;
3967 /* We use value_mark and value_free_to_mark because it could
3968 be a long time before we return to the command level and
3969 call free_all_values. We can't call free_all_values
3970 because we might be in the middle of evaluating a
3972 struct value
*mark
= value_mark ();
3974 if (is_watchpoint (b
))
3975 w
= (struct watchpoint
*) b
;
3979 /* Need to select the frame, with all that implies so that
3980 the conditions will have the right context. Because we
3981 use the frame, we will not see an inlined function's
3982 variables when we arrive at a breakpoint at the start
3983 of the inlined function; the current frame will be the
3985 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
3986 select_frame (get_current_frame ());
3989 struct frame_info
*frame
;
3991 /* For local watchpoint expressions, which particular
3992 instance of a local is being watched matters, so we
3993 keep track of the frame to evaluate the expression
3994 in. To evaluate the condition however, it doesn't
3995 really matter which instantiation of the function
3996 where the condition makes sense triggers the
3997 watchpoint. This allows an expression like "watch
3998 global if q > 10" set in `func', catch writes to
3999 global on all threads that call `func', or catch
4000 writes on all recursive calls of `func' by a single
4001 thread. We simply always evaluate the condition in
4002 the innermost frame that's executing where it makes
4003 sense to evaluate the condition. It seems
4005 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
4007 select_frame (frame
);
4009 within_current_scope
= 0;
4011 if (within_current_scope
)
4013 = catch_errors (breakpoint_cond_eval
, cond
,
4014 "Error in testing breakpoint condition:\n",
4018 warning (_("Watchpoint condition cannot be tested "
4019 "in the current scope"));
4020 /* If we failed to set the right context for this
4021 watchpoint, unconditionally report it. */
4024 /* FIXME-someday, should give breakpoint #. */
4025 value_free_to_mark (mark
);
4028 if (cond
&& value_is_zero
)
4032 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
4036 else if (b
->ignore_count
> 0)
4039 annotate_ignore_count_change ();
4041 /* Increase the hit count even though we don't stop. */
4043 observer_notify_breakpoint_modified (b
);
4049 /* Get a bpstat associated with having just stopped at address
4050 BP_ADDR in thread PTID.
4052 Determine whether we stopped at a breakpoint, etc, or whether we
4053 don't understand this stop. Result is a chain of bpstat's such
4056 if we don't understand the stop, the result is a null pointer.
4058 if we understand why we stopped, the result is not null.
4060 Each element of the chain refers to a particular breakpoint or
4061 watchpoint at which we have stopped. (We may have stopped for
4062 several reasons concurrently.)
4064 Each element of the chain has valid next, breakpoint_at,
4065 commands, FIXME??? fields. */
4068 bpstat_stop_status (struct address_space
*aspace
,
4069 CORE_ADDR bp_addr
, ptid_t ptid
)
4071 struct breakpoint
*b
= NULL
;
4072 struct bp_location
*bl
;
4073 struct bp_location
*loc
;
4074 /* First item of allocated bpstat's. */
4075 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
4076 /* Pointer to the last thing in the chain currently. */
4079 int need_remove_insert
;
4082 /* First, build the bpstat chain with locations that explain a
4083 target stop, while being careful to not set the target running,
4084 as that may invalidate locations (in particular watchpoint
4085 locations are recreated). Resuming will happen here with
4086 breakpoint conditions or watchpoint expressions that include
4087 inferior function calls. */
4091 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
4094 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
4096 /* For hardware watchpoints, we look only at the first
4097 location. The watchpoint_check function will work on the
4098 entire expression, not the individual locations. For
4099 read watchpoints, the watchpoints_triggered function has
4100 checked all locations already. */
4101 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
4104 if (bl
->shlib_disabled
)
4107 if (!bpstat_check_location (bl
, aspace
, bp_addr
))
4110 /* Come here if it's a watchpoint, or if the break address
4113 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
4116 /* Assume we stop. Should we find a watchpoint that is not
4117 actually triggered, or if the condition of the breakpoint
4118 evaluates as false, we'll reset 'stop' to 0. */
4122 /* If this is a scope breakpoint, mark the associated
4123 watchpoint as triggered so that we will handle the
4124 out-of-scope event. We'll get to the watchpoint next
4126 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
4128 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
4130 w
->watchpoint_triggered
= watch_triggered_yes
;
4135 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4137 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
))
4139 bs
= bpstat_alloc (loc
, &bs_link
);
4140 /* For hits of moribund locations, we should just proceed. */
4143 bs
->print_it
= print_it_noop
;
4147 /* Now go through the locations that caused the target to stop, and
4148 check whether we're interested in reporting this stop to higher
4149 layers, or whether we should resume the target transparently. */
4153 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4158 b
= bs
->breakpoint_at
;
4159 b
->ops
->check_status (bs
);
4162 bpstat_check_breakpoint_conditions (bs
, ptid
);
4167 observer_notify_breakpoint_modified (b
);
4169 /* We will stop here. */
4170 if (b
->disposition
== disp_disable
)
4172 if (b
->enable_state
!= bp_permanent
)
4173 b
->enable_state
= bp_disabled
;
4178 bs
->commands
= b
->commands
;
4179 incref_counted_command_line (bs
->commands
);
4180 if (command_line_is_silent (bs
->commands
4181 ? bs
->commands
->commands
: NULL
))
4185 /* Print nothing for this entry if we don't stop or don't print. */
4186 if (bs
->stop
== 0 || bs
->print
== 0)
4187 bs
->print_it
= print_it_noop
;
4191 /* If we aren't stopping, the value of some hardware watchpoint may
4192 not have changed, but the intermediate memory locations we are
4193 watching may have. Don't bother if we're stopping; this will get
4195 need_remove_insert
= 0;
4196 if (! bpstat_causes_stop (bs_head
))
4197 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4199 && bs
->breakpoint_at
4200 && is_hardware_watchpoint (bs
->breakpoint_at
))
4202 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
4204 update_watchpoint (w
, 0 /* don't reparse. */);
4205 need_remove_insert
= 1;
4208 if (need_remove_insert
)
4209 update_global_location_list (1);
4210 else if (removed_any
)
4211 update_global_location_list (0);
4217 handle_jit_event (void)
4219 struct frame_info
*frame
;
4220 struct gdbarch
*gdbarch
;
4222 /* Switch terminal for any messages produced by
4223 breakpoint_re_set. */
4224 target_terminal_ours_for_output ();
4226 frame
= get_current_frame ();
4227 gdbarch
= get_frame_arch (frame
);
4229 jit_event_handler (gdbarch
);
4231 target_terminal_inferior ();
4234 /* Prepare WHAT final decision for infrun. */
4236 /* Decide what infrun needs to do with this bpstat. */
4239 bpstat_what (bpstat bs_head
)
4241 struct bpstat_what retval
;
4242 /* We need to defer calling `solib_add', as adding new symbols
4243 resets breakpoints, which in turn deletes breakpoint locations,
4244 and hence may clear unprocessed entries in the BS chain. */
4245 int shlib_event
= 0;
4249 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4250 retval
.call_dummy
= STOP_NONE
;
4251 retval
.is_longjmp
= 0;
4253 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4255 /* Extract this BS's action. After processing each BS, we check
4256 if its action overrides all we've seem so far. */
4257 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4260 if (bs
->breakpoint_at
== NULL
)
4262 /* I suspect this can happen if it was a momentary
4263 breakpoint which has since been deleted. */
4267 bptype
= bs
->breakpoint_at
->type
;
4274 case bp_hardware_breakpoint
:
4280 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4282 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4285 this_action
= BPSTAT_WHAT_SINGLE
;
4288 case bp_hardware_watchpoint
:
4289 case bp_read_watchpoint
:
4290 case bp_access_watchpoint
:
4294 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4296 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4300 /* There was a watchpoint, but we're not stopping.
4301 This requires no further action. */
4306 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
4307 retval
.is_longjmp
= bptype
== bp_longjmp
;
4309 case bp_longjmp_resume
:
4310 case bp_exception_resume
:
4311 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
4312 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
4314 case bp_step_resume
:
4316 this_action
= BPSTAT_WHAT_STEP_RESUME
;
4319 /* It is for the wrong frame. */
4320 this_action
= BPSTAT_WHAT_SINGLE
;
4323 case bp_hp_step_resume
:
4325 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
4328 /* It is for the wrong frame. */
4329 this_action
= BPSTAT_WHAT_SINGLE
;
4332 case bp_watchpoint_scope
:
4333 case bp_thread_event
:
4334 case bp_overlay_event
:
4335 case bp_longjmp_master
:
4336 case bp_std_terminate_master
:
4337 case bp_exception_master
:
4338 this_action
= BPSTAT_WHAT_SINGLE
;
4344 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4346 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4350 /* There was a catchpoint, but we're not stopping.
4351 This requires no further action. */
4354 case bp_shlib_event
:
4357 /* If requested, stop when the dynamic linker notifies GDB
4358 of events. This allows the user to get control and place
4359 breakpoints in initializer routines for dynamically
4360 loaded objects (among other things). */
4361 if (stop_on_solib_events
)
4362 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4364 this_action
= BPSTAT_WHAT_SINGLE
;
4368 this_action
= BPSTAT_WHAT_SINGLE
;
4371 /* Make sure the action is stop (silent or noisy),
4372 so infrun.c pops the dummy frame. */
4373 retval
.call_dummy
= STOP_STACK_DUMMY
;
4374 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4376 case bp_std_terminate
:
4377 /* Make sure the action is stop (silent or noisy),
4378 so infrun.c pops the dummy frame. */
4379 retval
.call_dummy
= STOP_STD_TERMINATE
;
4380 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4383 case bp_fast_tracepoint
:
4384 case bp_static_tracepoint
:
4385 /* Tracepoint hits should not be reported back to GDB, and
4386 if one got through somehow, it should have been filtered
4388 internal_error (__FILE__
, __LINE__
,
4389 _("bpstat_what: tracepoint encountered"));
4391 case bp_gnu_ifunc_resolver
:
4392 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
4393 this_action
= BPSTAT_WHAT_SINGLE
;
4395 case bp_gnu_ifunc_resolver_return
:
4396 /* The breakpoint will be removed, execution will restart from the
4397 PC of the former breakpoint. */
4398 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4401 internal_error (__FILE__
, __LINE__
,
4402 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
4405 retval
.main_action
= max (retval
.main_action
, this_action
);
4408 /* These operations may affect the bs->breakpoint_at state so they are
4409 delayed after MAIN_ACTION is decided above. */
4414 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_shlib_event\n");
4416 /* Check for any newly added shared libraries if we're supposed
4417 to be adding them automatically. */
4419 /* Switch terminal for any messages produced by
4420 breakpoint_re_set. */
4421 target_terminal_ours_for_output ();
4424 SOLIB_ADD (NULL
, 0, ¤t_target
, auto_solib_add
);
4426 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
4429 target_terminal_inferior ();
4435 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_jit_event\n");
4437 handle_jit_event ();
4440 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4442 struct breakpoint
*b
= bs
->breakpoint_at
;
4448 case bp_gnu_ifunc_resolver
:
4449 gnu_ifunc_resolver_stop (b
);
4451 case bp_gnu_ifunc_resolver_return
:
4452 gnu_ifunc_resolver_return_stop (b
);
4460 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4461 without hardware support). This isn't related to a specific bpstat,
4462 just to things like whether watchpoints are set. */
4465 bpstat_should_step (void)
4467 struct breakpoint
*b
;
4470 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
4476 bpstat_causes_stop (bpstat bs
)
4478 for (; bs
!= NULL
; bs
= bs
->next
)
4487 /* Compute a string of spaces suitable to indent the next line
4488 so it starts at the position corresponding to the table column
4489 named COL_NAME in the currently active table of UIOUT. */
4492 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
4494 static char wrap_indent
[80];
4495 int i
, total_width
, width
, align
;
4499 for (i
= 1; ui_out_query_field (uiout
, i
, &width
, &align
, &text
); i
++)
4501 if (strcmp (text
, col_name
) == 0)
4503 gdb_assert (total_width
< sizeof wrap_indent
);
4504 memset (wrap_indent
, ' ', total_width
);
4505 wrap_indent
[total_width
] = 0;
4510 total_width
+= width
+ 1;
4516 /* Print the LOC location out of the list of B->LOC locations. */
4519 print_breakpoint_location (struct breakpoint
*b
,
4520 struct bp_location
*loc
)
4522 struct ui_out
*uiout
= current_uiout
;
4523 struct cleanup
*old_chain
= save_current_program_space ();
4525 if (loc
!= NULL
&& loc
->shlib_disabled
)
4529 set_current_program_space (loc
->pspace
);
4531 if (b
->display_canonical
)
4532 ui_out_field_string (uiout
, "what", b
->addr_string
);
4533 else if (b
->source_file
&& loc
)
4536 = find_pc_sect_function (loc
->address
, loc
->section
);
4539 ui_out_text (uiout
, "in ");
4540 ui_out_field_string (uiout
, "func",
4541 SYMBOL_PRINT_NAME (sym
));
4542 ui_out_text (uiout
, " ");
4543 ui_out_wrap_hint (uiout
, wrap_indent_at_field (uiout
, "what"));
4544 ui_out_text (uiout
, "at ");
4546 ui_out_field_string (uiout
, "file", b
->source_file
);
4547 ui_out_text (uiout
, ":");
4549 if (ui_out_is_mi_like_p (uiout
))
4551 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
4552 char *fullname
= symtab_to_fullname (sal
.symtab
);
4555 ui_out_field_string (uiout
, "fullname", fullname
);
4558 ui_out_field_int (uiout
, "line", b
->line_number
);
4562 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4563 struct cleanup
*stb_chain
= make_cleanup_ui_out_stream_delete (stb
);
4565 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
->stream
,
4567 ui_out_field_stream (uiout
, "at", stb
);
4569 do_cleanups (stb_chain
);
4572 ui_out_field_string (uiout
, "pending", b
->addr_string
);
4574 do_cleanups (old_chain
);
4578 bptype_string (enum bptype type
)
4580 struct ep_type_description
4585 static struct ep_type_description bptypes
[] =
4587 {bp_none
, "?deleted?"},
4588 {bp_breakpoint
, "breakpoint"},
4589 {bp_hardware_breakpoint
, "hw breakpoint"},
4590 {bp_until
, "until"},
4591 {bp_finish
, "finish"},
4592 {bp_watchpoint
, "watchpoint"},
4593 {bp_hardware_watchpoint
, "hw watchpoint"},
4594 {bp_read_watchpoint
, "read watchpoint"},
4595 {bp_access_watchpoint
, "acc watchpoint"},
4596 {bp_longjmp
, "longjmp"},
4597 {bp_longjmp_resume
, "longjmp resume"},
4598 {bp_exception
, "exception"},
4599 {bp_exception_resume
, "exception resume"},
4600 {bp_step_resume
, "step resume"},
4601 {bp_hp_step_resume
, "high-priority step resume"},
4602 {bp_watchpoint_scope
, "watchpoint scope"},
4603 {bp_call_dummy
, "call dummy"},
4604 {bp_std_terminate
, "std::terminate"},
4605 {bp_shlib_event
, "shlib events"},
4606 {bp_thread_event
, "thread events"},
4607 {bp_overlay_event
, "overlay events"},
4608 {bp_longjmp_master
, "longjmp master"},
4609 {bp_std_terminate_master
, "std::terminate master"},
4610 {bp_exception_master
, "exception master"},
4611 {bp_catchpoint
, "catchpoint"},
4612 {bp_tracepoint
, "tracepoint"},
4613 {bp_fast_tracepoint
, "fast tracepoint"},
4614 {bp_static_tracepoint
, "static tracepoint"},
4615 {bp_jit_event
, "jit events"},
4616 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
4617 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
4620 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
4621 || ((int) type
!= bptypes
[(int) type
].type
))
4622 internal_error (__FILE__
, __LINE__
,
4623 _("bptypes table does not describe type #%d."),
4626 return bptypes
[(int) type
].description
;
4629 /* Print B to gdb_stdout. */
4632 print_one_breakpoint_location (struct breakpoint
*b
,
4633 struct bp_location
*loc
,
4635 struct bp_location
**last_loc
,
4638 struct command_line
*l
;
4639 static char bpenables
[] = "nynny";
4641 struct ui_out
*uiout
= current_uiout
;
4642 int header_of_multiple
= 0;
4643 int part_of_multiple
= (loc
!= NULL
);
4644 struct value_print_options opts
;
4646 get_user_print_options (&opts
);
4648 gdb_assert (!loc
|| loc_number
!= 0);
4649 /* See comment in print_one_breakpoint concerning treatment of
4650 breakpoints with single disabled location. */
4653 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
4654 header_of_multiple
= 1;
4662 if (part_of_multiple
)
4665 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
4666 ui_out_field_string (uiout
, "number", formatted
);
4671 ui_out_field_int (uiout
, "number", b
->number
);
4676 if (part_of_multiple
)
4677 ui_out_field_skip (uiout
, "type");
4679 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
4683 if (part_of_multiple
)
4684 ui_out_field_skip (uiout
, "disp");
4686 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
4691 if (part_of_multiple
)
4692 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
4694 ui_out_field_fmt (uiout
, "enabled", "%c",
4695 bpenables
[(int) b
->enable_state
]);
4696 ui_out_spaces (uiout
, 2);
4700 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4702 /* Although the print_one can possibly print all locations,
4703 calling it here is not likely to get any nice result. So,
4704 make sure there's just one location. */
4705 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4706 b
->ops
->print_one (b
, last_loc
);
4712 internal_error (__FILE__
, __LINE__
,
4713 _("print_one_breakpoint: bp_none encountered\n"));
4717 case bp_hardware_watchpoint
:
4718 case bp_read_watchpoint
:
4719 case bp_access_watchpoint
:
4721 struct watchpoint
*w
= (struct watchpoint
*) b
;
4723 /* Field 4, the address, is omitted (which makes the columns
4724 not line up too nicely with the headers, but the effect
4725 is relatively readable). */
4726 if (opts
.addressprint
)
4727 ui_out_field_skip (uiout
, "addr");
4729 ui_out_field_string (uiout
, "what", w
->exp_string
);
4734 case bp_hardware_breakpoint
:
4738 case bp_longjmp_resume
:
4740 case bp_exception_resume
:
4741 case bp_step_resume
:
4742 case bp_hp_step_resume
:
4743 case bp_watchpoint_scope
:
4745 case bp_std_terminate
:
4746 case bp_shlib_event
:
4747 case bp_thread_event
:
4748 case bp_overlay_event
:
4749 case bp_longjmp_master
:
4750 case bp_std_terminate_master
:
4751 case bp_exception_master
:
4753 case bp_fast_tracepoint
:
4754 case bp_static_tracepoint
:
4756 case bp_gnu_ifunc_resolver
:
4757 case bp_gnu_ifunc_resolver_return
:
4758 if (opts
.addressprint
)
4761 if (header_of_multiple
)
4762 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4763 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4764 ui_out_field_string (uiout
, "addr", "<PENDING>");
4766 ui_out_field_core_addr (uiout
, "addr",
4767 loc
->gdbarch
, loc
->address
);
4770 if (!header_of_multiple
)
4771 print_breakpoint_location (b
, loc
);
4778 /* For backward compatibility, don't display inferiors unless there
4781 && !header_of_multiple
4783 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4784 && (number_of_program_spaces () > 1
4785 || number_of_inferiors () > 1)
4786 /* LOC is for existing B, it cannot be in
4787 moribund_locations and thus having NULL OWNER. */
4788 && loc
->owner
->type
!= bp_catchpoint
)))
4790 struct inferior
*inf
;
4793 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4795 if (inf
->pspace
== loc
->pspace
)
4800 ui_out_text (uiout
, " inf ");
4803 ui_out_text (uiout
, ", ");
4804 ui_out_text (uiout
, plongest (inf
->num
));
4809 if (!part_of_multiple
)
4811 if (b
->thread
!= -1)
4813 /* FIXME: This seems to be redundant and lost here; see the
4814 "stop only in" line a little further down. */
4815 ui_out_text (uiout
, " thread ");
4816 ui_out_field_int (uiout
, "thread", b
->thread
);
4818 else if (b
->task
!= 0)
4820 ui_out_text (uiout
, " task ");
4821 ui_out_field_int (uiout
, "task", b
->task
);
4825 ui_out_text (uiout
, "\n");
4827 if (!part_of_multiple
)
4828 b
->ops
->print_one_detail (b
, uiout
);
4830 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4833 ui_out_text (uiout
, "\tstop only in stack frame at ");
4834 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
4836 ui_out_field_core_addr (uiout
, "frame",
4837 b
->gdbarch
, b
->frame_id
.stack_addr
);
4838 ui_out_text (uiout
, "\n");
4841 if (!part_of_multiple
&& b
->cond_string
)
4844 if (is_tracepoint (b
))
4845 ui_out_text (uiout
, "\ttrace only if ");
4847 ui_out_text (uiout
, "\tstop only if ");
4848 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4849 ui_out_text (uiout
, "\n");
4852 if (!part_of_multiple
&& b
->thread
!= -1)
4854 /* FIXME should make an annotation for this. */
4855 ui_out_text (uiout
, "\tstop only in thread ");
4856 ui_out_field_int (uiout
, "thread", b
->thread
);
4857 ui_out_text (uiout
, "\n");
4860 if (!part_of_multiple
&& b
->hit_count
)
4862 /* FIXME should make an annotation for this. */
4863 if (ep_is_catchpoint (b
))
4864 ui_out_text (uiout
, "\tcatchpoint");
4866 ui_out_text (uiout
, "\tbreakpoint");
4867 ui_out_text (uiout
, " already hit ");
4868 ui_out_field_int (uiout
, "times", b
->hit_count
);
4869 if (b
->hit_count
== 1)
4870 ui_out_text (uiout
, " time\n");
4872 ui_out_text (uiout
, " times\n");
4875 /* Output the count also if it is zero, but only if this is mi.
4876 FIXME: Should have a better test for this. */
4877 if (ui_out_is_mi_like_p (uiout
))
4878 if (!part_of_multiple
&& b
->hit_count
== 0)
4879 ui_out_field_int (uiout
, "times", b
->hit_count
);
4881 if (!part_of_multiple
&& b
->ignore_count
)
4884 ui_out_text (uiout
, "\tignore next ");
4885 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
4886 ui_out_text (uiout
, " hits\n");
4889 l
= b
->commands
? b
->commands
->commands
: NULL
;
4890 if (!part_of_multiple
&& l
)
4892 struct cleanup
*script_chain
;
4895 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
4896 print_command_lines (uiout
, l
, 4);
4897 do_cleanups (script_chain
);
4900 if (is_tracepoint (b
))
4902 struct tracepoint
*t
= (struct tracepoint
*) b
;
4904 if (!part_of_multiple
&& t
->pass_count
)
4906 annotate_field (10);
4907 ui_out_text (uiout
, "\tpass count ");
4908 ui_out_field_int (uiout
, "pass", t
->pass_count
);
4909 ui_out_text (uiout
, " \n");
4913 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
4915 if (is_watchpoint (b
))
4917 struct watchpoint
*w
= (struct watchpoint
*) b
;
4919 ui_out_field_string (uiout
, "original-location", w
->exp_string
);
4921 else if (b
->addr_string
)
4922 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
4927 print_one_breakpoint (struct breakpoint
*b
,
4928 struct bp_location
**last_loc
,
4931 struct cleanup
*bkpt_chain
;
4932 struct ui_out
*uiout
= current_uiout
;
4934 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
4936 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
4937 do_cleanups (bkpt_chain
);
4939 /* If this breakpoint has custom print function,
4940 it's already printed. Otherwise, print individual
4941 locations, if any. */
4942 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
4944 /* If breakpoint has a single location that is disabled, we
4945 print it as if it had several locations, since otherwise it's
4946 hard to represent "breakpoint enabled, location disabled"
4949 Note that while hardware watchpoints have several locations
4950 internally, that's not a property exposed to user. */
4952 && !is_hardware_watchpoint (b
)
4953 && (b
->loc
->next
|| !b
->loc
->enabled
))
4955 struct bp_location
*loc
;
4958 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
4960 struct cleanup
*inner2
=
4961 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
4962 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
4963 do_cleanups (inner2
);
4970 breakpoint_address_bits (struct breakpoint
*b
)
4972 int print_address_bits
= 0;
4973 struct bp_location
*loc
;
4975 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
4979 /* Software watchpoints that aren't watching memory don't have
4980 an address to print. */
4981 if (b
->type
== bp_watchpoint
&& loc
->watchpoint_type
== -1)
4984 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
4985 if (addr_bit
> print_address_bits
)
4986 print_address_bits
= addr_bit
;
4989 return print_address_bits
;
4992 struct captured_breakpoint_query_args
4998 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
5000 struct captured_breakpoint_query_args
*args
= data
;
5001 struct breakpoint
*b
;
5002 struct bp_location
*dummy_loc
= NULL
;
5006 if (args
->bnum
== b
->number
)
5008 print_one_breakpoint (b
, &dummy_loc
, 0);
5016 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
5017 char **error_message
)
5019 struct captured_breakpoint_query_args args
;
5022 /* For the moment we don't trust print_one_breakpoint() to not throw
5024 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
5025 error_message
, RETURN_MASK_ALL
) < 0)
5031 /* Return true if this breakpoint was set by the user, false if it is
5032 internal or momentary. */
5035 user_breakpoint_p (struct breakpoint
*b
)
5037 return b
->number
> 0;
5040 /* Print information on user settable breakpoint (watchpoint, etc)
5041 number BNUM. If BNUM is -1 print all user-settable breakpoints.
5042 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
5043 FILTER is non-NULL, call it on each breakpoint and only include the
5044 ones for which it returns non-zero. Return the total number of
5045 breakpoints listed. */
5048 breakpoint_1 (char *args
, int allflag
,
5049 int (*filter
) (const struct breakpoint
*))
5051 struct breakpoint
*b
;
5052 struct bp_location
*last_loc
= NULL
;
5053 int nr_printable_breakpoints
;
5054 struct cleanup
*bkpttbl_chain
;
5055 struct value_print_options opts
;
5056 int print_address_bits
= 0;
5057 int print_type_col_width
= 14;
5058 struct ui_out
*uiout
= current_uiout
;
5060 get_user_print_options (&opts
);
5062 /* Compute the number of rows in the table, as well as the size
5063 required for address fields. */
5064 nr_printable_breakpoints
= 0;
5067 /* If we have a filter, only list the breakpoints it accepts. */
5068 if (filter
&& !filter (b
))
5071 /* If we have an "args" string, it is a list of breakpoints to
5072 accept. Skip the others. */
5073 if (args
!= NULL
&& *args
!= '\0')
5075 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
5077 if (!allflag
&& !number_is_in_list (args
, b
->number
))
5081 if (allflag
|| user_breakpoint_p (b
))
5083 int addr_bit
, type_len
;
5085 addr_bit
= breakpoint_address_bits (b
);
5086 if (addr_bit
> print_address_bits
)
5087 print_address_bits
= addr_bit
;
5089 type_len
= strlen (bptype_string (b
->type
));
5090 if (type_len
> print_type_col_width
)
5091 print_type_col_width
= type_len
;
5093 nr_printable_breakpoints
++;
5097 if (opts
.addressprint
)
5099 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
5100 nr_printable_breakpoints
,
5104 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
5105 nr_printable_breakpoints
,
5108 if (nr_printable_breakpoints
> 0)
5109 annotate_breakpoints_headers ();
5110 if (nr_printable_breakpoints
> 0)
5112 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
5113 if (nr_printable_breakpoints
> 0)
5115 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
5116 "type", "Type"); /* 2 */
5117 if (nr_printable_breakpoints
> 0)
5119 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
5120 if (nr_printable_breakpoints
> 0)
5122 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
5123 if (opts
.addressprint
)
5125 if (nr_printable_breakpoints
> 0)
5127 if (print_address_bits
<= 32)
5128 ui_out_table_header (uiout
, 10, ui_left
,
5129 "addr", "Address"); /* 5 */
5131 ui_out_table_header (uiout
, 18, ui_left
,
5132 "addr", "Address"); /* 5 */
5134 if (nr_printable_breakpoints
> 0)
5136 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
5137 ui_out_table_body (uiout
);
5138 if (nr_printable_breakpoints
> 0)
5139 annotate_breakpoints_table ();
5144 /* If we have a filter, only list the breakpoints it accepts. */
5145 if (filter
&& !filter (b
))
5148 /* If we have an "args" string, it is a list of breakpoints to
5149 accept. Skip the others. */
5151 if (args
!= NULL
&& *args
!= '\0')
5153 if (allflag
) /* maintenance info breakpoint */
5155 if (parse_and_eval_long (args
) != b
->number
)
5158 else /* all others */
5160 if (!number_is_in_list (args
, b
->number
))
5164 /* We only print out user settable breakpoints unless the
5166 if (allflag
|| user_breakpoint_p (b
))
5167 print_one_breakpoint (b
, &last_loc
, allflag
);
5170 do_cleanups (bkpttbl_chain
);
5172 if (nr_printable_breakpoints
== 0)
5174 /* If there's a filter, let the caller decide how to report
5178 if (args
== NULL
|| *args
== '\0')
5179 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
5181 ui_out_message (uiout
, 0,
5182 "No breakpoint or watchpoint matching '%s'.\n",
5188 if (last_loc
&& !server_command
)
5189 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
5192 /* FIXME? Should this be moved up so that it is only called when
5193 there have been breakpoints? */
5194 annotate_breakpoints_table_end ();
5196 return nr_printable_breakpoints
;
5199 /* Display the value of default-collect in a way that is generally
5200 compatible with the breakpoint list. */
5203 default_collect_info (void)
5205 struct ui_out
*uiout
= current_uiout
;
5207 /* If it has no value (which is frequently the case), say nothing; a
5208 message like "No default-collect." gets in user's face when it's
5210 if (!*default_collect
)
5213 /* The following phrase lines up nicely with per-tracepoint collect
5215 ui_out_text (uiout
, "default collect ");
5216 ui_out_field_string (uiout
, "default-collect", default_collect
);
5217 ui_out_text (uiout
, " \n");
5221 breakpoints_info (char *args
, int from_tty
)
5223 breakpoint_1 (args
, 0, NULL
);
5225 default_collect_info ();
5229 watchpoints_info (char *args
, int from_tty
)
5231 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
5232 struct ui_out
*uiout
= current_uiout
;
5234 if (num_printed
== 0)
5236 if (args
== NULL
|| *args
== '\0')
5237 ui_out_message (uiout
, 0, "No watchpoints.\n");
5239 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
5244 maintenance_info_breakpoints (char *args
, int from_tty
)
5246 breakpoint_1 (args
, 1, NULL
);
5248 default_collect_info ();
5252 breakpoint_has_pc (struct breakpoint
*b
,
5253 struct program_space
*pspace
,
5254 CORE_ADDR pc
, struct obj_section
*section
)
5256 struct bp_location
*bl
= b
->loc
;
5258 for (; bl
; bl
= bl
->next
)
5260 if (bl
->pspace
== pspace
5261 && bl
->address
== pc
5262 && (!overlay_debugging
|| bl
->section
== section
))
5268 /* Print a message describing any breakpoints set at PC. This
5269 concerns with logical breakpoints, so we match program spaces, not
5273 describe_other_breakpoints (struct gdbarch
*gdbarch
,
5274 struct program_space
*pspace
, CORE_ADDR pc
,
5275 struct obj_section
*section
, int thread
)
5278 struct breakpoint
*b
;
5281 others
+= breakpoint_has_pc (b
, pspace
, pc
, section
);
5285 printf_filtered (_("Note: breakpoint "));
5286 else /* if (others == ???) */
5287 printf_filtered (_("Note: breakpoints "));
5289 if (breakpoint_has_pc (b
, pspace
, pc
, section
))
5292 printf_filtered ("%d", b
->number
);
5293 if (b
->thread
== -1 && thread
!= -1)
5294 printf_filtered (" (all threads)");
5295 else if (b
->thread
!= -1)
5296 printf_filtered (" (thread %d)", b
->thread
);
5297 printf_filtered ("%s%s ",
5298 ((b
->enable_state
== bp_disabled
5299 || b
->enable_state
== bp_call_disabled
5300 || b
->enable_state
== bp_startup_disabled
)
5302 : b
->enable_state
== bp_permanent
5306 : ((others
== 1) ? " and" : ""));
5308 printf_filtered (_("also set at pc "));
5309 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
5310 printf_filtered (".\n");
5314 /* Set the default place to put a breakpoint
5315 for the `break' command with no arguments. */
5318 set_default_breakpoint (int valid
, struct program_space
*pspace
,
5319 CORE_ADDR addr
, struct symtab
*symtab
,
5322 default_breakpoint_valid
= valid
;
5323 default_breakpoint_pspace
= pspace
;
5324 default_breakpoint_address
= addr
;
5325 default_breakpoint_symtab
= symtab
;
5326 default_breakpoint_line
= line
;
5329 /* Return true iff it is meaningful to use the address member of
5330 BPT. For some breakpoint types, the address member is irrelevant
5331 and it makes no sense to attempt to compare it to other addresses
5332 (or use it for any other purpose either).
5334 More specifically, each of the following breakpoint types will
5335 always have a zero valued address and we don't want to mark
5336 breakpoints of any of these types to be a duplicate of an actual
5337 breakpoint at address zero:
5345 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
5347 enum bptype type
= bpt
->type
;
5349 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
5352 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5353 true if LOC1 and LOC2 represent the same watchpoint location. */
5356 watchpoint_locations_match (struct bp_location
*loc1
,
5357 struct bp_location
*loc2
)
5359 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
5360 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
5362 /* Both of them must exist. */
5363 gdb_assert (w1
!= NULL
);
5364 gdb_assert (w2
!= NULL
);
5366 /* If the target can evaluate the condition expression in hardware,
5367 then we we need to insert both watchpoints even if they are at
5368 the same place. Otherwise the watchpoint will only trigger when
5369 the condition of whichever watchpoint was inserted evaluates to
5370 true, not giving a chance for GDB to check the condition of the
5371 other watchpoint. */
5373 && target_can_accel_watchpoint_condition (loc1
->address
,
5375 loc1
->watchpoint_type
,
5378 && target_can_accel_watchpoint_condition (loc2
->address
,
5380 loc2
->watchpoint_type
,
5384 /* Note that this checks the owner's type, not the location's. In
5385 case the target does not support read watchpoints, but does
5386 support access watchpoints, we'll have bp_read_watchpoint
5387 watchpoints with hw_access locations. Those should be considered
5388 duplicates of hw_read locations. The hw_read locations will
5389 become hw_access locations later. */
5390 return (loc1
->owner
->type
== loc2
->owner
->type
5391 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
5392 && loc1
->address
== loc2
->address
5393 && loc1
->length
== loc2
->length
);
5396 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5397 same breakpoint location. In most targets, this can only be true
5398 if ASPACE1 matches ASPACE2. On targets that have global
5399 breakpoints, the address space doesn't really matter. */
5402 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
5403 struct address_space
*aspace2
, CORE_ADDR addr2
)
5405 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5406 || aspace1
== aspace2
)
5410 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
5411 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
5412 matches ASPACE2. On targets that have global breakpoints, the address
5413 space doesn't really matter. */
5416 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
5417 int len1
, struct address_space
*aspace2
,
5420 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5421 || aspace1
== aspace2
)
5422 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
5425 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
5426 a ranged breakpoint. In most targets, a match happens only if ASPACE
5427 matches the breakpoint's address space. On targets that have global
5428 breakpoints, the address space doesn't really matter. */
5431 breakpoint_location_address_match (struct bp_location
*bl
,
5432 struct address_space
*aspace
,
5435 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
5438 && breakpoint_address_match_range (bl
->pspace
->aspace
,
5439 bl
->address
, bl
->length
,
5443 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5444 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5445 represent the same location. */
5448 breakpoint_locations_match (struct bp_location
*loc1
,
5449 struct bp_location
*loc2
)
5451 int hw_point1
, hw_point2
;
5453 /* Both of them must not be in moribund_locations. */
5454 gdb_assert (loc1
->owner
!= NULL
);
5455 gdb_assert (loc2
->owner
!= NULL
);
5457 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
5458 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
5460 if (hw_point1
!= hw_point2
)
5463 return watchpoint_locations_match (loc1
, loc2
);
5465 /* We compare bp_location.length in order to cover ranged breakpoints. */
5466 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
5467 loc2
->pspace
->aspace
, loc2
->address
)
5468 && loc1
->length
== loc2
->length
);
5472 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
5473 int bnum
, int have_bnum
)
5475 /* The longest string possibly returned by hex_string_custom
5476 is 50 chars. These must be at least that big for safety. */
5480 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
5481 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
5483 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5484 bnum
, astr1
, astr2
);
5486 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
5489 /* Adjust a breakpoint's address to account for architectural
5490 constraints on breakpoint placement. Return the adjusted address.
5491 Note: Very few targets require this kind of adjustment. For most
5492 targets, this function is simply the identity function. */
5495 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
5496 CORE_ADDR bpaddr
, enum bptype bptype
)
5498 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
5500 /* Very few targets need any kind of breakpoint adjustment. */
5503 else if (bptype
== bp_watchpoint
5504 || bptype
== bp_hardware_watchpoint
5505 || bptype
== bp_read_watchpoint
5506 || bptype
== bp_access_watchpoint
5507 || bptype
== bp_catchpoint
)
5509 /* Watchpoints and the various bp_catch_* eventpoints should not
5510 have their addresses modified. */
5515 CORE_ADDR adjusted_bpaddr
;
5517 /* Some targets have architectural constraints on the placement
5518 of breakpoint instructions. Obtain the adjusted address. */
5519 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
5521 /* An adjusted breakpoint address can significantly alter
5522 a user's expectations. Print a warning if an adjustment
5524 if (adjusted_bpaddr
!= bpaddr
)
5525 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
5527 return adjusted_bpaddr
;
5532 init_bp_location (struct bp_location
*loc
, const struct bp_location_ops
*ops
,
5533 struct breakpoint
*owner
)
5535 memset (loc
, 0, sizeof (*loc
));
5537 gdb_assert (ops
!= NULL
);
5542 loc
->shlib_disabled
= 0;
5545 switch (owner
->type
)
5551 case bp_longjmp_resume
:
5553 case bp_exception_resume
:
5554 case bp_step_resume
:
5555 case bp_hp_step_resume
:
5556 case bp_watchpoint_scope
:
5558 case bp_std_terminate
:
5559 case bp_shlib_event
:
5560 case bp_thread_event
:
5561 case bp_overlay_event
:
5563 case bp_longjmp_master
:
5564 case bp_std_terminate_master
:
5565 case bp_exception_master
:
5566 case bp_gnu_ifunc_resolver
:
5567 case bp_gnu_ifunc_resolver_return
:
5568 loc
->loc_type
= bp_loc_software_breakpoint
;
5570 case bp_hardware_breakpoint
:
5571 loc
->loc_type
= bp_loc_hardware_breakpoint
;
5573 case bp_hardware_watchpoint
:
5574 case bp_read_watchpoint
:
5575 case bp_access_watchpoint
:
5576 loc
->loc_type
= bp_loc_hardware_watchpoint
;
5581 case bp_fast_tracepoint
:
5582 case bp_static_tracepoint
:
5583 loc
->loc_type
= bp_loc_other
;
5586 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
5592 /* Allocate a struct bp_location. */
5594 static struct bp_location
*
5595 allocate_bp_location (struct breakpoint
*bpt
)
5597 return bpt
->ops
->allocate_location (bpt
);
5601 free_bp_location (struct bp_location
*loc
)
5603 loc
->ops
->dtor (loc
);
5607 /* Increment reference count. */
5610 incref_bp_location (struct bp_location
*bl
)
5615 /* Decrement reference count. If the reference count reaches 0,
5616 destroy the bp_location. Sets *BLP to NULL. */
5619 decref_bp_location (struct bp_location
**blp
)
5621 gdb_assert ((*blp
)->refc
> 0);
5623 if (--(*blp
)->refc
== 0)
5624 free_bp_location (*blp
);
5628 /* Add breakpoint B at the end of the global breakpoint chain. */
5631 add_to_breakpoint_chain (struct breakpoint
*b
)
5633 struct breakpoint
*b1
;
5635 /* Add this breakpoint to the end of the chain so that a list of
5636 breakpoints will come out in order of increasing numbers. */
5638 b1
= breakpoint_chain
;
5640 breakpoint_chain
= b
;
5649 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
5652 init_raw_breakpoint_without_location (struct breakpoint
*b
,
5653 struct gdbarch
*gdbarch
,
5655 const struct breakpoint_ops
*ops
)
5657 memset (b
, 0, sizeof (*b
));
5659 gdb_assert (ops
!= NULL
);
5663 b
->gdbarch
= gdbarch
;
5664 b
->language
= current_language
->la_language
;
5665 b
->input_radix
= input_radix
;
5667 b
->enable_state
= bp_enabled
;
5670 b
->ignore_count
= 0;
5672 b
->frame_id
= null_frame_id
;
5673 b
->condition_not_parsed
= 0;
5674 b
->py_bp_object
= NULL
;
5675 b
->related_breakpoint
= b
;
5678 /* Helper to set_raw_breakpoint below. Creates a breakpoint
5679 that has type BPTYPE and has no locations as yet. */
5681 static struct breakpoint
*
5682 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
5684 const struct breakpoint_ops
*ops
)
5686 struct breakpoint
*b
= XNEW (struct breakpoint
);
5688 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
5689 add_to_breakpoint_chain (b
);
5693 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
5694 resolutions should be made as the user specified the location explicitly
5698 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
5700 gdb_assert (loc
->owner
!= NULL
);
5702 if (loc
->owner
->type
== bp_breakpoint
5703 || loc
->owner
->type
== bp_hardware_breakpoint
5704 || is_tracepoint (loc
->owner
))
5708 find_pc_partial_function_gnu_ifunc (loc
->address
, &loc
->function_name
,
5709 NULL
, NULL
, &is_gnu_ifunc
);
5711 if (is_gnu_ifunc
&& !explicit_loc
)
5713 struct breakpoint
*b
= loc
->owner
;
5715 gdb_assert (loc
->pspace
== current_program_space
);
5716 if (gnu_ifunc_resolve_name (loc
->function_name
,
5717 &loc
->requested_address
))
5719 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
5720 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
5721 loc
->requested_address
,
5724 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
5725 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
5727 /* Create only the whole new breakpoint of this type but do not
5728 mess more complicated breakpoints with multiple locations. */
5729 b
->type
= bp_gnu_ifunc_resolver
;
5733 if (loc
->function_name
)
5734 loc
->function_name
= xstrdup (loc
->function_name
);
5738 /* Attempt to determine architecture of location identified by SAL. */
5739 static struct gdbarch
*
5740 get_sal_arch (struct symtab_and_line sal
)
5743 return get_objfile_arch (sal
.section
->objfile
);
5745 return get_objfile_arch (sal
.symtab
->objfile
);
5750 /* Low level routine for partially initializing a breakpoint of type
5751 BPTYPE. The newly created breakpoint's address, section, source
5752 file name, and line number are provided by SAL.
5754 It is expected that the caller will complete the initialization of
5755 the newly created breakpoint struct as well as output any status
5756 information regarding the creation of a new breakpoint. */
5759 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
5760 struct symtab_and_line sal
, enum bptype bptype
,
5761 const struct breakpoint_ops
*ops
)
5763 CORE_ADDR adjusted_address
;
5764 struct gdbarch
*loc_gdbarch
;
5766 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
5768 loc_gdbarch
= get_sal_arch (sal
);
5770 loc_gdbarch
= b
->gdbarch
;
5772 if (bptype
!= bp_catchpoint
)
5773 gdb_assert (sal
.pspace
!= NULL
);
5775 /* Adjust the breakpoint's address prior to allocating a location.
5776 Once we call allocate_bp_location(), that mostly uninitialized
5777 location will be placed on the location chain. Adjustment of the
5778 breakpoint may cause target_read_memory() to be called and we do
5779 not want its scan of the location chain to find a breakpoint and
5780 location that's only been partially initialized. */
5781 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
5784 b
->loc
= allocate_bp_location (b
);
5785 b
->loc
->gdbarch
= loc_gdbarch
;
5786 b
->loc
->requested_address
= sal
.pc
;
5787 b
->loc
->address
= adjusted_address
;
5788 b
->loc
->pspace
= sal
.pspace
;
5790 /* Store the program space that was used to set the breakpoint, for
5791 breakpoint resetting. */
5792 b
->pspace
= sal
.pspace
;
5794 if (sal
.symtab
== NULL
)
5795 b
->source_file
= NULL
;
5797 b
->source_file
= xstrdup (sal
.symtab
->filename
);
5798 b
->loc
->section
= sal
.section
;
5799 b
->line_number
= sal
.line
;
5801 set_breakpoint_location_function (b
->loc
,
5802 sal
.explicit_pc
|| sal
.explicit_line
);
5804 breakpoints_changed ();
5807 /* set_raw_breakpoint is a low level routine for allocating and
5808 partially initializing a breakpoint of type BPTYPE. The newly
5809 created breakpoint's address, section, source file name, and line
5810 number are provided by SAL. The newly created and partially
5811 initialized breakpoint is added to the breakpoint chain and
5812 is also returned as the value of this function.
5814 It is expected that the caller will complete the initialization of
5815 the newly created breakpoint struct as well as output any status
5816 information regarding the creation of a new breakpoint. In
5817 particular, set_raw_breakpoint does NOT set the breakpoint
5818 number! Care should be taken to not allow an error to occur
5819 prior to completing the initialization of the breakpoint. If this
5820 should happen, a bogus breakpoint will be left on the chain. */
5823 set_raw_breakpoint (struct gdbarch
*gdbarch
,
5824 struct symtab_and_line sal
, enum bptype bptype
,
5825 const struct breakpoint_ops
*ops
)
5827 struct breakpoint
*b
= XNEW (struct breakpoint
);
5829 init_raw_breakpoint (b
, gdbarch
, sal
, bptype
, ops
);
5830 add_to_breakpoint_chain (b
);
5835 /* Note that the breakpoint object B describes a permanent breakpoint
5836 instruction, hard-wired into the inferior's code. */
5838 make_breakpoint_permanent (struct breakpoint
*b
)
5840 struct bp_location
*bl
;
5842 b
->enable_state
= bp_permanent
;
5844 /* By definition, permanent breakpoints are already present in the
5845 code. Mark all locations as inserted. For now,
5846 make_breakpoint_permanent is called in just one place, so it's
5847 hard to say if it's reasonable to have permanent breakpoint with
5848 multiple locations or not, but it's easy to implement. */
5849 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5853 /* Call this routine when stepping and nexting to enable a breakpoint
5854 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
5855 initiated the operation. */
5858 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
5860 struct breakpoint
*b
, *b_tmp
;
5861 int thread
= tp
->num
;
5863 /* To avoid having to rescan all objfile symbols at every step,
5864 we maintain a list of continually-inserted but always disabled
5865 longjmp "master" breakpoints. Here, we simply create momentary
5866 clones of those and enable them for the requested thread. */
5867 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5868 if (b
->pspace
== current_program_space
5869 && (b
->type
== bp_longjmp_master
5870 || b
->type
== bp_exception_master
))
5872 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
5873 struct breakpoint
*clone
;
5875 clone
= momentary_breakpoint_from_master (b
, type
,
5876 &momentary_breakpoint_ops
);
5877 clone
->thread
= thread
;
5880 tp
->initiating_frame
= frame
;
5883 /* Delete all longjmp breakpoints from THREAD. */
5885 delete_longjmp_breakpoint (int thread
)
5887 struct breakpoint
*b
, *b_tmp
;
5889 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5890 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
5892 if (b
->thread
== thread
)
5893 delete_breakpoint (b
);
5898 enable_overlay_breakpoints (void)
5900 struct breakpoint
*b
;
5903 if (b
->type
== bp_overlay_event
)
5905 b
->enable_state
= bp_enabled
;
5906 update_global_location_list (1);
5907 overlay_events_enabled
= 1;
5912 disable_overlay_breakpoints (void)
5914 struct breakpoint
*b
;
5917 if (b
->type
== bp_overlay_event
)
5919 b
->enable_state
= bp_disabled
;
5920 update_global_location_list (0);
5921 overlay_events_enabled
= 0;
5925 /* Set an active std::terminate breakpoint for each std::terminate
5926 master breakpoint. */
5928 set_std_terminate_breakpoint (void)
5930 struct breakpoint
*b
, *b_tmp
;
5932 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5933 if (b
->pspace
== current_program_space
5934 && b
->type
== bp_std_terminate_master
)
5936 momentary_breakpoint_from_master (b
, bp_std_terminate
,
5937 &momentary_breakpoint_ops
);
5941 /* Delete all the std::terminate breakpoints. */
5943 delete_std_terminate_breakpoint (void)
5945 struct breakpoint
*b
, *b_tmp
;
5947 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5948 if (b
->type
== bp_std_terminate
)
5949 delete_breakpoint (b
);
5953 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5955 struct breakpoint
*b
;
5957 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
5958 &internal_breakpoint_ops
);
5960 b
->enable_state
= bp_enabled
;
5961 /* addr_string has to be used or breakpoint_re_set will delete me. */
5963 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
5965 update_global_location_list_nothrow (1);
5971 remove_thread_event_breakpoints (void)
5973 struct breakpoint
*b
, *b_tmp
;
5975 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5976 if (b
->type
== bp_thread_event
5977 && b
->loc
->pspace
== current_program_space
)
5978 delete_breakpoint (b
);
5981 struct lang_and_radix
5987 /* Create a breakpoint for JIT code registration and unregistration. */
5990 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5992 struct breakpoint
*b
;
5994 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
5995 &internal_breakpoint_ops
);
5996 update_global_location_list_nothrow (1);
6000 /* Remove JIT code registration and unregistration breakpoint(s). */
6003 remove_jit_event_breakpoints (void)
6005 struct breakpoint
*b
, *b_tmp
;
6007 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6008 if (b
->type
== bp_jit_event
6009 && b
->loc
->pspace
== current_program_space
)
6010 delete_breakpoint (b
);
6014 remove_solib_event_breakpoints (void)
6016 struct breakpoint
*b
, *b_tmp
;
6018 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6019 if (b
->type
== bp_shlib_event
6020 && b
->loc
->pspace
== current_program_space
)
6021 delete_breakpoint (b
);
6025 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6027 struct breakpoint
*b
;
6029 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
6030 &internal_breakpoint_ops
);
6031 update_global_location_list_nothrow (1);
6035 /* Disable any breakpoints that are on code in shared libraries. Only
6036 apply to enabled breakpoints, disabled ones can just stay disabled. */
6039 disable_breakpoints_in_shlibs (void)
6041 struct bp_location
*loc
, **locp_tmp
;
6043 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6045 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6046 struct breakpoint
*b
= loc
->owner
;
6048 /* We apply the check to all breakpoints, including disabled for
6049 those with loc->duplicate set. This is so that when breakpoint
6050 becomes enabled, or the duplicate is removed, gdb will try to
6051 insert all breakpoints. If we don't set shlib_disabled here,
6052 we'll try to insert those breakpoints and fail. */
6053 if (((b
->type
== bp_breakpoint
)
6054 || (b
->type
== bp_jit_event
)
6055 || (b
->type
== bp_hardware_breakpoint
)
6056 || (is_tracepoint (b
)))
6057 && loc
->pspace
== current_program_space
6058 && !loc
->shlib_disabled
6060 && PC_SOLIB (loc
->address
)
6062 && solib_name_from_address (loc
->pspace
, loc
->address
)
6066 loc
->shlib_disabled
= 1;
6071 /* Disable any breakpoints that are in an unloaded shared library.
6072 Only apply to enabled breakpoints, disabled ones can just stay
6076 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
6078 struct bp_location
*loc
, **locp_tmp
;
6079 int disabled_shlib_breaks
= 0;
6081 /* SunOS a.out shared libraries are always mapped, so do not
6082 disable breakpoints; they will only be reported as unloaded
6083 through clear_solib when GDB discards its shared library
6084 list. See clear_solib for more information. */
6085 if (exec_bfd
!= NULL
6086 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
6089 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6091 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6092 struct breakpoint
*b
= loc
->owner
;
6094 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
6095 || loc
->loc_type
== bp_loc_software_breakpoint
)
6096 && solib
->pspace
== loc
->pspace
6097 && !loc
->shlib_disabled
6098 && (b
->type
== bp_breakpoint
6099 || b
->type
== bp_jit_event
6100 || b
->type
== bp_hardware_breakpoint
)
6101 && solib_contains_address_p (solib
, loc
->address
))
6103 loc
->shlib_disabled
= 1;
6104 /* At this point, we cannot rely on remove_breakpoint
6105 succeeding so we must mark the breakpoint as not inserted
6106 to prevent future errors occurring in remove_breakpoints. */
6109 /* This may cause duplicate notifications for the same breakpoint. */
6110 observer_notify_breakpoint_modified (b
);
6112 if (!disabled_shlib_breaks
)
6114 target_terminal_ours_for_output ();
6115 warning (_("Temporarily disabling breakpoints "
6116 "for unloaded shared library \"%s\""),
6119 disabled_shlib_breaks
= 1;
6124 /* FORK & VFORK catchpoints. */
6126 /* An instance of this type is used to represent a fork or vfork
6127 catchpoint. It includes a "struct breakpoint" as a kind of base
6128 class; users downcast to "struct breakpoint *" when needed. A
6129 breakpoint is really of this type iff its ops pointer points to
6130 CATCH_FORK_BREAKPOINT_OPS. */
6132 struct fork_catchpoint
6134 /* The base class. */
6135 struct breakpoint base
;
6137 /* Process id of a child process whose forking triggered this
6138 catchpoint. This field is only valid immediately after this
6139 catchpoint has triggered. */
6140 ptid_t forked_inferior_pid
;
6143 /* Implement the "insert" breakpoint_ops method for fork
6147 insert_catch_fork (struct bp_location
*bl
)
6149 return target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
6152 /* Implement the "remove" breakpoint_ops method for fork
6156 remove_catch_fork (struct bp_location
*bl
)
6158 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
6161 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6165 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
6166 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6168 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
6170 return inferior_has_forked (inferior_ptid
, &c
->forked_inferior_pid
);
6173 /* Implement the "print_it" breakpoint_ops method for fork
6176 static enum print_stop_action
6177 print_it_catch_fork (bpstat bs
)
6179 struct breakpoint
*b
= bs
->breakpoint_at
;
6180 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
6182 annotate_catchpoint (b
->number
);
6183 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
6184 b
->number
, ptid_get_pid (c
->forked_inferior_pid
));
6185 return PRINT_SRC_AND_LOC
;
6188 /* Implement the "print_one" breakpoint_ops method for fork
6192 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6194 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6195 struct value_print_options opts
;
6196 struct ui_out
*uiout
= current_uiout
;
6198 get_user_print_options (&opts
);
6200 /* Field 4, the address, is omitted (which makes the columns not
6201 line up too nicely with the headers, but the effect is relatively
6203 if (opts
.addressprint
)
6204 ui_out_field_skip (uiout
, "addr");
6206 ui_out_text (uiout
, "fork");
6207 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
6209 ui_out_text (uiout
, ", process ");
6210 ui_out_field_int (uiout
, "what",
6211 ptid_get_pid (c
->forked_inferior_pid
));
6212 ui_out_spaces (uiout
, 1);
6216 /* Implement the "print_mention" breakpoint_ops method for fork
6220 print_mention_catch_fork (struct breakpoint
*b
)
6222 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
6225 /* Implement the "print_recreate" breakpoint_ops method for fork
6229 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
6231 fprintf_unfiltered (fp
, "catch fork");
6232 print_recreate_thread (b
, fp
);
6235 /* The breakpoint_ops structure to be used in fork catchpoints. */
6237 static struct breakpoint_ops catch_fork_breakpoint_ops
;
6239 /* Implement the "insert" breakpoint_ops method for vfork
6243 insert_catch_vfork (struct bp_location
*bl
)
6245 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
6248 /* Implement the "remove" breakpoint_ops method for vfork
6252 remove_catch_vfork (struct bp_location
*bl
)
6254 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
6257 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6261 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
6262 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6264 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
6266 return inferior_has_vforked (inferior_ptid
, &c
->forked_inferior_pid
);
6269 /* Implement the "print_it" breakpoint_ops method for vfork
6272 static enum print_stop_action
6273 print_it_catch_vfork (bpstat bs
)
6275 struct breakpoint
*b
= bs
->breakpoint_at
;
6276 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6278 annotate_catchpoint (b
->number
);
6279 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
6280 b
->number
, ptid_get_pid (c
->forked_inferior_pid
));
6281 return PRINT_SRC_AND_LOC
;
6284 /* Implement the "print_one" breakpoint_ops method for vfork
6288 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6290 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6291 struct value_print_options opts
;
6292 struct ui_out
*uiout
= current_uiout
;
6294 get_user_print_options (&opts
);
6295 /* Field 4, the address, is omitted (which makes the columns not
6296 line up too nicely with the headers, but the effect is relatively
6298 if (opts
.addressprint
)
6299 ui_out_field_skip (uiout
, "addr");
6301 ui_out_text (uiout
, "vfork");
6302 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
6304 ui_out_text (uiout
, ", process ");
6305 ui_out_field_int (uiout
, "what",
6306 ptid_get_pid (c
->forked_inferior_pid
));
6307 ui_out_spaces (uiout
, 1);
6311 /* Implement the "print_mention" breakpoint_ops method for vfork
6315 print_mention_catch_vfork (struct breakpoint
*b
)
6317 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
6320 /* Implement the "print_recreate" breakpoint_ops method for vfork
6324 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
6326 fprintf_unfiltered (fp
, "catch vfork");
6327 print_recreate_thread (b
, fp
);
6330 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6332 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
6334 /* An instance of this type is used to represent a syscall catchpoint.
6335 It includes a "struct breakpoint" as a kind of base class; users
6336 downcast to "struct breakpoint *" when needed. A breakpoint is
6337 really of this type iff its ops pointer points to
6338 CATCH_SYSCALL_BREAKPOINT_OPS. */
6340 struct syscall_catchpoint
6342 /* The base class. */
6343 struct breakpoint base
;
6345 /* Syscall numbers used for the 'catch syscall' feature. If no
6346 syscall has been specified for filtering, its value is NULL.
6347 Otherwise, it holds a list of all syscalls to be caught. The
6348 list elements are allocated with xmalloc. */
6349 VEC(int) *syscalls_to_be_caught
;
6352 /* Implement the "dtor" breakpoint_ops method for syscall
6356 dtor_catch_syscall (struct breakpoint
*b
)
6358 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6360 VEC_free (int, c
->syscalls_to_be_caught
);
6362 base_breakpoint_ops
.dtor (b
);
6365 /* Implement the "insert" breakpoint_ops method for syscall
6369 insert_catch_syscall (struct bp_location
*bl
)
6371 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bl
->owner
;
6372 struct inferior
*inf
= current_inferior ();
6374 ++inf
->total_syscalls_count
;
6375 if (!c
->syscalls_to_be_caught
)
6376 ++inf
->any_syscall_count
;
6382 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6387 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6389 int old_size
= VEC_length (int, inf
->syscalls_counts
);
6390 uintptr_t vec_addr_offset
6391 = old_size
* ((uintptr_t) sizeof (int));
6393 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
6394 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
6396 memset ((void *) vec_addr
, 0,
6397 (iter
+ 1 - old_size
) * sizeof (int));
6399 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6400 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
6404 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6405 inf
->total_syscalls_count
!= 0,
6406 inf
->any_syscall_count
,
6407 VEC_length (int, inf
->syscalls_counts
),
6408 VEC_address (int, inf
->syscalls_counts
));
6411 /* Implement the "remove" breakpoint_ops method for syscall
6415 remove_catch_syscall (struct bp_location
*bl
)
6417 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bl
->owner
;
6418 struct inferior
*inf
= current_inferior ();
6420 --inf
->total_syscalls_count
;
6421 if (!c
->syscalls_to_be_caught
)
6422 --inf
->any_syscall_count
;
6428 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6432 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6433 /* Shouldn't happen. */
6435 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6436 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
6440 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6441 inf
->total_syscalls_count
!= 0,
6442 inf
->any_syscall_count
,
6443 VEC_length (int, inf
->syscalls_counts
),
6445 inf
->syscalls_counts
));
6448 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6452 breakpoint_hit_catch_syscall (const struct bp_location
*bl
,
6453 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6455 /* We must check if we are catching specific syscalls in this
6456 breakpoint. If we are, then we must guarantee that the called
6457 syscall is the same syscall we are catching. */
6458 int syscall_number
= 0;
6459 const struct syscall_catchpoint
*c
6460 = (const struct syscall_catchpoint
*) bl
->owner
;
6462 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
6465 /* Now, checking if the syscall is the same. */
6466 if (c
->syscalls_to_be_caught
)
6471 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6473 if (syscall_number
== iter
)
6483 /* Implement the "print_it" breakpoint_ops method for syscall
6486 static enum print_stop_action
6487 print_it_catch_syscall (bpstat bs
)
6489 struct breakpoint
*b
= bs
->breakpoint_at
;
6490 /* These are needed because we want to know in which state a
6491 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6492 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6493 must print "called syscall" or "returned from syscall". */
6495 struct target_waitstatus last
;
6497 struct cleanup
*old_chain
;
6500 get_last_target_status (&ptid
, &last
);
6502 get_syscall_by_number (last
.value
.syscall_number
, &s
);
6504 annotate_catchpoint (b
->number
);
6507 syscall_id
= xstrprintf ("%d", last
.value
.syscall_number
);
6509 syscall_id
= xstrprintf ("'%s'", s
.name
);
6511 old_chain
= make_cleanup (xfree
, syscall_id
);
6513 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
6514 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
6515 b
->number
, syscall_id
);
6516 else if (last
.kind
== TARGET_WAITKIND_SYSCALL_RETURN
)
6517 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
6518 b
->number
, syscall_id
);
6520 do_cleanups (old_chain
);
6522 return PRINT_SRC_AND_LOC
;
6525 /* Implement the "print_one" breakpoint_ops method for syscall
6529 print_one_catch_syscall (struct breakpoint
*b
,
6530 struct bp_location
**last_loc
)
6532 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6533 struct value_print_options opts
;
6534 struct ui_out
*uiout
= current_uiout
;
6536 get_user_print_options (&opts
);
6537 /* Field 4, the address, is omitted (which makes the columns not
6538 line up too nicely with the headers, but the effect is relatively
6540 if (opts
.addressprint
)
6541 ui_out_field_skip (uiout
, "addr");
6544 if (c
->syscalls_to_be_caught
6545 && VEC_length (int, c
->syscalls_to_be_caught
) > 1)
6546 ui_out_text (uiout
, "syscalls \"");
6548 ui_out_text (uiout
, "syscall \"");
6550 if (c
->syscalls_to_be_caught
)
6553 char *text
= xstrprintf ("%s", "");
6556 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6561 get_syscall_by_number (iter
, &s
);
6564 text
= xstrprintf ("%s%s, ", text
, s
.name
);
6566 text
= xstrprintf ("%s%d, ", text
, iter
);
6568 /* We have to xfree the last 'text' (now stored at 'x')
6569 because xstrprintf dynamically allocates new space for it
6573 /* Remove the last comma. */
6574 text
[strlen (text
) - 2] = '\0';
6575 ui_out_field_string (uiout
, "what", text
);
6578 ui_out_field_string (uiout
, "what", "<any syscall>");
6579 ui_out_text (uiout
, "\" ");
6582 /* Implement the "print_mention" breakpoint_ops method for syscall
6586 print_mention_catch_syscall (struct breakpoint
*b
)
6588 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6590 if (c
->syscalls_to_be_caught
)
6594 if (VEC_length (int, c
->syscalls_to_be_caught
) > 1)
6595 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
6597 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
6600 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6604 get_syscall_by_number (iter
, &s
);
6607 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
6609 printf_filtered (" %d", s
.number
);
6611 printf_filtered (")");
6614 printf_filtered (_("Catchpoint %d (any syscall)"),
6618 /* Implement the "print_recreate" breakpoint_ops method for syscall
6622 print_recreate_catch_syscall (struct breakpoint
*b
, struct ui_file
*fp
)
6624 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6626 fprintf_unfiltered (fp
, "catch syscall");
6628 if (c
->syscalls_to_be_caught
)
6633 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6638 get_syscall_by_number (iter
, &s
);
6640 fprintf_unfiltered (fp
, " %s", s
.name
);
6642 fprintf_unfiltered (fp
, " %d", s
.number
);
6645 print_recreate_thread (b
, fp
);
6648 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6650 static struct breakpoint_ops catch_syscall_breakpoint_ops
;
6652 /* Returns non-zero if 'b' is a syscall catchpoint. */
6655 syscall_catchpoint_p (struct breakpoint
*b
)
6657 return (b
->ops
== &catch_syscall_breakpoint_ops
);
6660 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
6661 is non-zero, then make the breakpoint temporary. If COND_STRING is
6662 not NULL, then store it in the breakpoint. OPS, if not NULL, is
6663 the breakpoint_ops structure associated to the catchpoint. */
6666 init_catchpoint (struct breakpoint
*b
,
6667 struct gdbarch
*gdbarch
, int tempflag
,
6669 const struct breakpoint_ops
*ops
)
6671 struct symtab_and_line sal
;
6674 sal
.pspace
= current_program_space
;
6676 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
6678 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
6679 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6683 install_breakpoint (int internal
, struct breakpoint
*b
)
6685 add_to_breakpoint_chain (b
);
6686 set_breakpoint_number (internal
, b
);
6689 observer_notify_breakpoint_created (b
);
6690 update_global_location_list (1);
6694 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
6695 int tempflag
, char *cond_string
,
6696 const struct breakpoint_ops
*ops
)
6698 struct fork_catchpoint
*c
= XNEW (struct fork_catchpoint
);
6700 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
, ops
);
6702 c
->forked_inferior_pid
= null_ptid
;
6704 install_breakpoint (0, &c
->base
);
6707 /* Exec catchpoints. */
6709 /* An instance of this type is used to represent an exec catchpoint.
6710 It includes a "struct breakpoint" as a kind of base class; users
6711 downcast to "struct breakpoint *" when needed. A breakpoint is
6712 really of this type iff its ops pointer points to
6713 CATCH_EXEC_BREAKPOINT_OPS. */
6715 struct exec_catchpoint
6717 /* The base class. */
6718 struct breakpoint base
;
6720 /* Filename of a program whose exec triggered this catchpoint.
6721 This field is only valid immediately after this catchpoint has
6723 char *exec_pathname
;
6726 /* Implement the "dtor" breakpoint_ops method for exec
6730 dtor_catch_exec (struct breakpoint
*b
)
6732 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
6734 xfree (c
->exec_pathname
);
6736 base_breakpoint_ops
.dtor (b
);
6740 insert_catch_exec (struct bp_location
*bl
)
6742 return target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
6746 remove_catch_exec (struct bp_location
*bl
)
6748 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
6752 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
6753 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6755 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
6757 return inferior_has_execd (inferior_ptid
, &c
->exec_pathname
);
6760 static enum print_stop_action
6761 print_it_catch_exec (bpstat bs
)
6763 struct breakpoint
*b
= bs
->breakpoint_at
;
6764 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
6766 annotate_catchpoint (b
->number
);
6767 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
6769 return PRINT_SRC_AND_LOC
;
6773 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
6775 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
6776 struct value_print_options opts
;
6777 struct ui_out
*uiout
= current_uiout
;
6779 get_user_print_options (&opts
);
6781 /* Field 4, the address, is omitted (which makes the columns
6782 not line up too nicely with the headers, but the effect
6783 is relatively readable). */
6784 if (opts
.addressprint
)
6785 ui_out_field_skip (uiout
, "addr");
6787 ui_out_text (uiout
, "exec");
6788 if (c
->exec_pathname
!= NULL
)
6790 ui_out_text (uiout
, ", program \"");
6791 ui_out_field_string (uiout
, "what", c
->exec_pathname
);
6792 ui_out_text (uiout
, "\" ");
6797 print_mention_catch_exec (struct breakpoint
*b
)
6799 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
6802 /* Implement the "print_recreate" breakpoint_ops method for exec
6806 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
6808 fprintf_unfiltered (fp
, "catch exec");
6809 print_recreate_thread (b
, fp
);
6812 static struct breakpoint_ops catch_exec_breakpoint_ops
;
6815 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
6816 const struct breakpoint_ops
*ops
)
6818 struct syscall_catchpoint
*c
;
6819 struct gdbarch
*gdbarch
= get_current_arch ();
6821 c
= XNEW (struct syscall_catchpoint
);
6822 init_catchpoint (&c
->base
, gdbarch
, tempflag
, NULL
, ops
);
6823 c
->syscalls_to_be_caught
= filter
;
6825 install_breakpoint (0, &c
->base
);
6829 hw_breakpoint_used_count (void)
6832 struct breakpoint
*b
;
6833 struct bp_location
*bl
;
6837 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
6838 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6840 /* Special types of hardware breakpoints may use more than
6842 i
+= b
->ops
->resources_needed (bl
);
6850 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
6853 struct breakpoint
*b
;
6854 struct bp_location
*bl
;
6856 *other_type_used
= 0;
6859 if (!breakpoint_enabled (b
))
6862 if (b
->type
== type
)
6863 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6865 /* Special types of hardware watchpoints may use more than
6867 i
+= b
->ops
->resources_needed (bl
);
6869 else if (is_hardware_watchpoint (b
))
6870 *other_type_used
= 1;
6877 disable_watchpoints_before_interactive_call_start (void)
6879 struct breakpoint
*b
;
6883 if (is_watchpoint (b
) && breakpoint_enabled (b
))
6885 b
->enable_state
= bp_call_disabled
;
6886 update_global_location_list (0);
6892 enable_watchpoints_after_interactive_call_stop (void)
6894 struct breakpoint
*b
;
6898 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
6900 b
->enable_state
= bp_enabled
;
6901 update_global_location_list (1);
6907 disable_breakpoints_before_startup (void)
6909 struct breakpoint
*b
;
6914 if (b
->pspace
!= current_program_space
)
6917 if ((b
->type
== bp_breakpoint
6918 || b
->type
== bp_hardware_breakpoint
)
6919 && breakpoint_enabled (b
))
6921 b
->enable_state
= bp_startup_disabled
;
6927 update_global_location_list (0);
6929 current_program_space
->executing_startup
= 1;
6933 enable_breakpoints_after_startup (void)
6935 struct breakpoint
*b
;
6938 current_program_space
->executing_startup
= 0;
6942 if (b
->pspace
!= current_program_space
)
6945 if ((b
->type
== bp_breakpoint
6946 || b
->type
== bp_hardware_breakpoint
)
6947 && b
->enable_state
== bp_startup_disabled
)
6949 b
->enable_state
= bp_enabled
;
6955 breakpoint_re_set ();
6959 /* Set a breakpoint that will evaporate an end of command
6960 at address specified by SAL.
6961 Restrict it to frame FRAME if FRAME is nonzero. */
6964 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
6965 struct frame_id frame_id
, enum bptype type
)
6967 struct breakpoint
*b
;
6969 /* If FRAME_ID is valid, it should be a real frame, not an inlined
6971 gdb_assert (!frame_id_inlined_p (frame_id
));
6973 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
6974 b
->enable_state
= bp_enabled
;
6975 b
->disposition
= disp_donttouch
;
6976 b
->frame_id
= frame_id
;
6978 /* If we're debugging a multi-threaded program, then we want
6979 momentary breakpoints to be active in only a single thread of
6981 if (in_thread_list (inferior_ptid
))
6982 b
->thread
= pid_to_thread_id (inferior_ptid
);
6984 update_global_location_list_nothrow (1);
6989 /* Make a momentary breakpoint based on the master breakpoint ORIG.
6990 The new breakpoint will have type TYPE, and use OPS as it
6993 static struct breakpoint
*
6994 momentary_breakpoint_from_master (struct breakpoint
*orig
,
6996 const struct breakpoint_ops
*ops
)
6998 struct breakpoint
*copy
;
7000 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
7001 copy
->loc
= allocate_bp_location (copy
);
7002 set_breakpoint_location_function (copy
->loc
, 1);
7004 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
7005 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
7006 copy
->loc
->address
= orig
->loc
->address
;
7007 copy
->loc
->section
= orig
->loc
->section
;
7008 copy
->loc
->pspace
= orig
->loc
->pspace
;
7010 if (orig
->source_file
== NULL
)
7011 copy
->source_file
= NULL
;
7013 copy
->source_file
= xstrdup (orig
->source_file
);
7015 copy
->line_number
= orig
->line_number
;
7016 copy
->frame_id
= orig
->frame_id
;
7017 copy
->thread
= orig
->thread
;
7018 copy
->pspace
= orig
->pspace
;
7020 copy
->enable_state
= bp_enabled
;
7021 copy
->disposition
= disp_donttouch
;
7022 copy
->number
= internal_breakpoint_number
--;
7024 update_global_location_list_nothrow (0);
7028 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
7032 clone_momentary_breakpoint (struct breakpoint
*orig
)
7034 /* If there's nothing to clone, then return nothing. */
7038 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
);
7042 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
7045 struct symtab_and_line sal
;
7047 sal
= find_pc_line (pc
, 0);
7049 sal
.section
= find_pc_overlay (pc
);
7050 sal
.explicit_pc
= 1;
7052 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
7056 /* Tell the user we have just set a breakpoint B. */
7059 mention (struct breakpoint
*b
)
7061 b
->ops
->print_mention (b
);
7062 if (ui_out_is_mi_like_p (current_uiout
))
7064 printf_filtered ("\n");
7068 static struct bp_location
*
7069 add_location_to_breakpoint (struct breakpoint
*b
,
7070 const struct symtab_and_line
*sal
)
7072 struct bp_location
*loc
, **tmp
;
7074 loc
= allocate_bp_location (b
);
7075 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
7078 loc
->gdbarch
= get_sal_arch (*sal
);
7080 loc
->gdbarch
= b
->gdbarch
;
7081 loc
->requested_address
= sal
->pc
;
7082 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7083 loc
->requested_address
, b
->type
);
7084 loc
->pspace
= sal
->pspace
;
7085 gdb_assert (loc
->pspace
!= NULL
);
7086 loc
->section
= sal
->section
;
7088 set_breakpoint_location_function (loc
,
7089 sal
->explicit_pc
|| sal
->explicit_line
);
7094 /* Return 1 if LOC is pointing to a permanent breakpoint,
7095 return 0 otherwise. */
7098 bp_loc_is_permanent (struct bp_location
*loc
)
7102 const gdb_byte
*brk
;
7103 gdb_byte
*target_mem
;
7104 struct cleanup
*cleanup
;
7107 gdb_assert (loc
!= NULL
);
7109 addr
= loc
->address
;
7110 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
7112 /* Software breakpoints unsupported? */
7116 target_mem
= alloca (len
);
7118 /* Enable the automatic memory restoration from breakpoints while
7119 we read the memory. Otherwise we could say about our temporary
7120 breakpoints they are permanent. */
7121 cleanup
= save_current_space_and_thread ();
7123 switch_to_program_space_and_thread (loc
->pspace
);
7124 make_show_memory_breakpoints_cleanup (0);
7126 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
7127 && memcmp (target_mem
, brk
, len
) == 0)
7130 do_cleanups (cleanup
);
7137 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7138 as textual description of the location, and COND_STRING
7139 as condition expression. */
7142 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7143 struct symtabs_and_lines sals
, char *addr_string
,
7145 enum bptype type
, enum bpdisp disposition
,
7146 int thread
, int task
, int ignore_count
,
7147 const struct breakpoint_ops
*ops
, int from_tty
,
7148 int enabled
, int internal
, int display_canonical
)
7152 if (type
== bp_hardware_breakpoint
)
7154 int i
= hw_breakpoint_used_count ();
7155 int target_resources_ok
=
7156 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
7158 if (target_resources_ok
== 0)
7159 error (_("No hardware breakpoint support in the target."));
7160 else if (target_resources_ok
< 0)
7161 error (_("Hardware breakpoints used exceeds limit."));
7164 gdb_assert (sals
.nelts
> 0);
7166 for (i
= 0; i
< sals
.nelts
; ++i
)
7168 struct symtab_and_line sal
= sals
.sals
[i
];
7169 struct bp_location
*loc
;
7173 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
7175 loc_gdbarch
= gdbarch
;
7177 describe_other_breakpoints (loc_gdbarch
,
7178 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
7183 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
7187 b
->cond_string
= cond_string
;
7188 b
->ignore_count
= ignore_count
;
7189 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7190 b
->disposition
= disposition
;
7191 b
->pspace
= sals
.sals
[0].pspace
;
7193 if (type
== bp_static_tracepoint
)
7195 struct tracepoint
*t
= (struct tracepoint
*) b
;
7196 struct static_tracepoint_marker marker
;
7198 if (is_marker_spec (addr_string
))
7200 /* We already know the marker exists, otherwise, we
7201 wouldn't see a sal for it. */
7202 char *p
= &addr_string
[3];
7207 p
= skip_spaces (p
);
7209 endp
= skip_to_space (p
);
7211 marker_str
= savestring (p
, endp
- p
);
7212 t
->static_trace_marker_id
= marker_str
;
7214 printf_filtered (_("Probed static tracepoint "
7216 t
->static_trace_marker_id
);
7218 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
7220 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
7221 release_static_tracepoint_marker (&marker
);
7223 printf_filtered (_("Probed static tracepoint "
7225 t
->static_trace_marker_id
);
7228 warning (_("Couldn't determine the static "
7229 "tracepoint marker to probe"));
7232 if (enabled
&& b
->pspace
->executing_startup
7233 && (b
->type
== bp_breakpoint
7234 || b
->type
== bp_hardware_breakpoint
))
7235 b
->enable_state
= bp_startup_disabled
;
7241 loc
= add_location_to_breakpoint (b
, &sal
);
7244 if (bp_loc_is_permanent (loc
))
7245 make_breakpoint_permanent (b
);
7249 char *arg
= b
->cond_string
;
7250 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
7252 error (_("Garbage %s follows condition"), arg
);
7256 b
->display_canonical
= display_canonical
;
7258 b
->addr_string
= addr_string
;
7260 /* addr_string has to be used or breakpoint_re_set will delete
7263 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
7267 create_breakpoint_sal (struct gdbarch
*gdbarch
,
7268 struct symtabs_and_lines sals
, char *addr_string
,
7270 enum bptype type
, enum bpdisp disposition
,
7271 int thread
, int task
, int ignore_count
,
7272 const struct breakpoint_ops
*ops
, int from_tty
,
7273 int enabled
, int internal
, int display_canonical
)
7275 struct breakpoint
*b
;
7276 struct cleanup
*old_chain
;
7278 if (is_tracepoint_type (type
))
7280 struct tracepoint
*t
;
7282 t
= XCNEW (struct tracepoint
);
7286 b
= XNEW (struct breakpoint
);
7288 old_chain
= make_cleanup (xfree
, b
);
7290 init_breakpoint_sal (b
, gdbarch
,
7294 thread
, task
, ignore_count
,
7296 enabled
, internal
, display_canonical
);
7297 discard_cleanups (old_chain
);
7299 install_breakpoint (internal
, b
);
7302 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7303 elements to fill the void space. */
7305 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
7307 int i
= index_to_remove
+1;
7308 int last_index
= sal
->nelts
-1;
7310 for (;i
<= last_index
; ++i
)
7311 sal
->sals
[i
-1] = sal
->sals
[i
];
7316 /* If appropriate, obtains all sals that correspond to the same file
7317 and line as SAL, in all program spaces. Users debugging with IDEs,
7318 will want to set a breakpoint at foo.c:line, and not really care
7319 about program spaces. This is done only if SAL does not have
7320 explicit PC and has line and file information. If we got just a
7321 single expanded sal, return the original.
7323 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7324 which the name of enclosing function is different from SAL. This
7325 makes sure that if we have breakpoint originally set in template
7326 instantiation, say foo<int>(), we won't expand SAL to locations at
7327 the same line in all existing instantiations of 'foo'. */
7329 static struct symtabs_and_lines
7330 expand_line_sal_maybe (struct symtab_and_line sal
)
7332 struct symtabs_and_lines expanded
;
7333 CORE_ADDR original_pc
= sal
.pc
;
7334 char *original_function
= NULL
;
7337 struct cleanup
*old_chain
;
7339 /* If we have explicit pc, don't expand.
7340 If we have no line number, we can't expand. */
7341 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
7344 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7345 expanded
.sals
[0] = sal
;
7351 old_chain
= save_current_space_and_thread ();
7353 switch_to_program_space_and_thread (sal
.pspace
);
7355 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
7357 /* Note that expand_line_sal visits *all* program spaces. */
7358 expanded
= expand_line_sal (sal
);
7360 if (expanded
.nelts
== 1)
7362 /* We had one sal, we got one sal. Return that sal, adjusting it
7363 past the function prologue if necessary. */
7364 xfree (expanded
.sals
);
7366 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7367 sal
.pc
= original_pc
;
7368 expanded
.sals
[0] = sal
;
7369 skip_prologue_sal (&expanded
.sals
[0]);
7370 do_cleanups (old_chain
);
7374 if (!sal
.explicit_line
)
7376 CORE_ADDR func_addr
, func_end
;
7377 for (i
= 0; i
< expanded
.nelts
; ++i
)
7379 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
7380 char *this_function
;
7382 /* We need to switch threads as well since we're about to
7384 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
7386 if (find_pc_partial_function (pc
, &this_function
,
7387 &func_addr
, &func_end
))
7390 && strcmp (this_function
, original_function
) != 0)
7392 remove_sal (&expanded
, i
);
7399 /* Skip the function prologue if necessary. */
7400 for (i
= 0; i
< expanded
.nelts
; ++i
)
7401 skip_prologue_sal (&expanded
.sals
[i
]);
7403 do_cleanups (old_chain
);
7405 if (expanded
.nelts
<= 1)
7407 /* This is an ugly workaround. If we get zero expanded sals
7408 then something is really wrong. Fix that by returning the
7411 xfree (expanded
.sals
);
7413 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7414 sal
.pc
= original_pc
;
7415 expanded
.sals
[0] = sal
;
7422 for (i
= 0; i
< expanded
.nelts
; ++i
)
7423 if (expanded
.sals
[i
].pc
== original_pc
)
7434 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7435 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7436 value. COND_STRING, if not NULL, specified the condition to be
7437 used for all breakpoints. Essentially the only case where
7438 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7439 function. In that case, it's still not possible to specify
7440 separate conditions for different overloaded functions, so
7441 we take just a single condition string.
7443 NOTE: If the function succeeds, the caller is expected to cleanup
7444 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7445 array contents). If the function fails (error() is called), the
7446 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7447 COND and SALS arrays and each of those arrays contents. */
7450 create_breakpoints_sal (struct gdbarch
*gdbarch
,
7451 struct symtabs_and_lines sals
,
7452 struct linespec_result
*canonical
,
7454 enum bptype type
, enum bpdisp disposition
,
7455 int thread
, int task
, int ignore_count
,
7456 const struct breakpoint_ops
*ops
, int from_tty
,
7457 int enabled
, int internal
)
7461 for (i
= 0; i
< sals
.nelts
; ++i
)
7463 struct symtabs_and_lines expanded
=
7464 expand_line_sal_maybe (sals
.sals
[i
]);
7466 create_breakpoint_sal (gdbarch
, expanded
, canonical
->canonical
[i
],
7467 cond_string
, type
, disposition
,
7468 thread
, task
, ignore_count
, ops
,
7469 from_tty
, enabled
, internal
,
7470 canonical
->special_display
);
7474 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7475 followed by conditionals. On return, SALS contains an array of SAL
7476 addresses found. ADDR_STRING contains a vector of (canonical)
7477 address strings. ADDRESS points to the end of the SAL.
7479 The array and the line spec strings are allocated on the heap, it is
7480 the caller's responsibility to free them. */
7483 parse_breakpoint_sals (char **address
,
7484 struct symtabs_and_lines
*sals
,
7485 struct linespec_result
*canonical
)
7487 char *addr_start
= *address
;
7489 /* If no arg given, or if first arg is 'if ', use the default
7491 if ((*address
) == NULL
7492 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
7494 if (default_breakpoint_valid
)
7496 struct symtab_and_line sal
;
7498 init_sal (&sal
); /* Initialize to zeroes. */
7499 sals
->sals
= (struct symtab_and_line
*)
7500 xmalloc (sizeof (struct symtab_and_line
));
7501 sal
.pc
= default_breakpoint_address
;
7502 sal
.line
= default_breakpoint_line
;
7503 sal
.symtab
= default_breakpoint_symtab
;
7504 sal
.pspace
= default_breakpoint_pspace
;
7505 sal
.section
= find_pc_overlay (sal
.pc
);
7507 /* "break" without arguments is equivalent to "break *PC"
7508 where PC is the default_breakpoint_address. So make sure
7509 to set sal.explicit_pc to prevent GDB from trying to
7510 expand the list of sals to include all other instances
7511 with the same symtab and line. */
7512 sal
.explicit_pc
= 1;
7514 sals
->sals
[0] = sal
;
7518 error (_("No default breakpoint address now."));
7522 /* Force almost all breakpoints to be in terms of the
7523 current_source_symtab (which is decode_line_1's default).
7524 This should produce the results we want almost all of the
7525 time while leaving default_breakpoint_* alone.
7527 ObjC: However, don't match an Objective-C method name which
7528 may have a '+' or '-' succeeded by a '[' */
7530 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
7532 if (default_breakpoint_valid
7534 || ((strchr ("+-", (*address
)[0]) != NULL
)
7535 && ((*address
)[1] != '['))))
7536 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
7537 default_breakpoint_line
, canonical
);
7539 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
7542 /* For any SAL that didn't have a canonical string, fill one in. */
7543 if (sals
->nelts
> 0 && canonical
->canonical
== NULL
)
7544 canonical
->canonical
= xcalloc (sals
->nelts
, sizeof (char *));
7545 if (addr_start
!= (*address
))
7549 for (i
= 0; i
< sals
->nelts
; i
++)
7551 /* Add the string if not present. */
7552 if (canonical
->canonical
[i
] == NULL
)
7553 canonical
->canonical
[i
] = savestring (addr_start
,
7554 (*address
) - addr_start
);
7560 /* Convert each SAL into a real PC. Verify that the PC can be
7561 inserted as a breakpoint. If it can't throw an error. */
7564 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
7568 for (i
= 0; i
< sals
->nelts
; i
++)
7569 resolve_sal_pc (&sals
->sals
[i
]);
7572 /* Fast tracepoints may have restrictions on valid locations. For
7573 instance, a fast tracepoint using a jump instead of a trap will
7574 likely have to overwrite more bytes than a trap would, and so can
7575 only be placed where the instruction is longer than the jump, or a
7576 multi-instruction sequence does not have a jump into the middle of
7580 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
7581 struct symtabs_and_lines
*sals
)
7584 struct symtab_and_line
*sal
;
7586 struct cleanup
*old_chain
;
7588 for (i
= 0; i
< sals
->nelts
; i
++)
7590 sal
= &sals
->sals
[i
];
7592 rslt
= gdbarch_fast_tracepoint_valid_at (gdbarch
, sal
->pc
,
7594 old_chain
= make_cleanup (xfree
, msg
);
7597 error (_("May not have a fast tracepoint at 0x%s%s"),
7598 paddress (gdbarch
, sal
->pc
), (msg
? msg
: ""));
7600 do_cleanups (old_chain
);
7604 /* Given TOK, a string specification of condition and thread, as
7605 accepted by the 'break' command, extract the condition
7606 string and thread number and set *COND_STRING and *THREAD.
7607 PC identifies the context at which the condition should be parsed.
7608 If no condition is found, *COND_STRING is set to NULL.
7609 If no thread is found, *THREAD is set to -1. */
7611 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
7612 char **cond_string
, int *thread
, int *task
)
7614 *cond_string
= NULL
;
7620 char *cond_start
= NULL
;
7621 char *cond_end
= NULL
;
7623 tok
= skip_spaces (tok
);
7625 end_tok
= skip_to_space (tok
);
7627 toklen
= end_tok
- tok
;
7629 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7631 struct expression
*expr
;
7633 tok
= cond_start
= end_tok
+ 1;
7634 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
7637 *cond_string
= savestring (cond_start
,
7638 cond_end
- cond_start
);
7640 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7646 *thread
= strtol (tok
, &tok
, 0);
7648 error (_("Junk after thread keyword."));
7649 if (!valid_thread_id (*thread
))
7650 error (_("Unknown thread %d."), *thread
);
7652 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
7658 *task
= strtol (tok
, &tok
, 0);
7660 error (_("Junk after task keyword."));
7661 if (!valid_task_id (*task
))
7662 error (_("Unknown task %d."), *task
);
7665 error (_("Junk at end of arguments."));
7669 /* Decode a static tracepoint marker spec. */
7671 static struct symtabs_and_lines
7672 decode_static_tracepoint_spec (char **arg_p
)
7674 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
7675 struct symtabs_and_lines sals
;
7676 struct symtab_and_line sal
;
7678 struct cleanup
*old_chain
;
7679 char *p
= &(*arg_p
)[3];
7684 p
= skip_spaces (p
);
7686 endp
= skip_to_space (p
);
7688 marker_str
= savestring (p
, endp
- p
);
7689 old_chain
= make_cleanup (xfree
, marker_str
);
7691 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
7692 if (VEC_empty(static_tracepoint_marker_p
, markers
))
7693 error (_("No known static tracepoint marker named %s"), marker_str
);
7695 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
7696 sals
.sals
= xmalloc (sizeof *sals
.sals
* sals
.nelts
);
7698 for (i
= 0; i
< sals
.nelts
; i
++)
7700 struct static_tracepoint_marker
*marker
;
7702 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
7704 init_sal (&sals
.sals
[i
]);
7706 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
7707 sals
.sals
[i
].pc
= marker
->address
;
7709 release_static_tracepoint_marker (marker
);
7712 do_cleanups (old_chain
);
7718 /* Set a breakpoint. This function is shared between CLI and MI
7719 functions for setting a breakpoint. This function has two major
7720 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7721 parameter. If non-zero, the function will parse arg, extracting
7722 breakpoint location, address and thread. Otherwise, ARG is just
7723 the location of breakpoint, with condition and thread specified by
7724 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
7725 the breakpoint number will be allocated from the internal
7726 breakpoint count. Returns true if any breakpoint was created;
7730 create_breakpoint (struct gdbarch
*gdbarch
,
7731 char *arg
, char *cond_string
, int thread
,
7732 int parse_condition_and_thread
,
7733 int tempflag
, enum bptype type_wanted
,
7735 enum auto_boolean pending_break_support
,
7736 const struct breakpoint_ops
*ops
,
7737 int from_tty
, int enabled
, int internal
)
7739 volatile struct gdb_exception e
;
7740 struct symtabs_and_lines sals
;
7741 struct symtab_and_line pending_sal
;
7743 char *addr_start
= arg
;
7744 struct linespec_result canonical
;
7745 struct cleanup
*old_chain
;
7746 struct cleanup
*bkpt_chain
= NULL
;
7750 int prev_bkpt_count
= breakpoint_count
;
7752 gdb_assert (ops
!= NULL
);
7756 init_linespec_result (&canonical
);
7758 if (type_wanted
== bp_static_tracepoint
&& is_marker_spec (arg
))
7762 sals
= decode_static_tracepoint_spec (&arg
);
7764 copy_arg
= savestring (addr_start
, arg
- addr_start
);
7765 canonical
.canonical
= xcalloc (sals
.nelts
, sizeof (char *));
7766 for (i
= 0; i
< sals
.nelts
; i
++)
7767 canonical
.canonical
[i
] = xstrdup (copy_arg
);
7771 TRY_CATCH (e
, RETURN_MASK_ALL
)
7773 parse_breakpoint_sals (&arg
, &sals
, &canonical
);
7776 /* If caller is interested in rc value from parse, set value. */
7780 throw_exception (e
);
7784 case NOT_FOUND_ERROR
:
7786 /* If pending breakpoint support is turned off, throw
7789 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
7790 throw_exception (e
);
7792 exception_print (gdb_stderr
, e
);
7794 /* If pending breakpoint support is auto query and the user
7795 selects no, then simply return the error code. */
7796 if (pending_break_support
== AUTO_BOOLEAN_AUTO
7797 && !nquery (_("Make breakpoint pending on "
7798 "future shared library load? ")))
7801 /* At this point, either the user was queried about setting
7802 a pending breakpoint and selected yes, or pending
7803 breakpoint behavior is on and thus a pending breakpoint
7804 is defaulted on behalf of the user. */
7805 copy_arg
= xstrdup (addr_start
);
7806 canonical
.canonical
= ©_arg
;
7808 sals
.sals
= &pending_sal
;
7813 throw_exception (e
);
7823 /* Create a chain of things that always need to be cleaned up. */
7824 old_chain
= make_cleanup (null_cleanup
, 0);
7828 /* Make sure that all storage allocated to SALS gets freed. */
7829 make_cleanup (xfree
, sals
.sals
);
7831 /* Cleanup the canonical array but not its contents. */
7832 make_cleanup (xfree
, canonical
.canonical
);
7835 /* ----------------------------- SNIP -----------------------------
7836 Anything added to the cleanup chain beyond this point is assumed
7837 to be part of a breakpoint. If the breakpoint create succeeds
7838 then the memory is not reclaimed. */
7839 bkpt_chain
= make_cleanup (null_cleanup
, 0);
7841 /* Mark the contents of the canonical for cleanup. These go on
7842 the bkpt_chain and only occur if the breakpoint create fails. */
7843 for (i
= 0; i
< sals
.nelts
; i
++)
7845 if (canonical
.canonical
[i
] != NULL
)
7846 make_cleanup (xfree
, canonical
.canonical
[i
]);
7849 /* Resolve all line numbers to PC's and verify that the addresses
7850 are ok for the target. */
7852 breakpoint_sals_to_pc (&sals
);
7854 /* Fast tracepoints may have additional restrictions on location. */
7855 if (type_wanted
== bp_fast_tracepoint
)
7856 check_fast_tracepoint_sals (gdbarch
, &sals
);
7858 /* Verify that condition can be parsed, before setting any
7859 breakpoints. Allocate a separate condition expression for each
7863 if (parse_condition_and_thread
)
7865 /* Here we only parse 'arg' to separate condition
7866 from thread number, so parsing in context of first
7867 sal is OK. When setting the breakpoint we'll
7868 re-parse it in context of each sal. */
7871 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
7874 make_cleanup (xfree
, cond_string
);
7878 /* Create a private copy of condition string. */
7881 cond_string
= xstrdup (cond_string
);
7882 make_cleanup (xfree
, cond_string
);
7886 /* If the user is creating a static tracepoint by marker id
7887 (strace -m MARKER_ID), then store the sals index, so that
7888 breakpoint_re_set can try to match up which of the newly
7889 found markers corresponds to this one, and, don't try to
7890 expand multiple locations for each sal, given than SALS
7891 already should contain all sals for MARKER_ID. */
7892 if (type_wanted
== bp_static_tracepoint
7893 && is_marker_spec (canonical
.canonical
[0]))
7897 for (i
= 0; i
< sals
.nelts
; ++i
)
7899 struct symtabs_and_lines expanded
;
7900 struct tracepoint
*tp
;
7901 struct cleanup
*old_chain
;
7904 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7905 expanded
.sals
[0] = sals
.sals
[i
];
7906 old_chain
= make_cleanup (xfree
, expanded
.sals
);
7908 tp
= XCNEW (struct tracepoint
);
7909 init_breakpoint_sal (&tp
->base
, gdbarch
, expanded
,
7910 canonical
.canonical
[i
],
7911 cond_string
, type_wanted
,
7912 tempflag
? disp_del
: disp_donttouch
,
7913 thread
, task
, ignore_count
, ops
,
7914 from_tty
, enabled
, internal
,
7915 canonical
.special_display
);
7916 /* Given that its possible to have multiple markers with
7917 the same string id, if the user is creating a static
7918 tracepoint by marker id ("strace -m MARKER_ID"), then
7919 store the sals index, so that breakpoint_re_set can
7920 try to match up which of the newly found markers
7921 corresponds to this one */
7922 tp
->static_trace_marker_id_idx
= i
;
7924 install_breakpoint (internal
, &tp
->base
);
7926 do_cleanups (old_chain
);
7930 create_breakpoints_sal (gdbarch
, sals
, &canonical
, cond_string
,
7932 tempflag
? disp_del
: disp_donttouch
,
7933 thread
, task
, ignore_count
, ops
, from_tty
,
7938 struct breakpoint
*b
;
7940 make_cleanup (xfree
, copy_arg
);
7942 b
= set_raw_breakpoint_without_location (gdbarch
, type_wanted
, ops
);
7943 set_breakpoint_number (internal
, b
);
7945 b
->addr_string
= canonical
.canonical
[0];
7946 b
->cond_string
= NULL
;
7947 b
->ignore_count
= ignore_count
;
7948 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
7949 b
->condition_not_parsed
= 1;
7950 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7951 b
->pspace
= current_program_space
;
7952 b
->py_bp_object
= NULL
;
7954 if (enabled
&& b
->pspace
->executing_startup
7955 && (b
->type
== bp_breakpoint
7956 || b
->type
== bp_hardware_breakpoint
))
7957 b
->enable_state
= bp_startup_disabled
;
7960 /* Do not mention breakpoints with a negative number,
7961 but do notify observers. */
7963 observer_notify_breakpoint_created (b
);
7968 warning (_("Multiple breakpoints were set.\nUse the "
7969 "\"delete\" command to delete unwanted breakpoints."));
7970 prev_breakpoint_count
= prev_bkpt_count
;
7973 /* That's it. Discard the cleanups for data inserted into the
7975 discard_cleanups (bkpt_chain
);
7976 /* But cleanup everything else. */
7977 do_cleanups (old_chain
);
7979 /* error call may happen here - have BKPT_CHAIN already discarded. */
7980 update_global_location_list (1);
7985 /* Set a breakpoint.
7986 ARG is a string describing breakpoint address,
7987 condition, and thread.
7988 FLAG specifies if a breakpoint is hardware on,
7989 and if breakpoint is temporary, using BP_HARDWARE_FLAG
7993 break_command_1 (char *arg
, int flag
, int from_tty
)
7995 int tempflag
= flag
& BP_TEMPFLAG
;
7996 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
7997 ? bp_hardware_breakpoint
8000 create_breakpoint (get_current_arch (),
8002 NULL
, 0, 1 /* parse arg */,
8003 tempflag
, type_wanted
,
8004 0 /* Ignore count */,
8005 pending_break_support
,
8006 &bkpt_breakpoint_ops
,
8012 /* Helper function for break_command_1 and disassemble_command. */
8015 resolve_sal_pc (struct symtab_and_line
*sal
)
8019 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
8021 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
8022 error (_("No line %d in file \"%s\"."),
8023 sal
->line
, sal
->symtab
->filename
);
8026 /* If this SAL corresponds to a breakpoint inserted using a line
8027 number, then skip the function prologue if necessary. */
8028 if (sal
->explicit_line
)
8029 skip_prologue_sal (sal
);
8032 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
8034 struct blockvector
*bv
;
8038 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
8041 sym
= block_linkage_function (b
);
8044 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
8045 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
8049 /* It really is worthwhile to have the section, so we'll
8050 just have to look harder. This case can be executed
8051 if we have line numbers but no functions (as can
8052 happen in assembly source). */
8054 struct minimal_symbol
*msym
;
8055 struct cleanup
*old_chain
= save_current_space_and_thread ();
8057 switch_to_program_space_and_thread (sal
->pspace
);
8059 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
8061 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
8063 do_cleanups (old_chain
);
8070 break_command (char *arg
, int from_tty
)
8072 break_command_1 (arg
, 0, from_tty
);
8076 tbreak_command (char *arg
, int from_tty
)
8078 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
8082 hbreak_command (char *arg
, int from_tty
)
8084 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
8088 thbreak_command (char *arg
, int from_tty
)
8090 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
8094 stop_command (char *arg
, int from_tty
)
8096 printf_filtered (_("Specify the type of breakpoint to set.\n\
8097 Usage: stop in <function | address>\n\
8098 stop at <line>\n"));
8102 stopin_command (char *arg
, int from_tty
)
8106 if (arg
== (char *) NULL
)
8108 else if (*arg
!= '*')
8113 /* Look for a ':'. If this is a line number specification, then
8114 say it is bad, otherwise, it should be an address or
8115 function/method name. */
8116 while (*argptr
&& !hasColon
)
8118 hasColon
= (*argptr
== ':');
8123 badInput
= (*argptr
!= ':'); /* Not a class::method */
8125 badInput
= isdigit (*arg
); /* a simple line number */
8129 printf_filtered (_("Usage: stop in <function | address>\n"));
8131 break_command_1 (arg
, 0, from_tty
);
8135 stopat_command (char *arg
, int from_tty
)
8139 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
8146 /* Look for a ':'. If there is a '::' then get out, otherwise
8147 it is probably a line number. */
8148 while (*argptr
&& !hasColon
)
8150 hasColon
= (*argptr
== ':');
8155 badInput
= (*argptr
== ':'); /* we have class::method */
8157 badInput
= !isdigit (*arg
); /* not a line number */
8161 printf_filtered (_("Usage: stop at <line>\n"));
8163 break_command_1 (arg
, 0, from_tty
);
8166 /* Implement the "breakpoint_hit" breakpoint_ops method for
8167 ranged breakpoints. */
8170 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
8171 struct address_space
*aspace
,
8174 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
8175 bl
->length
, aspace
, bp_addr
);
8178 /* Implement the "resources_needed" breakpoint_ops method for
8179 ranged breakpoints. */
8182 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
8184 return target_ranged_break_num_registers ();
8187 /* Implement the "print_it" breakpoint_ops method for
8188 ranged breakpoints. */
8190 static enum print_stop_action
8191 print_it_ranged_breakpoint (bpstat bs
)
8193 struct breakpoint
*b
= bs
->breakpoint_at
;
8194 struct bp_location
*bl
= b
->loc
;
8195 struct ui_out
*uiout
= current_uiout
;
8197 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8199 /* Ranged breakpoints have only one location. */
8200 gdb_assert (bl
&& bl
->next
== NULL
);
8202 annotate_breakpoint (b
->number
);
8203 if (b
->disposition
== disp_del
)
8204 ui_out_text (uiout
, "\nTemporary ranged breakpoint ");
8206 ui_out_text (uiout
, "\nRanged breakpoint ");
8207 if (ui_out_is_mi_like_p (uiout
))
8209 ui_out_field_string (uiout
, "reason",
8210 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
8211 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8213 ui_out_field_int (uiout
, "bkptno", b
->number
);
8214 ui_out_text (uiout
, ", ");
8216 return PRINT_SRC_AND_LOC
;
8219 /* Implement the "print_one" breakpoint_ops method for
8220 ranged breakpoints. */
8223 print_one_ranged_breakpoint (struct breakpoint
*b
,
8224 struct bp_location
**last_loc
)
8226 struct bp_location
*bl
= b
->loc
;
8227 struct value_print_options opts
;
8228 struct ui_out
*uiout
= current_uiout
;
8230 /* Ranged breakpoints have only one location. */
8231 gdb_assert (bl
&& bl
->next
== NULL
);
8233 get_user_print_options (&opts
);
8235 if (opts
.addressprint
)
8236 /* We don't print the address range here, it will be printed later
8237 by print_one_detail_ranged_breakpoint. */
8238 ui_out_field_skip (uiout
, "addr");
8240 print_breakpoint_location (b
, bl
);
8244 /* Implement the "print_one_detail" breakpoint_ops method for
8245 ranged breakpoints. */
8248 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
8249 struct ui_out
*uiout
)
8251 CORE_ADDR address_start
, address_end
;
8252 struct bp_location
*bl
= b
->loc
;
8253 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
8254 struct cleanup
*cleanup
= make_cleanup_ui_out_stream_delete (stb
);
8258 address_start
= bl
->address
;
8259 address_end
= address_start
+ bl
->length
- 1;
8261 ui_out_text (uiout
, "\taddress range: ");
8262 fprintf_unfiltered (stb
->stream
, "[%s, %s]",
8263 print_core_address (bl
->gdbarch
, address_start
),
8264 print_core_address (bl
->gdbarch
, address_end
));
8265 ui_out_field_stream (uiout
, "addr", stb
);
8266 ui_out_text (uiout
, "\n");
8268 do_cleanups (cleanup
);
8271 /* Implement the "print_mention" breakpoint_ops method for
8272 ranged breakpoints. */
8275 print_mention_ranged_breakpoint (struct breakpoint
*b
)
8277 struct bp_location
*bl
= b
->loc
;
8278 struct ui_out
*uiout
= current_uiout
;
8281 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8283 if (ui_out_is_mi_like_p (uiout
))
8286 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
8287 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
8288 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
8291 /* Implement the "print_recreate" breakpoint_ops method for
8292 ranged breakpoints. */
8295 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8297 fprintf_unfiltered (fp
, "break-range %s, %s", b
->addr_string
,
8298 b
->addr_string_range_end
);
8299 print_recreate_thread (b
, fp
);
8302 /* The breakpoint_ops structure to be used in ranged breakpoints. */
8304 static struct breakpoint_ops ranged_breakpoint_ops
;
8306 /* Find the address where the end of the breakpoint range should be
8307 placed, given the SAL of the end of the range. This is so that if
8308 the user provides a line number, the end of the range is set to the
8309 last instruction of the given line. */
8312 find_breakpoint_range_end (struct symtab_and_line sal
)
8316 /* If the user provided a PC value, use it. Otherwise,
8317 find the address of the end of the given location. */
8318 if (sal
.explicit_pc
)
8325 ret
= find_line_pc_range (sal
, &start
, &end
);
8327 error (_("Could not find location of the end of the range."));
8329 /* find_line_pc_range returns the start of the next line. */
8336 /* Implement the "break-range" CLI command. */
8339 break_range_command (char *arg
, int from_tty
)
8341 char *arg_start
, *addr_string_start
, *addr_string_end
;
8342 struct linespec_result canonical_start
, canonical_end
;
8343 int bp_count
, can_use_bp
, length
;
8345 struct breakpoint
*b
;
8346 struct symtab_and_line sal_start
, sal_end
;
8347 struct symtabs_and_lines sals_start
, sals_end
;
8348 struct cleanup
*cleanup_bkpt
;
8350 /* We don't support software ranged breakpoints. */
8351 if (target_ranged_break_num_registers () < 0)
8352 error (_("This target does not support hardware ranged breakpoints."));
8354 bp_count
= hw_breakpoint_used_count ();
8355 bp_count
+= target_ranged_break_num_registers ();
8356 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8359 error (_("Hardware breakpoints used exceeds limit."));
8361 if (arg
== NULL
|| arg
[0] == '\0')
8362 error(_("No address range specified."));
8364 sals_start
.sals
= NULL
;
8365 sals_start
.nelts
= 0;
8366 init_linespec_result (&canonical_start
);
8368 while (*arg
== ' ' || *arg
== '\t')
8371 parse_breakpoint_sals (&arg
, &sals_start
, &canonical_start
);
8373 sal_start
= sals_start
.sals
[0];
8374 addr_string_start
= canonical_start
.canonical
[0];
8375 cleanup_bkpt
= make_cleanup (xfree
, addr_string_start
);
8376 xfree (sals_start
.sals
);
8377 xfree (canonical_start
.canonical
);
8380 error (_("Too few arguments."));
8381 else if (sals_start
.nelts
== 0)
8382 error (_("Could not find location of the beginning of the range."));
8383 else if (sals_start
.nelts
!= 1)
8384 error (_("Cannot create a ranged breakpoint with multiple locations."));
8386 resolve_sal_pc (&sal_start
);
8388 arg
++; /* Skip the comma. */
8389 while (*arg
== ' ' || *arg
== '\t')
8392 /* Parse the end location. */
8394 sals_end
.sals
= NULL
;
8396 init_linespec_result (&canonical_end
);
8399 /* We call decode_line_1 directly here instead of using
8400 parse_breakpoint_sals because we need to specify the start location's
8401 symtab and line as the default symtab and line for the end of the
8402 range. This makes it possible to have ranges like "foo.c:27, +14",
8403 where +14 means 14 lines from the start location. */
8404 sals_end
= decode_line_1 (&arg
, 1, sal_start
.symtab
, sal_start
.line
,
8407 /* canonical_end can be NULL if it was of the form "*0xdeadbeef". */
8408 if (canonical_end
.canonical
== NULL
)
8409 canonical_end
.canonical
= xcalloc (1, sizeof (char *));
8410 /* Add the string if not present. */
8411 if (arg_start
!= arg
&& canonical_end
.canonical
[0] == NULL
)
8412 canonical_end
.canonical
[0] = savestring (arg_start
, arg
- arg_start
);
8414 sal_end
= sals_end
.sals
[0];
8415 addr_string_end
= canonical_end
.canonical
[0];
8416 make_cleanup (xfree
, addr_string_end
);
8417 xfree (sals_end
.sals
);
8418 xfree (canonical_end
.canonical
);
8420 if (sals_end
.nelts
== 0)
8421 error (_("Could not find location of the end of the range."));
8422 else if (sals_end
.nelts
!= 1)
8423 error (_("Cannot create a ranged breakpoint with multiple locations."));
8425 resolve_sal_pc (&sal_end
);
8427 end
= find_breakpoint_range_end (sal_end
);
8428 if (sal_start
.pc
> end
)
8429 error (_("Invalid address range, end precedes start."));
8431 length
= end
- sal_start
.pc
+ 1;
8433 /* Length overflowed. */
8434 error (_("Address range too large."));
8435 else if (length
== 1)
8437 /* This range is simple enough to be handled by
8438 the `hbreak' command. */
8439 hbreak_command (addr_string_start
, 1);
8441 do_cleanups (cleanup_bkpt
);
8446 /* Now set up the breakpoint. */
8447 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
8448 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
8449 set_breakpoint_count (breakpoint_count
+ 1);
8450 b
->number
= breakpoint_count
;
8451 b
->disposition
= disp_donttouch
;
8452 b
->addr_string
= addr_string_start
;
8453 b
->addr_string_range_end
= addr_string_end
;
8454 b
->loc
->length
= length
;
8456 discard_cleanups (cleanup_bkpt
);
8459 observer_notify_breakpoint_created (b
);
8460 update_global_location_list (1);
8463 /* Return non-zero if EXP is verified as constant. Returned zero
8464 means EXP is variable. Also the constant detection may fail for
8465 some constant expressions and in such case still falsely return
8468 watchpoint_exp_is_const (const struct expression
*exp
)
8476 /* We are only interested in the descriptor of each element. */
8477 operator_length (exp
, i
, &oplenp
, &argsp
);
8480 switch (exp
->elts
[i
].opcode
)
8490 case BINOP_LOGICAL_AND
:
8491 case BINOP_LOGICAL_OR
:
8492 case BINOP_BITWISE_AND
:
8493 case BINOP_BITWISE_IOR
:
8494 case BINOP_BITWISE_XOR
:
8496 case BINOP_NOTEQUAL
:
8512 case TERNOP_SLICE_COUNT
:
8524 case OP_OBJC_NSSTRING
:
8527 case UNOP_LOGICAL_NOT
:
8528 case UNOP_COMPLEMENT
:
8531 /* Unary, binary and ternary operators: We have to check
8532 their operands. If they are constant, then so is the
8533 result of that operation. For instance, if A and B are
8534 determined to be constants, then so is "A + B".
8536 UNOP_IND is one exception to the rule above, because the
8537 value of *ADDR is not necessarily a constant, even when
8542 /* Check whether the associated symbol is a constant.
8544 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8545 possible that a buggy compiler could mark a variable as
8546 constant even when it is not, and TYPE_CONST would return
8547 true in this case, while SYMBOL_CLASS wouldn't.
8549 We also have to check for function symbols because they
8550 are always constant. */
8552 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
8554 if (SYMBOL_CLASS (s
) != LOC_BLOCK
8555 && SYMBOL_CLASS (s
) != LOC_CONST
8556 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
8561 /* The default action is to return 0 because we are using
8562 the optimistic approach here: If we don't know something,
8563 then it is not a constant. */
8572 /* Implement the "dtor" breakpoint_ops method for watchpoints. */
8575 dtor_watchpoint (struct breakpoint
*self
)
8577 struct watchpoint
*w
= (struct watchpoint
*) self
;
8579 xfree (w
->cond_exp
);
8581 xfree (w
->exp_string
);
8582 xfree (w
->exp_string_reparse
);
8583 value_free (w
->val
);
8585 base_breakpoint_ops
.dtor (self
);
8588 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
8591 re_set_watchpoint (struct breakpoint
*b
)
8593 struct watchpoint
*w
= (struct watchpoint
*) b
;
8595 /* Watchpoint can be either on expression using entirely global
8596 variables, or it can be on local variables.
8598 Watchpoints of the first kind are never auto-deleted, and even
8599 persist across program restarts. Since they can use variables
8600 from shared libraries, we need to reparse expression as libraries
8601 are loaded and unloaded.
8603 Watchpoints on local variables can also change meaning as result
8604 of solib event. For example, if a watchpoint uses both a local
8605 and a global variables in expression, it's a local watchpoint,
8606 but unloading of a shared library will make the expression
8607 invalid. This is not a very common use case, but we still
8608 re-evaluate expression, to avoid surprises to the user.
8610 Note that for local watchpoints, we re-evaluate it only if
8611 watchpoints frame id is still valid. If it's not, it means the
8612 watchpoint is out of scope and will be deleted soon. In fact,
8613 I'm not sure we'll ever be called in this case.
8615 If a local watchpoint's frame id is still valid, then
8616 w->exp_valid_block is likewise valid, and we can safely use it.
8618 Don't do anything about disabled watchpoints, since they will be
8619 reevaluated again when enabled. */
8620 update_watchpoint (w
, 1 /* reparse */);
8623 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8626 insert_watchpoint (struct bp_location
*bl
)
8628 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8629 int length
= w
->exact
? 1 : bl
->length
;
8631 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8635 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8638 remove_watchpoint (struct bp_location
*bl
)
8640 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8641 int length
= w
->exact
? 1 : bl
->length
;
8643 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8648 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
8649 struct address_space
*aspace
, CORE_ADDR bp_addr
)
8651 struct breakpoint
*b
= bl
->owner
;
8652 struct watchpoint
*w
= (struct watchpoint
*) b
;
8654 /* Continuable hardware watchpoints are treated as non-existent if the
8655 reason we stopped wasn't a hardware watchpoint (we didn't stop on
8656 some data address). Otherwise gdb won't stop on a break instruction
8657 in the code (not from a breakpoint) when a hardware watchpoint has
8658 been defined. Also skip watchpoints which we know did not trigger
8659 (did not match the data address). */
8660 if (is_hardware_watchpoint (b
)
8661 && w
->watchpoint_triggered
== watch_triggered_no
)
8668 check_status_watchpoint (bpstat bs
)
8670 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
8672 bpstat_check_watchpoint (bs
);
8675 /* Implement the "resources_needed" breakpoint_ops method for
8676 hardware watchpoints. */
8679 resources_needed_watchpoint (const struct bp_location
*bl
)
8681 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8682 int length
= w
->exact
? 1 : bl
->length
;
8684 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
8687 /* Implement the "works_in_software_mode" breakpoint_ops method for
8688 hardware watchpoints. */
8691 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
8693 /* Read and access watchpoints only work with hardware support. */
8694 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
8697 static enum print_stop_action
8698 print_it_watchpoint (bpstat bs
)
8700 struct cleanup
*old_chain
;
8701 struct breakpoint
*b
;
8702 const struct bp_location
*bl
;
8703 struct ui_stream
*stb
;
8704 enum print_stop_action result
;
8705 struct watchpoint
*w
;
8706 struct ui_out
*uiout
= current_uiout
;
8708 gdb_assert (bs
->bp_location_at
!= NULL
);
8710 bl
= bs
->bp_location_at
;
8711 b
= bs
->breakpoint_at
;
8712 w
= (struct watchpoint
*) b
;
8714 stb
= ui_out_stream_new (uiout
);
8715 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
8720 case bp_hardware_watchpoint
:
8721 annotate_watchpoint (b
->number
);
8722 if (ui_out_is_mi_like_p (uiout
))
8725 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
8727 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8728 ui_out_text (uiout
, "\nOld value = ");
8729 watchpoint_value_print (bs
->old_val
, stb
->stream
);
8730 ui_out_field_stream (uiout
, "old", stb
);
8731 ui_out_text (uiout
, "\nNew value = ");
8732 watchpoint_value_print (w
->val
, stb
->stream
);
8733 ui_out_field_stream (uiout
, "new", stb
);
8734 ui_out_text (uiout
, "\n");
8735 /* More than one watchpoint may have been triggered. */
8736 result
= PRINT_UNKNOWN
;
8739 case bp_read_watchpoint
:
8740 if (ui_out_is_mi_like_p (uiout
))
8743 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
8745 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8746 ui_out_text (uiout
, "\nValue = ");
8747 watchpoint_value_print (w
->val
, stb
->stream
);
8748 ui_out_field_stream (uiout
, "value", stb
);
8749 ui_out_text (uiout
, "\n");
8750 result
= PRINT_UNKNOWN
;
8753 case bp_access_watchpoint
:
8754 if (bs
->old_val
!= NULL
)
8756 annotate_watchpoint (b
->number
);
8757 if (ui_out_is_mi_like_p (uiout
))
8760 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
8762 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8763 ui_out_text (uiout
, "\nOld value = ");
8764 watchpoint_value_print (bs
->old_val
, stb
->stream
);
8765 ui_out_field_stream (uiout
, "old", stb
);
8766 ui_out_text (uiout
, "\nNew value = ");
8771 if (ui_out_is_mi_like_p (uiout
))
8774 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
8775 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8776 ui_out_text (uiout
, "\nValue = ");
8778 watchpoint_value_print (w
->val
, stb
->stream
);
8779 ui_out_field_stream (uiout
, "new", stb
);
8780 ui_out_text (uiout
, "\n");
8781 result
= PRINT_UNKNOWN
;
8784 result
= PRINT_UNKNOWN
;
8787 do_cleanups (old_chain
);
8791 /* Implement the "print_mention" breakpoint_ops method for hardware
8795 print_mention_watchpoint (struct breakpoint
*b
)
8797 struct cleanup
*ui_out_chain
;
8798 struct watchpoint
*w
= (struct watchpoint
*) b
;
8799 struct ui_out
*uiout
= current_uiout
;
8804 ui_out_text (uiout
, "Watchpoint ");
8805 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
8807 case bp_hardware_watchpoint
:
8808 ui_out_text (uiout
, "Hardware watchpoint ");
8809 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
8811 case bp_read_watchpoint
:
8812 ui_out_text (uiout
, "Hardware read watchpoint ");
8813 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
8815 case bp_access_watchpoint
:
8816 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
8817 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
8820 internal_error (__FILE__
, __LINE__
,
8821 _("Invalid hardware watchpoint type."));
8824 ui_out_field_int (uiout
, "number", b
->number
);
8825 ui_out_text (uiout
, ": ");
8826 ui_out_field_string (uiout
, "exp", w
->exp_string
);
8827 do_cleanups (ui_out_chain
);
8830 /* Implement the "print_recreate" breakpoint_ops method for
8834 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8836 struct watchpoint
*w
= (struct watchpoint
*) b
;
8841 case bp_hardware_watchpoint
:
8842 fprintf_unfiltered (fp
, "watch");
8844 case bp_read_watchpoint
:
8845 fprintf_unfiltered (fp
, "rwatch");
8847 case bp_access_watchpoint
:
8848 fprintf_unfiltered (fp
, "awatch");
8851 internal_error (__FILE__
, __LINE__
,
8852 _("Invalid watchpoint type."));
8855 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
8856 print_recreate_thread (b
, fp
);
8859 /* The breakpoint_ops structure to be used in hardware watchpoints. */
8861 static struct breakpoint_ops watchpoint_breakpoint_ops
;
8863 /* Implement the "insert" breakpoint_ops method for
8864 masked hardware watchpoints. */
8867 insert_masked_watchpoint (struct bp_location
*bl
)
8869 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8871 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
8872 bl
->watchpoint_type
);
8875 /* Implement the "remove" breakpoint_ops method for
8876 masked hardware watchpoints. */
8879 remove_masked_watchpoint (struct bp_location
*bl
)
8881 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8883 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
8884 bl
->watchpoint_type
);
8887 /* Implement the "resources_needed" breakpoint_ops method for
8888 masked hardware watchpoints. */
8891 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
8893 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8895 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
8898 /* Implement the "works_in_software_mode" breakpoint_ops method for
8899 masked hardware watchpoints. */
8902 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
8907 /* Implement the "print_it" breakpoint_ops method for
8908 masked hardware watchpoints. */
8910 static enum print_stop_action
8911 print_it_masked_watchpoint (bpstat bs
)
8913 struct breakpoint
*b
= bs
->breakpoint_at
;
8914 struct ui_out
*uiout
= current_uiout
;
8916 /* Masked watchpoints have only one location. */
8917 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
8921 case bp_hardware_watchpoint
:
8922 annotate_watchpoint (b
->number
);
8923 if (ui_out_is_mi_like_p (uiout
))
8926 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
8929 case bp_read_watchpoint
:
8930 if (ui_out_is_mi_like_p (uiout
))
8933 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
8936 case bp_access_watchpoint
:
8937 if (ui_out_is_mi_like_p (uiout
))
8940 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
8943 internal_error (__FILE__
, __LINE__
,
8944 _("Invalid hardware watchpoint type."));
8948 ui_out_text (uiout
, _("\n\
8949 Check the underlying instruction at PC for the memory\n\
8950 address and value which triggered this watchpoint.\n"));
8951 ui_out_text (uiout
, "\n");
8953 /* More than one watchpoint may have been triggered. */
8954 return PRINT_UNKNOWN
;
8957 /* Implement the "print_one_detail" breakpoint_ops method for
8958 masked hardware watchpoints. */
8961 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
8962 struct ui_out
*uiout
)
8964 struct watchpoint
*w
= (struct watchpoint
*) b
;
8966 /* Masked watchpoints have only one location. */
8967 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
8969 ui_out_text (uiout
, "\tmask ");
8970 ui_out_field_core_addr (uiout
, "mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
8971 ui_out_text (uiout
, "\n");
8974 /* Implement the "print_mention" breakpoint_ops method for
8975 masked hardware watchpoints. */
8978 print_mention_masked_watchpoint (struct breakpoint
*b
)
8980 struct watchpoint
*w
= (struct watchpoint
*) b
;
8981 struct ui_out
*uiout
= current_uiout
;
8982 struct cleanup
*ui_out_chain
;
8986 case bp_hardware_watchpoint
:
8987 ui_out_text (uiout
, "Masked hardware watchpoint ");
8988 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
8990 case bp_read_watchpoint
:
8991 ui_out_text (uiout
, "Masked hardware read watchpoint ");
8992 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
8994 case bp_access_watchpoint
:
8995 ui_out_text (uiout
, "Masked hardware access (read/write) watchpoint ");
8996 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
8999 internal_error (__FILE__
, __LINE__
,
9000 _("Invalid hardware watchpoint type."));
9003 ui_out_field_int (uiout
, "number", b
->number
);
9004 ui_out_text (uiout
, ": ");
9005 ui_out_field_string (uiout
, "exp", w
->exp_string
);
9006 do_cleanups (ui_out_chain
);
9009 /* Implement the "print_recreate" breakpoint_ops method for
9010 masked hardware watchpoints. */
9013 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9015 struct watchpoint
*w
= (struct watchpoint
*) b
;
9020 case bp_hardware_watchpoint
:
9021 fprintf_unfiltered (fp
, "watch");
9023 case bp_read_watchpoint
:
9024 fprintf_unfiltered (fp
, "rwatch");
9026 case bp_access_watchpoint
:
9027 fprintf_unfiltered (fp
, "awatch");
9030 internal_error (__FILE__
, __LINE__
,
9031 _("Invalid hardware watchpoint type."));
9034 sprintf_vma (tmp
, w
->hw_wp_mask
);
9035 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
9036 print_recreate_thread (b
, fp
);
9039 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
9041 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
9043 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
9046 is_masked_watchpoint (const struct breakpoint
*b
)
9048 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
9051 /* accessflag: hw_write: watch write,
9052 hw_read: watch read,
9053 hw_access: watch access (read or write) */
9055 watch_command_1 (char *arg
, int accessflag
, int from_tty
,
9056 int just_location
, int internal
)
9058 volatile struct gdb_exception e
;
9059 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
9060 struct expression
*exp
;
9061 struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
9062 struct value
*val
, *mark
, *result
;
9063 struct frame_info
*frame
;
9064 char *exp_start
= NULL
;
9065 char *exp_end
= NULL
;
9066 char *tok
, *end_tok
;
9068 char *cond_start
= NULL
;
9069 char *cond_end
= NULL
;
9070 enum bptype bp_type
;
9073 /* Flag to indicate whether we are going to use masks for
9074 the hardware watchpoint. */
9077 struct watchpoint
*w
;
9079 /* Make sure that we actually have parameters to parse. */
9080 if (arg
!= NULL
&& arg
[0] != '\0')
9084 /* Look for "parameter value" pairs at the end
9085 of the arguments string. */
9086 for (tok
= arg
+ strlen (arg
) - 1; tok
> arg
; tok
--)
9088 /* Skip whitespace at the end of the argument list. */
9089 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
9092 /* Find the beginning of the last token.
9093 This is the value of the parameter. */
9094 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
9096 value_start
= tok
+ 1;
9098 /* Skip whitespace. */
9099 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
9104 /* Find the beginning of the second to last token.
9105 This is the parameter itself. */
9106 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
9109 toklen
= end_tok
- tok
+ 1;
9111 if (toklen
== 6 && !strncmp (tok
, "thread", 6))
9113 /* At this point we've found a "thread" token, which means
9114 the user is trying to set a watchpoint that triggers
9115 only in a specific thread. */
9119 error(_("You can specify only one thread."));
9121 /* Extract the thread ID from the next token. */
9122 thread
= strtol (value_start
, &endp
, 0);
9124 /* Check if the user provided a valid numeric value for the
9126 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
9127 error (_("Invalid thread ID specification %s."), value_start
);
9129 /* Check if the thread actually exists. */
9130 if (!valid_thread_id (thread
))
9131 error (_("Unknown thread %d."), thread
);
9133 else if (toklen
== 4 && !strncmp (tok
, "mask", 4))
9135 /* We've found a "mask" token, which means the user wants to
9136 create a hardware watchpoint that is going to have the mask
9138 struct value
*mask_value
, *mark
;
9141 error(_("You can specify only one mask."));
9143 use_mask
= just_location
= 1;
9145 mark
= value_mark ();
9146 mask_value
= parse_to_comma_and_eval (&value_start
);
9147 mask
= value_as_address (mask_value
);
9148 value_free_to_mark (mark
);
9151 /* We didn't recognize what we found. We should stop here. */
9154 /* Truncate the string and get rid of the "parameter value" pair before
9155 the arguments string is parsed by the parse_exp_1 function. */
9160 /* Parse the rest of the arguments. */
9161 innermost_block
= NULL
;
9163 exp
= parse_exp_1 (&arg
, 0, 0);
9165 /* Remove trailing whitespace from the expression before saving it.
9166 This makes the eventual display of the expression string a bit
9168 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
9171 /* Checking if the expression is not constant. */
9172 if (watchpoint_exp_is_const (exp
))
9176 len
= exp_end
- exp_start
;
9177 while (len
> 0 && isspace (exp_start
[len
- 1]))
9179 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
9182 exp_valid_block
= innermost_block
;
9183 mark
= value_mark ();
9184 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
);
9190 exp_valid_block
= NULL
;
9191 val
= value_addr (result
);
9192 release_value (val
);
9193 value_free_to_mark (mark
);
9197 ret
= target_masked_watch_num_registers (value_as_address (val
),
9200 error (_("This target does not support masked watchpoints."));
9202 error (_("Invalid mask or memory region."));
9205 else if (val
!= NULL
)
9206 release_value (val
);
9208 tok
= skip_spaces (arg
);
9209 end_tok
= skip_to_space (tok
);
9211 toklen
= end_tok
- tok
;
9212 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9214 struct expression
*cond
;
9216 innermost_block
= NULL
;
9217 tok
= cond_start
= end_tok
+ 1;
9218 cond
= parse_exp_1 (&tok
, 0, 0);
9220 /* The watchpoint expression may not be local, but the condition
9221 may still be. E.g.: `watch global if local > 0'. */
9222 cond_exp_valid_block
= innermost_block
;
9228 error (_("Junk at end of command."));
9230 if (accessflag
== hw_read
)
9231 bp_type
= bp_read_watchpoint
;
9232 else if (accessflag
== hw_access
)
9233 bp_type
= bp_access_watchpoint
;
9235 bp_type
= bp_hardware_watchpoint
;
9237 frame
= block_innermost_frame (exp_valid_block
);
9239 /* If the expression is "local", then set up a "watchpoint scope"
9240 breakpoint at the point where we've left the scope of the watchpoint
9241 expression. Create the scope breakpoint before the watchpoint, so
9242 that we will encounter it first in bpstat_stop_status. */
9243 if (exp_valid_block
&& frame
)
9245 if (frame_id_p (frame_unwind_caller_id (frame
)))
9248 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
9249 frame_unwind_caller_pc (frame
),
9250 bp_watchpoint_scope
,
9251 &momentary_breakpoint_ops
);
9253 scope_breakpoint
->enable_state
= bp_enabled
;
9255 /* Automatically delete the breakpoint when it hits. */
9256 scope_breakpoint
->disposition
= disp_del
;
9258 /* Only break in the proper frame (help with recursion). */
9259 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
9261 /* Set the address at which we will stop. */
9262 scope_breakpoint
->loc
->gdbarch
9263 = frame_unwind_caller_arch (frame
);
9264 scope_breakpoint
->loc
->requested_address
9265 = frame_unwind_caller_pc (frame
);
9266 scope_breakpoint
->loc
->address
9267 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
9268 scope_breakpoint
->loc
->requested_address
,
9269 scope_breakpoint
->type
);
9273 /* Now set up the breakpoint. */
9275 w
= XCNEW (struct watchpoint
);
9278 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
9279 &masked_watchpoint_breakpoint_ops
);
9281 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
9282 &watchpoint_breakpoint_ops
);
9284 b
->disposition
= disp_donttouch
;
9285 b
->pspace
= current_program_space
;
9287 w
->exp_valid_block
= exp_valid_block
;
9288 w
->cond_exp_valid_block
= cond_exp_valid_block
;
9291 struct type
*t
= value_type (val
);
9292 CORE_ADDR addr
= value_as_address (val
);
9295 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
9296 name
= type_to_string (t
);
9298 w
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
9299 core_addr_to_string (addr
));
9302 w
->exp_string
= xstrprintf ("-location %.*s",
9303 (int) (exp_end
- exp_start
), exp_start
);
9305 /* The above expression is in C. */
9306 b
->language
= language_c
;
9309 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
9313 w
->hw_wp_mask
= mask
;
9322 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9328 w
->watchpoint_frame
= get_frame_id (frame
);
9329 w
->watchpoint_thread
= inferior_ptid
;
9333 w
->watchpoint_frame
= null_frame_id
;
9334 w
->watchpoint_thread
= null_ptid
;
9337 if (scope_breakpoint
!= NULL
)
9339 /* The scope breakpoint is related to the watchpoint. We will
9340 need to act on them together. */
9341 b
->related_breakpoint
= scope_breakpoint
;
9342 scope_breakpoint
->related_breakpoint
= b
;
9346 value_free_to_mark (mark
);
9348 TRY_CATCH (e
, RETURN_MASK_ALL
)
9350 /* Finally update the new watchpoint. This creates the locations
9351 that should be inserted. */
9352 update_watchpoint (w
, 1);
9356 delete_breakpoint (b
);
9357 throw_exception (e
);
9360 install_breakpoint (internal
, b
);
9363 /* Return count of debug registers needed to watch the given expression.
9364 If the watchpoint cannot be handled in hardware return zero. */
9367 can_use_hardware_watchpoint (struct value
*v
)
9369 int found_memory_cnt
= 0;
9370 struct value
*head
= v
;
9372 /* Did the user specifically forbid us to use hardware watchpoints? */
9373 if (!can_use_hw_watchpoints
)
9376 /* Make sure that the value of the expression depends only upon
9377 memory contents, and values computed from them within GDB. If we
9378 find any register references or function calls, we can't use a
9379 hardware watchpoint.
9381 The idea here is that evaluating an expression generates a series
9382 of values, one holding the value of every subexpression. (The
9383 expression a*b+c has five subexpressions: a, b, a*b, c, and
9384 a*b+c.) GDB's values hold almost enough information to establish
9385 the criteria given above --- they identify memory lvalues,
9386 register lvalues, computed values, etcetera. So we can evaluate
9387 the expression, and then scan the chain of values that leaves
9388 behind to decide whether we can detect any possible change to the
9389 expression's final value using only hardware watchpoints.
9391 However, I don't think that the values returned by inferior
9392 function calls are special in any way. So this function may not
9393 notice that an expression involving an inferior function call
9394 can't be watched with hardware watchpoints. FIXME. */
9395 for (; v
; v
= value_next (v
))
9397 if (VALUE_LVAL (v
) == lval_memory
)
9399 if (v
!= head
&& value_lazy (v
))
9400 /* A lazy memory lvalue in the chain is one that GDB never
9401 needed to fetch; we either just used its address (e.g.,
9402 `a' in `a.b') or we never needed it at all (e.g., `a'
9403 in `a,b'). This doesn't apply to HEAD; if that is
9404 lazy then it was not readable, but watch it anyway. */
9408 /* Ahh, memory we actually used! Check if we can cover
9409 it with hardware watchpoints. */
9410 struct type
*vtype
= check_typedef (value_type (v
));
9412 /* We only watch structs and arrays if user asked for it
9413 explicitly, never if they just happen to appear in a
9414 middle of some value chain. */
9416 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
9417 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
9419 CORE_ADDR vaddr
= value_address (v
);
9423 len
= (target_exact_watchpoints
9424 && is_scalar_type_recursive (vtype
))?
9425 1 : TYPE_LENGTH (value_type (v
));
9427 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
9431 found_memory_cnt
+= num_regs
;
9435 else if (VALUE_LVAL (v
) != not_lval
9436 && deprecated_value_modifiable (v
) == 0)
9437 return 0; /* These are values from the history (e.g., $1). */
9438 else if (VALUE_LVAL (v
) == lval_register
)
9439 return 0; /* Cannot watch a register with a HW watchpoint. */
9442 /* The expression itself looks suitable for using a hardware
9443 watchpoint, but give the target machine a chance to reject it. */
9444 return found_memory_cnt
;
9448 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
9450 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
9453 /* A helper function that looks for an argument at the start of a
9454 string. The argument must also either be at the end of the string,
9455 or be followed by whitespace. Returns 1 if it finds the argument,
9456 0 otherwise. If the argument is found, it updates *STR. */
9459 check_for_argument (char **str
, char *arg
, int arg_len
)
9461 if (strncmp (*str
, arg
, arg_len
) == 0
9462 && ((*str
)[arg_len
] == '\0' || isspace ((*str
)[arg_len
])))
9470 /* A helper function that looks for the "-location" argument and then
9471 calls watch_command_1. */
9474 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
9476 int just_location
= 0;
9479 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
9480 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
9482 arg
= skip_spaces (arg
);
9486 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
9490 watch_command (char *arg
, int from_tty
)
9492 watch_maybe_just_location (arg
, hw_write
, from_tty
);
9496 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9498 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
9502 rwatch_command (char *arg
, int from_tty
)
9504 watch_maybe_just_location (arg
, hw_read
, from_tty
);
9508 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9510 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
9514 awatch_command (char *arg
, int from_tty
)
9516 watch_maybe_just_location (arg
, hw_access
, from_tty
);
9520 /* Helper routines for the until_command routine in infcmd.c. Here
9521 because it uses the mechanisms of breakpoints. */
9523 struct until_break_command_continuation_args
9525 struct breakpoint
*breakpoint
;
9526 struct breakpoint
*breakpoint2
;
9530 /* This function is called by fetch_inferior_event via the
9531 cmd_continuation pointer, to complete the until command. It takes
9532 care of cleaning up the temporary breakpoints set up by the until
9535 until_break_command_continuation (void *arg
, int err
)
9537 struct until_break_command_continuation_args
*a
= arg
;
9539 delete_breakpoint (a
->breakpoint
);
9541 delete_breakpoint (a
->breakpoint2
);
9542 delete_longjmp_breakpoint (a
->thread_num
);
9546 until_break_command (char *arg
, int from_tty
, int anywhere
)
9548 struct symtabs_and_lines sals
;
9549 struct symtab_and_line sal
;
9550 struct frame_info
*frame
= get_selected_frame (NULL
);
9551 struct breakpoint
*breakpoint
;
9552 struct breakpoint
*breakpoint2
= NULL
;
9553 struct cleanup
*old_chain
;
9555 struct thread_info
*tp
;
9557 clear_proceed_status ();
9559 /* Set a breakpoint where the user wants it and at return from
9562 if (default_breakpoint_valid
)
9563 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
9564 default_breakpoint_line
, NULL
);
9566 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
, 0, NULL
);
9568 if (sals
.nelts
!= 1)
9569 error (_("Couldn't get information on specified line."));
9572 xfree (sals
.sals
); /* malloc'd, so freed. */
9575 error (_("Junk at end of arguments."));
9577 resolve_sal_pc (&sal
);
9580 /* If the user told us to continue until a specified location,
9581 we don't specify a frame at which we need to stop. */
9582 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9583 null_frame_id
, bp_until
);
9585 /* Otherwise, specify the selected frame, because we want to stop
9586 only at the very same frame. */
9587 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9588 get_stack_frame_id (frame
),
9591 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
9593 tp
= inferior_thread ();
9596 /* Keep within the current frame, or in frames called by the current
9599 if (frame_id_p (frame_unwind_caller_id (frame
)))
9601 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
9602 sal
.pc
= frame_unwind_caller_pc (frame
);
9603 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
9605 frame_unwind_caller_id (frame
),
9607 make_cleanup_delete_breakpoint (breakpoint2
);
9609 set_longjmp_breakpoint (tp
, frame_unwind_caller_id (frame
));
9610 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
9613 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
9615 /* If we are running asynchronously, and proceed call above has
9616 actually managed to start the target, arrange for breakpoints to
9617 be deleted when the target stops. Otherwise, we're already
9618 stopped and delete breakpoints via cleanup chain. */
9620 if (target_can_async_p () && is_running (inferior_ptid
))
9622 struct until_break_command_continuation_args
*args
;
9623 args
= xmalloc (sizeof (*args
));
9625 args
->breakpoint
= breakpoint
;
9626 args
->breakpoint2
= breakpoint2
;
9627 args
->thread_num
= thread
;
9629 discard_cleanups (old_chain
);
9630 add_continuation (inferior_thread (),
9631 until_break_command_continuation
, args
,
9635 do_cleanups (old_chain
);
9638 /* This function attempts to parse an optional "if <cond>" clause
9639 from the arg string. If one is not found, it returns NULL.
9641 Else, it returns a pointer to the condition string. (It does not
9642 attempt to evaluate the string against a particular block.) And,
9643 it updates arg to point to the first character following the parsed
9644 if clause in the arg string. */
9647 ep_parse_optional_if_clause (char **arg
)
9651 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
9654 /* Skip the "if" keyword. */
9657 /* Skip any extra leading whitespace, and record the start of the
9658 condition string. */
9659 *arg
= skip_spaces (*arg
);
9662 /* Assume that the condition occupies the remainder of the arg
9664 (*arg
) += strlen (cond_string
);
9669 /* Commands to deal with catching events, such as signals, exceptions,
9670 process start/exit, etc. */
9674 catch_fork_temporary
, catch_vfork_temporary
,
9675 catch_fork_permanent
, catch_vfork_permanent
9680 catch_fork_command_1 (char *arg
, int from_tty
,
9681 struct cmd_list_element
*command
)
9683 struct gdbarch
*gdbarch
= get_current_arch ();
9684 char *cond_string
= NULL
;
9685 catch_fork_kind fork_kind
;
9688 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
9689 tempflag
= (fork_kind
== catch_fork_temporary
9690 || fork_kind
== catch_vfork_temporary
);
9694 arg
= skip_spaces (arg
);
9696 /* The allowed syntax is:
9698 catch [v]fork if <cond>
9700 First, check if there's an if clause. */
9701 cond_string
= ep_parse_optional_if_clause (&arg
);
9703 if ((*arg
!= '\0') && !isspace (*arg
))
9704 error (_("Junk at end of arguments."));
9706 /* If this target supports it, create a fork or vfork catchpoint
9707 and enable reporting of such events. */
9710 case catch_fork_temporary
:
9711 case catch_fork_permanent
:
9712 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9713 &catch_fork_breakpoint_ops
);
9715 case catch_vfork_temporary
:
9716 case catch_vfork_permanent
:
9717 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9718 &catch_vfork_breakpoint_ops
);
9721 error (_("unsupported or unknown fork kind; cannot catch it"));
9727 catch_exec_command_1 (char *arg
, int from_tty
,
9728 struct cmd_list_element
*command
)
9730 struct exec_catchpoint
*c
;
9731 struct gdbarch
*gdbarch
= get_current_arch ();
9733 char *cond_string
= NULL
;
9735 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9739 arg
= skip_spaces (arg
);
9741 /* The allowed syntax is:
9743 catch exec if <cond>
9745 First, check if there's an if clause. */
9746 cond_string
= ep_parse_optional_if_clause (&arg
);
9748 if ((*arg
!= '\0') && !isspace (*arg
))
9749 error (_("Junk at end of arguments."));
9751 c
= XNEW (struct exec_catchpoint
);
9752 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
,
9753 &catch_exec_breakpoint_ops
);
9754 c
->exec_pathname
= NULL
;
9756 install_breakpoint (0, &c
->base
);
9759 static enum print_stop_action
9760 print_it_exception_catchpoint (bpstat bs
)
9762 struct ui_out
*uiout
= current_uiout
;
9763 struct breakpoint
*b
= bs
->breakpoint_at
;
9764 int bp_temp
, bp_throw
;
9766 annotate_catchpoint (b
->number
);
9768 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9769 if (b
->loc
->address
!= b
->loc
->requested_address
)
9770 breakpoint_adjustment_warning (b
->loc
->requested_address
,
9773 bp_temp
= b
->disposition
== disp_del
;
9775 bp_temp
? "Temporary catchpoint "
9777 if (!ui_out_is_mi_like_p (uiout
))
9778 ui_out_field_int (uiout
, "bkptno", b
->number
);
9780 bp_throw
? " (exception thrown), "
9781 : " (exception caught), ");
9782 if (ui_out_is_mi_like_p (uiout
))
9784 ui_out_field_string (uiout
, "reason",
9785 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9786 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
9787 ui_out_field_int (uiout
, "bkptno", b
->number
);
9789 return PRINT_SRC_AND_LOC
;
9793 print_one_exception_catchpoint (struct breakpoint
*b
,
9794 struct bp_location
**last_loc
)
9796 struct value_print_options opts
;
9797 struct ui_out
*uiout
= current_uiout
;
9799 get_user_print_options (&opts
);
9800 if (opts
.addressprint
)
9803 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
9804 ui_out_field_string (uiout
, "addr", "<PENDING>");
9806 ui_out_field_core_addr (uiout
, "addr",
9807 b
->loc
->gdbarch
, b
->loc
->address
);
9812 if (strstr (b
->addr_string
, "throw") != NULL
)
9813 ui_out_field_string (uiout
, "what", "exception throw");
9815 ui_out_field_string (uiout
, "what", "exception catch");
9819 print_mention_exception_catchpoint (struct breakpoint
*b
)
9821 struct ui_out
*uiout
= current_uiout
;
9825 bp_temp
= b
->disposition
== disp_del
;
9826 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9827 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
9828 : _("Catchpoint "));
9829 ui_out_field_int (uiout
, "bkptno", b
->number
);
9830 ui_out_text (uiout
, bp_throw
? _(" (throw)")
9834 /* Implement the "print_recreate" breakpoint_ops method for throw and
9835 catch catchpoints. */
9838 print_recreate_exception_catchpoint (struct breakpoint
*b
,
9844 bp_temp
= b
->disposition
== disp_del
;
9845 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9846 fprintf_unfiltered (fp
, bp_temp
? "tcatch " : "catch ");
9847 fprintf_unfiltered (fp
, bp_throw
? "throw" : "catch");
9848 print_recreate_thread (b
, fp
);
9851 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
;
9854 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
9855 enum exception_event_kind ex_event
, int from_tty
)
9857 char *trigger_func_name
;
9859 if (ex_event
== EX_EVENT_CATCH
)
9860 trigger_func_name
= "__cxa_begin_catch";
9862 trigger_func_name
= "__cxa_throw";
9864 create_breakpoint (get_current_arch (),
9865 trigger_func_name
, cond_string
, -1,
9866 0 /* condition and thread are valid. */,
9867 tempflag
, bp_breakpoint
,
9869 AUTO_BOOLEAN_TRUE
/* pending */,
9870 &gnu_v3_exception_catchpoint_ops
, from_tty
,
9877 /* Deal with "catch catch" and "catch throw" commands. */
9880 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
9881 int tempflag
, int from_tty
)
9883 char *cond_string
= NULL
;
9887 arg
= skip_spaces (arg
);
9889 cond_string
= ep_parse_optional_if_clause (&arg
);
9891 if ((*arg
!= '\0') && !isspace (*arg
))
9892 error (_("Junk at end of arguments."));
9894 if (ex_event
!= EX_EVENT_THROW
9895 && ex_event
!= EX_EVENT_CATCH
)
9896 error (_("Unsupported or unknown exception event; cannot catch it"));
9898 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
9901 warning (_("Unsupported with this platform/compiler combination."));
9904 /* Implementation of "catch catch" command. */
9907 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9909 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9911 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
9914 /* Implementation of "catch throw" command. */
9917 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
9919 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9921 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
9925 init_ada_exception_breakpoint (struct breakpoint
*b
,
9926 struct gdbarch
*gdbarch
,
9927 struct symtab_and_line sal
,
9929 const struct breakpoint_ops
*ops
,
9935 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9937 loc_gdbarch
= gdbarch
;
9939 describe_other_breakpoints (loc_gdbarch
,
9940 sal
.pspace
, sal
.pc
, sal
.section
, -1);
9941 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
9942 version for exception catchpoints, because two catchpoints
9943 used for different exception names will use the same address.
9944 In this case, a "breakpoint ... also set at..." warning is
9945 unproductive. Besides, the warning phrasing is also a bit
9946 inappropriate, we should use the word catchpoint, and tell
9947 the user what type of catchpoint it is. The above is good
9948 enough for now, though. */
9951 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
9953 b
->enable_state
= bp_enabled
;
9954 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9955 b
->addr_string
= addr_string
;
9956 b
->language
= language_ada
;
9959 /* Splits the argument using space as delimiter. Returns an xmalloc'd
9960 filter list, or NULL if no filtering is required. */
9962 catch_syscall_split_args (char *arg
)
9964 VEC(int) *result
= NULL
;
9965 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (int), &result
);
9967 while (*arg
!= '\0')
9969 int i
, syscall_number
;
9974 /* Skip whitespace. */
9975 while (isspace (*arg
))
9978 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
9979 cur_name
[i
] = arg
[i
];
9983 /* Check if the user provided a syscall name or a number. */
9984 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
9985 if (*endptr
== '\0')
9986 get_syscall_by_number (syscall_number
, &s
);
9989 /* We have a name. Let's check if it's valid and convert it
9991 get_syscall_by_name (cur_name
, &s
);
9993 if (s
.number
== UNKNOWN_SYSCALL
)
9994 /* Here we have to issue an error instead of a warning,
9995 because GDB cannot do anything useful if there's no
9996 syscall number to be caught. */
9997 error (_("Unknown syscall name '%s'."), cur_name
);
10000 /* Ok, it's valid. */
10001 VEC_safe_push (int, result
, s
.number
);
10004 discard_cleanups (cleanup
);
10008 /* Implement the "catch syscall" command. */
10011 catch_syscall_command_1 (char *arg
, int from_tty
,
10012 struct cmd_list_element
*command
)
10017 struct gdbarch
*gdbarch
= get_current_arch ();
10019 /* Checking if the feature if supported. */
10020 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
10021 error (_("The feature 'catch syscall' is not supported on \
10022 this architecture yet."));
10024 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
10026 arg
= skip_spaces (arg
);
10028 /* We need to do this first "dummy" translation in order
10029 to get the syscall XML file loaded or, most important,
10030 to display a warning to the user if there's no XML file
10031 for his/her architecture. */
10032 get_syscall_by_number (0, &s
);
10034 /* The allowed syntax is:
10036 catch syscall <name | number> [<name | number> ... <name | number>]
10038 Let's check if there's a syscall name. */
10041 filter
= catch_syscall_split_args (arg
);
10045 create_syscall_event_catchpoint (tempflag
, filter
,
10046 &catch_syscall_breakpoint_ops
);
10050 catch_command (char *arg
, int from_tty
)
10052 error (_("Catch requires an event name."));
10057 tcatch_command (char *arg
, int from_tty
)
10059 error (_("Catch requires an event name."));
10062 /* Delete breakpoints by address or line. */
10065 clear_command (char *arg
, int from_tty
)
10067 struct breakpoint
*b
;
10068 VEC(breakpoint_p
) *found
= 0;
10071 struct symtabs_and_lines sals
;
10072 struct symtab_and_line sal
;
10077 sals
= decode_line_spec (arg
, 1);
10082 sals
.sals
= (struct symtab_and_line
*)
10083 xmalloc (sizeof (struct symtab_and_line
));
10084 make_cleanup (xfree
, sals
.sals
);
10085 init_sal (&sal
); /* Initialize to zeroes. */
10086 sal
.line
= default_breakpoint_line
;
10087 sal
.symtab
= default_breakpoint_symtab
;
10088 sal
.pc
= default_breakpoint_address
;
10089 sal
.pspace
= default_breakpoint_pspace
;
10090 if (sal
.symtab
== 0)
10091 error (_("No source file specified."));
10093 sals
.sals
[0] = sal
;
10099 /* We don't call resolve_sal_pc here. That's not as bad as it
10100 seems, because all existing breakpoints typically have both
10101 file/line and pc set. So, if clear is given file/line, we can
10102 match this to existing breakpoint without obtaining pc at all.
10104 We only support clearing given the address explicitly
10105 present in breakpoint table. Say, we've set breakpoint
10106 at file:line. There were several PC values for that file:line,
10107 due to optimization, all in one block.
10109 We've picked one PC value. If "clear" is issued with another
10110 PC corresponding to the same file:line, the breakpoint won't
10111 be cleared. We probably can still clear the breakpoint, but
10112 since the other PC value is never presented to user, user
10113 can only find it by guessing, and it does not seem important
10114 to support that. */
10116 /* For each line spec given, delete bps which correspond to it. Do
10117 it in two passes, solely to preserve the current behavior that
10118 from_tty is forced true if we delete more than one
10122 for (i
= 0; i
< sals
.nelts
; i
++)
10124 /* If exact pc given, clear bpts at that pc.
10125 If line given (pc == 0), clear all bpts on specified line.
10126 If defaulting, clear all bpts on default line
10129 defaulting sal.pc != 0 tests to do
10134 1 0 <can't happen> */
10136 sal
= sals
.sals
[i
];
10138 /* Find all matching breakpoints and add them to 'found'. */
10139 ALL_BREAKPOINTS (b
)
10142 /* Are we going to delete b? */
10143 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
10145 struct bp_location
*loc
= b
->loc
;
10146 for (; loc
; loc
= loc
->next
)
10148 int pc_match
= sal
.pc
10149 && (loc
->pspace
== sal
.pspace
)
10150 && (loc
->address
== sal
.pc
)
10151 && (!section_is_overlay (loc
->section
)
10152 || loc
->section
== sal
.section
);
10153 int line_match
= ((default_match
|| (0 == sal
.pc
))
10154 && b
->source_file
!= NULL
10155 && sal
.symtab
!= NULL
10156 && sal
.pspace
== loc
->pspace
10157 && filename_cmp (b
->source_file
,
10158 sal
.symtab
->filename
) == 0
10159 && b
->line_number
== sal
.line
);
10160 if (pc_match
|| line_match
)
10169 VEC_safe_push(breakpoint_p
, found
, b
);
10172 /* Now go thru the 'found' chain and delete them. */
10173 if (VEC_empty(breakpoint_p
, found
))
10176 error (_("No breakpoint at %s."), arg
);
10178 error (_("No breakpoint at this line."));
10181 if (VEC_length(breakpoint_p
, found
) > 1)
10182 from_tty
= 1; /* Always report if deleted more than one. */
10185 if (VEC_length(breakpoint_p
, found
) == 1)
10186 printf_unfiltered (_("Deleted breakpoint "));
10188 printf_unfiltered (_("Deleted breakpoints "));
10190 breakpoints_changed ();
10192 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
10195 printf_unfiltered ("%d ", b
->number
);
10196 delete_breakpoint (b
);
10199 putchar_unfiltered ('\n');
10202 /* Delete breakpoint in BS if they are `delete' breakpoints and
10203 all breakpoints that are marked for deletion, whether hit or not.
10204 This is called after any breakpoint is hit, or after errors. */
10207 breakpoint_auto_delete (bpstat bs
)
10209 struct breakpoint
*b
, *b_tmp
;
10211 for (; bs
; bs
= bs
->next
)
10212 if (bs
->breakpoint_at
10213 && bs
->breakpoint_at
->disposition
== disp_del
10215 delete_breakpoint (bs
->breakpoint_at
);
10217 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10219 if (b
->disposition
== disp_del_at_next_stop
)
10220 delete_breakpoint (b
);
10224 /* A comparison function for bp_location AP and BP being interfaced to
10225 qsort. Sort elements primarily by their ADDRESS (no matter what
10226 does breakpoint_address_is_meaningful say for its OWNER),
10227 secondarily by ordering first bp_permanent OWNERed elements and
10228 terciarily just ensuring the array is sorted stable way despite
10229 qsort being an unstable algorithm. */
10232 bp_location_compare (const void *ap
, const void *bp
)
10234 struct bp_location
*a
= *(void **) ap
;
10235 struct bp_location
*b
= *(void **) bp
;
10236 /* A and B come from existing breakpoints having non-NULL OWNER. */
10237 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
10238 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
10240 if (a
->address
!= b
->address
)
10241 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
10243 /* Sort permanent breakpoints first. */
10244 if (a_perm
!= b_perm
)
10245 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
10247 /* Make the user-visible order stable across GDB runs. Locations of
10248 the same breakpoint can be sorted in arbitrary order. */
10250 if (a
->owner
->number
!= b
->owner
->number
)
10251 return (a
->owner
->number
> b
->owner
->number
)
10252 - (a
->owner
->number
< b
->owner
->number
);
10254 return (a
> b
) - (a
< b
);
10257 /* Set bp_location_placed_address_before_address_max and
10258 bp_location_shadow_len_after_address_max according to the current
10259 content of the bp_location array. */
10262 bp_location_target_extensions_update (void)
10264 struct bp_location
*bl
, **blp_tmp
;
10266 bp_location_placed_address_before_address_max
= 0;
10267 bp_location_shadow_len_after_address_max
= 0;
10269 ALL_BP_LOCATIONS (bl
, blp_tmp
)
10271 CORE_ADDR start
, end
, addr
;
10273 if (!bp_location_has_shadow (bl
))
10276 start
= bl
->target_info
.placed_address
;
10277 end
= start
+ bl
->target_info
.shadow_len
;
10279 gdb_assert (bl
->address
>= start
);
10280 addr
= bl
->address
- start
;
10281 if (addr
> bp_location_placed_address_before_address_max
)
10282 bp_location_placed_address_before_address_max
= addr
;
10284 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
10286 gdb_assert (bl
->address
< end
);
10287 addr
= end
- bl
->address
;
10288 if (addr
> bp_location_shadow_len_after_address_max
)
10289 bp_location_shadow_len_after_address_max
= addr
;
10293 /* Swap the insertion/duplication state between two locations. */
10296 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
10298 const int left_inserted
= left
->inserted
;
10299 const int left_duplicate
= left
->duplicate
;
10300 const struct bp_target_info left_target_info
= left
->target_info
;
10302 left
->inserted
= right
->inserted
;
10303 left
->duplicate
= right
->duplicate
;
10304 left
->target_info
= right
->target_info
;
10305 right
->inserted
= left_inserted
;
10306 right
->duplicate
= left_duplicate
;
10307 right
->target_info
= left_target_info
;
10310 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
10311 into the inferior, only remove already-inserted locations that no
10312 longer should be inserted. Functions that delete a breakpoint or
10313 breakpoints should pass false, so that deleting a breakpoint
10314 doesn't have the side effect of inserting the locations of other
10315 breakpoints that are marked not-inserted, but should_be_inserted
10316 returns true on them.
10318 This behaviour is useful is situations close to tear-down -- e.g.,
10319 after an exec, while the target still has execution, but breakpoint
10320 shadows of the previous executable image should *NOT* be restored
10321 to the new image; or before detaching, where the target still has
10322 execution and wants to delete breakpoints from GDB's lists, and all
10323 breakpoints had already been removed from the inferior. */
10326 update_global_location_list (int should_insert
)
10328 struct breakpoint
*b
;
10329 struct bp_location
**locp
, *loc
;
10330 struct cleanup
*cleanups
;
10332 /* Used in the duplicates detection below. When iterating over all
10333 bp_locations, points to the first bp_location of a given address.
10334 Breakpoints and watchpoints of different types are never
10335 duplicates of each other. Keep one pointer for each type of
10336 breakpoint/watchpoint, so we only need to loop over all locations
10338 struct bp_location
*bp_loc_first
; /* breakpoint */
10339 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
10340 struct bp_location
*awp_loc_first
; /* access watchpoint */
10341 struct bp_location
*rwp_loc_first
; /* read watchpoint */
10343 /* Saved former bp_location array which we compare against the newly
10344 built bp_location from the current state of ALL_BREAKPOINTS. */
10345 struct bp_location
**old_location
, **old_locp
;
10346 unsigned old_location_count
;
10348 old_location
= bp_location
;
10349 old_location_count
= bp_location_count
;
10350 bp_location
= NULL
;
10351 bp_location_count
= 0;
10352 cleanups
= make_cleanup (xfree
, old_location
);
10354 ALL_BREAKPOINTS (b
)
10355 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10356 bp_location_count
++;
10358 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
10359 locp
= bp_location
;
10360 ALL_BREAKPOINTS (b
)
10361 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10363 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
10364 bp_location_compare
);
10366 bp_location_target_extensions_update ();
10368 /* Identify bp_location instances that are no longer present in the
10369 new list, and therefore should be freed. Note that it's not
10370 necessary that those locations should be removed from inferior --
10371 if there's another location at the same address (previously
10372 marked as duplicate), we don't need to remove/insert the
10375 LOCP is kept in sync with OLD_LOCP, each pointing to the current
10376 and former bp_location array state respectively. */
10378 locp
= bp_location
;
10379 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
10382 struct bp_location
*old_loc
= *old_locp
;
10383 struct bp_location
**loc2p
;
10385 /* Tells if 'old_loc' is found among the new locations. If
10386 not, we have to free it. */
10387 int found_object
= 0;
10388 /* Tells if the location should remain inserted in the target. */
10389 int keep_in_target
= 0;
10392 /* Skip LOCP entries which will definitely never be needed.
10393 Stop either at or being the one matching OLD_LOC. */
10394 while (locp
< bp_location
+ bp_location_count
10395 && (*locp
)->address
< old_loc
->address
)
10399 (loc2p
< bp_location
+ bp_location_count
10400 && (*loc2p
)->address
== old_loc
->address
);
10403 if (*loc2p
== old_loc
)
10410 /* If this location is no longer present, and inserted, look if
10411 there's maybe a new location at the same address. If so,
10412 mark that one inserted, and don't remove this one. This is
10413 needed so that we don't have a time window where a breakpoint
10414 at certain location is not inserted. */
10416 if (old_loc
->inserted
)
10418 /* If the location is inserted now, we might have to remove
10421 if (found_object
&& should_be_inserted (old_loc
))
10423 /* The location is still present in the location list,
10424 and still should be inserted. Don't do anything. */
10425 keep_in_target
= 1;
10429 /* The location is either no longer present, or got
10430 disabled. See if there's another location at the
10431 same address, in which case we don't need to remove
10432 this one from the target. */
10434 /* OLD_LOC comes from existing struct breakpoint. */
10435 if (breakpoint_address_is_meaningful (old_loc
->owner
))
10438 (loc2p
< bp_location
+ bp_location_count
10439 && (*loc2p
)->address
== old_loc
->address
);
10442 struct bp_location
*loc2
= *loc2p
;
10444 if (breakpoint_locations_match (loc2
, old_loc
))
10446 /* Read watchpoint locations are switched to
10447 access watchpoints, if the former are not
10448 supported, but the latter are. */
10449 if (is_hardware_watchpoint (old_loc
->owner
))
10451 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
10452 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
10455 /* loc2 is a duplicated location. We need to check
10456 if it should be inserted in case it will be
10458 if (loc2
!= old_loc
10459 && unduplicated_should_be_inserted (loc2
))
10461 swap_insertion (old_loc
, loc2
);
10462 keep_in_target
= 1;
10470 if (!keep_in_target
)
10472 if (remove_breakpoint (old_loc
, mark_uninserted
))
10474 /* This is just about all we can do. We could keep
10475 this location on the global list, and try to
10476 remove it next time, but there's no particular
10477 reason why we will succeed next time.
10479 Note that at this point, old_loc->owner is still
10480 valid, as delete_breakpoint frees the breakpoint
10481 only after calling us. */
10482 printf_filtered (_("warning: Error removing "
10483 "breakpoint %d\n"),
10484 old_loc
->owner
->number
);
10492 if (removed
&& non_stop
10493 && breakpoint_address_is_meaningful (old_loc
->owner
)
10494 && !is_hardware_watchpoint (old_loc
->owner
))
10496 /* This location was removed from the target. In
10497 non-stop mode, a race condition is possible where
10498 we've removed a breakpoint, but stop events for that
10499 breakpoint are already queued and will arrive later.
10500 We apply an heuristic to be able to distinguish such
10501 SIGTRAPs from other random SIGTRAPs: we keep this
10502 breakpoint location for a bit, and will retire it
10503 after we see some number of events. The theory here
10504 is that reporting of events should, "on the average",
10505 be fair, so after a while we'll see events from all
10506 threads that have anything of interest, and no longer
10507 need to keep this breakpoint location around. We
10508 don't hold locations forever so to reduce chances of
10509 mistaking a non-breakpoint SIGTRAP for a breakpoint
10512 The heuristic failing can be disastrous on
10513 decr_pc_after_break targets.
10515 On decr_pc_after_break targets, like e.g., x86-linux,
10516 if we fail to recognize a late breakpoint SIGTRAP,
10517 because events_till_retirement has reached 0 too
10518 soon, we'll fail to do the PC adjustment, and report
10519 a random SIGTRAP to the user. When the user resumes
10520 the inferior, it will most likely immediately crash
10521 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
10522 corrupted, because of being resumed e.g., in the
10523 middle of a multi-byte instruction, or skipped a
10524 one-byte instruction. This was actually seen happen
10525 on native x86-linux, and should be less rare on
10526 targets that do not support new thread events, like
10527 remote, due to the heuristic depending on
10530 Mistaking a random SIGTRAP for a breakpoint trap
10531 causes similar symptoms (PC adjustment applied when
10532 it shouldn't), but then again, playing with SIGTRAPs
10533 behind the debugger's back is asking for trouble.
10535 Since hardware watchpoint traps are always
10536 distinguishable from other traps, so we don't need to
10537 apply keep hardware watchpoint moribund locations
10538 around. We simply always ignore hardware watchpoint
10539 traps we can no longer explain. */
10541 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
10542 old_loc
->owner
= NULL
;
10544 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
10548 old_loc
->owner
= NULL
;
10549 decref_bp_location (&old_loc
);
10554 /* Rescan breakpoints at the same address and section, marking the
10555 first one as "first" and any others as "duplicates". This is so
10556 that the bpt instruction is only inserted once. If we have a
10557 permanent breakpoint at the same place as BPT, make that one the
10558 official one, and the rest as duplicates. Permanent breakpoints
10559 are sorted first for the same address.
10561 Do the same for hardware watchpoints, but also considering the
10562 watchpoint's type (regular/access/read) and length. */
10564 bp_loc_first
= NULL
;
10565 wp_loc_first
= NULL
;
10566 awp_loc_first
= NULL
;
10567 rwp_loc_first
= NULL
;
10568 ALL_BP_LOCATIONS (loc
, locp
)
10570 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
10572 struct breakpoint
*b
= loc
->owner
;
10573 struct bp_location
**loc_first_p
;
10575 if (b
->enable_state
== bp_disabled
10576 || b
->enable_state
== bp_call_disabled
10577 || b
->enable_state
== bp_startup_disabled
10579 || loc
->shlib_disabled
10580 || !breakpoint_address_is_meaningful (b
)
10581 || is_tracepoint (b
))
10584 /* Permanent breakpoint should always be inserted. */
10585 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
10586 internal_error (__FILE__
, __LINE__
,
10587 _("allegedly permanent breakpoint is not "
10588 "actually inserted"));
10590 if (b
->type
== bp_hardware_watchpoint
)
10591 loc_first_p
= &wp_loc_first
;
10592 else if (b
->type
== bp_read_watchpoint
)
10593 loc_first_p
= &rwp_loc_first
;
10594 else if (b
->type
== bp_access_watchpoint
)
10595 loc_first_p
= &awp_loc_first
;
10597 loc_first_p
= &bp_loc_first
;
10599 if (*loc_first_p
== NULL
10600 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
10601 || !breakpoint_locations_match (loc
, *loc_first_p
))
10603 *loc_first_p
= loc
;
10604 loc
->duplicate
= 0;
10609 /* This and the above ensure the invariant that the first location
10610 is not duplicated, and is the inserted one.
10611 All following are marked as duplicated, and are not inserted. */
10613 swap_insertion (loc
, *loc_first_p
);
10614 loc
->duplicate
= 1;
10616 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
10617 && b
->enable_state
!= bp_permanent
)
10618 internal_error (__FILE__
, __LINE__
,
10619 _("another breakpoint was inserted on top of "
10620 "a permanent breakpoint"));
10623 if (breakpoints_always_inserted_mode () && should_insert
10624 && (have_live_inferiors ()
10625 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
10626 insert_breakpoint_locations ();
10628 do_cleanups (cleanups
);
10632 breakpoint_retire_moribund (void)
10634 struct bp_location
*loc
;
10637 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
10638 if (--(loc
->events_till_retirement
) == 0)
10640 decref_bp_location (&loc
);
10641 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
10647 update_global_location_list_nothrow (int inserting
)
10649 struct gdb_exception e
;
10651 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10652 update_global_location_list (inserting
);
10655 /* Clear BKP from a BPS. */
10658 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
10662 for (bs
= bps
; bs
; bs
= bs
->next
)
10663 if (bs
->breakpoint_at
== bpt
)
10665 bs
->breakpoint_at
= NULL
;
10666 bs
->old_val
= NULL
;
10667 /* bs->commands will be freed later. */
10671 /* Callback for iterate_over_threads. */
10673 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
10675 struct breakpoint
*bpt
= data
;
10677 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
10681 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
10685 say_where (struct breakpoint
*b
)
10687 struct ui_out
*uiout
= current_uiout
;
10688 struct value_print_options opts
;
10690 get_user_print_options (&opts
);
10692 /* i18n: cagney/2005-02-11: Below needs to be merged into a
10694 if (b
->loc
== NULL
)
10696 printf_filtered (_(" (%s) pending."), b
->addr_string
);
10700 if (opts
.addressprint
|| b
->source_file
== NULL
)
10702 printf_filtered (" at ");
10703 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
10706 if (b
->source_file
)
10707 printf_filtered (": file %s, line %d.",
10708 b
->source_file
, b
->line_number
);
10712 struct bp_location
*loc
= b
->loc
;
10714 for (; loc
; loc
= loc
->next
)
10716 printf_filtered (" (%d locations)", n
);
10721 /* Default bp_location_ops methods. */
10724 bp_location_dtor (struct bp_location
*self
)
10726 xfree (self
->cond
);
10727 xfree (self
->function_name
);
10730 static const struct bp_location_ops bp_location_ops
=
10735 /* Default breakpoint_ops methods all breakpoint_ops ultimately
10739 base_breakpoint_dtor (struct breakpoint
*self
)
10741 decref_counted_command_line (&self
->commands
);
10742 xfree (self
->cond_string
);
10743 xfree (self
->addr_string
);
10744 xfree (self
->addr_string_range_end
);
10745 xfree (self
->source_file
);
10748 static struct bp_location
*
10749 base_breakpoint_allocate_location (struct breakpoint
*self
)
10751 struct bp_location
*loc
;
10753 loc
= XNEW (struct bp_location
);
10754 init_bp_location (loc
, &bp_location_ops
, self
);
10759 base_breakpoint_re_set (struct breakpoint
*b
)
10761 /* Nothing to re-set. */
10764 #define internal_error_pure_virtual_called() \
10765 gdb_assert_not_reached ("pure virtual function called")
10768 base_breakpoint_insert_location (struct bp_location
*bl
)
10770 internal_error_pure_virtual_called ();
10774 base_breakpoint_remove_location (struct bp_location
*bl
)
10776 internal_error_pure_virtual_called ();
10780 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
10781 struct address_space
*aspace
,
10784 internal_error_pure_virtual_called ();
10788 base_breakpoint_check_status (bpstat bs
)
10793 /* A "works_in_software_mode" breakpoint_ops method that just internal
10797 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
10799 internal_error_pure_virtual_called ();
10802 /* A "resources_needed" breakpoint_ops method that just internal
10806 base_breakpoint_resources_needed (const struct bp_location
*bl
)
10808 internal_error_pure_virtual_called ();
10811 static enum print_stop_action
10812 base_breakpoint_print_it (bpstat bs
)
10814 internal_error_pure_virtual_called ();
10818 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
10819 struct ui_out
*uiout
)
10825 base_breakpoint_print_mention (struct breakpoint
*b
)
10827 internal_error_pure_virtual_called ();
10831 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
10833 internal_error_pure_virtual_called ();
10836 static struct breakpoint_ops base_breakpoint_ops
=
10838 base_breakpoint_dtor
,
10839 base_breakpoint_allocate_location
,
10840 base_breakpoint_re_set
,
10841 base_breakpoint_insert_location
,
10842 base_breakpoint_remove_location
,
10843 base_breakpoint_breakpoint_hit
,
10844 base_breakpoint_check_status
,
10845 base_breakpoint_resources_needed
,
10846 base_breakpoint_works_in_software_mode
,
10847 base_breakpoint_print_it
,
10849 base_breakpoint_print_one_detail
,
10850 base_breakpoint_print_mention
,
10851 base_breakpoint_print_recreate
10854 /* Default breakpoint_ops methods. */
10857 bkpt_re_set (struct breakpoint
*b
)
10859 /* Do not attempt to re-set breakpoints disabled during startup. */
10860 if (b
->enable_state
== bp_startup_disabled
)
10863 /* FIXME: is this still reachable? */
10864 if (b
->addr_string
== NULL
)
10866 /* Anything without a string can't be re-set. */
10867 delete_breakpoint (b
);
10871 breakpoint_re_set_default (b
);
10875 bkpt_insert_location (struct bp_location
*bl
)
10877 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
10878 return target_insert_hw_breakpoint (bl
->gdbarch
,
10881 return target_insert_breakpoint (bl
->gdbarch
,
10886 bkpt_remove_location (struct bp_location
*bl
)
10888 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
10889 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
10891 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
);
10895 bkpt_breakpoint_hit (const struct bp_location
*bl
,
10896 struct address_space
*aspace
, CORE_ADDR bp_addr
)
10898 struct breakpoint
*b
= bl
->owner
;
10900 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
10904 if (overlay_debugging
/* unmapped overlay section */
10905 && section_is_overlay (bl
->section
)
10906 && !section_is_mapped (bl
->section
))
10913 bkpt_resources_needed (const struct bp_location
*bl
)
10915 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
10920 static enum print_stop_action
10921 bkpt_print_it (bpstat bs
)
10923 struct breakpoint
*b
;
10924 const struct bp_location
*bl
;
10926 struct ui_out
*uiout
= current_uiout
;
10928 gdb_assert (bs
->bp_location_at
!= NULL
);
10930 bl
= bs
->bp_location_at
;
10931 b
= bs
->breakpoint_at
;
10933 bp_temp
= b
->disposition
== disp_del
;
10934 if (bl
->address
!= bl
->requested_address
)
10935 breakpoint_adjustment_warning (bl
->requested_address
,
10938 annotate_breakpoint (b
->number
);
10940 ui_out_text (uiout
, "\nTemporary breakpoint ");
10942 ui_out_text (uiout
, "\nBreakpoint ");
10943 if (ui_out_is_mi_like_p (uiout
))
10945 ui_out_field_string (uiout
, "reason",
10946 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
10947 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
10949 ui_out_field_int (uiout
, "bkptno", b
->number
);
10950 ui_out_text (uiout
, ", ");
10952 return PRINT_SRC_AND_LOC
;
10956 bkpt_print_mention (struct breakpoint
*b
)
10958 if (ui_out_is_mi_like_p (current_uiout
))
10963 case bp_breakpoint
:
10964 case bp_gnu_ifunc_resolver
:
10965 if (b
->disposition
== disp_del
)
10966 printf_filtered (_("Temporary breakpoint"));
10968 printf_filtered (_("Breakpoint"));
10969 printf_filtered (_(" %d"), b
->number
);
10970 if (b
->type
== bp_gnu_ifunc_resolver
)
10971 printf_filtered (_(" at gnu-indirect-function resolver"));
10973 case bp_hardware_breakpoint
:
10974 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
10982 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
10984 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
10985 fprintf_unfiltered (fp
, "tbreak");
10986 else if (tp
->type
== bp_breakpoint
)
10987 fprintf_unfiltered (fp
, "break");
10988 else if (tp
->type
== bp_hardware_breakpoint
10989 && tp
->disposition
== disp_del
)
10990 fprintf_unfiltered (fp
, "thbreak");
10991 else if (tp
->type
== bp_hardware_breakpoint
)
10992 fprintf_unfiltered (fp
, "hbreak");
10994 internal_error (__FILE__
, __LINE__
,
10995 _("unhandled breakpoint type %d"), (int) tp
->type
);
10997 fprintf_unfiltered (fp
, " %s", tp
->addr_string
);
11000 /* Virtual table for internal breakpoints. */
11003 internal_bkpt_re_set (struct breakpoint
*b
)
11007 /* Delete overlay event and longjmp master breakpoints; they
11008 will be reset later by breakpoint_re_set. */
11009 case bp_overlay_event
:
11010 case bp_longjmp_master
:
11011 case bp_std_terminate_master
:
11012 case bp_exception_master
:
11013 delete_breakpoint (b
);
11016 /* This breakpoint is special, it's set up when the inferior
11017 starts and we really don't want to touch it. */
11018 case bp_shlib_event
:
11020 /* Like bp_shlib_event, this breakpoint type is special. Once
11021 it is set up, we do not want to touch it. */
11022 case bp_thread_event
:
11028 internal_bkpt_check_status (bpstat bs
)
11030 /* We do not stop for these. */
11034 static enum print_stop_action
11035 internal_bkpt_print_it (bpstat bs
)
11037 struct breakpoint
*b
;
11039 b
= bs
->breakpoint_at
;
11043 case bp_shlib_event
:
11044 /* Did we stop because the user set the stop_on_solib_events
11045 variable? (If so, we report this as a generic, "Stopped due
11046 to shlib event" message.) */
11047 printf_filtered (_("Stopped due to shared library event\n"));
11050 case bp_thread_event
:
11051 /* Not sure how we will get here.
11052 GDB should not stop for these breakpoints. */
11053 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
11056 case bp_overlay_event
:
11057 /* By analogy with the thread event, GDB should not stop for these. */
11058 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
11061 case bp_longjmp_master
:
11062 /* These should never be enabled. */
11063 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
11066 case bp_std_terminate_master
:
11067 /* These should never be enabled. */
11068 printf_filtered (_("std::terminate Master Breakpoint: "
11069 "gdb should not stop!\n"));
11072 case bp_exception_master
:
11073 /* These should never be enabled. */
11074 printf_filtered (_("Exception Master Breakpoint: "
11075 "gdb should not stop!\n"));
11079 return PRINT_NOTHING
;
11083 internal_bkpt_print_mention (struct breakpoint
*b
)
11085 /* Nothing to mention. These breakpoints are internal. */
11088 /* Virtual table for momentary breakpoints */
11091 momentary_bkpt_re_set (struct breakpoint
*b
)
11093 /* Keep temporary breakpoints, which can be encountered when we step
11094 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
11095 Otherwise these should have been blown away via the cleanup chain
11096 or by breakpoint_init_inferior when we rerun the executable. */
11100 momentary_bkpt_check_status (bpstat bs
)
11102 /* Nothing. The point of these breakpoints is causing a stop. */
11105 static enum print_stop_action
11106 momentary_bkpt_print_it (bpstat bs
)
11108 struct ui_out
*uiout
= current_uiout
;
11110 if (ui_out_is_mi_like_p (uiout
))
11112 struct breakpoint
*b
= bs
->breakpoint_at
;
11117 ui_out_field_string
11119 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
11123 ui_out_field_string
11125 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
11130 return PRINT_UNKNOWN
;
11134 momentary_bkpt_print_mention (struct breakpoint
*b
)
11136 /* Nothing to mention. These breakpoints are internal. */
11139 /* The breakpoint_ops structure to be used in tracepoints. */
11142 tracepoint_re_set (struct breakpoint
*b
)
11144 breakpoint_re_set_default (b
);
11148 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
11149 struct address_space
*aspace
, CORE_ADDR bp_addr
)
11151 /* By definition, the inferior does not report stops at
11157 tracepoint_print_one_detail (const struct breakpoint
*self
,
11158 struct ui_out
*uiout
)
11160 struct tracepoint
*tp
= (struct tracepoint
*) self
;
11161 if (tp
->static_trace_marker_id
)
11163 gdb_assert (self
->type
== bp_static_tracepoint
);
11165 ui_out_text (uiout
, "\tmarker id is ");
11166 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
11167 tp
->static_trace_marker_id
);
11168 ui_out_text (uiout
, "\n");
11173 tracepoint_print_mention (struct breakpoint
*b
)
11175 if (ui_out_is_mi_like_p (current_uiout
))
11180 case bp_tracepoint
:
11181 printf_filtered (_("Tracepoint"));
11182 printf_filtered (_(" %d"), b
->number
);
11184 case bp_fast_tracepoint
:
11185 printf_filtered (_("Fast tracepoint"));
11186 printf_filtered (_(" %d"), b
->number
);
11188 case bp_static_tracepoint
:
11189 printf_filtered (_("Static tracepoint"));
11190 printf_filtered (_(" %d"), b
->number
);
11193 internal_error (__FILE__
, __LINE__
,
11194 _("unhandled tracepoint type %d"), (int) b
->type
);
11201 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
11203 struct tracepoint
*tp
= (struct tracepoint
*) self
;
11205 if (self
->type
== bp_fast_tracepoint
)
11206 fprintf_unfiltered (fp
, "ftrace");
11207 if (self
->type
== bp_static_tracepoint
)
11208 fprintf_unfiltered (fp
, "strace");
11209 else if (self
->type
== bp_tracepoint
)
11210 fprintf_unfiltered (fp
, "trace");
11212 internal_error (__FILE__
, __LINE__
,
11213 _("unhandled tracepoint type %d"), (int) self
->type
);
11215 fprintf_unfiltered (fp
, " %s", self
->addr_string
);
11216 print_recreate_thread (self
, fp
);
11218 if (tp
->pass_count
)
11219 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
11222 struct breakpoint_ops tracepoint_breakpoint_ops
;
11224 /* Delete a breakpoint and clean up all traces of it in the data
11228 delete_breakpoint (struct breakpoint
*bpt
)
11230 struct breakpoint
*b
;
11232 gdb_assert (bpt
!= NULL
);
11234 /* Has this bp already been deleted? This can happen because
11235 multiple lists can hold pointers to bp's. bpstat lists are
11238 One example of this happening is a watchpoint's scope bp. When
11239 the scope bp triggers, we notice that the watchpoint is out of
11240 scope, and delete it. We also delete its scope bp. But the
11241 scope bp is marked "auto-deleting", and is already on a bpstat.
11242 That bpstat is then checked for auto-deleting bp's, which are
11245 A real solution to this problem might involve reference counts in
11246 bp's, and/or giving them pointers back to their referencing
11247 bpstat's, and teaching delete_breakpoint to only free a bp's
11248 storage when no more references were extent. A cheaper bandaid
11250 if (bpt
->type
== bp_none
)
11253 /* At least avoid this stale reference until the reference counting
11254 of breakpoints gets resolved. */
11255 if (bpt
->related_breakpoint
!= bpt
)
11257 struct breakpoint
*related
;
11258 struct watchpoint
*w
;
11260 if (bpt
->type
== bp_watchpoint_scope
)
11261 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
11262 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
11263 w
= (struct watchpoint
*) bpt
;
11267 watchpoint_del_at_next_stop (w
);
11269 /* Unlink bpt from the bpt->related_breakpoint ring. */
11270 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
11271 related
= related
->related_breakpoint
);
11272 related
->related_breakpoint
= bpt
->related_breakpoint
;
11273 bpt
->related_breakpoint
= bpt
;
11276 /* watch_command_1 creates a watchpoint but only sets its number if
11277 update_watchpoint succeeds in creating its bp_locations. If there's
11278 a problem in that process, we'll be asked to delete the half-created
11279 watchpoint. In that case, don't announce the deletion. */
11281 observer_notify_breakpoint_deleted (bpt
);
11283 if (breakpoint_chain
== bpt
)
11284 breakpoint_chain
= bpt
->next
;
11286 ALL_BREAKPOINTS (b
)
11287 if (b
->next
== bpt
)
11289 b
->next
= bpt
->next
;
11293 /* Be sure no bpstat's are pointing at the breakpoint after it's
11295 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
11296 in all threads for now. Note that we cannot just remove bpstats
11297 pointing at bpt from the stop_bpstat list entirely, as breakpoint
11298 commands are associated with the bpstat; if we remove it here,
11299 then the later call to bpstat_do_actions (&stop_bpstat); in
11300 event-top.c won't do anything, and temporary breakpoints with
11301 commands won't work. */
11303 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
11305 /* Now that breakpoint is removed from breakpoint list, update the
11306 global location list. This will remove locations that used to
11307 belong to this breakpoint. Do this before freeing the breakpoint
11308 itself, since remove_breakpoint looks at location's owner. It
11309 might be better design to have location completely
11310 self-contained, but it's not the case now. */
11311 update_global_location_list (0);
11313 bpt
->ops
->dtor (bpt
);
11314 /* On the chance that someone will soon try again to delete this
11315 same bp, we mark it as deleted before freeing its storage. */
11316 bpt
->type
= bp_none
;
11321 do_delete_breakpoint_cleanup (void *b
)
11323 delete_breakpoint (b
);
11327 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
11329 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
11332 /* Iterator function to call a user-provided callback function once
11333 for each of B and its related breakpoints. */
11336 iterate_over_related_breakpoints (struct breakpoint
*b
,
11337 void (*function
) (struct breakpoint
*,
11341 struct breakpoint
*related
;
11346 struct breakpoint
*next
;
11348 /* FUNCTION may delete RELATED. */
11349 next
= related
->related_breakpoint
;
11351 if (next
== related
)
11353 /* RELATED is the last ring entry. */
11354 function (related
, data
);
11356 /* FUNCTION may have deleted it, so we'd never reach back to
11357 B. There's nothing left to do anyway, so just break
11362 function (related
, data
);
11366 while (related
!= b
);
11370 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
11372 delete_breakpoint (b
);
11375 /* A callback for map_breakpoint_numbers that calls
11376 delete_breakpoint. */
11379 do_map_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
11381 iterate_over_related_breakpoints (b
, do_delete_breakpoint
, NULL
);
11385 delete_command (char *arg
, int from_tty
)
11387 struct breakpoint
*b
, *b_tmp
;
11393 int breaks_to_delete
= 0;
11395 /* Delete all breakpoints if no argument. Do not delete
11396 internal breakpoints, these have to be deleted with an
11397 explicit breakpoint number argument. */
11398 ALL_BREAKPOINTS (b
)
11399 if (user_breakpoint_p (b
))
11401 breaks_to_delete
= 1;
11405 /* Ask user only if there are some breakpoints to delete. */
11407 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
11409 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11410 if (user_breakpoint_p (b
))
11411 delete_breakpoint (b
);
11415 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
11419 all_locations_are_pending (struct bp_location
*loc
)
11421 for (; loc
; loc
= loc
->next
)
11422 if (!loc
->shlib_disabled
)
11427 /* Subroutine of update_breakpoint_locations to simplify it.
11428 Return non-zero if multiple fns in list LOC have the same name.
11429 Null names are ignored. */
11432 ambiguous_names_p (struct bp_location
*loc
)
11434 struct bp_location
*l
;
11435 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
11436 (int (*) (const void *,
11437 const void *)) streq
,
11438 NULL
, xcalloc
, xfree
);
11440 for (l
= loc
; l
!= NULL
; l
= l
->next
)
11443 const char *name
= l
->function_name
;
11445 /* Allow for some names to be NULL, ignore them. */
11449 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
11451 /* NOTE: We can assume slot != NULL here because xcalloc never
11455 htab_delete (htab
);
11461 htab_delete (htab
);
11465 /* When symbols change, it probably means the sources changed as well,
11466 and it might mean the static tracepoint markers are no longer at
11467 the same address or line numbers they used to be at last we
11468 checked. Losing your static tracepoints whenever you rebuild is
11469 undesirable. This function tries to resync/rematch gdb static
11470 tracepoints with the markers on the target, for static tracepoints
11471 that have not been set by marker id. Static tracepoint that have
11472 been set by marker id are reset by marker id in breakpoint_re_set.
11475 1) For a tracepoint set at a specific address, look for a marker at
11476 the old PC. If one is found there, assume to be the same marker.
11477 If the name / string id of the marker found is different from the
11478 previous known name, assume that means the user renamed the marker
11479 in the sources, and output a warning.
11481 2) For a tracepoint set at a given line number, look for a marker
11482 at the new address of the old line number. If one is found there,
11483 assume to be the same marker. If the name / string id of the
11484 marker found is different from the previous known name, assume that
11485 means the user renamed the marker in the sources, and output a
11488 3) If a marker is no longer found at the same address or line, it
11489 may mean the marker no longer exists. But it may also just mean
11490 the code changed a bit. Maybe the user added a few lines of code
11491 that made the marker move up or down (in line number terms). Ask
11492 the target for info about the marker with the string id as we knew
11493 it. If found, update line number and address in the matching
11494 static tracepoint. This will get confused if there's more than one
11495 marker with the same ID (possible in UST, although unadvised
11496 precisely because it confuses tools). */
11498 static struct symtab_and_line
11499 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
11501 struct tracepoint
*tp
= (struct tracepoint
*) b
;
11502 struct static_tracepoint_marker marker
;
11508 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
11510 if (target_static_tracepoint_marker_at (pc
, &marker
))
11512 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
11513 warning (_("static tracepoint %d changed probed marker from %s to %s"),
11515 tp
->static_trace_marker_id
, marker
.str_id
);
11517 xfree (tp
->static_trace_marker_id
);
11518 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
11519 release_static_tracepoint_marker (&marker
);
11524 /* Old marker wasn't found on target at lineno. Try looking it up
11526 if (!sal
.explicit_pc
11528 && sal
.symtab
!= NULL
11529 && tp
->static_trace_marker_id
!= NULL
)
11531 VEC(static_tracepoint_marker_p
) *markers
;
11534 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
11536 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
11538 struct symtab_and_line sal
;
11539 struct symbol
*sym
;
11540 struct static_tracepoint_marker
*marker
;
11541 struct ui_out
*uiout
= current_uiout
;
11543 marker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
11545 xfree (tp
->static_trace_marker_id
);
11546 tp
->static_trace_marker_id
= xstrdup (marker
->str_id
);
11548 warning (_("marker for static tracepoint %d (%s) not "
11549 "found at previous line number"),
11550 b
->number
, tp
->static_trace_marker_id
);
11554 sal
.pc
= marker
->address
;
11556 sal
= find_pc_line (marker
->address
, 0);
11557 sym
= find_pc_sect_function (marker
->address
, NULL
);
11558 ui_out_text (uiout
, "Now in ");
11561 ui_out_field_string (uiout
, "func",
11562 SYMBOL_PRINT_NAME (sym
));
11563 ui_out_text (uiout
, " at ");
11565 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
11566 ui_out_text (uiout
, ":");
11568 if (ui_out_is_mi_like_p (uiout
))
11570 char *fullname
= symtab_to_fullname (sal
.symtab
);
11573 ui_out_field_string (uiout
, "fullname", fullname
);
11576 ui_out_field_int (uiout
, "line", sal
.line
);
11577 ui_out_text (uiout
, "\n");
11579 b
->line_number
= sal
.line
;
11581 xfree (b
->source_file
);
11583 b
->source_file
= xstrdup (sal
.symtab
->filename
);
11585 b
->source_file
= NULL
;
11587 xfree (b
->addr_string
);
11588 b
->addr_string
= xstrprintf ("%s:%d",
11589 sal
.symtab
->filename
, b
->line_number
);
11591 /* Might be nice to check if function changed, and warn if
11594 release_static_tracepoint_marker (marker
);
11600 /* Returns 1 iff locations A and B are sufficiently same that
11601 we don't need to report breakpoint as changed. */
11604 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
11608 if (a
->address
!= b
->address
)
11611 if (a
->shlib_disabled
!= b
->shlib_disabled
)
11614 if (a
->enabled
!= b
->enabled
)
11621 if ((a
== NULL
) != (b
== NULL
))
11627 /* Create new breakpoint locations for B (a hardware or software breakpoint)
11628 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
11629 a ranged breakpoint. */
11632 update_breakpoint_locations (struct breakpoint
*b
,
11633 struct symtabs_and_lines sals
,
11634 struct symtabs_and_lines sals_end
)
11637 struct bp_location
*existing_locations
= b
->loc
;
11639 /* Ranged breakpoints have only one start location and one end location. */
11640 gdb_assert (sals_end
.nelts
== 0 || (sals
.nelts
== 1 && sals_end
.nelts
== 1));
11642 /* If there's no new locations, and all existing locations are
11643 pending, don't do anything. This optimizes the common case where
11644 all locations are in the same shared library, that was unloaded.
11645 We'd like to retain the location, so that when the library is
11646 loaded again, we don't loose the enabled/disabled status of the
11647 individual locations. */
11648 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
11653 for (i
= 0; i
< sals
.nelts
; ++i
)
11655 struct bp_location
*new_loc
=
11656 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
11658 /* Reparse conditions, they might contain references to the
11660 if (b
->cond_string
!= NULL
)
11663 struct gdb_exception e
;
11665 s
= b
->cond_string
;
11666 TRY_CATCH (e
, RETURN_MASK_ERROR
)
11668 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
11673 warning (_("failed to reevaluate condition "
11674 "for breakpoint %d: %s"),
11675 b
->number
, e
.message
);
11676 new_loc
->enabled
= 0;
11680 if (b
->source_file
!= NULL
)
11681 xfree (b
->source_file
);
11682 if (sals
.sals
[i
].symtab
== NULL
)
11683 b
->source_file
= NULL
;
11685 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
11687 if (b
->line_number
== 0)
11688 b
->line_number
= sals
.sals
[i
].line
;
11690 if (sals_end
.nelts
)
11692 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
11694 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
11698 /* Update locations of permanent breakpoints. */
11699 if (b
->enable_state
== bp_permanent
)
11700 make_breakpoint_permanent (b
);
11702 /* If possible, carry over 'disable' status from existing
11705 struct bp_location
*e
= existing_locations
;
11706 /* If there are multiple breakpoints with the same function name,
11707 e.g. for inline functions, comparing function names won't work.
11708 Instead compare pc addresses; this is just a heuristic as things
11709 may have moved, but in practice it gives the correct answer
11710 often enough until a better solution is found. */
11711 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
11713 for (; e
; e
= e
->next
)
11715 if (!e
->enabled
&& e
->function_name
)
11717 struct bp_location
*l
= b
->loc
;
11718 if (have_ambiguous_names
)
11720 for (; l
; l
= l
->next
)
11721 if (breakpoint_locations_match (e
, l
))
11729 for (; l
; l
= l
->next
)
11730 if (l
->function_name
11731 && strcmp (e
->function_name
, l
->function_name
) == 0)
11741 if (!locations_are_equal (existing_locations
, b
->loc
))
11742 observer_notify_breakpoint_modified (b
);
11744 update_global_location_list (1);
11747 /* Find the SaL locations corresponding to the given ADDR_STRING.
11748 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
11750 static struct symtabs_and_lines
11751 addr_string_to_sals (struct breakpoint
*b
, char *addr_string
, int *found
)
11755 struct symtabs_and_lines sals
= {0};
11756 struct gdb_exception e
;
11759 marker_spec
= b
->type
== bp_static_tracepoint
&& is_marker_spec (s
);
11761 TRY_CATCH (e
, RETURN_MASK_ERROR
)
11765 struct tracepoint
*tp
= (struct tracepoint
*) b
;
11767 sals
= decode_static_tracepoint_spec (&s
);
11768 if (sals
.nelts
> tp
->static_trace_marker_id_idx
)
11770 sals
.sals
[0] = sals
.sals
[tp
->static_trace_marker_id_idx
];
11774 error (_("marker %s not found"), tp
->static_trace_marker_id
);
11777 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, NULL
);
11781 int not_found_and_ok
= 0;
11782 /* For pending breakpoints, it's expected that parsing will
11783 fail until the right shared library is loaded. User has
11784 already told to create pending breakpoints and don't need
11785 extra messages. If breakpoint is in bp_shlib_disabled
11786 state, then user already saw the message about that
11787 breakpoint being disabled, and don't want to see more
11789 if (e
.error
== NOT_FOUND_ERROR
11790 && (b
->condition_not_parsed
11791 || (b
->loc
&& b
->loc
->shlib_disabled
)
11792 || b
->enable_state
== bp_disabled
))
11793 not_found_and_ok
= 1;
11795 if (!not_found_and_ok
)
11797 /* We surely don't want to warn about the same breakpoint
11798 10 times. One solution, implemented here, is disable
11799 the breakpoint on error. Another solution would be to
11800 have separate 'warning emitted' flag. Since this
11801 happens only when a binary has changed, I don't know
11802 which approach is better. */
11803 b
->enable_state
= bp_disabled
;
11804 throw_exception (e
);
11808 if (e
.reason
== 0 || e
.error
!= NOT_FOUND_ERROR
)
11810 gdb_assert (sals
.nelts
== 1);
11812 resolve_sal_pc (&sals
.sals
[0]);
11813 if (b
->condition_not_parsed
&& s
&& s
[0])
11815 char *cond_string
= 0;
11819 find_condition_and_thread (s
, sals
.sals
[0].pc
,
11820 &cond_string
, &thread
, &task
);
11822 b
->cond_string
= cond_string
;
11823 b
->thread
= thread
;
11825 b
->condition_not_parsed
= 0;
11828 if (b
->type
== bp_static_tracepoint
&& !marker_spec
)
11829 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
11839 /* The default re_set method, for typical hardware or software
11840 breakpoints. Reevaluate the breakpoint and recreate its
11844 breakpoint_re_set_default (struct breakpoint
*b
)
11847 struct symtabs_and_lines sals
, sals_end
;
11848 struct symtabs_and_lines expanded
= {0};
11849 struct symtabs_and_lines expanded_end
= {0};
11851 sals
= addr_string_to_sals (b
, b
->addr_string
, &found
);
11854 make_cleanup (xfree
, sals
.sals
);
11855 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
11858 if (b
->addr_string_range_end
)
11860 sals_end
= addr_string_to_sals (b
, b
->addr_string_range_end
, &found
);
11863 make_cleanup (xfree
, sals_end
.sals
);
11864 expanded_end
= expand_line_sal_maybe (sals_end
.sals
[0]);
11868 update_breakpoint_locations (b
, expanded
, expanded_end
);
11871 /* Prepare the global context for a re-set of breakpoint B. */
11873 static struct cleanup
*
11874 prepare_re_set_context (struct breakpoint
*b
)
11876 struct cleanup
*cleanups
;
11878 input_radix
= b
->input_radix
;
11879 cleanups
= save_current_space_and_thread ();
11880 switch_to_program_space_and_thread (b
->pspace
);
11881 set_language (b
->language
);
11886 /* Reset a breakpoint given it's struct breakpoint * BINT.
11887 The value we return ends up being the return value from catch_errors.
11888 Unused in this case. */
11891 breakpoint_re_set_one (void *bint
)
11893 /* Get past catch_errs. */
11894 struct breakpoint
*b
= (struct breakpoint
*) bint
;
11895 struct cleanup
*cleanups
;
11897 cleanups
= prepare_re_set_context (b
);
11898 b
->ops
->re_set (b
);
11899 do_cleanups (cleanups
);
11903 /* Re-set all breakpoints after symbols have been re-loaded. */
11905 breakpoint_re_set (void)
11907 struct breakpoint
*b
, *b_tmp
;
11908 enum language save_language
;
11909 int save_input_radix
;
11910 struct cleanup
*old_chain
;
11912 save_language
= current_language
->la_language
;
11913 save_input_radix
= input_radix
;
11914 old_chain
= save_current_program_space ();
11916 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11918 /* Format possible error msg. */
11919 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
11921 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
11922 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
11923 do_cleanups (cleanups
);
11925 set_language (save_language
);
11926 input_radix
= save_input_radix
;
11928 jit_breakpoint_re_set ();
11930 do_cleanups (old_chain
);
11932 create_overlay_event_breakpoint ();
11933 create_longjmp_master_breakpoint ();
11934 create_std_terminate_master_breakpoint ();
11935 create_exception_master_breakpoint ();
11938 /* Reset the thread number of this breakpoint:
11940 - If the breakpoint is for all threads, leave it as-is.
11941 - Else, reset it to the current thread for inferior_ptid. */
11943 breakpoint_re_set_thread (struct breakpoint
*b
)
11945 if (b
->thread
!= -1)
11947 if (in_thread_list (inferior_ptid
))
11948 b
->thread
= pid_to_thread_id (inferior_ptid
);
11950 /* We're being called after following a fork. The new fork is
11951 selected as current, and unless this was a vfork will have a
11952 different program space from the original thread. Reset that
11954 b
->loc
->pspace
= current_program_space
;
11958 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11959 If from_tty is nonzero, it prints a message to that effect,
11960 which ends with a period (no newline). */
11963 set_ignore_count (int bptnum
, int count
, int from_tty
)
11965 struct breakpoint
*b
;
11970 ALL_BREAKPOINTS (b
)
11971 if (b
->number
== bptnum
)
11973 if (is_tracepoint (b
))
11975 if (from_tty
&& count
!= 0)
11976 printf_filtered (_("Ignore count ignored for tracepoint %d."),
11981 b
->ignore_count
= count
;
11985 printf_filtered (_("Will stop next time "
11986 "breakpoint %d is reached."),
11988 else if (count
== 1)
11989 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
11992 printf_filtered (_("Will ignore next %d "
11993 "crossings of breakpoint %d."),
11996 breakpoints_changed ();
11997 observer_notify_breakpoint_modified (b
);
12001 error (_("No breakpoint number %d."), bptnum
);
12004 /* Command to set ignore-count of breakpoint N to COUNT. */
12007 ignore_command (char *args
, int from_tty
)
12013 error_no_arg (_("a breakpoint number"));
12015 num
= get_number (&p
);
12017 error (_("bad breakpoint number: '%s'"), args
);
12019 error (_("Second argument (specified ignore-count) is missing."));
12021 set_ignore_count (num
,
12022 longest_to_int (value_as_long (parse_and_eval (p
))),
12025 printf_filtered ("\n");
12028 /* Call FUNCTION on each of the breakpoints
12029 whose numbers are given in ARGS. */
12032 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
12037 struct breakpoint
*b
, *tmp
;
12039 struct get_number_or_range_state state
;
12042 error_no_arg (_("one or more breakpoint numbers"));
12044 init_number_or_range (&state
, args
);
12046 while (!state
.finished
)
12048 char *p
= state
.string
;
12052 num
= get_number_or_range (&state
);
12055 warning (_("bad breakpoint number at or near '%s'"), p
);
12059 ALL_BREAKPOINTS_SAFE (b
, tmp
)
12060 if (b
->number
== num
)
12063 function (b
, data
);
12067 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
12072 static struct bp_location
*
12073 find_location_by_number (char *number
)
12075 char *dot
= strchr (number
, '.');
12079 struct breakpoint
*b
;
12080 struct bp_location
*loc
;
12085 bp_num
= get_number (&p1
);
12087 error (_("Bad breakpoint number '%s'"), number
);
12089 ALL_BREAKPOINTS (b
)
12090 if (b
->number
== bp_num
)
12095 if (!b
|| b
->number
!= bp_num
)
12096 error (_("Bad breakpoint number '%s'"), number
);
12099 loc_num
= get_number (&p1
);
12101 error (_("Bad breakpoint location number '%s'"), number
);
12105 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
12108 error (_("Bad breakpoint location number '%s'"), dot
+1);
12114 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
12115 If from_tty is nonzero, it prints a message to that effect,
12116 which ends with a period (no newline). */
12119 disable_breakpoint (struct breakpoint
*bpt
)
12121 /* Never disable a watchpoint scope breakpoint; we want to
12122 hit them when we leave scope so we can delete both the
12123 watchpoint and its scope breakpoint at that time. */
12124 if (bpt
->type
== bp_watchpoint_scope
)
12127 /* You can't disable permanent breakpoints. */
12128 if (bpt
->enable_state
== bp_permanent
)
12131 bpt
->enable_state
= bp_disabled
;
12133 if (target_supports_enable_disable_tracepoint ()
12134 && current_trace_status ()->running
&& is_tracepoint (bpt
))
12136 struct bp_location
*location
;
12138 for (location
= bpt
->loc
; location
; location
= location
->next
)
12139 target_disable_tracepoint (location
);
12142 update_global_location_list (0);
12144 observer_notify_breakpoint_modified (bpt
);
12147 /* A callback for iterate_over_related_breakpoints. */
12150 do_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
12152 disable_breakpoint (b
);
12155 /* A callback for map_breakpoint_numbers that calls
12156 disable_breakpoint. */
12159 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
12161 iterate_over_related_breakpoints (b
, do_disable_breakpoint
, NULL
);
12165 disable_command (char *args
, int from_tty
)
12169 struct breakpoint
*bpt
;
12171 ALL_BREAKPOINTS (bpt
)
12172 if (user_breakpoint_p (bpt
))
12173 disable_breakpoint (bpt
);
12175 else if (strchr (args
, '.'))
12177 struct bp_location
*loc
= find_location_by_number (args
);
12181 if (target_supports_enable_disable_tracepoint ()
12182 && current_trace_status ()->running
&& loc
->owner
12183 && is_tracepoint (loc
->owner
))
12184 target_disable_tracepoint (loc
);
12186 update_global_location_list (0);
12189 map_breakpoint_numbers (args
, do_map_disable_breakpoint
, NULL
);
12193 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
)
12195 int target_resources_ok
;
12197 if (bpt
->type
== bp_hardware_breakpoint
)
12200 i
= hw_breakpoint_used_count ();
12201 target_resources_ok
=
12202 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
12204 if (target_resources_ok
== 0)
12205 error (_("No hardware breakpoint support in the target."));
12206 else if (target_resources_ok
< 0)
12207 error (_("Hardware breakpoints used exceeds limit."));
12210 if (is_watchpoint (bpt
))
12212 /* Initialize it just to avoid a GCC false warning. */
12213 enum enable_state orig_enable_state
= 0;
12214 struct gdb_exception e
;
12216 TRY_CATCH (e
, RETURN_MASK_ALL
)
12218 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
12220 orig_enable_state
= bpt
->enable_state
;
12221 bpt
->enable_state
= bp_enabled
;
12222 update_watchpoint (w
, 1 /* reparse */);
12226 bpt
->enable_state
= orig_enable_state
;
12227 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
12233 if (bpt
->enable_state
!= bp_permanent
)
12234 bpt
->enable_state
= bp_enabled
;
12236 if (target_supports_enable_disable_tracepoint ()
12237 && current_trace_status ()->running
&& is_tracepoint (bpt
))
12239 struct bp_location
*location
;
12241 for (location
= bpt
->loc
; location
; location
= location
->next
)
12242 target_enable_tracepoint (location
);
12245 bpt
->disposition
= disposition
;
12246 update_global_location_list (1);
12247 breakpoints_changed ();
12249 observer_notify_breakpoint_modified (bpt
);
12254 enable_breakpoint (struct breakpoint
*bpt
)
12256 enable_breakpoint_disp (bpt
, bpt
->disposition
);
12260 do_enable_breakpoint (struct breakpoint
*bpt
, void *arg
)
12262 enable_breakpoint (bpt
);
12265 /* A callback for map_breakpoint_numbers that calls
12266 enable_breakpoint. */
12269 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
12271 iterate_over_related_breakpoints (b
, do_enable_breakpoint
, NULL
);
12274 /* The enable command enables the specified breakpoints (or all defined
12275 breakpoints) so they once again become (or continue to be) effective
12276 in stopping the inferior. */
12279 enable_command (char *args
, int from_tty
)
12283 struct breakpoint
*bpt
;
12285 ALL_BREAKPOINTS (bpt
)
12286 if (user_breakpoint_p (bpt
))
12287 enable_breakpoint (bpt
);
12289 else if (strchr (args
, '.'))
12291 struct bp_location
*loc
= find_location_by_number (args
);
12295 if (target_supports_enable_disable_tracepoint ()
12296 && current_trace_status ()->running
&& loc
->owner
12297 && is_tracepoint (loc
->owner
))
12298 target_enable_tracepoint (loc
);
12300 update_global_location_list (1);
12303 map_breakpoint_numbers (args
, do_map_enable_breakpoint
, NULL
);
12307 do_enable_breakpoint_disp (struct breakpoint
*bpt
, void *arg
)
12309 enum bpdisp disp
= *(enum bpdisp
*) arg
;
12311 enable_breakpoint_disp (bpt
, disp
);
12315 do_map_enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
12317 enum bpdisp disp
= disp_disable
;
12319 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
12323 enable_once_command (char *args
, int from_tty
)
12325 map_breakpoint_numbers (args
, do_map_enable_once_breakpoint
, NULL
);
12329 do_map_enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
12331 enum bpdisp disp
= disp_del
;
12333 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
12337 enable_delete_command (char *args
, int from_tty
)
12339 map_breakpoint_numbers (args
, do_map_enable_delete_breakpoint
, NULL
);
12343 set_breakpoint_cmd (char *args
, int from_tty
)
12348 show_breakpoint_cmd (char *args
, int from_tty
)
12352 /* Invalidate last known value of any hardware watchpoint if
12353 the memory which that value represents has been written to by
12357 invalidate_bp_value_on_memory_change (CORE_ADDR addr
, int len
,
12358 const bfd_byte
*data
)
12360 struct breakpoint
*bp
;
12362 ALL_BREAKPOINTS (bp
)
12363 if (bp
->enable_state
== bp_enabled
12364 && bp
->type
== bp_hardware_watchpoint
)
12366 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
12368 if (wp
->val_valid
&& wp
->val
)
12370 struct bp_location
*loc
;
12372 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
12373 if (loc
->loc_type
== bp_loc_hardware_watchpoint
12374 && loc
->address
+ loc
->length
> addr
12375 && addr
+ len
> loc
->address
)
12377 value_free (wp
->val
);
12385 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
12387 struct symtabs_and_lines
12388 decode_line_spec_1 (char *string
, int funfirstline
)
12390 struct symtabs_and_lines sals
;
12393 error (_("Empty line specification."));
12394 if (default_breakpoint_valid
)
12395 sals
= decode_line_1 (&string
, funfirstline
,
12396 default_breakpoint_symtab
,
12397 default_breakpoint_line
,
12400 sals
= decode_line_1 (&string
, funfirstline
,
12401 (struct symtab
*) NULL
, 0, NULL
);
12403 error (_("Junk at end of line specification: %s"), string
);
12407 /* Create and insert a raw software breakpoint at PC. Return an
12408 identifier, which should be used to remove the breakpoint later.
12409 In general, places which call this should be using something on the
12410 breakpoint chain instead; this function should be eliminated
12414 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
12415 struct address_space
*aspace
, CORE_ADDR pc
)
12417 struct bp_target_info
*bp_tgt
;
12419 bp_tgt
= XZALLOC (struct bp_target_info
);
12421 bp_tgt
->placed_address_space
= aspace
;
12422 bp_tgt
->placed_address
= pc
;
12424 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
12426 /* Could not insert the breakpoint. */
12434 /* Remove a breakpoint BP inserted by
12435 deprecated_insert_raw_breakpoint. */
12438 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
12440 struct bp_target_info
*bp_tgt
= bp
;
12443 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
12449 /* One (or perhaps two) breakpoints used for software single
12452 static void *single_step_breakpoints
[2];
12453 static struct gdbarch
*single_step_gdbarch
[2];
12455 /* Create and insert a breakpoint for software single step. */
12458 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
12459 struct address_space
*aspace
,
12464 if (single_step_breakpoints
[0] == NULL
)
12466 bpt_p
= &single_step_breakpoints
[0];
12467 single_step_gdbarch
[0] = gdbarch
;
12471 gdb_assert (single_step_breakpoints
[1] == NULL
);
12472 bpt_p
= &single_step_breakpoints
[1];
12473 single_step_gdbarch
[1] = gdbarch
;
12476 /* NOTE drow/2006-04-11: A future improvement to this function would
12477 be to only create the breakpoints once, and actually put them on
12478 the breakpoint chain. That would let us use set_raw_breakpoint.
12479 We could adjust the addresses each time they were needed. Doing
12480 this requires corresponding changes elsewhere where single step
12481 breakpoints are handled, however. So, for now, we use this. */
12483 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
12484 if (*bpt_p
== NULL
)
12485 error (_("Could not insert single-step breakpoint at %s"),
12486 paddress (gdbarch
, next_pc
));
12489 /* Check if the breakpoints used for software single stepping
12490 were inserted or not. */
12493 single_step_breakpoints_inserted (void)
12495 return (single_step_breakpoints
[0] != NULL
12496 || single_step_breakpoints
[1] != NULL
);
12499 /* Remove and delete any breakpoints used for software single step. */
12502 remove_single_step_breakpoints (void)
12504 gdb_assert (single_step_breakpoints
[0] != NULL
);
12506 /* See insert_single_step_breakpoint for more about this deprecated
12508 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
12509 single_step_breakpoints
[0]);
12510 single_step_gdbarch
[0] = NULL
;
12511 single_step_breakpoints
[0] = NULL
;
12513 if (single_step_breakpoints
[1] != NULL
)
12515 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
12516 single_step_breakpoints
[1]);
12517 single_step_gdbarch
[1] = NULL
;
12518 single_step_breakpoints
[1] = NULL
;
12522 /* Delete software single step breakpoints without removing them from
12523 the inferior. This is intended to be used if the inferior's address
12524 space where they were inserted is already gone, e.g. after exit or
12528 cancel_single_step_breakpoints (void)
12532 for (i
= 0; i
< 2; i
++)
12533 if (single_step_breakpoints
[i
])
12535 xfree (single_step_breakpoints
[i
]);
12536 single_step_breakpoints
[i
] = NULL
;
12537 single_step_gdbarch
[i
] = NULL
;
12541 /* Detach software single-step breakpoints from INFERIOR_PTID without
12545 detach_single_step_breakpoints (void)
12549 for (i
= 0; i
< 2; i
++)
12550 if (single_step_breakpoints
[i
])
12551 target_remove_breakpoint (single_step_gdbarch
[i
],
12552 single_step_breakpoints
[i
]);
12555 /* Check whether a software single-step breakpoint is inserted at
12559 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
12564 for (i
= 0; i
< 2; i
++)
12566 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
12568 && breakpoint_address_match (bp_tgt
->placed_address_space
,
12569 bp_tgt
->placed_address
,
12577 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
12578 non-zero otherwise. */
12580 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
12582 if (syscall_catchpoint_p (bp
)
12583 && bp
->enable_state
!= bp_disabled
12584 && bp
->enable_state
!= bp_call_disabled
)
12591 catch_syscall_enabled (void)
12593 struct inferior
*inf
= current_inferior ();
12595 return inf
->total_syscalls_count
!= 0;
12599 catching_syscall_number (int syscall_number
)
12601 struct breakpoint
*bp
;
12603 ALL_BREAKPOINTS (bp
)
12604 if (is_syscall_catchpoint_enabled (bp
))
12606 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bp
;
12608 if (c
->syscalls_to_be_caught
)
12612 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
12614 if (syscall_number
== iter
)
12624 /* Complete syscall names. Used by "catch syscall". */
12626 catch_syscall_completer (struct cmd_list_element
*cmd
,
12627 char *text
, char *word
)
12629 const char **list
= get_syscall_names ();
12631 = (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
12637 /* Tracepoint-specific operations. */
12639 /* Set tracepoint count to NUM. */
12641 set_tracepoint_count (int num
)
12643 tracepoint_count
= num
;
12644 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
12648 trace_command (char *arg
, int from_tty
)
12650 if (create_breakpoint (get_current_arch (),
12652 NULL
, 0, 1 /* parse arg */,
12654 bp_tracepoint
/* type_wanted */,
12655 0 /* Ignore count */,
12656 pending_break_support
,
12657 &tracepoint_breakpoint_ops
,
12661 set_tracepoint_count (breakpoint_count
);
12665 ftrace_command (char *arg
, int from_tty
)
12667 if (create_breakpoint (get_current_arch (),
12669 NULL
, 0, 1 /* parse arg */,
12671 bp_fast_tracepoint
/* type_wanted */,
12672 0 /* Ignore count */,
12673 pending_break_support
,
12674 &tracepoint_breakpoint_ops
,
12678 set_tracepoint_count (breakpoint_count
);
12681 /* strace command implementation. Creates a static tracepoint. */
12684 strace_command (char *arg
, int from_tty
)
12686 if (create_breakpoint (get_current_arch (),
12688 NULL
, 0, 1 /* parse arg */,
12690 bp_static_tracepoint
/* type_wanted */,
12691 0 /* Ignore count */,
12692 pending_break_support
,
12693 &tracepoint_breakpoint_ops
,
12697 set_tracepoint_count (breakpoint_count
);
12700 /* Set up a fake reader function that gets command lines from a linked
12701 list that was acquired during tracepoint uploading. */
12703 static struct uploaded_tp
*this_utp
;
12704 static int next_cmd
;
12707 read_uploaded_action (void)
12711 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
12718 /* Given information about a tracepoint as recorded on a target (which
12719 can be either a live system or a trace file), attempt to create an
12720 equivalent GDB tracepoint. This is not a reliable process, since
12721 the target does not necessarily have all the information used when
12722 the tracepoint was originally defined. */
12724 struct tracepoint
*
12725 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
12727 char *addr_str
, small_buf
[100];
12728 struct tracepoint
*tp
;
12730 if (utp
->at_string
)
12731 addr_str
= utp
->at_string
;
12734 /* In the absence of a source location, fall back to raw
12735 address. Since there is no way to confirm that the address
12736 means the same thing as when the trace was started, warn the
12738 warning (_("Uploaded tracepoint %d has no "
12739 "source location, using raw address"),
12741 sprintf (small_buf
, "*%s", hex_string (utp
->addr
));
12742 addr_str
= small_buf
;
12745 /* There's not much we can do with a sequence of bytecodes. */
12746 if (utp
->cond
&& !utp
->cond_string
)
12747 warning (_("Uploaded tracepoint %d condition "
12748 "has no source form, ignoring it"),
12751 if (!create_breakpoint (get_current_arch (),
12753 utp
->cond_string
, -1, 0 /* parse cond/thread */,
12755 utp
->type
/* type_wanted */,
12756 0 /* Ignore count */,
12757 pending_break_support
,
12758 &tracepoint_breakpoint_ops
,
12760 utp
->enabled
/* enabled */,
12764 set_tracepoint_count (breakpoint_count
);
12766 /* Get the tracepoint we just created. */
12767 tp
= get_tracepoint (tracepoint_count
);
12768 gdb_assert (tp
!= NULL
);
12772 sprintf (small_buf
, "%d %d", utp
->pass
, tp
->base
.number
);
12774 trace_pass_command (small_buf
, 0);
12777 /* If we have uploaded versions of the original commands, set up a
12778 special-purpose "reader" function and call the usual command line
12779 reader, then pass the result to the breakpoint command-setting
12781 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
12783 struct command_line
*cmd_list
;
12788 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
12790 breakpoint_set_commands (&tp
->base
, cmd_list
);
12792 else if (!VEC_empty (char_ptr
, utp
->actions
)
12793 || !VEC_empty (char_ptr
, utp
->step_actions
))
12794 warning (_("Uploaded tracepoint %d actions "
12795 "have no source form, ignoring them"),
12801 /* Print information on tracepoint number TPNUM_EXP, or all if
12805 tracepoints_info (char *args
, int from_tty
)
12807 struct ui_out
*uiout
= current_uiout
;
12810 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
12812 if (num_printed
== 0)
12814 if (args
== NULL
|| *args
== '\0')
12815 ui_out_message (uiout
, 0, "No tracepoints.\n");
12817 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
12820 default_collect_info ();
12823 /* The 'enable trace' command enables tracepoints.
12824 Not supported by all targets. */
12826 enable_trace_command (char *args
, int from_tty
)
12828 enable_command (args
, from_tty
);
12831 /* The 'disable trace' command disables tracepoints.
12832 Not supported by all targets. */
12834 disable_trace_command (char *args
, int from_tty
)
12836 disable_command (args
, from_tty
);
12839 /* Remove a tracepoint (or all if no argument). */
12841 delete_trace_command (char *arg
, int from_tty
)
12843 struct breakpoint
*b
, *b_tmp
;
12849 int breaks_to_delete
= 0;
12851 /* Delete all breakpoints if no argument.
12852 Do not delete internal or call-dummy breakpoints, these
12853 have to be deleted with an explicit breakpoint number
12855 ALL_TRACEPOINTS (b
)
12856 if (is_tracepoint (b
) && user_breakpoint_p (b
))
12858 breaks_to_delete
= 1;
12862 /* Ask user only if there are some breakpoints to delete. */
12864 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
12866 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12867 if (is_tracepoint (b
) && user_breakpoint_p (b
))
12868 delete_breakpoint (b
);
12872 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
12875 /* Helper function for trace_pass_command. */
12878 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
12880 tp
->pass_count
= count
;
12881 observer_notify_tracepoint_modified (tp
->base
.number
);
12883 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
12884 tp
->base
.number
, count
);
12887 /* Set passcount for tracepoint.
12889 First command argument is passcount, second is tracepoint number.
12890 If tracepoint number omitted, apply to most recently defined.
12891 Also accepts special argument "all". */
12894 trace_pass_command (char *args
, int from_tty
)
12896 struct tracepoint
*t1
;
12897 unsigned int count
;
12899 if (args
== 0 || *args
== 0)
12900 error (_("passcount command requires an "
12901 "argument (count + optional TP num)"));
12903 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
12905 while (*args
&& isspace ((int) *args
))
12908 if (*args
&& strncasecmp (args
, "all", 3) == 0)
12910 struct breakpoint
*b
;
12912 args
+= 3; /* Skip special argument "all". */
12914 error (_("Junk at end of arguments."));
12916 ALL_TRACEPOINTS (b
)
12918 t1
= (struct tracepoint
*) b
;
12919 trace_pass_set_count (t1
, count
, from_tty
);
12922 else if (*args
== '\0')
12924 t1
= get_tracepoint_by_number (&args
, NULL
, 1);
12926 trace_pass_set_count (t1
, count
, from_tty
);
12930 struct get_number_or_range_state state
;
12932 init_number_or_range (&state
, args
);
12933 while (!state
.finished
)
12935 t1
= get_tracepoint_by_number (&args
, &state
, 1);
12937 trace_pass_set_count (t1
, count
, from_tty
);
12942 struct tracepoint
*
12943 get_tracepoint (int num
)
12945 struct breakpoint
*t
;
12947 ALL_TRACEPOINTS (t
)
12948 if (t
->number
== num
)
12949 return (struct tracepoint
*) t
;
12954 /* Find the tracepoint with the given target-side number (which may be
12955 different from the tracepoint number after disconnecting and
12958 struct tracepoint
*
12959 get_tracepoint_by_number_on_target (int num
)
12961 struct breakpoint
*b
;
12963 ALL_TRACEPOINTS (b
)
12965 struct tracepoint
*t
= (struct tracepoint
*) b
;
12967 if (t
->number_on_target
== num
)
12974 /* Utility: parse a tracepoint number and look it up in the list.
12975 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
12976 If OPTIONAL_P is true, then if the argument is missing, the most
12977 recent tracepoint (tracepoint_count) is returned. */
12978 struct tracepoint
*
12979 get_tracepoint_by_number (char **arg
,
12980 struct get_number_or_range_state
*state
,
12983 extern int tracepoint_count
;
12984 struct breakpoint
*t
;
12986 char *instring
= arg
== NULL
? NULL
: *arg
;
12990 gdb_assert (!state
->finished
);
12991 tpnum
= get_number_or_range (state
);
12993 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
12996 tpnum
= tracepoint_count
;
12998 error_no_arg (_("tracepoint number"));
13001 tpnum
= get_number (arg
);
13005 if (instring
&& *instring
)
13006 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
13009 printf_filtered (_("Tracepoint argument missing "
13010 "and no previous tracepoint\n"));
13014 ALL_TRACEPOINTS (t
)
13015 if (t
->number
== tpnum
)
13017 return (struct tracepoint
*) t
;
13020 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
13025 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
13027 if (b
->thread
!= -1)
13028 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
13031 fprintf_unfiltered (fp
, " task %d", b
->task
);
13033 fprintf_unfiltered (fp
, "\n");
13036 /* Save information on user settable breakpoints (watchpoints, etc) to
13037 a new script file named FILENAME. If FILTER is non-NULL, call it
13038 on each breakpoint and only include the ones for which it returns
13042 save_breakpoints (char *filename
, int from_tty
,
13043 int (*filter
) (const struct breakpoint
*))
13045 struct breakpoint
*tp
;
13048 struct cleanup
*cleanup
;
13049 struct ui_file
*fp
;
13050 int extra_trace_bits
= 0;
13052 if (filename
== 0 || *filename
== 0)
13053 error (_("Argument required (file name in which to save)"));
13055 /* See if we have anything to save. */
13056 ALL_BREAKPOINTS (tp
)
13058 /* Skip internal and momentary breakpoints. */
13059 if (!user_breakpoint_p (tp
))
13062 /* If we have a filter, only save the breakpoints it accepts. */
13063 if (filter
&& !filter (tp
))
13068 if (is_tracepoint (tp
))
13070 extra_trace_bits
= 1;
13072 /* We can stop searching. */
13079 warning (_("Nothing to save."));
13083 pathname
= tilde_expand (filename
);
13084 cleanup
= make_cleanup (xfree
, pathname
);
13085 fp
= gdb_fopen (pathname
, "w");
13087 error (_("Unable to open file '%s' for saving (%s)"),
13088 filename
, safe_strerror (errno
));
13089 make_cleanup_ui_file_delete (fp
);
13091 if (extra_trace_bits
)
13092 save_trace_state_variables (fp
);
13094 ALL_BREAKPOINTS (tp
)
13096 /* Skip internal and momentary breakpoints. */
13097 if (!user_breakpoint_p (tp
))
13100 /* If we have a filter, only save the breakpoints it accepts. */
13101 if (filter
&& !filter (tp
))
13104 tp
->ops
->print_recreate (tp
, fp
);
13106 /* Note, we can't rely on tp->number for anything, as we can't
13107 assume the recreated breakpoint numbers will match. Use $bpnum
13110 if (tp
->cond_string
)
13111 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
13113 if (tp
->ignore_count
)
13114 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
13118 volatile struct gdb_exception ex
;
13120 fprintf_unfiltered (fp
, " commands\n");
13122 ui_out_redirect (current_uiout
, fp
);
13123 TRY_CATCH (ex
, RETURN_MASK_ALL
)
13125 print_command_lines (current_uiout
, tp
->commands
->commands
, 2);
13127 ui_out_redirect (current_uiout
, NULL
);
13130 throw_exception (ex
);
13132 fprintf_unfiltered (fp
, " end\n");
13135 if (tp
->enable_state
== bp_disabled
)
13136 fprintf_unfiltered (fp
, "disable\n");
13138 /* If this is a multi-location breakpoint, check if the locations
13139 should be individually disabled. Watchpoint locations are
13140 special, and not user visible. */
13141 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
13143 struct bp_location
*loc
;
13146 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
13148 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
13152 if (extra_trace_bits
&& *default_collect
)
13153 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
13155 do_cleanups (cleanup
);
13157 printf_filtered (_("Saved to file '%s'.\n"), filename
);
13160 /* The `save breakpoints' command. */
13163 save_breakpoints_command (char *args
, int from_tty
)
13165 save_breakpoints (args
, from_tty
, NULL
);
13168 /* The `save tracepoints' command. */
13171 save_tracepoints_command (char *args
, int from_tty
)
13173 save_breakpoints (args
, from_tty
, is_tracepoint
);
13176 /* Create a vector of all tracepoints. */
13178 VEC(breakpoint_p
) *
13179 all_tracepoints (void)
13181 VEC(breakpoint_p
) *tp_vec
= 0;
13182 struct breakpoint
*tp
;
13184 ALL_TRACEPOINTS (tp
)
13186 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
13193 /* This help string is used for the break, hbreak, tbreak and thbreak
13194 commands. It is defined as a macro to prevent duplication.
13195 COMMAND should be a string constant containing the name of the
13197 #define BREAK_ARGS_HELP(command) \
13198 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
13199 LOCATION may be a line number, function name, or \"*\" and an address.\n\
13200 If a line number is specified, break at start of code for that line.\n\
13201 If a function is specified, break at start of code for that function.\n\
13202 If an address is specified, break at that exact address.\n\
13203 With no LOCATION, uses current execution address of the selected\n\
13204 stack frame. This is useful for breaking on return to a stack frame.\n\
13206 THREADNUM is the number from \"info threads\".\n\
13207 CONDITION is a boolean expression.\n\
13209 Multiple breakpoints at one place are permitted, and useful if their\n\
13210 conditions are different.\n\
13212 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
13214 /* List of subcommands for "catch". */
13215 static struct cmd_list_element
*catch_cmdlist
;
13217 /* List of subcommands for "tcatch". */
13218 static struct cmd_list_element
*tcatch_cmdlist
;
13221 add_catch_command (char *name
, char *docstring
,
13222 void (*sfunc
) (char *args
, int from_tty
,
13223 struct cmd_list_element
*command
),
13224 char **(*completer
) (struct cmd_list_element
*cmd
,
13225 char *text
, char *word
),
13226 void *user_data_catch
,
13227 void *user_data_tcatch
)
13229 struct cmd_list_element
*command
;
13231 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
13233 set_cmd_sfunc (command
, sfunc
);
13234 set_cmd_context (command
, user_data_catch
);
13235 set_cmd_completer (command
, completer
);
13237 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
13239 set_cmd_sfunc (command
, sfunc
);
13240 set_cmd_context (command
, user_data_tcatch
);
13241 set_cmd_completer (command
, completer
);
13245 clear_syscall_counts (struct inferior
*inf
)
13247 inf
->total_syscalls_count
= 0;
13248 inf
->any_syscall_count
= 0;
13249 VEC_free (int, inf
->syscalls_counts
);
13253 save_command (char *arg
, int from_tty
)
13255 printf_unfiltered (_("\"save\" must be followed by "
13256 "the name of a save subcommand.\n"));
13257 help_list (save_cmdlist
, "save ", -1, gdb_stdout
);
13260 struct breakpoint
*
13261 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
13264 struct breakpoint
*b
, *b_tmp
;
13266 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13268 if ((*callback
) (b
, data
))
13276 initialize_breakpoint_ops (void)
13278 static int initialized
= 0;
13280 struct breakpoint_ops
*ops
;
13286 /* The breakpoint_ops structure to be inherit by all kinds of
13287 breakpoints (real breakpoints, i.e., user "break" breakpoints,
13288 internal and momentary breakpoints, etc.). */
13289 ops
= &bkpt_base_breakpoint_ops
;
13290 *ops
= base_breakpoint_ops
;
13291 ops
->re_set
= bkpt_re_set
;
13292 ops
->insert_location
= bkpt_insert_location
;
13293 ops
->remove_location
= bkpt_remove_location
;
13294 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
13296 /* The breakpoint_ops structure to be used in regular breakpoints. */
13297 ops
= &bkpt_breakpoint_ops
;
13298 *ops
= bkpt_base_breakpoint_ops
;
13299 ops
->re_set
= bkpt_re_set
;
13300 ops
->resources_needed
= bkpt_resources_needed
;
13301 ops
->print_it
= bkpt_print_it
;
13302 ops
->print_mention
= bkpt_print_mention
;
13303 ops
->print_recreate
= bkpt_print_recreate
;
13305 /* Ranged breakpoints. */
13306 ops
= &ranged_breakpoint_ops
;
13307 *ops
= bkpt_breakpoint_ops
;
13308 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
13309 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
13310 ops
->print_it
= print_it_ranged_breakpoint
;
13311 ops
->print_one
= print_one_ranged_breakpoint
;
13312 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
13313 ops
->print_mention
= print_mention_ranged_breakpoint
;
13314 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
13316 /* Internal breakpoints. */
13317 ops
= &internal_breakpoint_ops
;
13318 *ops
= bkpt_base_breakpoint_ops
;
13319 ops
->re_set
= internal_bkpt_re_set
;
13320 ops
->check_status
= internal_bkpt_check_status
;
13321 ops
->print_it
= internal_bkpt_print_it
;
13322 ops
->print_mention
= internal_bkpt_print_mention
;
13324 /* Momentary breakpoints. */
13325 ops
= &momentary_breakpoint_ops
;
13326 *ops
= bkpt_base_breakpoint_ops
;
13327 ops
->re_set
= momentary_bkpt_re_set
;
13328 ops
->check_status
= momentary_bkpt_check_status
;
13329 ops
->print_it
= momentary_bkpt_print_it
;
13330 ops
->print_mention
= momentary_bkpt_print_mention
;
13332 /* GNU v3 exception catchpoints. */
13333 ops
= &gnu_v3_exception_catchpoint_ops
;
13334 *ops
= bkpt_breakpoint_ops
;
13335 ops
->print_it
= print_it_exception_catchpoint
;
13336 ops
->print_one
= print_one_exception_catchpoint
;
13337 ops
->print_mention
= print_mention_exception_catchpoint
;
13338 ops
->print_recreate
= print_recreate_exception_catchpoint
;
13341 ops
= &watchpoint_breakpoint_ops
;
13342 *ops
= base_breakpoint_ops
;
13343 ops
->dtor
= dtor_watchpoint
;
13344 ops
->re_set
= re_set_watchpoint
;
13345 ops
->insert_location
= insert_watchpoint
;
13346 ops
->remove_location
= remove_watchpoint
;
13347 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
13348 ops
->check_status
= check_status_watchpoint
;
13349 ops
->resources_needed
= resources_needed_watchpoint
;
13350 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
13351 ops
->print_it
= print_it_watchpoint
;
13352 ops
->print_mention
= print_mention_watchpoint
;
13353 ops
->print_recreate
= print_recreate_watchpoint
;
13355 /* Masked watchpoints. */
13356 ops
= &masked_watchpoint_breakpoint_ops
;
13357 *ops
= watchpoint_breakpoint_ops
;
13358 ops
->insert_location
= insert_masked_watchpoint
;
13359 ops
->remove_location
= remove_masked_watchpoint
;
13360 ops
->resources_needed
= resources_needed_masked_watchpoint
;
13361 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
13362 ops
->print_it
= print_it_masked_watchpoint
;
13363 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
13364 ops
->print_mention
= print_mention_masked_watchpoint
;
13365 ops
->print_recreate
= print_recreate_masked_watchpoint
;
13368 ops
= &tracepoint_breakpoint_ops
;
13369 *ops
= base_breakpoint_ops
;
13370 ops
->re_set
= tracepoint_re_set
;
13371 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
13372 ops
->print_one_detail
= tracepoint_print_one_detail
;
13373 ops
->print_mention
= tracepoint_print_mention
;
13374 ops
->print_recreate
= tracepoint_print_recreate
;
13376 /* Fork catchpoints. */
13377 ops
= &catch_fork_breakpoint_ops
;
13378 *ops
= base_breakpoint_ops
;
13379 ops
->insert_location
= insert_catch_fork
;
13380 ops
->remove_location
= remove_catch_fork
;
13381 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
13382 ops
->print_it
= print_it_catch_fork
;
13383 ops
->print_one
= print_one_catch_fork
;
13384 ops
->print_mention
= print_mention_catch_fork
;
13385 ops
->print_recreate
= print_recreate_catch_fork
;
13387 /* Vfork catchpoints. */
13388 ops
= &catch_vfork_breakpoint_ops
;
13389 *ops
= base_breakpoint_ops
;
13390 ops
->insert_location
= insert_catch_vfork
;
13391 ops
->remove_location
= remove_catch_vfork
;
13392 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
13393 ops
->print_it
= print_it_catch_vfork
;
13394 ops
->print_one
= print_one_catch_vfork
;
13395 ops
->print_mention
= print_mention_catch_vfork
;
13396 ops
->print_recreate
= print_recreate_catch_vfork
;
13398 /* Exec catchpoints. */
13399 ops
= &catch_exec_breakpoint_ops
;
13400 *ops
= base_breakpoint_ops
;
13401 ops
->dtor
= dtor_catch_exec
;
13402 ops
->insert_location
= insert_catch_exec
;
13403 ops
->remove_location
= remove_catch_exec
;
13404 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
13405 ops
->print_it
= print_it_catch_exec
;
13406 ops
->print_one
= print_one_catch_exec
;
13407 ops
->print_mention
= print_mention_catch_exec
;
13408 ops
->print_recreate
= print_recreate_catch_exec
;
13410 /* Syscall catchpoints. */
13411 ops
= &catch_syscall_breakpoint_ops
;
13412 *ops
= base_breakpoint_ops
;
13413 ops
->dtor
= dtor_catch_syscall
;
13414 ops
->insert_location
= insert_catch_syscall
;
13415 ops
->remove_location
= remove_catch_syscall
;
13416 ops
->breakpoint_hit
= breakpoint_hit_catch_syscall
;
13417 ops
->print_it
= print_it_catch_syscall
;
13418 ops
->print_one
= print_one_catch_syscall
;
13419 ops
->print_mention
= print_mention_catch_syscall
;
13420 ops
->print_recreate
= print_recreate_catch_syscall
;
13424 _initialize_breakpoint (void)
13426 struct cmd_list_element
*c
;
13428 initialize_breakpoint_ops ();
13430 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
13431 observer_attach_inferior_exit (clear_syscall_counts
);
13432 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
13434 breakpoint_objfile_key
= register_objfile_data ();
13436 breakpoint_chain
= 0;
13437 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
13438 before a breakpoint is set. */
13439 breakpoint_count
= 0;
13441 tracepoint_count
= 0;
13443 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
13444 Set ignore-count of breakpoint number N to COUNT.\n\
13445 Usage is `ignore N COUNT'."));
13447 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
13449 add_com ("commands", class_breakpoint
, commands_command
, _("\
13450 Set commands to be executed when a breakpoint is hit.\n\
13451 Give breakpoint number as argument after \"commands\".\n\
13452 With no argument, the targeted breakpoint is the last one set.\n\
13453 The commands themselves follow starting on the next line.\n\
13454 Type a line containing \"end\" to indicate the end of them.\n\
13455 Give \"silent\" as the first line to make the breakpoint silent;\n\
13456 then no output is printed when it is hit, except what the commands print."));
13458 add_com ("condition", class_breakpoint
, condition_command
, _("\
13459 Specify breakpoint number N to break only if COND is true.\n\
13460 Usage is `condition N COND', where N is an integer and COND is an\n\
13461 expression to be evaluated whenever breakpoint N is reached."));
13463 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
13464 Set a temporary breakpoint.\n\
13465 Like \"break\" except the breakpoint is only temporary,\n\
13466 so it will be deleted when hit. Equivalent to \"break\" followed\n\
13467 by using \"enable delete\" on the breakpoint number.\n\
13469 BREAK_ARGS_HELP ("tbreak")));
13470 set_cmd_completer (c
, location_completer
);
13472 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
13473 Set a hardware assisted breakpoint.\n\
13474 Like \"break\" except the breakpoint requires hardware support,\n\
13475 some target hardware may not have this support.\n\
13477 BREAK_ARGS_HELP ("hbreak")));
13478 set_cmd_completer (c
, location_completer
);
13480 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
13481 Set a temporary hardware assisted breakpoint.\n\
13482 Like \"hbreak\" except the breakpoint is only temporary,\n\
13483 so it will be deleted when hit.\n\
13485 BREAK_ARGS_HELP ("thbreak")));
13486 set_cmd_completer (c
, location_completer
);
13488 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
13489 Enable some breakpoints.\n\
13490 Give breakpoint numbers (separated by spaces) as arguments.\n\
13491 With no subcommand, breakpoints are enabled until you command otherwise.\n\
13492 This is used to cancel the effect of the \"disable\" command.\n\
13493 With a subcommand you can enable temporarily."),
13494 &enablelist
, "enable ", 1, &cmdlist
);
13496 add_com ("ab", class_breakpoint
, enable_command
, _("\
13497 Enable some breakpoints.\n\
13498 Give breakpoint numbers (separated by spaces) as arguments.\n\
13499 With no subcommand, breakpoints are enabled until you command otherwise.\n\
13500 This is used to cancel the effect of the \"disable\" command.\n\
13501 With a subcommand you can enable temporarily."));
13503 add_com_alias ("en", "enable", class_breakpoint
, 1);
13505 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
13506 Enable some breakpoints.\n\
13507 Give breakpoint numbers (separated by spaces) as arguments.\n\
13508 This is used to cancel the effect of the \"disable\" command.\n\
13509 May be abbreviated to simply \"enable\".\n"),
13510 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
13512 add_cmd ("once", no_class
, enable_once_command
, _("\
13513 Enable breakpoints for one hit. Give breakpoint numbers.\n\
13514 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
13517 add_cmd ("delete", no_class
, enable_delete_command
, _("\
13518 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
13519 If a breakpoint is hit while enabled in this fashion, it is deleted."),
13522 add_cmd ("delete", no_class
, enable_delete_command
, _("\
13523 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
13524 If a breakpoint is hit while enabled in this fashion, it is deleted."),
13527 add_cmd ("once", no_class
, enable_once_command
, _("\
13528 Enable breakpoints for one hit. Give breakpoint numbers.\n\
13529 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
13532 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
13533 Disable some breakpoints.\n\
13534 Arguments are breakpoint numbers with spaces in between.\n\
13535 To disable all breakpoints, give no argument.\n\
13536 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
13537 &disablelist
, "disable ", 1, &cmdlist
);
13538 add_com_alias ("dis", "disable", class_breakpoint
, 1);
13539 add_com_alias ("disa", "disable", class_breakpoint
, 1);
13541 add_com ("sb", class_breakpoint
, disable_command
, _("\
13542 Disable some breakpoints.\n\
13543 Arguments are breakpoint numbers with spaces in between.\n\
13544 To disable all breakpoints, give no argument.\n\
13545 A disabled breakpoint is not forgotten, but has no effect until re-enabled."));
13547 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
13548 Disable some breakpoints.\n\
13549 Arguments are breakpoint numbers with spaces in between.\n\
13550 To disable all breakpoints, give no argument.\n\
13551 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
13552 This command may be abbreviated \"disable\"."),
13555 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
13556 Delete some breakpoints or auto-display expressions.\n\
13557 Arguments are breakpoint numbers with spaces in between.\n\
13558 To delete all breakpoints, give no argument.\n\
13560 Also a prefix command for deletion of other GDB objects.\n\
13561 The \"unset\" command is also an alias for \"delete\"."),
13562 &deletelist
, "delete ", 1, &cmdlist
);
13563 add_com_alias ("d", "delete", class_breakpoint
, 1);
13564 add_com_alias ("del", "delete", class_breakpoint
, 1);
13566 add_com ("db", class_breakpoint
, delete_command
, _("\
13567 Delete some breakpoints.\n\
13568 Arguments are breakpoint numbers with spaces in between.\n\
13569 To delete all breakpoints, give no argument.\n"));
13571 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
13572 Delete some breakpoints or auto-display expressions.\n\
13573 Arguments are breakpoint numbers with spaces in between.\n\
13574 To delete all breakpoints, give no argument.\n\
13575 This command may be abbreviated \"delete\"."),
13578 add_com ("clear", class_breakpoint
, clear_command
, _("\
13579 Clear breakpoint at specified line or function.\n\
13580 Argument may be line number, function name, or \"*\" and an address.\n\
13581 If line number is specified, all breakpoints in that line are cleared.\n\
13582 If function is specified, breakpoints at beginning of function are cleared.\n\
13583 If an address is specified, breakpoints at that address are cleared.\n\
13585 With no argument, clears all breakpoints in the line that the selected frame\n\
13586 is executing in.\n\
13588 See also the \"delete\" command which clears breakpoints by number."));
13589 add_com_alias ("cl", "clear", class_breakpoint
, 1);
13591 c
= add_com ("break", class_breakpoint
, break_command
, _("\
13592 Set breakpoint at specified line or function.\n"
13593 BREAK_ARGS_HELP ("break")));
13594 set_cmd_completer (c
, location_completer
);
13596 add_com_alias ("b", "break", class_run
, 1);
13597 add_com_alias ("br", "break", class_run
, 1);
13598 add_com_alias ("bre", "break", class_run
, 1);
13599 add_com_alias ("brea", "break", class_run
, 1);
13602 add_com_alias ("ba", "break", class_breakpoint
, 1);
13606 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
13607 Break in function/address or break at a line in the current file."),
13608 &stoplist
, "stop ", 1, &cmdlist
);
13609 add_cmd ("in", class_breakpoint
, stopin_command
,
13610 _("Break in function or address."), &stoplist
);
13611 add_cmd ("at", class_breakpoint
, stopat_command
,
13612 _("Break at a line in the current file."), &stoplist
);
13613 add_com ("status", class_info
, breakpoints_info
, _("\
13614 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
13615 The \"Type\" column indicates one of:\n\
13616 \tbreakpoint - normal breakpoint\n\
13617 \twatchpoint - watchpoint\n\
13618 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13619 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13620 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13621 address and file/line number respectively.\n\
13623 Convenience variable \"$_\" and default examine address for \"x\"\n\
13624 are set to the address of the last breakpoint listed unless the command\n\
13625 is prefixed with \"server \".\n\n\
13626 Convenience variable \"$bpnum\" contains the number of the last\n\
13627 breakpoint set."));
13630 add_info ("breakpoints", breakpoints_info
, _("\
13631 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
13632 The \"Type\" column indicates one of:\n\
13633 \tbreakpoint - normal breakpoint\n\
13634 \twatchpoint - watchpoint\n\
13635 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13636 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13637 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13638 address and file/line number respectively.\n\
13640 Convenience variable \"$_\" and default examine address for \"x\"\n\
13641 are set to the address of the last breakpoint listed unless the command\n\
13642 is prefixed with \"server \".\n\n\
13643 Convenience variable \"$bpnum\" contains the number of the last\n\
13644 breakpoint set."));
13646 add_info_alias ("b", "breakpoints", 1);
13649 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
13650 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
13651 The \"Type\" column indicates one of:\n\
13652 \tbreakpoint - normal breakpoint\n\
13653 \twatchpoint - watchpoint\n\
13654 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13655 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13656 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13657 address and file/line number respectively.\n\
13659 Convenience variable \"$_\" and default examine address for \"x\"\n\
13660 are set to the address of the last breakpoint listed unless the command\n\
13661 is prefixed with \"server \".\n\n\
13662 Convenience variable \"$bpnum\" contains the number of the last\n\
13663 breakpoint set."));
13665 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
13666 Status of all breakpoints, or breakpoint number NUMBER.\n\
13667 The \"Type\" column indicates one of:\n\
13668 \tbreakpoint - normal breakpoint\n\
13669 \twatchpoint - watchpoint\n\
13670 \tlongjmp - internal breakpoint used to step through longjmp()\n\
13671 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
13672 \tuntil - internal breakpoint used by the \"until\" command\n\
13673 \tfinish - internal breakpoint used by the \"finish\" command\n\
13674 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13675 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13676 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13677 address and file/line number respectively.\n\
13679 Convenience variable \"$_\" and default examine address for \"x\"\n\
13680 are set to the address of the last breakpoint listed unless the command\n\
13681 is prefixed with \"server \".\n\n\
13682 Convenience variable \"$bpnum\" contains the number of the last\n\
13684 &maintenanceinfolist
);
13686 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
13687 Set catchpoints to catch events."),
13688 &catch_cmdlist
, "catch ",
13689 0/*allow-unknown*/, &cmdlist
);
13691 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
13692 Set temporary catchpoints to catch events."),
13693 &tcatch_cmdlist
, "tcatch ",
13694 0/*allow-unknown*/, &cmdlist
);
13696 /* Add catch and tcatch sub-commands. */
13697 add_catch_command ("catch", _("\
13698 Catch an exception, when caught.\n\
13699 With an argument, catch only exceptions with the given name."),
13700 catch_catch_command
,
13704 add_catch_command ("throw", _("\
13705 Catch an exception, when thrown.\n\
13706 With an argument, catch only exceptions with the given name."),
13707 catch_throw_command
,
13711 add_catch_command ("fork", _("Catch calls to fork."),
13712 catch_fork_command_1
,
13714 (void *) (uintptr_t) catch_fork_permanent
,
13715 (void *) (uintptr_t) catch_fork_temporary
);
13716 add_catch_command ("vfork", _("Catch calls to vfork."),
13717 catch_fork_command_1
,
13719 (void *) (uintptr_t) catch_vfork_permanent
,
13720 (void *) (uintptr_t) catch_vfork_temporary
);
13721 add_catch_command ("exec", _("Catch calls to exec."),
13722 catch_exec_command_1
,
13726 add_catch_command ("syscall", _("\
13727 Catch system calls by their names and/or numbers.\n\
13728 Arguments say which system calls to catch. If no arguments\n\
13729 are given, every system call will be caught.\n\
13730 Arguments, if given, should be one or more system call names\n\
13731 (if your system supports that), or system call numbers."),
13732 catch_syscall_command_1
,
13733 catch_syscall_completer
,
13737 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
13738 Set a watchpoint for an expression.\n\
13739 Usage: watch [-l|-location] EXPRESSION\n\
13740 A watchpoint stops execution of your program whenever the value of\n\
13741 an expression changes.\n\
13742 If -l or -location is given, this evaluates EXPRESSION and watches\n\
13743 the memory to which it refers."));
13744 set_cmd_completer (c
, expression_completer
);
13746 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
13747 Set a read watchpoint for an expression.\n\
13748 Usage: rwatch [-l|-location] EXPRESSION\n\
13749 A watchpoint stops execution of your program whenever the value of\n\
13750 an expression is read.\n\
13751 If -l or -location is given, this evaluates EXPRESSION and watches\n\
13752 the memory to which it refers."));
13753 set_cmd_completer (c
, expression_completer
);
13755 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
13756 Set a watchpoint for an expression.\n\
13757 Usage: awatch [-l|-location] EXPRESSION\n\
13758 A watchpoint stops execution of your program whenever the value of\n\
13759 an expression is either read or written.\n\
13760 If -l or -location is given, this evaluates EXPRESSION and watches\n\
13761 the memory to which it refers."));
13762 set_cmd_completer (c
, expression_completer
);
13764 add_info ("watchpoints", watchpoints_info
, _("\
13765 Status of specified watchpoints (all watchpoints if no argument)."));
13767 /* XXX: cagney/2005-02-23: This should be a boolean, and should
13768 respond to changes - contrary to the description. */
13769 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
13770 &can_use_hw_watchpoints
, _("\
13771 Set debugger's willingness to use watchpoint hardware."), _("\
13772 Show debugger's willingness to use watchpoint hardware."), _("\
13773 If zero, gdb will not use hardware for new watchpoints, even if\n\
13774 such is available. (However, any hardware watchpoints that were\n\
13775 created before setting this to nonzero, will continue to use watchpoint\n\
13778 show_can_use_hw_watchpoints
,
13779 &setlist
, &showlist
);
13781 can_use_hw_watchpoints
= 1;
13783 /* Tracepoint manipulation commands. */
13785 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
13786 Set a tracepoint at specified line or function.\n\
13788 BREAK_ARGS_HELP ("trace") "\n\
13789 Do \"help tracepoints\" for info on other tracepoint commands."));
13790 set_cmd_completer (c
, location_completer
);
13792 add_com_alias ("tp", "trace", class_alias
, 0);
13793 add_com_alias ("tr", "trace", class_alias
, 1);
13794 add_com_alias ("tra", "trace", class_alias
, 1);
13795 add_com_alias ("trac", "trace", class_alias
, 1);
13797 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
13798 Set a fast tracepoint at specified line or function.\n\
13800 BREAK_ARGS_HELP ("ftrace") "\n\
13801 Do \"help tracepoints\" for info on other tracepoint commands."));
13802 set_cmd_completer (c
, location_completer
);
13804 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
13805 Set a static tracepoint at specified line, function or marker.\n\
13807 strace [LOCATION] [if CONDITION]\n\
13808 LOCATION may be a line number, function name, \"*\" and an address,\n\
13809 or -m MARKER_ID.\n\
13810 If a line number is specified, probe the marker at start of code\n\
13811 for that line. If a function is specified, probe the marker at start\n\
13812 of code for that function. If an address is specified, probe the marker\n\
13813 at that exact address. If a marker id is specified, probe the marker\n\
13814 with that name. With no LOCATION, uses current execution address of\n\
13815 the selected stack frame.\n\
13816 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
13817 This collects arbitrary user data passed in the probe point call to the\n\
13818 tracing library. You can inspect it when analyzing the trace buffer,\n\
13819 by printing the $_sdata variable like any other convenience variable.\n\
13821 CONDITION is a boolean expression.\n\
13823 Multiple tracepoints at one place are permitted, and useful if their\n\
13824 conditions are different.\n\
13826 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
13827 Do \"help tracepoints\" for info on other tracepoint commands."));
13828 set_cmd_completer (c
, location_completer
);
13830 add_info ("tracepoints", tracepoints_info
, _("\
13831 Status of specified tracepoints (all tracepoints if no argument).\n\
13832 Convenience variable \"$tpnum\" contains the number of the\n\
13833 last tracepoint set."));
13835 add_info_alias ("tp", "tracepoints", 1);
13837 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
13838 Delete specified tracepoints.\n\
13839 Arguments are tracepoint numbers, separated by spaces.\n\
13840 No argument means delete all tracepoints."),
13843 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
13844 Disable specified tracepoints.\n\
13845 Arguments are tracepoint numbers, separated by spaces.\n\
13846 No argument means disable all tracepoints."),
13848 deprecate_cmd (c
, "disable");
13850 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
13851 Enable specified tracepoints.\n\
13852 Arguments are tracepoint numbers, separated by spaces.\n\
13853 No argument means enable all tracepoints."),
13855 deprecate_cmd (c
, "enable");
13857 add_com ("passcount", class_trace
, trace_pass_command
, _("\
13858 Set the passcount for a tracepoint.\n\
13859 The trace will end when the tracepoint has been passed 'count' times.\n\
13860 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
13861 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
13863 add_prefix_cmd ("save", class_breakpoint
, save_command
,
13864 _("Save breakpoint definitions as a script."),
13865 &save_cmdlist
, "save ",
13866 0/*allow-unknown*/, &cmdlist
);
13868 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
13869 Save current breakpoint definitions as a script.\n\
13870 This includes all types of breakpoints (breakpoints, watchpoints,\n\
13871 catchpoints, tracepoints). Use the 'source' command in another debug\n\
13872 session to restore them."),
13874 set_cmd_completer (c
, filename_completer
);
13876 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
13877 Save current tracepoint definitions as a script.\n\
13878 Use the 'source' command in another debug session to restore them."),
13880 set_cmd_completer (c
, filename_completer
);
13882 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
13883 deprecate_cmd (c
, "save tracepoints");
13885 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
13886 Breakpoint specific settings\n\
13887 Configure various breakpoint-specific variables such as\n\
13888 pending breakpoint behavior"),
13889 &breakpoint_set_cmdlist
, "set breakpoint ",
13890 0/*allow-unknown*/, &setlist
);
13891 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
13892 Breakpoint specific settings\n\
13893 Configure various breakpoint-specific variables such as\n\
13894 pending breakpoint behavior"),
13895 &breakpoint_show_cmdlist
, "show breakpoint ",
13896 0/*allow-unknown*/, &showlist
);
13898 add_setshow_auto_boolean_cmd ("pending", no_class
,
13899 &pending_break_support
, _("\
13900 Set debugger's behavior regarding pending breakpoints."), _("\
13901 Show debugger's behavior regarding pending breakpoints."), _("\
13902 If on, an unrecognized breakpoint location will cause gdb to create a\n\
13903 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
13904 an error. If auto, an unrecognized breakpoint location results in a\n\
13905 user-query to see if a pending breakpoint should be created."),
13907 show_pending_break_support
,
13908 &breakpoint_set_cmdlist
,
13909 &breakpoint_show_cmdlist
);
13911 pending_break_support
= AUTO_BOOLEAN_AUTO
;
13913 add_setshow_boolean_cmd ("auto-hw", no_class
,
13914 &automatic_hardware_breakpoints
, _("\
13915 Set automatic usage of hardware breakpoints."), _("\
13916 Show automatic usage of hardware breakpoints."), _("\
13917 If set, the debugger will automatically use hardware breakpoints for\n\
13918 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
13919 a warning will be emitted for such breakpoints."),
13921 show_automatic_hardware_breakpoints
,
13922 &breakpoint_set_cmdlist
,
13923 &breakpoint_show_cmdlist
);
13925 add_setshow_enum_cmd ("always-inserted", class_support
,
13926 always_inserted_enums
, &always_inserted_mode
, _("\
13927 Set mode for inserting breakpoints."), _("\
13928 Show mode for inserting breakpoints."), _("\
13929 When this mode is off, breakpoints are inserted in inferior when it is\n\
13930 resumed, and removed when execution stops. When this mode is on,\n\
13931 breakpoints are inserted immediately and removed only when the user\n\
13932 deletes the breakpoint. When this mode is auto (which is the default),\n\
13933 the behaviour depends on the non-stop setting (see help set non-stop).\n\
13934 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
13935 behaves as if always-inserted mode is on; if gdb is controlling the\n\
13936 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
13938 &show_always_inserted_mode
,
13939 &breakpoint_set_cmdlist
,
13940 &breakpoint_show_cmdlist
);
13942 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
13943 Set a breakpoint for an address range.\n\
13944 break-range START-LOCATION, END-LOCATION\n\
13945 where START-LOCATION and END-LOCATION can be one of the following:\n\
13946 LINENUM, for that line in the current file,\n\
13947 FILE:LINENUM, for that line in that file,\n\
13948 +OFFSET, for that number of lines after the current line\n\
13949 or the start of the range\n\
13950 FUNCTION, for the first line in that function,\n\
13951 FILE:FUNCTION, to distinguish among like-named static functions.\n\
13952 *ADDRESS, for the instruction at that address.\n\
13954 The breakpoint will stop execution of the inferior whenever it executes\n\
13955 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
13956 range (including START-LOCATION and END-LOCATION)."));
13958 automatic_hardware_breakpoints
= 1;
13960 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);