1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
26 #include "breakpoint.h"
27 #include "tracepoint.h"
29 #include "expression.h"
35 #include "gdbthread.h"
38 #include "gdb_string.h"
39 #include "gdb-demangle.h"
40 #include "filenames.h"
46 #include "completer.h"
49 #include "cli/cli-script.h"
50 #include "gdb_assert.h"
55 #include "exceptions.h"
61 #include "xml-syscall.h"
62 #include "parser-defs.h"
63 #include "gdb_regex.h"
65 #include "cli/cli-utils.h"
66 #include "continuations.h"
69 #include "gdb_regex.h"
71 #include "dummy-frame.h"
75 /* readline include files */
76 #include "readline/readline.h"
77 #include "readline/history.h"
79 /* readline defines this. */
82 #include "mi/mi-common.h"
83 #include "python/python.h"
85 /* Enums for exception-handling support. */
86 enum exception_event_kind
93 /* Prototypes for local functions. */
95 static void enable_delete_command (char *, int);
97 static void enable_once_command (char *, int);
99 static void enable_count_command (char *, int);
101 static void disable_command (char *, int);
103 static void enable_command (char *, int);
105 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint *,
109 static void ignore_command (char *, int);
111 static int breakpoint_re_set_one (void *);
113 static void breakpoint_re_set_default (struct breakpoint *);
115 static void create_sals_from_address_default (char **,
116 struct linespec_result *,
120 static void create_breakpoints_sal_default (struct gdbarch *,
121 struct linespec_result *,
122 char *, char *, enum bptype,
123 enum bpdisp, int, int,
125 const struct breakpoint_ops *,
126 int, int, int, unsigned);
128 static void decode_linespec_default (struct breakpoint *, char **,
129 struct symtabs_and_lines *);
131 static void clear_command (char *, int);
133 static void catch_command (char *, int);
135 static int can_use_hardware_watchpoint (struct value *);
137 static void break_command_1 (char *, int, int);
139 static void mention (struct breakpoint *);
141 static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
143 const struct breakpoint_ops *);
144 static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
145 const struct symtab_and_line *);
147 /* This function is used in gdbtk sources and thus can not be made
149 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
150 struct symtab_and_line,
152 const struct breakpoint_ops *);
154 static struct breakpoint *
155 momentary_breakpoint_from_master (struct breakpoint *orig,
157 const struct breakpoint_ops *ops);
159 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
161 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
165 static void describe_other_breakpoints (struct gdbarch *,
166 struct program_space *, CORE_ADDR,
167 struct obj_section *, int);
169 static int breakpoint_address_match (struct address_space *aspace1,
171 struct address_space *aspace2,
174 static int watchpoint_locations_match (struct bp_location *loc1,
175 struct bp_location *loc2);
177 static int breakpoint_location_address_match (struct bp_location *bl,
178 struct address_space *aspace,
181 static void breakpoints_info (char *, int);
183 static void watchpoints_info (char *, int);
185 static int breakpoint_1 (char *, int,
186 int (*) (const struct breakpoint *));
188 static int breakpoint_cond_eval (void *);
190 static void cleanup_executing_breakpoints (void *);
192 static void commands_command (char *, int);
194 static void condition_command (char *, int);
203 static int remove_breakpoint (struct bp_location *, insertion_state_t);
204 static int remove_breakpoint_1 (struct bp_location *, insertion_state_t);
206 static enum print_stop_action print_bp_stop_message (bpstat bs);
208 static int watchpoint_check (void *);
210 static void maintenance_info_breakpoints (char *, int);
212 static int hw_breakpoint_used_count (void);
214 static int hw_watchpoint_use_count (struct breakpoint *);
216 static int hw_watchpoint_used_count_others (struct breakpoint *except,
218 int *other_type_used);
220 static void hbreak_command (char *, int);
222 static void thbreak_command (char *, int);
224 static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
227 static void stop_command (char *arg, int from_tty);
229 static void stopin_command (char *arg, int from_tty);
231 static void stopat_command (char *arg, int from_tty);
233 static void tcatch_command (char *arg, int from_tty);
235 static void detach_single_step_breakpoints (void);
237 static int single_step_breakpoint_inserted_here_p (struct address_space *,
240 static void free_bp_location (struct bp_location *loc);
241 static void incref_bp_location (struct bp_location *loc);
242 static void decref_bp_location (struct bp_location **loc);
244 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
246 static void update_global_location_list (int);
248 static void update_global_location_list_nothrow (int);
250 static int is_hardware_watchpoint (const struct breakpoint *bpt);
252 static void insert_breakpoint_locations (void);
254 static int syscall_catchpoint_p (struct breakpoint *b);
256 static void tracepoints_info (char *, int);
258 static void delete_trace_command (char *, int);
260 static void enable_trace_command (char *, int);
262 static void disable_trace_command (char *, int);
264 static void trace_pass_command (char *, int);
266 static void set_tracepoint_count (int num);
268 static int is_masked_watchpoint (const struct breakpoint *b);
270 static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
272 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
275 static int strace_marker_p (struct breakpoint *b);
277 /* The abstract base class all breakpoint_ops structures inherit
279 struct breakpoint_ops base_breakpoint_ops;
281 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
282 that are implemented on top of software or hardware breakpoints
283 (user breakpoints, internal and momentary breakpoints, etc.). */
284 static struct breakpoint_ops bkpt_base_breakpoint_ops;
286 /* Internal breakpoints class type. */
287 static struct breakpoint_ops internal_breakpoint_ops;
289 /* Momentary breakpoints class type. */
290 static struct breakpoint_ops momentary_breakpoint_ops;
292 /* Momentary breakpoints for bp_longjmp and bp_exception class type. */
293 static struct breakpoint_ops longjmp_breakpoint_ops;
295 /* The breakpoint_ops structure to be used in regular user created
297 struct breakpoint_ops bkpt_breakpoint_ops;
299 /* Breakpoints set on probes. */
300 static struct breakpoint_ops bkpt_probe_breakpoint_ops;
302 /* Dynamic printf class type. */
303 struct breakpoint_ops dprintf_breakpoint_ops;
305 /* The style in which to perform a dynamic printf. This is a user
306 option because different output options have different tradeoffs;
307 if GDB does the printing, there is better error handling if there
308 is a problem with any of the arguments, but using an inferior
309 function lets you have special-purpose printers and sending of
310 output to the same place as compiled-in print functions. */
312 static const char dprintf_style_gdb[] = "gdb";
313 static const char dprintf_style_call[] = "call";
314 static const char dprintf_style_agent[] = "agent";
315 static const char *const dprintf_style_enums[] = {
321 static const char *dprintf_style = dprintf_style_gdb;
323 /* The function to use for dynamic printf if the preferred style is to
324 call into the inferior. The value is simply a string that is
325 copied into the command, so it can be anything that GDB can
326 evaluate to a callable address, not necessarily a function name. */
328 static char *dprintf_function = "";
330 /* The channel to use for dynamic printf if the preferred style is to
331 call into the inferior; if a nonempty string, it will be passed to
332 the call as the first argument, with the format string as the
333 second. As with the dprintf function, this can be anything that
334 GDB knows how to evaluate, so in addition to common choices like
335 "stderr", this could be an app-specific expression like
336 "mystreams[curlogger]". */
338 static char *dprintf_channel = "";
340 /* True if dprintf commands should continue to operate even if GDB
342 static int disconnected_dprintf = 1;
344 /* A reference-counted struct command_line. This lets multiple
345 breakpoints share a single command list. */
346 struct counted_command_line
348 /* The reference count. */
351 /* The command list. */
352 struct command_line *commands;
355 struct command_line *
356 breakpoint_commands (struct breakpoint *b)
358 return b->commands ? b->commands->commands : NULL;
361 /* Flag indicating that a command has proceeded the inferior past the
362 current breakpoint. */
364 static int breakpoint_proceeded;
367 bpdisp_text (enum bpdisp disp)
369 /* NOTE: the following values are a part of MI protocol and
370 represent values of 'disp' field returned when inferior stops at
372 static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
374 return bpdisps[(int) disp];
377 /* Prototypes for exported functions. */
378 /* If FALSE, gdb will not use hardware support for watchpoints, even
379 if such is available. */
380 static int can_use_hw_watchpoints;
383 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
384 struct cmd_list_element *c,
387 fprintf_filtered (file,
388 _("Debugger's willingness to use "
389 "watchpoint hardware is %s.\n"),
393 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
394 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
395 for unrecognized breakpoint locations.
396 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
397 static enum auto_boolean pending_break_support;
399 show_pending_break_support (struct ui_file *file, int from_tty,
400 struct cmd_list_element *c,
403 fprintf_filtered (file,
404 _("Debugger's behavior regarding "
405 "pending breakpoints is %s.\n"),
409 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
410 set with "break" but falling in read-only memory.
411 If 0, gdb will warn about such breakpoints, but won't automatically
412 use hardware breakpoints. */
413 static int automatic_hardware_breakpoints;
415 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
416 struct cmd_list_element *c,
419 fprintf_filtered (file,
420 _("Automatic usage of hardware breakpoints is %s.\n"),
424 /* If on, gdb will keep breakpoints inserted even as inferior is
425 stopped, and immediately insert any new breakpoints. If off, gdb
426 will insert breakpoints into inferior only when resuming it, and
427 will remove breakpoints upon stop. If auto, GDB will behave as ON
428 if in non-stop mode, and as OFF if all-stop mode.*/
430 static enum auto_boolean always_inserted_mode = AUTO_BOOLEAN_AUTO;
433 show_always_inserted_mode (struct ui_file *file, int from_tty,
434 struct cmd_list_element *c, const char *value)
436 if (always_inserted_mode == AUTO_BOOLEAN_AUTO)
437 fprintf_filtered (file,
438 _("Always inserted breakpoint "
439 "mode is %s (currently %s).\n"),
441 breakpoints_always_inserted_mode () ? "on" : "off");
443 fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
448 breakpoints_always_inserted_mode (void)
450 return (always_inserted_mode == AUTO_BOOLEAN_TRUE
451 || (always_inserted_mode == AUTO_BOOLEAN_AUTO && non_stop));
454 static const char condition_evaluation_both[] = "host or target";
456 /* Modes for breakpoint condition evaluation. */
457 static const char condition_evaluation_auto[] = "auto";
458 static const char condition_evaluation_host[] = "host";
459 static const char condition_evaluation_target[] = "target";
460 static const char *const condition_evaluation_enums[] = {
461 condition_evaluation_auto,
462 condition_evaluation_host,
463 condition_evaluation_target,
467 /* Global that holds the current mode for breakpoint condition evaluation. */
468 static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
470 /* Global that we use to display information to the user (gets its value from
471 condition_evaluation_mode_1. */
472 static const char *condition_evaluation_mode = condition_evaluation_auto;
474 /* Translate a condition evaluation mode MODE into either "host"
475 or "target". This is used mostly to translate from "auto" to the
476 real setting that is being used. It returns the translated
480 translate_condition_evaluation_mode (const char *mode)
482 if (mode == condition_evaluation_auto)
484 if (target_supports_evaluation_of_breakpoint_conditions ())
485 return condition_evaluation_target;
487 return condition_evaluation_host;
493 /* Discovers what condition_evaluation_auto translates to. */
496 breakpoint_condition_evaluation_mode (void)
498 return translate_condition_evaluation_mode (condition_evaluation_mode);
501 /* Return true if GDB should evaluate breakpoint conditions or false
505 gdb_evaluates_breakpoint_condition_p (void)
507 const char *mode = breakpoint_condition_evaluation_mode ();
509 return (mode == condition_evaluation_host);
512 void _initialize_breakpoint (void);
514 /* Are we executing breakpoint commands? */
515 static int executing_breakpoint_commands;
517 /* Are overlay event breakpoints enabled? */
518 static int overlay_events_enabled;
520 /* See description in breakpoint.h. */
521 int target_exact_watchpoints = 0;
523 /* Walk the following statement or block through all breakpoints.
524 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
525 current breakpoint. */
527 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
529 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
530 for (B = breakpoint_chain; \
531 B ? (TMP=B->next, 1): 0; \
534 /* Similar iterator for the low-level breakpoints. SAFE variant is
535 not provided so update_global_location_list must not be called
536 while executing the block of ALL_BP_LOCATIONS. */
538 #define ALL_BP_LOCATIONS(B,BP_TMP) \
539 for (BP_TMP = bp_location; \
540 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
543 /* Iterates through locations with address ADDRESS for the currently selected
544 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
545 to where the loop should start from.
546 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
547 appropriate location to start with. */
549 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
550 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
551 BP_LOCP_TMP = BP_LOCP_START; \
553 && (BP_LOCP_TMP < bp_location + bp_location_count \
554 && (*BP_LOCP_TMP)->address == ADDRESS); \
557 /* Iterator for tracepoints only. */
559 #define ALL_TRACEPOINTS(B) \
560 for (B = breakpoint_chain; B; B = B->next) \
561 if (is_tracepoint (B))
563 /* Chains of all breakpoints defined. */
565 struct breakpoint *breakpoint_chain;
567 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
569 static struct bp_location **bp_location;
571 /* Number of elements of BP_LOCATION. */
573 static unsigned bp_location_count;
575 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
576 ADDRESS for the current elements of BP_LOCATION which get a valid
577 result from bp_location_has_shadow. You can use it for roughly
578 limiting the subrange of BP_LOCATION to scan for shadow bytes for
579 an address you need to read. */
581 static CORE_ADDR bp_location_placed_address_before_address_max;
583 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
584 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
585 BP_LOCATION which get a valid result from bp_location_has_shadow.
586 You can use it for roughly limiting the subrange of BP_LOCATION to
587 scan for shadow bytes for an address you need to read. */
589 static CORE_ADDR bp_location_shadow_len_after_address_max;
591 /* The locations that no longer correspond to any breakpoint, unlinked
592 from bp_location array, but for which a hit may still be reported
594 VEC(bp_location_p) *moribund_locations = NULL;
596 /* Number of last breakpoint made. */
598 static int breakpoint_count;
600 /* The value of `breakpoint_count' before the last command that
601 created breakpoints. If the last (break-like) command created more
602 than one breakpoint, then the difference between BREAKPOINT_COUNT
603 and PREV_BREAKPOINT_COUNT is more than one. */
604 static int prev_breakpoint_count;
606 /* Number of last tracepoint made. */
608 static int tracepoint_count;
610 static struct cmd_list_element *breakpoint_set_cmdlist;
611 static struct cmd_list_element *breakpoint_show_cmdlist;
612 struct cmd_list_element *save_cmdlist;
614 /* Return whether a breakpoint is an active enabled breakpoint. */
616 breakpoint_enabled (struct breakpoint *b)
618 return (b->enable_state == bp_enabled);
621 /* Set breakpoint count to NUM. */
624 set_breakpoint_count (int num)
626 prev_breakpoint_count = breakpoint_count;
627 breakpoint_count = num;
628 set_internalvar_integer (lookup_internalvar ("bpnum"), num);
631 /* Used by `start_rbreak_breakpoints' below, to record the current
632 breakpoint count before "rbreak" creates any breakpoint. */
633 static int rbreak_start_breakpoint_count;
635 /* Called at the start an "rbreak" command to record the first
639 start_rbreak_breakpoints (void)
641 rbreak_start_breakpoint_count = breakpoint_count;
644 /* Called at the end of an "rbreak" command to record the last
648 end_rbreak_breakpoints (void)
650 prev_breakpoint_count = rbreak_start_breakpoint_count;
653 /* Used in run_command to zero the hit count when a new run starts. */
656 clear_breakpoint_hit_counts (void)
658 struct breakpoint *b;
664 /* Allocate a new counted_command_line with reference count of 1.
665 The new structure owns COMMANDS. */
667 static struct counted_command_line *
668 alloc_counted_command_line (struct command_line *commands)
670 struct counted_command_line *result
671 = xmalloc (sizeof (struct counted_command_line));
674 result->commands = commands;
678 /* Increment reference count. This does nothing if CMD is NULL. */
681 incref_counted_command_line (struct counted_command_line *cmd)
687 /* Decrement reference count. If the reference count reaches 0,
688 destroy the counted_command_line. Sets *CMDP to NULL. This does
689 nothing if *CMDP is NULL. */
692 decref_counted_command_line (struct counted_command_line **cmdp)
696 if (--(*cmdp)->refc == 0)
698 free_command_lines (&(*cmdp)->commands);
705 /* A cleanup function that calls decref_counted_command_line. */
708 do_cleanup_counted_command_line (void *arg)
710 decref_counted_command_line (arg);
713 /* Create a cleanup that calls decref_counted_command_line on the
716 static struct cleanup *
717 make_cleanup_decref_counted_command_line (struct counted_command_line **cmdp)
719 return make_cleanup (do_cleanup_counted_command_line, cmdp);
723 /* Return the breakpoint with the specified number, or NULL
724 if the number does not refer to an existing breakpoint. */
727 get_breakpoint (int num)
729 struct breakpoint *b;
732 if (b->number == num)
740 /* Mark locations as "conditions have changed" in case the target supports
741 evaluating conditions on its side. */
744 mark_breakpoint_modified (struct breakpoint *b)
746 struct bp_location *loc;
748 /* This is only meaningful if the target is
749 evaluating conditions and if the user has
750 opted for condition evaluation on the target's
752 if (gdb_evaluates_breakpoint_condition_p ()
753 || !target_supports_evaluation_of_breakpoint_conditions ())
756 if (!is_breakpoint (b))
759 for (loc = b->loc; loc; loc = loc->next)
760 loc->condition_changed = condition_modified;
763 /* Mark location as "conditions have changed" in case the target supports
764 evaluating conditions on its side. */
767 mark_breakpoint_location_modified (struct bp_location *loc)
769 /* This is only meaningful if the target is
770 evaluating conditions and if the user has
771 opted for condition evaluation on the target's
773 if (gdb_evaluates_breakpoint_condition_p ()
774 || !target_supports_evaluation_of_breakpoint_conditions ())
778 if (!is_breakpoint (loc->owner))
781 loc->condition_changed = condition_modified;
784 /* Sets the condition-evaluation mode using the static global
785 condition_evaluation_mode. */
788 set_condition_evaluation_mode (char *args, int from_tty,
789 struct cmd_list_element *c)
791 const char *old_mode, *new_mode;
793 if ((condition_evaluation_mode_1 == condition_evaluation_target)
794 && !target_supports_evaluation_of_breakpoint_conditions ())
796 condition_evaluation_mode_1 = condition_evaluation_mode;
797 warning (_("Target does not support breakpoint condition evaluation.\n"
798 "Using host evaluation mode instead."));
802 new_mode = translate_condition_evaluation_mode (condition_evaluation_mode_1);
803 old_mode = translate_condition_evaluation_mode (condition_evaluation_mode);
805 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
806 settings was "auto". */
807 condition_evaluation_mode = condition_evaluation_mode_1;
809 /* Only update the mode if the user picked a different one. */
810 if (new_mode != old_mode)
812 struct bp_location *loc, **loc_tmp;
813 /* If the user switched to a different evaluation mode, we
814 need to synch the changes with the target as follows:
816 "host" -> "target": Send all (valid) conditions to the target.
817 "target" -> "host": Remove all the conditions from the target.
820 if (new_mode == condition_evaluation_target)
822 /* Mark everything modified and synch conditions with the
824 ALL_BP_LOCATIONS (loc, loc_tmp)
825 mark_breakpoint_location_modified (loc);
829 /* Manually mark non-duplicate locations to synch conditions
830 with the target. We do this to remove all the conditions the
831 target knows about. */
832 ALL_BP_LOCATIONS (loc, loc_tmp)
833 if (is_breakpoint (loc->owner) && loc->inserted)
834 loc->needs_update = 1;
838 update_global_location_list (1);
844 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
845 what "auto" is translating to. */
848 show_condition_evaluation_mode (struct ui_file *file, int from_tty,
849 struct cmd_list_element *c, const char *value)
851 if (condition_evaluation_mode == condition_evaluation_auto)
852 fprintf_filtered (file,
853 _("Breakpoint condition evaluation "
854 "mode is %s (currently %s).\n"),
856 breakpoint_condition_evaluation_mode ());
858 fprintf_filtered (file, _("Breakpoint condition evaluation mode is %s.\n"),
862 /* A comparison function for bp_location AP and BP that is used by
863 bsearch. This comparison function only cares about addresses, unlike
864 the more general bp_location_compare function. */
867 bp_location_compare_addrs (const void *ap, const void *bp)
869 struct bp_location *a = *(void **) ap;
870 struct bp_location *b = *(void **) bp;
872 if (a->address == b->address)
875 return ((a->address > b->address) - (a->address < b->address));
878 /* Helper function to skip all bp_locations with addresses
879 less than ADDRESS. It returns the first bp_location that
880 is greater than or equal to ADDRESS. If none is found, just
883 static struct bp_location **
884 get_first_locp_gte_addr (CORE_ADDR address)
886 struct bp_location dummy_loc;
887 struct bp_location *dummy_locp = &dummy_loc;
888 struct bp_location **locp_found = NULL;
890 /* Initialize the dummy location's address field. */
891 memset (&dummy_loc, 0, sizeof (struct bp_location));
892 dummy_loc.address = address;
894 /* Find a close match to the first location at ADDRESS. */
895 locp_found = bsearch (&dummy_locp, bp_location, bp_location_count,
896 sizeof (struct bp_location **),
897 bp_location_compare_addrs);
899 /* Nothing was found, nothing left to do. */
900 if (locp_found == NULL)
903 /* We may have found a location that is at ADDRESS but is not the first in the
904 location's list. Go backwards (if possible) and locate the first one. */
905 while ((locp_found - 1) >= bp_location
906 && (*(locp_found - 1))->address == address)
913 set_breakpoint_condition (struct breakpoint *b, char *exp,
916 xfree (b->cond_string);
917 b->cond_string = NULL;
919 if (is_watchpoint (b))
921 struct watchpoint *w = (struct watchpoint *) b;
928 struct bp_location *loc;
930 for (loc = b->loc; loc; loc = loc->next)
935 /* No need to free the condition agent expression
936 bytecode (if we have one). We will handle this
937 when we go through update_global_location_list. */
944 printf_filtered (_("Breakpoint %d now unconditional.\n"), b->number);
948 const char *arg = exp;
950 /* I don't know if it matters whether this is the string the user
951 typed in or the decompiled expression. */
952 b->cond_string = xstrdup (arg);
953 b->condition_not_parsed = 0;
955 if (is_watchpoint (b))
957 struct watchpoint *w = (struct watchpoint *) b;
959 innermost_block = NULL;
961 w->cond_exp = parse_exp_1 (&arg, 0, 0, 0);
963 error (_("Junk at end of expression"));
964 w->cond_exp_valid_block = innermost_block;
968 struct bp_location *loc;
970 for (loc = b->loc; loc; loc = loc->next)
974 parse_exp_1 (&arg, loc->address,
975 block_for_pc (loc->address), 0);
977 error (_("Junk at end of expression"));
981 mark_breakpoint_modified (b);
983 observer_notify_breakpoint_modified (b);
986 /* Completion for the "condition" command. */
988 static VEC (char_ptr) *
989 condition_completer (struct cmd_list_element *cmd,
990 const char *text, const char *word)
994 text = skip_spaces_const (text);
995 space = skip_to_space_const (text);
999 struct breakpoint *b;
1000 VEC (char_ptr) *result = NULL;
1004 /* We don't support completion of history indices. */
1005 if (isdigit (text[1]))
1007 return complete_internalvar (&text[1]);
1010 /* We're completing the breakpoint number. */
1011 len = strlen (text);
1017 xsnprintf (number, sizeof (number), "%d", b->number);
1019 if (strncmp (number, text, len) == 0)
1020 VEC_safe_push (char_ptr, result, xstrdup (number));
1026 /* We're completing the expression part. */
1027 text = skip_spaces_const (space);
1028 return expression_completer (cmd, text, word);
1031 /* condition N EXP -- set break condition of breakpoint N to EXP. */
1034 condition_command (char *arg, int from_tty)
1036 struct breakpoint *b;
1041 error_no_arg (_("breakpoint number"));
1044 bnum = get_number (&p);
1046 error (_("Bad breakpoint argument: '%s'"), arg);
1049 if (b->number == bnum)
1051 /* Check if this breakpoint has a Python object assigned to
1052 it, and if it has a definition of the "stop"
1053 method. This method and conditions entered into GDB from
1054 the CLI are mutually exclusive. */
1056 && gdbpy_breakpoint_has_py_cond (b->py_bp_object))
1057 error (_("Cannot set a condition where a Python 'stop' "
1058 "method has been defined in the breakpoint."));
1059 set_breakpoint_condition (b, p, from_tty);
1061 if (is_breakpoint (b))
1062 update_global_location_list (1);
1067 error (_("No breakpoint number %d."), bnum);
1070 /* Check that COMMAND do not contain commands that are suitable
1071 only for tracepoints and not suitable for ordinary breakpoints.
1072 Throw if any such commands is found. */
1075 check_no_tracepoint_commands (struct command_line *commands)
1077 struct command_line *c;
1079 for (c = commands; c; c = c->next)
1083 if (c->control_type == while_stepping_control)
1084 error (_("The 'while-stepping' command can "
1085 "only be used for tracepoints"));
1087 for (i = 0; i < c->body_count; ++i)
1088 check_no_tracepoint_commands ((c->body_list)[i]);
1090 /* Not that command parsing removes leading whitespace and comment
1091 lines and also empty lines. So, we only need to check for
1092 command directly. */
1093 if (strstr (c->line, "collect ") == c->line)
1094 error (_("The 'collect' command can only be used for tracepoints"));
1096 if (strstr (c->line, "teval ") == c->line)
1097 error (_("The 'teval' command can only be used for tracepoints"));
1101 /* Encapsulate tests for different types of tracepoints. */
1104 is_tracepoint_type (enum bptype type)
1106 return (type == bp_tracepoint
1107 || type == bp_fast_tracepoint
1108 || type == bp_static_tracepoint);
1112 is_tracepoint (const struct breakpoint *b)
1114 return is_tracepoint_type (b->type);
1117 /* A helper function that validates that COMMANDS are valid for a
1118 breakpoint. This function will throw an exception if a problem is
1122 validate_commands_for_breakpoint (struct breakpoint *b,
1123 struct command_line *commands)
1125 if (is_tracepoint (b))
1127 struct tracepoint *t = (struct tracepoint *) b;
1128 struct command_line *c;
1129 struct command_line *while_stepping = 0;
1131 /* Reset the while-stepping step count. The previous commands
1132 might have included a while-stepping action, while the new
1136 /* We need to verify that each top-level element of commands is
1137 valid for tracepoints, that there's at most one
1138 while-stepping element, and that the while-stepping's body
1139 has valid tracing commands excluding nested while-stepping.
1140 We also need to validate the tracepoint action line in the
1141 context of the tracepoint --- validate_actionline actually
1142 has side effects, like setting the tracepoint's
1143 while-stepping STEP_COUNT, in addition to checking if the
1144 collect/teval actions parse and make sense in the
1145 tracepoint's context. */
1146 for (c = commands; c; c = c->next)
1148 if (c->control_type == while_stepping_control)
1150 if (b->type == bp_fast_tracepoint)
1151 error (_("The 'while-stepping' command "
1152 "cannot be used for fast tracepoint"));
1153 else if (b->type == bp_static_tracepoint)
1154 error (_("The 'while-stepping' command "
1155 "cannot be used for static tracepoint"));
1158 error (_("The 'while-stepping' command "
1159 "can be used only once"));
1164 validate_actionline (c->line, b);
1168 struct command_line *c2;
1170 gdb_assert (while_stepping->body_count == 1);
1171 c2 = while_stepping->body_list[0];
1172 for (; c2; c2 = c2->next)
1174 if (c2->control_type == while_stepping_control)
1175 error (_("The 'while-stepping' command cannot be nested"));
1181 check_no_tracepoint_commands (commands);
1185 /* Return a vector of all the static tracepoints set at ADDR. The
1186 caller is responsible for releasing the vector. */
1189 static_tracepoints_here (CORE_ADDR addr)
1191 struct breakpoint *b;
1192 VEC(breakpoint_p) *found = 0;
1193 struct bp_location *loc;
1196 if (b->type == bp_static_tracepoint)
1198 for (loc = b->loc; loc; loc = loc->next)
1199 if (loc->address == addr)
1200 VEC_safe_push(breakpoint_p, found, b);
1206 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1207 validate that only allowed commands are included. */
1210 breakpoint_set_commands (struct breakpoint *b,
1211 struct command_line *commands)
1213 validate_commands_for_breakpoint (b, commands);
1215 decref_counted_command_line (&b->commands);
1216 b->commands = alloc_counted_command_line (commands);
1217 observer_notify_breakpoint_modified (b);
1220 /* Set the internal `silent' flag on the breakpoint. Note that this
1221 is not the same as the "silent" that may appear in the breakpoint's
1225 breakpoint_set_silent (struct breakpoint *b, int silent)
1227 int old_silent = b->silent;
1230 if (old_silent != silent)
1231 observer_notify_breakpoint_modified (b);
1234 /* Set the thread for this breakpoint. If THREAD is -1, make the
1235 breakpoint work for any thread. */
1238 breakpoint_set_thread (struct breakpoint *b, int thread)
1240 int old_thread = b->thread;
1243 if (old_thread != thread)
1244 observer_notify_breakpoint_modified (b);
1247 /* Set the task for this breakpoint. If TASK is 0, make the
1248 breakpoint work for any task. */
1251 breakpoint_set_task (struct breakpoint *b, int task)
1253 int old_task = b->task;
1256 if (old_task != task)
1257 observer_notify_breakpoint_modified (b);
1261 check_tracepoint_command (char *line, void *closure)
1263 struct breakpoint *b = closure;
1265 validate_actionline (line, b);
1268 /* A structure used to pass information through
1269 map_breakpoint_numbers. */
1271 struct commands_info
1273 /* True if the command was typed at a tty. */
1276 /* The breakpoint range spec. */
1279 /* Non-NULL if the body of the commands are being read from this
1280 already-parsed command. */
1281 struct command_line *control;
1283 /* The command lines read from the user, or NULL if they have not
1285 struct counted_command_line *cmd;
1288 /* A callback for map_breakpoint_numbers that sets the commands for
1289 commands_command. */
1292 do_map_commands_command (struct breakpoint *b, void *data)
1294 struct commands_info *info = data;
1296 if (info->cmd == NULL)
1298 struct command_line *l;
1300 if (info->control != NULL)
1301 l = copy_command_lines (info->control->body_list[0]);
1304 struct cleanup *old_chain;
1307 str = xstrprintf (_("Type commands for breakpoint(s) "
1308 "%s, one per line."),
1311 old_chain = make_cleanup (xfree, str);
1313 l = read_command_lines (str,
1316 ? check_tracepoint_command : 0),
1319 do_cleanups (old_chain);
1322 info->cmd = alloc_counted_command_line (l);
1325 /* If a breakpoint was on the list more than once, we don't need to
1327 if (b->commands != info->cmd)
1329 validate_commands_for_breakpoint (b, info->cmd->commands);
1330 incref_counted_command_line (info->cmd);
1331 decref_counted_command_line (&b->commands);
1332 b->commands = info->cmd;
1333 observer_notify_breakpoint_modified (b);
1338 commands_command_1 (char *arg, int from_tty,
1339 struct command_line *control)
1341 struct cleanup *cleanups;
1342 struct commands_info info;
1344 info.from_tty = from_tty;
1345 info.control = control;
1347 /* If we read command lines from the user, then `info' will hold an
1348 extra reference to the commands that we must clean up. */
1349 cleanups = make_cleanup_decref_counted_command_line (&info.cmd);
1351 if (arg == NULL || !*arg)
1353 if (breakpoint_count - prev_breakpoint_count > 1)
1354 arg = xstrprintf ("%d-%d", prev_breakpoint_count + 1,
1356 else if (breakpoint_count > 0)
1357 arg = xstrprintf ("%d", breakpoint_count);
1360 /* So that we don't try to free the incoming non-NULL
1361 argument in the cleanup below. Mapping breakpoint
1362 numbers will fail in this case. */
1367 /* The command loop has some static state, so we need to preserve
1369 arg = xstrdup (arg);
1372 make_cleanup (xfree, arg);
1376 map_breakpoint_numbers (arg, do_map_commands_command, &info);
1378 if (info.cmd == NULL)
1379 error (_("No breakpoints specified."));
1381 do_cleanups (cleanups);
1385 commands_command (char *arg, int from_tty)
1387 commands_command_1 (arg, from_tty, NULL);
1390 /* Like commands_command, but instead of reading the commands from
1391 input stream, takes them from an already parsed command structure.
1393 This is used by cli-script.c to DTRT with breakpoint commands
1394 that are part of if and while bodies. */
1395 enum command_control_type
1396 commands_from_control_command (char *arg, struct command_line *cmd)
1398 commands_command_1 (arg, 0, cmd);
1399 return simple_control;
1402 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1405 bp_location_has_shadow (struct bp_location *bl)
1407 if (bl->loc_type != bp_loc_software_breakpoint)
1411 if (bl->target_info.shadow_len == 0)
1412 /* BL isn't valid, or doesn't shadow memory. */
1417 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1418 by replacing any memory breakpoints with their shadowed contents.
1420 If READBUF is not NULL, this buffer must not overlap with any of
1421 the breakpoint location's shadow_contents buffers. Otherwise,
1422 a failed assertion internal error will be raised.
1424 The range of shadowed area by each bp_location is:
1425 bl->address - bp_location_placed_address_before_address_max
1426 up to bl->address + bp_location_shadow_len_after_address_max
1427 The range we were requested to resolve shadows for is:
1428 memaddr ... memaddr + len
1429 Thus the safe cutoff boundaries for performance optimization are
1430 memaddr + len <= (bl->address
1431 - bp_location_placed_address_before_address_max)
1433 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1436 breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1437 const gdb_byte *writebuf_org,
1438 ULONGEST memaddr, LONGEST len)
1440 /* Left boundary, right boundary and median element of our binary
1442 unsigned bc_l, bc_r, bc;
1444 /* Find BC_L which is a leftmost element which may affect BUF
1445 content. It is safe to report lower value but a failure to
1446 report higher one. */
1449 bc_r = bp_location_count;
1450 while (bc_l + 1 < bc_r)
1452 struct bp_location *bl;
1454 bc = (bc_l + bc_r) / 2;
1455 bl = bp_location[bc];
1457 /* Check first BL->ADDRESS will not overflow due to the added
1458 constant. Then advance the left boundary only if we are sure
1459 the BC element can in no way affect the BUF content (MEMADDR
1460 to MEMADDR + LEN range).
1462 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1463 offset so that we cannot miss a breakpoint with its shadow
1464 range tail still reaching MEMADDR. */
1466 if ((bl->address + bp_location_shadow_len_after_address_max
1468 && (bl->address + bp_location_shadow_len_after_address_max
1475 /* Due to the binary search above, we need to make sure we pick the
1476 first location that's at BC_L's address. E.g., if there are
1477 multiple locations at the same address, BC_L may end up pointing
1478 at a duplicate location, and miss the "master"/"inserted"
1479 location. Say, given locations L1, L2 and L3 at addresses A and
1482 L1@A, L2@A, L3@B, ...
1484 BC_L could end up pointing at location L2, while the "master"
1485 location could be L1. Since the `loc->inserted' flag is only set
1486 on "master" locations, we'd forget to restore the shadow of L1
1489 && bp_location[bc_l]->address == bp_location[bc_l - 1]->address)
1492 /* Now do full processing of the found relevant range of elements. */
1494 for (bc = bc_l; bc < bp_location_count; bc++)
1496 struct bp_location *bl = bp_location[bc];
1497 CORE_ADDR bp_addr = 0;
1501 /* bp_location array has BL->OWNER always non-NULL. */
1502 if (bl->owner->type == bp_none)
1503 warning (_("reading through apparently deleted breakpoint #%d?"),
1506 /* Performance optimization: any further element can no longer affect BUF
1509 if (bl->address >= bp_location_placed_address_before_address_max
1510 && memaddr + len <= (bl->address
1511 - bp_location_placed_address_before_address_max))
1514 if (!bp_location_has_shadow (bl))
1516 if (!breakpoint_address_match (bl->target_info.placed_address_space, 0,
1517 current_program_space->aspace, 0))
1520 /* Addresses and length of the part of the breakpoint that
1522 bp_addr = bl->target_info.placed_address;
1523 bp_size = bl->target_info.shadow_len;
1525 if (bp_addr + bp_size <= memaddr)
1526 /* The breakpoint is entirely before the chunk of memory we
1530 if (bp_addr >= memaddr + len)
1531 /* The breakpoint is entirely after the chunk of memory we are
1535 /* Offset within shadow_contents. */
1536 if (bp_addr < memaddr)
1538 /* Only copy the second part of the breakpoint. */
1539 bp_size -= memaddr - bp_addr;
1540 bptoffset = memaddr - bp_addr;
1544 if (bp_addr + bp_size > memaddr + len)
1546 /* Only copy the first part of the breakpoint. */
1547 bp_size -= (bp_addr + bp_size) - (memaddr + len);
1550 if (readbuf != NULL)
1552 /* Verify that the readbuf buffer does not overlap with
1553 the shadow_contents buffer. */
1554 gdb_assert (bl->target_info.shadow_contents >= readbuf + len
1555 || readbuf >= (bl->target_info.shadow_contents
1556 + bl->target_info.shadow_len));
1558 /* Update the read buffer with this inserted breakpoint's
1560 memcpy (readbuf + bp_addr - memaddr,
1561 bl->target_info.shadow_contents + bptoffset, bp_size);
1565 struct gdbarch *gdbarch = bl->gdbarch;
1566 const unsigned char *bp;
1567 CORE_ADDR placed_address = bl->target_info.placed_address;
1568 int placed_size = bl->target_info.placed_size;
1570 /* Update the shadow with what we want to write to memory. */
1571 memcpy (bl->target_info.shadow_contents + bptoffset,
1572 writebuf_org + bp_addr - memaddr, bp_size);
1574 /* Determine appropriate breakpoint contents and size for this
1576 bp = gdbarch_breakpoint_from_pc (gdbarch, &placed_address, &placed_size);
1578 /* Update the final write buffer with this inserted
1579 breakpoint's INSN. */
1580 memcpy (writebuf + bp_addr - memaddr, bp + bptoffset, bp_size);
1586 /* Return true if BPT is either a software breakpoint or a hardware
1590 is_breakpoint (const struct breakpoint *bpt)
1592 return (bpt->type == bp_breakpoint
1593 || bpt->type == bp_hardware_breakpoint
1594 || bpt->type == bp_dprintf);
1597 /* Return true if BPT is of any hardware watchpoint kind. */
1600 is_hardware_watchpoint (const struct breakpoint *bpt)
1602 return (bpt->type == bp_hardware_watchpoint
1603 || bpt->type == bp_read_watchpoint
1604 || bpt->type == bp_access_watchpoint);
1607 /* Return true if BPT is of any watchpoint kind, hardware or
1611 is_watchpoint (const struct breakpoint *bpt)
1613 return (is_hardware_watchpoint (bpt)
1614 || bpt->type == bp_watchpoint);
1617 /* Returns true if the current thread and its running state are safe
1618 to evaluate or update watchpoint B. Watchpoints on local
1619 expressions need to be evaluated in the context of the thread that
1620 was current when the watchpoint was created, and, that thread needs
1621 to be stopped to be able to select the correct frame context.
1622 Watchpoints on global expressions can be evaluated on any thread,
1623 and in any state. It is presently left to the target allowing
1624 memory accesses when threads are running. */
1627 watchpoint_in_thread_scope (struct watchpoint *b)
1629 return (b->base.pspace == current_program_space
1630 && (ptid_equal (b->watchpoint_thread, null_ptid)
1631 || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1632 && !is_executing (inferior_ptid))));
1635 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1636 associated bp_watchpoint_scope breakpoint. */
1639 watchpoint_del_at_next_stop (struct watchpoint *w)
1641 struct breakpoint *b = &w->base;
1643 if (b->related_breakpoint != b)
1645 gdb_assert (b->related_breakpoint->type == bp_watchpoint_scope);
1646 gdb_assert (b->related_breakpoint->related_breakpoint == b);
1647 b->related_breakpoint->disposition = disp_del_at_next_stop;
1648 b->related_breakpoint->related_breakpoint = b->related_breakpoint;
1649 b->related_breakpoint = b;
1651 b->disposition = disp_del_at_next_stop;
1654 /* Assuming that B is a watchpoint:
1655 - Reparse watchpoint expression, if REPARSE is non-zero
1656 - Evaluate expression and store the result in B->val
1657 - Evaluate the condition if there is one, and store the result
1659 - Update the list of values that must be watched in B->loc.
1661 If the watchpoint disposition is disp_del_at_next_stop, then do
1662 nothing. If this is local watchpoint that is out of scope, delete
1665 Even with `set breakpoint always-inserted on' the watchpoints are
1666 removed + inserted on each stop here. Normal breakpoints must
1667 never be removed because they might be missed by a running thread
1668 when debugging in non-stop mode. On the other hand, hardware
1669 watchpoints (is_hardware_watchpoint; processed here) are specific
1670 to each LWP since they are stored in each LWP's hardware debug
1671 registers. Therefore, such LWP must be stopped first in order to
1672 be able to modify its hardware watchpoints.
1674 Hardware watchpoints must be reset exactly once after being
1675 presented to the user. It cannot be done sooner, because it would
1676 reset the data used to present the watchpoint hit to the user. And
1677 it must not be done later because it could display the same single
1678 watchpoint hit during multiple GDB stops. Note that the latter is
1679 relevant only to the hardware watchpoint types bp_read_watchpoint
1680 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1681 not user-visible - its hit is suppressed if the memory content has
1684 The following constraints influence the location where we can reset
1685 hardware watchpoints:
1687 * target_stopped_by_watchpoint and target_stopped_data_address are
1688 called several times when GDB stops.
1691 * Multiple hardware watchpoints can be hit at the same time,
1692 causing GDB to stop. GDB only presents one hardware watchpoint
1693 hit at a time as the reason for stopping, and all the other hits
1694 are presented later, one after the other, each time the user
1695 requests the execution to be resumed. Execution is not resumed
1696 for the threads still having pending hit event stored in
1697 LWP_INFO->STATUS. While the watchpoint is already removed from
1698 the inferior on the first stop the thread hit event is kept being
1699 reported from its cached value by linux_nat_stopped_data_address
1700 until the real thread resume happens after the watchpoint gets
1701 presented and thus its LWP_INFO->STATUS gets reset.
1703 Therefore the hardware watchpoint hit can get safely reset on the
1704 watchpoint removal from inferior. */
1707 update_watchpoint (struct watchpoint *b, int reparse)
1709 int within_current_scope;
1710 struct frame_id saved_frame_id;
1713 /* If this is a local watchpoint, we only want to check if the
1714 watchpoint frame is in scope if the current thread is the thread
1715 that was used to create the watchpoint. */
1716 if (!watchpoint_in_thread_scope (b))
1719 if (b->base.disposition == disp_del_at_next_stop)
1724 /* Determine if the watchpoint is within scope. */
1725 if (b->exp_valid_block == NULL)
1726 within_current_scope = 1;
1729 struct frame_info *fi = get_current_frame ();
1730 struct gdbarch *frame_arch = get_frame_arch (fi);
1731 CORE_ADDR frame_pc = get_frame_pc (fi);
1733 /* If we're in a function epilogue, unwinding may not work
1734 properly, so do not attempt to recreate locations at this
1735 point. See similar comments in watchpoint_check. */
1736 if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
1739 /* Save the current frame's ID so we can restore it after
1740 evaluating the watchpoint expression on its own frame. */
1741 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1742 took a frame parameter, so that we didn't have to change the
1745 saved_frame_id = get_frame_id (get_selected_frame (NULL));
1747 fi = frame_find_by_id (b->watchpoint_frame);
1748 within_current_scope = (fi != NULL);
1749 if (within_current_scope)
1753 /* We don't free locations. They are stored in the bp_location array
1754 and update_global_location_list will eventually delete them and
1755 remove breakpoints if needed. */
1758 if (within_current_scope && reparse)
1767 s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1768 b->exp = parse_exp_1 (&s, 0, b->exp_valid_block, 0);
1769 /* If the meaning of expression itself changed, the old value is
1770 no longer relevant. We don't want to report a watchpoint hit
1771 to the user when the old value and the new value may actually
1772 be completely different objects. */
1773 value_free (b->val);
1777 /* Note that unlike with breakpoints, the watchpoint's condition
1778 expression is stored in the breakpoint object, not in the
1779 locations (re)created below. */
1780 if (b->base.cond_string != NULL)
1782 if (b->cond_exp != NULL)
1784 xfree (b->cond_exp);
1788 s = b->base.cond_string;
1789 b->cond_exp = parse_exp_1 (&s, 0, b->cond_exp_valid_block, 0);
1793 /* If we failed to parse the expression, for example because
1794 it refers to a global variable in a not-yet-loaded shared library,
1795 don't try to insert watchpoint. We don't automatically delete
1796 such watchpoint, though, since failure to parse expression
1797 is different from out-of-scope watchpoint. */
1798 if (!target_has_execution)
1800 /* Without execution, memory can't change. No use to try and
1801 set watchpoint locations. The watchpoint will be reset when
1802 the target gains execution, through breakpoint_re_set. */
1803 if (!can_use_hw_watchpoints)
1805 if (b->base.ops->works_in_software_mode (&b->base))
1806 b->base.type = bp_watchpoint;
1808 error (_("Software read/access watchpoints not supported."));
1811 else if (within_current_scope && b->exp)
1814 struct value *val_chain, *v, *result, *next;
1815 struct program_space *frame_pspace;
1817 fetch_subexp_value (b->exp, &pc, &v, &result, &val_chain, 0);
1819 /* Avoid setting b->val if it's already set. The meaning of
1820 b->val is 'the last value' user saw, and we should update
1821 it only if we reported that last value to user. As it
1822 happens, the code that reports it updates b->val directly.
1823 We don't keep track of the memory value for masked
1825 if (!b->val_valid && !is_masked_watchpoint (&b->base))
1831 frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1833 /* Look at each value on the value chain. */
1834 for (v = val_chain; v; v = value_next (v))
1836 /* If it's a memory location, and GDB actually needed
1837 its contents to evaluate the expression, then we
1838 must watch it. If the first value returned is
1839 still lazy, that means an error occurred reading it;
1840 watch it anyway in case it becomes readable. */
1841 if (VALUE_LVAL (v) == lval_memory
1842 && (v == val_chain || ! value_lazy (v)))
1844 struct type *vtype = check_typedef (value_type (v));
1846 /* We only watch structs and arrays if user asked
1847 for it explicitly, never if they just happen to
1848 appear in the middle of some value chain. */
1850 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1851 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1855 struct bp_location *loc, **tmp;
1857 addr = value_address (v);
1859 if (b->base.type == bp_read_watchpoint)
1861 else if (b->base.type == bp_access_watchpoint)
1864 loc = allocate_bp_location (&b->base);
1865 for (tmp = &(b->base.loc); *tmp != NULL; tmp = &((*tmp)->next))
1868 loc->gdbarch = get_type_arch (value_type (v));
1870 loc->pspace = frame_pspace;
1871 loc->address = addr;
1872 loc->length = TYPE_LENGTH (value_type (v));
1873 loc->watchpoint_type = type;
1878 /* Change the type of breakpoint between hardware assisted or
1879 an ordinary watchpoint depending on the hardware support
1880 and free hardware slots. REPARSE is set when the inferior
1885 enum bp_loc_type loc_type;
1886 struct bp_location *bl;
1888 reg_cnt = can_use_hardware_watchpoint (val_chain);
1892 int i, target_resources_ok, other_type_used;
1895 /* Use an exact watchpoint when there's only one memory region to be
1896 watched, and only one debug register is needed to watch it. */
1897 b->exact = target_exact_watchpoints && reg_cnt == 1;
1899 /* We need to determine how many resources are already
1900 used for all other hardware watchpoints plus this one
1901 to see if we still have enough resources to also fit
1902 this watchpoint in as well. */
1904 /* If this is a software watchpoint, we try to turn it
1905 to a hardware one -- count resources as if B was of
1906 hardware watchpoint type. */
1907 type = b->base.type;
1908 if (type == bp_watchpoint)
1909 type = bp_hardware_watchpoint;
1911 /* This watchpoint may or may not have been placed on
1912 the list yet at this point (it won't be in the list
1913 if we're trying to create it for the first time,
1914 through watch_command), so always account for it
1917 /* Count resources used by all watchpoints except B. */
1918 i = hw_watchpoint_used_count_others (&b->base, type, &other_type_used);
1920 /* Add in the resources needed for B. */
1921 i += hw_watchpoint_use_count (&b->base);
1924 = target_can_use_hardware_watchpoint (type, i, other_type_used);
1925 if (target_resources_ok <= 0)
1927 int sw_mode = b->base.ops->works_in_software_mode (&b->base);
1929 if (target_resources_ok == 0 && !sw_mode)
1930 error (_("Target does not support this type of "
1931 "hardware watchpoint."));
1932 else if (target_resources_ok < 0 && !sw_mode)
1933 error (_("There are not enough available hardware "
1934 "resources for this watchpoint."));
1936 /* Downgrade to software watchpoint. */
1937 b->base.type = bp_watchpoint;
1941 /* If this was a software watchpoint, we've just
1942 found we have enough resources to turn it to a
1943 hardware watchpoint. Otherwise, this is a
1945 b->base.type = type;
1948 else if (!b->base.ops->works_in_software_mode (&b->base))
1949 error (_("Expression cannot be implemented with "
1950 "read/access watchpoint."));
1952 b->base.type = bp_watchpoint;
1954 loc_type = (b->base.type == bp_watchpoint? bp_loc_other
1955 : bp_loc_hardware_watchpoint);
1956 for (bl = b->base.loc; bl; bl = bl->next)
1957 bl->loc_type = loc_type;
1960 for (v = val_chain; v; v = next)
1962 next = value_next (v);
1967 /* If a software watchpoint is not watching any memory, then the
1968 above left it without any location set up. But,
1969 bpstat_stop_status requires a location to be able to report
1970 stops, so make sure there's at least a dummy one. */
1971 if (b->base.type == bp_watchpoint && b->base.loc == NULL)
1973 struct breakpoint *base = &b->base;
1974 base->loc = allocate_bp_location (base);
1975 base->loc->pspace = frame_pspace;
1976 base->loc->address = -1;
1977 base->loc->length = -1;
1978 base->loc->watchpoint_type = -1;
1981 else if (!within_current_scope)
1983 printf_filtered (_("\
1984 Watchpoint %d deleted because the program has left the block\n\
1985 in which its expression is valid.\n"),
1987 watchpoint_del_at_next_stop (b);
1990 /* Restore the selected frame. */
1992 select_frame (frame_find_by_id (saved_frame_id));
1996 /* Returns 1 iff breakpoint location should be
1997 inserted in the inferior. We don't differentiate the type of BL's owner
1998 (breakpoint vs. tracepoint), although insert_location in tracepoint's
1999 breakpoint_ops is not defined, because in insert_bp_location,
2000 tracepoint's insert_location will not be called. */
2002 should_be_inserted (struct bp_location *bl)
2004 if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
2007 if (bl->owner->disposition == disp_del_at_next_stop)
2010 if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
2013 if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
2016 /* This is set for example, when we're attached to the parent of a
2017 vfork, and have detached from the child. The child is running
2018 free, and we expect it to do an exec or exit, at which point the
2019 OS makes the parent schedulable again (and the target reports
2020 that the vfork is done). Until the child is done with the shared
2021 memory region, do not insert breakpoints in the parent, otherwise
2022 the child could still trip on the parent's breakpoints. Since
2023 the parent is blocked anyway, it won't miss any breakpoint. */
2024 if (bl->pspace->breakpoints_not_allowed)
2030 /* Same as should_be_inserted but does the check assuming
2031 that the location is not duplicated. */
2034 unduplicated_should_be_inserted (struct bp_location *bl)
2037 const int save_duplicate = bl->duplicate;
2040 result = should_be_inserted (bl);
2041 bl->duplicate = save_duplicate;
2045 /* Parses a conditional described by an expression COND into an
2046 agent expression bytecode suitable for evaluation
2047 by the bytecode interpreter. Return NULL if there was
2048 any error during parsing. */
2050 static struct agent_expr *
2051 parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
2053 struct agent_expr *aexpr = NULL;
2054 volatile struct gdb_exception ex;
2059 /* We don't want to stop processing, so catch any errors
2060 that may show up. */
2061 TRY_CATCH (ex, RETURN_MASK_ERROR)
2063 aexpr = gen_eval_for_expr (scope, cond);
2068 /* If we got here, it means the condition could not be parsed to a valid
2069 bytecode expression and thus can't be evaluated on the target's side.
2070 It's no use iterating through the conditions. */
2074 /* We have a valid agent expression. */
2078 /* Based on location BL, create a list of breakpoint conditions to be
2079 passed on to the target. If we have duplicated locations with different
2080 conditions, we will add such conditions to the list. The idea is that the
2081 target will evaluate the list of conditions and will only notify GDB when
2082 one of them is true. */
2085 build_target_condition_list (struct bp_location *bl)
2087 struct bp_location **locp = NULL, **loc2p;
2088 int null_condition_or_parse_error = 0;
2089 int modified = bl->needs_update;
2090 struct bp_location *loc;
2092 /* This is only meaningful if the target is
2093 evaluating conditions and if the user has
2094 opted for condition evaluation on the target's
2096 if (gdb_evaluates_breakpoint_condition_p ()
2097 || !target_supports_evaluation_of_breakpoint_conditions ())
2100 /* Do a first pass to check for locations with no assigned
2101 conditions or conditions that fail to parse to a valid agent expression
2102 bytecode. If any of these happen, then it's no use to send conditions
2103 to the target since this location will always trigger and generate a
2104 response back to GDB. */
2105 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2108 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2112 struct agent_expr *aexpr;
2114 /* Re-parse the conditions since something changed. In that
2115 case we already freed the condition bytecodes (see
2116 force_breakpoint_reinsertion). We just
2117 need to parse the condition to bytecodes again. */
2118 aexpr = parse_cond_to_aexpr (bl->address, loc->cond);
2119 loc->cond_bytecode = aexpr;
2121 /* Check if we managed to parse the conditional expression
2122 correctly. If not, we will not send this condition
2128 /* If we have a NULL bytecode expression, it means something
2129 went wrong or we have a null condition expression. */
2130 if (!loc->cond_bytecode)
2132 null_condition_or_parse_error = 1;
2138 /* If any of these happened, it means we will have to evaluate the conditions
2139 for the location's address on gdb's side. It is no use keeping bytecodes
2140 for all the other duplicate locations, thus we free all of them here.
2142 This is so we have a finer control over which locations' conditions are
2143 being evaluated by GDB or the remote stub. */
2144 if (null_condition_or_parse_error)
2146 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2149 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2151 /* Only go as far as the first NULL bytecode is
2153 if (!loc->cond_bytecode)
2156 free_agent_expr (loc->cond_bytecode);
2157 loc->cond_bytecode = NULL;
2162 /* No NULL conditions or failed bytecode generation. Build a condition list
2163 for this location's address. */
2164 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2168 && is_breakpoint (loc->owner)
2169 && loc->pspace->num == bl->pspace->num
2170 && loc->owner->enable_state == bp_enabled
2172 /* Add the condition to the vector. This will be used later to send the
2173 conditions to the target. */
2174 VEC_safe_push (agent_expr_p, bl->target_info.conditions,
2175 loc->cond_bytecode);
2181 /* Parses a command described by string CMD into an agent expression
2182 bytecode suitable for evaluation by the bytecode interpreter.
2183 Return NULL if there was any error during parsing. */
2185 static struct agent_expr *
2186 parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
2188 struct cleanup *old_cleanups = 0;
2189 struct expression *expr, **argvec;
2190 struct agent_expr *aexpr = NULL;
2191 volatile struct gdb_exception ex;
2192 const char *cmdrest;
2193 const char *format_start, *format_end;
2194 struct format_piece *fpieces;
2196 struct gdbarch *gdbarch = get_current_arch ();
2203 if (*cmdrest == ',')
2205 cmdrest = skip_spaces_const (cmdrest);
2207 if (*cmdrest++ != '"')
2208 error (_("No format string following the location"));
2210 format_start = cmdrest;
2212 fpieces = parse_format_string (&cmdrest);
2214 old_cleanups = make_cleanup (free_format_pieces_cleanup, &fpieces);
2216 format_end = cmdrest;
2218 if (*cmdrest++ != '"')
2219 error (_("Bad format string, non-terminated '\"'."));
2221 cmdrest = skip_spaces_const (cmdrest);
2223 if (!(*cmdrest == ',' || *cmdrest == '\0'))
2224 error (_("Invalid argument syntax"));
2226 if (*cmdrest == ',')
2228 cmdrest = skip_spaces_const (cmdrest);
2230 /* For each argument, make an expression. */
2232 argvec = (struct expression **) alloca (strlen (cmd)
2233 * sizeof (struct expression *));
2236 while (*cmdrest != '\0')
2241 expr = parse_exp_1 (&cmd1, scope, block_for_pc (scope), 1);
2242 argvec[nargs++] = expr;
2244 if (*cmdrest == ',')
2248 /* We don't want to stop processing, so catch any errors
2249 that may show up. */
2250 TRY_CATCH (ex, RETURN_MASK_ERROR)
2252 aexpr = gen_printf (scope, gdbarch, 0, 0,
2253 format_start, format_end - format_start,
2254 fpieces, nargs, argvec);
2257 do_cleanups (old_cleanups);
2261 /* If we got here, it means the command could not be parsed to a valid
2262 bytecode expression and thus can't be evaluated on the target's side.
2263 It's no use iterating through the other commands. */
2267 /* We have a valid agent expression, return it. */
2271 /* Based on location BL, create a list of breakpoint commands to be
2272 passed on to the target. If we have duplicated locations with
2273 different commands, we will add any such to the list. */
2276 build_target_command_list (struct bp_location *bl)
2278 struct bp_location **locp = NULL, **loc2p;
2279 int null_command_or_parse_error = 0;
2280 int modified = bl->needs_update;
2281 struct bp_location *loc;
2283 /* For now, limit to agent-style dprintf breakpoints. */
2284 if (bl->owner->type != bp_dprintf
2285 || strcmp (dprintf_style, dprintf_style_agent) != 0)
2288 if (!target_can_run_breakpoint_commands ())
2291 /* Do a first pass to check for locations with no assigned
2292 conditions or conditions that fail to parse to a valid agent expression
2293 bytecode. If any of these happen, then it's no use to send conditions
2294 to the target since this location will always trigger and generate a
2295 response back to GDB. */
2296 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2299 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2303 struct agent_expr *aexpr;
2305 /* Re-parse the commands since something changed. In that
2306 case we already freed the command bytecodes (see
2307 force_breakpoint_reinsertion). We just
2308 need to parse the command to bytecodes again. */
2309 aexpr = parse_cmd_to_aexpr (bl->address,
2310 loc->owner->extra_string);
2311 loc->cmd_bytecode = aexpr;
2317 /* If we have a NULL bytecode expression, it means something
2318 went wrong or we have a null command expression. */
2319 if (!loc->cmd_bytecode)
2321 null_command_or_parse_error = 1;
2327 /* If anything failed, then we're not doing target-side commands,
2329 if (null_command_or_parse_error)
2331 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2334 if (is_breakpoint (loc->owner)
2335 && loc->pspace->num == bl->pspace->num)
2337 /* Only go as far as the first NULL bytecode is
2339 if (loc->cmd_bytecode == NULL)
2342 free_agent_expr (loc->cmd_bytecode);
2343 loc->cmd_bytecode = NULL;
2348 /* No NULL commands or failed bytecode generation. Build a command list
2349 for this location's address. */
2350 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2353 if (loc->owner->extra_string
2354 && is_breakpoint (loc->owner)
2355 && loc->pspace->num == bl->pspace->num
2356 && loc->owner->enable_state == bp_enabled
2358 /* Add the command to the vector. This will be used later
2359 to send the commands to the target. */
2360 VEC_safe_push (agent_expr_p, bl->target_info.tcommands,
2364 bl->target_info.persist = 0;
2365 /* Maybe flag this location as persistent. */
2366 if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2367 bl->target_info.persist = 1;
2370 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2371 location. Any error messages are printed to TMP_ERROR_STREAM; and
2372 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2373 Returns 0 for success, 1 if the bp_location type is not supported or
2376 NOTE drow/2003-09-09: This routine could be broken down to an
2377 object-style method for each breakpoint or catchpoint type. */
2379 insert_bp_location (struct bp_location *bl,
2380 struct ui_file *tmp_error_stream,
2381 int *disabled_breaks,
2382 int *hw_breakpoint_error,
2383 int *hw_bp_error_explained_already)
2386 char *hw_bp_err_string = NULL;
2387 struct gdb_exception e;
2389 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2392 /* Note we don't initialize bl->target_info, as that wipes out
2393 the breakpoint location's shadow_contents if the breakpoint
2394 is still inserted at that location. This in turn breaks
2395 target_read_memory which depends on these buffers when
2396 a memory read is requested at the breakpoint location:
2397 Once the target_info has been wiped, we fail to see that
2398 we have a breakpoint inserted at that address and thus
2399 read the breakpoint instead of returning the data saved in
2400 the breakpoint location's shadow contents. */
2401 bl->target_info.placed_address = bl->address;
2402 bl->target_info.placed_address_space = bl->pspace->aspace;
2403 bl->target_info.length = bl->length;
2405 /* When working with target-side conditions, we must pass all the conditions
2406 for the same breakpoint address down to the target since GDB will not
2407 insert those locations. With a list of breakpoint conditions, the target
2408 can decide when to stop and notify GDB. */
2410 if (is_breakpoint (bl->owner))
2412 build_target_condition_list (bl);
2413 build_target_command_list (bl);
2414 /* Reset the modification marker. */
2415 bl->needs_update = 0;
2418 if (bl->loc_type == bp_loc_software_breakpoint
2419 || bl->loc_type == bp_loc_hardware_breakpoint)
2421 if (bl->owner->type != bp_hardware_breakpoint)
2423 /* If the explicitly specified breakpoint type
2424 is not hardware breakpoint, check the memory map to see
2425 if the breakpoint address is in read only memory or not.
2427 Two important cases are:
2428 - location type is not hardware breakpoint, memory
2429 is readonly. We change the type of the location to
2430 hardware breakpoint.
2431 - location type is hardware breakpoint, memory is
2432 read-write. This means we've previously made the
2433 location hardware one, but then the memory map changed,
2436 When breakpoints are removed, remove_breakpoints will use
2437 location types we've just set here, the only possible
2438 problem is that memory map has changed during running
2439 program, but it's not going to work anyway with current
2441 struct mem_region *mr
2442 = lookup_mem_region (bl->target_info.placed_address);
2446 if (automatic_hardware_breakpoints)
2448 enum bp_loc_type new_type;
2450 if (mr->attrib.mode != MEM_RW)
2451 new_type = bp_loc_hardware_breakpoint;
2453 new_type = bp_loc_software_breakpoint;
2455 if (new_type != bl->loc_type)
2457 static int said = 0;
2459 bl->loc_type = new_type;
2462 fprintf_filtered (gdb_stdout,
2463 _("Note: automatically using "
2464 "hardware breakpoints for "
2465 "read-only addresses.\n"));
2470 else if (bl->loc_type == bp_loc_software_breakpoint
2471 && mr->attrib.mode != MEM_RW)
2472 warning (_("cannot set software breakpoint "
2473 "at readonly address %s"),
2474 paddress (bl->gdbarch, bl->address));
2478 /* First check to see if we have to handle an overlay. */
2479 if (overlay_debugging == ovly_off
2480 || bl->section == NULL
2481 || !(section_is_overlay (bl->section)))
2483 /* No overlay handling: just set the breakpoint. */
2484 TRY_CATCH (e, RETURN_MASK_ALL)
2486 val = bl->owner->ops->insert_location (bl);
2491 hw_bp_err_string = (char *) e.message;
2496 /* This breakpoint is in an overlay section.
2497 Shall we set a breakpoint at the LMA? */
2498 if (!overlay_events_enabled)
2500 /* Yes -- overlay event support is not active,
2501 so we must try to set a breakpoint at the LMA.
2502 This will not work for a hardware breakpoint. */
2503 if (bl->loc_type == bp_loc_hardware_breakpoint)
2504 warning (_("hardware breakpoint %d not supported in overlay!"),
2508 CORE_ADDR addr = overlay_unmapped_address (bl->address,
2510 /* Set a software (trap) breakpoint at the LMA. */
2511 bl->overlay_target_info = bl->target_info;
2512 bl->overlay_target_info.placed_address = addr;
2513 val = target_insert_breakpoint (bl->gdbarch,
2514 &bl->overlay_target_info);
2516 fprintf_unfiltered (tmp_error_stream,
2517 "Overlay breakpoint %d "
2518 "failed: in ROM?\n",
2522 /* Shall we set a breakpoint at the VMA? */
2523 if (section_is_mapped (bl->section))
2525 /* Yes. This overlay section is mapped into memory. */
2526 TRY_CATCH (e, RETURN_MASK_ALL)
2528 val = bl->owner->ops->insert_location (bl);
2533 hw_bp_err_string = (char *) e.message;
2538 /* No. This breakpoint will not be inserted.
2539 No error, but do not mark the bp as 'inserted'. */
2546 /* Can't set the breakpoint. */
2547 if (solib_name_from_address (bl->pspace, bl->address))
2549 /* See also: disable_breakpoints_in_shlibs. */
2551 bl->shlib_disabled = 1;
2552 observer_notify_breakpoint_modified (bl->owner);
2553 if (!*disabled_breaks)
2555 fprintf_unfiltered (tmp_error_stream,
2556 "Cannot insert breakpoint %d.\n",
2558 fprintf_unfiltered (tmp_error_stream,
2559 "Temporarily disabling shared "
2560 "library breakpoints:\n");
2562 *disabled_breaks = 1;
2563 fprintf_unfiltered (tmp_error_stream,
2564 "breakpoint #%d\n", bl->owner->number);
2568 if (bl->loc_type == bp_loc_hardware_breakpoint)
2570 *hw_breakpoint_error = 1;
2571 *hw_bp_error_explained_already = hw_bp_err_string != NULL;
2572 fprintf_unfiltered (tmp_error_stream,
2573 "Cannot insert hardware breakpoint %d%s",
2574 bl->owner->number, hw_bp_err_string ? ":" : ".\n");
2575 if (hw_bp_err_string)
2576 fprintf_unfiltered (tmp_error_stream, "%s.\n", hw_bp_err_string);
2580 char *message = memory_error_message (TARGET_XFER_E_IO,
2581 bl->gdbarch, bl->address);
2582 struct cleanup *old_chain = make_cleanup (xfree, message);
2584 fprintf_unfiltered (tmp_error_stream,
2585 "Cannot insert breakpoint %d.\n"
2587 bl->owner->number, message);
2589 do_cleanups (old_chain);
2600 else if (bl->loc_type == bp_loc_hardware_watchpoint
2601 /* NOTE drow/2003-09-08: This state only exists for removing
2602 watchpoints. It's not clear that it's necessary... */
2603 && bl->owner->disposition != disp_del_at_next_stop)
2605 gdb_assert (bl->owner->ops != NULL
2606 && bl->owner->ops->insert_location != NULL);
2608 val = bl->owner->ops->insert_location (bl);
2610 /* If trying to set a read-watchpoint, and it turns out it's not
2611 supported, try emulating one with an access watchpoint. */
2612 if (val == 1 && bl->watchpoint_type == hw_read)
2614 struct bp_location *loc, **loc_temp;
2616 /* But don't try to insert it, if there's already another
2617 hw_access location that would be considered a duplicate
2619 ALL_BP_LOCATIONS (loc, loc_temp)
2621 && loc->watchpoint_type == hw_access
2622 && watchpoint_locations_match (bl, loc))
2626 bl->target_info = loc->target_info;
2627 bl->watchpoint_type = hw_access;
2634 bl->watchpoint_type = hw_access;
2635 val = bl->owner->ops->insert_location (bl);
2638 /* Back to the original value. */
2639 bl->watchpoint_type = hw_read;
2643 bl->inserted = (val == 0);
2646 else if (bl->owner->type == bp_catchpoint)
2648 gdb_assert (bl->owner->ops != NULL
2649 && bl->owner->ops->insert_location != NULL);
2651 val = bl->owner->ops->insert_location (bl);
2654 bl->owner->enable_state = bp_disabled;
2658 Error inserting catchpoint %d: Your system does not support this type\n\
2659 of catchpoint."), bl->owner->number);
2661 warning (_("Error inserting catchpoint %d."), bl->owner->number);
2664 bl->inserted = (val == 0);
2666 /* We've already printed an error message if there was a problem
2667 inserting this catchpoint, and we've disabled the catchpoint,
2668 so just return success. */
2675 /* This function is called when program space PSPACE is about to be
2676 deleted. It takes care of updating breakpoints to not reference
2680 breakpoint_program_space_exit (struct program_space *pspace)
2682 struct breakpoint *b, *b_temp;
2683 struct bp_location *loc, **loc_temp;
2685 /* Remove any breakpoint that was set through this program space. */
2686 ALL_BREAKPOINTS_SAFE (b, b_temp)
2688 if (b->pspace == pspace)
2689 delete_breakpoint (b);
2692 /* Breakpoints set through other program spaces could have locations
2693 bound to PSPACE as well. Remove those. */
2694 ALL_BP_LOCATIONS (loc, loc_temp)
2696 struct bp_location *tmp;
2698 if (loc->pspace == pspace)
2700 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2701 if (loc->owner->loc == loc)
2702 loc->owner->loc = loc->next;
2704 for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
2705 if (tmp->next == loc)
2707 tmp->next = loc->next;
2713 /* Now update the global location list to permanently delete the
2714 removed locations above. */
2715 update_global_location_list (0);
2718 /* Make sure all breakpoints are inserted in inferior.
2719 Throws exception on any error.
2720 A breakpoint that is already inserted won't be inserted
2721 again, so calling this function twice is safe. */
2723 insert_breakpoints (void)
2725 struct breakpoint *bpt;
2727 ALL_BREAKPOINTS (bpt)
2728 if (is_hardware_watchpoint (bpt))
2730 struct watchpoint *w = (struct watchpoint *) bpt;
2732 update_watchpoint (w, 0 /* don't reparse. */);
2735 update_global_location_list (1);
2737 /* update_global_location_list does not insert breakpoints when
2738 always_inserted_mode is not enabled. Explicitly insert them
2740 if (!breakpoints_always_inserted_mode ())
2741 insert_breakpoint_locations ();
2744 /* Invoke CALLBACK for each of bp_location. */
2747 iterate_over_bp_locations (walk_bp_location_callback callback)
2749 struct bp_location *loc, **loc_tmp;
2751 ALL_BP_LOCATIONS (loc, loc_tmp)
2753 callback (loc, NULL);
2757 /* This is used when we need to synch breakpoint conditions between GDB and the
2758 target. It is the case with deleting and disabling of breakpoints when using
2759 always-inserted mode. */
2762 update_inserted_breakpoint_locations (void)
2764 struct bp_location *bl, **blp_tmp;
2767 int disabled_breaks = 0;
2768 int hw_breakpoint_error = 0;
2769 int hw_bp_details_reported = 0;
2771 struct ui_file *tmp_error_stream = mem_fileopen ();
2772 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
2774 /* Explicitly mark the warning -- this will only be printed if
2775 there was an error. */
2776 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
2778 save_current_space_and_thread ();
2780 ALL_BP_LOCATIONS (bl, blp_tmp)
2782 /* We only want to update software breakpoints and hardware
2784 if (!is_breakpoint (bl->owner))
2787 /* We only want to update locations that are already inserted
2788 and need updating. This is to avoid unwanted insertion during
2789 deletion of breakpoints. */
2790 if (!bl->inserted || (bl->inserted && !bl->needs_update))
2793 switch_to_program_space_and_thread (bl->pspace);
2795 /* For targets that support global breakpoints, there's no need
2796 to select an inferior to insert breakpoint to. In fact, even
2797 if we aren't attached to any process yet, we should still
2798 insert breakpoints. */
2799 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2800 && ptid_equal (inferior_ptid, null_ptid))
2803 val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
2804 &hw_breakpoint_error, &hw_bp_details_reported);
2811 target_terminal_ours_for_output ();
2812 error_stream (tmp_error_stream);
2815 do_cleanups (cleanups);
2818 /* Used when starting or continuing the program. */
2821 insert_breakpoint_locations (void)
2823 struct breakpoint *bpt;
2824 struct bp_location *bl, **blp_tmp;
2827 int disabled_breaks = 0;
2828 int hw_breakpoint_error = 0;
2829 int hw_bp_error_explained_already = 0;
2831 struct ui_file *tmp_error_stream = mem_fileopen ();
2832 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
2834 /* Explicitly mark the warning -- this will only be printed if
2835 there was an error. */
2836 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
2838 save_current_space_and_thread ();
2840 ALL_BP_LOCATIONS (bl, blp_tmp)
2842 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2845 /* There is no point inserting thread-specific breakpoints if
2846 the thread no longer exists. ALL_BP_LOCATIONS bp_location
2847 has BL->OWNER always non-NULL. */
2848 if (bl->owner->thread != -1
2849 && !valid_thread_id (bl->owner->thread))
2852 switch_to_program_space_and_thread (bl->pspace);
2854 /* For targets that support global breakpoints, there's no need
2855 to select an inferior to insert breakpoint to. In fact, even
2856 if we aren't attached to any process yet, we should still
2857 insert breakpoints. */
2858 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2859 && ptid_equal (inferior_ptid, null_ptid))
2862 val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
2863 &hw_breakpoint_error, &hw_bp_error_explained_already);
2868 /* If we failed to insert all locations of a watchpoint, remove
2869 them, as half-inserted watchpoint is of limited use. */
2870 ALL_BREAKPOINTS (bpt)
2872 int some_failed = 0;
2873 struct bp_location *loc;
2875 if (!is_hardware_watchpoint (bpt))
2878 if (!breakpoint_enabled (bpt))
2881 if (bpt->disposition == disp_del_at_next_stop)
2884 for (loc = bpt->loc; loc; loc = loc->next)
2885 if (!loc->inserted && should_be_inserted (loc))
2892 for (loc = bpt->loc; loc; loc = loc->next)
2894 remove_breakpoint (loc, mark_uninserted);
2896 hw_breakpoint_error = 1;
2897 fprintf_unfiltered (tmp_error_stream,
2898 "Could not insert hardware watchpoint %d.\n",
2906 /* If a hardware breakpoint or watchpoint was inserted, add a
2907 message about possibly exhausted resources. */
2908 if (hw_breakpoint_error && !hw_bp_error_explained_already)
2910 fprintf_unfiltered (tmp_error_stream,
2911 "Could not insert hardware breakpoints:\n\
2912 You may have requested too many hardware breakpoints/watchpoints.\n");
2914 target_terminal_ours_for_output ();
2915 error_stream (tmp_error_stream);
2918 do_cleanups (cleanups);
2921 /* Used when the program stops.
2922 Returns zero if successful, or non-zero if there was a problem
2923 removing a breakpoint location. */
2926 remove_breakpoints (void)
2928 struct bp_location *bl, **blp_tmp;
2931 ALL_BP_LOCATIONS (bl, blp_tmp)
2933 if (bl->inserted && !is_tracepoint (bl->owner))
2934 val |= remove_breakpoint (bl, mark_uninserted);
2939 /* When a thread exits, remove breakpoints that are related to
2943 remove_threaded_breakpoints (struct thread_info *tp, int silent)
2945 struct breakpoint *b, *b_tmp;
2947 ALL_BREAKPOINTS_SAFE (b, b_tmp)
2949 if (b->thread == tp->num && user_breakpoint_p (b))
2951 b->disposition = disp_del_at_next_stop;
2953 printf_filtered (_("\
2954 Thread-specific breakpoint %d deleted - thread %d no longer in the thread list.\n"),
2955 b->number, tp->num);
2957 /* Hide it from the user. */
2963 /* Remove breakpoints of process PID. */
2966 remove_breakpoints_pid (int pid)
2968 struct bp_location *bl, **blp_tmp;
2970 struct inferior *inf = find_inferior_pid (pid);
2972 ALL_BP_LOCATIONS (bl, blp_tmp)
2974 if (bl->pspace != inf->pspace)
2977 if (bl->owner->type == bp_dprintf)
2982 val = remove_breakpoint (bl, mark_uninserted);
2991 reattach_breakpoints (int pid)
2993 struct cleanup *old_chain;
2994 struct bp_location *bl, **blp_tmp;
2996 struct ui_file *tmp_error_stream;
2997 int dummy1 = 0, dummy2 = 0, dummy3 = 0;
2998 struct inferior *inf;
2999 struct thread_info *tp;
3001 tp = any_live_thread_of_process (pid);
3005 inf = find_inferior_pid (pid);
3006 old_chain = save_inferior_ptid ();
3008 inferior_ptid = tp->ptid;
3010 tmp_error_stream = mem_fileopen ();
3011 make_cleanup_ui_file_delete (tmp_error_stream);
3013 ALL_BP_LOCATIONS (bl, blp_tmp)
3015 if (bl->pspace != inf->pspace)
3021 val = insert_bp_location (bl, tmp_error_stream, &dummy1, &dummy2, &dummy3);
3024 do_cleanups (old_chain);
3029 do_cleanups (old_chain);
3033 static int internal_breakpoint_number = -1;
3035 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3036 If INTERNAL is non-zero, the breakpoint number will be populated
3037 from internal_breakpoint_number and that variable decremented.
3038 Otherwise the breakpoint number will be populated from
3039 breakpoint_count and that value incremented. Internal breakpoints
3040 do not set the internal var bpnum. */
3042 set_breakpoint_number (int internal, struct breakpoint *b)
3045 b->number = internal_breakpoint_number--;
3048 set_breakpoint_count (breakpoint_count + 1);
3049 b->number = breakpoint_count;
3053 static struct breakpoint *
3054 create_internal_breakpoint (struct gdbarch *gdbarch,
3055 CORE_ADDR address, enum bptype type,
3056 const struct breakpoint_ops *ops)
3058 struct symtab_and_line sal;
3059 struct breakpoint *b;
3061 init_sal (&sal); /* Initialize to zeroes. */
3064 sal.section = find_pc_overlay (sal.pc);
3065 sal.pspace = current_program_space;
3067 b = set_raw_breakpoint (gdbarch, sal, type, ops);
3068 b->number = internal_breakpoint_number--;
3069 b->disposition = disp_donttouch;
3074 static const char *const longjmp_names[] =
3076 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3078 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3080 /* Per-objfile data private to breakpoint.c. */
3081 struct breakpoint_objfile_data
3083 /* Minimal symbol for "_ovly_debug_event" (if any). */
3084 struct minimal_symbol *overlay_msym;
3086 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3087 struct minimal_symbol *longjmp_msym[NUM_LONGJMP_NAMES];
3089 /* True if we have looked for longjmp probes. */
3090 int longjmp_searched;
3092 /* SystemTap probe points for longjmp (if any). */
3093 VEC (probe_p) *longjmp_probes;
3095 /* Minimal symbol for "std::terminate()" (if any). */
3096 struct minimal_symbol *terminate_msym;
3098 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3099 struct minimal_symbol *exception_msym;
3101 /* True if we have looked for exception probes. */
3102 int exception_searched;
3104 /* SystemTap probe points for unwinding (if any). */
3105 VEC (probe_p) *exception_probes;
3108 static const struct objfile_data *breakpoint_objfile_key;
3110 /* Minimal symbol not found sentinel. */
3111 static struct minimal_symbol msym_not_found;
3113 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3116 msym_not_found_p (const struct minimal_symbol *msym)
3118 return msym == &msym_not_found;
3121 /* Return per-objfile data needed by breakpoint.c.
3122 Allocate the data if necessary. */
3124 static struct breakpoint_objfile_data *
3125 get_breakpoint_objfile_data (struct objfile *objfile)
3127 struct breakpoint_objfile_data *bp_objfile_data;
3129 bp_objfile_data = objfile_data (objfile, breakpoint_objfile_key);
3130 if (bp_objfile_data == NULL)
3132 bp_objfile_data = obstack_alloc (&objfile->objfile_obstack,
3133 sizeof (*bp_objfile_data));
3135 memset (bp_objfile_data, 0, sizeof (*bp_objfile_data));
3136 set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
3138 return bp_objfile_data;
3142 free_breakpoint_probes (struct objfile *obj, void *data)
3144 struct breakpoint_objfile_data *bp_objfile_data = data;
3146 VEC_free (probe_p, bp_objfile_data->longjmp_probes);
3147 VEC_free (probe_p, bp_objfile_data->exception_probes);
3151 create_overlay_event_breakpoint (void)
3153 struct objfile *objfile;
3154 const char *const func_name = "_ovly_debug_event";
3156 ALL_OBJFILES (objfile)
3158 struct breakpoint *b;
3159 struct breakpoint_objfile_data *bp_objfile_data;
3162 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3164 if (msym_not_found_p (bp_objfile_data->overlay_msym))
3167 if (bp_objfile_data->overlay_msym == NULL)
3169 struct minimal_symbol *m;
3171 m = lookup_minimal_symbol_text (func_name, objfile);
3174 /* Avoid future lookups in this objfile. */
3175 bp_objfile_data->overlay_msym = &msym_not_found;
3178 bp_objfile_data->overlay_msym = m;
3181 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
3182 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3184 &internal_breakpoint_ops);
3185 b->addr_string = xstrdup (func_name);
3187 if (overlay_debugging == ovly_auto)
3189 b->enable_state = bp_enabled;
3190 overlay_events_enabled = 1;
3194 b->enable_state = bp_disabled;
3195 overlay_events_enabled = 0;
3198 update_global_location_list (1);
3202 create_longjmp_master_breakpoint (void)
3204 struct program_space *pspace;
3205 struct cleanup *old_chain;
3207 old_chain = save_current_program_space ();
3209 ALL_PSPACES (pspace)
3211 struct objfile *objfile;
3213 set_current_program_space (pspace);
3215 ALL_OBJFILES (objfile)
3218 struct gdbarch *gdbarch;
3219 struct breakpoint_objfile_data *bp_objfile_data;
3221 gdbarch = get_objfile_arch (objfile);
3222 if (!gdbarch_get_longjmp_target_p (gdbarch))
3225 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3227 if (!bp_objfile_data->longjmp_searched)
3231 ret = find_probes_in_objfile (objfile, "libc", "longjmp");
3234 /* We are only interested in checking one element. */
3235 struct probe *p = VEC_index (probe_p, ret, 0);
3237 if (!can_evaluate_probe_arguments (p))
3239 /* We cannot use the probe interface here, because it does
3240 not know how to evaluate arguments. */
3241 VEC_free (probe_p, ret);
3245 bp_objfile_data->longjmp_probes = ret;
3246 bp_objfile_data->longjmp_searched = 1;
3249 if (bp_objfile_data->longjmp_probes != NULL)
3252 struct probe *probe;
3253 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3256 VEC_iterate (probe_p,
3257 bp_objfile_data->longjmp_probes,
3261 struct breakpoint *b;
3263 b = create_internal_breakpoint (gdbarch, probe->address,
3265 &internal_breakpoint_ops);
3266 b->addr_string = xstrdup ("-probe-stap libc:longjmp");
3267 b->enable_state = bp_disabled;
3273 for (i = 0; i < NUM_LONGJMP_NAMES; i++)
3275 struct breakpoint *b;
3276 const char *func_name;
3279 if (msym_not_found_p (bp_objfile_data->longjmp_msym[i]))
3282 func_name = longjmp_names[i];
3283 if (bp_objfile_data->longjmp_msym[i] == NULL)
3285 struct minimal_symbol *m;
3287 m = lookup_minimal_symbol_text (func_name, objfile);
3290 /* Prevent future lookups in this objfile. */
3291 bp_objfile_data->longjmp_msym[i] = &msym_not_found;
3294 bp_objfile_data->longjmp_msym[i] = m;
3297 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
3298 b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3299 &internal_breakpoint_ops);
3300 b->addr_string = xstrdup (func_name);
3301 b->enable_state = bp_disabled;
3305 update_global_location_list (1);
3307 do_cleanups (old_chain);
3310 /* Create a master std::terminate breakpoint. */
3312 create_std_terminate_master_breakpoint (void)
3314 struct program_space *pspace;
3315 struct cleanup *old_chain;
3316 const char *const func_name = "std::terminate()";
3318 old_chain = save_current_program_space ();
3320 ALL_PSPACES (pspace)
3322 struct objfile *objfile;
3325 set_current_program_space (pspace);
3327 ALL_OBJFILES (objfile)
3329 struct breakpoint *b;
3330 struct breakpoint_objfile_data *bp_objfile_data;
3332 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3334 if (msym_not_found_p (bp_objfile_data->terminate_msym))
3337 if (bp_objfile_data->terminate_msym == NULL)
3339 struct minimal_symbol *m;
3341 m = lookup_minimal_symbol (func_name, NULL, objfile);
3342 if (m == NULL || (MSYMBOL_TYPE (m) != mst_text
3343 && MSYMBOL_TYPE (m) != mst_file_text))
3345 /* Prevent future lookups in this objfile. */
3346 bp_objfile_data->terminate_msym = &msym_not_found;
3349 bp_objfile_data->terminate_msym = m;
3352 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
3353 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3354 bp_std_terminate_master,
3355 &internal_breakpoint_ops);
3356 b->addr_string = xstrdup (func_name);
3357 b->enable_state = bp_disabled;
3361 update_global_location_list (1);
3363 do_cleanups (old_chain);
3366 /* Install a master breakpoint on the unwinder's debug hook. */
3369 create_exception_master_breakpoint (void)
3371 struct objfile *objfile;
3372 const char *const func_name = "_Unwind_DebugHook";
3374 ALL_OBJFILES (objfile)
3376 struct breakpoint *b;
3377 struct gdbarch *gdbarch;
3378 struct breakpoint_objfile_data *bp_objfile_data;
3381 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3383 /* We prefer the SystemTap probe point if it exists. */
3384 if (!bp_objfile_data->exception_searched)
3388 ret = find_probes_in_objfile (objfile, "libgcc", "unwind");
3392 /* We are only interested in checking one element. */
3393 struct probe *p = VEC_index (probe_p, ret, 0);
3395 if (!can_evaluate_probe_arguments (p))
3397 /* We cannot use the probe interface here, because it does
3398 not know how to evaluate arguments. */
3399 VEC_free (probe_p, ret);
3403 bp_objfile_data->exception_probes = ret;
3404 bp_objfile_data->exception_searched = 1;
3407 if (bp_objfile_data->exception_probes != NULL)
3409 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3411 struct probe *probe;
3414 VEC_iterate (probe_p,
3415 bp_objfile_data->exception_probes,
3419 struct breakpoint *b;
3421 b = create_internal_breakpoint (gdbarch, probe->address,
3422 bp_exception_master,
3423 &internal_breakpoint_ops);
3424 b->addr_string = xstrdup ("-probe-stap libgcc:unwind");
3425 b->enable_state = bp_disabled;
3431 /* Otherwise, try the hook function. */
3433 if (msym_not_found_p (bp_objfile_data->exception_msym))
3436 gdbarch = get_objfile_arch (objfile);
3438 if (bp_objfile_data->exception_msym == NULL)
3440 struct minimal_symbol *debug_hook;
3442 debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3443 if (debug_hook == NULL)
3445 bp_objfile_data->exception_msym = &msym_not_found;
3449 bp_objfile_data->exception_msym = debug_hook;
3452 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
3453 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3455 b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3456 &internal_breakpoint_ops);
3457 b->addr_string = xstrdup (func_name);
3458 b->enable_state = bp_disabled;
3461 update_global_location_list (1);
3465 update_breakpoints_after_exec (void)
3467 struct breakpoint *b, *b_tmp;
3468 struct bp_location *bploc, **bplocp_tmp;
3470 /* We're about to delete breakpoints from GDB's lists. If the
3471 INSERTED flag is true, GDB will try to lift the breakpoints by
3472 writing the breakpoints' "shadow contents" back into memory. The
3473 "shadow contents" are NOT valid after an exec, so GDB should not
3474 do that. Instead, the target is responsible from marking
3475 breakpoints out as soon as it detects an exec. We don't do that
3476 here instead, because there may be other attempts to delete
3477 breakpoints after detecting an exec and before reaching here. */
3478 ALL_BP_LOCATIONS (bploc, bplocp_tmp)
3479 if (bploc->pspace == current_program_space)
3480 gdb_assert (!bploc->inserted);
3482 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3484 if (b->pspace != current_program_space)
3487 /* Solib breakpoints must be explicitly reset after an exec(). */
3488 if (b->type == bp_shlib_event)
3490 delete_breakpoint (b);
3494 /* JIT breakpoints must be explicitly reset after an exec(). */
3495 if (b->type == bp_jit_event)
3497 delete_breakpoint (b);
3501 /* Thread event breakpoints must be set anew after an exec(),
3502 as must overlay event and longjmp master breakpoints. */
3503 if (b->type == bp_thread_event || b->type == bp_overlay_event
3504 || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3505 || b->type == bp_exception_master)
3507 delete_breakpoint (b);
3511 /* Step-resume breakpoints are meaningless after an exec(). */
3512 if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
3514 delete_breakpoint (b);
3518 /* Longjmp and longjmp-resume breakpoints are also meaningless
3520 if (b->type == bp_longjmp || b->type == bp_longjmp_resume
3521 || b->type == bp_longjmp_call_dummy
3522 || b->type == bp_exception || b->type == bp_exception_resume)
3524 delete_breakpoint (b);
3528 if (b->type == bp_catchpoint)
3530 /* For now, none of the bp_catchpoint breakpoints need to
3531 do anything at this point. In the future, if some of
3532 the catchpoints need to something, we will need to add
3533 a new method, and call this method from here. */
3537 /* bp_finish is a special case. The only way we ought to be able
3538 to see one of these when an exec() has happened, is if the user
3539 caught a vfork, and then said "finish". Ordinarily a finish just
3540 carries them to the call-site of the current callee, by setting
3541 a temporary bp there and resuming. But in this case, the finish
3542 will carry them entirely through the vfork & exec.
3544 We don't want to allow a bp_finish to remain inserted now. But
3545 we can't safely delete it, 'cause finish_command has a handle to
3546 the bp on a bpstat, and will later want to delete it. There's a
3547 chance (and I've seen it happen) that if we delete the bp_finish
3548 here, that its storage will get reused by the time finish_command
3549 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3550 We really must allow finish_command to delete a bp_finish.
3552 In the absence of a general solution for the "how do we know
3553 it's safe to delete something others may have handles to?"
3554 problem, what we'll do here is just uninsert the bp_finish, and
3555 let finish_command delete it.
3557 (We know the bp_finish is "doomed" in the sense that it's
3558 momentary, and will be deleted as soon as finish_command sees
3559 the inferior stopped. So it doesn't matter that the bp's
3560 address is probably bogus in the new a.out, unlike e.g., the
3561 solib breakpoints.) */
3563 if (b->type == bp_finish)
3568 /* Without a symbolic address, we have little hope of the
3569 pre-exec() address meaning the same thing in the post-exec()
3571 if (b->addr_string == NULL)
3573 delete_breakpoint (b);
3577 /* FIXME what about longjmp breakpoints? Re-create them here? */
3578 create_overlay_event_breakpoint ();
3579 create_longjmp_master_breakpoint ();
3580 create_std_terminate_master_breakpoint ();
3581 create_exception_master_breakpoint ();
3585 detach_breakpoints (ptid_t ptid)
3587 struct bp_location *bl, **blp_tmp;
3589 struct cleanup *old_chain = save_inferior_ptid ();
3590 struct inferior *inf = current_inferior ();
3592 if (ptid_get_pid (ptid) == ptid_get_pid (inferior_ptid))
3593 error (_("Cannot detach breakpoints of inferior_ptid"));
3595 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3596 inferior_ptid = ptid;
3597 ALL_BP_LOCATIONS (bl, blp_tmp)
3599 if (bl->pspace != inf->pspace)
3602 /* This function must physically remove breakpoints locations
3603 from the specified ptid, without modifying the breakpoint
3604 package's state. Locations of type bp_loc_other are only
3605 maintained at GDB side. So, there is no need to remove
3606 these bp_loc_other locations. Moreover, removing these
3607 would modify the breakpoint package's state. */
3608 if (bl->loc_type == bp_loc_other)
3612 val |= remove_breakpoint_1 (bl, mark_inserted);
3615 /* Detach single-step breakpoints as well. */
3616 detach_single_step_breakpoints ();
3618 do_cleanups (old_chain);
3622 /* Remove the breakpoint location BL from the current address space.
3623 Note that this is used to detach breakpoints from a child fork.
3624 When we get here, the child isn't in the inferior list, and neither
3625 do we have objects to represent its address space --- we should
3626 *not* look at bl->pspace->aspace here. */
3629 remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is)
3633 /* BL is never in moribund_locations by our callers. */
3634 gdb_assert (bl->owner != NULL);
3636 if (bl->owner->enable_state == bp_permanent)
3637 /* Permanent breakpoints cannot be inserted or removed. */
3640 /* The type of none suggests that owner is actually deleted.
3641 This should not ever happen. */
3642 gdb_assert (bl->owner->type != bp_none);
3644 if (bl->loc_type == bp_loc_software_breakpoint
3645 || bl->loc_type == bp_loc_hardware_breakpoint)
3647 /* "Normal" instruction breakpoint: either the standard
3648 trap-instruction bp (bp_breakpoint), or a
3649 bp_hardware_breakpoint. */
3651 /* First check to see if we have to handle an overlay. */
3652 if (overlay_debugging == ovly_off
3653 || bl->section == NULL
3654 || !(section_is_overlay (bl->section)))
3656 /* No overlay handling: just remove the breakpoint. */
3657 val = bl->owner->ops->remove_location (bl);
3661 /* This breakpoint is in an overlay section.
3662 Did we set a breakpoint at the LMA? */
3663 if (!overlay_events_enabled)
3665 /* Yes -- overlay event support is not active, so we
3666 should have set a breakpoint at the LMA. Remove it.
3668 /* Ignore any failures: if the LMA is in ROM, we will
3669 have already warned when we failed to insert it. */
3670 if (bl->loc_type == bp_loc_hardware_breakpoint)
3671 target_remove_hw_breakpoint (bl->gdbarch,
3672 &bl->overlay_target_info);
3674 target_remove_breakpoint (bl->gdbarch,
3675 &bl->overlay_target_info);
3677 /* Did we set a breakpoint at the VMA?
3678 If so, we will have marked the breakpoint 'inserted'. */
3681 /* Yes -- remove it. Previously we did not bother to
3682 remove the breakpoint if the section had been
3683 unmapped, but let's not rely on that being safe. We
3684 don't know what the overlay manager might do. */
3686 /* However, we should remove *software* breakpoints only
3687 if the section is still mapped, or else we overwrite
3688 wrong code with the saved shadow contents. */
3689 if (bl->loc_type == bp_loc_hardware_breakpoint
3690 || section_is_mapped (bl->section))
3691 val = bl->owner->ops->remove_location (bl);
3697 /* No -- not inserted, so no need to remove. No error. */
3702 /* In some cases, we might not be able to remove a breakpoint
3703 in a shared library that has already been removed, but we
3704 have not yet processed the shlib unload event. */
3705 if (val && solib_name_from_address (bl->pspace, bl->address))
3710 bl->inserted = (is == mark_inserted);
3712 else if (bl->loc_type == bp_loc_hardware_watchpoint)
3714 gdb_assert (bl->owner->ops != NULL
3715 && bl->owner->ops->remove_location != NULL);
3717 bl->inserted = (is == mark_inserted);
3718 bl->owner->ops->remove_location (bl);
3720 /* Failure to remove any of the hardware watchpoints comes here. */
3721 if ((is == mark_uninserted) && (bl->inserted))
3722 warning (_("Could not remove hardware watchpoint %d."),
3725 else if (bl->owner->type == bp_catchpoint
3726 && breakpoint_enabled (bl->owner)
3729 gdb_assert (bl->owner->ops != NULL
3730 && bl->owner->ops->remove_location != NULL);
3732 val = bl->owner->ops->remove_location (bl);
3736 bl->inserted = (is == mark_inserted);
3743 remove_breakpoint (struct bp_location *bl, insertion_state_t is)
3746 struct cleanup *old_chain;
3748 /* BL is never in moribund_locations by our callers. */
3749 gdb_assert (bl->owner != NULL);
3751 if (bl->owner->enable_state == bp_permanent)
3752 /* Permanent breakpoints cannot be inserted or removed. */
3755 /* The type of none suggests that owner is actually deleted.
3756 This should not ever happen. */
3757 gdb_assert (bl->owner->type != bp_none);
3759 old_chain = save_current_space_and_thread ();
3761 switch_to_program_space_and_thread (bl->pspace);
3763 ret = remove_breakpoint_1 (bl, is);
3765 do_cleanups (old_chain);
3769 /* Clear the "inserted" flag in all breakpoints. */
3772 mark_breakpoints_out (void)
3774 struct bp_location *bl, **blp_tmp;
3776 ALL_BP_LOCATIONS (bl, blp_tmp)
3777 if (bl->pspace == current_program_space)
3781 /* Clear the "inserted" flag in all breakpoints and delete any
3782 breakpoints which should go away between runs of the program.
3784 Plus other such housekeeping that has to be done for breakpoints
3787 Note: this function gets called at the end of a run (by
3788 generic_mourn_inferior) and when a run begins (by
3789 init_wait_for_inferior). */
3794 breakpoint_init_inferior (enum inf_context context)
3796 struct breakpoint *b, *b_tmp;
3797 struct bp_location *bl, **blp_tmp;
3799 struct program_space *pspace = current_program_space;
3801 /* If breakpoint locations are shared across processes, then there's
3803 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3806 ALL_BP_LOCATIONS (bl, blp_tmp)
3808 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
3809 if (bl->pspace == pspace
3810 && bl->owner->enable_state != bp_permanent)
3814 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3816 if (b->loc && b->loc->pspace != pspace)
3822 case bp_longjmp_call_dummy:
3824 /* If the call dummy breakpoint is at the entry point it will
3825 cause problems when the inferior is rerun, so we better get
3828 case bp_watchpoint_scope:
3830 /* Also get rid of scope breakpoints. */
3832 case bp_shlib_event:
3834 /* Also remove solib event breakpoints. Their addresses may
3835 have changed since the last time we ran the program.
3836 Actually we may now be debugging against different target;
3837 and so the solib backend that installed this breakpoint may
3838 not be used in by the target. E.g.,
3840 (gdb) file prog-linux
3841 (gdb) run # native linux target
3844 (gdb) file prog-win.exe
3845 (gdb) tar rem :9999 # remote Windows gdbserver.
3848 case bp_step_resume:
3850 /* Also remove step-resume breakpoints. */
3852 delete_breakpoint (b);
3856 case bp_hardware_watchpoint:
3857 case bp_read_watchpoint:
3858 case bp_access_watchpoint:
3860 struct watchpoint *w = (struct watchpoint *) b;
3862 /* Likewise for watchpoints on local expressions. */
3863 if (w->exp_valid_block != NULL)
3864 delete_breakpoint (b);
3865 else if (context == inf_starting)
3867 /* Reset val field to force reread of starting value in
3868 insert_breakpoints. */
3870 value_free (w->val);
3881 /* Get rid of the moribund locations. */
3882 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
3883 decref_bp_location (&bl);
3884 VEC_free (bp_location_p, moribund_locations);
3887 /* These functions concern about actual breakpoints inserted in the
3888 target --- to e.g. check if we need to do decr_pc adjustment or if
3889 we need to hop over the bkpt --- so we check for address space
3890 match, not program space. */
3892 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3893 exists at PC. It returns ordinary_breakpoint_here if it's an
3894 ordinary breakpoint, or permanent_breakpoint_here if it's a
3895 permanent breakpoint.
3896 - When continuing from a location with an ordinary breakpoint, we
3897 actually single step once before calling insert_breakpoints.
3898 - When continuing from a location with a permanent breakpoint, we
3899 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3900 the target, to advance the PC past the breakpoint. */
3902 enum breakpoint_here
3903 breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
3905 struct bp_location *bl, **blp_tmp;
3906 int any_breakpoint_here = 0;
3908 ALL_BP_LOCATIONS (bl, blp_tmp)
3910 if (bl->loc_type != bp_loc_software_breakpoint
3911 && bl->loc_type != bp_loc_hardware_breakpoint)
3914 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
3915 if ((breakpoint_enabled (bl->owner)
3916 || bl->owner->enable_state == bp_permanent)
3917 && breakpoint_location_address_match (bl, aspace, pc))
3919 if (overlay_debugging
3920 && section_is_overlay (bl->section)
3921 && !section_is_mapped (bl->section))
3922 continue; /* unmapped overlay -- can't be a match */
3923 else if (bl->owner->enable_state == bp_permanent)
3924 return permanent_breakpoint_here;
3926 any_breakpoint_here = 1;
3930 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
3933 /* Return true if there's a moribund breakpoint at PC. */
3936 moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
3938 struct bp_location *loc;
3941 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
3942 if (breakpoint_location_address_match (loc, aspace, pc))
3948 /* Returns non-zero if there's a breakpoint inserted at PC, which is
3949 inserted using regular breakpoint_chain / bp_location array
3950 mechanism. This does not check for single-step breakpoints, which
3951 are inserted and removed using direct target manipulation. */
3954 regular_breakpoint_inserted_here_p (struct address_space *aspace,
3957 struct bp_location *bl, **blp_tmp;
3959 ALL_BP_LOCATIONS (bl, blp_tmp)
3961 if (bl->loc_type != bp_loc_software_breakpoint
3962 && bl->loc_type != bp_loc_hardware_breakpoint)
3966 && breakpoint_location_address_match (bl, aspace, pc))
3968 if (overlay_debugging
3969 && section_is_overlay (bl->section)
3970 && !section_is_mapped (bl->section))
3971 continue; /* unmapped overlay -- can't be a match */
3979 /* Returns non-zero iff there's either regular breakpoint
3980 or a single step breakpoint inserted at PC. */
3983 breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
3985 if (regular_breakpoint_inserted_here_p (aspace, pc))
3988 if (single_step_breakpoint_inserted_here_p (aspace, pc))
3994 /* This function returns non-zero iff there is a software breakpoint
3998 software_breakpoint_inserted_here_p (struct address_space *aspace,
4001 struct bp_location *bl, **blp_tmp;
4003 ALL_BP_LOCATIONS (bl, blp_tmp)
4005 if (bl->loc_type != bp_loc_software_breakpoint)
4009 && breakpoint_address_match (bl->pspace->aspace, bl->address,
4012 if (overlay_debugging
4013 && section_is_overlay (bl->section)
4014 && !section_is_mapped (bl->section))
4015 continue; /* unmapped overlay -- can't be a match */
4021 /* Also check for software single-step breakpoints. */
4022 if (single_step_breakpoint_inserted_here_p (aspace, pc))
4029 hardware_watchpoint_inserted_in_range (struct address_space *aspace,
4030 CORE_ADDR addr, ULONGEST len)
4032 struct breakpoint *bpt;
4034 ALL_BREAKPOINTS (bpt)
4036 struct bp_location *loc;
4038 if (bpt->type != bp_hardware_watchpoint
4039 && bpt->type != bp_access_watchpoint)
4042 if (!breakpoint_enabled (bpt))
4045 for (loc = bpt->loc; loc; loc = loc->next)
4046 if (loc->pspace->aspace == aspace && loc->inserted)
4050 /* Check for intersection. */
4051 l = max (loc->address, addr);
4052 h = min (loc->address + loc->length, addr + len);
4060 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
4061 PC is valid for process/thread PTID. */
4064 breakpoint_thread_match (struct address_space *aspace, CORE_ADDR pc,
4067 struct bp_location *bl, **blp_tmp;
4068 /* The thread and task IDs associated to PTID, computed lazily. */
4072 ALL_BP_LOCATIONS (bl, blp_tmp)
4074 if (bl->loc_type != bp_loc_software_breakpoint
4075 && bl->loc_type != bp_loc_hardware_breakpoint)
4078 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
4079 if (!breakpoint_enabled (bl->owner)
4080 && bl->owner->enable_state != bp_permanent)
4083 if (!breakpoint_location_address_match (bl, aspace, pc))
4086 if (bl->owner->thread != -1)
4088 /* This is a thread-specific breakpoint. Check that ptid
4089 matches that thread. If thread hasn't been computed yet,
4090 it is now time to do so. */
4092 thread = pid_to_thread_id (ptid);
4093 if (bl->owner->thread != thread)
4097 if (bl->owner->task != 0)
4099 /* This is a task-specific breakpoint. Check that ptid
4100 matches that task. If task hasn't been computed yet,
4101 it is now time to do so. */
4103 task = ada_get_task_number (ptid);
4104 if (bl->owner->task != task)
4108 if (overlay_debugging
4109 && section_is_overlay (bl->section)
4110 && !section_is_mapped (bl->section))
4111 continue; /* unmapped overlay -- can't be a match */
4120 /* bpstat stuff. External routines' interfaces are documented
4124 is_catchpoint (struct breakpoint *ep)
4126 return (ep->type == bp_catchpoint);
4129 /* Frees any storage that is part of a bpstat. Does not walk the
4133 bpstat_free (bpstat bs)
4135 if (bs->old_val != NULL)
4136 value_free (bs->old_val);
4137 decref_counted_command_line (&bs->commands);
4138 decref_bp_location (&bs->bp_location_at);
4142 /* Clear a bpstat so that it says we are not at any breakpoint.
4143 Also free any storage that is part of a bpstat. */
4146 bpstat_clear (bpstat *bsp)
4163 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4164 is part of the bpstat is copied as well. */
4167 bpstat_copy (bpstat bs)
4171 bpstat retval = NULL;
4176 for (; bs != NULL; bs = bs->next)
4178 tmp = (bpstat) xmalloc (sizeof (*tmp));
4179 memcpy (tmp, bs, sizeof (*tmp));
4180 incref_counted_command_line (tmp->commands);
4181 incref_bp_location (tmp->bp_location_at);
4182 if (bs->old_val != NULL)
4184 tmp->old_val = value_copy (bs->old_val);
4185 release_value (tmp->old_val);
4189 /* This is the first thing in the chain. */
4199 /* Find the bpstat associated with this breakpoint. */
4202 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
4207 for (; bsp != NULL; bsp = bsp->next)
4209 if (bsp->breakpoint_at == breakpoint)
4215 /* See breakpoint.h. */
4217 enum bpstat_signal_value
4218 bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
4220 enum bpstat_signal_value result = BPSTAT_SIGNAL_NO;
4222 for (; bsp != NULL; bsp = bsp->next)
4224 /* Ensure that, if we ever entered this loop, then we at least
4225 return BPSTAT_SIGNAL_HIDE. */
4226 enum bpstat_signal_value newval;
4228 if (bsp->breakpoint_at == NULL)
4230 /* A moribund location can never explain a signal other than
4232 if (sig == GDB_SIGNAL_TRAP)
4233 newval = BPSTAT_SIGNAL_HIDE;
4235 newval = BPSTAT_SIGNAL_NO;
4238 newval = bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
4241 if (newval > result)
4248 /* Put in *NUM the breakpoint number of the first breakpoint we are
4249 stopped at. *BSP upon return is a bpstat which points to the
4250 remaining breakpoints stopped at (but which is not guaranteed to be
4251 good for anything but further calls to bpstat_num).
4253 Return 0 if passed a bpstat which does not indicate any breakpoints.
4254 Return -1 if stopped at a breakpoint that has been deleted since
4256 Return 1 otherwise. */
4259 bpstat_num (bpstat *bsp, int *num)
4261 struct breakpoint *b;
4264 return 0; /* No more breakpoint values */
4266 /* We assume we'll never have several bpstats that correspond to a
4267 single breakpoint -- otherwise, this function might return the
4268 same number more than once and this will look ugly. */
4269 b = (*bsp)->breakpoint_at;
4270 *bsp = (*bsp)->next;
4272 return -1; /* breakpoint that's been deleted since */
4274 *num = b->number; /* We have its number */
4278 /* See breakpoint.h. */
4281 bpstat_clear_actions (void)
4283 struct thread_info *tp;
4286 if (ptid_equal (inferior_ptid, null_ptid))
4289 tp = find_thread_ptid (inferior_ptid);
4293 for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
4295 decref_counted_command_line (&bs->commands);
4297 if (bs->old_val != NULL)
4299 value_free (bs->old_val);
4305 /* Called when a command is about to proceed the inferior. */
4308 breakpoint_about_to_proceed (void)
4310 if (!ptid_equal (inferior_ptid, null_ptid))
4312 struct thread_info *tp = inferior_thread ();
4314 /* Allow inferior function calls in breakpoint commands to not
4315 interrupt the command list. When the call finishes
4316 successfully, the inferior will be standing at the same
4317 breakpoint as if nothing happened. */
4318 if (tp->control.in_infcall)
4322 breakpoint_proceeded = 1;
4325 /* Stub for cleaning up our state if we error-out of a breakpoint
4328 cleanup_executing_breakpoints (void *ignore)
4330 executing_breakpoint_commands = 0;
4333 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4334 or its equivalent. */
4337 command_line_is_silent (struct command_line *cmd)
4339 return cmd && (strcmp ("silent", cmd->line) == 0
4340 || (xdb_commands && strcmp ("Q", cmd->line) == 0));
4343 /* Execute all the commands associated with all the breakpoints at
4344 this location. Any of these commands could cause the process to
4345 proceed beyond this point, etc. We look out for such changes by
4346 checking the global "breakpoint_proceeded" after each command.
4348 Returns true if a breakpoint command resumed the inferior. In that
4349 case, it is the caller's responsibility to recall it again with the
4350 bpstat of the current thread. */
4353 bpstat_do_actions_1 (bpstat *bsp)
4356 struct cleanup *old_chain;
4359 /* Avoid endless recursion if a `source' command is contained
4361 if (executing_breakpoint_commands)
4364 executing_breakpoint_commands = 1;
4365 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
4367 prevent_dont_repeat ();
4369 /* This pointer will iterate over the list of bpstat's. */
4372 breakpoint_proceeded = 0;
4373 for (; bs != NULL; bs = bs->next)
4375 struct counted_command_line *ccmd;
4376 struct command_line *cmd;
4377 struct cleanup *this_cmd_tree_chain;
4379 /* Take ownership of the BSP's command tree, if it has one.
4381 The command tree could legitimately contain commands like
4382 'step' and 'next', which call clear_proceed_status, which
4383 frees stop_bpstat's command tree. To make sure this doesn't
4384 free the tree we're executing out from under us, we need to
4385 take ownership of the tree ourselves. Since a given bpstat's
4386 commands are only executed once, we don't need to copy it; we
4387 can clear the pointer in the bpstat, and make sure we free
4388 the tree when we're done. */
4389 ccmd = bs->commands;
4390 bs->commands = NULL;
4391 this_cmd_tree_chain = make_cleanup_decref_counted_command_line (&ccmd);
4392 cmd = ccmd ? ccmd->commands : NULL;
4393 if (command_line_is_silent (cmd))
4395 /* The action has been already done by bpstat_stop_status. */
4401 execute_control_command (cmd);
4403 if (breakpoint_proceeded)
4409 /* We can free this command tree now. */
4410 do_cleanups (this_cmd_tree_chain);
4412 if (breakpoint_proceeded)
4414 if (target_can_async_p ())
4415 /* If we are in async mode, then the target might be still
4416 running, not stopped at any breakpoint, so nothing for
4417 us to do here -- just return to the event loop. */
4420 /* In sync mode, when execute_control_command returns
4421 we're already standing on the next breakpoint.
4422 Breakpoint commands for that stop were not run, since
4423 execute_command does not run breakpoint commands --
4424 only command_line_handler does, but that one is not
4425 involved in execution of breakpoint commands. So, we
4426 can now execute breakpoint commands. It should be
4427 noted that making execute_command do bpstat actions is
4428 not an option -- in this case we'll have recursive
4429 invocation of bpstat for each breakpoint with a
4430 command, and can easily blow up GDB stack. Instead, we
4431 return true, which will trigger the caller to recall us
4432 with the new stop_bpstat. */
4437 do_cleanups (old_chain);
4442 bpstat_do_actions (void)
4444 struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
4446 /* Do any commands attached to breakpoint we are stopped at. */
4447 while (!ptid_equal (inferior_ptid, null_ptid)
4448 && target_has_execution
4449 && !is_exited (inferior_ptid)
4450 && !is_executing (inferior_ptid))
4451 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4452 and only return when it is stopped at the next breakpoint, we
4453 keep doing breakpoint actions until it returns false to
4454 indicate the inferior was not resumed. */
4455 if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
4458 discard_cleanups (cleanup_if_error);
4461 /* Print out the (old or new) value associated with a watchpoint. */
4464 watchpoint_value_print (struct value *val, struct ui_file *stream)
4467 fprintf_unfiltered (stream, _("<unreadable>"));
4470 struct value_print_options opts;
4471 get_user_print_options (&opts);
4472 value_print (val, stream, &opts);
4476 /* Generic routine for printing messages indicating why we
4477 stopped. The behavior of this function depends on the value
4478 'print_it' in the bpstat structure. Under some circumstances we
4479 may decide not to print anything here and delegate the task to
4482 static enum print_stop_action
4483 print_bp_stop_message (bpstat bs)
4485 switch (bs->print_it)
4488 /* Nothing should be printed for this bpstat entry. */
4489 return PRINT_UNKNOWN;
4493 /* We still want to print the frame, but we already printed the
4494 relevant messages. */
4495 return PRINT_SRC_AND_LOC;
4498 case print_it_normal:
4500 struct breakpoint *b = bs->breakpoint_at;
4502 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4503 which has since been deleted. */
4505 return PRINT_UNKNOWN;
4507 /* Normal case. Call the breakpoint's print_it method. */
4508 return b->ops->print_it (bs);
4513 internal_error (__FILE__, __LINE__,
4514 _("print_bp_stop_message: unrecognized enum value"));
4519 /* A helper function that prints a shared library stopped event. */
4522 print_solib_event (int is_catchpoint)
4525 = !VEC_empty (char_ptr, current_program_space->deleted_solibs);
4527 = !VEC_empty (so_list_ptr, current_program_space->added_solibs);
4531 if (any_added || any_deleted)
4532 ui_out_text (current_uiout,
4533 _("Stopped due to shared library event:\n"));
4535 ui_out_text (current_uiout,
4536 _("Stopped due to shared library event (no "
4537 "libraries added or removed)\n"));
4540 if (ui_out_is_mi_like_p (current_uiout))
4541 ui_out_field_string (current_uiout, "reason",
4542 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
4546 struct cleanup *cleanup;
4550 ui_out_text (current_uiout, _(" Inferior unloaded "));
4551 cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
4554 VEC_iterate (char_ptr, current_program_space->deleted_solibs,
4559 ui_out_text (current_uiout, " ");
4560 ui_out_field_string (current_uiout, "library", name);
4561 ui_out_text (current_uiout, "\n");
4564 do_cleanups (cleanup);
4569 struct so_list *iter;
4571 struct cleanup *cleanup;
4573 ui_out_text (current_uiout, _(" Inferior loaded "));
4574 cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
4577 VEC_iterate (so_list_ptr, current_program_space->added_solibs,
4582 ui_out_text (current_uiout, " ");
4583 ui_out_field_string (current_uiout, "library", iter->so_name);
4584 ui_out_text (current_uiout, "\n");
4587 do_cleanups (cleanup);
4591 /* Print a message indicating what happened. This is called from
4592 normal_stop(). The input to this routine is the head of the bpstat
4593 list - a list of the eventpoints that caused this stop. KIND is
4594 the target_waitkind for the stopping event. This
4595 routine calls the generic print routine for printing a message
4596 about reasons for stopping. This will print (for example) the
4597 "Breakpoint n," part of the output. The return value of this
4600 PRINT_UNKNOWN: Means we printed nothing.
4601 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4602 code to print the location. An example is
4603 "Breakpoint 1, " which should be followed by
4605 PRINT_SRC_ONLY: Means we printed something, but there is no need
4606 to also print the location part of the message.
4607 An example is the catch/throw messages, which
4608 don't require a location appended to the end.
4609 PRINT_NOTHING: We have done some printing and we don't need any
4610 further info to be printed. */
4612 enum print_stop_action
4613 bpstat_print (bpstat bs, int kind)
4617 /* Maybe another breakpoint in the chain caused us to stop.
4618 (Currently all watchpoints go on the bpstat whether hit or not.
4619 That probably could (should) be changed, provided care is taken
4620 with respect to bpstat_explains_signal). */
4621 for (; bs; bs = bs->next)
4623 val = print_bp_stop_message (bs);
4624 if (val == PRINT_SRC_ONLY
4625 || val == PRINT_SRC_AND_LOC
4626 || val == PRINT_NOTHING)
4630 /* If we had hit a shared library event breakpoint,
4631 print_bp_stop_message would print out this message. If we hit an
4632 OS-level shared library event, do the same thing. */
4633 if (kind == TARGET_WAITKIND_LOADED)
4635 print_solib_event (0);
4636 return PRINT_NOTHING;
4639 /* We reached the end of the chain, or we got a null BS to start
4640 with and nothing was printed. */
4641 return PRINT_UNKNOWN;
4644 /* Evaluate the expression EXP and return 1 if value is zero. This is
4645 used inside a catch_errors to evaluate the breakpoint condition.
4646 The argument is a "struct expression *" that has been cast to a
4647 "char *" to make it pass through catch_errors. */
4650 breakpoint_cond_eval (void *exp)
4652 struct value *mark = value_mark ();
4653 int i = !value_true (evaluate_expression ((struct expression *) exp));
4655 value_free_to_mark (mark);
4659 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4662 bpstat_alloc (struct bp_location *bl, bpstat **bs_link_pointer)
4666 bs = (bpstat) xmalloc (sizeof (*bs));
4668 **bs_link_pointer = bs;
4669 *bs_link_pointer = &bs->next;
4670 bs->breakpoint_at = bl->owner;
4671 bs->bp_location_at = bl;
4672 incref_bp_location (bl);
4673 /* If the condition is false, etc., don't do the commands. */
4674 bs->commands = NULL;
4676 bs->print_it = print_it_normal;
4680 /* The target has stopped with waitstatus WS. Check if any hardware
4681 watchpoints have triggered, according to the target. */
4684 watchpoints_triggered (struct target_waitstatus *ws)
4686 int stopped_by_watchpoint = target_stopped_by_watchpoint ();
4688 struct breakpoint *b;
4690 if (!stopped_by_watchpoint)
4692 /* We were not stopped by a watchpoint. Mark all watchpoints
4693 as not triggered. */
4695 if (is_hardware_watchpoint (b))
4697 struct watchpoint *w = (struct watchpoint *) b;
4699 w->watchpoint_triggered = watch_triggered_no;
4705 if (!target_stopped_data_address (¤t_target, &addr))
4707 /* We were stopped by a watchpoint, but we don't know where.
4708 Mark all watchpoints as unknown. */
4710 if (is_hardware_watchpoint (b))
4712 struct watchpoint *w = (struct watchpoint *) b;
4714 w->watchpoint_triggered = watch_triggered_unknown;
4720 /* The target could report the data address. Mark watchpoints
4721 affected by this data address as triggered, and all others as not
4725 if (is_hardware_watchpoint (b))
4727 struct watchpoint *w = (struct watchpoint *) b;
4728 struct bp_location *loc;
4730 w->watchpoint_triggered = watch_triggered_no;
4731 for (loc = b->loc; loc; loc = loc->next)
4733 if (is_masked_watchpoint (b))
4735 CORE_ADDR newaddr = addr & w->hw_wp_mask;
4736 CORE_ADDR start = loc->address & w->hw_wp_mask;
4738 if (newaddr == start)
4740 w->watchpoint_triggered = watch_triggered_yes;
4744 /* Exact match not required. Within range is sufficient. */
4745 else if (target_watchpoint_addr_within_range (¤t_target,
4749 w->watchpoint_triggered = watch_triggered_yes;
4758 /* Possible return values for watchpoint_check (this can't be an enum
4759 because of check_errors). */
4760 /* The watchpoint has been deleted. */
4761 #define WP_DELETED 1
4762 /* The value has changed. */
4763 #define WP_VALUE_CHANGED 2
4764 /* The value has not changed. */
4765 #define WP_VALUE_NOT_CHANGED 3
4766 /* Ignore this watchpoint, no matter if the value changed or not. */
4769 #define BP_TEMPFLAG 1
4770 #define BP_HARDWAREFLAG 2
4772 /* Evaluate watchpoint condition expression and check if its value
4775 P should be a pointer to struct bpstat, but is defined as a void *
4776 in order for this function to be usable with catch_errors. */
4779 watchpoint_check (void *p)
4781 bpstat bs = (bpstat) p;
4782 struct watchpoint *b;
4783 struct frame_info *fr;
4784 int within_current_scope;
4786 /* BS is built from an existing struct breakpoint. */
4787 gdb_assert (bs->breakpoint_at != NULL);
4788 b = (struct watchpoint *) bs->breakpoint_at;
4790 /* If this is a local watchpoint, we only want to check if the
4791 watchpoint frame is in scope if the current thread is the thread
4792 that was used to create the watchpoint. */
4793 if (!watchpoint_in_thread_scope (b))
4796 if (b->exp_valid_block == NULL)
4797 within_current_scope = 1;
4800 struct frame_info *frame = get_current_frame ();
4801 struct gdbarch *frame_arch = get_frame_arch (frame);
4802 CORE_ADDR frame_pc = get_frame_pc (frame);
4804 /* in_function_epilogue_p() returns a non-zero value if we're
4805 still in the function but the stack frame has already been
4806 invalidated. Since we can't rely on the values of local
4807 variables after the stack has been destroyed, we are treating
4808 the watchpoint in that state as `not changed' without further
4809 checking. Don't mark watchpoints as changed if the current
4810 frame is in an epilogue - even if they are in some other
4811 frame, our view of the stack is likely to be wrong and
4812 frame_find_by_id could error out. */
4813 if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
4816 fr = frame_find_by_id (b->watchpoint_frame);
4817 within_current_scope = (fr != NULL);
4819 /* If we've gotten confused in the unwinder, we might have
4820 returned a frame that can't describe this variable. */
4821 if (within_current_scope)
4823 struct symbol *function;
4825 function = get_frame_function (fr);
4826 if (function == NULL
4827 || !contained_in (b->exp_valid_block,
4828 SYMBOL_BLOCK_VALUE (function)))
4829 within_current_scope = 0;
4832 if (within_current_scope)
4833 /* If we end up stopping, the current frame will get selected
4834 in normal_stop. So this call to select_frame won't affect
4839 if (within_current_scope)
4841 /* We use value_{,free_to_}mark because it could be a *long*
4842 time before we return to the command level and call
4843 free_all_values. We can't call free_all_values because we
4844 might be in the middle of evaluating a function call. */
4848 struct value *new_val;
4850 if (is_masked_watchpoint (&b->base))
4851 /* Since we don't know the exact trigger address (from
4852 stopped_data_address), just tell the user we've triggered
4853 a mask watchpoint. */
4854 return WP_VALUE_CHANGED;
4856 mark = value_mark ();
4857 fetch_subexp_value (b->exp, &pc, &new_val, NULL, NULL, 0);
4859 /* We use value_equal_contents instead of value_equal because
4860 the latter coerces an array to a pointer, thus comparing just
4861 the address of the array instead of its contents. This is
4862 not what we want. */
4863 if ((b->val != NULL) != (new_val != NULL)
4864 || (b->val != NULL && !value_equal_contents (b->val, new_val)))
4866 if (new_val != NULL)
4868 release_value (new_val);
4869 value_free_to_mark (mark);
4871 bs->old_val = b->val;
4874 return WP_VALUE_CHANGED;
4878 /* Nothing changed. */
4879 value_free_to_mark (mark);
4880 return WP_VALUE_NOT_CHANGED;
4885 struct ui_out *uiout = current_uiout;
4887 /* This seems like the only logical thing to do because
4888 if we temporarily ignored the watchpoint, then when
4889 we reenter the block in which it is valid it contains
4890 garbage (in the case of a function, it may have two
4891 garbage values, one before and one after the prologue).
4892 So we can't even detect the first assignment to it and
4893 watch after that (since the garbage may or may not equal
4894 the first value assigned). */
4895 /* We print all the stop information in
4896 breakpoint_ops->print_it, but in this case, by the time we
4897 call breakpoint_ops->print_it this bp will be deleted
4898 already. So we have no choice but print the information
4900 if (ui_out_is_mi_like_p (uiout))
4902 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
4903 ui_out_text (uiout, "\nWatchpoint ");
4904 ui_out_field_int (uiout, "wpnum", b->base.number);
4906 " deleted because the program has left the block in\n\
4907 which its expression is valid.\n");
4909 /* Make sure the watchpoint's commands aren't executed. */
4910 decref_counted_command_line (&b->base.commands);
4911 watchpoint_del_at_next_stop (b);
4917 /* Return true if it looks like target has stopped due to hitting
4918 breakpoint location BL. This function does not check if we should
4919 stop, only if BL explains the stop. */
4922 bpstat_check_location (const struct bp_location *bl,
4923 struct address_space *aspace, CORE_ADDR bp_addr,
4924 const struct target_waitstatus *ws)
4926 struct breakpoint *b = bl->owner;
4928 /* BL is from an existing breakpoint. */
4929 gdb_assert (b != NULL);
4931 return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
4934 /* Determine if the watched values have actually changed, and we
4935 should stop. If not, set BS->stop to 0. */
4938 bpstat_check_watchpoint (bpstat bs)
4940 const struct bp_location *bl;
4941 struct watchpoint *b;
4943 /* BS is built for existing struct breakpoint. */
4944 bl = bs->bp_location_at;
4945 gdb_assert (bl != NULL);
4946 b = (struct watchpoint *) bs->breakpoint_at;
4947 gdb_assert (b != NULL);
4950 int must_check_value = 0;
4952 if (b->base.type == bp_watchpoint)
4953 /* For a software watchpoint, we must always check the
4955 must_check_value = 1;
4956 else if (b->watchpoint_triggered == watch_triggered_yes)
4957 /* We have a hardware watchpoint (read, write, or access)
4958 and the target earlier reported an address watched by
4960 must_check_value = 1;
4961 else if (b->watchpoint_triggered == watch_triggered_unknown
4962 && b->base.type == bp_hardware_watchpoint)
4963 /* We were stopped by a hardware watchpoint, but the target could
4964 not report the data address. We must check the watchpoint's
4965 value. Access and read watchpoints are out of luck; without
4966 a data address, we can't figure it out. */
4967 must_check_value = 1;
4969 if (must_check_value)
4972 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
4974 struct cleanup *cleanups = make_cleanup (xfree, message);
4975 int e = catch_errors (watchpoint_check, bs, message,
4977 do_cleanups (cleanups);
4981 /* We've already printed what needs to be printed. */
4982 bs->print_it = print_it_done;
4986 bs->print_it = print_it_noop;
4989 case WP_VALUE_CHANGED:
4990 if (b->base.type == bp_read_watchpoint)
4992 /* There are two cases to consider here:
4994 1. We're watching the triggered memory for reads.
4995 In that case, trust the target, and always report
4996 the watchpoint hit to the user. Even though
4997 reads don't cause value changes, the value may
4998 have changed since the last time it was read, and
4999 since we're not trapping writes, we will not see
5000 those, and as such we should ignore our notion of
5003 2. We're watching the triggered memory for both
5004 reads and writes. There are two ways this may
5007 2.1. This is a target that can't break on data
5008 reads only, but can break on accesses (reads or
5009 writes), such as e.g., x86. We detect this case
5010 at the time we try to insert read watchpoints.
5012 2.2. Otherwise, the target supports read
5013 watchpoints, but, the user set an access or write
5014 watchpoint watching the same memory as this read
5017 If we're watching memory writes as well as reads,
5018 ignore watchpoint hits when we find that the
5019 value hasn't changed, as reads don't cause
5020 changes. This still gives false positives when
5021 the program writes the same value to memory as
5022 what there was already in memory (we will confuse
5023 it for a read), but it's much better than
5026 int other_write_watchpoint = 0;
5028 if (bl->watchpoint_type == hw_read)
5030 struct breakpoint *other_b;
5032 ALL_BREAKPOINTS (other_b)
5033 if (other_b->type == bp_hardware_watchpoint
5034 || other_b->type == bp_access_watchpoint)
5036 struct watchpoint *other_w =
5037 (struct watchpoint *) other_b;
5039 if (other_w->watchpoint_triggered
5040 == watch_triggered_yes)
5042 other_write_watchpoint = 1;
5048 if (other_write_watchpoint
5049 || bl->watchpoint_type == hw_access)
5051 /* We're watching the same memory for writes,
5052 and the value changed since the last time we
5053 updated it, so this trap must be for a write.
5055 bs->print_it = print_it_noop;
5060 case WP_VALUE_NOT_CHANGED:
5061 if (b->base.type == bp_hardware_watchpoint
5062 || b->base.type == bp_watchpoint)
5064 /* Don't stop: write watchpoints shouldn't fire if
5065 the value hasn't changed. */
5066 bs->print_it = print_it_noop;
5074 /* Error from catch_errors. */
5075 printf_filtered (_("Watchpoint %d deleted.\n"), b->base.number);
5076 watchpoint_del_at_next_stop (b);
5077 /* We've already printed what needs to be printed. */
5078 bs->print_it = print_it_done;
5082 else /* must_check_value == 0 */
5084 /* This is a case where some watchpoint(s) triggered, but
5085 not at the address of this watchpoint, or else no
5086 watchpoint triggered after all. So don't print
5087 anything for this watchpoint. */
5088 bs->print_it = print_it_noop;
5095 /* Check conditions (condition proper, frame, thread and ignore count)
5096 of breakpoint referred to by BS. If we should not stop for this
5097 breakpoint, set BS->stop to 0. */
5100 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
5102 int thread_id = pid_to_thread_id (ptid);
5103 const struct bp_location *bl;
5104 struct breakpoint *b;
5106 /* BS is built for existing struct breakpoint. */
5107 bl = bs->bp_location_at;
5108 gdb_assert (bl != NULL);
5109 b = bs->breakpoint_at;
5110 gdb_assert (b != NULL);
5112 /* Even if the target evaluated the condition on its end and notified GDB, we
5113 need to do so again since GDB does not know if we stopped due to a
5114 breakpoint or a single step breakpoint. */
5116 if (frame_id_p (b->frame_id)
5117 && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
5121 int value_is_zero = 0;
5122 struct expression *cond;
5124 /* Evaluate Python breakpoints that have a "stop"
5125 method implemented. */
5126 if (b->py_bp_object)
5127 bs->stop = gdbpy_should_stop (b->py_bp_object);
5129 if (is_watchpoint (b))
5131 struct watchpoint *w = (struct watchpoint *) b;
5138 if (cond && b->disposition != disp_del_at_next_stop)
5140 int within_current_scope = 1;
5141 struct watchpoint * w;
5143 /* We use value_mark and value_free_to_mark because it could
5144 be a long time before we return to the command level and
5145 call free_all_values. We can't call free_all_values
5146 because we might be in the middle of evaluating a
5148 struct value *mark = value_mark ();
5150 if (is_watchpoint (b))
5151 w = (struct watchpoint *) b;
5155 /* Need to select the frame, with all that implies so that
5156 the conditions will have the right context. Because we
5157 use the frame, we will not see an inlined function's
5158 variables when we arrive at a breakpoint at the start
5159 of the inlined function; the current frame will be the
5161 if (w == NULL || w->cond_exp_valid_block == NULL)
5162 select_frame (get_current_frame ());
5165 struct frame_info *frame;
5167 /* For local watchpoint expressions, which particular
5168 instance of a local is being watched matters, so we
5169 keep track of the frame to evaluate the expression
5170 in. To evaluate the condition however, it doesn't
5171 really matter which instantiation of the function
5172 where the condition makes sense triggers the
5173 watchpoint. This allows an expression like "watch
5174 global if q > 10" set in `func', catch writes to
5175 global on all threads that call `func', or catch
5176 writes on all recursive calls of `func' by a single
5177 thread. We simply always evaluate the condition in
5178 the innermost frame that's executing where it makes
5179 sense to evaluate the condition. It seems
5181 frame = block_innermost_frame (w->cond_exp_valid_block);
5183 select_frame (frame);
5185 within_current_scope = 0;
5187 if (within_current_scope)
5189 = catch_errors (breakpoint_cond_eval, cond,
5190 "Error in testing breakpoint condition:\n",
5194 warning (_("Watchpoint condition cannot be tested "
5195 "in the current scope"));
5196 /* If we failed to set the right context for this
5197 watchpoint, unconditionally report it. */
5200 /* FIXME-someday, should give breakpoint #. */
5201 value_free_to_mark (mark);
5204 if (cond && value_is_zero)
5208 else if (b->thread != -1 && b->thread != thread_id)
5212 else if (b->ignore_count > 0)
5216 /* Increase the hit count even though we don't stop. */
5218 observer_notify_breakpoint_modified (b);
5224 /* Get a bpstat associated with having just stopped at address
5225 BP_ADDR in thread PTID.
5227 Determine whether we stopped at a breakpoint, etc, or whether we
5228 don't understand this stop. Result is a chain of bpstat's such
5231 if we don't understand the stop, the result is a null pointer.
5233 if we understand why we stopped, the result is not null.
5235 Each element of the chain refers to a particular breakpoint or
5236 watchpoint at which we have stopped. (We may have stopped for
5237 several reasons concurrently.)
5239 Each element of the chain has valid next, breakpoint_at,
5240 commands, FIXME??? fields. */
5243 bpstat_stop_status (struct address_space *aspace,
5244 CORE_ADDR bp_addr, ptid_t ptid,
5245 const struct target_waitstatus *ws)
5247 struct breakpoint *b = NULL;
5248 struct bp_location *bl;
5249 struct bp_location *loc;
5250 /* First item of allocated bpstat's. */
5251 bpstat bs_head = NULL, *bs_link = &bs_head;
5252 /* Pointer to the last thing in the chain currently. */
5255 int need_remove_insert;
5258 /* First, build the bpstat chain with locations that explain a
5259 target stop, while being careful to not set the target running,
5260 as that may invalidate locations (in particular watchpoint
5261 locations are recreated). Resuming will happen here with
5262 breakpoint conditions or watchpoint expressions that include
5263 inferior function calls. */
5267 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
5270 for (bl = b->loc; bl != NULL; bl = bl->next)
5272 /* For hardware watchpoints, we look only at the first
5273 location. The watchpoint_check function will work on the
5274 entire expression, not the individual locations. For
5275 read watchpoints, the watchpoints_triggered function has
5276 checked all locations already. */
5277 if (b->type == bp_hardware_watchpoint && bl != b->loc)
5280 if (!bl->enabled || bl->shlib_disabled)
5283 if (!bpstat_check_location (bl, aspace, bp_addr, ws))
5286 /* Come here if it's a watchpoint, or if the break address
5289 bs = bpstat_alloc (bl, &bs_link); /* Alloc a bpstat to
5292 /* Assume we stop. Should we find a watchpoint that is not
5293 actually triggered, or if the condition of the breakpoint
5294 evaluates as false, we'll reset 'stop' to 0. */
5298 /* If this is a scope breakpoint, mark the associated
5299 watchpoint as triggered so that we will handle the
5300 out-of-scope event. We'll get to the watchpoint next
5302 if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
5304 struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5306 w->watchpoint_triggered = watch_triggered_yes;
5311 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
5313 if (breakpoint_location_address_match (loc, aspace, bp_addr))
5315 bs = bpstat_alloc (loc, &bs_link);
5316 /* For hits of moribund locations, we should just proceed. */
5319 bs->print_it = print_it_noop;
5323 /* A bit of special processing for shlib breakpoints. We need to
5324 process solib loading here, so that the lists of loaded and
5325 unloaded libraries are correct before we handle "catch load" and
5327 for (bs = bs_head; bs != NULL; bs = bs->next)
5329 if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
5331 handle_solib_event ();
5336 /* Now go through the locations that caused the target to stop, and
5337 check whether we're interested in reporting this stop to higher
5338 layers, or whether we should resume the target transparently. */
5342 for (bs = bs_head; bs != NULL; bs = bs->next)
5347 b = bs->breakpoint_at;
5348 b->ops->check_status (bs);
5351 bpstat_check_breakpoint_conditions (bs, ptid);
5356 observer_notify_breakpoint_modified (b);
5358 /* We will stop here. */
5359 if (b->disposition == disp_disable)
5361 --(b->enable_count);
5362 if (b->enable_count <= 0
5363 && b->enable_state != bp_permanent)
5364 b->enable_state = bp_disabled;
5369 bs->commands = b->commands;
5370 incref_counted_command_line (bs->commands);
5371 if (command_line_is_silent (bs->commands
5372 ? bs->commands->commands : NULL))
5375 b->ops->after_condition_true (bs);
5380 /* Print nothing for this entry if we don't stop or don't
5382 if (!bs->stop || !bs->print)
5383 bs->print_it = print_it_noop;
5386 /* If we aren't stopping, the value of some hardware watchpoint may
5387 not have changed, but the intermediate memory locations we are
5388 watching may have. Don't bother if we're stopping; this will get
5390 need_remove_insert = 0;
5391 if (! bpstat_causes_stop (bs_head))
5392 for (bs = bs_head; bs != NULL; bs = bs->next)
5394 && bs->breakpoint_at
5395 && is_hardware_watchpoint (bs->breakpoint_at))
5397 struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5399 update_watchpoint (w, 0 /* don't reparse. */);
5400 need_remove_insert = 1;
5403 if (need_remove_insert)
5404 update_global_location_list (1);
5405 else if (removed_any)
5406 update_global_location_list (0);
5412 handle_jit_event (void)
5414 struct frame_info *frame;
5415 struct gdbarch *gdbarch;
5417 /* Switch terminal for any messages produced by
5418 breakpoint_re_set. */
5419 target_terminal_ours_for_output ();
5421 frame = get_current_frame ();
5422 gdbarch = get_frame_arch (frame);
5424 jit_event_handler (gdbarch);
5426 target_terminal_inferior ();
5429 /* Prepare WHAT final decision for infrun. */
5431 /* Decide what infrun needs to do with this bpstat. */
5434 bpstat_what (bpstat bs_head)
5436 struct bpstat_what retval;
5440 retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
5441 retval.call_dummy = STOP_NONE;
5442 retval.is_longjmp = 0;
5444 for (bs = bs_head; bs != NULL; bs = bs->next)
5446 /* Extract this BS's action. After processing each BS, we check
5447 if its action overrides all we've seem so far. */
5448 enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5451 if (bs->breakpoint_at == NULL)
5453 /* I suspect this can happen if it was a momentary
5454 breakpoint which has since been deleted. */
5458 bptype = bs->breakpoint_at->type;
5465 case bp_hardware_breakpoint:
5468 case bp_shlib_event:
5472 this_action = BPSTAT_WHAT_STOP_NOISY;
5474 this_action = BPSTAT_WHAT_STOP_SILENT;
5477 this_action = BPSTAT_WHAT_SINGLE;
5480 case bp_hardware_watchpoint:
5481 case bp_read_watchpoint:
5482 case bp_access_watchpoint:
5486 this_action = BPSTAT_WHAT_STOP_NOISY;
5488 this_action = BPSTAT_WHAT_STOP_SILENT;
5492 /* There was a watchpoint, but we're not stopping.
5493 This requires no further action. */
5497 case bp_longjmp_call_dummy:
5499 this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5500 retval.is_longjmp = bptype != bp_exception;
5502 case bp_longjmp_resume:
5503 case bp_exception_resume:
5504 this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5505 retval.is_longjmp = bptype == bp_longjmp_resume;
5507 case bp_step_resume:
5509 this_action = BPSTAT_WHAT_STEP_RESUME;
5512 /* It is for the wrong frame. */
5513 this_action = BPSTAT_WHAT_SINGLE;
5516 case bp_hp_step_resume:
5518 this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5521 /* It is for the wrong frame. */
5522 this_action = BPSTAT_WHAT_SINGLE;
5525 case bp_watchpoint_scope:
5526 case bp_thread_event:
5527 case bp_overlay_event:
5528 case bp_longjmp_master:
5529 case bp_std_terminate_master:
5530 case bp_exception_master:
5531 this_action = BPSTAT_WHAT_SINGLE;
5537 this_action = BPSTAT_WHAT_STOP_NOISY;
5539 this_action = BPSTAT_WHAT_STOP_SILENT;
5543 /* There was a catchpoint, but we're not stopping.
5544 This requires no further action. */
5549 this_action = BPSTAT_WHAT_SINGLE;
5552 /* Make sure the action is stop (silent or noisy),
5553 so infrun.c pops the dummy frame. */
5554 retval.call_dummy = STOP_STACK_DUMMY;
5555 this_action = BPSTAT_WHAT_STOP_SILENT;
5557 case bp_std_terminate:
5558 /* Make sure the action is stop (silent or noisy),
5559 so infrun.c pops the dummy frame. */
5560 retval.call_dummy = STOP_STD_TERMINATE;
5561 this_action = BPSTAT_WHAT_STOP_SILENT;
5564 case bp_fast_tracepoint:
5565 case bp_static_tracepoint:
5566 /* Tracepoint hits should not be reported back to GDB, and
5567 if one got through somehow, it should have been filtered
5569 internal_error (__FILE__, __LINE__,
5570 _("bpstat_what: tracepoint encountered"));
5572 case bp_gnu_ifunc_resolver:
5573 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5574 this_action = BPSTAT_WHAT_SINGLE;
5576 case bp_gnu_ifunc_resolver_return:
5577 /* The breakpoint will be removed, execution will restart from the
5578 PC of the former breakpoint. */
5579 this_action = BPSTAT_WHAT_KEEP_CHECKING;
5584 this_action = BPSTAT_WHAT_STOP_SILENT;
5586 this_action = BPSTAT_WHAT_SINGLE;
5590 internal_error (__FILE__, __LINE__,
5591 _("bpstat_what: unhandled bptype %d"), (int) bptype);
5594 retval.main_action = max (retval.main_action, this_action);
5597 /* These operations may affect the bs->breakpoint_at state so they are
5598 delayed after MAIN_ACTION is decided above. */
5603 fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_jit_event\n");
5605 handle_jit_event ();
5608 for (bs = bs_head; bs != NULL; bs = bs->next)
5610 struct breakpoint *b = bs->breakpoint_at;
5616 case bp_gnu_ifunc_resolver:
5617 gnu_ifunc_resolver_stop (b);
5619 case bp_gnu_ifunc_resolver_return:
5620 gnu_ifunc_resolver_return_stop (b);
5628 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5629 without hardware support). This isn't related to a specific bpstat,
5630 just to things like whether watchpoints are set. */
5633 bpstat_should_step (void)
5635 struct breakpoint *b;
5638 if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
5644 bpstat_causes_stop (bpstat bs)
5646 for (; bs != NULL; bs = bs->next)
5655 /* Compute a string of spaces suitable to indent the next line
5656 so it starts at the position corresponding to the table column
5657 named COL_NAME in the currently active table of UIOUT. */
5660 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
5662 static char wrap_indent[80];
5663 int i, total_width, width, align;
5667 for (i = 1; ui_out_query_field (uiout, i, &width, &align, &text); i++)
5669 if (strcmp (text, col_name) == 0)
5671 gdb_assert (total_width < sizeof wrap_indent);
5672 memset (wrap_indent, ' ', total_width);
5673 wrap_indent[total_width] = 0;
5678 total_width += width + 1;
5684 /* Determine if the locations of this breakpoint will have their conditions
5685 evaluated by the target, host or a mix of both. Returns the following:
5687 "host": Host evals condition.
5688 "host or target": Host or Target evals condition.
5689 "target": Target evals condition.
5693 bp_condition_evaluator (struct breakpoint *b)
5695 struct bp_location *bl;
5696 char host_evals = 0;
5697 char target_evals = 0;
5702 if (!is_breakpoint (b))
5705 if (gdb_evaluates_breakpoint_condition_p ()
5706 || !target_supports_evaluation_of_breakpoint_conditions ())
5707 return condition_evaluation_host;
5709 for (bl = b->loc; bl; bl = bl->next)
5711 if (bl->cond_bytecode)
5717 if (host_evals && target_evals)
5718 return condition_evaluation_both;
5719 else if (target_evals)
5720 return condition_evaluation_target;
5722 return condition_evaluation_host;
5725 /* Determine the breakpoint location's condition evaluator. This is
5726 similar to bp_condition_evaluator, but for locations. */
5729 bp_location_condition_evaluator (struct bp_location *bl)
5731 if (bl && !is_breakpoint (bl->owner))
5734 if (gdb_evaluates_breakpoint_condition_p ()
5735 || !target_supports_evaluation_of_breakpoint_conditions ())
5736 return condition_evaluation_host;
5738 if (bl && bl->cond_bytecode)
5739 return condition_evaluation_target;
5741 return condition_evaluation_host;
5744 /* Print the LOC location out of the list of B->LOC locations. */
5747 print_breakpoint_location (struct breakpoint *b,
5748 struct bp_location *loc)
5750 struct ui_out *uiout = current_uiout;
5751 struct cleanup *old_chain = save_current_program_space ();
5753 if (loc != NULL && loc->shlib_disabled)
5757 set_current_program_space (loc->pspace);
5759 if (b->display_canonical)
5760 ui_out_field_string (uiout, "what", b->addr_string);
5761 else if (loc && loc->symtab)
5764 = find_pc_sect_function (loc->address, loc->section);
5767 ui_out_text (uiout, "in ");
5768 ui_out_field_string (uiout, "func",
5769 SYMBOL_PRINT_NAME (sym));
5770 ui_out_text (uiout, " ");
5771 ui_out_wrap_hint (uiout, wrap_indent_at_field (uiout, "what"));
5772 ui_out_text (uiout, "at ");
5774 ui_out_field_string (uiout, "file",
5775 symtab_to_filename_for_display (loc->symtab));
5776 ui_out_text (uiout, ":");
5778 if (ui_out_is_mi_like_p (uiout))
5779 ui_out_field_string (uiout, "fullname",
5780 symtab_to_fullname (loc->symtab));
5782 ui_out_field_int (uiout, "line", loc->line_number);
5786 struct ui_file *stb = mem_fileopen ();
5787 struct cleanup *stb_chain = make_cleanup_ui_file_delete (stb);
5789 print_address_symbolic (loc->gdbarch, loc->address, stb,
5791 ui_out_field_stream (uiout, "at", stb);
5793 do_cleanups (stb_chain);
5796 ui_out_field_string (uiout, "pending", b->addr_string);
5798 if (loc && is_breakpoint (b)
5799 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5800 && bp_condition_evaluator (b) == condition_evaluation_both)
5802 ui_out_text (uiout, " (");
5803 ui_out_field_string (uiout, "evaluated-by",
5804 bp_location_condition_evaluator (loc));
5805 ui_out_text (uiout, ")");
5808 do_cleanups (old_chain);
5812 bptype_string (enum bptype type)
5814 struct ep_type_description
5819 static struct ep_type_description bptypes[] =
5821 {bp_none, "?deleted?"},
5822 {bp_breakpoint, "breakpoint"},
5823 {bp_hardware_breakpoint, "hw breakpoint"},
5824 {bp_until, "until"},
5825 {bp_finish, "finish"},
5826 {bp_watchpoint, "watchpoint"},
5827 {bp_hardware_watchpoint, "hw watchpoint"},
5828 {bp_read_watchpoint, "read watchpoint"},
5829 {bp_access_watchpoint, "acc watchpoint"},
5830 {bp_longjmp, "longjmp"},
5831 {bp_longjmp_resume, "longjmp resume"},
5832 {bp_longjmp_call_dummy, "longjmp for call dummy"},
5833 {bp_exception, "exception"},
5834 {bp_exception_resume, "exception resume"},
5835 {bp_step_resume, "step resume"},
5836 {bp_hp_step_resume, "high-priority step resume"},
5837 {bp_watchpoint_scope, "watchpoint scope"},
5838 {bp_call_dummy, "call dummy"},
5839 {bp_std_terminate, "std::terminate"},
5840 {bp_shlib_event, "shlib events"},
5841 {bp_thread_event, "thread events"},
5842 {bp_overlay_event, "overlay events"},
5843 {bp_longjmp_master, "longjmp master"},
5844 {bp_std_terminate_master, "std::terminate master"},
5845 {bp_exception_master, "exception master"},
5846 {bp_catchpoint, "catchpoint"},
5847 {bp_tracepoint, "tracepoint"},
5848 {bp_fast_tracepoint, "fast tracepoint"},
5849 {bp_static_tracepoint, "static tracepoint"},
5850 {bp_dprintf, "dprintf"},
5851 {bp_jit_event, "jit events"},
5852 {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
5853 {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
5856 if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
5857 || ((int) type != bptypes[(int) type].type))
5858 internal_error (__FILE__, __LINE__,
5859 _("bptypes table does not describe type #%d."),
5862 return bptypes[(int) type].description;
5865 /* For MI, output a field named 'thread-groups' with a list as the value.
5866 For CLI, prefix the list with the string 'inf'. */
5869 output_thread_groups (struct ui_out *uiout,
5870 const char *field_name,
5874 struct cleanup *back_to;
5875 int is_mi = ui_out_is_mi_like_p (uiout);
5879 /* For backward compatibility, don't display inferiors in CLI unless
5880 there are several. Always display them for MI. */
5881 if (!is_mi && mi_only)
5884 back_to = make_cleanup_ui_out_list_begin_end (uiout, field_name);
5886 for (i = 0; VEC_iterate (int, inf_num, i, inf); ++i)
5892 xsnprintf (mi_group, sizeof (mi_group), "i%d", inf);
5893 ui_out_field_string (uiout, NULL, mi_group);
5898 ui_out_text (uiout, " inf ");
5900 ui_out_text (uiout, ", ");
5902 ui_out_text (uiout, plongest (inf));
5906 do_cleanups (back_to);
5909 /* Print B to gdb_stdout. */
5912 print_one_breakpoint_location (struct breakpoint *b,
5913 struct bp_location *loc,
5915 struct bp_location **last_loc,
5918 struct command_line *l;
5919 static char bpenables[] = "nynny";
5921 struct ui_out *uiout = current_uiout;
5922 int header_of_multiple = 0;
5923 int part_of_multiple = (loc != NULL);
5924 struct value_print_options opts;
5926 get_user_print_options (&opts);
5928 gdb_assert (!loc || loc_number != 0);
5929 /* See comment in print_one_breakpoint concerning treatment of
5930 breakpoints with single disabled location. */
5933 && (b->loc->next != NULL || !b->loc->enabled)))
5934 header_of_multiple = 1;
5942 if (part_of_multiple)
5945 formatted = xstrprintf ("%d.%d", b->number, loc_number);
5946 ui_out_field_string (uiout, "number", formatted);
5951 ui_out_field_int (uiout, "number", b->number);
5956 if (part_of_multiple)
5957 ui_out_field_skip (uiout, "type");
5959 ui_out_field_string (uiout, "type", bptype_string (b->type));
5963 if (part_of_multiple)
5964 ui_out_field_skip (uiout, "disp");
5966 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
5971 if (part_of_multiple)
5972 ui_out_field_string (uiout, "enabled", loc->enabled ? "y" : "n");
5974 ui_out_field_fmt (uiout, "enabled", "%c",
5975 bpenables[(int) b->enable_state]);
5976 ui_out_spaces (uiout, 2);
5980 if (b->ops != NULL && b->ops->print_one != NULL)
5982 /* Although the print_one can possibly print all locations,
5983 calling it here is not likely to get any nice result. So,
5984 make sure there's just one location. */
5985 gdb_assert (b->loc == NULL || b->loc->next == NULL);
5986 b->ops->print_one (b, last_loc);
5992 internal_error (__FILE__, __LINE__,
5993 _("print_one_breakpoint: bp_none encountered\n"));
5997 case bp_hardware_watchpoint:
5998 case bp_read_watchpoint:
5999 case bp_access_watchpoint:
6001 struct watchpoint *w = (struct watchpoint *) b;
6003 /* Field 4, the address, is omitted (which makes the columns
6004 not line up too nicely with the headers, but the effect
6005 is relatively readable). */
6006 if (opts.addressprint)
6007 ui_out_field_skip (uiout, "addr");
6009 ui_out_field_string (uiout, "what", w->exp_string);
6014 case bp_hardware_breakpoint:
6018 case bp_longjmp_resume:
6019 case bp_longjmp_call_dummy:
6021 case bp_exception_resume:
6022 case bp_step_resume:
6023 case bp_hp_step_resume:
6024 case bp_watchpoint_scope:
6026 case bp_std_terminate:
6027 case bp_shlib_event:
6028 case bp_thread_event:
6029 case bp_overlay_event:
6030 case bp_longjmp_master:
6031 case bp_std_terminate_master:
6032 case bp_exception_master:
6034 case bp_fast_tracepoint:
6035 case bp_static_tracepoint:
6038 case bp_gnu_ifunc_resolver:
6039 case bp_gnu_ifunc_resolver_return:
6040 if (opts.addressprint)
6043 if (header_of_multiple)
6044 ui_out_field_string (uiout, "addr", "<MULTIPLE>");
6045 else if (b->loc == NULL || loc->shlib_disabled)
6046 ui_out_field_string (uiout, "addr", "<PENDING>");
6048 ui_out_field_core_addr (uiout, "addr",
6049 loc->gdbarch, loc->address);
6052 if (!header_of_multiple)
6053 print_breakpoint_location (b, loc);
6060 if (loc != NULL && !header_of_multiple)
6062 struct inferior *inf;
6063 VEC(int) *inf_num = NULL;
6068 if (inf->pspace == loc->pspace)
6069 VEC_safe_push (int, inf_num, inf->num);
6072 /* For backward compatibility, don't display inferiors in CLI unless
6073 there are several. Always display for MI. */
6075 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6076 && (number_of_program_spaces () > 1
6077 || number_of_inferiors () > 1)
6078 /* LOC is for existing B, it cannot be in
6079 moribund_locations and thus having NULL OWNER. */
6080 && loc->owner->type != bp_catchpoint))
6082 output_thread_groups (uiout, "thread-groups", inf_num, mi_only);
6083 VEC_free (int, inf_num);
6086 if (!part_of_multiple)
6088 if (b->thread != -1)
6090 /* FIXME: This seems to be redundant and lost here; see the
6091 "stop only in" line a little further down. */
6092 ui_out_text (uiout, " thread ");
6093 ui_out_field_int (uiout, "thread", b->thread);
6095 else if (b->task != 0)
6097 ui_out_text (uiout, " task ");
6098 ui_out_field_int (uiout, "task", b->task);
6102 ui_out_text (uiout, "\n");
6104 if (!part_of_multiple)
6105 b->ops->print_one_detail (b, uiout);
6107 if (part_of_multiple && frame_id_p (b->frame_id))
6110 ui_out_text (uiout, "\tstop only in stack frame at ");
6111 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6113 ui_out_field_core_addr (uiout, "frame",
6114 b->gdbarch, b->frame_id.stack_addr);
6115 ui_out_text (uiout, "\n");
6118 if (!part_of_multiple && b->cond_string)
6121 if (is_tracepoint (b))
6122 ui_out_text (uiout, "\ttrace only if ");
6124 ui_out_text (uiout, "\tstop only if ");
6125 ui_out_field_string (uiout, "cond", b->cond_string);
6127 /* Print whether the target is doing the breakpoint's condition
6128 evaluation. If GDB is doing the evaluation, don't print anything. */
6129 if (is_breakpoint (b)
6130 && breakpoint_condition_evaluation_mode ()
6131 == condition_evaluation_target)
6133 ui_out_text (uiout, " (");
6134 ui_out_field_string (uiout, "evaluated-by",
6135 bp_condition_evaluator (b));
6136 ui_out_text (uiout, " evals)");
6138 ui_out_text (uiout, "\n");
6141 if (!part_of_multiple && b->thread != -1)
6143 /* FIXME should make an annotation for this. */
6144 ui_out_text (uiout, "\tstop only in thread ");
6145 ui_out_field_int (uiout, "thread", b->thread);
6146 ui_out_text (uiout, "\n");
6149 if (!part_of_multiple)
6153 /* FIXME should make an annotation for this. */
6154 if (is_catchpoint (b))
6155 ui_out_text (uiout, "\tcatchpoint");
6156 else if (is_tracepoint (b))
6157 ui_out_text (uiout, "\ttracepoint");
6159 ui_out_text (uiout, "\tbreakpoint");
6160 ui_out_text (uiout, " already hit ");
6161 ui_out_field_int (uiout, "times", b->hit_count);
6162 if (b->hit_count == 1)
6163 ui_out_text (uiout, " time\n");
6165 ui_out_text (uiout, " times\n");
6169 /* Output the count also if it is zero, but only if this is mi. */
6170 if (ui_out_is_mi_like_p (uiout))
6171 ui_out_field_int (uiout, "times", b->hit_count);
6175 if (!part_of_multiple && b->ignore_count)
6178 ui_out_text (uiout, "\tignore next ");
6179 ui_out_field_int (uiout, "ignore", b->ignore_count);
6180 ui_out_text (uiout, " hits\n");
6183 /* Note that an enable count of 1 corresponds to "enable once"
6184 behavior, which is reported by the combination of enablement and
6185 disposition, so we don't need to mention it here. */
6186 if (!part_of_multiple && b->enable_count > 1)
6189 ui_out_text (uiout, "\tdisable after ");
6190 /* Tweak the wording to clarify that ignore and enable counts
6191 are distinct, and have additive effect. */
6192 if (b->ignore_count)
6193 ui_out_text (uiout, "additional ");
6195 ui_out_text (uiout, "next ");
6196 ui_out_field_int (uiout, "enable", b->enable_count);
6197 ui_out_text (uiout, " hits\n");
6200 if (!part_of_multiple && is_tracepoint (b))
6202 struct tracepoint *tp = (struct tracepoint *) b;
6204 if (tp->traceframe_usage)
6206 ui_out_text (uiout, "\ttrace buffer usage ");
6207 ui_out_field_int (uiout, "traceframe-usage", tp->traceframe_usage);
6208 ui_out_text (uiout, " bytes\n");
6212 l = b->commands ? b->commands->commands : NULL;
6213 if (!part_of_multiple && l)
6215 struct cleanup *script_chain;
6218 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
6219 print_command_lines (uiout, l, 4);
6220 do_cleanups (script_chain);
6223 if (is_tracepoint (b))
6225 struct tracepoint *t = (struct tracepoint *) b;
6227 if (!part_of_multiple && t->pass_count)
6229 annotate_field (10);
6230 ui_out_text (uiout, "\tpass count ");
6231 ui_out_field_int (uiout, "pass", t->pass_count);
6232 ui_out_text (uiout, " \n");
6235 /* Don't display it when tracepoint or tracepoint location is
6237 if (!header_of_multiple && loc != NULL && !loc->shlib_disabled)
6239 annotate_field (11);
6241 if (ui_out_is_mi_like_p (uiout))
6242 ui_out_field_string (uiout, "installed",
6243 loc->inserted ? "y" : "n");
6247 ui_out_text (uiout, "\t");
6249 ui_out_text (uiout, "\tnot ");
6250 ui_out_text (uiout, "installed on target\n");
6255 if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
6257 if (is_watchpoint (b))
6259 struct watchpoint *w = (struct watchpoint *) b;
6261 ui_out_field_string (uiout, "original-location", w->exp_string);
6263 else if (b->addr_string)
6264 ui_out_field_string (uiout, "original-location", b->addr_string);
6269 print_one_breakpoint (struct breakpoint *b,
6270 struct bp_location **last_loc,
6273 struct cleanup *bkpt_chain;
6274 struct ui_out *uiout = current_uiout;
6276 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
6278 print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
6279 do_cleanups (bkpt_chain);
6281 /* If this breakpoint has custom print function,
6282 it's already printed. Otherwise, print individual
6283 locations, if any. */
6284 if (b->ops == NULL || b->ops->print_one == NULL)
6286 /* If breakpoint has a single location that is disabled, we
6287 print it as if it had several locations, since otherwise it's
6288 hard to represent "breakpoint enabled, location disabled"
6291 Note that while hardware watchpoints have several locations
6292 internally, that's not a property exposed to user. */
6294 && !is_hardware_watchpoint (b)
6295 && (b->loc->next || !b->loc->enabled))
6297 struct bp_location *loc;
6300 for (loc = b->loc; loc; loc = loc->next, ++n)
6302 struct cleanup *inner2 =
6303 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
6304 print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6305 do_cleanups (inner2);
6312 breakpoint_address_bits (struct breakpoint *b)
6314 int print_address_bits = 0;
6315 struct bp_location *loc;
6317 for (loc = b->loc; loc; loc = loc->next)
6321 /* Software watchpoints that aren't watching memory don't have
6322 an address to print. */
6323 if (b->type == bp_watchpoint && loc->watchpoint_type == -1)
6326 addr_bit = gdbarch_addr_bit (loc->gdbarch);
6327 if (addr_bit > print_address_bits)
6328 print_address_bits = addr_bit;
6331 return print_address_bits;
6334 struct captured_breakpoint_query_args
6340 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
6342 struct captured_breakpoint_query_args *args = data;
6343 struct breakpoint *b;
6344 struct bp_location *dummy_loc = NULL;
6348 if (args->bnum == b->number)
6350 print_one_breakpoint (b, &dummy_loc, 0);
6358 gdb_breakpoint_query (struct ui_out *uiout, int bnum,
6359 char **error_message)
6361 struct captured_breakpoint_query_args args;
6364 /* For the moment we don't trust print_one_breakpoint() to not throw
6366 if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
6367 error_message, RETURN_MASK_ALL) < 0)
6373 /* Return true if this breakpoint was set by the user, false if it is
6374 internal or momentary. */
6377 user_breakpoint_p (struct breakpoint *b)
6379 return b->number > 0;
6382 /* Print information on user settable breakpoint (watchpoint, etc)
6383 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6384 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6385 FILTER is non-NULL, call it on each breakpoint and only include the
6386 ones for which it returns non-zero. Return the total number of
6387 breakpoints listed. */
6390 breakpoint_1 (char *args, int allflag,
6391 int (*filter) (const struct breakpoint *))
6393 struct breakpoint *b;
6394 struct bp_location *last_loc = NULL;
6395 int nr_printable_breakpoints;
6396 struct cleanup *bkpttbl_chain;
6397 struct value_print_options opts;
6398 int print_address_bits = 0;
6399 int print_type_col_width = 14;
6400 struct ui_out *uiout = current_uiout;
6402 get_user_print_options (&opts);
6404 /* Compute the number of rows in the table, as well as the size
6405 required for address fields. */
6406 nr_printable_breakpoints = 0;
6409 /* If we have a filter, only list the breakpoints it accepts. */
6410 if (filter && !filter (b))
6413 /* If we have an "args" string, it is a list of breakpoints to
6414 accept. Skip the others. */
6415 if (args != NULL && *args != '\0')
6417 if (allflag && parse_and_eval_long (args) != b->number)
6419 if (!allflag && !number_is_in_list (args, b->number))
6423 if (allflag || user_breakpoint_p (b))
6425 int addr_bit, type_len;
6427 addr_bit = breakpoint_address_bits (b);
6428 if (addr_bit > print_address_bits)
6429 print_address_bits = addr_bit;
6431 type_len = strlen (bptype_string (b->type));
6432 if (type_len > print_type_col_width)
6433 print_type_col_width = type_len;
6435 nr_printable_breakpoints++;
6439 if (opts.addressprint)
6441 = make_cleanup_ui_out_table_begin_end (uiout, 6,
6442 nr_printable_breakpoints,
6446 = make_cleanup_ui_out_table_begin_end (uiout, 5,
6447 nr_printable_breakpoints,
6450 if (nr_printable_breakpoints > 0)
6451 annotate_breakpoints_headers ();
6452 if (nr_printable_breakpoints > 0)
6454 ui_out_table_header (uiout, 7, ui_left, "number", "Num"); /* 1 */
6455 if (nr_printable_breakpoints > 0)
6457 ui_out_table_header (uiout, print_type_col_width, ui_left,
6458 "type", "Type"); /* 2 */
6459 if (nr_printable_breakpoints > 0)
6461 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
6462 if (nr_printable_breakpoints > 0)
6464 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
6465 if (opts.addressprint)
6467 if (nr_printable_breakpoints > 0)
6469 if (print_address_bits <= 32)
6470 ui_out_table_header (uiout, 10, ui_left,
6471 "addr", "Address"); /* 5 */
6473 ui_out_table_header (uiout, 18, ui_left,
6474 "addr", "Address"); /* 5 */
6476 if (nr_printable_breakpoints > 0)
6478 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
6479 ui_out_table_body (uiout);
6480 if (nr_printable_breakpoints > 0)
6481 annotate_breakpoints_table ();
6486 /* If we have a filter, only list the breakpoints it accepts. */
6487 if (filter && !filter (b))
6490 /* If we have an "args" string, it is a list of breakpoints to
6491 accept. Skip the others. */
6493 if (args != NULL && *args != '\0')
6495 if (allflag) /* maintenance info breakpoint */
6497 if (parse_and_eval_long (args) != b->number)
6500 else /* all others */
6502 if (!number_is_in_list (args, b->number))
6506 /* We only print out user settable breakpoints unless the
6508 if (allflag || user_breakpoint_p (b))
6509 print_one_breakpoint (b, &last_loc, allflag);
6512 do_cleanups (bkpttbl_chain);
6514 if (nr_printable_breakpoints == 0)
6516 /* If there's a filter, let the caller decide how to report
6520 if (args == NULL || *args == '\0')
6521 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
6523 ui_out_message (uiout, 0,
6524 "No breakpoint or watchpoint matching '%s'.\n",
6530 if (last_loc && !server_command)
6531 set_next_address (last_loc->gdbarch, last_loc->address);
6534 /* FIXME? Should this be moved up so that it is only called when
6535 there have been breakpoints? */
6536 annotate_breakpoints_table_end ();
6538 return nr_printable_breakpoints;
6541 /* Display the value of default-collect in a way that is generally
6542 compatible with the breakpoint list. */
6545 default_collect_info (void)
6547 struct ui_out *uiout = current_uiout;
6549 /* If it has no value (which is frequently the case), say nothing; a
6550 message like "No default-collect." gets in user's face when it's
6552 if (!*default_collect)
6555 /* The following phrase lines up nicely with per-tracepoint collect
6557 ui_out_text (uiout, "default collect ");
6558 ui_out_field_string (uiout, "default-collect", default_collect);
6559 ui_out_text (uiout, " \n");
6563 breakpoints_info (char *args, int from_tty)
6565 breakpoint_1 (args, 0, NULL);
6567 default_collect_info ();
6571 watchpoints_info (char *args, int from_tty)
6573 int num_printed = breakpoint_1 (args, 0, is_watchpoint);
6574 struct ui_out *uiout = current_uiout;
6576 if (num_printed == 0)
6578 if (args == NULL || *args == '\0')
6579 ui_out_message (uiout, 0, "No watchpoints.\n");
6581 ui_out_message (uiout, 0, "No watchpoint matching '%s'.\n", args);
6586 maintenance_info_breakpoints (char *args, int from_tty)
6588 breakpoint_1 (args, 1, NULL);
6590 default_collect_info ();
6594 breakpoint_has_pc (struct breakpoint *b,
6595 struct program_space *pspace,
6596 CORE_ADDR pc, struct obj_section *section)
6598 struct bp_location *bl = b->loc;
6600 for (; bl; bl = bl->next)
6602 if (bl->pspace == pspace
6603 && bl->address == pc
6604 && (!overlay_debugging || bl->section == section))
6610 /* Print a message describing any user-breakpoints set at PC. This
6611 concerns with logical breakpoints, so we match program spaces, not
6615 describe_other_breakpoints (struct gdbarch *gdbarch,
6616 struct program_space *pspace, CORE_ADDR pc,
6617 struct obj_section *section, int thread)
6620 struct breakpoint *b;
6623 others += (user_breakpoint_p (b)
6624 && breakpoint_has_pc (b, pspace, pc, section));
6628 printf_filtered (_("Note: breakpoint "));
6629 else /* if (others == ???) */
6630 printf_filtered (_("Note: breakpoints "));
6632 if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
6635 printf_filtered ("%d", b->number);
6636 if (b->thread == -1 && thread != -1)
6637 printf_filtered (" (all threads)");
6638 else if (b->thread != -1)
6639 printf_filtered (" (thread %d)", b->thread);
6640 printf_filtered ("%s%s ",
6641 ((b->enable_state == bp_disabled
6642 || b->enable_state == bp_call_disabled)
6644 : b->enable_state == bp_permanent
6648 : ((others == 1) ? " and" : ""));
6650 printf_filtered (_("also set at pc "));
6651 fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
6652 printf_filtered (".\n");
6657 /* Return true iff it is meaningful to use the address member of
6658 BPT. For some breakpoint types, the address member is irrelevant
6659 and it makes no sense to attempt to compare it to other addresses
6660 (or use it for any other purpose either).
6662 More specifically, each of the following breakpoint types will
6663 always have a zero valued address and we don't want to mark
6664 breakpoints of any of these types to be a duplicate of an actual
6665 breakpoint at address zero:
6673 breakpoint_address_is_meaningful (struct breakpoint *bpt)
6675 enum bptype type = bpt->type;
6677 return (type != bp_watchpoint && type != bp_catchpoint);
6680 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6681 true if LOC1 and LOC2 represent the same watchpoint location. */
6684 watchpoint_locations_match (struct bp_location *loc1,
6685 struct bp_location *loc2)
6687 struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
6688 struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
6690 /* Both of them must exist. */
6691 gdb_assert (w1 != NULL);
6692 gdb_assert (w2 != NULL);
6694 /* If the target can evaluate the condition expression in hardware,
6695 then we we need to insert both watchpoints even if they are at
6696 the same place. Otherwise the watchpoint will only trigger when
6697 the condition of whichever watchpoint was inserted evaluates to
6698 true, not giving a chance for GDB to check the condition of the
6699 other watchpoint. */
6701 && target_can_accel_watchpoint_condition (loc1->address,
6703 loc1->watchpoint_type,
6706 && target_can_accel_watchpoint_condition (loc2->address,
6708 loc2->watchpoint_type,
6712 /* Note that this checks the owner's type, not the location's. In
6713 case the target does not support read watchpoints, but does
6714 support access watchpoints, we'll have bp_read_watchpoint
6715 watchpoints with hw_access locations. Those should be considered
6716 duplicates of hw_read locations. The hw_read locations will
6717 become hw_access locations later. */
6718 return (loc1->owner->type == loc2->owner->type
6719 && loc1->pspace->aspace == loc2->pspace->aspace
6720 && loc1->address == loc2->address
6721 && loc1->length == loc2->length);
6724 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
6725 same breakpoint location. In most targets, this can only be true
6726 if ASPACE1 matches ASPACE2. On targets that have global
6727 breakpoints, the address space doesn't really matter. */
6730 breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
6731 struct address_space *aspace2, CORE_ADDR addr2)
6733 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6734 || aspace1 == aspace2)
6738 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6739 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6740 matches ASPACE2. On targets that have global breakpoints, the address
6741 space doesn't really matter. */
6744 breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
6745 int len1, struct address_space *aspace2,
6748 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6749 || aspace1 == aspace2)
6750 && addr2 >= addr1 && addr2 < addr1 + len1);
6753 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6754 a ranged breakpoint. In most targets, a match happens only if ASPACE
6755 matches the breakpoint's address space. On targets that have global
6756 breakpoints, the address space doesn't really matter. */
6759 breakpoint_location_address_match (struct bp_location *bl,
6760 struct address_space *aspace,
6763 return (breakpoint_address_match (bl->pspace->aspace, bl->address,
6766 && breakpoint_address_match_range (bl->pspace->aspace,
6767 bl->address, bl->length,
6771 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6772 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6773 true, otherwise returns false. */
6776 tracepoint_locations_match (struct bp_location *loc1,
6777 struct bp_location *loc2)
6779 if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
6780 /* Since tracepoint locations are never duplicated with others', tracepoint
6781 locations at the same address of different tracepoints are regarded as
6782 different locations. */
6783 return (loc1->address == loc2->address && loc1->owner == loc2->owner);
6788 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6789 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6790 represent the same location. */
6793 breakpoint_locations_match (struct bp_location *loc1,
6794 struct bp_location *loc2)
6796 int hw_point1, hw_point2;
6798 /* Both of them must not be in moribund_locations. */
6799 gdb_assert (loc1->owner != NULL);
6800 gdb_assert (loc2->owner != NULL);
6802 hw_point1 = is_hardware_watchpoint (loc1->owner);
6803 hw_point2 = is_hardware_watchpoint (loc2->owner);
6805 if (hw_point1 != hw_point2)
6808 return watchpoint_locations_match (loc1, loc2);
6809 else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
6810 return tracepoint_locations_match (loc1, loc2);
6812 /* We compare bp_location.length in order to cover ranged breakpoints. */
6813 return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
6814 loc2->pspace->aspace, loc2->address)
6815 && loc1->length == loc2->length);
6819 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
6820 int bnum, int have_bnum)
6822 /* The longest string possibly returned by hex_string_custom
6823 is 50 chars. These must be at least that big for safety. */
6827 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
6828 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
6830 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6831 bnum, astr1, astr2);
6833 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
6836 /* Adjust a breakpoint's address to account for architectural
6837 constraints on breakpoint placement. Return the adjusted address.
6838 Note: Very few targets require this kind of adjustment. For most
6839 targets, this function is simply the identity function. */
6842 adjust_breakpoint_address (struct gdbarch *gdbarch,
6843 CORE_ADDR bpaddr, enum bptype bptype)
6845 if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
6847 /* Very few targets need any kind of breakpoint adjustment. */
6850 else if (bptype == bp_watchpoint
6851 || bptype == bp_hardware_watchpoint
6852 || bptype == bp_read_watchpoint
6853 || bptype == bp_access_watchpoint
6854 || bptype == bp_catchpoint)
6856 /* Watchpoints and the various bp_catch_* eventpoints should not
6857 have their addresses modified. */
6862 CORE_ADDR adjusted_bpaddr;
6864 /* Some targets have architectural constraints on the placement
6865 of breakpoint instructions. Obtain the adjusted address. */
6866 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
6868 /* An adjusted breakpoint address can significantly alter
6869 a user's expectations. Print a warning if an adjustment
6871 if (adjusted_bpaddr != bpaddr)
6872 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
6874 return adjusted_bpaddr;
6879 init_bp_location (struct bp_location *loc, const struct bp_location_ops *ops,
6880 struct breakpoint *owner)
6882 memset (loc, 0, sizeof (*loc));
6884 gdb_assert (ops != NULL);
6889 loc->cond_bytecode = NULL;
6890 loc->shlib_disabled = 0;
6893 switch (owner->type)
6899 case bp_longjmp_resume:
6900 case bp_longjmp_call_dummy:
6902 case bp_exception_resume:
6903 case bp_step_resume:
6904 case bp_hp_step_resume:
6905 case bp_watchpoint_scope:
6907 case bp_std_terminate:
6908 case bp_shlib_event:
6909 case bp_thread_event:
6910 case bp_overlay_event:
6912 case bp_longjmp_master:
6913 case bp_std_terminate_master:
6914 case bp_exception_master:
6915 case bp_gnu_ifunc_resolver:
6916 case bp_gnu_ifunc_resolver_return:
6918 loc->loc_type = bp_loc_software_breakpoint;
6919 mark_breakpoint_location_modified (loc);
6921 case bp_hardware_breakpoint:
6922 loc->loc_type = bp_loc_hardware_breakpoint;
6923 mark_breakpoint_location_modified (loc);
6925 case bp_hardware_watchpoint:
6926 case bp_read_watchpoint:
6927 case bp_access_watchpoint:
6928 loc->loc_type = bp_loc_hardware_watchpoint;
6933 case bp_fast_tracepoint:
6934 case bp_static_tracepoint:
6935 loc->loc_type = bp_loc_other;
6938 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
6944 /* Allocate a struct bp_location. */
6946 static struct bp_location *
6947 allocate_bp_location (struct breakpoint *bpt)
6949 return bpt->ops->allocate_location (bpt);
6953 free_bp_location (struct bp_location *loc)
6955 loc->ops->dtor (loc);
6959 /* Increment reference count. */
6962 incref_bp_location (struct bp_location *bl)
6967 /* Decrement reference count. If the reference count reaches 0,
6968 destroy the bp_location. Sets *BLP to NULL. */
6971 decref_bp_location (struct bp_location **blp)
6973 gdb_assert ((*blp)->refc > 0);
6975 if (--(*blp)->refc == 0)
6976 free_bp_location (*blp);
6980 /* Add breakpoint B at the end of the global breakpoint chain. */
6983 add_to_breakpoint_chain (struct breakpoint *b)
6985 struct breakpoint *b1;
6987 /* Add this breakpoint to the end of the chain so that a list of
6988 breakpoints will come out in order of increasing numbers. */
6990 b1 = breakpoint_chain;
6992 breakpoint_chain = b;
7001 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7004 init_raw_breakpoint_without_location (struct breakpoint *b,
7005 struct gdbarch *gdbarch,
7007 const struct breakpoint_ops *ops)
7009 memset (b, 0, sizeof (*b));
7011 gdb_assert (ops != NULL);
7015 b->gdbarch = gdbarch;
7016 b->language = current_language->la_language;
7017 b->input_radix = input_radix;
7019 b->enable_state = bp_enabled;
7022 b->ignore_count = 0;
7024 b->frame_id = null_frame_id;
7025 b->condition_not_parsed = 0;
7026 b->py_bp_object = NULL;
7027 b->related_breakpoint = b;
7030 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7031 that has type BPTYPE and has no locations as yet. */
7033 static struct breakpoint *
7034 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
7036 const struct breakpoint_ops *ops)
7038 struct breakpoint *b = XNEW (struct breakpoint);
7040 init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
7041 add_to_breakpoint_chain (b);
7045 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7046 resolutions should be made as the user specified the location explicitly
7050 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
7052 gdb_assert (loc->owner != NULL);
7054 if (loc->owner->type == bp_breakpoint
7055 || loc->owner->type == bp_hardware_breakpoint
7056 || is_tracepoint (loc->owner))
7059 const char *function_name;
7060 CORE_ADDR func_addr;
7062 find_pc_partial_function_gnu_ifunc (loc->address, &function_name,
7063 &func_addr, NULL, &is_gnu_ifunc);
7065 if (is_gnu_ifunc && !explicit_loc)
7067 struct breakpoint *b = loc->owner;
7069 gdb_assert (loc->pspace == current_program_space);
7070 if (gnu_ifunc_resolve_name (function_name,
7071 &loc->requested_address))
7073 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7074 loc->address = adjust_breakpoint_address (loc->gdbarch,
7075 loc->requested_address,
7078 else if (b->type == bp_breakpoint && b->loc == loc
7079 && loc->next == NULL && b->related_breakpoint == b)
7081 /* Create only the whole new breakpoint of this type but do not
7082 mess more complicated breakpoints with multiple locations. */
7083 b->type = bp_gnu_ifunc_resolver;
7084 /* Remember the resolver's address for use by the return
7086 loc->related_address = func_addr;
7091 loc->function_name = xstrdup (function_name);
7095 /* Attempt to determine architecture of location identified by SAL. */
7097 get_sal_arch (struct symtab_and_line sal)
7100 return get_objfile_arch (sal.section->objfile);
7102 return get_objfile_arch (sal.symtab->objfile);
7107 /* Low level routine for partially initializing a breakpoint of type
7108 BPTYPE. The newly created breakpoint's address, section, source
7109 file name, and line number are provided by SAL.
7111 It is expected that the caller will complete the initialization of
7112 the newly created breakpoint struct as well as output any status
7113 information regarding the creation of a new breakpoint. */
7116 init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
7117 struct symtab_and_line sal, enum bptype bptype,
7118 const struct breakpoint_ops *ops)
7120 init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
7122 add_location_to_breakpoint (b, &sal);
7124 if (bptype != bp_catchpoint)
7125 gdb_assert (sal.pspace != NULL);
7127 /* Store the program space that was used to set the breakpoint,
7128 except for ordinary breakpoints, which are independent of the
7130 if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
7131 b->pspace = sal.pspace;
7134 /* set_raw_breakpoint is a low level routine for allocating and
7135 partially initializing a breakpoint of type BPTYPE. The newly
7136 created breakpoint's address, section, source file name, and line
7137 number are provided by SAL. The newly created and partially
7138 initialized breakpoint is added to the breakpoint chain and
7139 is also returned as the value of this function.
7141 It is expected that the caller will complete the initialization of
7142 the newly created breakpoint struct as well as output any status
7143 information regarding the creation of a new breakpoint. In
7144 particular, set_raw_breakpoint does NOT set the breakpoint
7145 number! Care should be taken to not allow an error to occur
7146 prior to completing the initialization of the breakpoint. If this
7147 should happen, a bogus breakpoint will be left on the chain. */
7150 set_raw_breakpoint (struct gdbarch *gdbarch,
7151 struct symtab_and_line sal, enum bptype bptype,
7152 const struct breakpoint_ops *ops)
7154 struct breakpoint *b = XNEW (struct breakpoint);
7156 init_raw_breakpoint (b, gdbarch, sal, bptype, ops);
7157 add_to_breakpoint_chain (b);
7162 /* Note that the breakpoint object B describes a permanent breakpoint
7163 instruction, hard-wired into the inferior's code. */
7165 make_breakpoint_permanent (struct breakpoint *b)
7167 struct bp_location *bl;
7169 b->enable_state = bp_permanent;
7171 /* By definition, permanent breakpoints are already present in the
7172 code. Mark all locations as inserted. For now,
7173 make_breakpoint_permanent is called in just one place, so it's
7174 hard to say if it's reasonable to have permanent breakpoint with
7175 multiple locations or not, but it's easy to implement. */
7176 for (bl = b->loc; bl; bl = bl->next)
7180 /* Call this routine when stepping and nexting to enable a breakpoint
7181 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7182 initiated the operation. */
7185 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
7187 struct breakpoint *b, *b_tmp;
7188 int thread = tp->num;
7190 /* To avoid having to rescan all objfile symbols at every step,
7191 we maintain a list of continually-inserted but always disabled
7192 longjmp "master" breakpoints. Here, we simply create momentary
7193 clones of those and enable them for the requested thread. */
7194 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7195 if (b->pspace == current_program_space
7196 && (b->type == bp_longjmp_master
7197 || b->type == bp_exception_master))
7199 enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7200 struct breakpoint *clone;
7202 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7203 after their removal. */
7204 clone = momentary_breakpoint_from_master (b, type,
7205 &longjmp_breakpoint_ops);
7206 clone->thread = thread;
7209 tp->initiating_frame = frame;
7212 /* Delete all longjmp breakpoints from THREAD. */
7214 delete_longjmp_breakpoint (int thread)
7216 struct breakpoint *b, *b_tmp;
7218 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7219 if (b->type == bp_longjmp || b->type == bp_exception)
7221 if (b->thread == thread)
7222 delete_breakpoint (b);
7227 delete_longjmp_breakpoint_at_next_stop (int thread)
7229 struct breakpoint *b, *b_tmp;
7231 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7232 if (b->type == bp_longjmp || b->type == bp_exception)
7234 if (b->thread == thread)
7235 b->disposition = disp_del_at_next_stop;
7239 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7240 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7241 pointer to any of them. Return NULL if this system cannot place longjmp
7245 set_longjmp_breakpoint_for_call_dummy (void)
7247 struct breakpoint *b, *retval = NULL;
7250 if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7252 struct breakpoint *new_b;
7254 new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
7255 &momentary_breakpoint_ops);
7256 new_b->thread = pid_to_thread_id (inferior_ptid);
7258 /* Link NEW_B into the chain of RETVAL breakpoints. */
7260 gdb_assert (new_b->related_breakpoint == new_b);
7263 new_b->related_breakpoint = retval;
7264 while (retval->related_breakpoint != new_b->related_breakpoint)
7265 retval = retval->related_breakpoint;
7266 retval->related_breakpoint = new_b;
7272 /* Verify all existing dummy frames and their associated breakpoints for
7273 THREAD. Remove those which can no longer be found in the current frame
7276 You should call this function only at places where it is safe to currently
7277 unwind the whole stack. Failed stack unwind would discard live dummy
7281 check_longjmp_breakpoint_for_call_dummy (int thread)
7283 struct breakpoint *b, *b_tmp;
7285 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7286 if (b->type == bp_longjmp_call_dummy && b->thread == thread)
7288 struct breakpoint *dummy_b = b->related_breakpoint;
7290 while (dummy_b != b && dummy_b->type != bp_call_dummy)
7291 dummy_b = dummy_b->related_breakpoint;
7292 if (dummy_b->type != bp_call_dummy
7293 || frame_find_by_id (dummy_b->frame_id) != NULL)
7296 dummy_frame_discard (dummy_b->frame_id);
7298 while (b->related_breakpoint != b)
7300 if (b_tmp == b->related_breakpoint)
7301 b_tmp = b->related_breakpoint->next;
7302 delete_breakpoint (b->related_breakpoint);
7304 delete_breakpoint (b);
7309 enable_overlay_breakpoints (void)
7311 struct breakpoint *b;
7314 if (b->type == bp_overlay_event)
7316 b->enable_state = bp_enabled;
7317 update_global_location_list (1);
7318 overlay_events_enabled = 1;
7323 disable_overlay_breakpoints (void)
7325 struct breakpoint *b;
7328 if (b->type == bp_overlay_event)
7330 b->enable_state = bp_disabled;
7331 update_global_location_list (0);
7332 overlay_events_enabled = 0;
7336 /* Set an active std::terminate breakpoint for each std::terminate
7337 master breakpoint. */
7339 set_std_terminate_breakpoint (void)
7341 struct breakpoint *b, *b_tmp;
7343 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7344 if (b->pspace == current_program_space
7345 && b->type == bp_std_terminate_master)
7347 momentary_breakpoint_from_master (b, bp_std_terminate,
7348 &momentary_breakpoint_ops);
7352 /* Delete all the std::terminate breakpoints. */
7354 delete_std_terminate_breakpoint (void)
7356 struct breakpoint *b, *b_tmp;
7358 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7359 if (b->type == bp_std_terminate)
7360 delete_breakpoint (b);
7364 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7366 struct breakpoint *b;
7368 b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7369 &internal_breakpoint_ops);
7371 b->enable_state = bp_enabled;
7372 /* addr_string has to be used or breakpoint_re_set will delete me. */
7374 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
7376 update_global_location_list_nothrow (1);
7382 remove_thread_event_breakpoints (void)
7384 struct breakpoint *b, *b_tmp;
7386 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7387 if (b->type == bp_thread_event
7388 && b->loc->pspace == current_program_space)
7389 delete_breakpoint (b);
7392 struct lang_and_radix
7398 /* Create a breakpoint for JIT code registration and unregistration. */
7401 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7403 struct breakpoint *b;
7405 b = create_internal_breakpoint (gdbarch, address, bp_jit_event,
7406 &internal_breakpoint_ops);
7407 update_global_location_list_nothrow (1);
7411 /* Remove JIT code registration and unregistration breakpoint(s). */
7414 remove_jit_event_breakpoints (void)
7416 struct breakpoint *b, *b_tmp;
7418 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7419 if (b->type == bp_jit_event
7420 && b->loc->pspace == current_program_space)
7421 delete_breakpoint (b);
7425 remove_solib_event_breakpoints (void)
7427 struct breakpoint *b, *b_tmp;
7429 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7430 if (b->type == bp_shlib_event
7431 && b->loc->pspace == current_program_space)
7432 delete_breakpoint (b);
7436 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7438 struct breakpoint *b;
7440 b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7441 &internal_breakpoint_ops);
7442 update_global_location_list_nothrow (1);
7446 /* Disable any breakpoints that are on code in shared libraries. Only
7447 apply to enabled breakpoints, disabled ones can just stay disabled. */
7450 disable_breakpoints_in_shlibs (void)
7452 struct bp_location *loc, **locp_tmp;
7454 ALL_BP_LOCATIONS (loc, locp_tmp)
7456 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7457 struct breakpoint *b = loc->owner;
7459 /* We apply the check to all breakpoints, including disabled for
7460 those with loc->duplicate set. This is so that when breakpoint
7461 becomes enabled, or the duplicate is removed, gdb will try to
7462 insert all breakpoints. If we don't set shlib_disabled here,
7463 we'll try to insert those breakpoints and fail. */
7464 if (((b->type == bp_breakpoint)
7465 || (b->type == bp_jit_event)
7466 || (b->type == bp_hardware_breakpoint)
7467 || (is_tracepoint (b)))
7468 && loc->pspace == current_program_space
7469 && !loc->shlib_disabled
7470 && solib_name_from_address (loc->pspace, loc->address)
7473 loc->shlib_disabled = 1;
7478 /* Disable any breakpoints and tracepoints that are in an unloaded shared
7479 library. Only apply to enabled breakpoints, disabled ones can just stay
7483 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7485 struct bp_location *loc, **locp_tmp;
7486 int disabled_shlib_breaks = 0;
7488 /* SunOS a.out shared libraries are always mapped, so do not
7489 disable breakpoints; they will only be reported as unloaded
7490 through clear_solib when GDB discards its shared library
7491 list. See clear_solib for more information. */
7492 if (exec_bfd != NULL
7493 && bfd_get_flavour (exec_bfd) == bfd_target_aout_flavour)
7496 ALL_BP_LOCATIONS (loc, locp_tmp)
7498 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7499 struct breakpoint *b = loc->owner;
7501 if (solib->pspace == loc->pspace
7502 && !loc->shlib_disabled
7503 && (((b->type == bp_breakpoint
7504 || b->type == bp_jit_event
7505 || b->type == bp_hardware_breakpoint)
7506 && (loc->loc_type == bp_loc_hardware_breakpoint
7507 || loc->loc_type == bp_loc_software_breakpoint))
7508 || is_tracepoint (b))
7509 && solib_contains_address_p (solib, loc->address))
7511 loc->shlib_disabled = 1;
7512 /* At this point, we cannot rely on remove_breakpoint
7513 succeeding so we must mark the breakpoint as not inserted
7514 to prevent future errors occurring in remove_breakpoints. */
7517 /* This may cause duplicate notifications for the same breakpoint. */
7518 observer_notify_breakpoint_modified (b);
7520 if (!disabled_shlib_breaks)
7522 target_terminal_ours_for_output ();
7523 warning (_("Temporarily disabling breakpoints "
7524 "for unloaded shared library \"%s\""),
7527 disabled_shlib_breaks = 1;
7532 /* FORK & VFORK catchpoints. */
7534 /* An instance of this type is used to represent a fork or vfork
7535 catchpoint. It includes a "struct breakpoint" as a kind of base
7536 class; users downcast to "struct breakpoint *" when needed. A
7537 breakpoint is really of this type iff its ops pointer points to
7538 CATCH_FORK_BREAKPOINT_OPS. */
7540 struct fork_catchpoint
7542 /* The base class. */
7543 struct breakpoint base;
7545 /* Process id of a child process whose forking triggered this
7546 catchpoint. This field is only valid immediately after this
7547 catchpoint has triggered. */
7548 ptid_t forked_inferior_pid;
7551 /* Implement the "insert" breakpoint_ops method for fork
7555 insert_catch_fork (struct bp_location *bl)
7557 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid));
7560 /* Implement the "remove" breakpoint_ops method for fork
7564 remove_catch_fork (struct bp_location *bl)
7566 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid));
7569 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7573 breakpoint_hit_catch_fork (const struct bp_location *bl,
7574 struct address_space *aspace, CORE_ADDR bp_addr,
7575 const struct target_waitstatus *ws)
7577 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7579 if (ws->kind != TARGET_WAITKIND_FORKED)
7582 c->forked_inferior_pid = ws->value.related_pid;
7586 /* Implement the "print_it" breakpoint_ops method for fork
7589 static enum print_stop_action
7590 print_it_catch_fork (bpstat bs)
7592 struct ui_out *uiout = current_uiout;
7593 struct breakpoint *b = bs->breakpoint_at;
7594 struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
7596 annotate_catchpoint (b->number);
7597 if (b->disposition == disp_del)
7598 ui_out_text (uiout, "\nTemporary catchpoint ");
7600 ui_out_text (uiout, "\nCatchpoint ");
7601 if (ui_out_is_mi_like_p (uiout))
7603 ui_out_field_string (uiout, "reason",
7604 async_reason_lookup (EXEC_ASYNC_FORK));
7605 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7607 ui_out_field_int (uiout, "bkptno", b->number);
7608 ui_out_text (uiout, " (forked process ");
7609 ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
7610 ui_out_text (uiout, "), ");
7611 return PRINT_SRC_AND_LOC;
7614 /* Implement the "print_one" breakpoint_ops method for fork
7618 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
7620 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7621 struct value_print_options opts;
7622 struct ui_out *uiout = current_uiout;
7624 get_user_print_options (&opts);
7626 /* Field 4, the address, is omitted (which makes the columns not
7627 line up too nicely with the headers, but the effect is relatively
7629 if (opts.addressprint)
7630 ui_out_field_skip (uiout, "addr");
7632 ui_out_text (uiout, "fork");
7633 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7635 ui_out_text (uiout, ", process ");
7636 ui_out_field_int (uiout, "what",
7637 ptid_get_pid (c->forked_inferior_pid));
7638 ui_out_spaces (uiout, 1);
7641 if (ui_out_is_mi_like_p (uiout))
7642 ui_out_field_string (uiout, "catch-type", "fork");
7645 /* Implement the "print_mention" breakpoint_ops method for fork
7649 print_mention_catch_fork (struct breakpoint *b)
7651 printf_filtered (_("Catchpoint %d (fork)"), b->number);
7654 /* Implement the "print_recreate" breakpoint_ops method for fork
7658 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
7660 fprintf_unfiltered (fp, "catch fork");
7661 print_recreate_thread (b, fp);
7664 /* The breakpoint_ops structure to be used in fork catchpoints. */
7666 static struct breakpoint_ops catch_fork_breakpoint_ops;
7668 /* Implement the "insert" breakpoint_ops method for vfork
7672 insert_catch_vfork (struct bp_location *bl)
7674 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid));
7677 /* Implement the "remove" breakpoint_ops method for vfork
7681 remove_catch_vfork (struct bp_location *bl)
7683 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid));
7686 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7690 breakpoint_hit_catch_vfork (const struct bp_location *bl,
7691 struct address_space *aspace, CORE_ADDR bp_addr,
7692 const struct target_waitstatus *ws)
7694 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7696 if (ws->kind != TARGET_WAITKIND_VFORKED)
7699 c->forked_inferior_pid = ws->value.related_pid;
7703 /* Implement the "print_it" breakpoint_ops method for vfork
7706 static enum print_stop_action
7707 print_it_catch_vfork (bpstat bs)
7709 struct ui_out *uiout = current_uiout;
7710 struct breakpoint *b = bs->breakpoint_at;
7711 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7713 annotate_catchpoint (b->number);
7714 if (b->disposition == disp_del)
7715 ui_out_text (uiout, "\nTemporary catchpoint ");
7717 ui_out_text (uiout, "\nCatchpoint ");
7718 if (ui_out_is_mi_like_p (uiout))
7720 ui_out_field_string (uiout, "reason",
7721 async_reason_lookup (EXEC_ASYNC_VFORK));
7722 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7724 ui_out_field_int (uiout, "bkptno", b->number);
7725 ui_out_text (uiout, " (vforked process ");
7726 ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
7727 ui_out_text (uiout, "), ");
7728 return PRINT_SRC_AND_LOC;
7731 /* Implement the "print_one" breakpoint_ops method for vfork
7735 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
7737 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7738 struct value_print_options opts;
7739 struct ui_out *uiout = current_uiout;
7741 get_user_print_options (&opts);
7742 /* Field 4, the address, is omitted (which makes the columns not
7743 line up too nicely with the headers, but the effect is relatively
7745 if (opts.addressprint)
7746 ui_out_field_skip (uiout, "addr");
7748 ui_out_text (uiout, "vfork");
7749 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7751 ui_out_text (uiout, ", process ");
7752 ui_out_field_int (uiout, "what",
7753 ptid_get_pid (c->forked_inferior_pid));
7754 ui_out_spaces (uiout, 1);
7757 if (ui_out_is_mi_like_p (uiout))
7758 ui_out_field_string (uiout, "catch-type", "vfork");
7761 /* Implement the "print_mention" breakpoint_ops method for vfork
7765 print_mention_catch_vfork (struct breakpoint *b)
7767 printf_filtered (_("Catchpoint %d (vfork)"), b->number);
7770 /* Implement the "print_recreate" breakpoint_ops method for vfork
7774 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
7776 fprintf_unfiltered (fp, "catch vfork");
7777 print_recreate_thread (b, fp);
7780 /* The breakpoint_ops structure to be used in vfork catchpoints. */
7782 static struct breakpoint_ops catch_vfork_breakpoint_ops;
7784 /* An instance of this type is used to represent an solib catchpoint.
7785 It includes a "struct breakpoint" as a kind of base class; users
7786 downcast to "struct breakpoint *" when needed. A breakpoint is
7787 really of this type iff its ops pointer points to
7788 CATCH_SOLIB_BREAKPOINT_OPS. */
7790 struct solib_catchpoint
7792 /* The base class. */
7793 struct breakpoint base;
7795 /* True for "catch load", false for "catch unload". */
7796 unsigned char is_load;
7798 /* Regular expression to match, if any. COMPILED is only valid when
7799 REGEX is non-NULL. */
7805 dtor_catch_solib (struct breakpoint *b)
7807 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7810 regfree (&self->compiled);
7811 xfree (self->regex);
7813 base_breakpoint_ops.dtor (b);
7817 insert_catch_solib (struct bp_location *ignore)
7823 remove_catch_solib (struct bp_location *ignore)
7829 breakpoint_hit_catch_solib (const struct bp_location *bl,
7830 struct address_space *aspace,
7832 const struct target_waitstatus *ws)
7834 struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
7835 struct breakpoint *other;
7837 if (ws->kind == TARGET_WAITKIND_LOADED)
7840 ALL_BREAKPOINTS (other)
7842 struct bp_location *other_bl;
7844 if (other == bl->owner)
7847 if (other->type != bp_shlib_event)
7850 if (self->base.pspace != NULL && other->pspace != self->base.pspace)
7853 for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
7855 if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
7864 check_status_catch_solib (struct bpstats *bs)
7866 struct solib_catchpoint *self
7867 = (struct solib_catchpoint *) bs->breakpoint_at;
7872 struct so_list *iter;
7875 VEC_iterate (so_list_ptr, current_program_space->added_solibs,
7880 || regexec (&self->compiled, iter->so_name, 0, NULL, 0) == 0)
7889 VEC_iterate (char_ptr, current_program_space->deleted_solibs,
7894 || regexec (&self->compiled, iter, 0, NULL, 0) == 0)
7900 bs->print_it = print_it_noop;
7903 static enum print_stop_action
7904 print_it_catch_solib (bpstat bs)
7906 struct breakpoint *b = bs->breakpoint_at;
7907 struct ui_out *uiout = current_uiout;
7909 annotate_catchpoint (b->number);
7910 if (b->disposition == disp_del)
7911 ui_out_text (uiout, "\nTemporary catchpoint ");
7913 ui_out_text (uiout, "\nCatchpoint ");
7914 ui_out_field_int (uiout, "bkptno", b->number);
7915 ui_out_text (uiout, "\n");
7916 if (ui_out_is_mi_like_p (uiout))
7917 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7918 print_solib_event (1);
7919 return PRINT_SRC_AND_LOC;
7923 print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
7925 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7926 struct value_print_options opts;
7927 struct ui_out *uiout = current_uiout;
7930 get_user_print_options (&opts);
7931 /* Field 4, the address, is omitted (which makes the columns not
7932 line up too nicely with the headers, but the effect is relatively
7934 if (opts.addressprint)
7937 ui_out_field_skip (uiout, "addr");
7944 msg = xstrprintf (_("load of library matching %s"), self->regex);
7946 msg = xstrdup (_("load of library"));
7951 msg = xstrprintf (_("unload of library matching %s"), self->regex);
7953 msg = xstrdup (_("unload of library"));
7955 ui_out_field_string (uiout, "what", msg);
7958 if (ui_out_is_mi_like_p (uiout))
7959 ui_out_field_string (uiout, "catch-type",
7960 self->is_load ? "load" : "unload");
7964 print_mention_catch_solib (struct breakpoint *b)
7966 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7968 printf_filtered (_("Catchpoint %d (%s)"), b->number,
7969 self->is_load ? "load" : "unload");
7973 print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
7975 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7977 fprintf_unfiltered (fp, "%s %s",
7978 b->disposition == disp_del ? "tcatch" : "catch",
7979 self->is_load ? "load" : "unload");
7981 fprintf_unfiltered (fp, " %s", self->regex);
7982 fprintf_unfiltered (fp, "\n");
7985 static struct breakpoint_ops catch_solib_breakpoint_ops;
7987 /* Shared helper function (MI and CLI) for creating and installing
7988 a shared object event catchpoint. If IS_LOAD is non-zero then
7989 the events to be caught are load events, otherwise they are
7990 unload events. If IS_TEMP is non-zero the catchpoint is a
7991 temporary one. If ENABLED is non-zero the catchpoint is
7992 created in an enabled state. */
7995 add_solib_catchpoint (char *arg, int is_load, int is_temp, int enabled)
7997 struct solib_catchpoint *c;
7998 struct gdbarch *gdbarch = get_current_arch ();
7999 struct cleanup *cleanup;
8003 arg = skip_spaces (arg);
8005 c = XCNEW (struct solib_catchpoint);
8006 cleanup = make_cleanup (xfree, c);
8012 errcode = regcomp (&c->compiled, arg, REG_NOSUB);
8015 char *err = get_regcomp_error (errcode, &c->compiled);
8017 make_cleanup (xfree, err);
8018 error (_("Invalid regexp (%s): %s"), err, arg);
8020 c->regex = xstrdup (arg);
8023 c->is_load = is_load;
8024 init_catchpoint (&c->base, gdbarch, is_temp, NULL,
8025 &catch_solib_breakpoint_ops);
8027 c->base.enable_state = enabled ? bp_enabled : bp_disabled;
8029 discard_cleanups (cleanup);
8030 install_breakpoint (0, &c->base, 1);
8033 /* A helper function that does all the work for "catch load" and
8037 catch_load_or_unload (char *arg, int from_tty, int is_load,
8038 struct cmd_list_element *command)
8041 const int enabled = 1;
8043 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8045 add_solib_catchpoint (arg, is_load, tempflag, enabled);
8049 catch_load_command_1 (char *arg, int from_tty,
8050 struct cmd_list_element *command)
8052 catch_load_or_unload (arg, from_tty, 1, command);
8056 catch_unload_command_1 (char *arg, int from_tty,
8057 struct cmd_list_element *command)
8059 catch_load_or_unload (arg, from_tty, 0, command);
8062 /* An instance of this type is used to represent a syscall catchpoint.
8063 It includes a "struct breakpoint" as a kind of base class; users
8064 downcast to "struct breakpoint *" when needed. A breakpoint is
8065 really of this type iff its ops pointer points to
8066 CATCH_SYSCALL_BREAKPOINT_OPS. */
8068 struct syscall_catchpoint
8070 /* The base class. */
8071 struct breakpoint base;
8073 /* Syscall numbers used for the 'catch syscall' feature. If no
8074 syscall has been specified for filtering, its value is NULL.
8075 Otherwise, it holds a list of all syscalls to be caught. The
8076 list elements are allocated with xmalloc. */
8077 VEC(int) *syscalls_to_be_caught;
8080 /* Implement the "dtor" breakpoint_ops method for syscall
8084 dtor_catch_syscall (struct breakpoint *b)
8086 struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8088 VEC_free (int, c->syscalls_to_be_caught);
8090 base_breakpoint_ops.dtor (b);
8093 static const struct inferior_data *catch_syscall_inferior_data = NULL;
8095 struct catch_syscall_inferior_data
8097 /* We keep a count of the number of times the user has requested a
8098 particular syscall to be tracked, and pass this information to the
8099 target. This lets capable targets implement filtering directly. */
8101 /* Number of times that "any" syscall is requested. */
8102 int any_syscall_count;
8104 /* Count of each system call. */
8105 VEC(int) *syscalls_counts;
8107 /* This counts all syscall catch requests, so we can readily determine
8108 if any catching is necessary. */
8109 int total_syscalls_count;
8112 static struct catch_syscall_inferior_data*
8113 get_catch_syscall_inferior_data (struct inferior *inf)
8115 struct catch_syscall_inferior_data *inf_data;
8117 inf_data = inferior_data (inf, catch_syscall_inferior_data);
8118 if (inf_data == NULL)
8120 inf_data = XZALLOC (struct catch_syscall_inferior_data);
8121 set_inferior_data (inf, catch_syscall_inferior_data, inf_data);
8128 catch_syscall_inferior_data_cleanup (struct inferior *inf, void *arg)
8134 /* Implement the "insert" breakpoint_ops method for syscall
8138 insert_catch_syscall (struct bp_location *bl)
8140 struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
8141 struct inferior *inf = current_inferior ();
8142 struct catch_syscall_inferior_data *inf_data
8143 = get_catch_syscall_inferior_data (inf);
8145 ++inf_data->total_syscalls_count;
8146 if (!c->syscalls_to_be_caught)
8147 ++inf_data->any_syscall_count;
8153 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8158 if (iter >= VEC_length (int, inf_data->syscalls_counts))
8160 int old_size = VEC_length (int, inf_data->syscalls_counts);
8161 uintptr_t vec_addr_offset
8162 = old_size * ((uintptr_t) sizeof (int));
8164 VEC_safe_grow (int, inf_data->syscalls_counts, iter + 1);
8165 vec_addr = ((uintptr_t) VEC_address (int,
8166 inf_data->syscalls_counts)
8168 memset ((void *) vec_addr, 0,
8169 (iter + 1 - old_size) * sizeof (int));
8171 elem = VEC_index (int, inf_data->syscalls_counts, iter);
8172 VEC_replace (int, inf_data->syscalls_counts, iter, ++elem);
8176 return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
8177 inf_data->total_syscalls_count != 0,
8178 inf_data->any_syscall_count,
8180 inf_data->syscalls_counts),
8182 inf_data->syscalls_counts));
8185 /* Implement the "remove" breakpoint_ops method for syscall
8189 remove_catch_syscall (struct bp_location *bl)
8191 struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
8192 struct inferior *inf = current_inferior ();
8193 struct catch_syscall_inferior_data *inf_data
8194 = get_catch_syscall_inferior_data (inf);
8196 --inf_data->total_syscalls_count;
8197 if (!c->syscalls_to_be_caught)
8198 --inf_data->any_syscall_count;
8204 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8208 if (iter >= VEC_length (int, inf_data->syscalls_counts))
8209 /* Shouldn't happen. */
8211 elem = VEC_index (int, inf_data->syscalls_counts, iter);
8212 VEC_replace (int, inf_data->syscalls_counts, iter, --elem);
8216 return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
8217 inf_data->total_syscalls_count != 0,
8218 inf_data->any_syscall_count,
8220 inf_data->syscalls_counts),
8222 inf_data->syscalls_counts));
8225 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
8229 breakpoint_hit_catch_syscall (const struct bp_location *bl,
8230 struct address_space *aspace, CORE_ADDR bp_addr,
8231 const struct target_waitstatus *ws)
8233 /* We must check if we are catching specific syscalls in this
8234 breakpoint. If we are, then we must guarantee that the called
8235 syscall is the same syscall we are catching. */
8236 int syscall_number = 0;
8237 const struct syscall_catchpoint *c
8238 = (const struct syscall_catchpoint *) bl->owner;
8240 if (ws->kind != TARGET_WAITKIND_SYSCALL_ENTRY
8241 && ws->kind != TARGET_WAITKIND_SYSCALL_RETURN)
8244 syscall_number = ws->value.syscall_number;
8246 /* Now, checking if the syscall is the same. */
8247 if (c->syscalls_to_be_caught)
8252 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8254 if (syscall_number == iter)
8264 /* Implement the "print_it" breakpoint_ops method for syscall
8267 static enum print_stop_action
8268 print_it_catch_syscall (bpstat bs)
8270 struct ui_out *uiout = current_uiout;
8271 struct breakpoint *b = bs->breakpoint_at;
8272 /* These are needed because we want to know in which state a
8273 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
8274 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
8275 must print "called syscall" or "returned from syscall". */
8277 struct target_waitstatus last;
8280 get_last_target_status (&ptid, &last);
8282 get_syscall_by_number (last.value.syscall_number, &s);
8284 annotate_catchpoint (b->number);
8286 if (b->disposition == disp_del)
8287 ui_out_text (uiout, "\nTemporary catchpoint ");
8289 ui_out_text (uiout, "\nCatchpoint ");
8290 if (ui_out_is_mi_like_p (uiout))
8292 ui_out_field_string (uiout, "reason",
8293 async_reason_lookup (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY
8294 ? EXEC_ASYNC_SYSCALL_ENTRY
8295 : EXEC_ASYNC_SYSCALL_RETURN));
8296 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8298 ui_out_field_int (uiout, "bkptno", b->number);
8300 if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
8301 ui_out_text (uiout, " (call to syscall ");
8303 ui_out_text (uiout, " (returned from syscall ");
8305 if (s.name == NULL || ui_out_is_mi_like_p (uiout))
8306 ui_out_field_int (uiout, "syscall-number", last.value.syscall_number);
8308 ui_out_field_string (uiout, "syscall-name", s.name);
8310 ui_out_text (uiout, "), ");
8312 return PRINT_SRC_AND_LOC;
8315 /* Implement the "print_one" breakpoint_ops method for syscall
8319 print_one_catch_syscall (struct breakpoint *b,
8320 struct bp_location **last_loc)
8322 struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8323 struct value_print_options opts;
8324 struct ui_out *uiout = current_uiout;
8326 get_user_print_options (&opts);
8327 /* Field 4, the address, is omitted (which makes the columns not
8328 line up too nicely with the headers, but the effect is relatively
8330 if (opts.addressprint)
8331 ui_out_field_skip (uiout, "addr");
8334 if (c->syscalls_to_be_caught
8335 && VEC_length (int, c->syscalls_to_be_caught) > 1)
8336 ui_out_text (uiout, "syscalls \"");
8338 ui_out_text (uiout, "syscall \"");
8340 if (c->syscalls_to_be_caught)
8343 char *text = xstrprintf ("%s", "");
8346 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8351 get_syscall_by_number (iter, &s);
8354 text = xstrprintf ("%s%s, ", text, s.name);
8356 text = xstrprintf ("%s%d, ", text, iter);
8358 /* We have to xfree the last 'text' (now stored at 'x')
8359 because xstrprintf dynamically allocates new space for it
8363 /* Remove the last comma. */
8364 text[strlen (text) - 2] = '\0';
8365 ui_out_field_string (uiout, "what", text);
8368 ui_out_field_string (uiout, "what", "<any syscall>");
8369 ui_out_text (uiout, "\" ");
8371 if (ui_out_is_mi_like_p (uiout))
8372 ui_out_field_string (uiout, "catch-type", "syscall");
8375 /* Implement the "print_mention" breakpoint_ops method for syscall
8379 print_mention_catch_syscall (struct breakpoint *b)
8381 struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8383 if (c->syscalls_to_be_caught)
8387 if (VEC_length (int, c->syscalls_to_be_caught) > 1)
8388 printf_filtered (_("Catchpoint %d (syscalls"), b->number);
8390 printf_filtered (_("Catchpoint %d (syscall"), b->number);
8393 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8397 get_syscall_by_number (iter, &s);
8400 printf_filtered (" '%s' [%d]", s.name, s.number);
8402 printf_filtered (" %d", s.number);
8404 printf_filtered (")");
8407 printf_filtered (_("Catchpoint %d (any syscall)"),
8411 /* Implement the "print_recreate" breakpoint_ops method for syscall
8415 print_recreate_catch_syscall (struct breakpoint *b, struct ui_file *fp)
8417 struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8419 fprintf_unfiltered (fp, "catch syscall");
8421 if (c->syscalls_to_be_caught)
8426 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8431 get_syscall_by_number (iter, &s);
8433 fprintf_unfiltered (fp, " %s", s.name);
8435 fprintf_unfiltered (fp, " %d", s.number);
8438 print_recreate_thread (b, fp);
8441 /* The breakpoint_ops structure to be used in syscall catchpoints. */
8443 static struct breakpoint_ops catch_syscall_breakpoint_ops;
8445 /* Returns non-zero if 'b' is a syscall catchpoint. */
8448 syscall_catchpoint_p (struct breakpoint *b)
8450 return (b->ops == &catch_syscall_breakpoint_ops);
8453 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8454 is non-zero, then make the breakpoint temporary. If COND_STRING is
8455 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8456 the breakpoint_ops structure associated to the catchpoint. */
8459 init_catchpoint (struct breakpoint *b,
8460 struct gdbarch *gdbarch, int tempflag,
8462 const struct breakpoint_ops *ops)
8464 struct symtab_and_line sal;
8467 sal.pspace = current_program_space;
8469 init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
8471 b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
8472 b->disposition = tempflag ? disp_del : disp_donttouch;
8476 install_breakpoint (int internal, struct breakpoint *b, int update_gll)
8478 add_to_breakpoint_chain (b);
8479 set_breakpoint_number (internal, b);
8480 if (is_tracepoint (b))
8481 set_tracepoint_count (breakpoint_count);
8484 observer_notify_breakpoint_created (b);
8487 update_global_location_list (1);
8491 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
8492 int tempflag, char *cond_string,
8493 const struct breakpoint_ops *ops)
8495 struct fork_catchpoint *c = XNEW (struct fork_catchpoint);
8497 init_catchpoint (&c->base, gdbarch, tempflag, cond_string, ops);
8499 c->forked_inferior_pid = null_ptid;
8501 install_breakpoint (0, &c->base, 1);
8504 /* Exec catchpoints. */
8506 /* An instance of this type is used to represent an exec catchpoint.
8507 It includes a "struct breakpoint" as a kind of base class; users
8508 downcast to "struct breakpoint *" when needed. A breakpoint is
8509 really of this type iff its ops pointer points to
8510 CATCH_EXEC_BREAKPOINT_OPS. */
8512 struct exec_catchpoint
8514 /* The base class. */
8515 struct breakpoint base;
8517 /* Filename of a program whose exec triggered this catchpoint.
8518 This field is only valid immediately after this catchpoint has
8520 char *exec_pathname;
8523 /* Implement the "dtor" breakpoint_ops method for exec
8527 dtor_catch_exec (struct breakpoint *b)
8529 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8531 xfree (c->exec_pathname);
8533 base_breakpoint_ops.dtor (b);
8537 insert_catch_exec (struct bp_location *bl)
8539 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid));
8543 remove_catch_exec (struct bp_location *bl)
8545 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid));
8549 breakpoint_hit_catch_exec (const struct bp_location *bl,
8550 struct address_space *aspace, CORE_ADDR bp_addr,
8551 const struct target_waitstatus *ws)
8553 struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8555 if (ws->kind != TARGET_WAITKIND_EXECD)
8558 c->exec_pathname = xstrdup (ws->value.execd_pathname);
8562 static enum print_stop_action
8563 print_it_catch_exec (bpstat bs)
8565 struct ui_out *uiout = current_uiout;
8566 struct breakpoint *b = bs->breakpoint_at;
8567 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8569 annotate_catchpoint (b->number);
8570 if (b->disposition == disp_del)
8571 ui_out_text (uiout, "\nTemporary catchpoint ");
8573 ui_out_text (uiout, "\nCatchpoint ");
8574 if (ui_out_is_mi_like_p (uiout))
8576 ui_out_field_string (uiout, "reason",
8577 async_reason_lookup (EXEC_ASYNC_EXEC));
8578 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8580 ui_out_field_int (uiout, "bkptno", b->number);
8581 ui_out_text (uiout, " (exec'd ");
8582 ui_out_field_string (uiout, "new-exec", c->exec_pathname);
8583 ui_out_text (uiout, "), ");
8585 return PRINT_SRC_AND_LOC;
8589 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
8591 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8592 struct value_print_options opts;
8593 struct ui_out *uiout = current_uiout;
8595 get_user_print_options (&opts);
8597 /* Field 4, the address, is omitted (which makes the columns
8598 not line up too nicely with the headers, but the effect
8599 is relatively readable). */
8600 if (opts.addressprint)
8601 ui_out_field_skip (uiout, "addr");
8603 ui_out_text (uiout, "exec");
8604 if (c->exec_pathname != NULL)
8606 ui_out_text (uiout, ", program \"");
8607 ui_out_field_string (uiout, "what", c->exec_pathname);
8608 ui_out_text (uiout, "\" ");
8611 if (ui_out_is_mi_like_p (uiout))
8612 ui_out_field_string (uiout, "catch-type", "exec");
8616 print_mention_catch_exec (struct breakpoint *b)
8618 printf_filtered (_("Catchpoint %d (exec)"), b->number);
8621 /* Implement the "print_recreate" breakpoint_ops method for exec
8625 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8627 fprintf_unfiltered (fp, "catch exec");
8628 print_recreate_thread (b, fp);
8631 static struct breakpoint_ops catch_exec_breakpoint_ops;
8634 create_syscall_event_catchpoint (int tempflag, VEC(int) *filter,
8635 const struct breakpoint_ops *ops)
8637 struct syscall_catchpoint *c;
8638 struct gdbarch *gdbarch = get_current_arch ();
8640 c = XNEW (struct syscall_catchpoint);
8641 init_catchpoint (&c->base, gdbarch, tempflag, NULL, ops);
8642 c->syscalls_to_be_caught = filter;
8644 install_breakpoint (0, &c->base, 1);
8648 hw_breakpoint_used_count (void)
8651 struct breakpoint *b;
8652 struct bp_location *bl;
8656 if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
8657 for (bl = b->loc; bl; bl = bl->next)
8659 /* Special types of hardware breakpoints may use more than
8661 i += b->ops->resources_needed (bl);
8668 /* Returns the resources B would use if it were a hardware
8672 hw_watchpoint_use_count (struct breakpoint *b)
8675 struct bp_location *bl;
8677 if (!breakpoint_enabled (b))
8680 for (bl = b->loc; bl; bl = bl->next)
8682 /* Special types of hardware watchpoints may use more than
8684 i += b->ops->resources_needed (bl);
8690 /* Returns the sum the used resources of all hardware watchpoints of
8691 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8692 the sum of the used resources of all hardware watchpoints of other
8693 types _not_ TYPE. */
8696 hw_watchpoint_used_count_others (struct breakpoint *except,
8697 enum bptype type, int *other_type_used)
8700 struct breakpoint *b;
8702 *other_type_used = 0;
8707 if (!breakpoint_enabled (b))
8710 if (b->type == type)
8711 i += hw_watchpoint_use_count (b);
8712 else if (is_hardware_watchpoint (b))
8713 *other_type_used = 1;
8720 disable_watchpoints_before_interactive_call_start (void)
8722 struct breakpoint *b;
8726 if (is_watchpoint (b) && breakpoint_enabled (b))
8728 b->enable_state = bp_call_disabled;
8729 update_global_location_list (0);
8735 enable_watchpoints_after_interactive_call_stop (void)
8737 struct breakpoint *b;
8741 if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
8743 b->enable_state = bp_enabled;
8744 update_global_location_list (1);
8750 disable_breakpoints_before_startup (void)
8752 current_program_space->executing_startup = 1;
8753 update_global_location_list (0);
8757 enable_breakpoints_after_startup (void)
8759 current_program_space->executing_startup = 0;
8760 breakpoint_re_set ();
8764 /* Set a breakpoint that will evaporate an end of command
8765 at address specified by SAL.
8766 Restrict it to frame FRAME if FRAME is nonzero. */
8769 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8770 struct frame_id frame_id, enum bptype type)
8772 struct breakpoint *b;
8774 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8776 gdb_assert (!frame_id_artificial_p (frame_id));
8778 b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
8779 b->enable_state = bp_enabled;
8780 b->disposition = disp_donttouch;
8781 b->frame_id = frame_id;
8783 /* If we're debugging a multi-threaded program, then we want
8784 momentary breakpoints to be active in only a single thread of
8786 if (in_thread_list (inferior_ptid))
8787 b->thread = pid_to_thread_id (inferior_ptid);
8789 update_global_location_list_nothrow (1);
8794 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8795 The new breakpoint will have type TYPE, and use OPS as it
8798 static struct breakpoint *
8799 momentary_breakpoint_from_master (struct breakpoint *orig,
8801 const struct breakpoint_ops *ops)
8803 struct breakpoint *copy;
8805 copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
8806 copy->loc = allocate_bp_location (copy);
8807 set_breakpoint_location_function (copy->loc, 1);
8809 copy->loc->gdbarch = orig->loc->gdbarch;
8810 copy->loc->requested_address = orig->loc->requested_address;
8811 copy->loc->address = orig->loc->address;
8812 copy->loc->section = orig->loc->section;
8813 copy->loc->pspace = orig->loc->pspace;
8814 copy->loc->probe = orig->loc->probe;
8815 copy->loc->line_number = orig->loc->line_number;
8816 copy->loc->symtab = orig->loc->symtab;
8817 copy->frame_id = orig->frame_id;
8818 copy->thread = orig->thread;
8819 copy->pspace = orig->pspace;
8821 copy->enable_state = bp_enabled;
8822 copy->disposition = disp_donttouch;
8823 copy->number = internal_breakpoint_number--;
8825 update_global_location_list_nothrow (0);
8829 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8833 clone_momentary_breakpoint (struct breakpoint *orig)
8835 /* If there's nothing to clone, then return nothing. */
8839 return momentary_breakpoint_from_master (orig, orig->type, orig->ops);
8843 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8846 struct symtab_and_line sal;
8848 sal = find_pc_line (pc, 0);
8850 sal.section = find_pc_overlay (pc);
8851 sal.explicit_pc = 1;
8853 return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
8857 /* Tell the user we have just set a breakpoint B. */
8860 mention (struct breakpoint *b)
8862 b->ops->print_mention (b);
8863 if (ui_out_is_mi_like_p (current_uiout))
8865 printf_filtered ("\n");
8869 static struct bp_location *
8870 add_location_to_breakpoint (struct breakpoint *b,
8871 const struct symtab_and_line *sal)
8873 struct bp_location *loc, **tmp;
8874 CORE_ADDR adjusted_address;
8875 struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
8877 if (loc_gdbarch == NULL)
8878 loc_gdbarch = b->gdbarch;
8880 /* Adjust the breakpoint's address prior to allocating a location.
8881 Once we call allocate_bp_location(), that mostly uninitialized
8882 location will be placed on the location chain. Adjustment of the
8883 breakpoint may cause target_read_memory() to be called and we do
8884 not want its scan of the location chain to find a breakpoint and
8885 location that's only been partially initialized. */
8886 adjusted_address = adjust_breakpoint_address (loc_gdbarch,
8889 /* Sort the locations by their ADDRESS. */
8890 loc = allocate_bp_location (b);
8891 for (tmp = &(b->loc); *tmp != NULL && (*tmp)->address <= adjusted_address;
8892 tmp = &((*tmp)->next))
8897 loc->requested_address = sal->pc;
8898 loc->address = adjusted_address;
8899 loc->pspace = sal->pspace;
8900 loc->probe = sal->probe;
8901 gdb_assert (loc->pspace != NULL);
8902 loc->section = sal->section;
8903 loc->gdbarch = loc_gdbarch;
8904 loc->line_number = sal->line;
8905 loc->symtab = sal->symtab;
8907 set_breakpoint_location_function (loc,
8908 sal->explicit_pc || sal->explicit_line);
8913 /* Return 1 if LOC is pointing to a permanent breakpoint,
8914 return 0 otherwise. */
8917 bp_loc_is_permanent (struct bp_location *loc)
8921 const gdb_byte *bpoint;
8922 gdb_byte *target_mem;
8923 struct cleanup *cleanup;
8926 gdb_assert (loc != NULL);
8928 addr = loc->address;
8929 bpoint = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
8931 /* Software breakpoints unsupported? */
8935 target_mem = alloca (len);
8937 /* Enable the automatic memory restoration from breakpoints while
8938 we read the memory. Otherwise we could say about our temporary
8939 breakpoints they are permanent. */
8940 cleanup = save_current_space_and_thread ();
8942 switch_to_program_space_and_thread (loc->pspace);
8943 make_show_memory_breakpoints_cleanup (0);
8945 if (target_read_memory (loc->address, target_mem, len) == 0
8946 && memcmp (target_mem, bpoint, len) == 0)
8949 do_cleanups (cleanup);
8954 /* Build a command list for the dprintf corresponding to the current
8955 settings of the dprintf style options. */
8958 update_dprintf_command_list (struct breakpoint *b)
8960 char *dprintf_args = b->extra_string;
8961 char *printf_line = NULL;
8966 dprintf_args = skip_spaces (dprintf_args);
8968 /* Allow a comma, as it may have terminated a location, but don't
8970 if (*dprintf_args == ',')
8972 dprintf_args = skip_spaces (dprintf_args);
8974 if (*dprintf_args != '"')
8975 error (_("Bad format string, missing '\"'."));
8977 if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
8978 printf_line = xstrprintf ("printf %s", dprintf_args);
8979 else if (strcmp (dprintf_style, dprintf_style_call) == 0)
8981 if (!dprintf_function)
8982 error (_("No function supplied for dprintf call"));
8984 if (dprintf_channel && strlen (dprintf_channel) > 0)
8985 printf_line = xstrprintf ("call (void) %s (%s,%s)",
8990 printf_line = xstrprintf ("call (void) %s (%s)",
8994 else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
8996 if (target_can_run_breakpoint_commands ())
8997 printf_line = xstrprintf ("agent-printf %s", dprintf_args);
9000 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
9001 printf_line = xstrprintf ("printf %s", dprintf_args);
9005 internal_error (__FILE__, __LINE__,
9006 _("Invalid dprintf style."));
9008 gdb_assert (printf_line != NULL);
9009 /* Manufacture a printf sequence. */
9011 struct command_line *printf_cmd_line
9012 = xmalloc (sizeof (struct command_line));
9014 printf_cmd_line = xmalloc (sizeof (struct command_line));
9015 printf_cmd_line->control_type = simple_control;
9016 printf_cmd_line->body_count = 0;
9017 printf_cmd_line->body_list = NULL;
9018 printf_cmd_line->next = NULL;
9019 printf_cmd_line->line = printf_line;
9021 breakpoint_set_commands (b, printf_cmd_line);
9025 /* Update all dprintf commands, making their command lists reflect
9026 current style settings. */
9029 update_dprintf_commands (char *args, int from_tty,
9030 struct cmd_list_element *c)
9032 struct breakpoint *b;
9036 if (b->type == bp_dprintf)
9037 update_dprintf_command_list (b);
9041 /* Create a breakpoint with SAL as location. Use ADDR_STRING
9042 as textual description of the location, and COND_STRING
9043 as condition expression. */
9046 init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
9047 struct symtabs_and_lines sals, char *addr_string,
9048 char *filter, char *cond_string,
9050 enum bptype type, enum bpdisp disposition,
9051 int thread, int task, int ignore_count,
9052 const struct breakpoint_ops *ops, int from_tty,
9053 int enabled, int internal, unsigned flags,
9054 int display_canonical)
9058 if (type == bp_hardware_breakpoint)
9060 int target_resources_ok;
9062 i = hw_breakpoint_used_count ();
9063 target_resources_ok =
9064 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
9066 if (target_resources_ok == 0)
9067 error (_("No hardware breakpoint support in the target."));
9068 else if (target_resources_ok < 0)
9069 error (_("Hardware breakpoints used exceeds limit."));
9072 gdb_assert (sals.nelts > 0);
9074 for (i = 0; i < sals.nelts; ++i)
9076 struct symtab_and_line sal = sals.sals[i];
9077 struct bp_location *loc;
9081 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
9083 loc_gdbarch = gdbarch;
9085 describe_other_breakpoints (loc_gdbarch,
9086 sal.pspace, sal.pc, sal.section, thread);
9091 init_raw_breakpoint (b, gdbarch, sal, type, ops);
9095 b->cond_string = cond_string;
9096 b->extra_string = extra_string;
9097 b->ignore_count = ignore_count;
9098 b->enable_state = enabled ? bp_enabled : bp_disabled;
9099 b->disposition = disposition;
9101 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
9102 b->loc->inserted = 1;
9104 if (type == bp_static_tracepoint)
9106 struct tracepoint *t = (struct tracepoint *) b;
9107 struct static_tracepoint_marker marker;
9109 if (strace_marker_p (b))
9111 /* We already know the marker exists, otherwise, we
9112 wouldn't see a sal for it. */
9113 char *p = &addr_string[3];
9117 p = skip_spaces (p);
9119 endp = skip_to_space (p);
9121 marker_str = savestring (p, endp - p);
9122 t->static_trace_marker_id = marker_str;
9124 printf_filtered (_("Probed static tracepoint "
9126 t->static_trace_marker_id);
9128 else if (target_static_tracepoint_marker_at (sal.pc, &marker))
9130 t->static_trace_marker_id = xstrdup (marker.str_id);
9131 release_static_tracepoint_marker (&marker);
9133 printf_filtered (_("Probed static tracepoint "
9135 t->static_trace_marker_id);
9138 warning (_("Couldn't determine the static "
9139 "tracepoint marker to probe"));
9146 loc = add_location_to_breakpoint (b, &sal);
9147 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
9151 if (bp_loc_is_permanent (loc))
9152 make_breakpoint_permanent (b);
9156 const char *arg = b->cond_string;
9158 loc->cond = parse_exp_1 (&arg, loc->address,
9159 block_for_pc (loc->address), 0);
9161 error (_("Garbage '%s' follows condition"), arg);
9164 /* Dynamic printf requires and uses additional arguments on the
9165 command line, otherwise it's an error. */
9166 if (type == bp_dprintf)
9168 if (b->extra_string)
9169 update_dprintf_command_list (b);
9171 error (_("Format string required"));
9173 else if (b->extra_string)
9174 error (_("Garbage '%s' at end of command"), b->extra_string);
9177 b->display_canonical = display_canonical;
9179 b->addr_string = addr_string;
9181 /* addr_string has to be used or breakpoint_re_set will delete
9184 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
9189 create_breakpoint_sal (struct gdbarch *gdbarch,
9190 struct symtabs_and_lines sals, char *addr_string,
9191 char *filter, char *cond_string,
9193 enum bptype type, enum bpdisp disposition,
9194 int thread, int task, int ignore_count,
9195 const struct breakpoint_ops *ops, int from_tty,
9196 int enabled, int internal, unsigned flags,
9197 int display_canonical)
9199 struct breakpoint *b;
9200 struct cleanup *old_chain;
9202 if (is_tracepoint_type (type))
9204 struct tracepoint *t;
9206 t = XCNEW (struct tracepoint);
9210 b = XNEW (struct breakpoint);
9212 old_chain = make_cleanup (xfree, b);
9214 init_breakpoint_sal (b, gdbarch,
9216 filter, cond_string, extra_string,
9218 thread, task, ignore_count,
9220 enabled, internal, flags,
9222 discard_cleanups (old_chain);
9224 install_breakpoint (internal, b, 0);
9227 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9228 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9229 value. COND_STRING, if not NULL, specified the condition to be
9230 used for all breakpoints. Essentially the only case where
9231 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9232 function. In that case, it's still not possible to specify
9233 separate conditions for different overloaded functions, so
9234 we take just a single condition string.
9236 NOTE: If the function succeeds, the caller is expected to cleanup
9237 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9238 array contents). If the function fails (error() is called), the
9239 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9240 COND and SALS arrays and each of those arrays contents. */
9243 create_breakpoints_sal (struct gdbarch *gdbarch,
9244 struct linespec_result *canonical,
9245 char *cond_string, char *extra_string,
9246 enum bptype type, enum bpdisp disposition,
9247 int thread, int task, int ignore_count,
9248 const struct breakpoint_ops *ops, int from_tty,
9249 int enabled, int internal, unsigned flags)
9252 struct linespec_sals *lsal;
9254 if (canonical->pre_expanded)
9255 gdb_assert (VEC_length (linespec_sals, canonical->sals) == 1);
9257 for (i = 0; VEC_iterate (linespec_sals, canonical->sals, i, lsal); ++i)
9259 /* Note that 'addr_string' can be NULL in the case of a plain
9260 'break', without arguments. */
9261 char *addr_string = (canonical->addr_string
9262 ? xstrdup (canonical->addr_string)
9264 char *filter_string = lsal->canonical ? xstrdup (lsal->canonical) : NULL;
9265 struct cleanup *inner = make_cleanup (xfree, addr_string);
9267 make_cleanup (xfree, filter_string);
9268 create_breakpoint_sal (gdbarch, lsal->sals,
9271 cond_string, extra_string,
9273 thread, task, ignore_count, ops,
9274 from_tty, enabled, internal, flags,
9275 canonical->special_display);
9276 discard_cleanups (inner);
9280 /* Parse ADDRESS which is assumed to be a SAL specification possibly
9281 followed by conditionals. On return, SALS contains an array of SAL
9282 addresses found. ADDR_STRING contains a vector of (canonical)
9283 address strings. ADDRESS points to the end of the SAL.
9285 The array and the line spec strings are allocated on the heap, it is
9286 the caller's responsibility to free them. */
9289 parse_breakpoint_sals (char **address,
9290 struct linespec_result *canonical)
9292 /* If no arg given, or if first arg is 'if ', use the default
9294 if ((*address) == NULL
9295 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
9297 /* The last displayed codepoint, if it's valid, is our default breakpoint
9299 if (last_displayed_sal_is_valid ())
9301 struct linespec_sals lsal;
9302 struct symtab_and_line sal;
9305 init_sal (&sal); /* Initialize to zeroes. */
9306 lsal.sals.sals = (struct symtab_and_line *)
9307 xmalloc (sizeof (struct symtab_and_line));
9309 /* Set sal's pspace, pc, symtab, and line to the values
9310 corresponding to the last call to print_frame_info.
9311 Be sure to reinitialize LINE with NOTCURRENT == 0
9312 as the breakpoint line number is inappropriate otherwise.
9313 find_pc_line would adjust PC, re-set it back. */
9314 get_last_displayed_sal (&sal);
9316 sal = find_pc_line (pc, 0);
9318 /* "break" without arguments is equivalent to "break *PC"
9319 where PC is the last displayed codepoint's address. So
9320 make sure to set sal.explicit_pc to prevent GDB from
9321 trying to expand the list of sals to include all other
9322 instances with the same symtab and line. */
9324 sal.explicit_pc = 1;
9326 lsal.sals.sals[0] = sal;
9327 lsal.sals.nelts = 1;
9328 lsal.canonical = NULL;
9330 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
9333 error (_("No default breakpoint address now."));
9337 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
9339 /* Force almost all breakpoints to be in terms of the
9340 current_source_symtab (which is decode_line_1's default).
9341 This should produce the results we want almost all of the
9342 time while leaving default_breakpoint_* alone.
9344 ObjC: However, don't match an Objective-C method name which
9345 may have a '+' or '-' succeeded by a '['. */
9346 if (last_displayed_sal_is_valid ()
9348 || ((strchr ("+-", (*address)[0]) != NULL)
9349 && ((*address)[1] != '['))))
9350 decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
9351 get_last_displayed_symtab (),
9352 get_last_displayed_line (),
9353 canonical, NULL, NULL);
9355 decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
9356 cursal.symtab, cursal.line, canonical, NULL, NULL);
9361 /* Convert each SAL into a real PC. Verify that the PC can be
9362 inserted as a breakpoint. If it can't throw an error. */
9365 breakpoint_sals_to_pc (struct symtabs_and_lines *sals)
9369 for (i = 0; i < sals->nelts; i++)
9370 resolve_sal_pc (&sals->sals[i]);
9373 /* Fast tracepoints may have restrictions on valid locations. For
9374 instance, a fast tracepoint using a jump instead of a trap will
9375 likely have to overwrite more bytes than a trap would, and so can
9376 only be placed where the instruction is longer than the jump, or a
9377 multi-instruction sequence does not have a jump into the middle of
9381 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9382 struct symtabs_and_lines *sals)
9385 struct symtab_and_line *sal;
9387 struct cleanup *old_chain;
9389 for (i = 0; i < sals->nelts; i++)
9391 struct gdbarch *sarch;
9393 sal = &sals->sals[i];
9395 sarch = get_sal_arch (*sal);
9396 /* We fall back to GDBARCH if there is no architecture
9397 associated with SAL. */
9400 rslt = gdbarch_fast_tracepoint_valid_at (sarch, sal->pc,
9402 old_chain = make_cleanup (xfree, msg);
9405 error (_("May not have a fast tracepoint at 0x%s%s"),
9406 paddress (sarch, sal->pc), (msg ? msg : ""));
9408 do_cleanups (old_chain);
9412 /* Issue an invalid thread ID error. */
9414 static void ATTRIBUTE_NORETURN
9415 invalid_thread_id_error (int id)
9417 error (_("Unknown thread %d."), id);
9420 /* Given TOK, a string specification of condition and thread, as
9421 accepted by the 'break' command, extract the condition
9422 string and thread number and set *COND_STRING and *THREAD.
9423 PC identifies the context at which the condition should be parsed.
9424 If no condition is found, *COND_STRING is set to NULL.
9425 If no thread is found, *THREAD is set to -1. */
9428 find_condition_and_thread (const char *tok, CORE_ADDR pc,
9429 char **cond_string, int *thread, int *task,
9432 *cond_string = NULL;
9439 const char *end_tok;
9441 const char *cond_start = NULL;
9442 const char *cond_end = NULL;
9444 tok = skip_spaces_const (tok);
9446 if ((*tok == '"' || *tok == ',') && rest)
9448 *rest = savestring (tok, strlen (tok));
9452 end_tok = skip_to_space_const (tok);
9454 toklen = end_tok - tok;
9456 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9458 struct expression *expr;
9460 tok = cond_start = end_tok + 1;
9461 expr = parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
9464 *cond_string = savestring (cond_start, cond_end - cond_start);
9466 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9471 *thread = strtol (tok, &tmptok, 0);
9473 error (_("Junk after thread keyword."));
9474 if (!valid_thread_id (*thread))
9475 invalid_thread_id_error (*thread);
9478 else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9483 *task = strtol (tok, &tmptok, 0);
9485 error (_("Junk after task keyword."));
9486 if (!valid_task_id (*task))
9487 error (_("Unknown task %d."), *task);
9492 *rest = savestring (tok, strlen (tok));
9496 error (_("Junk at end of arguments."));
9500 /* Decode a static tracepoint marker spec. */
9502 static struct symtabs_and_lines
9503 decode_static_tracepoint_spec (char **arg_p)
9505 VEC(static_tracepoint_marker_p) *markers = NULL;
9506 struct symtabs_and_lines sals;
9507 struct cleanup *old_chain;
9508 char *p = &(*arg_p)[3];
9513 p = skip_spaces (p);
9515 endp = skip_to_space (p);
9517 marker_str = savestring (p, endp - p);
9518 old_chain = make_cleanup (xfree, marker_str);
9520 markers = target_static_tracepoint_markers_by_strid (marker_str);
9521 if (VEC_empty(static_tracepoint_marker_p, markers))
9522 error (_("No known static tracepoint marker named %s"), marker_str);
9524 sals.nelts = VEC_length(static_tracepoint_marker_p, markers);
9525 sals.sals = xmalloc (sizeof *sals.sals * sals.nelts);
9527 for (i = 0; i < sals.nelts; i++)
9529 struct static_tracepoint_marker *marker;
9531 marker = VEC_index (static_tracepoint_marker_p, markers, i);
9533 init_sal (&sals.sals[i]);
9535 sals.sals[i] = find_pc_line (marker->address, 0);
9536 sals.sals[i].pc = marker->address;
9538 release_static_tracepoint_marker (marker);
9541 do_cleanups (old_chain);
9547 /* Set a breakpoint. This function is shared between CLI and MI
9548 functions for setting a breakpoint. This function has two major
9549 modes of operations, selected by the PARSE_ARG parameter. If
9550 non-zero, the function will parse ARG, extracting location,
9551 condition, thread and extra string. Otherwise, ARG is just the
9552 breakpoint's location, with condition, thread, and extra string
9553 specified by the COND_STRING, THREAD and EXTRA_STRING parameters.
9554 If INTERNAL is non-zero, the breakpoint number will be allocated
9555 from the internal breakpoint count. Returns true if any breakpoint
9556 was created; false otherwise. */
9559 create_breakpoint (struct gdbarch *gdbarch,
9560 char *arg, char *cond_string,
9561 int thread, char *extra_string,
9563 int tempflag, enum bptype type_wanted,
9565 enum auto_boolean pending_break_support,
9566 const struct breakpoint_ops *ops,
9567 int from_tty, int enabled, int internal,
9570 volatile struct gdb_exception e;
9571 char *copy_arg = NULL;
9572 char *addr_start = arg;
9573 struct linespec_result canonical;
9574 struct cleanup *old_chain;
9575 struct cleanup *bkpt_chain = NULL;
9578 int prev_bkpt_count = breakpoint_count;
9580 gdb_assert (ops != NULL);
9582 init_linespec_result (&canonical);
9584 TRY_CATCH (e, RETURN_MASK_ALL)
9586 ops->create_sals_from_address (&arg, &canonical, type_wanted,
9587 addr_start, ©_arg);
9590 /* If caller is interested in rc value from parse, set value. */
9594 if (VEC_empty (linespec_sals, canonical.sals))
9600 case NOT_FOUND_ERROR:
9602 /* If pending breakpoint support is turned off, throw
9605 if (pending_break_support == AUTO_BOOLEAN_FALSE)
9606 throw_exception (e);
9608 exception_print (gdb_stderr, e);
9610 /* If pending breakpoint support is auto query and the user
9611 selects no, then simply return the error code. */
9612 if (pending_break_support == AUTO_BOOLEAN_AUTO
9613 && !nquery (_("Make %s pending on future shared library load? "),
9614 bptype_string (type_wanted)))
9617 /* At this point, either the user was queried about setting
9618 a pending breakpoint and selected yes, or pending
9619 breakpoint behavior is on and thus a pending breakpoint
9620 is defaulted on behalf of the user. */
9622 struct linespec_sals lsal;
9624 copy_arg = xstrdup (addr_start);
9625 lsal.canonical = xstrdup (copy_arg);
9626 lsal.sals.nelts = 1;
9627 lsal.sals.sals = XNEW (struct symtab_and_line);
9628 init_sal (&lsal.sals.sals[0]);
9630 VEC_safe_push (linespec_sals, canonical.sals, &lsal);
9634 throw_exception (e);
9638 throw_exception (e);
9641 /* Create a chain of things that always need to be cleaned up. */
9642 old_chain = make_cleanup_destroy_linespec_result (&canonical);
9644 /* ----------------------------- SNIP -----------------------------
9645 Anything added to the cleanup chain beyond this point is assumed
9646 to be part of a breakpoint. If the breakpoint create succeeds
9647 then the memory is not reclaimed. */
9648 bkpt_chain = make_cleanup (null_cleanup, 0);
9650 /* Resolve all line numbers to PC's and verify that the addresses
9651 are ok for the target. */
9655 struct linespec_sals *iter;
9657 for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9658 breakpoint_sals_to_pc (&iter->sals);
9661 /* Fast tracepoints may have additional restrictions on location. */
9662 if (!pending && type_wanted == bp_fast_tracepoint)
9665 struct linespec_sals *iter;
9667 for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9668 check_fast_tracepoint_sals (gdbarch, &iter->sals);
9671 /* Verify that condition can be parsed, before setting any
9672 breakpoints. Allocate a separate condition expression for each
9679 struct linespec_sals *lsal;
9681 lsal = VEC_index (linespec_sals, canonical.sals, 0);
9683 /* Here we only parse 'arg' to separate condition
9684 from thread number, so parsing in context of first
9685 sal is OK. When setting the breakpoint we'll
9686 re-parse it in context of each sal. */
9688 find_condition_and_thread (arg, lsal->sals.sals[0].pc, &cond_string,
9689 &thread, &task, &rest);
9691 make_cleanup (xfree, cond_string);
9693 make_cleanup (xfree, rest);
9695 extra_string = rest;
9700 error (_("Garbage '%s' at end of location"), arg);
9702 /* Create a private copy of condition string. */
9705 cond_string = xstrdup (cond_string);
9706 make_cleanup (xfree, cond_string);
9708 /* Create a private copy of any extra string. */
9711 extra_string = xstrdup (extra_string);
9712 make_cleanup (xfree, extra_string);
9716 ops->create_breakpoints_sal (gdbarch, &canonical,
9717 cond_string, extra_string, type_wanted,
9718 tempflag ? disp_del : disp_donttouch,
9719 thread, task, ignore_count, ops,
9720 from_tty, enabled, internal, flags);
9724 struct breakpoint *b;
9726 make_cleanup (xfree, copy_arg);
9728 if (is_tracepoint_type (type_wanted))
9730 struct tracepoint *t;
9732 t = XCNEW (struct tracepoint);
9736 b = XNEW (struct breakpoint);
9738 init_raw_breakpoint_without_location (b, gdbarch, type_wanted, ops);
9740 b->addr_string = copy_arg;
9742 b->cond_string = NULL;
9745 /* Create a private copy of condition string. */
9748 cond_string = xstrdup (cond_string);
9749 make_cleanup (xfree, cond_string);
9751 b->cond_string = cond_string;
9753 b->extra_string = NULL;
9754 b->ignore_count = ignore_count;
9755 b->disposition = tempflag ? disp_del : disp_donttouch;
9756 b->condition_not_parsed = 1;
9757 b->enable_state = enabled ? bp_enabled : bp_disabled;
9758 if ((type_wanted != bp_breakpoint
9759 && type_wanted != bp_hardware_breakpoint) || thread != -1)
9760 b->pspace = current_program_space;
9762 install_breakpoint (internal, b, 0);
9765 if (VEC_length (linespec_sals, canonical.sals) > 1)
9767 warning (_("Multiple breakpoints were set.\nUse the "
9768 "\"delete\" command to delete unwanted breakpoints."));
9769 prev_breakpoint_count = prev_bkpt_count;
9772 /* That's it. Discard the cleanups for data inserted into the
9774 discard_cleanups (bkpt_chain);
9775 /* But cleanup everything else. */
9776 do_cleanups (old_chain);
9778 /* error call may happen here - have BKPT_CHAIN already discarded. */
9779 update_global_location_list (1);
9784 /* Set a breakpoint.
9785 ARG is a string describing breakpoint address,
9786 condition, and thread.
9787 FLAG specifies if a breakpoint is hardware on,
9788 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9792 break_command_1 (char *arg, int flag, int from_tty)
9794 int tempflag = flag & BP_TEMPFLAG;
9795 enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9796 ? bp_hardware_breakpoint
9798 struct breakpoint_ops *ops;
9799 const char *arg_cp = arg;
9801 /* Matching breakpoints on probes. */
9802 if (arg && probe_linespec_to_ops (&arg_cp) != NULL)
9803 ops = &bkpt_probe_breakpoint_ops;
9805 ops = &bkpt_breakpoint_ops;
9807 create_breakpoint (get_current_arch (),
9809 NULL, 0, NULL, 1 /* parse arg */,
9810 tempflag, type_wanted,
9811 0 /* Ignore count */,
9812 pending_break_support,
9820 /* Helper function for break_command_1 and disassemble_command. */
9823 resolve_sal_pc (struct symtab_and_line *sal)
9827 if (sal->pc == 0 && sal->symtab != NULL)
9829 if (!find_line_pc (sal->symtab, sal->line, &pc))
9830 error (_("No line %d in file \"%s\"."),
9831 sal->line, symtab_to_filename_for_display (sal->symtab));
9834 /* If this SAL corresponds to a breakpoint inserted using a line
9835 number, then skip the function prologue if necessary. */
9836 if (sal->explicit_line)
9837 skip_prologue_sal (sal);
9840 if (sal->section == 0 && sal->symtab != NULL)
9842 struct blockvector *bv;
9846 bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
9849 sym = block_linkage_function (b);
9852 fixup_symbol_section (sym, sal->symtab->objfile);
9853 sal->section = SYMBOL_OBJ_SECTION (sal->symtab->objfile, sym);
9857 /* It really is worthwhile to have the section, so we'll
9858 just have to look harder. This case can be executed
9859 if we have line numbers but no functions (as can
9860 happen in assembly source). */
9862 struct bound_minimal_symbol msym;
9863 struct cleanup *old_chain = save_current_space_and_thread ();
9865 switch_to_program_space_and_thread (sal->pspace);
9867 msym = lookup_minimal_symbol_by_pc (sal->pc);
9869 sal->section = SYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
9871 do_cleanups (old_chain);
9878 break_command (char *arg, int from_tty)
9880 break_command_1 (arg, 0, from_tty);
9884 tbreak_command (char *arg, int from_tty)
9886 break_command_1 (arg, BP_TEMPFLAG, from_tty);
9890 hbreak_command (char *arg, int from_tty)
9892 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
9896 thbreak_command (char *arg, int from_tty)
9898 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
9902 stop_command (char *arg, int from_tty)
9904 printf_filtered (_("Specify the type of breakpoint to set.\n\
9905 Usage: stop in <function | address>\n\
9906 stop at <line>\n"));
9910 stopin_command (char *arg, int from_tty)
9914 if (arg == (char *) NULL)
9916 else if (*arg != '*')
9921 /* Look for a ':'. If this is a line number specification, then
9922 say it is bad, otherwise, it should be an address or
9923 function/method name. */
9924 while (*argptr && !hasColon)
9926 hasColon = (*argptr == ':');
9931 badInput = (*argptr != ':'); /* Not a class::method */
9933 badInput = isdigit (*arg); /* a simple line number */
9937 printf_filtered (_("Usage: stop in <function | address>\n"));
9939 break_command_1 (arg, 0, from_tty);
9943 stopat_command (char *arg, int from_tty)
9947 if (arg == (char *) NULL || *arg == '*') /* no line number */
9954 /* Look for a ':'. If there is a '::' then get out, otherwise
9955 it is probably a line number. */
9956 while (*argptr && !hasColon)
9958 hasColon = (*argptr == ':');
9963 badInput = (*argptr == ':'); /* we have class::method */
9965 badInput = !isdigit (*arg); /* not a line number */
9969 printf_filtered (_("Usage: stop at <line>\n"));
9971 break_command_1 (arg, 0, from_tty);
9974 /* The dynamic printf command is mostly like a regular breakpoint, but
9975 with a prewired command list consisting of a single output command,
9976 built from extra arguments supplied on the dprintf command
9980 dprintf_command (char *arg, int from_tty)
9982 create_breakpoint (get_current_arch (),
9984 NULL, 0, NULL, 1 /* parse arg */,
9986 0 /* Ignore count */,
9987 pending_break_support,
9988 &dprintf_breakpoint_ops,
9996 agent_printf_command (char *arg, int from_tty)
9998 error (_("May only run agent-printf on the target"));
10001 /* Implement the "breakpoint_hit" breakpoint_ops method for
10002 ranged breakpoints. */
10005 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
10006 struct address_space *aspace,
10008 const struct target_waitstatus *ws)
10010 if (ws->kind != TARGET_WAITKIND_STOPPED
10011 || ws->value.sig != GDB_SIGNAL_TRAP)
10014 return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
10015 bl->length, aspace, bp_addr);
10018 /* Implement the "resources_needed" breakpoint_ops method for
10019 ranged breakpoints. */
10022 resources_needed_ranged_breakpoint (const struct bp_location *bl)
10024 return target_ranged_break_num_registers ();
10027 /* Implement the "print_it" breakpoint_ops method for
10028 ranged breakpoints. */
10030 static enum print_stop_action
10031 print_it_ranged_breakpoint (bpstat bs)
10033 struct breakpoint *b = bs->breakpoint_at;
10034 struct bp_location *bl = b->loc;
10035 struct ui_out *uiout = current_uiout;
10037 gdb_assert (b->type == bp_hardware_breakpoint);
10039 /* Ranged breakpoints have only one location. */
10040 gdb_assert (bl && bl->next == NULL);
10042 annotate_breakpoint (b->number);
10043 if (b->disposition == disp_del)
10044 ui_out_text (uiout, "\nTemporary ranged breakpoint ");
10046 ui_out_text (uiout, "\nRanged breakpoint ");
10047 if (ui_out_is_mi_like_p (uiout))
10049 ui_out_field_string (uiout, "reason",
10050 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
10051 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
10053 ui_out_field_int (uiout, "bkptno", b->number);
10054 ui_out_text (uiout, ", ");
10056 return PRINT_SRC_AND_LOC;
10059 /* Implement the "print_one" breakpoint_ops method for
10060 ranged breakpoints. */
10063 print_one_ranged_breakpoint (struct breakpoint *b,
10064 struct bp_location **last_loc)
10066 struct bp_location *bl = b->loc;
10067 struct value_print_options opts;
10068 struct ui_out *uiout = current_uiout;
10070 /* Ranged breakpoints have only one location. */
10071 gdb_assert (bl && bl->next == NULL);
10073 get_user_print_options (&opts);
10075 if (opts.addressprint)
10076 /* We don't print the address range here, it will be printed later
10077 by print_one_detail_ranged_breakpoint. */
10078 ui_out_field_skip (uiout, "addr");
10079 annotate_field (5);
10080 print_breakpoint_location (b, bl);
10084 /* Implement the "print_one_detail" breakpoint_ops method for
10085 ranged breakpoints. */
10088 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
10089 struct ui_out *uiout)
10091 CORE_ADDR address_start, address_end;
10092 struct bp_location *bl = b->loc;
10093 struct ui_file *stb = mem_fileopen ();
10094 struct cleanup *cleanup = make_cleanup_ui_file_delete (stb);
10098 address_start = bl->address;
10099 address_end = address_start + bl->length - 1;
10101 ui_out_text (uiout, "\taddress range: ");
10102 fprintf_unfiltered (stb, "[%s, %s]",
10103 print_core_address (bl->gdbarch, address_start),
10104 print_core_address (bl->gdbarch, address_end));
10105 ui_out_field_stream (uiout, "addr", stb);
10106 ui_out_text (uiout, "\n");
10108 do_cleanups (cleanup);
10111 /* Implement the "print_mention" breakpoint_ops method for
10112 ranged breakpoints. */
10115 print_mention_ranged_breakpoint (struct breakpoint *b)
10117 struct bp_location *bl = b->loc;
10118 struct ui_out *uiout = current_uiout;
10121 gdb_assert (b->type == bp_hardware_breakpoint);
10123 if (ui_out_is_mi_like_p (uiout))
10126 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
10127 b->number, paddress (bl->gdbarch, bl->address),
10128 paddress (bl->gdbarch, bl->address + bl->length - 1));
10131 /* Implement the "print_recreate" breakpoint_ops method for
10132 ranged breakpoints. */
10135 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
10137 fprintf_unfiltered (fp, "break-range %s, %s", b->addr_string,
10138 b->addr_string_range_end);
10139 print_recreate_thread (b, fp);
10142 /* The breakpoint_ops structure to be used in ranged breakpoints. */
10144 static struct breakpoint_ops ranged_breakpoint_ops;
10146 /* Find the address where the end of the breakpoint range should be
10147 placed, given the SAL of the end of the range. This is so that if
10148 the user provides a line number, the end of the range is set to the
10149 last instruction of the given line. */
10152 find_breakpoint_range_end (struct symtab_and_line sal)
10156 /* If the user provided a PC value, use it. Otherwise,
10157 find the address of the end of the given location. */
10158 if (sal.explicit_pc)
10165 ret = find_line_pc_range (sal, &start, &end);
10167 error (_("Could not find location of the end of the range."));
10169 /* find_line_pc_range returns the start of the next line. */
10176 /* Implement the "break-range" CLI command. */
10179 break_range_command (char *arg, int from_tty)
10181 char *arg_start, *addr_string_start, *addr_string_end;
10182 struct linespec_result canonical_start, canonical_end;
10183 int bp_count, can_use_bp, length;
10185 struct breakpoint *b;
10186 struct symtab_and_line sal_start, sal_end;
10187 struct cleanup *cleanup_bkpt;
10188 struct linespec_sals *lsal_start, *lsal_end;
10190 /* We don't support software ranged breakpoints. */
10191 if (target_ranged_break_num_registers () < 0)
10192 error (_("This target does not support hardware ranged breakpoints."));
10194 bp_count = hw_breakpoint_used_count ();
10195 bp_count += target_ranged_break_num_registers ();
10196 can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
10198 if (can_use_bp < 0)
10199 error (_("Hardware breakpoints used exceeds limit."));
10201 arg = skip_spaces (arg);
10202 if (arg == NULL || arg[0] == '\0')
10203 error(_("No address range specified."));
10205 init_linespec_result (&canonical_start);
10208 parse_breakpoint_sals (&arg, &canonical_start);
10210 cleanup_bkpt = make_cleanup_destroy_linespec_result (&canonical_start);
10213 error (_("Too few arguments."));
10214 else if (VEC_empty (linespec_sals, canonical_start.sals))
10215 error (_("Could not find location of the beginning of the range."));
10217 lsal_start = VEC_index (linespec_sals, canonical_start.sals, 0);
10219 if (VEC_length (linespec_sals, canonical_start.sals) > 1
10220 || lsal_start->sals.nelts != 1)
10221 error (_("Cannot create a ranged breakpoint with multiple locations."));
10223 sal_start = lsal_start->sals.sals[0];
10224 addr_string_start = savestring (arg_start, arg - arg_start);
10225 make_cleanup (xfree, addr_string_start);
10227 arg++; /* Skip the comma. */
10228 arg = skip_spaces (arg);
10230 /* Parse the end location. */
10232 init_linespec_result (&canonical_end);
10235 /* We call decode_line_full directly here instead of using
10236 parse_breakpoint_sals because we need to specify the start location's
10237 symtab and line as the default symtab and line for the end of the
10238 range. This makes it possible to have ranges like "foo.c:27, +14",
10239 where +14 means 14 lines from the start location. */
10240 decode_line_full (&arg, DECODE_LINE_FUNFIRSTLINE,
10241 sal_start.symtab, sal_start.line,
10242 &canonical_end, NULL, NULL);
10244 make_cleanup_destroy_linespec_result (&canonical_end);
10246 if (VEC_empty (linespec_sals, canonical_end.sals))
10247 error (_("Could not find location of the end of the range."));
10249 lsal_end = VEC_index (linespec_sals, canonical_end.sals, 0);
10250 if (VEC_length (linespec_sals, canonical_end.sals) > 1
10251 || lsal_end->sals.nelts != 1)
10252 error (_("Cannot create a ranged breakpoint with multiple locations."));
10254 sal_end = lsal_end->sals.sals[0];
10255 addr_string_end = savestring (arg_start, arg - arg_start);
10256 make_cleanup (xfree, addr_string_end);
10258 end = find_breakpoint_range_end (sal_end);
10259 if (sal_start.pc > end)
10260 error (_("Invalid address range, end precedes start."));
10262 length = end - sal_start.pc + 1;
10264 /* Length overflowed. */
10265 error (_("Address range too large."));
10266 else if (length == 1)
10268 /* This range is simple enough to be handled by
10269 the `hbreak' command. */
10270 hbreak_command (addr_string_start, 1);
10272 do_cleanups (cleanup_bkpt);
10277 /* Now set up the breakpoint. */
10278 b = set_raw_breakpoint (get_current_arch (), sal_start,
10279 bp_hardware_breakpoint, &ranged_breakpoint_ops);
10280 set_breakpoint_count (breakpoint_count + 1);
10281 b->number = breakpoint_count;
10282 b->disposition = disp_donttouch;
10283 b->addr_string = xstrdup (addr_string_start);
10284 b->addr_string_range_end = xstrdup (addr_string_end);
10285 b->loc->length = length;
10287 do_cleanups (cleanup_bkpt);
10290 observer_notify_breakpoint_created (b);
10291 update_global_location_list (1);
10294 /* Return non-zero if EXP is verified as constant. Returned zero
10295 means EXP is variable. Also the constant detection may fail for
10296 some constant expressions and in such case still falsely return
10300 watchpoint_exp_is_const (const struct expression *exp)
10302 int i = exp->nelts;
10308 /* We are only interested in the descriptor of each element. */
10309 operator_length (exp, i, &oplenp, &argsp);
10312 switch (exp->elts[i].opcode)
10322 case BINOP_LOGICAL_AND:
10323 case BINOP_LOGICAL_OR:
10324 case BINOP_BITWISE_AND:
10325 case BINOP_BITWISE_IOR:
10326 case BINOP_BITWISE_XOR:
10328 case BINOP_NOTEQUAL:
10357 case OP_OBJC_NSSTRING:
10360 case UNOP_LOGICAL_NOT:
10361 case UNOP_COMPLEMENT:
10366 case UNOP_CAST_TYPE:
10367 case UNOP_REINTERPRET_CAST:
10368 case UNOP_DYNAMIC_CAST:
10369 /* Unary, binary and ternary operators: We have to check
10370 their operands. If they are constant, then so is the
10371 result of that operation. For instance, if A and B are
10372 determined to be constants, then so is "A + B".
10374 UNOP_IND is one exception to the rule above, because the
10375 value of *ADDR is not necessarily a constant, even when
10380 /* Check whether the associated symbol is a constant.
10382 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10383 possible that a buggy compiler could mark a variable as
10384 constant even when it is not, and TYPE_CONST would return
10385 true in this case, while SYMBOL_CLASS wouldn't.
10387 We also have to check for function symbols because they
10388 are always constant. */
10390 struct symbol *s = exp->elts[i + 2].symbol;
10392 if (SYMBOL_CLASS (s) != LOC_BLOCK
10393 && SYMBOL_CLASS (s) != LOC_CONST
10394 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
10399 /* The default action is to return 0 because we are using
10400 the optimistic approach here: If we don't know something,
10401 then it is not a constant. */
10410 /* Implement the "dtor" breakpoint_ops method for watchpoints. */
10413 dtor_watchpoint (struct breakpoint *self)
10415 struct watchpoint *w = (struct watchpoint *) self;
10417 xfree (w->cond_exp);
10419 xfree (w->exp_string);
10420 xfree (w->exp_string_reparse);
10421 value_free (w->val);
10423 base_breakpoint_ops.dtor (self);
10426 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10429 re_set_watchpoint (struct breakpoint *b)
10431 struct watchpoint *w = (struct watchpoint *) b;
10433 /* Watchpoint can be either on expression using entirely global
10434 variables, or it can be on local variables.
10436 Watchpoints of the first kind are never auto-deleted, and even
10437 persist across program restarts. Since they can use variables
10438 from shared libraries, we need to reparse expression as libraries
10439 are loaded and unloaded.
10441 Watchpoints on local variables can also change meaning as result
10442 of solib event. For example, if a watchpoint uses both a local
10443 and a global variables in expression, it's a local watchpoint,
10444 but unloading of a shared library will make the expression
10445 invalid. This is not a very common use case, but we still
10446 re-evaluate expression, to avoid surprises to the user.
10448 Note that for local watchpoints, we re-evaluate it only if
10449 watchpoints frame id is still valid. If it's not, it means the
10450 watchpoint is out of scope and will be deleted soon. In fact,
10451 I'm not sure we'll ever be called in this case.
10453 If a local watchpoint's frame id is still valid, then
10454 w->exp_valid_block is likewise valid, and we can safely use it.
10456 Don't do anything about disabled watchpoints, since they will be
10457 reevaluated again when enabled. */
10458 update_watchpoint (w, 1 /* reparse */);
10461 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10464 insert_watchpoint (struct bp_location *bl)
10466 struct watchpoint *w = (struct watchpoint *) bl->owner;
10467 int length = w->exact ? 1 : bl->length;
10469 return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
10473 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10476 remove_watchpoint (struct bp_location *bl)
10478 struct watchpoint *w = (struct watchpoint *) bl->owner;
10479 int length = w->exact ? 1 : bl->length;
10481 return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
10486 breakpoint_hit_watchpoint (const struct bp_location *bl,
10487 struct address_space *aspace, CORE_ADDR bp_addr,
10488 const struct target_waitstatus *ws)
10490 struct breakpoint *b = bl->owner;
10491 struct watchpoint *w = (struct watchpoint *) b;
10493 /* Continuable hardware watchpoints are treated as non-existent if the
10494 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10495 some data address). Otherwise gdb won't stop on a break instruction
10496 in the code (not from a breakpoint) when a hardware watchpoint has
10497 been defined. Also skip watchpoints which we know did not trigger
10498 (did not match the data address). */
10499 if (is_hardware_watchpoint (b)
10500 && w->watchpoint_triggered == watch_triggered_no)
10507 check_status_watchpoint (bpstat bs)
10509 gdb_assert (is_watchpoint (bs->breakpoint_at));
10511 bpstat_check_watchpoint (bs);
10514 /* Implement the "resources_needed" breakpoint_ops method for
10515 hardware watchpoints. */
10518 resources_needed_watchpoint (const struct bp_location *bl)
10520 struct watchpoint *w = (struct watchpoint *) bl->owner;
10521 int length = w->exact? 1 : bl->length;
10523 return target_region_ok_for_hw_watchpoint (bl->address, length);
10526 /* Implement the "works_in_software_mode" breakpoint_ops method for
10527 hardware watchpoints. */
10530 works_in_software_mode_watchpoint (const struct breakpoint *b)
10532 /* Read and access watchpoints only work with hardware support. */
10533 return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
10536 static enum print_stop_action
10537 print_it_watchpoint (bpstat bs)
10539 struct cleanup *old_chain;
10540 struct breakpoint *b;
10541 struct ui_file *stb;
10542 enum print_stop_action result;
10543 struct watchpoint *w;
10544 struct ui_out *uiout = current_uiout;
10546 gdb_assert (bs->bp_location_at != NULL);
10548 b = bs->breakpoint_at;
10549 w = (struct watchpoint *) b;
10551 stb = mem_fileopen ();
10552 old_chain = make_cleanup_ui_file_delete (stb);
10556 case bp_watchpoint:
10557 case bp_hardware_watchpoint:
10558 annotate_watchpoint (b->number);
10559 if (ui_out_is_mi_like_p (uiout))
10560 ui_out_field_string
10562 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10564 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10565 ui_out_text (uiout, "\nOld value = ");
10566 watchpoint_value_print (bs->old_val, stb);
10567 ui_out_field_stream (uiout, "old", stb);
10568 ui_out_text (uiout, "\nNew value = ");
10569 watchpoint_value_print (w->val, stb);
10570 ui_out_field_stream (uiout, "new", stb);
10571 ui_out_text (uiout, "\n");
10572 /* More than one watchpoint may have been triggered. */
10573 result = PRINT_UNKNOWN;
10576 case bp_read_watchpoint:
10577 if (ui_out_is_mi_like_p (uiout))
10578 ui_out_field_string
10580 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10582 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10583 ui_out_text (uiout, "\nValue = ");
10584 watchpoint_value_print (w->val, stb);
10585 ui_out_field_stream (uiout, "value", stb);
10586 ui_out_text (uiout, "\n");
10587 result = PRINT_UNKNOWN;
10590 case bp_access_watchpoint:
10591 if (bs->old_val != NULL)
10593 annotate_watchpoint (b->number);
10594 if (ui_out_is_mi_like_p (uiout))
10595 ui_out_field_string
10597 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10599 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10600 ui_out_text (uiout, "\nOld value = ");
10601 watchpoint_value_print (bs->old_val, stb);
10602 ui_out_field_stream (uiout, "old", stb);
10603 ui_out_text (uiout, "\nNew value = ");
10608 if (ui_out_is_mi_like_p (uiout))
10609 ui_out_field_string
10611 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10612 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10613 ui_out_text (uiout, "\nValue = ");
10615 watchpoint_value_print (w->val, stb);
10616 ui_out_field_stream (uiout, "new", stb);
10617 ui_out_text (uiout, "\n");
10618 result = PRINT_UNKNOWN;
10621 result = PRINT_UNKNOWN;
10624 do_cleanups (old_chain);
10628 /* Implement the "print_mention" breakpoint_ops method for hardware
10632 print_mention_watchpoint (struct breakpoint *b)
10634 struct cleanup *ui_out_chain;
10635 struct watchpoint *w = (struct watchpoint *) b;
10636 struct ui_out *uiout = current_uiout;
10640 case bp_watchpoint:
10641 ui_out_text (uiout, "Watchpoint ");
10642 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10644 case bp_hardware_watchpoint:
10645 ui_out_text (uiout, "Hardware watchpoint ");
10646 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10648 case bp_read_watchpoint:
10649 ui_out_text (uiout, "Hardware read watchpoint ");
10650 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10652 case bp_access_watchpoint:
10653 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
10654 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
10657 internal_error (__FILE__, __LINE__,
10658 _("Invalid hardware watchpoint type."));
10661 ui_out_field_int (uiout, "number", b->number);
10662 ui_out_text (uiout, ": ");
10663 ui_out_field_string (uiout, "exp", w->exp_string);
10664 do_cleanups (ui_out_chain);
10667 /* Implement the "print_recreate" breakpoint_ops method for
10671 print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10673 struct watchpoint *w = (struct watchpoint *) b;
10677 case bp_watchpoint:
10678 case bp_hardware_watchpoint:
10679 fprintf_unfiltered (fp, "watch");
10681 case bp_read_watchpoint:
10682 fprintf_unfiltered (fp, "rwatch");
10684 case bp_access_watchpoint:
10685 fprintf_unfiltered (fp, "awatch");
10688 internal_error (__FILE__, __LINE__,
10689 _("Invalid watchpoint type."));
10692 fprintf_unfiltered (fp, " %s", w->exp_string);
10693 print_recreate_thread (b, fp);
10696 /* Implement the "explains_signal" breakpoint_ops method for
10699 static enum bpstat_signal_value
10700 explains_signal_watchpoint (struct breakpoint *b, enum gdb_signal sig)
10702 /* A software watchpoint cannot cause a signal other than
10703 GDB_SIGNAL_TRAP. */
10704 if (b->type == bp_watchpoint && sig != GDB_SIGNAL_TRAP)
10705 return BPSTAT_SIGNAL_NO;
10707 return BPSTAT_SIGNAL_HIDE;
10710 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10712 static struct breakpoint_ops watchpoint_breakpoint_ops;
10714 /* Implement the "insert" breakpoint_ops method for
10715 masked hardware watchpoints. */
10718 insert_masked_watchpoint (struct bp_location *bl)
10720 struct watchpoint *w = (struct watchpoint *) bl->owner;
10722 return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
10723 bl->watchpoint_type);
10726 /* Implement the "remove" breakpoint_ops method for
10727 masked hardware watchpoints. */
10730 remove_masked_watchpoint (struct bp_location *bl)
10732 struct watchpoint *w = (struct watchpoint *) bl->owner;
10734 return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
10735 bl->watchpoint_type);
10738 /* Implement the "resources_needed" breakpoint_ops method for
10739 masked hardware watchpoints. */
10742 resources_needed_masked_watchpoint (const struct bp_location *bl)
10744 struct watchpoint *w = (struct watchpoint *) bl->owner;
10746 return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
10749 /* Implement the "works_in_software_mode" breakpoint_ops method for
10750 masked hardware watchpoints. */
10753 works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10758 /* Implement the "print_it" breakpoint_ops method for
10759 masked hardware watchpoints. */
10761 static enum print_stop_action
10762 print_it_masked_watchpoint (bpstat bs)
10764 struct breakpoint *b = bs->breakpoint_at;
10765 struct ui_out *uiout = current_uiout;
10767 /* Masked watchpoints have only one location. */
10768 gdb_assert (b->loc && b->loc->next == NULL);
10772 case bp_hardware_watchpoint:
10773 annotate_watchpoint (b->number);
10774 if (ui_out_is_mi_like_p (uiout))
10775 ui_out_field_string
10777 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10780 case bp_read_watchpoint:
10781 if (ui_out_is_mi_like_p (uiout))
10782 ui_out_field_string
10784 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10787 case bp_access_watchpoint:
10788 if (ui_out_is_mi_like_p (uiout))
10789 ui_out_field_string
10791 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10794 internal_error (__FILE__, __LINE__,
10795 _("Invalid hardware watchpoint type."));
10799 ui_out_text (uiout, _("\n\
10800 Check the underlying instruction at PC for the memory\n\
10801 address and value which triggered this watchpoint.\n"));
10802 ui_out_text (uiout, "\n");
10804 /* More than one watchpoint may have been triggered. */
10805 return PRINT_UNKNOWN;
10808 /* Implement the "print_one_detail" breakpoint_ops method for
10809 masked hardware watchpoints. */
10812 print_one_detail_masked_watchpoint (const struct breakpoint *b,
10813 struct ui_out *uiout)
10815 struct watchpoint *w = (struct watchpoint *) b;
10817 /* Masked watchpoints have only one location. */
10818 gdb_assert (b->loc && b->loc->next == NULL);
10820 ui_out_text (uiout, "\tmask ");
10821 ui_out_field_core_addr (uiout, "mask", b->loc->gdbarch, w->hw_wp_mask);
10822 ui_out_text (uiout, "\n");
10825 /* Implement the "print_mention" breakpoint_ops method for
10826 masked hardware watchpoints. */
10829 print_mention_masked_watchpoint (struct breakpoint *b)
10831 struct watchpoint *w = (struct watchpoint *) b;
10832 struct ui_out *uiout = current_uiout;
10833 struct cleanup *ui_out_chain;
10837 case bp_hardware_watchpoint:
10838 ui_out_text (uiout, "Masked hardware watchpoint ");
10839 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10841 case bp_read_watchpoint:
10842 ui_out_text (uiout, "Masked hardware read watchpoint ");
10843 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10845 case bp_access_watchpoint:
10846 ui_out_text (uiout, "Masked hardware access (read/write) watchpoint ");
10847 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
10850 internal_error (__FILE__, __LINE__,
10851 _("Invalid hardware watchpoint type."));
10854 ui_out_field_int (uiout, "number", b->number);
10855 ui_out_text (uiout, ": ");
10856 ui_out_field_string (uiout, "exp", w->exp_string);
10857 do_cleanups (ui_out_chain);
10860 /* Implement the "print_recreate" breakpoint_ops method for
10861 masked hardware watchpoints. */
10864 print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
10866 struct watchpoint *w = (struct watchpoint *) b;
10871 case bp_hardware_watchpoint:
10872 fprintf_unfiltered (fp, "watch");
10874 case bp_read_watchpoint:
10875 fprintf_unfiltered (fp, "rwatch");
10877 case bp_access_watchpoint:
10878 fprintf_unfiltered (fp, "awatch");
10881 internal_error (__FILE__, __LINE__,
10882 _("Invalid hardware watchpoint type."));
10885 sprintf_vma (tmp, w->hw_wp_mask);
10886 fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
10887 print_recreate_thread (b, fp);
10890 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10892 static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
10894 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10897 is_masked_watchpoint (const struct breakpoint *b)
10899 return b->ops == &masked_watchpoint_breakpoint_ops;
10902 /* accessflag: hw_write: watch write,
10903 hw_read: watch read,
10904 hw_access: watch access (read or write) */
10906 watch_command_1 (const char *arg, int accessflag, int from_tty,
10907 int just_location, int internal)
10909 volatile struct gdb_exception e;
10910 struct breakpoint *b, *scope_breakpoint = NULL;
10911 struct expression *exp;
10912 const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
10913 struct value *val, *mark, *result;
10914 struct frame_info *frame;
10915 const char *exp_start = NULL;
10916 const char *exp_end = NULL;
10917 const char *tok, *end_tok;
10919 const char *cond_start = NULL;
10920 const char *cond_end = NULL;
10921 enum bptype bp_type;
10924 /* Flag to indicate whether we are going to use masks for
10925 the hardware watchpoint. */
10927 CORE_ADDR mask = 0;
10928 struct watchpoint *w;
10930 struct cleanup *back_to;
10932 /* Make sure that we actually have parameters to parse. */
10933 if (arg != NULL && arg[0] != '\0')
10935 const char *value_start;
10937 exp_end = arg + strlen (arg);
10939 /* Look for "parameter value" pairs at the end
10940 of the arguments string. */
10941 for (tok = exp_end - 1; tok > arg; tok--)
10943 /* Skip whitespace at the end of the argument list. */
10944 while (tok > arg && (*tok == ' ' || *tok == '\t'))
10947 /* Find the beginning of the last token.
10948 This is the value of the parameter. */
10949 while (tok > arg && (*tok != ' ' && *tok != '\t'))
10951 value_start = tok + 1;
10953 /* Skip whitespace. */
10954 while (tok > arg && (*tok == ' ' || *tok == '\t'))
10959 /* Find the beginning of the second to last token.
10960 This is the parameter itself. */
10961 while (tok > arg && (*tok != ' ' && *tok != '\t'))
10964 toklen = end_tok - tok + 1;
10966 if (toklen == 6 && !strncmp (tok, "thread", 6))
10968 /* At this point we've found a "thread" token, which means
10969 the user is trying to set a watchpoint that triggers
10970 only in a specific thread. */
10974 error(_("You can specify only one thread."));
10976 /* Extract the thread ID from the next token. */
10977 thread = strtol (value_start, &endp, 0);
10979 /* Check if the user provided a valid numeric value for the
10981 if (*endp != ' ' && *endp != '\t' && *endp != '\0')
10982 error (_("Invalid thread ID specification %s."), value_start);
10984 /* Check if the thread actually exists. */
10985 if (!valid_thread_id (thread))
10986 invalid_thread_id_error (thread);
10988 else if (toklen == 4 && !strncmp (tok, "mask", 4))
10990 /* We've found a "mask" token, which means the user wants to
10991 create a hardware watchpoint that is going to have the mask
10993 struct value *mask_value, *mark;
10996 error(_("You can specify only one mask."));
10998 use_mask = just_location = 1;
11000 mark = value_mark ();
11001 mask_value = parse_to_comma_and_eval (&value_start);
11002 mask = value_as_address (mask_value);
11003 value_free_to_mark (mark);
11006 /* We didn't recognize what we found. We should stop here. */
11009 /* Truncate the string and get rid of the "parameter value" pair before
11010 the arguments string is parsed by the parse_exp_1 function. */
11017 /* Parse the rest of the arguments. From here on out, everything
11018 is in terms of a newly allocated string instead of the original
11020 innermost_block = NULL;
11021 expression = savestring (arg, exp_end - arg);
11022 back_to = make_cleanup (xfree, expression);
11023 exp_start = arg = expression;
11024 exp = parse_exp_1 (&arg, 0, 0, 0);
11026 /* Remove trailing whitespace from the expression before saving it.
11027 This makes the eventual display of the expression string a bit
11029 while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
11032 /* Checking if the expression is not constant. */
11033 if (watchpoint_exp_is_const (exp))
11037 len = exp_end - exp_start;
11038 while (len > 0 && isspace (exp_start[len - 1]))
11040 error (_("Cannot watch constant value `%.*s'."), len, exp_start);
11043 exp_valid_block = innermost_block;
11044 mark = value_mark ();
11045 fetch_subexp_value (exp, &pc, &val, &result, NULL, just_location);
11051 exp_valid_block = NULL;
11052 val = value_addr (result);
11053 release_value (val);
11054 value_free_to_mark (mark);
11058 ret = target_masked_watch_num_registers (value_as_address (val),
11061 error (_("This target does not support masked watchpoints."));
11062 else if (ret == -2)
11063 error (_("Invalid mask or memory region."));
11066 else if (val != NULL)
11067 release_value (val);
11069 tok = skip_spaces_const (arg);
11070 end_tok = skip_to_space_const (tok);
11072 toklen = end_tok - tok;
11073 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
11075 struct expression *cond;
11077 innermost_block = NULL;
11078 tok = cond_start = end_tok + 1;
11079 cond = parse_exp_1 (&tok, 0, 0, 0);
11081 /* The watchpoint expression may not be local, but the condition
11082 may still be. E.g.: `watch global if local > 0'. */
11083 cond_exp_valid_block = innermost_block;
11089 error (_("Junk at end of command."));
11091 frame = block_innermost_frame (exp_valid_block);
11093 /* If the expression is "local", then set up a "watchpoint scope"
11094 breakpoint at the point where we've left the scope of the watchpoint
11095 expression. Create the scope breakpoint before the watchpoint, so
11096 that we will encounter it first in bpstat_stop_status. */
11097 if (exp_valid_block && frame)
11099 if (frame_id_p (frame_unwind_caller_id (frame)))
11102 = create_internal_breakpoint (frame_unwind_caller_arch (frame),
11103 frame_unwind_caller_pc (frame),
11104 bp_watchpoint_scope,
11105 &momentary_breakpoint_ops);
11107 scope_breakpoint->enable_state = bp_enabled;
11109 /* Automatically delete the breakpoint when it hits. */
11110 scope_breakpoint->disposition = disp_del;
11112 /* Only break in the proper frame (help with recursion). */
11113 scope_breakpoint->frame_id = frame_unwind_caller_id (frame);
11115 /* Set the address at which we will stop. */
11116 scope_breakpoint->loc->gdbarch
11117 = frame_unwind_caller_arch (frame);
11118 scope_breakpoint->loc->requested_address
11119 = frame_unwind_caller_pc (frame);
11120 scope_breakpoint->loc->address
11121 = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
11122 scope_breakpoint->loc->requested_address,
11123 scope_breakpoint->type);
11127 /* Now set up the breakpoint. We create all watchpoints as hardware
11128 watchpoints here even if hardware watchpoints are turned off, a call
11129 to update_watchpoint later in this function will cause the type to
11130 drop back to bp_watchpoint (software watchpoint) if required. */
11132 if (accessflag == hw_read)
11133 bp_type = bp_read_watchpoint;
11134 else if (accessflag == hw_access)
11135 bp_type = bp_access_watchpoint;
11137 bp_type = bp_hardware_watchpoint;
11139 w = XCNEW (struct watchpoint);
11142 init_raw_breakpoint_without_location (b, NULL, bp_type,
11143 &masked_watchpoint_breakpoint_ops);
11145 init_raw_breakpoint_without_location (b, NULL, bp_type,
11146 &watchpoint_breakpoint_ops);
11147 b->thread = thread;
11148 b->disposition = disp_donttouch;
11149 b->pspace = current_program_space;
11151 w->exp_valid_block = exp_valid_block;
11152 w->cond_exp_valid_block = cond_exp_valid_block;
11155 struct type *t = value_type (val);
11156 CORE_ADDR addr = value_as_address (val);
11159 t = check_typedef (TYPE_TARGET_TYPE (check_typedef (t)));
11160 name = type_to_string (t);
11162 w->exp_string_reparse = xstrprintf ("* (%s *) %s", name,
11163 core_addr_to_string (addr));
11166 w->exp_string = xstrprintf ("-location %.*s",
11167 (int) (exp_end - exp_start), exp_start);
11169 /* The above expression is in C. */
11170 b->language = language_c;
11173 w->exp_string = savestring (exp_start, exp_end - exp_start);
11177 w->hw_wp_mask = mask;
11186 b->cond_string = savestring (cond_start, cond_end - cond_start);
11188 b->cond_string = 0;
11192 w->watchpoint_frame = get_frame_id (frame);
11193 w->watchpoint_thread = inferior_ptid;
11197 w->watchpoint_frame = null_frame_id;
11198 w->watchpoint_thread = null_ptid;
11201 if (scope_breakpoint != NULL)
11203 /* The scope breakpoint is related to the watchpoint. We will
11204 need to act on them together. */
11205 b->related_breakpoint = scope_breakpoint;
11206 scope_breakpoint->related_breakpoint = b;
11209 if (!just_location)
11210 value_free_to_mark (mark);
11212 TRY_CATCH (e, RETURN_MASK_ALL)
11214 /* Finally update the new watchpoint. This creates the locations
11215 that should be inserted. */
11216 update_watchpoint (w, 1);
11220 delete_breakpoint (b);
11221 throw_exception (e);
11224 install_breakpoint (internal, b, 1);
11225 do_cleanups (back_to);
11228 /* Return count of debug registers needed to watch the given expression.
11229 If the watchpoint cannot be handled in hardware return zero. */
11232 can_use_hardware_watchpoint (struct value *v)
11234 int found_memory_cnt = 0;
11235 struct value *head = v;
11237 /* Did the user specifically forbid us to use hardware watchpoints? */
11238 if (!can_use_hw_watchpoints)
11241 /* Make sure that the value of the expression depends only upon
11242 memory contents, and values computed from them within GDB. If we
11243 find any register references or function calls, we can't use a
11244 hardware watchpoint.
11246 The idea here is that evaluating an expression generates a series
11247 of values, one holding the value of every subexpression. (The
11248 expression a*b+c has five subexpressions: a, b, a*b, c, and
11249 a*b+c.) GDB's values hold almost enough information to establish
11250 the criteria given above --- they identify memory lvalues,
11251 register lvalues, computed values, etcetera. So we can evaluate
11252 the expression, and then scan the chain of values that leaves
11253 behind to decide whether we can detect any possible change to the
11254 expression's final value using only hardware watchpoints.
11256 However, I don't think that the values returned by inferior
11257 function calls are special in any way. So this function may not
11258 notice that an expression involving an inferior function call
11259 can't be watched with hardware watchpoints. FIXME. */
11260 for (; v; v = value_next (v))
11262 if (VALUE_LVAL (v) == lval_memory)
11264 if (v != head && value_lazy (v))
11265 /* A lazy memory lvalue in the chain is one that GDB never
11266 needed to fetch; we either just used its address (e.g.,
11267 `a' in `a.b') or we never needed it at all (e.g., `a'
11268 in `a,b'). This doesn't apply to HEAD; if that is
11269 lazy then it was not readable, but watch it anyway. */
11273 /* Ahh, memory we actually used! Check if we can cover
11274 it with hardware watchpoints. */
11275 struct type *vtype = check_typedef (value_type (v));
11277 /* We only watch structs and arrays if user asked for it
11278 explicitly, never if they just happen to appear in a
11279 middle of some value chain. */
11281 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
11282 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
11284 CORE_ADDR vaddr = value_address (v);
11288 len = (target_exact_watchpoints
11289 && is_scalar_type_recursive (vtype))?
11290 1 : TYPE_LENGTH (value_type (v));
11292 num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
11296 found_memory_cnt += num_regs;
11300 else if (VALUE_LVAL (v) != not_lval
11301 && deprecated_value_modifiable (v) == 0)
11302 return 0; /* These are values from the history (e.g., $1). */
11303 else if (VALUE_LVAL (v) == lval_register)
11304 return 0; /* Cannot watch a register with a HW watchpoint. */
11307 /* The expression itself looks suitable for using a hardware
11308 watchpoint, but give the target machine a chance to reject it. */
11309 return found_memory_cnt;
11313 watch_command_wrapper (char *arg, int from_tty, int internal)
11315 watch_command_1 (arg, hw_write, from_tty, 0, internal);
11318 /* A helper function that looks for the "-location" argument and then
11319 calls watch_command_1. */
11322 watch_maybe_just_location (char *arg, int accessflag, int from_tty)
11324 int just_location = 0;
11327 && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
11328 || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
11330 arg = skip_spaces (arg);
11334 watch_command_1 (arg, accessflag, from_tty, just_location, 0);
11338 watch_command (char *arg, int from_tty)
11340 watch_maybe_just_location (arg, hw_write, from_tty);
11344 rwatch_command_wrapper (char *arg, int from_tty, int internal)
11346 watch_command_1 (arg, hw_read, from_tty, 0, internal);
11350 rwatch_command (char *arg, int from_tty)
11352 watch_maybe_just_location (arg, hw_read, from_tty);
11356 awatch_command_wrapper (char *arg, int from_tty, int internal)
11358 watch_command_1 (arg, hw_access, from_tty, 0, internal);
11362 awatch_command (char *arg, int from_tty)
11364 watch_maybe_just_location (arg, hw_access, from_tty);
11368 /* Helper routines for the until_command routine in infcmd.c. Here
11369 because it uses the mechanisms of breakpoints. */
11371 struct until_break_command_continuation_args
11373 struct breakpoint *breakpoint;
11374 struct breakpoint *breakpoint2;
11378 /* This function is called by fetch_inferior_event via the
11379 cmd_continuation pointer, to complete the until command. It takes
11380 care of cleaning up the temporary breakpoints set up by the until
11383 until_break_command_continuation (void *arg, int err)
11385 struct until_break_command_continuation_args *a = arg;
11387 delete_breakpoint (a->breakpoint);
11388 if (a->breakpoint2)
11389 delete_breakpoint (a->breakpoint2);
11390 delete_longjmp_breakpoint (a->thread_num);
11394 until_break_command (char *arg, int from_tty, int anywhere)
11396 struct symtabs_and_lines sals;
11397 struct symtab_and_line sal;
11398 struct frame_info *frame;
11399 struct gdbarch *frame_gdbarch;
11400 struct frame_id stack_frame_id;
11401 struct frame_id caller_frame_id;
11402 struct breakpoint *breakpoint;
11403 struct breakpoint *breakpoint2 = NULL;
11404 struct cleanup *old_chain;
11406 struct thread_info *tp;
11408 clear_proceed_status ();
11410 /* Set a breakpoint where the user wants it and at return from
11413 if (last_displayed_sal_is_valid ())
11414 sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
11415 get_last_displayed_symtab (),
11416 get_last_displayed_line ());
11418 sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
11419 (struct symtab *) NULL, 0);
11421 if (sals.nelts != 1)
11422 error (_("Couldn't get information on specified line."));
11424 sal = sals.sals[0];
11425 xfree (sals.sals); /* malloc'd, so freed. */
11428 error (_("Junk at end of arguments."));
11430 resolve_sal_pc (&sal);
11432 tp = inferior_thread ();
11435 old_chain = make_cleanup (null_cleanup, NULL);
11437 /* Note linespec handling above invalidates the frame chain.
11438 Installing a breakpoint also invalidates the frame chain (as it
11439 may need to switch threads), so do any frame handling before
11442 frame = get_selected_frame (NULL);
11443 frame_gdbarch = get_frame_arch (frame);
11444 stack_frame_id = get_stack_frame_id (frame);
11445 caller_frame_id = frame_unwind_caller_id (frame);
11447 /* Keep within the current frame, or in frames called by the current
11450 if (frame_id_p (caller_frame_id))
11452 struct symtab_and_line sal2;
11454 sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11455 sal2.pc = frame_unwind_caller_pc (frame);
11456 breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
11460 make_cleanup_delete_breakpoint (breakpoint2);
11462 set_longjmp_breakpoint (tp, caller_frame_id);
11463 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
11466 /* set_momentary_breakpoint could invalidate FRAME. */
11470 /* If the user told us to continue until a specified location,
11471 we don't specify a frame at which we need to stop. */
11472 breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11473 null_frame_id, bp_until);
11475 /* Otherwise, specify the selected frame, because we want to stop
11476 only at the very same frame. */
11477 breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11478 stack_frame_id, bp_until);
11479 make_cleanup_delete_breakpoint (breakpoint);
11481 proceed (-1, GDB_SIGNAL_DEFAULT, 0);
11483 /* If we are running asynchronously, and proceed call above has
11484 actually managed to start the target, arrange for breakpoints to
11485 be deleted when the target stops. Otherwise, we're already
11486 stopped and delete breakpoints via cleanup chain. */
11488 if (target_can_async_p () && is_running (inferior_ptid))
11490 struct until_break_command_continuation_args *args;
11491 args = xmalloc (sizeof (*args));
11493 args->breakpoint = breakpoint;
11494 args->breakpoint2 = breakpoint2;
11495 args->thread_num = thread;
11497 discard_cleanups (old_chain);
11498 add_continuation (inferior_thread (),
11499 until_break_command_continuation, args,
11503 do_cleanups (old_chain);
11506 /* This function attempts to parse an optional "if <cond>" clause
11507 from the arg string. If one is not found, it returns NULL.
11509 Else, it returns a pointer to the condition string. (It does not
11510 attempt to evaluate the string against a particular block.) And,
11511 it updates arg to point to the first character following the parsed
11512 if clause in the arg string. */
11515 ep_parse_optional_if_clause (char **arg)
11519 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
11522 /* Skip the "if" keyword. */
11525 /* Skip any extra leading whitespace, and record the start of the
11526 condition string. */
11527 *arg = skip_spaces (*arg);
11528 cond_string = *arg;
11530 /* Assume that the condition occupies the remainder of the arg
11532 (*arg) += strlen (cond_string);
11534 return cond_string;
11537 /* Commands to deal with catching events, such as signals, exceptions,
11538 process start/exit, etc. */
11542 catch_fork_temporary, catch_vfork_temporary,
11543 catch_fork_permanent, catch_vfork_permanent
11548 catch_fork_command_1 (char *arg, int from_tty,
11549 struct cmd_list_element *command)
11551 struct gdbarch *gdbarch = get_current_arch ();
11552 char *cond_string = NULL;
11553 catch_fork_kind fork_kind;
11556 fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11557 tempflag = (fork_kind == catch_fork_temporary
11558 || fork_kind == catch_vfork_temporary);
11562 arg = skip_spaces (arg);
11564 /* The allowed syntax is:
11566 catch [v]fork if <cond>
11568 First, check if there's an if clause. */
11569 cond_string = ep_parse_optional_if_clause (&arg);
11571 if ((*arg != '\0') && !isspace (*arg))
11572 error (_("Junk at end of arguments."));
11574 /* If this target supports it, create a fork or vfork catchpoint
11575 and enable reporting of such events. */
11578 case catch_fork_temporary:
11579 case catch_fork_permanent:
11580 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11581 &catch_fork_breakpoint_ops);
11583 case catch_vfork_temporary:
11584 case catch_vfork_permanent:
11585 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11586 &catch_vfork_breakpoint_ops);
11589 error (_("unsupported or unknown fork kind; cannot catch it"));
11595 catch_exec_command_1 (char *arg, int from_tty,
11596 struct cmd_list_element *command)
11598 struct exec_catchpoint *c;
11599 struct gdbarch *gdbarch = get_current_arch ();
11601 char *cond_string = NULL;
11603 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11607 arg = skip_spaces (arg);
11609 /* The allowed syntax is:
11611 catch exec if <cond>
11613 First, check if there's an if clause. */
11614 cond_string = ep_parse_optional_if_clause (&arg);
11616 if ((*arg != '\0') && !isspace (*arg))
11617 error (_("Junk at end of arguments."));
11619 c = XNEW (struct exec_catchpoint);
11620 init_catchpoint (&c->base, gdbarch, tempflag, cond_string,
11621 &catch_exec_breakpoint_ops);
11622 c->exec_pathname = NULL;
11624 install_breakpoint (0, &c->base, 1);
11628 init_ada_exception_breakpoint (struct breakpoint *b,
11629 struct gdbarch *gdbarch,
11630 struct symtab_and_line sal,
11632 const struct breakpoint_ops *ops,
11639 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11641 loc_gdbarch = gdbarch;
11643 describe_other_breakpoints (loc_gdbarch,
11644 sal.pspace, sal.pc, sal.section, -1);
11645 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11646 version for exception catchpoints, because two catchpoints
11647 used for different exception names will use the same address.
11648 In this case, a "breakpoint ... also set at..." warning is
11649 unproductive. Besides, the warning phrasing is also a bit
11650 inappropriate, we should use the word catchpoint, and tell
11651 the user what type of catchpoint it is. The above is good
11652 enough for now, though. */
11655 init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
11657 b->enable_state = enabled ? bp_enabled : bp_disabled;
11658 b->disposition = tempflag ? disp_del : disp_donttouch;
11659 b->addr_string = addr_string;
11660 b->language = language_ada;
11663 /* Splits the argument using space as delimiter. Returns an xmalloc'd
11664 filter list, or NULL if no filtering is required. */
11666 catch_syscall_split_args (char *arg)
11668 VEC(int) *result = NULL;
11669 struct cleanup *cleanup = make_cleanup (VEC_cleanup (int), &result);
11671 while (*arg != '\0')
11673 int i, syscall_number;
11675 char cur_name[128];
11678 /* Skip whitespace. */
11679 arg = skip_spaces (arg);
11681 for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
11682 cur_name[i] = arg[i];
11683 cur_name[i] = '\0';
11686 /* Check if the user provided a syscall name or a number. */
11687 syscall_number = (int) strtol (cur_name, &endptr, 0);
11688 if (*endptr == '\0')
11689 get_syscall_by_number (syscall_number, &s);
11692 /* We have a name. Let's check if it's valid and convert it
11694 get_syscall_by_name (cur_name, &s);
11696 if (s.number == UNKNOWN_SYSCALL)
11697 /* Here we have to issue an error instead of a warning,
11698 because GDB cannot do anything useful if there's no
11699 syscall number to be caught. */
11700 error (_("Unknown syscall name '%s'."), cur_name);
11703 /* Ok, it's valid. */
11704 VEC_safe_push (int, result, s.number);
11707 discard_cleanups (cleanup);
11711 /* Implement the "catch syscall" command. */
11714 catch_syscall_command_1 (char *arg, int from_tty,
11715 struct cmd_list_element *command)
11720 struct gdbarch *gdbarch = get_current_arch ();
11722 /* Checking if the feature if supported. */
11723 if (gdbarch_get_syscall_number_p (gdbarch) == 0)
11724 error (_("The feature 'catch syscall' is not supported on \
11725 this architecture yet."));
11727 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11729 arg = skip_spaces (arg);
11731 /* We need to do this first "dummy" translation in order
11732 to get the syscall XML file loaded or, most important,
11733 to display a warning to the user if there's no XML file
11734 for his/her architecture. */
11735 get_syscall_by_number (0, &s);
11737 /* The allowed syntax is:
11739 catch syscall <name | number> [<name | number> ... <name | number>]
11741 Let's check if there's a syscall name. */
11744 filter = catch_syscall_split_args (arg);
11748 create_syscall_event_catchpoint (tempflag, filter,
11749 &catch_syscall_breakpoint_ops);
11753 catch_command (char *arg, int from_tty)
11755 error (_("Catch requires an event name."));
11760 tcatch_command (char *arg, int from_tty)
11762 error (_("Catch requires an event name."));
11765 /* A qsort comparison function that sorts breakpoints in order. */
11768 compare_breakpoints (const void *a, const void *b)
11770 const breakpoint_p *ba = a;
11771 uintptr_t ua = (uintptr_t) *ba;
11772 const breakpoint_p *bb = b;
11773 uintptr_t ub = (uintptr_t) *bb;
11775 if ((*ba)->number < (*bb)->number)
11777 else if ((*ba)->number > (*bb)->number)
11780 /* Now sort by address, in case we see, e..g, two breakpoints with
11784 return ua > ub ? 1 : 0;
11787 /* Delete breakpoints by address or line. */
11790 clear_command (char *arg, int from_tty)
11792 struct breakpoint *b, *prev;
11793 VEC(breakpoint_p) *found = 0;
11796 struct symtabs_and_lines sals;
11797 struct symtab_and_line sal;
11799 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
11803 sals = decode_line_with_current_source (arg,
11804 (DECODE_LINE_FUNFIRSTLINE
11805 | DECODE_LINE_LIST_MODE));
11806 make_cleanup (xfree, sals.sals);
11811 sals.sals = (struct symtab_and_line *)
11812 xmalloc (sizeof (struct symtab_and_line));
11813 make_cleanup (xfree, sals.sals);
11814 init_sal (&sal); /* Initialize to zeroes. */
11816 /* Set sal's line, symtab, pc, and pspace to the values
11817 corresponding to the last call to print_frame_info. If the
11818 codepoint is not valid, this will set all the fields to 0. */
11819 get_last_displayed_sal (&sal);
11820 if (sal.symtab == 0)
11821 error (_("No source file specified."));
11823 sals.sals[0] = sal;
11829 /* We don't call resolve_sal_pc here. That's not as bad as it
11830 seems, because all existing breakpoints typically have both
11831 file/line and pc set. So, if clear is given file/line, we can
11832 match this to existing breakpoint without obtaining pc at all.
11834 We only support clearing given the address explicitly
11835 present in breakpoint table. Say, we've set breakpoint
11836 at file:line. There were several PC values for that file:line,
11837 due to optimization, all in one block.
11839 We've picked one PC value. If "clear" is issued with another
11840 PC corresponding to the same file:line, the breakpoint won't
11841 be cleared. We probably can still clear the breakpoint, but
11842 since the other PC value is never presented to user, user
11843 can only find it by guessing, and it does not seem important
11844 to support that. */
11846 /* For each line spec given, delete bps which correspond to it. Do
11847 it in two passes, solely to preserve the current behavior that
11848 from_tty is forced true if we delete more than one
11852 make_cleanup (VEC_cleanup (breakpoint_p), &found);
11853 for (i = 0; i < sals.nelts; i++)
11855 const char *sal_fullname;
11857 /* If exact pc given, clear bpts at that pc.
11858 If line given (pc == 0), clear all bpts on specified line.
11859 If defaulting, clear all bpts on default line
11862 defaulting sal.pc != 0 tests to do
11867 1 0 <can't happen> */
11869 sal = sals.sals[i];
11870 sal_fullname = (sal.symtab == NULL
11871 ? NULL : symtab_to_fullname (sal.symtab));
11873 /* Find all matching breakpoints and add them to 'found'. */
11874 ALL_BREAKPOINTS (b)
11877 /* Are we going to delete b? */
11878 if (b->type != bp_none && !is_watchpoint (b))
11880 struct bp_location *loc = b->loc;
11881 for (; loc; loc = loc->next)
11883 /* If the user specified file:line, don't allow a PC
11884 match. This matches historical gdb behavior. */
11885 int pc_match = (!sal.explicit_line
11887 && (loc->pspace == sal.pspace)
11888 && (loc->address == sal.pc)
11889 && (!section_is_overlay (loc->section)
11890 || loc->section == sal.section));
11891 int line_match = 0;
11893 if ((default_match || sal.explicit_line)
11894 && loc->symtab != NULL
11895 && sal_fullname != NULL
11896 && sal.pspace == loc->pspace
11897 && loc->line_number == sal.line
11898 && filename_cmp (symtab_to_fullname (loc->symtab),
11899 sal_fullname) == 0)
11902 if (pc_match || line_match)
11911 VEC_safe_push(breakpoint_p, found, b);
11915 /* Now go thru the 'found' chain and delete them. */
11916 if (VEC_empty(breakpoint_p, found))
11919 error (_("No breakpoint at %s."), arg);
11921 error (_("No breakpoint at this line."));
11924 /* Remove duplicates from the vec. */
11925 qsort (VEC_address (breakpoint_p, found),
11926 VEC_length (breakpoint_p, found),
11927 sizeof (breakpoint_p),
11928 compare_breakpoints);
11929 prev = VEC_index (breakpoint_p, found, 0);
11930 for (ix = 1; VEC_iterate (breakpoint_p, found, ix, b); ++ix)
11934 VEC_ordered_remove (breakpoint_p, found, ix);
11939 if (VEC_length(breakpoint_p, found) > 1)
11940 from_tty = 1; /* Always report if deleted more than one. */
11943 if (VEC_length(breakpoint_p, found) == 1)
11944 printf_unfiltered (_("Deleted breakpoint "));
11946 printf_unfiltered (_("Deleted breakpoints "));
11949 for (ix = 0; VEC_iterate(breakpoint_p, found, ix, b); ix++)
11952 printf_unfiltered ("%d ", b->number);
11953 delete_breakpoint (b);
11956 putchar_unfiltered ('\n');
11958 do_cleanups (cleanups);
11961 /* Delete breakpoint in BS if they are `delete' breakpoints and
11962 all breakpoints that are marked for deletion, whether hit or not.
11963 This is called after any breakpoint is hit, or after errors. */
11966 breakpoint_auto_delete (bpstat bs)
11968 struct breakpoint *b, *b_tmp;
11970 for (; bs; bs = bs->next)
11971 if (bs->breakpoint_at
11972 && bs->breakpoint_at->disposition == disp_del
11974 delete_breakpoint (bs->breakpoint_at);
11976 ALL_BREAKPOINTS_SAFE (b, b_tmp)
11978 if (b->disposition == disp_del_at_next_stop)
11979 delete_breakpoint (b);
11983 /* A comparison function for bp_location AP and BP being interfaced to
11984 qsort. Sort elements primarily by their ADDRESS (no matter what
11985 does breakpoint_address_is_meaningful say for its OWNER),
11986 secondarily by ordering first bp_permanent OWNERed elements and
11987 terciarily just ensuring the array is sorted stable way despite
11988 qsort being an unstable algorithm. */
11991 bp_location_compare (const void *ap, const void *bp)
11993 struct bp_location *a = *(void **) ap;
11994 struct bp_location *b = *(void **) bp;
11995 /* A and B come from existing breakpoints having non-NULL OWNER. */
11996 int a_perm = a->owner->enable_state == bp_permanent;
11997 int b_perm = b->owner->enable_state == bp_permanent;
11999 if (a->address != b->address)
12000 return (a->address > b->address) - (a->address < b->address);
12002 /* Sort locations at the same address by their pspace number, keeping
12003 locations of the same inferior (in a multi-inferior environment)
12006 if (a->pspace->num != b->pspace->num)
12007 return ((a->pspace->num > b->pspace->num)
12008 - (a->pspace->num < b->pspace->num));
12010 /* Sort permanent breakpoints first. */
12011 if (a_perm != b_perm)
12012 return (a_perm < b_perm) - (a_perm > b_perm);
12014 /* Make the internal GDB representation stable across GDB runs
12015 where A and B memory inside GDB can differ. Breakpoint locations of
12016 the same type at the same address can be sorted in arbitrary order. */
12018 if (a->owner->number != b->owner->number)
12019 return ((a->owner->number > b->owner->number)
12020 - (a->owner->number < b->owner->number));
12022 return (a > b) - (a < b);
12025 /* Set bp_location_placed_address_before_address_max and
12026 bp_location_shadow_len_after_address_max according to the current
12027 content of the bp_location array. */
12030 bp_location_target_extensions_update (void)
12032 struct bp_location *bl, **blp_tmp;
12034 bp_location_placed_address_before_address_max = 0;
12035 bp_location_shadow_len_after_address_max = 0;
12037 ALL_BP_LOCATIONS (bl, blp_tmp)
12039 CORE_ADDR start, end, addr;
12041 if (!bp_location_has_shadow (bl))
12044 start = bl->target_info.placed_address;
12045 end = start + bl->target_info.shadow_len;
12047 gdb_assert (bl->address >= start);
12048 addr = bl->address - start;
12049 if (addr > bp_location_placed_address_before_address_max)
12050 bp_location_placed_address_before_address_max = addr;
12052 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
12054 gdb_assert (bl->address < end);
12055 addr = end - bl->address;
12056 if (addr > bp_location_shadow_len_after_address_max)
12057 bp_location_shadow_len_after_address_max = addr;
12061 /* Download tracepoint locations if they haven't been. */
12064 download_tracepoint_locations (void)
12066 struct breakpoint *b;
12067 struct cleanup *old_chain;
12069 if (!target_can_download_tracepoint ())
12072 old_chain = save_current_space_and_thread ();
12074 ALL_TRACEPOINTS (b)
12076 struct bp_location *bl;
12077 struct tracepoint *t;
12078 int bp_location_downloaded = 0;
12080 if ((b->type == bp_fast_tracepoint
12081 ? !may_insert_fast_tracepoints
12082 : !may_insert_tracepoints))
12085 for (bl = b->loc; bl; bl = bl->next)
12087 /* In tracepoint, locations are _never_ duplicated, so
12088 should_be_inserted is equivalent to
12089 unduplicated_should_be_inserted. */
12090 if (!should_be_inserted (bl) || bl->inserted)
12093 switch_to_program_space_and_thread (bl->pspace);
12095 target_download_tracepoint (bl);
12098 bp_location_downloaded = 1;
12100 t = (struct tracepoint *) b;
12101 t->number_on_target = b->number;
12102 if (bp_location_downloaded)
12103 observer_notify_breakpoint_modified (b);
12106 do_cleanups (old_chain);
12109 /* Swap the insertion/duplication state between two locations. */
12112 swap_insertion (struct bp_location *left, struct bp_location *right)
12114 const int left_inserted = left->inserted;
12115 const int left_duplicate = left->duplicate;
12116 const int left_needs_update = left->needs_update;
12117 const struct bp_target_info left_target_info = left->target_info;
12119 /* Locations of tracepoints can never be duplicated. */
12120 if (is_tracepoint (left->owner))
12121 gdb_assert (!left->duplicate);
12122 if (is_tracepoint (right->owner))
12123 gdb_assert (!right->duplicate);
12125 left->inserted = right->inserted;
12126 left->duplicate = right->duplicate;
12127 left->needs_update = right->needs_update;
12128 left->target_info = right->target_info;
12129 right->inserted = left_inserted;
12130 right->duplicate = left_duplicate;
12131 right->needs_update = left_needs_update;
12132 right->target_info = left_target_info;
12135 /* Force the re-insertion of the locations at ADDRESS. This is called
12136 once a new/deleted/modified duplicate location is found and we are evaluating
12137 conditions on the target's side. Such conditions need to be updated on
12141 force_breakpoint_reinsertion (struct bp_location *bl)
12143 struct bp_location **locp = NULL, **loc2p;
12144 struct bp_location *loc;
12145 CORE_ADDR address = 0;
12148 address = bl->address;
12149 pspace_num = bl->pspace->num;
12151 /* This is only meaningful if the target is
12152 evaluating conditions and if the user has
12153 opted for condition evaluation on the target's
12155 if (gdb_evaluates_breakpoint_condition_p ()
12156 || !target_supports_evaluation_of_breakpoint_conditions ())
12159 /* Flag all breakpoint locations with this address and
12160 the same program space as the location
12161 as "its condition has changed". We need to
12162 update the conditions on the target's side. */
12163 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
12167 if (!is_breakpoint (loc->owner)
12168 || pspace_num != loc->pspace->num)
12171 /* Flag the location appropriately. We use a different state to
12172 let everyone know that we already updated the set of locations
12173 with addr bl->address and program space bl->pspace. This is so
12174 we don't have to keep calling these functions just to mark locations
12175 that have already been marked. */
12176 loc->condition_changed = condition_updated;
12178 /* Free the agent expression bytecode as well. We will compute
12180 if (loc->cond_bytecode)
12182 free_agent_expr (loc->cond_bytecode);
12183 loc->cond_bytecode = NULL;
12188 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
12189 into the inferior, only remove already-inserted locations that no
12190 longer should be inserted. Functions that delete a breakpoint or
12191 breakpoints should pass false, so that deleting a breakpoint
12192 doesn't have the side effect of inserting the locations of other
12193 breakpoints that are marked not-inserted, but should_be_inserted
12194 returns true on them.
12196 This behaviour is useful is situations close to tear-down -- e.g.,
12197 after an exec, while the target still has execution, but breakpoint
12198 shadows of the previous executable image should *NOT* be restored
12199 to the new image; or before detaching, where the target still has
12200 execution and wants to delete breakpoints from GDB's lists, and all
12201 breakpoints had already been removed from the inferior. */
12204 update_global_location_list (int should_insert)
12206 struct breakpoint *b;
12207 struct bp_location **locp, *loc;
12208 struct cleanup *cleanups;
12209 /* Last breakpoint location address that was marked for update. */
12210 CORE_ADDR last_addr = 0;
12211 /* Last breakpoint location program space that was marked for update. */
12212 int last_pspace_num = -1;
12214 /* Used in the duplicates detection below. When iterating over all
12215 bp_locations, points to the first bp_location of a given address.
12216 Breakpoints and watchpoints of different types are never
12217 duplicates of each other. Keep one pointer for each type of
12218 breakpoint/watchpoint, so we only need to loop over all locations
12220 struct bp_location *bp_loc_first; /* breakpoint */
12221 struct bp_location *wp_loc_first; /* hardware watchpoint */
12222 struct bp_location *awp_loc_first; /* access watchpoint */
12223 struct bp_location *rwp_loc_first; /* read watchpoint */
12225 /* Saved former bp_location array which we compare against the newly
12226 built bp_location from the current state of ALL_BREAKPOINTS. */
12227 struct bp_location **old_location, **old_locp;
12228 unsigned old_location_count;
12230 old_location = bp_location;
12231 old_location_count = bp_location_count;
12232 bp_location = NULL;
12233 bp_location_count = 0;
12234 cleanups = make_cleanup (xfree, old_location);
12236 ALL_BREAKPOINTS (b)
12237 for (loc = b->loc; loc; loc = loc->next)
12238 bp_location_count++;
12240 bp_location = xmalloc (sizeof (*bp_location) * bp_location_count);
12241 locp = bp_location;
12242 ALL_BREAKPOINTS (b)
12243 for (loc = b->loc; loc; loc = loc->next)
12245 qsort (bp_location, bp_location_count, sizeof (*bp_location),
12246 bp_location_compare);
12248 bp_location_target_extensions_update ();
12250 /* Identify bp_location instances that are no longer present in the
12251 new list, and therefore should be freed. Note that it's not
12252 necessary that those locations should be removed from inferior --
12253 if there's another location at the same address (previously
12254 marked as duplicate), we don't need to remove/insert the
12257 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12258 and former bp_location array state respectively. */
12260 locp = bp_location;
12261 for (old_locp = old_location; old_locp < old_location + old_location_count;
12264 struct bp_location *old_loc = *old_locp;
12265 struct bp_location **loc2p;
12267 /* Tells if 'old_loc' is found among the new locations. If
12268 not, we have to free it. */
12269 int found_object = 0;
12270 /* Tells if the location should remain inserted in the target. */
12271 int keep_in_target = 0;
12274 /* Skip LOCP entries which will definitely never be needed.
12275 Stop either at or being the one matching OLD_LOC. */
12276 while (locp < bp_location + bp_location_count
12277 && (*locp)->address < old_loc->address)
12281 (loc2p < bp_location + bp_location_count
12282 && (*loc2p)->address == old_loc->address);
12285 /* Check if this is a new/duplicated location or a duplicated
12286 location that had its condition modified. If so, we want to send
12287 its condition to the target if evaluation of conditions is taking
12289 if ((*loc2p)->condition_changed == condition_modified
12290 && (last_addr != old_loc->address
12291 || last_pspace_num != old_loc->pspace->num))
12293 force_breakpoint_reinsertion (*loc2p);
12294 last_pspace_num = old_loc->pspace->num;
12297 if (*loc2p == old_loc)
12301 /* We have already handled this address, update it so that we don't
12302 have to go through updates again. */
12303 last_addr = old_loc->address;
12305 /* Target-side condition evaluation: Handle deleted locations. */
12307 force_breakpoint_reinsertion (old_loc);
12309 /* If this location is no longer present, and inserted, look if
12310 there's maybe a new location at the same address. If so,
12311 mark that one inserted, and don't remove this one. This is
12312 needed so that we don't have a time window where a breakpoint
12313 at certain location is not inserted. */
12315 if (old_loc->inserted)
12317 /* If the location is inserted now, we might have to remove
12320 if (found_object && should_be_inserted (old_loc))
12322 /* The location is still present in the location list,
12323 and still should be inserted. Don't do anything. */
12324 keep_in_target = 1;
12328 /* This location still exists, but it won't be kept in the
12329 target since it may have been disabled. We proceed to
12330 remove its target-side condition. */
12332 /* The location is either no longer present, or got
12333 disabled. See if there's another location at the
12334 same address, in which case we don't need to remove
12335 this one from the target. */
12337 /* OLD_LOC comes from existing struct breakpoint. */
12338 if (breakpoint_address_is_meaningful (old_loc->owner))
12341 (loc2p < bp_location + bp_location_count
12342 && (*loc2p)->address == old_loc->address);
12345 struct bp_location *loc2 = *loc2p;
12347 if (breakpoint_locations_match (loc2, old_loc))
12349 /* Read watchpoint locations are switched to
12350 access watchpoints, if the former are not
12351 supported, but the latter are. */
12352 if (is_hardware_watchpoint (old_loc->owner))
12354 gdb_assert (is_hardware_watchpoint (loc2->owner));
12355 loc2->watchpoint_type = old_loc->watchpoint_type;
12358 /* loc2 is a duplicated location. We need to check
12359 if it should be inserted in case it will be
12361 if (loc2 != old_loc
12362 && unduplicated_should_be_inserted (loc2))
12364 swap_insertion (old_loc, loc2);
12365 keep_in_target = 1;
12373 if (!keep_in_target)
12375 if (remove_breakpoint (old_loc, mark_uninserted))
12377 /* This is just about all we can do. We could keep
12378 this location on the global list, and try to
12379 remove it next time, but there's no particular
12380 reason why we will succeed next time.
12382 Note that at this point, old_loc->owner is still
12383 valid, as delete_breakpoint frees the breakpoint
12384 only after calling us. */
12385 printf_filtered (_("warning: Error removing "
12386 "breakpoint %d\n"),
12387 old_loc->owner->number);
12395 if (removed && non_stop
12396 && breakpoint_address_is_meaningful (old_loc->owner)
12397 && !is_hardware_watchpoint (old_loc->owner))
12399 /* This location was removed from the target. In
12400 non-stop mode, a race condition is possible where
12401 we've removed a breakpoint, but stop events for that
12402 breakpoint are already queued and will arrive later.
12403 We apply an heuristic to be able to distinguish such
12404 SIGTRAPs from other random SIGTRAPs: we keep this
12405 breakpoint location for a bit, and will retire it
12406 after we see some number of events. The theory here
12407 is that reporting of events should, "on the average",
12408 be fair, so after a while we'll see events from all
12409 threads that have anything of interest, and no longer
12410 need to keep this breakpoint location around. We
12411 don't hold locations forever so to reduce chances of
12412 mistaking a non-breakpoint SIGTRAP for a breakpoint
12415 The heuristic failing can be disastrous on
12416 decr_pc_after_break targets.
12418 On decr_pc_after_break targets, like e.g., x86-linux,
12419 if we fail to recognize a late breakpoint SIGTRAP,
12420 because events_till_retirement has reached 0 too
12421 soon, we'll fail to do the PC adjustment, and report
12422 a random SIGTRAP to the user. When the user resumes
12423 the inferior, it will most likely immediately crash
12424 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12425 corrupted, because of being resumed e.g., in the
12426 middle of a multi-byte instruction, or skipped a
12427 one-byte instruction. This was actually seen happen
12428 on native x86-linux, and should be less rare on
12429 targets that do not support new thread events, like
12430 remote, due to the heuristic depending on
12433 Mistaking a random SIGTRAP for a breakpoint trap
12434 causes similar symptoms (PC adjustment applied when
12435 it shouldn't), but then again, playing with SIGTRAPs
12436 behind the debugger's back is asking for trouble.
12438 Since hardware watchpoint traps are always
12439 distinguishable from other traps, so we don't need to
12440 apply keep hardware watchpoint moribund locations
12441 around. We simply always ignore hardware watchpoint
12442 traps we can no longer explain. */
12444 old_loc->events_till_retirement = 3 * (thread_count () + 1);
12445 old_loc->owner = NULL;
12447 VEC_safe_push (bp_location_p, moribund_locations, old_loc);
12451 old_loc->owner = NULL;
12452 decref_bp_location (&old_loc);
12457 /* Rescan breakpoints at the same address and section, marking the
12458 first one as "first" and any others as "duplicates". This is so
12459 that the bpt instruction is only inserted once. If we have a
12460 permanent breakpoint at the same place as BPT, make that one the
12461 official one, and the rest as duplicates. Permanent breakpoints
12462 are sorted first for the same address.
12464 Do the same for hardware watchpoints, but also considering the
12465 watchpoint's type (regular/access/read) and length. */
12467 bp_loc_first = NULL;
12468 wp_loc_first = NULL;
12469 awp_loc_first = NULL;
12470 rwp_loc_first = NULL;
12471 ALL_BP_LOCATIONS (loc, locp)
12473 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12475 struct bp_location **loc_first_p;
12478 if (!unduplicated_should_be_inserted (loc)
12479 || !breakpoint_address_is_meaningful (b)
12480 /* Don't detect duplicate for tracepoint locations because they are
12481 never duplicated. See the comments in field `duplicate' of
12482 `struct bp_location'. */
12483 || is_tracepoint (b))
12485 /* Clear the condition modification flag. */
12486 loc->condition_changed = condition_unchanged;
12490 /* Permanent breakpoint should always be inserted. */
12491 if (b->enable_state == bp_permanent && ! loc->inserted)
12492 internal_error (__FILE__, __LINE__,
12493 _("allegedly permanent breakpoint is not "
12494 "actually inserted"));
12496 if (b->type == bp_hardware_watchpoint)
12497 loc_first_p = &wp_loc_first;
12498 else if (b->type == bp_read_watchpoint)
12499 loc_first_p = &rwp_loc_first;
12500 else if (b->type == bp_access_watchpoint)
12501 loc_first_p = &awp_loc_first;
12503 loc_first_p = &bp_loc_first;
12505 if (*loc_first_p == NULL
12506 || (overlay_debugging && loc->section != (*loc_first_p)->section)
12507 || !breakpoint_locations_match (loc, *loc_first_p))
12509 *loc_first_p = loc;
12510 loc->duplicate = 0;
12512 if (is_breakpoint (loc->owner) && loc->condition_changed)
12514 loc->needs_update = 1;
12515 /* Clear the condition modification flag. */
12516 loc->condition_changed = condition_unchanged;
12522 /* This and the above ensure the invariant that the first location
12523 is not duplicated, and is the inserted one.
12524 All following are marked as duplicated, and are not inserted. */
12526 swap_insertion (loc, *loc_first_p);
12527 loc->duplicate = 1;
12529 /* Clear the condition modification flag. */
12530 loc->condition_changed = condition_unchanged;
12532 if ((*loc_first_p)->owner->enable_state == bp_permanent && loc->inserted
12533 && b->enable_state != bp_permanent)
12534 internal_error (__FILE__, __LINE__,
12535 _("another breakpoint was inserted on top of "
12536 "a permanent breakpoint"));
12539 if (breakpoints_always_inserted_mode ()
12540 && (have_live_inferiors ()
12541 || (gdbarch_has_global_breakpoints (target_gdbarch ()))))
12544 insert_breakpoint_locations ();
12547 /* Though should_insert is false, we may need to update conditions
12548 on the target's side if it is evaluating such conditions. We
12549 only update conditions for locations that are marked
12551 update_inserted_breakpoint_locations ();
12556 download_tracepoint_locations ();
12558 do_cleanups (cleanups);
12562 breakpoint_retire_moribund (void)
12564 struct bp_location *loc;
12567 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
12568 if (--(loc->events_till_retirement) == 0)
12570 decref_bp_location (&loc);
12571 VEC_unordered_remove (bp_location_p, moribund_locations, ix);
12577 update_global_location_list_nothrow (int inserting)
12579 volatile struct gdb_exception e;
12581 TRY_CATCH (e, RETURN_MASK_ERROR)
12582 update_global_location_list (inserting);
12585 /* Clear BKP from a BPS. */
12588 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12592 for (bs = bps; bs; bs = bs->next)
12593 if (bs->breakpoint_at == bpt)
12595 bs->breakpoint_at = NULL;
12596 bs->old_val = NULL;
12597 /* bs->commands will be freed later. */
12601 /* Callback for iterate_over_threads. */
12603 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12605 struct breakpoint *bpt = data;
12607 bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12611 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12615 say_where (struct breakpoint *b)
12617 struct value_print_options opts;
12619 get_user_print_options (&opts);
12621 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12623 if (b->loc == NULL)
12625 printf_filtered (_(" (%s) pending."), b->addr_string);
12629 if (opts.addressprint || b->loc->symtab == NULL)
12631 printf_filtered (" at ");
12632 fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
12635 if (b->loc->symtab != NULL)
12637 /* If there is a single location, we can print the location
12639 if (b->loc->next == NULL)
12640 printf_filtered (": file %s, line %d.",
12641 symtab_to_filename_for_display (b->loc->symtab),
12642 b->loc->line_number);
12644 /* This is not ideal, but each location may have a
12645 different file name, and this at least reflects the
12646 real situation somewhat. */
12647 printf_filtered (": %s.", b->addr_string);
12652 struct bp_location *loc = b->loc;
12654 for (; loc; loc = loc->next)
12656 printf_filtered (" (%d locations)", n);
12661 /* Default bp_location_ops methods. */
12664 bp_location_dtor (struct bp_location *self)
12666 xfree (self->cond);
12667 if (self->cond_bytecode)
12668 free_agent_expr (self->cond_bytecode);
12669 xfree (self->function_name);
12672 static const struct bp_location_ops bp_location_ops =
12677 /* Default breakpoint_ops methods all breakpoint_ops ultimately
12681 base_breakpoint_dtor (struct breakpoint *self)
12683 decref_counted_command_line (&self->commands);
12684 xfree (self->cond_string);
12685 xfree (self->extra_string);
12686 xfree (self->addr_string);
12687 xfree (self->filter);
12688 xfree (self->addr_string_range_end);
12691 static struct bp_location *
12692 base_breakpoint_allocate_location (struct breakpoint *self)
12694 struct bp_location *loc;
12696 loc = XNEW (struct bp_location);
12697 init_bp_location (loc, &bp_location_ops, self);
12702 base_breakpoint_re_set (struct breakpoint *b)
12704 /* Nothing to re-set. */
12707 #define internal_error_pure_virtual_called() \
12708 gdb_assert_not_reached ("pure virtual function called")
12711 base_breakpoint_insert_location (struct bp_location *bl)
12713 internal_error_pure_virtual_called ();
12717 base_breakpoint_remove_location (struct bp_location *bl)
12719 internal_error_pure_virtual_called ();
12723 base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12724 struct address_space *aspace,
12726 const struct target_waitstatus *ws)
12728 internal_error_pure_virtual_called ();
12732 base_breakpoint_check_status (bpstat bs)
12737 /* A "works_in_software_mode" breakpoint_ops method that just internal
12741 base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12743 internal_error_pure_virtual_called ();
12746 /* A "resources_needed" breakpoint_ops method that just internal
12750 base_breakpoint_resources_needed (const struct bp_location *bl)
12752 internal_error_pure_virtual_called ();
12755 static enum print_stop_action
12756 base_breakpoint_print_it (bpstat bs)
12758 internal_error_pure_virtual_called ();
12762 base_breakpoint_print_one_detail (const struct breakpoint *self,
12763 struct ui_out *uiout)
12769 base_breakpoint_print_mention (struct breakpoint *b)
12771 internal_error_pure_virtual_called ();
12775 base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12777 internal_error_pure_virtual_called ();
12781 base_breakpoint_create_sals_from_address (char **arg,
12782 struct linespec_result *canonical,
12783 enum bptype type_wanted,
12787 internal_error_pure_virtual_called ();
12791 base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12792 struct linespec_result *c,
12794 char *extra_string,
12795 enum bptype type_wanted,
12796 enum bpdisp disposition,
12798 int task, int ignore_count,
12799 const struct breakpoint_ops *o,
12800 int from_tty, int enabled,
12801 int internal, unsigned flags)
12803 internal_error_pure_virtual_called ();
12807 base_breakpoint_decode_linespec (struct breakpoint *b, char **s,
12808 struct symtabs_and_lines *sals)
12810 internal_error_pure_virtual_called ();
12813 /* The default 'explains_signal' method. */
12815 static enum bpstat_signal_value
12816 base_breakpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
12818 return BPSTAT_SIGNAL_HIDE;
12821 /* The default "after_condition_true" method. */
12824 base_breakpoint_after_condition_true (struct bpstats *bs)
12826 /* Nothing to do. */
12829 struct breakpoint_ops base_breakpoint_ops =
12831 base_breakpoint_dtor,
12832 base_breakpoint_allocate_location,
12833 base_breakpoint_re_set,
12834 base_breakpoint_insert_location,
12835 base_breakpoint_remove_location,
12836 base_breakpoint_breakpoint_hit,
12837 base_breakpoint_check_status,
12838 base_breakpoint_resources_needed,
12839 base_breakpoint_works_in_software_mode,
12840 base_breakpoint_print_it,
12842 base_breakpoint_print_one_detail,
12843 base_breakpoint_print_mention,
12844 base_breakpoint_print_recreate,
12845 base_breakpoint_create_sals_from_address,
12846 base_breakpoint_create_breakpoints_sal,
12847 base_breakpoint_decode_linespec,
12848 base_breakpoint_explains_signal,
12849 base_breakpoint_after_condition_true,
12852 /* Default breakpoint_ops methods. */
12855 bkpt_re_set (struct breakpoint *b)
12857 /* FIXME: is this still reachable? */
12858 if (b->addr_string == NULL)
12860 /* Anything without a string can't be re-set. */
12861 delete_breakpoint (b);
12865 breakpoint_re_set_default (b);
12869 bkpt_insert_location (struct bp_location *bl)
12871 if (bl->loc_type == bp_loc_hardware_breakpoint)
12872 return target_insert_hw_breakpoint (bl->gdbarch,
12875 return target_insert_breakpoint (bl->gdbarch,
12880 bkpt_remove_location (struct bp_location *bl)
12882 if (bl->loc_type == bp_loc_hardware_breakpoint)
12883 return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
12885 return target_remove_breakpoint (bl->gdbarch, &bl->target_info);
12889 bkpt_breakpoint_hit (const struct bp_location *bl,
12890 struct address_space *aspace, CORE_ADDR bp_addr,
12891 const struct target_waitstatus *ws)
12893 if (ws->kind != TARGET_WAITKIND_STOPPED
12894 || ws->value.sig != GDB_SIGNAL_TRAP)
12897 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
12901 if (overlay_debugging /* unmapped overlay section */
12902 && section_is_overlay (bl->section)
12903 && !section_is_mapped (bl->section))
12910 bkpt_resources_needed (const struct bp_location *bl)
12912 gdb_assert (bl->owner->type == bp_hardware_breakpoint);
12917 static enum print_stop_action
12918 bkpt_print_it (bpstat bs)
12920 struct breakpoint *b;
12921 const struct bp_location *bl;
12923 struct ui_out *uiout = current_uiout;
12925 gdb_assert (bs->bp_location_at != NULL);
12927 bl = bs->bp_location_at;
12928 b = bs->breakpoint_at;
12930 bp_temp = b->disposition == disp_del;
12931 if (bl->address != bl->requested_address)
12932 breakpoint_adjustment_warning (bl->requested_address,
12935 annotate_breakpoint (b->number);
12937 ui_out_text (uiout, "\nTemporary breakpoint ");
12939 ui_out_text (uiout, "\nBreakpoint ");
12940 if (ui_out_is_mi_like_p (uiout))
12942 ui_out_field_string (uiout, "reason",
12943 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
12944 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
12946 ui_out_field_int (uiout, "bkptno", b->number);
12947 ui_out_text (uiout, ", ");
12949 return PRINT_SRC_AND_LOC;
12953 bkpt_print_mention (struct breakpoint *b)
12955 if (ui_out_is_mi_like_p (current_uiout))
12960 case bp_breakpoint:
12961 case bp_gnu_ifunc_resolver:
12962 if (b->disposition == disp_del)
12963 printf_filtered (_("Temporary breakpoint"));
12965 printf_filtered (_("Breakpoint"));
12966 printf_filtered (_(" %d"), b->number);
12967 if (b->type == bp_gnu_ifunc_resolver)
12968 printf_filtered (_(" at gnu-indirect-function resolver"));
12970 case bp_hardware_breakpoint:
12971 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
12974 printf_filtered (_("Dprintf %d"), b->number);
12982 bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
12984 if (tp->type == bp_breakpoint && tp->disposition == disp_del)
12985 fprintf_unfiltered (fp, "tbreak");
12986 else if (tp->type == bp_breakpoint)
12987 fprintf_unfiltered (fp, "break");
12988 else if (tp->type == bp_hardware_breakpoint
12989 && tp->disposition == disp_del)
12990 fprintf_unfiltered (fp, "thbreak");
12991 else if (tp->type == bp_hardware_breakpoint)
12992 fprintf_unfiltered (fp, "hbreak");
12994 internal_error (__FILE__, __LINE__,
12995 _("unhandled breakpoint type %d"), (int) tp->type);
12997 fprintf_unfiltered (fp, " %s", tp->addr_string);
12998 print_recreate_thread (tp, fp);
13002 bkpt_create_sals_from_address (char **arg,
13003 struct linespec_result *canonical,
13004 enum bptype type_wanted,
13005 char *addr_start, char **copy_arg)
13007 create_sals_from_address_default (arg, canonical, type_wanted,
13008 addr_start, copy_arg);
13012 bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
13013 struct linespec_result *canonical,
13015 char *extra_string,
13016 enum bptype type_wanted,
13017 enum bpdisp disposition,
13019 int task, int ignore_count,
13020 const struct breakpoint_ops *ops,
13021 int from_tty, int enabled,
13022 int internal, unsigned flags)
13024 create_breakpoints_sal_default (gdbarch, canonical,
13025 cond_string, extra_string,
13027 disposition, thread, task,
13028 ignore_count, ops, from_tty,
13029 enabled, internal, flags);
13033 bkpt_decode_linespec (struct breakpoint *b, char **s,
13034 struct symtabs_and_lines *sals)
13036 decode_linespec_default (b, s, sals);
13039 /* Virtual table for internal breakpoints. */
13042 internal_bkpt_re_set (struct breakpoint *b)
13046 /* Delete overlay event and longjmp master breakpoints; they
13047 will be reset later by breakpoint_re_set. */
13048 case bp_overlay_event:
13049 case bp_longjmp_master:
13050 case bp_std_terminate_master:
13051 case bp_exception_master:
13052 delete_breakpoint (b);
13055 /* This breakpoint is special, it's set up when the inferior
13056 starts and we really don't want to touch it. */
13057 case bp_shlib_event:
13059 /* Like bp_shlib_event, this breakpoint type is special. Once
13060 it is set up, we do not want to touch it. */
13061 case bp_thread_event:
13067 internal_bkpt_check_status (bpstat bs)
13069 if (bs->breakpoint_at->type == bp_shlib_event)
13071 /* If requested, stop when the dynamic linker notifies GDB of
13072 events. This allows the user to get control and place
13073 breakpoints in initializer routines for dynamically loaded
13074 objects (among other things). */
13075 bs->stop = stop_on_solib_events;
13076 bs->print = stop_on_solib_events;
13082 static enum print_stop_action
13083 internal_bkpt_print_it (bpstat bs)
13085 struct breakpoint *b;
13087 b = bs->breakpoint_at;
13091 case bp_shlib_event:
13092 /* Did we stop because the user set the stop_on_solib_events
13093 variable? (If so, we report this as a generic, "Stopped due
13094 to shlib event" message.) */
13095 print_solib_event (0);
13098 case bp_thread_event:
13099 /* Not sure how we will get here.
13100 GDB should not stop for these breakpoints. */
13101 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
13104 case bp_overlay_event:
13105 /* By analogy with the thread event, GDB should not stop for these. */
13106 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
13109 case bp_longjmp_master:
13110 /* These should never be enabled. */
13111 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
13114 case bp_std_terminate_master:
13115 /* These should never be enabled. */
13116 printf_filtered (_("std::terminate Master Breakpoint: "
13117 "gdb should not stop!\n"));
13120 case bp_exception_master:
13121 /* These should never be enabled. */
13122 printf_filtered (_("Exception Master Breakpoint: "
13123 "gdb should not stop!\n"));
13127 return PRINT_NOTHING;
13131 internal_bkpt_print_mention (struct breakpoint *b)
13133 /* Nothing to mention. These breakpoints are internal. */
13136 /* Virtual table for momentary breakpoints */
13139 momentary_bkpt_re_set (struct breakpoint *b)
13141 /* Keep temporary breakpoints, which can be encountered when we step
13142 over a dlopen call and solib_add is resetting the breakpoints.
13143 Otherwise these should have been blown away via the cleanup chain
13144 or by breakpoint_init_inferior when we rerun the executable. */
13148 momentary_bkpt_check_status (bpstat bs)
13150 /* Nothing. The point of these breakpoints is causing a stop. */
13153 static enum print_stop_action
13154 momentary_bkpt_print_it (bpstat bs)
13156 struct ui_out *uiout = current_uiout;
13158 if (ui_out_is_mi_like_p (uiout))
13160 struct breakpoint *b = bs->breakpoint_at;
13165 ui_out_field_string
13167 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED));
13171 ui_out_field_string
13173 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED));
13178 return PRINT_UNKNOWN;
13182 momentary_bkpt_print_mention (struct breakpoint *b)
13184 /* Nothing to mention. These breakpoints are internal. */
13187 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13189 It gets cleared already on the removal of the first one of such placed
13190 breakpoints. This is OK as they get all removed altogether. */
13193 longjmp_bkpt_dtor (struct breakpoint *self)
13195 struct thread_info *tp = find_thread_id (self->thread);
13198 tp->initiating_frame = null_frame_id;
13200 momentary_breakpoint_ops.dtor (self);
13203 /* Specific methods for probe breakpoints. */
13206 bkpt_probe_insert_location (struct bp_location *bl)
13208 int v = bkpt_insert_location (bl);
13212 /* The insertion was successful, now let's set the probe's semaphore
13214 bl->probe->pops->set_semaphore (bl->probe, bl->gdbarch);
13221 bkpt_probe_remove_location (struct bp_location *bl)
13223 /* Let's clear the semaphore before removing the location. */
13224 bl->probe->pops->clear_semaphore (bl->probe, bl->gdbarch);
13226 return bkpt_remove_location (bl);
13230 bkpt_probe_create_sals_from_address (char **arg,
13231 struct linespec_result *canonical,
13232 enum bptype type_wanted,
13233 char *addr_start, char **copy_arg)
13235 struct linespec_sals lsal;
13237 lsal.sals = parse_probes (arg, canonical);
13239 *copy_arg = xstrdup (canonical->addr_string);
13240 lsal.canonical = xstrdup (*copy_arg);
13242 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13246 bkpt_probe_decode_linespec (struct breakpoint *b, char **s,
13247 struct symtabs_and_lines *sals)
13249 *sals = parse_probes (s, NULL);
13251 error (_("probe not found"));
13254 /* The breakpoint_ops structure to be used in tracepoints. */
13257 tracepoint_re_set (struct breakpoint *b)
13259 breakpoint_re_set_default (b);
13263 tracepoint_breakpoint_hit (const struct bp_location *bl,
13264 struct address_space *aspace, CORE_ADDR bp_addr,
13265 const struct target_waitstatus *ws)
13267 /* By definition, the inferior does not report stops at
13273 tracepoint_print_one_detail (const struct breakpoint *self,
13274 struct ui_out *uiout)
13276 struct tracepoint *tp = (struct tracepoint *) self;
13277 if (tp->static_trace_marker_id)
13279 gdb_assert (self->type == bp_static_tracepoint);
13281 ui_out_text (uiout, "\tmarker id is ");
13282 ui_out_field_string (uiout, "static-tracepoint-marker-string-id",
13283 tp->static_trace_marker_id);
13284 ui_out_text (uiout, "\n");
13289 tracepoint_print_mention (struct breakpoint *b)
13291 if (ui_out_is_mi_like_p (current_uiout))
13296 case bp_tracepoint:
13297 printf_filtered (_("Tracepoint"));
13298 printf_filtered (_(" %d"), b->number);
13300 case bp_fast_tracepoint:
13301 printf_filtered (_("Fast tracepoint"));
13302 printf_filtered (_(" %d"), b->number);
13304 case bp_static_tracepoint:
13305 printf_filtered (_("Static tracepoint"));
13306 printf_filtered (_(" %d"), b->number);
13309 internal_error (__FILE__, __LINE__,
13310 _("unhandled tracepoint type %d"), (int) b->type);
13317 tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
13319 struct tracepoint *tp = (struct tracepoint *) self;
13321 if (self->type == bp_fast_tracepoint)
13322 fprintf_unfiltered (fp, "ftrace");
13323 if (self->type == bp_static_tracepoint)
13324 fprintf_unfiltered (fp, "strace");
13325 else if (self->type == bp_tracepoint)
13326 fprintf_unfiltered (fp, "trace");
13328 internal_error (__FILE__, __LINE__,
13329 _("unhandled tracepoint type %d"), (int) self->type);
13331 fprintf_unfiltered (fp, " %s", self->addr_string);
13332 print_recreate_thread (self, fp);
13334 if (tp->pass_count)
13335 fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
13339 tracepoint_create_sals_from_address (char **arg,
13340 struct linespec_result *canonical,
13341 enum bptype type_wanted,
13342 char *addr_start, char **copy_arg)
13344 create_sals_from_address_default (arg, canonical, type_wanted,
13345 addr_start, copy_arg);
13349 tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
13350 struct linespec_result *canonical,
13352 char *extra_string,
13353 enum bptype type_wanted,
13354 enum bpdisp disposition,
13356 int task, int ignore_count,
13357 const struct breakpoint_ops *ops,
13358 int from_tty, int enabled,
13359 int internal, unsigned flags)
13361 create_breakpoints_sal_default (gdbarch, canonical,
13362 cond_string, extra_string,
13364 disposition, thread, task,
13365 ignore_count, ops, from_tty,
13366 enabled, internal, flags);
13370 tracepoint_decode_linespec (struct breakpoint *b, char **s,
13371 struct symtabs_and_lines *sals)
13373 decode_linespec_default (b, s, sals);
13376 struct breakpoint_ops tracepoint_breakpoint_ops;
13378 /* The breakpoint_ops structure to be use on tracepoints placed in a
13382 tracepoint_probe_create_sals_from_address (char **arg,
13383 struct linespec_result *canonical,
13384 enum bptype type_wanted,
13385 char *addr_start, char **copy_arg)
13387 /* We use the same method for breakpoint on probes. */
13388 bkpt_probe_create_sals_from_address (arg, canonical, type_wanted,
13389 addr_start, copy_arg);
13393 tracepoint_probe_decode_linespec (struct breakpoint *b, char **s,
13394 struct symtabs_and_lines *sals)
13396 /* We use the same method for breakpoint on probes. */
13397 bkpt_probe_decode_linespec (b, s, sals);
13400 static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
13402 /* Dprintf breakpoint_ops methods. */
13405 dprintf_re_set (struct breakpoint *b)
13407 breakpoint_re_set_default (b);
13409 /* This breakpoint could have been pending, and be resolved now, and
13410 if so, we should now have the extra string. If we don't, the
13411 dprintf was malformed when created, but we couldn't tell because
13412 we can't extract the extra string until the location is
13414 if (b->loc != NULL && b->extra_string == NULL)
13415 error (_("Format string required"));
13417 /* 1 - connect to target 1, that can run breakpoint commands.
13418 2 - create a dprintf, which resolves fine.
13419 3 - disconnect from target 1
13420 4 - connect to target 2, that can NOT run breakpoint commands.
13422 After steps #3/#4, you'll want the dprintf command list to
13423 be updated, because target 1 and 2 may well return different
13424 answers for target_can_run_breakpoint_commands().
13425 Given absence of finer grained resetting, we get to do
13426 it all the time. */
13427 if (b->extra_string != NULL)
13428 update_dprintf_command_list (b);
13431 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13434 dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp)
13436 fprintf_unfiltered (fp, "dprintf %s%s", tp->addr_string,
13438 print_recreate_thread (tp, fp);
13441 /* Implement the "after_condition_true" breakpoint_ops method for
13444 dprintf's are implemented with regular commands in their command
13445 list, but we run the commands here instead of before presenting the
13446 stop to the user, as dprintf's don't actually cause a stop. This
13447 also makes it so that the commands of multiple dprintfs at the same
13448 address are all handled. */
13451 dprintf_after_condition_true (struct bpstats *bs)
13453 struct cleanup *old_chain;
13454 struct bpstats tmp_bs = { NULL };
13455 struct bpstats *tmp_bs_p = &tmp_bs;
13457 /* dprintf's never cause a stop. This wasn't set in the
13458 check_status hook instead because that would make the dprintf's
13459 condition not be evaluated. */
13462 /* Run the command list here. Take ownership of it instead of
13463 copying. We never want these commands to run later in
13464 bpstat_do_actions, if a breakpoint that causes a stop happens to
13465 be set at same address as this dprintf, or even if running the
13466 commands here throws. */
13467 tmp_bs.commands = bs->commands;
13468 bs->commands = NULL;
13469 old_chain = make_cleanup_decref_counted_command_line (&tmp_bs.commands);
13471 bpstat_do_actions_1 (&tmp_bs_p);
13473 /* 'tmp_bs.commands' will usually be NULL by now, but
13474 bpstat_do_actions_1 may return early without processing the whole
13476 do_cleanups (old_chain);
13479 /* The breakpoint_ops structure to be used on static tracepoints with
13483 strace_marker_create_sals_from_address (char **arg,
13484 struct linespec_result *canonical,
13485 enum bptype type_wanted,
13486 char *addr_start, char **copy_arg)
13488 struct linespec_sals lsal;
13490 lsal.sals = decode_static_tracepoint_spec (arg);
13492 *copy_arg = savestring (addr_start, *arg - addr_start);
13494 canonical->addr_string = xstrdup (*copy_arg);
13495 lsal.canonical = xstrdup (*copy_arg);
13496 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13500 strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
13501 struct linespec_result *canonical,
13503 char *extra_string,
13504 enum bptype type_wanted,
13505 enum bpdisp disposition,
13507 int task, int ignore_count,
13508 const struct breakpoint_ops *ops,
13509 int from_tty, int enabled,
13510 int internal, unsigned flags)
13513 struct linespec_sals *lsal = VEC_index (linespec_sals,
13514 canonical->sals, 0);
13516 /* If the user is creating a static tracepoint by marker id
13517 (strace -m MARKER_ID), then store the sals index, so that
13518 breakpoint_re_set can try to match up which of the newly
13519 found markers corresponds to this one, and, don't try to
13520 expand multiple locations for each sal, given than SALS
13521 already should contain all sals for MARKER_ID. */
13523 for (i = 0; i < lsal->sals.nelts; ++i)
13525 struct symtabs_and_lines expanded;
13526 struct tracepoint *tp;
13527 struct cleanup *old_chain;
13530 expanded.nelts = 1;
13531 expanded.sals = &lsal->sals.sals[i];
13533 addr_string = xstrdup (canonical->addr_string);
13534 old_chain = make_cleanup (xfree, addr_string);
13536 tp = XCNEW (struct tracepoint);
13537 init_breakpoint_sal (&tp->base, gdbarch, expanded,
13539 cond_string, extra_string,
13540 type_wanted, disposition,
13541 thread, task, ignore_count, ops,
13542 from_tty, enabled, internal, flags,
13543 canonical->special_display);
13544 /* Given that its possible to have multiple markers with
13545 the same string id, if the user is creating a static
13546 tracepoint by marker id ("strace -m MARKER_ID"), then
13547 store the sals index, so that breakpoint_re_set can
13548 try to match up which of the newly found markers
13549 corresponds to this one */
13550 tp->static_trace_marker_id_idx = i;
13552 install_breakpoint (internal, &tp->base, 0);
13554 discard_cleanups (old_chain);
13559 strace_marker_decode_linespec (struct breakpoint *b, char **s,
13560 struct symtabs_and_lines *sals)
13562 struct tracepoint *tp = (struct tracepoint *) b;
13564 *sals = decode_static_tracepoint_spec (s);
13565 if (sals->nelts > tp->static_trace_marker_id_idx)
13567 sals->sals[0] = sals->sals[tp->static_trace_marker_id_idx];
13571 error (_("marker %s not found"), tp->static_trace_marker_id);
13574 static struct breakpoint_ops strace_marker_breakpoint_ops;
13577 strace_marker_p (struct breakpoint *b)
13579 return b->ops == &strace_marker_breakpoint_ops;
13582 /* Delete a breakpoint and clean up all traces of it in the data
13586 delete_breakpoint (struct breakpoint *bpt)
13588 struct breakpoint *b;
13590 gdb_assert (bpt != NULL);
13592 /* Has this bp already been deleted? This can happen because
13593 multiple lists can hold pointers to bp's. bpstat lists are
13596 One example of this happening is a watchpoint's scope bp. When
13597 the scope bp triggers, we notice that the watchpoint is out of
13598 scope, and delete it. We also delete its scope bp. But the
13599 scope bp is marked "auto-deleting", and is already on a bpstat.
13600 That bpstat is then checked for auto-deleting bp's, which are
13603 A real solution to this problem might involve reference counts in
13604 bp's, and/or giving them pointers back to their referencing
13605 bpstat's, and teaching delete_breakpoint to only free a bp's
13606 storage when no more references were extent. A cheaper bandaid
13608 if (bpt->type == bp_none)
13611 /* At least avoid this stale reference until the reference counting
13612 of breakpoints gets resolved. */
13613 if (bpt->related_breakpoint != bpt)
13615 struct breakpoint *related;
13616 struct watchpoint *w;
13618 if (bpt->type == bp_watchpoint_scope)
13619 w = (struct watchpoint *) bpt->related_breakpoint;
13620 else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
13621 w = (struct watchpoint *) bpt;
13625 watchpoint_del_at_next_stop (w);
13627 /* Unlink bpt from the bpt->related_breakpoint ring. */
13628 for (related = bpt; related->related_breakpoint != bpt;
13629 related = related->related_breakpoint);
13630 related->related_breakpoint = bpt->related_breakpoint;
13631 bpt->related_breakpoint = bpt;
13634 /* watch_command_1 creates a watchpoint but only sets its number if
13635 update_watchpoint succeeds in creating its bp_locations. If there's
13636 a problem in that process, we'll be asked to delete the half-created
13637 watchpoint. In that case, don't announce the deletion. */
13639 observer_notify_breakpoint_deleted (bpt);
13641 if (breakpoint_chain == bpt)
13642 breakpoint_chain = bpt->next;
13644 ALL_BREAKPOINTS (b)
13645 if (b->next == bpt)
13647 b->next = bpt->next;
13651 /* Be sure no bpstat's are pointing at the breakpoint after it's
13653 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13654 in all threads for now. Note that we cannot just remove bpstats
13655 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13656 commands are associated with the bpstat; if we remove it here,
13657 then the later call to bpstat_do_actions (&stop_bpstat); in
13658 event-top.c won't do anything, and temporary breakpoints with
13659 commands won't work. */
13661 iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13663 /* Now that breakpoint is removed from breakpoint list, update the
13664 global location list. This will remove locations that used to
13665 belong to this breakpoint. Do this before freeing the breakpoint
13666 itself, since remove_breakpoint looks at location's owner. It
13667 might be better design to have location completely
13668 self-contained, but it's not the case now. */
13669 update_global_location_list (0);
13671 bpt->ops->dtor (bpt);
13672 /* On the chance that someone will soon try again to delete this
13673 same bp, we mark it as deleted before freeing its storage. */
13674 bpt->type = bp_none;
13679 do_delete_breakpoint_cleanup (void *b)
13681 delete_breakpoint (b);
13685 make_cleanup_delete_breakpoint (struct breakpoint *b)
13687 return make_cleanup (do_delete_breakpoint_cleanup, b);
13690 /* Iterator function to call a user-provided callback function once
13691 for each of B and its related breakpoints. */
13694 iterate_over_related_breakpoints (struct breakpoint *b,
13695 void (*function) (struct breakpoint *,
13699 struct breakpoint *related;
13704 struct breakpoint *next;
13706 /* FUNCTION may delete RELATED. */
13707 next = related->related_breakpoint;
13709 if (next == related)
13711 /* RELATED is the last ring entry. */
13712 function (related, data);
13714 /* FUNCTION may have deleted it, so we'd never reach back to
13715 B. There's nothing left to do anyway, so just break
13720 function (related, data);
13724 while (related != b);
13728 do_delete_breakpoint (struct breakpoint *b, void *ignore)
13730 delete_breakpoint (b);
13733 /* A callback for map_breakpoint_numbers that calls
13734 delete_breakpoint. */
13737 do_map_delete_breakpoint (struct breakpoint *b, void *ignore)
13739 iterate_over_related_breakpoints (b, do_delete_breakpoint, NULL);
13743 delete_command (char *arg, int from_tty)
13745 struct breakpoint *b, *b_tmp;
13751 int breaks_to_delete = 0;
13753 /* Delete all breakpoints if no argument. Do not delete
13754 internal breakpoints, these have to be deleted with an
13755 explicit breakpoint number argument. */
13756 ALL_BREAKPOINTS (b)
13757 if (user_breakpoint_p (b))
13759 breaks_to_delete = 1;
13763 /* Ask user only if there are some breakpoints to delete. */
13765 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
13767 ALL_BREAKPOINTS_SAFE (b, b_tmp)
13768 if (user_breakpoint_p (b))
13769 delete_breakpoint (b);
13773 map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
13777 all_locations_are_pending (struct bp_location *loc)
13779 for (; loc; loc = loc->next)
13780 if (!loc->shlib_disabled
13781 && !loc->pspace->executing_startup)
13786 /* Subroutine of update_breakpoint_locations to simplify it.
13787 Return non-zero if multiple fns in list LOC have the same name.
13788 Null names are ignored. */
13791 ambiguous_names_p (struct bp_location *loc)
13793 struct bp_location *l;
13794 htab_t htab = htab_create_alloc (13, htab_hash_string,
13795 (int (*) (const void *,
13796 const void *)) streq,
13797 NULL, xcalloc, xfree);
13799 for (l = loc; l != NULL; l = l->next)
13802 const char *name = l->function_name;
13804 /* Allow for some names to be NULL, ignore them. */
13808 slot = (const char **) htab_find_slot (htab, (const void *) name,
13810 /* NOTE: We can assume slot != NULL here because xcalloc never
13814 htab_delete (htab);
13820 htab_delete (htab);
13824 /* When symbols change, it probably means the sources changed as well,
13825 and it might mean the static tracepoint markers are no longer at
13826 the same address or line numbers they used to be at last we
13827 checked. Losing your static tracepoints whenever you rebuild is
13828 undesirable. This function tries to resync/rematch gdb static
13829 tracepoints with the markers on the target, for static tracepoints
13830 that have not been set by marker id. Static tracepoint that have
13831 been set by marker id are reset by marker id in breakpoint_re_set.
13834 1) For a tracepoint set at a specific address, look for a marker at
13835 the old PC. If one is found there, assume to be the same marker.
13836 If the name / string id of the marker found is different from the
13837 previous known name, assume that means the user renamed the marker
13838 in the sources, and output a warning.
13840 2) For a tracepoint set at a given line number, look for a marker
13841 at the new address of the old line number. If one is found there,
13842 assume to be the same marker. If the name / string id of the
13843 marker found is different from the previous known name, assume that
13844 means the user renamed the marker in the sources, and output a
13847 3) If a marker is no longer found at the same address or line, it
13848 may mean the marker no longer exists. But it may also just mean
13849 the code changed a bit. Maybe the user added a few lines of code
13850 that made the marker move up or down (in line number terms). Ask
13851 the target for info about the marker with the string id as we knew
13852 it. If found, update line number and address in the matching
13853 static tracepoint. This will get confused if there's more than one
13854 marker with the same ID (possible in UST, although unadvised
13855 precisely because it confuses tools). */
13857 static struct symtab_and_line
13858 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
13860 struct tracepoint *tp = (struct tracepoint *) b;
13861 struct static_tracepoint_marker marker;
13866 find_line_pc (sal.symtab, sal.line, &pc);
13868 if (target_static_tracepoint_marker_at (pc, &marker))
13870 if (strcmp (tp->static_trace_marker_id, marker.str_id) != 0)
13871 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13873 tp->static_trace_marker_id, marker.str_id);
13875 xfree (tp->static_trace_marker_id);
13876 tp->static_trace_marker_id = xstrdup (marker.str_id);
13877 release_static_tracepoint_marker (&marker);
13882 /* Old marker wasn't found on target at lineno. Try looking it up
13884 if (!sal.explicit_pc
13886 && sal.symtab != NULL
13887 && tp->static_trace_marker_id != NULL)
13889 VEC(static_tracepoint_marker_p) *markers;
13892 = target_static_tracepoint_markers_by_strid (tp->static_trace_marker_id);
13894 if (!VEC_empty(static_tracepoint_marker_p, markers))
13896 struct symtab_and_line sal2;
13897 struct symbol *sym;
13898 struct static_tracepoint_marker *tpmarker;
13899 struct ui_out *uiout = current_uiout;
13901 tpmarker = VEC_index (static_tracepoint_marker_p, markers, 0);
13903 xfree (tp->static_trace_marker_id);
13904 tp->static_trace_marker_id = xstrdup (tpmarker->str_id);
13906 warning (_("marker for static tracepoint %d (%s) not "
13907 "found at previous line number"),
13908 b->number, tp->static_trace_marker_id);
13912 sal2.pc = tpmarker->address;
13914 sal2 = find_pc_line (tpmarker->address, 0);
13915 sym = find_pc_sect_function (tpmarker->address, NULL);
13916 ui_out_text (uiout, "Now in ");
13919 ui_out_field_string (uiout, "func",
13920 SYMBOL_PRINT_NAME (sym));
13921 ui_out_text (uiout, " at ");
13923 ui_out_field_string (uiout, "file",
13924 symtab_to_filename_for_display (sal2.symtab));
13925 ui_out_text (uiout, ":");
13927 if (ui_out_is_mi_like_p (uiout))
13929 const char *fullname = symtab_to_fullname (sal2.symtab);
13931 ui_out_field_string (uiout, "fullname", fullname);
13934 ui_out_field_int (uiout, "line", sal2.line);
13935 ui_out_text (uiout, "\n");
13937 b->loc->line_number = sal2.line;
13938 b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
13940 xfree (b->addr_string);
13941 b->addr_string = xstrprintf ("%s:%d",
13942 symtab_to_filename_for_display (sal2.symtab),
13943 b->loc->line_number);
13945 /* Might be nice to check if function changed, and warn if
13948 release_static_tracepoint_marker (tpmarker);
13954 /* Returns 1 iff locations A and B are sufficiently same that
13955 we don't need to report breakpoint as changed. */
13958 locations_are_equal (struct bp_location *a, struct bp_location *b)
13962 if (a->address != b->address)
13965 if (a->shlib_disabled != b->shlib_disabled)
13968 if (a->enabled != b->enabled)
13975 if ((a == NULL) != (b == NULL))
13981 /* Create new breakpoint locations for B (a hardware or software breakpoint)
13982 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
13983 a ranged breakpoint. */
13986 update_breakpoint_locations (struct breakpoint *b,
13987 struct symtabs_and_lines sals,
13988 struct symtabs_and_lines sals_end)
13991 struct bp_location *existing_locations = b->loc;
13993 if (sals_end.nelts != 0 && (sals.nelts != 1 || sals_end.nelts != 1))
13995 /* Ranged breakpoints have only one start location and one end
13997 b->enable_state = bp_disabled;
13998 update_global_location_list (1);
13999 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
14000 "multiple locations found\n"),
14005 /* If there's no new locations, and all existing locations are
14006 pending, don't do anything. This optimizes the common case where
14007 all locations are in the same shared library, that was unloaded.
14008 We'd like to retain the location, so that when the library is
14009 loaded again, we don't loose the enabled/disabled status of the
14010 individual locations. */
14011 if (all_locations_are_pending (existing_locations) && sals.nelts == 0)
14016 for (i = 0; i < sals.nelts; ++i)
14018 struct bp_location *new_loc;
14020 switch_to_program_space_and_thread (sals.sals[i].pspace);
14022 new_loc = add_location_to_breakpoint (b, &(sals.sals[i]));
14024 /* Reparse conditions, they might contain references to the
14026 if (b->cond_string != NULL)
14029 volatile struct gdb_exception e;
14031 s = b->cond_string;
14032 TRY_CATCH (e, RETURN_MASK_ERROR)
14034 new_loc->cond = parse_exp_1 (&s, sals.sals[i].pc,
14035 block_for_pc (sals.sals[i].pc),
14040 warning (_("failed to reevaluate condition "
14041 "for breakpoint %d: %s"),
14042 b->number, e.message);
14043 new_loc->enabled = 0;
14047 if (sals_end.nelts)
14049 CORE_ADDR end = find_breakpoint_range_end (sals_end.sals[0]);
14051 new_loc->length = end - sals.sals[0].pc + 1;
14055 /* Update locations of permanent breakpoints. */
14056 if (b->enable_state == bp_permanent)
14057 make_breakpoint_permanent (b);
14059 /* If possible, carry over 'disable' status from existing
14062 struct bp_location *e = existing_locations;
14063 /* If there are multiple breakpoints with the same function name,
14064 e.g. for inline functions, comparing function names won't work.
14065 Instead compare pc addresses; this is just a heuristic as things
14066 may have moved, but in practice it gives the correct answer
14067 often enough until a better solution is found. */
14068 int have_ambiguous_names = ambiguous_names_p (b->loc);
14070 for (; e; e = e->next)
14072 if (!e->enabled && e->function_name)
14074 struct bp_location *l = b->loc;
14075 if (have_ambiguous_names)
14077 for (; l; l = l->next)
14078 if (breakpoint_locations_match (e, l))
14086 for (; l; l = l->next)
14087 if (l->function_name
14088 && strcmp (e->function_name, l->function_name) == 0)
14098 if (!locations_are_equal (existing_locations, b->loc))
14099 observer_notify_breakpoint_modified (b);
14101 update_global_location_list (1);
14104 /* Find the SaL locations corresponding to the given ADDR_STRING.
14105 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
14107 static struct symtabs_and_lines
14108 addr_string_to_sals (struct breakpoint *b, char *addr_string, int *found)
14111 struct symtabs_and_lines sals = {0};
14112 volatile struct gdb_exception e;
14114 gdb_assert (b->ops != NULL);
14117 TRY_CATCH (e, RETURN_MASK_ERROR)
14119 b->ops->decode_linespec (b, &s, &sals);
14123 int not_found_and_ok = 0;
14124 /* For pending breakpoints, it's expected that parsing will
14125 fail until the right shared library is loaded. User has
14126 already told to create pending breakpoints and don't need
14127 extra messages. If breakpoint is in bp_shlib_disabled
14128 state, then user already saw the message about that
14129 breakpoint being disabled, and don't want to see more
14131 if (e.error == NOT_FOUND_ERROR
14132 && (b->condition_not_parsed
14133 || (b->loc && b->loc->shlib_disabled)
14134 || (b->loc && b->loc->pspace->executing_startup)
14135 || b->enable_state == bp_disabled))
14136 not_found_and_ok = 1;
14138 if (!not_found_and_ok)
14140 /* We surely don't want to warn about the same breakpoint
14141 10 times. One solution, implemented here, is disable
14142 the breakpoint on error. Another solution would be to
14143 have separate 'warning emitted' flag. Since this
14144 happens only when a binary has changed, I don't know
14145 which approach is better. */
14146 b->enable_state = bp_disabled;
14147 throw_exception (e);
14151 if (e.reason == 0 || e.error != NOT_FOUND_ERROR)
14155 for (i = 0; i < sals.nelts; ++i)
14156 resolve_sal_pc (&sals.sals[i]);
14157 if (b->condition_not_parsed && s && s[0])
14159 char *cond_string, *extra_string;
14162 find_condition_and_thread (s, sals.sals[0].pc,
14163 &cond_string, &thread, &task,
14166 b->cond_string = cond_string;
14167 b->thread = thread;
14170 b->extra_string = extra_string;
14171 b->condition_not_parsed = 0;
14174 if (b->type == bp_static_tracepoint && !strace_marker_p (b))
14175 sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
14185 /* The default re_set method, for typical hardware or software
14186 breakpoints. Reevaluate the breakpoint and recreate its
14190 breakpoint_re_set_default (struct breakpoint *b)
14193 struct symtabs_and_lines sals, sals_end;
14194 struct symtabs_and_lines expanded = {0};
14195 struct symtabs_and_lines expanded_end = {0};
14197 sals = addr_string_to_sals (b, b->addr_string, &found);
14200 make_cleanup (xfree, sals.sals);
14204 if (b->addr_string_range_end)
14206 sals_end = addr_string_to_sals (b, b->addr_string_range_end, &found);
14209 make_cleanup (xfree, sals_end.sals);
14210 expanded_end = sals_end;
14214 update_breakpoint_locations (b, expanded, expanded_end);
14217 /* Default method for creating SALs from an address string. It basically
14218 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14221 create_sals_from_address_default (char **arg,
14222 struct linespec_result *canonical,
14223 enum bptype type_wanted,
14224 char *addr_start, char **copy_arg)
14226 parse_breakpoint_sals (arg, canonical);
14229 /* Call create_breakpoints_sal for the given arguments. This is the default
14230 function for the `create_breakpoints_sal' method of
14234 create_breakpoints_sal_default (struct gdbarch *gdbarch,
14235 struct linespec_result *canonical,
14237 char *extra_string,
14238 enum bptype type_wanted,
14239 enum bpdisp disposition,
14241 int task, int ignore_count,
14242 const struct breakpoint_ops *ops,
14243 int from_tty, int enabled,
14244 int internal, unsigned flags)
14246 create_breakpoints_sal (gdbarch, canonical, cond_string,
14248 type_wanted, disposition,
14249 thread, task, ignore_count, ops, from_tty,
14250 enabled, internal, flags);
14253 /* Decode the line represented by S by calling decode_line_full. This is the
14254 default function for the `decode_linespec' method of breakpoint_ops. */
14257 decode_linespec_default (struct breakpoint *b, char **s,
14258 struct symtabs_and_lines *sals)
14260 struct linespec_result canonical;
14262 init_linespec_result (&canonical);
14263 decode_line_full (s, DECODE_LINE_FUNFIRSTLINE,
14264 (struct symtab *) NULL, 0,
14265 &canonical, multiple_symbols_all,
14268 /* We should get 0 or 1 resulting SALs. */
14269 gdb_assert (VEC_length (linespec_sals, canonical.sals) < 2);
14271 if (VEC_length (linespec_sals, canonical.sals) > 0)
14273 struct linespec_sals *lsal;
14275 lsal = VEC_index (linespec_sals, canonical.sals, 0);
14276 *sals = lsal->sals;
14277 /* Arrange it so the destructor does not free the
14279 lsal->sals.sals = NULL;
14282 destroy_linespec_result (&canonical);
14285 /* Prepare the global context for a re-set of breakpoint B. */
14287 static struct cleanup *
14288 prepare_re_set_context (struct breakpoint *b)
14290 struct cleanup *cleanups;
14292 input_radix = b->input_radix;
14293 cleanups = save_current_space_and_thread ();
14294 if (b->pspace != NULL)
14295 switch_to_program_space_and_thread (b->pspace);
14296 set_language (b->language);
14301 /* Reset a breakpoint given it's struct breakpoint * BINT.
14302 The value we return ends up being the return value from catch_errors.
14303 Unused in this case. */
14306 breakpoint_re_set_one (void *bint)
14308 /* Get past catch_errs. */
14309 struct breakpoint *b = (struct breakpoint *) bint;
14310 struct cleanup *cleanups;
14312 cleanups = prepare_re_set_context (b);
14313 b->ops->re_set (b);
14314 do_cleanups (cleanups);
14318 /* Re-set all breakpoints after symbols have been re-loaded. */
14320 breakpoint_re_set (void)
14322 struct breakpoint *b, *b_tmp;
14323 enum language save_language;
14324 int save_input_radix;
14325 struct cleanup *old_chain;
14327 save_language = current_language->la_language;
14328 save_input_radix = input_radix;
14329 old_chain = save_current_program_space ();
14331 ALL_BREAKPOINTS_SAFE (b, b_tmp)
14333 /* Format possible error msg. */
14334 char *message = xstrprintf ("Error in re-setting breakpoint %d: ",
14336 struct cleanup *cleanups = make_cleanup (xfree, message);
14337 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
14338 do_cleanups (cleanups);
14340 set_language (save_language);
14341 input_radix = save_input_radix;
14343 jit_breakpoint_re_set ();
14345 do_cleanups (old_chain);
14347 create_overlay_event_breakpoint ();
14348 create_longjmp_master_breakpoint ();
14349 create_std_terminate_master_breakpoint ();
14350 create_exception_master_breakpoint ();
14353 /* Reset the thread number of this breakpoint:
14355 - If the breakpoint is for all threads, leave it as-is.
14356 - Else, reset it to the current thread for inferior_ptid. */
14358 breakpoint_re_set_thread (struct breakpoint *b)
14360 if (b->thread != -1)
14362 if (in_thread_list (inferior_ptid))
14363 b->thread = pid_to_thread_id (inferior_ptid);
14365 /* We're being called after following a fork. The new fork is
14366 selected as current, and unless this was a vfork will have a
14367 different program space from the original thread. Reset that
14369 b->loc->pspace = current_program_space;
14373 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14374 If from_tty is nonzero, it prints a message to that effect,
14375 which ends with a period (no newline). */
14378 set_ignore_count (int bptnum, int count, int from_tty)
14380 struct breakpoint *b;
14385 ALL_BREAKPOINTS (b)
14386 if (b->number == bptnum)
14388 if (is_tracepoint (b))
14390 if (from_tty && count != 0)
14391 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14396 b->ignore_count = count;
14400 printf_filtered (_("Will stop next time "
14401 "breakpoint %d is reached."),
14403 else if (count == 1)
14404 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14407 printf_filtered (_("Will ignore next %d "
14408 "crossings of breakpoint %d."),
14411 observer_notify_breakpoint_modified (b);
14415 error (_("No breakpoint number %d."), bptnum);
14418 /* Command to set ignore-count of breakpoint N to COUNT. */
14421 ignore_command (char *args, int from_tty)
14427 error_no_arg (_("a breakpoint number"));
14429 num = get_number (&p);
14431 error (_("bad breakpoint number: '%s'"), args);
14433 error (_("Second argument (specified ignore-count) is missing."));
14435 set_ignore_count (num,
14436 longest_to_int (value_as_long (parse_and_eval (p))),
14439 printf_filtered ("\n");
14442 /* Call FUNCTION on each of the breakpoints
14443 whose numbers are given in ARGS. */
14446 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *,
14451 struct breakpoint *b, *tmp;
14453 struct get_number_or_range_state state;
14456 error_no_arg (_("one or more breakpoint numbers"));
14458 init_number_or_range (&state, args);
14460 while (!state.finished)
14462 char *p = state.string;
14466 num = get_number_or_range (&state);
14469 warning (_("bad breakpoint number at or near '%s'"), p);
14473 ALL_BREAKPOINTS_SAFE (b, tmp)
14474 if (b->number == num)
14477 function (b, data);
14481 printf_unfiltered (_("No breakpoint number %d.\n"), num);
14486 static struct bp_location *
14487 find_location_by_number (char *number)
14489 char *dot = strchr (number, '.');
14493 struct breakpoint *b;
14494 struct bp_location *loc;
14499 bp_num = get_number (&p1);
14501 error (_("Bad breakpoint number '%s'"), number);
14503 ALL_BREAKPOINTS (b)
14504 if (b->number == bp_num)
14509 if (!b || b->number != bp_num)
14510 error (_("Bad breakpoint number '%s'"), number);
14513 loc_num = get_number (&p1);
14515 error (_("Bad breakpoint location number '%s'"), number);
14519 for (;loc_num && loc; --loc_num, loc = loc->next)
14522 error (_("Bad breakpoint location number '%s'"), dot+1);
14528 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14529 If from_tty is nonzero, it prints a message to that effect,
14530 which ends with a period (no newline). */
14533 disable_breakpoint (struct breakpoint *bpt)
14535 /* Never disable a watchpoint scope breakpoint; we want to
14536 hit them when we leave scope so we can delete both the
14537 watchpoint and its scope breakpoint at that time. */
14538 if (bpt->type == bp_watchpoint_scope)
14541 /* You can't disable permanent breakpoints. */
14542 if (bpt->enable_state == bp_permanent)
14545 bpt->enable_state = bp_disabled;
14547 /* Mark breakpoint locations modified. */
14548 mark_breakpoint_modified (bpt);
14550 if (target_supports_enable_disable_tracepoint ()
14551 && current_trace_status ()->running && is_tracepoint (bpt))
14553 struct bp_location *location;
14555 for (location = bpt->loc; location; location = location->next)
14556 target_disable_tracepoint (location);
14559 update_global_location_list (0);
14561 observer_notify_breakpoint_modified (bpt);
14564 /* A callback for iterate_over_related_breakpoints. */
14567 do_disable_breakpoint (struct breakpoint *b, void *ignore)
14569 disable_breakpoint (b);
14572 /* A callback for map_breakpoint_numbers that calls
14573 disable_breakpoint. */
14576 do_map_disable_breakpoint (struct breakpoint *b, void *ignore)
14578 iterate_over_related_breakpoints (b, do_disable_breakpoint, NULL);
14582 disable_command (char *args, int from_tty)
14586 struct breakpoint *bpt;
14588 ALL_BREAKPOINTS (bpt)
14589 if (user_breakpoint_p (bpt))
14590 disable_breakpoint (bpt);
14594 char *num = extract_arg (&args);
14598 if (strchr (num, '.'))
14600 struct bp_location *loc = find_location_by_number (num);
14607 mark_breakpoint_location_modified (loc);
14609 if (target_supports_enable_disable_tracepoint ()
14610 && current_trace_status ()->running && loc->owner
14611 && is_tracepoint (loc->owner))
14612 target_disable_tracepoint (loc);
14614 update_global_location_list (0);
14617 map_breakpoint_numbers (num, do_map_disable_breakpoint, NULL);
14618 num = extract_arg (&args);
14624 enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14627 int target_resources_ok;
14629 if (bpt->type == bp_hardware_breakpoint)
14632 i = hw_breakpoint_used_count ();
14633 target_resources_ok =
14634 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
14636 if (target_resources_ok == 0)
14637 error (_("No hardware breakpoint support in the target."));
14638 else if (target_resources_ok < 0)
14639 error (_("Hardware breakpoints used exceeds limit."));
14642 if (is_watchpoint (bpt))
14644 /* Initialize it just to avoid a GCC false warning. */
14645 enum enable_state orig_enable_state = 0;
14646 volatile struct gdb_exception e;
14648 TRY_CATCH (e, RETURN_MASK_ALL)
14650 struct watchpoint *w = (struct watchpoint *) bpt;
14652 orig_enable_state = bpt->enable_state;
14653 bpt->enable_state = bp_enabled;
14654 update_watchpoint (w, 1 /* reparse */);
14658 bpt->enable_state = orig_enable_state;
14659 exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14665 if (bpt->enable_state != bp_permanent)
14666 bpt->enable_state = bp_enabled;
14668 bpt->enable_state = bp_enabled;
14670 /* Mark breakpoint locations modified. */
14671 mark_breakpoint_modified (bpt);
14673 if (target_supports_enable_disable_tracepoint ()
14674 && current_trace_status ()->running && is_tracepoint (bpt))
14676 struct bp_location *location;
14678 for (location = bpt->loc; location; location = location->next)
14679 target_enable_tracepoint (location);
14682 bpt->disposition = disposition;
14683 bpt->enable_count = count;
14684 update_global_location_list (1);
14686 observer_notify_breakpoint_modified (bpt);
14691 enable_breakpoint (struct breakpoint *bpt)
14693 enable_breakpoint_disp (bpt, bpt->disposition, 0);
14697 do_enable_breakpoint (struct breakpoint *bpt, void *arg)
14699 enable_breakpoint (bpt);
14702 /* A callback for map_breakpoint_numbers that calls
14703 enable_breakpoint. */
14706 do_map_enable_breakpoint (struct breakpoint *b, void *ignore)
14708 iterate_over_related_breakpoints (b, do_enable_breakpoint, NULL);
14711 /* The enable command enables the specified breakpoints (or all defined
14712 breakpoints) so they once again become (or continue to be) effective
14713 in stopping the inferior. */
14716 enable_command (char *args, int from_tty)
14720 struct breakpoint *bpt;
14722 ALL_BREAKPOINTS (bpt)
14723 if (user_breakpoint_p (bpt))
14724 enable_breakpoint (bpt);
14728 char *num = extract_arg (&args);
14732 if (strchr (num, '.'))
14734 struct bp_location *loc = find_location_by_number (num);
14741 mark_breakpoint_location_modified (loc);
14743 if (target_supports_enable_disable_tracepoint ()
14744 && current_trace_status ()->running && loc->owner
14745 && is_tracepoint (loc->owner))
14746 target_enable_tracepoint (loc);
14748 update_global_location_list (1);
14751 map_breakpoint_numbers (num, do_map_enable_breakpoint, NULL);
14752 num = extract_arg (&args);
14757 /* This struct packages up disposition data for application to multiple
14767 do_enable_breakpoint_disp (struct breakpoint *bpt, void *arg)
14769 struct disp_data disp_data = *(struct disp_data *) arg;
14771 enable_breakpoint_disp (bpt, disp_data.disp, disp_data.count);
14775 do_map_enable_once_breakpoint (struct breakpoint *bpt, void *ignore)
14777 struct disp_data disp = { disp_disable, 1 };
14779 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14783 enable_once_command (char *args, int from_tty)
14785 map_breakpoint_numbers (args, do_map_enable_once_breakpoint, NULL);
14789 do_map_enable_count_breakpoint (struct breakpoint *bpt, void *countptr)
14791 struct disp_data disp = { disp_disable, *(int *) countptr };
14793 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14797 enable_count_command (char *args, int from_tty)
14799 int count = get_number (&args);
14801 map_breakpoint_numbers (args, do_map_enable_count_breakpoint, &count);
14805 do_map_enable_delete_breakpoint (struct breakpoint *bpt, void *ignore)
14807 struct disp_data disp = { disp_del, 1 };
14809 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14813 enable_delete_command (char *args, int from_tty)
14815 map_breakpoint_numbers (args, do_map_enable_delete_breakpoint, NULL);
14819 set_breakpoint_cmd (char *args, int from_tty)
14824 show_breakpoint_cmd (char *args, int from_tty)
14828 /* Invalidate last known value of any hardware watchpoint if
14829 the memory which that value represents has been written to by
14833 invalidate_bp_value_on_memory_change (struct inferior *inferior,
14834 CORE_ADDR addr, ssize_t len,
14835 const bfd_byte *data)
14837 struct breakpoint *bp;
14839 ALL_BREAKPOINTS (bp)
14840 if (bp->enable_state == bp_enabled
14841 && bp->type == bp_hardware_watchpoint)
14843 struct watchpoint *wp = (struct watchpoint *) bp;
14845 if (wp->val_valid && wp->val)
14847 struct bp_location *loc;
14849 for (loc = bp->loc; loc != NULL; loc = loc->next)
14850 if (loc->loc_type == bp_loc_hardware_watchpoint
14851 && loc->address + loc->length > addr
14852 && addr + len > loc->address)
14854 value_free (wp->val);
14862 /* Create and insert a raw software breakpoint at PC. Return an
14863 identifier, which should be used to remove the breakpoint later.
14864 In general, places which call this should be using something on the
14865 breakpoint chain instead; this function should be eliminated
14869 deprecated_insert_raw_breakpoint (struct gdbarch *gdbarch,
14870 struct address_space *aspace, CORE_ADDR pc)
14872 struct bp_target_info *bp_tgt;
14874 bp_tgt = XZALLOC (struct bp_target_info);
14876 bp_tgt->placed_address_space = aspace;
14877 bp_tgt->placed_address = pc;
14879 if (target_insert_breakpoint (gdbarch, bp_tgt) != 0)
14881 /* Could not insert the breakpoint. */
14889 /* Remove a breakpoint BP inserted by
14890 deprecated_insert_raw_breakpoint. */
14893 deprecated_remove_raw_breakpoint (struct gdbarch *gdbarch, void *bp)
14895 struct bp_target_info *bp_tgt = bp;
14898 ret = target_remove_breakpoint (gdbarch, bp_tgt);
14904 /* One (or perhaps two) breakpoints used for software single
14907 static void *single_step_breakpoints[2];
14908 static struct gdbarch *single_step_gdbarch[2];
14910 /* Create and insert a breakpoint for software single step. */
14913 insert_single_step_breakpoint (struct gdbarch *gdbarch,
14914 struct address_space *aspace,
14919 if (single_step_breakpoints[0] == NULL)
14921 bpt_p = &single_step_breakpoints[0];
14922 single_step_gdbarch[0] = gdbarch;
14926 gdb_assert (single_step_breakpoints[1] == NULL);
14927 bpt_p = &single_step_breakpoints[1];
14928 single_step_gdbarch[1] = gdbarch;
14931 /* NOTE drow/2006-04-11: A future improvement to this function would
14932 be to only create the breakpoints once, and actually put them on
14933 the breakpoint chain. That would let us use set_raw_breakpoint.
14934 We could adjust the addresses each time they were needed. Doing
14935 this requires corresponding changes elsewhere where single step
14936 breakpoints are handled, however. So, for now, we use this. */
14938 *bpt_p = deprecated_insert_raw_breakpoint (gdbarch, aspace, next_pc);
14939 if (*bpt_p == NULL)
14940 error (_("Could not insert single-step breakpoint at %s"),
14941 paddress (gdbarch, next_pc));
14944 /* Check if the breakpoints used for software single stepping
14945 were inserted or not. */
14948 single_step_breakpoints_inserted (void)
14950 return (single_step_breakpoints[0] != NULL
14951 || single_step_breakpoints[1] != NULL);
14954 /* Remove and delete any breakpoints used for software single step. */
14957 remove_single_step_breakpoints (void)
14959 gdb_assert (single_step_breakpoints[0] != NULL);
14961 /* See insert_single_step_breakpoint for more about this deprecated
14963 deprecated_remove_raw_breakpoint (single_step_gdbarch[0],
14964 single_step_breakpoints[0]);
14965 single_step_gdbarch[0] = NULL;
14966 single_step_breakpoints[0] = NULL;
14968 if (single_step_breakpoints[1] != NULL)
14970 deprecated_remove_raw_breakpoint (single_step_gdbarch[1],
14971 single_step_breakpoints[1]);
14972 single_step_gdbarch[1] = NULL;
14973 single_step_breakpoints[1] = NULL;
14977 /* Delete software single step breakpoints without removing them from
14978 the inferior. This is intended to be used if the inferior's address
14979 space where they were inserted is already gone, e.g. after exit or
14983 cancel_single_step_breakpoints (void)
14987 for (i = 0; i < 2; i++)
14988 if (single_step_breakpoints[i])
14990 xfree (single_step_breakpoints[i]);
14991 single_step_breakpoints[i] = NULL;
14992 single_step_gdbarch[i] = NULL;
14996 /* Detach software single-step breakpoints from INFERIOR_PTID without
15000 detach_single_step_breakpoints (void)
15004 for (i = 0; i < 2; i++)
15005 if (single_step_breakpoints[i])
15006 target_remove_breakpoint (single_step_gdbarch[i],
15007 single_step_breakpoints[i]);
15010 /* Check whether a software single-step breakpoint is inserted at
15014 single_step_breakpoint_inserted_here_p (struct address_space *aspace,
15019 for (i = 0; i < 2; i++)
15021 struct bp_target_info *bp_tgt = single_step_breakpoints[i];
15023 && breakpoint_address_match (bp_tgt->placed_address_space,
15024 bp_tgt->placed_address,
15032 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
15033 non-zero otherwise. */
15035 is_syscall_catchpoint_enabled (struct breakpoint *bp)
15037 if (syscall_catchpoint_p (bp)
15038 && bp->enable_state != bp_disabled
15039 && bp->enable_state != bp_call_disabled)
15046 catch_syscall_enabled (void)
15048 struct catch_syscall_inferior_data *inf_data
15049 = get_catch_syscall_inferior_data (current_inferior ());
15051 return inf_data->total_syscalls_count != 0;
15055 catching_syscall_number (int syscall_number)
15057 struct breakpoint *bp;
15059 ALL_BREAKPOINTS (bp)
15060 if (is_syscall_catchpoint_enabled (bp))
15062 struct syscall_catchpoint *c = (struct syscall_catchpoint *) bp;
15064 if (c->syscalls_to_be_caught)
15068 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
15070 if (syscall_number == iter)
15080 /* Complete syscall names. Used by "catch syscall". */
15081 static VEC (char_ptr) *
15082 catch_syscall_completer (struct cmd_list_element *cmd,
15083 const char *text, const char *word)
15085 const char **list = get_syscall_names ();
15086 VEC (char_ptr) *retlist
15087 = (list == NULL) ? NULL : complete_on_enum (list, word, word);
15093 /* Tracepoint-specific operations. */
15095 /* Set tracepoint count to NUM. */
15097 set_tracepoint_count (int num)
15099 tracepoint_count = num;
15100 set_internalvar_integer (lookup_internalvar ("tpnum"), num);
15104 trace_command (char *arg, int from_tty)
15106 struct breakpoint_ops *ops;
15107 const char *arg_cp = arg;
15109 if (arg && probe_linespec_to_ops (&arg_cp))
15110 ops = &tracepoint_probe_breakpoint_ops;
15112 ops = &tracepoint_breakpoint_ops;
15114 create_breakpoint (get_current_arch (),
15116 NULL, 0, NULL, 1 /* parse arg */,
15118 bp_tracepoint /* type_wanted */,
15119 0 /* Ignore count */,
15120 pending_break_support,
15124 0 /* internal */, 0);
15128 ftrace_command (char *arg, int from_tty)
15130 create_breakpoint (get_current_arch (),
15132 NULL, 0, NULL, 1 /* parse arg */,
15134 bp_fast_tracepoint /* type_wanted */,
15135 0 /* Ignore count */,
15136 pending_break_support,
15137 &tracepoint_breakpoint_ops,
15140 0 /* internal */, 0);
15143 /* strace command implementation. Creates a static tracepoint. */
15146 strace_command (char *arg, int from_tty)
15148 struct breakpoint_ops *ops;
15150 /* Decide if we are dealing with a static tracepoint marker (`-m'),
15151 or with a normal static tracepoint. */
15152 if (arg && strncmp (arg, "-m", 2) == 0 && isspace (arg[2]))
15153 ops = &strace_marker_breakpoint_ops;
15155 ops = &tracepoint_breakpoint_ops;
15157 create_breakpoint (get_current_arch (),
15159 NULL, 0, NULL, 1 /* parse arg */,
15161 bp_static_tracepoint /* type_wanted */,
15162 0 /* Ignore count */,
15163 pending_break_support,
15167 0 /* internal */, 0);
15170 /* Set up a fake reader function that gets command lines from a linked
15171 list that was acquired during tracepoint uploading. */
15173 static struct uploaded_tp *this_utp;
15174 static int next_cmd;
15177 read_uploaded_action (void)
15181 VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
15188 /* Given information about a tracepoint as recorded on a target (which
15189 can be either a live system or a trace file), attempt to create an
15190 equivalent GDB tracepoint. This is not a reliable process, since
15191 the target does not necessarily have all the information used when
15192 the tracepoint was originally defined. */
15194 struct tracepoint *
15195 create_tracepoint_from_upload (struct uploaded_tp *utp)
15197 char *addr_str, small_buf[100];
15198 struct tracepoint *tp;
15200 if (utp->at_string)
15201 addr_str = utp->at_string;
15204 /* In the absence of a source location, fall back to raw
15205 address. Since there is no way to confirm that the address
15206 means the same thing as when the trace was started, warn the
15208 warning (_("Uploaded tracepoint %d has no "
15209 "source location, using raw address"),
15211 xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (utp->addr));
15212 addr_str = small_buf;
15215 /* There's not much we can do with a sequence of bytecodes. */
15216 if (utp->cond && !utp->cond_string)
15217 warning (_("Uploaded tracepoint %d condition "
15218 "has no source form, ignoring it"),
15221 if (!create_breakpoint (get_current_arch (),
15223 utp->cond_string, -1, NULL,
15224 0 /* parse cond/thread */,
15226 utp->type /* type_wanted */,
15227 0 /* Ignore count */,
15228 pending_break_support,
15229 &tracepoint_breakpoint_ops,
15231 utp->enabled /* enabled */,
15233 CREATE_BREAKPOINT_FLAGS_INSERTED))
15236 /* Get the tracepoint we just created. */
15237 tp = get_tracepoint (tracepoint_count);
15238 gdb_assert (tp != NULL);
15242 xsnprintf (small_buf, sizeof (small_buf), "%d %d", utp->pass,
15245 trace_pass_command (small_buf, 0);
15248 /* If we have uploaded versions of the original commands, set up a
15249 special-purpose "reader" function and call the usual command line
15250 reader, then pass the result to the breakpoint command-setting
15252 if (!VEC_empty (char_ptr, utp->cmd_strings))
15254 struct command_line *cmd_list;
15259 cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
15261 breakpoint_set_commands (&tp->base, cmd_list);
15263 else if (!VEC_empty (char_ptr, utp->actions)
15264 || !VEC_empty (char_ptr, utp->step_actions))
15265 warning (_("Uploaded tracepoint %d actions "
15266 "have no source form, ignoring them"),
15269 /* Copy any status information that might be available. */
15270 tp->base.hit_count = utp->hit_count;
15271 tp->traceframe_usage = utp->traceframe_usage;
15276 /* Print information on tracepoint number TPNUM_EXP, or all if
15280 tracepoints_info (char *args, int from_tty)
15282 struct ui_out *uiout = current_uiout;
15285 num_printed = breakpoint_1 (args, 0, is_tracepoint);
15287 if (num_printed == 0)
15289 if (args == NULL || *args == '\0')
15290 ui_out_message (uiout, 0, "No tracepoints.\n");
15292 ui_out_message (uiout, 0, "No tracepoint matching '%s'.\n", args);
15295 default_collect_info ();
15298 /* The 'enable trace' command enables tracepoints.
15299 Not supported by all targets. */
15301 enable_trace_command (char *args, int from_tty)
15303 enable_command (args, from_tty);
15306 /* The 'disable trace' command disables tracepoints.
15307 Not supported by all targets. */
15309 disable_trace_command (char *args, int from_tty)
15311 disable_command (args, from_tty);
15314 /* Remove a tracepoint (or all if no argument). */
15316 delete_trace_command (char *arg, int from_tty)
15318 struct breakpoint *b, *b_tmp;
15324 int breaks_to_delete = 0;
15326 /* Delete all breakpoints if no argument.
15327 Do not delete internal or call-dummy breakpoints, these
15328 have to be deleted with an explicit breakpoint number
15330 ALL_TRACEPOINTS (b)
15331 if (is_tracepoint (b) && user_breakpoint_p (b))
15333 breaks_to_delete = 1;
15337 /* Ask user only if there are some breakpoints to delete. */
15339 || (breaks_to_delete && query (_("Delete all tracepoints? "))))
15341 ALL_BREAKPOINTS_SAFE (b, b_tmp)
15342 if (is_tracepoint (b) && user_breakpoint_p (b))
15343 delete_breakpoint (b);
15347 map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
15350 /* Helper function for trace_pass_command. */
15353 trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
15355 tp->pass_count = count;
15356 observer_notify_breakpoint_modified (&tp->base);
15358 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15359 tp->base.number, count);
15362 /* Set passcount for tracepoint.
15364 First command argument is passcount, second is tracepoint number.
15365 If tracepoint number omitted, apply to most recently defined.
15366 Also accepts special argument "all". */
15369 trace_pass_command (char *args, int from_tty)
15371 struct tracepoint *t1;
15372 unsigned int count;
15374 if (args == 0 || *args == 0)
15375 error (_("passcount command requires an "
15376 "argument (count + optional TP num)"));
15378 count = strtoul (args, &args, 10); /* Count comes first, then TP num. */
15380 args = skip_spaces (args);
15381 if (*args && strncasecmp (args, "all", 3) == 0)
15383 struct breakpoint *b;
15385 args += 3; /* Skip special argument "all". */
15387 error (_("Junk at end of arguments."));
15389 ALL_TRACEPOINTS (b)
15391 t1 = (struct tracepoint *) b;
15392 trace_pass_set_count (t1, count, from_tty);
15395 else if (*args == '\0')
15397 t1 = get_tracepoint_by_number (&args, NULL, 1);
15399 trace_pass_set_count (t1, count, from_tty);
15403 struct get_number_or_range_state state;
15405 init_number_or_range (&state, args);
15406 while (!state.finished)
15408 t1 = get_tracepoint_by_number (&args, &state, 1);
15410 trace_pass_set_count (t1, count, from_tty);
15415 struct tracepoint *
15416 get_tracepoint (int num)
15418 struct breakpoint *t;
15420 ALL_TRACEPOINTS (t)
15421 if (t->number == num)
15422 return (struct tracepoint *) t;
15427 /* Find the tracepoint with the given target-side number (which may be
15428 different from the tracepoint number after disconnecting and
15431 struct tracepoint *
15432 get_tracepoint_by_number_on_target (int num)
15434 struct breakpoint *b;
15436 ALL_TRACEPOINTS (b)
15438 struct tracepoint *t = (struct tracepoint *) b;
15440 if (t->number_on_target == num)
15447 /* Utility: parse a tracepoint number and look it up in the list.
15448 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15449 If OPTIONAL_P is true, then if the argument is missing, the most
15450 recent tracepoint (tracepoint_count) is returned. */
15451 struct tracepoint *
15452 get_tracepoint_by_number (char **arg,
15453 struct get_number_or_range_state *state,
15456 struct breakpoint *t;
15458 char *instring = arg == NULL ? NULL : *arg;
15462 gdb_assert (!state->finished);
15463 tpnum = get_number_or_range (state);
15465 else if (arg == NULL || *arg == NULL || ! **arg)
15468 tpnum = tracepoint_count;
15470 error_no_arg (_("tracepoint number"));
15473 tpnum = get_number (arg);
15477 if (instring && *instring)
15478 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15481 printf_filtered (_("Tracepoint argument missing "
15482 "and no previous tracepoint\n"));
15486 ALL_TRACEPOINTS (t)
15487 if (t->number == tpnum)
15489 return (struct tracepoint *) t;
15492 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
15497 print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
15499 if (b->thread != -1)
15500 fprintf_unfiltered (fp, " thread %d", b->thread);
15503 fprintf_unfiltered (fp, " task %d", b->task);
15505 fprintf_unfiltered (fp, "\n");
15508 /* Save information on user settable breakpoints (watchpoints, etc) to
15509 a new script file named FILENAME. If FILTER is non-NULL, call it
15510 on each breakpoint and only include the ones for which it returns
15514 save_breakpoints (char *filename, int from_tty,
15515 int (*filter) (const struct breakpoint *))
15517 struct breakpoint *tp;
15519 struct cleanup *cleanup;
15520 struct ui_file *fp;
15521 int extra_trace_bits = 0;
15523 if (filename == 0 || *filename == 0)
15524 error (_("Argument required (file name in which to save)"));
15526 /* See if we have anything to save. */
15527 ALL_BREAKPOINTS (tp)
15529 /* Skip internal and momentary breakpoints. */
15530 if (!user_breakpoint_p (tp))
15533 /* If we have a filter, only save the breakpoints it accepts. */
15534 if (filter && !filter (tp))
15539 if (is_tracepoint (tp))
15541 extra_trace_bits = 1;
15543 /* We can stop searching. */
15550 warning (_("Nothing to save."));
15554 filename = tilde_expand (filename);
15555 cleanup = make_cleanup (xfree, filename);
15556 fp = gdb_fopen (filename, "w");
15558 error (_("Unable to open file '%s' for saving (%s)"),
15559 filename, safe_strerror (errno));
15560 make_cleanup_ui_file_delete (fp);
15562 if (extra_trace_bits)
15563 save_trace_state_variables (fp);
15565 ALL_BREAKPOINTS (tp)
15567 /* Skip internal and momentary breakpoints. */
15568 if (!user_breakpoint_p (tp))
15571 /* If we have a filter, only save the breakpoints it accepts. */
15572 if (filter && !filter (tp))
15575 tp->ops->print_recreate (tp, fp);
15577 /* Note, we can't rely on tp->number for anything, as we can't
15578 assume the recreated breakpoint numbers will match. Use $bpnum
15581 if (tp->cond_string)
15582 fprintf_unfiltered (fp, " condition $bpnum %s\n", tp->cond_string);
15584 if (tp->ignore_count)
15585 fprintf_unfiltered (fp, " ignore $bpnum %d\n", tp->ignore_count);
15587 if (tp->type != bp_dprintf && tp->commands)
15589 volatile struct gdb_exception ex;
15591 fprintf_unfiltered (fp, " commands\n");
15593 ui_out_redirect (current_uiout, fp);
15594 TRY_CATCH (ex, RETURN_MASK_ALL)
15596 print_command_lines (current_uiout, tp->commands->commands, 2);
15598 ui_out_redirect (current_uiout, NULL);
15601 throw_exception (ex);
15603 fprintf_unfiltered (fp, " end\n");
15606 if (tp->enable_state == bp_disabled)
15607 fprintf_unfiltered (fp, "disable\n");
15609 /* If this is a multi-location breakpoint, check if the locations
15610 should be individually disabled. Watchpoint locations are
15611 special, and not user visible. */
15612 if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15614 struct bp_location *loc;
15617 for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15619 fprintf_unfiltered (fp, "disable $bpnum.%d\n", n);
15623 if (extra_trace_bits && *default_collect)
15624 fprintf_unfiltered (fp, "set default-collect %s\n", default_collect);
15627 printf_filtered (_("Saved to file '%s'.\n"), filename);
15628 do_cleanups (cleanup);
15631 /* The `save breakpoints' command. */
15634 save_breakpoints_command (char *args, int from_tty)
15636 save_breakpoints (args, from_tty, NULL);
15639 /* The `save tracepoints' command. */
15642 save_tracepoints_command (char *args, int from_tty)
15644 save_breakpoints (args, from_tty, is_tracepoint);
15647 /* Create a vector of all tracepoints. */
15649 VEC(breakpoint_p) *
15650 all_tracepoints (void)
15652 VEC(breakpoint_p) *tp_vec = 0;
15653 struct breakpoint *tp;
15655 ALL_TRACEPOINTS (tp)
15657 VEC_safe_push (breakpoint_p, tp_vec, tp);
15664 /* This help string is used for the break, hbreak, tbreak and thbreak
15665 commands. It is defined as a macro to prevent duplication.
15666 COMMAND should be a string constant containing the name of the
15668 #define BREAK_ARGS_HELP(command) \
15669 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15670 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15671 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15672 guessed probe type) or `-probe-stap' (for a SystemTap probe).\n\
15673 LOCATION may be a line number, function name, or \"*\" and an address.\n\
15674 If a line number is specified, break at start of code for that line.\n\
15675 If a function is specified, break at start of code for that function.\n\
15676 If an address is specified, break at that exact address.\n\
15677 With no LOCATION, uses current execution address of the selected\n\
15678 stack frame. This is useful for breaking on return to a stack frame.\n\
15680 THREADNUM is the number from \"info threads\".\n\
15681 CONDITION is a boolean expression.\n\
15683 Multiple breakpoints at one place are permitted, and useful if their\n\
15684 conditions are different.\n\
15686 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15688 /* List of subcommands for "catch". */
15689 static struct cmd_list_element *catch_cmdlist;
15691 /* List of subcommands for "tcatch". */
15692 static struct cmd_list_element *tcatch_cmdlist;
15695 add_catch_command (char *name, char *docstring,
15696 void (*sfunc) (char *args, int from_tty,
15697 struct cmd_list_element *command),
15698 completer_ftype *completer,
15699 void *user_data_catch,
15700 void *user_data_tcatch)
15702 struct cmd_list_element *command;
15704 command = add_cmd (name, class_breakpoint, NULL, docstring,
15706 set_cmd_sfunc (command, sfunc);
15707 set_cmd_context (command, user_data_catch);
15708 set_cmd_completer (command, completer);
15710 command = add_cmd (name, class_breakpoint, NULL, docstring,
15712 set_cmd_sfunc (command, sfunc);
15713 set_cmd_context (command, user_data_tcatch);
15714 set_cmd_completer (command, completer);
15718 clear_syscall_counts (struct inferior *inf)
15720 struct catch_syscall_inferior_data *inf_data
15721 = get_catch_syscall_inferior_data (inf);
15723 inf_data->total_syscalls_count = 0;
15724 inf_data->any_syscall_count = 0;
15725 VEC_free (int, inf_data->syscalls_counts);
15729 save_command (char *arg, int from_tty)
15731 printf_unfiltered (_("\"save\" must be followed by "
15732 "the name of a save subcommand.\n"));
15733 help_list (save_cmdlist, "save ", -1, gdb_stdout);
15736 struct breakpoint *
15737 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15740 struct breakpoint *b, *b_tmp;
15742 ALL_BREAKPOINTS_SAFE (b, b_tmp)
15744 if ((*callback) (b, data))
15751 /* Zero if any of the breakpoint's locations could be a location where
15752 functions have been inlined, nonzero otherwise. */
15755 is_non_inline_function (struct breakpoint *b)
15757 /* The shared library event breakpoint is set on the address of a
15758 non-inline function. */
15759 if (b->type == bp_shlib_event)
15765 /* Nonzero if the specified PC cannot be a location where functions
15766 have been inlined. */
15769 pc_at_non_inline_function (struct address_space *aspace, CORE_ADDR pc,
15770 const struct target_waitstatus *ws)
15772 struct breakpoint *b;
15773 struct bp_location *bl;
15775 ALL_BREAKPOINTS (b)
15777 if (!is_non_inline_function (b))
15780 for (bl = b->loc; bl != NULL; bl = bl->next)
15782 if (!bl->shlib_disabled
15783 && bpstat_check_location (bl, aspace, pc, ws))
15791 /* Remove any references to OBJFILE which is going to be freed. */
15794 breakpoint_free_objfile (struct objfile *objfile)
15796 struct bp_location **locp, *loc;
15798 ALL_BP_LOCATIONS (loc, locp)
15799 if (loc->symtab != NULL && loc->symtab->objfile == objfile)
15800 loc->symtab = NULL;
15804 initialize_breakpoint_ops (void)
15806 static int initialized = 0;
15808 struct breakpoint_ops *ops;
15814 /* The breakpoint_ops structure to be inherit by all kinds of
15815 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15816 internal and momentary breakpoints, etc.). */
15817 ops = &bkpt_base_breakpoint_ops;
15818 *ops = base_breakpoint_ops;
15819 ops->re_set = bkpt_re_set;
15820 ops->insert_location = bkpt_insert_location;
15821 ops->remove_location = bkpt_remove_location;
15822 ops->breakpoint_hit = bkpt_breakpoint_hit;
15823 ops->create_sals_from_address = bkpt_create_sals_from_address;
15824 ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
15825 ops->decode_linespec = bkpt_decode_linespec;
15827 /* The breakpoint_ops structure to be used in regular breakpoints. */
15828 ops = &bkpt_breakpoint_ops;
15829 *ops = bkpt_base_breakpoint_ops;
15830 ops->re_set = bkpt_re_set;
15831 ops->resources_needed = bkpt_resources_needed;
15832 ops->print_it = bkpt_print_it;
15833 ops->print_mention = bkpt_print_mention;
15834 ops->print_recreate = bkpt_print_recreate;
15836 /* Ranged breakpoints. */
15837 ops = &ranged_breakpoint_ops;
15838 *ops = bkpt_breakpoint_ops;
15839 ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15840 ops->resources_needed = resources_needed_ranged_breakpoint;
15841 ops->print_it = print_it_ranged_breakpoint;
15842 ops->print_one = print_one_ranged_breakpoint;
15843 ops->print_one_detail = print_one_detail_ranged_breakpoint;
15844 ops->print_mention = print_mention_ranged_breakpoint;
15845 ops->print_recreate = print_recreate_ranged_breakpoint;
15847 /* Internal breakpoints. */
15848 ops = &internal_breakpoint_ops;
15849 *ops = bkpt_base_breakpoint_ops;
15850 ops->re_set = internal_bkpt_re_set;
15851 ops->check_status = internal_bkpt_check_status;
15852 ops->print_it = internal_bkpt_print_it;
15853 ops->print_mention = internal_bkpt_print_mention;
15855 /* Momentary breakpoints. */
15856 ops = &momentary_breakpoint_ops;
15857 *ops = bkpt_base_breakpoint_ops;
15858 ops->re_set = momentary_bkpt_re_set;
15859 ops->check_status = momentary_bkpt_check_status;
15860 ops->print_it = momentary_bkpt_print_it;
15861 ops->print_mention = momentary_bkpt_print_mention;
15863 /* Momentary breakpoints for bp_longjmp and bp_exception. */
15864 ops = &longjmp_breakpoint_ops;
15865 *ops = momentary_breakpoint_ops;
15866 ops->dtor = longjmp_bkpt_dtor;
15868 /* Probe breakpoints. */
15869 ops = &bkpt_probe_breakpoint_ops;
15870 *ops = bkpt_breakpoint_ops;
15871 ops->insert_location = bkpt_probe_insert_location;
15872 ops->remove_location = bkpt_probe_remove_location;
15873 ops->create_sals_from_address = bkpt_probe_create_sals_from_address;
15874 ops->decode_linespec = bkpt_probe_decode_linespec;
15877 ops = &watchpoint_breakpoint_ops;
15878 *ops = base_breakpoint_ops;
15879 ops->dtor = dtor_watchpoint;
15880 ops->re_set = re_set_watchpoint;
15881 ops->insert_location = insert_watchpoint;
15882 ops->remove_location = remove_watchpoint;
15883 ops->breakpoint_hit = breakpoint_hit_watchpoint;
15884 ops->check_status = check_status_watchpoint;
15885 ops->resources_needed = resources_needed_watchpoint;
15886 ops->works_in_software_mode = works_in_software_mode_watchpoint;
15887 ops->print_it = print_it_watchpoint;
15888 ops->print_mention = print_mention_watchpoint;
15889 ops->print_recreate = print_recreate_watchpoint;
15890 ops->explains_signal = explains_signal_watchpoint;
15892 /* Masked watchpoints. */
15893 ops = &masked_watchpoint_breakpoint_ops;
15894 *ops = watchpoint_breakpoint_ops;
15895 ops->insert_location = insert_masked_watchpoint;
15896 ops->remove_location = remove_masked_watchpoint;
15897 ops->resources_needed = resources_needed_masked_watchpoint;
15898 ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15899 ops->print_it = print_it_masked_watchpoint;
15900 ops->print_one_detail = print_one_detail_masked_watchpoint;
15901 ops->print_mention = print_mention_masked_watchpoint;
15902 ops->print_recreate = print_recreate_masked_watchpoint;
15905 ops = &tracepoint_breakpoint_ops;
15906 *ops = base_breakpoint_ops;
15907 ops->re_set = tracepoint_re_set;
15908 ops->breakpoint_hit = tracepoint_breakpoint_hit;
15909 ops->print_one_detail = tracepoint_print_one_detail;
15910 ops->print_mention = tracepoint_print_mention;
15911 ops->print_recreate = tracepoint_print_recreate;
15912 ops->create_sals_from_address = tracepoint_create_sals_from_address;
15913 ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
15914 ops->decode_linespec = tracepoint_decode_linespec;
15916 /* Probe tracepoints. */
15917 ops = &tracepoint_probe_breakpoint_ops;
15918 *ops = tracepoint_breakpoint_ops;
15919 ops->create_sals_from_address = tracepoint_probe_create_sals_from_address;
15920 ops->decode_linespec = tracepoint_probe_decode_linespec;
15922 /* Static tracepoints with marker (`-m'). */
15923 ops = &strace_marker_breakpoint_ops;
15924 *ops = tracepoint_breakpoint_ops;
15925 ops->create_sals_from_address = strace_marker_create_sals_from_address;
15926 ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
15927 ops->decode_linespec = strace_marker_decode_linespec;
15929 /* Fork catchpoints. */
15930 ops = &catch_fork_breakpoint_ops;
15931 *ops = base_breakpoint_ops;
15932 ops->insert_location = insert_catch_fork;
15933 ops->remove_location = remove_catch_fork;
15934 ops->breakpoint_hit = breakpoint_hit_catch_fork;
15935 ops->print_it = print_it_catch_fork;
15936 ops->print_one = print_one_catch_fork;
15937 ops->print_mention = print_mention_catch_fork;
15938 ops->print_recreate = print_recreate_catch_fork;
15940 /* Vfork catchpoints. */
15941 ops = &catch_vfork_breakpoint_ops;
15942 *ops = base_breakpoint_ops;
15943 ops->insert_location = insert_catch_vfork;
15944 ops->remove_location = remove_catch_vfork;
15945 ops->breakpoint_hit = breakpoint_hit_catch_vfork;
15946 ops->print_it = print_it_catch_vfork;
15947 ops->print_one = print_one_catch_vfork;
15948 ops->print_mention = print_mention_catch_vfork;
15949 ops->print_recreate = print_recreate_catch_vfork;
15951 /* Exec catchpoints. */
15952 ops = &catch_exec_breakpoint_ops;
15953 *ops = base_breakpoint_ops;
15954 ops->dtor = dtor_catch_exec;
15955 ops->insert_location = insert_catch_exec;
15956 ops->remove_location = remove_catch_exec;
15957 ops->breakpoint_hit = breakpoint_hit_catch_exec;
15958 ops->print_it = print_it_catch_exec;
15959 ops->print_one = print_one_catch_exec;
15960 ops->print_mention = print_mention_catch_exec;
15961 ops->print_recreate = print_recreate_catch_exec;
15963 /* Syscall catchpoints. */
15964 ops = &catch_syscall_breakpoint_ops;
15965 *ops = base_breakpoint_ops;
15966 ops->dtor = dtor_catch_syscall;
15967 ops->insert_location = insert_catch_syscall;
15968 ops->remove_location = remove_catch_syscall;
15969 ops->breakpoint_hit = breakpoint_hit_catch_syscall;
15970 ops->print_it = print_it_catch_syscall;
15971 ops->print_one = print_one_catch_syscall;
15972 ops->print_mention = print_mention_catch_syscall;
15973 ops->print_recreate = print_recreate_catch_syscall;
15975 /* Solib-related catchpoints. */
15976 ops = &catch_solib_breakpoint_ops;
15977 *ops = base_breakpoint_ops;
15978 ops->dtor = dtor_catch_solib;
15979 ops->insert_location = insert_catch_solib;
15980 ops->remove_location = remove_catch_solib;
15981 ops->breakpoint_hit = breakpoint_hit_catch_solib;
15982 ops->check_status = check_status_catch_solib;
15983 ops->print_it = print_it_catch_solib;
15984 ops->print_one = print_one_catch_solib;
15985 ops->print_mention = print_mention_catch_solib;
15986 ops->print_recreate = print_recreate_catch_solib;
15988 ops = &dprintf_breakpoint_ops;
15989 *ops = bkpt_base_breakpoint_ops;
15990 ops->re_set = dprintf_re_set;
15991 ops->resources_needed = bkpt_resources_needed;
15992 ops->print_it = bkpt_print_it;
15993 ops->print_mention = bkpt_print_mention;
15994 ops->print_recreate = dprintf_print_recreate;
15995 ops->after_condition_true = dprintf_after_condition_true;
15998 /* Chain containing all defined "enable breakpoint" subcommands. */
16000 static struct cmd_list_element *enablebreaklist = NULL;
16003 _initialize_breakpoint (void)
16005 struct cmd_list_element *c;
16007 initialize_breakpoint_ops ();
16009 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
16010 observer_attach_inferior_exit (clear_syscall_counts);
16011 observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
16013 breakpoint_objfile_key
16014 = register_objfile_data_with_cleanup (NULL, free_breakpoint_probes);
16016 catch_syscall_inferior_data
16017 = register_inferior_data_with_cleanup (NULL,
16018 catch_syscall_inferior_data_cleanup);
16020 breakpoint_chain = 0;
16021 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
16022 before a breakpoint is set. */
16023 breakpoint_count = 0;
16025 tracepoint_count = 0;
16027 add_com ("ignore", class_breakpoint, ignore_command, _("\
16028 Set ignore-count of breakpoint number N to COUNT.\n\
16029 Usage is `ignore N COUNT'."));
16031 add_com_alias ("bc", "ignore", class_breakpoint, 1);
16033 add_com ("commands", class_breakpoint, commands_command, _("\
16034 Set commands to be executed when a breakpoint is hit.\n\
16035 Give breakpoint number as argument after \"commands\".\n\
16036 With no argument, the targeted breakpoint is the last one set.\n\
16037 The commands themselves follow starting on the next line.\n\
16038 Type a line containing \"end\" to indicate the end of them.\n\
16039 Give \"silent\" as the first line to make the breakpoint silent;\n\
16040 then no output is printed when it is hit, except what the commands print."));
16042 c = add_com ("condition", class_breakpoint, condition_command, _("\
16043 Specify breakpoint number N to break only if COND is true.\n\
16044 Usage is `condition N COND', where N is an integer and COND is an\n\
16045 expression to be evaluated whenever breakpoint N is reached."));
16046 set_cmd_completer (c, condition_completer);
16048 c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
16049 Set a temporary breakpoint.\n\
16050 Like \"break\" except the breakpoint is only temporary,\n\
16051 so it will be deleted when hit. Equivalent to \"break\" followed\n\
16052 by using \"enable delete\" on the breakpoint number.\n\
16054 BREAK_ARGS_HELP ("tbreak")));
16055 set_cmd_completer (c, location_completer);
16057 c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
16058 Set a hardware assisted breakpoint.\n\
16059 Like \"break\" except the breakpoint requires hardware support,\n\
16060 some target hardware may not have this support.\n\
16062 BREAK_ARGS_HELP ("hbreak")));
16063 set_cmd_completer (c, location_completer);
16065 c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
16066 Set a temporary hardware assisted breakpoint.\n\
16067 Like \"hbreak\" except the breakpoint is only temporary,\n\
16068 so it will be deleted when hit.\n\
16070 BREAK_ARGS_HELP ("thbreak")));
16071 set_cmd_completer (c, location_completer);
16073 add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
16074 Enable some breakpoints.\n\
16075 Give breakpoint numbers (separated by spaces) as arguments.\n\
16076 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16077 This is used to cancel the effect of the \"disable\" command.\n\
16078 With a subcommand you can enable temporarily."),
16079 &enablelist, "enable ", 1, &cmdlist);
16081 add_com ("ab", class_breakpoint, enable_command, _("\
16082 Enable some breakpoints.\n\
16083 Give breakpoint numbers (separated by spaces) as arguments.\n\
16084 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16085 This is used to cancel the effect of the \"disable\" command.\n\
16086 With a subcommand you can enable temporarily."));
16088 add_com_alias ("en", "enable", class_breakpoint, 1);
16090 add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
16091 Enable some breakpoints.\n\
16092 Give breakpoint numbers (separated by spaces) as arguments.\n\
16093 This is used to cancel the effect of the \"disable\" command.\n\
16094 May be abbreviated to simply \"enable\".\n"),
16095 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
16097 add_cmd ("once", no_class, enable_once_command, _("\
16098 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16099 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16102 add_cmd ("delete", no_class, enable_delete_command, _("\
16103 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16104 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16107 add_cmd ("count", no_class, enable_count_command, _("\
16108 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16109 If a breakpoint is hit while enabled in this fashion,\n\
16110 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16113 add_cmd ("delete", no_class, enable_delete_command, _("\
16114 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16115 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16118 add_cmd ("once", no_class, enable_once_command, _("\
16119 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16120 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16123 add_cmd ("count", no_class, enable_count_command, _("\
16124 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16125 If a breakpoint is hit while enabled in this fashion,\n\
16126 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16129 add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
16130 Disable some breakpoints.\n\
16131 Arguments are breakpoint numbers with spaces in between.\n\
16132 To disable all breakpoints, give no argument.\n\
16133 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
16134 &disablelist, "disable ", 1, &cmdlist);
16135 add_com_alias ("dis", "disable", class_breakpoint, 1);
16136 add_com_alias ("disa", "disable", class_breakpoint, 1);
16138 add_com ("sb", class_breakpoint, disable_command, _("\
16139 Disable some breakpoints.\n\
16140 Arguments are breakpoint numbers with spaces in between.\n\
16141 To disable all breakpoints, give no argument.\n\
16142 A disabled breakpoint is not forgotten, but has no effect until re-enabled."));
16144 add_cmd ("breakpoints", class_alias, disable_command, _("\
16145 Disable some breakpoints.\n\
16146 Arguments are breakpoint numbers with spaces in between.\n\
16147 To disable all breakpoints, give no argument.\n\
16148 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
16149 This command may be abbreviated \"disable\"."),
16152 add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
16153 Delete some breakpoints or auto-display expressions.\n\
16154 Arguments are breakpoint numbers with spaces in between.\n\
16155 To delete all breakpoints, give no argument.\n\
16157 Also a prefix command for deletion of other GDB objects.\n\
16158 The \"unset\" command is also an alias for \"delete\"."),
16159 &deletelist, "delete ", 1, &cmdlist);
16160 add_com_alias ("d", "delete", class_breakpoint, 1);
16161 add_com_alias ("del", "delete", class_breakpoint, 1);
16163 add_com ("db", class_breakpoint, delete_command, _("\
16164 Delete some breakpoints.\n\
16165 Arguments are breakpoint numbers with spaces in between.\n\
16166 To delete all breakpoints, give no argument.\n"));
16168 add_cmd ("breakpoints", class_alias, delete_command, _("\
16169 Delete some breakpoints or auto-display expressions.\n\
16170 Arguments are breakpoint numbers with spaces in between.\n\
16171 To delete all breakpoints, give no argument.\n\
16172 This command may be abbreviated \"delete\"."),
16175 add_com ("clear", class_breakpoint, clear_command, _("\
16176 Clear breakpoint at specified line or function.\n\
16177 Argument may be line number, function name, or \"*\" and an address.\n\
16178 If line number is specified, all breakpoints in that line are cleared.\n\
16179 If function is specified, breakpoints at beginning of function are cleared.\n\
16180 If an address is specified, breakpoints at that address are cleared.\n\
16182 With no argument, clears all breakpoints in the line that the selected frame\n\
16183 is executing in.\n\
16185 See also the \"delete\" command which clears breakpoints by number."));
16186 add_com_alias ("cl", "clear", class_breakpoint, 1);
16188 c = add_com ("break", class_breakpoint, break_command, _("\
16189 Set breakpoint at specified line or function.\n"
16190 BREAK_ARGS_HELP ("break")));
16191 set_cmd_completer (c, location_completer);
16193 add_com_alias ("b", "break", class_run, 1);
16194 add_com_alias ("br", "break", class_run, 1);
16195 add_com_alias ("bre", "break", class_run, 1);
16196 add_com_alias ("brea", "break", class_run, 1);
16199 add_com_alias ("ba", "break", class_breakpoint, 1);
16203 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
16204 Break in function/address or break at a line in the current file."),
16205 &stoplist, "stop ", 1, &cmdlist);
16206 add_cmd ("in", class_breakpoint, stopin_command,
16207 _("Break in function or address."), &stoplist);
16208 add_cmd ("at", class_breakpoint, stopat_command,
16209 _("Break at a line in the current file."), &stoplist);
16210 add_com ("status", class_info, breakpoints_info, _("\
16211 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16212 The \"Type\" column indicates one of:\n\
16213 \tbreakpoint - normal breakpoint\n\
16214 \twatchpoint - watchpoint\n\
16215 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16216 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16217 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16218 address and file/line number respectively.\n\
16220 Convenience variable \"$_\" and default examine address for \"x\"\n\
16221 are set to the address of the last breakpoint listed unless the command\n\
16222 is prefixed with \"server \".\n\n\
16223 Convenience variable \"$bpnum\" contains the number of the last\n\
16224 breakpoint set."));
16227 add_info ("breakpoints", breakpoints_info, _("\
16228 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
16229 The \"Type\" column indicates one of:\n\
16230 \tbreakpoint - normal breakpoint\n\
16231 \twatchpoint - watchpoint\n\
16232 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16233 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16234 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16235 address and file/line number respectively.\n\
16237 Convenience variable \"$_\" and default examine address for \"x\"\n\
16238 are set to the address of the last breakpoint listed unless the command\n\
16239 is prefixed with \"server \".\n\n\
16240 Convenience variable \"$bpnum\" contains the number of the last\n\
16241 breakpoint set."));
16243 add_info_alias ("b", "breakpoints", 1);
16246 add_com ("lb", class_breakpoint, breakpoints_info, _("\
16247 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16248 The \"Type\" column indicates one of:\n\
16249 \tbreakpoint - normal breakpoint\n\
16250 \twatchpoint - watchpoint\n\
16251 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16252 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16253 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16254 address and file/line number respectively.\n\
16256 Convenience variable \"$_\" and default examine address for \"x\"\n\
16257 are set to the address of the last breakpoint listed unless the command\n\
16258 is prefixed with \"server \".\n\n\
16259 Convenience variable \"$bpnum\" contains the number of the last\n\
16260 breakpoint set."));
16262 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
16263 Status of all breakpoints, or breakpoint number NUMBER.\n\
16264 The \"Type\" column indicates one of:\n\
16265 \tbreakpoint - normal breakpoint\n\
16266 \twatchpoint - watchpoint\n\
16267 \tlongjmp - internal breakpoint used to step through longjmp()\n\
16268 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16269 \tuntil - internal breakpoint used by the \"until\" command\n\
16270 \tfinish - internal breakpoint used by the \"finish\" command\n\
16271 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16272 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16273 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16274 address and file/line number respectively.\n\
16276 Convenience variable \"$_\" and default examine address for \"x\"\n\
16277 are set to the address of the last breakpoint listed unless the command\n\
16278 is prefixed with \"server \".\n\n\
16279 Convenience variable \"$bpnum\" contains the number of the last\n\
16281 &maintenanceinfolist);
16283 add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
16284 Set catchpoints to catch events."),
16285 &catch_cmdlist, "catch ",
16286 0/*allow-unknown*/, &cmdlist);
16288 add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
16289 Set temporary catchpoints to catch events."),
16290 &tcatch_cmdlist, "tcatch ",
16291 0/*allow-unknown*/, &cmdlist);
16293 add_catch_command ("fork", _("Catch calls to fork."),
16294 catch_fork_command_1,
16296 (void *) (uintptr_t) catch_fork_permanent,
16297 (void *) (uintptr_t) catch_fork_temporary);
16298 add_catch_command ("vfork", _("Catch calls to vfork."),
16299 catch_fork_command_1,
16301 (void *) (uintptr_t) catch_vfork_permanent,
16302 (void *) (uintptr_t) catch_vfork_temporary);
16303 add_catch_command ("exec", _("Catch calls to exec."),
16304 catch_exec_command_1,
16308 add_catch_command ("load", _("Catch loads of shared libraries.\n\
16309 Usage: catch load [REGEX]\n\
16310 If REGEX is given, only stop for libraries matching the regular expression."),
16311 catch_load_command_1,
16315 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16316 Usage: catch unload [REGEX]\n\
16317 If REGEX is given, only stop for libraries matching the regular expression."),
16318 catch_unload_command_1,
16322 add_catch_command ("syscall", _("\
16323 Catch system calls by their names and/or numbers.\n\
16324 Arguments say which system calls to catch. If no arguments\n\
16325 are given, every system call will be caught.\n\
16326 Arguments, if given, should be one or more system call names\n\
16327 (if your system supports that), or system call numbers."),
16328 catch_syscall_command_1,
16329 catch_syscall_completer,
16333 c = add_com ("watch", class_breakpoint, watch_command, _("\
16334 Set a watchpoint for an expression.\n\
16335 Usage: watch [-l|-location] EXPRESSION\n\
16336 A watchpoint stops execution of your program whenever the value of\n\
16337 an expression changes.\n\
16338 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16339 the memory to which it refers."));
16340 set_cmd_completer (c, expression_completer);
16342 c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
16343 Set a read watchpoint for an expression.\n\
16344 Usage: rwatch [-l|-location] EXPRESSION\n\
16345 A watchpoint stops execution of your program whenever the value of\n\
16346 an expression is read.\n\
16347 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16348 the memory to which it refers."));
16349 set_cmd_completer (c, expression_completer);
16351 c = add_com ("awatch", class_breakpoint, awatch_command, _("\
16352 Set a watchpoint for an expression.\n\
16353 Usage: awatch [-l|-location] EXPRESSION\n\
16354 A watchpoint stops execution of your program whenever the value of\n\
16355 an expression is either read or written.\n\
16356 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16357 the memory to which it refers."));
16358 set_cmd_completer (c, expression_completer);
16360 add_info ("watchpoints", watchpoints_info, _("\
16361 Status of specified watchpoints (all watchpoints if no argument)."));
16363 /* XXX: cagney/2005-02-23: This should be a boolean, and should
16364 respond to changes - contrary to the description. */
16365 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
16366 &can_use_hw_watchpoints, _("\
16367 Set debugger's willingness to use watchpoint hardware."), _("\
16368 Show debugger's willingness to use watchpoint hardware."), _("\
16369 If zero, gdb will not use hardware for new watchpoints, even if\n\
16370 such is available. (However, any hardware watchpoints that were\n\
16371 created before setting this to nonzero, will continue to use watchpoint\n\
16374 show_can_use_hw_watchpoints,
16375 &setlist, &showlist);
16377 can_use_hw_watchpoints = 1;
16379 /* Tracepoint manipulation commands. */
16381 c = add_com ("trace", class_breakpoint, trace_command, _("\
16382 Set a tracepoint at specified line or function.\n\
16384 BREAK_ARGS_HELP ("trace") "\n\
16385 Do \"help tracepoints\" for info on other tracepoint commands."));
16386 set_cmd_completer (c, location_completer);
16388 add_com_alias ("tp", "trace", class_alias, 0);
16389 add_com_alias ("tr", "trace", class_alias, 1);
16390 add_com_alias ("tra", "trace", class_alias, 1);
16391 add_com_alias ("trac", "trace", class_alias, 1);
16393 c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
16394 Set a fast tracepoint at specified line or function.\n\
16396 BREAK_ARGS_HELP ("ftrace") "\n\
16397 Do \"help tracepoints\" for info on other tracepoint commands."));
16398 set_cmd_completer (c, location_completer);
16400 c = add_com ("strace", class_breakpoint, strace_command, _("\
16401 Set a static tracepoint at specified line, function or marker.\n\
16403 strace [LOCATION] [if CONDITION]\n\
16404 LOCATION may be a line number, function name, \"*\" and an address,\n\
16405 or -m MARKER_ID.\n\
16406 If a line number is specified, probe the marker at start of code\n\
16407 for that line. If a function is specified, probe the marker at start\n\
16408 of code for that function. If an address is specified, probe the marker\n\
16409 at that exact address. If a marker id is specified, probe the marker\n\
16410 with that name. With no LOCATION, uses current execution address of\n\
16411 the selected stack frame.\n\
16412 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16413 This collects arbitrary user data passed in the probe point call to the\n\
16414 tracing library. You can inspect it when analyzing the trace buffer,\n\
16415 by printing the $_sdata variable like any other convenience variable.\n\
16417 CONDITION is a boolean expression.\n\
16419 Multiple tracepoints at one place are permitted, and useful if their\n\
16420 conditions are different.\n\
16422 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16423 Do \"help tracepoints\" for info on other tracepoint commands."));
16424 set_cmd_completer (c, location_completer);
16426 add_info ("tracepoints", tracepoints_info, _("\
16427 Status of specified tracepoints (all tracepoints if no argument).\n\
16428 Convenience variable \"$tpnum\" contains the number of the\n\
16429 last tracepoint set."));
16431 add_info_alias ("tp", "tracepoints", 1);
16433 add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
16434 Delete specified tracepoints.\n\
16435 Arguments are tracepoint numbers, separated by spaces.\n\
16436 No argument means delete all tracepoints."),
16438 add_alias_cmd ("tr", "tracepoints", class_trace, 1, &deletelist);
16440 c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
16441 Disable specified tracepoints.\n\
16442 Arguments are tracepoint numbers, separated by spaces.\n\
16443 No argument means disable all tracepoints."),
16445 deprecate_cmd (c, "disable");
16447 c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
16448 Enable specified tracepoints.\n\
16449 Arguments are tracepoint numbers, separated by spaces.\n\
16450 No argument means enable all tracepoints."),
16452 deprecate_cmd (c, "enable");
16454 add_com ("passcount", class_trace, trace_pass_command, _("\
16455 Set the passcount for a tracepoint.\n\
16456 The trace will end when the tracepoint has been passed 'count' times.\n\
16457 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16458 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16460 add_prefix_cmd ("save", class_breakpoint, save_command,
16461 _("Save breakpoint definitions as a script."),
16462 &save_cmdlist, "save ",
16463 0/*allow-unknown*/, &cmdlist);
16465 c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
16466 Save current breakpoint definitions as a script.\n\
16467 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16468 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16469 session to restore them."),
16471 set_cmd_completer (c, filename_completer);
16473 c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
16474 Save current tracepoint definitions as a script.\n\
16475 Use the 'source' command in another debug session to restore them."),
16477 set_cmd_completer (c, filename_completer);
16479 c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
16480 deprecate_cmd (c, "save tracepoints");
16482 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
16483 Breakpoint specific settings\n\
16484 Configure various breakpoint-specific variables such as\n\
16485 pending breakpoint behavior"),
16486 &breakpoint_set_cmdlist, "set breakpoint ",
16487 0/*allow-unknown*/, &setlist);
16488 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
16489 Breakpoint specific settings\n\
16490 Configure various breakpoint-specific variables such as\n\
16491 pending breakpoint behavior"),
16492 &breakpoint_show_cmdlist, "show breakpoint ",
16493 0/*allow-unknown*/, &showlist);
16495 add_setshow_auto_boolean_cmd ("pending", no_class,
16496 &pending_break_support, _("\
16497 Set debugger's behavior regarding pending breakpoints."), _("\
16498 Show debugger's behavior regarding pending breakpoints."), _("\
16499 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16500 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16501 an error. If auto, an unrecognized breakpoint location results in a\n\
16502 user-query to see if a pending breakpoint should be created."),
16504 show_pending_break_support,
16505 &breakpoint_set_cmdlist,
16506 &breakpoint_show_cmdlist);
16508 pending_break_support = AUTO_BOOLEAN_AUTO;
16510 add_setshow_boolean_cmd ("auto-hw", no_class,
16511 &automatic_hardware_breakpoints, _("\
16512 Set automatic usage of hardware breakpoints."), _("\
16513 Show automatic usage of hardware breakpoints."), _("\
16514 If set, the debugger will automatically use hardware breakpoints for\n\
16515 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16516 a warning will be emitted for such breakpoints."),
16518 show_automatic_hardware_breakpoints,
16519 &breakpoint_set_cmdlist,
16520 &breakpoint_show_cmdlist);
16522 add_setshow_auto_boolean_cmd ("always-inserted", class_support,
16523 &always_inserted_mode, _("\
16524 Set mode for inserting breakpoints."), _("\
16525 Show mode for inserting breakpoints."), _("\
16526 When this mode is off, breakpoints are inserted in inferior when it is\n\
16527 resumed, and removed when execution stops. When this mode is on,\n\
16528 breakpoints are inserted immediately and removed only when the user\n\
16529 deletes the breakpoint. When this mode is auto (which is the default),\n\
16530 the behaviour depends on the non-stop setting (see help set non-stop).\n\
16531 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
16532 behaves as if always-inserted mode is on; if gdb is controlling the\n\
16533 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
16535 &show_always_inserted_mode,
16536 &breakpoint_set_cmdlist,
16537 &breakpoint_show_cmdlist);
16539 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
16540 condition_evaluation_enums,
16541 &condition_evaluation_mode_1, _("\
16542 Set mode of breakpoint condition evaluation."), _("\
16543 Show mode of breakpoint condition evaluation."), _("\
16544 When this is set to \"host\", breakpoint conditions will be\n\
16545 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16546 breakpoint conditions will be downloaded to the target (if the target\n\
16547 supports such feature) and conditions will be evaluated on the target's side.\n\
16548 If this is set to \"auto\" (default), this will be automatically set to\n\
16549 \"target\" if it supports condition evaluation, otherwise it will\n\
16550 be set to \"gdb\""),
16551 &set_condition_evaluation_mode,
16552 &show_condition_evaluation_mode,
16553 &breakpoint_set_cmdlist,
16554 &breakpoint_show_cmdlist);
16556 add_com ("break-range", class_breakpoint, break_range_command, _("\
16557 Set a breakpoint for an address range.\n\
16558 break-range START-LOCATION, END-LOCATION\n\
16559 where START-LOCATION and END-LOCATION can be one of the following:\n\
16560 LINENUM, for that line in the current file,\n\
16561 FILE:LINENUM, for that line in that file,\n\
16562 +OFFSET, for that number of lines after the current line\n\
16563 or the start of the range\n\
16564 FUNCTION, for the first line in that function,\n\
16565 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16566 *ADDRESS, for the instruction at that address.\n\
16568 The breakpoint will stop execution of the inferior whenever it executes\n\
16569 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16570 range (including START-LOCATION and END-LOCATION)."));
16572 c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
16573 Set a dynamic printf at specified line or function.\n\
16574 dprintf location,format string,arg1,arg2,...\n\
16575 location may be a line number, function name, or \"*\" and an address.\n\
16576 If a line number is specified, break at start of code for that line.\n\
16577 If a function is specified, break at start of code for that function."));
16578 set_cmd_completer (c, location_completer);
16580 add_setshow_enum_cmd ("dprintf-style", class_support,
16581 dprintf_style_enums, &dprintf_style, _("\
16582 Set the style of usage for dynamic printf."), _("\
16583 Show the style of usage for dynamic printf."), _("\
16584 This setting chooses how GDB will do a dynamic printf.\n\
16585 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16586 console, as with the \"printf\" command.\n\
16587 If the value is \"call\", the print is done by calling a function in your\n\
16588 program; by default printf(), but you can choose a different function or\n\
16589 output stream by setting dprintf-function and dprintf-channel."),
16590 update_dprintf_commands, NULL,
16591 &setlist, &showlist);
16593 dprintf_function = xstrdup ("printf");
16594 add_setshow_string_cmd ("dprintf-function", class_support,
16595 &dprintf_function, _("\
16596 Set the function to use for dynamic printf"), _("\
16597 Show the function to use for dynamic printf"), NULL,
16598 update_dprintf_commands, NULL,
16599 &setlist, &showlist);
16601 dprintf_channel = xstrdup ("");
16602 add_setshow_string_cmd ("dprintf-channel", class_support,
16603 &dprintf_channel, _("\
16604 Set the channel to use for dynamic printf"), _("\
16605 Show the channel to use for dynamic printf"), NULL,
16606 update_dprintf_commands, NULL,
16607 &setlist, &showlist);
16609 add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
16610 &disconnected_dprintf, _("\
16611 Set whether dprintf continues after GDB disconnects."), _("\
16612 Show whether dprintf continues after GDB disconnects."), _("\
16613 Use this to let dprintf commands continue to hit and produce output\n\
16614 even if GDB disconnects or detaches from the target."),
16617 &setlist, &showlist);
16619 add_com ("agent-printf", class_vars, agent_printf_command, _("\
16620 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16621 (target agent only) This is useful for formatted output in user-defined commands."));
16623 automatic_hardware_breakpoints = 1;
16625 observer_attach_about_to_proceed (breakpoint_about_to_proceed);
16626 observer_attach_thread_exit (remove_threaded_breakpoints);