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"
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 (_("Can't set read/access watchpoint when "
1809 "hardware watchpoints are disabled."));
1812 else if (within_current_scope && b->exp)
1815 struct value *val_chain, *v, *result, *next;
1816 struct program_space *frame_pspace;
1818 fetch_subexp_value (b->exp, &pc, &v, &result, &val_chain, 0);
1820 /* Avoid setting b->val if it's already set. The meaning of
1821 b->val is 'the last value' user saw, and we should update
1822 it only if we reported that last value to user. As it
1823 happens, the code that reports it updates b->val directly.
1824 We don't keep track of the memory value for masked
1826 if (!b->val_valid && !is_masked_watchpoint (&b->base))
1832 frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1834 /* Look at each value on the value chain. */
1835 for (v = val_chain; v; v = value_next (v))
1837 /* If it's a memory location, and GDB actually needed
1838 its contents to evaluate the expression, then we
1839 must watch it. If the first value returned is
1840 still lazy, that means an error occurred reading it;
1841 watch it anyway in case it becomes readable. */
1842 if (VALUE_LVAL (v) == lval_memory
1843 && (v == val_chain || ! value_lazy (v)))
1845 struct type *vtype = check_typedef (value_type (v));
1847 /* We only watch structs and arrays if user asked
1848 for it explicitly, never if they just happen to
1849 appear in the middle of some value chain. */
1851 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1852 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1856 struct bp_location *loc, **tmp;
1858 addr = value_address (v);
1860 if (b->base.type == bp_read_watchpoint)
1862 else if (b->base.type == bp_access_watchpoint)
1865 loc = allocate_bp_location (&b->base);
1866 for (tmp = &(b->base.loc); *tmp != NULL; tmp = &((*tmp)->next))
1869 loc->gdbarch = get_type_arch (value_type (v));
1871 loc->pspace = frame_pspace;
1872 loc->address = addr;
1873 loc->length = TYPE_LENGTH (value_type (v));
1874 loc->watchpoint_type = type;
1879 /* Change the type of breakpoint between hardware assisted or
1880 an ordinary watchpoint depending on the hardware support
1881 and free hardware slots. REPARSE is set when the inferior
1886 enum bp_loc_type loc_type;
1887 struct bp_location *bl;
1889 reg_cnt = can_use_hardware_watchpoint (val_chain);
1893 int i, target_resources_ok, other_type_used;
1896 /* Use an exact watchpoint when there's only one memory region to be
1897 watched, and only one debug register is needed to watch it. */
1898 b->exact = target_exact_watchpoints && reg_cnt == 1;
1900 /* We need to determine how many resources are already
1901 used for all other hardware watchpoints plus this one
1902 to see if we still have enough resources to also fit
1903 this watchpoint in as well. */
1905 /* If this is a software watchpoint, we try to turn it
1906 to a hardware one -- count resources as if B was of
1907 hardware watchpoint type. */
1908 type = b->base.type;
1909 if (type == bp_watchpoint)
1910 type = bp_hardware_watchpoint;
1912 /* This watchpoint may or may not have been placed on
1913 the list yet at this point (it won't be in the list
1914 if we're trying to create it for the first time,
1915 through watch_command), so always account for it
1918 /* Count resources used by all watchpoints except B. */
1919 i = hw_watchpoint_used_count_others (&b->base, type, &other_type_used);
1921 /* Add in the resources needed for B. */
1922 i += hw_watchpoint_use_count (&b->base);
1925 = target_can_use_hardware_watchpoint (type, i, other_type_used);
1926 if (target_resources_ok <= 0)
1928 int sw_mode = b->base.ops->works_in_software_mode (&b->base);
1930 if (target_resources_ok == 0 && !sw_mode)
1931 error (_("Target does not support this type of "
1932 "hardware watchpoint."));
1933 else if (target_resources_ok < 0 && !sw_mode)
1934 error (_("There are not enough available hardware "
1935 "resources for this watchpoint."));
1937 /* Downgrade to software watchpoint. */
1938 b->base.type = bp_watchpoint;
1942 /* If this was a software watchpoint, we've just
1943 found we have enough resources to turn it to a
1944 hardware watchpoint. Otherwise, this is a
1946 b->base.type = type;
1949 else if (!b->base.ops->works_in_software_mode (&b->base))
1951 if (!can_use_hw_watchpoints)
1952 error (_("Can't set read/access watchpoint when "
1953 "hardware watchpoints are disabled."));
1955 error (_("Expression cannot be implemented with "
1956 "read/access watchpoint."));
1959 b->base.type = bp_watchpoint;
1961 loc_type = (b->base.type == bp_watchpoint? bp_loc_other
1962 : bp_loc_hardware_watchpoint);
1963 for (bl = b->base.loc; bl; bl = bl->next)
1964 bl->loc_type = loc_type;
1967 for (v = val_chain; v; v = next)
1969 next = value_next (v);
1974 /* If a software watchpoint is not watching any memory, then the
1975 above left it without any location set up. But,
1976 bpstat_stop_status requires a location to be able to report
1977 stops, so make sure there's at least a dummy one. */
1978 if (b->base.type == bp_watchpoint && b->base.loc == NULL)
1980 struct breakpoint *base = &b->base;
1981 base->loc = allocate_bp_location (base);
1982 base->loc->pspace = frame_pspace;
1983 base->loc->address = -1;
1984 base->loc->length = -1;
1985 base->loc->watchpoint_type = -1;
1988 else if (!within_current_scope)
1990 printf_filtered (_("\
1991 Watchpoint %d deleted because the program has left the block\n\
1992 in which its expression is valid.\n"),
1994 watchpoint_del_at_next_stop (b);
1997 /* Restore the selected frame. */
1999 select_frame (frame_find_by_id (saved_frame_id));
2003 /* Returns 1 iff breakpoint location should be
2004 inserted in the inferior. We don't differentiate the type of BL's owner
2005 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2006 breakpoint_ops is not defined, because in insert_bp_location,
2007 tracepoint's insert_location will not be called. */
2009 should_be_inserted (struct bp_location *bl)
2011 if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
2014 if (bl->owner->disposition == disp_del_at_next_stop)
2017 if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
2020 if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
2023 /* This is set for example, when we're attached to the parent of a
2024 vfork, and have detached from the child. The child is running
2025 free, and we expect it to do an exec or exit, at which point the
2026 OS makes the parent schedulable again (and the target reports
2027 that the vfork is done). Until the child is done with the shared
2028 memory region, do not insert breakpoints in the parent, otherwise
2029 the child could still trip on the parent's breakpoints. Since
2030 the parent is blocked anyway, it won't miss any breakpoint. */
2031 if (bl->pspace->breakpoints_not_allowed)
2037 /* Same as should_be_inserted but does the check assuming
2038 that the location is not duplicated. */
2041 unduplicated_should_be_inserted (struct bp_location *bl)
2044 const int save_duplicate = bl->duplicate;
2047 result = should_be_inserted (bl);
2048 bl->duplicate = save_duplicate;
2052 /* Parses a conditional described by an expression COND into an
2053 agent expression bytecode suitable for evaluation
2054 by the bytecode interpreter. Return NULL if there was
2055 any error during parsing. */
2057 static struct agent_expr *
2058 parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
2060 struct agent_expr *aexpr = NULL;
2061 volatile struct gdb_exception ex;
2066 /* We don't want to stop processing, so catch any errors
2067 that may show up. */
2068 TRY_CATCH (ex, RETURN_MASK_ERROR)
2070 aexpr = gen_eval_for_expr (scope, cond);
2075 /* If we got here, it means the condition could not be parsed to a valid
2076 bytecode expression and thus can't be evaluated on the target's side.
2077 It's no use iterating through the conditions. */
2081 /* We have a valid agent expression. */
2085 /* Based on location BL, create a list of breakpoint conditions to be
2086 passed on to the target. If we have duplicated locations with different
2087 conditions, we will add such conditions to the list. The idea is that the
2088 target will evaluate the list of conditions and will only notify GDB when
2089 one of them is true. */
2092 build_target_condition_list (struct bp_location *bl)
2094 struct bp_location **locp = NULL, **loc2p;
2095 int null_condition_or_parse_error = 0;
2096 int modified = bl->needs_update;
2097 struct bp_location *loc;
2099 /* This is only meaningful if the target is
2100 evaluating conditions and if the user has
2101 opted for condition evaluation on the target's
2103 if (gdb_evaluates_breakpoint_condition_p ()
2104 || !target_supports_evaluation_of_breakpoint_conditions ())
2107 /* Do a first pass to check for locations with no assigned
2108 conditions or conditions that fail to parse to a valid agent expression
2109 bytecode. If any of these happen, then it's no use to send conditions
2110 to the target since this location will always trigger and generate a
2111 response back to GDB. */
2112 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2115 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2119 struct agent_expr *aexpr;
2121 /* Re-parse the conditions since something changed. In that
2122 case we already freed the condition bytecodes (see
2123 force_breakpoint_reinsertion). We just
2124 need to parse the condition to bytecodes again. */
2125 aexpr = parse_cond_to_aexpr (bl->address, loc->cond);
2126 loc->cond_bytecode = aexpr;
2128 /* Check if we managed to parse the conditional expression
2129 correctly. If not, we will not send this condition
2135 /* If we have a NULL bytecode expression, it means something
2136 went wrong or we have a null condition expression. */
2137 if (!loc->cond_bytecode)
2139 null_condition_or_parse_error = 1;
2145 /* If any of these happened, it means we will have to evaluate the conditions
2146 for the location's address on gdb's side. It is no use keeping bytecodes
2147 for all the other duplicate locations, thus we free all of them here.
2149 This is so we have a finer control over which locations' conditions are
2150 being evaluated by GDB or the remote stub. */
2151 if (null_condition_or_parse_error)
2153 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2156 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2158 /* Only go as far as the first NULL bytecode is
2160 if (!loc->cond_bytecode)
2163 free_agent_expr (loc->cond_bytecode);
2164 loc->cond_bytecode = NULL;
2169 /* No NULL conditions or failed bytecode generation. Build a condition list
2170 for this location's address. */
2171 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2175 && is_breakpoint (loc->owner)
2176 && loc->pspace->num == bl->pspace->num
2177 && loc->owner->enable_state == bp_enabled
2179 /* Add the condition to the vector. This will be used later to send the
2180 conditions to the target. */
2181 VEC_safe_push (agent_expr_p, bl->target_info.conditions,
2182 loc->cond_bytecode);
2188 /* Parses a command described by string CMD into an agent expression
2189 bytecode suitable for evaluation by the bytecode interpreter.
2190 Return NULL if there was any error during parsing. */
2192 static struct agent_expr *
2193 parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
2195 struct cleanup *old_cleanups = 0;
2196 struct expression *expr, **argvec;
2197 struct agent_expr *aexpr = NULL;
2198 volatile struct gdb_exception ex;
2199 const char *cmdrest;
2200 const char *format_start, *format_end;
2201 struct format_piece *fpieces;
2203 struct gdbarch *gdbarch = get_current_arch ();
2210 if (*cmdrest == ',')
2212 cmdrest = skip_spaces_const (cmdrest);
2214 if (*cmdrest++ != '"')
2215 error (_("No format string following the location"));
2217 format_start = cmdrest;
2219 fpieces = parse_format_string (&cmdrest);
2221 old_cleanups = make_cleanup (free_format_pieces_cleanup, &fpieces);
2223 format_end = cmdrest;
2225 if (*cmdrest++ != '"')
2226 error (_("Bad format string, non-terminated '\"'."));
2228 cmdrest = skip_spaces_const (cmdrest);
2230 if (!(*cmdrest == ',' || *cmdrest == '\0'))
2231 error (_("Invalid argument syntax"));
2233 if (*cmdrest == ',')
2235 cmdrest = skip_spaces_const (cmdrest);
2237 /* For each argument, make an expression. */
2239 argvec = (struct expression **) alloca (strlen (cmd)
2240 * sizeof (struct expression *));
2243 while (*cmdrest != '\0')
2248 expr = parse_exp_1 (&cmd1, scope, block_for_pc (scope), 1);
2249 argvec[nargs++] = expr;
2251 if (*cmdrest == ',')
2255 /* We don't want to stop processing, so catch any errors
2256 that may show up. */
2257 TRY_CATCH (ex, RETURN_MASK_ERROR)
2259 aexpr = gen_printf (scope, gdbarch, 0, 0,
2260 format_start, format_end - format_start,
2261 fpieces, nargs, argvec);
2264 do_cleanups (old_cleanups);
2268 /* If we got here, it means the command could not be parsed to a valid
2269 bytecode expression and thus can't be evaluated on the target's side.
2270 It's no use iterating through the other commands. */
2274 /* We have a valid agent expression, return it. */
2278 /* Based on location BL, create a list of breakpoint commands to be
2279 passed on to the target. If we have duplicated locations with
2280 different commands, we will add any such to the list. */
2283 build_target_command_list (struct bp_location *bl)
2285 struct bp_location **locp = NULL, **loc2p;
2286 int null_command_or_parse_error = 0;
2287 int modified = bl->needs_update;
2288 struct bp_location *loc;
2290 /* For now, limit to agent-style dprintf breakpoints. */
2291 if (bl->owner->type != bp_dprintf
2292 || strcmp (dprintf_style, dprintf_style_agent) != 0)
2295 if (!target_can_run_breakpoint_commands ())
2298 /* Do a first pass to check for locations with no assigned
2299 conditions or conditions that fail to parse to a valid agent expression
2300 bytecode. If any of these happen, then it's no use to send conditions
2301 to the target since this location will always trigger and generate a
2302 response back to GDB. */
2303 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2306 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2310 struct agent_expr *aexpr;
2312 /* Re-parse the commands since something changed. In that
2313 case we already freed the command bytecodes (see
2314 force_breakpoint_reinsertion). We just
2315 need to parse the command to bytecodes again. */
2316 aexpr = parse_cmd_to_aexpr (bl->address,
2317 loc->owner->extra_string);
2318 loc->cmd_bytecode = aexpr;
2324 /* If we have a NULL bytecode expression, it means something
2325 went wrong or we have a null command expression. */
2326 if (!loc->cmd_bytecode)
2328 null_command_or_parse_error = 1;
2334 /* If anything failed, then we're not doing target-side commands,
2336 if (null_command_or_parse_error)
2338 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2341 if (is_breakpoint (loc->owner)
2342 && loc->pspace->num == bl->pspace->num)
2344 /* Only go as far as the first NULL bytecode is
2346 if (loc->cmd_bytecode == NULL)
2349 free_agent_expr (loc->cmd_bytecode);
2350 loc->cmd_bytecode = NULL;
2355 /* No NULL commands or failed bytecode generation. Build a command list
2356 for this location's address. */
2357 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2360 if (loc->owner->extra_string
2361 && is_breakpoint (loc->owner)
2362 && loc->pspace->num == bl->pspace->num
2363 && loc->owner->enable_state == bp_enabled
2365 /* Add the command to the vector. This will be used later
2366 to send the commands to the target. */
2367 VEC_safe_push (agent_expr_p, bl->target_info.tcommands,
2371 bl->target_info.persist = 0;
2372 /* Maybe flag this location as persistent. */
2373 if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2374 bl->target_info.persist = 1;
2377 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2378 location. Any error messages are printed to TMP_ERROR_STREAM; and
2379 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2380 Returns 0 for success, 1 if the bp_location type is not supported or
2383 NOTE drow/2003-09-09: This routine could be broken down to an
2384 object-style method for each breakpoint or catchpoint type. */
2386 insert_bp_location (struct bp_location *bl,
2387 struct ui_file *tmp_error_stream,
2388 int *disabled_breaks,
2389 int *hw_breakpoint_error,
2390 int *hw_bp_error_explained_already)
2393 char *hw_bp_err_string = NULL;
2394 struct gdb_exception e;
2396 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2399 /* Note we don't initialize bl->target_info, as that wipes out
2400 the breakpoint location's shadow_contents if the breakpoint
2401 is still inserted at that location. This in turn breaks
2402 target_read_memory which depends on these buffers when
2403 a memory read is requested at the breakpoint location:
2404 Once the target_info has been wiped, we fail to see that
2405 we have a breakpoint inserted at that address and thus
2406 read the breakpoint instead of returning the data saved in
2407 the breakpoint location's shadow contents. */
2408 bl->target_info.placed_address = bl->address;
2409 bl->target_info.placed_address_space = bl->pspace->aspace;
2410 bl->target_info.length = bl->length;
2412 /* When working with target-side conditions, we must pass all the conditions
2413 for the same breakpoint address down to the target since GDB will not
2414 insert those locations. With a list of breakpoint conditions, the target
2415 can decide when to stop and notify GDB. */
2417 if (is_breakpoint (bl->owner))
2419 build_target_condition_list (bl);
2420 build_target_command_list (bl);
2421 /* Reset the modification marker. */
2422 bl->needs_update = 0;
2425 if (bl->loc_type == bp_loc_software_breakpoint
2426 || bl->loc_type == bp_loc_hardware_breakpoint)
2428 if (bl->owner->type != bp_hardware_breakpoint)
2430 /* If the explicitly specified breakpoint type
2431 is not hardware breakpoint, check the memory map to see
2432 if the breakpoint address is in read only memory or not.
2434 Two important cases are:
2435 - location type is not hardware breakpoint, memory
2436 is readonly. We change the type of the location to
2437 hardware breakpoint.
2438 - location type is hardware breakpoint, memory is
2439 read-write. This means we've previously made the
2440 location hardware one, but then the memory map changed,
2443 When breakpoints are removed, remove_breakpoints will use
2444 location types we've just set here, the only possible
2445 problem is that memory map has changed during running
2446 program, but it's not going to work anyway with current
2448 struct mem_region *mr
2449 = lookup_mem_region (bl->target_info.placed_address);
2453 if (automatic_hardware_breakpoints)
2455 enum bp_loc_type new_type;
2457 if (mr->attrib.mode != MEM_RW)
2458 new_type = bp_loc_hardware_breakpoint;
2460 new_type = bp_loc_software_breakpoint;
2462 if (new_type != bl->loc_type)
2464 static int said = 0;
2466 bl->loc_type = new_type;
2469 fprintf_filtered (gdb_stdout,
2470 _("Note: automatically using "
2471 "hardware breakpoints for "
2472 "read-only addresses.\n"));
2477 else if (bl->loc_type == bp_loc_software_breakpoint
2478 && mr->attrib.mode != MEM_RW)
2479 warning (_("cannot set software breakpoint "
2480 "at readonly address %s"),
2481 paddress (bl->gdbarch, bl->address));
2485 /* First check to see if we have to handle an overlay. */
2486 if (overlay_debugging == ovly_off
2487 || bl->section == NULL
2488 || !(section_is_overlay (bl->section)))
2490 /* No overlay handling: just set the breakpoint. */
2491 TRY_CATCH (e, RETURN_MASK_ALL)
2493 val = bl->owner->ops->insert_location (bl);
2498 hw_bp_err_string = (char *) e.message;
2503 /* This breakpoint is in an overlay section.
2504 Shall we set a breakpoint at the LMA? */
2505 if (!overlay_events_enabled)
2507 /* Yes -- overlay event support is not active,
2508 so we must try to set a breakpoint at the LMA.
2509 This will not work for a hardware breakpoint. */
2510 if (bl->loc_type == bp_loc_hardware_breakpoint)
2511 warning (_("hardware breakpoint %d not supported in overlay!"),
2515 CORE_ADDR addr = overlay_unmapped_address (bl->address,
2517 /* Set a software (trap) breakpoint at the LMA. */
2518 bl->overlay_target_info = bl->target_info;
2519 bl->overlay_target_info.placed_address = addr;
2520 val = target_insert_breakpoint (bl->gdbarch,
2521 &bl->overlay_target_info);
2523 fprintf_unfiltered (tmp_error_stream,
2524 "Overlay breakpoint %d "
2525 "failed: in ROM?\n",
2529 /* Shall we set a breakpoint at the VMA? */
2530 if (section_is_mapped (bl->section))
2532 /* Yes. This overlay section is mapped into memory. */
2533 TRY_CATCH (e, RETURN_MASK_ALL)
2535 val = bl->owner->ops->insert_location (bl);
2540 hw_bp_err_string = (char *) e.message;
2545 /* No. This breakpoint will not be inserted.
2546 No error, but do not mark the bp as 'inserted'. */
2553 /* Can't set the breakpoint. */
2554 if (solib_name_from_address (bl->pspace, bl->address))
2556 /* See also: disable_breakpoints_in_shlibs. */
2558 bl->shlib_disabled = 1;
2559 observer_notify_breakpoint_modified (bl->owner);
2560 if (!*disabled_breaks)
2562 fprintf_unfiltered (tmp_error_stream,
2563 "Cannot insert breakpoint %d.\n",
2565 fprintf_unfiltered (tmp_error_stream,
2566 "Temporarily disabling shared "
2567 "library breakpoints:\n");
2569 *disabled_breaks = 1;
2570 fprintf_unfiltered (tmp_error_stream,
2571 "breakpoint #%d\n", bl->owner->number);
2575 if (bl->loc_type == bp_loc_hardware_breakpoint)
2577 *hw_breakpoint_error = 1;
2578 *hw_bp_error_explained_already = hw_bp_err_string != NULL;
2579 fprintf_unfiltered (tmp_error_stream,
2580 "Cannot insert hardware breakpoint %d%s",
2581 bl->owner->number, hw_bp_err_string ? ":" : ".\n");
2582 if (hw_bp_err_string)
2583 fprintf_unfiltered (tmp_error_stream, "%s.\n", hw_bp_err_string);
2587 char *message = memory_error_message (TARGET_XFER_E_IO,
2588 bl->gdbarch, bl->address);
2589 struct cleanup *old_chain = make_cleanup (xfree, message);
2591 fprintf_unfiltered (tmp_error_stream,
2592 "Cannot insert breakpoint %d.\n"
2594 bl->owner->number, message);
2596 do_cleanups (old_chain);
2607 else if (bl->loc_type == bp_loc_hardware_watchpoint
2608 /* NOTE drow/2003-09-08: This state only exists for removing
2609 watchpoints. It's not clear that it's necessary... */
2610 && bl->owner->disposition != disp_del_at_next_stop)
2612 gdb_assert (bl->owner->ops != NULL
2613 && bl->owner->ops->insert_location != NULL);
2615 val = bl->owner->ops->insert_location (bl);
2617 /* If trying to set a read-watchpoint, and it turns out it's not
2618 supported, try emulating one with an access watchpoint. */
2619 if (val == 1 && bl->watchpoint_type == hw_read)
2621 struct bp_location *loc, **loc_temp;
2623 /* But don't try to insert it, if there's already another
2624 hw_access location that would be considered a duplicate
2626 ALL_BP_LOCATIONS (loc, loc_temp)
2628 && loc->watchpoint_type == hw_access
2629 && watchpoint_locations_match (bl, loc))
2633 bl->target_info = loc->target_info;
2634 bl->watchpoint_type = hw_access;
2641 bl->watchpoint_type = hw_access;
2642 val = bl->owner->ops->insert_location (bl);
2645 /* Back to the original value. */
2646 bl->watchpoint_type = hw_read;
2650 bl->inserted = (val == 0);
2653 else if (bl->owner->type == bp_catchpoint)
2655 gdb_assert (bl->owner->ops != NULL
2656 && bl->owner->ops->insert_location != NULL);
2658 val = bl->owner->ops->insert_location (bl);
2661 bl->owner->enable_state = bp_disabled;
2665 Error inserting catchpoint %d: Your system does not support this type\n\
2666 of catchpoint."), bl->owner->number);
2668 warning (_("Error inserting catchpoint %d."), bl->owner->number);
2671 bl->inserted = (val == 0);
2673 /* We've already printed an error message if there was a problem
2674 inserting this catchpoint, and we've disabled the catchpoint,
2675 so just return success. */
2682 /* This function is called when program space PSPACE is about to be
2683 deleted. It takes care of updating breakpoints to not reference
2687 breakpoint_program_space_exit (struct program_space *pspace)
2689 struct breakpoint *b, *b_temp;
2690 struct bp_location *loc, **loc_temp;
2692 /* Remove any breakpoint that was set through this program space. */
2693 ALL_BREAKPOINTS_SAFE (b, b_temp)
2695 if (b->pspace == pspace)
2696 delete_breakpoint (b);
2699 /* Breakpoints set through other program spaces could have locations
2700 bound to PSPACE as well. Remove those. */
2701 ALL_BP_LOCATIONS (loc, loc_temp)
2703 struct bp_location *tmp;
2705 if (loc->pspace == pspace)
2707 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2708 if (loc->owner->loc == loc)
2709 loc->owner->loc = loc->next;
2711 for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
2712 if (tmp->next == loc)
2714 tmp->next = loc->next;
2720 /* Now update the global location list to permanently delete the
2721 removed locations above. */
2722 update_global_location_list (0);
2725 /* Make sure all breakpoints are inserted in inferior.
2726 Throws exception on any error.
2727 A breakpoint that is already inserted won't be inserted
2728 again, so calling this function twice is safe. */
2730 insert_breakpoints (void)
2732 struct breakpoint *bpt;
2734 ALL_BREAKPOINTS (bpt)
2735 if (is_hardware_watchpoint (bpt))
2737 struct watchpoint *w = (struct watchpoint *) bpt;
2739 update_watchpoint (w, 0 /* don't reparse. */);
2742 update_global_location_list (1);
2744 /* update_global_location_list does not insert breakpoints when
2745 always_inserted_mode is not enabled. Explicitly insert them
2747 if (!breakpoints_always_inserted_mode ())
2748 insert_breakpoint_locations ();
2751 /* Invoke CALLBACK for each of bp_location. */
2754 iterate_over_bp_locations (walk_bp_location_callback callback)
2756 struct bp_location *loc, **loc_tmp;
2758 ALL_BP_LOCATIONS (loc, loc_tmp)
2760 callback (loc, NULL);
2764 /* This is used when we need to synch breakpoint conditions between GDB and the
2765 target. It is the case with deleting and disabling of breakpoints when using
2766 always-inserted mode. */
2769 update_inserted_breakpoint_locations (void)
2771 struct bp_location *bl, **blp_tmp;
2774 int disabled_breaks = 0;
2775 int hw_breakpoint_error = 0;
2776 int hw_bp_details_reported = 0;
2778 struct ui_file *tmp_error_stream = mem_fileopen ();
2779 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
2781 /* Explicitly mark the warning -- this will only be printed if
2782 there was an error. */
2783 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
2785 save_current_space_and_thread ();
2787 ALL_BP_LOCATIONS (bl, blp_tmp)
2789 /* We only want to update software breakpoints and hardware
2791 if (!is_breakpoint (bl->owner))
2794 /* We only want to update locations that are already inserted
2795 and need updating. This is to avoid unwanted insertion during
2796 deletion of breakpoints. */
2797 if (!bl->inserted || (bl->inserted && !bl->needs_update))
2800 switch_to_program_space_and_thread (bl->pspace);
2802 /* For targets that support global breakpoints, there's no need
2803 to select an inferior to insert breakpoint to. In fact, even
2804 if we aren't attached to any process yet, we should still
2805 insert breakpoints. */
2806 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2807 && ptid_equal (inferior_ptid, null_ptid))
2810 val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
2811 &hw_breakpoint_error, &hw_bp_details_reported);
2818 target_terminal_ours_for_output ();
2819 error_stream (tmp_error_stream);
2822 do_cleanups (cleanups);
2825 /* Used when starting or continuing the program. */
2828 insert_breakpoint_locations (void)
2830 struct breakpoint *bpt;
2831 struct bp_location *bl, **blp_tmp;
2834 int disabled_breaks = 0;
2835 int hw_breakpoint_error = 0;
2836 int hw_bp_error_explained_already = 0;
2838 struct ui_file *tmp_error_stream = mem_fileopen ();
2839 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
2841 /* Explicitly mark the warning -- this will only be printed if
2842 there was an error. */
2843 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
2845 save_current_space_and_thread ();
2847 ALL_BP_LOCATIONS (bl, blp_tmp)
2849 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2852 /* There is no point inserting thread-specific breakpoints if
2853 the thread no longer exists. ALL_BP_LOCATIONS bp_location
2854 has BL->OWNER always non-NULL. */
2855 if (bl->owner->thread != -1
2856 && !valid_thread_id (bl->owner->thread))
2859 switch_to_program_space_and_thread (bl->pspace);
2861 /* For targets that support global breakpoints, there's no need
2862 to select an inferior to insert breakpoint to. In fact, even
2863 if we aren't attached to any process yet, we should still
2864 insert breakpoints. */
2865 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2866 && ptid_equal (inferior_ptid, null_ptid))
2869 val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
2870 &hw_breakpoint_error, &hw_bp_error_explained_already);
2875 /* If we failed to insert all locations of a watchpoint, remove
2876 them, as half-inserted watchpoint is of limited use. */
2877 ALL_BREAKPOINTS (bpt)
2879 int some_failed = 0;
2880 struct bp_location *loc;
2882 if (!is_hardware_watchpoint (bpt))
2885 if (!breakpoint_enabled (bpt))
2888 if (bpt->disposition == disp_del_at_next_stop)
2891 for (loc = bpt->loc; loc; loc = loc->next)
2892 if (!loc->inserted && should_be_inserted (loc))
2899 for (loc = bpt->loc; loc; loc = loc->next)
2901 remove_breakpoint (loc, mark_uninserted);
2903 hw_breakpoint_error = 1;
2904 fprintf_unfiltered (tmp_error_stream,
2905 "Could not insert hardware watchpoint %d.\n",
2913 /* If a hardware breakpoint or watchpoint was inserted, add a
2914 message about possibly exhausted resources. */
2915 if (hw_breakpoint_error && !hw_bp_error_explained_already)
2917 fprintf_unfiltered (tmp_error_stream,
2918 "Could not insert hardware breakpoints:\n\
2919 You may have requested too many hardware breakpoints/watchpoints.\n");
2921 target_terminal_ours_for_output ();
2922 error_stream (tmp_error_stream);
2925 do_cleanups (cleanups);
2928 /* Used when the program stops.
2929 Returns zero if successful, or non-zero if there was a problem
2930 removing a breakpoint location. */
2933 remove_breakpoints (void)
2935 struct bp_location *bl, **blp_tmp;
2938 ALL_BP_LOCATIONS (bl, blp_tmp)
2940 if (bl->inserted && !is_tracepoint (bl->owner))
2941 val |= remove_breakpoint (bl, mark_uninserted);
2946 /* When a thread exits, remove breakpoints that are related to
2950 remove_threaded_breakpoints (struct thread_info *tp, int silent)
2952 struct breakpoint *b, *b_tmp;
2954 ALL_BREAKPOINTS_SAFE (b, b_tmp)
2956 if (b->thread == tp->num && user_breakpoint_p (b))
2958 b->disposition = disp_del_at_next_stop;
2960 printf_filtered (_("\
2961 Thread-specific breakpoint %d deleted - thread %d no longer in the thread list.\n"),
2962 b->number, tp->num);
2964 /* Hide it from the user. */
2970 /* Remove breakpoints of process PID. */
2973 remove_breakpoints_pid (int pid)
2975 struct bp_location *bl, **blp_tmp;
2977 struct inferior *inf = find_inferior_pid (pid);
2979 ALL_BP_LOCATIONS (bl, blp_tmp)
2981 if (bl->pspace != inf->pspace)
2984 if (bl->owner->type == bp_dprintf)
2989 val = remove_breakpoint (bl, mark_uninserted);
2998 reattach_breakpoints (int pid)
3000 struct cleanup *old_chain;
3001 struct bp_location *bl, **blp_tmp;
3003 struct ui_file *tmp_error_stream;
3004 int dummy1 = 0, dummy2 = 0, dummy3 = 0;
3005 struct inferior *inf;
3006 struct thread_info *tp;
3008 tp = any_live_thread_of_process (pid);
3012 inf = find_inferior_pid (pid);
3013 old_chain = save_inferior_ptid ();
3015 inferior_ptid = tp->ptid;
3017 tmp_error_stream = mem_fileopen ();
3018 make_cleanup_ui_file_delete (tmp_error_stream);
3020 ALL_BP_LOCATIONS (bl, blp_tmp)
3022 if (bl->pspace != inf->pspace)
3028 val = insert_bp_location (bl, tmp_error_stream, &dummy1, &dummy2, &dummy3);
3031 do_cleanups (old_chain);
3036 do_cleanups (old_chain);
3040 static int internal_breakpoint_number = -1;
3042 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3043 If INTERNAL is non-zero, the breakpoint number will be populated
3044 from internal_breakpoint_number and that variable decremented.
3045 Otherwise the breakpoint number will be populated from
3046 breakpoint_count and that value incremented. Internal breakpoints
3047 do not set the internal var bpnum. */
3049 set_breakpoint_number (int internal, struct breakpoint *b)
3052 b->number = internal_breakpoint_number--;
3055 set_breakpoint_count (breakpoint_count + 1);
3056 b->number = breakpoint_count;
3060 static struct breakpoint *
3061 create_internal_breakpoint (struct gdbarch *gdbarch,
3062 CORE_ADDR address, enum bptype type,
3063 const struct breakpoint_ops *ops)
3065 struct symtab_and_line sal;
3066 struct breakpoint *b;
3068 init_sal (&sal); /* Initialize to zeroes. */
3071 sal.section = find_pc_overlay (sal.pc);
3072 sal.pspace = current_program_space;
3074 b = set_raw_breakpoint (gdbarch, sal, type, ops);
3075 b->number = internal_breakpoint_number--;
3076 b->disposition = disp_donttouch;
3081 static const char *const longjmp_names[] =
3083 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3085 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3087 /* Per-objfile data private to breakpoint.c. */
3088 struct breakpoint_objfile_data
3090 /* Minimal symbol for "_ovly_debug_event" (if any). */
3091 struct minimal_symbol *overlay_msym;
3093 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3094 struct minimal_symbol *longjmp_msym[NUM_LONGJMP_NAMES];
3096 /* True if we have looked for longjmp probes. */
3097 int longjmp_searched;
3099 /* SystemTap probe points for longjmp (if any). */
3100 VEC (probe_p) *longjmp_probes;
3102 /* Minimal symbol for "std::terminate()" (if any). */
3103 struct minimal_symbol *terminate_msym;
3105 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3106 struct minimal_symbol *exception_msym;
3108 /* True if we have looked for exception probes. */
3109 int exception_searched;
3111 /* SystemTap probe points for unwinding (if any). */
3112 VEC (probe_p) *exception_probes;
3115 static const struct objfile_data *breakpoint_objfile_key;
3117 /* Minimal symbol not found sentinel. */
3118 static struct minimal_symbol msym_not_found;
3120 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3123 msym_not_found_p (const struct minimal_symbol *msym)
3125 return msym == &msym_not_found;
3128 /* Return per-objfile data needed by breakpoint.c.
3129 Allocate the data if necessary. */
3131 static struct breakpoint_objfile_data *
3132 get_breakpoint_objfile_data (struct objfile *objfile)
3134 struct breakpoint_objfile_data *bp_objfile_data;
3136 bp_objfile_data = objfile_data (objfile, breakpoint_objfile_key);
3137 if (bp_objfile_data == NULL)
3139 bp_objfile_data = obstack_alloc (&objfile->objfile_obstack,
3140 sizeof (*bp_objfile_data));
3142 memset (bp_objfile_data, 0, sizeof (*bp_objfile_data));
3143 set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
3145 return bp_objfile_data;
3149 free_breakpoint_probes (struct objfile *obj, void *data)
3151 struct breakpoint_objfile_data *bp_objfile_data = data;
3153 VEC_free (probe_p, bp_objfile_data->longjmp_probes);
3154 VEC_free (probe_p, bp_objfile_data->exception_probes);
3158 create_overlay_event_breakpoint (void)
3160 struct objfile *objfile;
3161 const char *const func_name = "_ovly_debug_event";
3163 ALL_OBJFILES (objfile)
3165 struct breakpoint *b;
3166 struct breakpoint_objfile_data *bp_objfile_data;
3169 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3171 if (msym_not_found_p (bp_objfile_data->overlay_msym))
3174 if (bp_objfile_data->overlay_msym == NULL)
3176 struct minimal_symbol *m;
3178 m = lookup_minimal_symbol_text (func_name, objfile);
3181 /* Avoid future lookups in this objfile. */
3182 bp_objfile_data->overlay_msym = &msym_not_found;
3185 bp_objfile_data->overlay_msym = m;
3188 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
3189 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3191 &internal_breakpoint_ops);
3192 b->addr_string = xstrdup (func_name);
3194 if (overlay_debugging == ovly_auto)
3196 b->enable_state = bp_enabled;
3197 overlay_events_enabled = 1;
3201 b->enable_state = bp_disabled;
3202 overlay_events_enabled = 0;
3205 update_global_location_list (1);
3209 create_longjmp_master_breakpoint (void)
3211 struct program_space *pspace;
3212 struct cleanup *old_chain;
3214 old_chain = save_current_program_space ();
3216 ALL_PSPACES (pspace)
3218 struct objfile *objfile;
3220 set_current_program_space (pspace);
3222 ALL_OBJFILES (objfile)
3225 struct gdbarch *gdbarch;
3226 struct breakpoint_objfile_data *bp_objfile_data;
3228 gdbarch = get_objfile_arch (objfile);
3230 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3232 if (!bp_objfile_data->longjmp_searched)
3236 ret = find_probes_in_objfile (objfile, "libc", "longjmp");
3239 /* We are only interested in checking one element. */
3240 struct probe *p = VEC_index (probe_p, ret, 0);
3242 if (!can_evaluate_probe_arguments (p))
3244 /* We cannot use the probe interface here, because it does
3245 not know how to evaluate arguments. */
3246 VEC_free (probe_p, ret);
3250 bp_objfile_data->longjmp_probes = ret;
3251 bp_objfile_data->longjmp_searched = 1;
3254 if (bp_objfile_data->longjmp_probes != NULL)
3257 struct probe *probe;
3258 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3261 VEC_iterate (probe_p,
3262 bp_objfile_data->longjmp_probes,
3266 struct breakpoint *b;
3268 b = create_internal_breakpoint (gdbarch, probe->address,
3270 &internal_breakpoint_ops);
3271 b->addr_string = xstrdup ("-probe-stap libc:longjmp");
3272 b->enable_state = bp_disabled;
3278 if (!gdbarch_get_longjmp_target_p (gdbarch))
3281 for (i = 0; i < NUM_LONGJMP_NAMES; i++)
3283 struct breakpoint *b;
3284 const char *func_name;
3287 if (msym_not_found_p (bp_objfile_data->longjmp_msym[i]))
3290 func_name = longjmp_names[i];
3291 if (bp_objfile_data->longjmp_msym[i] == NULL)
3293 struct minimal_symbol *m;
3295 m = lookup_minimal_symbol_text (func_name, objfile);
3298 /* Prevent future lookups in this objfile. */
3299 bp_objfile_data->longjmp_msym[i] = &msym_not_found;
3302 bp_objfile_data->longjmp_msym[i] = m;
3305 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
3306 b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3307 &internal_breakpoint_ops);
3308 b->addr_string = xstrdup (func_name);
3309 b->enable_state = bp_disabled;
3313 update_global_location_list (1);
3315 do_cleanups (old_chain);
3318 /* Create a master std::terminate breakpoint. */
3320 create_std_terminate_master_breakpoint (void)
3322 struct program_space *pspace;
3323 struct cleanup *old_chain;
3324 const char *const func_name = "std::terminate()";
3326 old_chain = save_current_program_space ();
3328 ALL_PSPACES (pspace)
3330 struct objfile *objfile;
3333 set_current_program_space (pspace);
3335 ALL_OBJFILES (objfile)
3337 struct breakpoint *b;
3338 struct breakpoint_objfile_data *bp_objfile_data;
3340 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3342 if (msym_not_found_p (bp_objfile_data->terminate_msym))
3345 if (bp_objfile_data->terminate_msym == NULL)
3347 struct minimal_symbol *m;
3349 m = lookup_minimal_symbol (func_name, NULL, objfile);
3350 if (m == NULL || (MSYMBOL_TYPE (m) != mst_text
3351 && MSYMBOL_TYPE (m) != mst_file_text))
3353 /* Prevent future lookups in this objfile. */
3354 bp_objfile_data->terminate_msym = &msym_not_found;
3357 bp_objfile_data->terminate_msym = m;
3360 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
3361 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3362 bp_std_terminate_master,
3363 &internal_breakpoint_ops);
3364 b->addr_string = xstrdup (func_name);
3365 b->enable_state = bp_disabled;
3369 update_global_location_list (1);
3371 do_cleanups (old_chain);
3374 /* Install a master breakpoint on the unwinder's debug hook. */
3377 create_exception_master_breakpoint (void)
3379 struct objfile *objfile;
3380 const char *const func_name = "_Unwind_DebugHook";
3382 ALL_OBJFILES (objfile)
3384 struct breakpoint *b;
3385 struct gdbarch *gdbarch;
3386 struct breakpoint_objfile_data *bp_objfile_data;
3389 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3391 /* We prefer the SystemTap probe point if it exists. */
3392 if (!bp_objfile_data->exception_searched)
3396 ret = find_probes_in_objfile (objfile, "libgcc", "unwind");
3400 /* We are only interested in checking one element. */
3401 struct probe *p = VEC_index (probe_p, ret, 0);
3403 if (!can_evaluate_probe_arguments (p))
3405 /* We cannot use the probe interface here, because it does
3406 not know how to evaluate arguments. */
3407 VEC_free (probe_p, ret);
3411 bp_objfile_data->exception_probes = ret;
3412 bp_objfile_data->exception_searched = 1;
3415 if (bp_objfile_data->exception_probes != NULL)
3417 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3419 struct probe *probe;
3422 VEC_iterate (probe_p,
3423 bp_objfile_data->exception_probes,
3427 struct breakpoint *b;
3429 b = create_internal_breakpoint (gdbarch, probe->address,
3430 bp_exception_master,
3431 &internal_breakpoint_ops);
3432 b->addr_string = xstrdup ("-probe-stap libgcc:unwind");
3433 b->enable_state = bp_disabled;
3439 /* Otherwise, try the hook function. */
3441 if (msym_not_found_p (bp_objfile_data->exception_msym))
3444 gdbarch = get_objfile_arch (objfile);
3446 if (bp_objfile_data->exception_msym == NULL)
3448 struct minimal_symbol *debug_hook;
3450 debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3451 if (debug_hook == NULL)
3453 bp_objfile_data->exception_msym = &msym_not_found;
3457 bp_objfile_data->exception_msym = debug_hook;
3460 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
3461 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3463 b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3464 &internal_breakpoint_ops);
3465 b->addr_string = xstrdup (func_name);
3466 b->enable_state = bp_disabled;
3469 update_global_location_list (1);
3473 update_breakpoints_after_exec (void)
3475 struct breakpoint *b, *b_tmp;
3476 struct bp_location *bploc, **bplocp_tmp;
3478 /* We're about to delete breakpoints from GDB's lists. If the
3479 INSERTED flag is true, GDB will try to lift the breakpoints by
3480 writing the breakpoints' "shadow contents" back into memory. The
3481 "shadow contents" are NOT valid after an exec, so GDB should not
3482 do that. Instead, the target is responsible from marking
3483 breakpoints out as soon as it detects an exec. We don't do that
3484 here instead, because there may be other attempts to delete
3485 breakpoints after detecting an exec and before reaching here. */
3486 ALL_BP_LOCATIONS (bploc, bplocp_tmp)
3487 if (bploc->pspace == current_program_space)
3488 gdb_assert (!bploc->inserted);
3490 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3492 if (b->pspace != current_program_space)
3495 /* Solib breakpoints must be explicitly reset after an exec(). */
3496 if (b->type == bp_shlib_event)
3498 delete_breakpoint (b);
3502 /* JIT breakpoints must be explicitly reset after an exec(). */
3503 if (b->type == bp_jit_event)
3505 delete_breakpoint (b);
3509 /* Thread event breakpoints must be set anew after an exec(),
3510 as must overlay event and longjmp master breakpoints. */
3511 if (b->type == bp_thread_event || b->type == bp_overlay_event
3512 || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3513 || b->type == bp_exception_master)
3515 delete_breakpoint (b);
3519 /* Step-resume breakpoints are meaningless after an exec(). */
3520 if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
3522 delete_breakpoint (b);
3526 /* Longjmp and longjmp-resume breakpoints are also meaningless
3528 if (b->type == bp_longjmp || b->type == bp_longjmp_resume
3529 || b->type == bp_longjmp_call_dummy
3530 || b->type == bp_exception || b->type == bp_exception_resume)
3532 delete_breakpoint (b);
3536 if (b->type == bp_catchpoint)
3538 /* For now, none of the bp_catchpoint breakpoints need to
3539 do anything at this point. In the future, if some of
3540 the catchpoints need to something, we will need to add
3541 a new method, and call this method from here. */
3545 /* bp_finish is a special case. The only way we ought to be able
3546 to see one of these when an exec() has happened, is if the user
3547 caught a vfork, and then said "finish". Ordinarily a finish just
3548 carries them to the call-site of the current callee, by setting
3549 a temporary bp there and resuming. But in this case, the finish
3550 will carry them entirely through the vfork & exec.
3552 We don't want to allow a bp_finish to remain inserted now. But
3553 we can't safely delete it, 'cause finish_command has a handle to
3554 the bp on a bpstat, and will later want to delete it. There's a
3555 chance (and I've seen it happen) that if we delete the bp_finish
3556 here, that its storage will get reused by the time finish_command
3557 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3558 We really must allow finish_command to delete a bp_finish.
3560 In the absence of a general solution for the "how do we know
3561 it's safe to delete something others may have handles to?"
3562 problem, what we'll do here is just uninsert the bp_finish, and
3563 let finish_command delete it.
3565 (We know the bp_finish is "doomed" in the sense that it's
3566 momentary, and will be deleted as soon as finish_command sees
3567 the inferior stopped. So it doesn't matter that the bp's
3568 address is probably bogus in the new a.out, unlike e.g., the
3569 solib breakpoints.) */
3571 if (b->type == bp_finish)
3576 /* Without a symbolic address, we have little hope of the
3577 pre-exec() address meaning the same thing in the post-exec()
3579 if (b->addr_string == NULL)
3581 delete_breakpoint (b);
3585 /* FIXME what about longjmp breakpoints? Re-create them here? */
3586 create_overlay_event_breakpoint ();
3587 create_longjmp_master_breakpoint ();
3588 create_std_terminate_master_breakpoint ();
3589 create_exception_master_breakpoint ();
3593 detach_breakpoints (ptid_t ptid)
3595 struct bp_location *bl, **blp_tmp;
3597 struct cleanup *old_chain = save_inferior_ptid ();
3598 struct inferior *inf = current_inferior ();
3600 if (ptid_get_pid (ptid) == ptid_get_pid (inferior_ptid))
3601 error (_("Cannot detach breakpoints of inferior_ptid"));
3603 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3604 inferior_ptid = ptid;
3605 ALL_BP_LOCATIONS (bl, blp_tmp)
3607 if (bl->pspace != inf->pspace)
3610 /* This function must physically remove breakpoints locations
3611 from the specified ptid, without modifying the breakpoint
3612 package's state. Locations of type bp_loc_other are only
3613 maintained at GDB side. So, there is no need to remove
3614 these bp_loc_other locations. Moreover, removing these
3615 would modify the breakpoint package's state. */
3616 if (bl->loc_type == bp_loc_other)
3620 val |= remove_breakpoint_1 (bl, mark_inserted);
3623 /* Detach single-step breakpoints as well. */
3624 detach_single_step_breakpoints ();
3626 do_cleanups (old_chain);
3630 /* Remove the breakpoint location BL from the current address space.
3631 Note that this is used to detach breakpoints from a child fork.
3632 When we get here, the child isn't in the inferior list, and neither
3633 do we have objects to represent its address space --- we should
3634 *not* look at bl->pspace->aspace here. */
3637 remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is)
3641 /* BL is never in moribund_locations by our callers. */
3642 gdb_assert (bl->owner != NULL);
3644 if (bl->owner->enable_state == bp_permanent)
3645 /* Permanent breakpoints cannot be inserted or removed. */
3648 /* The type of none suggests that owner is actually deleted.
3649 This should not ever happen. */
3650 gdb_assert (bl->owner->type != bp_none);
3652 if (bl->loc_type == bp_loc_software_breakpoint
3653 || bl->loc_type == bp_loc_hardware_breakpoint)
3655 /* "Normal" instruction breakpoint: either the standard
3656 trap-instruction bp (bp_breakpoint), or a
3657 bp_hardware_breakpoint. */
3659 /* First check to see if we have to handle an overlay. */
3660 if (overlay_debugging == ovly_off
3661 || bl->section == NULL
3662 || !(section_is_overlay (bl->section)))
3664 /* No overlay handling: just remove the breakpoint. */
3665 val = bl->owner->ops->remove_location (bl);
3669 /* This breakpoint is in an overlay section.
3670 Did we set a breakpoint at the LMA? */
3671 if (!overlay_events_enabled)
3673 /* Yes -- overlay event support is not active, so we
3674 should have set a breakpoint at the LMA. Remove it.
3676 /* Ignore any failures: if the LMA is in ROM, we will
3677 have already warned when we failed to insert it. */
3678 if (bl->loc_type == bp_loc_hardware_breakpoint)
3679 target_remove_hw_breakpoint (bl->gdbarch,
3680 &bl->overlay_target_info);
3682 target_remove_breakpoint (bl->gdbarch,
3683 &bl->overlay_target_info);
3685 /* Did we set a breakpoint at the VMA?
3686 If so, we will have marked the breakpoint 'inserted'. */
3689 /* Yes -- remove it. Previously we did not bother to
3690 remove the breakpoint if the section had been
3691 unmapped, but let's not rely on that being safe. We
3692 don't know what the overlay manager might do. */
3694 /* However, we should remove *software* breakpoints only
3695 if the section is still mapped, or else we overwrite
3696 wrong code with the saved shadow contents. */
3697 if (bl->loc_type == bp_loc_hardware_breakpoint
3698 || section_is_mapped (bl->section))
3699 val = bl->owner->ops->remove_location (bl);
3705 /* No -- not inserted, so no need to remove. No error. */
3710 /* In some cases, we might not be able to remove a breakpoint
3711 in a shared library that has already been removed, but we
3712 have not yet processed the shlib unload event. */
3713 if (val && solib_name_from_address (bl->pspace, bl->address))
3718 bl->inserted = (is == mark_inserted);
3720 else if (bl->loc_type == bp_loc_hardware_watchpoint)
3722 gdb_assert (bl->owner->ops != NULL
3723 && bl->owner->ops->remove_location != NULL);
3725 bl->inserted = (is == mark_inserted);
3726 bl->owner->ops->remove_location (bl);
3728 /* Failure to remove any of the hardware watchpoints comes here. */
3729 if ((is == mark_uninserted) && (bl->inserted))
3730 warning (_("Could not remove hardware watchpoint %d."),
3733 else if (bl->owner->type == bp_catchpoint
3734 && breakpoint_enabled (bl->owner)
3737 gdb_assert (bl->owner->ops != NULL
3738 && bl->owner->ops->remove_location != NULL);
3740 val = bl->owner->ops->remove_location (bl);
3744 bl->inserted = (is == mark_inserted);
3751 remove_breakpoint (struct bp_location *bl, insertion_state_t is)
3754 struct cleanup *old_chain;
3756 /* BL is never in moribund_locations by our callers. */
3757 gdb_assert (bl->owner != NULL);
3759 if (bl->owner->enable_state == bp_permanent)
3760 /* Permanent breakpoints cannot be inserted or removed. */
3763 /* The type of none suggests that owner is actually deleted.
3764 This should not ever happen. */
3765 gdb_assert (bl->owner->type != bp_none);
3767 old_chain = save_current_space_and_thread ();
3769 switch_to_program_space_and_thread (bl->pspace);
3771 ret = remove_breakpoint_1 (bl, is);
3773 do_cleanups (old_chain);
3777 /* Clear the "inserted" flag in all breakpoints. */
3780 mark_breakpoints_out (void)
3782 struct bp_location *bl, **blp_tmp;
3784 ALL_BP_LOCATIONS (bl, blp_tmp)
3785 if (bl->pspace == current_program_space)
3789 /* Clear the "inserted" flag in all breakpoints and delete any
3790 breakpoints which should go away between runs of the program.
3792 Plus other such housekeeping that has to be done for breakpoints
3795 Note: this function gets called at the end of a run (by
3796 generic_mourn_inferior) and when a run begins (by
3797 init_wait_for_inferior). */
3802 breakpoint_init_inferior (enum inf_context context)
3804 struct breakpoint *b, *b_tmp;
3805 struct bp_location *bl, **blp_tmp;
3807 struct program_space *pspace = current_program_space;
3809 /* If breakpoint locations are shared across processes, then there's
3811 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3814 ALL_BP_LOCATIONS (bl, blp_tmp)
3816 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
3817 if (bl->pspace == pspace
3818 && bl->owner->enable_state != bp_permanent)
3822 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3824 if (b->loc && b->loc->pspace != pspace)
3830 case bp_longjmp_call_dummy:
3832 /* If the call dummy breakpoint is at the entry point it will
3833 cause problems when the inferior is rerun, so we better get
3836 case bp_watchpoint_scope:
3838 /* Also get rid of scope breakpoints. */
3840 case bp_shlib_event:
3842 /* Also remove solib event breakpoints. Their addresses may
3843 have changed since the last time we ran the program.
3844 Actually we may now be debugging against different target;
3845 and so the solib backend that installed this breakpoint may
3846 not be used in by the target. E.g.,
3848 (gdb) file prog-linux
3849 (gdb) run # native linux target
3852 (gdb) file prog-win.exe
3853 (gdb) tar rem :9999 # remote Windows gdbserver.
3856 case bp_step_resume:
3858 /* Also remove step-resume breakpoints. */
3860 delete_breakpoint (b);
3864 case bp_hardware_watchpoint:
3865 case bp_read_watchpoint:
3866 case bp_access_watchpoint:
3868 struct watchpoint *w = (struct watchpoint *) b;
3870 /* Likewise for watchpoints on local expressions. */
3871 if (w->exp_valid_block != NULL)
3872 delete_breakpoint (b);
3873 else if (context == inf_starting)
3875 /* Reset val field to force reread of starting value in
3876 insert_breakpoints. */
3878 value_free (w->val);
3889 /* Get rid of the moribund locations. */
3890 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
3891 decref_bp_location (&bl);
3892 VEC_free (bp_location_p, moribund_locations);
3895 /* These functions concern about actual breakpoints inserted in the
3896 target --- to e.g. check if we need to do decr_pc adjustment or if
3897 we need to hop over the bkpt --- so we check for address space
3898 match, not program space. */
3900 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3901 exists at PC. It returns ordinary_breakpoint_here if it's an
3902 ordinary breakpoint, or permanent_breakpoint_here if it's a
3903 permanent breakpoint.
3904 - When continuing from a location with an ordinary breakpoint, we
3905 actually single step once before calling insert_breakpoints.
3906 - When continuing from a location with a permanent breakpoint, we
3907 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3908 the target, to advance the PC past the breakpoint. */
3910 enum breakpoint_here
3911 breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
3913 struct bp_location *bl, **blp_tmp;
3914 int any_breakpoint_here = 0;
3916 ALL_BP_LOCATIONS (bl, blp_tmp)
3918 if (bl->loc_type != bp_loc_software_breakpoint
3919 && bl->loc_type != bp_loc_hardware_breakpoint)
3922 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
3923 if ((breakpoint_enabled (bl->owner)
3924 || bl->owner->enable_state == bp_permanent)
3925 && breakpoint_location_address_match (bl, aspace, pc))
3927 if (overlay_debugging
3928 && section_is_overlay (bl->section)
3929 && !section_is_mapped (bl->section))
3930 continue; /* unmapped overlay -- can't be a match */
3931 else if (bl->owner->enable_state == bp_permanent)
3932 return permanent_breakpoint_here;
3934 any_breakpoint_here = 1;
3938 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
3941 /* Return true if there's a moribund breakpoint at PC. */
3944 moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
3946 struct bp_location *loc;
3949 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
3950 if (breakpoint_location_address_match (loc, aspace, pc))
3956 /* Returns non-zero if there's a breakpoint inserted at PC, which is
3957 inserted using regular breakpoint_chain / bp_location array
3958 mechanism. This does not check for single-step breakpoints, which
3959 are inserted and removed using direct target manipulation. */
3962 regular_breakpoint_inserted_here_p (struct address_space *aspace,
3965 struct bp_location *bl, **blp_tmp;
3967 ALL_BP_LOCATIONS (bl, blp_tmp)
3969 if (bl->loc_type != bp_loc_software_breakpoint
3970 && bl->loc_type != bp_loc_hardware_breakpoint)
3974 && breakpoint_location_address_match (bl, aspace, pc))
3976 if (overlay_debugging
3977 && section_is_overlay (bl->section)
3978 && !section_is_mapped (bl->section))
3979 continue; /* unmapped overlay -- can't be a match */
3987 /* Returns non-zero iff there's either regular breakpoint
3988 or a single step breakpoint inserted at PC. */
3991 breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
3993 if (regular_breakpoint_inserted_here_p (aspace, pc))
3996 if (single_step_breakpoint_inserted_here_p (aspace, pc))
4002 /* This function returns non-zero iff there is a software breakpoint
4006 software_breakpoint_inserted_here_p (struct address_space *aspace,
4009 struct bp_location *bl, **blp_tmp;
4011 ALL_BP_LOCATIONS (bl, blp_tmp)
4013 if (bl->loc_type != bp_loc_software_breakpoint)
4017 && breakpoint_address_match (bl->pspace->aspace, bl->address,
4020 if (overlay_debugging
4021 && section_is_overlay (bl->section)
4022 && !section_is_mapped (bl->section))
4023 continue; /* unmapped overlay -- can't be a match */
4029 /* Also check for software single-step breakpoints. */
4030 if (single_step_breakpoint_inserted_here_p (aspace, pc))
4037 hardware_watchpoint_inserted_in_range (struct address_space *aspace,
4038 CORE_ADDR addr, ULONGEST len)
4040 struct breakpoint *bpt;
4042 ALL_BREAKPOINTS (bpt)
4044 struct bp_location *loc;
4046 if (bpt->type != bp_hardware_watchpoint
4047 && bpt->type != bp_access_watchpoint)
4050 if (!breakpoint_enabled (bpt))
4053 for (loc = bpt->loc; loc; loc = loc->next)
4054 if (loc->pspace->aspace == aspace && loc->inserted)
4058 /* Check for intersection. */
4059 l = max (loc->address, addr);
4060 h = min (loc->address + loc->length, addr + len);
4068 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
4069 PC is valid for process/thread PTID. */
4072 breakpoint_thread_match (struct address_space *aspace, CORE_ADDR pc,
4075 struct bp_location *bl, **blp_tmp;
4076 /* The thread and task IDs associated to PTID, computed lazily. */
4080 ALL_BP_LOCATIONS (bl, blp_tmp)
4082 if (bl->loc_type != bp_loc_software_breakpoint
4083 && bl->loc_type != bp_loc_hardware_breakpoint)
4086 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
4087 if (!breakpoint_enabled (bl->owner)
4088 && bl->owner->enable_state != bp_permanent)
4091 if (!breakpoint_location_address_match (bl, aspace, pc))
4094 if (bl->owner->thread != -1)
4096 /* This is a thread-specific breakpoint. Check that ptid
4097 matches that thread. If thread hasn't been computed yet,
4098 it is now time to do so. */
4100 thread = pid_to_thread_id (ptid);
4101 if (bl->owner->thread != thread)
4105 if (bl->owner->task != 0)
4107 /* This is a task-specific breakpoint. Check that ptid
4108 matches that task. If task hasn't been computed yet,
4109 it is now time to do so. */
4111 task = ada_get_task_number (ptid);
4112 if (bl->owner->task != task)
4116 if (overlay_debugging
4117 && section_is_overlay (bl->section)
4118 && !section_is_mapped (bl->section))
4119 continue; /* unmapped overlay -- can't be a match */
4128 /* bpstat stuff. External routines' interfaces are documented
4132 is_catchpoint (struct breakpoint *ep)
4134 return (ep->type == bp_catchpoint);
4137 /* Frees any storage that is part of a bpstat. Does not walk the
4141 bpstat_free (bpstat bs)
4143 if (bs->old_val != NULL)
4144 value_free (bs->old_val);
4145 decref_counted_command_line (&bs->commands);
4146 decref_bp_location (&bs->bp_location_at);
4150 /* Clear a bpstat so that it says we are not at any breakpoint.
4151 Also free any storage that is part of a bpstat. */
4154 bpstat_clear (bpstat *bsp)
4171 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4172 is part of the bpstat is copied as well. */
4175 bpstat_copy (bpstat bs)
4179 bpstat retval = NULL;
4184 for (; bs != NULL; bs = bs->next)
4186 tmp = (bpstat) xmalloc (sizeof (*tmp));
4187 memcpy (tmp, bs, sizeof (*tmp));
4188 incref_counted_command_line (tmp->commands);
4189 incref_bp_location (tmp->bp_location_at);
4190 if (bs->old_val != NULL)
4192 tmp->old_val = value_copy (bs->old_val);
4193 release_value (tmp->old_val);
4197 /* This is the first thing in the chain. */
4207 /* Find the bpstat associated with this breakpoint. */
4210 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
4215 for (; bsp != NULL; bsp = bsp->next)
4217 if (bsp->breakpoint_at == breakpoint)
4223 /* See breakpoint.h. */
4226 bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
4228 for (; bsp != NULL; bsp = bsp->next)
4230 if (bsp->breakpoint_at == NULL)
4232 /* A moribund location can never explain a signal other than
4234 if (sig == GDB_SIGNAL_TRAP)
4239 if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
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.
4645 This returns the inverse of the condition because it is called
4646 from catch_errors which returns 0 if an exception happened, and if an
4647 exception happens we want execution to stop.
4648 The argument is a "struct expression *" that has been cast to a
4649 "void *" to make it pass through catch_errors. */
4652 breakpoint_cond_eval (void *exp)
4654 struct value *mark = value_mark ();
4655 int i = !value_true (evaluate_expression ((struct expression *) exp));
4657 value_free_to_mark (mark);
4661 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4664 bpstat_alloc (struct bp_location *bl, bpstat **bs_link_pointer)
4668 bs = (bpstat) xmalloc (sizeof (*bs));
4670 **bs_link_pointer = bs;
4671 *bs_link_pointer = &bs->next;
4672 bs->breakpoint_at = bl->owner;
4673 bs->bp_location_at = bl;
4674 incref_bp_location (bl);
4675 /* If the condition is false, etc., don't do the commands. */
4676 bs->commands = NULL;
4678 bs->print_it = print_it_normal;
4682 /* The target has stopped with waitstatus WS. Check if any hardware
4683 watchpoints have triggered, according to the target. */
4686 watchpoints_triggered (struct target_waitstatus *ws)
4688 int stopped_by_watchpoint = target_stopped_by_watchpoint ();
4690 struct breakpoint *b;
4692 if (!stopped_by_watchpoint)
4694 /* We were not stopped by a watchpoint. Mark all watchpoints
4695 as not triggered. */
4697 if (is_hardware_watchpoint (b))
4699 struct watchpoint *w = (struct watchpoint *) b;
4701 w->watchpoint_triggered = watch_triggered_no;
4707 if (!target_stopped_data_address (¤t_target, &addr))
4709 /* We were stopped by a watchpoint, but we don't know where.
4710 Mark all watchpoints as unknown. */
4712 if (is_hardware_watchpoint (b))
4714 struct watchpoint *w = (struct watchpoint *) b;
4716 w->watchpoint_triggered = watch_triggered_unknown;
4722 /* The target could report the data address. Mark watchpoints
4723 affected by this data address as triggered, and all others as not
4727 if (is_hardware_watchpoint (b))
4729 struct watchpoint *w = (struct watchpoint *) b;
4730 struct bp_location *loc;
4732 w->watchpoint_triggered = watch_triggered_no;
4733 for (loc = b->loc; loc; loc = loc->next)
4735 if (is_masked_watchpoint (b))
4737 CORE_ADDR newaddr = addr & w->hw_wp_mask;
4738 CORE_ADDR start = loc->address & w->hw_wp_mask;
4740 if (newaddr == start)
4742 w->watchpoint_triggered = watch_triggered_yes;
4746 /* Exact match not required. Within range is sufficient. */
4747 else if (target_watchpoint_addr_within_range (¤t_target,
4751 w->watchpoint_triggered = watch_triggered_yes;
4760 /* Possible return values for watchpoint_check (this can't be an enum
4761 because of check_errors). */
4762 /* The watchpoint has been deleted. */
4763 #define WP_DELETED 1
4764 /* The value has changed. */
4765 #define WP_VALUE_CHANGED 2
4766 /* The value has not changed. */
4767 #define WP_VALUE_NOT_CHANGED 3
4768 /* Ignore this watchpoint, no matter if the value changed or not. */
4771 #define BP_TEMPFLAG 1
4772 #define BP_HARDWAREFLAG 2
4774 /* Evaluate watchpoint condition expression and check if its value
4777 P should be a pointer to struct bpstat, but is defined as a void *
4778 in order for this function to be usable with catch_errors. */
4781 watchpoint_check (void *p)
4783 bpstat bs = (bpstat) p;
4784 struct watchpoint *b;
4785 struct frame_info *fr;
4786 int within_current_scope;
4788 /* BS is built from an existing struct breakpoint. */
4789 gdb_assert (bs->breakpoint_at != NULL);
4790 b = (struct watchpoint *) bs->breakpoint_at;
4792 /* If this is a local watchpoint, we only want to check if the
4793 watchpoint frame is in scope if the current thread is the thread
4794 that was used to create the watchpoint. */
4795 if (!watchpoint_in_thread_scope (b))
4798 if (b->exp_valid_block == NULL)
4799 within_current_scope = 1;
4802 struct frame_info *frame = get_current_frame ();
4803 struct gdbarch *frame_arch = get_frame_arch (frame);
4804 CORE_ADDR frame_pc = get_frame_pc (frame);
4806 /* in_function_epilogue_p() returns a non-zero value if we're
4807 still in the function but the stack frame has already been
4808 invalidated. Since we can't rely on the values of local
4809 variables after the stack has been destroyed, we are treating
4810 the watchpoint in that state as `not changed' without further
4811 checking. Don't mark watchpoints as changed if the current
4812 frame is in an epilogue - even if they are in some other
4813 frame, our view of the stack is likely to be wrong and
4814 frame_find_by_id could error out. */
4815 if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
4818 fr = frame_find_by_id (b->watchpoint_frame);
4819 within_current_scope = (fr != NULL);
4821 /* If we've gotten confused in the unwinder, we might have
4822 returned a frame that can't describe this variable. */
4823 if (within_current_scope)
4825 struct symbol *function;
4827 function = get_frame_function (fr);
4828 if (function == NULL
4829 || !contained_in (b->exp_valid_block,
4830 SYMBOL_BLOCK_VALUE (function)))
4831 within_current_scope = 0;
4834 if (within_current_scope)
4835 /* If we end up stopping, the current frame will get selected
4836 in normal_stop. So this call to select_frame won't affect
4841 if (within_current_scope)
4843 /* We use value_{,free_to_}mark because it could be a *long*
4844 time before we return to the command level and call
4845 free_all_values. We can't call free_all_values because we
4846 might be in the middle of evaluating a function call. */
4850 struct value *new_val;
4852 if (is_masked_watchpoint (&b->base))
4853 /* Since we don't know the exact trigger address (from
4854 stopped_data_address), just tell the user we've triggered
4855 a mask watchpoint. */
4856 return WP_VALUE_CHANGED;
4858 mark = value_mark ();
4859 fetch_subexp_value (b->exp, &pc, &new_val, NULL, NULL, 0);
4861 /* We use value_equal_contents instead of value_equal because
4862 the latter coerces an array to a pointer, thus comparing just
4863 the address of the array instead of its contents. This is
4864 not what we want. */
4865 if ((b->val != NULL) != (new_val != NULL)
4866 || (b->val != NULL && !value_equal_contents (b->val, new_val)))
4868 if (new_val != NULL)
4870 release_value (new_val);
4871 value_free_to_mark (mark);
4873 bs->old_val = b->val;
4876 return WP_VALUE_CHANGED;
4880 /* Nothing changed. */
4881 value_free_to_mark (mark);
4882 return WP_VALUE_NOT_CHANGED;
4887 struct ui_out *uiout = current_uiout;
4889 /* This seems like the only logical thing to do because
4890 if we temporarily ignored the watchpoint, then when
4891 we reenter the block in which it is valid it contains
4892 garbage (in the case of a function, it may have two
4893 garbage values, one before and one after the prologue).
4894 So we can't even detect the first assignment to it and
4895 watch after that (since the garbage may or may not equal
4896 the first value assigned). */
4897 /* We print all the stop information in
4898 breakpoint_ops->print_it, but in this case, by the time we
4899 call breakpoint_ops->print_it this bp will be deleted
4900 already. So we have no choice but print the information
4902 if (ui_out_is_mi_like_p (uiout))
4904 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
4905 ui_out_text (uiout, "\nWatchpoint ");
4906 ui_out_field_int (uiout, "wpnum", b->base.number);
4908 " deleted because the program has left the block in\n\
4909 which its expression is valid.\n");
4911 /* Make sure the watchpoint's commands aren't executed. */
4912 decref_counted_command_line (&b->base.commands);
4913 watchpoint_del_at_next_stop (b);
4919 /* Return true if it looks like target has stopped due to hitting
4920 breakpoint location BL. This function does not check if we should
4921 stop, only if BL explains the stop. */
4924 bpstat_check_location (const struct bp_location *bl,
4925 struct address_space *aspace, CORE_ADDR bp_addr,
4926 const struct target_waitstatus *ws)
4928 struct breakpoint *b = bl->owner;
4930 /* BL is from an existing breakpoint. */
4931 gdb_assert (b != NULL);
4933 return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
4936 /* Determine if the watched values have actually changed, and we
4937 should stop. If not, set BS->stop to 0. */
4940 bpstat_check_watchpoint (bpstat bs)
4942 const struct bp_location *bl;
4943 struct watchpoint *b;
4945 /* BS is built for existing struct breakpoint. */
4946 bl = bs->bp_location_at;
4947 gdb_assert (bl != NULL);
4948 b = (struct watchpoint *) bs->breakpoint_at;
4949 gdb_assert (b != NULL);
4952 int must_check_value = 0;
4954 if (b->base.type == bp_watchpoint)
4955 /* For a software watchpoint, we must always check the
4957 must_check_value = 1;
4958 else if (b->watchpoint_triggered == watch_triggered_yes)
4959 /* We have a hardware watchpoint (read, write, or access)
4960 and the target earlier reported an address watched by
4962 must_check_value = 1;
4963 else if (b->watchpoint_triggered == watch_triggered_unknown
4964 && b->base.type == bp_hardware_watchpoint)
4965 /* We were stopped by a hardware watchpoint, but the target could
4966 not report the data address. We must check the watchpoint's
4967 value. Access and read watchpoints are out of luck; without
4968 a data address, we can't figure it out. */
4969 must_check_value = 1;
4971 if (must_check_value)
4974 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
4976 struct cleanup *cleanups = make_cleanup (xfree, message);
4977 int e = catch_errors (watchpoint_check, bs, message,
4979 do_cleanups (cleanups);
4983 /* We've already printed what needs to be printed. */
4984 bs->print_it = print_it_done;
4988 bs->print_it = print_it_noop;
4991 case WP_VALUE_CHANGED:
4992 if (b->base.type == bp_read_watchpoint)
4994 /* There are two cases to consider here:
4996 1. We're watching the triggered memory for reads.
4997 In that case, trust the target, and always report
4998 the watchpoint hit to the user. Even though
4999 reads don't cause value changes, the value may
5000 have changed since the last time it was read, and
5001 since we're not trapping writes, we will not see
5002 those, and as such we should ignore our notion of
5005 2. We're watching the triggered memory for both
5006 reads and writes. There are two ways this may
5009 2.1. This is a target that can't break on data
5010 reads only, but can break on accesses (reads or
5011 writes), such as e.g., x86. We detect this case
5012 at the time we try to insert read watchpoints.
5014 2.2. Otherwise, the target supports read
5015 watchpoints, but, the user set an access or write
5016 watchpoint watching the same memory as this read
5019 If we're watching memory writes as well as reads,
5020 ignore watchpoint hits when we find that the
5021 value hasn't changed, as reads don't cause
5022 changes. This still gives false positives when
5023 the program writes the same value to memory as
5024 what there was already in memory (we will confuse
5025 it for a read), but it's much better than
5028 int other_write_watchpoint = 0;
5030 if (bl->watchpoint_type == hw_read)
5032 struct breakpoint *other_b;
5034 ALL_BREAKPOINTS (other_b)
5035 if (other_b->type == bp_hardware_watchpoint
5036 || other_b->type == bp_access_watchpoint)
5038 struct watchpoint *other_w =
5039 (struct watchpoint *) other_b;
5041 if (other_w->watchpoint_triggered
5042 == watch_triggered_yes)
5044 other_write_watchpoint = 1;
5050 if (other_write_watchpoint
5051 || bl->watchpoint_type == hw_access)
5053 /* We're watching the same memory for writes,
5054 and the value changed since the last time we
5055 updated it, so this trap must be for a write.
5057 bs->print_it = print_it_noop;
5062 case WP_VALUE_NOT_CHANGED:
5063 if (b->base.type == bp_hardware_watchpoint
5064 || b->base.type == bp_watchpoint)
5066 /* Don't stop: write watchpoints shouldn't fire if
5067 the value hasn't changed. */
5068 bs->print_it = print_it_noop;
5076 /* Error from catch_errors. */
5077 printf_filtered (_("Watchpoint %d deleted.\n"), b->base.number);
5078 watchpoint_del_at_next_stop (b);
5079 /* We've already printed what needs to be printed. */
5080 bs->print_it = print_it_done;
5084 else /* must_check_value == 0 */
5086 /* This is a case where some watchpoint(s) triggered, but
5087 not at the address of this watchpoint, or else no
5088 watchpoint triggered after all. So don't print
5089 anything for this watchpoint. */
5090 bs->print_it = print_it_noop;
5096 /* For breakpoints that are currently marked as telling gdb to stop,
5097 check conditions (condition proper, frame, thread and ignore count)
5098 of breakpoint referred to by BS. If we should not stop for this
5099 breakpoint, set BS->stop to 0. */
5102 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
5104 int thread_id = pid_to_thread_id (ptid);
5105 const struct bp_location *bl;
5106 struct breakpoint *b;
5107 int value_is_zero = 0;
5108 struct expression *cond;
5110 gdb_assert (bs->stop);
5112 /* BS is built for existing struct breakpoint. */
5113 bl = bs->bp_location_at;
5114 gdb_assert (bl != NULL);
5115 b = bs->breakpoint_at;
5116 gdb_assert (b != NULL);
5118 /* Even if the target evaluated the condition on its end and notified GDB, we
5119 need to do so again since GDB does not know if we stopped due to a
5120 breakpoint or a single step breakpoint. */
5122 if (frame_id_p (b->frame_id)
5123 && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
5129 /* If this is a thread-specific breakpoint, don't waste cpu evaluating the
5130 condition if this isn't the specified thread. */
5131 if (b->thread != -1 && b->thread != thread_id)
5137 /* Evaluate Python breakpoints that have a "stop" method implemented. */
5138 if (b->py_bp_object)
5139 bs->stop = gdbpy_should_stop (b->py_bp_object);
5141 if (is_watchpoint (b))
5143 struct watchpoint *w = (struct watchpoint *) b;
5150 if (cond && b->disposition != disp_del_at_next_stop)
5152 int within_current_scope = 1;
5153 struct watchpoint * w;
5155 /* We use value_mark and value_free_to_mark because it could
5156 be a long time before we return to the command level and
5157 call free_all_values. We can't call free_all_values
5158 because we might be in the middle of evaluating a
5160 struct value *mark = value_mark ();
5162 if (is_watchpoint (b))
5163 w = (struct watchpoint *) b;
5167 /* Need to select the frame, with all that implies so that
5168 the conditions will have the right context. Because we
5169 use the frame, we will not see an inlined function's
5170 variables when we arrive at a breakpoint at the start
5171 of the inlined function; the current frame will be the
5173 if (w == NULL || w->cond_exp_valid_block == NULL)
5174 select_frame (get_current_frame ());
5177 struct frame_info *frame;
5179 /* For local watchpoint expressions, which particular
5180 instance of a local is being watched matters, so we
5181 keep track of the frame to evaluate the expression
5182 in. To evaluate the condition however, it doesn't
5183 really matter which instantiation of the function
5184 where the condition makes sense triggers the
5185 watchpoint. This allows an expression like "watch
5186 global if q > 10" set in `func', catch writes to
5187 global on all threads that call `func', or catch
5188 writes on all recursive calls of `func' by a single
5189 thread. We simply always evaluate the condition in
5190 the innermost frame that's executing where it makes
5191 sense to evaluate the condition. It seems
5193 frame = block_innermost_frame (w->cond_exp_valid_block);
5195 select_frame (frame);
5197 within_current_scope = 0;
5199 if (within_current_scope)
5201 = catch_errors (breakpoint_cond_eval, cond,
5202 "Error in testing breakpoint condition:\n",
5206 warning (_("Watchpoint condition cannot be tested "
5207 "in the current scope"));
5208 /* If we failed to set the right context for this
5209 watchpoint, unconditionally report it. */
5212 /* FIXME-someday, should give breakpoint #. */
5213 value_free_to_mark (mark);
5216 if (cond && value_is_zero)
5220 else if (b->ignore_count > 0)
5224 /* Increase the hit count even though we don't stop. */
5226 observer_notify_breakpoint_modified (b);
5231 /* Get a bpstat associated with having just stopped at address
5232 BP_ADDR in thread PTID.
5234 Determine whether we stopped at a breakpoint, etc, or whether we
5235 don't understand this stop. Result is a chain of bpstat's such
5238 if we don't understand the stop, the result is a null pointer.
5240 if we understand why we stopped, the result is not null.
5242 Each element of the chain refers to a particular breakpoint or
5243 watchpoint at which we have stopped. (We may have stopped for
5244 several reasons concurrently.)
5246 Each element of the chain has valid next, breakpoint_at,
5247 commands, FIXME??? fields. */
5250 bpstat_stop_status (struct address_space *aspace,
5251 CORE_ADDR bp_addr, ptid_t ptid,
5252 const struct target_waitstatus *ws)
5254 struct breakpoint *b = NULL;
5255 struct bp_location *bl;
5256 struct bp_location *loc;
5257 /* First item of allocated bpstat's. */
5258 bpstat bs_head = NULL, *bs_link = &bs_head;
5259 /* Pointer to the last thing in the chain currently. */
5262 int need_remove_insert;
5265 /* First, build the bpstat chain with locations that explain a
5266 target stop, while being careful to not set the target running,
5267 as that may invalidate locations (in particular watchpoint
5268 locations are recreated). Resuming will happen here with
5269 breakpoint conditions or watchpoint expressions that include
5270 inferior function calls. */
5274 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
5277 for (bl = b->loc; bl != NULL; bl = bl->next)
5279 /* For hardware watchpoints, we look only at the first
5280 location. The watchpoint_check function will work on the
5281 entire expression, not the individual locations. For
5282 read watchpoints, the watchpoints_triggered function has
5283 checked all locations already. */
5284 if (b->type == bp_hardware_watchpoint && bl != b->loc)
5287 if (!bl->enabled || bl->shlib_disabled)
5290 if (!bpstat_check_location (bl, aspace, bp_addr, ws))
5293 /* Come here if it's a watchpoint, or if the break address
5296 bs = bpstat_alloc (bl, &bs_link); /* Alloc a bpstat to
5299 /* Assume we stop. Should we find a watchpoint that is not
5300 actually triggered, or if the condition of the breakpoint
5301 evaluates as false, we'll reset 'stop' to 0. */
5305 /* If this is a scope breakpoint, mark the associated
5306 watchpoint as triggered so that we will handle the
5307 out-of-scope event. We'll get to the watchpoint next
5309 if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
5311 struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5313 w->watchpoint_triggered = watch_triggered_yes;
5318 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
5320 if (breakpoint_location_address_match (loc, aspace, bp_addr))
5322 bs = bpstat_alloc (loc, &bs_link);
5323 /* For hits of moribund locations, we should just proceed. */
5326 bs->print_it = print_it_noop;
5330 /* A bit of special processing for shlib breakpoints. We need to
5331 process solib loading here, so that the lists of loaded and
5332 unloaded libraries are correct before we handle "catch load" and
5334 for (bs = bs_head; bs != NULL; bs = bs->next)
5336 if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
5338 handle_solib_event ();
5343 /* Now go through the locations that caused the target to stop, and
5344 check whether we're interested in reporting this stop to higher
5345 layers, or whether we should resume the target transparently. */
5349 for (bs = bs_head; bs != NULL; bs = bs->next)
5354 b = bs->breakpoint_at;
5355 b->ops->check_status (bs);
5358 bpstat_check_breakpoint_conditions (bs, ptid);
5363 observer_notify_breakpoint_modified (b);
5365 /* We will stop here. */
5366 if (b->disposition == disp_disable)
5368 --(b->enable_count);
5369 if (b->enable_count <= 0
5370 && b->enable_state != bp_permanent)
5371 b->enable_state = bp_disabled;
5376 bs->commands = b->commands;
5377 incref_counted_command_line (bs->commands);
5378 if (command_line_is_silent (bs->commands
5379 ? bs->commands->commands : NULL))
5382 b->ops->after_condition_true (bs);
5387 /* Print nothing for this entry if we don't stop or don't
5389 if (!bs->stop || !bs->print)
5390 bs->print_it = print_it_noop;
5393 /* If we aren't stopping, the value of some hardware watchpoint may
5394 not have changed, but the intermediate memory locations we are
5395 watching may have. Don't bother if we're stopping; this will get
5397 need_remove_insert = 0;
5398 if (! bpstat_causes_stop (bs_head))
5399 for (bs = bs_head; bs != NULL; bs = bs->next)
5401 && bs->breakpoint_at
5402 && is_hardware_watchpoint (bs->breakpoint_at))
5404 struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5406 update_watchpoint (w, 0 /* don't reparse. */);
5407 need_remove_insert = 1;
5410 if (need_remove_insert)
5411 update_global_location_list (1);
5412 else if (removed_any)
5413 update_global_location_list (0);
5419 handle_jit_event (void)
5421 struct frame_info *frame;
5422 struct gdbarch *gdbarch;
5424 /* Switch terminal for any messages produced by
5425 breakpoint_re_set. */
5426 target_terminal_ours_for_output ();
5428 frame = get_current_frame ();
5429 gdbarch = get_frame_arch (frame);
5431 jit_event_handler (gdbarch);
5433 target_terminal_inferior ();
5436 /* Prepare WHAT final decision for infrun. */
5438 /* Decide what infrun needs to do with this bpstat. */
5441 bpstat_what (bpstat bs_head)
5443 struct bpstat_what retval;
5447 retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
5448 retval.call_dummy = STOP_NONE;
5449 retval.is_longjmp = 0;
5451 for (bs = bs_head; bs != NULL; bs = bs->next)
5453 /* Extract this BS's action. After processing each BS, we check
5454 if its action overrides all we've seem so far. */
5455 enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5458 if (bs->breakpoint_at == NULL)
5460 /* I suspect this can happen if it was a momentary
5461 breakpoint which has since been deleted. */
5465 bptype = bs->breakpoint_at->type;
5472 case bp_hardware_breakpoint:
5475 case bp_shlib_event:
5479 this_action = BPSTAT_WHAT_STOP_NOISY;
5481 this_action = BPSTAT_WHAT_STOP_SILENT;
5484 this_action = BPSTAT_WHAT_SINGLE;
5487 case bp_hardware_watchpoint:
5488 case bp_read_watchpoint:
5489 case bp_access_watchpoint:
5493 this_action = BPSTAT_WHAT_STOP_NOISY;
5495 this_action = BPSTAT_WHAT_STOP_SILENT;
5499 /* There was a watchpoint, but we're not stopping.
5500 This requires no further action. */
5504 case bp_longjmp_call_dummy:
5506 this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5507 retval.is_longjmp = bptype != bp_exception;
5509 case bp_longjmp_resume:
5510 case bp_exception_resume:
5511 this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5512 retval.is_longjmp = bptype == bp_longjmp_resume;
5514 case bp_step_resume:
5516 this_action = BPSTAT_WHAT_STEP_RESUME;
5519 /* It is for the wrong frame. */
5520 this_action = BPSTAT_WHAT_SINGLE;
5523 case bp_hp_step_resume:
5525 this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5528 /* It is for the wrong frame. */
5529 this_action = BPSTAT_WHAT_SINGLE;
5532 case bp_watchpoint_scope:
5533 case bp_thread_event:
5534 case bp_overlay_event:
5535 case bp_longjmp_master:
5536 case bp_std_terminate_master:
5537 case bp_exception_master:
5538 this_action = BPSTAT_WHAT_SINGLE;
5544 this_action = BPSTAT_WHAT_STOP_NOISY;
5546 this_action = BPSTAT_WHAT_STOP_SILENT;
5550 /* There was a catchpoint, but we're not stopping.
5551 This requires no further action. */
5556 this_action = BPSTAT_WHAT_SINGLE;
5559 /* Make sure the action is stop (silent or noisy),
5560 so infrun.c pops the dummy frame. */
5561 retval.call_dummy = STOP_STACK_DUMMY;
5562 this_action = BPSTAT_WHAT_STOP_SILENT;
5564 case bp_std_terminate:
5565 /* Make sure the action is stop (silent or noisy),
5566 so infrun.c pops the dummy frame. */
5567 retval.call_dummy = STOP_STD_TERMINATE;
5568 this_action = BPSTAT_WHAT_STOP_SILENT;
5571 case bp_fast_tracepoint:
5572 case bp_static_tracepoint:
5573 /* Tracepoint hits should not be reported back to GDB, and
5574 if one got through somehow, it should have been filtered
5576 internal_error (__FILE__, __LINE__,
5577 _("bpstat_what: tracepoint encountered"));
5579 case bp_gnu_ifunc_resolver:
5580 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5581 this_action = BPSTAT_WHAT_SINGLE;
5583 case bp_gnu_ifunc_resolver_return:
5584 /* The breakpoint will be removed, execution will restart from the
5585 PC of the former breakpoint. */
5586 this_action = BPSTAT_WHAT_KEEP_CHECKING;
5591 this_action = BPSTAT_WHAT_STOP_SILENT;
5593 this_action = BPSTAT_WHAT_SINGLE;
5597 internal_error (__FILE__, __LINE__,
5598 _("bpstat_what: unhandled bptype %d"), (int) bptype);
5601 retval.main_action = max (retval.main_action, this_action);
5604 /* These operations may affect the bs->breakpoint_at state so they are
5605 delayed after MAIN_ACTION is decided above. */
5610 fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_jit_event\n");
5612 handle_jit_event ();
5615 for (bs = bs_head; bs != NULL; bs = bs->next)
5617 struct breakpoint *b = bs->breakpoint_at;
5623 case bp_gnu_ifunc_resolver:
5624 gnu_ifunc_resolver_stop (b);
5626 case bp_gnu_ifunc_resolver_return:
5627 gnu_ifunc_resolver_return_stop (b);
5635 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5636 without hardware support). This isn't related to a specific bpstat,
5637 just to things like whether watchpoints are set. */
5640 bpstat_should_step (void)
5642 struct breakpoint *b;
5645 if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
5651 bpstat_causes_stop (bpstat bs)
5653 for (; bs != NULL; bs = bs->next)
5662 /* Compute a string of spaces suitable to indent the next line
5663 so it starts at the position corresponding to the table column
5664 named COL_NAME in the currently active table of UIOUT. */
5667 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
5669 static char wrap_indent[80];
5670 int i, total_width, width, align;
5674 for (i = 1; ui_out_query_field (uiout, i, &width, &align, &text); i++)
5676 if (strcmp (text, col_name) == 0)
5678 gdb_assert (total_width < sizeof wrap_indent);
5679 memset (wrap_indent, ' ', total_width);
5680 wrap_indent[total_width] = 0;
5685 total_width += width + 1;
5691 /* Determine if the locations of this breakpoint will have their conditions
5692 evaluated by the target, host or a mix of both. Returns the following:
5694 "host": Host evals condition.
5695 "host or target": Host or Target evals condition.
5696 "target": Target evals condition.
5700 bp_condition_evaluator (struct breakpoint *b)
5702 struct bp_location *bl;
5703 char host_evals = 0;
5704 char target_evals = 0;
5709 if (!is_breakpoint (b))
5712 if (gdb_evaluates_breakpoint_condition_p ()
5713 || !target_supports_evaluation_of_breakpoint_conditions ())
5714 return condition_evaluation_host;
5716 for (bl = b->loc; bl; bl = bl->next)
5718 if (bl->cond_bytecode)
5724 if (host_evals && target_evals)
5725 return condition_evaluation_both;
5726 else if (target_evals)
5727 return condition_evaluation_target;
5729 return condition_evaluation_host;
5732 /* Determine the breakpoint location's condition evaluator. This is
5733 similar to bp_condition_evaluator, but for locations. */
5736 bp_location_condition_evaluator (struct bp_location *bl)
5738 if (bl && !is_breakpoint (bl->owner))
5741 if (gdb_evaluates_breakpoint_condition_p ()
5742 || !target_supports_evaluation_of_breakpoint_conditions ())
5743 return condition_evaluation_host;
5745 if (bl && bl->cond_bytecode)
5746 return condition_evaluation_target;
5748 return condition_evaluation_host;
5751 /* Print the LOC location out of the list of B->LOC locations. */
5754 print_breakpoint_location (struct breakpoint *b,
5755 struct bp_location *loc)
5757 struct ui_out *uiout = current_uiout;
5758 struct cleanup *old_chain = save_current_program_space ();
5760 if (loc != NULL && loc->shlib_disabled)
5764 set_current_program_space (loc->pspace);
5766 if (b->display_canonical)
5767 ui_out_field_string (uiout, "what", b->addr_string);
5768 else if (loc && loc->symtab)
5771 = find_pc_sect_function (loc->address, loc->section);
5774 ui_out_text (uiout, "in ");
5775 ui_out_field_string (uiout, "func",
5776 SYMBOL_PRINT_NAME (sym));
5777 ui_out_text (uiout, " ");
5778 ui_out_wrap_hint (uiout, wrap_indent_at_field (uiout, "what"));
5779 ui_out_text (uiout, "at ");
5781 ui_out_field_string (uiout, "file",
5782 symtab_to_filename_for_display (loc->symtab));
5783 ui_out_text (uiout, ":");
5785 if (ui_out_is_mi_like_p (uiout))
5786 ui_out_field_string (uiout, "fullname",
5787 symtab_to_fullname (loc->symtab));
5789 ui_out_field_int (uiout, "line", loc->line_number);
5793 struct ui_file *stb = mem_fileopen ();
5794 struct cleanup *stb_chain = make_cleanup_ui_file_delete (stb);
5796 print_address_symbolic (loc->gdbarch, loc->address, stb,
5798 ui_out_field_stream (uiout, "at", stb);
5800 do_cleanups (stb_chain);
5803 ui_out_field_string (uiout, "pending", b->addr_string);
5805 if (loc && is_breakpoint (b)
5806 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5807 && bp_condition_evaluator (b) == condition_evaluation_both)
5809 ui_out_text (uiout, " (");
5810 ui_out_field_string (uiout, "evaluated-by",
5811 bp_location_condition_evaluator (loc));
5812 ui_out_text (uiout, ")");
5815 do_cleanups (old_chain);
5819 bptype_string (enum bptype type)
5821 struct ep_type_description
5826 static struct ep_type_description bptypes[] =
5828 {bp_none, "?deleted?"},
5829 {bp_breakpoint, "breakpoint"},
5830 {bp_hardware_breakpoint, "hw breakpoint"},
5831 {bp_until, "until"},
5832 {bp_finish, "finish"},
5833 {bp_watchpoint, "watchpoint"},
5834 {bp_hardware_watchpoint, "hw watchpoint"},
5835 {bp_read_watchpoint, "read watchpoint"},
5836 {bp_access_watchpoint, "acc watchpoint"},
5837 {bp_longjmp, "longjmp"},
5838 {bp_longjmp_resume, "longjmp resume"},
5839 {bp_longjmp_call_dummy, "longjmp for call dummy"},
5840 {bp_exception, "exception"},
5841 {bp_exception_resume, "exception resume"},
5842 {bp_step_resume, "step resume"},
5843 {bp_hp_step_resume, "high-priority step resume"},
5844 {bp_watchpoint_scope, "watchpoint scope"},
5845 {bp_call_dummy, "call dummy"},
5846 {bp_std_terminate, "std::terminate"},
5847 {bp_shlib_event, "shlib events"},
5848 {bp_thread_event, "thread events"},
5849 {bp_overlay_event, "overlay events"},
5850 {bp_longjmp_master, "longjmp master"},
5851 {bp_std_terminate_master, "std::terminate master"},
5852 {bp_exception_master, "exception master"},
5853 {bp_catchpoint, "catchpoint"},
5854 {bp_tracepoint, "tracepoint"},
5855 {bp_fast_tracepoint, "fast tracepoint"},
5856 {bp_static_tracepoint, "static tracepoint"},
5857 {bp_dprintf, "dprintf"},
5858 {bp_jit_event, "jit events"},
5859 {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
5860 {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
5863 if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
5864 || ((int) type != bptypes[(int) type].type))
5865 internal_error (__FILE__, __LINE__,
5866 _("bptypes table does not describe type #%d."),
5869 return bptypes[(int) type].description;
5872 /* For MI, output a field named 'thread-groups' with a list as the value.
5873 For CLI, prefix the list with the string 'inf'. */
5876 output_thread_groups (struct ui_out *uiout,
5877 const char *field_name,
5881 struct cleanup *back_to;
5882 int is_mi = ui_out_is_mi_like_p (uiout);
5886 /* For backward compatibility, don't display inferiors in CLI unless
5887 there are several. Always display them for MI. */
5888 if (!is_mi && mi_only)
5891 back_to = make_cleanup_ui_out_list_begin_end (uiout, field_name);
5893 for (i = 0; VEC_iterate (int, inf_num, i, inf); ++i)
5899 xsnprintf (mi_group, sizeof (mi_group), "i%d", inf);
5900 ui_out_field_string (uiout, NULL, mi_group);
5905 ui_out_text (uiout, " inf ");
5907 ui_out_text (uiout, ", ");
5909 ui_out_text (uiout, plongest (inf));
5913 do_cleanups (back_to);
5916 /* Print B to gdb_stdout. */
5919 print_one_breakpoint_location (struct breakpoint *b,
5920 struct bp_location *loc,
5922 struct bp_location **last_loc,
5925 struct command_line *l;
5926 static char bpenables[] = "nynny";
5928 struct ui_out *uiout = current_uiout;
5929 int header_of_multiple = 0;
5930 int part_of_multiple = (loc != NULL);
5931 struct value_print_options opts;
5933 get_user_print_options (&opts);
5935 gdb_assert (!loc || loc_number != 0);
5936 /* See comment in print_one_breakpoint concerning treatment of
5937 breakpoints with single disabled location. */
5940 && (b->loc->next != NULL || !b->loc->enabled)))
5941 header_of_multiple = 1;
5949 if (part_of_multiple)
5952 formatted = xstrprintf ("%d.%d", b->number, loc_number);
5953 ui_out_field_string (uiout, "number", formatted);
5958 ui_out_field_int (uiout, "number", b->number);
5963 if (part_of_multiple)
5964 ui_out_field_skip (uiout, "type");
5966 ui_out_field_string (uiout, "type", bptype_string (b->type));
5970 if (part_of_multiple)
5971 ui_out_field_skip (uiout, "disp");
5973 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
5978 if (part_of_multiple)
5979 ui_out_field_string (uiout, "enabled", loc->enabled ? "y" : "n");
5981 ui_out_field_fmt (uiout, "enabled", "%c",
5982 bpenables[(int) b->enable_state]);
5983 ui_out_spaces (uiout, 2);
5987 if (b->ops != NULL && b->ops->print_one != NULL)
5989 /* Although the print_one can possibly print all locations,
5990 calling it here is not likely to get any nice result. So,
5991 make sure there's just one location. */
5992 gdb_assert (b->loc == NULL || b->loc->next == NULL);
5993 b->ops->print_one (b, last_loc);
5999 internal_error (__FILE__, __LINE__,
6000 _("print_one_breakpoint: bp_none encountered\n"));
6004 case bp_hardware_watchpoint:
6005 case bp_read_watchpoint:
6006 case bp_access_watchpoint:
6008 struct watchpoint *w = (struct watchpoint *) b;
6010 /* Field 4, the address, is omitted (which makes the columns
6011 not line up too nicely with the headers, but the effect
6012 is relatively readable). */
6013 if (opts.addressprint)
6014 ui_out_field_skip (uiout, "addr");
6016 ui_out_field_string (uiout, "what", w->exp_string);
6021 case bp_hardware_breakpoint:
6025 case bp_longjmp_resume:
6026 case bp_longjmp_call_dummy:
6028 case bp_exception_resume:
6029 case bp_step_resume:
6030 case bp_hp_step_resume:
6031 case bp_watchpoint_scope:
6033 case bp_std_terminate:
6034 case bp_shlib_event:
6035 case bp_thread_event:
6036 case bp_overlay_event:
6037 case bp_longjmp_master:
6038 case bp_std_terminate_master:
6039 case bp_exception_master:
6041 case bp_fast_tracepoint:
6042 case bp_static_tracepoint:
6045 case bp_gnu_ifunc_resolver:
6046 case bp_gnu_ifunc_resolver_return:
6047 if (opts.addressprint)
6050 if (header_of_multiple)
6051 ui_out_field_string (uiout, "addr", "<MULTIPLE>");
6052 else if (b->loc == NULL || loc->shlib_disabled)
6053 ui_out_field_string (uiout, "addr", "<PENDING>");
6055 ui_out_field_core_addr (uiout, "addr",
6056 loc->gdbarch, loc->address);
6059 if (!header_of_multiple)
6060 print_breakpoint_location (b, loc);
6067 if (loc != NULL && !header_of_multiple)
6069 struct inferior *inf;
6070 VEC(int) *inf_num = NULL;
6075 if (inf->pspace == loc->pspace)
6076 VEC_safe_push (int, inf_num, inf->num);
6079 /* For backward compatibility, don't display inferiors in CLI unless
6080 there are several. Always display for MI. */
6082 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6083 && (number_of_program_spaces () > 1
6084 || number_of_inferiors () > 1)
6085 /* LOC is for existing B, it cannot be in
6086 moribund_locations and thus having NULL OWNER. */
6087 && loc->owner->type != bp_catchpoint))
6089 output_thread_groups (uiout, "thread-groups", inf_num, mi_only);
6090 VEC_free (int, inf_num);
6093 if (!part_of_multiple)
6095 if (b->thread != -1)
6097 /* FIXME: This seems to be redundant and lost here; see the
6098 "stop only in" line a little further down. */
6099 ui_out_text (uiout, " thread ");
6100 ui_out_field_int (uiout, "thread", b->thread);
6102 else if (b->task != 0)
6104 ui_out_text (uiout, " task ");
6105 ui_out_field_int (uiout, "task", b->task);
6109 ui_out_text (uiout, "\n");
6111 if (!part_of_multiple)
6112 b->ops->print_one_detail (b, uiout);
6114 if (part_of_multiple && frame_id_p (b->frame_id))
6117 ui_out_text (uiout, "\tstop only in stack frame at ");
6118 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6120 ui_out_field_core_addr (uiout, "frame",
6121 b->gdbarch, b->frame_id.stack_addr);
6122 ui_out_text (uiout, "\n");
6125 if (!part_of_multiple && b->cond_string)
6128 if (is_tracepoint (b))
6129 ui_out_text (uiout, "\ttrace only if ");
6131 ui_out_text (uiout, "\tstop only if ");
6132 ui_out_field_string (uiout, "cond", b->cond_string);
6134 /* Print whether the target is doing the breakpoint's condition
6135 evaluation. If GDB is doing the evaluation, don't print anything. */
6136 if (is_breakpoint (b)
6137 && breakpoint_condition_evaluation_mode ()
6138 == condition_evaluation_target)
6140 ui_out_text (uiout, " (");
6141 ui_out_field_string (uiout, "evaluated-by",
6142 bp_condition_evaluator (b));
6143 ui_out_text (uiout, " evals)");
6145 ui_out_text (uiout, "\n");
6148 if (!part_of_multiple && b->thread != -1)
6150 /* FIXME should make an annotation for this. */
6151 ui_out_text (uiout, "\tstop only in thread ");
6152 ui_out_field_int (uiout, "thread", b->thread);
6153 ui_out_text (uiout, "\n");
6156 if (!part_of_multiple)
6160 /* FIXME should make an annotation for this. */
6161 if (is_catchpoint (b))
6162 ui_out_text (uiout, "\tcatchpoint");
6163 else if (is_tracepoint (b))
6164 ui_out_text (uiout, "\ttracepoint");
6166 ui_out_text (uiout, "\tbreakpoint");
6167 ui_out_text (uiout, " already hit ");
6168 ui_out_field_int (uiout, "times", b->hit_count);
6169 if (b->hit_count == 1)
6170 ui_out_text (uiout, " time\n");
6172 ui_out_text (uiout, " times\n");
6176 /* Output the count also if it is zero, but only if this is mi. */
6177 if (ui_out_is_mi_like_p (uiout))
6178 ui_out_field_int (uiout, "times", b->hit_count);
6182 if (!part_of_multiple && b->ignore_count)
6185 ui_out_text (uiout, "\tignore next ");
6186 ui_out_field_int (uiout, "ignore", b->ignore_count);
6187 ui_out_text (uiout, " hits\n");
6190 /* Note that an enable count of 1 corresponds to "enable once"
6191 behavior, which is reported by the combination of enablement and
6192 disposition, so we don't need to mention it here. */
6193 if (!part_of_multiple && b->enable_count > 1)
6196 ui_out_text (uiout, "\tdisable after ");
6197 /* Tweak the wording to clarify that ignore and enable counts
6198 are distinct, and have additive effect. */
6199 if (b->ignore_count)
6200 ui_out_text (uiout, "additional ");
6202 ui_out_text (uiout, "next ");
6203 ui_out_field_int (uiout, "enable", b->enable_count);
6204 ui_out_text (uiout, " hits\n");
6207 if (!part_of_multiple && is_tracepoint (b))
6209 struct tracepoint *tp = (struct tracepoint *) b;
6211 if (tp->traceframe_usage)
6213 ui_out_text (uiout, "\ttrace buffer usage ");
6214 ui_out_field_int (uiout, "traceframe-usage", tp->traceframe_usage);
6215 ui_out_text (uiout, " bytes\n");
6219 l = b->commands ? b->commands->commands : NULL;
6220 if (!part_of_multiple && l)
6222 struct cleanup *script_chain;
6225 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
6226 print_command_lines (uiout, l, 4);
6227 do_cleanups (script_chain);
6230 if (is_tracepoint (b))
6232 struct tracepoint *t = (struct tracepoint *) b;
6234 if (!part_of_multiple && t->pass_count)
6236 annotate_field (10);
6237 ui_out_text (uiout, "\tpass count ");
6238 ui_out_field_int (uiout, "pass", t->pass_count);
6239 ui_out_text (uiout, " \n");
6242 /* Don't display it when tracepoint or tracepoint location is
6244 if (!header_of_multiple && loc != NULL && !loc->shlib_disabled)
6246 annotate_field (11);
6248 if (ui_out_is_mi_like_p (uiout))
6249 ui_out_field_string (uiout, "installed",
6250 loc->inserted ? "y" : "n");
6254 ui_out_text (uiout, "\t");
6256 ui_out_text (uiout, "\tnot ");
6257 ui_out_text (uiout, "installed on target\n");
6262 if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
6264 if (is_watchpoint (b))
6266 struct watchpoint *w = (struct watchpoint *) b;
6268 ui_out_field_string (uiout, "original-location", w->exp_string);
6270 else if (b->addr_string)
6271 ui_out_field_string (uiout, "original-location", b->addr_string);
6276 print_one_breakpoint (struct breakpoint *b,
6277 struct bp_location **last_loc,
6280 struct cleanup *bkpt_chain;
6281 struct ui_out *uiout = current_uiout;
6283 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
6285 print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
6286 do_cleanups (bkpt_chain);
6288 /* If this breakpoint has custom print function,
6289 it's already printed. Otherwise, print individual
6290 locations, if any. */
6291 if (b->ops == NULL || b->ops->print_one == NULL)
6293 /* If breakpoint has a single location that is disabled, we
6294 print it as if it had several locations, since otherwise it's
6295 hard to represent "breakpoint enabled, location disabled"
6298 Note that while hardware watchpoints have several locations
6299 internally, that's not a property exposed to user. */
6301 && !is_hardware_watchpoint (b)
6302 && (b->loc->next || !b->loc->enabled))
6304 struct bp_location *loc;
6307 for (loc = b->loc; loc; loc = loc->next, ++n)
6309 struct cleanup *inner2 =
6310 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
6311 print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6312 do_cleanups (inner2);
6319 breakpoint_address_bits (struct breakpoint *b)
6321 int print_address_bits = 0;
6322 struct bp_location *loc;
6324 for (loc = b->loc; loc; loc = loc->next)
6328 /* Software watchpoints that aren't watching memory don't have
6329 an address to print. */
6330 if (b->type == bp_watchpoint && loc->watchpoint_type == -1)
6333 addr_bit = gdbarch_addr_bit (loc->gdbarch);
6334 if (addr_bit > print_address_bits)
6335 print_address_bits = addr_bit;
6338 return print_address_bits;
6341 struct captured_breakpoint_query_args
6347 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
6349 struct captured_breakpoint_query_args *args = data;
6350 struct breakpoint *b;
6351 struct bp_location *dummy_loc = NULL;
6355 if (args->bnum == b->number)
6357 print_one_breakpoint (b, &dummy_loc, 0);
6365 gdb_breakpoint_query (struct ui_out *uiout, int bnum,
6366 char **error_message)
6368 struct captured_breakpoint_query_args args;
6371 /* For the moment we don't trust print_one_breakpoint() to not throw
6373 if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
6374 error_message, RETURN_MASK_ALL) < 0)
6380 /* Return true if this breakpoint was set by the user, false if it is
6381 internal or momentary. */
6384 user_breakpoint_p (struct breakpoint *b)
6386 return b->number > 0;
6389 /* Print information on user settable breakpoint (watchpoint, etc)
6390 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6391 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6392 FILTER is non-NULL, call it on each breakpoint and only include the
6393 ones for which it returns non-zero. Return the total number of
6394 breakpoints listed. */
6397 breakpoint_1 (char *args, int allflag,
6398 int (*filter) (const struct breakpoint *))
6400 struct breakpoint *b;
6401 struct bp_location *last_loc = NULL;
6402 int nr_printable_breakpoints;
6403 struct cleanup *bkpttbl_chain;
6404 struct value_print_options opts;
6405 int print_address_bits = 0;
6406 int print_type_col_width = 14;
6407 struct ui_out *uiout = current_uiout;
6409 get_user_print_options (&opts);
6411 /* Compute the number of rows in the table, as well as the size
6412 required for address fields. */
6413 nr_printable_breakpoints = 0;
6416 /* If we have a filter, only list the breakpoints it accepts. */
6417 if (filter && !filter (b))
6420 /* If we have an "args" string, it is a list of breakpoints to
6421 accept. Skip the others. */
6422 if (args != NULL && *args != '\0')
6424 if (allflag && parse_and_eval_long (args) != b->number)
6426 if (!allflag && !number_is_in_list (args, b->number))
6430 if (allflag || user_breakpoint_p (b))
6432 int addr_bit, type_len;
6434 addr_bit = breakpoint_address_bits (b);
6435 if (addr_bit > print_address_bits)
6436 print_address_bits = addr_bit;
6438 type_len = strlen (bptype_string (b->type));
6439 if (type_len > print_type_col_width)
6440 print_type_col_width = type_len;
6442 nr_printable_breakpoints++;
6446 if (opts.addressprint)
6448 = make_cleanup_ui_out_table_begin_end (uiout, 6,
6449 nr_printable_breakpoints,
6453 = make_cleanup_ui_out_table_begin_end (uiout, 5,
6454 nr_printable_breakpoints,
6457 if (nr_printable_breakpoints > 0)
6458 annotate_breakpoints_headers ();
6459 if (nr_printable_breakpoints > 0)
6461 ui_out_table_header (uiout, 7, ui_left, "number", "Num"); /* 1 */
6462 if (nr_printable_breakpoints > 0)
6464 ui_out_table_header (uiout, print_type_col_width, ui_left,
6465 "type", "Type"); /* 2 */
6466 if (nr_printable_breakpoints > 0)
6468 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
6469 if (nr_printable_breakpoints > 0)
6471 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
6472 if (opts.addressprint)
6474 if (nr_printable_breakpoints > 0)
6476 if (print_address_bits <= 32)
6477 ui_out_table_header (uiout, 10, ui_left,
6478 "addr", "Address"); /* 5 */
6480 ui_out_table_header (uiout, 18, ui_left,
6481 "addr", "Address"); /* 5 */
6483 if (nr_printable_breakpoints > 0)
6485 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
6486 ui_out_table_body (uiout);
6487 if (nr_printable_breakpoints > 0)
6488 annotate_breakpoints_table ();
6493 /* If we have a filter, only list the breakpoints it accepts. */
6494 if (filter && !filter (b))
6497 /* If we have an "args" string, it is a list of breakpoints to
6498 accept. Skip the others. */
6500 if (args != NULL && *args != '\0')
6502 if (allflag) /* maintenance info breakpoint */
6504 if (parse_and_eval_long (args) != b->number)
6507 else /* all others */
6509 if (!number_is_in_list (args, b->number))
6513 /* We only print out user settable breakpoints unless the
6515 if (allflag || user_breakpoint_p (b))
6516 print_one_breakpoint (b, &last_loc, allflag);
6519 do_cleanups (bkpttbl_chain);
6521 if (nr_printable_breakpoints == 0)
6523 /* If there's a filter, let the caller decide how to report
6527 if (args == NULL || *args == '\0')
6528 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
6530 ui_out_message (uiout, 0,
6531 "No breakpoint or watchpoint matching '%s'.\n",
6537 if (last_loc && !server_command)
6538 set_next_address (last_loc->gdbarch, last_loc->address);
6541 /* FIXME? Should this be moved up so that it is only called when
6542 there have been breakpoints? */
6543 annotate_breakpoints_table_end ();
6545 return nr_printable_breakpoints;
6548 /* Display the value of default-collect in a way that is generally
6549 compatible with the breakpoint list. */
6552 default_collect_info (void)
6554 struct ui_out *uiout = current_uiout;
6556 /* If it has no value (which is frequently the case), say nothing; a
6557 message like "No default-collect." gets in user's face when it's
6559 if (!*default_collect)
6562 /* The following phrase lines up nicely with per-tracepoint collect
6564 ui_out_text (uiout, "default collect ");
6565 ui_out_field_string (uiout, "default-collect", default_collect);
6566 ui_out_text (uiout, " \n");
6570 breakpoints_info (char *args, int from_tty)
6572 breakpoint_1 (args, 0, NULL);
6574 default_collect_info ();
6578 watchpoints_info (char *args, int from_tty)
6580 int num_printed = breakpoint_1 (args, 0, is_watchpoint);
6581 struct ui_out *uiout = current_uiout;
6583 if (num_printed == 0)
6585 if (args == NULL || *args == '\0')
6586 ui_out_message (uiout, 0, "No watchpoints.\n");
6588 ui_out_message (uiout, 0, "No watchpoint matching '%s'.\n", args);
6593 maintenance_info_breakpoints (char *args, int from_tty)
6595 breakpoint_1 (args, 1, NULL);
6597 default_collect_info ();
6601 breakpoint_has_pc (struct breakpoint *b,
6602 struct program_space *pspace,
6603 CORE_ADDR pc, struct obj_section *section)
6605 struct bp_location *bl = b->loc;
6607 for (; bl; bl = bl->next)
6609 if (bl->pspace == pspace
6610 && bl->address == pc
6611 && (!overlay_debugging || bl->section == section))
6617 /* Print a message describing any user-breakpoints set at PC. This
6618 concerns with logical breakpoints, so we match program spaces, not
6622 describe_other_breakpoints (struct gdbarch *gdbarch,
6623 struct program_space *pspace, CORE_ADDR pc,
6624 struct obj_section *section, int thread)
6627 struct breakpoint *b;
6630 others += (user_breakpoint_p (b)
6631 && breakpoint_has_pc (b, pspace, pc, section));
6635 printf_filtered (_("Note: breakpoint "));
6636 else /* if (others == ???) */
6637 printf_filtered (_("Note: breakpoints "));
6639 if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
6642 printf_filtered ("%d", b->number);
6643 if (b->thread == -1 && thread != -1)
6644 printf_filtered (" (all threads)");
6645 else if (b->thread != -1)
6646 printf_filtered (" (thread %d)", b->thread);
6647 printf_filtered ("%s%s ",
6648 ((b->enable_state == bp_disabled
6649 || b->enable_state == bp_call_disabled)
6651 : b->enable_state == bp_permanent
6655 : ((others == 1) ? " and" : ""));
6657 printf_filtered (_("also set at pc "));
6658 fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
6659 printf_filtered (".\n");
6664 /* Return true iff it is meaningful to use the address member of
6665 BPT. For some breakpoint types, the address member is irrelevant
6666 and it makes no sense to attempt to compare it to other addresses
6667 (or use it for any other purpose either).
6669 More specifically, each of the following breakpoint types will
6670 always have a zero valued address and we don't want to mark
6671 breakpoints of any of these types to be a duplicate of an actual
6672 breakpoint at address zero:
6680 breakpoint_address_is_meaningful (struct breakpoint *bpt)
6682 enum bptype type = bpt->type;
6684 return (type != bp_watchpoint && type != bp_catchpoint);
6687 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6688 true if LOC1 and LOC2 represent the same watchpoint location. */
6691 watchpoint_locations_match (struct bp_location *loc1,
6692 struct bp_location *loc2)
6694 struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
6695 struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
6697 /* Both of them must exist. */
6698 gdb_assert (w1 != NULL);
6699 gdb_assert (w2 != NULL);
6701 /* If the target can evaluate the condition expression in hardware,
6702 then we we need to insert both watchpoints even if they are at
6703 the same place. Otherwise the watchpoint will only trigger when
6704 the condition of whichever watchpoint was inserted evaluates to
6705 true, not giving a chance for GDB to check the condition of the
6706 other watchpoint. */
6708 && target_can_accel_watchpoint_condition (loc1->address,
6710 loc1->watchpoint_type,
6713 && target_can_accel_watchpoint_condition (loc2->address,
6715 loc2->watchpoint_type,
6719 /* Note that this checks the owner's type, not the location's. In
6720 case the target does not support read watchpoints, but does
6721 support access watchpoints, we'll have bp_read_watchpoint
6722 watchpoints with hw_access locations. Those should be considered
6723 duplicates of hw_read locations. The hw_read locations will
6724 become hw_access locations later. */
6725 return (loc1->owner->type == loc2->owner->type
6726 && loc1->pspace->aspace == loc2->pspace->aspace
6727 && loc1->address == loc2->address
6728 && loc1->length == loc2->length);
6731 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
6732 same breakpoint location. In most targets, this can only be true
6733 if ASPACE1 matches ASPACE2. On targets that have global
6734 breakpoints, the address space doesn't really matter. */
6737 breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
6738 struct address_space *aspace2, CORE_ADDR addr2)
6740 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6741 || aspace1 == aspace2)
6745 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6746 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6747 matches ASPACE2. On targets that have global breakpoints, the address
6748 space doesn't really matter. */
6751 breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
6752 int len1, struct address_space *aspace2,
6755 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6756 || aspace1 == aspace2)
6757 && addr2 >= addr1 && addr2 < addr1 + len1);
6760 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6761 a ranged breakpoint. In most targets, a match happens only if ASPACE
6762 matches the breakpoint's address space. On targets that have global
6763 breakpoints, the address space doesn't really matter. */
6766 breakpoint_location_address_match (struct bp_location *bl,
6767 struct address_space *aspace,
6770 return (breakpoint_address_match (bl->pspace->aspace, bl->address,
6773 && breakpoint_address_match_range (bl->pspace->aspace,
6774 bl->address, bl->length,
6778 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6779 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6780 true, otherwise returns false. */
6783 tracepoint_locations_match (struct bp_location *loc1,
6784 struct bp_location *loc2)
6786 if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
6787 /* Since tracepoint locations are never duplicated with others', tracepoint
6788 locations at the same address of different tracepoints are regarded as
6789 different locations. */
6790 return (loc1->address == loc2->address && loc1->owner == loc2->owner);
6795 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6796 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6797 represent the same location. */
6800 breakpoint_locations_match (struct bp_location *loc1,
6801 struct bp_location *loc2)
6803 int hw_point1, hw_point2;
6805 /* Both of them must not be in moribund_locations. */
6806 gdb_assert (loc1->owner != NULL);
6807 gdb_assert (loc2->owner != NULL);
6809 hw_point1 = is_hardware_watchpoint (loc1->owner);
6810 hw_point2 = is_hardware_watchpoint (loc2->owner);
6812 if (hw_point1 != hw_point2)
6815 return watchpoint_locations_match (loc1, loc2);
6816 else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
6817 return tracepoint_locations_match (loc1, loc2);
6819 /* We compare bp_location.length in order to cover ranged breakpoints. */
6820 return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
6821 loc2->pspace->aspace, loc2->address)
6822 && loc1->length == loc2->length);
6826 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
6827 int bnum, int have_bnum)
6829 /* The longest string possibly returned by hex_string_custom
6830 is 50 chars. These must be at least that big for safety. */
6834 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
6835 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
6837 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6838 bnum, astr1, astr2);
6840 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
6843 /* Adjust a breakpoint's address to account for architectural
6844 constraints on breakpoint placement. Return the adjusted address.
6845 Note: Very few targets require this kind of adjustment. For most
6846 targets, this function is simply the identity function. */
6849 adjust_breakpoint_address (struct gdbarch *gdbarch,
6850 CORE_ADDR bpaddr, enum bptype bptype)
6852 if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
6854 /* Very few targets need any kind of breakpoint adjustment. */
6857 else if (bptype == bp_watchpoint
6858 || bptype == bp_hardware_watchpoint
6859 || bptype == bp_read_watchpoint
6860 || bptype == bp_access_watchpoint
6861 || bptype == bp_catchpoint)
6863 /* Watchpoints and the various bp_catch_* eventpoints should not
6864 have their addresses modified. */
6869 CORE_ADDR adjusted_bpaddr;
6871 /* Some targets have architectural constraints on the placement
6872 of breakpoint instructions. Obtain the adjusted address. */
6873 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
6875 /* An adjusted breakpoint address can significantly alter
6876 a user's expectations. Print a warning if an adjustment
6878 if (adjusted_bpaddr != bpaddr)
6879 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
6881 return adjusted_bpaddr;
6886 init_bp_location (struct bp_location *loc, const struct bp_location_ops *ops,
6887 struct breakpoint *owner)
6889 memset (loc, 0, sizeof (*loc));
6891 gdb_assert (ops != NULL);
6896 loc->cond_bytecode = NULL;
6897 loc->shlib_disabled = 0;
6900 switch (owner->type)
6906 case bp_longjmp_resume:
6907 case bp_longjmp_call_dummy:
6909 case bp_exception_resume:
6910 case bp_step_resume:
6911 case bp_hp_step_resume:
6912 case bp_watchpoint_scope:
6914 case bp_std_terminate:
6915 case bp_shlib_event:
6916 case bp_thread_event:
6917 case bp_overlay_event:
6919 case bp_longjmp_master:
6920 case bp_std_terminate_master:
6921 case bp_exception_master:
6922 case bp_gnu_ifunc_resolver:
6923 case bp_gnu_ifunc_resolver_return:
6925 loc->loc_type = bp_loc_software_breakpoint;
6926 mark_breakpoint_location_modified (loc);
6928 case bp_hardware_breakpoint:
6929 loc->loc_type = bp_loc_hardware_breakpoint;
6930 mark_breakpoint_location_modified (loc);
6932 case bp_hardware_watchpoint:
6933 case bp_read_watchpoint:
6934 case bp_access_watchpoint:
6935 loc->loc_type = bp_loc_hardware_watchpoint;
6940 case bp_fast_tracepoint:
6941 case bp_static_tracepoint:
6942 loc->loc_type = bp_loc_other;
6945 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
6951 /* Allocate a struct bp_location. */
6953 static struct bp_location *
6954 allocate_bp_location (struct breakpoint *bpt)
6956 return bpt->ops->allocate_location (bpt);
6960 free_bp_location (struct bp_location *loc)
6962 loc->ops->dtor (loc);
6966 /* Increment reference count. */
6969 incref_bp_location (struct bp_location *bl)
6974 /* Decrement reference count. If the reference count reaches 0,
6975 destroy the bp_location. Sets *BLP to NULL. */
6978 decref_bp_location (struct bp_location **blp)
6980 gdb_assert ((*blp)->refc > 0);
6982 if (--(*blp)->refc == 0)
6983 free_bp_location (*blp);
6987 /* Add breakpoint B at the end of the global breakpoint chain. */
6990 add_to_breakpoint_chain (struct breakpoint *b)
6992 struct breakpoint *b1;
6994 /* Add this breakpoint to the end of the chain so that a list of
6995 breakpoints will come out in order of increasing numbers. */
6997 b1 = breakpoint_chain;
6999 breakpoint_chain = b;
7008 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7011 init_raw_breakpoint_without_location (struct breakpoint *b,
7012 struct gdbarch *gdbarch,
7014 const struct breakpoint_ops *ops)
7016 memset (b, 0, sizeof (*b));
7018 gdb_assert (ops != NULL);
7022 b->gdbarch = gdbarch;
7023 b->language = current_language->la_language;
7024 b->input_radix = input_radix;
7026 b->enable_state = bp_enabled;
7029 b->ignore_count = 0;
7031 b->frame_id = null_frame_id;
7032 b->condition_not_parsed = 0;
7033 b->py_bp_object = NULL;
7034 b->related_breakpoint = b;
7037 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7038 that has type BPTYPE and has no locations as yet. */
7040 static struct breakpoint *
7041 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
7043 const struct breakpoint_ops *ops)
7045 struct breakpoint *b = XNEW (struct breakpoint);
7047 init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
7048 add_to_breakpoint_chain (b);
7052 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7053 resolutions should be made as the user specified the location explicitly
7057 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
7059 gdb_assert (loc->owner != NULL);
7061 if (loc->owner->type == bp_breakpoint
7062 || loc->owner->type == bp_hardware_breakpoint
7063 || is_tracepoint (loc->owner))
7066 const char *function_name;
7067 CORE_ADDR func_addr;
7069 find_pc_partial_function_gnu_ifunc (loc->address, &function_name,
7070 &func_addr, NULL, &is_gnu_ifunc);
7072 if (is_gnu_ifunc && !explicit_loc)
7074 struct breakpoint *b = loc->owner;
7076 gdb_assert (loc->pspace == current_program_space);
7077 if (gnu_ifunc_resolve_name (function_name,
7078 &loc->requested_address))
7080 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7081 loc->address = adjust_breakpoint_address (loc->gdbarch,
7082 loc->requested_address,
7085 else if (b->type == bp_breakpoint && b->loc == loc
7086 && loc->next == NULL && b->related_breakpoint == b)
7088 /* Create only the whole new breakpoint of this type but do not
7089 mess more complicated breakpoints with multiple locations. */
7090 b->type = bp_gnu_ifunc_resolver;
7091 /* Remember the resolver's address for use by the return
7093 loc->related_address = func_addr;
7098 loc->function_name = xstrdup (function_name);
7102 /* Attempt to determine architecture of location identified by SAL. */
7104 get_sal_arch (struct symtab_and_line sal)
7107 return get_objfile_arch (sal.section->objfile);
7109 return get_objfile_arch (sal.symtab->objfile);
7114 /* Low level routine for partially initializing a breakpoint of type
7115 BPTYPE. The newly created breakpoint's address, section, source
7116 file name, and line number are provided by SAL.
7118 It is expected that the caller will complete the initialization of
7119 the newly created breakpoint struct as well as output any status
7120 information regarding the creation of a new breakpoint. */
7123 init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
7124 struct symtab_and_line sal, enum bptype bptype,
7125 const struct breakpoint_ops *ops)
7127 init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
7129 add_location_to_breakpoint (b, &sal);
7131 if (bptype != bp_catchpoint)
7132 gdb_assert (sal.pspace != NULL);
7134 /* Store the program space that was used to set the breakpoint,
7135 except for ordinary breakpoints, which are independent of the
7137 if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
7138 b->pspace = sal.pspace;
7141 /* set_raw_breakpoint is a low level routine for allocating and
7142 partially initializing a breakpoint of type BPTYPE. The newly
7143 created breakpoint's address, section, source file name, and line
7144 number are provided by SAL. The newly created and partially
7145 initialized breakpoint is added to the breakpoint chain and
7146 is also returned as the value of this function.
7148 It is expected that the caller will complete the initialization of
7149 the newly created breakpoint struct as well as output any status
7150 information regarding the creation of a new breakpoint. In
7151 particular, set_raw_breakpoint does NOT set the breakpoint
7152 number! Care should be taken to not allow an error to occur
7153 prior to completing the initialization of the breakpoint. If this
7154 should happen, a bogus breakpoint will be left on the chain. */
7157 set_raw_breakpoint (struct gdbarch *gdbarch,
7158 struct symtab_and_line sal, enum bptype bptype,
7159 const struct breakpoint_ops *ops)
7161 struct breakpoint *b = XNEW (struct breakpoint);
7163 init_raw_breakpoint (b, gdbarch, sal, bptype, ops);
7164 add_to_breakpoint_chain (b);
7169 /* Note that the breakpoint object B describes a permanent breakpoint
7170 instruction, hard-wired into the inferior's code. */
7172 make_breakpoint_permanent (struct breakpoint *b)
7174 struct bp_location *bl;
7176 b->enable_state = bp_permanent;
7178 /* By definition, permanent breakpoints are already present in the
7179 code. Mark all locations as inserted. For now,
7180 make_breakpoint_permanent is called in just one place, so it's
7181 hard to say if it's reasonable to have permanent breakpoint with
7182 multiple locations or not, but it's easy to implement. */
7183 for (bl = b->loc; bl; bl = bl->next)
7187 /* Call this routine when stepping and nexting to enable a breakpoint
7188 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7189 initiated the operation. */
7192 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
7194 struct breakpoint *b, *b_tmp;
7195 int thread = tp->num;
7197 /* To avoid having to rescan all objfile symbols at every step,
7198 we maintain a list of continually-inserted but always disabled
7199 longjmp "master" breakpoints. Here, we simply create momentary
7200 clones of those and enable them for the requested thread. */
7201 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7202 if (b->pspace == current_program_space
7203 && (b->type == bp_longjmp_master
7204 || b->type == bp_exception_master))
7206 enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7207 struct breakpoint *clone;
7209 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7210 after their removal. */
7211 clone = momentary_breakpoint_from_master (b, type,
7212 &longjmp_breakpoint_ops);
7213 clone->thread = thread;
7216 tp->initiating_frame = frame;
7219 /* Delete all longjmp breakpoints from THREAD. */
7221 delete_longjmp_breakpoint (int thread)
7223 struct breakpoint *b, *b_tmp;
7225 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7226 if (b->type == bp_longjmp || b->type == bp_exception)
7228 if (b->thread == thread)
7229 delete_breakpoint (b);
7234 delete_longjmp_breakpoint_at_next_stop (int thread)
7236 struct breakpoint *b, *b_tmp;
7238 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7239 if (b->type == bp_longjmp || b->type == bp_exception)
7241 if (b->thread == thread)
7242 b->disposition = disp_del_at_next_stop;
7246 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7247 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7248 pointer to any of them. Return NULL if this system cannot place longjmp
7252 set_longjmp_breakpoint_for_call_dummy (void)
7254 struct breakpoint *b, *retval = NULL;
7257 if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7259 struct breakpoint *new_b;
7261 new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
7262 &momentary_breakpoint_ops);
7263 new_b->thread = pid_to_thread_id (inferior_ptid);
7265 /* Link NEW_B into the chain of RETVAL breakpoints. */
7267 gdb_assert (new_b->related_breakpoint == new_b);
7270 new_b->related_breakpoint = retval;
7271 while (retval->related_breakpoint != new_b->related_breakpoint)
7272 retval = retval->related_breakpoint;
7273 retval->related_breakpoint = new_b;
7279 /* Verify all existing dummy frames and their associated breakpoints for
7280 THREAD. Remove those which can no longer be found in the current frame
7283 You should call this function only at places where it is safe to currently
7284 unwind the whole stack. Failed stack unwind would discard live dummy
7288 check_longjmp_breakpoint_for_call_dummy (int thread)
7290 struct breakpoint *b, *b_tmp;
7292 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7293 if (b->type == bp_longjmp_call_dummy && b->thread == thread)
7295 struct breakpoint *dummy_b = b->related_breakpoint;
7297 while (dummy_b != b && dummy_b->type != bp_call_dummy)
7298 dummy_b = dummy_b->related_breakpoint;
7299 if (dummy_b->type != bp_call_dummy
7300 || frame_find_by_id (dummy_b->frame_id) != NULL)
7303 dummy_frame_discard (dummy_b->frame_id);
7305 while (b->related_breakpoint != b)
7307 if (b_tmp == b->related_breakpoint)
7308 b_tmp = b->related_breakpoint->next;
7309 delete_breakpoint (b->related_breakpoint);
7311 delete_breakpoint (b);
7316 enable_overlay_breakpoints (void)
7318 struct breakpoint *b;
7321 if (b->type == bp_overlay_event)
7323 b->enable_state = bp_enabled;
7324 update_global_location_list (1);
7325 overlay_events_enabled = 1;
7330 disable_overlay_breakpoints (void)
7332 struct breakpoint *b;
7335 if (b->type == bp_overlay_event)
7337 b->enable_state = bp_disabled;
7338 update_global_location_list (0);
7339 overlay_events_enabled = 0;
7343 /* Set an active std::terminate breakpoint for each std::terminate
7344 master breakpoint. */
7346 set_std_terminate_breakpoint (void)
7348 struct breakpoint *b, *b_tmp;
7350 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7351 if (b->pspace == current_program_space
7352 && b->type == bp_std_terminate_master)
7354 momentary_breakpoint_from_master (b, bp_std_terminate,
7355 &momentary_breakpoint_ops);
7359 /* Delete all the std::terminate breakpoints. */
7361 delete_std_terminate_breakpoint (void)
7363 struct breakpoint *b, *b_tmp;
7365 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7366 if (b->type == bp_std_terminate)
7367 delete_breakpoint (b);
7371 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7373 struct breakpoint *b;
7375 b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7376 &internal_breakpoint_ops);
7378 b->enable_state = bp_enabled;
7379 /* addr_string has to be used or breakpoint_re_set will delete me. */
7381 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
7383 update_global_location_list_nothrow (1);
7389 remove_thread_event_breakpoints (void)
7391 struct breakpoint *b, *b_tmp;
7393 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7394 if (b->type == bp_thread_event
7395 && b->loc->pspace == current_program_space)
7396 delete_breakpoint (b);
7399 struct lang_and_radix
7405 /* Create a breakpoint for JIT code registration and unregistration. */
7408 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7410 struct breakpoint *b;
7412 b = create_internal_breakpoint (gdbarch, address, bp_jit_event,
7413 &internal_breakpoint_ops);
7414 update_global_location_list_nothrow (1);
7418 /* Remove JIT code registration and unregistration breakpoint(s). */
7421 remove_jit_event_breakpoints (void)
7423 struct breakpoint *b, *b_tmp;
7425 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7426 if (b->type == bp_jit_event
7427 && b->loc->pspace == current_program_space)
7428 delete_breakpoint (b);
7432 remove_solib_event_breakpoints (void)
7434 struct breakpoint *b, *b_tmp;
7436 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7437 if (b->type == bp_shlib_event
7438 && b->loc->pspace == current_program_space)
7439 delete_breakpoint (b);
7443 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7445 struct breakpoint *b;
7447 b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7448 &internal_breakpoint_ops);
7449 update_global_location_list_nothrow (1);
7453 /* Disable any breakpoints that are on code in shared libraries. Only
7454 apply to enabled breakpoints, disabled ones can just stay disabled. */
7457 disable_breakpoints_in_shlibs (void)
7459 struct bp_location *loc, **locp_tmp;
7461 ALL_BP_LOCATIONS (loc, locp_tmp)
7463 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7464 struct breakpoint *b = loc->owner;
7466 /* We apply the check to all breakpoints, including disabled for
7467 those with loc->duplicate set. This is so that when breakpoint
7468 becomes enabled, or the duplicate is removed, gdb will try to
7469 insert all breakpoints. If we don't set shlib_disabled here,
7470 we'll try to insert those breakpoints and fail. */
7471 if (((b->type == bp_breakpoint)
7472 || (b->type == bp_jit_event)
7473 || (b->type == bp_hardware_breakpoint)
7474 || (is_tracepoint (b)))
7475 && loc->pspace == current_program_space
7476 && !loc->shlib_disabled
7477 && solib_name_from_address (loc->pspace, loc->address)
7480 loc->shlib_disabled = 1;
7485 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7486 notification of unloaded_shlib. Only apply to enabled breakpoints,
7487 disabled ones can just stay disabled. */
7490 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7492 struct bp_location *loc, **locp_tmp;
7493 int disabled_shlib_breaks = 0;
7495 /* SunOS a.out shared libraries are always mapped, so do not
7496 disable breakpoints; they will only be reported as unloaded
7497 through clear_solib when GDB discards its shared library
7498 list. See clear_solib for more information. */
7499 if (exec_bfd != NULL
7500 && bfd_get_flavour (exec_bfd) == bfd_target_aout_flavour)
7503 ALL_BP_LOCATIONS (loc, locp_tmp)
7505 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7506 struct breakpoint *b = loc->owner;
7508 if (solib->pspace == loc->pspace
7509 && !loc->shlib_disabled
7510 && (((b->type == bp_breakpoint
7511 || b->type == bp_jit_event
7512 || b->type == bp_hardware_breakpoint)
7513 && (loc->loc_type == bp_loc_hardware_breakpoint
7514 || loc->loc_type == bp_loc_software_breakpoint))
7515 || is_tracepoint (b))
7516 && solib_contains_address_p (solib, loc->address))
7518 loc->shlib_disabled = 1;
7519 /* At this point, we cannot rely on remove_breakpoint
7520 succeeding so we must mark the breakpoint as not inserted
7521 to prevent future errors occurring in remove_breakpoints. */
7524 /* This may cause duplicate notifications for the same breakpoint. */
7525 observer_notify_breakpoint_modified (b);
7527 if (!disabled_shlib_breaks)
7529 target_terminal_ours_for_output ();
7530 warning (_("Temporarily disabling breakpoints "
7531 "for unloaded shared library \"%s\""),
7534 disabled_shlib_breaks = 1;
7539 /* Disable any breakpoints and tracepoints in OBJFILE upon
7540 notification of free_objfile. Only apply to enabled breakpoints,
7541 disabled ones can just stay disabled. */
7544 disable_breakpoints_in_freed_objfile (struct objfile *objfile)
7546 struct breakpoint *b;
7548 if (objfile == NULL)
7551 /* If the file is a shared library not loaded by the user then
7552 solib_unloaded was notified and disable_breakpoints_in_unloaded_shlib
7553 was called. In that case there is no need to take action again. */
7554 if ((objfile->flags & OBJF_SHARED) && !(objfile->flags & OBJF_USERLOADED))
7559 struct bp_location *loc;
7560 int bp_modified = 0;
7562 if (!is_breakpoint (b) && !is_tracepoint (b))
7565 for (loc = b->loc; loc != NULL; loc = loc->next)
7567 CORE_ADDR loc_addr = loc->address;
7569 if (loc->loc_type != bp_loc_hardware_breakpoint
7570 && loc->loc_type != bp_loc_software_breakpoint)
7573 if (loc->shlib_disabled != 0)
7576 if (objfile->pspace != loc->pspace)
7579 if (loc->loc_type != bp_loc_hardware_breakpoint
7580 && loc->loc_type != bp_loc_software_breakpoint)
7583 if (is_addr_in_objfile (loc_addr, objfile))
7585 loc->shlib_disabled = 1;
7588 mark_breakpoint_location_modified (loc);
7595 observer_notify_breakpoint_modified (b);
7599 /* FORK & VFORK catchpoints. */
7601 /* An instance of this type is used to represent a fork or vfork
7602 catchpoint. It includes a "struct breakpoint" as a kind of base
7603 class; users downcast to "struct breakpoint *" when needed. A
7604 breakpoint is really of this type iff its ops pointer points to
7605 CATCH_FORK_BREAKPOINT_OPS. */
7607 struct fork_catchpoint
7609 /* The base class. */
7610 struct breakpoint base;
7612 /* Process id of a child process whose forking triggered this
7613 catchpoint. This field is only valid immediately after this
7614 catchpoint has triggered. */
7615 ptid_t forked_inferior_pid;
7618 /* Implement the "insert" breakpoint_ops method for fork
7622 insert_catch_fork (struct bp_location *bl)
7624 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid));
7627 /* Implement the "remove" breakpoint_ops method for fork
7631 remove_catch_fork (struct bp_location *bl)
7633 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid));
7636 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7640 breakpoint_hit_catch_fork (const struct bp_location *bl,
7641 struct address_space *aspace, CORE_ADDR bp_addr,
7642 const struct target_waitstatus *ws)
7644 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7646 if (ws->kind != TARGET_WAITKIND_FORKED)
7649 c->forked_inferior_pid = ws->value.related_pid;
7653 /* Implement the "print_it" breakpoint_ops method for fork
7656 static enum print_stop_action
7657 print_it_catch_fork (bpstat bs)
7659 struct ui_out *uiout = current_uiout;
7660 struct breakpoint *b = bs->breakpoint_at;
7661 struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
7663 annotate_catchpoint (b->number);
7664 if (b->disposition == disp_del)
7665 ui_out_text (uiout, "\nTemporary catchpoint ");
7667 ui_out_text (uiout, "\nCatchpoint ");
7668 if (ui_out_is_mi_like_p (uiout))
7670 ui_out_field_string (uiout, "reason",
7671 async_reason_lookup (EXEC_ASYNC_FORK));
7672 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7674 ui_out_field_int (uiout, "bkptno", b->number);
7675 ui_out_text (uiout, " (forked process ");
7676 ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
7677 ui_out_text (uiout, "), ");
7678 return PRINT_SRC_AND_LOC;
7681 /* Implement the "print_one" breakpoint_ops method for fork
7685 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
7687 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7688 struct value_print_options opts;
7689 struct ui_out *uiout = current_uiout;
7691 get_user_print_options (&opts);
7693 /* Field 4, the address, is omitted (which makes the columns not
7694 line up too nicely with the headers, but the effect is relatively
7696 if (opts.addressprint)
7697 ui_out_field_skip (uiout, "addr");
7699 ui_out_text (uiout, "fork");
7700 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7702 ui_out_text (uiout, ", process ");
7703 ui_out_field_int (uiout, "what",
7704 ptid_get_pid (c->forked_inferior_pid));
7705 ui_out_spaces (uiout, 1);
7708 if (ui_out_is_mi_like_p (uiout))
7709 ui_out_field_string (uiout, "catch-type", "fork");
7712 /* Implement the "print_mention" breakpoint_ops method for fork
7716 print_mention_catch_fork (struct breakpoint *b)
7718 printf_filtered (_("Catchpoint %d (fork)"), b->number);
7721 /* Implement the "print_recreate" breakpoint_ops method for fork
7725 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
7727 fprintf_unfiltered (fp, "catch fork");
7728 print_recreate_thread (b, fp);
7731 /* The breakpoint_ops structure to be used in fork catchpoints. */
7733 static struct breakpoint_ops catch_fork_breakpoint_ops;
7735 /* Implement the "insert" breakpoint_ops method for vfork
7739 insert_catch_vfork (struct bp_location *bl)
7741 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid));
7744 /* Implement the "remove" breakpoint_ops method for vfork
7748 remove_catch_vfork (struct bp_location *bl)
7750 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid));
7753 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7757 breakpoint_hit_catch_vfork (const struct bp_location *bl,
7758 struct address_space *aspace, CORE_ADDR bp_addr,
7759 const struct target_waitstatus *ws)
7761 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7763 if (ws->kind != TARGET_WAITKIND_VFORKED)
7766 c->forked_inferior_pid = ws->value.related_pid;
7770 /* Implement the "print_it" breakpoint_ops method for vfork
7773 static enum print_stop_action
7774 print_it_catch_vfork (bpstat bs)
7776 struct ui_out *uiout = current_uiout;
7777 struct breakpoint *b = bs->breakpoint_at;
7778 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7780 annotate_catchpoint (b->number);
7781 if (b->disposition == disp_del)
7782 ui_out_text (uiout, "\nTemporary catchpoint ");
7784 ui_out_text (uiout, "\nCatchpoint ");
7785 if (ui_out_is_mi_like_p (uiout))
7787 ui_out_field_string (uiout, "reason",
7788 async_reason_lookup (EXEC_ASYNC_VFORK));
7789 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7791 ui_out_field_int (uiout, "bkptno", b->number);
7792 ui_out_text (uiout, " (vforked process ");
7793 ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
7794 ui_out_text (uiout, "), ");
7795 return PRINT_SRC_AND_LOC;
7798 /* Implement the "print_one" breakpoint_ops method for vfork
7802 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
7804 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7805 struct value_print_options opts;
7806 struct ui_out *uiout = current_uiout;
7808 get_user_print_options (&opts);
7809 /* Field 4, the address, is omitted (which makes the columns not
7810 line up too nicely with the headers, but the effect is relatively
7812 if (opts.addressprint)
7813 ui_out_field_skip (uiout, "addr");
7815 ui_out_text (uiout, "vfork");
7816 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7818 ui_out_text (uiout, ", process ");
7819 ui_out_field_int (uiout, "what",
7820 ptid_get_pid (c->forked_inferior_pid));
7821 ui_out_spaces (uiout, 1);
7824 if (ui_out_is_mi_like_p (uiout))
7825 ui_out_field_string (uiout, "catch-type", "vfork");
7828 /* Implement the "print_mention" breakpoint_ops method for vfork
7832 print_mention_catch_vfork (struct breakpoint *b)
7834 printf_filtered (_("Catchpoint %d (vfork)"), b->number);
7837 /* Implement the "print_recreate" breakpoint_ops method for vfork
7841 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
7843 fprintf_unfiltered (fp, "catch vfork");
7844 print_recreate_thread (b, fp);
7847 /* The breakpoint_ops structure to be used in vfork catchpoints. */
7849 static struct breakpoint_ops catch_vfork_breakpoint_ops;
7851 /* An instance of this type is used to represent an solib catchpoint.
7852 It includes a "struct breakpoint" as a kind of base class; users
7853 downcast to "struct breakpoint *" when needed. A breakpoint is
7854 really of this type iff its ops pointer points to
7855 CATCH_SOLIB_BREAKPOINT_OPS. */
7857 struct solib_catchpoint
7859 /* The base class. */
7860 struct breakpoint base;
7862 /* True for "catch load", false for "catch unload". */
7863 unsigned char is_load;
7865 /* Regular expression to match, if any. COMPILED is only valid when
7866 REGEX is non-NULL. */
7872 dtor_catch_solib (struct breakpoint *b)
7874 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7877 regfree (&self->compiled);
7878 xfree (self->regex);
7880 base_breakpoint_ops.dtor (b);
7884 insert_catch_solib (struct bp_location *ignore)
7890 remove_catch_solib (struct bp_location *ignore)
7896 breakpoint_hit_catch_solib (const struct bp_location *bl,
7897 struct address_space *aspace,
7899 const struct target_waitstatus *ws)
7901 struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
7902 struct breakpoint *other;
7904 if (ws->kind == TARGET_WAITKIND_LOADED)
7907 ALL_BREAKPOINTS (other)
7909 struct bp_location *other_bl;
7911 if (other == bl->owner)
7914 if (other->type != bp_shlib_event)
7917 if (self->base.pspace != NULL && other->pspace != self->base.pspace)
7920 for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
7922 if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
7931 check_status_catch_solib (struct bpstats *bs)
7933 struct solib_catchpoint *self
7934 = (struct solib_catchpoint *) bs->breakpoint_at;
7939 struct so_list *iter;
7942 VEC_iterate (so_list_ptr, current_program_space->added_solibs,
7947 || regexec (&self->compiled, iter->so_name, 0, NULL, 0) == 0)
7956 VEC_iterate (char_ptr, current_program_space->deleted_solibs,
7961 || regexec (&self->compiled, iter, 0, NULL, 0) == 0)
7967 bs->print_it = print_it_noop;
7970 static enum print_stop_action
7971 print_it_catch_solib (bpstat bs)
7973 struct breakpoint *b = bs->breakpoint_at;
7974 struct ui_out *uiout = current_uiout;
7976 annotate_catchpoint (b->number);
7977 if (b->disposition == disp_del)
7978 ui_out_text (uiout, "\nTemporary catchpoint ");
7980 ui_out_text (uiout, "\nCatchpoint ");
7981 ui_out_field_int (uiout, "bkptno", b->number);
7982 ui_out_text (uiout, "\n");
7983 if (ui_out_is_mi_like_p (uiout))
7984 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7985 print_solib_event (1);
7986 return PRINT_SRC_AND_LOC;
7990 print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
7992 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7993 struct value_print_options opts;
7994 struct ui_out *uiout = current_uiout;
7997 get_user_print_options (&opts);
7998 /* Field 4, the address, is omitted (which makes the columns not
7999 line up too nicely with the headers, but the effect is relatively
8001 if (opts.addressprint)
8004 ui_out_field_skip (uiout, "addr");
8011 msg = xstrprintf (_("load of library matching %s"), self->regex);
8013 msg = xstrdup (_("load of library"));
8018 msg = xstrprintf (_("unload of library matching %s"), self->regex);
8020 msg = xstrdup (_("unload of library"));
8022 ui_out_field_string (uiout, "what", msg);
8025 if (ui_out_is_mi_like_p (uiout))
8026 ui_out_field_string (uiout, "catch-type",
8027 self->is_load ? "load" : "unload");
8031 print_mention_catch_solib (struct breakpoint *b)
8033 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8035 printf_filtered (_("Catchpoint %d (%s)"), b->number,
8036 self->is_load ? "load" : "unload");
8040 print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
8042 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8044 fprintf_unfiltered (fp, "%s %s",
8045 b->disposition == disp_del ? "tcatch" : "catch",
8046 self->is_load ? "load" : "unload");
8048 fprintf_unfiltered (fp, " %s", self->regex);
8049 fprintf_unfiltered (fp, "\n");
8052 static struct breakpoint_ops catch_solib_breakpoint_ops;
8054 /* Shared helper function (MI and CLI) for creating and installing
8055 a shared object event catchpoint. If IS_LOAD is non-zero then
8056 the events to be caught are load events, otherwise they are
8057 unload events. If IS_TEMP is non-zero the catchpoint is a
8058 temporary one. If ENABLED is non-zero the catchpoint is
8059 created in an enabled state. */
8062 add_solib_catchpoint (char *arg, int is_load, int is_temp, int enabled)
8064 struct solib_catchpoint *c;
8065 struct gdbarch *gdbarch = get_current_arch ();
8066 struct cleanup *cleanup;
8070 arg = skip_spaces (arg);
8072 c = XCNEW (struct solib_catchpoint);
8073 cleanup = make_cleanup (xfree, c);
8079 errcode = regcomp (&c->compiled, arg, REG_NOSUB);
8082 char *err = get_regcomp_error (errcode, &c->compiled);
8084 make_cleanup (xfree, err);
8085 error (_("Invalid regexp (%s): %s"), err, arg);
8087 c->regex = xstrdup (arg);
8090 c->is_load = is_load;
8091 init_catchpoint (&c->base, gdbarch, is_temp, NULL,
8092 &catch_solib_breakpoint_ops);
8094 c->base.enable_state = enabled ? bp_enabled : bp_disabled;
8096 discard_cleanups (cleanup);
8097 install_breakpoint (0, &c->base, 1);
8100 /* A helper function that does all the work for "catch load" and
8104 catch_load_or_unload (char *arg, int from_tty, int is_load,
8105 struct cmd_list_element *command)
8108 const int enabled = 1;
8110 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8112 add_solib_catchpoint (arg, is_load, tempflag, enabled);
8116 catch_load_command_1 (char *arg, int from_tty,
8117 struct cmd_list_element *command)
8119 catch_load_or_unload (arg, from_tty, 1, command);
8123 catch_unload_command_1 (char *arg, int from_tty,
8124 struct cmd_list_element *command)
8126 catch_load_or_unload (arg, from_tty, 0, command);
8129 /* An instance of this type is used to represent a syscall catchpoint.
8130 It includes a "struct breakpoint" as a kind of base class; users
8131 downcast to "struct breakpoint *" when needed. A breakpoint is
8132 really of this type iff its ops pointer points to
8133 CATCH_SYSCALL_BREAKPOINT_OPS. */
8135 struct syscall_catchpoint
8137 /* The base class. */
8138 struct breakpoint base;
8140 /* Syscall numbers used for the 'catch syscall' feature. If no
8141 syscall has been specified for filtering, its value is NULL.
8142 Otherwise, it holds a list of all syscalls to be caught. The
8143 list elements are allocated with xmalloc. */
8144 VEC(int) *syscalls_to_be_caught;
8147 /* Implement the "dtor" breakpoint_ops method for syscall
8151 dtor_catch_syscall (struct breakpoint *b)
8153 struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8155 VEC_free (int, c->syscalls_to_be_caught);
8157 base_breakpoint_ops.dtor (b);
8160 static const struct inferior_data *catch_syscall_inferior_data = NULL;
8162 struct catch_syscall_inferior_data
8164 /* We keep a count of the number of times the user has requested a
8165 particular syscall to be tracked, and pass this information to the
8166 target. This lets capable targets implement filtering directly. */
8168 /* Number of times that "any" syscall is requested. */
8169 int any_syscall_count;
8171 /* Count of each system call. */
8172 VEC(int) *syscalls_counts;
8174 /* This counts all syscall catch requests, so we can readily determine
8175 if any catching is necessary. */
8176 int total_syscalls_count;
8179 static struct catch_syscall_inferior_data*
8180 get_catch_syscall_inferior_data (struct inferior *inf)
8182 struct catch_syscall_inferior_data *inf_data;
8184 inf_data = inferior_data (inf, catch_syscall_inferior_data);
8185 if (inf_data == NULL)
8187 inf_data = XZALLOC (struct catch_syscall_inferior_data);
8188 set_inferior_data (inf, catch_syscall_inferior_data, inf_data);
8195 catch_syscall_inferior_data_cleanup (struct inferior *inf, void *arg)
8201 /* Implement the "insert" breakpoint_ops method for syscall
8205 insert_catch_syscall (struct bp_location *bl)
8207 struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
8208 struct inferior *inf = current_inferior ();
8209 struct catch_syscall_inferior_data *inf_data
8210 = get_catch_syscall_inferior_data (inf);
8212 ++inf_data->total_syscalls_count;
8213 if (!c->syscalls_to_be_caught)
8214 ++inf_data->any_syscall_count;
8220 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8225 if (iter >= VEC_length (int, inf_data->syscalls_counts))
8227 int old_size = VEC_length (int, inf_data->syscalls_counts);
8228 uintptr_t vec_addr_offset
8229 = old_size * ((uintptr_t) sizeof (int));
8231 VEC_safe_grow (int, inf_data->syscalls_counts, iter + 1);
8232 vec_addr = ((uintptr_t) VEC_address (int,
8233 inf_data->syscalls_counts)
8235 memset ((void *) vec_addr, 0,
8236 (iter + 1 - old_size) * sizeof (int));
8238 elem = VEC_index (int, inf_data->syscalls_counts, iter);
8239 VEC_replace (int, inf_data->syscalls_counts, iter, ++elem);
8243 return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
8244 inf_data->total_syscalls_count != 0,
8245 inf_data->any_syscall_count,
8247 inf_data->syscalls_counts),
8249 inf_data->syscalls_counts));
8252 /* Implement the "remove" breakpoint_ops method for syscall
8256 remove_catch_syscall (struct bp_location *bl)
8258 struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
8259 struct inferior *inf = current_inferior ();
8260 struct catch_syscall_inferior_data *inf_data
8261 = get_catch_syscall_inferior_data (inf);
8263 --inf_data->total_syscalls_count;
8264 if (!c->syscalls_to_be_caught)
8265 --inf_data->any_syscall_count;
8271 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8275 if (iter >= VEC_length (int, inf_data->syscalls_counts))
8276 /* Shouldn't happen. */
8278 elem = VEC_index (int, inf_data->syscalls_counts, iter);
8279 VEC_replace (int, inf_data->syscalls_counts, iter, --elem);
8283 return target_set_syscall_catchpoint (ptid_get_pid (inferior_ptid),
8284 inf_data->total_syscalls_count != 0,
8285 inf_data->any_syscall_count,
8287 inf_data->syscalls_counts),
8289 inf_data->syscalls_counts));
8292 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
8296 breakpoint_hit_catch_syscall (const struct bp_location *bl,
8297 struct address_space *aspace, CORE_ADDR bp_addr,
8298 const struct target_waitstatus *ws)
8300 /* We must check if we are catching specific syscalls in this
8301 breakpoint. If we are, then we must guarantee that the called
8302 syscall is the same syscall we are catching. */
8303 int syscall_number = 0;
8304 const struct syscall_catchpoint *c
8305 = (const struct syscall_catchpoint *) bl->owner;
8307 if (ws->kind != TARGET_WAITKIND_SYSCALL_ENTRY
8308 && ws->kind != TARGET_WAITKIND_SYSCALL_RETURN)
8311 syscall_number = ws->value.syscall_number;
8313 /* Now, checking if the syscall is the same. */
8314 if (c->syscalls_to_be_caught)
8319 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8321 if (syscall_number == iter)
8331 /* Implement the "print_it" breakpoint_ops method for syscall
8334 static enum print_stop_action
8335 print_it_catch_syscall (bpstat bs)
8337 struct ui_out *uiout = current_uiout;
8338 struct breakpoint *b = bs->breakpoint_at;
8339 /* These are needed because we want to know in which state a
8340 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
8341 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
8342 must print "called syscall" or "returned from syscall". */
8344 struct target_waitstatus last;
8347 get_last_target_status (&ptid, &last);
8349 get_syscall_by_number (last.value.syscall_number, &s);
8351 annotate_catchpoint (b->number);
8353 if (b->disposition == disp_del)
8354 ui_out_text (uiout, "\nTemporary catchpoint ");
8356 ui_out_text (uiout, "\nCatchpoint ");
8357 if (ui_out_is_mi_like_p (uiout))
8359 ui_out_field_string (uiout, "reason",
8360 async_reason_lookup (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY
8361 ? EXEC_ASYNC_SYSCALL_ENTRY
8362 : EXEC_ASYNC_SYSCALL_RETURN));
8363 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8365 ui_out_field_int (uiout, "bkptno", b->number);
8367 if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
8368 ui_out_text (uiout, " (call to syscall ");
8370 ui_out_text (uiout, " (returned from syscall ");
8372 if (s.name == NULL || ui_out_is_mi_like_p (uiout))
8373 ui_out_field_int (uiout, "syscall-number", last.value.syscall_number);
8375 ui_out_field_string (uiout, "syscall-name", s.name);
8377 ui_out_text (uiout, "), ");
8379 return PRINT_SRC_AND_LOC;
8382 /* Implement the "print_one" breakpoint_ops method for syscall
8386 print_one_catch_syscall (struct breakpoint *b,
8387 struct bp_location **last_loc)
8389 struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8390 struct value_print_options opts;
8391 struct ui_out *uiout = current_uiout;
8393 get_user_print_options (&opts);
8394 /* Field 4, the address, is omitted (which makes the columns not
8395 line up too nicely with the headers, but the effect is relatively
8397 if (opts.addressprint)
8398 ui_out_field_skip (uiout, "addr");
8401 if (c->syscalls_to_be_caught
8402 && VEC_length (int, c->syscalls_to_be_caught) > 1)
8403 ui_out_text (uiout, "syscalls \"");
8405 ui_out_text (uiout, "syscall \"");
8407 if (c->syscalls_to_be_caught)
8410 char *text = xstrprintf ("%s", "");
8413 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8418 get_syscall_by_number (iter, &s);
8421 text = xstrprintf ("%s%s, ", text, s.name);
8423 text = xstrprintf ("%s%d, ", text, iter);
8425 /* We have to xfree the last 'text' (now stored at 'x')
8426 because xstrprintf dynamically allocates new space for it
8430 /* Remove the last comma. */
8431 text[strlen (text) - 2] = '\0';
8432 ui_out_field_string (uiout, "what", text);
8435 ui_out_field_string (uiout, "what", "<any syscall>");
8436 ui_out_text (uiout, "\" ");
8438 if (ui_out_is_mi_like_p (uiout))
8439 ui_out_field_string (uiout, "catch-type", "syscall");
8442 /* Implement the "print_mention" breakpoint_ops method for syscall
8446 print_mention_catch_syscall (struct breakpoint *b)
8448 struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8450 if (c->syscalls_to_be_caught)
8454 if (VEC_length (int, c->syscalls_to_be_caught) > 1)
8455 printf_filtered (_("Catchpoint %d (syscalls"), b->number);
8457 printf_filtered (_("Catchpoint %d (syscall"), b->number);
8460 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8464 get_syscall_by_number (iter, &s);
8467 printf_filtered (" '%s' [%d]", s.name, s.number);
8469 printf_filtered (" %d", s.number);
8471 printf_filtered (")");
8474 printf_filtered (_("Catchpoint %d (any syscall)"),
8478 /* Implement the "print_recreate" breakpoint_ops method for syscall
8482 print_recreate_catch_syscall (struct breakpoint *b, struct ui_file *fp)
8484 struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8486 fprintf_unfiltered (fp, "catch syscall");
8488 if (c->syscalls_to_be_caught)
8493 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8498 get_syscall_by_number (iter, &s);
8500 fprintf_unfiltered (fp, " %s", s.name);
8502 fprintf_unfiltered (fp, " %d", s.number);
8505 print_recreate_thread (b, fp);
8508 /* The breakpoint_ops structure to be used in syscall catchpoints. */
8510 static struct breakpoint_ops catch_syscall_breakpoint_ops;
8512 /* Returns non-zero if 'b' is a syscall catchpoint. */
8515 syscall_catchpoint_p (struct breakpoint *b)
8517 return (b->ops == &catch_syscall_breakpoint_ops);
8520 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8521 is non-zero, then make the breakpoint temporary. If COND_STRING is
8522 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8523 the breakpoint_ops structure associated to the catchpoint. */
8526 init_catchpoint (struct breakpoint *b,
8527 struct gdbarch *gdbarch, int tempflag,
8529 const struct breakpoint_ops *ops)
8531 struct symtab_and_line sal;
8534 sal.pspace = current_program_space;
8536 init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
8538 b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
8539 b->disposition = tempflag ? disp_del : disp_donttouch;
8543 install_breakpoint (int internal, struct breakpoint *b, int update_gll)
8545 add_to_breakpoint_chain (b);
8546 set_breakpoint_number (internal, b);
8547 if (is_tracepoint (b))
8548 set_tracepoint_count (breakpoint_count);
8551 observer_notify_breakpoint_created (b);
8554 update_global_location_list (1);
8558 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
8559 int tempflag, char *cond_string,
8560 const struct breakpoint_ops *ops)
8562 struct fork_catchpoint *c = XNEW (struct fork_catchpoint);
8564 init_catchpoint (&c->base, gdbarch, tempflag, cond_string, ops);
8566 c->forked_inferior_pid = null_ptid;
8568 install_breakpoint (0, &c->base, 1);
8571 /* Exec catchpoints. */
8573 /* An instance of this type is used to represent an exec catchpoint.
8574 It includes a "struct breakpoint" as a kind of base class; users
8575 downcast to "struct breakpoint *" when needed. A breakpoint is
8576 really of this type iff its ops pointer points to
8577 CATCH_EXEC_BREAKPOINT_OPS. */
8579 struct exec_catchpoint
8581 /* The base class. */
8582 struct breakpoint base;
8584 /* Filename of a program whose exec triggered this catchpoint.
8585 This field is only valid immediately after this catchpoint has
8587 char *exec_pathname;
8590 /* Implement the "dtor" breakpoint_ops method for exec
8594 dtor_catch_exec (struct breakpoint *b)
8596 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8598 xfree (c->exec_pathname);
8600 base_breakpoint_ops.dtor (b);
8604 insert_catch_exec (struct bp_location *bl)
8606 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid));
8610 remove_catch_exec (struct bp_location *bl)
8612 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid));
8616 breakpoint_hit_catch_exec (const struct bp_location *bl,
8617 struct address_space *aspace, CORE_ADDR bp_addr,
8618 const struct target_waitstatus *ws)
8620 struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8622 if (ws->kind != TARGET_WAITKIND_EXECD)
8625 c->exec_pathname = xstrdup (ws->value.execd_pathname);
8629 static enum print_stop_action
8630 print_it_catch_exec (bpstat bs)
8632 struct ui_out *uiout = current_uiout;
8633 struct breakpoint *b = bs->breakpoint_at;
8634 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8636 annotate_catchpoint (b->number);
8637 if (b->disposition == disp_del)
8638 ui_out_text (uiout, "\nTemporary catchpoint ");
8640 ui_out_text (uiout, "\nCatchpoint ");
8641 if (ui_out_is_mi_like_p (uiout))
8643 ui_out_field_string (uiout, "reason",
8644 async_reason_lookup (EXEC_ASYNC_EXEC));
8645 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8647 ui_out_field_int (uiout, "bkptno", b->number);
8648 ui_out_text (uiout, " (exec'd ");
8649 ui_out_field_string (uiout, "new-exec", c->exec_pathname);
8650 ui_out_text (uiout, "), ");
8652 return PRINT_SRC_AND_LOC;
8656 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
8658 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8659 struct value_print_options opts;
8660 struct ui_out *uiout = current_uiout;
8662 get_user_print_options (&opts);
8664 /* Field 4, the address, is omitted (which makes the columns
8665 not line up too nicely with the headers, but the effect
8666 is relatively readable). */
8667 if (opts.addressprint)
8668 ui_out_field_skip (uiout, "addr");
8670 ui_out_text (uiout, "exec");
8671 if (c->exec_pathname != NULL)
8673 ui_out_text (uiout, ", program \"");
8674 ui_out_field_string (uiout, "what", c->exec_pathname);
8675 ui_out_text (uiout, "\" ");
8678 if (ui_out_is_mi_like_p (uiout))
8679 ui_out_field_string (uiout, "catch-type", "exec");
8683 print_mention_catch_exec (struct breakpoint *b)
8685 printf_filtered (_("Catchpoint %d (exec)"), b->number);
8688 /* Implement the "print_recreate" breakpoint_ops method for exec
8692 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8694 fprintf_unfiltered (fp, "catch exec");
8695 print_recreate_thread (b, fp);
8698 static struct breakpoint_ops catch_exec_breakpoint_ops;
8701 create_syscall_event_catchpoint (int tempflag, VEC(int) *filter,
8702 const struct breakpoint_ops *ops)
8704 struct syscall_catchpoint *c;
8705 struct gdbarch *gdbarch = get_current_arch ();
8707 c = XNEW (struct syscall_catchpoint);
8708 init_catchpoint (&c->base, gdbarch, tempflag, NULL, ops);
8709 c->syscalls_to_be_caught = filter;
8711 install_breakpoint (0, &c->base, 1);
8715 hw_breakpoint_used_count (void)
8718 struct breakpoint *b;
8719 struct bp_location *bl;
8723 if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
8724 for (bl = b->loc; bl; bl = bl->next)
8726 /* Special types of hardware breakpoints may use more than
8728 i += b->ops->resources_needed (bl);
8735 /* Returns the resources B would use if it were a hardware
8739 hw_watchpoint_use_count (struct breakpoint *b)
8742 struct bp_location *bl;
8744 if (!breakpoint_enabled (b))
8747 for (bl = b->loc; bl; bl = bl->next)
8749 /* Special types of hardware watchpoints may use more than
8751 i += b->ops->resources_needed (bl);
8757 /* Returns the sum the used resources of all hardware watchpoints of
8758 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8759 the sum of the used resources of all hardware watchpoints of other
8760 types _not_ TYPE. */
8763 hw_watchpoint_used_count_others (struct breakpoint *except,
8764 enum bptype type, int *other_type_used)
8767 struct breakpoint *b;
8769 *other_type_used = 0;
8774 if (!breakpoint_enabled (b))
8777 if (b->type == type)
8778 i += hw_watchpoint_use_count (b);
8779 else if (is_hardware_watchpoint (b))
8780 *other_type_used = 1;
8787 disable_watchpoints_before_interactive_call_start (void)
8789 struct breakpoint *b;
8793 if (is_watchpoint (b) && breakpoint_enabled (b))
8795 b->enable_state = bp_call_disabled;
8796 update_global_location_list (0);
8802 enable_watchpoints_after_interactive_call_stop (void)
8804 struct breakpoint *b;
8808 if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
8810 b->enable_state = bp_enabled;
8811 update_global_location_list (1);
8817 disable_breakpoints_before_startup (void)
8819 current_program_space->executing_startup = 1;
8820 update_global_location_list (0);
8824 enable_breakpoints_after_startup (void)
8826 current_program_space->executing_startup = 0;
8827 breakpoint_re_set ();
8831 /* Set a breakpoint that will evaporate an end of command
8832 at address specified by SAL.
8833 Restrict it to frame FRAME if FRAME is nonzero. */
8836 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8837 struct frame_id frame_id, enum bptype type)
8839 struct breakpoint *b;
8841 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8843 gdb_assert (!frame_id_artificial_p (frame_id));
8845 b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
8846 b->enable_state = bp_enabled;
8847 b->disposition = disp_donttouch;
8848 b->frame_id = frame_id;
8850 /* If we're debugging a multi-threaded program, then we want
8851 momentary breakpoints to be active in only a single thread of
8853 if (in_thread_list (inferior_ptid))
8854 b->thread = pid_to_thread_id (inferior_ptid);
8856 update_global_location_list_nothrow (1);
8861 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8862 The new breakpoint will have type TYPE, and use OPS as it
8865 static struct breakpoint *
8866 momentary_breakpoint_from_master (struct breakpoint *orig,
8868 const struct breakpoint_ops *ops)
8870 struct breakpoint *copy;
8872 copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
8873 copy->loc = allocate_bp_location (copy);
8874 set_breakpoint_location_function (copy->loc, 1);
8876 copy->loc->gdbarch = orig->loc->gdbarch;
8877 copy->loc->requested_address = orig->loc->requested_address;
8878 copy->loc->address = orig->loc->address;
8879 copy->loc->section = orig->loc->section;
8880 copy->loc->pspace = orig->loc->pspace;
8881 copy->loc->probe = orig->loc->probe;
8882 copy->loc->line_number = orig->loc->line_number;
8883 copy->loc->symtab = orig->loc->symtab;
8884 copy->frame_id = orig->frame_id;
8885 copy->thread = orig->thread;
8886 copy->pspace = orig->pspace;
8888 copy->enable_state = bp_enabled;
8889 copy->disposition = disp_donttouch;
8890 copy->number = internal_breakpoint_number--;
8892 update_global_location_list_nothrow (0);
8896 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8900 clone_momentary_breakpoint (struct breakpoint *orig)
8902 /* If there's nothing to clone, then return nothing. */
8906 return momentary_breakpoint_from_master (orig, orig->type, orig->ops);
8910 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8913 struct symtab_and_line sal;
8915 sal = find_pc_line (pc, 0);
8917 sal.section = find_pc_overlay (pc);
8918 sal.explicit_pc = 1;
8920 return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
8924 /* Tell the user we have just set a breakpoint B. */
8927 mention (struct breakpoint *b)
8929 b->ops->print_mention (b);
8930 if (ui_out_is_mi_like_p (current_uiout))
8932 printf_filtered ("\n");
8936 static struct bp_location *
8937 add_location_to_breakpoint (struct breakpoint *b,
8938 const struct symtab_and_line *sal)
8940 struct bp_location *loc, **tmp;
8941 CORE_ADDR adjusted_address;
8942 struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
8944 if (loc_gdbarch == NULL)
8945 loc_gdbarch = b->gdbarch;
8947 /* Adjust the breakpoint's address prior to allocating a location.
8948 Once we call allocate_bp_location(), that mostly uninitialized
8949 location will be placed on the location chain. Adjustment of the
8950 breakpoint may cause target_read_memory() to be called and we do
8951 not want its scan of the location chain to find a breakpoint and
8952 location that's only been partially initialized. */
8953 adjusted_address = adjust_breakpoint_address (loc_gdbarch,
8956 /* Sort the locations by their ADDRESS. */
8957 loc = allocate_bp_location (b);
8958 for (tmp = &(b->loc); *tmp != NULL && (*tmp)->address <= adjusted_address;
8959 tmp = &((*tmp)->next))
8964 loc->requested_address = sal->pc;
8965 loc->address = adjusted_address;
8966 loc->pspace = sal->pspace;
8967 loc->probe = sal->probe;
8968 gdb_assert (loc->pspace != NULL);
8969 loc->section = sal->section;
8970 loc->gdbarch = loc_gdbarch;
8971 loc->line_number = sal->line;
8972 loc->symtab = sal->symtab;
8974 set_breakpoint_location_function (loc,
8975 sal->explicit_pc || sal->explicit_line);
8980 /* Return 1 if LOC is pointing to a permanent breakpoint,
8981 return 0 otherwise. */
8984 bp_loc_is_permanent (struct bp_location *loc)
8988 const gdb_byte *bpoint;
8989 gdb_byte *target_mem;
8990 struct cleanup *cleanup;
8993 gdb_assert (loc != NULL);
8995 addr = loc->address;
8996 bpoint = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
8998 /* Software breakpoints unsupported? */
9002 target_mem = alloca (len);
9004 /* Enable the automatic memory restoration from breakpoints while
9005 we read the memory. Otherwise we could say about our temporary
9006 breakpoints they are permanent. */
9007 cleanup = save_current_space_and_thread ();
9009 switch_to_program_space_and_thread (loc->pspace);
9010 make_show_memory_breakpoints_cleanup (0);
9012 if (target_read_memory (loc->address, target_mem, len) == 0
9013 && memcmp (target_mem, bpoint, len) == 0)
9016 do_cleanups (cleanup);
9021 /* Build a command list for the dprintf corresponding to the current
9022 settings of the dprintf style options. */
9025 update_dprintf_command_list (struct breakpoint *b)
9027 char *dprintf_args = b->extra_string;
9028 char *printf_line = NULL;
9033 dprintf_args = skip_spaces (dprintf_args);
9035 /* Allow a comma, as it may have terminated a location, but don't
9037 if (*dprintf_args == ',')
9039 dprintf_args = skip_spaces (dprintf_args);
9041 if (*dprintf_args != '"')
9042 error (_("Bad format string, missing '\"'."));
9044 if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
9045 printf_line = xstrprintf ("printf %s", dprintf_args);
9046 else if (strcmp (dprintf_style, dprintf_style_call) == 0)
9048 if (!dprintf_function)
9049 error (_("No function supplied for dprintf call"));
9051 if (dprintf_channel && strlen (dprintf_channel) > 0)
9052 printf_line = xstrprintf ("call (void) %s (%s,%s)",
9057 printf_line = xstrprintf ("call (void) %s (%s)",
9061 else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
9063 if (target_can_run_breakpoint_commands ())
9064 printf_line = xstrprintf ("agent-printf %s", dprintf_args);
9067 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
9068 printf_line = xstrprintf ("printf %s", dprintf_args);
9072 internal_error (__FILE__, __LINE__,
9073 _("Invalid dprintf style."));
9075 gdb_assert (printf_line != NULL);
9076 /* Manufacture a printf sequence. */
9078 struct command_line *printf_cmd_line
9079 = xmalloc (sizeof (struct command_line));
9081 printf_cmd_line = xmalloc (sizeof (struct command_line));
9082 printf_cmd_line->control_type = simple_control;
9083 printf_cmd_line->body_count = 0;
9084 printf_cmd_line->body_list = NULL;
9085 printf_cmd_line->next = NULL;
9086 printf_cmd_line->line = printf_line;
9088 breakpoint_set_commands (b, printf_cmd_line);
9092 /* Update all dprintf commands, making their command lists reflect
9093 current style settings. */
9096 update_dprintf_commands (char *args, int from_tty,
9097 struct cmd_list_element *c)
9099 struct breakpoint *b;
9103 if (b->type == bp_dprintf)
9104 update_dprintf_command_list (b);
9108 /* Create a breakpoint with SAL as location. Use ADDR_STRING
9109 as textual description of the location, and COND_STRING
9110 as condition expression. */
9113 init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
9114 struct symtabs_and_lines sals, char *addr_string,
9115 char *filter, char *cond_string,
9117 enum bptype type, enum bpdisp disposition,
9118 int thread, int task, int ignore_count,
9119 const struct breakpoint_ops *ops, int from_tty,
9120 int enabled, int internal, unsigned flags,
9121 int display_canonical)
9125 if (type == bp_hardware_breakpoint)
9127 int target_resources_ok;
9129 i = hw_breakpoint_used_count ();
9130 target_resources_ok =
9131 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
9133 if (target_resources_ok == 0)
9134 error (_("No hardware breakpoint support in the target."));
9135 else if (target_resources_ok < 0)
9136 error (_("Hardware breakpoints used exceeds limit."));
9139 gdb_assert (sals.nelts > 0);
9141 for (i = 0; i < sals.nelts; ++i)
9143 struct symtab_and_line sal = sals.sals[i];
9144 struct bp_location *loc;
9148 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
9150 loc_gdbarch = gdbarch;
9152 describe_other_breakpoints (loc_gdbarch,
9153 sal.pspace, sal.pc, sal.section, thread);
9158 init_raw_breakpoint (b, gdbarch, sal, type, ops);
9162 b->cond_string = cond_string;
9163 b->extra_string = extra_string;
9164 b->ignore_count = ignore_count;
9165 b->enable_state = enabled ? bp_enabled : bp_disabled;
9166 b->disposition = disposition;
9168 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
9169 b->loc->inserted = 1;
9171 if (type == bp_static_tracepoint)
9173 struct tracepoint *t = (struct tracepoint *) b;
9174 struct static_tracepoint_marker marker;
9176 if (strace_marker_p (b))
9178 /* We already know the marker exists, otherwise, we
9179 wouldn't see a sal for it. */
9180 char *p = &addr_string[3];
9184 p = skip_spaces (p);
9186 endp = skip_to_space (p);
9188 marker_str = savestring (p, endp - p);
9189 t->static_trace_marker_id = marker_str;
9191 printf_filtered (_("Probed static tracepoint "
9193 t->static_trace_marker_id);
9195 else if (target_static_tracepoint_marker_at (sal.pc, &marker))
9197 t->static_trace_marker_id = xstrdup (marker.str_id);
9198 release_static_tracepoint_marker (&marker);
9200 printf_filtered (_("Probed static tracepoint "
9202 t->static_trace_marker_id);
9205 warning (_("Couldn't determine the static "
9206 "tracepoint marker to probe"));
9213 loc = add_location_to_breakpoint (b, &sal);
9214 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
9218 if (bp_loc_is_permanent (loc))
9219 make_breakpoint_permanent (b);
9223 const char *arg = b->cond_string;
9225 loc->cond = parse_exp_1 (&arg, loc->address,
9226 block_for_pc (loc->address), 0);
9228 error (_("Garbage '%s' follows condition"), arg);
9231 /* Dynamic printf requires and uses additional arguments on the
9232 command line, otherwise it's an error. */
9233 if (type == bp_dprintf)
9235 if (b->extra_string)
9236 update_dprintf_command_list (b);
9238 error (_("Format string required"));
9240 else if (b->extra_string)
9241 error (_("Garbage '%s' at end of command"), b->extra_string);
9244 b->display_canonical = display_canonical;
9246 b->addr_string = addr_string;
9248 /* addr_string has to be used or breakpoint_re_set will delete
9251 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
9256 create_breakpoint_sal (struct gdbarch *gdbarch,
9257 struct symtabs_and_lines sals, char *addr_string,
9258 char *filter, char *cond_string,
9260 enum bptype type, enum bpdisp disposition,
9261 int thread, int task, int ignore_count,
9262 const struct breakpoint_ops *ops, int from_tty,
9263 int enabled, int internal, unsigned flags,
9264 int display_canonical)
9266 struct breakpoint *b;
9267 struct cleanup *old_chain;
9269 if (is_tracepoint_type (type))
9271 struct tracepoint *t;
9273 t = XCNEW (struct tracepoint);
9277 b = XNEW (struct breakpoint);
9279 old_chain = make_cleanup (xfree, b);
9281 init_breakpoint_sal (b, gdbarch,
9283 filter, cond_string, extra_string,
9285 thread, task, ignore_count,
9287 enabled, internal, flags,
9289 discard_cleanups (old_chain);
9291 install_breakpoint (internal, b, 0);
9294 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9295 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9296 value. COND_STRING, if not NULL, specified the condition to be
9297 used for all breakpoints. Essentially the only case where
9298 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9299 function. In that case, it's still not possible to specify
9300 separate conditions for different overloaded functions, so
9301 we take just a single condition string.
9303 NOTE: If the function succeeds, the caller is expected to cleanup
9304 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9305 array contents). If the function fails (error() is called), the
9306 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9307 COND and SALS arrays and each of those arrays contents. */
9310 create_breakpoints_sal (struct gdbarch *gdbarch,
9311 struct linespec_result *canonical,
9312 char *cond_string, char *extra_string,
9313 enum bptype type, enum bpdisp disposition,
9314 int thread, int task, int ignore_count,
9315 const struct breakpoint_ops *ops, int from_tty,
9316 int enabled, int internal, unsigned flags)
9319 struct linespec_sals *lsal;
9321 if (canonical->pre_expanded)
9322 gdb_assert (VEC_length (linespec_sals, canonical->sals) == 1);
9324 for (i = 0; VEC_iterate (linespec_sals, canonical->sals, i, lsal); ++i)
9326 /* Note that 'addr_string' can be NULL in the case of a plain
9327 'break', without arguments. */
9328 char *addr_string = (canonical->addr_string
9329 ? xstrdup (canonical->addr_string)
9331 char *filter_string = lsal->canonical ? xstrdup (lsal->canonical) : NULL;
9332 struct cleanup *inner = make_cleanup (xfree, addr_string);
9334 make_cleanup (xfree, filter_string);
9335 create_breakpoint_sal (gdbarch, lsal->sals,
9338 cond_string, extra_string,
9340 thread, task, ignore_count, ops,
9341 from_tty, enabled, internal, flags,
9342 canonical->special_display);
9343 discard_cleanups (inner);
9347 /* Parse ADDRESS which is assumed to be a SAL specification possibly
9348 followed by conditionals. On return, SALS contains an array of SAL
9349 addresses found. ADDR_STRING contains a vector of (canonical)
9350 address strings. ADDRESS points to the end of the SAL.
9352 The array and the line spec strings are allocated on the heap, it is
9353 the caller's responsibility to free them. */
9356 parse_breakpoint_sals (char **address,
9357 struct linespec_result *canonical)
9359 /* If no arg given, or if first arg is 'if ', use the default
9361 if ((*address) == NULL
9362 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
9364 /* The last displayed codepoint, if it's valid, is our default breakpoint
9366 if (last_displayed_sal_is_valid ())
9368 struct linespec_sals lsal;
9369 struct symtab_and_line sal;
9372 init_sal (&sal); /* Initialize to zeroes. */
9373 lsal.sals.sals = (struct symtab_and_line *)
9374 xmalloc (sizeof (struct symtab_and_line));
9376 /* Set sal's pspace, pc, symtab, and line to the values
9377 corresponding to the last call to print_frame_info.
9378 Be sure to reinitialize LINE with NOTCURRENT == 0
9379 as the breakpoint line number is inappropriate otherwise.
9380 find_pc_line would adjust PC, re-set it back. */
9381 get_last_displayed_sal (&sal);
9383 sal = find_pc_line (pc, 0);
9385 /* "break" without arguments is equivalent to "break *PC"
9386 where PC is the last displayed codepoint's address. So
9387 make sure to set sal.explicit_pc to prevent GDB from
9388 trying to expand the list of sals to include all other
9389 instances with the same symtab and line. */
9391 sal.explicit_pc = 1;
9393 lsal.sals.sals[0] = sal;
9394 lsal.sals.nelts = 1;
9395 lsal.canonical = NULL;
9397 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
9400 error (_("No default breakpoint address now."));
9404 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
9406 /* Force almost all breakpoints to be in terms of the
9407 current_source_symtab (which is decode_line_1's default).
9408 This should produce the results we want almost all of the
9409 time while leaving default_breakpoint_* alone.
9411 ObjC: However, don't match an Objective-C method name which
9412 may have a '+' or '-' succeeded by a '['. */
9413 if (last_displayed_sal_is_valid ()
9415 || ((strchr ("+-", (*address)[0]) != NULL)
9416 && ((*address)[1] != '['))))
9417 decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
9418 get_last_displayed_symtab (),
9419 get_last_displayed_line (),
9420 canonical, NULL, NULL);
9422 decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
9423 cursal.symtab, cursal.line, canonical, NULL, NULL);
9428 /* Convert each SAL into a real PC. Verify that the PC can be
9429 inserted as a breakpoint. If it can't throw an error. */
9432 breakpoint_sals_to_pc (struct symtabs_and_lines *sals)
9436 for (i = 0; i < sals->nelts; i++)
9437 resolve_sal_pc (&sals->sals[i]);
9440 /* Fast tracepoints may have restrictions on valid locations. For
9441 instance, a fast tracepoint using a jump instead of a trap will
9442 likely have to overwrite more bytes than a trap would, and so can
9443 only be placed where the instruction is longer than the jump, or a
9444 multi-instruction sequence does not have a jump into the middle of
9448 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9449 struct symtabs_and_lines *sals)
9452 struct symtab_and_line *sal;
9454 struct cleanup *old_chain;
9456 for (i = 0; i < sals->nelts; i++)
9458 struct gdbarch *sarch;
9460 sal = &sals->sals[i];
9462 sarch = get_sal_arch (*sal);
9463 /* We fall back to GDBARCH if there is no architecture
9464 associated with SAL. */
9467 rslt = gdbarch_fast_tracepoint_valid_at (sarch, sal->pc,
9469 old_chain = make_cleanup (xfree, msg);
9472 error (_("May not have a fast tracepoint at 0x%s%s"),
9473 paddress (sarch, sal->pc), (msg ? msg : ""));
9475 do_cleanups (old_chain);
9479 /* Issue an invalid thread ID error. */
9481 static void ATTRIBUTE_NORETURN
9482 invalid_thread_id_error (int id)
9484 error (_("Unknown thread %d."), id);
9487 /* Given TOK, a string specification of condition and thread, as
9488 accepted by the 'break' command, extract the condition
9489 string and thread number and set *COND_STRING and *THREAD.
9490 PC identifies the context at which the condition should be parsed.
9491 If no condition is found, *COND_STRING is set to NULL.
9492 If no thread is found, *THREAD is set to -1. */
9495 find_condition_and_thread (const char *tok, CORE_ADDR pc,
9496 char **cond_string, int *thread, int *task,
9499 *cond_string = NULL;
9506 const char *end_tok;
9508 const char *cond_start = NULL;
9509 const char *cond_end = NULL;
9511 tok = skip_spaces_const (tok);
9513 if ((*tok == '"' || *tok == ',') && rest)
9515 *rest = savestring (tok, strlen (tok));
9519 end_tok = skip_to_space_const (tok);
9521 toklen = end_tok - tok;
9523 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9525 struct expression *expr;
9527 tok = cond_start = end_tok + 1;
9528 expr = parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
9531 *cond_string = savestring (cond_start, cond_end - cond_start);
9533 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9538 *thread = strtol (tok, &tmptok, 0);
9540 error (_("Junk after thread keyword."));
9541 if (!valid_thread_id (*thread))
9542 invalid_thread_id_error (*thread);
9545 else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9550 *task = strtol (tok, &tmptok, 0);
9552 error (_("Junk after task keyword."));
9553 if (!valid_task_id (*task))
9554 error (_("Unknown task %d."), *task);
9559 *rest = savestring (tok, strlen (tok));
9563 error (_("Junk at end of arguments."));
9567 /* Decode a static tracepoint marker spec. */
9569 static struct symtabs_and_lines
9570 decode_static_tracepoint_spec (char **arg_p)
9572 VEC(static_tracepoint_marker_p) *markers = NULL;
9573 struct symtabs_and_lines sals;
9574 struct cleanup *old_chain;
9575 char *p = &(*arg_p)[3];
9580 p = skip_spaces (p);
9582 endp = skip_to_space (p);
9584 marker_str = savestring (p, endp - p);
9585 old_chain = make_cleanup (xfree, marker_str);
9587 markers = target_static_tracepoint_markers_by_strid (marker_str);
9588 if (VEC_empty(static_tracepoint_marker_p, markers))
9589 error (_("No known static tracepoint marker named %s"), marker_str);
9591 sals.nelts = VEC_length(static_tracepoint_marker_p, markers);
9592 sals.sals = xmalloc (sizeof *sals.sals * sals.nelts);
9594 for (i = 0; i < sals.nelts; i++)
9596 struct static_tracepoint_marker *marker;
9598 marker = VEC_index (static_tracepoint_marker_p, markers, i);
9600 init_sal (&sals.sals[i]);
9602 sals.sals[i] = find_pc_line (marker->address, 0);
9603 sals.sals[i].pc = marker->address;
9605 release_static_tracepoint_marker (marker);
9608 do_cleanups (old_chain);
9614 /* Set a breakpoint. This function is shared between CLI and MI
9615 functions for setting a breakpoint. This function has two major
9616 modes of operations, selected by the PARSE_ARG parameter. If
9617 non-zero, the function will parse ARG, extracting location,
9618 condition, thread and extra string. Otherwise, ARG is just the
9619 breakpoint's location, with condition, thread, and extra string
9620 specified by the COND_STRING, THREAD and EXTRA_STRING parameters.
9621 If INTERNAL is non-zero, the breakpoint number will be allocated
9622 from the internal breakpoint count. Returns true if any breakpoint
9623 was created; false otherwise. */
9626 create_breakpoint (struct gdbarch *gdbarch,
9627 char *arg, char *cond_string,
9628 int thread, char *extra_string,
9630 int tempflag, enum bptype type_wanted,
9632 enum auto_boolean pending_break_support,
9633 const struct breakpoint_ops *ops,
9634 int from_tty, int enabled, int internal,
9637 volatile struct gdb_exception e;
9638 char *copy_arg = NULL;
9639 char *addr_start = arg;
9640 struct linespec_result canonical;
9641 struct cleanup *old_chain;
9642 struct cleanup *bkpt_chain = NULL;
9645 int prev_bkpt_count = breakpoint_count;
9647 gdb_assert (ops != NULL);
9649 init_linespec_result (&canonical);
9651 TRY_CATCH (e, RETURN_MASK_ALL)
9653 ops->create_sals_from_address (&arg, &canonical, type_wanted,
9654 addr_start, ©_arg);
9657 /* If caller is interested in rc value from parse, set value. */
9661 if (VEC_empty (linespec_sals, canonical.sals))
9667 case NOT_FOUND_ERROR:
9669 /* If pending breakpoint support is turned off, throw
9672 if (pending_break_support == AUTO_BOOLEAN_FALSE)
9673 throw_exception (e);
9675 exception_print (gdb_stderr, e);
9677 /* If pending breakpoint support is auto query and the user
9678 selects no, then simply return the error code. */
9679 if (pending_break_support == AUTO_BOOLEAN_AUTO
9680 && !nquery (_("Make %s pending on future shared library load? "),
9681 bptype_string (type_wanted)))
9684 /* At this point, either the user was queried about setting
9685 a pending breakpoint and selected yes, or pending
9686 breakpoint behavior is on and thus a pending breakpoint
9687 is defaulted on behalf of the user. */
9689 struct linespec_sals lsal;
9691 copy_arg = xstrdup (addr_start);
9692 lsal.canonical = xstrdup (copy_arg);
9693 lsal.sals.nelts = 1;
9694 lsal.sals.sals = XNEW (struct symtab_and_line);
9695 init_sal (&lsal.sals.sals[0]);
9697 VEC_safe_push (linespec_sals, canonical.sals, &lsal);
9701 throw_exception (e);
9705 throw_exception (e);
9708 /* Create a chain of things that always need to be cleaned up. */
9709 old_chain = make_cleanup_destroy_linespec_result (&canonical);
9711 /* ----------------------------- SNIP -----------------------------
9712 Anything added to the cleanup chain beyond this point is assumed
9713 to be part of a breakpoint. If the breakpoint create succeeds
9714 then the memory is not reclaimed. */
9715 bkpt_chain = make_cleanup (null_cleanup, 0);
9717 /* Resolve all line numbers to PC's and verify that the addresses
9718 are ok for the target. */
9722 struct linespec_sals *iter;
9724 for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9725 breakpoint_sals_to_pc (&iter->sals);
9728 /* Fast tracepoints may have additional restrictions on location. */
9729 if (!pending && type_wanted == bp_fast_tracepoint)
9732 struct linespec_sals *iter;
9734 for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9735 check_fast_tracepoint_sals (gdbarch, &iter->sals);
9738 /* Verify that condition can be parsed, before setting any
9739 breakpoints. Allocate a separate condition expression for each
9746 struct linespec_sals *lsal;
9748 lsal = VEC_index (linespec_sals, canonical.sals, 0);
9750 /* Here we only parse 'arg' to separate condition
9751 from thread number, so parsing in context of first
9752 sal is OK. When setting the breakpoint we'll
9753 re-parse it in context of each sal. */
9755 find_condition_and_thread (arg, lsal->sals.sals[0].pc, &cond_string,
9756 &thread, &task, &rest);
9758 make_cleanup (xfree, cond_string);
9760 make_cleanup (xfree, rest);
9762 extra_string = rest;
9767 error (_("Garbage '%s' at end of location"), arg);
9769 /* Create a private copy of condition string. */
9772 cond_string = xstrdup (cond_string);
9773 make_cleanup (xfree, cond_string);
9775 /* Create a private copy of any extra string. */
9778 extra_string = xstrdup (extra_string);
9779 make_cleanup (xfree, extra_string);
9783 ops->create_breakpoints_sal (gdbarch, &canonical,
9784 cond_string, extra_string, type_wanted,
9785 tempflag ? disp_del : disp_donttouch,
9786 thread, task, ignore_count, ops,
9787 from_tty, enabled, internal, flags);
9791 struct breakpoint *b;
9793 make_cleanup (xfree, copy_arg);
9795 if (is_tracepoint_type (type_wanted))
9797 struct tracepoint *t;
9799 t = XCNEW (struct tracepoint);
9803 b = XNEW (struct breakpoint);
9805 init_raw_breakpoint_without_location (b, gdbarch, type_wanted, ops);
9807 b->addr_string = copy_arg;
9809 b->cond_string = NULL;
9812 /* Create a private copy of condition string. */
9815 cond_string = xstrdup (cond_string);
9816 make_cleanup (xfree, cond_string);
9818 b->cond_string = cond_string;
9820 b->extra_string = NULL;
9821 b->ignore_count = ignore_count;
9822 b->disposition = tempflag ? disp_del : disp_donttouch;
9823 b->condition_not_parsed = 1;
9824 b->enable_state = enabled ? bp_enabled : bp_disabled;
9825 if ((type_wanted != bp_breakpoint
9826 && type_wanted != bp_hardware_breakpoint) || thread != -1)
9827 b->pspace = current_program_space;
9829 install_breakpoint (internal, b, 0);
9832 if (VEC_length (linespec_sals, canonical.sals) > 1)
9834 warning (_("Multiple breakpoints were set.\nUse the "
9835 "\"delete\" command to delete unwanted breakpoints."));
9836 prev_breakpoint_count = prev_bkpt_count;
9839 /* That's it. Discard the cleanups for data inserted into the
9841 discard_cleanups (bkpt_chain);
9842 /* But cleanup everything else. */
9843 do_cleanups (old_chain);
9845 /* error call may happen here - have BKPT_CHAIN already discarded. */
9846 update_global_location_list (1);
9851 /* Set a breakpoint.
9852 ARG is a string describing breakpoint address,
9853 condition, and thread.
9854 FLAG specifies if a breakpoint is hardware on,
9855 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9859 break_command_1 (char *arg, int flag, int from_tty)
9861 int tempflag = flag & BP_TEMPFLAG;
9862 enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9863 ? bp_hardware_breakpoint
9865 struct breakpoint_ops *ops;
9866 const char *arg_cp = arg;
9868 /* Matching breakpoints on probes. */
9869 if (arg && probe_linespec_to_ops (&arg_cp) != NULL)
9870 ops = &bkpt_probe_breakpoint_ops;
9872 ops = &bkpt_breakpoint_ops;
9874 create_breakpoint (get_current_arch (),
9876 NULL, 0, NULL, 1 /* parse arg */,
9877 tempflag, type_wanted,
9878 0 /* Ignore count */,
9879 pending_break_support,
9887 /* Helper function for break_command_1 and disassemble_command. */
9890 resolve_sal_pc (struct symtab_and_line *sal)
9894 if (sal->pc == 0 && sal->symtab != NULL)
9896 if (!find_line_pc (sal->symtab, sal->line, &pc))
9897 error (_("No line %d in file \"%s\"."),
9898 sal->line, symtab_to_filename_for_display (sal->symtab));
9901 /* If this SAL corresponds to a breakpoint inserted using a line
9902 number, then skip the function prologue if necessary. */
9903 if (sal->explicit_line)
9904 skip_prologue_sal (sal);
9907 if (sal->section == 0 && sal->symtab != NULL)
9909 struct blockvector *bv;
9913 bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
9916 sym = block_linkage_function (b);
9919 fixup_symbol_section (sym, sal->symtab->objfile);
9920 sal->section = SYMBOL_OBJ_SECTION (sal->symtab->objfile, sym);
9924 /* It really is worthwhile to have the section, so we'll
9925 just have to look harder. This case can be executed
9926 if we have line numbers but no functions (as can
9927 happen in assembly source). */
9929 struct bound_minimal_symbol msym;
9930 struct cleanup *old_chain = save_current_space_and_thread ();
9932 switch_to_program_space_and_thread (sal->pspace);
9934 msym = lookup_minimal_symbol_by_pc (sal->pc);
9936 sal->section = SYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
9938 do_cleanups (old_chain);
9945 break_command (char *arg, int from_tty)
9947 break_command_1 (arg, 0, from_tty);
9951 tbreak_command (char *arg, int from_tty)
9953 break_command_1 (arg, BP_TEMPFLAG, from_tty);
9957 hbreak_command (char *arg, int from_tty)
9959 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
9963 thbreak_command (char *arg, int from_tty)
9965 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
9969 stop_command (char *arg, int from_tty)
9971 printf_filtered (_("Specify the type of breakpoint to set.\n\
9972 Usage: stop in <function | address>\n\
9973 stop at <line>\n"));
9977 stopin_command (char *arg, int from_tty)
9981 if (arg == (char *) NULL)
9983 else if (*arg != '*')
9988 /* Look for a ':'. If this is a line number specification, then
9989 say it is bad, otherwise, it should be an address or
9990 function/method name. */
9991 while (*argptr && !hasColon)
9993 hasColon = (*argptr == ':');
9998 badInput = (*argptr != ':'); /* Not a class::method */
10000 badInput = isdigit (*arg); /* a simple line number */
10004 printf_filtered (_("Usage: stop in <function | address>\n"));
10006 break_command_1 (arg, 0, from_tty);
10010 stopat_command (char *arg, int from_tty)
10014 if (arg == (char *) NULL || *arg == '*') /* no line number */
10018 char *argptr = arg;
10021 /* Look for a ':'. If there is a '::' then get out, otherwise
10022 it is probably a line number. */
10023 while (*argptr && !hasColon)
10025 hasColon = (*argptr == ':');
10030 badInput = (*argptr == ':'); /* we have class::method */
10032 badInput = !isdigit (*arg); /* not a line number */
10036 printf_filtered (_("Usage: stop at <line>\n"));
10038 break_command_1 (arg, 0, from_tty);
10041 /* The dynamic printf command is mostly like a regular breakpoint, but
10042 with a prewired command list consisting of a single output command,
10043 built from extra arguments supplied on the dprintf command
10047 dprintf_command (char *arg, int from_tty)
10049 create_breakpoint (get_current_arch (),
10051 NULL, 0, NULL, 1 /* parse arg */,
10053 0 /* Ignore count */,
10054 pending_break_support,
10055 &dprintf_breakpoint_ops,
10063 agent_printf_command (char *arg, int from_tty)
10065 error (_("May only run agent-printf on the target"));
10068 /* Implement the "breakpoint_hit" breakpoint_ops method for
10069 ranged breakpoints. */
10072 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
10073 struct address_space *aspace,
10075 const struct target_waitstatus *ws)
10077 if (ws->kind != TARGET_WAITKIND_STOPPED
10078 || ws->value.sig != GDB_SIGNAL_TRAP)
10081 return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
10082 bl->length, aspace, bp_addr);
10085 /* Implement the "resources_needed" breakpoint_ops method for
10086 ranged breakpoints. */
10089 resources_needed_ranged_breakpoint (const struct bp_location *bl)
10091 return target_ranged_break_num_registers ();
10094 /* Implement the "print_it" breakpoint_ops method for
10095 ranged breakpoints. */
10097 static enum print_stop_action
10098 print_it_ranged_breakpoint (bpstat bs)
10100 struct breakpoint *b = bs->breakpoint_at;
10101 struct bp_location *bl = b->loc;
10102 struct ui_out *uiout = current_uiout;
10104 gdb_assert (b->type == bp_hardware_breakpoint);
10106 /* Ranged breakpoints have only one location. */
10107 gdb_assert (bl && bl->next == NULL);
10109 annotate_breakpoint (b->number);
10110 if (b->disposition == disp_del)
10111 ui_out_text (uiout, "\nTemporary ranged breakpoint ");
10113 ui_out_text (uiout, "\nRanged breakpoint ");
10114 if (ui_out_is_mi_like_p (uiout))
10116 ui_out_field_string (uiout, "reason",
10117 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
10118 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
10120 ui_out_field_int (uiout, "bkptno", b->number);
10121 ui_out_text (uiout, ", ");
10123 return PRINT_SRC_AND_LOC;
10126 /* Implement the "print_one" breakpoint_ops method for
10127 ranged breakpoints. */
10130 print_one_ranged_breakpoint (struct breakpoint *b,
10131 struct bp_location **last_loc)
10133 struct bp_location *bl = b->loc;
10134 struct value_print_options opts;
10135 struct ui_out *uiout = current_uiout;
10137 /* Ranged breakpoints have only one location. */
10138 gdb_assert (bl && bl->next == NULL);
10140 get_user_print_options (&opts);
10142 if (opts.addressprint)
10143 /* We don't print the address range here, it will be printed later
10144 by print_one_detail_ranged_breakpoint. */
10145 ui_out_field_skip (uiout, "addr");
10146 annotate_field (5);
10147 print_breakpoint_location (b, bl);
10151 /* Implement the "print_one_detail" breakpoint_ops method for
10152 ranged breakpoints. */
10155 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
10156 struct ui_out *uiout)
10158 CORE_ADDR address_start, address_end;
10159 struct bp_location *bl = b->loc;
10160 struct ui_file *stb = mem_fileopen ();
10161 struct cleanup *cleanup = make_cleanup_ui_file_delete (stb);
10165 address_start = bl->address;
10166 address_end = address_start + bl->length - 1;
10168 ui_out_text (uiout, "\taddress range: ");
10169 fprintf_unfiltered (stb, "[%s, %s]",
10170 print_core_address (bl->gdbarch, address_start),
10171 print_core_address (bl->gdbarch, address_end));
10172 ui_out_field_stream (uiout, "addr", stb);
10173 ui_out_text (uiout, "\n");
10175 do_cleanups (cleanup);
10178 /* Implement the "print_mention" breakpoint_ops method for
10179 ranged breakpoints. */
10182 print_mention_ranged_breakpoint (struct breakpoint *b)
10184 struct bp_location *bl = b->loc;
10185 struct ui_out *uiout = current_uiout;
10188 gdb_assert (b->type == bp_hardware_breakpoint);
10190 if (ui_out_is_mi_like_p (uiout))
10193 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
10194 b->number, paddress (bl->gdbarch, bl->address),
10195 paddress (bl->gdbarch, bl->address + bl->length - 1));
10198 /* Implement the "print_recreate" breakpoint_ops method for
10199 ranged breakpoints. */
10202 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
10204 fprintf_unfiltered (fp, "break-range %s, %s", b->addr_string,
10205 b->addr_string_range_end);
10206 print_recreate_thread (b, fp);
10209 /* The breakpoint_ops structure to be used in ranged breakpoints. */
10211 static struct breakpoint_ops ranged_breakpoint_ops;
10213 /* Find the address where the end of the breakpoint range should be
10214 placed, given the SAL of the end of the range. This is so that if
10215 the user provides a line number, the end of the range is set to the
10216 last instruction of the given line. */
10219 find_breakpoint_range_end (struct symtab_and_line sal)
10223 /* If the user provided a PC value, use it. Otherwise,
10224 find the address of the end of the given location. */
10225 if (sal.explicit_pc)
10232 ret = find_line_pc_range (sal, &start, &end);
10234 error (_("Could not find location of the end of the range."));
10236 /* find_line_pc_range returns the start of the next line. */
10243 /* Implement the "break-range" CLI command. */
10246 break_range_command (char *arg, int from_tty)
10248 char *arg_start, *addr_string_start, *addr_string_end;
10249 struct linespec_result canonical_start, canonical_end;
10250 int bp_count, can_use_bp, length;
10252 struct breakpoint *b;
10253 struct symtab_and_line sal_start, sal_end;
10254 struct cleanup *cleanup_bkpt;
10255 struct linespec_sals *lsal_start, *lsal_end;
10257 /* We don't support software ranged breakpoints. */
10258 if (target_ranged_break_num_registers () < 0)
10259 error (_("This target does not support hardware ranged breakpoints."));
10261 bp_count = hw_breakpoint_used_count ();
10262 bp_count += target_ranged_break_num_registers ();
10263 can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
10265 if (can_use_bp < 0)
10266 error (_("Hardware breakpoints used exceeds limit."));
10268 arg = skip_spaces (arg);
10269 if (arg == NULL || arg[0] == '\0')
10270 error(_("No address range specified."));
10272 init_linespec_result (&canonical_start);
10275 parse_breakpoint_sals (&arg, &canonical_start);
10277 cleanup_bkpt = make_cleanup_destroy_linespec_result (&canonical_start);
10280 error (_("Too few arguments."));
10281 else if (VEC_empty (linespec_sals, canonical_start.sals))
10282 error (_("Could not find location of the beginning of the range."));
10284 lsal_start = VEC_index (linespec_sals, canonical_start.sals, 0);
10286 if (VEC_length (linespec_sals, canonical_start.sals) > 1
10287 || lsal_start->sals.nelts != 1)
10288 error (_("Cannot create a ranged breakpoint with multiple locations."));
10290 sal_start = lsal_start->sals.sals[0];
10291 addr_string_start = savestring (arg_start, arg - arg_start);
10292 make_cleanup (xfree, addr_string_start);
10294 arg++; /* Skip the comma. */
10295 arg = skip_spaces (arg);
10297 /* Parse the end location. */
10299 init_linespec_result (&canonical_end);
10302 /* We call decode_line_full directly here instead of using
10303 parse_breakpoint_sals because we need to specify the start location's
10304 symtab and line as the default symtab and line for the end of the
10305 range. This makes it possible to have ranges like "foo.c:27, +14",
10306 where +14 means 14 lines from the start location. */
10307 decode_line_full (&arg, DECODE_LINE_FUNFIRSTLINE,
10308 sal_start.symtab, sal_start.line,
10309 &canonical_end, NULL, NULL);
10311 make_cleanup_destroy_linespec_result (&canonical_end);
10313 if (VEC_empty (linespec_sals, canonical_end.sals))
10314 error (_("Could not find location of the end of the range."));
10316 lsal_end = VEC_index (linespec_sals, canonical_end.sals, 0);
10317 if (VEC_length (linespec_sals, canonical_end.sals) > 1
10318 || lsal_end->sals.nelts != 1)
10319 error (_("Cannot create a ranged breakpoint with multiple locations."));
10321 sal_end = lsal_end->sals.sals[0];
10322 addr_string_end = savestring (arg_start, arg - arg_start);
10323 make_cleanup (xfree, addr_string_end);
10325 end = find_breakpoint_range_end (sal_end);
10326 if (sal_start.pc > end)
10327 error (_("Invalid address range, end precedes start."));
10329 length = end - sal_start.pc + 1;
10331 /* Length overflowed. */
10332 error (_("Address range too large."));
10333 else if (length == 1)
10335 /* This range is simple enough to be handled by
10336 the `hbreak' command. */
10337 hbreak_command (addr_string_start, 1);
10339 do_cleanups (cleanup_bkpt);
10344 /* Now set up the breakpoint. */
10345 b = set_raw_breakpoint (get_current_arch (), sal_start,
10346 bp_hardware_breakpoint, &ranged_breakpoint_ops);
10347 set_breakpoint_count (breakpoint_count + 1);
10348 b->number = breakpoint_count;
10349 b->disposition = disp_donttouch;
10350 b->addr_string = xstrdup (addr_string_start);
10351 b->addr_string_range_end = xstrdup (addr_string_end);
10352 b->loc->length = length;
10354 do_cleanups (cleanup_bkpt);
10357 observer_notify_breakpoint_created (b);
10358 update_global_location_list (1);
10361 /* Return non-zero if EXP is verified as constant. Returned zero
10362 means EXP is variable. Also the constant detection may fail for
10363 some constant expressions and in such case still falsely return
10367 watchpoint_exp_is_const (const struct expression *exp)
10369 int i = exp->nelts;
10375 /* We are only interested in the descriptor of each element. */
10376 operator_length (exp, i, &oplenp, &argsp);
10379 switch (exp->elts[i].opcode)
10389 case BINOP_LOGICAL_AND:
10390 case BINOP_LOGICAL_OR:
10391 case BINOP_BITWISE_AND:
10392 case BINOP_BITWISE_IOR:
10393 case BINOP_BITWISE_XOR:
10395 case BINOP_NOTEQUAL:
10424 case OP_OBJC_NSSTRING:
10427 case UNOP_LOGICAL_NOT:
10428 case UNOP_COMPLEMENT:
10433 case UNOP_CAST_TYPE:
10434 case UNOP_REINTERPRET_CAST:
10435 case UNOP_DYNAMIC_CAST:
10436 /* Unary, binary and ternary operators: We have to check
10437 their operands. If they are constant, then so is the
10438 result of that operation. For instance, if A and B are
10439 determined to be constants, then so is "A + B".
10441 UNOP_IND is one exception to the rule above, because the
10442 value of *ADDR is not necessarily a constant, even when
10447 /* Check whether the associated symbol is a constant.
10449 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10450 possible that a buggy compiler could mark a variable as
10451 constant even when it is not, and TYPE_CONST would return
10452 true in this case, while SYMBOL_CLASS wouldn't.
10454 We also have to check for function symbols because they
10455 are always constant. */
10457 struct symbol *s = exp->elts[i + 2].symbol;
10459 if (SYMBOL_CLASS (s) != LOC_BLOCK
10460 && SYMBOL_CLASS (s) != LOC_CONST
10461 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
10466 /* The default action is to return 0 because we are using
10467 the optimistic approach here: If we don't know something,
10468 then it is not a constant. */
10477 /* Implement the "dtor" breakpoint_ops method for watchpoints. */
10480 dtor_watchpoint (struct breakpoint *self)
10482 struct watchpoint *w = (struct watchpoint *) self;
10484 xfree (w->cond_exp);
10486 xfree (w->exp_string);
10487 xfree (w->exp_string_reparse);
10488 value_free (w->val);
10490 base_breakpoint_ops.dtor (self);
10493 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10496 re_set_watchpoint (struct breakpoint *b)
10498 struct watchpoint *w = (struct watchpoint *) b;
10500 /* Watchpoint can be either on expression using entirely global
10501 variables, or it can be on local variables.
10503 Watchpoints of the first kind are never auto-deleted, and even
10504 persist across program restarts. Since they can use variables
10505 from shared libraries, we need to reparse expression as libraries
10506 are loaded and unloaded.
10508 Watchpoints on local variables can also change meaning as result
10509 of solib event. For example, if a watchpoint uses both a local
10510 and a global variables in expression, it's a local watchpoint,
10511 but unloading of a shared library will make the expression
10512 invalid. This is not a very common use case, but we still
10513 re-evaluate expression, to avoid surprises to the user.
10515 Note that for local watchpoints, we re-evaluate it only if
10516 watchpoints frame id is still valid. If it's not, it means the
10517 watchpoint is out of scope and will be deleted soon. In fact,
10518 I'm not sure we'll ever be called in this case.
10520 If a local watchpoint's frame id is still valid, then
10521 w->exp_valid_block is likewise valid, and we can safely use it.
10523 Don't do anything about disabled watchpoints, since they will be
10524 reevaluated again when enabled. */
10525 update_watchpoint (w, 1 /* reparse */);
10528 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10531 insert_watchpoint (struct bp_location *bl)
10533 struct watchpoint *w = (struct watchpoint *) bl->owner;
10534 int length = w->exact ? 1 : bl->length;
10536 return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
10540 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10543 remove_watchpoint (struct bp_location *bl)
10545 struct watchpoint *w = (struct watchpoint *) bl->owner;
10546 int length = w->exact ? 1 : bl->length;
10548 return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
10553 breakpoint_hit_watchpoint (const struct bp_location *bl,
10554 struct address_space *aspace, CORE_ADDR bp_addr,
10555 const struct target_waitstatus *ws)
10557 struct breakpoint *b = bl->owner;
10558 struct watchpoint *w = (struct watchpoint *) b;
10560 /* Continuable hardware watchpoints are treated as non-existent if the
10561 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10562 some data address). Otherwise gdb won't stop on a break instruction
10563 in the code (not from a breakpoint) when a hardware watchpoint has
10564 been defined. Also skip watchpoints which we know did not trigger
10565 (did not match the data address). */
10566 if (is_hardware_watchpoint (b)
10567 && w->watchpoint_triggered == watch_triggered_no)
10574 check_status_watchpoint (bpstat bs)
10576 gdb_assert (is_watchpoint (bs->breakpoint_at));
10578 bpstat_check_watchpoint (bs);
10581 /* Implement the "resources_needed" breakpoint_ops method for
10582 hardware watchpoints. */
10585 resources_needed_watchpoint (const struct bp_location *bl)
10587 struct watchpoint *w = (struct watchpoint *) bl->owner;
10588 int length = w->exact? 1 : bl->length;
10590 return target_region_ok_for_hw_watchpoint (bl->address, length);
10593 /* Implement the "works_in_software_mode" breakpoint_ops method for
10594 hardware watchpoints. */
10597 works_in_software_mode_watchpoint (const struct breakpoint *b)
10599 /* Read and access watchpoints only work with hardware support. */
10600 return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
10603 static enum print_stop_action
10604 print_it_watchpoint (bpstat bs)
10606 struct cleanup *old_chain;
10607 struct breakpoint *b;
10608 struct ui_file *stb;
10609 enum print_stop_action result;
10610 struct watchpoint *w;
10611 struct ui_out *uiout = current_uiout;
10613 gdb_assert (bs->bp_location_at != NULL);
10615 b = bs->breakpoint_at;
10616 w = (struct watchpoint *) b;
10618 stb = mem_fileopen ();
10619 old_chain = make_cleanup_ui_file_delete (stb);
10623 case bp_watchpoint:
10624 case bp_hardware_watchpoint:
10625 annotate_watchpoint (b->number);
10626 if (ui_out_is_mi_like_p (uiout))
10627 ui_out_field_string
10629 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10631 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10632 ui_out_text (uiout, "\nOld value = ");
10633 watchpoint_value_print (bs->old_val, stb);
10634 ui_out_field_stream (uiout, "old", stb);
10635 ui_out_text (uiout, "\nNew value = ");
10636 watchpoint_value_print (w->val, stb);
10637 ui_out_field_stream (uiout, "new", stb);
10638 ui_out_text (uiout, "\n");
10639 /* More than one watchpoint may have been triggered. */
10640 result = PRINT_UNKNOWN;
10643 case bp_read_watchpoint:
10644 if (ui_out_is_mi_like_p (uiout))
10645 ui_out_field_string
10647 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10649 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10650 ui_out_text (uiout, "\nValue = ");
10651 watchpoint_value_print (w->val, stb);
10652 ui_out_field_stream (uiout, "value", stb);
10653 ui_out_text (uiout, "\n");
10654 result = PRINT_UNKNOWN;
10657 case bp_access_watchpoint:
10658 if (bs->old_val != NULL)
10660 annotate_watchpoint (b->number);
10661 if (ui_out_is_mi_like_p (uiout))
10662 ui_out_field_string
10664 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10666 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10667 ui_out_text (uiout, "\nOld value = ");
10668 watchpoint_value_print (bs->old_val, stb);
10669 ui_out_field_stream (uiout, "old", stb);
10670 ui_out_text (uiout, "\nNew value = ");
10675 if (ui_out_is_mi_like_p (uiout))
10676 ui_out_field_string
10678 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10679 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10680 ui_out_text (uiout, "\nValue = ");
10682 watchpoint_value_print (w->val, stb);
10683 ui_out_field_stream (uiout, "new", stb);
10684 ui_out_text (uiout, "\n");
10685 result = PRINT_UNKNOWN;
10688 result = PRINT_UNKNOWN;
10691 do_cleanups (old_chain);
10695 /* Implement the "print_mention" breakpoint_ops method for hardware
10699 print_mention_watchpoint (struct breakpoint *b)
10701 struct cleanup *ui_out_chain;
10702 struct watchpoint *w = (struct watchpoint *) b;
10703 struct ui_out *uiout = current_uiout;
10707 case bp_watchpoint:
10708 ui_out_text (uiout, "Watchpoint ");
10709 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10711 case bp_hardware_watchpoint:
10712 ui_out_text (uiout, "Hardware watchpoint ");
10713 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10715 case bp_read_watchpoint:
10716 ui_out_text (uiout, "Hardware read watchpoint ");
10717 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10719 case bp_access_watchpoint:
10720 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
10721 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
10724 internal_error (__FILE__, __LINE__,
10725 _("Invalid hardware watchpoint type."));
10728 ui_out_field_int (uiout, "number", b->number);
10729 ui_out_text (uiout, ": ");
10730 ui_out_field_string (uiout, "exp", w->exp_string);
10731 do_cleanups (ui_out_chain);
10734 /* Implement the "print_recreate" breakpoint_ops method for
10738 print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10740 struct watchpoint *w = (struct watchpoint *) b;
10744 case bp_watchpoint:
10745 case bp_hardware_watchpoint:
10746 fprintf_unfiltered (fp, "watch");
10748 case bp_read_watchpoint:
10749 fprintf_unfiltered (fp, "rwatch");
10751 case bp_access_watchpoint:
10752 fprintf_unfiltered (fp, "awatch");
10755 internal_error (__FILE__, __LINE__,
10756 _("Invalid watchpoint type."));
10759 fprintf_unfiltered (fp, " %s", w->exp_string);
10760 print_recreate_thread (b, fp);
10763 /* Implement the "explains_signal" breakpoint_ops method for
10767 explains_signal_watchpoint (struct breakpoint *b, enum gdb_signal sig)
10769 /* A software watchpoint cannot cause a signal other than
10770 GDB_SIGNAL_TRAP. */
10771 if (b->type == bp_watchpoint && sig != GDB_SIGNAL_TRAP)
10777 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10779 static struct breakpoint_ops watchpoint_breakpoint_ops;
10781 /* Implement the "insert" breakpoint_ops method for
10782 masked hardware watchpoints. */
10785 insert_masked_watchpoint (struct bp_location *bl)
10787 struct watchpoint *w = (struct watchpoint *) bl->owner;
10789 return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
10790 bl->watchpoint_type);
10793 /* Implement the "remove" breakpoint_ops method for
10794 masked hardware watchpoints. */
10797 remove_masked_watchpoint (struct bp_location *bl)
10799 struct watchpoint *w = (struct watchpoint *) bl->owner;
10801 return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
10802 bl->watchpoint_type);
10805 /* Implement the "resources_needed" breakpoint_ops method for
10806 masked hardware watchpoints. */
10809 resources_needed_masked_watchpoint (const struct bp_location *bl)
10811 struct watchpoint *w = (struct watchpoint *) bl->owner;
10813 return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
10816 /* Implement the "works_in_software_mode" breakpoint_ops method for
10817 masked hardware watchpoints. */
10820 works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10825 /* Implement the "print_it" breakpoint_ops method for
10826 masked hardware watchpoints. */
10828 static enum print_stop_action
10829 print_it_masked_watchpoint (bpstat bs)
10831 struct breakpoint *b = bs->breakpoint_at;
10832 struct ui_out *uiout = current_uiout;
10834 /* Masked watchpoints have only one location. */
10835 gdb_assert (b->loc && b->loc->next == NULL);
10839 case bp_hardware_watchpoint:
10840 annotate_watchpoint (b->number);
10841 if (ui_out_is_mi_like_p (uiout))
10842 ui_out_field_string
10844 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10847 case bp_read_watchpoint:
10848 if (ui_out_is_mi_like_p (uiout))
10849 ui_out_field_string
10851 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10854 case bp_access_watchpoint:
10855 if (ui_out_is_mi_like_p (uiout))
10856 ui_out_field_string
10858 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10861 internal_error (__FILE__, __LINE__,
10862 _("Invalid hardware watchpoint type."));
10866 ui_out_text (uiout, _("\n\
10867 Check the underlying instruction at PC for the memory\n\
10868 address and value which triggered this watchpoint.\n"));
10869 ui_out_text (uiout, "\n");
10871 /* More than one watchpoint may have been triggered. */
10872 return PRINT_UNKNOWN;
10875 /* Implement the "print_one_detail" breakpoint_ops method for
10876 masked hardware watchpoints. */
10879 print_one_detail_masked_watchpoint (const struct breakpoint *b,
10880 struct ui_out *uiout)
10882 struct watchpoint *w = (struct watchpoint *) b;
10884 /* Masked watchpoints have only one location. */
10885 gdb_assert (b->loc && b->loc->next == NULL);
10887 ui_out_text (uiout, "\tmask ");
10888 ui_out_field_core_addr (uiout, "mask", b->loc->gdbarch, w->hw_wp_mask);
10889 ui_out_text (uiout, "\n");
10892 /* Implement the "print_mention" breakpoint_ops method for
10893 masked hardware watchpoints. */
10896 print_mention_masked_watchpoint (struct breakpoint *b)
10898 struct watchpoint *w = (struct watchpoint *) b;
10899 struct ui_out *uiout = current_uiout;
10900 struct cleanup *ui_out_chain;
10904 case bp_hardware_watchpoint:
10905 ui_out_text (uiout, "Masked hardware watchpoint ");
10906 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10908 case bp_read_watchpoint:
10909 ui_out_text (uiout, "Masked hardware read watchpoint ");
10910 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10912 case bp_access_watchpoint:
10913 ui_out_text (uiout, "Masked hardware access (read/write) watchpoint ");
10914 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
10917 internal_error (__FILE__, __LINE__,
10918 _("Invalid hardware watchpoint type."));
10921 ui_out_field_int (uiout, "number", b->number);
10922 ui_out_text (uiout, ": ");
10923 ui_out_field_string (uiout, "exp", w->exp_string);
10924 do_cleanups (ui_out_chain);
10927 /* Implement the "print_recreate" breakpoint_ops method for
10928 masked hardware watchpoints. */
10931 print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
10933 struct watchpoint *w = (struct watchpoint *) b;
10938 case bp_hardware_watchpoint:
10939 fprintf_unfiltered (fp, "watch");
10941 case bp_read_watchpoint:
10942 fprintf_unfiltered (fp, "rwatch");
10944 case bp_access_watchpoint:
10945 fprintf_unfiltered (fp, "awatch");
10948 internal_error (__FILE__, __LINE__,
10949 _("Invalid hardware watchpoint type."));
10952 sprintf_vma (tmp, w->hw_wp_mask);
10953 fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
10954 print_recreate_thread (b, fp);
10957 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10959 static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
10961 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10964 is_masked_watchpoint (const struct breakpoint *b)
10966 return b->ops == &masked_watchpoint_breakpoint_ops;
10969 /* accessflag: hw_write: watch write,
10970 hw_read: watch read,
10971 hw_access: watch access (read or write) */
10973 watch_command_1 (const char *arg, int accessflag, int from_tty,
10974 int just_location, int internal)
10976 volatile struct gdb_exception e;
10977 struct breakpoint *b, *scope_breakpoint = NULL;
10978 struct expression *exp;
10979 const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
10980 struct value *val, *mark, *result;
10981 struct frame_info *frame;
10982 const char *exp_start = NULL;
10983 const char *exp_end = NULL;
10984 const char *tok, *end_tok;
10986 const char *cond_start = NULL;
10987 const char *cond_end = NULL;
10988 enum bptype bp_type;
10991 /* Flag to indicate whether we are going to use masks for
10992 the hardware watchpoint. */
10994 CORE_ADDR mask = 0;
10995 struct watchpoint *w;
10997 struct cleanup *back_to;
10999 /* Make sure that we actually have parameters to parse. */
11000 if (arg != NULL && arg[0] != '\0')
11002 const char *value_start;
11004 exp_end = arg + strlen (arg);
11006 /* Look for "parameter value" pairs at the end
11007 of the arguments string. */
11008 for (tok = exp_end - 1; tok > arg; tok--)
11010 /* Skip whitespace at the end of the argument list. */
11011 while (tok > arg && (*tok == ' ' || *tok == '\t'))
11014 /* Find the beginning of the last token.
11015 This is the value of the parameter. */
11016 while (tok > arg && (*tok != ' ' && *tok != '\t'))
11018 value_start = tok + 1;
11020 /* Skip whitespace. */
11021 while (tok > arg && (*tok == ' ' || *tok == '\t'))
11026 /* Find the beginning of the second to last token.
11027 This is the parameter itself. */
11028 while (tok > arg && (*tok != ' ' && *tok != '\t'))
11031 toklen = end_tok - tok + 1;
11033 if (toklen == 6 && !strncmp (tok, "thread", 6))
11035 /* At this point we've found a "thread" token, which means
11036 the user is trying to set a watchpoint that triggers
11037 only in a specific thread. */
11041 error(_("You can specify only one thread."));
11043 /* Extract the thread ID from the next token. */
11044 thread = strtol (value_start, &endp, 0);
11046 /* Check if the user provided a valid numeric value for the
11048 if (*endp != ' ' && *endp != '\t' && *endp != '\0')
11049 error (_("Invalid thread ID specification %s."), value_start);
11051 /* Check if the thread actually exists. */
11052 if (!valid_thread_id (thread))
11053 invalid_thread_id_error (thread);
11055 else if (toklen == 4 && !strncmp (tok, "mask", 4))
11057 /* We've found a "mask" token, which means the user wants to
11058 create a hardware watchpoint that is going to have the mask
11060 struct value *mask_value, *mark;
11063 error(_("You can specify only one mask."));
11065 use_mask = just_location = 1;
11067 mark = value_mark ();
11068 mask_value = parse_to_comma_and_eval (&value_start);
11069 mask = value_as_address (mask_value);
11070 value_free_to_mark (mark);
11073 /* We didn't recognize what we found. We should stop here. */
11076 /* Truncate the string and get rid of the "parameter value" pair before
11077 the arguments string is parsed by the parse_exp_1 function. */
11084 /* Parse the rest of the arguments. From here on out, everything
11085 is in terms of a newly allocated string instead of the original
11087 innermost_block = NULL;
11088 expression = savestring (arg, exp_end - arg);
11089 back_to = make_cleanup (xfree, expression);
11090 exp_start = arg = expression;
11091 exp = parse_exp_1 (&arg, 0, 0, 0);
11093 /* Remove trailing whitespace from the expression before saving it.
11094 This makes the eventual display of the expression string a bit
11096 while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
11099 /* Checking if the expression is not constant. */
11100 if (watchpoint_exp_is_const (exp))
11104 len = exp_end - exp_start;
11105 while (len > 0 && isspace (exp_start[len - 1]))
11107 error (_("Cannot watch constant value `%.*s'."), len, exp_start);
11110 exp_valid_block = innermost_block;
11111 mark = value_mark ();
11112 fetch_subexp_value (exp, &pc, &val, &result, NULL, just_location);
11118 exp_valid_block = NULL;
11119 val = value_addr (result);
11120 release_value (val);
11121 value_free_to_mark (mark);
11125 ret = target_masked_watch_num_registers (value_as_address (val),
11128 error (_("This target does not support masked watchpoints."));
11129 else if (ret == -2)
11130 error (_("Invalid mask or memory region."));
11133 else if (val != NULL)
11134 release_value (val);
11136 tok = skip_spaces_const (arg);
11137 end_tok = skip_to_space_const (tok);
11139 toklen = end_tok - tok;
11140 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
11142 struct expression *cond;
11144 innermost_block = NULL;
11145 tok = cond_start = end_tok + 1;
11146 cond = parse_exp_1 (&tok, 0, 0, 0);
11148 /* The watchpoint expression may not be local, but the condition
11149 may still be. E.g.: `watch global if local > 0'. */
11150 cond_exp_valid_block = innermost_block;
11156 error (_("Junk at end of command."));
11158 frame = block_innermost_frame (exp_valid_block);
11160 /* If the expression is "local", then set up a "watchpoint scope"
11161 breakpoint at the point where we've left the scope of the watchpoint
11162 expression. Create the scope breakpoint before the watchpoint, so
11163 that we will encounter it first in bpstat_stop_status. */
11164 if (exp_valid_block && frame)
11166 if (frame_id_p (frame_unwind_caller_id (frame)))
11169 = create_internal_breakpoint (frame_unwind_caller_arch (frame),
11170 frame_unwind_caller_pc (frame),
11171 bp_watchpoint_scope,
11172 &momentary_breakpoint_ops);
11174 scope_breakpoint->enable_state = bp_enabled;
11176 /* Automatically delete the breakpoint when it hits. */
11177 scope_breakpoint->disposition = disp_del;
11179 /* Only break in the proper frame (help with recursion). */
11180 scope_breakpoint->frame_id = frame_unwind_caller_id (frame);
11182 /* Set the address at which we will stop. */
11183 scope_breakpoint->loc->gdbarch
11184 = frame_unwind_caller_arch (frame);
11185 scope_breakpoint->loc->requested_address
11186 = frame_unwind_caller_pc (frame);
11187 scope_breakpoint->loc->address
11188 = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
11189 scope_breakpoint->loc->requested_address,
11190 scope_breakpoint->type);
11194 /* Now set up the breakpoint. We create all watchpoints as hardware
11195 watchpoints here even if hardware watchpoints are turned off, a call
11196 to update_watchpoint later in this function will cause the type to
11197 drop back to bp_watchpoint (software watchpoint) if required. */
11199 if (accessflag == hw_read)
11200 bp_type = bp_read_watchpoint;
11201 else if (accessflag == hw_access)
11202 bp_type = bp_access_watchpoint;
11204 bp_type = bp_hardware_watchpoint;
11206 w = XCNEW (struct watchpoint);
11209 init_raw_breakpoint_without_location (b, NULL, bp_type,
11210 &masked_watchpoint_breakpoint_ops);
11212 init_raw_breakpoint_without_location (b, NULL, bp_type,
11213 &watchpoint_breakpoint_ops);
11214 b->thread = thread;
11215 b->disposition = disp_donttouch;
11216 b->pspace = current_program_space;
11218 w->exp_valid_block = exp_valid_block;
11219 w->cond_exp_valid_block = cond_exp_valid_block;
11222 struct type *t = value_type (val);
11223 CORE_ADDR addr = value_as_address (val);
11226 t = check_typedef (TYPE_TARGET_TYPE (check_typedef (t)));
11227 name = type_to_string (t);
11229 w->exp_string_reparse = xstrprintf ("* (%s *) %s", name,
11230 core_addr_to_string (addr));
11233 w->exp_string = xstrprintf ("-location %.*s",
11234 (int) (exp_end - exp_start), exp_start);
11236 /* The above expression is in C. */
11237 b->language = language_c;
11240 w->exp_string = savestring (exp_start, exp_end - exp_start);
11244 w->hw_wp_mask = mask;
11253 b->cond_string = savestring (cond_start, cond_end - cond_start);
11255 b->cond_string = 0;
11259 w->watchpoint_frame = get_frame_id (frame);
11260 w->watchpoint_thread = inferior_ptid;
11264 w->watchpoint_frame = null_frame_id;
11265 w->watchpoint_thread = null_ptid;
11268 if (scope_breakpoint != NULL)
11270 /* The scope breakpoint is related to the watchpoint. We will
11271 need to act on them together. */
11272 b->related_breakpoint = scope_breakpoint;
11273 scope_breakpoint->related_breakpoint = b;
11276 if (!just_location)
11277 value_free_to_mark (mark);
11279 TRY_CATCH (e, RETURN_MASK_ALL)
11281 /* Finally update the new watchpoint. This creates the locations
11282 that should be inserted. */
11283 update_watchpoint (w, 1);
11287 delete_breakpoint (b);
11288 throw_exception (e);
11291 install_breakpoint (internal, b, 1);
11292 do_cleanups (back_to);
11295 /* Return count of debug registers needed to watch the given expression.
11296 If the watchpoint cannot be handled in hardware return zero. */
11299 can_use_hardware_watchpoint (struct value *v)
11301 int found_memory_cnt = 0;
11302 struct value *head = v;
11304 /* Did the user specifically forbid us to use hardware watchpoints? */
11305 if (!can_use_hw_watchpoints)
11308 /* Make sure that the value of the expression depends only upon
11309 memory contents, and values computed from them within GDB. If we
11310 find any register references or function calls, we can't use a
11311 hardware watchpoint.
11313 The idea here is that evaluating an expression generates a series
11314 of values, one holding the value of every subexpression. (The
11315 expression a*b+c has five subexpressions: a, b, a*b, c, and
11316 a*b+c.) GDB's values hold almost enough information to establish
11317 the criteria given above --- they identify memory lvalues,
11318 register lvalues, computed values, etcetera. So we can evaluate
11319 the expression, and then scan the chain of values that leaves
11320 behind to decide whether we can detect any possible change to the
11321 expression's final value using only hardware watchpoints.
11323 However, I don't think that the values returned by inferior
11324 function calls are special in any way. So this function may not
11325 notice that an expression involving an inferior function call
11326 can't be watched with hardware watchpoints. FIXME. */
11327 for (; v; v = value_next (v))
11329 if (VALUE_LVAL (v) == lval_memory)
11331 if (v != head && value_lazy (v))
11332 /* A lazy memory lvalue in the chain is one that GDB never
11333 needed to fetch; we either just used its address (e.g.,
11334 `a' in `a.b') or we never needed it at all (e.g., `a'
11335 in `a,b'). This doesn't apply to HEAD; if that is
11336 lazy then it was not readable, but watch it anyway. */
11340 /* Ahh, memory we actually used! Check if we can cover
11341 it with hardware watchpoints. */
11342 struct type *vtype = check_typedef (value_type (v));
11344 /* We only watch structs and arrays if user asked for it
11345 explicitly, never if they just happen to appear in a
11346 middle of some value chain. */
11348 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
11349 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
11351 CORE_ADDR vaddr = value_address (v);
11355 len = (target_exact_watchpoints
11356 && is_scalar_type_recursive (vtype))?
11357 1 : TYPE_LENGTH (value_type (v));
11359 num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
11363 found_memory_cnt += num_regs;
11367 else if (VALUE_LVAL (v) != not_lval
11368 && deprecated_value_modifiable (v) == 0)
11369 return 0; /* These are values from the history (e.g., $1). */
11370 else if (VALUE_LVAL (v) == lval_register)
11371 return 0; /* Cannot watch a register with a HW watchpoint. */
11374 /* The expression itself looks suitable for using a hardware
11375 watchpoint, but give the target machine a chance to reject it. */
11376 return found_memory_cnt;
11380 watch_command_wrapper (char *arg, int from_tty, int internal)
11382 watch_command_1 (arg, hw_write, from_tty, 0, internal);
11385 /* A helper function that looks for the "-location" argument and then
11386 calls watch_command_1. */
11389 watch_maybe_just_location (char *arg, int accessflag, int from_tty)
11391 int just_location = 0;
11394 && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
11395 || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
11397 arg = skip_spaces (arg);
11401 watch_command_1 (arg, accessflag, from_tty, just_location, 0);
11405 watch_command (char *arg, int from_tty)
11407 watch_maybe_just_location (arg, hw_write, from_tty);
11411 rwatch_command_wrapper (char *arg, int from_tty, int internal)
11413 watch_command_1 (arg, hw_read, from_tty, 0, internal);
11417 rwatch_command (char *arg, int from_tty)
11419 watch_maybe_just_location (arg, hw_read, from_tty);
11423 awatch_command_wrapper (char *arg, int from_tty, int internal)
11425 watch_command_1 (arg, hw_access, from_tty, 0, internal);
11429 awatch_command (char *arg, int from_tty)
11431 watch_maybe_just_location (arg, hw_access, from_tty);
11435 /* Helper routines for the until_command routine in infcmd.c. Here
11436 because it uses the mechanisms of breakpoints. */
11438 struct until_break_command_continuation_args
11440 struct breakpoint *breakpoint;
11441 struct breakpoint *breakpoint2;
11445 /* This function is called by fetch_inferior_event via the
11446 cmd_continuation pointer, to complete the until command. It takes
11447 care of cleaning up the temporary breakpoints set up by the until
11450 until_break_command_continuation (void *arg, int err)
11452 struct until_break_command_continuation_args *a = arg;
11454 delete_breakpoint (a->breakpoint);
11455 if (a->breakpoint2)
11456 delete_breakpoint (a->breakpoint2);
11457 delete_longjmp_breakpoint (a->thread_num);
11461 until_break_command (char *arg, int from_tty, int anywhere)
11463 struct symtabs_and_lines sals;
11464 struct symtab_and_line sal;
11465 struct frame_info *frame;
11466 struct gdbarch *frame_gdbarch;
11467 struct frame_id stack_frame_id;
11468 struct frame_id caller_frame_id;
11469 struct breakpoint *breakpoint;
11470 struct breakpoint *breakpoint2 = NULL;
11471 struct cleanup *old_chain;
11473 struct thread_info *tp;
11475 clear_proceed_status ();
11477 /* Set a breakpoint where the user wants it and at return from
11480 if (last_displayed_sal_is_valid ())
11481 sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
11482 get_last_displayed_symtab (),
11483 get_last_displayed_line ());
11485 sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
11486 (struct symtab *) NULL, 0);
11488 if (sals.nelts != 1)
11489 error (_("Couldn't get information on specified line."));
11491 sal = sals.sals[0];
11492 xfree (sals.sals); /* malloc'd, so freed. */
11495 error (_("Junk at end of arguments."));
11497 resolve_sal_pc (&sal);
11499 tp = inferior_thread ();
11502 old_chain = make_cleanup (null_cleanup, NULL);
11504 /* Note linespec handling above invalidates the frame chain.
11505 Installing a breakpoint also invalidates the frame chain (as it
11506 may need to switch threads), so do any frame handling before
11509 frame = get_selected_frame (NULL);
11510 frame_gdbarch = get_frame_arch (frame);
11511 stack_frame_id = get_stack_frame_id (frame);
11512 caller_frame_id = frame_unwind_caller_id (frame);
11514 /* Keep within the current frame, or in frames called by the current
11517 if (frame_id_p (caller_frame_id))
11519 struct symtab_and_line sal2;
11521 sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11522 sal2.pc = frame_unwind_caller_pc (frame);
11523 breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
11527 make_cleanup_delete_breakpoint (breakpoint2);
11529 set_longjmp_breakpoint (tp, caller_frame_id);
11530 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
11533 /* set_momentary_breakpoint could invalidate FRAME. */
11537 /* If the user told us to continue until a specified location,
11538 we don't specify a frame at which we need to stop. */
11539 breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11540 null_frame_id, bp_until);
11542 /* Otherwise, specify the selected frame, because we want to stop
11543 only at the very same frame. */
11544 breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11545 stack_frame_id, bp_until);
11546 make_cleanup_delete_breakpoint (breakpoint);
11548 proceed (-1, GDB_SIGNAL_DEFAULT, 0);
11550 /* If we are running asynchronously, and proceed call above has
11551 actually managed to start the target, arrange for breakpoints to
11552 be deleted when the target stops. Otherwise, we're already
11553 stopped and delete breakpoints via cleanup chain. */
11555 if (target_can_async_p () && is_running (inferior_ptid))
11557 struct until_break_command_continuation_args *args;
11558 args = xmalloc (sizeof (*args));
11560 args->breakpoint = breakpoint;
11561 args->breakpoint2 = breakpoint2;
11562 args->thread_num = thread;
11564 discard_cleanups (old_chain);
11565 add_continuation (inferior_thread (),
11566 until_break_command_continuation, args,
11570 do_cleanups (old_chain);
11573 /* This function attempts to parse an optional "if <cond>" clause
11574 from the arg string. If one is not found, it returns NULL.
11576 Else, it returns a pointer to the condition string. (It does not
11577 attempt to evaluate the string against a particular block.) And,
11578 it updates arg to point to the first character following the parsed
11579 if clause in the arg string. */
11582 ep_parse_optional_if_clause (char **arg)
11586 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
11589 /* Skip the "if" keyword. */
11592 /* Skip any extra leading whitespace, and record the start of the
11593 condition string. */
11594 *arg = skip_spaces (*arg);
11595 cond_string = *arg;
11597 /* Assume that the condition occupies the remainder of the arg
11599 (*arg) += strlen (cond_string);
11601 return cond_string;
11604 /* Commands to deal with catching events, such as signals, exceptions,
11605 process start/exit, etc. */
11609 catch_fork_temporary, catch_vfork_temporary,
11610 catch_fork_permanent, catch_vfork_permanent
11615 catch_fork_command_1 (char *arg, int from_tty,
11616 struct cmd_list_element *command)
11618 struct gdbarch *gdbarch = get_current_arch ();
11619 char *cond_string = NULL;
11620 catch_fork_kind fork_kind;
11623 fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11624 tempflag = (fork_kind == catch_fork_temporary
11625 || fork_kind == catch_vfork_temporary);
11629 arg = skip_spaces (arg);
11631 /* The allowed syntax is:
11633 catch [v]fork if <cond>
11635 First, check if there's an if clause. */
11636 cond_string = ep_parse_optional_if_clause (&arg);
11638 if ((*arg != '\0') && !isspace (*arg))
11639 error (_("Junk at end of arguments."));
11641 /* If this target supports it, create a fork or vfork catchpoint
11642 and enable reporting of such events. */
11645 case catch_fork_temporary:
11646 case catch_fork_permanent:
11647 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11648 &catch_fork_breakpoint_ops);
11650 case catch_vfork_temporary:
11651 case catch_vfork_permanent:
11652 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11653 &catch_vfork_breakpoint_ops);
11656 error (_("unsupported or unknown fork kind; cannot catch it"));
11662 catch_exec_command_1 (char *arg, int from_tty,
11663 struct cmd_list_element *command)
11665 struct exec_catchpoint *c;
11666 struct gdbarch *gdbarch = get_current_arch ();
11668 char *cond_string = NULL;
11670 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11674 arg = skip_spaces (arg);
11676 /* The allowed syntax is:
11678 catch exec if <cond>
11680 First, check if there's an if clause. */
11681 cond_string = ep_parse_optional_if_clause (&arg);
11683 if ((*arg != '\0') && !isspace (*arg))
11684 error (_("Junk at end of arguments."));
11686 c = XNEW (struct exec_catchpoint);
11687 init_catchpoint (&c->base, gdbarch, tempflag, cond_string,
11688 &catch_exec_breakpoint_ops);
11689 c->exec_pathname = NULL;
11691 install_breakpoint (0, &c->base, 1);
11695 init_ada_exception_breakpoint (struct breakpoint *b,
11696 struct gdbarch *gdbarch,
11697 struct symtab_and_line sal,
11699 const struct breakpoint_ops *ops,
11706 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11708 loc_gdbarch = gdbarch;
11710 describe_other_breakpoints (loc_gdbarch,
11711 sal.pspace, sal.pc, sal.section, -1);
11712 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11713 version for exception catchpoints, because two catchpoints
11714 used for different exception names will use the same address.
11715 In this case, a "breakpoint ... also set at..." warning is
11716 unproductive. Besides, the warning phrasing is also a bit
11717 inappropriate, we should use the word catchpoint, and tell
11718 the user what type of catchpoint it is. The above is good
11719 enough for now, though. */
11722 init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
11724 b->enable_state = enabled ? bp_enabled : bp_disabled;
11725 b->disposition = tempflag ? disp_del : disp_donttouch;
11726 b->addr_string = addr_string;
11727 b->language = language_ada;
11730 /* Splits the argument using space as delimiter. Returns an xmalloc'd
11731 filter list, or NULL if no filtering is required. */
11733 catch_syscall_split_args (char *arg)
11735 VEC(int) *result = NULL;
11736 struct cleanup *cleanup = make_cleanup (VEC_cleanup (int), &result);
11738 while (*arg != '\0')
11740 int i, syscall_number;
11742 char cur_name[128];
11745 /* Skip whitespace. */
11746 arg = skip_spaces (arg);
11748 for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
11749 cur_name[i] = arg[i];
11750 cur_name[i] = '\0';
11753 /* Check if the user provided a syscall name or a number. */
11754 syscall_number = (int) strtol (cur_name, &endptr, 0);
11755 if (*endptr == '\0')
11756 get_syscall_by_number (syscall_number, &s);
11759 /* We have a name. Let's check if it's valid and convert it
11761 get_syscall_by_name (cur_name, &s);
11763 if (s.number == UNKNOWN_SYSCALL)
11764 /* Here we have to issue an error instead of a warning,
11765 because GDB cannot do anything useful if there's no
11766 syscall number to be caught. */
11767 error (_("Unknown syscall name '%s'."), cur_name);
11770 /* Ok, it's valid. */
11771 VEC_safe_push (int, result, s.number);
11774 discard_cleanups (cleanup);
11778 /* Implement the "catch syscall" command. */
11781 catch_syscall_command_1 (char *arg, int from_tty,
11782 struct cmd_list_element *command)
11787 struct gdbarch *gdbarch = get_current_arch ();
11789 /* Checking if the feature if supported. */
11790 if (gdbarch_get_syscall_number_p (gdbarch) == 0)
11791 error (_("The feature 'catch syscall' is not supported on \
11792 this architecture yet."));
11794 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11796 arg = skip_spaces (arg);
11798 /* We need to do this first "dummy" translation in order
11799 to get the syscall XML file loaded or, most important,
11800 to display a warning to the user if there's no XML file
11801 for his/her architecture. */
11802 get_syscall_by_number (0, &s);
11804 /* The allowed syntax is:
11806 catch syscall <name | number> [<name | number> ... <name | number>]
11808 Let's check if there's a syscall name. */
11811 filter = catch_syscall_split_args (arg);
11815 create_syscall_event_catchpoint (tempflag, filter,
11816 &catch_syscall_breakpoint_ops);
11820 catch_command (char *arg, int from_tty)
11822 error (_("Catch requires an event name."));
11827 tcatch_command (char *arg, int from_tty)
11829 error (_("Catch requires an event name."));
11832 /* A qsort comparison function that sorts breakpoints in order. */
11835 compare_breakpoints (const void *a, const void *b)
11837 const breakpoint_p *ba = a;
11838 uintptr_t ua = (uintptr_t) *ba;
11839 const breakpoint_p *bb = b;
11840 uintptr_t ub = (uintptr_t) *bb;
11842 if ((*ba)->number < (*bb)->number)
11844 else if ((*ba)->number > (*bb)->number)
11847 /* Now sort by address, in case we see, e..g, two breakpoints with
11851 return ua > ub ? 1 : 0;
11854 /* Delete breakpoints by address or line. */
11857 clear_command (char *arg, int from_tty)
11859 struct breakpoint *b, *prev;
11860 VEC(breakpoint_p) *found = 0;
11863 struct symtabs_and_lines sals;
11864 struct symtab_and_line sal;
11866 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
11870 sals = decode_line_with_current_source (arg,
11871 (DECODE_LINE_FUNFIRSTLINE
11872 | DECODE_LINE_LIST_MODE));
11873 make_cleanup (xfree, sals.sals);
11878 sals.sals = (struct symtab_and_line *)
11879 xmalloc (sizeof (struct symtab_and_line));
11880 make_cleanup (xfree, sals.sals);
11881 init_sal (&sal); /* Initialize to zeroes. */
11883 /* Set sal's line, symtab, pc, and pspace to the values
11884 corresponding to the last call to print_frame_info. If the
11885 codepoint is not valid, this will set all the fields to 0. */
11886 get_last_displayed_sal (&sal);
11887 if (sal.symtab == 0)
11888 error (_("No source file specified."));
11890 sals.sals[0] = sal;
11896 /* We don't call resolve_sal_pc here. That's not as bad as it
11897 seems, because all existing breakpoints typically have both
11898 file/line and pc set. So, if clear is given file/line, we can
11899 match this to existing breakpoint without obtaining pc at all.
11901 We only support clearing given the address explicitly
11902 present in breakpoint table. Say, we've set breakpoint
11903 at file:line. There were several PC values for that file:line,
11904 due to optimization, all in one block.
11906 We've picked one PC value. If "clear" is issued with another
11907 PC corresponding to the same file:line, the breakpoint won't
11908 be cleared. We probably can still clear the breakpoint, but
11909 since the other PC value is never presented to user, user
11910 can only find it by guessing, and it does not seem important
11911 to support that. */
11913 /* For each line spec given, delete bps which correspond to it. Do
11914 it in two passes, solely to preserve the current behavior that
11915 from_tty is forced true if we delete more than one
11919 make_cleanup (VEC_cleanup (breakpoint_p), &found);
11920 for (i = 0; i < sals.nelts; i++)
11922 const char *sal_fullname;
11924 /* If exact pc given, clear bpts at that pc.
11925 If line given (pc == 0), clear all bpts on specified line.
11926 If defaulting, clear all bpts on default line
11929 defaulting sal.pc != 0 tests to do
11934 1 0 <can't happen> */
11936 sal = sals.sals[i];
11937 sal_fullname = (sal.symtab == NULL
11938 ? NULL : symtab_to_fullname (sal.symtab));
11940 /* Find all matching breakpoints and add them to 'found'. */
11941 ALL_BREAKPOINTS (b)
11944 /* Are we going to delete b? */
11945 if (b->type != bp_none && !is_watchpoint (b))
11947 struct bp_location *loc = b->loc;
11948 for (; loc; loc = loc->next)
11950 /* If the user specified file:line, don't allow a PC
11951 match. This matches historical gdb behavior. */
11952 int pc_match = (!sal.explicit_line
11954 && (loc->pspace == sal.pspace)
11955 && (loc->address == sal.pc)
11956 && (!section_is_overlay (loc->section)
11957 || loc->section == sal.section));
11958 int line_match = 0;
11960 if ((default_match || sal.explicit_line)
11961 && loc->symtab != NULL
11962 && sal_fullname != NULL
11963 && sal.pspace == loc->pspace
11964 && loc->line_number == sal.line
11965 && filename_cmp (symtab_to_fullname (loc->symtab),
11966 sal_fullname) == 0)
11969 if (pc_match || line_match)
11978 VEC_safe_push(breakpoint_p, found, b);
11982 /* Now go thru the 'found' chain and delete them. */
11983 if (VEC_empty(breakpoint_p, found))
11986 error (_("No breakpoint at %s."), arg);
11988 error (_("No breakpoint at this line."));
11991 /* Remove duplicates from the vec. */
11992 qsort (VEC_address (breakpoint_p, found),
11993 VEC_length (breakpoint_p, found),
11994 sizeof (breakpoint_p),
11995 compare_breakpoints);
11996 prev = VEC_index (breakpoint_p, found, 0);
11997 for (ix = 1; VEC_iterate (breakpoint_p, found, ix, b); ++ix)
12001 VEC_ordered_remove (breakpoint_p, found, ix);
12006 if (VEC_length(breakpoint_p, found) > 1)
12007 from_tty = 1; /* Always report if deleted more than one. */
12010 if (VEC_length(breakpoint_p, found) == 1)
12011 printf_unfiltered (_("Deleted breakpoint "));
12013 printf_unfiltered (_("Deleted breakpoints "));
12016 for (ix = 0; VEC_iterate(breakpoint_p, found, ix, b); ix++)
12019 printf_unfiltered ("%d ", b->number);
12020 delete_breakpoint (b);
12023 putchar_unfiltered ('\n');
12025 do_cleanups (cleanups);
12028 /* Delete breakpoint in BS if they are `delete' breakpoints and
12029 all breakpoints that are marked for deletion, whether hit or not.
12030 This is called after any breakpoint is hit, or after errors. */
12033 breakpoint_auto_delete (bpstat bs)
12035 struct breakpoint *b, *b_tmp;
12037 for (; bs; bs = bs->next)
12038 if (bs->breakpoint_at
12039 && bs->breakpoint_at->disposition == disp_del
12041 delete_breakpoint (bs->breakpoint_at);
12043 ALL_BREAKPOINTS_SAFE (b, b_tmp)
12045 if (b->disposition == disp_del_at_next_stop)
12046 delete_breakpoint (b);
12050 /* A comparison function for bp_location AP and BP being interfaced to
12051 qsort. Sort elements primarily by their ADDRESS (no matter what
12052 does breakpoint_address_is_meaningful say for its OWNER),
12053 secondarily by ordering first bp_permanent OWNERed elements and
12054 terciarily just ensuring the array is sorted stable way despite
12055 qsort being an unstable algorithm. */
12058 bp_location_compare (const void *ap, const void *bp)
12060 struct bp_location *a = *(void **) ap;
12061 struct bp_location *b = *(void **) bp;
12062 /* A and B come from existing breakpoints having non-NULL OWNER. */
12063 int a_perm = a->owner->enable_state == bp_permanent;
12064 int b_perm = b->owner->enable_state == bp_permanent;
12066 if (a->address != b->address)
12067 return (a->address > b->address) - (a->address < b->address);
12069 /* Sort locations at the same address by their pspace number, keeping
12070 locations of the same inferior (in a multi-inferior environment)
12073 if (a->pspace->num != b->pspace->num)
12074 return ((a->pspace->num > b->pspace->num)
12075 - (a->pspace->num < b->pspace->num));
12077 /* Sort permanent breakpoints first. */
12078 if (a_perm != b_perm)
12079 return (a_perm < b_perm) - (a_perm > b_perm);
12081 /* Make the internal GDB representation stable across GDB runs
12082 where A and B memory inside GDB can differ. Breakpoint locations of
12083 the same type at the same address can be sorted in arbitrary order. */
12085 if (a->owner->number != b->owner->number)
12086 return ((a->owner->number > b->owner->number)
12087 - (a->owner->number < b->owner->number));
12089 return (a > b) - (a < b);
12092 /* Set bp_location_placed_address_before_address_max and
12093 bp_location_shadow_len_after_address_max according to the current
12094 content of the bp_location array. */
12097 bp_location_target_extensions_update (void)
12099 struct bp_location *bl, **blp_tmp;
12101 bp_location_placed_address_before_address_max = 0;
12102 bp_location_shadow_len_after_address_max = 0;
12104 ALL_BP_LOCATIONS (bl, blp_tmp)
12106 CORE_ADDR start, end, addr;
12108 if (!bp_location_has_shadow (bl))
12111 start = bl->target_info.placed_address;
12112 end = start + bl->target_info.shadow_len;
12114 gdb_assert (bl->address >= start);
12115 addr = bl->address - start;
12116 if (addr > bp_location_placed_address_before_address_max)
12117 bp_location_placed_address_before_address_max = addr;
12119 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
12121 gdb_assert (bl->address < end);
12122 addr = end - bl->address;
12123 if (addr > bp_location_shadow_len_after_address_max)
12124 bp_location_shadow_len_after_address_max = addr;
12128 /* Download tracepoint locations if they haven't been. */
12131 download_tracepoint_locations (void)
12133 struct breakpoint *b;
12134 struct cleanup *old_chain;
12136 if (!target_can_download_tracepoint ())
12139 old_chain = save_current_space_and_thread ();
12141 ALL_TRACEPOINTS (b)
12143 struct bp_location *bl;
12144 struct tracepoint *t;
12145 int bp_location_downloaded = 0;
12147 if ((b->type == bp_fast_tracepoint
12148 ? !may_insert_fast_tracepoints
12149 : !may_insert_tracepoints))
12152 for (bl = b->loc; bl; bl = bl->next)
12154 /* In tracepoint, locations are _never_ duplicated, so
12155 should_be_inserted is equivalent to
12156 unduplicated_should_be_inserted. */
12157 if (!should_be_inserted (bl) || bl->inserted)
12160 switch_to_program_space_and_thread (bl->pspace);
12162 target_download_tracepoint (bl);
12165 bp_location_downloaded = 1;
12167 t = (struct tracepoint *) b;
12168 t->number_on_target = b->number;
12169 if (bp_location_downloaded)
12170 observer_notify_breakpoint_modified (b);
12173 do_cleanups (old_chain);
12176 /* Swap the insertion/duplication state between two locations. */
12179 swap_insertion (struct bp_location *left, struct bp_location *right)
12181 const int left_inserted = left->inserted;
12182 const int left_duplicate = left->duplicate;
12183 const int left_needs_update = left->needs_update;
12184 const struct bp_target_info left_target_info = left->target_info;
12186 /* Locations of tracepoints can never be duplicated. */
12187 if (is_tracepoint (left->owner))
12188 gdb_assert (!left->duplicate);
12189 if (is_tracepoint (right->owner))
12190 gdb_assert (!right->duplicate);
12192 left->inserted = right->inserted;
12193 left->duplicate = right->duplicate;
12194 left->needs_update = right->needs_update;
12195 left->target_info = right->target_info;
12196 right->inserted = left_inserted;
12197 right->duplicate = left_duplicate;
12198 right->needs_update = left_needs_update;
12199 right->target_info = left_target_info;
12202 /* Force the re-insertion of the locations at ADDRESS. This is called
12203 once a new/deleted/modified duplicate location is found and we are evaluating
12204 conditions on the target's side. Such conditions need to be updated on
12208 force_breakpoint_reinsertion (struct bp_location *bl)
12210 struct bp_location **locp = NULL, **loc2p;
12211 struct bp_location *loc;
12212 CORE_ADDR address = 0;
12215 address = bl->address;
12216 pspace_num = bl->pspace->num;
12218 /* This is only meaningful if the target is
12219 evaluating conditions and if the user has
12220 opted for condition evaluation on the target's
12222 if (gdb_evaluates_breakpoint_condition_p ()
12223 || !target_supports_evaluation_of_breakpoint_conditions ())
12226 /* Flag all breakpoint locations with this address and
12227 the same program space as the location
12228 as "its condition has changed". We need to
12229 update the conditions on the target's side. */
12230 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
12234 if (!is_breakpoint (loc->owner)
12235 || pspace_num != loc->pspace->num)
12238 /* Flag the location appropriately. We use a different state to
12239 let everyone know that we already updated the set of locations
12240 with addr bl->address and program space bl->pspace. This is so
12241 we don't have to keep calling these functions just to mark locations
12242 that have already been marked. */
12243 loc->condition_changed = condition_updated;
12245 /* Free the agent expression bytecode as well. We will compute
12247 if (loc->cond_bytecode)
12249 free_agent_expr (loc->cond_bytecode);
12250 loc->cond_bytecode = NULL;
12255 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
12256 into the inferior, only remove already-inserted locations that no
12257 longer should be inserted. Functions that delete a breakpoint or
12258 breakpoints should pass false, so that deleting a breakpoint
12259 doesn't have the side effect of inserting the locations of other
12260 breakpoints that are marked not-inserted, but should_be_inserted
12261 returns true on them.
12263 This behaviour is useful is situations close to tear-down -- e.g.,
12264 after an exec, while the target still has execution, but breakpoint
12265 shadows of the previous executable image should *NOT* be restored
12266 to the new image; or before detaching, where the target still has
12267 execution and wants to delete breakpoints from GDB's lists, and all
12268 breakpoints had already been removed from the inferior. */
12271 update_global_location_list (int should_insert)
12273 struct breakpoint *b;
12274 struct bp_location **locp, *loc;
12275 struct cleanup *cleanups;
12276 /* Last breakpoint location address that was marked for update. */
12277 CORE_ADDR last_addr = 0;
12278 /* Last breakpoint location program space that was marked for update. */
12279 int last_pspace_num = -1;
12281 /* Used in the duplicates detection below. When iterating over all
12282 bp_locations, points to the first bp_location of a given address.
12283 Breakpoints and watchpoints of different types are never
12284 duplicates of each other. Keep one pointer for each type of
12285 breakpoint/watchpoint, so we only need to loop over all locations
12287 struct bp_location *bp_loc_first; /* breakpoint */
12288 struct bp_location *wp_loc_first; /* hardware watchpoint */
12289 struct bp_location *awp_loc_first; /* access watchpoint */
12290 struct bp_location *rwp_loc_first; /* read watchpoint */
12292 /* Saved former bp_location array which we compare against the newly
12293 built bp_location from the current state of ALL_BREAKPOINTS. */
12294 struct bp_location **old_location, **old_locp;
12295 unsigned old_location_count;
12297 old_location = bp_location;
12298 old_location_count = bp_location_count;
12299 bp_location = NULL;
12300 bp_location_count = 0;
12301 cleanups = make_cleanup (xfree, old_location);
12303 ALL_BREAKPOINTS (b)
12304 for (loc = b->loc; loc; loc = loc->next)
12305 bp_location_count++;
12307 bp_location = xmalloc (sizeof (*bp_location) * bp_location_count);
12308 locp = bp_location;
12309 ALL_BREAKPOINTS (b)
12310 for (loc = b->loc; loc; loc = loc->next)
12312 qsort (bp_location, bp_location_count, sizeof (*bp_location),
12313 bp_location_compare);
12315 bp_location_target_extensions_update ();
12317 /* Identify bp_location instances that are no longer present in the
12318 new list, and therefore should be freed. Note that it's not
12319 necessary that those locations should be removed from inferior --
12320 if there's another location at the same address (previously
12321 marked as duplicate), we don't need to remove/insert the
12324 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12325 and former bp_location array state respectively. */
12327 locp = bp_location;
12328 for (old_locp = old_location; old_locp < old_location + old_location_count;
12331 struct bp_location *old_loc = *old_locp;
12332 struct bp_location **loc2p;
12334 /* Tells if 'old_loc' is found among the new locations. If
12335 not, we have to free it. */
12336 int found_object = 0;
12337 /* Tells if the location should remain inserted in the target. */
12338 int keep_in_target = 0;
12341 /* Skip LOCP entries which will definitely never be needed.
12342 Stop either at or being the one matching OLD_LOC. */
12343 while (locp < bp_location + bp_location_count
12344 && (*locp)->address < old_loc->address)
12348 (loc2p < bp_location + bp_location_count
12349 && (*loc2p)->address == old_loc->address);
12352 /* Check if this is a new/duplicated location or a duplicated
12353 location that had its condition modified. If so, we want to send
12354 its condition to the target if evaluation of conditions is taking
12356 if ((*loc2p)->condition_changed == condition_modified
12357 && (last_addr != old_loc->address
12358 || last_pspace_num != old_loc->pspace->num))
12360 force_breakpoint_reinsertion (*loc2p);
12361 last_pspace_num = old_loc->pspace->num;
12364 if (*loc2p == old_loc)
12368 /* We have already handled this address, update it so that we don't
12369 have to go through updates again. */
12370 last_addr = old_loc->address;
12372 /* Target-side condition evaluation: Handle deleted locations. */
12374 force_breakpoint_reinsertion (old_loc);
12376 /* If this location is no longer present, and inserted, look if
12377 there's maybe a new location at the same address. If so,
12378 mark that one inserted, and don't remove this one. This is
12379 needed so that we don't have a time window where a breakpoint
12380 at certain location is not inserted. */
12382 if (old_loc->inserted)
12384 /* If the location is inserted now, we might have to remove
12387 if (found_object && should_be_inserted (old_loc))
12389 /* The location is still present in the location list,
12390 and still should be inserted. Don't do anything. */
12391 keep_in_target = 1;
12395 /* This location still exists, but it won't be kept in the
12396 target since it may have been disabled. We proceed to
12397 remove its target-side condition. */
12399 /* The location is either no longer present, or got
12400 disabled. See if there's another location at the
12401 same address, in which case we don't need to remove
12402 this one from the target. */
12404 /* OLD_LOC comes from existing struct breakpoint. */
12405 if (breakpoint_address_is_meaningful (old_loc->owner))
12408 (loc2p < bp_location + bp_location_count
12409 && (*loc2p)->address == old_loc->address);
12412 struct bp_location *loc2 = *loc2p;
12414 if (breakpoint_locations_match (loc2, old_loc))
12416 /* Read watchpoint locations are switched to
12417 access watchpoints, if the former are not
12418 supported, but the latter are. */
12419 if (is_hardware_watchpoint (old_loc->owner))
12421 gdb_assert (is_hardware_watchpoint (loc2->owner));
12422 loc2->watchpoint_type = old_loc->watchpoint_type;
12425 /* loc2 is a duplicated location. We need to check
12426 if it should be inserted in case it will be
12428 if (loc2 != old_loc
12429 && unduplicated_should_be_inserted (loc2))
12431 swap_insertion (old_loc, loc2);
12432 keep_in_target = 1;
12440 if (!keep_in_target)
12442 if (remove_breakpoint (old_loc, mark_uninserted))
12444 /* This is just about all we can do. We could keep
12445 this location on the global list, and try to
12446 remove it next time, but there's no particular
12447 reason why we will succeed next time.
12449 Note that at this point, old_loc->owner is still
12450 valid, as delete_breakpoint frees the breakpoint
12451 only after calling us. */
12452 printf_filtered (_("warning: Error removing "
12453 "breakpoint %d\n"),
12454 old_loc->owner->number);
12462 if (removed && non_stop
12463 && breakpoint_address_is_meaningful (old_loc->owner)
12464 && !is_hardware_watchpoint (old_loc->owner))
12466 /* This location was removed from the target. In
12467 non-stop mode, a race condition is possible where
12468 we've removed a breakpoint, but stop events for that
12469 breakpoint are already queued and will arrive later.
12470 We apply an heuristic to be able to distinguish such
12471 SIGTRAPs from other random SIGTRAPs: we keep this
12472 breakpoint location for a bit, and will retire it
12473 after we see some number of events. The theory here
12474 is that reporting of events should, "on the average",
12475 be fair, so after a while we'll see events from all
12476 threads that have anything of interest, and no longer
12477 need to keep this breakpoint location around. We
12478 don't hold locations forever so to reduce chances of
12479 mistaking a non-breakpoint SIGTRAP for a breakpoint
12482 The heuristic failing can be disastrous on
12483 decr_pc_after_break targets.
12485 On decr_pc_after_break targets, like e.g., x86-linux,
12486 if we fail to recognize a late breakpoint SIGTRAP,
12487 because events_till_retirement has reached 0 too
12488 soon, we'll fail to do the PC adjustment, and report
12489 a random SIGTRAP to the user. When the user resumes
12490 the inferior, it will most likely immediately crash
12491 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12492 corrupted, because of being resumed e.g., in the
12493 middle of a multi-byte instruction, or skipped a
12494 one-byte instruction. This was actually seen happen
12495 on native x86-linux, and should be less rare on
12496 targets that do not support new thread events, like
12497 remote, due to the heuristic depending on
12500 Mistaking a random SIGTRAP for a breakpoint trap
12501 causes similar symptoms (PC adjustment applied when
12502 it shouldn't), but then again, playing with SIGTRAPs
12503 behind the debugger's back is asking for trouble.
12505 Since hardware watchpoint traps are always
12506 distinguishable from other traps, so we don't need to
12507 apply keep hardware watchpoint moribund locations
12508 around. We simply always ignore hardware watchpoint
12509 traps we can no longer explain. */
12511 old_loc->events_till_retirement = 3 * (thread_count () + 1);
12512 old_loc->owner = NULL;
12514 VEC_safe_push (bp_location_p, moribund_locations, old_loc);
12518 old_loc->owner = NULL;
12519 decref_bp_location (&old_loc);
12524 /* Rescan breakpoints at the same address and section, marking the
12525 first one as "first" and any others as "duplicates". This is so
12526 that the bpt instruction is only inserted once. If we have a
12527 permanent breakpoint at the same place as BPT, make that one the
12528 official one, and the rest as duplicates. Permanent breakpoints
12529 are sorted first for the same address.
12531 Do the same for hardware watchpoints, but also considering the
12532 watchpoint's type (regular/access/read) and length. */
12534 bp_loc_first = NULL;
12535 wp_loc_first = NULL;
12536 awp_loc_first = NULL;
12537 rwp_loc_first = NULL;
12538 ALL_BP_LOCATIONS (loc, locp)
12540 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12542 struct bp_location **loc_first_p;
12545 if (!unduplicated_should_be_inserted (loc)
12546 || !breakpoint_address_is_meaningful (b)
12547 /* Don't detect duplicate for tracepoint locations because they are
12548 never duplicated. See the comments in field `duplicate' of
12549 `struct bp_location'. */
12550 || is_tracepoint (b))
12552 /* Clear the condition modification flag. */
12553 loc->condition_changed = condition_unchanged;
12557 /* Permanent breakpoint should always be inserted. */
12558 if (b->enable_state == bp_permanent && ! loc->inserted)
12559 internal_error (__FILE__, __LINE__,
12560 _("allegedly permanent breakpoint is not "
12561 "actually inserted"));
12563 if (b->type == bp_hardware_watchpoint)
12564 loc_first_p = &wp_loc_first;
12565 else if (b->type == bp_read_watchpoint)
12566 loc_first_p = &rwp_loc_first;
12567 else if (b->type == bp_access_watchpoint)
12568 loc_first_p = &awp_loc_first;
12570 loc_first_p = &bp_loc_first;
12572 if (*loc_first_p == NULL
12573 || (overlay_debugging && loc->section != (*loc_first_p)->section)
12574 || !breakpoint_locations_match (loc, *loc_first_p))
12576 *loc_first_p = loc;
12577 loc->duplicate = 0;
12579 if (is_breakpoint (loc->owner) && loc->condition_changed)
12581 loc->needs_update = 1;
12582 /* Clear the condition modification flag. */
12583 loc->condition_changed = condition_unchanged;
12589 /* This and the above ensure the invariant that the first location
12590 is not duplicated, and is the inserted one.
12591 All following are marked as duplicated, and are not inserted. */
12593 swap_insertion (loc, *loc_first_p);
12594 loc->duplicate = 1;
12596 /* Clear the condition modification flag. */
12597 loc->condition_changed = condition_unchanged;
12599 if ((*loc_first_p)->owner->enable_state == bp_permanent && loc->inserted
12600 && b->enable_state != bp_permanent)
12601 internal_error (__FILE__, __LINE__,
12602 _("another breakpoint was inserted on top of "
12603 "a permanent breakpoint"));
12606 if (breakpoints_always_inserted_mode ()
12607 && (have_live_inferiors ()
12608 || (gdbarch_has_global_breakpoints (target_gdbarch ()))))
12611 insert_breakpoint_locations ();
12614 /* Though should_insert is false, we may need to update conditions
12615 on the target's side if it is evaluating such conditions. We
12616 only update conditions for locations that are marked
12618 update_inserted_breakpoint_locations ();
12623 download_tracepoint_locations ();
12625 do_cleanups (cleanups);
12629 breakpoint_retire_moribund (void)
12631 struct bp_location *loc;
12634 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
12635 if (--(loc->events_till_retirement) == 0)
12637 decref_bp_location (&loc);
12638 VEC_unordered_remove (bp_location_p, moribund_locations, ix);
12644 update_global_location_list_nothrow (int inserting)
12646 volatile struct gdb_exception e;
12648 TRY_CATCH (e, RETURN_MASK_ERROR)
12649 update_global_location_list (inserting);
12652 /* Clear BKP from a BPS. */
12655 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12659 for (bs = bps; bs; bs = bs->next)
12660 if (bs->breakpoint_at == bpt)
12662 bs->breakpoint_at = NULL;
12663 bs->old_val = NULL;
12664 /* bs->commands will be freed later. */
12668 /* Callback for iterate_over_threads. */
12670 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12672 struct breakpoint *bpt = data;
12674 bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12678 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12682 say_where (struct breakpoint *b)
12684 struct value_print_options opts;
12686 get_user_print_options (&opts);
12688 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12690 if (b->loc == NULL)
12692 printf_filtered (_(" (%s) pending."), b->addr_string);
12696 if (opts.addressprint || b->loc->symtab == NULL)
12698 printf_filtered (" at ");
12699 fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
12702 if (b->loc->symtab != NULL)
12704 /* If there is a single location, we can print the location
12706 if (b->loc->next == NULL)
12707 printf_filtered (": file %s, line %d.",
12708 symtab_to_filename_for_display (b->loc->symtab),
12709 b->loc->line_number);
12711 /* This is not ideal, but each location may have a
12712 different file name, and this at least reflects the
12713 real situation somewhat. */
12714 printf_filtered (": %s.", b->addr_string);
12719 struct bp_location *loc = b->loc;
12721 for (; loc; loc = loc->next)
12723 printf_filtered (" (%d locations)", n);
12728 /* Default bp_location_ops methods. */
12731 bp_location_dtor (struct bp_location *self)
12733 xfree (self->cond);
12734 if (self->cond_bytecode)
12735 free_agent_expr (self->cond_bytecode);
12736 xfree (self->function_name);
12739 static const struct bp_location_ops bp_location_ops =
12744 /* Default breakpoint_ops methods all breakpoint_ops ultimately
12748 base_breakpoint_dtor (struct breakpoint *self)
12750 decref_counted_command_line (&self->commands);
12751 xfree (self->cond_string);
12752 xfree (self->extra_string);
12753 xfree (self->addr_string);
12754 xfree (self->filter);
12755 xfree (self->addr_string_range_end);
12758 static struct bp_location *
12759 base_breakpoint_allocate_location (struct breakpoint *self)
12761 struct bp_location *loc;
12763 loc = XNEW (struct bp_location);
12764 init_bp_location (loc, &bp_location_ops, self);
12769 base_breakpoint_re_set (struct breakpoint *b)
12771 /* Nothing to re-set. */
12774 #define internal_error_pure_virtual_called() \
12775 gdb_assert_not_reached ("pure virtual function called")
12778 base_breakpoint_insert_location (struct bp_location *bl)
12780 internal_error_pure_virtual_called ();
12784 base_breakpoint_remove_location (struct bp_location *bl)
12786 internal_error_pure_virtual_called ();
12790 base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12791 struct address_space *aspace,
12793 const struct target_waitstatus *ws)
12795 internal_error_pure_virtual_called ();
12799 base_breakpoint_check_status (bpstat bs)
12804 /* A "works_in_software_mode" breakpoint_ops method that just internal
12808 base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12810 internal_error_pure_virtual_called ();
12813 /* A "resources_needed" breakpoint_ops method that just internal
12817 base_breakpoint_resources_needed (const struct bp_location *bl)
12819 internal_error_pure_virtual_called ();
12822 static enum print_stop_action
12823 base_breakpoint_print_it (bpstat bs)
12825 internal_error_pure_virtual_called ();
12829 base_breakpoint_print_one_detail (const struct breakpoint *self,
12830 struct ui_out *uiout)
12836 base_breakpoint_print_mention (struct breakpoint *b)
12838 internal_error_pure_virtual_called ();
12842 base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12844 internal_error_pure_virtual_called ();
12848 base_breakpoint_create_sals_from_address (char **arg,
12849 struct linespec_result *canonical,
12850 enum bptype type_wanted,
12854 internal_error_pure_virtual_called ();
12858 base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12859 struct linespec_result *c,
12861 char *extra_string,
12862 enum bptype type_wanted,
12863 enum bpdisp disposition,
12865 int task, int ignore_count,
12866 const struct breakpoint_ops *o,
12867 int from_tty, int enabled,
12868 int internal, unsigned flags)
12870 internal_error_pure_virtual_called ();
12874 base_breakpoint_decode_linespec (struct breakpoint *b, char **s,
12875 struct symtabs_and_lines *sals)
12877 internal_error_pure_virtual_called ();
12880 /* The default 'explains_signal' method. */
12883 base_breakpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
12888 /* The default "after_condition_true" method. */
12891 base_breakpoint_after_condition_true (struct bpstats *bs)
12893 /* Nothing to do. */
12896 struct breakpoint_ops base_breakpoint_ops =
12898 base_breakpoint_dtor,
12899 base_breakpoint_allocate_location,
12900 base_breakpoint_re_set,
12901 base_breakpoint_insert_location,
12902 base_breakpoint_remove_location,
12903 base_breakpoint_breakpoint_hit,
12904 base_breakpoint_check_status,
12905 base_breakpoint_resources_needed,
12906 base_breakpoint_works_in_software_mode,
12907 base_breakpoint_print_it,
12909 base_breakpoint_print_one_detail,
12910 base_breakpoint_print_mention,
12911 base_breakpoint_print_recreate,
12912 base_breakpoint_create_sals_from_address,
12913 base_breakpoint_create_breakpoints_sal,
12914 base_breakpoint_decode_linespec,
12915 base_breakpoint_explains_signal,
12916 base_breakpoint_after_condition_true,
12919 /* Default breakpoint_ops methods. */
12922 bkpt_re_set (struct breakpoint *b)
12924 /* FIXME: is this still reachable? */
12925 if (b->addr_string == NULL)
12927 /* Anything without a string can't be re-set. */
12928 delete_breakpoint (b);
12932 breakpoint_re_set_default (b);
12936 bkpt_insert_location (struct bp_location *bl)
12938 if (bl->loc_type == bp_loc_hardware_breakpoint)
12939 return target_insert_hw_breakpoint (bl->gdbarch,
12942 return target_insert_breakpoint (bl->gdbarch,
12947 bkpt_remove_location (struct bp_location *bl)
12949 if (bl->loc_type == bp_loc_hardware_breakpoint)
12950 return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
12952 return target_remove_breakpoint (bl->gdbarch, &bl->target_info);
12956 bkpt_breakpoint_hit (const struct bp_location *bl,
12957 struct address_space *aspace, CORE_ADDR bp_addr,
12958 const struct target_waitstatus *ws)
12960 if (ws->kind != TARGET_WAITKIND_STOPPED
12961 || ws->value.sig != GDB_SIGNAL_TRAP)
12964 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
12968 if (overlay_debugging /* unmapped overlay section */
12969 && section_is_overlay (bl->section)
12970 && !section_is_mapped (bl->section))
12977 bkpt_resources_needed (const struct bp_location *bl)
12979 gdb_assert (bl->owner->type == bp_hardware_breakpoint);
12984 static enum print_stop_action
12985 bkpt_print_it (bpstat bs)
12987 struct breakpoint *b;
12988 const struct bp_location *bl;
12990 struct ui_out *uiout = current_uiout;
12992 gdb_assert (bs->bp_location_at != NULL);
12994 bl = bs->bp_location_at;
12995 b = bs->breakpoint_at;
12997 bp_temp = b->disposition == disp_del;
12998 if (bl->address != bl->requested_address)
12999 breakpoint_adjustment_warning (bl->requested_address,
13002 annotate_breakpoint (b->number);
13004 ui_out_text (uiout, "\nTemporary breakpoint ");
13006 ui_out_text (uiout, "\nBreakpoint ");
13007 if (ui_out_is_mi_like_p (uiout))
13009 ui_out_field_string (uiout, "reason",
13010 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
13011 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
13013 ui_out_field_int (uiout, "bkptno", b->number);
13014 ui_out_text (uiout, ", ");
13016 return PRINT_SRC_AND_LOC;
13020 bkpt_print_mention (struct breakpoint *b)
13022 if (ui_out_is_mi_like_p (current_uiout))
13027 case bp_breakpoint:
13028 case bp_gnu_ifunc_resolver:
13029 if (b->disposition == disp_del)
13030 printf_filtered (_("Temporary breakpoint"));
13032 printf_filtered (_("Breakpoint"));
13033 printf_filtered (_(" %d"), b->number);
13034 if (b->type == bp_gnu_ifunc_resolver)
13035 printf_filtered (_(" at gnu-indirect-function resolver"));
13037 case bp_hardware_breakpoint:
13038 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
13041 printf_filtered (_("Dprintf %d"), b->number);
13049 bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
13051 if (tp->type == bp_breakpoint && tp->disposition == disp_del)
13052 fprintf_unfiltered (fp, "tbreak");
13053 else if (tp->type == bp_breakpoint)
13054 fprintf_unfiltered (fp, "break");
13055 else if (tp->type == bp_hardware_breakpoint
13056 && tp->disposition == disp_del)
13057 fprintf_unfiltered (fp, "thbreak");
13058 else if (tp->type == bp_hardware_breakpoint)
13059 fprintf_unfiltered (fp, "hbreak");
13061 internal_error (__FILE__, __LINE__,
13062 _("unhandled breakpoint type %d"), (int) tp->type);
13064 fprintf_unfiltered (fp, " %s", tp->addr_string);
13065 print_recreate_thread (tp, fp);
13069 bkpt_create_sals_from_address (char **arg,
13070 struct linespec_result *canonical,
13071 enum bptype type_wanted,
13072 char *addr_start, char **copy_arg)
13074 create_sals_from_address_default (arg, canonical, type_wanted,
13075 addr_start, copy_arg);
13079 bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
13080 struct linespec_result *canonical,
13082 char *extra_string,
13083 enum bptype type_wanted,
13084 enum bpdisp disposition,
13086 int task, int ignore_count,
13087 const struct breakpoint_ops *ops,
13088 int from_tty, int enabled,
13089 int internal, unsigned flags)
13091 create_breakpoints_sal_default (gdbarch, canonical,
13092 cond_string, extra_string,
13094 disposition, thread, task,
13095 ignore_count, ops, from_tty,
13096 enabled, internal, flags);
13100 bkpt_decode_linespec (struct breakpoint *b, char **s,
13101 struct symtabs_and_lines *sals)
13103 decode_linespec_default (b, s, sals);
13106 /* Virtual table for internal breakpoints. */
13109 internal_bkpt_re_set (struct breakpoint *b)
13113 /* Delete overlay event and longjmp master breakpoints; they
13114 will be reset later by breakpoint_re_set. */
13115 case bp_overlay_event:
13116 case bp_longjmp_master:
13117 case bp_std_terminate_master:
13118 case bp_exception_master:
13119 delete_breakpoint (b);
13122 /* This breakpoint is special, it's set up when the inferior
13123 starts and we really don't want to touch it. */
13124 case bp_shlib_event:
13126 /* Like bp_shlib_event, this breakpoint type is special. Once
13127 it is set up, we do not want to touch it. */
13128 case bp_thread_event:
13134 internal_bkpt_check_status (bpstat bs)
13136 if (bs->breakpoint_at->type == bp_shlib_event)
13138 /* If requested, stop when the dynamic linker notifies GDB of
13139 events. This allows the user to get control and place
13140 breakpoints in initializer routines for dynamically loaded
13141 objects (among other things). */
13142 bs->stop = stop_on_solib_events;
13143 bs->print = stop_on_solib_events;
13149 static enum print_stop_action
13150 internal_bkpt_print_it (bpstat bs)
13152 struct breakpoint *b;
13154 b = bs->breakpoint_at;
13158 case bp_shlib_event:
13159 /* Did we stop because the user set the stop_on_solib_events
13160 variable? (If so, we report this as a generic, "Stopped due
13161 to shlib event" message.) */
13162 print_solib_event (0);
13165 case bp_thread_event:
13166 /* Not sure how we will get here.
13167 GDB should not stop for these breakpoints. */
13168 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
13171 case bp_overlay_event:
13172 /* By analogy with the thread event, GDB should not stop for these. */
13173 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
13176 case bp_longjmp_master:
13177 /* These should never be enabled. */
13178 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
13181 case bp_std_terminate_master:
13182 /* These should never be enabled. */
13183 printf_filtered (_("std::terminate Master Breakpoint: "
13184 "gdb should not stop!\n"));
13187 case bp_exception_master:
13188 /* These should never be enabled. */
13189 printf_filtered (_("Exception Master Breakpoint: "
13190 "gdb should not stop!\n"));
13194 return PRINT_NOTHING;
13198 internal_bkpt_print_mention (struct breakpoint *b)
13200 /* Nothing to mention. These breakpoints are internal. */
13203 /* Virtual table for momentary breakpoints */
13206 momentary_bkpt_re_set (struct breakpoint *b)
13208 /* Keep temporary breakpoints, which can be encountered when we step
13209 over a dlopen call and solib_add is resetting the breakpoints.
13210 Otherwise these should have been blown away via the cleanup chain
13211 or by breakpoint_init_inferior when we rerun the executable. */
13215 momentary_bkpt_check_status (bpstat bs)
13217 /* Nothing. The point of these breakpoints is causing a stop. */
13220 static enum print_stop_action
13221 momentary_bkpt_print_it (bpstat bs)
13223 struct ui_out *uiout = current_uiout;
13225 if (ui_out_is_mi_like_p (uiout))
13227 struct breakpoint *b = bs->breakpoint_at;
13232 ui_out_field_string
13234 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED));
13238 ui_out_field_string
13240 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED));
13245 return PRINT_UNKNOWN;
13249 momentary_bkpt_print_mention (struct breakpoint *b)
13251 /* Nothing to mention. These breakpoints are internal. */
13254 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13256 It gets cleared already on the removal of the first one of such placed
13257 breakpoints. This is OK as they get all removed altogether. */
13260 longjmp_bkpt_dtor (struct breakpoint *self)
13262 struct thread_info *tp = find_thread_id (self->thread);
13265 tp->initiating_frame = null_frame_id;
13267 momentary_breakpoint_ops.dtor (self);
13270 /* Specific methods for probe breakpoints. */
13273 bkpt_probe_insert_location (struct bp_location *bl)
13275 int v = bkpt_insert_location (bl);
13279 /* The insertion was successful, now let's set the probe's semaphore
13281 bl->probe->pops->set_semaphore (bl->probe, bl->gdbarch);
13288 bkpt_probe_remove_location (struct bp_location *bl)
13290 /* Let's clear the semaphore before removing the location. */
13291 bl->probe->pops->clear_semaphore (bl->probe, bl->gdbarch);
13293 return bkpt_remove_location (bl);
13297 bkpt_probe_create_sals_from_address (char **arg,
13298 struct linespec_result *canonical,
13299 enum bptype type_wanted,
13300 char *addr_start, char **copy_arg)
13302 struct linespec_sals lsal;
13304 lsal.sals = parse_probes (arg, canonical);
13306 *copy_arg = xstrdup (canonical->addr_string);
13307 lsal.canonical = xstrdup (*copy_arg);
13309 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13313 bkpt_probe_decode_linespec (struct breakpoint *b, char **s,
13314 struct symtabs_and_lines *sals)
13316 *sals = parse_probes (s, NULL);
13318 error (_("probe not found"));
13321 /* The breakpoint_ops structure to be used in tracepoints. */
13324 tracepoint_re_set (struct breakpoint *b)
13326 breakpoint_re_set_default (b);
13330 tracepoint_breakpoint_hit (const struct bp_location *bl,
13331 struct address_space *aspace, CORE_ADDR bp_addr,
13332 const struct target_waitstatus *ws)
13334 /* By definition, the inferior does not report stops at
13340 tracepoint_print_one_detail (const struct breakpoint *self,
13341 struct ui_out *uiout)
13343 struct tracepoint *tp = (struct tracepoint *) self;
13344 if (tp->static_trace_marker_id)
13346 gdb_assert (self->type == bp_static_tracepoint);
13348 ui_out_text (uiout, "\tmarker id is ");
13349 ui_out_field_string (uiout, "static-tracepoint-marker-string-id",
13350 tp->static_trace_marker_id);
13351 ui_out_text (uiout, "\n");
13356 tracepoint_print_mention (struct breakpoint *b)
13358 if (ui_out_is_mi_like_p (current_uiout))
13363 case bp_tracepoint:
13364 printf_filtered (_("Tracepoint"));
13365 printf_filtered (_(" %d"), b->number);
13367 case bp_fast_tracepoint:
13368 printf_filtered (_("Fast tracepoint"));
13369 printf_filtered (_(" %d"), b->number);
13371 case bp_static_tracepoint:
13372 printf_filtered (_("Static tracepoint"));
13373 printf_filtered (_(" %d"), b->number);
13376 internal_error (__FILE__, __LINE__,
13377 _("unhandled tracepoint type %d"), (int) b->type);
13384 tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
13386 struct tracepoint *tp = (struct tracepoint *) self;
13388 if (self->type == bp_fast_tracepoint)
13389 fprintf_unfiltered (fp, "ftrace");
13390 if (self->type == bp_static_tracepoint)
13391 fprintf_unfiltered (fp, "strace");
13392 else if (self->type == bp_tracepoint)
13393 fprintf_unfiltered (fp, "trace");
13395 internal_error (__FILE__, __LINE__,
13396 _("unhandled tracepoint type %d"), (int) self->type);
13398 fprintf_unfiltered (fp, " %s", self->addr_string);
13399 print_recreate_thread (self, fp);
13401 if (tp->pass_count)
13402 fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
13406 tracepoint_create_sals_from_address (char **arg,
13407 struct linespec_result *canonical,
13408 enum bptype type_wanted,
13409 char *addr_start, char **copy_arg)
13411 create_sals_from_address_default (arg, canonical, type_wanted,
13412 addr_start, copy_arg);
13416 tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
13417 struct linespec_result *canonical,
13419 char *extra_string,
13420 enum bptype type_wanted,
13421 enum bpdisp disposition,
13423 int task, int ignore_count,
13424 const struct breakpoint_ops *ops,
13425 int from_tty, int enabled,
13426 int internal, unsigned flags)
13428 create_breakpoints_sal_default (gdbarch, canonical,
13429 cond_string, extra_string,
13431 disposition, thread, task,
13432 ignore_count, ops, from_tty,
13433 enabled, internal, flags);
13437 tracepoint_decode_linespec (struct breakpoint *b, char **s,
13438 struct symtabs_and_lines *sals)
13440 decode_linespec_default (b, s, sals);
13443 struct breakpoint_ops tracepoint_breakpoint_ops;
13445 /* The breakpoint_ops structure to be use on tracepoints placed in a
13449 tracepoint_probe_create_sals_from_address (char **arg,
13450 struct linespec_result *canonical,
13451 enum bptype type_wanted,
13452 char *addr_start, char **copy_arg)
13454 /* We use the same method for breakpoint on probes. */
13455 bkpt_probe_create_sals_from_address (arg, canonical, type_wanted,
13456 addr_start, copy_arg);
13460 tracepoint_probe_decode_linespec (struct breakpoint *b, char **s,
13461 struct symtabs_and_lines *sals)
13463 /* We use the same method for breakpoint on probes. */
13464 bkpt_probe_decode_linespec (b, s, sals);
13467 static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
13469 /* Dprintf breakpoint_ops methods. */
13472 dprintf_re_set (struct breakpoint *b)
13474 breakpoint_re_set_default (b);
13476 /* This breakpoint could have been pending, and be resolved now, and
13477 if so, we should now have the extra string. If we don't, the
13478 dprintf was malformed when created, but we couldn't tell because
13479 we can't extract the extra string until the location is
13481 if (b->loc != NULL && b->extra_string == NULL)
13482 error (_("Format string required"));
13484 /* 1 - connect to target 1, that can run breakpoint commands.
13485 2 - create a dprintf, which resolves fine.
13486 3 - disconnect from target 1
13487 4 - connect to target 2, that can NOT run breakpoint commands.
13489 After steps #3/#4, you'll want the dprintf command list to
13490 be updated, because target 1 and 2 may well return different
13491 answers for target_can_run_breakpoint_commands().
13492 Given absence of finer grained resetting, we get to do
13493 it all the time. */
13494 if (b->extra_string != NULL)
13495 update_dprintf_command_list (b);
13498 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13501 dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp)
13503 fprintf_unfiltered (fp, "dprintf %s%s", tp->addr_string,
13505 print_recreate_thread (tp, fp);
13508 /* Implement the "after_condition_true" breakpoint_ops method for
13511 dprintf's are implemented with regular commands in their command
13512 list, but we run the commands here instead of before presenting the
13513 stop to the user, as dprintf's don't actually cause a stop. This
13514 also makes it so that the commands of multiple dprintfs at the same
13515 address are all handled. */
13518 dprintf_after_condition_true (struct bpstats *bs)
13520 struct cleanup *old_chain;
13521 struct bpstats tmp_bs = { NULL };
13522 struct bpstats *tmp_bs_p = &tmp_bs;
13524 /* dprintf's never cause a stop. This wasn't set in the
13525 check_status hook instead because that would make the dprintf's
13526 condition not be evaluated. */
13529 /* Run the command list here. Take ownership of it instead of
13530 copying. We never want these commands to run later in
13531 bpstat_do_actions, if a breakpoint that causes a stop happens to
13532 be set at same address as this dprintf, or even if running the
13533 commands here throws. */
13534 tmp_bs.commands = bs->commands;
13535 bs->commands = NULL;
13536 old_chain = make_cleanup_decref_counted_command_line (&tmp_bs.commands);
13538 bpstat_do_actions_1 (&tmp_bs_p);
13540 /* 'tmp_bs.commands' will usually be NULL by now, but
13541 bpstat_do_actions_1 may return early without processing the whole
13543 do_cleanups (old_chain);
13546 /* The breakpoint_ops structure to be used on static tracepoints with
13550 strace_marker_create_sals_from_address (char **arg,
13551 struct linespec_result *canonical,
13552 enum bptype type_wanted,
13553 char *addr_start, char **copy_arg)
13555 struct linespec_sals lsal;
13557 lsal.sals = decode_static_tracepoint_spec (arg);
13559 *copy_arg = savestring (addr_start, *arg - addr_start);
13561 canonical->addr_string = xstrdup (*copy_arg);
13562 lsal.canonical = xstrdup (*copy_arg);
13563 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13567 strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
13568 struct linespec_result *canonical,
13570 char *extra_string,
13571 enum bptype type_wanted,
13572 enum bpdisp disposition,
13574 int task, int ignore_count,
13575 const struct breakpoint_ops *ops,
13576 int from_tty, int enabled,
13577 int internal, unsigned flags)
13580 struct linespec_sals *lsal = VEC_index (linespec_sals,
13581 canonical->sals, 0);
13583 /* If the user is creating a static tracepoint by marker id
13584 (strace -m MARKER_ID), then store the sals index, so that
13585 breakpoint_re_set can try to match up which of the newly
13586 found markers corresponds to this one, and, don't try to
13587 expand multiple locations for each sal, given than SALS
13588 already should contain all sals for MARKER_ID. */
13590 for (i = 0; i < lsal->sals.nelts; ++i)
13592 struct symtabs_and_lines expanded;
13593 struct tracepoint *tp;
13594 struct cleanup *old_chain;
13597 expanded.nelts = 1;
13598 expanded.sals = &lsal->sals.sals[i];
13600 addr_string = xstrdup (canonical->addr_string);
13601 old_chain = make_cleanup (xfree, addr_string);
13603 tp = XCNEW (struct tracepoint);
13604 init_breakpoint_sal (&tp->base, gdbarch, expanded,
13606 cond_string, extra_string,
13607 type_wanted, disposition,
13608 thread, task, ignore_count, ops,
13609 from_tty, enabled, internal, flags,
13610 canonical->special_display);
13611 /* Given that its possible to have multiple markers with
13612 the same string id, if the user is creating a static
13613 tracepoint by marker id ("strace -m MARKER_ID"), then
13614 store the sals index, so that breakpoint_re_set can
13615 try to match up which of the newly found markers
13616 corresponds to this one */
13617 tp->static_trace_marker_id_idx = i;
13619 install_breakpoint (internal, &tp->base, 0);
13621 discard_cleanups (old_chain);
13626 strace_marker_decode_linespec (struct breakpoint *b, char **s,
13627 struct symtabs_and_lines *sals)
13629 struct tracepoint *tp = (struct tracepoint *) b;
13631 *sals = decode_static_tracepoint_spec (s);
13632 if (sals->nelts > tp->static_trace_marker_id_idx)
13634 sals->sals[0] = sals->sals[tp->static_trace_marker_id_idx];
13638 error (_("marker %s not found"), tp->static_trace_marker_id);
13641 static struct breakpoint_ops strace_marker_breakpoint_ops;
13644 strace_marker_p (struct breakpoint *b)
13646 return b->ops == &strace_marker_breakpoint_ops;
13649 /* Delete a breakpoint and clean up all traces of it in the data
13653 delete_breakpoint (struct breakpoint *bpt)
13655 struct breakpoint *b;
13657 gdb_assert (bpt != NULL);
13659 /* Has this bp already been deleted? This can happen because
13660 multiple lists can hold pointers to bp's. bpstat lists are
13663 One example of this happening is a watchpoint's scope bp. When
13664 the scope bp triggers, we notice that the watchpoint is out of
13665 scope, and delete it. We also delete its scope bp. But the
13666 scope bp is marked "auto-deleting", and is already on a bpstat.
13667 That bpstat is then checked for auto-deleting bp's, which are
13670 A real solution to this problem might involve reference counts in
13671 bp's, and/or giving them pointers back to their referencing
13672 bpstat's, and teaching delete_breakpoint to only free a bp's
13673 storage when no more references were extent. A cheaper bandaid
13675 if (bpt->type == bp_none)
13678 /* At least avoid this stale reference until the reference counting
13679 of breakpoints gets resolved. */
13680 if (bpt->related_breakpoint != bpt)
13682 struct breakpoint *related;
13683 struct watchpoint *w;
13685 if (bpt->type == bp_watchpoint_scope)
13686 w = (struct watchpoint *) bpt->related_breakpoint;
13687 else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
13688 w = (struct watchpoint *) bpt;
13692 watchpoint_del_at_next_stop (w);
13694 /* Unlink bpt from the bpt->related_breakpoint ring. */
13695 for (related = bpt; related->related_breakpoint != bpt;
13696 related = related->related_breakpoint);
13697 related->related_breakpoint = bpt->related_breakpoint;
13698 bpt->related_breakpoint = bpt;
13701 /* watch_command_1 creates a watchpoint but only sets its number if
13702 update_watchpoint succeeds in creating its bp_locations. If there's
13703 a problem in that process, we'll be asked to delete the half-created
13704 watchpoint. In that case, don't announce the deletion. */
13706 observer_notify_breakpoint_deleted (bpt);
13708 if (breakpoint_chain == bpt)
13709 breakpoint_chain = bpt->next;
13711 ALL_BREAKPOINTS (b)
13712 if (b->next == bpt)
13714 b->next = bpt->next;
13718 /* Be sure no bpstat's are pointing at the breakpoint after it's
13720 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13721 in all threads for now. Note that we cannot just remove bpstats
13722 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13723 commands are associated with the bpstat; if we remove it here,
13724 then the later call to bpstat_do_actions (&stop_bpstat); in
13725 event-top.c won't do anything, and temporary breakpoints with
13726 commands won't work. */
13728 iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13730 /* Now that breakpoint is removed from breakpoint list, update the
13731 global location list. This will remove locations that used to
13732 belong to this breakpoint. Do this before freeing the breakpoint
13733 itself, since remove_breakpoint looks at location's owner. It
13734 might be better design to have location completely
13735 self-contained, but it's not the case now. */
13736 update_global_location_list (0);
13738 bpt->ops->dtor (bpt);
13739 /* On the chance that someone will soon try again to delete this
13740 same bp, we mark it as deleted before freeing its storage. */
13741 bpt->type = bp_none;
13746 do_delete_breakpoint_cleanup (void *b)
13748 delete_breakpoint (b);
13752 make_cleanup_delete_breakpoint (struct breakpoint *b)
13754 return make_cleanup (do_delete_breakpoint_cleanup, b);
13757 /* Iterator function to call a user-provided callback function once
13758 for each of B and its related breakpoints. */
13761 iterate_over_related_breakpoints (struct breakpoint *b,
13762 void (*function) (struct breakpoint *,
13766 struct breakpoint *related;
13771 struct breakpoint *next;
13773 /* FUNCTION may delete RELATED. */
13774 next = related->related_breakpoint;
13776 if (next == related)
13778 /* RELATED is the last ring entry. */
13779 function (related, data);
13781 /* FUNCTION may have deleted it, so we'd never reach back to
13782 B. There's nothing left to do anyway, so just break
13787 function (related, data);
13791 while (related != b);
13795 do_delete_breakpoint (struct breakpoint *b, void *ignore)
13797 delete_breakpoint (b);
13800 /* A callback for map_breakpoint_numbers that calls
13801 delete_breakpoint. */
13804 do_map_delete_breakpoint (struct breakpoint *b, void *ignore)
13806 iterate_over_related_breakpoints (b, do_delete_breakpoint, NULL);
13810 delete_command (char *arg, int from_tty)
13812 struct breakpoint *b, *b_tmp;
13818 int breaks_to_delete = 0;
13820 /* Delete all breakpoints if no argument. Do not delete
13821 internal breakpoints, these have to be deleted with an
13822 explicit breakpoint number argument. */
13823 ALL_BREAKPOINTS (b)
13824 if (user_breakpoint_p (b))
13826 breaks_to_delete = 1;
13830 /* Ask user only if there are some breakpoints to delete. */
13832 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
13834 ALL_BREAKPOINTS_SAFE (b, b_tmp)
13835 if (user_breakpoint_p (b))
13836 delete_breakpoint (b);
13840 map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
13844 all_locations_are_pending (struct bp_location *loc)
13846 for (; loc; loc = loc->next)
13847 if (!loc->shlib_disabled
13848 && !loc->pspace->executing_startup)
13853 /* Subroutine of update_breakpoint_locations to simplify it.
13854 Return non-zero if multiple fns in list LOC have the same name.
13855 Null names are ignored. */
13858 ambiguous_names_p (struct bp_location *loc)
13860 struct bp_location *l;
13861 htab_t htab = htab_create_alloc (13, htab_hash_string,
13862 (int (*) (const void *,
13863 const void *)) streq,
13864 NULL, xcalloc, xfree);
13866 for (l = loc; l != NULL; l = l->next)
13869 const char *name = l->function_name;
13871 /* Allow for some names to be NULL, ignore them. */
13875 slot = (const char **) htab_find_slot (htab, (const void *) name,
13877 /* NOTE: We can assume slot != NULL here because xcalloc never
13881 htab_delete (htab);
13887 htab_delete (htab);
13891 /* When symbols change, it probably means the sources changed as well,
13892 and it might mean the static tracepoint markers are no longer at
13893 the same address or line numbers they used to be at last we
13894 checked. Losing your static tracepoints whenever you rebuild is
13895 undesirable. This function tries to resync/rematch gdb static
13896 tracepoints with the markers on the target, for static tracepoints
13897 that have not been set by marker id. Static tracepoint that have
13898 been set by marker id are reset by marker id in breakpoint_re_set.
13901 1) For a tracepoint set at a specific address, look for a marker at
13902 the old PC. If one is found there, assume to be the same marker.
13903 If the name / string id of the marker found is different from the
13904 previous known name, assume that means the user renamed the marker
13905 in the sources, and output a warning.
13907 2) For a tracepoint set at a given line number, look for a marker
13908 at the new address of the old line number. If one is found there,
13909 assume to be the same marker. If the name / string id of the
13910 marker found is different from the previous known name, assume that
13911 means the user renamed the marker in the sources, and output a
13914 3) If a marker is no longer found at the same address or line, it
13915 may mean the marker no longer exists. But it may also just mean
13916 the code changed a bit. Maybe the user added a few lines of code
13917 that made the marker move up or down (in line number terms). Ask
13918 the target for info about the marker with the string id as we knew
13919 it. If found, update line number and address in the matching
13920 static tracepoint. This will get confused if there's more than one
13921 marker with the same ID (possible in UST, although unadvised
13922 precisely because it confuses tools). */
13924 static struct symtab_and_line
13925 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
13927 struct tracepoint *tp = (struct tracepoint *) b;
13928 struct static_tracepoint_marker marker;
13933 find_line_pc (sal.symtab, sal.line, &pc);
13935 if (target_static_tracepoint_marker_at (pc, &marker))
13937 if (strcmp (tp->static_trace_marker_id, marker.str_id) != 0)
13938 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13940 tp->static_trace_marker_id, marker.str_id);
13942 xfree (tp->static_trace_marker_id);
13943 tp->static_trace_marker_id = xstrdup (marker.str_id);
13944 release_static_tracepoint_marker (&marker);
13949 /* Old marker wasn't found on target at lineno. Try looking it up
13951 if (!sal.explicit_pc
13953 && sal.symtab != NULL
13954 && tp->static_trace_marker_id != NULL)
13956 VEC(static_tracepoint_marker_p) *markers;
13959 = target_static_tracepoint_markers_by_strid (tp->static_trace_marker_id);
13961 if (!VEC_empty(static_tracepoint_marker_p, markers))
13963 struct symtab_and_line sal2;
13964 struct symbol *sym;
13965 struct static_tracepoint_marker *tpmarker;
13966 struct ui_out *uiout = current_uiout;
13968 tpmarker = VEC_index (static_tracepoint_marker_p, markers, 0);
13970 xfree (tp->static_trace_marker_id);
13971 tp->static_trace_marker_id = xstrdup (tpmarker->str_id);
13973 warning (_("marker for static tracepoint %d (%s) not "
13974 "found at previous line number"),
13975 b->number, tp->static_trace_marker_id);
13979 sal2.pc = tpmarker->address;
13981 sal2 = find_pc_line (tpmarker->address, 0);
13982 sym = find_pc_sect_function (tpmarker->address, NULL);
13983 ui_out_text (uiout, "Now in ");
13986 ui_out_field_string (uiout, "func",
13987 SYMBOL_PRINT_NAME (sym));
13988 ui_out_text (uiout, " at ");
13990 ui_out_field_string (uiout, "file",
13991 symtab_to_filename_for_display (sal2.symtab));
13992 ui_out_text (uiout, ":");
13994 if (ui_out_is_mi_like_p (uiout))
13996 const char *fullname = symtab_to_fullname (sal2.symtab);
13998 ui_out_field_string (uiout, "fullname", fullname);
14001 ui_out_field_int (uiout, "line", sal2.line);
14002 ui_out_text (uiout, "\n");
14004 b->loc->line_number = sal2.line;
14005 b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
14007 xfree (b->addr_string);
14008 b->addr_string = xstrprintf ("%s:%d",
14009 symtab_to_filename_for_display (sal2.symtab),
14010 b->loc->line_number);
14012 /* Might be nice to check if function changed, and warn if
14015 release_static_tracepoint_marker (tpmarker);
14021 /* Returns 1 iff locations A and B are sufficiently same that
14022 we don't need to report breakpoint as changed. */
14025 locations_are_equal (struct bp_location *a, struct bp_location *b)
14029 if (a->address != b->address)
14032 if (a->shlib_disabled != b->shlib_disabled)
14035 if (a->enabled != b->enabled)
14042 if ((a == NULL) != (b == NULL))
14048 /* Create new breakpoint locations for B (a hardware or software breakpoint)
14049 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
14050 a ranged breakpoint. */
14053 update_breakpoint_locations (struct breakpoint *b,
14054 struct symtabs_and_lines sals,
14055 struct symtabs_and_lines sals_end)
14058 struct bp_location *existing_locations = b->loc;
14060 if (sals_end.nelts != 0 && (sals.nelts != 1 || sals_end.nelts != 1))
14062 /* Ranged breakpoints have only one start location and one end
14064 b->enable_state = bp_disabled;
14065 update_global_location_list (1);
14066 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
14067 "multiple locations found\n"),
14072 /* If there's no new locations, and all existing locations are
14073 pending, don't do anything. This optimizes the common case where
14074 all locations are in the same shared library, that was unloaded.
14075 We'd like to retain the location, so that when the library is
14076 loaded again, we don't loose the enabled/disabled status of the
14077 individual locations. */
14078 if (all_locations_are_pending (existing_locations) && sals.nelts == 0)
14083 for (i = 0; i < sals.nelts; ++i)
14085 struct bp_location *new_loc;
14087 switch_to_program_space_and_thread (sals.sals[i].pspace);
14089 new_loc = add_location_to_breakpoint (b, &(sals.sals[i]));
14091 /* Reparse conditions, they might contain references to the
14093 if (b->cond_string != NULL)
14096 volatile struct gdb_exception e;
14098 s = b->cond_string;
14099 TRY_CATCH (e, RETURN_MASK_ERROR)
14101 new_loc->cond = parse_exp_1 (&s, sals.sals[i].pc,
14102 block_for_pc (sals.sals[i].pc),
14107 warning (_("failed to reevaluate condition "
14108 "for breakpoint %d: %s"),
14109 b->number, e.message);
14110 new_loc->enabled = 0;
14114 if (sals_end.nelts)
14116 CORE_ADDR end = find_breakpoint_range_end (sals_end.sals[0]);
14118 new_loc->length = end - sals.sals[0].pc + 1;
14122 /* Update locations of permanent breakpoints. */
14123 if (b->enable_state == bp_permanent)
14124 make_breakpoint_permanent (b);
14126 /* If possible, carry over 'disable' status from existing
14129 struct bp_location *e = existing_locations;
14130 /* If there are multiple breakpoints with the same function name,
14131 e.g. for inline functions, comparing function names won't work.
14132 Instead compare pc addresses; this is just a heuristic as things
14133 may have moved, but in practice it gives the correct answer
14134 often enough until a better solution is found. */
14135 int have_ambiguous_names = ambiguous_names_p (b->loc);
14137 for (; e; e = e->next)
14139 if (!e->enabled && e->function_name)
14141 struct bp_location *l = b->loc;
14142 if (have_ambiguous_names)
14144 for (; l; l = l->next)
14145 if (breakpoint_locations_match (e, l))
14153 for (; l; l = l->next)
14154 if (l->function_name
14155 && strcmp (e->function_name, l->function_name) == 0)
14165 if (!locations_are_equal (existing_locations, b->loc))
14166 observer_notify_breakpoint_modified (b);
14168 update_global_location_list (1);
14171 /* Find the SaL locations corresponding to the given ADDR_STRING.
14172 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
14174 static struct symtabs_and_lines
14175 addr_string_to_sals (struct breakpoint *b, char *addr_string, int *found)
14178 struct symtabs_and_lines sals = {0};
14179 volatile struct gdb_exception e;
14181 gdb_assert (b->ops != NULL);
14184 TRY_CATCH (e, RETURN_MASK_ERROR)
14186 b->ops->decode_linespec (b, &s, &sals);
14190 int not_found_and_ok = 0;
14191 /* For pending breakpoints, it's expected that parsing will
14192 fail until the right shared library is loaded. User has
14193 already told to create pending breakpoints and don't need
14194 extra messages. If breakpoint is in bp_shlib_disabled
14195 state, then user already saw the message about that
14196 breakpoint being disabled, and don't want to see more
14198 if (e.error == NOT_FOUND_ERROR
14199 && (b->condition_not_parsed
14200 || (b->loc && b->loc->shlib_disabled)
14201 || (b->loc && b->loc->pspace->executing_startup)
14202 || b->enable_state == bp_disabled))
14203 not_found_and_ok = 1;
14205 if (!not_found_and_ok)
14207 /* We surely don't want to warn about the same breakpoint
14208 10 times. One solution, implemented here, is disable
14209 the breakpoint on error. Another solution would be to
14210 have separate 'warning emitted' flag. Since this
14211 happens only when a binary has changed, I don't know
14212 which approach is better. */
14213 b->enable_state = bp_disabled;
14214 throw_exception (e);
14218 if (e.reason == 0 || e.error != NOT_FOUND_ERROR)
14222 for (i = 0; i < sals.nelts; ++i)
14223 resolve_sal_pc (&sals.sals[i]);
14224 if (b->condition_not_parsed && s && s[0])
14226 char *cond_string, *extra_string;
14229 find_condition_and_thread (s, sals.sals[0].pc,
14230 &cond_string, &thread, &task,
14233 b->cond_string = cond_string;
14234 b->thread = thread;
14237 b->extra_string = extra_string;
14238 b->condition_not_parsed = 0;
14241 if (b->type == bp_static_tracepoint && !strace_marker_p (b))
14242 sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
14252 /* The default re_set method, for typical hardware or software
14253 breakpoints. Reevaluate the breakpoint and recreate its
14257 breakpoint_re_set_default (struct breakpoint *b)
14260 struct symtabs_and_lines sals, sals_end;
14261 struct symtabs_and_lines expanded = {0};
14262 struct symtabs_and_lines expanded_end = {0};
14264 sals = addr_string_to_sals (b, b->addr_string, &found);
14267 make_cleanup (xfree, sals.sals);
14271 if (b->addr_string_range_end)
14273 sals_end = addr_string_to_sals (b, b->addr_string_range_end, &found);
14276 make_cleanup (xfree, sals_end.sals);
14277 expanded_end = sals_end;
14281 update_breakpoint_locations (b, expanded, expanded_end);
14284 /* Default method for creating SALs from an address string. It basically
14285 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14288 create_sals_from_address_default (char **arg,
14289 struct linespec_result *canonical,
14290 enum bptype type_wanted,
14291 char *addr_start, char **copy_arg)
14293 parse_breakpoint_sals (arg, canonical);
14296 /* Call create_breakpoints_sal for the given arguments. This is the default
14297 function for the `create_breakpoints_sal' method of
14301 create_breakpoints_sal_default (struct gdbarch *gdbarch,
14302 struct linespec_result *canonical,
14304 char *extra_string,
14305 enum bptype type_wanted,
14306 enum bpdisp disposition,
14308 int task, int ignore_count,
14309 const struct breakpoint_ops *ops,
14310 int from_tty, int enabled,
14311 int internal, unsigned flags)
14313 create_breakpoints_sal (gdbarch, canonical, cond_string,
14315 type_wanted, disposition,
14316 thread, task, ignore_count, ops, from_tty,
14317 enabled, internal, flags);
14320 /* Decode the line represented by S by calling decode_line_full. This is the
14321 default function for the `decode_linespec' method of breakpoint_ops. */
14324 decode_linespec_default (struct breakpoint *b, char **s,
14325 struct symtabs_and_lines *sals)
14327 struct linespec_result canonical;
14329 init_linespec_result (&canonical);
14330 decode_line_full (s, DECODE_LINE_FUNFIRSTLINE,
14331 (struct symtab *) NULL, 0,
14332 &canonical, multiple_symbols_all,
14335 /* We should get 0 or 1 resulting SALs. */
14336 gdb_assert (VEC_length (linespec_sals, canonical.sals) < 2);
14338 if (VEC_length (linespec_sals, canonical.sals) > 0)
14340 struct linespec_sals *lsal;
14342 lsal = VEC_index (linespec_sals, canonical.sals, 0);
14343 *sals = lsal->sals;
14344 /* Arrange it so the destructor does not free the
14346 lsal->sals.sals = NULL;
14349 destroy_linespec_result (&canonical);
14352 /* Prepare the global context for a re-set of breakpoint B. */
14354 static struct cleanup *
14355 prepare_re_set_context (struct breakpoint *b)
14357 struct cleanup *cleanups;
14359 input_radix = b->input_radix;
14360 cleanups = save_current_space_and_thread ();
14361 if (b->pspace != NULL)
14362 switch_to_program_space_and_thread (b->pspace);
14363 set_language (b->language);
14368 /* Reset a breakpoint given it's struct breakpoint * BINT.
14369 The value we return ends up being the return value from catch_errors.
14370 Unused in this case. */
14373 breakpoint_re_set_one (void *bint)
14375 /* Get past catch_errs. */
14376 struct breakpoint *b = (struct breakpoint *) bint;
14377 struct cleanup *cleanups;
14379 cleanups = prepare_re_set_context (b);
14380 b->ops->re_set (b);
14381 do_cleanups (cleanups);
14385 /* Re-set all breakpoints after symbols have been re-loaded. */
14387 breakpoint_re_set (void)
14389 struct breakpoint *b, *b_tmp;
14390 enum language save_language;
14391 int save_input_radix;
14392 struct cleanup *old_chain;
14394 save_language = current_language->la_language;
14395 save_input_radix = input_radix;
14396 old_chain = save_current_program_space ();
14398 ALL_BREAKPOINTS_SAFE (b, b_tmp)
14400 /* Format possible error msg. */
14401 char *message = xstrprintf ("Error in re-setting breakpoint %d: ",
14403 struct cleanup *cleanups = make_cleanup (xfree, message);
14404 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
14405 do_cleanups (cleanups);
14407 set_language (save_language);
14408 input_radix = save_input_radix;
14410 jit_breakpoint_re_set ();
14412 do_cleanups (old_chain);
14414 create_overlay_event_breakpoint ();
14415 create_longjmp_master_breakpoint ();
14416 create_std_terminate_master_breakpoint ();
14417 create_exception_master_breakpoint ();
14420 /* Reset the thread number of this breakpoint:
14422 - If the breakpoint is for all threads, leave it as-is.
14423 - Else, reset it to the current thread for inferior_ptid. */
14425 breakpoint_re_set_thread (struct breakpoint *b)
14427 if (b->thread != -1)
14429 if (in_thread_list (inferior_ptid))
14430 b->thread = pid_to_thread_id (inferior_ptid);
14432 /* We're being called after following a fork. The new fork is
14433 selected as current, and unless this was a vfork will have a
14434 different program space from the original thread. Reset that
14436 b->loc->pspace = current_program_space;
14440 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14441 If from_tty is nonzero, it prints a message to that effect,
14442 which ends with a period (no newline). */
14445 set_ignore_count (int bptnum, int count, int from_tty)
14447 struct breakpoint *b;
14452 ALL_BREAKPOINTS (b)
14453 if (b->number == bptnum)
14455 if (is_tracepoint (b))
14457 if (from_tty && count != 0)
14458 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14463 b->ignore_count = count;
14467 printf_filtered (_("Will stop next time "
14468 "breakpoint %d is reached."),
14470 else if (count == 1)
14471 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14474 printf_filtered (_("Will ignore next %d "
14475 "crossings of breakpoint %d."),
14478 observer_notify_breakpoint_modified (b);
14482 error (_("No breakpoint number %d."), bptnum);
14485 /* Command to set ignore-count of breakpoint N to COUNT. */
14488 ignore_command (char *args, int from_tty)
14494 error_no_arg (_("a breakpoint number"));
14496 num = get_number (&p);
14498 error (_("bad breakpoint number: '%s'"), args);
14500 error (_("Second argument (specified ignore-count) is missing."));
14502 set_ignore_count (num,
14503 longest_to_int (value_as_long (parse_and_eval (p))),
14506 printf_filtered ("\n");
14509 /* Call FUNCTION on each of the breakpoints
14510 whose numbers are given in ARGS. */
14513 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *,
14518 struct breakpoint *b, *tmp;
14520 struct get_number_or_range_state state;
14523 error_no_arg (_("one or more breakpoint numbers"));
14525 init_number_or_range (&state, args);
14527 while (!state.finished)
14529 char *p = state.string;
14533 num = get_number_or_range (&state);
14536 warning (_("bad breakpoint number at or near '%s'"), p);
14540 ALL_BREAKPOINTS_SAFE (b, tmp)
14541 if (b->number == num)
14544 function (b, data);
14548 printf_unfiltered (_("No breakpoint number %d.\n"), num);
14553 static struct bp_location *
14554 find_location_by_number (char *number)
14556 char *dot = strchr (number, '.');
14560 struct breakpoint *b;
14561 struct bp_location *loc;
14566 bp_num = get_number (&p1);
14568 error (_("Bad breakpoint number '%s'"), number);
14570 ALL_BREAKPOINTS (b)
14571 if (b->number == bp_num)
14576 if (!b || b->number != bp_num)
14577 error (_("Bad breakpoint number '%s'"), number);
14580 loc_num = get_number (&p1);
14582 error (_("Bad breakpoint location number '%s'"), number);
14586 for (;loc_num && loc; --loc_num, loc = loc->next)
14589 error (_("Bad breakpoint location number '%s'"), dot+1);
14595 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14596 If from_tty is nonzero, it prints a message to that effect,
14597 which ends with a period (no newline). */
14600 disable_breakpoint (struct breakpoint *bpt)
14602 /* Never disable a watchpoint scope breakpoint; we want to
14603 hit them when we leave scope so we can delete both the
14604 watchpoint and its scope breakpoint at that time. */
14605 if (bpt->type == bp_watchpoint_scope)
14608 /* You can't disable permanent breakpoints. */
14609 if (bpt->enable_state == bp_permanent)
14612 bpt->enable_state = bp_disabled;
14614 /* Mark breakpoint locations modified. */
14615 mark_breakpoint_modified (bpt);
14617 if (target_supports_enable_disable_tracepoint ()
14618 && current_trace_status ()->running && is_tracepoint (bpt))
14620 struct bp_location *location;
14622 for (location = bpt->loc; location; location = location->next)
14623 target_disable_tracepoint (location);
14626 update_global_location_list (0);
14628 observer_notify_breakpoint_modified (bpt);
14631 /* A callback for iterate_over_related_breakpoints. */
14634 do_disable_breakpoint (struct breakpoint *b, void *ignore)
14636 disable_breakpoint (b);
14639 /* A callback for map_breakpoint_numbers that calls
14640 disable_breakpoint. */
14643 do_map_disable_breakpoint (struct breakpoint *b, void *ignore)
14645 iterate_over_related_breakpoints (b, do_disable_breakpoint, NULL);
14649 disable_command (char *args, int from_tty)
14653 struct breakpoint *bpt;
14655 ALL_BREAKPOINTS (bpt)
14656 if (user_breakpoint_p (bpt))
14657 disable_breakpoint (bpt);
14661 char *num = extract_arg (&args);
14665 if (strchr (num, '.'))
14667 struct bp_location *loc = find_location_by_number (num);
14674 mark_breakpoint_location_modified (loc);
14676 if (target_supports_enable_disable_tracepoint ()
14677 && current_trace_status ()->running && loc->owner
14678 && is_tracepoint (loc->owner))
14679 target_disable_tracepoint (loc);
14681 update_global_location_list (0);
14684 map_breakpoint_numbers (num, do_map_disable_breakpoint, NULL);
14685 num = extract_arg (&args);
14691 enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14694 int target_resources_ok;
14696 if (bpt->type == bp_hardware_breakpoint)
14699 i = hw_breakpoint_used_count ();
14700 target_resources_ok =
14701 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
14703 if (target_resources_ok == 0)
14704 error (_("No hardware breakpoint support in the target."));
14705 else if (target_resources_ok < 0)
14706 error (_("Hardware breakpoints used exceeds limit."));
14709 if (is_watchpoint (bpt))
14711 /* Initialize it just to avoid a GCC false warning. */
14712 enum enable_state orig_enable_state = 0;
14713 volatile struct gdb_exception e;
14715 TRY_CATCH (e, RETURN_MASK_ALL)
14717 struct watchpoint *w = (struct watchpoint *) bpt;
14719 orig_enable_state = bpt->enable_state;
14720 bpt->enable_state = bp_enabled;
14721 update_watchpoint (w, 1 /* reparse */);
14725 bpt->enable_state = orig_enable_state;
14726 exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14732 if (bpt->enable_state != bp_permanent)
14733 bpt->enable_state = bp_enabled;
14735 bpt->enable_state = bp_enabled;
14737 /* Mark breakpoint locations modified. */
14738 mark_breakpoint_modified (bpt);
14740 if (target_supports_enable_disable_tracepoint ()
14741 && current_trace_status ()->running && is_tracepoint (bpt))
14743 struct bp_location *location;
14745 for (location = bpt->loc; location; location = location->next)
14746 target_enable_tracepoint (location);
14749 bpt->disposition = disposition;
14750 bpt->enable_count = count;
14751 update_global_location_list (1);
14753 observer_notify_breakpoint_modified (bpt);
14758 enable_breakpoint (struct breakpoint *bpt)
14760 enable_breakpoint_disp (bpt, bpt->disposition, 0);
14764 do_enable_breakpoint (struct breakpoint *bpt, void *arg)
14766 enable_breakpoint (bpt);
14769 /* A callback for map_breakpoint_numbers that calls
14770 enable_breakpoint. */
14773 do_map_enable_breakpoint (struct breakpoint *b, void *ignore)
14775 iterate_over_related_breakpoints (b, do_enable_breakpoint, NULL);
14778 /* The enable command enables the specified breakpoints (or all defined
14779 breakpoints) so they once again become (or continue to be) effective
14780 in stopping the inferior. */
14783 enable_command (char *args, int from_tty)
14787 struct breakpoint *bpt;
14789 ALL_BREAKPOINTS (bpt)
14790 if (user_breakpoint_p (bpt))
14791 enable_breakpoint (bpt);
14795 char *num = extract_arg (&args);
14799 if (strchr (num, '.'))
14801 struct bp_location *loc = find_location_by_number (num);
14808 mark_breakpoint_location_modified (loc);
14810 if (target_supports_enable_disable_tracepoint ()
14811 && current_trace_status ()->running && loc->owner
14812 && is_tracepoint (loc->owner))
14813 target_enable_tracepoint (loc);
14815 update_global_location_list (1);
14818 map_breakpoint_numbers (num, do_map_enable_breakpoint, NULL);
14819 num = extract_arg (&args);
14824 /* This struct packages up disposition data for application to multiple
14834 do_enable_breakpoint_disp (struct breakpoint *bpt, void *arg)
14836 struct disp_data disp_data = *(struct disp_data *) arg;
14838 enable_breakpoint_disp (bpt, disp_data.disp, disp_data.count);
14842 do_map_enable_once_breakpoint (struct breakpoint *bpt, void *ignore)
14844 struct disp_data disp = { disp_disable, 1 };
14846 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14850 enable_once_command (char *args, int from_tty)
14852 map_breakpoint_numbers (args, do_map_enable_once_breakpoint, NULL);
14856 do_map_enable_count_breakpoint (struct breakpoint *bpt, void *countptr)
14858 struct disp_data disp = { disp_disable, *(int *) countptr };
14860 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14864 enable_count_command (char *args, int from_tty)
14866 int count = get_number (&args);
14868 map_breakpoint_numbers (args, do_map_enable_count_breakpoint, &count);
14872 do_map_enable_delete_breakpoint (struct breakpoint *bpt, void *ignore)
14874 struct disp_data disp = { disp_del, 1 };
14876 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14880 enable_delete_command (char *args, int from_tty)
14882 map_breakpoint_numbers (args, do_map_enable_delete_breakpoint, NULL);
14886 set_breakpoint_cmd (char *args, int from_tty)
14891 show_breakpoint_cmd (char *args, int from_tty)
14895 /* Invalidate last known value of any hardware watchpoint if
14896 the memory which that value represents has been written to by
14900 invalidate_bp_value_on_memory_change (struct inferior *inferior,
14901 CORE_ADDR addr, ssize_t len,
14902 const bfd_byte *data)
14904 struct breakpoint *bp;
14906 ALL_BREAKPOINTS (bp)
14907 if (bp->enable_state == bp_enabled
14908 && bp->type == bp_hardware_watchpoint)
14910 struct watchpoint *wp = (struct watchpoint *) bp;
14912 if (wp->val_valid && wp->val)
14914 struct bp_location *loc;
14916 for (loc = bp->loc; loc != NULL; loc = loc->next)
14917 if (loc->loc_type == bp_loc_hardware_watchpoint
14918 && loc->address + loc->length > addr
14919 && addr + len > loc->address)
14921 value_free (wp->val);
14929 /* Create and insert a raw software breakpoint at PC. Return an
14930 identifier, which should be used to remove the breakpoint later.
14931 In general, places which call this should be using something on the
14932 breakpoint chain instead; this function should be eliminated
14936 deprecated_insert_raw_breakpoint (struct gdbarch *gdbarch,
14937 struct address_space *aspace, CORE_ADDR pc)
14939 struct bp_target_info *bp_tgt;
14941 bp_tgt = XZALLOC (struct bp_target_info);
14943 bp_tgt->placed_address_space = aspace;
14944 bp_tgt->placed_address = pc;
14946 if (target_insert_breakpoint (gdbarch, bp_tgt) != 0)
14948 /* Could not insert the breakpoint. */
14956 /* Remove a breakpoint BP inserted by
14957 deprecated_insert_raw_breakpoint. */
14960 deprecated_remove_raw_breakpoint (struct gdbarch *gdbarch, void *bp)
14962 struct bp_target_info *bp_tgt = bp;
14965 ret = target_remove_breakpoint (gdbarch, bp_tgt);
14971 /* One (or perhaps two) breakpoints used for software single
14974 static void *single_step_breakpoints[2];
14975 static struct gdbarch *single_step_gdbarch[2];
14977 /* Create and insert a breakpoint for software single step. */
14980 insert_single_step_breakpoint (struct gdbarch *gdbarch,
14981 struct address_space *aspace,
14986 if (single_step_breakpoints[0] == NULL)
14988 bpt_p = &single_step_breakpoints[0];
14989 single_step_gdbarch[0] = gdbarch;
14993 gdb_assert (single_step_breakpoints[1] == NULL);
14994 bpt_p = &single_step_breakpoints[1];
14995 single_step_gdbarch[1] = gdbarch;
14998 /* NOTE drow/2006-04-11: A future improvement to this function would
14999 be to only create the breakpoints once, and actually put them on
15000 the breakpoint chain. That would let us use set_raw_breakpoint.
15001 We could adjust the addresses each time they were needed. Doing
15002 this requires corresponding changes elsewhere where single step
15003 breakpoints are handled, however. So, for now, we use this. */
15005 *bpt_p = deprecated_insert_raw_breakpoint (gdbarch, aspace, next_pc);
15006 if (*bpt_p == NULL)
15007 error (_("Could not insert single-step breakpoint at %s"),
15008 paddress (gdbarch, next_pc));
15011 /* Check if the breakpoints used for software single stepping
15012 were inserted or not. */
15015 single_step_breakpoints_inserted (void)
15017 return (single_step_breakpoints[0] != NULL
15018 || single_step_breakpoints[1] != NULL);
15021 /* Remove and delete any breakpoints used for software single step. */
15024 remove_single_step_breakpoints (void)
15026 gdb_assert (single_step_breakpoints[0] != NULL);
15028 /* See insert_single_step_breakpoint for more about this deprecated
15030 deprecated_remove_raw_breakpoint (single_step_gdbarch[0],
15031 single_step_breakpoints[0]);
15032 single_step_gdbarch[0] = NULL;
15033 single_step_breakpoints[0] = NULL;
15035 if (single_step_breakpoints[1] != NULL)
15037 deprecated_remove_raw_breakpoint (single_step_gdbarch[1],
15038 single_step_breakpoints[1]);
15039 single_step_gdbarch[1] = NULL;
15040 single_step_breakpoints[1] = NULL;
15044 /* Delete software single step breakpoints without removing them from
15045 the inferior. This is intended to be used if the inferior's address
15046 space where they were inserted is already gone, e.g. after exit or
15050 cancel_single_step_breakpoints (void)
15054 for (i = 0; i < 2; i++)
15055 if (single_step_breakpoints[i])
15057 xfree (single_step_breakpoints[i]);
15058 single_step_breakpoints[i] = NULL;
15059 single_step_gdbarch[i] = NULL;
15063 /* Detach software single-step breakpoints from INFERIOR_PTID without
15067 detach_single_step_breakpoints (void)
15071 for (i = 0; i < 2; i++)
15072 if (single_step_breakpoints[i])
15073 target_remove_breakpoint (single_step_gdbarch[i],
15074 single_step_breakpoints[i]);
15077 /* Check whether a software single-step breakpoint is inserted at
15081 single_step_breakpoint_inserted_here_p (struct address_space *aspace,
15086 for (i = 0; i < 2; i++)
15088 struct bp_target_info *bp_tgt = single_step_breakpoints[i];
15090 && breakpoint_address_match (bp_tgt->placed_address_space,
15091 bp_tgt->placed_address,
15099 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
15100 non-zero otherwise. */
15102 is_syscall_catchpoint_enabled (struct breakpoint *bp)
15104 if (syscall_catchpoint_p (bp)
15105 && bp->enable_state != bp_disabled
15106 && bp->enable_state != bp_call_disabled)
15113 catch_syscall_enabled (void)
15115 struct catch_syscall_inferior_data *inf_data
15116 = get_catch_syscall_inferior_data (current_inferior ());
15118 return inf_data->total_syscalls_count != 0;
15122 catching_syscall_number (int syscall_number)
15124 struct breakpoint *bp;
15126 ALL_BREAKPOINTS (bp)
15127 if (is_syscall_catchpoint_enabled (bp))
15129 struct syscall_catchpoint *c = (struct syscall_catchpoint *) bp;
15131 if (c->syscalls_to_be_caught)
15135 VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
15137 if (syscall_number == iter)
15147 /* Complete syscall names. Used by "catch syscall". */
15148 static VEC (char_ptr) *
15149 catch_syscall_completer (struct cmd_list_element *cmd,
15150 const char *text, const char *word)
15152 const char **list = get_syscall_names ();
15153 VEC (char_ptr) *retlist
15154 = (list == NULL) ? NULL : complete_on_enum (list, word, word);
15160 /* Tracepoint-specific operations. */
15162 /* Set tracepoint count to NUM. */
15164 set_tracepoint_count (int num)
15166 tracepoint_count = num;
15167 set_internalvar_integer (lookup_internalvar ("tpnum"), num);
15171 trace_command (char *arg, int from_tty)
15173 struct breakpoint_ops *ops;
15174 const char *arg_cp = arg;
15176 if (arg && probe_linespec_to_ops (&arg_cp))
15177 ops = &tracepoint_probe_breakpoint_ops;
15179 ops = &tracepoint_breakpoint_ops;
15181 create_breakpoint (get_current_arch (),
15183 NULL, 0, NULL, 1 /* parse arg */,
15185 bp_tracepoint /* type_wanted */,
15186 0 /* Ignore count */,
15187 pending_break_support,
15191 0 /* internal */, 0);
15195 ftrace_command (char *arg, int from_tty)
15197 create_breakpoint (get_current_arch (),
15199 NULL, 0, NULL, 1 /* parse arg */,
15201 bp_fast_tracepoint /* type_wanted */,
15202 0 /* Ignore count */,
15203 pending_break_support,
15204 &tracepoint_breakpoint_ops,
15207 0 /* internal */, 0);
15210 /* strace command implementation. Creates a static tracepoint. */
15213 strace_command (char *arg, int from_tty)
15215 struct breakpoint_ops *ops;
15217 /* Decide if we are dealing with a static tracepoint marker (`-m'),
15218 or with a normal static tracepoint. */
15219 if (arg && strncmp (arg, "-m", 2) == 0 && isspace (arg[2]))
15220 ops = &strace_marker_breakpoint_ops;
15222 ops = &tracepoint_breakpoint_ops;
15224 create_breakpoint (get_current_arch (),
15226 NULL, 0, NULL, 1 /* parse arg */,
15228 bp_static_tracepoint /* type_wanted */,
15229 0 /* Ignore count */,
15230 pending_break_support,
15234 0 /* internal */, 0);
15237 /* Set up a fake reader function that gets command lines from a linked
15238 list that was acquired during tracepoint uploading. */
15240 static struct uploaded_tp *this_utp;
15241 static int next_cmd;
15244 read_uploaded_action (void)
15248 VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
15255 /* Given information about a tracepoint as recorded on a target (which
15256 can be either a live system or a trace file), attempt to create an
15257 equivalent GDB tracepoint. This is not a reliable process, since
15258 the target does not necessarily have all the information used when
15259 the tracepoint was originally defined. */
15261 struct tracepoint *
15262 create_tracepoint_from_upload (struct uploaded_tp *utp)
15264 char *addr_str, small_buf[100];
15265 struct tracepoint *tp;
15267 if (utp->at_string)
15268 addr_str = utp->at_string;
15271 /* In the absence of a source location, fall back to raw
15272 address. Since there is no way to confirm that the address
15273 means the same thing as when the trace was started, warn the
15275 warning (_("Uploaded tracepoint %d has no "
15276 "source location, using raw address"),
15278 xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (utp->addr));
15279 addr_str = small_buf;
15282 /* There's not much we can do with a sequence of bytecodes. */
15283 if (utp->cond && !utp->cond_string)
15284 warning (_("Uploaded tracepoint %d condition "
15285 "has no source form, ignoring it"),
15288 if (!create_breakpoint (get_current_arch (),
15290 utp->cond_string, -1, NULL,
15291 0 /* parse cond/thread */,
15293 utp->type /* type_wanted */,
15294 0 /* Ignore count */,
15295 pending_break_support,
15296 &tracepoint_breakpoint_ops,
15298 utp->enabled /* enabled */,
15300 CREATE_BREAKPOINT_FLAGS_INSERTED))
15303 /* Get the tracepoint we just created. */
15304 tp = get_tracepoint (tracepoint_count);
15305 gdb_assert (tp != NULL);
15309 xsnprintf (small_buf, sizeof (small_buf), "%d %d", utp->pass,
15312 trace_pass_command (small_buf, 0);
15315 /* If we have uploaded versions of the original commands, set up a
15316 special-purpose "reader" function and call the usual command line
15317 reader, then pass the result to the breakpoint command-setting
15319 if (!VEC_empty (char_ptr, utp->cmd_strings))
15321 struct command_line *cmd_list;
15326 cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
15328 breakpoint_set_commands (&tp->base, cmd_list);
15330 else if (!VEC_empty (char_ptr, utp->actions)
15331 || !VEC_empty (char_ptr, utp->step_actions))
15332 warning (_("Uploaded tracepoint %d actions "
15333 "have no source form, ignoring them"),
15336 /* Copy any status information that might be available. */
15337 tp->base.hit_count = utp->hit_count;
15338 tp->traceframe_usage = utp->traceframe_usage;
15343 /* Print information on tracepoint number TPNUM_EXP, or all if
15347 tracepoints_info (char *args, int from_tty)
15349 struct ui_out *uiout = current_uiout;
15352 num_printed = breakpoint_1 (args, 0, is_tracepoint);
15354 if (num_printed == 0)
15356 if (args == NULL || *args == '\0')
15357 ui_out_message (uiout, 0, "No tracepoints.\n");
15359 ui_out_message (uiout, 0, "No tracepoint matching '%s'.\n", args);
15362 default_collect_info ();
15365 /* The 'enable trace' command enables tracepoints.
15366 Not supported by all targets. */
15368 enable_trace_command (char *args, int from_tty)
15370 enable_command (args, from_tty);
15373 /* The 'disable trace' command disables tracepoints.
15374 Not supported by all targets. */
15376 disable_trace_command (char *args, int from_tty)
15378 disable_command (args, from_tty);
15381 /* Remove a tracepoint (or all if no argument). */
15383 delete_trace_command (char *arg, int from_tty)
15385 struct breakpoint *b, *b_tmp;
15391 int breaks_to_delete = 0;
15393 /* Delete all breakpoints if no argument.
15394 Do not delete internal or call-dummy breakpoints, these
15395 have to be deleted with an explicit breakpoint number
15397 ALL_TRACEPOINTS (b)
15398 if (is_tracepoint (b) && user_breakpoint_p (b))
15400 breaks_to_delete = 1;
15404 /* Ask user only if there are some breakpoints to delete. */
15406 || (breaks_to_delete && query (_("Delete all tracepoints? "))))
15408 ALL_BREAKPOINTS_SAFE (b, b_tmp)
15409 if (is_tracepoint (b) && user_breakpoint_p (b))
15410 delete_breakpoint (b);
15414 map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
15417 /* Helper function for trace_pass_command. */
15420 trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
15422 tp->pass_count = count;
15423 observer_notify_breakpoint_modified (&tp->base);
15425 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15426 tp->base.number, count);
15429 /* Set passcount for tracepoint.
15431 First command argument is passcount, second is tracepoint number.
15432 If tracepoint number omitted, apply to most recently defined.
15433 Also accepts special argument "all". */
15436 trace_pass_command (char *args, int from_tty)
15438 struct tracepoint *t1;
15439 unsigned int count;
15441 if (args == 0 || *args == 0)
15442 error (_("passcount command requires an "
15443 "argument (count + optional TP num)"));
15445 count = strtoul (args, &args, 10); /* Count comes first, then TP num. */
15447 args = skip_spaces (args);
15448 if (*args && strncasecmp (args, "all", 3) == 0)
15450 struct breakpoint *b;
15452 args += 3; /* Skip special argument "all". */
15454 error (_("Junk at end of arguments."));
15456 ALL_TRACEPOINTS (b)
15458 t1 = (struct tracepoint *) b;
15459 trace_pass_set_count (t1, count, from_tty);
15462 else if (*args == '\0')
15464 t1 = get_tracepoint_by_number (&args, NULL, 1);
15466 trace_pass_set_count (t1, count, from_tty);
15470 struct get_number_or_range_state state;
15472 init_number_or_range (&state, args);
15473 while (!state.finished)
15475 t1 = get_tracepoint_by_number (&args, &state, 1);
15477 trace_pass_set_count (t1, count, from_tty);
15482 struct tracepoint *
15483 get_tracepoint (int num)
15485 struct breakpoint *t;
15487 ALL_TRACEPOINTS (t)
15488 if (t->number == num)
15489 return (struct tracepoint *) t;
15494 /* Find the tracepoint with the given target-side number (which may be
15495 different from the tracepoint number after disconnecting and
15498 struct tracepoint *
15499 get_tracepoint_by_number_on_target (int num)
15501 struct breakpoint *b;
15503 ALL_TRACEPOINTS (b)
15505 struct tracepoint *t = (struct tracepoint *) b;
15507 if (t->number_on_target == num)
15514 /* Utility: parse a tracepoint number and look it up in the list.
15515 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15516 If OPTIONAL_P is true, then if the argument is missing, the most
15517 recent tracepoint (tracepoint_count) is returned. */
15518 struct tracepoint *
15519 get_tracepoint_by_number (char **arg,
15520 struct get_number_or_range_state *state,
15523 struct breakpoint *t;
15525 char *instring = arg == NULL ? NULL : *arg;
15529 gdb_assert (!state->finished);
15530 tpnum = get_number_or_range (state);
15532 else if (arg == NULL || *arg == NULL || ! **arg)
15535 tpnum = tracepoint_count;
15537 error_no_arg (_("tracepoint number"));
15540 tpnum = get_number (arg);
15544 if (instring && *instring)
15545 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15548 printf_filtered (_("Tracepoint argument missing "
15549 "and no previous tracepoint\n"));
15553 ALL_TRACEPOINTS (t)
15554 if (t->number == tpnum)
15556 return (struct tracepoint *) t;
15559 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
15564 print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
15566 if (b->thread != -1)
15567 fprintf_unfiltered (fp, " thread %d", b->thread);
15570 fprintf_unfiltered (fp, " task %d", b->task);
15572 fprintf_unfiltered (fp, "\n");
15575 /* Save information on user settable breakpoints (watchpoints, etc) to
15576 a new script file named FILENAME. If FILTER is non-NULL, call it
15577 on each breakpoint and only include the ones for which it returns
15581 save_breakpoints (char *filename, int from_tty,
15582 int (*filter) (const struct breakpoint *))
15584 struct breakpoint *tp;
15586 struct cleanup *cleanup;
15587 struct ui_file *fp;
15588 int extra_trace_bits = 0;
15590 if (filename == 0 || *filename == 0)
15591 error (_("Argument required (file name in which to save)"));
15593 /* See if we have anything to save. */
15594 ALL_BREAKPOINTS (tp)
15596 /* Skip internal and momentary breakpoints. */
15597 if (!user_breakpoint_p (tp))
15600 /* If we have a filter, only save the breakpoints it accepts. */
15601 if (filter && !filter (tp))
15606 if (is_tracepoint (tp))
15608 extra_trace_bits = 1;
15610 /* We can stop searching. */
15617 warning (_("Nothing to save."));
15621 filename = tilde_expand (filename);
15622 cleanup = make_cleanup (xfree, filename);
15623 fp = gdb_fopen (filename, "w");
15625 error (_("Unable to open file '%s' for saving (%s)"),
15626 filename, safe_strerror (errno));
15627 make_cleanup_ui_file_delete (fp);
15629 if (extra_trace_bits)
15630 save_trace_state_variables (fp);
15632 ALL_BREAKPOINTS (tp)
15634 /* Skip internal and momentary breakpoints. */
15635 if (!user_breakpoint_p (tp))
15638 /* If we have a filter, only save the breakpoints it accepts. */
15639 if (filter && !filter (tp))
15642 tp->ops->print_recreate (tp, fp);
15644 /* Note, we can't rely on tp->number for anything, as we can't
15645 assume the recreated breakpoint numbers will match. Use $bpnum
15648 if (tp->cond_string)
15649 fprintf_unfiltered (fp, " condition $bpnum %s\n", tp->cond_string);
15651 if (tp->ignore_count)
15652 fprintf_unfiltered (fp, " ignore $bpnum %d\n", tp->ignore_count);
15654 if (tp->type != bp_dprintf && tp->commands)
15656 volatile struct gdb_exception ex;
15658 fprintf_unfiltered (fp, " commands\n");
15660 ui_out_redirect (current_uiout, fp);
15661 TRY_CATCH (ex, RETURN_MASK_ALL)
15663 print_command_lines (current_uiout, tp->commands->commands, 2);
15665 ui_out_redirect (current_uiout, NULL);
15668 throw_exception (ex);
15670 fprintf_unfiltered (fp, " end\n");
15673 if (tp->enable_state == bp_disabled)
15674 fprintf_unfiltered (fp, "disable\n");
15676 /* If this is a multi-location breakpoint, check if the locations
15677 should be individually disabled. Watchpoint locations are
15678 special, and not user visible. */
15679 if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15681 struct bp_location *loc;
15684 for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15686 fprintf_unfiltered (fp, "disable $bpnum.%d\n", n);
15690 if (extra_trace_bits && *default_collect)
15691 fprintf_unfiltered (fp, "set default-collect %s\n", default_collect);
15694 printf_filtered (_("Saved to file '%s'.\n"), filename);
15695 do_cleanups (cleanup);
15698 /* The `save breakpoints' command. */
15701 save_breakpoints_command (char *args, int from_tty)
15703 save_breakpoints (args, from_tty, NULL);
15706 /* The `save tracepoints' command. */
15709 save_tracepoints_command (char *args, int from_tty)
15711 save_breakpoints (args, from_tty, is_tracepoint);
15714 /* Create a vector of all tracepoints. */
15716 VEC(breakpoint_p) *
15717 all_tracepoints (void)
15719 VEC(breakpoint_p) *tp_vec = 0;
15720 struct breakpoint *tp;
15722 ALL_TRACEPOINTS (tp)
15724 VEC_safe_push (breakpoint_p, tp_vec, tp);
15731 /* This help string is used for the break, hbreak, tbreak and thbreak
15732 commands. It is defined as a macro to prevent duplication.
15733 COMMAND should be a string constant containing the name of the
15735 #define BREAK_ARGS_HELP(command) \
15736 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15737 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15738 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15739 guessed probe type) or `-probe-stap' (for a SystemTap probe).\n\
15740 LOCATION may be a line number, function name, or \"*\" and an address.\n\
15741 If a line number is specified, break at start of code for that line.\n\
15742 If a function is specified, break at start of code for that function.\n\
15743 If an address is specified, break at that exact address.\n\
15744 With no LOCATION, uses current execution address of the selected\n\
15745 stack frame. This is useful for breaking on return to a stack frame.\n\
15747 THREADNUM is the number from \"info threads\".\n\
15748 CONDITION is a boolean expression.\n\
15750 Multiple breakpoints at one place are permitted, and useful if their\n\
15751 conditions are different.\n\
15753 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15755 /* List of subcommands for "catch". */
15756 static struct cmd_list_element *catch_cmdlist;
15758 /* List of subcommands for "tcatch". */
15759 static struct cmd_list_element *tcatch_cmdlist;
15762 add_catch_command (char *name, char *docstring,
15763 void (*sfunc) (char *args, int from_tty,
15764 struct cmd_list_element *command),
15765 completer_ftype *completer,
15766 void *user_data_catch,
15767 void *user_data_tcatch)
15769 struct cmd_list_element *command;
15771 command = add_cmd (name, class_breakpoint, NULL, docstring,
15773 set_cmd_sfunc (command, sfunc);
15774 set_cmd_context (command, user_data_catch);
15775 set_cmd_completer (command, completer);
15777 command = add_cmd (name, class_breakpoint, NULL, docstring,
15779 set_cmd_sfunc (command, sfunc);
15780 set_cmd_context (command, user_data_tcatch);
15781 set_cmd_completer (command, completer);
15785 clear_syscall_counts (struct inferior *inf)
15787 struct catch_syscall_inferior_data *inf_data
15788 = get_catch_syscall_inferior_data (inf);
15790 inf_data->total_syscalls_count = 0;
15791 inf_data->any_syscall_count = 0;
15792 VEC_free (int, inf_data->syscalls_counts);
15796 save_command (char *arg, int from_tty)
15798 printf_unfiltered (_("\"save\" must be followed by "
15799 "the name of a save subcommand.\n"));
15800 help_list (save_cmdlist, "save ", -1, gdb_stdout);
15803 struct breakpoint *
15804 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15807 struct breakpoint *b, *b_tmp;
15809 ALL_BREAKPOINTS_SAFE (b, b_tmp)
15811 if ((*callback) (b, data))
15818 /* Zero if any of the breakpoint's locations could be a location where
15819 functions have been inlined, nonzero otherwise. */
15822 is_non_inline_function (struct breakpoint *b)
15824 /* The shared library event breakpoint is set on the address of a
15825 non-inline function. */
15826 if (b->type == bp_shlib_event)
15832 /* Nonzero if the specified PC cannot be a location where functions
15833 have been inlined. */
15836 pc_at_non_inline_function (struct address_space *aspace, CORE_ADDR pc,
15837 const struct target_waitstatus *ws)
15839 struct breakpoint *b;
15840 struct bp_location *bl;
15842 ALL_BREAKPOINTS (b)
15844 if (!is_non_inline_function (b))
15847 for (bl = b->loc; bl != NULL; bl = bl->next)
15849 if (!bl->shlib_disabled
15850 && bpstat_check_location (bl, aspace, pc, ws))
15858 /* Remove any references to OBJFILE which is going to be freed. */
15861 breakpoint_free_objfile (struct objfile *objfile)
15863 struct bp_location **locp, *loc;
15865 ALL_BP_LOCATIONS (loc, locp)
15866 if (loc->symtab != NULL && loc->symtab->objfile == objfile)
15867 loc->symtab = NULL;
15871 initialize_breakpoint_ops (void)
15873 static int initialized = 0;
15875 struct breakpoint_ops *ops;
15881 /* The breakpoint_ops structure to be inherit by all kinds of
15882 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15883 internal and momentary breakpoints, etc.). */
15884 ops = &bkpt_base_breakpoint_ops;
15885 *ops = base_breakpoint_ops;
15886 ops->re_set = bkpt_re_set;
15887 ops->insert_location = bkpt_insert_location;
15888 ops->remove_location = bkpt_remove_location;
15889 ops->breakpoint_hit = bkpt_breakpoint_hit;
15890 ops->create_sals_from_address = bkpt_create_sals_from_address;
15891 ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
15892 ops->decode_linespec = bkpt_decode_linespec;
15894 /* The breakpoint_ops structure to be used in regular breakpoints. */
15895 ops = &bkpt_breakpoint_ops;
15896 *ops = bkpt_base_breakpoint_ops;
15897 ops->re_set = bkpt_re_set;
15898 ops->resources_needed = bkpt_resources_needed;
15899 ops->print_it = bkpt_print_it;
15900 ops->print_mention = bkpt_print_mention;
15901 ops->print_recreate = bkpt_print_recreate;
15903 /* Ranged breakpoints. */
15904 ops = &ranged_breakpoint_ops;
15905 *ops = bkpt_breakpoint_ops;
15906 ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15907 ops->resources_needed = resources_needed_ranged_breakpoint;
15908 ops->print_it = print_it_ranged_breakpoint;
15909 ops->print_one = print_one_ranged_breakpoint;
15910 ops->print_one_detail = print_one_detail_ranged_breakpoint;
15911 ops->print_mention = print_mention_ranged_breakpoint;
15912 ops->print_recreate = print_recreate_ranged_breakpoint;
15914 /* Internal breakpoints. */
15915 ops = &internal_breakpoint_ops;
15916 *ops = bkpt_base_breakpoint_ops;
15917 ops->re_set = internal_bkpt_re_set;
15918 ops->check_status = internal_bkpt_check_status;
15919 ops->print_it = internal_bkpt_print_it;
15920 ops->print_mention = internal_bkpt_print_mention;
15922 /* Momentary breakpoints. */
15923 ops = &momentary_breakpoint_ops;
15924 *ops = bkpt_base_breakpoint_ops;
15925 ops->re_set = momentary_bkpt_re_set;
15926 ops->check_status = momentary_bkpt_check_status;
15927 ops->print_it = momentary_bkpt_print_it;
15928 ops->print_mention = momentary_bkpt_print_mention;
15930 /* Momentary breakpoints for bp_longjmp and bp_exception. */
15931 ops = &longjmp_breakpoint_ops;
15932 *ops = momentary_breakpoint_ops;
15933 ops->dtor = longjmp_bkpt_dtor;
15935 /* Probe breakpoints. */
15936 ops = &bkpt_probe_breakpoint_ops;
15937 *ops = bkpt_breakpoint_ops;
15938 ops->insert_location = bkpt_probe_insert_location;
15939 ops->remove_location = bkpt_probe_remove_location;
15940 ops->create_sals_from_address = bkpt_probe_create_sals_from_address;
15941 ops->decode_linespec = bkpt_probe_decode_linespec;
15944 ops = &watchpoint_breakpoint_ops;
15945 *ops = base_breakpoint_ops;
15946 ops->dtor = dtor_watchpoint;
15947 ops->re_set = re_set_watchpoint;
15948 ops->insert_location = insert_watchpoint;
15949 ops->remove_location = remove_watchpoint;
15950 ops->breakpoint_hit = breakpoint_hit_watchpoint;
15951 ops->check_status = check_status_watchpoint;
15952 ops->resources_needed = resources_needed_watchpoint;
15953 ops->works_in_software_mode = works_in_software_mode_watchpoint;
15954 ops->print_it = print_it_watchpoint;
15955 ops->print_mention = print_mention_watchpoint;
15956 ops->print_recreate = print_recreate_watchpoint;
15957 ops->explains_signal = explains_signal_watchpoint;
15959 /* Masked watchpoints. */
15960 ops = &masked_watchpoint_breakpoint_ops;
15961 *ops = watchpoint_breakpoint_ops;
15962 ops->insert_location = insert_masked_watchpoint;
15963 ops->remove_location = remove_masked_watchpoint;
15964 ops->resources_needed = resources_needed_masked_watchpoint;
15965 ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15966 ops->print_it = print_it_masked_watchpoint;
15967 ops->print_one_detail = print_one_detail_masked_watchpoint;
15968 ops->print_mention = print_mention_masked_watchpoint;
15969 ops->print_recreate = print_recreate_masked_watchpoint;
15972 ops = &tracepoint_breakpoint_ops;
15973 *ops = base_breakpoint_ops;
15974 ops->re_set = tracepoint_re_set;
15975 ops->breakpoint_hit = tracepoint_breakpoint_hit;
15976 ops->print_one_detail = tracepoint_print_one_detail;
15977 ops->print_mention = tracepoint_print_mention;
15978 ops->print_recreate = tracepoint_print_recreate;
15979 ops->create_sals_from_address = tracepoint_create_sals_from_address;
15980 ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
15981 ops->decode_linespec = tracepoint_decode_linespec;
15983 /* Probe tracepoints. */
15984 ops = &tracepoint_probe_breakpoint_ops;
15985 *ops = tracepoint_breakpoint_ops;
15986 ops->create_sals_from_address = tracepoint_probe_create_sals_from_address;
15987 ops->decode_linespec = tracepoint_probe_decode_linespec;
15989 /* Static tracepoints with marker (`-m'). */
15990 ops = &strace_marker_breakpoint_ops;
15991 *ops = tracepoint_breakpoint_ops;
15992 ops->create_sals_from_address = strace_marker_create_sals_from_address;
15993 ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
15994 ops->decode_linespec = strace_marker_decode_linespec;
15996 /* Fork catchpoints. */
15997 ops = &catch_fork_breakpoint_ops;
15998 *ops = base_breakpoint_ops;
15999 ops->insert_location = insert_catch_fork;
16000 ops->remove_location = remove_catch_fork;
16001 ops->breakpoint_hit = breakpoint_hit_catch_fork;
16002 ops->print_it = print_it_catch_fork;
16003 ops->print_one = print_one_catch_fork;
16004 ops->print_mention = print_mention_catch_fork;
16005 ops->print_recreate = print_recreate_catch_fork;
16007 /* Vfork catchpoints. */
16008 ops = &catch_vfork_breakpoint_ops;
16009 *ops = base_breakpoint_ops;
16010 ops->insert_location = insert_catch_vfork;
16011 ops->remove_location = remove_catch_vfork;
16012 ops->breakpoint_hit = breakpoint_hit_catch_vfork;
16013 ops->print_it = print_it_catch_vfork;
16014 ops->print_one = print_one_catch_vfork;
16015 ops->print_mention = print_mention_catch_vfork;
16016 ops->print_recreate = print_recreate_catch_vfork;
16018 /* Exec catchpoints. */
16019 ops = &catch_exec_breakpoint_ops;
16020 *ops = base_breakpoint_ops;
16021 ops->dtor = dtor_catch_exec;
16022 ops->insert_location = insert_catch_exec;
16023 ops->remove_location = remove_catch_exec;
16024 ops->breakpoint_hit = breakpoint_hit_catch_exec;
16025 ops->print_it = print_it_catch_exec;
16026 ops->print_one = print_one_catch_exec;
16027 ops->print_mention = print_mention_catch_exec;
16028 ops->print_recreate = print_recreate_catch_exec;
16030 /* Syscall catchpoints. */
16031 ops = &catch_syscall_breakpoint_ops;
16032 *ops = base_breakpoint_ops;
16033 ops->dtor = dtor_catch_syscall;
16034 ops->insert_location = insert_catch_syscall;
16035 ops->remove_location = remove_catch_syscall;
16036 ops->breakpoint_hit = breakpoint_hit_catch_syscall;
16037 ops->print_it = print_it_catch_syscall;
16038 ops->print_one = print_one_catch_syscall;
16039 ops->print_mention = print_mention_catch_syscall;
16040 ops->print_recreate = print_recreate_catch_syscall;
16042 /* Solib-related catchpoints. */
16043 ops = &catch_solib_breakpoint_ops;
16044 *ops = base_breakpoint_ops;
16045 ops->dtor = dtor_catch_solib;
16046 ops->insert_location = insert_catch_solib;
16047 ops->remove_location = remove_catch_solib;
16048 ops->breakpoint_hit = breakpoint_hit_catch_solib;
16049 ops->check_status = check_status_catch_solib;
16050 ops->print_it = print_it_catch_solib;
16051 ops->print_one = print_one_catch_solib;
16052 ops->print_mention = print_mention_catch_solib;
16053 ops->print_recreate = print_recreate_catch_solib;
16055 ops = &dprintf_breakpoint_ops;
16056 *ops = bkpt_base_breakpoint_ops;
16057 ops->re_set = dprintf_re_set;
16058 ops->resources_needed = bkpt_resources_needed;
16059 ops->print_it = bkpt_print_it;
16060 ops->print_mention = bkpt_print_mention;
16061 ops->print_recreate = dprintf_print_recreate;
16062 ops->after_condition_true = dprintf_after_condition_true;
16065 /* Chain containing all defined "enable breakpoint" subcommands. */
16067 static struct cmd_list_element *enablebreaklist = NULL;
16070 _initialize_breakpoint (void)
16072 struct cmd_list_element *c;
16074 initialize_breakpoint_ops ();
16076 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
16077 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile);
16078 observer_attach_inferior_exit (clear_syscall_counts);
16079 observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
16081 breakpoint_objfile_key
16082 = register_objfile_data_with_cleanup (NULL, free_breakpoint_probes);
16084 catch_syscall_inferior_data
16085 = register_inferior_data_with_cleanup (NULL,
16086 catch_syscall_inferior_data_cleanup);
16088 breakpoint_chain = 0;
16089 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
16090 before a breakpoint is set. */
16091 breakpoint_count = 0;
16093 tracepoint_count = 0;
16095 add_com ("ignore", class_breakpoint, ignore_command, _("\
16096 Set ignore-count of breakpoint number N to COUNT.\n\
16097 Usage is `ignore N COUNT'."));
16099 add_com_alias ("bc", "ignore", class_breakpoint, 1);
16101 add_com ("commands", class_breakpoint, commands_command, _("\
16102 Set commands to be executed when a breakpoint is hit.\n\
16103 Give breakpoint number as argument after \"commands\".\n\
16104 With no argument, the targeted breakpoint is the last one set.\n\
16105 The commands themselves follow starting on the next line.\n\
16106 Type a line containing \"end\" to indicate the end of them.\n\
16107 Give \"silent\" as the first line to make the breakpoint silent;\n\
16108 then no output is printed when it is hit, except what the commands print."));
16110 c = add_com ("condition", class_breakpoint, condition_command, _("\
16111 Specify breakpoint number N to break only if COND is true.\n\
16112 Usage is `condition N COND', where N is an integer and COND is an\n\
16113 expression to be evaluated whenever breakpoint N is reached."));
16114 set_cmd_completer (c, condition_completer);
16116 c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
16117 Set a temporary breakpoint.\n\
16118 Like \"break\" except the breakpoint is only temporary,\n\
16119 so it will be deleted when hit. Equivalent to \"break\" followed\n\
16120 by using \"enable delete\" on the breakpoint number.\n\
16122 BREAK_ARGS_HELP ("tbreak")));
16123 set_cmd_completer (c, location_completer);
16125 c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
16126 Set a hardware assisted breakpoint.\n\
16127 Like \"break\" except the breakpoint requires hardware support,\n\
16128 some target hardware may not have this support.\n\
16130 BREAK_ARGS_HELP ("hbreak")));
16131 set_cmd_completer (c, location_completer);
16133 c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
16134 Set a temporary hardware assisted breakpoint.\n\
16135 Like \"hbreak\" except the breakpoint is only temporary,\n\
16136 so it will be deleted when hit.\n\
16138 BREAK_ARGS_HELP ("thbreak")));
16139 set_cmd_completer (c, location_completer);
16141 add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
16142 Enable some breakpoints.\n\
16143 Give breakpoint numbers (separated by spaces) as arguments.\n\
16144 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16145 This is used to cancel the effect of the \"disable\" command.\n\
16146 With a subcommand you can enable temporarily."),
16147 &enablelist, "enable ", 1, &cmdlist);
16149 add_com ("ab", class_breakpoint, enable_command, _("\
16150 Enable some breakpoints.\n\
16151 Give breakpoint numbers (separated by spaces) as arguments.\n\
16152 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16153 This is used to cancel the effect of the \"disable\" command.\n\
16154 With a subcommand you can enable temporarily."));
16156 add_com_alias ("en", "enable", class_breakpoint, 1);
16158 add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
16159 Enable some breakpoints.\n\
16160 Give breakpoint numbers (separated by spaces) as arguments.\n\
16161 This is used to cancel the effect of the \"disable\" command.\n\
16162 May be abbreviated to simply \"enable\".\n"),
16163 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
16165 add_cmd ("once", no_class, enable_once_command, _("\
16166 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16167 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16170 add_cmd ("delete", no_class, enable_delete_command, _("\
16171 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16172 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16175 add_cmd ("count", no_class, enable_count_command, _("\
16176 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16177 If a breakpoint is hit while enabled in this fashion,\n\
16178 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16181 add_cmd ("delete", no_class, enable_delete_command, _("\
16182 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16183 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16186 add_cmd ("once", no_class, enable_once_command, _("\
16187 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16188 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16191 add_cmd ("count", no_class, enable_count_command, _("\
16192 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16193 If a breakpoint is hit while enabled in this fashion,\n\
16194 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16197 add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
16198 Disable some breakpoints.\n\
16199 Arguments are breakpoint numbers with spaces in between.\n\
16200 To disable all breakpoints, give no argument.\n\
16201 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
16202 &disablelist, "disable ", 1, &cmdlist);
16203 add_com_alias ("dis", "disable", class_breakpoint, 1);
16204 add_com_alias ("disa", "disable", class_breakpoint, 1);
16206 add_com ("sb", class_breakpoint, disable_command, _("\
16207 Disable some breakpoints.\n\
16208 Arguments are breakpoint numbers with spaces in between.\n\
16209 To disable all breakpoints, give no argument.\n\
16210 A disabled breakpoint is not forgotten, but has no effect until re-enabled."));
16212 add_cmd ("breakpoints", class_alias, disable_command, _("\
16213 Disable some breakpoints.\n\
16214 Arguments are breakpoint numbers with spaces in between.\n\
16215 To disable all breakpoints, give no argument.\n\
16216 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
16217 This command may be abbreviated \"disable\"."),
16220 add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
16221 Delete some breakpoints or auto-display expressions.\n\
16222 Arguments are breakpoint numbers with spaces in between.\n\
16223 To delete all breakpoints, give no argument.\n\
16225 Also a prefix command for deletion of other GDB objects.\n\
16226 The \"unset\" command is also an alias for \"delete\"."),
16227 &deletelist, "delete ", 1, &cmdlist);
16228 add_com_alias ("d", "delete", class_breakpoint, 1);
16229 add_com_alias ("del", "delete", class_breakpoint, 1);
16231 add_com ("db", class_breakpoint, delete_command, _("\
16232 Delete some breakpoints.\n\
16233 Arguments are breakpoint numbers with spaces in between.\n\
16234 To delete all breakpoints, give no argument.\n"));
16236 add_cmd ("breakpoints", class_alias, delete_command, _("\
16237 Delete some breakpoints or auto-display expressions.\n\
16238 Arguments are breakpoint numbers with spaces in between.\n\
16239 To delete all breakpoints, give no argument.\n\
16240 This command may be abbreviated \"delete\"."),
16243 add_com ("clear", class_breakpoint, clear_command, _("\
16244 Clear breakpoint at specified line or function.\n\
16245 Argument may be line number, function name, or \"*\" and an address.\n\
16246 If line number is specified, all breakpoints in that line are cleared.\n\
16247 If function is specified, breakpoints at beginning of function are cleared.\n\
16248 If an address is specified, breakpoints at that address are cleared.\n\
16250 With no argument, clears all breakpoints in the line that the selected frame\n\
16251 is executing in.\n\
16253 See also the \"delete\" command which clears breakpoints by number."));
16254 add_com_alias ("cl", "clear", class_breakpoint, 1);
16256 c = add_com ("break", class_breakpoint, break_command, _("\
16257 Set breakpoint at specified line or function.\n"
16258 BREAK_ARGS_HELP ("break")));
16259 set_cmd_completer (c, location_completer);
16261 add_com_alias ("b", "break", class_run, 1);
16262 add_com_alias ("br", "break", class_run, 1);
16263 add_com_alias ("bre", "break", class_run, 1);
16264 add_com_alias ("brea", "break", class_run, 1);
16267 add_com_alias ("ba", "break", class_breakpoint, 1);
16271 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
16272 Break in function/address or break at a line in the current file."),
16273 &stoplist, "stop ", 1, &cmdlist);
16274 add_cmd ("in", class_breakpoint, stopin_command,
16275 _("Break in function or address."), &stoplist);
16276 add_cmd ("at", class_breakpoint, stopat_command,
16277 _("Break at a line in the current file."), &stoplist);
16278 add_com ("status", class_info, breakpoints_info, _("\
16279 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16280 The \"Type\" column indicates one of:\n\
16281 \tbreakpoint - normal breakpoint\n\
16282 \twatchpoint - watchpoint\n\
16283 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16284 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16285 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16286 address and file/line number respectively.\n\
16288 Convenience variable \"$_\" and default examine address for \"x\"\n\
16289 are set to the address of the last breakpoint listed unless the command\n\
16290 is prefixed with \"server \".\n\n\
16291 Convenience variable \"$bpnum\" contains the number of the last\n\
16292 breakpoint set."));
16295 add_info ("breakpoints", breakpoints_info, _("\
16296 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
16297 The \"Type\" column indicates one of:\n\
16298 \tbreakpoint - normal breakpoint\n\
16299 \twatchpoint - watchpoint\n\
16300 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16301 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16302 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16303 address and file/line number respectively.\n\
16305 Convenience variable \"$_\" and default examine address for \"x\"\n\
16306 are set to the address of the last breakpoint listed unless the command\n\
16307 is prefixed with \"server \".\n\n\
16308 Convenience variable \"$bpnum\" contains the number of the last\n\
16309 breakpoint set."));
16311 add_info_alias ("b", "breakpoints", 1);
16314 add_com ("lb", class_breakpoint, breakpoints_info, _("\
16315 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16316 The \"Type\" column indicates one of:\n\
16317 \tbreakpoint - normal breakpoint\n\
16318 \twatchpoint - watchpoint\n\
16319 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16320 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16321 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16322 address and file/line number respectively.\n\
16324 Convenience variable \"$_\" and default examine address for \"x\"\n\
16325 are set to the address of the last breakpoint listed unless the command\n\
16326 is prefixed with \"server \".\n\n\
16327 Convenience variable \"$bpnum\" contains the number of the last\n\
16328 breakpoint set."));
16330 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
16331 Status of all breakpoints, or breakpoint number NUMBER.\n\
16332 The \"Type\" column indicates one of:\n\
16333 \tbreakpoint - normal breakpoint\n\
16334 \twatchpoint - watchpoint\n\
16335 \tlongjmp - internal breakpoint used to step through longjmp()\n\
16336 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16337 \tuntil - internal breakpoint used by the \"until\" command\n\
16338 \tfinish - internal breakpoint used by the \"finish\" command\n\
16339 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16340 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16341 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16342 address and file/line number respectively.\n\
16344 Convenience variable \"$_\" and default examine address for \"x\"\n\
16345 are set to the address of the last breakpoint listed unless the command\n\
16346 is prefixed with \"server \".\n\n\
16347 Convenience variable \"$bpnum\" contains the number of the last\n\
16349 &maintenanceinfolist);
16351 add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
16352 Set catchpoints to catch events."),
16353 &catch_cmdlist, "catch ",
16354 0/*allow-unknown*/, &cmdlist);
16356 add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
16357 Set temporary catchpoints to catch events."),
16358 &tcatch_cmdlist, "tcatch ",
16359 0/*allow-unknown*/, &cmdlist);
16361 add_catch_command ("fork", _("Catch calls to fork."),
16362 catch_fork_command_1,
16364 (void *) (uintptr_t) catch_fork_permanent,
16365 (void *) (uintptr_t) catch_fork_temporary);
16366 add_catch_command ("vfork", _("Catch calls to vfork."),
16367 catch_fork_command_1,
16369 (void *) (uintptr_t) catch_vfork_permanent,
16370 (void *) (uintptr_t) catch_vfork_temporary);
16371 add_catch_command ("exec", _("Catch calls to exec."),
16372 catch_exec_command_1,
16376 add_catch_command ("load", _("Catch loads of shared libraries.\n\
16377 Usage: catch load [REGEX]\n\
16378 If REGEX is given, only stop for libraries matching the regular expression."),
16379 catch_load_command_1,
16383 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16384 Usage: catch unload [REGEX]\n\
16385 If REGEX is given, only stop for libraries matching the regular expression."),
16386 catch_unload_command_1,
16390 add_catch_command ("syscall", _("\
16391 Catch system calls by their names and/or numbers.\n\
16392 Arguments say which system calls to catch. If no arguments\n\
16393 are given, every system call will be caught.\n\
16394 Arguments, if given, should be one or more system call names\n\
16395 (if your system supports that), or system call numbers."),
16396 catch_syscall_command_1,
16397 catch_syscall_completer,
16401 c = add_com ("watch", class_breakpoint, watch_command, _("\
16402 Set a watchpoint for an expression.\n\
16403 Usage: watch [-l|-location] EXPRESSION\n\
16404 A watchpoint stops execution of your program whenever the value of\n\
16405 an expression changes.\n\
16406 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16407 the memory to which it refers."));
16408 set_cmd_completer (c, expression_completer);
16410 c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
16411 Set a read watchpoint for an expression.\n\
16412 Usage: rwatch [-l|-location] EXPRESSION\n\
16413 A watchpoint stops execution of your program whenever the value of\n\
16414 an expression is read.\n\
16415 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16416 the memory to which it refers."));
16417 set_cmd_completer (c, expression_completer);
16419 c = add_com ("awatch", class_breakpoint, awatch_command, _("\
16420 Set a watchpoint for an expression.\n\
16421 Usage: awatch [-l|-location] EXPRESSION\n\
16422 A watchpoint stops execution of your program whenever the value of\n\
16423 an expression is either read or written.\n\
16424 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16425 the memory to which it refers."));
16426 set_cmd_completer (c, expression_completer);
16428 add_info ("watchpoints", watchpoints_info, _("\
16429 Status of specified watchpoints (all watchpoints if no argument)."));
16431 /* XXX: cagney/2005-02-23: This should be a boolean, and should
16432 respond to changes - contrary to the description. */
16433 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
16434 &can_use_hw_watchpoints, _("\
16435 Set debugger's willingness to use watchpoint hardware."), _("\
16436 Show debugger's willingness to use watchpoint hardware."), _("\
16437 If zero, gdb will not use hardware for new watchpoints, even if\n\
16438 such is available. (However, any hardware watchpoints that were\n\
16439 created before setting this to nonzero, will continue to use watchpoint\n\
16442 show_can_use_hw_watchpoints,
16443 &setlist, &showlist);
16445 can_use_hw_watchpoints = 1;
16447 /* Tracepoint manipulation commands. */
16449 c = add_com ("trace", class_breakpoint, trace_command, _("\
16450 Set a tracepoint at specified line or function.\n\
16452 BREAK_ARGS_HELP ("trace") "\n\
16453 Do \"help tracepoints\" for info on other tracepoint commands."));
16454 set_cmd_completer (c, location_completer);
16456 add_com_alias ("tp", "trace", class_alias, 0);
16457 add_com_alias ("tr", "trace", class_alias, 1);
16458 add_com_alias ("tra", "trace", class_alias, 1);
16459 add_com_alias ("trac", "trace", class_alias, 1);
16461 c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
16462 Set a fast tracepoint at specified line or function.\n\
16464 BREAK_ARGS_HELP ("ftrace") "\n\
16465 Do \"help tracepoints\" for info on other tracepoint commands."));
16466 set_cmd_completer (c, location_completer);
16468 c = add_com ("strace", class_breakpoint, strace_command, _("\
16469 Set a static tracepoint at specified line, function or marker.\n\
16471 strace [LOCATION] [if CONDITION]\n\
16472 LOCATION may be a line number, function name, \"*\" and an address,\n\
16473 or -m MARKER_ID.\n\
16474 If a line number is specified, probe the marker at start of code\n\
16475 for that line. If a function is specified, probe the marker at start\n\
16476 of code for that function. If an address is specified, probe the marker\n\
16477 at that exact address. If a marker id is specified, probe the marker\n\
16478 with that name. With no LOCATION, uses current execution address of\n\
16479 the selected stack frame.\n\
16480 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16481 This collects arbitrary user data passed in the probe point call to the\n\
16482 tracing library. You can inspect it when analyzing the trace buffer,\n\
16483 by printing the $_sdata variable like any other convenience variable.\n\
16485 CONDITION is a boolean expression.\n\
16487 Multiple tracepoints at one place are permitted, and useful if their\n\
16488 conditions are different.\n\
16490 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16491 Do \"help tracepoints\" for info on other tracepoint commands."));
16492 set_cmd_completer (c, location_completer);
16494 add_info ("tracepoints", tracepoints_info, _("\
16495 Status of specified tracepoints (all tracepoints if no argument).\n\
16496 Convenience variable \"$tpnum\" contains the number of the\n\
16497 last tracepoint set."));
16499 add_info_alias ("tp", "tracepoints", 1);
16501 add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
16502 Delete specified tracepoints.\n\
16503 Arguments are tracepoint numbers, separated by spaces.\n\
16504 No argument means delete all tracepoints."),
16506 add_alias_cmd ("tr", "tracepoints", class_trace, 1, &deletelist);
16508 c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
16509 Disable specified tracepoints.\n\
16510 Arguments are tracepoint numbers, separated by spaces.\n\
16511 No argument means disable all tracepoints."),
16513 deprecate_cmd (c, "disable");
16515 c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
16516 Enable specified tracepoints.\n\
16517 Arguments are tracepoint numbers, separated by spaces.\n\
16518 No argument means enable all tracepoints."),
16520 deprecate_cmd (c, "enable");
16522 add_com ("passcount", class_trace, trace_pass_command, _("\
16523 Set the passcount for a tracepoint.\n\
16524 The trace will end when the tracepoint has been passed 'count' times.\n\
16525 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16526 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16528 add_prefix_cmd ("save", class_breakpoint, save_command,
16529 _("Save breakpoint definitions as a script."),
16530 &save_cmdlist, "save ",
16531 0/*allow-unknown*/, &cmdlist);
16533 c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
16534 Save current breakpoint definitions as a script.\n\
16535 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16536 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16537 session to restore them."),
16539 set_cmd_completer (c, filename_completer);
16541 c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
16542 Save current tracepoint definitions as a script.\n\
16543 Use the 'source' command in another debug session to restore them."),
16545 set_cmd_completer (c, filename_completer);
16547 c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
16548 deprecate_cmd (c, "save tracepoints");
16550 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
16551 Breakpoint specific settings\n\
16552 Configure various breakpoint-specific variables such as\n\
16553 pending breakpoint behavior"),
16554 &breakpoint_set_cmdlist, "set breakpoint ",
16555 0/*allow-unknown*/, &setlist);
16556 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
16557 Breakpoint specific settings\n\
16558 Configure various breakpoint-specific variables such as\n\
16559 pending breakpoint behavior"),
16560 &breakpoint_show_cmdlist, "show breakpoint ",
16561 0/*allow-unknown*/, &showlist);
16563 add_setshow_auto_boolean_cmd ("pending", no_class,
16564 &pending_break_support, _("\
16565 Set debugger's behavior regarding pending breakpoints."), _("\
16566 Show debugger's behavior regarding pending breakpoints."), _("\
16567 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16568 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16569 an error. If auto, an unrecognized breakpoint location results in a\n\
16570 user-query to see if a pending breakpoint should be created."),
16572 show_pending_break_support,
16573 &breakpoint_set_cmdlist,
16574 &breakpoint_show_cmdlist);
16576 pending_break_support = AUTO_BOOLEAN_AUTO;
16578 add_setshow_boolean_cmd ("auto-hw", no_class,
16579 &automatic_hardware_breakpoints, _("\
16580 Set automatic usage of hardware breakpoints."), _("\
16581 Show automatic usage of hardware breakpoints."), _("\
16582 If set, the debugger will automatically use hardware breakpoints for\n\
16583 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16584 a warning will be emitted for such breakpoints."),
16586 show_automatic_hardware_breakpoints,
16587 &breakpoint_set_cmdlist,
16588 &breakpoint_show_cmdlist);
16590 add_setshow_auto_boolean_cmd ("always-inserted", class_support,
16591 &always_inserted_mode, _("\
16592 Set mode for inserting breakpoints."), _("\
16593 Show mode for inserting breakpoints."), _("\
16594 When this mode is off, breakpoints are inserted in inferior when it is\n\
16595 resumed, and removed when execution stops. When this mode is on,\n\
16596 breakpoints are inserted immediately and removed only when the user\n\
16597 deletes the breakpoint. When this mode is auto (which is the default),\n\
16598 the behaviour depends on the non-stop setting (see help set non-stop).\n\
16599 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
16600 behaves as if always-inserted mode is on; if gdb is controlling the\n\
16601 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
16603 &show_always_inserted_mode,
16604 &breakpoint_set_cmdlist,
16605 &breakpoint_show_cmdlist);
16607 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
16608 condition_evaluation_enums,
16609 &condition_evaluation_mode_1, _("\
16610 Set mode of breakpoint condition evaluation."), _("\
16611 Show mode of breakpoint condition evaluation."), _("\
16612 When this is set to \"host\", breakpoint conditions will be\n\
16613 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16614 breakpoint conditions will be downloaded to the target (if the target\n\
16615 supports such feature) and conditions will be evaluated on the target's side.\n\
16616 If this is set to \"auto\" (default), this will be automatically set to\n\
16617 \"target\" if it supports condition evaluation, otherwise it will\n\
16618 be set to \"gdb\""),
16619 &set_condition_evaluation_mode,
16620 &show_condition_evaluation_mode,
16621 &breakpoint_set_cmdlist,
16622 &breakpoint_show_cmdlist);
16624 add_com ("break-range", class_breakpoint, break_range_command, _("\
16625 Set a breakpoint for an address range.\n\
16626 break-range START-LOCATION, END-LOCATION\n\
16627 where START-LOCATION and END-LOCATION can be one of the following:\n\
16628 LINENUM, for that line in the current file,\n\
16629 FILE:LINENUM, for that line in that file,\n\
16630 +OFFSET, for that number of lines after the current line\n\
16631 or the start of the range\n\
16632 FUNCTION, for the first line in that function,\n\
16633 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16634 *ADDRESS, for the instruction at that address.\n\
16636 The breakpoint will stop execution of the inferior whenever it executes\n\
16637 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16638 range (including START-LOCATION and END-LOCATION)."));
16640 c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
16641 Set a dynamic printf at specified line or function.\n\
16642 dprintf location,format string,arg1,arg2,...\n\
16643 location may be a line number, function name, or \"*\" and an address.\n\
16644 If a line number is specified, break at start of code for that line.\n\
16645 If a function is specified, break at start of code for that function."));
16646 set_cmd_completer (c, location_completer);
16648 add_setshow_enum_cmd ("dprintf-style", class_support,
16649 dprintf_style_enums, &dprintf_style, _("\
16650 Set the style of usage for dynamic printf."), _("\
16651 Show the style of usage for dynamic printf."), _("\
16652 This setting chooses how GDB will do a dynamic printf.\n\
16653 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16654 console, as with the \"printf\" command.\n\
16655 If the value is \"call\", the print is done by calling a function in your\n\
16656 program; by default printf(), but you can choose a different function or\n\
16657 output stream by setting dprintf-function and dprintf-channel."),
16658 update_dprintf_commands, NULL,
16659 &setlist, &showlist);
16661 dprintf_function = xstrdup ("printf");
16662 add_setshow_string_cmd ("dprintf-function", class_support,
16663 &dprintf_function, _("\
16664 Set the function to use for dynamic printf"), _("\
16665 Show the function to use for dynamic printf"), NULL,
16666 update_dprintf_commands, NULL,
16667 &setlist, &showlist);
16669 dprintf_channel = xstrdup ("");
16670 add_setshow_string_cmd ("dprintf-channel", class_support,
16671 &dprintf_channel, _("\
16672 Set the channel to use for dynamic printf"), _("\
16673 Show the channel to use for dynamic printf"), NULL,
16674 update_dprintf_commands, NULL,
16675 &setlist, &showlist);
16677 add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
16678 &disconnected_dprintf, _("\
16679 Set whether dprintf continues after GDB disconnects."), _("\
16680 Show whether dprintf continues after GDB disconnects."), _("\
16681 Use this to let dprintf commands continue to hit and produce output\n\
16682 even if GDB disconnects or detaches from the target."),
16685 &setlist, &showlist);
16687 add_com ("agent-printf", class_vars, agent_printf_command, _("\
16688 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16689 (target agent only) This is useful for formatted output in user-defined commands."));
16691 automatic_hardware_breakpoints = 1;
16693 observer_attach_about_to_proceed (breakpoint_about_to_proceed);
16694 observer_attach_thread_exit (remove_threaded_breakpoints);