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"
41 #include "gdb-demangle.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"
72 /* readline include files */
73 #include "readline/readline.h"
74 #include "readline/history.h"
76 /* readline defines this. */
79 #include "mi/mi-common.h"
80 #include "python/python.h"
82 /* Prototypes for local functions. */
84 static void enable_delete_command (char *, int);
86 static void enable_once_command (char *, int);
88 static void disable_command (char *, int);
90 static void enable_command (char *, int);
92 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint
*,
96 static void ignore_command (char *, int);
98 static int breakpoint_re_set_one (void *);
100 static void breakpoint_re_set_default (struct breakpoint
*);
102 static void clear_command (char *, int);
104 static void catch_command (char *, int);
106 static int can_use_hardware_watchpoint (struct value
*);
108 static void break_command_1 (char *, int, int);
110 static void mention (struct breakpoint
*);
112 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
114 const struct breakpoint_ops
*);
115 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
116 const struct symtab_and_line
*);
118 /* This function is used in gdbtk sources and thus can not be made
120 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
121 struct symtab_and_line
,
123 const struct breakpoint_ops
*);
125 static struct breakpoint
*
126 momentary_breakpoint_from_master (struct breakpoint
*orig
,
128 const struct breakpoint_ops
*ops
);
130 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
132 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
136 static void describe_other_breakpoints (struct gdbarch
*,
137 struct program_space
*, CORE_ADDR
,
138 struct obj_section
*, int);
140 static int breakpoint_address_match (struct address_space
*aspace1
,
142 struct address_space
*aspace2
,
145 static int watchpoint_locations_match (struct bp_location
*loc1
,
146 struct bp_location
*loc2
);
148 static int breakpoint_location_address_match (struct bp_location
*bl
,
149 struct address_space
*aspace
,
152 static void breakpoints_info (char *, int);
154 static void watchpoints_info (char *, int);
156 static int breakpoint_1 (char *, int,
157 int (*) (const struct breakpoint
*));
159 static int breakpoint_cond_eval (void *);
161 static void cleanup_executing_breakpoints (void *);
163 static void commands_command (char *, int);
165 static void condition_command (char *, int);
174 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
175 static int remove_breakpoint_1 (struct bp_location
*, insertion_state_t
);
177 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
179 static int watchpoint_check (void *);
181 static void maintenance_info_breakpoints (char *, int);
183 static int hw_breakpoint_used_count (void);
185 static int hw_watchpoint_use_count (struct breakpoint
*);
187 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
189 int *other_type_used
);
191 static void hbreak_command (char *, int);
193 static void thbreak_command (char *, int);
195 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
);
197 static void stop_command (char *arg
, int from_tty
);
199 static void stopin_command (char *arg
, int from_tty
);
201 static void stopat_command (char *arg
, int from_tty
);
203 static char *ep_parse_optional_if_clause (char **arg
);
205 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
206 char *arg
, int tempflag
, int from_tty
);
208 static void tcatch_command (char *arg
, int from_tty
);
210 static void detach_single_step_breakpoints (void);
212 static int single_step_breakpoint_inserted_here_p (struct address_space
*,
215 static void free_bp_location (struct bp_location
*loc
);
216 static void incref_bp_location (struct bp_location
*loc
);
217 static void decref_bp_location (struct bp_location
**loc
);
219 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
221 static void update_global_location_list (int);
223 static void update_global_location_list_nothrow (int);
225 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
227 static void insert_breakpoint_locations (void);
229 static int syscall_catchpoint_p (struct breakpoint
*b
);
231 static void tracepoints_info (char *, int);
233 static void delete_trace_command (char *, int);
235 static void enable_trace_command (char *, int);
237 static void disable_trace_command (char *, int);
239 static void trace_pass_command (char *, int);
241 static int is_masked_watchpoint (const struct breakpoint
*b
);
243 /* Assuming we're creating a static tracepoint, does S look like a
244 static tracepoint marker spec ("-m MARKER_ID")? */
245 #define is_marker_spec(s) \
246 (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
248 /* The abstract base class all breakpoint_ops structures inherit
250 static struct breakpoint_ops base_breakpoint_ops
;
252 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
253 that are implemented on top of software or hardware breakpoints
254 (user breakpoints, internal and momentary breakpoints, etc.). */
255 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
257 /* Internal breakpoints class type. */
258 static struct breakpoint_ops internal_breakpoint_ops
;
260 /* Momentary breakpoints class type. */
261 static struct breakpoint_ops momentary_breakpoint_ops
;
263 /* The breakpoint_ops structure to be used in regular user created
265 struct breakpoint_ops bkpt_breakpoint_ops
;
267 /* A reference-counted struct command_line. This lets multiple
268 breakpoints share a single command list. */
269 struct counted_command_line
271 /* The reference count. */
274 /* The command list. */
275 struct command_line
*commands
;
278 struct command_line
*
279 breakpoint_commands (struct breakpoint
*b
)
281 return b
->commands
? b
->commands
->commands
: NULL
;
284 /* Flag indicating that a command has proceeded the inferior past the
285 current breakpoint. */
287 static int breakpoint_proceeded
;
290 bpdisp_text (enum bpdisp disp
)
292 /* NOTE: the following values are a part of MI protocol and
293 represent values of 'disp' field returned when inferior stops at
295 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
297 return bpdisps
[(int) disp
];
300 /* Prototypes for exported functions. */
301 /* If FALSE, gdb will not use hardware support for watchpoints, even
302 if such is available. */
303 static int can_use_hw_watchpoints
;
306 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
307 struct cmd_list_element
*c
,
310 fprintf_filtered (file
,
311 _("Debugger's willingness to use "
312 "watchpoint hardware is %s.\n"),
316 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
317 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
318 for unrecognized breakpoint locations.
319 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
320 static enum auto_boolean pending_break_support
;
322 show_pending_break_support (struct ui_file
*file
, int from_tty
,
323 struct cmd_list_element
*c
,
326 fprintf_filtered (file
,
327 _("Debugger's behavior regarding "
328 "pending breakpoints is %s.\n"),
332 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
333 set with "break" but falling in read-only memory.
334 If 0, gdb will warn about such breakpoints, but won't automatically
335 use hardware breakpoints. */
336 static int automatic_hardware_breakpoints
;
338 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
339 struct cmd_list_element
*c
,
342 fprintf_filtered (file
,
343 _("Automatic usage of hardware breakpoints is %s.\n"),
347 /* If on, gdb will keep breakpoints inserted even as inferior is
348 stopped, and immediately insert any new breakpoints. If off, gdb
349 will insert breakpoints into inferior only when resuming it, and
350 will remove breakpoints upon stop. If auto, GDB will behave as ON
351 if in non-stop mode, and as OFF if all-stop mode.*/
353 static const char always_inserted_auto
[] = "auto";
354 static const char always_inserted_on
[] = "on";
355 static const char always_inserted_off
[] = "off";
356 static const char *always_inserted_enums
[] = {
357 always_inserted_auto
,
362 static const char *always_inserted_mode
= always_inserted_auto
;
364 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
365 struct cmd_list_element
*c
, const char *value
)
367 if (always_inserted_mode
== always_inserted_auto
)
368 fprintf_filtered (file
,
369 _("Always inserted breakpoint "
370 "mode is %s (currently %s).\n"),
372 breakpoints_always_inserted_mode () ? "on" : "off");
374 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
379 breakpoints_always_inserted_mode (void)
381 return ((always_inserted_mode
== always_inserted_on
382 || (always_inserted_mode
== always_inserted_auto
&& non_stop
))
386 void _initialize_breakpoint (void);
388 /* Are we executing breakpoint commands? */
389 static int executing_breakpoint_commands
;
391 /* Are overlay event breakpoints enabled? */
392 static int overlay_events_enabled
;
394 /* See description in breakpoint.h. */
395 int target_exact_watchpoints
= 0;
397 /* Walk the following statement or block through all breakpoints.
398 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
399 current breakpoint. */
401 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
403 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
404 for (B = breakpoint_chain; \
405 B ? (TMP=B->next, 1): 0; \
408 /* Similar iterator for the low-level breakpoints. SAFE variant is
409 not provided so update_global_location_list must not be called
410 while executing the block of ALL_BP_LOCATIONS. */
412 #define ALL_BP_LOCATIONS(B,BP_TMP) \
413 for (BP_TMP = bp_location; \
414 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
417 /* Iterator for tracepoints only. */
419 #define ALL_TRACEPOINTS(B) \
420 for (B = breakpoint_chain; B; B = B->next) \
421 if (is_tracepoint (B))
423 /* Chains of all breakpoints defined. */
425 struct breakpoint
*breakpoint_chain
;
427 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
429 static struct bp_location
**bp_location
;
431 /* Number of elements of BP_LOCATION. */
433 static unsigned bp_location_count
;
435 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
436 ADDRESS for the current elements of BP_LOCATION which get a valid
437 result from bp_location_has_shadow. You can use it for roughly
438 limiting the subrange of BP_LOCATION to scan for shadow bytes for
439 an address you need to read. */
441 static CORE_ADDR bp_location_placed_address_before_address_max
;
443 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
444 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
445 BP_LOCATION which get a valid result from bp_location_has_shadow.
446 You can use it for roughly limiting the subrange of BP_LOCATION to
447 scan for shadow bytes for an address you need to read. */
449 static CORE_ADDR bp_location_shadow_len_after_address_max
;
451 /* The locations that no longer correspond to any breakpoint, unlinked
452 from bp_location array, but for which a hit may still be reported
454 VEC(bp_location_p
) *moribund_locations
= NULL
;
456 /* Number of last breakpoint made. */
458 static int breakpoint_count
;
460 /* The value of `breakpoint_count' before the last command that
461 created breakpoints. If the last (break-like) command created more
462 than one breakpoint, then the difference between BREAKPOINT_COUNT
463 and PREV_BREAKPOINT_COUNT is more than one. */
464 static int prev_breakpoint_count
;
466 /* Number of last tracepoint made. */
468 static int tracepoint_count
;
470 static struct cmd_list_element
*breakpoint_set_cmdlist
;
471 static struct cmd_list_element
*breakpoint_show_cmdlist
;
472 struct cmd_list_element
*save_cmdlist
;
474 /* Return whether a breakpoint is an active enabled breakpoint. */
476 breakpoint_enabled (struct breakpoint
*b
)
478 return (b
->enable_state
== bp_enabled
);
481 /* Set breakpoint count to NUM. */
484 set_breakpoint_count (int num
)
486 prev_breakpoint_count
= breakpoint_count
;
487 breakpoint_count
= num
;
488 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
491 /* Used by `start_rbreak_breakpoints' below, to record the current
492 breakpoint count before "rbreak" creates any breakpoint. */
493 static int rbreak_start_breakpoint_count
;
495 /* Called at the start an "rbreak" command to record the first
499 start_rbreak_breakpoints (void)
501 rbreak_start_breakpoint_count
= breakpoint_count
;
504 /* Called at the end of an "rbreak" command to record the last
508 end_rbreak_breakpoints (void)
510 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
513 /* Used in run_command to zero the hit count when a new run starts. */
516 clear_breakpoint_hit_counts (void)
518 struct breakpoint
*b
;
524 /* Allocate a new counted_command_line with reference count of 1.
525 The new structure owns COMMANDS. */
527 static struct counted_command_line
*
528 alloc_counted_command_line (struct command_line
*commands
)
530 struct counted_command_line
*result
531 = xmalloc (sizeof (struct counted_command_line
));
534 result
->commands
= commands
;
538 /* Increment reference count. This does nothing if CMD is NULL. */
541 incref_counted_command_line (struct counted_command_line
*cmd
)
547 /* Decrement reference count. If the reference count reaches 0,
548 destroy the counted_command_line. Sets *CMDP to NULL. This does
549 nothing if *CMDP is NULL. */
552 decref_counted_command_line (struct counted_command_line
**cmdp
)
556 if (--(*cmdp
)->refc
== 0)
558 free_command_lines (&(*cmdp
)->commands
);
565 /* A cleanup function that calls decref_counted_command_line. */
568 do_cleanup_counted_command_line (void *arg
)
570 decref_counted_command_line (arg
);
573 /* Create a cleanup that calls decref_counted_command_line on the
576 static struct cleanup
*
577 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
579 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
583 /* Return the breakpoint with the specified number, or NULL
584 if the number does not refer to an existing breakpoint. */
587 get_breakpoint (int num
)
589 struct breakpoint
*b
;
592 if (b
->number
== num
)
601 set_breakpoint_condition (struct breakpoint
*b
, char *exp
,
604 xfree (b
->cond_string
);
605 b
->cond_string
= NULL
;
607 if (is_watchpoint (b
))
609 struct watchpoint
*w
= (struct watchpoint
*) b
;
616 struct bp_location
*loc
;
618 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
628 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
634 /* I don't know if it matters whether this is the string the user
635 typed in or the decompiled expression. */
636 b
->cond_string
= xstrdup (arg
);
637 b
->condition_not_parsed
= 0;
639 if (is_watchpoint (b
))
641 struct watchpoint
*w
= (struct watchpoint
*) b
;
643 innermost_block
= NULL
;
645 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0);
647 error (_("Junk at end of expression"));
648 w
->cond_exp_valid_block
= innermost_block
;
652 struct bp_location
*loc
;
654 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
658 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
660 error (_("Junk at end of expression"));
664 breakpoints_changed ();
665 observer_notify_breakpoint_modified (b
);
668 /* condition N EXP -- set break condition of breakpoint N to EXP. */
671 condition_command (char *arg
, int from_tty
)
673 struct breakpoint
*b
;
678 error_no_arg (_("breakpoint number"));
681 bnum
= get_number (&p
);
683 error (_("Bad breakpoint argument: '%s'"), arg
);
686 if (b
->number
== bnum
)
688 /* Check if this breakpoint has a Python object assigned to
689 it, and if it has a definition of the "stop"
690 method. This method and conditions entered into GDB from
691 the CLI are mutually exclusive. */
693 && gdbpy_breakpoint_has_py_cond (b
->py_bp_object
))
694 error (_("Cannot set a condition where a Python 'stop' "
695 "method has been defined in the breakpoint."));
696 set_breakpoint_condition (b
, p
, from_tty
);
700 error (_("No breakpoint number %d."), bnum
);
703 /* Check that COMMAND do not contain commands that are suitable
704 only for tracepoints and not suitable for ordinary breakpoints.
705 Throw if any such commands is found. */
708 check_no_tracepoint_commands (struct command_line
*commands
)
710 struct command_line
*c
;
712 for (c
= commands
; c
; c
= c
->next
)
716 if (c
->control_type
== while_stepping_control
)
717 error (_("The 'while-stepping' command can "
718 "only be used for tracepoints"));
720 for (i
= 0; i
< c
->body_count
; ++i
)
721 check_no_tracepoint_commands ((c
->body_list
)[i
]);
723 /* Not that command parsing removes leading whitespace and comment
724 lines and also empty lines. So, we only need to check for
726 if (strstr (c
->line
, "collect ") == c
->line
)
727 error (_("The 'collect' command can only be used for tracepoints"));
729 if (strstr (c
->line
, "teval ") == c
->line
)
730 error (_("The 'teval' command can only be used for tracepoints"));
734 /* Encapsulate tests for different types of tracepoints. */
737 is_tracepoint_type (enum bptype type
)
739 return (type
== bp_tracepoint
740 || type
== bp_fast_tracepoint
741 || type
== bp_static_tracepoint
);
745 is_tracepoint (const struct breakpoint
*b
)
747 return is_tracepoint_type (b
->type
);
750 /* A helper function that validates that COMMANDS are valid for a
751 breakpoint. This function will throw an exception if a problem is
755 validate_commands_for_breakpoint (struct breakpoint
*b
,
756 struct command_line
*commands
)
758 if (is_tracepoint (b
))
760 /* We need to verify that each top-level element of commands is
761 valid for tracepoints, that there's at most one
762 while-stepping element, and that while-stepping's body has
763 valid tracing commands excluding nested while-stepping. */
764 struct command_line
*c
;
765 struct command_line
*while_stepping
= 0;
766 for (c
= commands
; c
; c
= c
->next
)
768 if (c
->control_type
== while_stepping_control
)
770 if (b
->type
== bp_fast_tracepoint
)
771 error (_("The 'while-stepping' command "
772 "cannot be used for fast tracepoint"));
773 else if (b
->type
== bp_static_tracepoint
)
774 error (_("The 'while-stepping' command "
775 "cannot be used for static tracepoint"));
778 error (_("The 'while-stepping' command "
779 "can be used only once"));
786 struct command_line
*c2
;
788 gdb_assert (while_stepping
->body_count
== 1);
789 c2
= while_stepping
->body_list
[0];
790 for (; c2
; c2
= c2
->next
)
792 if (c2
->control_type
== while_stepping_control
)
793 error (_("The 'while-stepping' command cannot be nested"));
799 check_no_tracepoint_commands (commands
);
803 /* Return a vector of all the static tracepoints set at ADDR. The
804 caller is responsible for releasing the vector. */
807 static_tracepoints_here (CORE_ADDR addr
)
809 struct breakpoint
*b
;
810 VEC(breakpoint_p
) *found
= 0;
811 struct bp_location
*loc
;
814 if (b
->type
== bp_static_tracepoint
)
816 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
817 if (loc
->address
== addr
)
818 VEC_safe_push(breakpoint_p
, found
, b
);
824 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
825 validate that only allowed commands are included. */
828 breakpoint_set_commands (struct breakpoint
*b
,
829 struct command_line
*commands
)
831 validate_commands_for_breakpoint (b
, commands
);
833 decref_counted_command_line (&b
->commands
);
834 b
->commands
= alloc_counted_command_line (commands
);
835 breakpoints_changed ();
836 observer_notify_breakpoint_modified (b
);
839 /* Set the internal `silent' flag on the breakpoint. Note that this
840 is not the same as the "silent" that may appear in the breakpoint's
844 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
846 int old_silent
= b
->silent
;
849 if (old_silent
!= silent
)
850 observer_notify_breakpoint_modified (b
);
853 /* Set the thread for this breakpoint. If THREAD is -1, make the
854 breakpoint work for any thread. */
857 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
859 int old_thread
= b
->thread
;
862 if (old_thread
!= thread
)
863 observer_notify_breakpoint_modified (b
);
866 /* Set the task for this breakpoint. If TASK is 0, make the
867 breakpoint work for any task. */
870 breakpoint_set_task (struct breakpoint
*b
, int task
)
872 int old_task
= b
->task
;
875 if (old_task
!= task
)
876 observer_notify_breakpoint_modified (b
);
880 check_tracepoint_command (char *line
, void *closure
)
882 struct breakpoint
*b
= closure
;
884 validate_actionline (&line
, b
);
887 /* A structure used to pass information through
888 map_breakpoint_numbers. */
892 /* True if the command was typed at a tty. */
895 /* The breakpoint range spec. */
898 /* Non-NULL if the body of the commands are being read from this
899 already-parsed command. */
900 struct command_line
*control
;
902 /* The command lines read from the user, or NULL if they have not
904 struct counted_command_line
*cmd
;
907 /* A callback for map_breakpoint_numbers that sets the commands for
911 do_map_commands_command (struct breakpoint
*b
, void *data
)
913 struct commands_info
*info
= data
;
915 if (info
->cmd
== NULL
)
917 struct command_line
*l
;
919 if (info
->control
!= NULL
)
920 l
= copy_command_lines (info
->control
->body_list
[0]);
923 struct cleanup
*old_chain
;
926 str
= xstrprintf (_("Type commands for breakpoint(s) "
927 "%s, one per line."),
930 old_chain
= make_cleanup (xfree
, str
);
932 l
= read_command_lines (str
,
935 ? check_tracepoint_command
: 0),
938 do_cleanups (old_chain
);
941 info
->cmd
= alloc_counted_command_line (l
);
944 /* If a breakpoint was on the list more than once, we don't need to
946 if (b
->commands
!= info
->cmd
)
948 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
949 incref_counted_command_line (info
->cmd
);
950 decref_counted_command_line (&b
->commands
);
951 b
->commands
= info
->cmd
;
952 breakpoints_changed ();
953 observer_notify_breakpoint_modified (b
);
958 commands_command_1 (char *arg
, int from_tty
,
959 struct command_line
*control
)
961 struct cleanup
*cleanups
;
962 struct commands_info info
;
964 info
.from_tty
= from_tty
;
965 info
.control
= control
;
967 /* If we read command lines from the user, then `info' will hold an
968 extra reference to the commands that we must clean up. */
969 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
971 if (arg
== NULL
|| !*arg
)
973 if (breakpoint_count
- prev_breakpoint_count
> 1)
974 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1,
976 else if (breakpoint_count
> 0)
977 arg
= xstrprintf ("%d", breakpoint_count
);
980 /* So that we don't try to free the incoming non-NULL
981 argument in the cleanup below. Mapping breakpoint
982 numbers will fail in this case. */
987 /* The command loop has some static state, so we need to preserve
992 make_cleanup (xfree
, arg
);
996 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
998 if (info
.cmd
== NULL
)
999 error (_("No breakpoints specified."));
1001 do_cleanups (cleanups
);
1005 commands_command (char *arg
, int from_tty
)
1007 commands_command_1 (arg
, from_tty
, NULL
);
1010 /* Like commands_command, but instead of reading the commands from
1011 input stream, takes them from an already parsed command structure.
1013 This is used by cli-script.c to DTRT with breakpoint commands
1014 that are part of if and while bodies. */
1015 enum command_control_type
1016 commands_from_control_command (char *arg
, struct command_line
*cmd
)
1018 commands_command_1 (arg
, 0, cmd
);
1019 return simple_control
;
1022 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1025 bp_location_has_shadow (struct bp_location
*bl
)
1027 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1031 if (bl
->target_info
.shadow_len
== 0)
1032 /* BL isn't valid, or doesn't shadow memory. */
1037 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1038 by replacing any memory breakpoints with their shadowed contents.
1040 The range of shadowed area by each bp_location is:
1041 bl->address - bp_location_placed_address_before_address_max
1042 up to bl->address + bp_location_shadow_len_after_address_max
1043 The range we were requested to resolve shadows for is:
1044 memaddr ... memaddr + len
1045 Thus the safe cutoff boundaries for performance optimization are
1046 memaddr + len <= (bl->address
1047 - bp_location_placed_address_before_address_max)
1049 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1052 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
1054 /* Left boundary, right boundary and median element of our binary
1056 unsigned bc_l
, bc_r
, bc
;
1058 /* Find BC_L which is a leftmost element which may affect BUF
1059 content. It is safe to report lower value but a failure to
1060 report higher one. */
1063 bc_r
= bp_location_count
;
1064 while (bc_l
+ 1 < bc_r
)
1066 struct bp_location
*bl
;
1068 bc
= (bc_l
+ bc_r
) / 2;
1069 bl
= bp_location
[bc
];
1071 /* Check first BL->ADDRESS will not overflow due to the added
1072 constant. Then advance the left boundary only if we are sure
1073 the BC element can in no way affect the BUF content (MEMADDR
1074 to MEMADDR + LEN range).
1076 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1077 offset so that we cannot miss a breakpoint with its shadow
1078 range tail still reaching MEMADDR. */
1080 if ((bl
->address
+ bp_location_shadow_len_after_address_max
1082 && (bl
->address
+ bp_location_shadow_len_after_address_max
1089 /* Due to the binary search above, we need to make sure we pick the
1090 first location that's at BC_L's address. E.g., if there are
1091 multiple locations at the same address, BC_L may end up pointing
1092 at a duplicate location, and miss the "master"/"inserted"
1093 location. Say, given locations L1, L2 and L3 at addresses A and
1096 L1@A, L2@A, L3@B, ...
1098 BC_L could end up pointing at location L2, while the "master"
1099 location could be L1. Since the `loc->inserted' flag is only set
1100 on "master" locations, we'd forget to restore the shadow of L1
1103 && bp_location
[bc_l
]->address
== bp_location
[bc_l
- 1]->address
)
1106 /* Now do full processing of the found relevant range of elements. */
1108 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1110 struct bp_location
*bl
= bp_location
[bc
];
1111 CORE_ADDR bp_addr
= 0;
1115 /* bp_location array has BL->OWNER always non-NULL. */
1116 if (bl
->owner
->type
== bp_none
)
1117 warning (_("reading through apparently deleted breakpoint #%d?"),
1120 /* Performance optimization: any further element can no longer affect BUF
1123 if (bl
->address
>= bp_location_placed_address_before_address_max
1124 && memaddr
+ len
<= (bl
->address
1125 - bp_location_placed_address_before_address_max
))
1128 if (!bp_location_has_shadow (bl
))
1130 if (!breakpoint_address_match (bl
->target_info
.placed_address_space
, 0,
1131 current_program_space
->aspace
, 0))
1134 /* Addresses and length of the part of the breakpoint that
1136 bp_addr
= bl
->target_info
.placed_address
;
1137 bp_size
= bl
->target_info
.shadow_len
;
1139 if (bp_addr
+ bp_size
<= memaddr
)
1140 /* The breakpoint is entirely before the chunk of memory we
1144 if (bp_addr
>= memaddr
+ len
)
1145 /* The breakpoint is entirely after the chunk of memory we are
1149 /* Offset within shadow_contents. */
1150 if (bp_addr
< memaddr
)
1152 /* Only copy the second part of the breakpoint. */
1153 bp_size
-= memaddr
- bp_addr
;
1154 bptoffset
= memaddr
- bp_addr
;
1158 if (bp_addr
+ bp_size
> memaddr
+ len
)
1160 /* Only copy the first part of the breakpoint. */
1161 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1164 memcpy (buf
+ bp_addr
- memaddr
,
1165 bl
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
1170 /* Return true if BPT is of any hardware watchpoint kind. */
1173 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1175 return (bpt
->type
== bp_hardware_watchpoint
1176 || bpt
->type
== bp_read_watchpoint
1177 || bpt
->type
== bp_access_watchpoint
);
1180 /* Return true if BPT is of any watchpoint kind, hardware or
1184 is_watchpoint (const struct breakpoint
*bpt
)
1186 return (is_hardware_watchpoint (bpt
)
1187 || bpt
->type
== bp_watchpoint
);
1190 /* Returns true if the current thread and its running state are safe
1191 to evaluate or update watchpoint B. Watchpoints on local
1192 expressions need to be evaluated in the context of the thread that
1193 was current when the watchpoint was created, and, that thread needs
1194 to be stopped to be able to select the correct frame context.
1195 Watchpoints on global expressions can be evaluated on any thread,
1196 and in any state. It is presently left to the target allowing
1197 memory accesses when threads are running. */
1200 watchpoint_in_thread_scope (struct watchpoint
*b
)
1202 return (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1203 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1204 && !is_executing (inferior_ptid
)));
1207 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1208 associated bp_watchpoint_scope breakpoint. */
1211 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1213 struct breakpoint
*b
= &w
->base
;
1215 if (b
->related_breakpoint
!= b
)
1217 gdb_assert (b
->related_breakpoint
->type
== bp_watchpoint_scope
);
1218 gdb_assert (b
->related_breakpoint
->related_breakpoint
== b
);
1219 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1220 b
->related_breakpoint
->related_breakpoint
= b
->related_breakpoint
;
1221 b
->related_breakpoint
= b
;
1223 b
->disposition
= disp_del_at_next_stop
;
1226 /* Assuming that B is a watchpoint:
1227 - Reparse watchpoint expression, if REPARSE is non-zero
1228 - Evaluate expression and store the result in B->val
1229 - Evaluate the condition if there is one, and store the result
1231 - Update the list of values that must be watched in B->loc.
1233 If the watchpoint disposition is disp_del_at_next_stop, then do
1234 nothing. If this is local watchpoint that is out of scope, delete
1237 Even with `set breakpoint always-inserted on' the watchpoints are
1238 removed + inserted on each stop here. Normal breakpoints must
1239 never be removed because they might be missed by a running thread
1240 when debugging in non-stop mode. On the other hand, hardware
1241 watchpoints (is_hardware_watchpoint; processed here) are specific
1242 to each LWP since they are stored in each LWP's hardware debug
1243 registers. Therefore, such LWP must be stopped first in order to
1244 be able to modify its hardware watchpoints.
1246 Hardware watchpoints must be reset exactly once after being
1247 presented to the user. It cannot be done sooner, because it would
1248 reset the data used to present the watchpoint hit to the user. And
1249 it must not be done later because it could display the same single
1250 watchpoint hit during multiple GDB stops. Note that the latter is
1251 relevant only to the hardware watchpoint types bp_read_watchpoint
1252 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1253 not user-visible - its hit is suppressed if the memory content has
1256 The following constraints influence the location where we can reset
1257 hardware watchpoints:
1259 * target_stopped_by_watchpoint and target_stopped_data_address are
1260 called several times when GDB stops.
1263 * Multiple hardware watchpoints can be hit at the same time,
1264 causing GDB to stop. GDB only presents one hardware watchpoint
1265 hit at a time as the reason for stopping, and all the other hits
1266 are presented later, one after the other, each time the user
1267 requests the execution to be resumed. Execution is not resumed
1268 for the threads still having pending hit event stored in
1269 LWP_INFO->STATUS. While the watchpoint is already removed from
1270 the inferior on the first stop the thread hit event is kept being
1271 reported from its cached value by linux_nat_stopped_data_address
1272 until the real thread resume happens after the watchpoint gets
1273 presented and thus its LWP_INFO->STATUS gets reset.
1275 Therefore the hardware watchpoint hit can get safely reset on the
1276 watchpoint removal from inferior. */
1279 update_watchpoint (struct watchpoint
*b
, int reparse
)
1281 int within_current_scope
;
1282 struct frame_id saved_frame_id
;
1285 /* If this is a local watchpoint, we only want to check if the
1286 watchpoint frame is in scope if the current thread is the thread
1287 that was used to create the watchpoint. */
1288 if (!watchpoint_in_thread_scope (b
))
1291 if (b
->base
.disposition
== disp_del_at_next_stop
)
1296 /* Determine if the watchpoint is within scope. */
1297 if (b
->exp_valid_block
== NULL
)
1298 within_current_scope
= 1;
1301 struct frame_info
*fi
= get_current_frame ();
1302 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1303 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1305 /* If we're in a function epilogue, unwinding may not work
1306 properly, so do not attempt to recreate locations at this
1307 point. See similar comments in watchpoint_check. */
1308 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
1311 /* Save the current frame's ID so we can restore it after
1312 evaluating the watchpoint expression on its own frame. */
1313 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1314 took a frame parameter, so that we didn't have to change the
1317 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1319 fi
= frame_find_by_id (b
->watchpoint_frame
);
1320 within_current_scope
= (fi
!= NULL
);
1321 if (within_current_scope
)
1325 /* We don't free locations. They are stored in the bp_location array
1326 and update_global_location_list will eventually delete them and
1327 remove breakpoints if needed. */
1330 if (within_current_scope
&& reparse
)
1339 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1340 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
1341 /* If the meaning of expression itself changed, the old value is
1342 no longer relevant. We don't want to report a watchpoint hit
1343 to the user when the old value and the new value may actually
1344 be completely different objects. */
1345 value_free (b
->val
);
1349 /* Note that unlike with breakpoints, the watchpoint's condition
1350 expression is stored in the breakpoint object, not in the
1351 locations (re)created below. */
1352 if (b
->base
.cond_string
!= NULL
)
1354 if (b
->cond_exp
!= NULL
)
1356 xfree (b
->cond_exp
);
1360 s
= b
->base
.cond_string
;
1361 b
->cond_exp
= parse_exp_1 (&s
, b
->cond_exp_valid_block
, 0);
1365 /* If we failed to parse the expression, for example because
1366 it refers to a global variable in a not-yet-loaded shared library,
1367 don't try to insert watchpoint. We don't automatically delete
1368 such watchpoint, though, since failure to parse expression
1369 is different from out-of-scope watchpoint. */
1370 if ( !target_has_execution
)
1372 /* Without execution, memory can't change. No use to try and
1373 set watchpoint locations. The watchpoint will be reset when
1374 the target gains execution, through breakpoint_re_set. */
1376 else if (within_current_scope
&& b
->exp
)
1379 struct value
*val_chain
, *v
, *result
, *next
;
1380 struct program_space
*frame_pspace
;
1382 fetch_subexp_value (b
->exp
, &pc
, &v
, &result
, &val_chain
);
1384 /* Avoid setting b->val if it's already set. The meaning of
1385 b->val is 'the last value' user saw, and we should update
1386 it only if we reported that last value to user. As it
1387 happens, the code that reports it updates b->val directly.
1388 We don't keep track of the memory value for masked
1390 if (!b
->val_valid
&& !is_masked_watchpoint (&b
->base
))
1396 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1398 /* Look at each value on the value chain. */
1399 for (v
= val_chain
; v
; v
= value_next (v
))
1401 /* If it's a memory location, and GDB actually needed
1402 its contents to evaluate the expression, then we
1403 must watch it. If the first value returned is
1404 still lazy, that means an error occurred reading it;
1405 watch it anyway in case it becomes readable. */
1406 if (VALUE_LVAL (v
) == lval_memory
1407 && (v
== val_chain
|| ! value_lazy (v
)))
1409 struct type
*vtype
= check_typedef (value_type (v
));
1411 /* We only watch structs and arrays if user asked
1412 for it explicitly, never if they just happen to
1413 appear in the middle of some value chain. */
1415 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
1416 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
1420 struct bp_location
*loc
, **tmp
;
1422 addr
= value_address (v
);
1423 len
= TYPE_LENGTH (value_type (v
));
1425 if (b
->base
.type
== bp_read_watchpoint
)
1427 else if (b
->base
.type
== bp_access_watchpoint
)
1430 loc
= allocate_bp_location (&b
->base
);
1431 for (tmp
= &(b
->base
.loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1434 loc
->gdbarch
= get_type_arch (value_type (v
));
1436 loc
->pspace
= frame_pspace
;
1437 loc
->address
= addr
;
1439 loc
->watchpoint_type
= type
;
1444 /* Change the type of breakpoint between hardware assisted or
1445 an ordinary watchpoint depending on the hardware support
1446 and free hardware slots. REPARSE is set when the inferior
1451 enum bp_loc_type loc_type
;
1452 struct bp_location
*bl
;
1454 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
1458 int i
, target_resources_ok
, other_type_used
;
1461 /* Use an exact watchpoint when there's only one memory region to be
1462 watched, and only one debug register is needed to watch it. */
1463 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
1465 /* We need to determine how many resources are already
1466 used for all other hardware watchpoints plus this one
1467 to see if we still have enough resources to also fit
1468 this watchpoint in as well. */
1470 /* If this is a software watchpoint, we try to turn it
1471 to a hardware one -- count resources as if B was of
1472 hardware watchpoint type. */
1473 type
= b
->base
.type
;
1474 if (type
== bp_watchpoint
)
1475 type
= bp_hardware_watchpoint
;
1477 /* This watchpoint may or may not have been placed on
1478 the list yet at this point (it won't be in the list
1479 if we're trying to create it for the first time,
1480 through watch_command), so always account for it
1483 /* Count resources used by all watchpoints except B. */
1484 i
= hw_watchpoint_used_count_others (&b
->base
, type
, &other_type_used
);
1486 /* Add in the resources needed for B. */
1487 i
+= hw_watchpoint_use_count (&b
->base
);
1490 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
1491 if (target_resources_ok
<= 0)
1493 int sw_mode
= b
->base
.ops
->works_in_software_mode (&b
->base
);
1495 if (target_resources_ok
== 0 && !sw_mode
)
1496 error (_("Target does not support this type of "
1497 "hardware watchpoint."));
1498 else if (target_resources_ok
< 0 && !sw_mode
)
1499 error (_("There are not enough available hardware "
1500 "resources for this watchpoint."));
1502 /* Downgrade to software watchpoint. */
1503 b
->base
.type
= bp_watchpoint
;
1507 /* If this was a software watchpoint, we've just
1508 found we have enough resources to turn it to a
1509 hardware watchpoint. Otherwise, this is a
1511 b
->base
.type
= type
;
1514 else if (!b
->base
.ops
->works_in_software_mode (&b
->base
))
1515 error (_("Expression cannot be implemented with "
1516 "read/access watchpoint."));
1518 b
->base
.type
= bp_watchpoint
;
1520 loc_type
= (b
->base
.type
== bp_watchpoint
? bp_loc_other
1521 : bp_loc_hardware_watchpoint
);
1522 for (bl
= b
->base
.loc
; bl
; bl
= bl
->next
)
1523 bl
->loc_type
= loc_type
;
1526 for (v
= val_chain
; v
; v
= next
)
1528 next
= value_next (v
);
1533 /* If a software watchpoint is not watching any memory, then the
1534 above left it without any location set up. But,
1535 bpstat_stop_status requires a location to be able to report
1536 stops, so make sure there's at least a dummy one. */
1537 if (b
->base
.type
== bp_watchpoint
&& b
->base
.loc
== NULL
)
1539 struct breakpoint
*base
= &b
->base
;
1540 base
->loc
= allocate_bp_location (base
);
1541 base
->loc
->pspace
= frame_pspace
;
1542 base
->loc
->address
= -1;
1543 base
->loc
->length
= -1;
1544 base
->loc
->watchpoint_type
= -1;
1547 else if (!within_current_scope
)
1549 printf_filtered (_("\
1550 Watchpoint %d deleted because the program has left the block\n\
1551 in which its expression is valid.\n"),
1553 watchpoint_del_at_next_stop (b
);
1556 /* Restore the selected frame. */
1558 select_frame (frame_find_by_id (saved_frame_id
));
1562 /* Returns 1 iff breakpoint location should be
1563 inserted in the inferior. We don't differentiate the type of BL's owner
1564 (breakpoint vs. tracepoint), although insert_location in tracepoint's
1565 breakpoint_ops is not defined, because in insert_bp_location,
1566 tracepoint's insert_location will not be called. */
1568 should_be_inserted (struct bp_location
*bl
)
1570 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
1573 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
1576 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
1579 /* This is set for example, when we're attached to the parent of a
1580 vfork, and have detached from the child. The child is running
1581 free, and we expect it to do an exec or exit, at which point the
1582 OS makes the parent schedulable again (and the target reports
1583 that the vfork is done). Until the child is done with the shared
1584 memory region, do not insert breakpoints in the parent, otherwise
1585 the child could still trip on the parent's breakpoints. Since
1586 the parent is blocked anyway, it won't miss any breakpoint. */
1587 if (bl
->pspace
->breakpoints_not_allowed
)
1593 /* Same as should_be_inserted but does the check assuming
1594 that the location is not duplicated. */
1597 unduplicated_should_be_inserted (struct bp_location
*bl
)
1600 const int save_duplicate
= bl
->duplicate
;
1603 result
= should_be_inserted (bl
);
1604 bl
->duplicate
= save_duplicate
;
1608 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
1609 location. Any error messages are printed to TMP_ERROR_STREAM; and
1610 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
1611 Returns 0 for success, 1 if the bp_location type is not supported or
1614 NOTE drow/2003-09-09: This routine could be broken down to an
1615 object-style method for each breakpoint or catchpoint type. */
1617 insert_bp_location (struct bp_location
*bl
,
1618 struct ui_file
*tmp_error_stream
,
1619 int *disabled_breaks
,
1620 int *hw_breakpoint_error
)
1624 if (!should_be_inserted (bl
) || bl
->inserted
)
1627 /* Initialize the target-specific information. */
1628 memset (&bl
->target_info
, 0, sizeof (bl
->target_info
));
1629 bl
->target_info
.placed_address
= bl
->address
;
1630 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
1631 bl
->target_info
.length
= bl
->length
;
1633 if (bl
->loc_type
== bp_loc_software_breakpoint
1634 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
1636 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
1638 /* If the explicitly specified breakpoint type
1639 is not hardware breakpoint, check the memory map to see
1640 if the breakpoint address is in read only memory or not.
1642 Two important cases are:
1643 - location type is not hardware breakpoint, memory
1644 is readonly. We change the type of the location to
1645 hardware breakpoint.
1646 - location type is hardware breakpoint, memory is
1647 read-write. This means we've previously made the
1648 location hardware one, but then the memory map changed,
1651 When breakpoints are removed, remove_breakpoints will use
1652 location types we've just set here, the only possible
1653 problem is that memory map has changed during running
1654 program, but it's not going to work anyway with current
1656 struct mem_region
*mr
1657 = lookup_mem_region (bl
->target_info
.placed_address
);
1661 if (automatic_hardware_breakpoints
)
1663 enum bp_loc_type new_type
;
1665 if (mr
->attrib
.mode
!= MEM_RW
)
1666 new_type
= bp_loc_hardware_breakpoint
;
1668 new_type
= bp_loc_software_breakpoint
;
1670 if (new_type
!= bl
->loc_type
)
1672 static int said
= 0;
1674 bl
->loc_type
= new_type
;
1677 fprintf_filtered (gdb_stdout
,
1678 _("Note: automatically using "
1679 "hardware breakpoints for "
1680 "read-only addresses.\n"));
1685 else if (bl
->loc_type
== bp_loc_software_breakpoint
1686 && mr
->attrib
.mode
!= MEM_RW
)
1687 warning (_("cannot set software breakpoint "
1688 "at readonly address %s"),
1689 paddress (bl
->gdbarch
, bl
->address
));
1693 /* First check to see if we have to handle an overlay. */
1694 if (overlay_debugging
== ovly_off
1695 || bl
->section
== NULL
1696 || !(section_is_overlay (bl
->section
)))
1698 /* No overlay handling: just set the breakpoint. */
1700 val
= bl
->owner
->ops
->insert_location (bl
);
1704 /* This breakpoint is in an overlay section.
1705 Shall we set a breakpoint at the LMA? */
1706 if (!overlay_events_enabled
)
1708 /* Yes -- overlay event support is not active,
1709 so we must try to set a breakpoint at the LMA.
1710 This will not work for a hardware breakpoint. */
1711 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1712 warning (_("hardware breakpoint %d not supported in overlay!"),
1716 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
1718 /* Set a software (trap) breakpoint at the LMA. */
1719 bl
->overlay_target_info
= bl
->target_info
;
1720 bl
->overlay_target_info
.placed_address
= addr
;
1721 val
= target_insert_breakpoint (bl
->gdbarch
,
1722 &bl
->overlay_target_info
);
1724 fprintf_unfiltered (tmp_error_stream
,
1725 "Overlay breakpoint %d "
1726 "failed: in ROM?\n",
1730 /* Shall we set a breakpoint at the VMA? */
1731 if (section_is_mapped (bl
->section
))
1733 /* Yes. This overlay section is mapped into memory. */
1734 val
= bl
->owner
->ops
->insert_location (bl
);
1738 /* No. This breakpoint will not be inserted.
1739 No error, but do not mark the bp as 'inserted'. */
1746 /* Can't set the breakpoint. */
1747 if (solib_name_from_address (bl
->pspace
, bl
->address
))
1749 /* See also: disable_breakpoints_in_shlibs. */
1751 bl
->shlib_disabled
= 1;
1752 observer_notify_breakpoint_modified (bl
->owner
);
1753 if (!*disabled_breaks
)
1755 fprintf_unfiltered (tmp_error_stream
,
1756 "Cannot insert breakpoint %d.\n",
1758 fprintf_unfiltered (tmp_error_stream
,
1759 "Temporarily disabling shared "
1760 "library breakpoints:\n");
1762 *disabled_breaks
= 1;
1763 fprintf_unfiltered (tmp_error_stream
,
1764 "breakpoint #%d\n", bl
->owner
->number
);
1768 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
1770 *hw_breakpoint_error
= 1;
1771 fprintf_unfiltered (tmp_error_stream
,
1772 "Cannot insert hardware "
1778 fprintf_unfiltered (tmp_error_stream
,
1779 "Cannot insert breakpoint %d.\n",
1781 fprintf_filtered (tmp_error_stream
,
1782 "Error accessing memory address ");
1783 fputs_filtered (paddress (bl
->gdbarch
, bl
->address
),
1785 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1786 safe_strerror (val
));
1797 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
1798 /* NOTE drow/2003-09-08: This state only exists for removing
1799 watchpoints. It's not clear that it's necessary... */
1800 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
1802 gdb_assert (bl
->owner
->ops
!= NULL
1803 && bl
->owner
->ops
->insert_location
!= NULL
);
1805 val
= bl
->owner
->ops
->insert_location (bl
);
1807 /* If trying to set a read-watchpoint, and it turns out it's not
1808 supported, try emulating one with an access watchpoint. */
1809 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
1811 struct bp_location
*loc
, **loc_temp
;
1813 /* But don't try to insert it, if there's already another
1814 hw_access location that would be considered a duplicate
1816 ALL_BP_LOCATIONS (loc
, loc_temp
)
1818 && loc
->watchpoint_type
== hw_access
1819 && watchpoint_locations_match (bl
, loc
))
1823 bl
->target_info
= loc
->target_info
;
1824 bl
->watchpoint_type
= hw_access
;
1831 bl
->watchpoint_type
= hw_access
;
1832 val
= bl
->owner
->ops
->insert_location (bl
);
1835 /* Back to the original value. */
1836 bl
->watchpoint_type
= hw_read
;
1840 bl
->inserted
= (val
== 0);
1843 else if (bl
->owner
->type
== bp_catchpoint
)
1845 gdb_assert (bl
->owner
->ops
!= NULL
1846 && bl
->owner
->ops
->insert_location
!= NULL
);
1848 val
= bl
->owner
->ops
->insert_location (bl
);
1851 bl
->owner
->enable_state
= bp_disabled
;
1855 Error inserting catchpoint %d: Your system does not support this type\n\
1856 of catchpoint."), bl
->owner
->number
);
1858 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
1861 bl
->inserted
= (val
== 0);
1863 /* We've already printed an error message if there was a problem
1864 inserting this catchpoint, and we've disabled the catchpoint,
1865 so just return success. */
1872 /* This function is called when program space PSPACE is about to be
1873 deleted. It takes care of updating breakpoints to not reference
1877 breakpoint_program_space_exit (struct program_space
*pspace
)
1879 struct breakpoint
*b
, *b_temp
;
1880 struct bp_location
*loc
, **loc_temp
;
1882 /* Remove any breakpoint that was set through this program space. */
1883 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
1885 if (b
->pspace
== pspace
)
1886 delete_breakpoint (b
);
1889 /* Breakpoints set through other program spaces could have locations
1890 bound to PSPACE as well. Remove those. */
1891 ALL_BP_LOCATIONS (loc
, loc_temp
)
1893 struct bp_location
*tmp
;
1895 if (loc
->pspace
== pspace
)
1897 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1898 if (loc
->owner
->loc
== loc
)
1899 loc
->owner
->loc
= loc
->next
;
1901 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
1902 if (tmp
->next
== loc
)
1904 tmp
->next
= loc
->next
;
1910 /* Now update the global location list to permanently delete the
1911 removed locations above. */
1912 update_global_location_list (0);
1915 /* Make sure all breakpoints are inserted in inferior.
1916 Throws exception on any error.
1917 A breakpoint that is already inserted won't be inserted
1918 again, so calling this function twice is safe. */
1920 insert_breakpoints (void)
1922 struct breakpoint
*bpt
;
1924 ALL_BREAKPOINTS (bpt
)
1925 if (is_hardware_watchpoint (bpt
))
1927 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
1929 update_watchpoint (w
, 0 /* don't reparse. */);
1932 update_global_location_list (1);
1934 /* update_global_location_list does not insert breakpoints when
1935 always_inserted_mode is not enabled. Explicitly insert them
1937 if (!breakpoints_always_inserted_mode ())
1938 insert_breakpoint_locations ();
1941 /* Used when starting or continuing the program. */
1944 insert_breakpoint_locations (void)
1946 struct breakpoint
*bpt
;
1947 struct bp_location
*bl
, **blp_tmp
;
1950 int disabled_breaks
= 0;
1951 int hw_breakpoint_error
= 0;
1953 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1954 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
1956 /* Explicitly mark the warning -- this will only be printed if
1957 there was an error. */
1958 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1960 save_current_space_and_thread ();
1962 ALL_BP_LOCATIONS (bl
, blp_tmp
)
1964 if (!should_be_inserted (bl
) || bl
->inserted
)
1967 /* There is no point inserting thread-specific breakpoints if
1968 the thread no longer exists. ALL_BP_LOCATIONS bp_location
1969 has BL->OWNER always non-NULL. */
1970 if (bl
->owner
->thread
!= -1
1971 && !valid_thread_id (bl
->owner
->thread
))
1974 switch_to_program_space_and_thread (bl
->pspace
);
1976 /* For targets that support global breakpoints, there's no need
1977 to select an inferior to insert breakpoint to. In fact, even
1978 if we aren't attached to any process yet, we should still
1979 insert breakpoints. */
1980 if (!gdbarch_has_global_breakpoints (target_gdbarch
)
1981 && ptid_equal (inferior_ptid
, null_ptid
))
1984 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
1985 &hw_breakpoint_error
);
1990 /* If we failed to insert all locations of a watchpoint, remove
1991 them, as half-inserted watchpoint is of limited use. */
1992 ALL_BREAKPOINTS (bpt
)
1994 int some_failed
= 0;
1995 struct bp_location
*loc
;
1997 if (!is_hardware_watchpoint (bpt
))
2000 if (!breakpoint_enabled (bpt
))
2003 if (bpt
->disposition
== disp_del_at_next_stop
)
2006 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2007 if (!loc
->inserted
&& should_be_inserted (loc
))
2014 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
2016 remove_breakpoint (loc
, mark_uninserted
);
2018 hw_breakpoint_error
= 1;
2019 fprintf_unfiltered (tmp_error_stream
,
2020 "Could not insert hardware watchpoint %d.\n",
2028 /* If a hardware breakpoint or watchpoint was inserted, add a
2029 message about possibly exhausted resources. */
2030 if (hw_breakpoint_error
)
2032 fprintf_unfiltered (tmp_error_stream
,
2033 "Could not insert hardware breakpoints:\n\
2034 You may have requested too many hardware breakpoints/watchpoints.\n");
2036 target_terminal_ours_for_output ();
2037 error_stream (tmp_error_stream
);
2040 do_cleanups (cleanups
);
2043 /* Used when the program stops.
2044 Returns zero if successful, or non-zero if there was a problem
2045 removing a breakpoint location. */
2048 remove_breakpoints (void)
2050 struct bp_location
*bl
, **blp_tmp
;
2053 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2055 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
2056 val
|= remove_breakpoint (bl
, mark_uninserted
);
2061 /* Remove breakpoints of process PID. */
2064 remove_breakpoints_pid (int pid
)
2066 struct bp_location
*bl
, **blp_tmp
;
2068 struct inferior
*inf
= find_inferior_pid (pid
);
2070 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2072 if (bl
->pspace
!= inf
->pspace
)
2077 val
= remove_breakpoint (bl
, mark_uninserted
);
2086 reattach_breakpoints (int pid
)
2088 struct cleanup
*old_chain
;
2089 struct bp_location
*bl
, **blp_tmp
;
2091 struct ui_file
*tmp_error_stream
;
2092 int dummy1
= 0, dummy2
= 0;
2093 struct inferior
*inf
;
2094 struct thread_info
*tp
;
2096 tp
= any_live_thread_of_process (pid
);
2100 inf
= find_inferior_pid (pid
);
2101 old_chain
= save_inferior_ptid ();
2103 inferior_ptid
= tp
->ptid
;
2105 tmp_error_stream
= mem_fileopen ();
2106 make_cleanup_ui_file_delete (tmp_error_stream
);
2108 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2110 if (bl
->pspace
!= inf
->pspace
)
2116 val
= insert_bp_location (bl
, tmp_error_stream
, &dummy1
, &dummy2
);
2119 do_cleanups (old_chain
);
2124 do_cleanups (old_chain
);
2128 static int internal_breakpoint_number
= -1;
2130 /* Set the breakpoint number of B, depending on the value of INTERNAL.
2131 If INTERNAL is non-zero, the breakpoint number will be populated
2132 from internal_breakpoint_number and that variable decremented.
2133 Otherwise the breakpoint number will be populated from
2134 breakpoint_count and that value incremented. Internal breakpoints
2135 do not set the internal var bpnum. */
2137 set_breakpoint_number (int internal
, struct breakpoint
*b
)
2140 b
->number
= internal_breakpoint_number
--;
2143 set_breakpoint_count (breakpoint_count
+ 1);
2144 b
->number
= breakpoint_count
;
2148 static struct breakpoint
*
2149 create_internal_breakpoint (struct gdbarch
*gdbarch
,
2150 CORE_ADDR address
, enum bptype type
,
2151 const struct breakpoint_ops
*ops
)
2153 struct symtab_and_line sal
;
2154 struct breakpoint
*b
;
2156 init_sal (&sal
); /* Initialize to zeroes. */
2159 sal
.section
= find_pc_overlay (sal
.pc
);
2160 sal
.pspace
= current_program_space
;
2162 b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
2163 b
->number
= internal_breakpoint_number
--;
2164 b
->disposition
= disp_donttouch
;
2169 static const char *const longjmp_names
[] =
2171 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
2173 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
2175 /* Per-objfile data private to breakpoint.c. */
2176 struct breakpoint_objfile_data
2178 /* Minimal symbol for "_ovly_debug_event" (if any). */
2179 struct minimal_symbol
*overlay_msym
;
2181 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
2182 struct minimal_symbol
*longjmp_msym
[NUM_LONGJMP_NAMES
];
2184 /* Minimal symbol for "std::terminate()" (if any). */
2185 struct minimal_symbol
*terminate_msym
;
2187 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
2188 struct minimal_symbol
*exception_msym
;
2191 static const struct objfile_data
*breakpoint_objfile_key
;
2193 /* Minimal symbol not found sentinel. */
2194 static struct minimal_symbol msym_not_found
;
2196 /* Returns TRUE if MSYM point to the "not found" sentinel. */
2199 msym_not_found_p (const struct minimal_symbol
*msym
)
2201 return msym
== &msym_not_found
;
2204 /* Return per-objfile data needed by breakpoint.c.
2205 Allocate the data if necessary. */
2207 static struct breakpoint_objfile_data
*
2208 get_breakpoint_objfile_data (struct objfile
*objfile
)
2210 struct breakpoint_objfile_data
*bp_objfile_data
;
2212 bp_objfile_data
= objfile_data (objfile
, breakpoint_objfile_key
);
2213 if (bp_objfile_data
== NULL
)
2215 bp_objfile_data
= obstack_alloc (&objfile
->objfile_obstack
,
2216 sizeof (*bp_objfile_data
));
2218 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
2219 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
2221 return bp_objfile_data
;
2225 create_overlay_event_breakpoint (void)
2227 struct objfile
*objfile
;
2228 const char *const func_name
= "_ovly_debug_event";
2230 ALL_OBJFILES (objfile
)
2232 struct breakpoint
*b
;
2233 struct breakpoint_objfile_data
*bp_objfile_data
;
2236 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2238 if (msym_not_found_p (bp_objfile_data
->overlay_msym
))
2241 if (bp_objfile_data
->overlay_msym
== NULL
)
2243 struct minimal_symbol
*m
;
2245 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2248 /* Avoid future lookups in this objfile. */
2249 bp_objfile_data
->overlay_msym
= &msym_not_found
;
2252 bp_objfile_data
->overlay_msym
= m
;
2255 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
2256 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2258 &internal_breakpoint_ops
);
2259 b
->addr_string
= xstrdup (func_name
);
2261 if (overlay_debugging
== ovly_auto
)
2263 b
->enable_state
= bp_enabled
;
2264 overlay_events_enabled
= 1;
2268 b
->enable_state
= bp_disabled
;
2269 overlay_events_enabled
= 0;
2272 update_global_location_list (1);
2276 create_longjmp_master_breakpoint (void)
2278 struct program_space
*pspace
;
2279 struct cleanup
*old_chain
;
2281 old_chain
= save_current_program_space ();
2283 ALL_PSPACES (pspace
)
2285 struct objfile
*objfile
;
2287 set_current_program_space (pspace
);
2289 ALL_OBJFILES (objfile
)
2292 struct gdbarch
*gdbarch
;
2293 struct breakpoint_objfile_data
*bp_objfile_data
;
2295 gdbarch
= get_objfile_arch (objfile
);
2296 if (!gdbarch_get_longjmp_target_p (gdbarch
))
2299 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2301 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
2303 struct breakpoint
*b
;
2304 const char *func_name
;
2307 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
]))
2310 func_name
= longjmp_names
[i
];
2311 if (bp_objfile_data
->longjmp_msym
[i
] == NULL
)
2313 struct minimal_symbol
*m
;
2315 m
= lookup_minimal_symbol_text (func_name
, objfile
);
2318 /* Prevent future lookups in this objfile. */
2319 bp_objfile_data
->longjmp_msym
[i
] = &msym_not_found
;
2322 bp_objfile_data
->longjmp_msym
[i
] = m
;
2325 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
2326 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
2327 &internal_breakpoint_ops
);
2328 b
->addr_string
= xstrdup (func_name
);
2329 b
->enable_state
= bp_disabled
;
2333 update_global_location_list (1);
2335 do_cleanups (old_chain
);
2338 /* Create a master std::terminate breakpoint. */
2340 create_std_terminate_master_breakpoint (void)
2342 struct program_space
*pspace
;
2343 struct cleanup
*old_chain
;
2344 const char *const func_name
= "std::terminate()";
2346 old_chain
= save_current_program_space ();
2348 ALL_PSPACES (pspace
)
2350 struct objfile
*objfile
;
2353 set_current_program_space (pspace
);
2355 ALL_OBJFILES (objfile
)
2357 struct breakpoint
*b
;
2358 struct breakpoint_objfile_data
*bp_objfile_data
;
2360 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2362 if (msym_not_found_p (bp_objfile_data
->terminate_msym
))
2365 if (bp_objfile_data
->terminate_msym
== NULL
)
2367 struct minimal_symbol
*m
;
2369 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2370 if (m
== NULL
|| (MSYMBOL_TYPE (m
) != mst_text
2371 && MSYMBOL_TYPE (m
) != mst_file_text
))
2373 /* Prevent future lookups in this objfile. */
2374 bp_objfile_data
->terminate_msym
= &msym_not_found
;
2377 bp_objfile_data
->terminate_msym
= m
;
2380 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
2381 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
2382 bp_std_terminate_master
,
2383 &internal_breakpoint_ops
);
2384 b
->addr_string
= xstrdup (func_name
);
2385 b
->enable_state
= bp_disabled
;
2389 update_global_location_list (1);
2391 do_cleanups (old_chain
);
2394 /* Install a master breakpoint on the unwinder's debug hook. */
2397 create_exception_master_breakpoint (void)
2399 struct objfile
*objfile
;
2400 const char *const func_name
= "_Unwind_DebugHook";
2402 ALL_OBJFILES (objfile
)
2404 struct breakpoint
*b
;
2405 struct gdbarch
*gdbarch
;
2406 struct breakpoint_objfile_data
*bp_objfile_data
;
2409 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
2411 if (msym_not_found_p (bp_objfile_data
->exception_msym
))
2414 gdbarch
= get_objfile_arch (objfile
);
2416 if (bp_objfile_data
->exception_msym
== NULL
)
2418 struct minimal_symbol
*debug_hook
;
2420 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
2421 if (debug_hook
== NULL
)
2423 bp_objfile_data
->exception_msym
= &msym_not_found
;
2427 bp_objfile_data
->exception_msym
= debug_hook
;
2430 addr
= SYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
2431 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
2433 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
2434 &internal_breakpoint_ops
);
2435 b
->addr_string
= xstrdup (func_name
);
2436 b
->enable_state
= bp_disabled
;
2439 update_global_location_list (1);
2443 update_breakpoints_after_exec (void)
2445 struct breakpoint
*b
, *b_tmp
;
2446 struct bp_location
*bploc
, **bplocp_tmp
;
2448 /* We're about to delete breakpoints from GDB's lists. If the
2449 INSERTED flag is true, GDB will try to lift the breakpoints by
2450 writing the breakpoints' "shadow contents" back into memory. The
2451 "shadow contents" are NOT valid after an exec, so GDB should not
2452 do that. Instead, the target is responsible from marking
2453 breakpoints out as soon as it detects an exec. We don't do that
2454 here instead, because there may be other attempts to delete
2455 breakpoints after detecting an exec and before reaching here. */
2456 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
2457 if (bploc
->pspace
== current_program_space
)
2458 gdb_assert (!bploc
->inserted
);
2460 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2462 if (b
->pspace
!= current_program_space
)
2465 /* Solib breakpoints must be explicitly reset after an exec(). */
2466 if (b
->type
== bp_shlib_event
)
2468 delete_breakpoint (b
);
2472 /* JIT breakpoints must be explicitly reset after an exec(). */
2473 if (b
->type
== bp_jit_event
)
2475 delete_breakpoint (b
);
2479 /* Thread event breakpoints must be set anew after an exec(),
2480 as must overlay event and longjmp master breakpoints. */
2481 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
2482 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
2483 || b
->type
== bp_exception_master
)
2485 delete_breakpoint (b
);
2489 /* Step-resume breakpoints are meaningless after an exec(). */
2490 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
2492 delete_breakpoint (b
);
2496 /* Longjmp and longjmp-resume breakpoints are also meaningless
2498 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
2499 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
2501 delete_breakpoint (b
);
2505 if (b
->type
== bp_catchpoint
)
2507 /* For now, none of the bp_catchpoint breakpoints need to
2508 do anything at this point. In the future, if some of
2509 the catchpoints need to something, we will need to add
2510 a new method, and call this method from here. */
2514 /* bp_finish is a special case. The only way we ought to be able
2515 to see one of these when an exec() has happened, is if the user
2516 caught a vfork, and then said "finish". Ordinarily a finish just
2517 carries them to the call-site of the current callee, by setting
2518 a temporary bp there and resuming. But in this case, the finish
2519 will carry them entirely through the vfork & exec.
2521 We don't want to allow a bp_finish to remain inserted now. But
2522 we can't safely delete it, 'cause finish_command has a handle to
2523 the bp on a bpstat, and will later want to delete it. There's a
2524 chance (and I've seen it happen) that if we delete the bp_finish
2525 here, that its storage will get reused by the time finish_command
2526 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2527 We really must allow finish_command to delete a bp_finish.
2529 In the absence of a general solution for the "how do we know
2530 it's safe to delete something others may have handles to?"
2531 problem, what we'll do here is just uninsert the bp_finish, and
2532 let finish_command delete it.
2534 (We know the bp_finish is "doomed" in the sense that it's
2535 momentary, and will be deleted as soon as finish_command sees
2536 the inferior stopped. So it doesn't matter that the bp's
2537 address is probably bogus in the new a.out, unlike e.g., the
2538 solib breakpoints.) */
2540 if (b
->type
== bp_finish
)
2545 /* Without a symbolic address, we have little hope of the
2546 pre-exec() address meaning the same thing in the post-exec()
2548 if (b
->addr_string
== NULL
)
2550 delete_breakpoint (b
);
2554 /* FIXME what about longjmp breakpoints? Re-create them here? */
2555 create_overlay_event_breakpoint ();
2556 create_longjmp_master_breakpoint ();
2557 create_std_terminate_master_breakpoint ();
2558 create_exception_master_breakpoint ();
2562 detach_breakpoints (int pid
)
2564 struct bp_location
*bl
, **blp_tmp
;
2566 struct cleanup
*old_chain
= save_inferior_ptid ();
2567 struct inferior
*inf
= current_inferior ();
2569 if (pid
== PIDGET (inferior_ptid
))
2570 error (_("Cannot detach breakpoints of inferior_ptid"));
2572 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2573 inferior_ptid
= pid_to_ptid (pid
);
2574 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2576 if (bl
->pspace
!= inf
->pspace
)
2580 val
|= remove_breakpoint_1 (bl
, mark_inserted
);
2583 /* Detach single-step breakpoints as well. */
2584 detach_single_step_breakpoints ();
2586 do_cleanups (old_chain
);
2590 /* Remove the breakpoint location BL from the current address space.
2591 Note that this is used to detach breakpoints from a child fork.
2592 When we get here, the child isn't in the inferior list, and neither
2593 do we have objects to represent its address space --- we should
2594 *not* look at bl->pspace->aspace here. */
2597 remove_breakpoint_1 (struct bp_location
*bl
, insertion_state_t is
)
2601 /* BL is never in moribund_locations by our callers. */
2602 gdb_assert (bl
->owner
!= NULL
);
2604 if (bl
->owner
->enable_state
== bp_permanent
)
2605 /* Permanent breakpoints cannot be inserted or removed. */
2608 /* The type of none suggests that owner is actually deleted.
2609 This should not ever happen. */
2610 gdb_assert (bl
->owner
->type
!= bp_none
);
2612 if (bl
->loc_type
== bp_loc_software_breakpoint
2613 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2615 /* "Normal" instruction breakpoint: either the standard
2616 trap-instruction bp (bp_breakpoint), or a
2617 bp_hardware_breakpoint. */
2619 /* First check to see if we have to handle an overlay. */
2620 if (overlay_debugging
== ovly_off
2621 || bl
->section
== NULL
2622 || !(section_is_overlay (bl
->section
)))
2624 /* No overlay handling: just remove the breakpoint. */
2625 val
= bl
->owner
->ops
->remove_location (bl
);
2629 /* This breakpoint is in an overlay section.
2630 Did we set a breakpoint at the LMA? */
2631 if (!overlay_events_enabled
)
2633 /* Yes -- overlay event support is not active, so we
2634 should have set a breakpoint at the LMA. Remove it.
2636 /* Ignore any failures: if the LMA is in ROM, we will
2637 have already warned when we failed to insert it. */
2638 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2639 target_remove_hw_breakpoint (bl
->gdbarch
,
2640 &bl
->overlay_target_info
);
2642 target_remove_breakpoint (bl
->gdbarch
,
2643 &bl
->overlay_target_info
);
2645 /* Did we set a breakpoint at the VMA?
2646 If so, we will have marked the breakpoint 'inserted'. */
2649 /* Yes -- remove it. Previously we did not bother to
2650 remove the breakpoint if the section had been
2651 unmapped, but let's not rely on that being safe. We
2652 don't know what the overlay manager might do. */
2654 /* However, we should remove *software* breakpoints only
2655 if the section is still mapped, or else we overwrite
2656 wrong code with the saved shadow contents. */
2657 if (bl
->loc_type
== bp_loc_hardware_breakpoint
2658 || section_is_mapped (bl
->section
))
2659 val
= bl
->owner
->ops
->remove_location (bl
);
2665 /* No -- not inserted, so no need to remove. No error. */
2670 /* In some cases, we might not be able to remove a breakpoint
2671 in a shared library that has already been removed, but we
2672 have not yet processed the shlib unload event. */
2673 if (val
&& solib_name_from_address (bl
->pspace
, bl
->address
))
2678 bl
->inserted
= (is
== mark_inserted
);
2680 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
2682 gdb_assert (bl
->owner
->ops
!= NULL
2683 && bl
->owner
->ops
->remove_location
!= NULL
);
2685 bl
->inserted
= (is
== mark_inserted
);
2686 bl
->owner
->ops
->remove_location (bl
);
2688 /* Failure to remove any of the hardware watchpoints comes here. */
2689 if ((is
== mark_uninserted
) && (bl
->inserted
))
2690 warning (_("Could not remove hardware watchpoint %d."),
2693 else if (bl
->owner
->type
== bp_catchpoint
2694 && breakpoint_enabled (bl
->owner
)
2697 gdb_assert (bl
->owner
->ops
!= NULL
2698 && bl
->owner
->ops
->remove_location
!= NULL
);
2700 val
= bl
->owner
->ops
->remove_location (bl
);
2704 bl
->inserted
= (is
== mark_inserted
);
2711 remove_breakpoint (struct bp_location
*bl
, insertion_state_t is
)
2714 struct cleanup
*old_chain
;
2716 /* BL is never in moribund_locations by our callers. */
2717 gdb_assert (bl
->owner
!= NULL
);
2719 if (bl
->owner
->enable_state
== bp_permanent
)
2720 /* Permanent breakpoints cannot be inserted or removed. */
2723 /* The type of none suggests that owner is actually deleted.
2724 This should not ever happen. */
2725 gdb_assert (bl
->owner
->type
!= bp_none
);
2727 old_chain
= save_current_space_and_thread ();
2729 switch_to_program_space_and_thread (bl
->pspace
);
2731 ret
= remove_breakpoint_1 (bl
, is
);
2733 do_cleanups (old_chain
);
2737 /* Clear the "inserted" flag in all breakpoints. */
2740 mark_breakpoints_out (void)
2742 struct bp_location
*bl
, **blp_tmp
;
2744 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2745 if (bl
->pspace
== current_program_space
)
2749 /* Clear the "inserted" flag in all breakpoints and delete any
2750 breakpoints which should go away between runs of the program.
2752 Plus other such housekeeping that has to be done for breakpoints
2755 Note: this function gets called at the end of a run (by
2756 generic_mourn_inferior) and when a run begins (by
2757 init_wait_for_inferior). */
2762 breakpoint_init_inferior (enum inf_context context
)
2764 struct breakpoint
*b
, *b_tmp
;
2765 struct bp_location
*bl
, **blp_tmp
;
2767 struct program_space
*pspace
= current_program_space
;
2769 /* If breakpoint locations are shared across processes, then there's
2771 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2774 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2776 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2777 if (bl
->pspace
== pspace
2778 && bl
->owner
->enable_state
!= bp_permanent
)
2782 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
2784 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
2791 /* If the call dummy breakpoint is at the entry point it will
2792 cause problems when the inferior is rerun, so we better get
2795 case bp_watchpoint_scope
:
2797 /* Also get rid of scope breakpoints. */
2799 case bp_shlib_event
:
2801 /* Also remove solib event breakpoints. Their addresses may
2802 have changed since the last time we ran the program.
2803 Actually we may now be debugging against different target;
2804 and so the solib backend that installed this breakpoint may
2805 not be used in by the target. E.g.,
2807 (gdb) file prog-linux
2808 (gdb) run # native linux target
2811 (gdb) file prog-win.exe
2812 (gdb) tar rem :9999 # remote Windows gdbserver.
2815 delete_breakpoint (b
);
2819 case bp_hardware_watchpoint
:
2820 case bp_read_watchpoint
:
2821 case bp_access_watchpoint
:
2823 struct watchpoint
*w
= (struct watchpoint
*) b
;
2825 /* Likewise for watchpoints on local expressions. */
2826 if (w
->exp_valid_block
!= NULL
)
2827 delete_breakpoint (b
);
2828 else if (context
== inf_starting
)
2830 /* Reset val field to force reread of starting value in
2831 insert_breakpoints. */
2833 value_free (w
->val
);
2844 /* Get rid of the moribund locations. */
2845 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
2846 decref_bp_location (&bl
);
2847 VEC_free (bp_location_p
, moribund_locations
);
2850 /* These functions concern about actual breakpoints inserted in the
2851 target --- to e.g. check if we need to do decr_pc adjustment or if
2852 we need to hop over the bkpt --- so we check for address space
2853 match, not program space. */
2855 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2856 exists at PC. It returns ordinary_breakpoint_here if it's an
2857 ordinary breakpoint, or permanent_breakpoint_here if it's a
2858 permanent breakpoint.
2859 - When continuing from a location with an ordinary breakpoint, we
2860 actually single step once before calling insert_breakpoints.
2861 - When continuing from a location with a permanent breakpoint, we
2862 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2863 the target, to advance the PC past the breakpoint. */
2865 enum breakpoint_here
2866 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2868 struct bp_location
*bl
, **blp_tmp
;
2869 int any_breakpoint_here
= 0;
2871 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2873 if (bl
->loc_type
!= bp_loc_software_breakpoint
2874 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2877 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2878 if ((breakpoint_enabled (bl
->owner
)
2879 || bl
->owner
->enable_state
== bp_permanent
)
2880 && breakpoint_location_address_match (bl
, aspace
, pc
))
2882 if (overlay_debugging
2883 && section_is_overlay (bl
->section
)
2884 && !section_is_mapped (bl
->section
))
2885 continue; /* unmapped overlay -- can't be a match */
2886 else if (bl
->owner
->enable_state
== bp_permanent
)
2887 return permanent_breakpoint_here
;
2889 any_breakpoint_here
= 1;
2893 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
2896 /* Return true if there's a moribund breakpoint at PC. */
2899 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2901 struct bp_location
*loc
;
2904 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2905 if (breakpoint_location_address_match (loc
, aspace
, pc
))
2911 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2912 inserted using regular breakpoint_chain / bp_location array
2913 mechanism. This does not check for single-step breakpoints, which
2914 are inserted and removed using direct target manipulation. */
2917 regular_breakpoint_inserted_here_p (struct address_space
*aspace
,
2920 struct bp_location
*bl
, **blp_tmp
;
2922 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2924 if (bl
->loc_type
!= bp_loc_software_breakpoint
2925 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
2929 && breakpoint_location_address_match (bl
, aspace
, pc
))
2931 if (overlay_debugging
2932 && section_is_overlay (bl
->section
)
2933 && !section_is_mapped (bl
->section
))
2934 continue; /* unmapped overlay -- can't be a match */
2942 /* Returns non-zero iff there's either regular breakpoint
2943 or a single step breakpoint inserted at PC. */
2946 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
2948 if (regular_breakpoint_inserted_here_p (aspace
, pc
))
2951 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2957 /* This function returns non-zero iff there is a software breakpoint
2961 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
2964 struct bp_location
*bl
, **blp_tmp
;
2966 ALL_BP_LOCATIONS (bl
, blp_tmp
)
2968 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
2972 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
2975 if (overlay_debugging
2976 && section_is_overlay (bl
->section
)
2977 && !section_is_mapped (bl
->section
))
2978 continue; /* unmapped overlay -- can't be a match */
2984 /* Also check for software single-step breakpoints. */
2985 if (single_step_breakpoint_inserted_here_p (aspace
, pc
))
2992 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
2993 CORE_ADDR addr
, ULONGEST len
)
2995 struct breakpoint
*bpt
;
2997 ALL_BREAKPOINTS (bpt
)
2999 struct bp_location
*loc
;
3001 if (bpt
->type
!= bp_hardware_watchpoint
3002 && bpt
->type
!= bp_access_watchpoint
)
3005 if (!breakpoint_enabled (bpt
))
3008 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3009 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
3013 /* Check for intersection. */
3014 l
= max (loc
->address
, addr
);
3015 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
3023 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
3024 PC is valid for process/thread PTID. */
3027 breakpoint_thread_match (struct address_space
*aspace
, CORE_ADDR pc
,
3030 struct bp_location
*bl
, **blp_tmp
;
3031 /* The thread and task IDs associated to PTID, computed lazily. */
3035 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3037 if (bl
->loc_type
!= bp_loc_software_breakpoint
3038 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
3041 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
3042 if (!breakpoint_enabled (bl
->owner
)
3043 && bl
->owner
->enable_state
!= bp_permanent
)
3046 if (!breakpoint_location_address_match (bl
, aspace
, pc
))
3049 if (bl
->owner
->thread
!= -1)
3051 /* This is a thread-specific breakpoint. Check that ptid
3052 matches that thread. If thread hasn't been computed yet,
3053 it is now time to do so. */
3055 thread
= pid_to_thread_id (ptid
);
3056 if (bl
->owner
->thread
!= thread
)
3060 if (bl
->owner
->task
!= 0)
3062 /* This is a task-specific breakpoint. Check that ptid
3063 matches that task. If task hasn't been computed yet,
3064 it is now time to do so. */
3066 task
= ada_get_task_number (ptid
);
3067 if (bl
->owner
->task
!= task
)
3071 if (overlay_debugging
3072 && section_is_overlay (bl
->section
)
3073 && !section_is_mapped (bl
->section
))
3074 continue; /* unmapped overlay -- can't be a match */
3083 /* bpstat stuff. External routines' interfaces are documented
3087 ep_is_catchpoint (struct breakpoint
*ep
)
3089 return (ep
->type
== bp_catchpoint
);
3092 /* Frees any storage that is part of a bpstat. Does not walk the
3096 bpstat_free (bpstat bs
)
3098 if (bs
->old_val
!= NULL
)
3099 value_free (bs
->old_val
);
3100 decref_counted_command_line (&bs
->commands
);
3101 decref_bp_location (&bs
->bp_location_at
);
3105 /* Clear a bpstat so that it says we are not at any breakpoint.
3106 Also free any storage that is part of a bpstat. */
3109 bpstat_clear (bpstat
*bsp
)
3126 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
3127 is part of the bpstat is copied as well. */
3130 bpstat_copy (bpstat bs
)
3134 bpstat retval
= NULL
;
3139 for (; bs
!= NULL
; bs
= bs
->next
)
3141 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
3142 memcpy (tmp
, bs
, sizeof (*tmp
));
3143 incref_counted_command_line (tmp
->commands
);
3144 incref_bp_location (tmp
->bp_location_at
);
3145 if (bs
->old_val
!= NULL
)
3147 tmp
->old_val
= value_copy (bs
->old_val
);
3148 release_value (tmp
->old_val
);
3152 /* This is the first thing in the chain. */
3162 /* Find the bpstat associated with this breakpoint. */
3165 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
3170 for (; bsp
!= NULL
; bsp
= bsp
->next
)
3172 if (bsp
->breakpoint_at
== breakpoint
)
3178 /* Put in *NUM the breakpoint number of the first breakpoint we are
3179 stopped at. *BSP upon return is a bpstat which points to the
3180 remaining breakpoints stopped at (but which is not guaranteed to be
3181 good for anything but further calls to bpstat_num).
3183 Return 0 if passed a bpstat which does not indicate any breakpoints.
3184 Return -1 if stopped at a breakpoint that has been deleted since
3186 Return 1 otherwise. */
3189 bpstat_num (bpstat
*bsp
, int *num
)
3191 struct breakpoint
*b
;
3194 return 0; /* No more breakpoint values */
3196 /* We assume we'll never have several bpstats that correspond to a
3197 single breakpoint -- otherwise, this function might return the
3198 same number more than once and this will look ugly. */
3199 b
= (*bsp
)->breakpoint_at
;
3200 *bsp
= (*bsp
)->next
;
3202 return -1; /* breakpoint that's been deleted since */
3204 *num
= b
->number
; /* We have its number */
3208 /* See breakpoint.h. */
3211 bpstat_clear_actions (void)
3213 struct thread_info
*tp
;
3216 if (ptid_equal (inferior_ptid
, null_ptid
))
3219 tp
= find_thread_ptid (inferior_ptid
);
3223 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
3225 decref_counted_command_line (&bs
->commands
);
3227 if (bs
->old_val
!= NULL
)
3229 value_free (bs
->old_val
);
3235 /* Called when a command is about to proceed the inferior. */
3238 breakpoint_about_to_proceed (void)
3240 if (!ptid_equal (inferior_ptid
, null_ptid
))
3242 struct thread_info
*tp
= inferior_thread ();
3244 /* Allow inferior function calls in breakpoint commands to not
3245 interrupt the command list. When the call finishes
3246 successfully, the inferior will be standing at the same
3247 breakpoint as if nothing happened. */
3248 if (tp
->control
.in_infcall
)
3252 breakpoint_proceeded
= 1;
3255 /* Stub for cleaning up our state if we error-out of a breakpoint
3258 cleanup_executing_breakpoints (void *ignore
)
3260 executing_breakpoint_commands
= 0;
3263 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
3264 or its equivalent. */
3267 command_line_is_silent (struct command_line
*cmd
)
3269 return cmd
&& (strcmp ("silent", cmd
->line
) == 0
3270 || (xdb_commands
&& strcmp ("Q", cmd
->line
) == 0));
3273 /* Execute all the commands associated with all the breakpoints at
3274 this location. Any of these commands could cause the process to
3275 proceed beyond this point, etc. We look out for such changes by
3276 checking the global "breakpoint_proceeded" after each command.
3278 Returns true if a breakpoint command resumed the inferior. In that
3279 case, it is the caller's responsibility to recall it again with the
3280 bpstat of the current thread. */
3283 bpstat_do_actions_1 (bpstat
*bsp
)
3286 struct cleanup
*old_chain
;
3289 /* Avoid endless recursion if a `source' command is contained
3291 if (executing_breakpoint_commands
)
3294 executing_breakpoint_commands
= 1;
3295 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
3297 prevent_dont_repeat ();
3299 /* This pointer will iterate over the list of bpstat's. */
3302 breakpoint_proceeded
= 0;
3303 for (; bs
!= NULL
; bs
= bs
->next
)
3305 struct counted_command_line
*ccmd
;
3306 struct command_line
*cmd
;
3307 struct cleanup
*this_cmd_tree_chain
;
3309 /* Take ownership of the BSP's command tree, if it has one.
3311 The command tree could legitimately contain commands like
3312 'step' and 'next', which call clear_proceed_status, which
3313 frees stop_bpstat's command tree. To make sure this doesn't
3314 free the tree we're executing out from under us, we need to
3315 take ownership of the tree ourselves. Since a given bpstat's
3316 commands are only executed once, we don't need to copy it; we
3317 can clear the pointer in the bpstat, and make sure we free
3318 the tree when we're done. */
3319 ccmd
= bs
->commands
;
3320 bs
->commands
= NULL
;
3321 this_cmd_tree_chain
= make_cleanup_decref_counted_command_line (&ccmd
);
3322 cmd
= ccmd
? ccmd
->commands
: NULL
;
3323 if (command_line_is_silent (cmd
))
3325 /* The action has been already done by bpstat_stop_status. */
3331 execute_control_command (cmd
);
3333 if (breakpoint_proceeded
)
3339 /* We can free this command tree now. */
3340 do_cleanups (this_cmd_tree_chain
);
3342 if (breakpoint_proceeded
)
3344 if (target_can_async_p ())
3345 /* If we are in async mode, then the target might be still
3346 running, not stopped at any breakpoint, so nothing for
3347 us to do here -- just return to the event loop. */
3350 /* In sync mode, when execute_control_command returns
3351 we're already standing on the next breakpoint.
3352 Breakpoint commands for that stop were not run, since
3353 execute_command does not run breakpoint commands --
3354 only command_line_handler does, but that one is not
3355 involved in execution of breakpoint commands. So, we
3356 can now execute breakpoint commands. It should be
3357 noted that making execute_command do bpstat actions is
3358 not an option -- in this case we'll have recursive
3359 invocation of bpstat for each breakpoint with a
3360 command, and can easily blow up GDB stack. Instead, we
3361 return true, which will trigger the caller to recall us
3362 with the new stop_bpstat. */
3367 do_cleanups (old_chain
);
3372 bpstat_do_actions (void)
3374 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
3376 /* Do any commands attached to breakpoint we are stopped at. */
3377 while (!ptid_equal (inferior_ptid
, null_ptid
)
3378 && target_has_execution
3379 && !is_exited (inferior_ptid
)
3380 && !is_executing (inferior_ptid
))
3381 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3382 and only return when it is stopped at the next breakpoint, we
3383 keep doing breakpoint actions until it returns false to
3384 indicate the inferior was not resumed. */
3385 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
3388 discard_cleanups (cleanup_if_error
);
3391 /* Print out the (old or new) value associated with a watchpoint. */
3394 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
3397 fprintf_unfiltered (stream
, _("<unreadable>"));
3400 struct value_print_options opts
;
3401 get_user_print_options (&opts
);
3402 value_print (val
, stream
, &opts
);
3406 /* Generic routine for printing messages indicating why we
3407 stopped. The behavior of this function depends on the value
3408 'print_it' in the bpstat structure. Under some circumstances we
3409 may decide not to print anything here and delegate the task to
3412 static enum print_stop_action
3413 print_bp_stop_message (bpstat bs
)
3415 switch (bs
->print_it
)
3418 /* Nothing should be printed for this bpstat entry. */
3419 return PRINT_UNKNOWN
;
3423 /* We still want to print the frame, but we already printed the
3424 relevant messages. */
3425 return PRINT_SRC_AND_LOC
;
3428 case print_it_normal
:
3430 struct breakpoint
*b
= bs
->breakpoint_at
;
3432 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3433 which has since been deleted. */
3435 return PRINT_UNKNOWN
;
3437 /* Normal case. Call the breakpoint's print_it method. */
3438 return b
->ops
->print_it (bs
);
3443 internal_error (__FILE__
, __LINE__
,
3444 _("print_bp_stop_message: unrecognized enum value"));
3449 /* Print a message indicating what happened. This is called from
3450 normal_stop(). The input to this routine is the head of the bpstat
3451 list - a list of the eventpoints that caused this stop. KIND is
3452 the target_waitkind for the stopping event. This
3453 routine calls the generic print routine for printing a message
3454 about reasons for stopping. This will print (for example) the
3455 "Breakpoint n," part of the output. The return value of this
3458 PRINT_UNKNOWN: Means we printed nothing.
3459 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3460 code to print the location. An example is
3461 "Breakpoint 1, " which should be followed by
3463 PRINT_SRC_ONLY: Means we printed something, but there is no need
3464 to also print the location part of the message.
3465 An example is the catch/throw messages, which
3466 don't require a location appended to the end.
3467 PRINT_NOTHING: We have done some printing and we don't need any
3468 further info to be printed. */
3470 enum print_stop_action
3471 bpstat_print (bpstat bs
, int kind
)
3475 /* Maybe another breakpoint in the chain caused us to stop.
3476 (Currently all watchpoints go on the bpstat whether hit or not.
3477 That probably could (should) be changed, provided care is taken
3478 with respect to bpstat_explains_signal). */
3479 for (; bs
; bs
= bs
->next
)
3481 val
= print_bp_stop_message (bs
);
3482 if (val
== PRINT_SRC_ONLY
3483 || val
== PRINT_SRC_AND_LOC
3484 || val
== PRINT_NOTHING
)
3488 /* If we had hit a shared library event breakpoint,
3489 print_bp_stop_message would print out this message. If we hit an
3490 OS-level shared library event, do the same thing. */
3491 if (kind
== TARGET_WAITKIND_LOADED
)
3493 ui_out_text (current_uiout
, _("Stopped due to shared library event\n"));
3494 if (ui_out_is_mi_like_p (current_uiout
))
3495 ui_out_field_string (current_uiout
, "reason",
3496 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
3497 return PRINT_NOTHING
;
3500 /* We reached the end of the chain, or we got a null BS to start
3501 with and nothing was printed. */
3502 return PRINT_UNKNOWN
;
3505 /* Evaluate the expression EXP and return 1 if value is zero. This is
3506 used inside a catch_errors to evaluate the breakpoint condition.
3507 The argument is a "struct expression *" that has been cast to a
3508 "char *" to make it pass through catch_errors. */
3511 breakpoint_cond_eval (void *exp
)
3513 struct value
*mark
= value_mark ();
3514 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
3516 value_free_to_mark (mark
);
3520 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
3523 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
3527 bs
= (bpstat
) xmalloc (sizeof (*bs
));
3529 **bs_link_pointer
= bs
;
3530 *bs_link_pointer
= &bs
->next
;
3531 bs
->breakpoint_at
= bl
->owner
;
3532 bs
->bp_location_at
= bl
;
3533 incref_bp_location (bl
);
3534 /* If the condition is false, etc., don't do the commands. */
3535 bs
->commands
= NULL
;
3537 bs
->print_it
= print_it_normal
;
3541 /* The target has stopped with waitstatus WS. Check if any hardware
3542 watchpoints have triggered, according to the target. */
3545 watchpoints_triggered (struct target_waitstatus
*ws
)
3547 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
3549 struct breakpoint
*b
;
3551 if (!stopped_by_watchpoint
)
3553 /* We were not stopped by a watchpoint. Mark all watchpoints
3554 as not triggered. */
3556 if (is_hardware_watchpoint (b
))
3558 struct watchpoint
*w
= (struct watchpoint
*) b
;
3560 w
->watchpoint_triggered
= watch_triggered_no
;
3566 if (!target_stopped_data_address (¤t_target
, &addr
))
3568 /* We were stopped by a watchpoint, but we don't know where.
3569 Mark all watchpoints as unknown. */
3571 if (is_hardware_watchpoint (b
))
3573 struct watchpoint
*w
= (struct watchpoint
*) b
;
3575 w
->watchpoint_triggered
= watch_triggered_unknown
;
3578 return stopped_by_watchpoint
;
3581 /* The target could report the data address. Mark watchpoints
3582 affected by this data address as triggered, and all others as not
3586 if (is_hardware_watchpoint (b
))
3588 struct watchpoint
*w
= (struct watchpoint
*) b
;
3589 struct bp_location
*loc
;
3591 w
->watchpoint_triggered
= watch_triggered_no
;
3592 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3594 if (is_masked_watchpoint (b
))
3596 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
3597 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
3599 if (newaddr
== start
)
3601 w
->watchpoint_triggered
= watch_triggered_yes
;
3605 /* Exact match not required. Within range is sufficient. */
3606 else if (target_watchpoint_addr_within_range (¤t_target
,
3610 w
->watchpoint_triggered
= watch_triggered_yes
;
3619 /* Possible return values for watchpoint_check (this can't be an enum
3620 because of check_errors). */
3621 /* The watchpoint has been deleted. */
3622 #define WP_DELETED 1
3623 /* The value has changed. */
3624 #define WP_VALUE_CHANGED 2
3625 /* The value has not changed. */
3626 #define WP_VALUE_NOT_CHANGED 3
3627 /* Ignore this watchpoint, no matter if the value changed or not. */
3630 #define BP_TEMPFLAG 1
3631 #define BP_HARDWAREFLAG 2
3633 /* Evaluate watchpoint condition expression and check if its value
3636 P should be a pointer to struct bpstat, but is defined as a void *
3637 in order for this function to be usable with catch_errors. */
3640 watchpoint_check (void *p
)
3642 bpstat bs
= (bpstat
) p
;
3643 struct watchpoint
*b
;
3644 struct frame_info
*fr
;
3645 int within_current_scope
;
3647 /* BS is built from an existing struct breakpoint. */
3648 gdb_assert (bs
->breakpoint_at
!= NULL
);
3649 b
= (struct watchpoint
*) bs
->breakpoint_at
;
3651 /* If this is a local watchpoint, we only want to check if the
3652 watchpoint frame is in scope if the current thread is the thread
3653 that was used to create the watchpoint. */
3654 if (!watchpoint_in_thread_scope (b
))
3657 if (b
->exp_valid_block
== NULL
)
3658 within_current_scope
= 1;
3661 struct frame_info
*frame
= get_current_frame ();
3662 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
3663 CORE_ADDR frame_pc
= get_frame_pc (frame
);
3665 /* in_function_epilogue_p() returns a non-zero value if we're
3666 still in the function but the stack frame has already been
3667 invalidated. Since we can't rely on the values of local
3668 variables after the stack has been destroyed, we are treating
3669 the watchpoint in that state as `not changed' without further
3670 checking. Don't mark watchpoints as changed if the current
3671 frame is in an epilogue - even if they are in some other
3672 frame, our view of the stack is likely to be wrong and
3673 frame_find_by_id could error out. */
3674 if (gdbarch_in_function_epilogue_p (frame_arch
, frame_pc
))
3677 fr
= frame_find_by_id (b
->watchpoint_frame
);
3678 within_current_scope
= (fr
!= NULL
);
3680 /* If we've gotten confused in the unwinder, we might have
3681 returned a frame that can't describe this variable. */
3682 if (within_current_scope
)
3684 struct symbol
*function
;
3686 function
= get_frame_function (fr
);
3687 if (function
== NULL
3688 || !contained_in (b
->exp_valid_block
,
3689 SYMBOL_BLOCK_VALUE (function
)))
3690 within_current_scope
= 0;
3693 if (within_current_scope
)
3694 /* If we end up stopping, the current frame will get selected
3695 in normal_stop. So this call to select_frame won't affect
3700 if (within_current_scope
)
3702 /* We use value_{,free_to_}mark because it could be a *long*
3703 time before we return to the command level and call
3704 free_all_values. We can't call free_all_values because we
3705 might be in the middle of evaluating a function call. */
3709 struct value
*new_val
;
3711 if (is_masked_watchpoint (&b
->base
))
3712 /* Since we don't know the exact trigger address (from
3713 stopped_data_address), just tell the user we've triggered
3714 a mask watchpoint. */
3715 return WP_VALUE_CHANGED
;
3717 mark
= value_mark ();
3718 fetch_subexp_value (b
->exp
, &pc
, &new_val
, NULL
, NULL
);
3720 /* We use value_equal_contents instead of value_equal because
3721 the latter coerces an array to a pointer, thus comparing just
3722 the address of the array instead of its contents. This is
3723 not what we want. */
3724 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
3725 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
3727 if (new_val
!= NULL
)
3729 release_value (new_val
);
3730 value_free_to_mark (mark
);
3732 bs
->old_val
= b
->val
;
3735 return WP_VALUE_CHANGED
;
3739 /* Nothing changed. */
3740 value_free_to_mark (mark
);
3741 return WP_VALUE_NOT_CHANGED
;
3746 struct ui_out
*uiout
= current_uiout
;
3748 /* This seems like the only logical thing to do because
3749 if we temporarily ignored the watchpoint, then when
3750 we reenter the block in which it is valid it contains
3751 garbage (in the case of a function, it may have two
3752 garbage values, one before and one after the prologue).
3753 So we can't even detect the first assignment to it and
3754 watch after that (since the garbage may or may not equal
3755 the first value assigned). */
3756 /* We print all the stop information in
3757 breakpoint_ops->print_it, but in this case, by the time we
3758 call breakpoint_ops->print_it this bp will be deleted
3759 already. So we have no choice but print the information
3761 if (ui_out_is_mi_like_p (uiout
))
3763 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
3764 ui_out_text (uiout
, "\nWatchpoint ");
3765 ui_out_field_int (uiout
, "wpnum", b
->base
.number
);
3767 " deleted because the program has left the block in\n\
3768 which its expression is valid.\n");
3770 /* Make sure the watchpoint's commands aren't executed. */
3771 decref_counted_command_line (&b
->base
.commands
);
3772 watchpoint_del_at_next_stop (b
);
3778 /* Return true if it looks like target has stopped due to hitting
3779 breakpoint location BL. This function does not check if we should
3780 stop, only if BL explains the stop. */
3783 bpstat_check_location (const struct bp_location
*bl
,
3784 struct address_space
*aspace
, CORE_ADDR bp_addr
)
3786 struct breakpoint
*b
= bl
->owner
;
3788 /* BL is from an existing breakpoint. */
3789 gdb_assert (b
!= NULL
);
3791 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
);
3794 /* Determine if the watched values have actually changed, and we
3795 should stop. If not, set BS->stop to 0. */
3798 bpstat_check_watchpoint (bpstat bs
)
3800 const struct bp_location
*bl
;
3801 struct watchpoint
*b
;
3803 /* BS is built for existing struct breakpoint. */
3804 bl
= bs
->bp_location_at
;
3805 gdb_assert (bl
!= NULL
);
3806 b
= (struct watchpoint
*) bs
->breakpoint_at
;
3807 gdb_assert (b
!= NULL
);
3810 int must_check_value
= 0;
3812 if (b
->base
.type
== bp_watchpoint
)
3813 /* For a software watchpoint, we must always check the
3815 must_check_value
= 1;
3816 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
3817 /* We have a hardware watchpoint (read, write, or access)
3818 and the target earlier reported an address watched by
3820 must_check_value
= 1;
3821 else if (b
->watchpoint_triggered
== watch_triggered_unknown
3822 && b
->base
.type
== bp_hardware_watchpoint
)
3823 /* We were stopped by a hardware watchpoint, but the target could
3824 not report the data address. We must check the watchpoint's
3825 value. Access and read watchpoints are out of luck; without
3826 a data address, we can't figure it out. */
3827 must_check_value
= 1;
3829 if (must_check_value
)
3832 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3834 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
3835 int e
= catch_errors (watchpoint_check
, bs
, message
,
3837 do_cleanups (cleanups
);
3841 /* We've already printed what needs to be printed. */
3842 bs
->print_it
= print_it_done
;
3846 bs
->print_it
= print_it_noop
;
3849 case WP_VALUE_CHANGED
:
3850 if (b
->base
.type
== bp_read_watchpoint
)
3852 /* There are two cases to consider here:
3854 1. We're watching the triggered memory for reads.
3855 In that case, trust the target, and always report
3856 the watchpoint hit to the user. Even though
3857 reads don't cause value changes, the value may
3858 have changed since the last time it was read, and
3859 since we're not trapping writes, we will not see
3860 those, and as such we should ignore our notion of
3863 2. We're watching the triggered memory for both
3864 reads and writes. There are two ways this may
3867 2.1. This is a target that can't break on data
3868 reads only, but can break on accesses (reads or
3869 writes), such as e.g., x86. We detect this case
3870 at the time we try to insert read watchpoints.
3872 2.2. Otherwise, the target supports read
3873 watchpoints, but, the user set an access or write
3874 watchpoint watching the same memory as this read
3877 If we're watching memory writes as well as reads,
3878 ignore watchpoint hits when we find that the
3879 value hasn't changed, as reads don't cause
3880 changes. This still gives false positives when
3881 the program writes the same value to memory as
3882 what there was already in memory (we will confuse
3883 it for a read), but it's much better than
3886 int other_write_watchpoint
= 0;
3888 if (bl
->watchpoint_type
== hw_read
)
3890 struct breakpoint
*other_b
;
3892 ALL_BREAKPOINTS (other_b
)
3893 if (other_b
->type
== bp_hardware_watchpoint
3894 || other_b
->type
== bp_access_watchpoint
)
3896 struct watchpoint
*other_w
=
3897 (struct watchpoint
*) other_b
;
3899 if (other_w
->watchpoint_triggered
3900 == watch_triggered_yes
)
3902 other_write_watchpoint
= 1;
3908 if (other_write_watchpoint
3909 || bl
->watchpoint_type
== hw_access
)
3911 /* We're watching the same memory for writes,
3912 and the value changed since the last time we
3913 updated it, so this trap must be for a write.
3915 bs
->print_it
= print_it_noop
;
3920 case WP_VALUE_NOT_CHANGED
:
3921 if (b
->base
.type
== bp_hardware_watchpoint
3922 || b
->base
.type
== bp_watchpoint
)
3924 /* Don't stop: write watchpoints shouldn't fire if
3925 the value hasn't changed. */
3926 bs
->print_it
= print_it_noop
;
3934 /* Error from catch_errors. */
3935 printf_filtered (_("Watchpoint %d deleted.\n"), b
->base
.number
);
3936 watchpoint_del_at_next_stop (b
);
3937 /* We've already printed what needs to be printed. */
3938 bs
->print_it
= print_it_done
;
3942 else /* must_check_value == 0 */
3944 /* This is a case where some watchpoint(s) triggered, but
3945 not at the address of this watchpoint, or else no
3946 watchpoint triggered after all. So don't print
3947 anything for this watchpoint. */
3948 bs
->print_it
= print_it_noop
;
3955 /* Check conditions (condition proper, frame, thread and ignore count)
3956 of breakpoint referred to by BS. If we should not stop for this
3957 breakpoint, set BS->stop to 0. */
3960 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
3962 int thread_id
= pid_to_thread_id (ptid
);
3963 const struct bp_location
*bl
;
3964 struct breakpoint
*b
;
3966 /* BS is built for existing struct breakpoint. */
3967 bl
= bs
->bp_location_at
;
3968 gdb_assert (bl
!= NULL
);
3969 b
= bs
->breakpoint_at
;
3970 gdb_assert (b
!= NULL
);
3972 if (frame_id_p (b
->frame_id
)
3973 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
3977 int value_is_zero
= 0;
3978 struct expression
*cond
;
3980 /* Evaluate Python breakpoints that have a "stop"
3981 method implemented. */
3982 if (b
->py_bp_object
)
3983 bs
->stop
= gdbpy_should_stop (b
->py_bp_object
);
3985 if (is_watchpoint (b
))
3987 struct watchpoint
*w
= (struct watchpoint
*) b
;
3994 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
3996 int within_current_scope
= 1;
3997 struct watchpoint
* w
;
3999 /* We use value_mark and value_free_to_mark because it could
4000 be a long time before we return to the command level and
4001 call free_all_values. We can't call free_all_values
4002 because we might be in the middle of evaluating a
4004 struct value
*mark
= value_mark ();
4006 if (is_watchpoint (b
))
4007 w
= (struct watchpoint
*) b
;
4011 /* Need to select the frame, with all that implies so that
4012 the conditions will have the right context. Because we
4013 use the frame, we will not see an inlined function's
4014 variables when we arrive at a breakpoint at the start
4015 of the inlined function; the current frame will be the
4017 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
4018 select_frame (get_current_frame ());
4021 struct frame_info
*frame
;
4023 /* For local watchpoint expressions, which particular
4024 instance of a local is being watched matters, so we
4025 keep track of the frame to evaluate the expression
4026 in. To evaluate the condition however, it doesn't
4027 really matter which instantiation of the function
4028 where the condition makes sense triggers the
4029 watchpoint. This allows an expression like "watch
4030 global if q > 10" set in `func', catch writes to
4031 global on all threads that call `func', or catch
4032 writes on all recursive calls of `func' by a single
4033 thread. We simply always evaluate the condition in
4034 the innermost frame that's executing where it makes
4035 sense to evaluate the condition. It seems
4037 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
4039 select_frame (frame
);
4041 within_current_scope
= 0;
4043 if (within_current_scope
)
4045 = catch_errors (breakpoint_cond_eval
, cond
,
4046 "Error in testing breakpoint condition:\n",
4050 warning (_("Watchpoint condition cannot be tested "
4051 "in the current scope"));
4052 /* If we failed to set the right context for this
4053 watchpoint, unconditionally report it. */
4056 /* FIXME-someday, should give breakpoint #. */
4057 value_free_to_mark (mark
);
4060 if (cond
&& value_is_zero
)
4064 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
4068 else if (b
->ignore_count
> 0)
4071 annotate_ignore_count_change ();
4073 /* Increase the hit count even though we don't stop. */
4075 observer_notify_breakpoint_modified (b
);
4081 /* Get a bpstat associated with having just stopped at address
4082 BP_ADDR in thread PTID.
4084 Determine whether we stopped at a breakpoint, etc, or whether we
4085 don't understand this stop. Result is a chain of bpstat's such
4088 if we don't understand the stop, the result is a null pointer.
4090 if we understand why we stopped, the result is not null.
4092 Each element of the chain refers to a particular breakpoint or
4093 watchpoint at which we have stopped. (We may have stopped for
4094 several reasons concurrently.)
4096 Each element of the chain has valid next, breakpoint_at,
4097 commands, FIXME??? fields. */
4100 bpstat_stop_status (struct address_space
*aspace
,
4101 CORE_ADDR bp_addr
, ptid_t ptid
)
4103 struct breakpoint
*b
= NULL
;
4104 struct bp_location
*bl
;
4105 struct bp_location
*loc
;
4106 /* First item of allocated bpstat's. */
4107 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
4108 /* Pointer to the last thing in the chain currently. */
4111 int need_remove_insert
;
4114 /* First, build the bpstat chain with locations that explain a
4115 target stop, while being careful to not set the target running,
4116 as that may invalidate locations (in particular watchpoint
4117 locations are recreated). Resuming will happen here with
4118 breakpoint conditions or watchpoint expressions that include
4119 inferior function calls. */
4123 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
4126 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
4128 /* For hardware watchpoints, we look only at the first
4129 location. The watchpoint_check function will work on the
4130 entire expression, not the individual locations. For
4131 read watchpoints, the watchpoints_triggered function has
4132 checked all locations already. */
4133 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
4136 if (bl
->shlib_disabled
)
4139 if (!bpstat_check_location (bl
, aspace
, bp_addr
))
4142 /* Come here if it's a watchpoint, or if the break address
4145 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
4148 /* Assume we stop. Should we find a watchpoint that is not
4149 actually triggered, or if the condition of the breakpoint
4150 evaluates as false, we'll reset 'stop' to 0. */
4154 /* If this is a scope breakpoint, mark the associated
4155 watchpoint as triggered so that we will handle the
4156 out-of-scope event. We'll get to the watchpoint next
4158 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
4160 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
4162 w
->watchpoint_triggered
= watch_triggered_yes
;
4167 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4169 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
))
4171 bs
= bpstat_alloc (loc
, &bs_link
);
4172 /* For hits of moribund locations, we should just proceed. */
4175 bs
->print_it
= print_it_noop
;
4179 /* Now go through the locations that caused the target to stop, and
4180 check whether we're interested in reporting this stop to higher
4181 layers, or whether we should resume the target transparently. */
4185 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4190 b
= bs
->breakpoint_at
;
4191 b
->ops
->check_status (bs
);
4194 bpstat_check_breakpoint_conditions (bs
, ptid
);
4199 observer_notify_breakpoint_modified (b
);
4201 /* We will stop here. */
4202 if (b
->disposition
== disp_disable
)
4204 if (b
->enable_state
!= bp_permanent
)
4205 b
->enable_state
= bp_disabled
;
4210 bs
->commands
= b
->commands
;
4211 incref_counted_command_line (bs
->commands
);
4212 if (command_line_is_silent (bs
->commands
4213 ? bs
->commands
->commands
: NULL
))
4217 /* Print nothing for this entry if we don't stop or don't print. */
4218 if (bs
->stop
== 0 || bs
->print
== 0)
4219 bs
->print_it
= print_it_noop
;
4223 /* If we aren't stopping, the value of some hardware watchpoint may
4224 not have changed, but the intermediate memory locations we are
4225 watching may have. Don't bother if we're stopping; this will get
4227 need_remove_insert
= 0;
4228 if (! bpstat_causes_stop (bs_head
))
4229 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4231 && bs
->breakpoint_at
4232 && is_hardware_watchpoint (bs
->breakpoint_at
))
4234 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
4236 update_watchpoint (w
, 0 /* don't reparse. */);
4237 need_remove_insert
= 1;
4240 if (need_remove_insert
)
4241 update_global_location_list (1);
4242 else if (removed_any
)
4243 update_global_location_list (0);
4249 handle_jit_event (void)
4251 struct frame_info
*frame
;
4252 struct gdbarch
*gdbarch
;
4254 /* Switch terminal for any messages produced by
4255 breakpoint_re_set. */
4256 target_terminal_ours_for_output ();
4258 frame
= get_current_frame ();
4259 gdbarch
= get_frame_arch (frame
);
4261 jit_event_handler (gdbarch
);
4263 target_terminal_inferior ();
4266 /* Prepare WHAT final decision for infrun. */
4268 /* Decide what infrun needs to do with this bpstat. */
4271 bpstat_what (bpstat bs_head
)
4273 struct bpstat_what retval
;
4274 /* We need to defer calling `solib_add', as adding new symbols
4275 resets breakpoints, which in turn deletes breakpoint locations,
4276 and hence may clear unprocessed entries in the BS chain. */
4277 int shlib_event
= 0;
4281 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4282 retval
.call_dummy
= STOP_NONE
;
4283 retval
.is_longjmp
= 0;
4285 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4287 /* Extract this BS's action. After processing each BS, we check
4288 if its action overrides all we've seem so far. */
4289 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4292 if (bs
->breakpoint_at
== NULL
)
4294 /* I suspect this can happen if it was a momentary
4295 breakpoint which has since been deleted. */
4299 bptype
= bs
->breakpoint_at
->type
;
4306 case bp_hardware_breakpoint
:
4312 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4314 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4317 this_action
= BPSTAT_WHAT_SINGLE
;
4320 case bp_hardware_watchpoint
:
4321 case bp_read_watchpoint
:
4322 case bp_access_watchpoint
:
4326 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4328 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4332 /* There was a watchpoint, but we're not stopping.
4333 This requires no further action. */
4338 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
4339 retval
.is_longjmp
= bptype
== bp_longjmp
;
4341 case bp_longjmp_resume
:
4342 case bp_exception_resume
:
4343 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
4344 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
4346 case bp_step_resume
:
4348 this_action
= BPSTAT_WHAT_STEP_RESUME
;
4351 /* It is for the wrong frame. */
4352 this_action
= BPSTAT_WHAT_SINGLE
;
4355 case bp_hp_step_resume
:
4357 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
4360 /* It is for the wrong frame. */
4361 this_action
= BPSTAT_WHAT_SINGLE
;
4364 case bp_watchpoint_scope
:
4365 case bp_thread_event
:
4366 case bp_overlay_event
:
4367 case bp_longjmp_master
:
4368 case bp_std_terminate_master
:
4369 case bp_exception_master
:
4370 this_action
= BPSTAT_WHAT_SINGLE
;
4376 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4378 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4382 /* There was a catchpoint, but we're not stopping.
4383 This requires no further action. */
4386 case bp_shlib_event
:
4389 /* If requested, stop when the dynamic linker notifies GDB
4390 of events. This allows the user to get control and place
4391 breakpoints in initializer routines for dynamically
4392 loaded objects (among other things). */
4393 if (stop_on_solib_events
)
4394 this_action
= BPSTAT_WHAT_STOP_NOISY
;
4396 this_action
= BPSTAT_WHAT_SINGLE
;
4400 this_action
= BPSTAT_WHAT_SINGLE
;
4403 /* Make sure the action is stop (silent or noisy),
4404 so infrun.c pops the dummy frame. */
4405 retval
.call_dummy
= STOP_STACK_DUMMY
;
4406 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4408 case bp_std_terminate
:
4409 /* Make sure the action is stop (silent or noisy),
4410 so infrun.c pops the dummy frame. */
4411 retval
.call_dummy
= STOP_STD_TERMINATE
;
4412 this_action
= BPSTAT_WHAT_STOP_SILENT
;
4415 case bp_fast_tracepoint
:
4416 case bp_static_tracepoint
:
4417 /* Tracepoint hits should not be reported back to GDB, and
4418 if one got through somehow, it should have been filtered
4420 internal_error (__FILE__
, __LINE__
,
4421 _("bpstat_what: tracepoint encountered"));
4423 case bp_gnu_ifunc_resolver
:
4424 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
4425 this_action
= BPSTAT_WHAT_SINGLE
;
4427 case bp_gnu_ifunc_resolver_return
:
4428 /* The breakpoint will be removed, execution will restart from the
4429 PC of the former breakpoint. */
4430 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
4433 internal_error (__FILE__
, __LINE__
,
4434 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
4437 retval
.main_action
= max (retval
.main_action
, this_action
);
4440 /* These operations may affect the bs->breakpoint_at state so they are
4441 delayed after MAIN_ACTION is decided above. */
4446 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_shlib_event\n");
4448 /* Check for any newly added shared libraries if we're supposed
4449 to be adding them automatically. */
4451 /* Switch terminal for any messages produced by
4452 breakpoint_re_set. */
4453 target_terminal_ours_for_output ();
4456 SOLIB_ADD (NULL
, 0, ¤t_target
, auto_solib_add
);
4458 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
4461 target_terminal_inferior ();
4467 fprintf_unfiltered (gdb_stdlog
, "bpstat_what: bp_jit_event\n");
4469 handle_jit_event ();
4472 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
4474 struct breakpoint
*b
= bs
->breakpoint_at
;
4480 case bp_gnu_ifunc_resolver
:
4481 gnu_ifunc_resolver_stop (b
);
4483 case bp_gnu_ifunc_resolver_return
:
4484 gnu_ifunc_resolver_return_stop (b
);
4492 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4493 without hardware support). This isn't related to a specific bpstat,
4494 just to things like whether watchpoints are set. */
4497 bpstat_should_step (void)
4499 struct breakpoint
*b
;
4502 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
4508 bpstat_causes_stop (bpstat bs
)
4510 for (; bs
!= NULL
; bs
= bs
->next
)
4519 /* Compute a string of spaces suitable to indent the next line
4520 so it starts at the position corresponding to the table column
4521 named COL_NAME in the currently active table of UIOUT. */
4524 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
4526 static char wrap_indent
[80];
4527 int i
, total_width
, width
, align
;
4531 for (i
= 1; ui_out_query_field (uiout
, i
, &width
, &align
, &text
); i
++)
4533 if (strcmp (text
, col_name
) == 0)
4535 gdb_assert (total_width
< sizeof wrap_indent
);
4536 memset (wrap_indent
, ' ', total_width
);
4537 wrap_indent
[total_width
] = 0;
4542 total_width
+= width
+ 1;
4548 /* Print the LOC location out of the list of B->LOC locations. */
4551 print_breakpoint_location (struct breakpoint
*b
,
4552 struct bp_location
*loc
)
4554 struct ui_out
*uiout
= current_uiout
;
4555 struct cleanup
*old_chain
= save_current_program_space ();
4557 if (loc
!= NULL
&& loc
->shlib_disabled
)
4561 set_current_program_space (loc
->pspace
);
4563 if (b
->display_canonical
)
4564 ui_out_field_string (uiout
, "what", b
->addr_string
);
4565 else if (b
->source_file
&& loc
)
4568 = find_pc_sect_function (loc
->address
, loc
->section
);
4571 ui_out_text (uiout
, "in ");
4572 ui_out_field_string (uiout
, "func",
4573 SYMBOL_PRINT_NAME (sym
));
4574 ui_out_text (uiout
, " ");
4575 ui_out_wrap_hint (uiout
, wrap_indent_at_field (uiout
, "what"));
4576 ui_out_text (uiout
, "at ");
4578 ui_out_field_string (uiout
, "file", b
->source_file
);
4579 ui_out_text (uiout
, ":");
4581 if (ui_out_is_mi_like_p (uiout
))
4583 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
4584 char *fullname
= symtab_to_fullname (sal
.symtab
);
4587 ui_out_field_string (uiout
, "fullname", fullname
);
4590 ui_out_field_int (uiout
, "line", b
->line_number
);
4594 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4595 struct cleanup
*stb_chain
= make_cleanup_ui_out_stream_delete (stb
);
4597 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
->stream
,
4599 ui_out_field_stream (uiout
, "at", stb
);
4601 do_cleanups (stb_chain
);
4604 ui_out_field_string (uiout
, "pending", b
->addr_string
);
4606 do_cleanups (old_chain
);
4610 bptype_string (enum bptype type
)
4612 struct ep_type_description
4617 static struct ep_type_description bptypes
[] =
4619 {bp_none
, "?deleted?"},
4620 {bp_breakpoint
, "breakpoint"},
4621 {bp_hardware_breakpoint
, "hw breakpoint"},
4622 {bp_until
, "until"},
4623 {bp_finish
, "finish"},
4624 {bp_watchpoint
, "watchpoint"},
4625 {bp_hardware_watchpoint
, "hw watchpoint"},
4626 {bp_read_watchpoint
, "read watchpoint"},
4627 {bp_access_watchpoint
, "acc watchpoint"},
4628 {bp_longjmp
, "longjmp"},
4629 {bp_longjmp_resume
, "longjmp resume"},
4630 {bp_exception
, "exception"},
4631 {bp_exception_resume
, "exception resume"},
4632 {bp_step_resume
, "step resume"},
4633 {bp_hp_step_resume
, "high-priority step resume"},
4634 {bp_watchpoint_scope
, "watchpoint scope"},
4635 {bp_call_dummy
, "call dummy"},
4636 {bp_std_terminate
, "std::terminate"},
4637 {bp_shlib_event
, "shlib events"},
4638 {bp_thread_event
, "thread events"},
4639 {bp_overlay_event
, "overlay events"},
4640 {bp_longjmp_master
, "longjmp master"},
4641 {bp_std_terminate_master
, "std::terminate master"},
4642 {bp_exception_master
, "exception master"},
4643 {bp_catchpoint
, "catchpoint"},
4644 {bp_tracepoint
, "tracepoint"},
4645 {bp_fast_tracepoint
, "fast tracepoint"},
4646 {bp_static_tracepoint
, "static tracepoint"},
4647 {bp_jit_event
, "jit events"},
4648 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
4649 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
4652 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
4653 || ((int) type
!= bptypes
[(int) type
].type
))
4654 internal_error (__FILE__
, __LINE__
,
4655 _("bptypes table does not describe type #%d."),
4658 return bptypes
[(int) type
].description
;
4661 /* Print B to gdb_stdout. */
4664 print_one_breakpoint_location (struct breakpoint
*b
,
4665 struct bp_location
*loc
,
4667 struct bp_location
**last_loc
,
4670 struct command_line
*l
;
4671 static char bpenables
[] = "nynny";
4673 struct ui_out
*uiout
= current_uiout
;
4674 int header_of_multiple
= 0;
4675 int part_of_multiple
= (loc
!= NULL
);
4676 struct value_print_options opts
;
4678 get_user_print_options (&opts
);
4680 gdb_assert (!loc
|| loc_number
!= 0);
4681 /* See comment in print_one_breakpoint concerning treatment of
4682 breakpoints with single disabled location. */
4685 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
4686 header_of_multiple
= 1;
4694 if (part_of_multiple
)
4697 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
4698 ui_out_field_string (uiout
, "number", formatted
);
4703 ui_out_field_int (uiout
, "number", b
->number
);
4708 if (part_of_multiple
)
4709 ui_out_field_skip (uiout
, "type");
4711 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
4715 if (part_of_multiple
)
4716 ui_out_field_skip (uiout
, "disp");
4718 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
4723 if (part_of_multiple
)
4724 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
4726 ui_out_field_fmt (uiout
, "enabled", "%c",
4727 bpenables
[(int) b
->enable_state
]);
4728 ui_out_spaces (uiout
, 2);
4732 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
4734 /* Although the print_one can possibly print all locations,
4735 calling it here is not likely to get any nice result. So,
4736 make sure there's just one location. */
4737 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
4738 b
->ops
->print_one (b
, last_loc
);
4744 internal_error (__FILE__
, __LINE__
,
4745 _("print_one_breakpoint: bp_none encountered\n"));
4749 case bp_hardware_watchpoint
:
4750 case bp_read_watchpoint
:
4751 case bp_access_watchpoint
:
4753 struct watchpoint
*w
= (struct watchpoint
*) b
;
4755 /* Field 4, the address, is omitted (which makes the columns
4756 not line up too nicely with the headers, but the effect
4757 is relatively readable). */
4758 if (opts
.addressprint
)
4759 ui_out_field_skip (uiout
, "addr");
4761 ui_out_field_string (uiout
, "what", w
->exp_string
);
4766 case bp_hardware_breakpoint
:
4770 case bp_longjmp_resume
:
4772 case bp_exception_resume
:
4773 case bp_step_resume
:
4774 case bp_hp_step_resume
:
4775 case bp_watchpoint_scope
:
4777 case bp_std_terminate
:
4778 case bp_shlib_event
:
4779 case bp_thread_event
:
4780 case bp_overlay_event
:
4781 case bp_longjmp_master
:
4782 case bp_std_terminate_master
:
4783 case bp_exception_master
:
4785 case bp_fast_tracepoint
:
4786 case bp_static_tracepoint
:
4788 case bp_gnu_ifunc_resolver
:
4789 case bp_gnu_ifunc_resolver_return
:
4790 if (opts
.addressprint
)
4793 if (header_of_multiple
)
4794 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
4795 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
4796 ui_out_field_string (uiout
, "addr", "<PENDING>");
4798 ui_out_field_core_addr (uiout
, "addr",
4799 loc
->gdbarch
, loc
->address
);
4802 if (!header_of_multiple
)
4803 print_breakpoint_location (b
, loc
);
4810 /* For backward compatibility, don't display inferiors unless there
4813 && !header_of_multiple
4815 || (!gdbarch_has_global_breakpoints (target_gdbarch
)
4816 && (number_of_program_spaces () > 1
4817 || number_of_inferiors () > 1)
4818 /* LOC is for existing B, it cannot be in
4819 moribund_locations and thus having NULL OWNER. */
4820 && loc
->owner
->type
!= bp_catchpoint
)))
4822 struct inferior
*inf
;
4825 for (inf
= inferior_list
; inf
!= NULL
; inf
= inf
->next
)
4827 if (inf
->pspace
== loc
->pspace
)
4832 ui_out_text (uiout
, " inf ");
4835 ui_out_text (uiout
, ", ");
4836 ui_out_text (uiout
, plongest (inf
->num
));
4841 if (!part_of_multiple
)
4843 if (b
->thread
!= -1)
4845 /* FIXME: This seems to be redundant and lost here; see the
4846 "stop only in" line a little further down. */
4847 ui_out_text (uiout
, " thread ");
4848 ui_out_field_int (uiout
, "thread", b
->thread
);
4850 else if (b
->task
!= 0)
4852 ui_out_text (uiout
, " task ");
4853 ui_out_field_int (uiout
, "task", b
->task
);
4857 ui_out_text (uiout
, "\n");
4859 if (!part_of_multiple
)
4860 b
->ops
->print_one_detail (b
, uiout
);
4862 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
4865 ui_out_text (uiout
, "\tstop only in stack frame at ");
4866 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
4868 ui_out_field_core_addr (uiout
, "frame",
4869 b
->gdbarch
, b
->frame_id
.stack_addr
);
4870 ui_out_text (uiout
, "\n");
4873 if (!part_of_multiple
&& b
->cond_string
)
4876 if (is_tracepoint (b
))
4877 ui_out_text (uiout
, "\ttrace only if ");
4879 ui_out_text (uiout
, "\tstop only if ");
4880 ui_out_field_string (uiout
, "cond", b
->cond_string
);
4881 ui_out_text (uiout
, "\n");
4884 if (!part_of_multiple
&& b
->thread
!= -1)
4886 /* FIXME should make an annotation for this. */
4887 ui_out_text (uiout
, "\tstop only in thread ");
4888 ui_out_field_int (uiout
, "thread", b
->thread
);
4889 ui_out_text (uiout
, "\n");
4892 if (!part_of_multiple
&& b
->hit_count
)
4894 /* FIXME should make an annotation for this. */
4895 if (ep_is_catchpoint (b
))
4896 ui_out_text (uiout
, "\tcatchpoint");
4897 else if (is_tracepoint (b
))
4898 ui_out_text (uiout
, "\ttracepoint");
4900 ui_out_text (uiout
, "\tbreakpoint");
4901 ui_out_text (uiout
, " already hit ");
4902 ui_out_field_int (uiout
, "times", b
->hit_count
);
4903 if (b
->hit_count
== 1)
4904 ui_out_text (uiout
, " time\n");
4906 ui_out_text (uiout
, " times\n");
4909 /* Output the count also if it is zero, but only if this is mi.
4910 FIXME: Should have a better test for this. */
4911 if (ui_out_is_mi_like_p (uiout
))
4912 if (!part_of_multiple
&& b
->hit_count
== 0)
4913 ui_out_field_int (uiout
, "times", b
->hit_count
);
4915 if (!part_of_multiple
&& b
->ignore_count
)
4918 ui_out_text (uiout
, "\tignore next ");
4919 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
4920 ui_out_text (uiout
, " hits\n");
4923 if (!part_of_multiple
&& is_tracepoint (b
))
4925 struct tracepoint
*tp
= (struct tracepoint
*) b
;
4927 if (tp
->traceframe_usage
)
4929 ui_out_text (uiout
, "\ttrace buffer usage ");
4930 ui_out_field_int (uiout
, "traceframe-usage", tp
->traceframe_usage
);
4931 ui_out_text (uiout
, " bytes\n");
4935 l
= b
->commands
? b
->commands
->commands
: NULL
;
4936 if (!part_of_multiple
&& l
)
4938 struct cleanup
*script_chain
;
4941 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
4942 print_command_lines (uiout
, l
, 4);
4943 do_cleanups (script_chain
);
4946 if (is_tracepoint (b
))
4948 struct tracepoint
*t
= (struct tracepoint
*) b
;
4950 if (!part_of_multiple
&& t
->pass_count
)
4952 annotate_field (10);
4953 ui_out_text (uiout
, "\tpass count ");
4954 ui_out_field_int (uiout
, "pass", t
->pass_count
);
4955 ui_out_text (uiout
, " \n");
4959 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
4961 if (is_watchpoint (b
))
4963 struct watchpoint
*w
= (struct watchpoint
*) b
;
4965 ui_out_field_string (uiout
, "original-location", w
->exp_string
);
4967 else if (b
->addr_string
)
4968 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
4973 print_one_breakpoint (struct breakpoint
*b
,
4974 struct bp_location
**last_loc
,
4977 struct cleanup
*bkpt_chain
;
4978 struct ui_out
*uiout
= current_uiout
;
4980 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
4982 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
4983 do_cleanups (bkpt_chain
);
4985 /* If this breakpoint has custom print function,
4986 it's already printed. Otherwise, print individual
4987 locations, if any. */
4988 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
4990 /* If breakpoint has a single location that is disabled, we
4991 print it as if it had several locations, since otherwise it's
4992 hard to represent "breakpoint enabled, location disabled"
4995 Note that while hardware watchpoints have several locations
4996 internally, that's not a property exposed to user. */
4998 && !is_hardware_watchpoint (b
)
4999 && (b
->loc
->next
|| !b
->loc
->enabled
))
5001 struct bp_location
*loc
;
5004 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
5006 struct cleanup
*inner2
=
5007 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
5008 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
5009 do_cleanups (inner2
);
5016 breakpoint_address_bits (struct breakpoint
*b
)
5018 int print_address_bits
= 0;
5019 struct bp_location
*loc
;
5021 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
5025 /* Software watchpoints that aren't watching memory don't have
5026 an address to print. */
5027 if (b
->type
== bp_watchpoint
&& loc
->watchpoint_type
== -1)
5030 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
5031 if (addr_bit
> print_address_bits
)
5032 print_address_bits
= addr_bit
;
5035 return print_address_bits
;
5038 struct captured_breakpoint_query_args
5044 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
5046 struct captured_breakpoint_query_args
*args
= data
;
5047 struct breakpoint
*b
;
5048 struct bp_location
*dummy_loc
= NULL
;
5052 if (args
->bnum
== b
->number
)
5054 print_one_breakpoint (b
, &dummy_loc
, 0);
5062 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
5063 char **error_message
)
5065 struct captured_breakpoint_query_args args
;
5068 /* For the moment we don't trust print_one_breakpoint() to not throw
5070 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
5071 error_message
, RETURN_MASK_ALL
) < 0)
5077 /* Return true if this breakpoint was set by the user, false if it is
5078 internal or momentary. */
5081 user_breakpoint_p (struct breakpoint
*b
)
5083 return b
->number
> 0;
5086 /* Print information on user settable breakpoint (watchpoint, etc)
5087 number BNUM. If BNUM is -1 print all user-settable breakpoints.
5088 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
5089 FILTER is non-NULL, call it on each breakpoint and only include the
5090 ones for which it returns non-zero. Return the total number of
5091 breakpoints listed. */
5094 breakpoint_1 (char *args
, int allflag
,
5095 int (*filter
) (const struct breakpoint
*))
5097 struct breakpoint
*b
;
5098 struct bp_location
*last_loc
= NULL
;
5099 int nr_printable_breakpoints
;
5100 struct cleanup
*bkpttbl_chain
;
5101 struct value_print_options opts
;
5102 int print_address_bits
= 0;
5103 int print_type_col_width
= 14;
5104 struct ui_out
*uiout
= current_uiout
;
5106 get_user_print_options (&opts
);
5108 /* Compute the number of rows in the table, as well as the size
5109 required for address fields. */
5110 nr_printable_breakpoints
= 0;
5113 /* If we have a filter, only list the breakpoints it accepts. */
5114 if (filter
&& !filter (b
))
5117 /* If we have an "args" string, it is a list of breakpoints to
5118 accept. Skip the others. */
5119 if (args
!= NULL
&& *args
!= '\0')
5121 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
5123 if (!allflag
&& !number_is_in_list (args
, b
->number
))
5127 if (allflag
|| user_breakpoint_p (b
))
5129 int addr_bit
, type_len
;
5131 addr_bit
= breakpoint_address_bits (b
);
5132 if (addr_bit
> print_address_bits
)
5133 print_address_bits
= addr_bit
;
5135 type_len
= strlen (bptype_string (b
->type
));
5136 if (type_len
> print_type_col_width
)
5137 print_type_col_width
= type_len
;
5139 nr_printable_breakpoints
++;
5143 if (opts
.addressprint
)
5145 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
5146 nr_printable_breakpoints
,
5150 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
5151 nr_printable_breakpoints
,
5154 if (nr_printable_breakpoints
> 0)
5155 annotate_breakpoints_headers ();
5156 if (nr_printable_breakpoints
> 0)
5158 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
5159 if (nr_printable_breakpoints
> 0)
5161 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
5162 "type", "Type"); /* 2 */
5163 if (nr_printable_breakpoints
> 0)
5165 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
5166 if (nr_printable_breakpoints
> 0)
5168 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
5169 if (opts
.addressprint
)
5171 if (nr_printable_breakpoints
> 0)
5173 if (print_address_bits
<= 32)
5174 ui_out_table_header (uiout
, 10, ui_left
,
5175 "addr", "Address"); /* 5 */
5177 ui_out_table_header (uiout
, 18, ui_left
,
5178 "addr", "Address"); /* 5 */
5180 if (nr_printable_breakpoints
> 0)
5182 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
5183 ui_out_table_body (uiout
);
5184 if (nr_printable_breakpoints
> 0)
5185 annotate_breakpoints_table ();
5190 /* If we have a filter, only list the breakpoints it accepts. */
5191 if (filter
&& !filter (b
))
5194 /* If we have an "args" string, it is a list of breakpoints to
5195 accept. Skip the others. */
5197 if (args
!= NULL
&& *args
!= '\0')
5199 if (allflag
) /* maintenance info breakpoint */
5201 if (parse_and_eval_long (args
) != b
->number
)
5204 else /* all others */
5206 if (!number_is_in_list (args
, b
->number
))
5210 /* We only print out user settable breakpoints unless the
5212 if (allflag
|| user_breakpoint_p (b
))
5213 print_one_breakpoint (b
, &last_loc
, allflag
);
5216 do_cleanups (bkpttbl_chain
);
5218 if (nr_printable_breakpoints
== 0)
5220 /* If there's a filter, let the caller decide how to report
5224 if (args
== NULL
|| *args
== '\0')
5225 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
5227 ui_out_message (uiout
, 0,
5228 "No breakpoint or watchpoint matching '%s'.\n",
5234 if (last_loc
&& !server_command
)
5235 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
5238 /* FIXME? Should this be moved up so that it is only called when
5239 there have been breakpoints? */
5240 annotate_breakpoints_table_end ();
5242 return nr_printable_breakpoints
;
5245 /* Display the value of default-collect in a way that is generally
5246 compatible with the breakpoint list. */
5249 default_collect_info (void)
5251 struct ui_out
*uiout
= current_uiout
;
5253 /* If it has no value (which is frequently the case), say nothing; a
5254 message like "No default-collect." gets in user's face when it's
5256 if (!*default_collect
)
5259 /* The following phrase lines up nicely with per-tracepoint collect
5261 ui_out_text (uiout
, "default collect ");
5262 ui_out_field_string (uiout
, "default-collect", default_collect
);
5263 ui_out_text (uiout
, " \n");
5267 breakpoints_info (char *args
, int from_tty
)
5269 breakpoint_1 (args
, 0, NULL
);
5271 default_collect_info ();
5275 watchpoints_info (char *args
, int from_tty
)
5277 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
5278 struct ui_out
*uiout
= current_uiout
;
5280 if (num_printed
== 0)
5282 if (args
== NULL
|| *args
== '\0')
5283 ui_out_message (uiout
, 0, "No watchpoints.\n");
5285 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
5290 maintenance_info_breakpoints (char *args
, int from_tty
)
5292 breakpoint_1 (args
, 1, NULL
);
5294 default_collect_info ();
5298 breakpoint_has_pc (struct breakpoint
*b
,
5299 struct program_space
*pspace
,
5300 CORE_ADDR pc
, struct obj_section
*section
)
5302 struct bp_location
*bl
= b
->loc
;
5304 for (; bl
; bl
= bl
->next
)
5306 if (bl
->pspace
== pspace
5307 && bl
->address
== pc
5308 && (!overlay_debugging
|| bl
->section
== section
))
5314 /* Print a message describing any user-breakpoints set at PC. This
5315 concerns with logical breakpoints, so we match program spaces, not
5319 describe_other_breakpoints (struct gdbarch
*gdbarch
,
5320 struct program_space
*pspace
, CORE_ADDR pc
,
5321 struct obj_section
*section
, int thread
)
5324 struct breakpoint
*b
;
5327 others
+= (user_breakpoint_p (b
)
5328 && breakpoint_has_pc (b
, pspace
, pc
, section
));
5332 printf_filtered (_("Note: breakpoint "));
5333 else /* if (others == ???) */
5334 printf_filtered (_("Note: breakpoints "));
5336 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
5339 printf_filtered ("%d", b
->number
);
5340 if (b
->thread
== -1 && thread
!= -1)
5341 printf_filtered (" (all threads)");
5342 else if (b
->thread
!= -1)
5343 printf_filtered (" (thread %d)", b
->thread
);
5344 printf_filtered ("%s%s ",
5345 ((b
->enable_state
== bp_disabled
5346 || b
->enable_state
== bp_call_disabled
5347 || b
->enable_state
== bp_startup_disabled
)
5349 : b
->enable_state
== bp_permanent
5353 : ((others
== 1) ? " and" : ""));
5355 printf_filtered (_("also set at pc "));
5356 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
5357 printf_filtered (".\n");
5362 /* Return true iff it is meaningful to use the address member of
5363 BPT. For some breakpoint types, the address member is irrelevant
5364 and it makes no sense to attempt to compare it to other addresses
5365 (or use it for any other purpose either).
5367 More specifically, each of the following breakpoint types will
5368 always have a zero valued address and we don't want to mark
5369 breakpoints of any of these types to be a duplicate of an actual
5370 breakpoint at address zero:
5378 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
5380 enum bptype type
= bpt
->type
;
5382 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
5385 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5386 true if LOC1 and LOC2 represent the same watchpoint location. */
5389 watchpoint_locations_match (struct bp_location
*loc1
,
5390 struct bp_location
*loc2
)
5392 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
5393 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
5395 /* Both of them must exist. */
5396 gdb_assert (w1
!= NULL
);
5397 gdb_assert (w2
!= NULL
);
5399 /* If the target can evaluate the condition expression in hardware,
5400 then we we need to insert both watchpoints even if they are at
5401 the same place. Otherwise the watchpoint will only trigger when
5402 the condition of whichever watchpoint was inserted evaluates to
5403 true, not giving a chance for GDB to check the condition of the
5404 other watchpoint. */
5406 && target_can_accel_watchpoint_condition (loc1
->address
,
5408 loc1
->watchpoint_type
,
5411 && target_can_accel_watchpoint_condition (loc2
->address
,
5413 loc2
->watchpoint_type
,
5417 /* Note that this checks the owner's type, not the location's. In
5418 case the target does not support read watchpoints, but does
5419 support access watchpoints, we'll have bp_read_watchpoint
5420 watchpoints with hw_access locations. Those should be considered
5421 duplicates of hw_read locations. The hw_read locations will
5422 become hw_access locations later. */
5423 return (loc1
->owner
->type
== loc2
->owner
->type
5424 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
5425 && loc1
->address
== loc2
->address
5426 && loc1
->length
== loc2
->length
);
5429 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5430 same breakpoint location. In most targets, this can only be true
5431 if ASPACE1 matches ASPACE2. On targets that have global
5432 breakpoints, the address space doesn't really matter. */
5435 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
5436 struct address_space
*aspace2
, CORE_ADDR addr2
)
5438 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5439 || aspace1
== aspace2
)
5443 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
5444 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
5445 matches ASPACE2. On targets that have global breakpoints, the address
5446 space doesn't really matter. */
5449 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
5450 int len1
, struct address_space
*aspace2
,
5453 return ((gdbarch_has_global_breakpoints (target_gdbarch
)
5454 || aspace1
== aspace2
)
5455 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
5458 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
5459 a ranged breakpoint. In most targets, a match happens only if ASPACE
5460 matches the breakpoint's address space. On targets that have global
5461 breakpoints, the address space doesn't really matter. */
5464 breakpoint_location_address_match (struct bp_location
*bl
,
5465 struct address_space
*aspace
,
5468 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
5471 && breakpoint_address_match_range (bl
->pspace
->aspace
,
5472 bl
->address
, bl
->length
,
5476 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
5477 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
5478 true, otherwise returns false. */
5481 tracepoint_locations_match (struct bp_location
*loc1
,
5482 struct bp_location
*loc2
)
5484 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
5485 /* Since tracepoint locations are never duplicated with others', tracepoint
5486 locations at the same address of different tracepoints are regarded as
5487 different locations. */
5488 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
5493 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5494 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5495 represent the same location. */
5498 breakpoint_locations_match (struct bp_location
*loc1
,
5499 struct bp_location
*loc2
)
5501 int hw_point1
, hw_point2
;
5503 /* Both of them must not be in moribund_locations. */
5504 gdb_assert (loc1
->owner
!= NULL
);
5505 gdb_assert (loc2
->owner
!= NULL
);
5507 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
5508 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
5510 if (hw_point1
!= hw_point2
)
5513 return watchpoint_locations_match (loc1
, loc2
);
5514 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
5515 return tracepoint_locations_match (loc1
, loc2
);
5517 /* We compare bp_location.length in order to cover ranged breakpoints. */
5518 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
5519 loc2
->pspace
->aspace
, loc2
->address
)
5520 && loc1
->length
== loc2
->length
);
5524 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
5525 int bnum
, int have_bnum
)
5527 /* The longest string possibly returned by hex_string_custom
5528 is 50 chars. These must be at least that big for safety. */
5532 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
5533 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
5535 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5536 bnum
, astr1
, astr2
);
5538 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
5541 /* Adjust a breakpoint's address to account for architectural
5542 constraints on breakpoint placement. Return the adjusted address.
5543 Note: Very few targets require this kind of adjustment. For most
5544 targets, this function is simply the identity function. */
5547 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
5548 CORE_ADDR bpaddr
, enum bptype bptype
)
5550 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
5552 /* Very few targets need any kind of breakpoint adjustment. */
5555 else if (bptype
== bp_watchpoint
5556 || bptype
== bp_hardware_watchpoint
5557 || bptype
== bp_read_watchpoint
5558 || bptype
== bp_access_watchpoint
5559 || bptype
== bp_catchpoint
)
5561 /* Watchpoints and the various bp_catch_* eventpoints should not
5562 have their addresses modified. */
5567 CORE_ADDR adjusted_bpaddr
;
5569 /* Some targets have architectural constraints on the placement
5570 of breakpoint instructions. Obtain the adjusted address. */
5571 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
5573 /* An adjusted breakpoint address can significantly alter
5574 a user's expectations. Print a warning if an adjustment
5576 if (adjusted_bpaddr
!= bpaddr
)
5577 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
5579 return adjusted_bpaddr
;
5584 init_bp_location (struct bp_location
*loc
, const struct bp_location_ops
*ops
,
5585 struct breakpoint
*owner
)
5587 memset (loc
, 0, sizeof (*loc
));
5589 gdb_assert (ops
!= NULL
);
5594 loc
->shlib_disabled
= 0;
5597 switch (owner
->type
)
5603 case bp_longjmp_resume
:
5605 case bp_exception_resume
:
5606 case bp_step_resume
:
5607 case bp_hp_step_resume
:
5608 case bp_watchpoint_scope
:
5610 case bp_std_terminate
:
5611 case bp_shlib_event
:
5612 case bp_thread_event
:
5613 case bp_overlay_event
:
5615 case bp_longjmp_master
:
5616 case bp_std_terminate_master
:
5617 case bp_exception_master
:
5618 case bp_gnu_ifunc_resolver
:
5619 case bp_gnu_ifunc_resolver_return
:
5620 loc
->loc_type
= bp_loc_software_breakpoint
;
5622 case bp_hardware_breakpoint
:
5623 loc
->loc_type
= bp_loc_hardware_breakpoint
;
5625 case bp_hardware_watchpoint
:
5626 case bp_read_watchpoint
:
5627 case bp_access_watchpoint
:
5628 loc
->loc_type
= bp_loc_hardware_watchpoint
;
5633 case bp_fast_tracepoint
:
5634 case bp_static_tracepoint
:
5635 loc
->loc_type
= bp_loc_other
;
5638 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
5644 /* Allocate a struct bp_location. */
5646 static struct bp_location
*
5647 allocate_bp_location (struct breakpoint
*bpt
)
5649 return bpt
->ops
->allocate_location (bpt
);
5653 free_bp_location (struct bp_location
*loc
)
5655 loc
->ops
->dtor (loc
);
5659 /* Increment reference count. */
5662 incref_bp_location (struct bp_location
*bl
)
5667 /* Decrement reference count. If the reference count reaches 0,
5668 destroy the bp_location. Sets *BLP to NULL. */
5671 decref_bp_location (struct bp_location
**blp
)
5673 gdb_assert ((*blp
)->refc
> 0);
5675 if (--(*blp
)->refc
== 0)
5676 free_bp_location (*blp
);
5680 /* Add breakpoint B at the end of the global breakpoint chain. */
5683 add_to_breakpoint_chain (struct breakpoint
*b
)
5685 struct breakpoint
*b1
;
5687 /* Add this breakpoint to the end of the chain so that a list of
5688 breakpoints will come out in order of increasing numbers. */
5690 b1
= breakpoint_chain
;
5692 breakpoint_chain
= b
;
5701 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
5704 init_raw_breakpoint_without_location (struct breakpoint
*b
,
5705 struct gdbarch
*gdbarch
,
5707 const struct breakpoint_ops
*ops
)
5709 memset (b
, 0, sizeof (*b
));
5711 gdb_assert (ops
!= NULL
);
5715 b
->gdbarch
= gdbarch
;
5716 b
->language
= current_language
->la_language
;
5717 b
->input_radix
= input_radix
;
5719 b
->enable_state
= bp_enabled
;
5722 b
->ignore_count
= 0;
5724 b
->frame_id
= null_frame_id
;
5725 b
->condition_not_parsed
= 0;
5726 b
->py_bp_object
= NULL
;
5727 b
->related_breakpoint
= b
;
5730 /* Helper to set_raw_breakpoint below. Creates a breakpoint
5731 that has type BPTYPE and has no locations as yet. */
5733 static struct breakpoint
*
5734 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
5736 const struct breakpoint_ops
*ops
)
5738 struct breakpoint
*b
= XNEW (struct breakpoint
);
5740 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
5741 add_to_breakpoint_chain (b
);
5745 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
5746 resolutions should be made as the user specified the location explicitly
5750 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
5752 gdb_assert (loc
->owner
!= NULL
);
5754 if (loc
->owner
->type
== bp_breakpoint
5755 || loc
->owner
->type
== bp_hardware_breakpoint
5756 || is_tracepoint (loc
->owner
))
5760 find_pc_partial_function_gnu_ifunc (loc
->address
, &loc
->function_name
,
5761 NULL
, NULL
, &is_gnu_ifunc
);
5763 if (is_gnu_ifunc
&& !explicit_loc
)
5765 struct breakpoint
*b
= loc
->owner
;
5767 gdb_assert (loc
->pspace
== current_program_space
);
5768 if (gnu_ifunc_resolve_name (loc
->function_name
,
5769 &loc
->requested_address
))
5771 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
5772 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
5773 loc
->requested_address
,
5776 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
5777 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
5779 /* Create only the whole new breakpoint of this type but do not
5780 mess more complicated breakpoints with multiple locations. */
5781 b
->type
= bp_gnu_ifunc_resolver
;
5785 if (loc
->function_name
)
5786 loc
->function_name
= xstrdup (loc
->function_name
);
5790 /* Attempt to determine architecture of location identified by SAL. */
5792 get_sal_arch (struct symtab_and_line sal
)
5795 return get_objfile_arch (sal
.section
->objfile
);
5797 return get_objfile_arch (sal
.symtab
->objfile
);
5802 /* Low level routine for partially initializing a breakpoint of type
5803 BPTYPE. The newly created breakpoint's address, section, source
5804 file name, and line number are provided by SAL.
5806 It is expected that the caller will complete the initialization of
5807 the newly created breakpoint struct as well as output any status
5808 information regarding the creation of a new breakpoint. */
5811 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
5812 struct symtab_and_line sal
, enum bptype bptype
,
5813 const struct breakpoint_ops
*ops
)
5815 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
5817 add_location_to_breakpoint (b
, &sal
);
5819 if (bptype
!= bp_catchpoint
)
5820 gdb_assert (sal
.pspace
!= NULL
);
5822 /* Store the program space that was used to set the breakpoint, for
5823 breakpoint resetting. */
5824 b
->pspace
= sal
.pspace
;
5826 if (sal
.symtab
== NULL
)
5827 b
->source_file
= NULL
;
5829 b
->source_file
= xstrdup (sal
.symtab
->filename
);
5830 b
->line_number
= sal
.line
;
5832 breakpoints_changed ();
5835 /* set_raw_breakpoint is a low level routine for allocating and
5836 partially initializing a breakpoint of type BPTYPE. The newly
5837 created breakpoint's address, section, source file name, and line
5838 number are provided by SAL. The newly created and partially
5839 initialized breakpoint is added to the breakpoint chain and
5840 is also returned as the value of this function.
5842 It is expected that the caller will complete the initialization of
5843 the newly created breakpoint struct as well as output any status
5844 information regarding the creation of a new breakpoint. In
5845 particular, set_raw_breakpoint does NOT set the breakpoint
5846 number! Care should be taken to not allow an error to occur
5847 prior to completing the initialization of the breakpoint. If this
5848 should happen, a bogus breakpoint will be left on the chain. */
5851 set_raw_breakpoint (struct gdbarch
*gdbarch
,
5852 struct symtab_and_line sal
, enum bptype bptype
,
5853 const struct breakpoint_ops
*ops
)
5855 struct breakpoint
*b
= XNEW (struct breakpoint
);
5857 init_raw_breakpoint (b
, gdbarch
, sal
, bptype
, ops
);
5858 add_to_breakpoint_chain (b
);
5863 /* Note that the breakpoint object B describes a permanent breakpoint
5864 instruction, hard-wired into the inferior's code. */
5866 make_breakpoint_permanent (struct breakpoint
*b
)
5868 struct bp_location
*bl
;
5870 b
->enable_state
= bp_permanent
;
5872 /* By definition, permanent breakpoints are already present in the
5873 code. Mark all locations as inserted. For now,
5874 make_breakpoint_permanent is called in just one place, so it's
5875 hard to say if it's reasonable to have permanent breakpoint with
5876 multiple locations or not, but it's easy to implement. */
5877 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
5881 /* Call this routine when stepping and nexting to enable a breakpoint
5882 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
5883 initiated the operation. */
5886 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
5888 struct breakpoint
*b
, *b_tmp
;
5889 int thread
= tp
->num
;
5891 /* To avoid having to rescan all objfile symbols at every step,
5892 we maintain a list of continually-inserted but always disabled
5893 longjmp "master" breakpoints. Here, we simply create momentary
5894 clones of those and enable them for the requested thread. */
5895 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5896 if (b
->pspace
== current_program_space
5897 && (b
->type
== bp_longjmp_master
5898 || b
->type
== bp_exception_master
))
5900 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
5901 struct breakpoint
*clone
;
5903 clone
= momentary_breakpoint_from_master (b
, type
,
5904 &momentary_breakpoint_ops
);
5905 clone
->thread
= thread
;
5908 tp
->initiating_frame
= frame
;
5911 /* Delete all longjmp breakpoints from THREAD. */
5913 delete_longjmp_breakpoint (int thread
)
5915 struct breakpoint
*b
, *b_tmp
;
5917 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5918 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
5920 if (b
->thread
== thread
)
5921 delete_breakpoint (b
);
5926 enable_overlay_breakpoints (void)
5928 struct breakpoint
*b
;
5931 if (b
->type
== bp_overlay_event
)
5933 b
->enable_state
= bp_enabled
;
5934 update_global_location_list (1);
5935 overlay_events_enabled
= 1;
5940 disable_overlay_breakpoints (void)
5942 struct breakpoint
*b
;
5945 if (b
->type
== bp_overlay_event
)
5947 b
->enable_state
= bp_disabled
;
5948 update_global_location_list (0);
5949 overlay_events_enabled
= 0;
5953 /* Set an active std::terminate breakpoint for each std::terminate
5954 master breakpoint. */
5956 set_std_terminate_breakpoint (void)
5958 struct breakpoint
*b
, *b_tmp
;
5960 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5961 if (b
->pspace
== current_program_space
5962 && b
->type
== bp_std_terminate_master
)
5964 momentary_breakpoint_from_master (b
, bp_std_terminate
,
5965 &momentary_breakpoint_ops
);
5969 /* Delete all the std::terminate breakpoints. */
5971 delete_std_terminate_breakpoint (void)
5973 struct breakpoint
*b
, *b_tmp
;
5975 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
5976 if (b
->type
== bp_std_terminate
)
5977 delete_breakpoint (b
);
5981 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
5983 struct breakpoint
*b
;
5985 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
5986 &internal_breakpoint_ops
);
5988 b
->enable_state
= bp_enabled
;
5989 /* addr_string has to be used or breakpoint_re_set will delete me. */
5991 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
5993 update_global_location_list_nothrow (1);
5999 remove_thread_event_breakpoints (void)
6001 struct breakpoint
*b
, *b_tmp
;
6003 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6004 if (b
->type
== bp_thread_event
6005 && b
->loc
->pspace
== current_program_space
)
6006 delete_breakpoint (b
);
6009 struct lang_and_radix
6015 /* Create a breakpoint for JIT code registration and unregistration. */
6018 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6020 struct breakpoint
*b
;
6022 b
= create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
6023 &internal_breakpoint_ops
);
6024 update_global_location_list_nothrow (1);
6028 /* Remove JIT code registration and unregistration breakpoint(s). */
6031 remove_jit_event_breakpoints (void)
6033 struct breakpoint
*b
, *b_tmp
;
6035 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6036 if (b
->type
== bp_jit_event
6037 && b
->loc
->pspace
== current_program_space
)
6038 delete_breakpoint (b
);
6042 remove_solib_event_breakpoints (void)
6044 struct breakpoint
*b
, *b_tmp
;
6046 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
6047 if (b
->type
== bp_shlib_event
6048 && b
->loc
->pspace
== current_program_space
)
6049 delete_breakpoint (b
);
6053 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
6055 struct breakpoint
*b
;
6057 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
6058 &internal_breakpoint_ops
);
6059 update_global_location_list_nothrow (1);
6063 /* Disable any breakpoints that are on code in shared libraries. Only
6064 apply to enabled breakpoints, disabled ones can just stay disabled. */
6067 disable_breakpoints_in_shlibs (void)
6069 struct bp_location
*loc
, **locp_tmp
;
6071 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6073 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6074 struct breakpoint
*b
= loc
->owner
;
6076 /* We apply the check to all breakpoints, including disabled for
6077 those with loc->duplicate set. This is so that when breakpoint
6078 becomes enabled, or the duplicate is removed, gdb will try to
6079 insert all breakpoints. If we don't set shlib_disabled here,
6080 we'll try to insert those breakpoints and fail. */
6081 if (((b
->type
== bp_breakpoint
)
6082 || (b
->type
== bp_jit_event
)
6083 || (b
->type
== bp_hardware_breakpoint
)
6084 || (is_tracepoint (b
)))
6085 && loc
->pspace
== current_program_space
6086 && !loc
->shlib_disabled
6088 && PC_SOLIB (loc
->address
)
6090 && solib_name_from_address (loc
->pspace
, loc
->address
)
6094 loc
->shlib_disabled
= 1;
6099 /* Disable any breakpoints and tracepoints that are in an unloaded shared
6100 library. Only apply to enabled breakpoints, disabled ones can just stay
6104 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
6106 struct bp_location
*loc
, **locp_tmp
;
6107 int disabled_shlib_breaks
= 0;
6109 /* SunOS a.out shared libraries are always mapped, so do not
6110 disable breakpoints; they will only be reported as unloaded
6111 through clear_solib when GDB discards its shared library
6112 list. See clear_solib for more information. */
6113 if (exec_bfd
!= NULL
6114 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
6117 ALL_BP_LOCATIONS (loc
, locp_tmp
)
6119 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6120 struct breakpoint
*b
= loc
->owner
;
6122 if (solib
->pspace
== loc
->pspace
6123 && !loc
->shlib_disabled
6124 && (((b
->type
== bp_breakpoint
6125 || b
->type
== bp_jit_event
6126 || b
->type
== bp_hardware_breakpoint
)
6127 && (loc
->loc_type
== bp_loc_hardware_breakpoint
6128 || loc
->loc_type
== bp_loc_software_breakpoint
))
6129 || is_tracepoint (b
))
6130 && solib_contains_address_p (solib
, loc
->address
))
6132 loc
->shlib_disabled
= 1;
6133 /* At this point, we cannot rely on remove_breakpoint
6134 succeeding so we must mark the breakpoint as not inserted
6135 to prevent future errors occurring in remove_breakpoints. */
6138 /* This may cause duplicate notifications for the same breakpoint. */
6139 observer_notify_breakpoint_modified (b
);
6141 if (!disabled_shlib_breaks
)
6143 target_terminal_ours_for_output ();
6144 warning (_("Temporarily disabling breakpoints "
6145 "for unloaded shared library \"%s\""),
6148 disabled_shlib_breaks
= 1;
6153 /* FORK & VFORK catchpoints. */
6155 /* An instance of this type is used to represent a fork or vfork
6156 catchpoint. It includes a "struct breakpoint" as a kind of base
6157 class; users downcast to "struct breakpoint *" when needed. A
6158 breakpoint is really of this type iff its ops pointer points to
6159 CATCH_FORK_BREAKPOINT_OPS. */
6161 struct fork_catchpoint
6163 /* The base class. */
6164 struct breakpoint base
;
6166 /* Process id of a child process whose forking triggered this
6167 catchpoint. This field is only valid immediately after this
6168 catchpoint has triggered. */
6169 ptid_t forked_inferior_pid
;
6172 /* Implement the "insert" breakpoint_ops method for fork
6176 insert_catch_fork (struct bp_location
*bl
)
6178 return target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
6181 /* Implement the "remove" breakpoint_ops method for fork
6185 remove_catch_fork (struct bp_location
*bl
)
6187 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
6190 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6194 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
6195 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6197 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
6199 return inferior_has_forked (inferior_ptid
, &c
->forked_inferior_pid
);
6202 /* Implement the "print_it" breakpoint_ops method for fork
6205 static enum print_stop_action
6206 print_it_catch_fork (bpstat bs
)
6208 struct ui_out
*uiout
= current_uiout
;
6209 struct breakpoint
*b
= bs
->breakpoint_at
;
6210 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
6212 annotate_catchpoint (b
->number
);
6213 if (b
->disposition
== disp_del
)
6214 ui_out_text (uiout
, "\nTemporary catchpoint ");
6216 ui_out_text (uiout
, "\nCatchpoint ");
6217 if (ui_out_is_mi_like_p (uiout
))
6219 ui_out_field_string (uiout
, "reason",
6220 async_reason_lookup (EXEC_ASYNC_FORK
));
6221 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6223 ui_out_field_int (uiout
, "bkptno", b
->number
);
6224 ui_out_text (uiout
, " (forked process ");
6225 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
6226 ui_out_text (uiout
, "), ");
6227 return PRINT_SRC_AND_LOC
;
6230 /* Implement the "print_one" breakpoint_ops method for fork
6234 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6236 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6237 struct value_print_options opts
;
6238 struct ui_out
*uiout
= current_uiout
;
6240 get_user_print_options (&opts
);
6242 /* Field 4, the address, is omitted (which makes the columns not
6243 line up too nicely with the headers, but the effect is relatively
6245 if (opts
.addressprint
)
6246 ui_out_field_skip (uiout
, "addr");
6248 ui_out_text (uiout
, "fork");
6249 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
6251 ui_out_text (uiout
, ", process ");
6252 ui_out_field_int (uiout
, "what",
6253 ptid_get_pid (c
->forked_inferior_pid
));
6254 ui_out_spaces (uiout
, 1);
6258 /* Implement the "print_mention" breakpoint_ops method for fork
6262 print_mention_catch_fork (struct breakpoint
*b
)
6264 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
6267 /* Implement the "print_recreate" breakpoint_ops method for fork
6271 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
6273 fprintf_unfiltered (fp
, "catch fork");
6274 print_recreate_thread (b
, fp
);
6277 /* The breakpoint_ops structure to be used in fork catchpoints. */
6279 static struct breakpoint_ops catch_fork_breakpoint_ops
;
6281 /* Implement the "insert" breakpoint_ops method for vfork
6285 insert_catch_vfork (struct bp_location
*bl
)
6287 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
6290 /* Implement the "remove" breakpoint_ops method for vfork
6294 remove_catch_vfork (struct bp_location
*bl
)
6296 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
6299 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6303 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
6304 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6306 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
6308 return inferior_has_vforked (inferior_ptid
, &c
->forked_inferior_pid
);
6311 /* Implement the "print_it" breakpoint_ops method for vfork
6314 static enum print_stop_action
6315 print_it_catch_vfork (bpstat bs
)
6317 struct ui_out
*uiout
= current_uiout
;
6318 struct breakpoint
*b
= bs
->breakpoint_at
;
6319 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6321 annotate_catchpoint (b
->number
);
6322 if (b
->disposition
== disp_del
)
6323 ui_out_text (uiout
, "\nTemporary catchpoint ");
6325 ui_out_text (uiout
, "\nCatchpoint ");
6326 if (ui_out_is_mi_like_p (uiout
))
6328 ui_out_field_string (uiout
, "reason",
6329 async_reason_lookup (EXEC_ASYNC_VFORK
));
6330 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6332 ui_out_field_int (uiout
, "bkptno", b
->number
);
6333 ui_out_text (uiout
, " (vforked process ");
6334 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
6335 ui_out_text (uiout
, "), ");
6336 return PRINT_SRC_AND_LOC
;
6339 /* Implement the "print_one" breakpoint_ops method for vfork
6343 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
6345 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
6346 struct value_print_options opts
;
6347 struct ui_out
*uiout
= current_uiout
;
6349 get_user_print_options (&opts
);
6350 /* Field 4, the address, is omitted (which makes the columns not
6351 line up too nicely with the headers, but the effect is relatively
6353 if (opts
.addressprint
)
6354 ui_out_field_skip (uiout
, "addr");
6356 ui_out_text (uiout
, "vfork");
6357 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
6359 ui_out_text (uiout
, ", process ");
6360 ui_out_field_int (uiout
, "what",
6361 ptid_get_pid (c
->forked_inferior_pid
));
6362 ui_out_spaces (uiout
, 1);
6366 /* Implement the "print_mention" breakpoint_ops method for vfork
6370 print_mention_catch_vfork (struct breakpoint
*b
)
6372 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
6375 /* Implement the "print_recreate" breakpoint_ops method for vfork
6379 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
6381 fprintf_unfiltered (fp
, "catch vfork");
6382 print_recreate_thread (b
, fp
);
6385 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6387 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
6389 /* An instance of this type is used to represent a syscall catchpoint.
6390 It includes a "struct breakpoint" as a kind of base class; users
6391 downcast to "struct breakpoint *" when needed. A breakpoint is
6392 really of this type iff its ops pointer points to
6393 CATCH_SYSCALL_BREAKPOINT_OPS. */
6395 struct syscall_catchpoint
6397 /* The base class. */
6398 struct breakpoint base
;
6400 /* Syscall numbers used for the 'catch syscall' feature. If no
6401 syscall has been specified for filtering, its value is NULL.
6402 Otherwise, it holds a list of all syscalls to be caught. The
6403 list elements are allocated with xmalloc. */
6404 VEC(int) *syscalls_to_be_caught
;
6407 /* Implement the "dtor" breakpoint_ops method for syscall
6411 dtor_catch_syscall (struct breakpoint
*b
)
6413 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6415 VEC_free (int, c
->syscalls_to_be_caught
);
6417 base_breakpoint_ops
.dtor (b
);
6420 /* Implement the "insert" breakpoint_ops method for syscall
6424 insert_catch_syscall (struct bp_location
*bl
)
6426 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bl
->owner
;
6427 struct inferior
*inf
= current_inferior ();
6429 ++inf
->total_syscalls_count
;
6430 if (!c
->syscalls_to_be_caught
)
6431 ++inf
->any_syscall_count
;
6437 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6442 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6444 int old_size
= VEC_length (int, inf
->syscalls_counts
);
6445 uintptr_t vec_addr_offset
6446 = old_size
* ((uintptr_t) sizeof (int));
6448 VEC_safe_grow (int, inf
->syscalls_counts
, iter
+ 1);
6449 vec_addr
= (uintptr_t) VEC_address (int, inf
->syscalls_counts
) +
6451 memset ((void *) vec_addr
, 0,
6452 (iter
+ 1 - old_size
) * sizeof (int));
6454 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6455 VEC_replace (int, inf
->syscalls_counts
, iter
, ++elem
);
6459 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6460 inf
->total_syscalls_count
!= 0,
6461 inf
->any_syscall_count
,
6462 VEC_length (int, inf
->syscalls_counts
),
6463 VEC_address (int, inf
->syscalls_counts
));
6466 /* Implement the "remove" breakpoint_ops method for syscall
6470 remove_catch_syscall (struct bp_location
*bl
)
6472 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bl
->owner
;
6473 struct inferior
*inf
= current_inferior ();
6475 --inf
->total_syscalls_count
;
6476 if (!c
->syscalls_to_be_caught
)
6477 --inf
->any_syscall_count
;
6483 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6487 if (iter
>= VEC_length (int, inf
->syscalls_counts
))
6488 /* Shouldn't happen. */
6490 elem
= VEC_index (int, inf
->syscalls_counts
, iter
);
6491 VEC_replace (int, inf
->syscalls_counts
, iter
, --elem
);
6495 return target_set_syscall_catchpoint (PIDGET (inferior_ptid
),
6496 inf
->total_syscalls_count
!= 0,
6497 inf
->any_syscall_count
,
6498 VEC_length (int, inf
->syscalls_counts
),
6500 inf
->syscalls_counts
));
6503 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6507 breakpoint_hit_catch_syscall (const struct bp_location
*bl
,
6508 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6510 /* We must check if we are catching specific syscalls in this
6511 breakpoint. If we are, then we must guarantee that the called
6512 syscall is the same syscall we are catching. */
6513 int syscall_number
= 0;
6514 const struct syscall_catchpoint
*c
6515 = (const struct syscall_catchpoint
*) bl
->owner
;
6517 if (!inferior_has_called_syscall (inferior_ptid
, &syscall_number
))
6520 /* Now, checking if the syscall is the same. */
6521 if (c
->syscalls_to_be_caught
)
6526 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6528 if (syscall_number
== iter
)
6538 /* Implement the "print_it" breakpoint_ops method for syscall
6541 static enum print_stop_action
6542 print_it_catch_syscall (bpstat bs
)
6544 struct ui_out
*uiout
= current_uiout
;
6545 struct breakpoint
*b
= bs
->breakpoint_at
;
6546 /* These are needed because we want to know in which state a
6547 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6548 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6549 must print "called syscall" or "returned from syscall". */
6551 struct target_waitstatus last
;
6555 get_last_target_status (&ptid
, &last
);
6557 get_syscall_by_number (last
.value
.syscall_number
, &s
);
6559 annotate_catchpoint (b
->number
);
6561 if (b
->disposition
== disp_del
)
6562 ui_out_text (uiout
, "\nTemporary catchpoint ");
6564 ui_out_text (uiout
, "\nCatchpoint ");
6565 if (ui_out_is_mi_like_p (uiout
))
6567 ui_out_field_string (uiout
, "reason",
6568 async_reason_lookup (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
6569 ? EXEC_ASYNC_SYSCALL_ENTRY
6570 : EXEC_ASYNC_SYSCALL_RETURN
));
6571 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6573 ui_out_field_int (uiout
, "bkptno", b
->number
);
6575 if (last
.kind
== TARGET_WAITKIND_SYSCALL_ENTRY
)
6576 ui_out_text (uiout
, " (call to syscall ");
6578 ui_out_text (uiout
, " (returned from syscall ");
6580 if (s
.name
== NULL
|| ui_out_is_mi_like_p (uiout
))
6581 ui_out_field_int (uiout
, "syscall-number", last
.value
.syscall_number
);
6583 ui_out_field_string (uiout
, "syscall-name", s
.name
);
6585 ui_out_text (uiout
, "), ");
6587 return PRINT_SRC_AND_LOC
;
6590 /* Implement the "print_one" breakpoint_ops method for syscall
6594 print_one_catch_syscall (struct breakpoint
*b
,
6595 struct bp_location
**last_loc
)
6597 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6598 struct value_print_options opts
;
6599 struct ui_out
*uiout
= current_uiout
;
6601 get_user_print_options (&opts
);
6602 /* Field 4, the address, is omitted (which makes the columns not
6603 line up too nicely with the headers, but the effect is relatively
6605 if (opts
.addressprint
)
6606 ui_out_field_skip (uiout
, "addr");
6609 if (c
->syscalls_to_be_caught
6610 && VEC_length (int, c
->syscalls_to_be_caught
) > 1)
6611 ui_out_text (uiout
, "syscalls \"");
6613 ui_out_text (uiout
, "syscall \"");
6615 if (c
->syscalls_to_be_caught
)
6618 char *text
= xstrprintf ("%s", "");
6621 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6626 get_syscall_by_number (iter
, &s
);
6629 text
= xstrprintf ("%s%s, ", text
, s
.name
);
6631 text
= xstrprintf ("%s%d, ", text
, iter
);
6633 /* We have to xfree the last 'text' (now stored at 'x')
6634 because xstrprintf dynamically allocates new space for it
6638 /* Remove the last comma. */
6639 text
[strlen (text
) - 2] = '\0';
6640 ui_out_field_string (uiout
, "what", text
);
6643 ui_out_field_string (uiout
, "what", "<any syscall>");
6644 ui_out_text (uiout
, "\" ");
6647 /* Implement the "print_mention" breakpoint_ops method for syscall
6651 print_mention_catch_syscall (struct breakpoint
*b
)
6653 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6655 if (c
->syscalls_to_be_caught
)
6659 if (VEC_length (int, c
->syscalls_to_be_caught
) > 1)
6660 printf_filtered (_("Catchpoint %d (syscalls"), b
->number
);
6662 printf_filtered (_("Catchpoint %d (syscall"), b
->number
);
6665 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6669 get_syscall_by_number (iter
, &s
);
6672 printf_filtered (" '%s' [%d]", s
.name
, s
.number
);
6674 printf_filtered (" %d", s
.number
);
6676 printf_filtered (")");
6679 printf_filtered (_("Catchpoint %d (any syscall)"),
6683 /* Implement the "print_recreate" breakpoint_ops method for syscall
6687 print_recreate_catch_syscall (struct breakpoint
*b
, struct ui_file
*fp
)
6689 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) b
;
6691 fprintf_unfiltered (fp
, "catch syscall");
6693 if (c
->syscalls_to_be_caught
)
6698 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
6703 get_syscall_by_number (iter
, &s
);
6705 fprintf_unfiltered (fp
, " %s", s
.name
);
6707 fprintf_unfiltered (fp
, " %d", s
.number
);
6710 print_recreate_thread (b
, fp
);
6713 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6715 static struct breakpoint_ops catch_syscall_breakpoint_ops
;
6717 /* Returns non-zero if 'b' is a syscall catchpoint. */
6720 syscall_catchpoint_p (struct breakpoint
*b
)
6722 return (b
->ops
== &catch_syscall_breakpoint_ops
);
6725 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
6726 is non-zero, then make the breakpoint temporary. If COND_STRING is
6727 not NULL, then store it in the breakpoint. OPS, if not NULL, is
6728 the breakpoint_ops structure associated to the catchpoint. */
6731 init_catchpoint (struct breakpoint
*b
,
6732 struct gdbarch
*gdbarch
, int tempflag
,
6734 const struct breakpoint_ops
*ops
)
6736 struct symtab_and_line sal
;
6739 sal
.pspace
= current_program_space
;
6741 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
6743 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
6744 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6748 install_breakpoint (int internal
, struct breakpoint
*b
, int update_gll
)
6750 add_to_breakpoint_chain (b
);
6751 set_breakpoint_number (internal
, b
);
6754 observer_notify_breakpoint_created (b
);
6757 update_global_location_list (1);
6761 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
6762 int tempflag
, char *cond_string
,
6763 const struct breakpoint_ops
*ops
)
6765 struct fork_catchpoint
*c
= XNEW (struct fork_catchpoint
);
6767 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
, ops
);
6769 c
->forked_inferior_pid
= null_ptid
;
6771 install_breakpoint (0, &c
->base
, 1);
6774 /* Exec catchpoints. */
6776 /* An instance of this type is used to represent an exec catchpoint.
6777 It includes a "struct breakpoint" as a kind of base class; users
6778 downcast to "struct breakpoint *" when needed. A breakpoint is
6779 really of this type iff its ops pointer points to
6780 CATCH_EXEC_BREAKPOINT_OPS. */
6782 struct exec_catchpoint
6784 /* The base class. */
6785 struct breakpoint base
;
6787 /* Filename of a program whose exec triggered this catchpoint.
6788 This field is only valid immediately after this catchpoint has
6790 char *exec_pathname
;
6793 /* Implement the "dtor" breakpoint_ops method for exec
6797 dtor_catch_exec (struct breakpoint
*b
)
6799 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
6801 xfree (c
->exec_pathname
);
6803 base_breakpoint_ops
.dtor (b
);
6807 insert_catch_exec (struct bp_location
*bl
)
6809 return target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
6813 remove_catch_exec (struct bp_location
*bl
)
6815 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
6819 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
6820 struct address_space
*aspace
, CORE_ADDR bp_addr
)
6822 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
6824 return inferior_has_execd (inferior_ptid
, &c
->exec_pathname
);
6827 static enum print_stop_action
6828 print_it_catch_exec (bpstat bs
)
6830 struct ui_out
*uiout
= current_uiout
;
6831 struct breakpoint
*b
= bs
->breakpoint_at
;
6832 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
6834 annotate_catchpoint (b
->number
);
6835 if (b
->disposition
== disp_del
)
6836 ui_out_text (uiout
, "\nTemporary catchpoint ");
6838 ui_out_text (uiout
, "\nCatchpoint ");
6839 if (ui_out_is_mi_like_p (uiout
))
6841 ui_out_field_string (uiout
, "reason",
6842 async_reason_lookup (EXEC_ASYNC_EXEC
));
6843 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6845 ui_out_field_int (uiout
, "bkptno", b
->number
);
6846 ui_out_text (uiout
, " (exec'd ");
6847 ui_out_field_string (uiout
, "new-exec", c
->exec_pathname
);
6848 ui_out_text (uiout
, "), ");
6850 return PRINT_SRC_AND_LOC
;
6854 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
6856 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
6857 struct value_print_options opts
;
6858 struct ui_out
*uiout
= current_uiout
;
6860 get_user_print_options (&opts
);
6862 /* Field 4, the address, is omitted (which makes the columns
6863 not line up too nicely with the headers, but the effect
6864 is relatively readable). */
6865 if (opts
.addressprint
)
6866 ui_out_field_skip (uiout
, "addr");
6868 ui_out_text (uiout
, "exec");
6869 if (c
->exec_pathname
!= NULL
)
6871 ui_out_text (uiout
, ", program \"");
6872 ui_out_field_string (uiout
, "what", c
->exec_pathname
);
6873 ui_out_text (uiout
, "\" ");
6878 print_mention_catch_exec (struct breakpoint
*b
)
6880 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
6883 /* Implement the "print_recreate" breakpoint_ops method for exec
6887 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
6889 fprintf_unfiltered (fp
, "catch exec");
6890 print_recreate_thread (b
, fp
);
6893 static struct breakpoint_ops catch_exec_breakpoint_ops
;
6896 create_syscall_event_catchpoint (int tempflag
, VEC(int) *filter
,
6897 const struct breakpoint_ops
*ops
)
6899 struct syscall_catchpoint
*c
;
6900 struct gdbarch
*gdbarch
= get_current_arch ();
6902 c
= XNEW (struct syscall_catchpoint
);
6903 init_catchpoint (&c
->base
, gdbarch
, tempflag
, NULL
, ops
);
6904 c
->syscalls_to_be_caught
= filter
;
6906 install_breakpoint (0, &c
->base
, 1);
6910 hw_breakpoint_used_count (void)
6913 struct breakpoint
*b
;
6914 struct bp_location
*bl
;
6918 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
6919 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6921 /* Special types of hardware breakpoints may use more than
6923 i
+= b
->ops
->resources_needed (bl
);
6930 /* Returns the resources B would use if it were a hardware
6934 hw_watchpoint_use_count (struct breakpoint
*b
)
6937 struct bp_location
*bl
;
6939 if (!breakpoint_enabled (b
))
6942 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6944 /* Special types of hardware watchpoints may use more than
6946 i
+= b
->ops
->resources_needed (bl
);
6952 /* Returns the sum the used resources of all hardware watchpoints of
6953 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
6954 the sum of the used resources of all hardware watchpoints of other
6955 types _not_ TYPE. */
6958 hw_watchpoint_used_count_others (struct breakpoint
*except
,
6959 enum bptype type
, int *other_type_used
)
6962 struct breakpoint
*b
;
6964 *other_type_used
= 0;
6969 if (!breakpoint_enabled (b
))
6972 if (b
->type
== type
)
6973 i
+= hw_watchpoint_use_count (b
);
6974 else if (is_hardware_watchpoint (b
))
6975 *other_type_used
= 1;
6982 disable_watchpoints_before_interactive_call_start (void)
6984 struct breakpoint
*b
;
6988 if (is_watchpoint (b
) && breakpoint_enabled (b
))
6990 b
->enable_state
= bp_call_disabled
;
6991 update_global_location_list (0);
6997 enable_watchpoints_after_interactive_call_stop (void)
6999 struct breakpoint
*b
;
7003 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
7005 b
->enable_state
= bp_enabled
;
7006 update_global_location_list (1);
7012 disable_breakpoints_before_startup (void)
7014 struct breakpoint
*b
;
7019 if (b
->pspace
!= current_program_space
)
7022 if ((b
->type
== bp_breakpoint
7023 || b
->type
== bp_hardware_breakpoint
)
7024 && breakpoint_enabled (b
))
7026 b
->enable_state
= bp_startup_disabled
;
7032 update_global_location_list (0);
7034 current_program_space
->executing_startup
= 1;
7038 enable_breakpoints_after_startup (void)
7040 struct breakpoint
*b
;
7043 current_program_space
->executing_startup
= 0;
7047 if (b
->pspace
!= current_program_space
)
7050 if ((b
->type
== bp_breakpoint
7051 || b
->type
== bp_hardware_breakpoint
)
7052 && b
->enable_state
== bp_startup_disabled
)
7054 b
->enable_state
= bp_enabled
;
7060 breakpoint_re_set ();
7064 /* Set a breakpoint that will evaporate an end of command
7065 at address specified by SAL.
7066 Restrict it to frame FRAME if FRAME is nonzero. */
7069 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
7070 struct frame_id frame_id
, enum bptype type
)
7072 struct breakpoint
*b
;
7074 /* If FRAME_ID is valid, it should be a real frame, not an inlined
7076 gdb_assert (!frame_id_inlined_p (frame_id
));
7078 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
7079 b
->enable_state
= bp_enabled
;
7080 b
->disposition
= disp_donttouch
;
7081 b
->frame_id
= frame_id
;
7083 /* If we're debugging a multi-threaded program, then we want
7084 momentary breakpoints to be active in only a single thread of
7086 if (in_thread_list (inferior_ptid
))
7087 b
->thread
= pid_to_thread_id (inferior_ptid
);
7089 update_global_location_list_nothrow (1);
7094 /* Make a momentary breakpoint based on the master breakpoint ORIG.
7095 The new breakpoint will have type TYPE, and use OPS as it
7098 static struct breakpoint
*
7099 momentary_breakpoint_from_master (struct breakpoint
*orig
,
7101 const struct breakpoint_ops
*ops
)
7103 struct breakpoint
*copy
;
7105 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
7106 copy
->loc
= allocate_bp_location (copy
);
7107 set_breakpoint_location_function (copy
->loc
, 1);
7109 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
7110 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
7111 copy
->loc
->address
= orig
->loc
->address
;
7112 copy
->loc
->section
= orig
->loc
->section
;
7113 copy
->loc
->pspace
= orig
->loc
->pspace
;
7115 if (orig
->source_file
== NULL
)
7116 copy
->source_file
= NULL
;
7118 copy
->source_file
= xstrdup (orig
->source_file
);
7120 copy
->line_number
= orig
->line_number
;
7121 copy
->frame_id
= orig
->frame_id
;
7122 copy
->thread
= orig
->thread
;
7123 copy
->pspace
= orig
->pspace
;
7125 copy
->enable_state
= bp_enabled
;
7126 copy
->disposition
= disp_donttouch
;
7127 copy
->number
= internal_breakpoint_number
--;
7129 update_global_location_list_nothrow (0);
7133 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
7137 clone_momentary_breakpoint (struct breakpoint
*orig
)
7139 /* If there's nothing to clone, then return nothing. */
7143 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
);
7147 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
7150 struct symtab_and_line sal
;
7152 sal
= find_pc_line (pc
, 0);
7154 sal
.section
= find_pc_overlay (pc
);
7155 sal
.explicit_pc
= 1;
7157 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
7161 /* Tell the user we have just set a breakpoint B. */
7164 mention (struct breakpoint
*b
)
7166 b
->ops
->print_mention (b
);
7167 if (ui_out_is_mi_like_p (current_uiout
))
7169 printf_filtered ("\n");
7173 static struct bp_location
*
7174 add_location_to_breakpoint (struct breakpoint
*b
,
7175 const struct symtab_and_line
*sal
)
7177 struct bp_location
*loc
, **tmp
;
7178 CORE_ADDR adjusted_address
;
7179 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
7181 if (loc_gdbarch
== NULL
)
7182 loc_gdbarch
= b
->gdbarch
;
7184 /* Adjust the breakpoint's address prior to allocating a location.
7185 Once we call allocate_bp_location(), that mostly uninitialized
7186 location will be placed on the location chain. Adjustment of the
7187 breakpoint may cause target_read_memory() to be called and we do
7188 not want its scan of the location chain to find a breakpoint and
7189 location that's only been partially initialized. */
7190 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
7193 loc
= allocate_bp_location (b
);
7194 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
7198 loc
->requested_address
= sal
->pc
;
7199 loc
->address
= adjusted_address
;
7200 loc
->pspace
= sal
->pspace
;
7201 gdb_assert (loc
->pspace
!= NULL
);
7202 loc
->section
= sal
->section
;
7203 loc
->gdbarch
= loc_gdbarch
;
7204 set_breakpoint_location_function (loc
,
7205 sal
->explicit_pc
|| sal
->explicit_line
);
7210 /* Return 1 if LOC is pointing to a permanent breakpoint,
7211 return 0 otherwise. */
7214 bp_loc_is_permanent (struct bp_location
*loc
)
7218 const gdb_byte
*brk
;
7219 gdb_byte
*target_mem
;
7220 struct cleanup
*cleanup
;
7223 gdb_assert (loc
!= NULL
);
7225 addr
= loc
->address
;
7226 brk
= gdbarch_breakpoint_from_pc (loc
->gdbarch
, &addr
, &len
);
7228 /* Software breakpoints unsupported? */
7232 target_mem
= alloca (len
);
7234 /* Enable the automatic memory restoration from breakpoints while
7235 we read the memory. Otherwise we could say about our temporary
7236 breakpoints they are permanent. */
7237 cleanup
= save_current_space_and_thread ();
7239 switch_to_program_space_and_thread (loc
->pspace
);
7240 make_show_memory_breakpoints_cleanup (0);
7242 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
7243 && memcmp (target_mem
, brk
, len
) == 0)
7246 do_cleanups (cleanup
);
7253 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7254 as textual description of the location, and COND_STRING
7255 as condition expression. */
7258 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7259 struct symtabs_and_lines sals
, char *addr_string
,
7261 enum bptype type
, enum bpdisp disposition
,
7262 int thread
, int task
, int ignore_count
,
7263 const struct breakpoint_ops
*ops
, int from_tty
,
7264 int enabled
, int internal
, int display_canonical
)
7268 if (type
== bp_hardware_breakpoint
)
7270 int target_resources_ok
;
7272 i
= hw_breakpoint_used_count ();
7273 target_resources_ok
=
7274 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
7276 if (target_resources_ok
== 0)
7277 error (_("No hardware breakpoint support in the target."));
7278 else if (target_resources_ok
< 0)
7279 error (_("Hardware breakpoints used exceeds limit."));
7282 gdb_assert (sals
.nelts
> 0);
7284 for (i
= 0; i
< sals
.nelts
; ++i
)
7286 struct symtab_and_line sal
= sals
.sals
[i
];
7287 struct bp_location
*loc
;
7291 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
7293 loc_gdbarch
= gdbarch
;
7295 describe_other_breakpoints (loc_gdbarch
,
7296 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
7301 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
7305 b
->cond_string
= cond_string
;
7306 b
->ignore_count
= ignore_count
;
7307 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
7308 b
->disposition
= disposition
;
7309 b
->pspace
= sals
.sals
[0].pspace
;
7311 if (type
== bp_static_tracepoint
)
7313 struct tracepoint
*t
= (struct tracepoint
*) b
;
7314 struct static_tracepoint_marker marker
;
7316 if (is_marker_spec (addr_string
))
7318 /* We already know the marker exists, otherwise, we
7319 wouldn't see a sal for it. */
7320 char *p
= &addr_string
[3];
7324 p
= skip_spaces (p
);
7326 endp
= skip_to_space (p
);
7328 marker_str
= savestring (p
, endp
- p
);
7329 t
->static_trace_marker_id
= marker_str
;
7331 printf_filtered (_("Probed static tracepoint "
7333 t
->static_trace_marker_id
);
7335 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
7337 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
7338 release_static_tracepoint_marker (&marker
);
7340 printf_filtered (_("Probed static tracepoint "
7342 t
->static_trace_marker_id
);
7345 warning (_("Couldn't determine the static "
7346 "tracepoint marker to probe"));
7349 if (enabled
&& b
->pspace
->executing_startup
7350 && (b
->type
== bp_breakpoint
7351 || b
->type
== bp_hardware_breakpoint
))
7352 b
->enable_state
= bp_startup_disabled
;
7358 loc
= add_location_to_breakpoint (b
, &sal
);
7361 if (bp_loc_is_permanent (loc
))
7362 make_breakpoint_permanent (b
);
7366 char *arg
= b
->cond_string
;
7367 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
7369 error (_("Garbage %s follows condition"), arg
);
7373 b
->display_canonical
= display_canonical
;
7375 b
->addr_string
= addr_string
;
7377 /* addr_string has to be used or breakpoint_re_set will delete
7380 = xstrprintf ("*%s", paddress (b
->loc
->gdbarch
, b
->loc
->address
));
7384 create_breakpoint_sal (struct gdbarch
*gdbarch
,
7385 struct symtabs_and_lines sals
, char *addr_string
,
7387 enum bptype type
, enum bpdisp disposition
,
7388 int thread
, int task
, int ignore_count
,
7389 const struct breakpoint_ops
*ops
, int from_tty
,
7390 int enabled
, int internal
, int display_canonical
)
7392 struct breakpoint
*b
;
7393 struct cleanup
*old_chain
;
7395 if (is_tracepoint_type (type
))
7397 struct tracepoint
*t
;
7399 t
= XCNEW (struct tracepoint
);
7403 b
= XNEW (struct breakpoint
);
7405 old_chain
= make_cleanup (xfree
, b
);
7407 init_breakpoint_sal (b
, gdbarch
,
7411 thread
, task
, ignore_count
,
7413 enabled
, internal
, display_canonical
);
7414 discard_cleanups (old_chain
);
7416 install_breakpoint (internal
, b
, 0);
7419 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7420 elements to fill the void space. */
7422 remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
7424 int i
= index_to_remove
+1;
7425 int last_index
= sal
->nelts
-1;
7427 for (;i
<= last_index
; ++i
)
7428 sal
->sals
[i
-1] = sal
->sals
[i
];
7433 /* If appropriate, obtains all sals that correspond to the same file
7434 and line as SAL, in all program spaces. Users debugging with IDEs,
7435 will want to set a breakpoint at foo.c:line, and not really care
7436 about program spaces. This is done only if SAL does not have
7437 explicit PC and has line and file information. If we got just a
7438 single expanded sal, return the original.
7440 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7441 which the name of enclosing function is different from SAL. This
7442 makes sure that if we have breakpoint originally set in template
7443 instantiation, say foo<int>(), we won't expand SAL to locations at
7444 the same line in all existing instantiations of 'foo'. */
7446 static struct symtabs_and_lines
7447 expand_line_sal_maybe (struct symtab_and_line sal
)
7449 struct symtabs_and_lines expanded
;
7450 CORE_ADDR original_pc
= sal
.pc
;
7451 char *original_function
= NULL
;
7454 struct cleanup
*old_chain
;
7456 /* If we have explicit pc, don't expand.
7457 If we have no line number, we can't expand. */
7458 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
7461 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7462 expanded
.sals
[0] = sal
;
7468 old_chain
= save_current_space_and_thread ();
7470 switch_to_program_space_and_thread (sal
.pspace
);
7472 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
7474 /* Note that expand_line_sal visits *all* program spaces. */
7475 expanded
= expand_line_sal (sal
);
7477 if (expanded
.nelts
== 1)
7479 /* We had one sal, we got one sal. Return that sal, adjusting it
7480 past the function prologue if necessary. */
7481 xfree (expanded
.sals
);
7483 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7484 sal
.pc
= original_pc
;
7485 expanded
.sals
[0] = sal
;
7486 skip_prologue_sal (&expanded
.sals
[0]);
7487 do_cleanups (old_chain
);
7491 if (!sal
.explicit_line
)
7493 CORE_ADDR func_addr
, func_end
;
7494 for (i
= 0; i
< expanded
.nelts
; ++i
)
7496 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
7497 char *this_function
;
7499 /* We need to switch threads as well since we're about to
7501 switch_to_program_space_and_thread (expanded
.sals
[i
].pspace
);
7503 if (find_pc_partial_function (pc
, &this_function
,
7504 &func_addr
, &func_end
))
7507 && strcmp (this_function
, original_function
) != 0)
7509 remove_sal (&expanded
, i
);
7516 /* Skip the function prologue if necessary. */
7517 for (i
= 0; i
< expanded
.nelts
; ++i
)
7518 skip_prologue_sal (&expanded
.sals
[i
]);
7520 do_cleanups (old_chain
);
7522 if (expanded
.nelts
<= 1)
7524 /* This is an ugly workaround. If we get zero expanded sals
7525 then something is really wrong. Fix that by returning the
7528 xfree (expanded
.sals
);
7530 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
7531 sal
.pc
= original_pc
;
7532 expanded
.sals
[0] = sal
;
7539 for (i
= 0; i
< expanded
.nelts
; ++i
)
7540 if (expanded
.sals
[i
].pc
== original_pc
)
7551 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7552 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7553 value. COND_STRING, if not NULL, specified the condition to be
7554 used for all breakpoints. Essentially the only case where
7555 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7556 function. In that case, it's still not possible to specify
7557 separate conditions for different overloaded functions, so
7558 we take just a single condition string.
7560 NOTE: If the function succeeds, the caller is expected to cleanup
7561 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7562 array contents). If the function fails (error() is called), the
7563 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7564 COND and SALS arrays and each of those arrays contents. */
7567 create_breakpoints_sal (struct gdbarch
*gdbarch
,
7568 struct symtabs_and_lines sals
,
7569 struct linespec_result
*canonical
,
7571 enum bptype type
, enum bpdisp disposition
,
7572 int thread
, int task
, int ignore_count
,
7573 const struct breakpoint_ops
*ops
, int from_tty
,
7574 int enabled
, int internal
)
7578 for (i
= 0; i
< sals
.nelts
; ++i
)
7580 struct symtabs_and_lines expanded
=
7581 expand_line_sal_maybe (sals
.sals
[i
]);
7583 create_breakpoint_sal (gdbarch
, expanded
, canonical
->canonical
[i
],
7584 cond_string
, type
, disposition
,
7585 thread
, task
, ignore_count
, ops
,
7586 from_tty
, enabled
, internal
,
7587 canonical
->special_display
);
7591 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7592 followed by conditionals. On return, SALS contains an array of SAL
7593 addresses found. ADDR_STRING contains a vector of (canonical)
7594 address strings. ADDRESS points to the end of the SAL.
7596 The array and the line spec strings are allocated on the heap, it is
7597 the caller's responsibility to free them. */
7600 parse_breakpoint_sals (char **address
,
7601 struct symtabs_and_lines
*sals
,
7602 struct linespec_result
*canonical
)
7604 char *addr_start
= *address
;
7606 /* If no arg given, or if first arg is 'if ', use the default
7608 if ((*address
) == NULL
7609 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
7611 /* The last displayed codepoint, if it's valid, is our default breakpoint
7613 if (last_displayed_sal_is_valid ())
7615 struct symtab_and_line sal
;
7617 init_sal (&sal
); /* Initialize to zeroes. */
7618 sals
->sals
= (struct symtab_and_line
*)
7619 xmalloc (sizeof (struct symtab_and_line
));
7621 /* Set sal's pspace, pc, symtab, and line to the values
7622 corresponding to the last call to print_frame_info. */
7623 get_last_displayed_sal (&sal
);
7624 sal
.section
= find_pc_overlay (sal
.pc
);
7626 /* "break" without arguments is equivalent to "break *PC"
7627 where PC is the last displayed codepoint's address. So
7628 make sure to set sal.explicit_pc to prevent GDB from
7629 trying to expand the list of sals to include all other
7630 instances with the same symtab and line. */
7631 sal
.explicit_pc
= 1;
7633 sals
->sals
[0] = sal
;
7637 error (_("No default breakpoint address now."));
7641 /* Force almost all breakpoints to be in terms of the
7642 current_source_symtab (which is decode_line_1's default).
7643 This should produce the results we want almost all of the
7644 time while leaving the last displayed codepoint pointers
7647 ObjC: However, don't match an Objective-C method name which
7648 may have a '+' or '-' succeeded by a '[' */
7650 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
7652 if (last_displayed_sal_is_valid ()
7654 || ((strchr ("+-", (*address
)[0]) != NULL
)
7655 && ((*address
)[1] != '['))))
7656 *sals
= decode_line_1 (address
, 1,
7657 get_last_displayed_symtab (),
7658 get_last_displayed_line (),
7661 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
7664 /* For any SAL that didn't have a canonical string, fill one in. */
7665 if (sals
->nelts
> 0 && canonical
->canonical
== NULL
)
7666 canonical
->canonical
= xcalloc (sals
->nelts
, sizeof (char *));
7667 if (addr_start
!= (*address
))
7671 for (i
= 0; i
< sals
->nelts
; i
++)
7673 /* Add the string if not present. */
7674 if (canonical
->canonical
[i
] == NULL
)
7675 canonical
->canonical
[i
] = savestring (addr_start
,
7676 (*address
) - addr_start
);
7682 /* Convert each SAL into a real PC. Verify that the PC can be
7683 inserted as a breakpoint. If it can't throw an error. */
7686 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
7690 for (i
= 0; i
< sals
->nelts
; i
++)
7691 resolve_sal_pc (&sals
->sals
[i
]);
7694 /* Fast tracepoints may have restrictions on valid locations. For
7695 instance, a fast tracepoint using a jump instead of a trap will
7696 likely have to overwrite more bytes than a trap would, and so can
7697 only be placed where the instruction is longer than the jump, or a
7698 multi-instruction sequence does not have a jump into the middle of
7702 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
7703 struct symtabs_and_lines
*sals
)
7706 struct symtab_and_line
*sal
;
7708 struct cleanup
*old_chain
;
7710 for (i
= 0; i
< sals
->nelts
; i
++)
7712 sal
= &sals
->sals
[i
];
7714 rslt
= gdbarch_fast_tracepoint_valid_at (gdbarch
, sal
->pc
,
7716 old_chain
= make_cleanup (xfree
, msg
);
7719 error (_("May not have a fast tracepoint at 0x%s%s"),
7720 paddress (gdbarch
, sal
->pc
), (msg
? msg
: ""));
7722 do_cleanups (old_chain
);
7726 /* Given TOK, a string specification of condition and thread, as
7727 accepted by the 'break' command, extract the condition
7728 string and thread number and set *COND_STRING and *THREAD.
7729 PC identifies the context at which the condition should be parsed.
7730 If no condition is found, *COND_STRING is set to NULL.
7731 If no thread is found, *THREAD is set to -1. */
7733 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
7734 char **cond_string
, int *thread
, int *task
)
7736 *cond_string
= NULL
;
7742 char *cond_start
= NULL
;
7743 char *cond_end
= NULL
;
7745 tok
= skip_spaces (tok
);
7747 end_tok
= skip_to_space (tok
);
7749 toklen
= end_tok
- tok
;
7751 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
7753 struct expression
*expr
;
7755 tok
= cond_start
= end_tok
+ 1;
7756 expr
= parse_exp_1 (&tok
, block_for_pc (pc
), 0);
7759 *cond_string
= savestring (cond_start
,
7760 cond_end
- cond_start
);
7762 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
7768 *thread
= strtol (tok
, &tok
, 0);
7770 error (_("Junk after thread keyword."));
7771 if (!valid_thread_id (*thread
))
7772 error (_("Unknown thread %d."), *thread
);
7774 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
7780 *task
= strtol (tok
, &tok
, 0);
7782 error (_("Junk after task keyword."));
7783 if (!valid_task_id (*task
))
7784 error (_("Unknown task %d."), *task
);
7787 error (_("Junk at end of arguments."));
7791 /* Decode a static tracepoint marker spec. */
7793 static struct symtabs_and_lines
7794 decode_static_tracepoint_spec (char **arg_p
)
7796 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
7797 struct symtabs_and_lines sals
;
7798 struct symtab_and_line sal
;
7800 struct cleanup
*old_chain
;
7801 char *p
= &(*arg_p
)[3];
7806 p
= skip_spaces (p
);
7808 endp
= skip_to_space (p
);
7810 marker_str
= savestring (p
, endp
- p
);
7811 old_chain
= make_cleanup (xfree
, marker_str
);
7813 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
7814 if (VEC_empty(static_tracepoint_marker_p
, markers
))
7815 error (_("No known static tracepoint marker named %s"), marker_str
);
7817 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
7818 sals
.sals
= xmalloc (sizeof *sals
.sals
* sals
.nelts
);
7820 for (i
= 0; i
< sals
.nelts
; i
++)
7822 struct static_tracepoint_marker
*marker
;
7824 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
7826 init_sal (&sals
.sals
[i
]);
7828 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
7829 sals
.sals
[i
].pc
= marker
->address
;
7831 release_static_tracepoint_marker (marker
);
7834 do_cleanups (old_chain
);
7840 /* Set a breakpoint. This function is shared between CLI and MI
7841 functions for setting a breakpoint. This function has two major
7842 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7843 parameter. If non-zero, the function will parse arg, extracting
7844 breakpoint location, address and thread. Otherwise, ARG is just
7845 the location of breakpoint, with condition and thread specified by
7846 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
7847 the breakpoint number will be allocated from the internal
7848 breakpoint count. Returns true if any breakpoint was created;
7852 create_breakpoint (struct gdbarch
*gdbarch
,
7853 char *arg
, char *cond_string
, int thread
,
7854 int parse_condition_and_thread
,
7855 int tempflag
, enum bptype type_wanted
,
7857 enum auto_boolean pending_break_support
,
7858 const struct breakpoint_ops
*ops
,
7859 int from_tty
, int enabled
, int internal
)
7861 volatile struct gdb_exception e
;
7862 struct symtabs_and_lines sals
;
7863 struct symtab_and_line pending_sal
;
7865 char *addr_start
= arg
;
7866 struct linespec_result canonical
;
7867 struct cleanup
*old_chain
;
7868 struct cleanup
*bkpt_chain
= NULL
;
7872 int prev_bkpt_count
= breakpoint_count
;
7874 gdb_assert (ops
!= NULL
);
7878 init_linespec_result (&canonical
);
7880 if (type_wanted
== bp_static_tracepoint
&& is_marker_spec (arg
))
7884 sals
= decode_static_tracepoint_spec (&arg
);
7886 copy_arg
= savestring (addr_start
, arg
- addr_start
);
7887 canonical
.canonical
= xcalloc (sals
.nelts
, sizeof (char *));
7888 for (i
= 0; i
< sals
.nelts
; i
++)
7889 canonical
.canonical
[i
] = xstrdup (copy_arg
);
7893 TRY_CATCH (e
, RETURN_MASK_ALL
)
7895 parse_breakpoint_sals (&arg
, &sals
, &canonical
);
7898 /* If caller is interested in rc value from parse, set value. */
7902 throw_exception (e
);
7906 case NOT_FOUND_ERROR
:
7908 /* If pending breakpoint support is turned off, throw
7911 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
7912 throw_exception (e
);
7914 exception_print (gdb_stderr
, e
);
7916 /* If pending breakpoint support is auto query and the user
7917 selects no, then simply return the error code. */
7918 if (pending_break_support
== AUTO_BOOLEAN_AUTO
7919 && !nquery (_("Make %s pending on future shared library load? "),
7920 bptype_string (type_wanted
)))
7923 /* At this point, either the user was queried about setting
7924 a pending breakpoint and selected yes, or pending
7925 breakpoint behavior is on and thus a pending breakpoint
7926 is defaulted on behalf of the user. */
7927 copy_arg
= xstrdup (addr_start
);
7928 canonical
.canonical
= ©_arg
;
7930 sals
.sals
= &pending_sal
;
7935 throw_exception (e
);
7945 /* Create a chain of things that always need to be cleaned up. */
7946 old_chain
= make_cleanup (null_cleanup
, 0);
7950 /* Make sure that all storage allocated to SALS gets freed. */
7951 make_cleanup (xfree
, sals
.sals
);
7953 /* Cleanup the canonical array but not its contents. */
7954 make_cleanup (xfree
, canonical
.canonical
);
7957 /* ----------------------------- SNIP -----------------------------
7958 Anything added to the cleanup chain beyond this point is assumed
7959 to be part of a breakpoint. If the breakpoint create succeeds
7960 then the memory is not reclaimed. */
7961 bkpt_chain
= make_cleanup (null_cleanup
, 0);
7963 /* Mark the contents of the canonical for cleanup. These go on
7964 the bkpt_chain and only occur if the breakpoint create fails. */
7965 for (i
= 0; i
< sals
.nelts
; i
++)
7967 if (canonical
.canonical
[i
] != NULL
)
7968 make_cleanup (xfree
, canonical
.canonical
[i
]);
7971 /* Resolve all line numbers to PC's and verify that the addresses
7972 are ok for the target. */
7974 breakpoint_sals_to_pc (&sals
);
7976 /* Fast tracepoints may have additional restrictions on location. */
7977 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
7978 check_fast_tracepoint_sals (gdbarch
, &sals
);
7980 /* Verify that condition can be parsed, before setting any
7981 breakpoints. Allocate a separate condition expression for each
7985 if (parse_condition_and_thread
)
7987 /* Here we only parse 'arg' to separate condition
7988 from thread number, so parsing in context of first
7989 sal is OK. When setting the breakpoint we'll
7990 re-parse it in context of each sal. */
7993 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
,
7996 make_cleanup (xfree
, cond_string
);
8000 /* Create a private copy of condition string. */
8003 cond_string
= xstrdup (cond_string
);
8004 make_cleanup (xfree
, cond_string
);
8008 /* If the user is creating a static tracepoint by marker id
8009 (strace -m MARKER_ID), then store the sals index, so that
8010 breakpoint_re_set can try to match up which of the newly
8011 found markers corresponds to this one, and, don't try to
8012 expand multiple locations for each sal, given than SALS
8013 already should contain all sals for MARKER_ID. */
8014 if (type_wanted
== bp_static_tracepoint
8015 && is_marker_spec (canonical
.canonical
[0]))
8019 for (i
= 0; i
< sals
.nelts
; ++i
)
8021 struct symtabs_and_lines expanded
;
8022 struct tracepoint
*tp
;
8023 struct cleanup
*old_chain
;
8026 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
8027 expanded
.sals
[0] = sals
.sals
[i
];
8028 old_chain
= make_cleanup (xfree
, expanded
.sals
);
8030 tp
= XCNEW (struct tracepoint
);
8031 init_breakpoint_sal (&tp
->base
, gdbarch
, expanded
,
8032 canonical
.canonical
[i
],
8033 cond_string
, type_wanted
,
8034 tempflag
? disp_del
: disp_donttouch
,
8035 thread
, task
, ignore_count
, ops
,
8036 from_tty
, enabled
, internal
,
8037 canonical
.special_display
);
8038 /* Given that its possible to have multiple markers with
8039 the same string id, if the user is creating a static
8040 tracepoint by marker id ("strace -m MARKER_ID"), then
8041 store the sals index, so that breakpoint_re_set can
8042 try to match up which of the newly found markers
8043 corresponds to this one */
8044 tp
->static_trace_marker_id_idx
= i
;
8046 install_breakpoint (internal
, &tp
->base
, 0);
8048 do_cleanups (old_chain
);
8052 create_breakpoints_sal (gdbarch
, sals
, &canonical
, cond_string
,
8054 tempflag
? disp_del
: disp_donttouch
,
8055 thread
, task
, ignore_count
, ops
, from_tty
,
8060 struct breakpoint
*b
;
8062 make_cleanup (xfree
, copy_arg
);
8064 if (is_tracepoint_type (type_wanted
))
8066 struct tracepoint
*t
;
8068 t
= XCNEW (struct tracepoint
);
8072 b
= XNEW (struct breakpoint
);
8074 init_raw_breakpoint_without_location (b
, gdbarch
, type_wanted
, ops
);
8076 b
->addr_string
= canonical
.canonical
[0];
8077 b
->cond_string
= NULL
;
8078 b
->ignore_count
= ignore_count
;
8079 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8080 b
->condition_not_parsed
= 1;
8081 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8082 b
->pspace
= current_program_space
;
8084 if (enabled
&& b
->pspace
->executing_startup
8085 && (b
->type
== bp_breakpoint
8086 || b
->type
== bp_hardware_breakpoint
))
8087 b
->enable_state
= bp_startup_disabled
;
8089 install_breakpoint (internal
, b
, 0);
8094 warning (_("Multiple breakpoints were set.\nUse the "
8095 "\"delete\" command to delete unwanted breakpoints."));
8096 prev_breakpoint_count
= prev_bkpt_count
;
8099 /* That's it. Discard the cleanups for data inserted into the
8101 discard_cleanups (bkpt_chain
);
8102 /* But cleanup everything else. */
8103 do_cleanups (old_chain
);
8105 /* error call may happen here - have BKPT_CHAIN already discarded. */
8106 update_global_location_list (1);
8111 /* Set a breakpoint.
8112 ARG is a string describing breakpoint address,
8113 condition, and thread.
8114 FLAG specifies if a breakpoint is hardware on,
8115 and if breakpoint is temporary, using BP_HARDWARE_FLAG
8119 break_command_1 (char *arg
, int flag
, int from_tty
)
8121 int tempflag
= flag
& BP_TEMPFLAG
;
8122 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
8123 ? bp_hardware_breakpoint
8126 create_breakpoint (get_current_arch (),
8128 NULL
, 0, 1 /* parse arg */,
8129 tempflag
, type_wanted
,
8130 0 /* Ignore count */,
8131 pending_break_support
,
8132 &bkpt_breakpoint_ops
,
8138 /* Helper function for break_command_1 and disassemble_command. */
8141 resolve_sal_pc (struct symtab_and_line
*sal
)
8145 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
8147 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
8148 error (_("No line %d in file \"%s\"."),
8149 sal
->line
, sal
->symtab
->filename
);
8152 /* If this SAL corresponds to a breakpoint inserted using a line
8153 number, then skip the function prologue if necessary. */
8154 if (sal
->explicit_line
)
8155 skip_prologue_sal (sal
);
8158 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
8160 struct blockvector
*bv
;
8164 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
8167 sym
= block_linkage_function (b
);
8170 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
8171 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
8175 /* It really is worthwhile to have the section, so we'll
8176 just have to look harder. This case can be executed
8177 if we have line numbers but no functions (as can
8178 happen in assembly source). */
8180 struct minimal_symbol
*msym
;
8181 struct cleanup
*old_chain
= save_current_space_and_thread ();
8183 switch_to_program_space_and_thread (sal
->pspace
);
8185 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
8187 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
8189 do_cleanups (old_chain
);
8196 break_command (char *arg
, int from_tty
)
8198 break_command_1 (arg
, 0, from_tty
);
8202 tbreak_command (char *arg
, int from_tty
)
8204 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
8208 hbreak_command (char *arg
, int from_tty
)
8210 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
8214 thbreak_command (char *arg
, int from_tty
)
8216 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
8220 stop_command (char *arg
, int from_tty
)
8222 printf_filtered (_("Specify the type of breakpoint to set.\n\
8223 Usage: stop in <function | address>\n\
8224 stop at <line>\n"));
8228 stopin_command (char *arg
, int from_tty
)
8232 if (arg
== (char *) NULL
)
8234 else if (*arg
!= '*')
8239 /* Look for a ':'. If this is a line number specification, then
8240 say it is bad, otherwise, it should be an address or
8241 function/method name. */
8242 while (*argptr
&& !hasColon
)
8244 hasColon
= (*argptr
== ':');
8249 badInput
= (*argptr
!= ':'); /* Not a class::method */
8251 badInput
= isdigit (*arg
); /* a simple line number */
8255 printf_filtered (_("Usage: stop in <function | address>\n"));
8257 break_command_1 (arg
, 0, from_tty
);
8261 stopat_command (char *arg
, int from_tty
)
8265 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
8272 /* Look for a ':'. If there is a '::' then get out, otherwise
8273 it is probably a line number. */
8274 while (*argptr
&& !hasColon
)
8276 hasColon
= (*argptr
== ':');
8281 badInput
= (*argptr
== ':'); /* we have class::method */
8283 badInput
= !isdigit (*arg
); /* not a line number */
8287 printf_filtered (_("Usage: stop at <line>\n"));
8289 break_command_1 (arg
, 0, from_tty
);
8292 /* Implement the "breakpoint_hit" breakpoint_ops method for
8293 ranged breakpoints. */
8296 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
8297 struct address_space
*aspace
,
8300 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
8301 bl
->length
, aspace
, bp_addr
);
8304 /* Implement the "resources_needed" breakpoint_ops method for
8305 ranged breakpoints. */
8308 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
8310 return target_ranged_break_num_registers ();
8313 /* Implement the "print_it" breakpoint_ops method for
8314 ranged breakpoints. */
8316 static enum print_stop_action
8317 print_it_ranged_breakpoint (bpstat bs
)
8319 struct breakpoint
*b
= bs
->breakpoint_at
;
8320 struct bp_location
*bl
= b
->loc
;
8321 struct ui_out
*uiout
= current_uiout
;
8323 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8325 /* Ranged breakpoints have only one location. */
8326 gdb_assert (bl
&& bl
->next
== NULL
);
8328 annotate_breakpoint (b
->number
);
8329 if (b
->disposition
== disp_del
)
8330 ui_out_text (uiout
, "\nTemporary ranged breakpoint ");
8332 ui_out_text (uiout
, "\nRanged breakpoint ");
8333 if (ui_out_is_mi_like_p (uiout
))
8335 ui_out_field_string (uiout
, "reason",
8336 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
8337 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8339 ui_out_field_int (uiout
, "bkptno", b
->number
);
8340 ui_out_text (uiout
, ", ");
8342 return PRINT_SRC_AND_LOC
;
8345 /* Implement the "print_one" breakpoint_ops method for
8346 ranged breakpoints. */
8349 print_one_ranged_breakpoint (struct breakpoint
*b
,
8350 struct bp_location
**last_loc
)
8352 struct bp_location
*bl
= b
->loc
;
8353 struct value_print_options opts
;
8354 struct ui_out
*uiout
= current_uiout
;
8356 /* Ranged breakpoints have only one location. */
8357 gdb_assert (bl
&& bl
->next
== NULL
);
8359 get_user_print_options (&opts
);
8361 if (opts
.addressprint
)
8362 /* We don't print the address range here, it will be printed later
8363 by print_one_detail_ranged_breakpoint. */
8364 ui_out_field_skip (uiout
, "addr");
8366 print_breakpoint_location (b
, bl
);
8370 /* Implement the "print_one_detail" breakpoint_ops method for
8371 ranged breakpoints. */
8374 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
8375 struct ui_out
*uiout
)
8377 CORE_ADDR address_start
, address_end
;
8378 struct bp_location
*bl
= b
->loc
;
8379 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
8380 struct cleanup
*cleanup
= make_cleanup_ui_out_stream_delete (stb
);
8384 address_start
= bl
->address
;
8385 address_end
= address_start
+ bl
->length
- 1;
8387 ui_out_text (uiout
, "\taddress range: ");
8388 fprintf_unfiltered (stb
->stream
, "[%s, %s]",
8389 print_core_address (bl
->gdbarch
, address_start
),
8390 print_core_address (bl
->gdbarch
, address_end
));
8391 ui_out_field_stream (uiout
, "addr", stb
);
8392 ui_out_text (uiout
, "\n");
8394 do_cleanups (cleanup
);
8397 /* Implement the "print_mention" breakpoint_ops method for
8398 ranged breakpoints. */
8401 print_mention_ranged_breakpoint (struct breakpoint
*b
)
8403 struct bp_location
*bl
= b
->loc
;
8404 struct ui_out
*uiout
= current_uiout
;
8407 gdb_assert (b
->type
== bp_hardware_breakpoint
);
8409 if (ui_out_is_mi_like_p (uiout
))
8412 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
8413 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
8414 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
8417 /* Implement the "print_recreate" breakpoint_ops method for
8418 ranged breakpoints. */
8421 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8423 fprintf_unfiltered (fp
, "break-range %s, %s", b
->addr_string
,
8424 b
->addr_string_range_end
);
8425 print_recreate_thread (b
, fp
);
8428 /* The breakpoint_ops structure to be used in ranged breakpoints. */
8430 static struct breakpoint_ops ranged_breakpoint_ops
;
8432 /* Find the address where the end of the breakpoint range should be
8433 placed, given the SAL of the end of the range. This is so that if
8434 the user provides a line number, the end of the range is set to the
8435 last instruction of the given line. */
8438 find_breakpoint_range_end (struct symtab_and_line sal
)
8442 /* If the user provided a PC value, use it. Otherwise,
8443 find the address of the end of the given location. */
8444 if (sal
.explicit_pc
)
8451 ret
= find_line_pc_range (sal
, &start
, &end
);
8453 error (_("Could not find location of the end of the range."));
8455 /* find_line_pc_range returns the start of the next line. */
8462 /* Implement the "break-range" CLI command. */
8465 break_range_command (char *arg
, int from_tty
)
8467 char *arg_start
, *addr_string_start
, *addr_string_end
;
8468 struct linespec_result canonical_start
, canonical_end
;
8469 int bp_count
, can_use_bp
, length
;
8471 struct breakpoint
*b
;
8472 struct symtab_and_line sal_start
, sal_end
;
8473 struct symtabs_and_lines sals_start
, sals_end
;
8474 struct cleanup
*cleanup_bkpt
;
8476 /* We don't support software ranged breakpoints. */
8477 if (target_ranged_break_num_registers () < 0)
8478 error (_("This target does not support hardware ranged breakpoints."));
8480 bp_count
= hw_breakpoint_used_count ();
8481 bp_count
+= target_ranged_break_num_registers ();
8482 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8485 error (_("Hardware breakpoints used exceeds limit."));
8487 if (arg
== NULL
|| arg
[0] == '\0')
8488 error(_("No address range specified."));
8490 sals_start
.sals
= NULL
;
8491 sals_start
.nelts
= 0;
8492 init_linespec_result (&canonical_start
);
8494 while (*arg
== ' ' || *arg
== '\t')
8497 parse_breakpoint_sals (&arg
, &sals_start
, &canonical_start
);
8499 sal_start
= sals_start
.sals
[0];
8500 addr_string_start
= canonical_start
.canonical
[0];
8501 cleanup_bkpt
= make_cleanup (xfree
, addr_string_start
);
8502 xfree (sals_start
.sals
);
8503 xfree (canonical_start
.canonical
);
8506 error (_("Too few arguments."));
8507 else if (sals_start
.nelts
== 0)
8508 error (_("Could not find location of the beginning of the range."));
8509 else if (sals_start
.nelts
!= 1)
8510 error (_("Cannot create a ranged breakpoint with multiple locations."));
8512 resolve_sal_pc (&sal_start
);
8514 arg
++; /* Skip the comma. */
8515 while (*arg
== ' ' || *arg
== '\t')
8518 /* Parse the end location. */
8520 sals_end
.sals
= NULL
;
8522 init_linespec_result (&canonical_end
);
8525 /* We call decode_line_1 directly here instead of using
8526 parse_breakpoint_sals because we need to specify the start location's
8527 symtab and line as the default symtab and line for the end of the
8528 range. This makes it possible to have ranges like "foo.c:27, +14",
8529 where +14 means 14 lines from the start location. */
8530 sals_end
= decode_line_1 (&arg
, 1, sal_start
.symtab
, sal_start
.line
,
8533 /* canonical_end can be NULL if it was of the form "*0xdeadbeef". */
8534 if (canonical_end
.canonical
== NULL
)
8535 canonical_end
.canonical
= xcalloc (1, sizeof (char *));
8536 /* Add the string if not present. */
8537 if (arg_start
!= arg
&& canonical_end
.canonical
[0] == NULL
)
8538 canonical_end
.canonical
[0] = savestring (arg_start
, arg
- arg_start
);
8540 sal_end
= sals_end
.sals
[0];
8541 addr_string_end
= canonical_end
.canonical
[0];
8542 make_cleanup (xfree
, addr_string_end
);
8543 xfree (sals_end
.sals
);
8544 xfree (canonical_end
.canonical
);
8546 if (sals_end
.nelts
== 0)
8547 error (_("Could not find location of the end of the range."));
8548 else if (sals_end
.nelts
!= 1)
8549 error (_("Cannot create a ranged breakpoint with multiple locations."));
8551 resolve_sal_pc (&sal_end
);
8553 end
= find_breakpoint_range_end (sal_end
);
8554 if (sal_start
.pc
> end
)
8555 error (_("Invalid address range, end precedes start."));
8557 length
= end
- sal_start
.pc
+ 1;
8559 /* Length overflowed. */
8560 error (_("Address range too large."));
8561 else if (length
== 1)
8563 /* This range is simple enough to be handled by
8564 the `hbreak' command. */
8565 hbreak_command (addr_string_start
, 1);
8567 do_cleanups (cleanup_bkpt
);
8572 /* Now set up the breakpoint. */
8573 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
8574 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
8575 set_breakpoint_count (breakpoint_count
+ 1);
8576 b
->number
= breakpoint_count
;
8577 b
->disposition
= disp_donttouch
;
8578 b
->addr_string
= addr_string_start
;
8579 b
->addr_string_range_end
= addr_string_end
;
8580 b
->loc
->length
= length
;
8582 discard_cleanups (cleanup_bkpt
);
8585 observer_notify_breakpoint_created (b
);
8586 update_global_location_list (1);
8589 /* Return non-zero if EXP is verified as constant. Returned zero
8590 means EXP is variable. Also the constant detection may fail for
8591 some constant expressions and in such case still falsely return
8594 watchpoint_exp_is_const (const struct expression
*exp
)
8602 /* We are only interested in the descriptor of each element. */
8603 operator_length (exp
, i
, &oplenp
, &argsp
);
8606 switch (exp
->elts
[i
].opcode
)
8616 case BINOP_LOGICAL_AND
:
8617 case BINOP_LOGICAL_OR
:
8618 case BINOP_BITWISE_AND
:
8619 case BINOP_BITWISE_IOR
:
8620 case BINOP_BITWISE_XOR
:
8622 case BINOP_NOTEQUAL
:
8638 case TERNOP_SLICE_COUNT
:
8650 case OP_OBJC_NSSTRING
:
8653 case UNOP_LOGICAL_NOT
:
8654 case UNOP_COMPLEMENT
:
8657 /* Unary, binary and ternary operators: We have to check
8658 their operands. If they are constant, then so is the
8659 result of that operation. For instance, if A and B are
8660 determined to be constants, then so is "A + B".
8662 UNOP_IND is one exception to the rule above, because the
8663 value of *ADDR is not necessarily a constant, even when
8668 /* Check whether the associated symbol is a constant.
8670 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8671 possible that a buggy compiler could mark a variable as
8672 constant even when it is not, and TYPE_CONST would return
8673 true in this case, while SYMBOL_CLASS wouldn't.
8675 We also have to check for function symbols because they
8676 are always constant. */
8678 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
8680 if (SYMBOL_CLASS (s
) != LOC_BLOCK
8681 && SYMBOL_CLASS (s
) != LOC_CONST
8682 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
8687 /* The default action is to return 0 because we are using
8688 the optimistic approach here: If we don't know something,
8689 then it is not a constant. */
8698 /* Implement the "dtor" breakpoint_ops method for watchpoints. */
8701 dtor_watchpoint (struct breakpoint
*self
)
8703 struct watchpoint
*w
= (struct watchpoint
*) self
;
8705 xfree (w
->cond_exp
);
8707 xfree (w
->exp_string
);
8708 xfree (w
->exp_string_reparse
);
8709 value_free (w
->val
);
8711 base_breakpoint_ops
.dtor (self
);
8714 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
8717 re_set_watchpoint (struct breakpoint
*b
)
8719 struct watchpoint
*w
= (struct watchpoint
*) b
;
8721 /* Watchpoint can be either on expression using entirely global
8722 variables, or it can be on local variables.
8724 Watchpoints of the first kind are never auto-deleted, and even
8725 persist across program restarts. Since they can use variables
8726 from shared libraries, we need to reparse expression as libraries
8727 are loaded and unloaded.
8729 Watchpoints on local variables can also change meaning as result
8730 of solib event. For example, if a watchpoint uses both a local
8731 and a global variables in expression, it's a local watchpoint,
8732 but unloading of a shared library will make the expression
8733 invalid. This is not a very common use case, but we still
8734 re-evaluate expression, to avoid surprises to the user.
8736 Note that for local watchpoints, we re-evaluate it only if
8737 watchpoints frame id is still valid. If it's not, it means the
8738 watchpoint is out of scope and will be deleted soon. In fact,
8739 I'm not sure we'll ever be called in this case.
8741 If a local watchpoint's frame id is still valid, then
8742 w->exp_valid_block is likewise valid, and we can safely use it.
8744 Don't do anything about disabled watchpoints, since they will be
8745 reevaluated again when enabled. */
8746 update_watchpoint (w
, 1 /* reparse */);
8749 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8752 insert_watchpoint (struct bp_location
*bl
)
8754 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8755 int length
= w
->exact
? 1 : bl
->length
;
8757 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8761 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8764 remove_watchpoint (struct bp_location
*bl
)
8766 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8767 int length
= w
->exact
? 1 : bl
->length
;
8769 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
8774 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
8775 struct address_space
*aspace
, CORE_ADDR bp_addr
)
8777 struct breakpoint
*b
= bl
->owner
;
8778 struct watchpoint
*w
= (struct watchpoint
*) b
;
8780 /* Continuable hardware watchpoints are treated as non-existent if the
8781 reason we stopped wasn't a hardware watchpoint (we didn't stop on
8782 some data address). Otherwise gdb won't stop on a break instruction
8783 in the code (not from a breakpoint) when a hardware watchpoint has
8784 been defined. Also skip watchpoints which we know did not trigger
8785 (did not match the data address). */
8786 if (is_hardware_watchpoint (b
)
8787 && w
->watchpoint_triggered
== watch_triggered_no
)
8794 check_status_watchpoint (bpstat bs
)
8796 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
8798 bpstat_check_watchpoint (bs
);
8801 /* Implement the "resources_needed" breakpoint_ops method for
8802 hardware watchpoints. */
8805 resources_needed_watchpoint (const struct bp_location
*bl
)
8807 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8808 int length
= w
->exact
? 1 : bl
->length
;
8810 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
8813 /* Implement the "works_in_software_mode" breakpoint_ops method for
8814 hardware watchpoints. */
8817 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
8819 /* Read and access watchpoints only work with hardware support. */
8820 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
8823 static enum print_stop_action
8824 print_it_watchpoint (bpstat bs
)
8826 struct cleanup
*old_chain
;
8827 struct breakpoint
*b
;
8828 const struct bp_location
*bl
;
8829 struct ui_stream
*stb
;
8830 enum print_stop_action result
;
8831 struct watchpoint
*w
;
8832 struct ui_out
*uiout
= current_uiout
;
8834 gdb_assert (bs
->bp_location_at
!= NULL
);
8836 bl
= bs
->bp_location_at
;
8837 b
= bs
->breakpoint_at
;
8838 w
= (struct watchpoint
*) b
;
8840 stb
= ui_out_stream_new (uiout
);
8841 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
8846 case bp_hardware_watchpoint
:
8847 annotate_watchpoint (b
->number
);
8848 if (ui_out_is_mi_like_p (uiout
))
8851 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
8853 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8854 ui_out_text (uiout
, "\nOld value = ");
8855 watchpoint_value_print (bs
->old_val
, stb
->stream
);
8856 ui_out_field_stream (uiout
, "old", stb
);
8857 ui_out_text (uiout
, "\nNew value = ");
8858 watchpoint_value_print (w
->val
, stb
->stream
);
8859 ui_out_field_stream (uiout
, "new", stb
);
8860 ui_out_text (uiout
, "\n");
8861 /* More than one watchpoint may have been triggered. */
8862 result
= PRINT_UNKNOWN
;
8865 case bp_read_watchpoint
:
8866 if (ui_out_is_mi_like_p (uiout
))
8869 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
8871 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8872 ui_out_text (uiout
, "\nValue = ");
8873 watchpoint_value_print (w
->val
, stb
->stream
);
8874 ui_out_field_stream (uiout
, "value", stb
);
8875 ui_out_text (uiout
, "\n");
8876 result
= PRINT_UNKNOWN
;
8879 case bp_access_watchpoint
:
8880 if (bs
->old_val
!= NULL
)
8882 annotate_watchpoint (b
->number
);
8883 if (ui_out_is_mi_like_p (uiout
))
8886 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
8888 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8889 ui_out_text (uiout
, "\nOld value = ");
8890 watchpoint_value_print (bs
->old_val
, stb
->stream
);
8891 ui_out_field_stream (uiout
, "old", stb
);
8892 ui_out_text (uiout
, "\nNew value = ");
8897 if (ui_out_is_mi_like_p (uiout
))
8900 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
8901 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
8902 ui_out_text (uiout
, "\nValue = ");
8904 watchpoint_value_print (w
->val
, stb
->stream
);
8905 ui_out_field_stream (uiout
, "new", stb
);
8906 ui_out_text (uiout
, "\n");
8907 result
= PRINT_UNKNOWN
;
8910 result
= PRINT_UNKNOWN
;
8913 do_cleanups (old_chain
);
8917 /* Implement the "print_mention" breakpoint_ops method for hardware
8921 print_mention_watchpoint (struct breakpoint
*b
)
8923 struct cleanup
*ui_out_chain
;
8924 struct watchpoint
*w
= (struct watchpoint
*) b
;
8925 struct ui_out
*uiout
= current_uiout
;
8930 ui_out_text (uiout
, "Watchpoint ");
8931 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
8933 case bp_hardware_watchpoint
:
8934 ui_out_text (uiout
, "Hardware watchpoint ");
8935 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
8937 case bp_read_watchpoint
:
8938 ui_out_text (uiout
, "Hardware read watchpoint ");
8939 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
8941 case bp_access_watchpoint
:
8942 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
8943 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
8946 internal_error (__FILE__
, __LINE__
,
8947 _("Invalid hardware watchpoint type."));
8950 ui_out_field_int (uiout
, "number", b
->number
);
8951 ui_out_text (uiout
, ": ");
8952 ui_out_field_string (uiout
, "exp", w
->exp_string
);
8953 do_cleanups (ui_out_chain
);
8956 /* Implement the "print_recreate" breakpoint_ops method for
8960 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
8962 struct watchpoint
*w
= (struct watchpoint
*) b
;
8967 case bp_hardware_watchpoint
:
8968 fprintf_unfiltered (fp
, "watch");
8970 case bp_read_watchpoint
:
8971 fprintf_unfiltered (fp
, "rwatch");
8973 case bp_access_watchpoint
:
8974 fprintf_unfiltered (fp
, "awatch");
8977 internal_error (__FILE__
, __LINE__
,
8978 _("Invalid watchpoint type."));
8981 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
8982 print_recreate_thread (b
, fp
);
8985 /* The breakpoint_ops structure to be used in hardware watchpoints. */
8987 static struct breakpoint_ops watchpoint_breakpoint_ops
;
8989 /* Implement the "insert" breakpoint_ops method for
8990 masked hardware watchpoints. */
8993 insert_masked_watchpoint (struct bp_location
*bl
)
8995 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
8997 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
8998 bl
->watchpoint_type
);
9001 /* Implement the "remove" breakpoint_ops method for
9002 masked hardware watchpoints. */
9005 remove_masked_watchpoint (struct bp_location
*bl
)
9007 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
9009 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
9010 bl
->watchpoint_type
);
9013 /* Implement the "resources_needed" breakpoint_ops method for
9014 masked hardware watchpoints. */
9017 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
9019 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
9021 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
9024 /* Implement the "works_in_software_mode" breakpoint_ops method for
9025 masked hardware watchpoints. */
9028 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
9033 /* Implement the "print_it" breakpoint_ops method for
9034 masked hardware watchpoints. */
9036 static enum print_stop_action
9037 print_it_masked_watchpoint (bpstat bs
)
9039 struct breakpoint
*b
= bs
->breakpoint_at
;
9040 struct ui_out
*uiout
= current_uiout
;
9042 /* Masked watchpoints have only one location. */
9043 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
9047 case bp_hardware_watchpoint
:
9048 annotate_watchpoint (b
->number
);
9049 if (ui_out_is_mi_like_p (uiout
))
9052 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
9055 case bp_read_watchpoint
:
9056 if (ui_out_is_mi_like_p (uiout
))
9059 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
9062 case bp_access_watchpoint
:
9063 if (ui_out_is_mi_like_p (uiout
))
9066 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
9069 internal_error (__FILE__
, __LINE__
,
9070 _("Invalid hardware watchpoint type."));
9074 ui_out_text (uiout
, _("\n\
9075 Check the underlying instruction at PC for the memory\n\
9076 address and value which triggered this watchpoint.\n"));
9077 ui_out_text (uiout
, "\n");
9079 /* More than one watchpoint may have been triggered. */
9080 return PRINT_UNKNOWN
;
9083 /* Implement the "print_one_detail" breakpoint_ops method for
9084 masked hardware watchpoints. */
9087 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
9088 struct ui_out
*uiout
)
9090 struct watchpoint
*w
= (struct watchpoint
*) b
;
9092 /* Masked watchpoints have only one location. */
9093 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
9095 ui_out_text (uiout
, "\tmask ");
9096 ui_out_field_core_addr (uiout
, "mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
9097 ui_out_text (uiout
, "\n");
9100 /* Implement the "print_mention" breakpoint_ops method for
9101 masked hardware watchpoints. */
9104 print_mention_masked_watchpoint (struct breakpoint
*b
)
9106 struct watchpoint
*w
= (struct watchpoint
*) b
;
9107 struct ui_out
*uiout
= current_uiout
;
9108 struct cleanup
*ui_out_chain
;
9112 case bp_hardware_watchpoint
:
9113 ui_out_text (uiout
, "Masked hardware watchpoint ");
9114 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
9116 case bp_read_watchpoint
:
9117 ui_out_text (uiout
, "Masked hardware read watchpoint ");
9118 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
9120 case bp_access_watchpoint
:
9121 ui_out_text (uiout
, "Masked hardware access (read/write) watchpoint ");
9122 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
9125 internal_error (__FILE__
, __LINE__
,
9126 _("Invalid hardware watchpoint type."));
9129 ui_out_field_int (uiout
, "number", b
->number
);
9130 ui_out_text (uiout
, ": ");
9131 ui_out_field_string (uiout
, "exp", w
->exp_string
);
9132 do_cleanups (ui_out_chain
);
9135 /* Implement the "print_recreate" breakpoint_ops method for
9136 masked hardware watchpoints. */
9139 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9141 struct watchpoint
*w
= (struct watchpoint
*) b
;
9146 case bp_hardware_watchpoint
:
9147 fprintf_unfiltered (fp
, "watch");
9149 case bp_read_watchpoint
:
9150 fprintf_unfiltered (fp
, "rwatch");
9152 case bp_access_watchpoint
:
9153 fprintf_unfiltered (fp
, "awatch");
9156 internal_error (__FILE__
, __LINE__
,
9157 _("Invalid hardware watchpoint type."));
9160 sprintf_vma (tmp
, w
->hw_wp_mask
);
9161 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
9162 print_recreate_thread (b
, fp
);
9165 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
9167 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
9169 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
9172 is_masked_watchpoint (const struct breakpoint
*b
)
9174 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
9177 /* accessflag: hw_write: watch write,
9178 hw_read: watch read,
9179 hw_access: watch access (read or write) */
9181 watch_command_1 (char *arg
, int accessflag
, int from_tty
,
9182 int just_location
, int internal
)
9184 volatile struct gdb_exception e
;
9185 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
9186 struct expression
*exp
;
9187 struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
9188 struct value
*val
, *mark
, *result
;
9189 struct frame_info
*frame
;
9190 char *exp_start
= NULL
;
9191 char *exp_end
= NULL
;
9192 char *tok
, *end_tok
;
9194 char *cond_start
= NULL
;
9195 char *cond_end
= NULL
;
9196 enum bptype bp_type
;
9199 /* Flag to indicate whether we are going to use masks for
9200 the hardware watchpoint. */
9203 struct watchpoint
*w
;
9205 /* Make sure that we actually have parameters to parse. */
9206 if (arg
!= NULL
&& arg
[0] != '\0')
9210 /* Look for "parameter value" pairs at the end
9211 of the arguments string. */
9212 for (tok
= arg
+ strlen (arg
) - 1; tok
> arg
; tok
--)
9214 /* Skip whitespace at the end of the argument list. */
9215 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
9218 /* Find the beginning of the last token.
9219 This is the value of the parameter. */
9220 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
9222 value_start
= tok
+ 1;
9224 /* Skip whitespace. */
9225 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
9230 /* Find the beginning of the second to last token.
9231 This is the parameter itself. */
9232 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
9235 toklen
= end_tok
- tok
+ 1;
9237 if (toklen
== 6 && !strncmp (tok
, "thread", 6))
9239 /* At this point we've found a "thread" token, which means
9240 the user is trying to set a watchpoint that triggers
9241 only in a specific thread. */
9245 error(_("You can specify only one thread."));
9247 /* Extract the thread ID from the next token. */
9248 thread
= strtol (value_start
, &endp
, 0);
9250 /* Check if the user provided a valid numeric value for the
9252 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
9253 error (_("Invalid thread ID specification %s."), value_start
);
9255 /* Check if the thread actually exists. */
9256 if (!valid_thread_id (thread
))
9257 error (_("Unknown thread %d."), thread
);
9259 else if (toklen
== 4 && !strncmp (tok
, "mask", 4))
9261 /* We've found a "mask" token, which means the user wants to
9262 create a hardware watchpoint that is going to have the mask
9264 struct value
*mask_value
, *mark
;
9267 error(_("You can specify only one mask."));
9269 use_mask
= just_location
= 1;
9271 mark
= value_mark ();
9272 mask_value
= parse_to_comma_and_eval (&value_start
);
9273 mask
= value_as_address (mask_value
);
9274 value_free_to_mark (mark
);
9277 /* We didn't recognize what we found. We should stop here. */
9280 /* Truncate the string and get rid of the "parameter value" pair before
9281 the arguments string is parsed by the parse_exp_1 function. */
9286 /* Parse the rest of the arguments. */
9287 innermost_block
= NULL
;
9289 exp
= parse_exp_1 (&arg
, 0, 0);
9291 /* Remove trailing whitespace from the expression before saving it.
9292 This makes the eventual display of the expression string a bit
9294 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
9297 /* Checking if the expression is not constant. */
9298 if (watchpoint_exp_is_const (exp
))
9302 len
= exp_end
- exp_start
;
9303 while (len
> 0 && isspace (exp_start
[len
- 1]))
9305 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
9308 exp_valid_block
= innermost_block
;
9309 mark
= value_mark ();
9310 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
);
9316 exp_valid_block
= NULL
;
9317 val
= value_addr (result
);
9318 release_value (val
);
9319 value_free_to_mark (mark
);
9323 ret
= target_masked_watch_num_registers (value_as_address (val
),
9326 error (_("This target does not support masked watchpoints."));
9328 error (_("Invalid mask or memory region."));
9331 else if (val
!= NULL
)
9332 release_value (val
);
9334 tok
= skip_spaces (arg
);
9335 end_tok
= skip_to_space (tok
);
9337 toklen
= end_tok
- tok
;
9338 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9340 struct expression
*cond
;
9342 innermost_block
= NULL
;
9343 tok
= cond_start
= end_tok
+ 1;
9344 cond
= parse_exp_1 (&tok
, 0, 0);
9346 /* The watchpoint expression may not be local, but the condition
9347 may still be. E.g.: `watch global if local > 0'. */
9348 cond_exp_valid_block
= innermost_block
;
9354 error (_("Junk at end of command."));
9356 if (accessflag
== hw_read
)
9357 bp_type
= bp_read_watchpoint
;
9358 else if (accessflag
== hw_access
)
9359 bp_type
= bp_access_watchpoint
;
9361 bp_type
= bp_hardware_watchpoint
;
9363 frame
= block_innermost_frame (exp_valid_block
);
9365 /* If the expression is "local", then set up a "watchpoint scope"
9366 breakpoint at the point where we've left the scope of the watchpoint
9367 expression. Create the scope breakpoint before the watchpoint, so
9368 that we will encounter it first in bpstat_stop_status. */
9369 if (exp_valid_block
&& frame
)
9371 if (frame_id_p (frame_unwind_caller_id (frame
)))
9374 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
9375 frame_unwind_caller_pc (frame
),
9376 bp_watchpoint_scope
,
9377 &momentary_breakpoint_ops
);
9379 scope_breakpoint
->enable_state
= bp_enabled
;
9381 /* Automatically delete the breakpoint when it hits. */
9382 scope_breakpoint
->disposition
= disp_del
;
9384 /* Only break in the proper frame (help with recursion). */
9385 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
9387 /* Set the address at which we will stop. */
9388 scope_breakpoint
->loc
->gdbarch
9389 = frame_unwind_caller_arch (frame
);
9390 scope_breakpoint
->loc
->requested_address
9391 = frame_unwind_caller_pc (frame
);
9392 scope_breakpoint
->loc
->address
9393 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
9394 scope_breakpoint
->loc
->requested_address
,
9395 scope_breakpoint
->type
);
9399 /* Now set up the breakpoint. */
9401 w
= XCNEW (struct watchpoint
);
9404 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
9405 &masked_watchpoint_breakpoint_ops
);
9407 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
9408 &watchpoint_breakpoint_ops
);
9410 b
->disposition
= disp_donttouch
;
9411 b
->pspace
= current_program_space
;
9413 w
->exp_valid_block
= exp_valid_block
;
9414 w
->cond_exp_valid_block
= cond_exp_valid_block
;
9417 struct type
*t
= value_type (val
);
9418 CORE_ADDR addr
= value_as_address (val
);
9421 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
9422 name
= type_to_string (t
);
9424 w
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
9425 core_addr_to_string (addr
));
9428 w
->exp_string
= xstrprintf ("-location %.*s",
9429 (int) (exp_end
- exp_start
), exp_start
);
9431 /* The above expression is in C. */
9432 b
->language
= language_c
;
9435 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
9439 w
->hw_wp_mask
= mask
;
9448 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9454 w
->watchpoint_frame
= get_frame_id (frame
);
9455 w
->watchpoint_thread
= inferior_ptid
;
9459 w
->watchpoint_frame
= null_frame_id
;
9460 w
->watchpoint_thread
= null_ptid
;
9463 if (scope_breakpoint
!= NULL
)
9465 /* The scope breakpoint is related to the watchpoint. We will
9466 need to act on them together. */
9467 b
->related_breakpoint
= scope_breakpoint
;
9468 scope_breakpoint
->related_breakpoint
= b
;
9472 value_free_to_mark (mark
);
9474 TRY_CATCH (e
, RETURN_MASK_ALL
)
9476 /* Finally update the new watchpoint. This creates the locations
9477 that should be inserted. */
9478 update_watchpoint (w
, 1);
9482 delete_breakpoint (b
);
9483 throw_exception (e
);
9486 install_breakpoint (internal
, b
, 1);
9489 /* Return count of debug registers needed to watch the given expression.
9490 If the watchpoint cannot be handled in hardware return zero. */
9493 can_use_hardware_watchpoint (struct value
*v
)
9495 int found_memory_cnt
= 0;
9496 struct value
*head
= v
;
9498 /* Did the user specifically forbid us to use hardware watchpoints? */
9499 if (!can_use_hw_watchpoints
)
9502 /* Make sure that the value of the expression depends only upon
9503 memory contents, and values computed from them within GDB. If we
9504 find any register references or function calls, we can't use a
9505 hardware watchpoint.
9507 The idea here is that evaluating an expression generates a series
9508 of values, one holding the value of every subexpression. (The
9509 expression a*b+c has five subexpressions: a, b, a*b, c, and
9510 a*b+c.) GDB's values hold almost enough information to establish
9511 the criteria given above --- they identify memory lvalues,
9512 register lvalues, computed values, etcetera. So we can evaluate
9513 the expression, and then scan the chain of values that leaves
9514 behind to decide whether we can detect any possible change to the
9515 expression's final value using only hardware watchpoints.
9517 However, I don't think that the values returned by inferior
9518 function calls are special in any way. So this function may not
9519 notice that an expression involving an inferior function call
9520 can't be watched with hardware watchpoints. FIXME. */
9521 for (; v
; v
= value_next (v
))
9523 if (VALUE_LVAL (v
) == lval_memory
)
9525 if (v
!= head
&& value_lazy (v
))
9526 /* A lazy memory lvalue in the chain is one that GDB never
9527 needed to fetch; we either just used its address (e.g.,
9528 `a' in `a.b') or we never needed it at all (e.g., `a'
9529 in `a,b'). This doesn't apply to HEAD; if that is
9530 lazy then it was not readable, but watch it anyway. */
9534 /* Ahh, memory we actually used! Check if we can cover
9535 it with hardware watchpoints. */
9536 struct type
*vtype
= check_typedef (value_type (v
));
9538 /* We only watch structs and arrays if user asked for it
9539 explicitly, never if they just happen to appear in a
9540 middle of some value chain. */
9542 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
9543 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
9545 CORE_ADDR vaddr
= value_address (v
);
9549 len
= (target_exact_watchpoints
9550 && is_scalar_type_recursive (vtype
))?
9551 1 : TYPE_LENGTH (value_type (v
));
9553 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
9557 found_memory_cnt
+= num_regs
;
9561 else if (VALUE_LVAL (v
) != not_lval
9562 && deprecated_value_modifiable (v
) == 0)
9563 return 0; /* These are values from the history (e.g., $1). */
9564 else if (VALUE_LVAL (v
) == lval_register
)
9565 return 0; /* Cannot watch a register with a HW watchpoint. */
9568 /* The expression itself looks suitable for using a hardware
9569 watchpoint, but give the target machine a chance to reject it. */
9570 return found_memory_cnt
;
9574 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
9576 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
9579 /* A helper function that looks for an argument at the start of a
9580 string. The argument must also either be at the end of the string,
9581 or be followed by whitespace. Returns 1 if it finds the argument,
9582 0 otherwise. If the argument is found, it updates *STR. */
9585 check_for_argument (char **str
, char *arg
, int arg_len
)
9587 if (strncmp (*str
, arg
, arg_len
) == 0
9588 && ((*str
)[arg_len
] == '\0' || isspace ((*str
)[arg_len
])))
9596 /* A helper function that looks for the "-location" argument and then
9597 calls watch_command_1. */
9600 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
9602 int just_location
= 0;
9605 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
9606 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
9608 arg
= skip_spaces (arg
);
9612 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
9616 watch_command (char *arg
, int from_tty
)
9618 watch_maybe_just_location (arg
, hw_write
, from_tty
);
9622 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9624 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
9628 rwatch_command (char *arg
, int from_tty
)
9630 watch_maybe_just_location (arg
, hw_read
, from_tty
);
9634 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
9636 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
9640 awatch_command (char *arg
, int from_tty
)
9642 watch_maybe_just_location (arg
, hw_access
, from_tty
);
9646 /* Helper routines for the until_command routine in infcmd.c. Here
9647 because it uses the mechanisms of breakpoints. */
9649 struct until_break_command_continuation_args
9651 struct breakpoint
*breakpoint
;
9652 struct breakpoint
*breakpoint2
;
9656 /* This function is called by fetch_inferior_event via the
9657 cmd_continuation pointer, to complete the until command. It takes
9658 care of cleaning up the temporary breakpoints set up by the until
9661 until_break_command_continuation (void *arg
, int err
)
9663 struct until_break_command_continuation_args
*a
= arg
;
9665 delete_breakpoint (a
->breakpoint
);
9667 delete_breakpoint (a
->breakpoint2
);
9668 delete_longjmp_breakpoint (a
->thread_num
);
9672 until_break_command (char *arg
, int from_tty
, int anywhere
)
9674 struct symtabs_and_lines sals
;
9675 struct symtab_and_line sal
;
9676 struct frame_info
*frame
= get_selected_frame (NULL
);
9677 struct breakpoint
*breakpoint
;
9678 struct breakpoint
*breakpoint2
= NULL
;
9679 struct cleanup
*old_chain
;
9681 struct thread_info
*tp
;
9683 clear_proceed_status ();
9685 /* Set a breakpoint where the user wants it and at return from
9688 if (last_displayed_sal_is_valid ())
9689 sals
= decode_line_1 (&arg
, 1,
9690 get_last_displayed_symtab (),
9691 get_last_displayed_line (),
9694 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
, 0, NULL
);
9696 if (sals
.nelts
!= 1)
9697 error (_("Couldn't get information on specified line."));
9700 xfree (sals
.sals
); /* malloc'd, so freed. */
9703 error (_("Junk at end of arguments."));
9705 resolve_sal_pc (&sal
);
9708 /* If the user told us to continue until a specified location,
9709 we don't specify a frame at which we need to stop. */
9710 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9711 null_frame_id
, bp_until
);
9713 /* Otherwise, specify the selected frame, because we want to stop
9714 only at the very same frame. */
9715 breakpoint
= set_momentary_breakpoint (get_frame_arch (frame
), sal
,
9716 get_stack_frame_id (frame
),
9719 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
9721 tp
= inferior_thread ();
9724 /* Keep within the current frame, or in frames called by the current
9727 if (frame_id_p (frame_unwind_caller_id (frame
)))
9729 sal
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
9730 sal
.pc
= frame_unwind_caller_pc (frame
);
9731 breakpoint2
= set_momentary_breakpoint (frame_unwind_caller_arch (frame
),
9733 frame_unwind_caller_id (frame
),
9735 make_cleanup_delete_breakpoint (breakpoint2
);
9737 set_longjmp_breakpoint (tp
, frame_unwind_caller_id (frame
));
9738 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
9741 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
9743 /* If we are running asynchronously, and proceed call above has
9744 actually managed to start the target, arrange for breakpoints to
9745 be deleted when the target stops. Otherwise, we're already
9746 stopped and delete breakpoints via cleanup chain. */
9748 if (target_can_async_p () && is_running (inferior_ptid
))
9750 struct until_break_command_continuation_args
*args
;
9751 args
= xmalloc (sizeof (*args
));
9753 args
->breakpoint
= breakpoint
;
9754 args
->breakpoint2
= breakpoint2
;
9755 args
->thread_num
= thread
;
9757 discard_cleanups (old_chain
);
9758 add_continuation (inferior_thread (),
9759 until_break_command_continuation
, args
,
9763 do_cleanups (old_chain
);
9766 /* This function attempts to parse an optional "if <cond>" clause
9767 from the arg string. If one is not found, it returns NULL.
9769 Else, it returns a pointer to the condition string. (It does not
9770 attempt to evaluate the string against a particular block.) And,
9771 it updates arg to point to the first character following the parsed
9772 if clause in the arg string. */
9775 ep_parse_optional_if_clause (char **arg
)
9779 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
9782 /* Skip the "if" keyword. */
9785 /* Skip any extra leading whitespace, and record the start of the
9786 condition string. */
9787 *arg
= skip_spaces (*arg
);
9790 /* Assume that the condition occupies the remainder of the arg
9792 (*arg
) += strlen (cond_string
);
9797 /* Commands to deal with catching events, such as signals, exceptions,
9798 process start/exit, etc. */
9802 catch_fork_temporary
, catch_vfork_temporary
,
9803 catch_fork_permanent
, catch_vfork_permanent
9808 catch_fork_command_1 (char *arg
, int from_tty
,
9809 struct cmd_list_element
*command
)
9811 struct gdbarch
*gdbarch
= get_current_arch ();
9812 char *cond_string
= NULL
;
9813 catch_fork_kind fork_kind
;
9816 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
9817 tempflag
= (fork_kind
== catch_fork_temporary
9818 || fork_kind
== catch_vfork_temporary
);
9822 arg
= skip_spaces (arg
);
9824 /* The allowed syntax is:
9826 catch [v]fork if <cond>
9828 First, check if there's an if clause. */
9829 cond_string
= ep_parse_optional_if_clause (&arg
);
9831 if ((*arg
!= '\0') && !isspace (*arg
))
9832 error (_("Junk at end of arguments."));
9834 /* If this target supports it, create a fork or vfork catchpoint
9835 and enable reporting of such events. */
9838 case catch_fork_temporary
:
9839 case catch_fork_permanent
:
9840 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9841 &catch_fork_breakpoint_ops
);
9843 case catch_vfork_temporary
:
9844 case catch_vfork_permanent
:
9845 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
9846 &catch_vfork_breakpoint_ops
);
9849 error (_("unsupported or unknown fork kind; cannot catch it"));
9855 catch_exec_command_1 (char *arg
, int from_tty
,
9856 struct cmd_list_element
*command
)
9858 struct exec_catchpoint
*c
;
9859 struct gdbarch
*gdbarch
= get_current_arch ();
9861 char *cond_string
= NULL
;
9863 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
9867 arg
= skip_spaces (arg
);
9869 /* The allowed syntax is:
9871 catch exec if <cond>
9873 First, check if there's an if clause. */
9874 cond_string
= ep_parse_optional_if_clause (&arg
);
9876 if ((*arg
!= '\0') && !isspace (*arg
))
9877 error (_("Junk at end of arguments."));
9879 c
= XNEW (struct exec_catchpoint
);
9880 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
,
9881 &catch_exec_breakpoint_ops
);
9882 c
->exec_pathname
= NULL
;
9884 install_breakpoint (0, &c
->base
, 1);
9887 static enum print_stop_action
9888 print_it_exception_catchpoint (bpstat bs
)
9890 struct ui_out
*uiout
= current_uiout
;
9891 struct breakpoint
*b
= bs
->breakpoint_at
;
9892 int bp_temp
, bp_throw
;
9894 annotate_catchpoint (b
->number
);
9896 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9897 if (b
->loc
->address
!= b
->loc
->requested_address
)
9898 breakpoint_adjustment_warning (b
->loc
->requested_address
,
9901 bp_temp
= b
->disposition
== disp_del
;
9903 bp_temp
? "Temporary catchpoint "
9905 if (!ui_out_is_mi_like_p (uiout
))
9906 ui_out_field_int (uiout
, "bkptno", b
->number
);
9908 bp_throw
? " (exception thrown), "
9909 : " (exception caught), ");
9910 if (ui_out_is_mi_like_p (uiout
))
9912 ui_out_field_string (uiout
, "reason",
9913 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9914 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
9915 ui_out_field_int (uiout
, "bkptno", b
->number
);
9917 return PRINT_SRC_AND_LOC
;
9921 print_one_exception_catchpoint (struct breakpoint
*b
,
9922 struct bp_location
**last_loc
)
9924 struct value_print_options opts
;
9925 struct ui_out
*uiout
= current_uiout
;
9927 get_user_print_options (&opts
);
9928 if (opts
.addressprint
)
9931 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
9932 ui_out_field_string (uiout
, "addr", "<PENDING>");
9934 ui_out_field_core_addr (uiout
, "addr",
9935 b
->loc
->gdbarch
, b
->loc
->address
);
9940 if (strstr (b
->addr_string
, "throw") != NULL
)
9941 ui_out_field_string (uiout
, "what", "exception throw");
9943 ui_out_field_string (uiout
, "what", "exception catch");
9947 print_mention_exception_catchpoint (struct breakpoint
*b
)
9949 struct ui_out
*uiout
= current_uiout
;
9953 bp_temp
= b
->disposition
== disp_del
;
9954 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9955 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
9956 : _("Catchpoint "));
9957 ui_out_field_int (uiout
, "bkptno", b
->number
);
9958 ui_out_text (uiout
, bp_throw
? _(" (throw)")
9962 /* Implement the "print_recreate" breakpoint_ops method for throw and
9963 catch catchpoints. */
9966 print_recreate_exception_catchpoint (struct breakpoint
*b
,
9972 bp_temp
= b
->disposition
== disp_del
;
9973 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
9974 fprintf_unfiltered (fp
, bp_temp
? "tcatch " : "catch ");
9975 fprintf_unfiltered (fp
, bp_throw
? "throw" : "catch");
9976 print_recreate_thread (b
, fp
);
9979 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
;
9982 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
9983 enum exception_event_kind ex_event
, int from_tty
)
9985 char *trigger_func_name
;
9987 if (ex_event
== EX_EVENT_CATCH
)
9988 trigger_func_name
= "__cxa_begin_catch";
9990 trigger_func_name
= "__cxa_throw";
9992 create_breakpoint (get_current_arch (),
9993 trigger_func_name
, cond_string
, -1,
9994 0 /* condition and thread are valid. */,
9995 tempflag
, bp_breakpoint
,
9997 AUTO_BOOLEAN_TRUE
/* pending */,
9998 &gnu_v3_exception_catchpoint_ops
, from_tty
,
10005 /* Deal with "catch catch" and "catch throw" commands. */
10008 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
10009 int tempflag
, int from_tty
)
10011 char *cond_string
= NULL
;
10015 arg
= skip_spaces (arg
);
10017 cond_string
= ep_parse_optional_if_clause (&arg
);
10019 if ((*arg
!= '\0') && !isspace (*arg
))
10020 error (_("Junk at end of arguments."));
10022 if (ex_event
!= EX_EVENT_THROW
10023 && ex_event
!= EX_EVENT_CATCH
)
10024 error (_("Unsupported or unknown exception event; cannot catch it"));
10026 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
10029 warning (_("Unsupported with this platform/compiler combination."));
10032 /* Implementation of "catch catch" command. */
10035 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
10037 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
10039 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
10042 /* Implementation of "catch throw" command. */
10045 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
10047 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
10049 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
10053 init_ada_exception_breakpoint (struct breakpoint
*b
,
10054 struct gdbarch
*gdbarch
,
10055 struct symtab_and_line sal
,
10057 const struct breakpoint_ops
*ops
,
10063 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
10065 loc_gdbarch
= gdbarch
;
10067 describe_other_breakpoints (loc_gdbarch
,
10068 sal
.pspace
, sal
.pc
, sal
.section
, -1);
10069 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
10070 version for exception catchpoints, because two catchpoints
10071 used for different exception names will use the same address.
10072 In this case, a "breakpoint ... also set at..." warning is
10073 unproductive. Besides, the warning phrasing is also a bit
10074 inappropriate, we should use the word catchpoint, and tell
10075 the user what type of catchpoint it is. The above is good
10076 enough for now, though. */
10079 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
10081 b
->enable_state
= bp_enabled
;
10082 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
10083 b
->addr_string
= addr_string
;
10084 b
->language
= language_ada
;
10087 /* Splits the argument using space as delimiter. Returns an xmalloc'd
10088 filter list, or NULL if no filtering is required. */
10090 catch_syscall_split_args (char *arg
)
10092 VEC(int) *result
= NULL
;
10093 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (int), &result
);
10095 while (*arg
!= '\0')
10097 int i
, syscall_number
;
10099 char cur_name
[128];
10102 /* Skip whitespace. */
10103 while (isspace (*arg
))
10106 for (i
= 0; i
< 127 && arg
[i
] && !isspace (arg
[i
]); ++i
)
10107 cur_name
[i
] = arg
[i
];
10108 cur_name
[i
] = '\0';
10111 /* Check if the user provided a syscall name or a number. */
10112 syscall_number
= (int) strtol (cur_name
, &endptr
, 0);
10113 if (*endptr
== '\0')
10114 get_syscall_by_number (syscall_number
, &s
);
10117 /* We have a name. Let's check if it's valid and convert it
10119 get_syscall_by_name (cur_name
, &s
);
10121 if (s
.number
== UNKNOWN_SYSCALL
)
10122 /* Here we have to issue an error instead of a warning,
10123 because GDB cannot do anything useful if there's no
10124 syscall number to be caught. */
10125 error (_("Unknown syscall name '%s'."), cur_name
);
10128 /* Ok, it's valid. */
10129 VEC_safe_push (int, result
, s
.number
);
10132 discard_cleanups (cleanup
);
10136 /* Implement the "catch syscall" command. */
10139 catch_syscall_command_1 (char *arg
, int from_tty
,
10140 struct cmd_list_element
*command
)
10145 struct gdbarch
*gdbarch
= get_current_arch ();
10147 /* Checking if the feature if supported. */
10148 if (gdbarch_get_syscall_number_p (gdbarch
) == 0)
10149 error (_("The feature 'catch syscall' is not supported on \
10150 this architecture yet."));
10152 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
10154 arg
= skip_spaces (arg
);
10156 /* We need to do this first "dummy" translation in order
10157 to get the syscall XML file loaded or, most important,
10158 to display a warning to the user if there's no XML file
10159 for his/her architecture. */
10160 get_syscall_by_number (0, &s
);
10162 /* The allowed syntax is:
10164 catch syscall <name | number> [<name | number> ... <name | number>]
10166 Let's check if there's a syscall name. */
10169 filter
= catch_syscall_split_args (arg
);
10173 create_syscall_event_catchpoint (tempflag
, filter
,
10174 &catch_syscall_breakpoint_ops
);
10178 catch_command (char *arg
, int from_tty
)
10180 error (_("Catch requires an event name."));
10185 tcatch_command (char *arg
, int from_tty
)
10187 error (_("Catch requires an event name."));
10190 /* Delete breakpoints by address or line. */
10193 clear_command (char *arg
, int from_tty
)
10195 struct breakpoint
*b
;
10196 VEC(breakpoint_p
) *found
= 0;
10199 struct symtabs_and_lines sals
;
10200 struct symtab_and_line sal
;
10205 sals
= decode_line_spec (arg
, 1);
10210 sals
.sals
= (struct symtab_and_line
*)
10211 xmalloc (sizeof (struct symtab_and_line
));
10212 make_cleanup (xfree
, sals
.sals
);
10213 init_sal (&sal
); /* Initialize to zeroes. */
10215 /* Set sal's line, symtab, pc, and pspace to the values
10216 corresponding to the last call to print_frame_info. If the
10217 codepoint is not valid, this will set all the fields to 0. */
10218 get_last_displayed_sal (&sal
);
10219 if (sal
.symtab
== 0)
10220 error (_("No source file specified."));
10222 sals
.sals
[0] = sal
;
10228 /* We don't call resolve_sal_pc here. That's not as bad as it
10229 seems, because all existing breakpoints typically have both
10230 file/line and pc set. So, if clear is given file/line, we can
10231 match this to existing breakpoint without obtaining pc at all.
10233 We only support clearing given the address explicitly
10234 present in breakpoint table. Say, we've set breakpoint
10235 at file:line. There were several PC values for that file:line,
10236 due to optimization, all in one block.
10238 We've picked one PC value. If "clear" is issued with another
10239 PC corresponding to the same file:line, the breakpoint won't
10240 be cleared. We probably can still clear the breakpoint, but
10241 since the other PC value is never presented to user, user
10242 can only find it by guessing, and it does not seem important
10243 to support that. */
10245 /* For each line spec given, delete bps which correspond to it. Do
10246 it in two passes, solely to preserve the current behavior that
10247 from_tty is forced true if we delete more than one
10251 for (i
= 0; i
< sals
.nelts
; i
++)
10253 /* If exact pc given, clear bpts at that pc.
10254 If line given (pc == 0), clear all bpts on specified line.
10255 If defaulting, clear all bpts on default line
10258 defaulting sal.pc != 0 tests to do
10263 1 0 <can't happen> */
10265 sal
= sals
.sals
[i
];
10267 /* Find all matching breakpoints and add them to 'found'. */
10268 ALL_BREAKPOINTS (b
)
10271 /* Are we going to delete b? */
10272 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
10274 struct bp_location
*loc
= b
->loc
;
10275 for (; loc
; loc
= loc
->next
)
10277 int pc_match
= sal
.pc
10278 && (loc
->pspace
== sal
.pspace
)
10279 && (loc
->address
== sal
.pc
)
10280 && (!section_is_overlay (loc
->section
)
10281 || loc
->section
== sal
.section
);
10282 int line_match
= ((default_match
|| (0 == sal
.pc
))
10283 && b
->source_file
!= NULL
10284 && sal
.symtab
!= NULL
10285 && sal
.pspace
== loc
->pspace
10286 && filename_cmp (b
->source_file
,
10287 sal
.symtab
->filename
) == 0
10288 && b
->line_number
== sal
.line
);
10289 if (pc_match
|| line_match
)
10298 VEC_safe_push(breakpoint_p
, found
, b
);
10301 /* Now go thru the 'found' chain and delete them. */
10302 if (VEC_empty(breakpoint_p
, found
))
10305 error (_("No breakpoint at %s."), arg
);
10307 error (_("No breakpoint at this line."));
10310 if (VEC_length(breakpoint_p
, found
) > 1)
10311 from_tty
= 1; /* Always report if deleted more than one. */
10314 if (VEC_length(breakpoint_p
, found
) == 1)
10315 printf_unfiltered (_("Deleted breakpoint "));
10317 printf_unfiltered (_("Deleted breakpoints "));
10319 breakpoints_changed ();
10321 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
10324 printf_unfiltered ("%d ", b
->number
);
10325 delete_breakpoint (b
);
10328 putchar_unfiltered ('\n');
10331 /* Delete breakpoint in BS if they are `delete' breakpoints and
10332 all breakpoints that are marked for deletion, whether hit or not.
10333 This is called after any breakpoint is hit, or after errors. */
10336 breakpoint_auto_delete (bpstat bs
)
10338 struct breakpoint
*b
, *b_tmp
;
10340 for (; bs
; bs
= bs
->next
)
10341 if (bs
->breakpoint_at
10342 && bs
->breakpoint_at
->disposition
== disp_del
10344 delete_breakpoint (bs
->breakpoint_at
);
10346 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
10348 if (b
->disposition
== disp_del_at_next_stop
)
10349 delete_breakpoint (b
);
10353 /* A comparison function for bp_location AP and BP being interfaced to
10354 qsort. Sort elements primarily by their ADDRESS (no matter what
10355 does breakpoint_address_is_meaningful say for its OWNER),
10356 secondarily by ordering first bp_permanent OWNERed elements and
10357 terciarily just ensuring the array is sorted stable way despite
10358 qsort being an unstable algorithm. */
10361 bp_location_compare (const void *ap
, const void *bp
)
10363 struct bp_location
*a
= *(void **) ap
;
10364 struct bp_location
*b
= *(void **) bp
;
10365 /* A and B come from existing breakpoints having non-NULL OWNER. */
10366 int a_perm
= a
->owner
->enable_state
== bp_permanent
;
10367 int b_perm
= b
->owner
->enable_state
== bp_permanent
;
10369 if (a
->address
!= b
->address
)
10370 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
10372 /* Sort permanent breakpoints first. */
10373 if (a_perm
!= b_perm
)
10374 return (a_perm
< b_perm
) - (a_perm
> b_perm
);
10376 /* Make the user-visible order stable across GDB runs. Locations of
10377 the same breakpoint can be sorted in arbitrary order. */
10379 if (a
->owner
->number
!= b
->owner
->number
)
10380 return (a
->owner
->number
> b
->owner
->number
)
10381 - (a
->owner
->number
< b
->owner
->number
);
10383 return (a
> b
) - (a
< b
);
10386 /* Set bp_location_placed_address_before_address_max and
10387 bp_location_shadow_len_after_address_max according to the current
10388 content of the bp_location array. */
10391 bp_location_target_extensions_update (void)
10393 struct bp_location
*bl
, **blp_tmp
;
10395 bp_location_placed_address_before_address_max
= 0;
10396 bp_location_shadow_len_after_address_max
= 0;
10398 ALL_BP_LOCATIONS (bl
, blp_tmp
)
10400 CORE_ADDR start
, end
, addr
;
10402 if (!bp_location_has_shadow (bl
))
10405 start
= bl
->target_info
.placed_address
;
10406 end
= start
+ bl
->target_info
.shadow_len
;
10408 gdb_assert (bl
->address
>= start
);
10409 addr
= bl
->address
- start
;
10410 if (addr
> bp_location_placed_address_before_address_max
)
10411 bp_location_placed_address_before_address_max
= addr
;
10413 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
10415 gdb_assert (bl
->address
< end
);
10416 addr
= end
- bl
->address
;
10417 if (addr
> bp_location_shadow_len_after_address_max
)
10418 bp_location_shadow_len_after_address_max
= addr
;
10422 /* Download tracepoint locations if they haven't been. */
10425 download_tracepoint_locations (void)
10427 struct bp_location
*bl
, **blp_tmp
;
10428 struct cleanup
*old_chain
;
10430 if (!target_can_download_tracepoint ())
10433 old_chain
= save_current_space_and_thread ();
10435 ALL_BP_LOCATIONS (bl
, blp_tmp
)
10437 struct tracepoint
*t
;
10439 if (!is_tracepoint (bl
->owner
))
10442 if ((bl
->owner
->type
== bp_fast_tracepoint
10443 ? !may_insert_fast_tracepoints
10444 : !may_insert_tracepoints
))
10447 /* In tracepoint, locations are _never_ duplicated, so
10448 should_be_inserted is equivalent to
10449 unduplicated_should_be_inserted. */
10450 if (!should_be_inserted (bl
) || bl
->inserted
)
10453 switch_to_program_space_and_thread (bl
->pspace
);
10455 target_download_tracepoint (bl
);
10458 t
= (struct tracepoint
*) bl
->owner
;
10459 t
->number_on_target
= bl
->owner
->number
;
10462 do_cleanups (old_chain
);
10465 /* Swap the insertion/duplication state between two locations. */
10468 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
10470 const int left_inserted
= left
->inserted
;
10471 const int left_duplicate
= left
->duplicate
;
10472 const struct bp_target_info left_target_info
= left
->target_info
;
10474 /* Locations of tracepoints can never be duplicated. */
10475 if (is_tracepoint (left
->owner
))
10476 gdb_assert (!left
->duplicate
);
10477 if (is_tracepoint (right
->owner
))
10478 gdb_assert (!right
->duplicate
);
10480 left
->inserted
= right
->inserted
;
10481 left
->duplicate
= right
->duplicate
;
10482 left
->target_info
= right
->target_info
;
10483 right
->inserted
= left_inserted
;
10484 right
->duplicate
= left_duplicate
;
10485 right
->target_info
= left_target_info
;
10488 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
10489 into the inferior, only remove already-inserted locations that no
10490 longer should be inserted. Functions that delete a breakpoint or
10491 breakpoints should pass false, so that deleting a breakpoint
10492 doesn't have the side effect of inserting the locations of other
10493 breakpoints that are marked not-inserted, but should_be_inserted
10494 returns true on them.
10496 This behaviour is useful is situations close to tear-down -- e.g.,
10497 after an exec, while the target still has execution, but breakpoint
10498 shadows of the previous executable image should *NOT* be restored
10499 to the new image; or before detaching, where the target still has
10500 execution and wants to delete breakpoints from GDB's lists, and all
10501 breakpoints had already been removed from the inferior. */
10504 update_global_location_list (int should_insert
)
10506 struct breakpoint
*b
;
10507 struct bp_location
**locp
, *loc
;
10508 struct cleanup
*cleanups
;
10510 /* Used in the duplicates detection below. When iterating over all
10511 bp_locations, points to the first bp_location of a given address.
10512 Breakpoints and watchpoints of different types are never
10513 duplicates of each other. Keep one pointer for each type of
10514 breakpoint/watchpoint, so we only need to loop over all locations
10516 struct bp_location
*bp_loc_first
; /* breakpoint */
10517 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
10518 struct bp_location
*awp_loc_first
; /* access watchpoint */
10519 struct bp_location
*rwp_loc_first
; /* read watchpoint */
10521 /* Saved former bp_location array which we compare against the newly
10522 built bp_location from the current state of ALL_BREAKPOINTS. */
10523 struct bp_location
**old_location
, **old_locp
;
10524 unsigned old_location_count
;
10526 old_location
= bp_location
;
10527 old_location_count
= bp_location_count
;
10528 bp_location
= NULL
;
10529 bp_location_count
= 0;
10530 cleanups
= make_cleanup (xfree
, old_location
);
10532 ALL_BREAKPOINTS (b
)
10533 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10534 bp_location_count
++;
10536 bp_location
= xmalloc (sizeof (*bp_location
) * bp_location_count
);
10537 locp
= bp_location
;
10538 ALL_BREAKPOINTS (b
)
10539 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
10541 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
10542 bp_location_compare
);
10544 bp_location_target_extensions_update ();
10546 /* Identify bp_location instances that are no longer present in the
10547 new list, and therefore should be freed. Note that it's not
10548 necessary that those locations should be removed from inferior --
10549 if there's another location at the same address (previously
10550 marked as duplicate), we don't need to remove/insert the
10553 LOCP is kept in sync with OLD_LOCP, each pointing to the current
10554 and former bp_location array state respectively. */
10556 locp
= bp_location
;
10557 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
10560 struct bp_location
*old_loc
= *old_locp
;
10561 struct bp_location
**loc2p
;
10563 /* Tells if 'old_loc' is found among the new locations. If
10564 not, we have to free it. */
10565 int found_object
= 0;
10566 /* Tells if the location should remain inserted in the target. */
10567 int keep_in_target
= 0;
10570 /* Skip LOCP entries which will definitely never be needed.
10571 Stop either at or being the one matching OLD_LOC. */
10572 while (locp
< bp_location
+ bp_location_count
10573 && (*locp
)->address
< old_loc
->address
)
10577 (loc2p
< bp_location
+ bp_location_count
10578 && (*loc2p
)->address
== old_loc
->address
);
10581 if (*loc2p
== old_loc
)
10588 /* If this location is no longer present, and inserted, look if
10589 there's maybe a new location at the same address. If so,
10590 mark that one inserted, and don't remove this one. This is
10591 needed so that we don't have a time window where a breakpoint
10592 at certain location is not inserted. */
10594 if (old_loc
->inserted
)
10596 /* If the location is inserted now, we might have to remove
10599 if (found_object
&& should_be_inserted (old_loc
))
10601 /* The location is still present in the location list,
10602 and still should be inserted. Don't do anything. */
10603 keep_in_target
= 1;
10607 /* The location is either no longer present, or got
10608 disabled. See if there's another location at the
10609 same address, in which case we don't need to remove
10610 this one from the target. */
10612 /* OLD_LOC comes from existing struct breakpoint. */
10613 if (breakpoint_address_is_meaningful (old_loc
->owner
))
10616 (loc2p
< bp_location
+ bp_location_count
10617 && (*loc2p
)->address
== old_loc
->address
);
10620 struct bp_location
*loc2
= *loc2p
;
10622 if (breakpoint_locations_match (loc2
, old_loc
))
10624 /* Read watchpoint locations are switched to
10625 access watchpoints, if the former are not
10626 supported, but the latter are. */
10627 if (is_hardware_watchpoint (old_loc
->owner
))
10629 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
10630 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
10633 /* loc2 is a duplicated location. We need to check
10634 if it should be inserted in case it will be
10636 if (loc2
!= old_loc
10637 && unduplicated_should_be_inserted (loc2
))
10639 swap_insertion (old_loc
, loc2
);
10640 keep_in_target
= 1;
10648 if (!keep_in_target
)
10650 if (remove_breakpoint (old_loc
, mark_uninserted
))
10652 /* This is just about all we can do. We could keep
10653 this location on the global list, and try to
10654 remove it next time, but there's no particular
10655 reason why we will succeed next time.
10657 Note that at this point, old_loc->owner is still
10658 valid, as delete_breakpoint frees the breakpoint
10659 only after calling us. */
10660 printf_filtered (_("warning: Error removing "
10661 "breakpoint %d\n"),
10662 old_loc
->owner
->number
);
10670 if (removed
&& non_stop
10671 && breakpoint_address_is_meaningful (old_loc
->owner
)
10672 && !is_hardware_watchpoint (old_loc
->owner
))
10674 /* This location was removed from the target. In
10675 non-stop mode, a race condition is possible where
10676 we've removed a breakpoint, but stop events for that
10677 breakpoint are already queued and will arrive later.
10678 We apply an heuristic to be able to distinguish such
10679 SIGTRAPs from other random SIGTRAPs: we keep this
10680 breakpoint location for a bit, and will retire it
10681 after we see some number of events. The theory here
10682 is that reporting of events should, "on the average",
10683 be fair, so after a while we'll see events from all
10684 threads that have anything of interest, and no longer
10685 need to keep this breakpoint location around. We
10686 don't hold locations forever so to reduce chances of
10687 mistaking a non-breakpoint SIGTRAP for a breakpoint
10690 The heuristic failing can be disastrous on
10691 decr_pc_after_break targets.
10693 On decr_pc_after_break targets, like e.g., x86-linux,
10694 if we fail to recognize a late breakpoint SIGTRAP,
10695 because events_till_retirement has reached 0 too
10696 soon, we'll fail to do the PC adjustment, and report
10697 a random SIGTRAP to the user. When the user resumes
10698 the inferior, it will most likely immediately crash
10699 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
10700 corrupted, because of being resumed e.g., in the
10701 middle of a multi-byte instruction, or skipped a
10702 one-byte instruction. This was actually seen happen
10703 on native x86-linux, and should be less rare on
10704 targets that do not support new thread events, like
10705 remote, due to the heuristic depending on
10708 Mistaking a random SIGTRAP for a breakpoint trap
10709 causes similar symptoms (PC adjustment applied when
10710 it shouldn't), but then again, playing with SIGTRAPs
10711 behind the debugger's back is asking for trouble.
10713 Since hardware watchpoint traps are always
10714 distinguishable from other traps, so we don't need to
10715 apply keep hardware watchpoint moribund locations
10716 around. We simply always ignore hardware watchpoint
10717 traps we can no longer explain. */
10719 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
10720 old_loc
->owner
= NULL
;
10722 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
10726 old_loc
->owner
= NULL
;
10727 decref_bp_location (&old_loc
);
10732 /* Rescan breakpoints at the same address and section, marking the
10733 first one as "first" and any others as "duplicates". This is so
10734 that the bpt instruction is only inserted once. If we have a
10735 permanent breakpoint at the same place as BPT, make that one the
10736 official one, and the rest as duplicates. Permanent breakpoints
10737 are sorted first for the same address.
10739 Do the same for hardware watchpoints, but also considering the
10740 watchpoint's type (regular/access/read) and length. */
10742 bp_loc_first
= NULL
;
10743 wp_loc_first
= NULL
;
10744 awp_loc_first
= NULL
;
10745 rwp_loc_first
= NULL
;
10746 ALL_BP_LOCATIONS (loc
, locp
)
10748 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
10750 struct breakpoint
*b
= loc
->owner
;
10751 struct bp_location
**loc_first_p
;
10753 if (b
->enable_state
== bp_disabled
10754 || b
->enable_state
== bp_call_disabled
10755 || b
->enable_state
== bp_startup_disabled
10757 || loc
->shlib_disabled
10758 || !breakpoint_address_is_meaningful (b
)
10759 /* Don't detect duplicate for tracepoint locations because they are
10760 never duplicated. See the comments in field `duplicate' of
10761 `struct bp_location'. */
10762 || is_tracepoint (b
))
10765 /* Permanent breakpoint should always be inserted. */
10766 if (b
->enable_state
== bp_permanent
&& ! loc
->inserted
)
10767 internal_error (__FILE__
, __LINE__
,
10768 _("allegedly permanent breakpoint is not "
10769 "actually inserted"));
10771 if (b
->type
== bp_hardware_watchpoint
)
10772 loc_first_p
= &wp_loc_first
;
10773 else if (b
->type
== bp_read_watchpoint
)
10774 loc_first_p
= &rwp_loc_first
;
10775 else if (b
->type
== bp_access_watchpoint
)
10776 loc_first_p
= &awp_loc_first
;
10778 loc_first_p
= &bp_loc_first
;
10780 if (*loc_first_p
== NULL
10781 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
10782 || !breakpoint_locations_match (loc
, *loc_first_p
))
10784 *loc_first_p
= loc
;
10785 loc
->duplicate
= 0;
10790 /* This and the above ensure the invariant that the first location
10791 is not duplicated, and is the inserted one.
10792 All following are marked as duplicated, and are not inserted. */
10794 swap_insertion (loc
, *loc_first_p
);
10795 loc
->duplicate
= 1;
10797 if ((*loc_first_p
)->owner
->enable_state
== bp_permanent
&& loc
->inserted
10798 && b
->enable_state
!= bp_permanent
)
10799 internal_error (__FILE__
, __LINE__
,
10800 _("another breakpoint was inserted on top of "
10801 "a permanent breakpoint"));
10804 if (breakpoints_always_inserted_mode () && should_insert
10805 && (have_live_inferiors ()
10806 || (gdbarch_has_global_breakpoints (target_gdbarch
))))
10807 insert_breakpoint_locations ();
10810 download_tracepoint_locations ();
10812 do_cleanups (cleanups
);
10816 breakpoint_retire_moribund (void)
10818 struct bp_location
*loc
;
10821 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
10822 if (--(loc
->events_till_retirement
) == 0)
10824 decref_bp_location (&loc
);
10825 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
10831 update_global_location_list_nothrow (int inserting
)
10833 struct gdb_exception e
;
10835 TRY_CATCH (e
, RETURN_MASK_ERROR
)
10836 update_global_location_list (inserting
);
10839 /* Clear BKP from a BPS. */
10842 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
10846 for (bs
= bps
; bs
; bs
= bs
->next
)
10847 if (bs
->breakpoint_at
== bpt
)
10849 bs
->breakpoint_at
= NULL
;
10850 bs
->old_val
= NULL
;
10851 /* bs->commands will be freed later. */
10855 /* Callback for iterate_over_threads. */
10857 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
10859 struct breakpoint
*bpt
= data
;
10861 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
10865 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
10869 say_where (struct breakpoint
*b
)
10871 struct ui_out
*uiout
= current_uiout
;
10872 struct value_print_options opts
;
10874 get_user_print_options (&opts
);
10876 /* i18n: cagney/2005-02-11: Below needs to be merged into a
10878 if (b
->loc
== NULL
)
10880 printf_filtered (_(" (%s) pending."), b
->addr_string
);
10884 if (opts
.addressprint
|| b
->source_file
== NULL
)
10886 printf_filtered (" at ");
10887 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
10890 if (b
->source_file
)
10891 printf_filtered (": file %s, line %d.",
10892 b
->source_file
, b
->line_number
);
10896 struct bp_location
*loc
= b
->loc
;
10898 for (; loc
; loc
= loc
->next
)
10900 printf_filtered (" (%d locations)", n
);
10905 /* Default bp_location_ops methods. */
10908 bp_location_dtor (struct bp_location
*self
)
10910 xfree (self
->cond
);
10911 xfree (self
->function_name
);
10914 static const struct bp_location_ops bp_location_ops
=
10919 /* Default breakpoint_ops methods all breakpoint_ops ultimately
10923 base_breakpoint_dtor (struct breakpoint
*self
)
10925 decref_counted_command_line (&self
->commands
);
10926 xfree (self
->cond_string
);
10927 xfree (self
->addr_string
);
10928 xfree (self
->addr_string_range_end
);
10929 xfree (self
->source_file
);
10932 static struct bp_location
*
10933 base_breakpoint_allocate_location (struct breakpoint
*self
)
10935 struct bp_location
*loc
;
10937 loc
= XNEW (struct bp_location
);
10938 init_bp_location (loc
, &bp_location_ops
, self
);
10943 base_breakpoint_re_set (struct breakpoint
*b
)
10945 /* Nothing to re-set. */
10948 #define internal_error_pure_virtual_called() \
10949 gdb_assert_not_reached ("pure virtual function called")
10952 base_breakpoint_insert_location (struct bp_location
*bl
)
10954 internal_error_pure_virtual_called ();
10958 base_breakpoint_remove_location (struct bp_location
*bl
)
10960 internal_error_pure_virtual_called ();
10964 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
10965 struct address_space
*aspace
,
10968 internal_error_pure_virtual_called ();
10972 base_breakpoint_check_status (bpstat bs
)
10977 /* A "works_in_software_mode" breakpoint_ops method that just internal
10981 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
10983 internal_error_pure_virtual_called ();
10986 /* A "resources_needed" breakpoint_ops method that just internal
10990 base_breakpoint_resources_needed (const struct bp_location
*bl
)
10992 internal_error_pure_virtual_called ();
10995 static enum print_stop_action
10996 base_breakpoint_print_it (bpstat bs
)
10998 internal_error_pure_virtual_called ();
11002 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
11003 struct ui_out
*uiout
)
11009 base_breakpoint_print_mention (struct breakpoint
*b
)
11011 internal_error_pure_virtual_called ();
11015 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
11017 internal_error_pure_virtual_called ();
11020 static struct breakpoint_ops base_breakpoint_ops
=
11022 base_breakpoint_dtor
,
11023 base_breakpoint_allocate_location
,
11024 base_breakpoint_re_set
,
11025 base_breakpoint_insert_location
,
11026 base_breakpoint_remove_location
,
11027 base_breakpoint_breakpoint_hit
,
11028 base_breakpoint_check_status
,
11029 base_breakpoint_resources_needed
,
11030 base_breakpoint_works_in_software_mode
,
11031 base_breakpoint_print_it
,
11033 base_breakpoint_print_one_detail
,
11034 base_breakpoint_print_mention
,
11035 base_breakpoint_print_recreate
11038 /* Default breakpoint_ops methods. */
11041 bkpt_re_set (struct breakpoint
*b
)
11043 /* Do not attempt to re-set breakpoints disabled during startup. */
11044 if (b
->enable_state
== bp_startup_disabled
)
11047 /* FIXME: is this still reachable? */
11048 if (b
->addr_string
== NULL
)
11050 /* Anything without a string can't be re-set. */
11051 delete_breakpoint (b
);
11055 breakpoint_re_set_default (b
);
11059 bkpt_insert_location (struct bp_location
*bl
)
11061 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
11062 return target_insert_hw_breakpoint (bl
->gdbarch
,
11065 return target_insert_breakpoint (bl
->gdbarch
,
11070 bkpt_remove_location (struct bp_location
*bl
)
11072 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
11073 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
11075 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
);
11079 bkpt_breakpoint_hit (const struct bp_location
*bl
,
11080 struct address_space
*aspace
, CORE_ADDR bp_addr
)
11082 struct breakpoint
*b
= bl
->owner
;
11084 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
11088 if (overlay_debugging
/* unmapped overlay section */
11089 && section_is_overlay (bl
->section
)
11090 && !section_is_mapped (bl
->section
))
11097 bkpt_resources_needed (const struct bp_location
*bl
)
11099 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
11104 static enum print_stop_action
11105 bkpt_print_it (bpstat bs
)
11107 struct breakpoint
*b
;
11108 const struct bp_location
*bl
;
11110 struct ui_out
*uiout
= current_uiout
;
11112 gdb_assert (bs
->bp_location_at
!= NULL
);
11114 bl
= bs
->bp_location_at
;
11115 b
= bs
->breakpoint_at
;
11117 bp_temp
= b
->disposition
== disp_del
;
11118 if (bl
->address
!= bl
->requested_address
)
11119 breakpoint_adjustment_warning (bl
->requested_address
,
11122 annotate_breakpoint (b
->number
);
11124 ui_out_text (uiout
, "\nTemporary breakpoint ");
11126 ui_out_text (uiout
, "\nBreakpoint ");
11127 if (ui_out_is_mi_like_p (uiout
))
11129 ui_out_field_string (uiout
, "reason",
11130 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
11131 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
11133 ui_out_field_int (uiout
, "bkptno", b
->number
);
11134 ui_out_text (uiout
, ", ");
11136 return PRINT_SRC_AND_LOC
;
11140 bkpt_print_mention (struct breakpoint
*b
)
11142 if (ui_out_is_mi_like_p (current_uiout
))
11147 case bp_breakpoint
:
11148 case bp_gnu_ifunc_resolver
:
11149 if (b
->disposition
== disp_del
)
11150 printf_filtered (_("Temporary breakpoint"));
11152 printf_filtered (_("Breakpoint"));
11153 printf_filtered (_(" %d"), b
->number
);
11154 if (b
->type
== bp_gnu_ifunc_resolver
)
11155 printf_filtered (_(" at gnu-indirect-function resolver"));
11157 case bp_hardware_breakpoint
:
11158 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
11166 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
11168 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
11169 fprintf_unfiltered (fp
, "tbreak");
11170 else if (tp
->type
== bp_breakpoint
)
11171 fprintf_unfiltered (fp
, "break");
11172 else if (tp
->type
== bp_hardware_breakpoint
11173 && tp
->disposition
== disp_del
)
11174 fprintf_unfiltered (fp
, "thbreak");
11175 else if (tp
->type
== bp_hardware_breakpoint
)
11176 fprintf_unfiltered (fp
, "hbreak");
11178 internal_error (__FILE__
, __LINE__
,
11179 _("unhandled breakpoint type %d"), (int) tp
->type
);
11181 fprintf_unfiltered (fp
, " %s", tp
->addr_string
);
11182 print_recreate_thread (tp
, fp
);
11185 /* Virtual table for internal breakpoints. */
11188 internal_bkpt_re_set (struct breakpoint
*b
)
11192 /* Delete overlay event and longjmp master breakpoints; they
11193 will be reset later by breakpoint_re_set. */
11194 case bp_overlay_event
:
11195 case bp_longjmp_master
:
11196 case bp_std_terminate_master
:
11197 case bp_exception_master
:
11198 delete_breakpoint (b
);
11201 /* This breakpoint is special, it's set up when the inferior
11202 starts and we really don't want to touch it. */
11203 case bp_shlib_event
:
11205 /* Like bp_shlib_event, this breakpoint type is special. Once
11206 it is set up, we do not want to touch it. */
11207 case bp_thread_event
:
11213 internal_bkpt_check_status (bpstat bs
)
11215 /* We do not stop for these. */
11219 static enum print_stop_action
11220 internal_bkpt_print_it (bpstat bs
)
11222 struct ui_out
*uiout
= current_uiout
;
11223 struct breakpoint
*b
;
11225 b
= bs
->breakpoint_at
;
11229 case bp_shlib_event
:
11230 /* Did we stop because the user set the stop_on_solib_events
11231 variable? (If so, we report this as a generic, "Stopped due
11232 to shlib event" message.) */
11233 ui_out_text (uiout
, _("Stopped due to shared library event\n"));
11234 if (ui_out_is_mi_like_p (uiout
))
11235 ui_out_field_string (uiout
, "reason",
11236 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
11239 case bp_thread_event
:
11240 /* Not sure how we will get here.
11241 GDB should not stop for these breakpoints. */
11242 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
11245 case bp_overlay_event
:
11246 /* By analogy with the thread event, GDB should not stop for these. */
11247 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
11250 case bp_longjmp_master
:
11251 /* These should never be enabled. */
11252 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
11255 case bp_std_terminate_master
:
11256 /* These should never be enabled. */
11257 printf_filtered (_("std::terminate Master Breakpoint: "
11258 "gdb should not stop!\n"));
11261 case bp_exception_master
:
11262 /* These should never be enabled. */
11263 printf_filtered (_("Exception Master Breakpoint: "
11264 "gdb should not stop!\n"));
11268 return PRINT_NOTHING
;
11272 internal_bkpt_print_mention (struct breakpoint
*b
)
11274 /* Nothing to mention. These breakpoints are internal. */
11277 /* Virtual table for momentary breakpoints */
11280 momentary_bkpt_re_set (struct breakpoint
*b
)
11282 /* Keep temporary breakpoints, which can be encountered when we step
11283 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
11284 Otherwise these should have been blown away via the cleanup chain
11285 or by breakpoint_init_inferior when we rerun the executable. */
11289 momentary_bkpt_check_status (bpstat bs
)
11291 /* Nothing. The point of these breakpoints is causing a stop. */
11294 static enum print_stop_action
11295 momentary_bkpt_print_it (bpstat bs
)
11297 struct ui_out
*uiout
= current_uiout
;
11299 if (ui_out_is_mi_like_p (uiout
))
11301 struct breakpoint
*b
= bs
->breakpoint_at
;
11306 ui_out_field_string
11308 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
11312 ui_out_field_string
11314 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
11319 return PRINT_UNKNOWN
;
11323 momentary_bkpt_print_mention (struct breakpoint
*b
)
11325 /* Nothing to mention. These breakpoints are internal. */
11328 /* The breakpoint_ops structure to be used in tracepoints. */
11331 tracepoint_re_set (struct breakpoint
*b
)
11333 breakpoint_re_set_default (b
);
11337 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
11338 struct address_space
*aspace
, CORE_ADDR bp_addr
)
11340 /* By definition, the inferior does not report stops at
11346 tracepoint_print_one_detail (const struct breakpoint
*self
,
11347 struct ui_out
*uiout
)
11349 struct tracepoint
*tp
= (struct tracepoint
*) self
;
11350 if (tp
->static_trace_marker_id
)
11352 gdb_assert (self
->type
== bp_static_tracepoint
);
11354 ui_out_text (uiout
, "\tmarker id is ");
11355 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
11356 tp
->static_trace_marker_id
);
11357 ui_out_text (uiout
, "\n");
11362 tracepoint_print_mention (struct breakpoint
*b
)
11364 if (ui_out_is_mi_like_p (current_uiout
))
11369 case bp_tracepoint
:
11370 printf_filtered (_("Tracepoint"));
11371 printf_filtered (_(" %d"), b
->number
);
11373 case bp_fast_tracepoint
:
11374 printf_filtered (_("Fast tracepoint"));
11375 printf_filtered (_(" %d"), b
->number
);
11377 case bp_static_tracepoint
:
11378 printf_filtered (_("Static tracepoint"));
11379 printf_filtered (_(" %d"), b
->number
);
11382 internal_error (__FILE__
, __LINE__
,
11383 _("unhandled tracepoint type %d"), (int) b
->type
);
11390 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
11392 struct tracepoint
*tp
= (struct tracepoint
*) self
;
11394 if (self
->type
== bp_fast_tracepoint
)
11395 fprintf_unfiltered (fp
, "ftrace");
11396 if (self
->type
== bp_static_tracepoint
)
11397 fprintf_unfiltered (fp
, "strace");
11398 else if (self
->type
== bp_tracepoint
)
11399 fprintf_unfiltered (fp
, "trace");
11401 internal_error (__FILE__
, __LINE__
,
11402 _("unhandled tracepoint type %d"), (int) self
->type
);
11404 fprintf_unfiltered (fp
, " %s", self
->addr_string
);
11405 print_recreate_thread (self
, fp
);
11407 if (tp
->pass_count
)
11408 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
11411 struct breakpoint_ops tracepoint_breakpoint_ops
;
11413 /* Delete a breakpoint and clean up all traces of it in the data
11417 delete_breakpoint (struct breakpoint
*bpt
)
11419 struct breakpoint
*b
;
11421 gdb_assert (bpt
!= NULL
);
11423 /* Has this bp already been deleted? This can happen because
11424 multiple lists can hold pointers to bp's. bpstat lists are
11427 One example of this happening is a watchpoint's scope bp. When
11428 the scope bp triggers, we notice that the watchpoint is out of
11429 scope, and delete it. We also delete its scope bp. But the
11430 scope bp is marked "auto-deleting", and is already on a bpstat.
11431 That bpstat is then checked for auto-deleting bp's, which are
11434 A real solution to this problem might involve reference counts in
11435 bp's, and/or giving them pointers back to their referencing
11436 bpstat's, and teaching delete_breakpoint to only free a bp's
11437 storage when no more references were extent. A cheaper bandaid
11439 if (bpt
->type
== bp_none
)
11442 /* At least avoid this stale reference until the reference counting
11443 of breakpoints gets resolved. */
11444 if (bpt
->related_breakpoint
!= bpt
)
11446 struct breakpoint
*related
;
11447 struct watchpoint
*w
;
11449 if (bpt
->type
== bp_watchpoint_scope
)
11450 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
11451 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
11452 w
= (struct watchpoint
*) bpt
;
11456 watchpoint_del_at_next_stop (w
);
11458 /* Unlink bpt from the bpt->related_breakpoint ring. */
11459 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
11460 related
= related
->related_breakpoint
);
11461 related
->related_breakpoint
= bpt
->related_breakpoint
;
11462 bpt
->related_breakpoint
= bpt
;
11465 /* watch_command_1 creates a watchpoint but only sets its number if
11466 update_watchpoint succeeds in creating its bp_locations. If there's
11467 a problem in that process, we'll be asked to delete the half-created
11468 watchpoint. In that case, don't announce the deletion. */
11470 observer_notify_breakpoint_deleted (bpt
);
11472 if (breakpoint_chain
== bpt
)
11473 breakpoint_chain
= bpt
->next
;
11475 ALL_BREAKPOINTS (b
)
11476 if (b
->next
== bpt
)
11478 b
->next
= bpt
->next
;
11482 /* Be sure no bpstat's are pointing at the breakpoint after it's
11484 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
11485 in all threads for now. Note that we cannot just remove bpstats
11486 pointing at bpt from the stop_bpstat list entirely, as breakpoint
11487 commands are associated with the bpstat; if we remove it here,
11488 then the later call to bpstat_do_actions (&stop_bpstat); in
11489 event-top.c won't do anything, and temporary breakpoints with
11490 commands won't work. */
11492 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
11494 /* Now that breakpoint is removed from breakpoint list, update the
11495 global location list. This will remove locations that used to
11496 belong to this breakpoint. Do this before freeing the breakpoint
11497 itself, since remove_breakpoint looks at location's owner. It
11498 might be better design to have location completely
11499 self-contained, but it's not the case now. */
11500 update_global_location_list (0);
11502 bpt
->ops
->dtor (bpt
);
11503 /* On the chance that someone will soon try again to delete this
11504 same bp, we mark it as deleted before freeing its storage. */
11505 bpt
->type
= bp_none
;
11510 do_delete_breakpoint_cleanup (void *b
)
11512 delete_breakpoint (b
);
11516 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
11518 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
11521 /* Iterator function to call a user-provided callback function once
11522 for each of B and its related breakpoints. */
11525 iterate_over_related_breakpoints (struct breakpoint
*b
,
11526 void (*function
) (struct breakpoint
*,
11530 struct breakpoint
*related
;
11535 struct breakpoint
*next
;
11537 /* FUNCTION may delete RELATED. */
11538 next
= related
->related_breakpoint
;
11540 if (next
== related
)
11542 /* RELATED is the last ring entry. */
11543 function (related
, data
);
11545 /* FUNCTION may have deleted it, so we'd never reach back to
11546 B. There's nothing left to do anyway, so just break
11551 function (related
, data
);
11555 while (related
!= b
);
11559 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
11561 delete_breakpoint (b
);
11564 /* A callback for map_breakpoint_numbers that calls
11565 delete_breakpoint. */
11568 do_map_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
11570 iterate_over_related_breakpoints (b
, do_delete_breakpoint
, NULL
);
11574 delete_command (char *arg
, int from_tty
)
11576 struct breakpoint
*b
, *b_tmp
;
11582 int breaks_to_delete
= 0;
11584 /* Delete all breakpoints if no argument. Do not delete
11585 internal breakpoints, these have to be deleted with an
11586 explicit breakpoint number argument. */
11587 ALL_BREAKPOINTS (b
)
11588 if (user_breakpoint_p (b
))
11590 breaks_to_delete
= 1;
11594 /* Ask user only if there are some breakpoints to delete. */
11596 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
11598 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
11599 if (user_breakpoint_p (b
))
11600 delete_breakpoint (b
);
11604 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
11608 all_locations_are_pending (struct bp_location
*loc
)
11610 for (; loc
; loc
= loc
->next
)
11611 if (!loc
->shlib_disabled
)
11616 /* Subroutine of update_breakpoint_locations to simplify it.
11617 Return non-zero if multiple fns in list LOC have the same name.
11618 Null names are ignored. */
11621 ambiguous_names_p (struct bp_location
*loc
)
11623 struct bp_location
*l
;
11624 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
11625 (int (*) (const void *,
11626 const void *)) streq
,
11627 NULL
, xcalloc
, xfree
);
11629 for (l
= loc
; l
!= NULL
; l
= l
->next
)
11632 const char *name
= l
->function_name
;
11634 /* Allow for some names to be NULL, ignore them. */
11638 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
11640 /* NOTE: We can assume slot != NULL here because xcalloc never
11644 htab_delete (htab
);
11650 htab_delete (htab
);
11654 /* When symbols change, it probably means the sources changed as well,
11655 and it might mean the static tracepoint markers are no longer at
11656 the same address or line numbers they used to be at last we
11657 checked. Losing your static tracepoints whenever you rebuild is
11658 undesirable. This function tries to resync/rematch gdb static
11659 tracepoints with the markers on the target, for static tracepoints
11660 that have not been set by marker id. Static tracepoint that have
11661 been set by marker id are reset by marker id in breakpoint_re_set.
11664 1) For a tracepoint set at a specific address, look for a marker at
11665 the old PC. If one is found there, assume to be the same marker.
11666 If the name / string id of the marker found is different from the
11667 previous known name, assume that means the user renamed the marker
11668 in the sources, and output a warning.
11670 2) For a tracepoint set at a given line number, look for a marker
11671 at the new address of the old line number. If one is found there,
11672 assume to be the same marker. If the name / string id of the
11673 marker found is different from the previous known name, assume that
11674 means the user renamed the marker in the sources, and output a
11677 3) If a marker is no longer found at the same address or line, it
11678 may mean the marker no longer exists. But it may also just mean
11679 the code changed a bit. Maybe the user added a few lines of code
11680 that made the marker move up or down (in line number terms). Ask
11681 the target for info about the marker with the string id as we knew
11682 it. If found, update line number and address in the matching
11683 static tracepoint. This will get confused if there's more than one
11684 marker with the same ID (possible in UST, although unadvised
11685 precisely because it confuses tools). */
11687 static struct symtab_and_line
11688 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
11690 struct tracepoint
*tp
= (struct tracepoint
*) b
;
11691 struct static_tracepoint_marker marker
;
11697 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
11699 if (target_static_tracepoint_marker_at (pc
, &marker
))
11701 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
11702 warning (_("static tracepoint %d changed probed marker from %s to %s"),
11704 tp
->static_trace_marker_id
, marker
.str_id
);
11706 xfree (tp
->static_trace_marker_id
);
11707 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
11708 release_static_tracepoint_marker (&marker
);
11713 /* Old marker wasn't found on target at lineno. Try looking it up
11715 if (!sal
.explicit_pc
11717 && sal
.symtab
!= NULL
11718 && tp
->static_trace_marker_id
!= NULL
)
11720 VEC(static_tracepoint_marker_p
) *markers
;
11723 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
11725 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
11727 struct symtab_and_line sal
;
11728 struct symbol
*sym
;
11729 struct static_tracepoint_marker
*marker
;
11730 struct ui_out
*uiout
= current_uiout
;
11732 marker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
11734 xfree (tp
->static_trace_marker_id
);
11735 tp
->static_trace_marker_id
= xstrdup (marker
->str_id
);
11737 warning (_("marker for static tracepoint %d (%s) not "
11738 "found at previous line number"),
11739 b
->number
, tp
->static_trace_marker_id
);
11743 sal
.pc
= marker
->address
;
11745 sal
= find_pc_line (marker
->address
, 0);
11746 sym
= find_pc_sect_function (marker
->address
, NULL
);
11747 ui_out_text (uiout
, "Now in ");
11750 ui_out_field_string (uiout
, "func",
11751 SYMBOL_PRINT_NAME (sym
));
11752 ui_out_text (uiout
, " at ");
11754 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
11755 ui_out_text (uiout
, ":");
11757 if (ui_out_is_mi_like_p (uiout
))
11759 char *fullname
= symtab_to_fullname (sal
.symtab
);
11762 ui_out_field_string (uiout
, "fullname", fullname
);
11765 ui_out_field_int (uiout
, "line", sal
.line
);
11766 ui_out_text (uiout
, "\n");
11768 b
->line_number
= sal
.line
;
11770 xfree (b
->source_file
);
11772 b
->source_file
= xstrdup (sal
.symtab
->filename
);
11774 b
->source_file
= NULL
;
11776 xfree (b
->addr_string
);
11777 b
->addr_string
= xstrprintf ("%s:%d",
11778 sal
.symtab
->filename
, b
->line_number
);
11780 /* Might be nice to check if function changed, and warn if
11783 release_static_tracepoint_marker (marker
);
11789 /* Returns 1 iff locations A and B are sufficiently same that
11790 we don't need to report breakpoint as changed. */
11793 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
11797 if (a
->address
!= b
->address
)
11800 if (a
->shlib_disabled
!= b
->shlib_disabled
)
11803 if (a
->enabled
!= b
->enabled
)
11810 if ((a
== NULL
) != (b
== NULL
))
11816 /* Create new breakpoint locations for B (a hardware or software breakpoint)
11817 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
11818 a ranged breakpoint. */
11821 update_breakpoint_locations (struct breakpoint
*b
,
11822 struct symtabs_and_lines sals
,
11823 struct symtabs_and_lines sals_end
)
11826 struct bp_location
*existing_locations
= b
->loc
;
11828 /* Ranged breakpoints have only one start location and one end location. */
11829 gdb_assert (sals_end
.nelts
== 0 || (sals
.nelts
== 1 && sals_end
.nelts
== 1));
11831 /* If there's no new locations, and all existing locations are
11832 pending, don't do anything. This optimizes the common case where
11833 all locations are in the same shared library, that was unloaded.
11834 We'd like to retain the location, so that when the library is
11835 loaded again, we don't loose the enabled/disabled status of the
11836 individual locations. */
11837 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
11842 for (i
= 0; i
< sals
.nelts
; ++i
)
11844 struct bp_location
*new_loc
=
11845 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
11847 /* Reparse conditions, they might contain references to the
11849 if (b
->cond_string
!= NULL
)
11852 struct gdb_exception e
;
11854 s
= b
->cond_string
;
11855 TRY_CATCH (e
, RETURN_MASK_ERROR
)
11857 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
11862 warning (_("failed to reevaluate condition "
11863 "for breakpoint %d: %s"),
11864 b
->number
, e
.message
);
11865 new_loc
->enabled
= 0;
11869 if (b
->source_file
!= NULL
)
11870 xfree (b
->source_file
);
11871 if (sals
.sals
[i
].symtab
== NULL
)
11872 b
->source_file
= NULL
;
11874 b
->source_file
= xstrdup (sals
.sals
[i
].symtab
->filename
);
11876 if (b
->line_number
== 0)
11877 b
->line_number
= sals
.sals
[i
].line
;
11879 if (sals_end
.nelts
)
11881 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
11883 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
11887 /* Update locations of permanent breakpoints. */
11888 if (b
->enable_state
== bp_permanent
)
11889 make_breakpoint_permanent (b
);
11891 /* If possible, carry over 'disable' status from existing
11894 struct bp_location
*e
= existing_locations
;
11895 /* If there are multiple breakpoints with the same function name,
11896 e.g. for inline functions, comparing function names won't work.
11897 Instead compare pc addresses; this is just a heuristic as things
11898 may have moved, but in practice it gives the correct answer
11899 often enough until a better solution is found. */
11900 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
11902 for (; e
; e
= e
->next
)
11904 if (!e
->enabled
&& e
->function_name
)
11906 struct bp_location
*l
= b
->loc
;
11907 if (have_ambiguous_names
)
11909 for (; l
; l
= l
->next
)
11910 if (breakpoint_locations_match (e
, l
))
11918 for (; l
; l
= l
->next
)
11919 if (l
->function_name
11920 && strcmp (e
->function_name
, l
->function_name
) == 0)
11930 if (!locations_are_equal (existing_locations
, b
->loc
))
11931 observer_notify_breakpoint_modified (b
);
11933 update_global_location_list (1);
11936 /* Find the SaL locations corresponding to the given ADDR_STRING.
11937 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
11939 static struct symtabs_and_lines
11940 addr_string_to_sals (struct breakpoint
*b
, char *addr_string
, int *found
)
11944 struct symtabs_and_lines sals
= {0};
11945 struct gdb_exception e
;
11948 marker_spec
= b
->type
== bp_static_tracepoint
&& is_marker_spec (s
);
11950 TRY_CATCH (e
, RETURN_MASK_ERROR
)
11954 struct tracepoint
*tp
= (struct tracepoint
*) b
;
11956 sals
= decode_static_tracepoint_spec (&s
);
11957 if (sals
.nelts
> tp
->static_trace_marker_id_idx
)
11959 sals
.sals
[0] = sals
.sals
[tp
->static_trace_marker_id_idx
];
11963 error (_("marker %s not found"), tp
->static_trace_marker_id
);
11966 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, NULL
);
11970 int not_found_and_ok
= 0;
11971 /* For pending breakpoints, it's expected that parsing will
11972 fail until the right shared library is loaded. User has
11973 already told to create pending breakpoints and don't need
11974 extra messages. If breakpoint is in bp_shlib_disabled
11975 state, then user already saw the message about that
11976 breakpoint being disabled, and don't want to see more
11978 if (e
.error
== NOT_FOUND_ERROR
11979 && (b
->condition_not_parsed
11980 || (b
->loc
&& b
->loc
->shlib_disabled
)
11981 || b
->enable_state
== bp_disabled
))
11982 not_found_and_ok
= 1;
11984 if (!not_found_and_ok
)
11986 /* We surely don't want to warn about the same breakpoint
11987 10 times. One solution, implemented here, is disable
11988 the breakpoint on error. Another solution would be to
11989 have separate 'warning emitted' flag. Since this
11990 happens only when a binary has changed, I don't know
11991 which approach is better. */
11992 b
->enable_state
= bp_disabled
;
11993 throw_exception (e
);
11997 if (e
.reason
== 0 || e
.error
!= NOT_FOUND_ERROR
)
11999 gdb_assert (sals
.nelts
== 1);
12001 resolve_sal_pc (&sals
.sals
[0]);
12002 if (b
->condition_not_parsed
&& s
&& s
[0])
12004 char *cond_string
= 0;
12008 find_condition_and_thread (s
, sals
.sals
[0].pc
,
12009 &cond_string
, &thread
, &task
);
12011 b
->cond_string
= cond_string
;
12012 b
->thread
= thread
;
12014 b
->condition_not_parsed
= 0;
12017 if (b
->type
== bp_static_tracepoint
&& !marker_spec
)
12018 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
12028 /* The default re_set method, for typical hardware or software
12029 breakpoints. Reevaluate the breakpoint and recreate its
12033 breakpoint_re_set_default (struct breakpoint
*b
)
12036 struct symtabs_and_lines sals
, sals_end
;
12037 struct symtabs_and_lines expanded
= {0};
12038 struct symtabs_and_lines expanded_end
= {0};
12040 sals
= addr_string_to_sals (b
, b
->addr_string
, &found
);
12043 make_cleanup (xfree
, sals
.sals
);
12044 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
12047 if (b
->addr_string_range_end
)
12049 sals_end
= addr_string_to_sals (b
, b
->addr_string_range_end
, &found
);
12052 make_cleanup (xfree
, sals_end
.sals
);
12053 expanded_end
= expand_line_sal_maybe (sals_end
.sals
[0]);
12057 update_breakpoint_locations (b
, expanded
, expanded_end
);
12060 /* Prepare the global context for a re-set of breakpoint B. */
12062 static struct cleanup
*
12063 prepare_re_set_context (struct breakpoint
*b
)
12065 struct cleanup
*cleanups
;
12067 input_radix
= b
->input_radix
;
12068 cleanups
= save_current_space_and_thread ();
12069 switch_to_program_space_and_thread (b
->pspace
);
12070 set_language (b
->language
);
12075 /* Reset a breakpoint given it's struct breakpoint * BINT.
12076 The value we return ends up being the return value from catch_errors.
12077 Unused in this case. */
12080 breakpoint_re_set_one (void *bint
)
12082 /* Get past catch_errs. */
12083 struct breakpoint
*b
= (struct breakpoint
*) bint
;
12084 struct cleanup
*cleanups
;
12086 cleanups
= prepare_re_set_context (b
);
12087 b
->ops
->re_set (b
);
12088 do_cleanups (cleanups
);
12092 /* Re-set all breakpoints after symbols have been re-loaded. */
12094 breakpoint_re_set (void)
12096 struct breakpoint
*b
, *b_tmp
;
12097 enum language save_language
;
12098 int save_input_radix
;
12099 struct cleanup
*old_chain
;
12101 save_language
= current_language
->la_language
;
12102 save_input_radix
= input_radix
;
12103 old_chain
= save_current_program_space ();
12105 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12107 /* Format possible error msg. */
12108 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
12110 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
12111 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
12112 do_cleanups (cleanups
);
12114 set_language (save_language
);
12115 input_radix
= save_input_radix
;
12117 jit_breakpoint_re_set ();
12119 do_cleanups (old_chain
);
12121 create_overlay_event_breakpoint ();
12122 create_longjmp_master_breakpoint ();
12123 create_std_terminate_master_breakpoint ();
12124 create_exception_master_breakpoint ();
12126 /* While we're at it, reset the skip list too. */
12130 /* Reset the thread number of this breakpoint:
12132 - If the breakpoint is for all threads, leave it as-is.
12133 - Else, reset it to the current thread for inferior_ptid. */
12135 breakpoint_re_set_thread (struct breakpoint
*b
)
12137 if (b
->thread
!= -1)
12139 if (in_thread_list (inferior_ptid
))
12140 b
->thread
= pid_to_thread_id (inferior_ptid
);
12142 /* We're being called after following a fork. The new fork is
12143 selected as current, and unless this was a vfork will have a
12144 different program space from the original thread. Reset that
12146 b
->loc
->pspace
= current_program_space
;
12150 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
12151 If from_tty is nonzero, it prints a message to that effect,
12152 which ends with a period (no newline). */
12155 set_ignore_count (int bptnum
, int count
, int from_tty
)
12157 struct breakpoint
*b
;
12162 ALL_BREAKPOINTS (b
)
12163 if (b
->number
== bptnum
)
12165 if (is_tracepoint (b
))
12167 if (from_tty
&& count
!= 0)
12168 printf_filtered (_("Ignore count ignored for tracepoint %d."),
12173 b
->ignore_count
= count
;
12177 printf_filtered (_("Will stop next time "
12178 "breakpoint %d is reached."),
12180 else if (count
== 1)
12181 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
12184 printf_filtered (_("Will ignore next %d "
12185 "crossings of breakpoint %d."),
12188 breakpoints_changed ();
12189 observer_notify_breakpoint_modified (b
);
12193 error (_("No breakpoint number %d."), bptnum
);
12196 /* Command to set ignore-count of breakpoint N to COUNT. */
12199 ignore_command (char *args
, int from_tty
)
12205 error_no_arg (_("a breakpoint number"));
12207 num
= get_number (&p
);
12209 error (_("bad breakpoint number: '%s'"), args
);
12211 error (_("Second argument (specified ignore-count) is missing."));
12213 set_ignore_count (num
,
12214 longest_to_int (value_as_long (parse_and_eval (p
))),
12217 printf_filtered ("\n");
12220 /* Call FUNCTION on each of the breakpoints
12221 whose numbers are given in ARGS. */
12224 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
12229 struct breakpoint
*b
, *tmp
;
12231 struct get_number_or_range_state state
;
12234 error_no_arg (_("one or more breakpoint numbers"));
12236 init_number_or_range (&state
, args
);
12238 while (!state
.finished
)
12240 char *p
= state
.string
;
12244 num
= get_number_or_range (&state
);
12247 warning (_("bad breakpoint number at or near '%s'"), p
);
12251 ALL_BREAKPOINTS_SAFE (b
, tmp
)
12252 if (b
->number
== num
)
12255 function (b
, data
);
12259 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
12264 static struct bp_location
*
12265 find_location_by_number (char *number
)
12267 char *dot
= strchr (number
, '.');
12271 struct breakpoint
*b
;
12272 struct bp_location
*loc
;
12277 bp_num
= get_number (&p1
);
12279 error (_("Bad breakpoint number '%s'"), number
);
12281 ALL_BREAKPOINTS (b
)
12282 if (b
->number
== bp_num
)
12287 if (!b
|| b
->number
!= bp_num
)
12288 error (_("Bad breakpoint number '%s'"), number
);
12291 loc_num
= get_number (&p1
);
12293 error (_("Bad breakpoint location number '%s'"), number
);
12297 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
12300 error (_("Bad breakpoint location number '%s'"), dot
+1);
12306 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
12307 If from_tty is nonzero, it prints a message to that effect,
12308 which ends with a period (no newline). */
12311 disable_breakpoint (struct breakpoint
*bpt
)
12313 /* Never disable a watchpoint scope breakpoint; we want to
12314 hit them when we leave scope so we can delete both the
12315 watchpoint and its scope breakpoint at that time. */
12316 if (bpt
->type
== bp_watchpoint_scope
)
12319 /* You can't disable permanent breakpoints. */
12320 if (bpt
->enable_state
== bp_permanent
)
12323 bpt
->enable_state
= bp_disabled
;
12325 if (target_supports_enable_disable_tracepoint ()
12326 && current_trace_status ()->running
&& is_tracepoint (bpt
))
12328 struct bp_location
*location
;
12330 for (location
= bpt
->loc
; location
; location
= location
->next
)
12331 target_disable_tracepoint (location
);
12334 update_global_location_list (0);
12336 observer_notify_breakpoint_modified (bpt
);
12339 /* A callback for iterate_over_related_breakpoints. */
12342 do_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
12344 disable_breakpoint (b
);
12347 /* A callback for map_breakpoint_numbers that calls
12348 disable_breakpoint. */
12351 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
12353 iterate_over_related_breakpoints (b
, do_disable_breakpoint
, NULL
);
12357 disable_command (char *args
, int from_tty
)
12361 struct breakpoint
*bpt
;
12363 ALL_BREAKPOINTS (bpt
)
12364 if (user_breakpoint_p (bpt
))
12365 disable_breakpoint (bpt
);
12367 else if (strchr (args
, '.'))
12369 struct bp_location
*loc
= find_location_by_number (args
);
12373 if (target_supports_enable_disable_tracepoint ()
12374 && current_trace_status ()->running
&& loc
->owner
12375 && is_tracepoint (loc
->owner
))
12376 target_disable_tracepoint (loc
);
12378 update_global_location_list (0);
12381 map_breakpoint_numbers (args
, do_map_disable_breakpoint
, NULL
);
12385 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
)
12387 int target_resources_ok
;
12389 if (bpt
->type
== bp_hardware_breakpoint
)
12392 i
= hw_breakpoint_used_count ();
12393 target_resources_ok
=
12394 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
12396 if (target_resources_ok
== 0)
12397 error (_("No hardware breakpoint support in the target."));
12398 else if (target_resources_ok
< 0)
12399 error (_("Hardware breakpoints used exceeds limit."));
12402 if (is_watchpoint (bpt
))
12404 /* Initialize it just to avoid a GCC false warning. */
12405 enum enable_state orig_enable_state
= 0;
12406 struct gdb_exception e
;
12408 TRY_CATCH (e
, RETURN_MASK_ALL
)
12410 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
12412 orig_enable_state
= bpt
->enable_state
;
12413 bpt
->enable_state
= bp_enabled
;
12414 update_watchpoint (w
, 1 /* reparse */);
12418 bpt
->enable_state
= orig_enable_state
;
12419 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
12425 if (bpt
->enable_state
!= bp_permanent
)
12426 bpt
->enable_state
= bp_enabled
;
12428 if (target_supports_enable_disable_tracepoint ()
12429 && current_trace_status ()->running
&& is_tracepoint (bpt
))
12431 struct bp_location
*location
;
12433 for (location
= bpt
->loc
; location
; location
= location
->next
)
12434 target_enable_tracepoint (location
);
12437 bpt
->disposition
= disposition
;
12438 update_global_location_list (1);
12439 breakpoints_changed ();
12441 observer_notify_breakpoint_modified (bpt
);
12446 enable_breakpoint (struct breakpoint
*bpt
)
12448 enable_breakpoint_disp (bpt
, bpt
->disposition
);
12452 do_enable_breakpoint (struct breakpoint
*bpt
, void *arg
)
12454 enable_breakpoint (bpt
);
12457 /* A callback for map_breakpoint_numbers that calls
12458 enable_breakpoint. */
12461 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
12463 iterate_over_related_breakpoints (b
, do_enable_breakpoint
, NULL
);
12466 /* The enable command enables the specified breakpoints (or all defined
12467 breakpoints) so they once again become (or continue to be) effective
12468 in stopping the inferior. */
12471 enable_command (char *args
, int from_tty
)
12475 struct breakpoint
*bpt
;
12477 ALL_BREAKPOINTS (bpt
)
12478 if (user_breakpoint_p (bpt
))
12479 enable_breakpoint (bpt
);
12481 else if (strchr (args
, '.'))
12483 struct bp_location
*loc
= find_location_by_number (args
);
12487 if (target_supports_enable_disable_tracepoint ()
12488 && current_trace_status ()->running
&& loc
->owner
12489 && is_tracepoint (loc
->owner
))
12490 target_enable_tracepoint (loc
);
12492 update_global_location_list (1);
12495 map_breakpoint_numbers (args
, do_map_enable_breakpoint
, NULL
);
12499 do_enable_breakpoint_disp (struct breakpoint
*bpt
, void *arg
)
12501 enum bpdisp disp
= *(enum bpdisp
*) arg
;
12503 enable_breakpoint_disp (bpt
, disp
);
12507 do_map_enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
12509 enum bpdisp disp
= disp_disable
;
12511 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
12515 enable_once_command (char *args
, int from_tty
)
12517 map_breakpoint_numbers (args
, do_map_enable_once_breakpoint
, NULL
);
12521 do_map_enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
12523 enum bpdisp disp
= disp_del
;
12525 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
12529 enable_delete_command (char *args
, int from_tty
)
12531 map_breakpoint_numbers (args
, do_map_enable_delete_breakpoint
, NULL
);
12535 set_breakpoint_cmd (char *args
, int from_tty
)
12540 show_breakpoint_cmd (char *args
, int from_tty
)
12544 /* Invalidate last known value of any hardware watchpoint if
12545 the memory which that value represents has been written to by
12549 invalidate_bp_value_on_memory_change (CORE_ADDR addr
, int len
,
12550 const bfd_byte
*data
)
12552 struct breakpoint
*bp
;
12554 ALL_BREAKPOINTS (bp
)
12555 if (bp
->enable_state
== bp_enabled
12556 && bp
->type
== bp_hardware_watchpoint
)
12558 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
12560 if (wp
->val_valid
&& wp
->val
)
12562 struct bp_location
*loc
;
12564 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
12565 if (loc
->loc_type
== bp_loc_hardware_watchpoint
12566 && loc
->address
+ loc
->length
> addr
12567 && addr
+ len
> loc
->address
)
12569 value_free (wp
->val
);
12577 /* Use the last displayed codepoint's values, or nothing
12578 if they aren't valid. */
12580 struct symtabs_and_lines
12581 decode_line_spec_1 (char *string
, int funfirstline
)
12583 struct symtabs_and_lines sals
;
12586 error (_("Empty line specification."));
12587 if (last_displayed_sal_is_valid ())
12588 sals
= decode_line_1 (&string
, funfirstline
,
12589 get_last_displayed_symtab (),
12590 get_last_displayed_line (),
12593 sals
= decode_line_1 (&string
, funfirstline
,
12594 (struct symtab
*) NULL
, 0, NULL
);
12596 error (_("Junk at end of line specification: %s"), string
);
12600 /* Create and insert a raw software breakpoint at PC. Return an
12601 identifier, which should be used to remove the breakpoint later.
12602 In general, places which call this should be using something on the
12603 breakpoint chain instead; this function should be eliminated
12607 deprecated_insert_raw_breakpoint (struct gdbarch
*gdbarch
,
12608 struct address_space
*aspace
, CORE_ADDR pc
)
12610 struct bp_target_info
*bp_tgt
;
12612 bp_tgt
= XZALLOC (struct bp_target_info
);
12614 bp_tgt
->placed_address_space
= aspace
;
12615 bp_tgt
->placed_address
= pc
;
12617 if (target_insert_breakpoint (gdbarch
, bp_tgt
) != 0)
12619 /* Could not insert the breakpoint. */
12627 /* Remove a breakpoint BP inserted by
12628 deprecated_insert_raw_breakpoint. */
12631 deprecated_remove_raw_breakpoint (struct gdbarch
*gdbarch
, void *bp
)
12633 struct bp_target_info
*bp_tgt
= bp
;
12636 ret
= target_remove_breakpoint (gdbarch
, bp_tgt
);
12642 /* One (or perhaps two) breakpoints used for software single
12645 static void *single_step_breakpoints
[2];
12646 static struct gdbarch
*single_step_gdbarch
[2];
12648 /* Create and insert a breakpoint for software single step. */
12651 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
12652 struct address_space
*aspace
,
12657 if (single_step_breakpoints
[0] == NULL
)
12659 bpt_p
= &single_step_breakpoints
[0];
12660 single_step_gdbarch
[0] = gdbarch
;
12664 gdb_assert (single_step_breakpoints
[1] == NULL
);
12665 bpt_p
= &single_step_breakpoints
[1];
12666 single_step_gdbarch
[1] = gdbarch
;
12669 /* NOTE drow/2006-04-11: A future improvement to this function would
12670 be to only create the breakpoints once, and actually put them on
12671 the breakpoint chain. That would let us use set_raw_breakpoint.
12672 We could adjust the addresses each time they were needed. Doing
12673 this requires corresponding changes elsewhere where single step
12674 breakpoints are handled, however. So, for now, we use this. */
12676 *bpt_p
= deprecated_insert_raw_breakpoint (gdbarch
, aspace
, next_pc
);
12677 if (*bpt_p
== NULL
)
12678 error (_("Could not insert single-step breakpoint at %s"),
12679 paddress (gdbarch
, next_pc
));
12682 /* Check if the breakpoints used for software single stepping
12683 were inserted or not. */
12686 single_step_breakpoints_inserted (void)
12688 return (single_step_breakpoints
[0] != NULL
12689 || single_step_breakpoints
[1] != NULL
);
12692 /* Remove and delete any breakpoints used for software single step. */
12695 remove_single_step_breakpoints (void)
12697 gdb_assert (single_step_breakpoints
[0] != NULL
);
12699 /* See insert_single_step_breakpoint for more about this deprecated
12701 deprecated_remove_raw_breakpoint (single_step_gdbarch
[0],
12702 single_step_breakpoints
[0]);
12703 single_step_gdbarch
[0] = NULL
;
12704 single_step_breakpoints
[0] = NULL
;
12706 if (single_step_breakpoints
[1] != NULL
)
12708 deprecated_remove_raw_breakpoint (single_step_gdbarch
[1],
12709 single_step_breakpoints
[1]);
12710 single_step_gdbarch
[1] = NULL
;
12711 single_step_breakpoints
[1] = NULL
;
12715 /* Delete software single step breakpoints without removing them from
12716 the inferior. This is intended to be used if the inferior's address
12717 space where they were inserted is already gone, e.g. after exit or
12721 cancel_single_step_breakpoints (void)
12725 for (i
= 0; i
< 2; i
++)
12726 if (single_step_breakpoints
[i
])
12728 xfree (single_step_breakpoints
[i
]);
12729 single_step_breakpoints
[i
] = NULL
;
12730 single_step_gdbarch
[i
] = NULL
;
12734 /* Detach software single-step breakpoints from INFERIOR_PTID without
12738 detach_single_step_breakpoints (void)
12742 for (i
= 0; i
< 2; i
++)
12743 if (single_step_breakpoints
[i
])
12744 target_remove_breakpoint (single_step_gdbarch
[i
],
12745 single_step_breakpoints
[i
]);
12748 /* Check whether a software single-step breakpoint is inserted at
12752 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
12757 for (i
= 0; i
< 2; i
++)
12759 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
12761 && breakpoint_address_match (bp_tgt
->placed_address_space
,
12762 bp_tgt
->placed_address
,
12770 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
12771 non-zero otherwise. */
12773 is_syscall_catchpoint_enabled (struct breakpoint
*bp
)
12775 if (syscall_catchpoint_p (bp
)
12776 && bp
->enable_state
!= bp_disabled
12777 && bp
->enable_state
!= bp_call_disabled
)
12784 catch_syscall_enabled (void)
12786 struct inferior
*inf
= current_inferior ();
12788 return inf
->total_syscalls_count
!= 0;
12792 catching_syscall_number (int syscall_number
)
12794 struct breakpoint
*bp
;
12796 ALL_BREAKPOINTS (bp
)
12797 if (is_syscall_catchpoint_enabled (bp
))
12799 struct syscall_catchpoint
*c
= (struct syscall_catchpoint
*) bp
;
12801 if (c
->syscalls_to_be_caught
)
12805 VEC_iterate (int, c
->syscalls_to_be_caught
, i
, iter
);
12807 if (syscall_number
== iter
)
12817 /* Complete syscall names. Used by "catch syscall". */
12819 catch_syscall_completer (struct cmd_list_element
*cmd
,
12820 char *text
, char *word
)
12822 const char **list
= get_syscall_names ();
12824 = (list
== NULL
) ? NULL
: complete_on_enum (list
, text
, word
);
12830 /* Tracepoint-specific operations. */
12832 /* Set tracepoint count to NUM. */
12834 set_tracepoint_count (int num
)
12836 tracepoint_count
= num
;
12837 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
12841 trace_command (char *arg
, int from_tty
)
12843 if (create_breakpoint (get_current_arch (),
12845 NULL
, 0, 1 /* parse arg */,
12847 bp_tracepoint
/* type_wanted */,
12848 0 /* Ignore count */,
12849 pending_break_support
,
12850 &tracepoint_breakpoint_ops
,
12854 set_tracepoint_count (breakpoint_count
);
12858 ftrace_command (char *arg
, int from_tty
)
12860 if (create_breakpoint (get_current_arch (),
12862 NULL
, 0, 1 /* parse arg */,
12864 bp_fast_tracepoint
/* type_wanted */,
12865 0 /* Ignore count */,
12866 pending_break_support
,
12867 &tracepoint_breakpoint_ops
,
12871 set_tracepoint_count (breakpoint_count
);
12874 /* strace command implementation. Creates a static tracepoint. */
12877 strace_command (char *arg
, int from_tty
)
12879 if (create_breakpoint (get_current_arch (),
12881 NULL
, 0, 1 /* parse arg */,
12883 bp_static_tracepoint
/* type_wanted */,
12884 0 /* Ignore count */,
12885 pending_break_support
,
12886 &tracepoint_breakpoint_ops
,
12890 set_tracepoint_count (breakpoint_count
);
12893 /* Set up a fake reader function that gets command lines from a linked
12894 list that was acquired during tracepoint uploading. */
12896 static struct uploaded_tp
*this_utp
;
12897 static int next_cmd
;
12900 read_uploaded_action (void)
12904 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
12911 /* Given information about a tracepoint as recorded on a target (which
12912 can be either a live system or a trace file), attempt to create an
12913 equivalent GDB tracepoint. This is not a reliable process, since
12914 the target does not necessarily have all the information used when
12915 the tracepoint was originally defined. */
12917 struct tracepoint
*
12918 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
12920 char *addr_str
, small_buf
[100];
12921 struct tracepoint
*tp
;
12923 if (utp
->at_string
)
12924 addr_str
= utp
->at_string
;
12927 /* In the absence of a source location, fall back to raw
12928 address. Since there is no way to confirm that the address
12929 means the same thing as when the trace was started, warn the
12931 warning (_("Uploaded tracepoint %d has no "
12932 "source location, using raw address"),
12934 sprintf (small_buf
, "*%s", hex_string (utp
->addr
));
12935 addr_str
= small_buf
;
12938 /* There's not much we can do with a sequence of bytecodes. */
12939 if (utp
->cond
&& !utp
->cond_string
)
12940 warning (_("Uploaded tracepoint %d condition "
12941 "has no source form, ignoring it"),
12944 if (!create_breakpoint (get_current_arch (),
12946 utp
->cond_string
, -1, 0 /* parse cond/thread */,
12948 utp
->type
/* type_wanted */,
12949 0 /* Ignore count */,
12950 pending_break_support
,
12951 &tracepoint_breakpoint_ops
,
12953 utp
->enabled
/* enabled */,
12957 set_tracepoint_count (breakpoint_count
);
12959 /* Get the tracepoint we just created. */
12960 tp
= get_tracepoint (tracepoint_count
);
12961 gdb_assert (tp
!= NULL
);
12965 sprintf (small_buf
, "%d %d", utp
->pass
, tp
->base
.number
);
12967 trace_pass_command (small_buf
, 0);
12970 /* If we have uploaded versions of the original commands, set up a
12971 special-purpose "reader" function and call the usual command line
12972 reader, then pass the result to the breakpoint command-setting
12974 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
12976 struct command_line
*cmd_list
;
12981 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
12983 breakpoint_set_commands (&tp
->base
, cmd_list
);
12985 else if (!VEC_empty (char_ptr
, utp
->actions
)
12986 || !VEC_empty (char_ptr
, utp
->step_actions
))
12987 warning (_("Uploaded tracepoint %d actions "
12988 "have no source form, ignoring them"),
12991 /* Copy any status information that might be available. */
12992 tp
->base
.hit_count
= utp
->hit_count
;
12993 tp
->traceframe_usage
= utp
->traceframe_usage
;
12998 /* Print information on tracepoint number TPNUM_EXP, or all if
13002 tracepoints_info (char *args
, int from_tty
)
13004 struct ui_out
*uiout
= current_uiout
;
13007 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
13009 if (num_printed
== 0)
13011 if (args
== NULL
|| *args
== '\0')
13012 ui_out_message (uiout
, 0, "No tracepoints.\n");
13014 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
13017 default_collect_info ();
13020 /* The 'enable trace' command enables tracepoints.
13021 Not supported by all targets. */
13023 enable_trace_command (char *args
, int from_tty
)
13025 enable_command (args
, from_tty
);
13028 /* The 'disable trace' command disables tracepoints.
13029 Not supported by all targets. */
13031 disable_trace_command (char *args
, int from_tty
)
13033 disable_command (args
, from_tty
);
13036 /* Remove a tracepoint (or all if no argument). */
13038 delete_trace_command (char *arg
, int from_tty
)
13040 struct breakpoint
*b
, *b_tmp
;
13046 int breaks_to_delete
= 0;
13048 /* Delete all breakpoints if no argument.
13049 Do not delete internal or call-dummy breakpoints, these
13050 have to be deleted with an explicit breakpoint number
13052 ALL_TRACEPOINTS (b
)
13053 if (is_tracepoint (b
) && user_breakpoint_p (b
))
13055 breaks_to_delete
= 1;
13059 /* Ask user only if there are some breakpoints to delete. */
13061 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
13063 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13064 if (is_tracepoint (b
) && user_breakpoint_p (b
))
13065 delete_breakpoint (b
);
13069 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
13072 /* Helper function for trace_pass_command. */
13075 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
13077 tp
->pass_count
= count
;
13078 observer_notify_tracepoint_modified (tp
->base
.number
);
13080 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
13081 tp
->base
.number
, count
);
13084 /* Set passcount for tracepoint.
13086 First command argument is passcount, second is tracepoint number.
13087 If tracepoint number omitted, apply to most recently defined.
13088 Also accepts special argument "all". */
13091 trace_pass_command (char *args
, int from_tty
)
13093 struct tracepoint
*t1
;
13094 unsigned int count
;
13096 if (args
== 0 || *args
== 0)
13097 error (_("passcount command requires an "
13098 "argument (count + optional TP num)"));
13100 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
13102 while (*args
&& isspace ((int) *args
))
13105 if (*args
&& strncasecmp (args
, "all", 3) == 0)
13107 struct breakpoint
*b
;
13109 args
+= 3; /* Skip special argument "all". */
13111 error (_("Junk at end of arguments."));
13113 ALL_TRACEPOINTS (b
)
13115 t1
= (struct tracepoint
*) b
;
13116 trace_pass_set_count (t1
, count
, from_tty
);
13119 else if (*args
== '\0')
13121 t1
= get_tracepoint_by_number (&args
, NULL
, 1);
13123 trace_pass_set_count (t1
, count
, from_tty
);
13127 struct get_number_or_range_state state
;
13129 init_number_or_range (&state
, args
);
13130 while (!state
.finished
)
13132 t1
= get_tracepoint_by_number (&args
, &state
, 1);
13134 trace_pass_set_count (t1
, count
, from_tty
);
13139 struct tracepoint
*
13140 get_tracepoint (int num
)
13142 struct breakpoint
*t
;
13144 ALL_TRACEPOINTS (t
)
13145 if (t
->number
== num
)
13146 return (struct tracepoint
*) t
;
13151 /* Find the tracepoint with the given target-side number (which may be
13152 different from the tracepoint number after disconnecting and
13155 struct tracepoint
*
13156 get_tracepoint_by_number_on_target (int num
)
13158 struct breakpoint
*b
;
13160 ALL_TRACEPOINTS (b
)
13162 struct tracepoint
*t
= (struct tracepoint
*) b
;
13164 if (t
->number_on_target
== num
)
13171 /* Utility: parse a tracepoint number and look it up in the list.
13172 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
13173 If OPTIONAL_P is true, then if the argument is missing, the most
13174 recent tracepoint (tracepoint_count) is returned. */
13175 struct tracepoint
*
13176 get_tracepoint_by_number (char **arg
,
13177 struct get_number_or_range_state
*state
,
13180 extern int tracepoint_count
;
13181 struct breakpoint
*t
;
13183 char *instring
= arg
== NULL
? NULL
: *arg
;
13187 gdb_assert (!state
->finished
);
13188 tpnum
= get_number_or_range (state
);
13190 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
13193 tpnum
= tracepoint_count
;
13195 error_no_arg (_("tracepoint number"));
13198 tpnum
= get_number (arg
);
13202 if (instring
&& *instring
)
13203 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
13206 printf_filtered (_("Tracepoint argument missing "
13207 "and no previous tracepoint\n"));
13211 ALL_TRACEPOINTS (t
)
13212 if (t
->number
== tpnum
)
13214 return (struct tracepoint
*) t
;
13217 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
13222 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
13224 if (b
->thread
!= -1)
13225 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
13228 fprintf_unfiltered (fp
, " task %d", b
->task
);
13230 fprintf_unfiltered (fp
, "\n");
13233 /* Save information on user settable breakpoints (watchpoints, etc) to
13234 a new script file named FILENAME. If FILTER is non-NULL, call it
13235 on each breakpoint and only include the ones for which it returns
13239 save_breakpoints (char *filename
, int from_tty
,
13240 int (*filter
) (const struct breakpoint
*))
13242 struct breakpoint
*tp
;
13245 struct cleanup
*cleanup
;
13246 struct ui_file
*fp
;
13247 int extra_trace_bits
= 0;
13249 if (filename
== 0 || *filename
== 0)
13250 error (_("Argument required (file name in which to save)"));
13252 /* See if we have anything to save. */
13253 ALL_BREAKPOINTS (tp
)
13255 /* Skip internal and momentary breakpoints. */
13256 if (!user_breakpoint_p (tp
))
13259 /* If we have a filter, only save the breakpoints it accepts. */
13260 if (filter
&& !filter (tp
))
13265 if (is_tracepoint (tp
))
13267 extra_trace_bits
= 1;
13269 /* We can stop searching. */
13276 warning (_("Nothing to save."));
13280 pathname
= tilde_expand (filename
);
13281 cleanup
= make_cleanup (xfree
, pathname
);
13282 fp
= gdb_fopen (pathname
, "w");
13284 error (_("Unable to open file '%s' for saving (%s)"),
13285 filename
, safe_strerror (errno
));
13286 make_cleanup_ui_file_delete (fp
);
13288 if (extra_trace_bits
)
13289 save_trace_state_variables (fp
);
13291 ALL_BREAKPOINTS (tp
)
13293 /* Skip internal and momentary breakpoints. */
13294 if (!user_breakpoint_p (tp
))
13297 /* If we have a filter, only save the breakpoints it accepts. */
13298 if (filter
&& !filter (tp
))
13301 tp
->ops
->print_recreate (tp
, fp
);
13303 /* Note, we can't rely on tp->number for anything, as we can't
13304 assume the recreated breakpoint numbers will match. Use $bpnum
13307 if (tp
->cond_string
)
13308 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
13310 if (tp
->ignore_count
)
13311 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
13315 volatile struct gdb_exception ex
;
13317 fprintf_unfiltered (fp
, " commands\n");
13319 ui_out_redirect (current_uiout
, fp
);
13320 TRY_CATCH (ex
, RETURN_MASK_ALL
)
13322 print_command_lines (current_uiout
, tp
->commands
->commands
, 2);
13324 ui_out_redirect (current_uiout
, NULL
);
13327 throw_exception (ex
);
13329 fprintf_unfiltered (fp
, " end\n");
13332 if (tp
->enable_state
== bp_disabled
)
13333 fprintf_unfiltered (fp
, "disable\n");
13335 /* If this is a multi-location breakpoint, check if the locations
13336 should be individually disabled. Watchpoint locations are
13337 special, and not user visible. */
13338 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
13340 struct bp_location
*loc
;
13343 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
13345 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
13349 if (extra_trace_bits
&& *default_collect
)
13350 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
13352 do_cleanups (cleanup
);
13354 printf_filtered (_("Saved to file '%s'.\n"), filename
);
13357 /* The `save breakpoints' command. */
13360 save_breakpoints_command (char *args
, int from_tty
)
13362 save_breakpoints (args
, from_tty
, NULL
);
13365 /* The `save tracepoints' command. */
13368 save_tracepoints_command (char *args
, int from_tty
)
13370 save_breakpoints (args
, from_tty
, is_tracepoint
);
13373 /* Create a vector of all tracepoints. */
13375 VEC(breakpoint_p
) *
13376 all_tracepoints (void)
13378 VEC(breakpoint_p
) *tp_vec
= 0;
13379 struct breakpoint
*tp
;
13381 ALL_TRACEPOINTS (tp
)
13383 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
13390 /* This help string is used for the break, hbreak, tbreak and thbreak
13391 commands. It is defined as a macro to prevent duplication.
13392 COMMAND should be a string constant containing the name of the
13394 #define BREAK_ARGS_HELP(command) \
13395 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
13396 LOCATION may be a line number, function name, or \"*\" and an address.\n\
13397 If a line number is specified, break at start of code for that line.\n\
13398 If a function is specified, break at start of code for that function.\n\
13399 If an address is specified, break at that exact address.\n\
13400 With no LOCATION, uses current execution address of the selected\n\
13401 stack frame. This is useful for breaking on return to a stack frame.\n\
13403 THREADNUM is the number from \"info threads\".\n\
13404 CONDITION is a boolean expression.\n\
13406 Multiple breakpoints at one place are permitted, and useful if their\n\
13407 conditions are different.\n\
13409 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
13411 /* List of subcommands for "catch". */
13412 static struct cmd_list_element
*catch_cmdlist
;
13414 /* List of subcommands for "tcatch". */
13415 static struct cmd_list_element
*tcatch_cmdlist
;
13418 add_catch_command (char *name
, char *docstring
,
13419 void (*sfunc
) (char *args
, int from_tty
,
13420 struct cmd_list_element
*command
),
13421 char **(*completer
) (struct cmd_list_element
*cmd
,
13422 char *text
, char *word
),
13423 void *user_data_catch
,
13424 void *user_data_tcatch
)
13426 struct cmd_list_element
*command
;
13428 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
13430 set_cmd_sfunc (command
, sfunc
);
13431 set_cmd_context (command
, user_data_catch
);
13432 set_cmd_completer (command
, completer
);
13434 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
13436 set_cmd_sfunc (command
, sfunc
);
13437 set_cmd_context (command
, user_data_tcatch
);
13438 set_cmd_completer (command
, completer
);
13442 clear_syscall_counts (struct inferior
*inf
)
13444 inf
->total_syscalls_count
= 0;
13445 inf
->any_syscall_count
= 0;
13446 VEC_free (int, inf
->syscalls_counts
);
13450 save_command (char *arg
, int from_tty
)
13452 printf_unfiltered (_("\"save\" must be followed by "
13453 "the name of a save subcommand.\n"));
13454 help_list (save_cmdlist
, "save ", -1, gdb_stdout
);
13457 struct breakpoint
*
13458 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
13461 struct breakpoint
*b
, *b_tmp
;
13463 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
13465 if ((*callback
) (b
, data
))
13472 /* Zero if any of the breakpoint's locations could be a location where
13473 functions have been inlined, nonzero otherwise. */
13476 is_non_inline_function (struct breakpoint
*b
)
13478 /* The shared library event breakpoint is set on the address of a
13479 non-inline function. */
13480 if (b
->type
== bp_shlib_event
)
13486 /* Nonzero if the specified PC cannot be a location where functions
13487 have been inlined. */
13490 pc_at_non_inline_function (struct address_space
*aspace
, CORE_ADDR pc
)
13492 struct breakpoint
*b
;
13493 struct bp_location
*bl
;
13495 ALL_BREAKPOINTS (b
)
13497 if (!is_non_inline_function (b
))
13500 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
13502 if (!bl
->shlib_disabled
13503 && bpstat_check_location (bl
, aspace
, pc
))
13512 initialize_breakpoint_ops (void)
13514 static int initialized
= 0;
13516 struct breakpoint_ops
*ops
;
13522 /* The breakpoint_ops structure to be inherit by all kinds of
13523 breakpoints (real breakpoints, i.e., user "break" breakpoints,
13524 internal and momentary breakpoints, etc.). */
13525 ops
= &bkpt_base_breakpoint_ops
;
13526 *ops
= base_breakpoint_ops
;
13527 ops
->re_set
= bkpt_re_set
;
13528 ops
->insert_location
= bkpt_insert_location
;
13529 ops
->remove_location
= bkpt_remove_location
;
13530 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
13532 /* The breakpoint_ops structure to be used in regular breakpoints. */
13533 ops
= &bkpt_breakpoint_ops
;
13534 *ops
= bkpt_base_breakpoint_ops
;
13535 ops
->re_set
= bkpt_re_set
;
13536 ops
->resources_needed
= bkpt_resources_needed
;
13537 ops
->print_it
= bkpt_print_it
;
13538 ops
->print_mention
= bkpt_print_mention
;
13539 ops
->print_recreate
= bkpt_print_recreate
;
13541 /* Ranged breakpoints. */
13542 ops
= &ranged_breakpoint_ops
;
13543 *ops
= bkpt_breakpoint_ops
;
13544 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
13545 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
13546 ops
->print_it
= print_it_ranged_breakpoint
;
13547 ops
->print_one
= print_one_ranged_breakpoint
;
13548 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
13549 ops
->print_mention
= print_mention_ranged_breakpoint
;
13550 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
13552 /* Internal breakpoints. */
13553 ops
= &internal_breakpoint_ops
;
13554 *ops
= bkpt_base_breakpoint_ops
;
13555 ops
->re_set
= internal_bkpt_re_set
;
13556 ops
->check_status
= internal_bkpt_check_status
;
13557 ops
->print_it
= internal_bkpt_print_it
;
13558 ops
->print_mention
= internal_bkpt_print_mention
;
13560 /* Momentary breakpoints. */
13561 ops
= &momentary_breakpoint_ops
;
13562 *ops
= bkpt_base_breakpoint_ops
;
13563 ops
->re_set
= momentary_bkpt_re_set
;
13564 ops
->check_status
= momentary_bkpt_check_status
;
13565 ops
->print_it
= momentary_bkpt_print_it
;
13566 ops
->print_mention
= momentary_bkpt_print_mention
;
13568 /* GNU v3 exception catchpoints. */
13569 ops
= &gnu_v3_exception_catchpoint_ops
;
13570 *ops
= bkpt_breakpoint_ops
;
13571 ops
->print_it
= print_it_exception_catchpoint
;
13572 ops
->print_one
= print_one_exception_catchpoint
;
13573 ops
->print_mention
= print_mention_exception_catchpoint
;
13574 ops
->print_recreate
= print_recreate_exception_catchpoint
;
13577 ops
= &watchpoint_breakpoint_ops
;
13578 *ops
= base_breakpoint_ops
;
13579 ops
->dtor
= dtor_watchpoint
;
13580 ops
->re_set
= re_set_watchpoint
;
13581 ops
->insert_location
= insert_watchpoint
;
13582 ops
->remove_location
= remove_watchpoint
;
13583 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
13584 ops
->check_status
= check_status_watchpoint
;
13585 ops
->resources_needed
= resources_needed_watchpoint
;
13586 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
13587 ops
->print_it
= print_it_watchpoint
;
13588 ops
->print_mention
= print_mention_watchpoint
;
13589 ops
->print_recreate
= print_recreate_watchpoint
;
13591 /* Masked watchpoints. */
13592 ops
= &masked_watchpoint_breakpoint_ops
;
13593 *ops
= watchpoint_breakpoint_ops
;
13594 ops
->insert_location
= insert_masked_watchpoint
;
13595 ops
->remove_location
= remove_masked_watchpoint
;
13596 ops
->resources_needed
= resources_needed_masked_watchpoint
;
13597 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
13598 ops
->print_it
= print_it_masked_watchpoint
;
13599 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
13600 ops
->print_mention
= print_mention_masked_watchpoint
;
13601 ops
->print_recreate
= print_recreate_masked_watchpoint
;
13604 ops
= &tracepoint_breakpoint_ops
;
13605 *ops
= base_breakpoint_ops
;
13606 ops
->re_set
= tracepoint_re_set
;
13607 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
13608 ops
->print_one_detail
= tracepoint_print_one_detail
;
13609 ops
->print_mention
= tracepoint_print_mention
;
13610 ops
->print_recreate
= tracepoint_print_recreate
;
13612 /* Fork catchpoints. */
13613 ops
= &catch_fork_breakpoint_ops
;
13614 *ops
= base_breakpoint_ops
;
13615 ops
->insert_location
= insert_catch_fork
;
13616 ops
->remove_location
= remove_catch_fork
;
13617 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
13618 ops
->print_it
= print_it_catch_fork
;
13619 ops
->print_one
= print_one_catch_fork
;
13620 ops
->print_mention
= print_mention_catch_fork
;
13621 ops
->print_recreate
= print_recreate_catch_fork
;
13623 /* Vfork catchpoints. */
13624 ops
= &catch_vfork_breakpoint_ops
;
13625 *ops
= base_breakpoint_ops
;
13626 ops
->insert_location
= insert_catch_vfork
;
13627 ops
->remove_location
= remove_catch_vfork
;
13628 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
13629 ops
->print_it
= print_it_catch_vfork
;
13630 ops
->print_one
= print_one_catch_vfork
;
13631 ops
->print_mention
= print_mention_catch_vfork
;
13632 ops
->print_recreate
= print_recreate_catch_vfork
;
13634 /* Exec catchpoints. */
13635 ops
= &catch_exec_breakpoint_ops
;
13636 *ops
= base_breakpoint_ops
;
13637 ops
->dtor
= dtor_catch_exec
;
13638 ops
->insert_location
= insert_catch_exec
;
13639 ops
->remove_location
= remove_catch_exec
;
13640 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
13641 ops
->print_it
= print_it_catch_exec
;
13642 ops
->print_one
= print_one_catch_exec
;
13643 ops
->print_mention
= print_mention_catch_exec
;
13644 ops
->print_recreate
= print_recreate_catch_exec
;
13646 /* Syscall catchpoints. */
13647 ops
= &catch_syscall_breakpoint_ops
;
13648 *ops
= base_breakpoint_ops
;
13649 ops
->dtor
= dtor_catch_syscall
;
13650 ops
->insert_location
= insert_catch_syscall
;
13651 ops
->remove_location
= remove_catch_syscall
;
13652 ops
->breakpoint_hit
= breakpoint_hit_catch_syscall
;
13653 ops
->print_it
= print_it_catch_syscall
;
13654 ops
->print_one
= print_one_catch_syscall
;
13655 ops
->print_mention
= print_mention_catch_syscall
;
13656 ops
->print_recreate
= print_recreate_catch_syscall
;
13660 _initialize_breakpoint (void)
13662 struct cmd_list_element
*c
;
13664 initialize_breakpoint_ops ();
13666 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
13667 observer_attach_inferior_exit (clear_syscall_counts
);
13668 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
13670 breakpoint_objfile_key
= register_objfile_data ();
13672 breakpoint_chain
= 0;
13673 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
13674 before a breakpoint is set. */
13675 breakpoint_count
= 0;
13677 tracepoint_count
= 0;
13679 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
13680 Set ignore-count of breakpoint number N to COUNT.\n\
13681 Usage is `ignore N COUNT'."));
13683 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
13685 add_com ("commands", class_breakpoint
, commands_command
, _("\
13686 Set commands to be executed when a breakpoint is hit.\n\
13687 Give breakpoint number as argument after \"commands\".\n\
13688 With no argument, the targeted breakpoint is the last one set.\n\
13689 The commands themselves follow starting on the next line.\n\
13690 Type a line containing \"end\" to indicate the end of them.\n\
13691 Give \"silent\" as the first line to make the breakpoint silent;\n\
13692 then no output is printed when it is hit, except what the commands print."));
13694 add_com ("condition", class_breakpoint
, condition_command
, _("\
13695 Specify breakpoint number N to break only if COND is true.\n\
13696 Usage is `condition N COND', where N is an integer and COND is an\n\
13697 expression to be evaluated whenever breakpoint N is reached."));
13699 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
13700 Set a temporary breakpoint.\n\
13701 Like \"break\" except the breakpoint is only temporary,\n\
13702 so it will be deleted when hit. Equivalent to \"break\" followed\n\
13703 by using \"enable delete\" on the breakpoint number.\n\
13705 BREAK_ARGS_HELP ("tbreak")));
13706 set_cmd_completer (c
, location_completer
);
13708 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
13709 Set a hardware assisted breakpoint.\n\
13710 Like \"break\" except the breakpoint requires hardware support,\n\
13711 some target hardware may not have this support.\n\
13713 BREAK_ARGS_HELP ("hbreak")));
13714 set_cmd_completer (c
, location_completer
);
13716 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
13717 Set a temporary hardware assisted breakpoint.\n\
13718 Like \"hbreak\" except the breakpoint is only temporary,\n\
13719 so it will be deleted when hit.\n\
13721 BREAK_ARGS_HELP ("thbreak")));
13722 set_cmd_completer (c
, location_completer
);
13724 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
13725 Enable some breakpoints.\n\
13726 Give breakpoint numbers (separated by spaces) as arguments.\n\
13727 With no subcommand, breakpoints are enabled until you command otherwise.\n\
13728 This is used to cancel the effect of the \"disable\" command.\n\
13729 With a subcommand you can enable temporarily."),
13730 &enablelist
, "enable ", 1, &cmdlist
);
13732 add_com ("ab", class_breakpoint
, enable_command
, _("\
13733 Enable some breakpoints.\n\
13734 Give breakpoint numbers (separated by spaces) as arguments.\n\
13735 With no subcommand, breakpoints are enabled until you command otherwise.\n\
13736 This is used to cancel the effect of the \"disable\" command.\n\
13737 With a subcommand you can enable temporarily."));
13739 add_com_alias ("en", "enable", class_breakpoint
, 1);
13741 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
13742 Enable some breakpoints.\n\
13743 Give breakpoint numbers (separated by spaces) as arguments.\n\
13744 This is used to cancel the effect of the \"disable\" command.\n\
13745 May be abbreviated to simply \"enable\".\n"),
13746 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
13748 add_cmd ("once", no_class
, enable_once_command
, _("\
13749 Enable breakpoints for one hit. Give breakpoint numbers.\n\
13750 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
13753 add_cmd ("delete", no_class
, enable_delete_command
, _("\
13754 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
13755 If a breakpoint is hit while enabled in this fashion, it is deleted."),
13758 add_cmd ("delete", no_class
, enable_delete_command
, _("\
13759 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
13760 If a breakpoint is hit while enabled in this fashion, it is deleted."),
13763 add_cmd ("once", no_class
, enable_once_command
, _("\
13764 Enable breakpoints for one hit. Give breakpoint numbers.\n\
13765 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
13768 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
13769 Disable some breakpoints.\n\
13770 Arguments are breakpoint numbers with spaces in between.\n\
13771 To disable all breakpoints, give no argument.\n\
13772 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
13773 &disablelist
, "disable ", 1, &cmdlist
);
13774 add_com_alias ("dis", "disable", class_breakpoint
, 1);
13775 add_com_alias ("disa", "disable", class_breakpoint
, 1);
13777 add_com ("sb", class_breakpoint
, disable_command
, _("\
13778 Disable some breakpoints.\n\
13779 Arguments are breakpoint numbers with spaces in between.\n\
13780 To disable all breakpoints, give no argument.\n\
13781 A disabled breakpoint is not forgotten, but has no effect until re-enabled."));
13783 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
13784 Disable some breakpoints.\n\
13785 Arguments are breakpoint numbers with spaces in between.\n\
13786 To disable all breakpoints, give no argument.\n\
13787 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
13788 This command may be abbreviated \"disable\"."),
13791 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
13792 Delete some breakpoints or auto-display expressions.\n\
13793 Arguments are breakpoint numbers with spaces in between.\n\
13794 To delete all breakpoints, give no argument.\n\
13796 Also a prefix command for deletion of other GDB objects.\n\
13797 The \"unset\" command is also an alias for \"delete\"."),
13798 &deletelist
, "delete ", 1, &cmdlist
);
13799 add_com_alias ("d", "delete", class_breakpoint
, 1);
13800 add_com_alias ("del", "delete", class_breakpoint
, 1);
13802 add_com ("db", class_breakpoint
, delete_command
, _("\
13803 Delete some breakpoints.\n\
13804 Arguments are breakpoint numbers with spaces in between.\n\
13805 To delete all breakpoints, give no argument.\n"));
13807 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
13808 Delete some breakpoints or auto-display expressions.\n\
13809 Arguments are breakpoint numbers with spaces in between.\n\
13810 To delete all breakpoints, give no argument.\n\
13811 This command may be abbreviated \"delete\"."),
13814 add_com ("clear", class_breakpoint
, clear_command
, _("\
13815 Clear breakpoint at specified line or function.\n\
13816 Argument may be line number, function name, or \"*\" and an address.\n\
13817 If line number is specified, all breakpoints in that line are cleared.\n\
13818 If function is specified, breakpoints at beginning of function are cleared.\n\
13819 If an address is specified, breakpoints at that address are cleared.\n\
13821 With no argument, clears all breakpoints in the line that the selected frame\n\
13822 is executing in.\n\
13824 See also the \"delete\" command which clears breakpoints by number."));
13825 add_com_alias ("cl", "clear", class_breakpoint
, 1);
13827 c
= add_com ("break", class_breakpoint
, break_command
, _("\
13828 Set breakpoint at specified line or function.\n"
13829 BREAK_ARGS_HELP ("break")));
13830 set_cmd_completer (c
, location_completer
);
13832 add_com_alias ("b", "break", class_run
, 1);
13833 add_com_alias ("br", "break", class_run
, 1);
13834 add_com_alias ("bre", "break", class_run
, 1);
13835 add_com_alias ("brea", "break", class_run
, 1);
13838 add_com_alias ("ba", "break", class_breakpoint
, 1);
13842 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
13843 Break in function/address or break at a line in the current file."),
13844 &stoplist
, "stop ", 1, &cmdlist
);
13845 add_cmd ("in", class_breakpoint
, stopin_command
,
13846 _("Break in function or address."), &stoplist
);
13847 add_cmd ("at", class_breakpoint
, stopat_command
,
13848 _("Break at a line in the current file."), &stoplist
);
13849 add_com ("status", class_info
, breakpoints_info
, _("\
13850 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
13851 The \"Type\" column indicates one of:\n\
13852 \tbreakpoint - normal breakpoint\n\
13853 \twatchpoint - watchpoint\n\
13854 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13855 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13856 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13857 address and file/line number respectively.\n\
13859 Convenience variable \"$_\" and default examine address for \"x\"\n\
13860 are set to the address of the last breakpoint listed unless the command\n\
13861 is prefixed with \"server \".\n\n\
13862 Convenience variable \"$bpnum\" contains the number of the last\n\
13863 breakpoint set."));
13866 add_info ("breakpoints", breakpoints_info
, _("\
13867 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
13868 The \"Type\" column indicates one of:\n\
13869 \tbreakpoint - normal breakpoint\n\
13870 \twatchpoint - watchpoint\n\
13871 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13872 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13873 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13874 address and file/line number respectively.\n\
13876 Convenience variable \"$_\" and default examine address for \"x\"\n\
13877 are set to the address of the last breakpoint listed unless the command\n\
13878 is prefixed with \"server \".\n\n\
13879 Convenience variable \"$bpnum\" contains the number of the last\n\
13880 breakpoint set."));
13882 add_info_alias ("b", "breakpoints", 1);
13885 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
13886 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
13887 The \"Type\" column indicates one of:\n\
13888 \tbreakpoint - normal breakpoint\n\
13889 \twatchpoint - watchpoint\n\
13890 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13891 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13892 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13893 address and file/line number respectively.\n\
13895 Convenience variable \"$_\" and default examine address for \"x\"\n\
13896 are set to the address of the last breakpoint listed unless the command\n\
13897 is prefixed with \"server \".\n\n\
13898 Convenience variable \"$bpnum\" contains the number of the last\n\
13899 breakpoint set."));
13901 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
13902 Status of all breakpoints, or breakpoint number NUMBER.\n\
13903 The \"Type\" column indicates one of:\n\
13904 \tbreakpoint - normal breakpoint\n\
13905 \twatchpoint - watchpoint\n\
13906 \tlongjmp - internal breakpoint used to step through longjmp()\n\
13907 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
13908 \tuntil - internal breakpoint used by the \"until\" command\n\
13909 \tfinish - internal breakpoint used by the \"finish\" command\n\
13910 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
13911 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
13912 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
13913 address and file/line number respectively.\n\
13915 Convenience variable \"$_\" and default examine address for \"x\"\n\
13916 are set to the address of the last breakpoint listed unless the command\n\
13917 is prefixed with \"server \".\n\n\
13918 Convenience variable \"$bpnum\" contains the number of the last\n\
13920 &maintenanceinfolist
);
13922 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
13923 Set catchpoints to catch events."),
13924 &catch_cmdlist
, "catch ",
13925 0/*allow-unknown*/, &cmdlist
);
13927 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
13928 Set temporary catchpoints to catch events."),
13929 &tcatch_cmdlist
, "tcatch ",
13930 0/*allow-unknown*/, &cmdlist
);
13932 /* Add catch and tcatch sub-commands. */
13933 add_catch_command ("catch", _("\
13934 Catch an exception, when caught.\n\
13935 With an argument, catch only exceptions with the given name."),
13936 catch_catch_command
,
13940 add_catch_command ("throw", _("\
13941 Catch an exception, when thrown.\n\
13942 With an argument, catch only exceptions with the given name."),
13943 catch_throw_command
,
13947 add_catch_command ("fork", _("Catch calls to fork."),
13948 catch_fork_command_1
,
13950 (void *) (uintptr_t) catch_fork_permanent
,
13951 (void *) (uintptr_t) catch_fork_temporary
);
13952 add_catch_command ("vfork", _("Catch calls to vfork."),
13953 catch_fork_command_1
,
13955 (void *) (uintptr_t) catch_vfork_permanent
,
13956 (void *) (uintptr_t) catch_vfork_temporary
);
13957 add_catch_command ("exec", _("Catch calls to exec."),
13958 catch_exec_command_1
,
13962 add_catch_command ("syscall", _("\
13963 Catch system calls by their names and/or numbers.\n\
13964 Arguments say which system calls to catch. If no arguments\n\
13965 are given, every system call will be caught.\n\
13966 Arguments, if given, should be one or more system call names\n\
13967 (if your system supports that), or system call numbers."),
13968 catch_syscall_command_1
,
13969 catch_syscall_completer
,
13973 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
13974 Set a watchpoint for an expression.\n\
13975 Usage: watch [-l|-location] EXPRESSION\n\
13976 A watchpoint stops execution of your program whenever the value of\n\
13977 an expression changes.\n\
13978 If -l or -location is given, this evaluates EXPRESSION and watches\n\
13979 the memory to which it refers."));
13980 set_cmd_completer (c
, expression_completer
);
13982 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
13983 Set a read watchpoint for an expression.\n\
13984 Usage: rwatch [-l|-location] EXPRESSION\n\
13985 A watchpoint stops execution of your program whenever the value of\n\
13986 an expression is read.\n\
13987 If -l or -location is given, this evaluates EXPRESSION and watches\n\
13988 the memory to which it refers."));
13989 set_cmd_completer (c
, expression_completer
);
13991 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
13992 Set a watchpoint for an expression.\n\
13993 Usage: awatch [-l|-location] EXPRESSION\n\
13994 A watchpoint stops execution of your program whenever the value of\n\
13995 an expression is either read or written.\n\
13996 If -l or -location is given, this evaluates EXPRESSION and watches\n\
13997 the memory to which it refers."));
13998 set_cmd_completer (c
, expression_completer
);
14000 add_info ("watchpoints", watchpoints_info
, _("\
14001 Status of specified watchpoints (all watchpoints if no argument)."));
14003 /* XXX: cagney/2005-02-23: This should be a boolean, and should
14004 respond to changes - contrary to the description. */
14005 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
14006 &can_use_hw_watchpoints
, _("\
14007 Set debugger's willingness to use watchpoint hardware."), _("\
14008 Show debugger's willingness to use watchpoint hardware."), _("\
14009 If zero, gdb will not use hardware for new watchpoints, even if\n\
14010 such is available. (However, any hardware watchpoints that were\n\
14011 created before setting this to nonzero, will continue to use watchpoint\n\
14014 show_can_use_hw_watchpoints
,
14015 &setlist
, &showlist
);
14017 can_use_hw_watchpoints
= 1;
14019 /* Tracepoint manipulation commands. */
14021 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
14022 Set a tracepoint at specified line or function.\n\
14024 BREAK_ARGS_HELP ("trace") "\n\
14025 Do \"help tracepoints\" for info on other tracepoint commands."));
14026 set_cmd_completer (c
, location_completer
);
14028 add_com_alias ("tp", "trace", class_alias
, 0);
14029 add_com_alias ("tr", "trace", class_alias
, 1);
14030 add_com_alias ("tra", "trace", class_alias
, 1);
14031 add_com_alias ("trac", "trace", class_alias
, 1);
14033 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
14034 Set a fast tracepoint at specified line or function.\n\
14036 BREAK_ARGS_HELP ("ftrace") "\n\
14037 Do \"help tracepoints\" for info on other tracepoint commands."));
14038 set_cmd_completer (c
, location_completer
);
14040 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
14041 Set a static tracepoint at specified line, function or marker.\n\
14043 strace [LOCATION] [if CONDITION]\n\
14044 LOCATION may be a line number, function name, \"*\" and an address,\n\
14045 or -m MARKER_ID.\n\
14046 If a line number is specified, probe the marker at start of code\n\
14047 for that line. If a function is specified, probe the marker at start\n\
14048 of code for that function. If an address is specified, probe the marker\n\
14049 at that exact address. If a marker id is specified, probe the marker\n\
14050 with that name. With no LOCATION, uses current execution address of\n\
14051 the selected stack frame.\n\
14052 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
14053 This collects arbitrary user data passed in the probe point call to the\n\
14054 tracing library. You can inspect it when analyzing the trace buffer,\n\
14055 by printing the $_sdata variable like any other convenience variable.\n\
14057 CONDITION is a boolean expression.\n\
14059 Multiple tracepoints at one place are permitted, and useful if their\n\
14060 conditions are different.\n\
14062 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
14063 Do \"help tracepoints\" for info on other tracepoint commands."));
14064 set_cmd_completer (c
, location_completer
);
14066 add_info ("tracepoints", tracepoints_info
, _("\
14067 Status of specified tracepoints (all tracepoints if no argument).\n\
14068 Convenience variable \"$tpnum\" contains the number of the\n\
14069 last tracepoint set."));
14071 add_info_alias ("tp", "tracepoints", 1);
14073 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
14074 Delete specified tracepoints.\n\
14075 Arguments are tracepoint numbers, separated by spaces.\n\
14076 No argument means delete all tracepoints."),
14079 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
14080 Disable specified tracepoints.\n\
14081 Arguments are tracepoint numbers, separated by spaces.\n\
14082 No argument means disable all tracepoints."),
14084 deprecate_cmd (c
, "disable");
14086 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
14087 Enable specified tracepoints.\n\
14088 Arguments are tracepoint numbers, separated by spaces.\n\
14089 No argument means enable all tracepoints."),
14091 deprecate_cmd (c
, "enable");
14093 add_com ("passcount", class_trace
, trace_pass_command
, _("\
14094 Set the passcount for a tracepoint.\n\
14095 The trace will end when the tracepoint has been passed 'count' times.\n\
14096 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
14097 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
14099 add_prefix_cmd ("save", class_breakpoint
, save_command
,
14100 _("Save breakpoint definitions as a script."),
14101 &save_cmdlist
, "save ",
14102 0/*allow-unknown*/, &cmdlist
);
14104 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
14105 Save current breakpoint definitions as a script.\n\
14106 This includes all types of breakpoints (breakpoints, watchpoints,\n\
14107 catchpoints, tracepoints). Use the 'source' command in another debug\n\
14108 session to restore them."),
14110 set_cmd_completer (c
, filename_completer
);
14112 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
14113 Save current tracepoint definitions as a script.\n\
14114 Use the 'source' command in another debug session to restore them."),
14116 set_cmd_completer (c
, filename_completer
);
14118 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
14119 deprecate_cmd (c
, "save tracepoints");
14121 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
14122 Breakpoint specific settings\n\
14123 Configure various breakpoint-specific variables such as\n\
14124 pending breakpoint behavior"),
14125 &breakpoint_set_cmdlist
, "set breakpoint ",
14126 0/*allow-unknown*/, &setlist
);
14127 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
14128 Breakpoint specific settings\n\
14129 Configure various breakpoint-specific variables such as\n\
14130 pending breakpoint behavior"),
14131 &breakpoint_show_cmdlist
, "show breakpoint ",
14132 0/*allow-unknown*/, &showlist
);
14134 add_setshow_auto_boolean_cmd ("pending", no_class
,
14135 &pending_break_support
, _("\
14136 Set debugger's behavior regarding pending breakpoints."), _("\
14137 Show debugger's behavior regarding pending breakpoints."), _("\
14138 If on, an unrecognized breakpoint location will cause gdb to create a\n\
14139 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
14140 an error. If auto, an unrecognized breakpoint location results in a\n\
14141 user-query to see if a pending breakpoint should be created."),
14143 show_pending_break_support
,
14144 &breakpoint_set_cmdlist
,
14145 &breakpoint_show_cmdlist
);
14147 pending_break_support
= AUTO_BOOLEAN_AUTO
;
14149 add_setshow_boolean_cmd ("auto-hw", no_class
,
14150 &automatic_hardware_breakpoints
, _("\
14151 Set automatic usage of hardware breakpoints."), _("\
14152 Show automatic usage of hardware breakpoints."), _("\
14153 If set, the debugger will automatically use hardware breakpoints for\n\
14154 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
14155 a warning will be emitted for such breakpoints."),
14157 show_automatic_hardware_breakpoints
,
14158 &breakpoint_set_cmdlist
,
14159 &breakpoint_show_cmdlist
);
14161 add_setshow_enum_cmd ("always-inserted", class_support
,
14162 always_inserted_enums
, &always_inserted_mode
, _("\
14163 Set mode for inserting breakpoints."), _("\
14164 Show mode for inserting breakpoints."), _("\
14165 When this mode is off, breakpoints are inserted in inferior when it is\n\
14166 resumed, and removed when execution stops. When this mode is on,\n\
14167 breakpoints are inserted immediately and removed only when the user\n\
14168 deletes the breakpoint. When this mode is auto (which is the default),\n\
14169 the behaviour depends on the non-stop setting (see help set non-stop).\n\
14170 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
14171 behaves as if always-inserted mode is on; if gdb is controlling the\n\
14172 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
14174 &show_always_inserted_mode
,
14175 &breakpoint_set_cmdlist
,
14176 &breakpoint_show_cmdlist
);
14178 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
14179 Set a breakpoint for an address range.\n\
14180 break-range START-LOCATION, END-LOCATION\n\
14181 where START-LOCATION and END-LOCATION can be one of the following:\n\
14182 LINENUM, for that line in the current file,\n\
14183 FILE:LINENUM, for that line in that file,\n\
14184 +OFFSET, for that number of lines after the current line\n\
14185 or the start of the range\n\
14186 FUNCTION, for the first line in that function,\n\
14187 FILE:FUNCTION, to distinguish among like-named static functions.\n\
14188 *ADDRESS, for the instruction at that address.\n\
14190 The breakpoint will stop execution of the inferior whenever it executes\n\
14191 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
14192 range (including START-LOCATION and END-LOCATION)."));
14194 automatic_hardware_breakpoints
= 1;
14196 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);