1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2016 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"
36 #include "gdbthread.h"
39 #include "gdb-demangle.h"
40 #include "filenames.h"
46 #include "completer.h"
49 #include "cli/cli-script.h"
59 #include "parser-defs.h"
60 #include "gdb_regex.h"
62 #include "cli/cli-utils.h"
63 #include "continuations.h"
67 #include "dummy-frame.h"
71 #include "thread-fsm.h"
72 #include "tid-parse.h"
74 /* readline include files */
75 #include "readline/readline.h"
76 #include "readline/history.h"
78 /* readline defines this. */
81 #include "mi/mi-common.h"
82 #include "extension.h"
84 /* Enums for exception-handling support. */
85 enum exception_event_kind
92 /* Prototypes for local functions. */
94 static void enable_delete_command (char *, int);
96 static void enable_once_command (char *, int);
98 static void enable_count_command (char *, int);
100 static void disable_command (char *, int);
102 static void enable_command (char *, int);
104 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint
*,
108 static void ignore_command (char *, int);
110 static int breakpoint_re_set_one (void *);
112 static void breakpoint_re_set_default (struct breakpoint
*);
115 create_sals_from_location_default (const struct event_location
*location
,
116 struct linespec_result
*canonical
,
117 enum bptype type_wanted
);
119 static void create_breakpoints_sal_default (struct gdbarch
*,
120 struct linespec_result
*,
121 char *, char *, enum bptype
,
122 enum bpdisp
, int, int,
124 const struct breakpoint_ops
*,
125 int, int, int, unsigned);
127 static void decode_location_default (struct breakpoint
*b
,
128 const struct event_location
*location
,
129 struct program_space
*search_pspace
,
130 struct symtabs_and_lines
*sals
);
132 static void clear_command (char *, int);
134 static void catch_command (char *, int);
136 static int can_use_hardware_watchpoint (struct value
*);
138 static void break_command_1 (char *, int, int);
140 static void mention (struct breakpoint
*);
142 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
144 const struct breakpoint_ops
*);
145 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
146 const struct symtab_and_line
*);
148 /* This function is used in gdbtk sources and thus can not be made
150 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
151 struct symtab_and_line
,
153 const struct breakpoint_ops
*);
155 static struct breakpoint
*
156 momentary_breakpoint_from_master (struct breakpoint
*orig
,
158 const struct breakpoint_ops
*ops
,
161 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
163 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
167 static void describe_other_breakpoints (struct gdbarch
*,
168 struct program_space
*, CORE_ADDR
,
169 struct obj_section
*, int);
171 static int watchpoint_locations_match (struct bp_location
*loc1
,
172 struct bp_location
*loc2
);
174 static int breakpoint_location_address_match (struct bp_location
*bl
,
175 struct address_space
*aspace
,
178 static int breakpoint_location_address_range_overlap (struct bp_location
*,
179 struct address_space
*,
182 static void breakpoints_info (char *, int);
184 static void watchpoints_info (char *, int);
186 static int breakpoint_1 (char *, int,
187 int (*) (const struct breakpoint
*));
189 static int breakpoint_cond_eval (void *);
191 static void cleanup_executing_breakpoints (void *);
193 static void commands_command (char *, int);
195 static void condition_command (char *, int);
197 static int remove_breakpoint (struct bp_location
*);
198 static int remove_breakpoint_1 (struct bp_location
*, enum remove_bp_reason
);
200 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
202 static int watchpoint_check (void *);
204 static void maintenance_info_breakpoints (char *, int);
206 static int hw_breakpoint_used_count (void);
208 static int hw_watchpoint_use_count (struct breakpoint
*);
210 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
212 int *other_type_used
);
214 static void hbreak_command (char *, int);
216 static void thbreak_command (char *, int);
218 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
221 static void stop_command (char *arg
, int from_tty
);
223 static void stopin_command (char *arg
, int from_tty
);
225 static void stopat_command (char *arg
, int from_tty
);
227 static void tcatch_command (char *arg
, int from_tty
);
229 static void free_bp_location (struct bp_location
*loc
);
230 static void incref_bp_location (struct bp_location
*loc
);
231 static void decref_bp_location (struct bp_location
**loc
);
233 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
235 /* update_global_location_list's modes of operation wrt to whether to
236 insert locations now. */
237 enum ugll_insert_mode
239 /* Don't insert any breakpoint locations into the inferior, only
240 remove already-inserted locations that no longer should be
241 inserted. Functions that delete a breakpoint or breakpoints
242 should specify this mode, so that deleting a breakpoint doesn't
243 have the side effect of inserting the locations of other
244 breakpoints that are marked not-inserted, but should_be_inserted
245 returns true on them.
247 This behavior is useful is situations close to tear-down -- e.g.,
248 after an exec, while the target still has execution, but
249 breakpoint shadows of the previous executable image should *NOT*
250 be restored to the new image; or before detaching, where the
251 target still has execution and wants to delete breakpoints from
252 GDB's lists, and all breakpoints had already been removed from
256 /* May insert breakpoints iff breakpoints_should_be_inserted_now
257 claims breakpoints should be inserted now. */
260 /* Insert locations now, irrespective of
261 breakpoints_should_be_inserted_now. E.g., say all threads are
262 stopped right now, and the user did "continue". We need to
263 insert breakpoints _before_ resuming the target, but
264 UGLL_MAY_INSERT wouldn't insert them, because
265 breakpoints_should_be_inserted_now returns false at that point,
266 as no thread is running yet. */
270 static void update_global_location_list (enum ugll_insert_mode
);
272 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
274 static int is_hardware_watchpoint (const struct breakpoint
*bpt
);
276 static void insert_breakpoint_locations (void);
278 static void tracepoints_info (char *, int);
280 static void delete_trace_command (char *, int);
282 static void enable_trace_command (char *, int);
284 static void disable_trace_command (char *, int);
286 static void trace_pass_command (char *, int);
288 static void set_tracepoint_count (int num
);
290 static int is_masked_watchpoint (const struct breakpoint
*b
);
292 static struct bp_location
**get_first_locp_gte_addr (CORE_ADDR address
);
294 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
297 static int strace_marker_p (struct breakpoint
*b
);
299 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
300 that are implemented on top of software or hardware breakpoints
301 (user breakpoints, internal and momentary breakpoints, etc.). */
302 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
304 /* Internal breakpoints class type. */
305 static struct breakpoint_ops internal_breakpoint_ops
;
307 /* Momentary breakpoints class type. */
308 static struct breakpoint_ops momentary_breakpoint_ops
;
310 /* Momentary breakpoints for bp_longjmp and bp_exception class type. */
311 static struct breakpoint_ops longjmp_breakpoint_ops
;
313 /* The breakpoint_ops structure to be used in regular user created
315 struct breakpoint_ops bkpt_breakpoint_ops
;
317 /* Breakpoints set on probes. */
318 static struct breakpoint_ops bkpt_probe_breakpoint_ops
;
320 /* Dynamic printf class type. */
321 struct breakpoint_ops dprintf_breakpoint_ops
;
323 /* The style in which to perform a dynamic printf. This is a user
324 option because different output options have different tradeoffs;
325 if GDB does the printing, there is better error handling if there
326 is a problem with any of the arguments, but using an inferior
327 function lets you have special-purpose printers and sending of
328 output to the same place as compiled-in print functions. */
330 static const char dprintf_style_gdb
[] = "gdb";
331 static const char dprintf_style_call
[] = "call";
332 static const char dprintf_style_agent
[] = "agent";
333 static const char *const dprintf_style_enums
[] = {
339 static const char *dprintf_style
= dprintf_style_gdb
;
341 /* The function to use for dynamic printf if the preferred style is to
342 call into the inferior. The value is simply a string that is
343 copied into the command, so it can be anything that GDB can
344 evaluate to a callable address, not necessarily a function name. */
346 static char *dprintf_function
= "";
348 /* The channel to use for dynamic printf if the preferred style is to
349 call into the inferior; if a nonempty string, it will be passed to
350 the call as the first argument, with the format string as the
351 second. As with the dprintf function, this can be anything that
352 GDB knows how to evaluate, so in addition to common choices like
353 "stderr", this could be an app-specific expression like
354 "mystreams[curlogger]". */
356 static char *dprintf_channel
= "";
358 /* True if dprintf commands should continue to operate even if GDB
360 static int disconnected_dprintf
= 1;
362 /* A reference-counted struct command_line. This lets multiple
363 breakpoints share a single command list. */
364 struct counted_command_line
366 /* The reference count. */
369 /* The command list. */
370 struct command_line
*commands
;
373 struct command_line
*
374 breakpoint_commands (struct breakpoint
*b
)
376 return b
->commands
? b
->commands
->commands
: NULL
;
379 /* Flag indicating that a command has proceeded the inferior past the
380 current breakpoint. */
382 static int breakpoint_proceeded
;
385 bpdisp_text (enum bpdisp disp
)
387 /* NOTE: the following values are a part of MI protocol and
388 represent values of 'disp' field returned when inferior stops at
390 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
392 return bpdisps
[(int) disp
];
395 /* Prototypes for exported functions. */
396 /* If FALSE, gdb will not use hardware support for watchpoints, even
397 if such is available. */
398 static int can_use_hw_watchpoints
;
401 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
402 struct cmd_list_element
*c
,
405 fprintf_filtered (file
,
406 _("Debugger's willingness to use "
407 "watchpoint hardware is %s.\n"),
411 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
412 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
413 for unrecognized breakpoint locations.
414 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
415 static enum auto_boolean pending_break_support
;
417 show_pending_break_support (struct ui_file
*file
, int from_tty
,
418 struct cmd_list_element
*c
,
421 fprintf_filtered (file
,
422 _("Debugger's behavior regarding "
423 "pending breakpoints is %s.\n"),
427 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
428 set with "break" but falling in read-only memory.
429 If 0, gdb will warn about such breakpoints, but won't automatically
430 use hardware breakpoints. */
431 static int automatic_hardware_breakpoints
;
433 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
434 struct cmd_list_element
*c
,
437 fprintf_filtered (file
,
438 _("Automatic usage of hardware breakpoints is %s.\n"),
442 /* If on, GDB keeps breakpoints inserted even if the inferior is
443 stopped, and immediately inserts any new breakpoints as soon as
444 they're created. If off (default), GDB keeps breakpoints off of
445 the target as long as possible. That is, it delays inserting
446 breakpoints until the next resume, and removes them again when the
447 target fully stops. This is a bit safer in case GDB crashes while
448 processing user input. */
449 static int always_inserted_mode
= 0;
452 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
453 struct cmd_list_element
*c
, const char *value
)
455 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
459 /* See breakpoint.h. */
462 breakpoints_should_be_inserted_now (void)
464 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
466 /* If breakpoints are global, they should be inserted even if no
467 thread under gdb's control is running, or even if there are
468 no threads under GDB's control yet. */
471 else if (target_has_execution
)
473 struct thread_info
*tp
;
475 if (always_inserted_mode
)
477 /* The user wants breakpoints inserted even if all threads
482 if (threads_are_executing ())
485 /* Don't remove breakpoints yet if, even though all threads are
486 stopped, we still have events to process. */
487 ALL_NON_EXITED_THREADS (tp
)
489 && tp
->suspend
.waitstatus_pending_p
)
495 static const char condition_evaluation_both
[] = "host or target";
497 /* Modes for breakpoint condition evaluation. */
498 static const char condition_evaluation_auto
[] = "auto";
499 static const char condition_evaluation_host
[] = "host";
500 static const char condition_evaluation_target
[] = "target";
501 static const char *const condition_evaluation_enums
[] = {
502 condition_evaluation_auto
,
503 condition_evaluation_host
,
504 condition_evaluation_target
,
508 /* Global that holds the current mode for breakpoint condition evaluation. */
509 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
511 /* Global that we use to display information to the user (gets its value from
512 condition_evaluation_mode_1. */
513 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
515 /* Translate a condition evaluation mode MODE into either "host"
516 or "target". This is used mostly to translate from "auto" to the
517 real setting that is being used. It returns the translated
521 translate_condition_evaluation_mode (const char *mode
)
523 if (mode
== condition_evaluation_auto
)
525 if (target_supports_evaluation_of_breakpoint_conditions ())
526 return condition_evaluation_target
;
528 return condition_evaluation_host
;
534 /* Discovers what condition_evaluation_auto translates to. */
537 breakpoint_condition_evaluation_mode (void)
539 return translate_condition_evaluation_mode (condition_evaluation_mode
);
542 /* Return true if GDB should evaluate breakpoint conditions or false
546 gdb_evaluates_breakpoint_condition_p (void)
548 const char *mode
= breakpoint_condition_evaluation_mode ();
550 return (mode
== condition_evaluation_host
);
553 void _initialize_breakpoint (void);
555 /* Are we executing breakpoint commands? */
556 static int executing_breakpoint_commands
;
558 /* Are overlay event breakpoints enabled? */
559 static int overlay_events_enabled
;
561 /* See description in breakpoint.h. */
562 int target_exact_watchpoints
= 0;
564 /* Walk the following statement or block through all breakpoints.
565 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
566 current breakpoint. */
568 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
570 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
571 for (B = breakpoint_chain; \
572 B ? (TMP=B->next, 1): 0; \
575 /* Similar iterator for the low-level breakpoints. SAFE variant is
576 not provided so update_global_location_list must not be called
577 while executing the block of ALL_BP_LOCATIONS. */
579 #define ALL_BP_LOCATIONS(B,BP_TMP) \
580 for (BP_TMP = bp_location; \
581 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
584 /* Iterates through locations with address ADDRESS for the currently selected
585 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
586 to where the loop should start from.
587 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
588 appropriate location to start with. */
590 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
591 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
592 BP_LOCP_TMP = BP_LOCP_START; \
594 && (BP_LOCP_TMP < bp_location + bp_location_count \
595 && (*BP_LOCP_TMP)->address == ADDRESS); \
598 /* Iterator for tracepoints only. */
600 #define ALL_TRACEPOINTS(B) \
601 for (B = breakpoint_chain; B; B = B->next) \
602 if (is_tracepoint (B))
604 /* Chains of all breakpoints defined. */
606 struct breakpoint
*breakpoint_chain
;
608 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
610 static struct bp_location
**bp_location
;
612 /* Number of elements of BP_LOCATION. */
614 static unsigned bp_location_count
;
616 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
617 ADDRESS for the current elements of BP_LOCATION which get a valid
618 result from bp_location_has_shadow. You can use it for roughly
619 limiting the subrange of BP_LOCATION to scan for shadow bytes for
620 an address you need to read. */
622 static CORE_ADDR bp_location_placed_address_before_address_max
;
624 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
625 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
626 BP_LOCATION which get a valid result from bp_location_has_shadow.
627 You can use it for roughly limiting the subrange of BP_LOCATION to
628 scan for shadow bytes for an address you need to read. */
630 static CORE_ADDR bp_location_shadow_len_after_address_max
;
632 /* The locations that no longer correspond to any breakpoint, unlinked
633 from bp_location array, but for which a hit may still be reported
635 VEC(bp_location_p
) *moribund_locations
= NULL
;
637 /* Number of last breakpoint made. */
639 static int breakpoint_count
;
641 /* The value of `breakpoint_count' before the last command that
642 created breakpoints. If the last (break-like) command created more
643 than one breakpoint, then the difference between BREAKPOINT_COUNT
644 and PREV_BREAKPOINT_COUNT is more than one. */
645 static int prev_breakpoint_count
;
647 /* Number of last tracepoint made. */
649 static int tracepoint_count
;
651 static struct cmd_list_element
*breakpoint_set_cmdlist
;
652 static struct cmd_list_element
*breakpoint_show_cmdlist
;
653 struct cmd_list_element
*save_cmdlist
;
655 /* See declaration at breakpoint.h. */
658 breakpoint_find_if (int (*func
) (struct breakpoint
*b
, void *d
),
661 struct breakpoint
*b
= NULL
;
665 if (func (b
, user_data
) != 0)
672 /* Return whether a breakpoint is an active enabled breakpoint. */
674 breakpoint_enabled (struct breakpoint
*b
)
676 return (b
->enable_state
== bp_enabled
);
679 /* Set breakpoint count to NUM. */
682 set_breakpoint_count (int num
)
684 prev_breakpoint_count
= breakpoint_count
;
685 breakpoint_count
= num
;
686 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
689 /* Used by `start_rbreak_breakpoints' below, to record the current
690 breakpoint count before "rbreak" creates any breakpoint. */
691 static int rbreak_start_breakpoint_count
;
693 /* Called at the start an "rbreak" command to record the first
697 start_rbreak_breakpoints (void)
699 rbreak_start_breakpoint_count
= breakpoint_count
;
702 /* Called at the end of an "rbreak" command to record the last
706 end_rbreak_breakpoints (void)
708 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
711 /* Used in run_command to zero the hit count when a new run starts. */
714 clear_breakpoint_hit_counts (void)
716 struct breakpoint
*b
;
722 /* Allocate a new counted_command_line with reference count of 1.
723 The new structure owns COMMANDS. */
725 static struct counted_command_line
*
726 alloc_counted_command_line (struct command_line
*commands
)
728 struct counted_command_line
*result
= XNEW (struct counted_command_line
);
731 result
->commands
= commands
;
736 /* Increment reference count. This does nothing if CMD is NULL. */
739 incref_counted_command_line (struct counted_command_line
*cmd
)
745 /* Decrement reference count. If the reference count reaches 0,
746 destroy the counted_command_line. Sets *CMDP to NULL. This does
747 nothing if *CMDP is NULL. */
750 decref_counted_command_line (struct counted_command_line
**cmdp
)
754 if (--(*cmdp
)->refc
== 0)
756 free_command_lines (&(*cmdp
)->commands
);
763 /* A cleanup function that calls decref_counted_command_line. */
766 do_cleanup_counted_command_line (void *arg
)
768 decref_counted_command_line ((struct counted_command_line
**) arg
);
771 /* Create a cleanup that calls decref_counted_command_line on the
774 static struct cleanup
*
775 make_cleanup_decref_counted_command_line (struct counted_command_line
**cmdp
)
777 return make_cleanup (do_cleanup_counted_command_line
, cmdp
);
781 /* Return the breakpoint with the specified number, or NULL
782 if the number does not refer to an existing breakpoint. */
785 get_breakpoint (int num
)
787 struct breakpoint
*b
;
790 if (b
->number
== num
)
798 /* Mark locations as "conditions have changed" in case the target supports
799 evaluating conditions on its side. */
802 mark_breakpoint_modified (struct breakpoint
*b
)
804 struct bp_location
*loc
;
806 /* This is only meaningful if the target is
807 evaluating conditions and if the user has
808 opted for condition evaluation on the target's
810 if (gdb_evaluates_breakpoint_condition_p ()
811 || !target_supports_evaluation_of_breakpoint_conditions ())
814 if (!is_breakpoint (b
))
817 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
818 loc
->condition_changed
= condition_modified
;
821 /* Mark location as "conditions have changed" in case the target supports
822 evaluating conditions on its side. */
825 mark_breakpoint_location_modified (struct bp_location
*loc
)
827 /* This is only meaningful if the target is
828 evaluating conditions and if the user has
829 opted for condition evaluation on the target's
831 if (gdb_evaluates_breakpoint_condition_p ()
832 || !target_supports_evaluation_of_breakpoint_conditions ())
836 if (!is_breakpoint (loc
->owner
))
839 loc
->condition_changed
= condition_modified
;
842 /* Sets the condition-evaluation mode using the static global
843 condition_evaluation_mode. */
846 set_condition_evaluation_mode (char *args
, int from_tty
,
847 struct cmd_list_element
*c
)
849 const char *old_mode
, *new_mode
;
851 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
852 && !target_supports_evaluation_of_breakpoint_conditions ())
854 condition_evaluation_mode_1
= condition_evaluation_mode
;
855 warning (_("Target does not support breakpoint condition evaluation.\n"
856 "Using host evaluation mode instead."));
860 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
861 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
863 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
864 settings was "auto". */
865 condition_evaluation_mode
= condition_evaluation_mode_1
;
867 /* Only update the mode if the user picked a different one. */
868 if (new_mode
!= old_mode
)
870 struct bp_location
*loc
, **loc_tmp
;
871 /* If the user switched to a different evaluation mode, we
872 need to synch the changes with the target as follows:
874 "host" -> "target": Send all (valid) conditions to the target.
875 "target" -> "host": Remove all the conditions from the target.
878 if (new_mode
== condition_evaluation_target
)
880 /* Mark everything modified and synch conditions with the
882 ALL_BP_LOCATIONS (loc
, loc_tmp
)
883 mark_breakpoint_location_modified (loc
);
887 /* Manually mark non-duplicate locations to synch conditions
888 with the target. We do this to remove all the conditions the
889 target knows about. */
890 ALL_BP_LOCATIONS (loc
, loc_tmp
)
891 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
892 loc
->needs_update
= 1;
896 update_global_location_list (UGLL_MAY_INSERT
);
902 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
903 what "auto" is translating to. */
906 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
907 struct cmd_list_element
*c
, const char *value
)
909 if (condition_evaluation_mode
== condition_evaluation_auto
)
910 fprintf_filtered (file
,
911 _("Breakpoint condition evaluation "
912 "mode is %s (currently %s).\n"),
914 breakpoint_condition_evaluation_mode ());
916 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
920 /* A comparison function for bp_location AP and BP that is used by
921 bsearch. This comparison function only cares about addresses, unlike
922 the more general bp_location_compare function. */
925 bp_location_compare_addrs (const void *ap
, const void *bp
)
927 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
928 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
930 if (a
->address
== b
->address
)
933 return ((a
->address
> b
->address
) - (a
->address
< b
->address
));
936 /* Helper function to skip all bp_locations with addresses
937 less than ADDRESS. It returns the first bp_location that
938 is greater than or equal to ADDRESS. If none is found, just
941 static struct bp_location
**
942 get_first_locp_gte_addr (CORE_ADDR address
)
944 struct bp_location dummy_loc
;
945 struct bp_location
*dummy_locp
= &dummy_loc
;
946 struct bp_location
**locp_found
= NULL
;
948 /* Initialize the dummy location's address field. */
949 memset (&dummy_loc
, 0, sizeof (struct bp_location
));
950 dummy_loc
.address
= address
;
952 /* Find a close match to the first location at ADDRESS. */
953 locp_found
= ((struct bp_location
**)
954 bsearch (&dummy_locp
, bp_location
, bp_location_count
,
955 sizeof (struct bp_location
**),
956 bp_location_compare_addrs
));
958 /* Nothing was found, nothing left to do. */
959 if (locp_found
== NULL
)
962 /* We may have found a location that is at ADDRESS but is not the first in the
963 location's list. Go backwards (if possible) and locate the first one. */
964 while ((locp_found
- 1) >= bp_location
965 && (*(locp_found
- 1))->address
== address
)
972 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
975 xfree (b
->cond_string
);
976 b
->cond_string
= NULL
;
978 if (is_watchpoint (b
))
980 struct watchpoint
*w
= (struct watchpoint
*) b
;
987 struct bp_location
*loc
;
989 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
994 /* No need to free the condition agent expression
995 bytecode (if we have one). We will handle this
996 when we go through update_global_location_list. */
1003 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
1007 const char *arg
= exp
;
1009 /* I don't know if it matters whether this is the string the user
1010 typed in or the decompiled expression. */
1011 b
->cond_string
= xstrdup (arg
);
1012 b
->condition_not_parsed
= 0;
1014 if (is_watchpoint (b
))
1016 struct watchpoint
*w
= (struct watchpoint
*) b
;
1018 innermost_block
= NULL
;
1020 w
->cond_exp
= parse_exp_1 (&arg
, 0, 0, 0);
1022 error (_("Junk at end of expression"));
1023 w
->cond_exp_valid_block
= innermost_block
;
1027 struct bp_location
*loc
;
1029 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1033 parse_exp_1 (&arg
, loc
->address
,
1034 block_for_pc (loc
->address
), 0);
1036 error (_("Junk at end of expression"));
1040 mark_breakpoint_modified (b
);
1042 observer_notify_breakpoint_modified (b
);
1045 /* Completion for the "condition" command. */
1047 static VEC (char_ptr
) *
1048 condition_completer (struct cmd_list_element
*cmd
,
1049 const char *text
, const char *word
)
1053 text
= skip_spaces_const (text
);
1054 space
= skip_to_space_const (text
);
1058 struct breakpoint
*b
;
1059 VEC (char_ptr
) *result
= NULL
;
1063 /* We don't support completion of history indices. */
1064 if (isdigit (text
[1]))
1066 return complete_internalvar (&text
[1]);
1069 /* We're completing the breakpoint number. */
1070 len
= strlen (text
);
1076 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
1078 if (strncmp (number
, text
, len
) == 0)
1079 VEC_safe_push (char_ptr
, result
, xstrdup (number
));
1085 /* We're completing the expression part. */
1086 text
= skip_spaces_const (space
);
1087 return expression_completer (cmd
, text
, word
);
1090 /* condition N EXP -- set break condition of breakpoint N to EXP. */
1093 condition_command (char *arg
, int from_tty
)
1095 struct breakpoint
*b
;
1100 error_no_arg (_("breakpoint number"));
1103 bnum
= get_number (&p
);
1105 error (_("Bad breakpoint argument: '%s'"), arg
);
1108 if (b
->number
== bnum
)
1110 /* Check if this breakpoint has a "stop" method implemented in an
1111 extension language. This method and conditions entered into GDB
1112 from the CLI are mutually exclusive. */
1113 const struct extension_language_defn
*extlang
1114 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
1116 if (extlang
!= NULL
)
1118 error (_("Only one stop condition allowed. There is currently"
1119 " a %s stop condition defined for this breakpoint."),
1120 ext_lang_capitalized_name (extlang
));
1122 set_breakpoint_condition (b
, p
, from_tty
);
1124 if (is_breakpoint (b
))
1125 update_global_location_list (UGLL_MAY_INSERT
);
1130 error (_("No breakpoint number %d."), bnum
);
1133 /* Check that COMMAND do not contain commands that are suitable
1134 only for tracepoints and not suitable for ordinary breakpoints.
1135 Throw if any such commands is found. */
1138 check_no_tracepoint_commands (struct command_line
*commands
)
1140 struct command_line
*c
;
1142 for (c
= commands
; c
; c
= c
->next
)
1146 if (c
->control_type
== while_stepping_control
)
1147 error (_("The 'while-stepping' command can "
1148 "only be used for tracepoints"));
1150 for (i
= 0; i
< c
->body_count
; ++i
)
1151 check_no_tracepoint_commands ((c
->body_list
)[i
]);
1153 /* Not that command parsing removes leading whitespace and comment
1154 lines and also empty lines. So, we only need to check for
1155 command directly. */
1156 if (strstr (c
->line
, "collect ") == c
->line
)
1157 error (_("The 'collect' command can only be used for tracepoints"));
1159 if (strstr (c
->line
, "teval ") == c
->line
)
1160 error (_("The 'teval' command can only be used for tracepoints"));
1164 /* Encapsulate tests for different types of tracepoints. */
1167 is_tracepoint_type (enum bptype type
)
1169 return (type
== bp_tracepoint
1170 || type
== bp_fast_tracepoint
1171 || type
== bp_static_tracepoint
);
1175 is_tracepoint (const struct breakpoint
*b
)
1177 return is_tracepoint_type (b
->type
);
1180 /* A helper function that validates that COMMANDS are valid for a
1181 breakpoint. This function will throw an exception if a problem is
1185 validate_commands_for_breakpoint (struct breakpoint
*b
,
1186 struct command_line
*commands
)
1188 if (is_tracepoint (b
))
1190 struct tracepoint
*t
= (struct tracepoint
*) b
;
1191 struct command_line
*c
;
1192 struct command_line
*while_stepping
= 0;
1194 /* Reset the while-stepping step count. The previous commands
1195 might have included a while-stepping action, while the new
1199 /* We need to verify that each top-level element of commands is
1200 valid for tracepoints, that there's at most one
1201 while-stepping element, and that the while-stepping's body
1202 has valid tracing commands excluding nested while-stepping.
1203 We also need to validate the tracepoint action line in the
1204 context of the tracepoint --- validate_actionline actually
1205 has side effects, like setting the tracepoint's
1206 while-stepping STEP_COUNT, in addition to checking if the
1207 collect/teval actions parse and make sense in the
1208 tracepoint's context. */
1209 for (c
= commands
; c
; c
= c
->next
)
1211 if (c
->control_type
== while_stepping_control
)
1213 if (b
->type
== bp_fast_tracepoint
)
1214 error (_("The 'while-stepping' command "
1215 "cannot be used for fast tracepoint"));
1216 else if (b
->type
== bp_static_tracepoint
)
1217 error (_("The 'while-stepping' command "
1218 "cannot be used for static tracepoint"));
1221 error (_("The 'while-stepping' command "
1222 "can be used only once"));
1227 validate_actionline (c
->line
, b
);
1231 struct command_line
*c2
;
1233 gdb_assert (while_stepping
->body_count
== 1);
1234 c2
= while_stepping
->body_list
[0];
1235 for (; c2
; c2
= c2
->next
)
1237 if (c2
->control_type
== while_stepping_control
)
1238 error (_("The 'while-stepping' command cannot be nested"));
1244 check_no_tracepoint_commands (commands
);
1248 /* Return a vector of all the static tracepoints set at ADDR. The
1249 caller is responsible for releasing the vector. */
1252 static_tracepoints_here (CORE_ADDR addr
)
1254 struct breakpoint
*b
;
1255 VEC(breakpoint_p
) *found
= 0;
1256 struct bp_location
*loc
;
1259 if (b
->type
== bp_static_tracepoint
)
1261 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1262 if (loc
->address
== addr
)
1263 VEC_safe_push(breakpoint_p
, found
, b
);
1269 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1270 validate that only allowed commands are included. */
1273 breakpoint_set_commands (struct breakpoint
*b
,
1274 struct command_line
*commands
)
1276 validate_commands_for_breakpoint (b
, commands
);
1278 decref_counted_command_line (&b
->commands
);
1279 b
->commands
= alloc_counted_command_line (commands
);
1280 observer_notify_breakpoint_modified (b
);
1283 /* Set the internal `silent' flag on the breakpoint. Note that this
1284 is not the same as the "silent" that may appear in the breakpoint's
1288 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1290 int old_silent
= b
->silent
;
1293 if (old_silent
!= silent
)
1294 observer_notify_breakpoint_modified (b
);
1297 /* Set the thread for this breakpoint. If THREAD is -1, make the
1298 breakpoint work for any thread. */
1301 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1303 int old_thread
= b
->thread
;
1306 if (old_thread
!= thread
)
1307 observer_notify_breakpoint_modified (b
);
1310 /* Set the task for this breakpoint. If TASK is 0, make the
1311 breakpoint work for any task. */
1314 breakpoint_set_task (struct breakpoint
*b
, int task
)
1316 int old_task
= b
->task
;
1319 if (old_task
!= task
)
1320 observer_notify_breakpoint_modified (b
);
1324 check_tracepoint_command (char *line
, void *closure
)
1326 struct breakpoint
*b
= (struct breakpoint
*) closure
;
1328 validate_actionline (line
, b
);
1331 /* A structure used to pass information through
1332 map_breakpoint_numbers. */
1334 struct commands_info
1336 /* True if the command was typed at a tty. */
1339 /* The breakpoint range spec. */
1342 /* Non-NULL if the body of the commands are being read from this
1343 already-parsed command. */
1344 struct command_line
*control
;
1346 /* The command lines read from the user, or NULL if they have not
1348 struct counted_command_line
*cmd
;
1351 /* A callback for map_breakpoint_numbers that sets the commands for
1352 commands_command. */
1355 do_map_commands_command (struct breakpoint
*b
, void *data
)
1357 struct commands_info
*info
= (struct commands_info
*) data
;
1359 if (info
->cmd
== NULL
)
1361 struct command_line
*l
;
1363 if (info
->control
!= NULL
)
1364 l
= copy_command_lines (info
->control
->body_list
[0]);
1367 struct cleanup
*old_chain
;
1370 str
= xstrprintf (_("Type commands for breakpoint(s) "
1371 "%s, one per line."),
1374 old_chain
= make_cleanup (xfree
, str
);
1376 l
= read_command_lines (str
,
1379 ? check_tracepoint_command
: 0),
1382 do_cleanups (old_chain
);
1385 info
->cmd
= alloc_counted_command_line (l
);
1388 /* If a breakpoint was on the list more than once, we don't need to
1390 if (b
->commands
!= info
->cmd
)
1392 validate_commands_for_breakpoint (b
, info
->cmd
->commands
);
1393 incref_counted_command_line (info
->cmd
);
1394 decref_counted_command_line (&b
->commands
);
1395 b
->commands
= info
->cmd
;
1396 observer_notify_breakpoint_modified (b
);
1401 commands_command_1 (char *arg
, int from_tty
,
1402 struct command_line
*control
)
1404 struct cleanup
*cleanups
;
1405 struct commands_info info
;
1407 info
.from_tty
= from_tty
;
1408 info
.control
= control
;
1410 /* If we read command lines from the user, then `info' will hold an
1411 extra reference to the commands that we must clean up. */
1412 cleanups
= make_cleanup_decref_counted_command_line (&info
.cmd
);
1414 if (arg
== NULL
|| !*arg
)
1416 if (breakpoint_count
- prev_breakpoint_count
> 1)
1417 arg
= xstrprintf ("%d-%d", prev_breakpoint_count
+ 1,
1419 else if (breakpoint_count
> 0)
1420 arg
= xstrprintf ("%d", breakpoint_count
);
1423 /* So that we don't try to free the incoming non-NULL
1424 argument in the cleanup below. Mapping breakpoint
1425 numbers will fail in this case. */
1430 /* The command loop has some static state, so we need to preserve
1432 arg
= xstrdup (arg
);
1435 make_cleanup (xfree
, arg
);
1439 map_breakpoint_numbers (arg
, do_map_commands_command
, &info
);
1441 if (info
.cmd
== NULL
)
1442 error (_("No breakpoints specified."));
1444 do_cleanups (cleanups
);
1448 commands_command (char *arg
, int from_tty
)
1450 commands_command_1 (arg
, from_tty
, NULL
);
1453 /* Like commands_command, but instead of reading the commands from
1454 input stream, takes them from an already parsed command structure.
1456 This is used by cli-script.c to DTRT with breakpoint commands
1457 that are part of if and while bodies. */
1458 enum command_control_type
1459 commands_from_control_command (char *arg
, struct command_line
*cmd
)
1461 commands_command_1 (arg
, 0, cmd
);
1462 return simple_control
;
1465 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1468 bp_location_has_shadow (struct bp_location
*bl
)
1470 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1474 if (bl
->target_info
.shadow_len
== 0)
1475 /* BL isn't valid, or doesn't shadow memory. */
1480 /* Update BUF, which is LEN bytes read from the target address
1481 MEMADDR, by replacing a memory breakpoint with its shadowed
1484 If READBUF is not NULL, this buffer must not overlap with the of
1485 the breakpoint location's shadow_contents buffer. Otherwise, a
1486 failed assertion internal error will be raised. */
1489 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1490 const gdb_byte
*writebuf_org
,
1491 ULONGEST memaddr
, LONGEST len
,
1492 struct bp_target_info
*target_info
,
1493 struct gdbarch
*gdbarch
)
1495 /* Now do full processing of the found relevant range of elements. */
1496 CORE_ADDR bp_addr
= 0;
1500 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1501 current_program_space
->aspace
, 0))
1503 /* The breakpoint is inserted in a different address space. */
1507 /* Addresses and length of the part of the breakpoint that
1509 bp_addr
= target_info
->placed_address
;
1510 bp_size
= target_info
->shadow_len
;
1512 if (bp_addr
+ bp_size
<= memaddr
)
1514 /* The breakpoint is entirely before the chunk of memory we are
1519 if (bp_addr
>= memaddr
+ len
)
1521 /* The breakpoint is entirely after the chunk of memory we are
1526 /* Offset within shadow_contents. */
1527 if (bp_addr
< memaddr
)
1529 /* Only copy the second part of the breakpoint. */
1530 bp_size
-= memaddr
- bp_addr
;
1531 bptoffset
= memaddr
- bp_addr
;
1535 if (bp_addr
+ bp_size
> memaddr
+ len
)
1537 /* Only copy the first part of the breakpoint. */
1538 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1541 if (readbuf
!= NULL
)
1543 /* Verify that the readbuf buffer does not overlap with the
1544 shadow_contents buffer. */
1545 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1546 || readbuf
>= (target_info
->shadow_contents
1547 + target_info
->shadow_len
));
1549 /* Update the read buffer with this inserted breakpoint's
1551 memcpy (readbuf
+ bp_addr
- memaddr
,
1552 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1556 const unsigned char *bp
;
1557 CORE_ADDR addr
= target_info
->reqstd_address
;
1560 /* Update the shadow with what we want to write to memory. */
1561 memcpy (target_info
->shadow_contents
+ bptoffset
,
1562 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1564 /* Determine appropriate breakpoint contents and size for this
1566 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1568 /* Update the final write buffer with this inserted
1569 breakpoint's INSN. */
1570 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1574 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1575 by replacing any memory breakpoints with their shadowed contents.
1577 If READBUF is not NULL, this buffer must not overlap with any of
1578 the breakpoint location's shadow_contents buffers. Otherwise,
1579 a failed assertion internal error will be raised.
1581 The range of shadowed area by each bp_location is:
1582 bl->address - bp_location_placed_address_before_address_max
1583 up to bl->address + bp_location_shadow_len_after_address_max
1584 The range we were requested to resolve shadows for is:
1585 memaddr ... memaddr + len
1586 Thus the safe cutoff boundaries for performance optimization are
1587 memaddr + len <= (bl->address
1588 - bp_location_placed_address_before_address_max)
1590 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1593 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1594 const gdb_byte
*writebuf_org
,
1595 ULONGEST memaddr
, LONGEST len
)
1597 /* Left boundary, right boundary and median element of our binary
1599 unsigned bc_l
, bc_r
, bc
;
1601 /* Find BC_L which is a leftmost element which may affect BUF
1602 content. It is safe to report lower value but a failure to
1603 report higher one. */
1606 bc_r
= bp_location_count
;
1607 while (bc_l
+ 1 < bc_r
)
1609 struct bp_location
*bl
;
1611 bc
= (bc_l
+ bc_r
) / 2;
1612 bl
= bp_location
[bc
];
1614 /* Check first BL->ADDRESS will not overflow due to the added
1615 constant. Then advance the left boundary only if we are sure
1616 the BC element can in no way affect the BUF content (MEMADDR
1617 to MEMADDR + LEN range).
1619 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1620 offset so that we cannot miss a breakpoint with its shadow
1621 range tail still reaching MEMADDR. */
1623 if ((bl
->address
+ bp_location_shadow_len_after_address_max
1625 && (bl
->address
+ bp_location_shadow_len_after_address_max
1632 /* Due to the binary search above, we need to make sure we pick the
1633 first location that's at BC_L's address. E.g., if there are
1634 multiple locations at the same address, BC_L may end up pointing
1635 at a duplicate location, and miss the "master"/"inserted"
1636 location. Say, given locations L1, L2 and L3 at addresses A and
1639 L1@A, L2@A, L3@B, ...
1641 BC_L could end up pointing at location L2, while the "master"
1642 location could be L1. Since the `loc->inserted' flag is only set
1643 on "master" locations, we'd forget to restore the shadow of L1
1646 && bp_location
[bc_l
]->address
== bp_location
[bc_l
- 1]->address
)
1649 /* Now do full processing of the found relevant range of elements. */
1651 for (bc
= bc_l
; bc
< bp_location_count
; bc
++)
1653 struct bp_location
*bl
= bp_location
[bc
];
1655 /* bp_location array has BL->OWNER always non-NULL. */
1656 if (bl
->owner
->type
== bp_none
)
1657 warning (_("reading through apparently deleted breakpoint #%d?"),
1660 /* Performance optimization: any further element can no longer affect BUF
1663 if (bl
->address
>= bp_location_placed_address_before_address_max
1664 && memaddr
+ len
<= (bl
->address
1665 - bp_location_placed_address_before_address_max
))
1668 if (!bp_location_has_shadow (bl
))
1671 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1672 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1678 /* Return true if BPT is either a software breakpoint or a hardware
1682 is_breakpoint (const struct breakpoint
*bpt
)
1684 return (bpt
->type
== bp_breakpoint
1685 || bpt
->type
== bp_hardware_breakpoint
1686 || bpt
->type
== bp_dprintf
);
1689 /* Return true if BPT is of any hardware watchpoint kind. */
1692 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1694 return (bpt
->type
== bp_hardware_watchpoint
1695 || bpt
->type
== bp_read_watchpoint
1696 || bpt
->type
== bp_access_watchpoint
);
1699 /* Return true if BPT is of any watchpoint kind, hardware or
1703 is_watchpoint (const struct breakpoint
*bpt
)
1705 return (is_hardware_watchpoint (bpt
)
1706 || bpt
->type
== bp_watchpoint
);
1709 /* Returns true if the current thread and its running state are safe
1710 to evaluate or update watchpoint B. Watchpoints on local
1711 expressions need to be evaluated in the context of the thread that
1712 was current when the watchpoint was created, and, that thread needs
1713 to be stopped to be able to select the correct frame context.
1714 Watchpoints on global expressions can be evaluated on any thread,
1715 and in any state. It is presently left to the target allowing
1716 memory accesses when threads are running. */
1719 watchpoint_in_thread_scope (struct watchpoint
*b
)
1721 return (b
->base
.pspace
== current_program_space
1722 && (ptid_equal (b
->watchpoint_thread
, null_ptid
)
1723 || (ptid_equal (inferior_ptid
, b
->watchpoint_thread
)
1724 && !is_executing (inferior_ptid
))));
1727 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1728 associated bp_watchpoint_scope breakpoint. */
1731 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1733 struct breakpoint
*b
= &w
->base
;
1735 if (b
->related_breakpoint
!= b
)
1737 gdb_assert (b
->related_breakpoint
->type
== bp_watchpoint_scope
);
1738 gdb_assert (b
->related_breakpoint
->related_breakpoint
== b
);
1739 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1740 b
->related_breakpoint
->related_breakpoint
= b
->related_breakpoint
;
1741 b
->related_breakpoint
= b
;
1743 b
->disposition
= disp_del_at_next_stop
;
1746 /* Extract a bitfield value from value VAL using the bit parameters contained in
1749 static struct value
*
1750 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1752 struct value
*bit_val
;
1757 bit_val
= allocate_value (value_type (val
));
1759 unpack_value_bitfield (bit_val
,
1762 value_contents_for_printing (val
),
1769 /* Allocate a dummy location and add it to B, which must be a software
1770 watchpoint. This is required because even if a software watchpoint
1771 is not watching any memory, bpstat_stop_status requires a location
1772 to be able to report stops. */
1775 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1776 struct program_space
*pspace
)
1778 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1780 b
->loc
= allocate_bp_location (b
);
1781 b
->loc
->pspace
= pspace
;
1782 b
->loc
->address
= -1;
1783 b
->loc
->length
= -1;
1786 /* Returns true if B is a software watchpoint that is not watching any
1787 memory (e.g., "watch $pc"). */
1790 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1792 return (b
->type
== bp_watchpoint
1794 && b
->loc
->next
== NULL
1795 && b
->loc
->address
== -1
1796 && b
->loc
->length
== -1);
1799 /* Assuming that B is a watchpoint:
1800 - Reparse watchpoint expression, if REPARSE is non-zero
1801 - Evaluate expression and store the result in B->val
1802 - Evaluate the condition if there is one, and store the result
1804 - Update the list of values that must be watched in B->loc.
1806 If the watchpoint disposition is disp_del_at_next_stop, then do
1807 nothing. If this is local watchpoint that is out of scope, delete
1810 Even with `set breakpoint always-inserted on' the watchpoints are
1811 removed + inserted on each stop here. Normal breakpoints must
1812 never be removed because they might be missed by a running thread
1813 when debugging in non-stop mode. On the other hand, hardware
1814 watchpoints (is_hardware_watchpoint; processed here) are specific
1815 to each LWP since they are stored in each LWP's hardware debug
1816 registers. Therefore, such LWP must be stopped first in order to
1817 be able to modify its hardware watchpoints.
1819 Hardware watchpoints must be reset exactly once after being
1820 presented to the user. It cannot be done sooner, because it would
1821 reset the data used to present the watchpoint hit to the user. And
1822 it must not be done later because it could display the same single
1823 watchpoint hit during multiple GDB stops. Note that the latter is
1824 relevant only to the hardware watchpoint types bp_read_watchpoint
1825 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1826 not user-visible - its hit is suppressed if the memory content has
1829 The following constraints influence the location where we can reset
1830 hardware watchpoints:
1832 * target_stopped_by_watchpoint and target_stopped_data_address are
1833 called several times when GDB stops.
1836 * Multiple hardware watchpoints can be hit at the same time,
1837 causing GDB to stop. GDB only presents one hardware watchpoint
1838 hit at a time as the reason for stopping, and all the other hits
1839 are presented later, one after the other, each time the user
1840 requests the execution to be resumed. Execution is not resumed
1841 for the threads still having pending hit event stored in
1842 LWP_INFO->STATUS. While the watchpoint is already removed from
1843 the inferior on the first stop the thread hit event is kept being
1844 reported from its cached value by linux_nat_stopped_data_address
1845 until the real thread resume happens after the watchpoint gets
1846 presented and thus its LWP_INFO->STATUS gets reset.
1848 Therefore the hardware watchpoint hit can get safely reset on the
1849 watchpoint removal from inferior. */
1852 update_watchpoint (struct watchpoint
*b
, int reparse
)
1854 int within_current_scope
;
1855 struct frame_id saved_frame_id
;
1858 /* If this is a local watchpoint, we only want to check if the
1859 watchpoint frame is in scope if the current thread is the thread
1860 that was used to create the watchpoint. */
1861 if (!watchpoint_in_thread_scope (b
))
1864 if (b
->base
.disposition
== disp_del_at_next_stop
)
1869 /* Determine if the watchpoint is within scope. */
1870 if (b
->exp_valid_block
== NULL
)
1871 within_current_scope
= 1;
1874 struct frame_info
*fi
= get_current_frame ();
1875 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1876 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1878 /* If we're at a point where the stack has been destroyed
1879 (e.g. in a function epilogue), unwinding may not work
1880 properly. Do not attempt to recreate locations at this
1881 point. See similar comments in watchpoint_check. */
1882 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1885 /* Save the current frame's ID so we can restore it after
1886 evaluating the watchpoint expression on its own frame. */
1887 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1888 took a frame parameter, so that we didn't have to change the
1891 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1893 fi
= frame_find_by_id (b
->watchpoint_frame
);
1894 within_current_scope
= (fi
!= NULL
);
1895 if (within_current_scope
)
1899 /* We don't free locations. They are stored in the bp_location array
1900 and update_global_location_list will eventually delete them and
1901 remove breakpoints if needed. */
1904 if (within_current_scope
&& reparse
)
1913 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1914 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1915 /* If the meaning of expression itself changed, the old value is
1916 no longer relevant. We don't want to report a watchpoint hit
1917 to the user when the old value and the new value may actually
1918 be completely different objects. */
1919 value_free (b
->val
);
1923 /* Note that unlike with breakpoints, the watchpoint's condition
1924 expression is stored in the breakpoint object, not in the
1925 locations (re)created below. */
1926 if (b
->base
.cond_string
!= NULL
)
1928 if (b
->cond_exp
!= NULL
)
1930 xfree (b
->cond_exp
);
1934 s
= b
->base
.cond_string
;
1935 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1939 /* If we failed to parse the expression, for example because
1940 it refers to a global variable in a not-yet-loaded shared library,
1941 don't try to insert watchpoint. We don't automatically delete
1942 such watchpoint, though, since failure to parse expression
1943 is different from out-of-scope watchpoint. */
1944 if (!target_has_execution
)
1946 /* Without execution, memory can't change. No use to try and
1947 set watchpoint locations. The watchpoint will be reset when
1948 the target gains execution, through breakpoint_re_set. */
1949 if (!can_use_hw_watchpoints
)
1951 if (b
->base
.ops
->works_in_software_mode (&b
->base
))
1952 b
->base
.type
= bp_watchpoint
;
1954 error (_("Can't set read/access watchpoint when "
1955 "hardware watchpoints are disabled."));
1958 else if (within_current_scope
&& b
->exp
)
1961 struct value
*val_chain
, *v
, *result
, *next
;
1962 struct program_space
*frame_pspace
;
1964 fetch_subexp_value (b
->exp
, &pc
, &v
, &result
, &val_chain
, 0);
1966 /* Avoid setting b->val if it's already set. The meaning of
1967 b->val is 'the last value' user saw, and we should update
1968 it only if we reported that last value to user. As it
1969 happens, the code that reports it updates b->val directly.
1970 We don't keep track of the memory value for masked
1972 if (!b
->val_valid
&& !is_masked_watchpoint (&b
->base
))
1974 if (b
->val_bitsize
!= 0)
1976 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1984 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1986 /* Look at each value on the value chain. */
1987 for (v
= val_chain
; v
; v
= value_next (v
))
1989 /* If it's a memory location, and GDB actually needed
1990 its contents to evaluate the expression, then we
1991 must watch it. If the first value returned is
1992 still lazy, that means an error occurred reading it;
1993 watch it anyway in case it becomes readable. */
1994 if (VALUE_LVAL (v
) == lval_memory
1995 && (v
== val_chain
|| ! value_lazy (v
)))
1997 struct type
*vtype
= check_typedef (value_type (v
));
1999 /* We only watch structs and arrays if user asked
2000 for it explicitly, never if they just happen to
2001 appear in the middle of some value chain. */
2003 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
2004 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
2007 enum target_hw_bp_type type
;
2008 struct bp_location
*loc
, **tmp
;
2009 int bitpos
= 0, bitsize
= 0;
2011 if (value_bitsize (v
) != 0)
2013 /* Extract the bit parameters out from the bitfield
2015 bitpos
= value_bitpos (v
);
2016 bitsize
= value_bitsize (v
);
2018 else if (v
== result
&& b
->val_bitsize
!= 0)
2020 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
2021 lvalue whose bit parameters are saved in the fields
2022 VAL_BITPOS and VAL_BITSIZE. */
2023 bitpos
= b
->val_bitpos
;
2024 bitsize
= b
->val_bitsize
;
2027 addr
= value_address (v
);
2030 /* Skip the bytes that don't contain the bitfield. */
2035 if (b
->base
.type
== bp_read_watchpoint
)
2037 else if (b
->base
.type
== bp_access_watchpoint
)
2040 loc
= allocate_bp_location (&b
->base
);
2041 for (tmp
= &(b
->base
.loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
2044 loc
->gdbarch
= get_type_arch (value_type (v
));
2046 loc
->pspace
= frame_pspace
;
2047 loc
->address
= addr
;
2051 /* Just cover the bytes that make up the bitfield. */
2052 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
2055 loc
->length
= TYPE_LENGTH (value_type (v
));
2057 loc
->watchpoint_type
= type
;
2062 /* Change the type of breakpoint between hardware assisted or
2063 an ordinary watchpoint depending on the hardware support
2064 and free hardware slots. REPARSE is set when the inferior
2069 enum bp_loc_type loc_type
;
2070 struct bp_location
*bl
;
2072 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
2076 int i
, target_resources_ok
, other_type_used
;
2079 /* Use an exact watchpoint when there's only one memory region to be
2080 watched, and only one debug register is needed to watch it. */
2081 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
2083 /* We need to determine how many resources are already
2084 used for all other hardware watchpoints plus this one
2085 to see if we still have enough resources to also fit
2086 this watchpoint in as well. */
2088 /* If this is a software watchpoint, we try to turn it
2089 to a hardware one -- count resources as if B was of
2090 hardware watchpoint type. */
2091 type
= b
->base
.type
;
2092 if (type
== bp_watchpoint
)
2093 type
= bp_hardware_watchpoint
;
2095 /* This watchpoint may or may not have been placed on
2096 the list yet at this point (it won't be in the list
2097 if we're trying to create it for the first time,
2098 through watch_command), so always account for it
2101 /* Count resources used by all watchpoints except B. */
2102 i
= hw_watchpoint_used_count_others (&b
->base
, type
, &other_type_used
);
2104 /* Add in the resources needed for B. */
2105 i
+= hw_watchpoint_use_count (&b
->base
);
2108 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
2109 if (target_resources_ok
<= 0)
2111 int sw_mode
= b
->base
.ops
->works_in_software_mode (&b
->base
);
2113 if (target_resources_ok
== 0 && !sw_mode
)
2114 error (_("Target does not support this type of "
2115 "hardware watchpoint."));
2116 else if (target_resources_ok
< 0 && !sw_mode
)
2117 error (_("There are not enough available hardware "
2118 "resources for this watchpoint."));
2120 /* Downgrade to software watchpoint. */
2121 b
->base
.type
= bp_watchpoint
;
2125 /* If this was a software watchpoint, we've just
2126 found we have enough resources to turn it to a
2127 hardware watchpoint. Otherwise, this is a
2129 b
->base
.type
= type
;
2132 else if (!b
->base
.ops
->works_in_software_mode (&b
->base
))
2134 if (!can_use_hw_watchpoints
)
2135 error (_("Can't set read/access watchpoint when "
2136 "hardware watchpoints are disabled."));
2138 error (_("Expression cannot be implemented with "
2139 "read/access watchpoint."));
2142 b
->base
.type
= bp_watchpoint
;
2144 loc_type
= (b
->base
.type
== bp_watchpoint
? bp_loc_other
2145 : bp_loc_hardware_watchpoint
);
2146 for (bl
= b
->base
.loc
; bl
; bl
= bl
->next
)
2147 bl
->loc_type
= loc_type
;
2150 for (v
= val_chain
; v
; v
= next
)
2152 next
= value_next (v
);
2157 /* If a software watchpoint is not watching any memory, then the
2158 above left it without any location set up. But,
2159 bpstat_stop_status requires a location to be able to report
2160 stops, so make sure there's at least a dummy one. */
2161 if (b
->base
.type
== bp_watchpoint
&& b
->base
.loc
== NULL
)
2162 software_watchpoint_add_no_memory_location (&b
->base
, frame_pspace
);
2164 else if (!within_current_scope
)
2166 printf_filtered (_("\
2167 Watchpoint %d deleted because the program has left the block\n\
2168 in which its expression is valid.\n"),
2170 watchpoint_del_at_next_stop (b
);
2173 /* Restore the selected frame. */
2175 select_frame (frame_find_by_id (saved_frame_id
));
2179 /* Returns 1 iff breakpoint location should be
2180 inserted in the inferior. We don't differentiate the type of BL's owner
2181 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2182 breakpoint_ops is not defined, because in insert_bp_location,
2183 tracepoint's insert_location will not be called. */
2185 should_be_inserted (struct bp_location
*bl
)
2187 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2190 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2193 if (!bl
->enabled
|| bl
->shlib_disabled
|| bl
->duplicate
)
2196 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2199 /* This is set for example, when we're attached to the parent of a
2200 vfork, and have detached from the child. The child is running
2201 free, and we expect it to do an exec or exit, at which point the
2202 OS makes the parent schedulable again (and the target reports
2203 that the vfork is done). Until the child is done with the shared
2204 memory region, do not insert breakpoints in the parent, otherwise
2205 the child could still trip on the parent's breakpoints. Since
2206 the parent is blocked anyway, it won't miss any breakpoint. */
2207 if (bl
->pspace
->breakpoints_not_allowed
)
2210 /* Don't insert a breakpoint if we're trying to step past its
2211 location, except if the breakpoint is a single-step breakpoint,
2212 and the breakpoint's thread is the thread which is stepping past
2214 if ((bl
->loc_type
== bp_loc_software_breakpoint
2215 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2216 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2218 /* The single-step breakpoint may be inserted at the location
2219 we're trying to step if the instruction branches to itself.
2220 However, the instruction won't be executed at all and it may
2221 break the semantics of the instruction, for example, the
2222 instruction is a conditional branch or updates some flags.
2223 We can't fix it unless GDB is able to emulate the instruction
2224 or switch to displaced stepping. */
2225 && !(bl
->owner
->type
== bp_single_step
2226 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2230 fprintf_unfiltered (gdb_stdlog
,
2231 "infrun: skipping breakpoint: "
2232 "stepping past insn at: %s\n",
2233 paddress (bl
->gdbarch
, bl
->address
));
2238 /* Don't insert watchpoints if we're trying to step past the
2239 instruction that triggered one. */
2240 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2241 && stepping_past_nonsteppable_watchpoint ())
2245 fprintf_unfiltered (gdb_stdlog
,
2246 "infrun: stepping past non-steppable watchpoint. "
2247 "skipping watchpoint at %s:%d\n",
2248 paddress (bl
->gdbarch
, bl
->address
),
2257 /* Same as should_be_inserted but does the check assuming
2258 that the location is not duplicated. */
2261 unduplicated_should_be_inserted (struct bp_location
*bl
)
2264 const int save_duplicate
= bl
->duplicate
;
2267 result
= should_be_inserted (bl
);
2268 bl
->duplicate
= save_duplicate
;
2272 /* Parses a conditional described by an expression COND into an
2273 agent expression bytecode suitable for evaluation
2274 by the bytecode interpreter. Return NULL if there was
2275 any error during parsing. */
2277 static struct agent_expr
*
2278 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2280 struct agent_expr
*aexpr
= NULL
;
2285 /* We don't want to stop processing, so catch any errors
2286 that may show up. */
2289 aexpr
= gen_eval_for_expr (scope
, cond
);
2292 CATCH (ex
, RETURN_MASK_ERROR
)
2294 /* If we got here, it means the condition could not be parsed to a valid
2295 bytecode expression and thus can't be evaluated on the target's side.
2296 It's no use iterating through the conditions. */
2301 /* We have a valid agent expression. */
2305 /* Based on location BL, create a list of breakpoint conditions to be
2306 passed on to the target. If we have duplicated locations with different
2307 conditions, we will add such conditions to the list. The idea is that the
2308 target will evaluate the list of conditions and will only notify GDB when
2309 one of them is true. */
2312 build_target_condition_list (struct bp_location
*bl
)
2314 struct bp_location
**locp
= NULL
, **loc2p
;
2315 int null_condition_or_parse_error
= 0;
2316 int modified
= bl
->needs_update
;
2317 struct bp_location
*loc
;
2319 /* Release conditions left over from a previous insert. */
2320 VEC_free (agent_expr_p
, bl
->target_info
.conditions
);
2322 /* This is only meaningful if the target is
2323 evaluating conditions and if the user has
2324 opted for condition evaluation on the target's
2326 if (gdb_evaluates_breakpoint_condition_p ()
2327 || !target_supports_evaluation_of_breakpoint_conditions ())
2330 /* Do a first pass to check for locations with no assigned
2331 conditions or conditions that fail to parse to a valid agent expression
2332 bytecode. If any of these happen, then it's no use to send conditions
2333 to the target since this location will always trigger and generate a
2334 response back to GDB. */
2335 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2338 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2342 struct agent_expr
*aexpr
;
2344 /* Re-parse the conditions since something changed. In that
2345 case we already freed the condition bytecodes (see
2346 force_breakpoint_reinsertion). We just
2347 need to parse the condition to bytecodes again. */
2348 aexpr
= parse_cond_to_aexpr (bl
->address
, loc
->cond
);
2349 loc
->cond_bytecode
= aexpr
;
2352 /* If we have a NULL bytecode expression, it means something
2353 went wrong or we have a null condition expression. */
2354 if (!loc
->cond_bytecode
)
2356 null_condition_or_parse_error
= 1;
2362 /* If any of these happened, it means we will have to evaluate the conditions
2363 for the location's address on gdb's side. It is no use keeping bytecodes
2364 for all the other duplicate locations, thus we free all of them here.
2366 This is so we have a finer control over which locations' conditions are
2367 being evaluated by GDB or the remote stub. */
2368 if (null_condition_or_parse_error
)
2370 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2373 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2375 /* Only go as far as the first NULL bytecode is
2377 if (!loc
->cond_bytecode
)
2380 free_agent_expr (loc
->cond_bytecode
);
2381 loc
->cond_bytecode
= NULL
;
2386 /* No NULL conditions or failed bytecode generation. Build a condition list
2387 for this location's address. */
2388 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2392 && is_breakpoint (loc
->owner
)
2393 && loc
->pspace
->num
== bl
->pspace
->num
2394 && loc
->owner
->enable_state
== bp_enabled
2396 /* Add the condition to the vector. This will be used later to send the
2397 conditions to the target. */
2398 VEC_safe_push (agent_expr_p
, bl
->target_info
.conditions
,
2399 loc
->cond_bytecode
);
2405 /* Parses a command described by string CMD into an agent expression
2406 bytecode suitable for evaluation by the bytecode interpreter.
2407 Return NULL if there was any error during parsing. */
2409 static struct agent_expr
*
2410 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2412 struct cleanup
*old_cleanups
= 0;
2413 struct expression
*expr
, **argvec
;
2414 struct agent_expr
*aexpr
= NULL
;
2415 const char *cmdrest
;
2416 const char *format_start
, *format_end
;
2417 struct format_piece
*fpieces
;
2419 struct gdbarch
*gdbarch
= get_current_arch ();
2426 if (*cmdrest
== ',')
2428 cmdrest
= skip_spaces_const (cmdrest
);
2430 if (*cmdrest
++ != '"')
2431 error (_("No format string following the location"));
2433 format_start
= cmdrest
;
2435 fpieces
= parse_format_string (&cmdrest
);
2437 old_cleanups
= make_cleanup (free_format_pieces_cleanup
, &fpieces
);
2439 format_end
= cmdrest
;
2441 if (*cmdrest
++ != '"')
2442 error (_("Bad format string, non-terminated '\"'."));
2444 cmdrest
= skip_spaces_const (cmdrest
);
2446 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2447 error (_("Invalid argument syntax"));
2449 if (*cmdrest
== ',')
2451 cmdrest
= skip_spaces_const (cmdrest
);
2453 /* For each argument, make an expression. */
2455 argvec
= (struct expression
**) alloca (strlen (cmd
)
2456 * sizeof (struct expression
*));
2459 while (*cmdrest
!= '\0')
2464 expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2465 argvec
[nargs
++] = expr
;
2467 if (*cmdrest
== ',')
2471 /* We don't want to stop processing, so catch any errors
2472 that may show up. */
2475 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2476 format_start
, format_end
- format_start
,
2477 fpieces
, nargs
, argvec
);
2479 CATCH (ex
, RETURN_MASK_ERROR
)
2481 /* If we got here, it means the command could not be parsed to a valid
2482 bytecode expression and thus can't be evaluated on the target's side.
2483 It's no use iterating through the other commands. */
2488 do_cleanups (old_cleanups
);
2490 /* We have a valid agent expression, return it. */
2494 /* Based on location BL, create a list of breakpoint commands to be
2495 passed on to the target. If we have duplicated locations with
2496 different commands, we will add any such to the list. */
2499 build_target_command_list (struct bp_location
*bl
)
2501 struct bp_location
**locp
= NULL
, **loc2p
;
2502 int null_command_or_parse_error
= 0;
2503 int modified
= bl
->needs_update
;
2504 struct bp_location
*loc
;
2506 /* Release commands left over from a previous insert. */
2507 VEC_free (agent_expr_p
, bl
->target_info
.tcommands
);
2509 if (!target_can_run_breakpoint_commands ())
2512 /* For now, limit to agent-style dprintf breakpoints. */
2513 if (dprintf_style
!= dprintf_style_agent
)
2516 /* For now, if we have any duplicate location that isn't a dprintf,
2517 don't install the target-side commands, as that would make the
2518 breakpoint not be reported to the core, and we'd lose
2520 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2523 if (is_breakpoint (loc
->owner
)
2524 && loc
->pspace
->num
== bl
->pspace
->num
2525 && loc
->owner
->type
!= bp_dprintf
)
2529 /* Do a first pass to check for locations with no assigned
2530 conditions or conditions that fail to parse to a valid agent expression
2531 bytecode. If any of these happen, then it's no use to send conditions
2532 to the target since this location will always trigger and generate a
2533 response back to GDB. */
2534 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2537 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2541 struct agent_expr
*aexpr
;
2543 /* Re-parse the commands since something changed. In that
2544 case we already freed the command bytecodes (see
2545 force_breakpoint_reinsertion). We just
2546 need to parse the command to bytecodes again. */
2547 aexpr
= parse_cmd_to_aexpr (bl
->address
,
2548 loc
->owner
->extra_string
);
2549 loc
->cmd_bytecode
= aexpr
;
2552 /* If we have a NULL bytecode expression, it means something
2553 went wrong or we have a null command expression. */
2554 if (!loc
->cmd_bytecode
)
2556 null_command_or_parse_error
= 1;
2562 /* If anything failed, then we're not doing target-side commands,
2564 if (null_command_or_parse_error
)
2566 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2569 if (is_breakpoint (loc
->owner
)
2570 && loc
->pspace
->num
== bl
->pspace
->num
)
2572 /* Only go as far as the first NULL bytecode is
2574 if (loc
->cmd_bytecode
== NULL
)
2577 free_agent_expr (loc
->cmd_bytecode
);
2578 loc
->cmd_bytecode
= NULL
;
2583 /* No NULL commands or failed bytecode generation. Build a command list
2584 for this location's address. */
2585 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, bl
->address
)
2588 if (loc
->owner
->extra_string
2589 && is_breakpoint (loc
->owner
)
2590 && loc
->pspace
->num
== bl
->pspace
->num
2591 && loc
->owner
->enable_state
== bp_enabled
2593 /* Add the command to the vector. This will be used later
2594 to send the commands to the target. */
2595 VEC_safe_push (agent_expr_p
, bl
->target_info
.tcommands
,
2599 bl
->target_info
.persist
= 0;
2600 /* Maybe flag this location as persistent. */
2601 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2602 bl
->target_info
.persist
= 1;
2605 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2606 location. Any error messages are printed to TMP_ERROR_STREAM; and
2607 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2608 Returns 0 for success, 1 if the bp_location type is not supported or
2611 NOTE drow/2003-09-09: This routine could be broken down to an
2612 object-style method for each breakpoint or catchpoint type. */
2614 insert_bp_location (struct bp_location
*bl
,
2615 struct ui_file
*tmp_error_stream
,
2616 int *disabled_breaks
,
2617 int *hw_breakpoint_error
,
2618 int *hw_bp_error_explained_already
)
2620 enum errors bp_err
= GDB_NO_ERROR
;
2621 const char *bp_err_message
= NULL
;
2623 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2626 /* Note we don't initialize bl->target_info, as that wipes out
2627 the breakpoint location's shadow_contents if the breakpoint
2628 is still inserted at that location. This in turn breaks
2629 target_read_memory which depends on these buffers when
2630 a memory read is requested at the breakpoint location:
2631 Once the target_info has been wiped, we fail to see that
2632 we have a breakpoint inserted at that address and thus
2633 read the breakpoint instead of returning the data saved in
2634 the breakpoint location's shadow contents. */
2635 bl
->target_info
.reqstd_address
= bl
->address
;
2636 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2637 bl
->target_info
.length
= bl
->length
;
2639 /* When working with target-side conditions, we must pass all the conditions
2640 for the same breakpoint address down to the target since GDB will not
2641 insert those locations. With a list of breakpoint conditions, the target
2642 can decide when to stop and notify GDB. */
2644 if (is_breakpoint (bl
->owner
))
2646 build_target_condition_list (bl
);
2647 build_target_command_list (bl
);
2648 /* Reset the modification marker. */
2649 bl
->needs_update
= 0;
2652 if (bl
->loc_type
== bp_loc_software_breakpoint
2653 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2655 if (bl
->owner
->type
!= bp_hardware_breakpoint
)
2657 /* If the explicitly specified breakpoint type
2658 is not hardware breakpoint, check the memory map to see
2659 if the breakpoint address is in read only memory or not.
2661 Two important cases are:
2662 - location type is not hardware breakpoint, memory
2663 is readonly. We change the type of the location to
2664 hardware breakpoint.
2665 - location type is hardware breakpoint, memory is
2666 read-write. This means we've previously made the
2667 location hardware one, but then the memory map changed,
2670 When breakpoints are removed, remove_breakpoints will use
2671 location types we've just set here, the only possible
2672 problem is that memory map has changed during running
2673 program, but it's not going to work anyway with current
2675 struct mem_region
*mr
2676 = lookup_mem_region (bl
->target_info
.reqstd_address
);
2680 if (automatic_hardware_breakpoints
)
2682 enum bp_loc_type new_type
;
2684 if (mr
->attrib
.mode
!= MEM_RW
)
2685 new_type
= bp_loc_hardware_breakpoint
;
2687 new_type
= bp_loc_software_breakpoint
;
2689 if (new_type
!= bl
->loc_type
)
2691 static int said
= 0;
2693 bl
->loc_type
= new_type
;
2696 fprintf_filtered (gdb_stdout
,
2697 _("Note: automatically using "
2698 "hardware breakpoints for "
2699 "read-only addresses.\n"));
2704 else if (bl
->loc_type
== bp_loc_software_breakpoint
2705 && mr
->attrib
.mode
!= MEM_RW
)
2707 fprintf_unfiltered (tmp_error_stream
,
2708 _("Cannot insert breakpoint %d.\n"
2709 "Cannot set software breakpoint "
2710 "at read-only address %s\n"),
2712 paddress (bl
->gdbarch
, bl
->address
));
2718 /* First check to see if we have to handle an overlay. */
2719 if (overlay_debugging
== ovly_off
2720 || bl
->section
== NULL
2721 || !(section_is_overlay (bl
->section
)))
2723 /* No overlay handling: just set the breakpoint. */
2728 val
= bl
->owner
->ops
->insert_location (bl
);
2730 bp_err
= GENERIC_ERROR
;
2732 CATCH (e
, RETURN_MASK_ALL
)
2735 bp_err_message
= e
.message
;
2741 /* This breakpoint is in an overlay section.
2742 Shall we set a breakpoint at the LMA? */
2743 if (!overlay_events_enabled
)
2745 /* Yes -- overlay event support is not active,
2746 so we must try to set a breakpoint at the LMA.
2747 This will not work for a hardware breakpoint. */
2748 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2749 warning (_("hardware breakpoint %d not supported in overlay!"),
2753 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2755 /* Set a software (trap) breakpoint at the LMA. */
2756 bl
->overlay_target_info
= bl
->target_info
;
2757 bl
->overlay_target_info
.reqstd_address
= addr
;
2759 /* No overlay handling: just set the breakpoint. */
2764 val
= target_insert_breakpoint (bl
->gdbarch
,
2765 &bl
->overlay_target_info
);
2767 bp_err
= GENERIC_ERROR
;
2769 CATCH (e
, RETURN_MASK_ALL
)
2772 bp_err_message
= e
.message
;
2776 if (bp_err
!= GDB_NO_ERROR
)
2777 fprintf_unfiltered (tmp_error_stream
,
2778 "Overlay breakpoint %d "
2779 "failed: in ROM?\n",
2783 /* Shall we set a breakpoint at the VMA? */
2784 if (section_is_mapped (bl
->section
))
2786 /* Yes. This overlay section is mapped into memory. */
2791 val
= bl
->owner
->ops
->insert_location (bl
);
2793 bp_err
= GENERIC_ERROR
;
2795 CATCH (e
, RETURN_MASK_ALL
)
2798 bp_err_message
= e
.message
;
2804 /* No. This breakpoint will not be inserted.
2805 No error, but do not mark the bp as 'inserted'. */
2810 if (bp_err
!= GDB_NO_ERROR
)
2812 /* Can't set the breakpoint. */
2814 /* In some cases, we might not be able to insert a
2815 breakpoint in a shared library that has already been
2816 removed, but we have not yet processed the shlib unload
2817 event. Unfortunately, some targets that implement
2818 breakpoint insertion themselves can't tell why the
2819 breakpoint insertion failed (e.g., the remote target
2820 doesn't define error codes), so we must treat generic
2821 errors as memory errors. */
2822 if ((bp_err
== GENERIC_ERROR
|| bp_err
== MEMORY_ERROR
)
2823 && bl
->loc_type
== bp_loc_software_breakpoint
2824 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2825 || shared_objfile_contains_address_p (bl
->pspace
,
2828 /* See also: disable_breakpoints_in_shlibs. */
2829 bl
->shlib_disabled
= 1;
2830 observer_notify_breakpoint_modified (bl
->owner
);
2831 if (!*disabled_breaks
)
2833 fprintf_unfiltered (tmp_error_stream
,
2834 "Cannot insert breakpoint %d.\n",
2836 fprintf_unfiltered (tmp_error_stream
,
2837 "Temporarily disabling shared "
2838 "library breakpoints:\n");
2840 *disabled_breaks
= 1;
2841 fprintf_unfiltered (tmp_error_stream
,
2842 "breakpoint #%d\n", bl
->owner
->number
);
2847 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2849 *hw_breakpoint_error
= 1;
2850 *hw_bp_error_explained_already
= bp_err_message
!= NULL
;
2851 fprintf_unfiltered (tmp_error_stream
,
2852 "Cannot insert hardware breakpoint %d%s",
2853 bl
->owner
->number
, bp_err_message
? ":" : ".\n");
2854 if (bp_err_message
!= NULL
)
2855 fprintf_unfiltered (tmp_error_stream
, "%s.\n", bp_err_message
);
2859 if (bp_err_message
== NULL
)
2862 = memory_error_message (TARGET_XFER_E_IO
,
2863 bl
->gdbarch
, bl
->address
);
2864 struct cleanup
*old_chain
= make_cleanup (xfree
, message
);
2866 fprintf_unfiltered (tmp_error_stream
,
2867 "Cannot insert breakpoint %d.\n"
2869 bl
->owner
->number
, message
);
2870 do_cleanups (old_chain
);
2874 fprintf_unfiltered (tmp_error_stream
,
2875 "Cannot insert breakpoint %d: %s\n",
2890 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2891 /* NOTE drow/2003-09-08: This state only exists for removing
2892 watchpoints. It's not clear that it's necessary... */
2893 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2897 gdb_assert (bl
->owner
->ops
!= NULL
2898 && bl
->owner
->ops
->insert_location
!= NULL
);
2900 val
= bl
->owner
->ops
->insert_location (bl
);
2902 /* If trying to set a read-watchpoint, and it turns out it's not
2903 supported, try emulating one with an access watchpoint. */
2904 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2906 struct bp_location
*loc
, **loc_temp
;
2908 /* But don't try to insert it, if there's already another
2909 hw_access location that would be considered a duplicate
2911 ALL_BP_LOCATIONS (loc
, loc_temp
)
2913 && loc
->watchpoint_type
== hw_access
2914 && watchpoint_locations_match (bl
, loc
))
2918 bl
->target_info
= loc
->target_info
;
2919 bl
->watchpoint_type
= hw_access
;
2926 bl
->watchpoint_type
= hw_access
;
2927 val
= bl
->owner
->ops
->insert_location (bl
);
2930 /* Back to the original value. */
2931 bl
->watchpoint_type
= hw_read
;
2935 bl
->inserted
= (val
== 0);
2938 else if (bl
->owner
->type
== bp_catchpoint
)
2942 gdb_assert (bl
->owner
->ops
!= NULL
2943 && bl
->owner
->ops
->insert_location
!= NULL
);
2945 val
= bl
->owner
->ops
->insert_location (bl
);
2948 bl
->owner
->enable_state
= bp_disabled
;
2952 Error inserting catchpoint %d: Your system does not support this type\n\
2953 of catchpoint."), bl
->owner
->number
);
2955 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2958 bl
->inserted
= (val
== 0);
2960 /* We've already printed an error message if there was a problem
2961 inserting this catchpoint, and we've disabled the catchpoint,
2962 so just return success. */
2969 /* This function is called when program space PSPACE is about to be
2970 deleted. It takes care of updating breakpoints to not reference
2974 breakpoint_program_space_exit (struct program_space
*pspace
)
2976 struct breakpoint
*b
, *b_temp
;
2977 struct bp_location
*loc
, **loc_temp
;
2979 /* Remove any breakpoint that was set through this program space. */
2980 ALL_BREAKPOINTS_SAFE (b
, b_temp
)
2982 if (b
->pspace
== pspace
)
2983 delete_breakpoint (b
);
2986 /* Breakpoints set through other program spaces could have locations
2987 bound to PSPACE as well. Remove those. */
2988 ALL_BP_LOCATIONS (loc
, loc_temp
)
2990 struct bp_location
*tmp
;
2992 if (loc
->pspace
== pspace
)
2994 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2995 if (loc
->owner
->loc
== loc
)
2996 loc
->owner
->loc
= loc
->next
;
2998 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2999 if (tmp
->next
== loc
)
3001 tmp
->next
= loc
->next
;
3007 /* Now update the global location list to permanently delete the
3008 removed locations above. */
3009 update_global_location_list (UGLL_DONT_INSERT
);
3012 /* Make sure all breakpoints are inserted in inferior.
3013 Throws exception on any error.
3014 A breakpoint that is already inserted won't be inserted
3015 again, so calling this function twice is safe. */
3017 insert_breakpoints (void)
3019 struct breakpoint
*bpt
;
3021 ALL_BREAKPOINTS (bpt
)
3022 if (is_hardware_watchpoint (bpt
))
3024 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
3026 update_watchpoint (w
, 0 /* don't reparse. */);
3029 /* Updating watchpoints creates new locations, so update the global
3030 location list. Explicitly tell ugll to insert locations and
3031 ignore breakpoints_always_inserted_mode. */
3032 update_global_location_list (UGLL_INSERT
);
3035 /* Invoke CALLBACK for each of bp_location. */
3038 iterate_over_bp_locations (walk_bp_location_callback callback
)
3040 struct bp_location
*loc
, **loc_tmp
;
3042 ALL_BP_LOCATIONS (loc
, loc_tmp
)
3044 callback (loc
, NULL
);
3048 /* This is used when we need to synch breakpoint conditions between GDB and the
3049 target. It is the case with deleting and disabling of breakpoints when using
3050 always-inserted mode. */
3053 update_inserted_breakpoint_locations (void)
3055 struct bp_location
*bl
, **blp_tmp
;
3058 int disabled_breaks
= 0;
3059 int hw_breakpoint_error
= 0;
3060 int hw_bp_details_reported
= 0;
3062 struct ui_file
*tmp_error_stream
= mem_fileopen ();
3063 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
3065 /* Explicitly mark the warning -- this will only be printed if
3066 there was an error. */
3067 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
3069 save_current_space_and_thread ();
3071 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3073 /* We only want to update software breakpoints and hardware
3075 if (!is_breakpoint (bl
->owner
))
3078 /* We only want to update locations that are already inserted
3079 and need updating. This is to avoid unwanted insertion during
3080 deletion of breakpoints. */
3081 if (!bl
->inserted
|| (bl
->inserted
&& !bl
->needs_update
))
3084 switch_to_program_space_and_thread (bl
->pspace
);
3086 /* For targets that support global breakpoints, there's no need
3087 to select an inferior to insert breakpoint to. In fact, even
3088 if we aren't attached to any process yet, we should still
3089 insert breakpoints. */
3090 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3091 && ptid_equal (inferior_ptid
, null_ptid
))
3094 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
3095 &hw_breakpoint_error
, &hw_bp_details_reported
);
3102 target_terminal_ours_for_output ();
3103 error_stream (tmp_error_stream
);
3106 do_cleanups (cleanups
);
3109 /* Used when starting or continuing the program. */
3112 insert_breakpoint_locations (void)
3114 struct breakpoint
*bpt
;
3115 struct bp_location
*bl
, **blp_tmp
;
3118 int disabled_breaks
= 0;
3119 int hw_breakpoint_error
= 0;
3120 int hw_bp_error_explained_already
= 0;
3122 struct ui_file
*tmp_error_stream
= mem_fileopen ();
3123 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_error_stream
);
3125 /* Explicitly mark the warning -- this will only be printed if
3126 there was an error. */
3127 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
3129 save_current_space_and_thread ();
3131 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3133 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3136 /* There is no point inserting thread-specific breakpoints if
3137 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3138 has BL->OWNER always non-NULL. */
3139 if (bl
->owner
->thread
!= -1
3140 && !valid_global_thread_id (bl
->owner
->thread
))
3143 switch_to_program_space_and_thread (bl
->pspace
);
3145 /* For targets that support global breakpoints, there's no need
3146 to select an inferior to insert breakpoint to. In fact, even
3147 if we aren't attached to any process yet, we should still
3148 insert breakpoints. */
3149 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3150 && ptid_equal (inferior_ptid
, null_ptid
))
3153 val
= insert_bp_location (bl
, tmp_error_stream
, &disabled_breaks
,
3154 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3159 /* If we failed to insert all locations of a watchpoint, remove
3160 them, as half-inserted watchpoint is of limited use. */
3161 ALL_BREAKPOINTS (bpt
)
3163 int some_failed
= 0;
3164 struct bp_location
*loc
;
3166 if (!is_hardware_watchpoint (bpt
))
3169 if (!breakpoint_enabled (bpt
))
3172 if (bpt
->disposition
== disp_del_at_next_stop
)
3175 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3176 if (!loc
->inserted
&& should_be_inserted (loc
))
3183 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
3185 remove_breakpoint (loc
);
3187 hw_breakpoint_error
= 1;
3188 fprintf_unfiltered (tmp_error_stream
,
3189 "Could not insert hardware watchpoint %d.\n",
3197 /* If a hardware breakpoint or watchpoint was inserted, add a
3198 message about possibly exhausted resources. */
3199 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3201 fprintf_unfiltered (tmp_error_stream
,
3202 "Could not insert hardware breakpoints:\n\
3203 You may have requested too many hardware breakpoints/watchpoints.\n");
3205 target_terminal_ours_for_output ();
3206 error_stream (tmp_error_stream
);
3209 do_cleanups (cleanups
);
3212 /* Used when the program stops.
3213 Returns zero if successful, or non-zero if there was a problem
3214 removing a breakpoint location. */
3217 remove_breakpoints (void)
3219 struct bp_location
*bl
, **blp_tmp
;
3222 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3224 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3225 val
|= remove_breakpoint (bl
);
3230 /* When a thread exits, remove breakpoints that are related to
3234 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3236 struct breakpoint
*b
, *b_tmp
;
3238 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3240 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3242 b
->disposition
= disp_del_at_next_stop
;
3244 printf_filtered (_("\
3245 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3246 b
->number
, print_thread_id (tp
));
3248 /* Hide it from the user. */
3254 /* Remove breakpoints of process PID. */
3257 remove_breakpoints_pid (int pid
)
3259 struct bp_location
*bl
, **blp_tmp
;
3261 struct inferior
*inf
= find_inferior_pid (pid
);
3263 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3265 if (bl
->pspace
!= inf
->pspace
)
3268 if (bl
->inserted
&& !bl
->target_info
.persist
)
3270 val
= remove_breakpoint (bl
);
3279 reattach_breakpoints (int pid
)
3281 struct cleanup
*old_chain
;
3282 struct bp_location
*bl
, **blp_tmp
;
3284 struct ui_file
*tmp_error_stream
;
3285 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
3286 struct inferior
*inf
;
3287 struct thread_info
*tp
;
3289 tp
= any_live_thread_of_process (pid
);
3293 inf
= find_inferior_pid (pid
);
3294 old_chain
= save_inferior_ptid ();
3296 inferior_ptid
= tp
->ptid
;
3298 tmp_error_stream
= mem_fileopen ();
3299 make_cleanup_ui_file_delete (tmp_error_stream
);
3301 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3303 if (bl
->pspace
!= inf
->pspace
)
3309 val
= insert_bp_location (bl
, tmp_error_stream
, &dummy1
, &dummy2
, &dummy3
);
3312 do_cleanups (old_chain
);
3317 do_cleanups (old_chain
);
3321 static int internal_breakpoint_number
= -1;
3323 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3324 If INTERNAL is non-zero, the breakpoint number will be populated
3325 from internal_breakpoint_number and that variable decremented.
3326 Otherwise the breakpoint number will be populated from
3327 breakpoint_count and that value incremented. Internal breakpoints
3328 do not set the internal var bpnum. */
3330 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3333 b
->number
= internal_breakpoint_number
--;
3336 set_breakpoint_count (breakpoint_count
+ 1);
3337 b
->number
= breakpoint_count
;
3341 static struct breakpoint
*
3342 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3343 CORE_ADDR address
, enum bptype type
,
3344 const struct breakpoint_ops
*ops
)
3346 struct symtab_and_line sal
;
3347 struct breakpoint
*b
;
3349 init_sal (&sal
); /* Initialize to zeroes. */
3352 sal
.section
= find_pc_overlay (sal
.pc
);
3353 sal
.pspace
= current_program_space
;
3355 b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3356 b
->number
= internal_breakpoint_number
--;
3357 b
->disposition
= disp_donttouch
;
3362 static const char *const longjmp_names
[] =
3364 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3366 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3368 /* Per-objfile data private to breakpoint.c. */
3369 struct breakpoint_objfile_data
3371 /* Minimal symbol for "_ovly_debug_event" (if any). */
3372 struct bound_minimal_symbol overlay_msym
;
3374 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3375 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
];
3377 /* True if we have looked for longjmp probes. */
3378 int longjmp_searched
;
3380 /* SystemTap probe points for longjmp (if any). */
3381 VEC (probe_p
) *longjmp_probes
;
3383 /* Minimal symbol for "std::terminate()" (if any). */
3384 struct bound_minimal_symbol terminate_msym
;
3386 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3387 struct bound_minimal_symbol exception_msym
;
3389 /* True if we have looked for exception probes. */
3390 int exception_searched
;
3392 /* SystemTap probe points for unwinding (if any). */
3393 VEC (probe_p
) *exception_probes
;
3396 static const struct objfile_data
*breakpoint_objfile_key
;
3398 /* Minimal symbol not found sentinel. */
3399 static struct minimal_symbol msym_not_found
;
3401 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3404 msym_not_found_p (const struct minimal_symbol
*msym
)
3406 return msym
== &msym_not_found
;
3409 /* Return per-objfile data needed by breakpoint.c.
3410 Allocate the data if necessary. */
3412 static struct breakpoint_objfile_data
*
3413 get_breakpoint_objfile_data (struct objfile
*objfile
)
3415 struct breakpoint_objfile_data
*bp_objfile_data
;
3417 bp_objfile_data
= ((struct breakpoint_objfile_data
*)
3418 objfile_data (objfile
, breakpoint_objfile_key
));
3419 if (bp_objfile_data
== NULL
)
3422 XOBNEW (&objfile
->objfile_obstack
, struct breakpoint_objfile_data
);
3424 memset (bp_objfile_data
, 0, sizeof (*bp_objfile_data
));
3425 set_objfile_data (objfile
, breakpoint_objfile_key
, bp_objfile_data
);
3427 return bp_objfile_data
;
3431 free_breakpoint_probes (struct objfile
*obj
, void *data
)
3433 struct breakpoint_objfile_data
*bp_objfile_data
3434 = (struct breakpoint_objfile_data
*) data
;
3436 VEC_free (probe_p
, bp_objfile_data
->longjmp_probes
);
3437 VEC_free (probe_p
, bp_objfile_data
->exception_probes
);
3441 create_overlay_event_breakpoint (void)
3443 struct objfile
*objfile
;
3444 const char *const func_name
= "_ovly_debug_event";
3446 ALL_OBJFILES (objfile
)
3448 struct breakpoint
*b
;
3449 struct breakpoint_objfile_data
*bp_objfile_data
;
3451 struct explicit_location explicit_loc
;
3453 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3455 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3458 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3460 struct bound_minimal_symbol m
;
3462 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3463 if (m
.minsym
== NULL
)
3465 /* Avoid future lookups in this objfile. */
3466 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3469 bp_objfile_data
->overlay_msym
= m
;
3472 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3473 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3475 &internal_breakpoint_ops
);
3476 initialize_explicit_location (&explicit_loc
);
3477 explicit_loc
.function_name
= ASTRDUP (func_name
);
3478 b
->location
= new_explicit_location (&explicit_loc
);
3480 if (overlay_debugging
== ovly_auto
)
3482 b
->enable_state
= bp_enabled
;
3483 overlay_events_enabled
= 1;
3487 b
->enable_state
= bp_disabled
;
3488 overlay_events_enabled
= 0;
3494 create_longjmp_master_breakpoint (void)
3496 struct program_space
*pspace
;
3497 struct cleanup
*old_chain
;
3499 old_chain
= save_current_program_space ();
3501 ALL_PSPACES (pspace
)
3503 struct objfile
*objfile
;
3505 set_current_program_space (pspace
);
3507 ALL_OBJFILES (objfile
)
3510 struct gdbarch
*gdbarch
;
3511 struct breakpoint_objfile_data
*bp_objfile_data
;
3513 gdbarch
= get_objfile_arch (objfile
);
3515 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3517 if (!bp_objfile_data
->longjmp_searched
)
3521 ret
= find_probes_in_objfile (objfile
, "libc", "longjmp");
3524 /* We are only interested in checking one element. */
3525 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3527 if (!can_evaluate_probe_arguments (p
))
3529 /* We cannot use the probe interface here, because it does
3530 not know how to evaluate arguments. */
3531 VEC_free (probe_p
, ret
);
3535 bp_objfile_data
->longjmp_probes
= ret
;
3536 bp_objfile_data
->longjmp_searched
= 1;
3539 if (bp_objfile_data
->longjmp_probes
!= NULL
)
3542 struct probe
*probe
;
3543 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3546 VEC_iterate (probe_p
,
3547 bp_objfile_data
->longjmp_probes
,
3551 struct breakpoint
*b
;
3553 b
= create_internal_breakpoint (gdbarch
,
3554 get_probe_address (probe
,
3557 &internal_breakpoint_ops
);
3559 = new_probe_location ("-probe-stap libc:longjmp");
3560 b
->enable_state
= bp_disabled
;
3566 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3569 for (i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3571 struct breakpoint
*b
;
3572 const char *func_name
;
3574 struct explicit_location explicit_loc
;
3576 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3579 func_name
= longjmp_names
[i
];
3580 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3582 struct bound_minimal_symbol m
;
3584 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3585 if (m
.minsym
== NULL
)
3587 /* Prevent future lookups in this objfile. */
3588 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3591 bp_objfile_data
->longjmp_msym
[i
] = m
;
3594 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3595 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3596 &internal_breakpoint_ops
);
3597 initialize_explicit_location (&explicit_loc
);
3598 explicit_loc
.function_name
= ASTRDUP (func_name
);
3599 b
->location
= new_explicit_location (&explicit_loc
);
3600 b
->enable_state
= bp_disabled
;
3605 do_cleanups (old_chain
);
3608 /* Create a master std::terminate breakpoint. */
3610 create_std_terminate_master_breakpoint (void)
3612 struct program_space
*pspace
;
3613 struct cleanup
*old_chain
;
3614 const char *const func_name
= "std::terminate()";
3616 old_chain
= save_current_program_space ();
3618 ALL_PSPACES (pspace
)
3620 struct objfile
*objfile
;
3623 set_current_program_space (pspace
);
3625 ALL_OBJFILES (objfile
)
3627 struct breakpoint
*b
;
3628 struct breakpoint_objfile_data
*bp_objfile_data
;
3629 struct explicit_location explicit_loc
;
3631 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3633 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3636 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3638 struct bound_minimal_symbol m
;
3640 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3641 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3642 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3644 /* Prevent future lookups in this objfile. */
3645 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3648 bp_objfile_data
->terminate_msym
= m
;
3651 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3652 b
= create_internal_breakpoint (get_objfile_arch (objfile
), addr
,
3653 bp_std_terminate_master
,
3654 &internal_breakpoint_ops
);
3655 initialize_explicit_location (&explicit_loc
);
3656 explicit_loc
.function_name
= ASTRDUP (func_name
);
3657 b
->location
= new_explicit_location (&explicit_loc
);
3658 b
->enable_state
= bp_disabled
;
3662 do_cleanups (old_chain
);
3665 /* Install a master breakpoint on the unwinder's debug hook. */
3668 create_exception_master_breakpoint (void)
3670 struct objfile
*objfile
;
3671 const char *const func_name
= "_Unwind_DebugHook";
3673 ALL_OBJFILES (objfile
)
3675 struct breakpoint
*b
;
3676 struct gdbarch
*gdbarch
;
3677 struct breakpoint_objfile_data
*bp_objfile_data
;
3679 struct explicit_location explicit_loc
;
3681 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3683 /* We prefer the SystemTap probe point if it exists. */
3684 if (!bp_objfile_data
->exception_searched
)
3688 ret
= find_probes_in_objfile (objfile
, "libgcc", "unwind");
3692 /* We are only interested in checking one element. */
3693 struct probe
*p
= VEC_index (probe_p
, ret
, 0);
3695 if (!can_evaluate_probe_arguments (p
))
3697 /* We cannot use the probe interface here, because it does
3698 not know how to evaluate arguments. */
3699 VEC_free (probe_p
, ret
);
3703 bp_objfile_data
->exception_probes
= ret
;
3704 bp_objfile_data
->exception_searched
= 1;
3707 if (bp_objfile_data
->exception_probes
!= NULL
)
3709 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3711 struct probe
*probe
;
3714 VEC_iterate (probe_p
,
3715 bp_objfile_data
->exception_probes
,
3719 struct breakpoint
*b
;
3721 b
= create_internal_breakpoint (gdbarch
,
3722 get_probe_address (probe
,
3724 bp_exception_master
,
3725 &internal_breakpoint_ops
);
3727 = new_probe_location ("-probe-stap libgcc:unwind");
3728 b
->enable_state
= bp_disabled
;
3734 /* Otherwise, try the hook function. */
3736 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3739 gdbarch
= get_objfile_arch (objfile
);
3741 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3743 struct bound_minimal_symbol debug_hook
;
3745 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3746 if (debug_hook
.minsym
== NULL
)
3748 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3752 bp_objfile_data
->exception_msym
= debug_hook
;
3755 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3756 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
3758 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3759 &internal_breakpoint_ops
);
3760 initialize_explicit_location (&explicit_loc
);
3761 explicit_loc
.function_name
= ASTRDUP (func_name
);
3762 b
->location
= new_explicit_location (&explicit_loc
);
3763 b
->enable_state
= bp_disabled
;
3767 /* Does B have a location spec? */
3770 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3772 return b
->location
!= NULL
&& event_location_empty_p (b
->location
);
3776 update_breakpoints_after_exec (void)
3778 struct breakpoint
*b
, *b_tmp
;
3779 struct bp_location
*bploc
, **bplocp_tmp
;
3781 /* We're about to delete breakpoints from GDB's lists. If the
3782 INSERTED flag is true, GDB will try to lift the breakpoints by
3783 writing the breakpoints' "shadow contents" back into memory. The
3784 "shadow contents" are NOT valid after an exec, so GDB should not
3785 do that. Instead, the target is responsible from marking
3786 breakpoints out as soon as it detects an exec. We don't do that
3787 here instead, because there may be other attempts to delete
3788 breakpoints after detecting an exec and before reaching here. */
3789 ALL_BP_LOCATIONS (bploc
, bplocp_tmp
)
3790 if (bploc
->pspace
== current_program_space
)
3791 gdb_assert (!bploc
->inserted
);
3793 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
3795 if (b
->pspace
!= current_program_space
)
3798 /* Solib breakpoints must be explicitly reset after an exec(). */
3799 if (b
->type
== bp_shlib_event
)
3801 delete_breakpoint (b
);
3805 /* JIT breakpoints must be explicitly reset after an exec(). */
3806 if (b
->type
== bp_jit_event
)
3808 delete_breakpoint (b
);
3812 /* Thread event breakpoints must be set anew after an exec(),
3813 as must overlay event and longjmp master breakpoints. */
3814 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3815 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3816 || b
->type
== bp_exception_master
)
3818 delete_breakpoint (b
);
3822 /* Step-resume breakpoints are meaningless after an exec(). */
3823 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3825 delete_breakpoint (b
);
3829 /* Just like single-step breakpoints. */
3830 if (b
->type
== bp_single_step
)
3832 delete_breakpoint (b
);
3836 /* Longjmp and longjmp-resume breakpoints are also meaningless
3838 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3839 || b
->type
== bp_longjmp_call_dummy
3840 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3842 delete_breakpoint (b
);
3846 if (b
->type
== bp_catchpoint
)
3848 /* For now, none of the bp_catchpoint breakpoints need to
3849 do anything at this point. In the future, if some of
3850 the catchpoints need to something, we will need to add
3851 a new method, and call this method from here. */
3855 /* bp_finish is a special case. The only way we ought to be able
3856 to see one of these when an exec() has happened, is if the user
3857 caught a vfork, and then said "finish". Ordinarily a finish just
3858 carries them to the call-site of the current callee, by setting
3859 a temporary bp there and resuming. But in this case, the finish
3860 will carry them entirely through the vfork & exec.
3862 We don't want to allow a bp_finish to remain inserted now. But
3863 we can't safely delete it, 'cause finish_command has a handle to
3864 the bp on a bpstat, and will later want to delete it. There's a
3865 chance (and I've seen it happen) that if we delete the bp_finish
3866 here, that its storage will get reused by the time finish_command
3867 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3868 We really must allow finish_command to delete a bp_finish.
3870 In the absence of a general solution for the "how do we know
3871 it's safe to delete something others may have handles to?"
3872 problem, what we'll do here is just uninsert the bp_finish, and
3873 let finish_command delete it.
3875 (We know the bp_finish is "doomed" in the sense that it's
3876 momentary, and will be deleted as soon as finish_command sees
3877 the inferior stopped. So it doesn't matter that the bp's
3878 address is probably bogus in the new a.out, unlike e.g., the
3879 solib breakpoints.) */
3881 if (b
->type
== bp_finish
)
3886 /* Without a symbolic address, we have little hope of the
3887 pre-exec() address meaning the same thing in the post-exec()
3889 if (breakpoint_event_location_empty_p (b
))
3891 delete_breakpoint (b
);
3898 detach_breakpoints (ptid_t ptid
)
3900 struct bp_location
*bl
, **blp_tmp
;
3902 struct cleanup
*old_chain
= save_inferior_ptid ();
3903 struct inferior
*inf
= current_inferior ();
3905 if (ptid_get_pid (ptid
) == ptid_get_pid (inferior_ptid
))
3906 error (_("Cannot detach breakpoints of inferior_ptid"));
3908 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3909 inferior_ptid
= ptid
;
3910 ALL_BP_LOCATIONS (bl
, blp_tmp
)
3912 if (bl
->pspace
!= inf
->pspace
)
3915 /* This function must physically remove breakpoints locations
3916 from the specified ptid, without modifying the breakpoint
3917 package's state. Locations of type bp_loc_other are only
3918 maintained at GDB side. So, there is no need to remove
3919 these bp_loc_other locations. Moreover, removing these
3920 would modify the breakpoint package's state. */
3921 if (bl
->loc_type
== bp_loc_other
)
3925 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3928 do_cleanups (old_chain
);
3932 /* Remove the breakpoint location BL from the current address space.
3933 Note that this is used to detach breakpoints from a child fork.
3934 When we get here, the child isn't in the inferior list, and neither
3935 do we have objects to represent its address space --- we should
3936 *not* look at bl->pspace->aspace here. */
3939 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3943 /* BL is never in moribund_locations by our callers. */
3944 gdb_assert (bl
->owner
!= NULL
);
3946 /* The type of none suggests that owner is actually deleted.
3947 This should not ever happen. */
3948 gdb_assert (bl
->owner
->type
!= bp_none
);
3950 if (bl
->loc_type
== bp_loc_software_breakpoint
3951 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3953 /* "Normal" instruction breakpoint: either the standard
3954 trap-instruction bp (bp_breakpoint), or a
3955 bp_hardware_breakpoint. */
3957 /* First check to see if we have to handle an overlay. */
3958 if (overlay_debugging
== ovly_off
3959 || bl
->section
== NULL
3960 || !(section_is_overlay (bl
->section
)))
3962 /* No overlay handling: just remove the breakpoint. */
3964 /* If we're trying to uninsert a memory breakpoint that we
3965 know is set in a dynamic object that is marked
3966 shlib_disabled, then either the dynamic object was
3967 removed with "remove-symbol-file" or with
3968 "nosharedlibrary". In the former case, we don't know
3969 whether another dynamic object might have loaded over the
3970 breakpoint's address -- the user might well let us know
3971 about it next with add-symbol-file (the whole point of
3972 add-symbol-file is letting the user manually maintain a
3973 list of dynamically loaded objects). If we have the
3974 breakpoint's shadow memory, that is, this is a software
3975 breakpoint managed by GDB, check whether the breakpoint
3976 is still inserted in memory, to avoid overwriting wrong
3977 code with stale saved shadow contents. Note that HW
3978 breakpoints don't have shadow memory, as they're
3979 implemented using a mechanism that is not dependent on
3980 being able to modify the target's memory, and as such
3981 they should always be removed. */
3982 if (bl
->shlib_disabled
3983 && bl
->target_info
.shadow_len
!= 0
3984 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3987 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3991 /* This breakpoint is in an overlay section.
3992 Did we set a breakpoint at the LMA? */
3993 if (!overlay_events_enabled
)
3995 /* Yes -- overlay event support is not active, so we
3996 should have set a breakpoint at the LMA. Remove it.
3998 /* Ignore any failures: if the LMA is in ROM, we will
3999 have already warned when we failed to insert it. */
4000 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
4001 target_remove_hw_breakpoint (bl
->gdbarch
,
4002 &bl
->overlay_target_info
);
4004 target_remove_breakpoint (bl
->gdbarch
,
4005 &bl
->overlay_target_info
,
4008 /* Did we set a breakpoint at the VMA?
4009 If so, we will have marked the breakpoint 'inserted'. */
4012 /* Yes -- remove it. Previously we did not bother to
4013 remove the breakpoint if the section had been
4014 unmapped, but let's not rely on that being safe. We
4015 don't know what the overlay manager might do. */
4017 /* However, we should remove *software* breakpoints only
4018 if the section is still mapped, or else we overwrite
4019 wrong code with the saved shadow contents. */
4020 if (bl
->loc_type
== bp_loc_hardware_breakpoint
4021 || section_is_mapped (bl
->section
))
4022 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
4028 /* No -- not inserted, so no need to remove. No error. */
4033 /* In some cases, we might not be able to remove a breakpoint in
4034 a shared library that has already been removed, but we have
4035 not yet processed the shlib unload event. Similarly for an
4036 unloaded add-symbol-file object - the user might not yet have
4037 had the chance to remove-symbol-file it. shlib_disabled will
4038 be set if the library/object has already been removed, but
4039 the breakpoint hasn't been uninserted yet, e.g., after
4040 "nosharedlibrary" or "remove-symbol-file" with breakpoints
4041 always-inserted mode. */
4043 && (bl
->loc_type
== bp_loc_software_breakpoint
4044 && (bl
->shlib_disabled
4045 || solib_name_from_address (bl
->pspace
, bl
->address
)
4046 || shared_objfile_contains_address_p (bl
->pspace
,
4052 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4054 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
4056 gdb_assert (bl
->owner
->ops
!= NULL
4057 && bl
->owner
->ops
->remove_location
!= NULL
);
4059 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4060 bl
->owner
->ops
->remove_location (bl
, reason
);
4062 /* Failure to remove any of the hardware watchpoints comes here. */
4063 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
4064 warning (_("Could not remove hardware watchpoint %d."),
4067 else if (bl
->owner
->type
== bp_catchpoint
4068 && breakpoint_enabled (bl
->owner
)
4071 gdb_assert (bl
->owner
->ops
!= NULL
4072 && bl
->owner
->ops
->remove_location
!= NULL
);
4074 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
4078 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4085 remove_breakpoint (struct bp_location
*bl
)
4088 struct cleanup
*old_chain
;
4090 /* BL is never in moribund_locations by our callers. */
4091 gdb_assert (bl
->owner
!= NULL
);
4093 /* The type of none suggests that owner is actually deleted.
4094 This should not ever happen. */
4095 gdb_assert (bl
->owner
->type
!= bp_none
);
4097 old_chain
= save_current_space_and_thread ();
4099 switch_to_program_space_and_thread (bl
->pspace
);
4101 ret
= remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
4103 do_cleanups (old_chain
);
4107 /* Clear the "inserted" flag in all breakpoints. */
4110 mark_breakpoints_out (void)
4112 struct bp_location
*bl
, **blp_tmp
;
4114 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4115 if (bl
->pspace
== current_program_space
)
4119 /* Clear the "inserted" flag in all breakpoints and delete any
4120 breakpoints which should go away between runs of the program.
4122 Plus other such housekeeping that has to be done for breakpoints
4125 Note: this function gets called at the end of a run (by
4126 generic_mourn_inferior) and when a run begins (by
4127 init_wait_for_inferior). */
4132 breakpoint_init_inferior (enum inf_context context
)
4134 struct breakpoint
*b
, *b_tmp
;
4135 struct bp_location
*bl
;
4137 struct program_space
*pspace
= current_program_space
;
4139 /* If breakpoint locations are shared across processes, then there's
4141 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
4144 mark_breakpoints_out ();
4146 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
4148 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
4154 case bp_longjmp_call_dummy
:
4156 /* If the call dummy breakpoint is at the entry point it will
4157 cause problems when the inferior is rerun, so we better get
4160 case bp_watchpoint_scope
:
4162 /* Also get rid of scope breakpoints. */
4164 case bp_shlib_event
:
4166 /* Also remove solib event breakpoints. Their addresses may
4167 have changed since the last time we ran the program.
4168 Actually we may now be debugging against different target;
4169 and so the solib backend that installed this breakpoint may
4170 not be used in by the target. E.g.,
4172 (gdb) file prog-linux
4173 (gdb) run # native linux target
4176 (gdb) file prog-win.exe
4177 (gdb) tar rem :9999 # remote Windows gdbserver.
4180 case bp_step_resume
:
4182 /* Also remove step-resume breakpoints. */
4184 case bp_single_step
:
4186 /* Also remove single-step breakpoints. */
4188 delete_breakpoint (b
);
4192 case bp_hardware_watchpoint
:
4193 case bp_read_watchpoint
:
4194 case bp_access_watchpoint
:
4196 struct watchpoint
*w
= (struct watchpoint
*) b
;
4198 /* Likewise for watchpoints on local expressions. */
4199 if (w
->exp_valid_block
!= NULL
)
4200 delete_breakpoint (b
);
4203 /* Get rid of existing locations, which are no longer
4204 valid. New ones will be created in
4205 update_watchpoint, when the inferior is restarted.
4206 The next update_global_location_list call will
4207 garbage collect them. */
4210 if (context
== inf_starting
)
4212 /* Reset val field to force reread of starting value in
4213 insert_breakpoints. */
4215 value_free (w
->val
);
4227 /* Get rid of the moribund locations. */
4228 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bl
); ++ix
)
4229 decref_bp_location (&bl
);
4230 VEC_free (bp_location_p
, moribund_locations
);
4233 /* These functions concern about actual breakpoints inserted in the
4234 target --- to e.g. check if we need to do decr_pc adjustment or if
4235 we need to hop over the bkpt --- so we check for address space
4236 match, not program space. */
4238 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4239 exists at PC. It returns ordinary_breakpoint_here if it's an
4240 ordinary breakpoint, or permanent_breakpoint_here if it's a
4241 permanent breakpoint.
4242 - When continuing from a location with an ordinary breakpoint, we
4243 actually single step once before calling insert_breakpoints.
4244 - When continuing from a location with a permanent breakpoint, we
4245 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4246 the target, to advance the PC past the breakpoint. */
4248 enum breakpoint_here
4249 breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4251 struct bp_location
*bl
, **blp_tmp
;
4252 int any_breakpoint_here
= 0;
4254 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4256 if (bl
->loc_type
!= bp_loc_software_breakpoint
4257 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4260 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4261 if ((breakpoint_enabled (bl
->owner
)
4263 && breakpoint_location_address_match (bl
, aspace
, pc
))
4265 if (overlay_debugging
4266 && section_is_overlay (bl
->section
)
4267 && !section_is_mapped (bl
->section
))
4268 continue; /* unmapped overlay -- can't be a match */
4269 else if (bl
->permanent
)
4270 return permanent_breakpoint_here
;
4272 any_breakpoint_here
= 1;
4276 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4279 /* See breakpoint.h. */
4282 breakpoint_in_range_p (struct address_space
*aspace
,
4283 CORE_ADDR addr
, ULONGEST len
)
4285 struct bp_location
*bl
, **blp_tmp
;
4287 ALL_BP_LOCATIONS (bl
, blp_tmp
)
4289 if (bl
->loc_type
!= bp_loc_software_breakpoint
4290 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4293 if ((breakpoint_enabled (bl
->owner
)
4295 && breakpoint_location_address_range_overlap (bl
, aspace
,
4298 if (overlay_debugging
4299 && section_is_overlay (bl
->section
)
4300 && !section_is_mapped (bl
->section
))
4302 /* Unmapped overlay -- can't be a match. */
4313 /* Return true if there's a moribund breakpoint at PC. */
4316 moribund_breakpoint_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4318 struct bp_location
*loc
;
4321 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
4322 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4328 /* Returns non-zero iff BL is inserted at PC, in address space
4332 bp_location_inserted_here_p (struct bp_location
*bl
,
4333 struct address_space
*aspace
, CORE_ADDR pc
)
4336 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4339 if (overlay_debugging
4340 && section_is_overlay (bl
->section
)
4341 && !section_is_mapped (bl
->section
))
4342 return 0; /* unmapped overlay -- can't be a match */
4349 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4352 breakpoint_inserted_here_p (struct address_space
*aspace
, CORE_ADDR pc
)
4354 struct bp_location
**blp
, **blp_tmp
= NULL
;
4356 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4358 struct bp_location
*bl
= *blp
;
4360 if (bl
->loc_type
!= bp_loc_software_breakpoint
4361 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4364 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4370 /* This function returns non-zero iff there is a software breakpoint
4374 software_breakpoint_inserted_here_p (struct address_space
*aspace
,
4377 struct bp_location
**blp
, **blp_tmp
= NULL
;
4379 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4381 struct bp_location
*bl
= *blp
;
4383 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4386 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4393 /* See breakpoint.h. */
4396 hardware_breakpoint_inserted_here_p (struct address_space
*aspace
,
4399 struct bp_location
**blp
, **blp_tmp
= NULL
;
4401 ALL_BP_LOCATIONS_AT_ADDR (blp
, blp_tmp
, pc
)
4403 struct bp_location
*bl
= *blp
;
4405 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4408 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4416 hardware_watchpoint_inserted_in_range (struct address_space
*aspace
,
4417 CORE_ADDR addr
, ULONGEST len
)
4419 struct breakpoint
*bpt
;
4421 ALL_BREAKPOINTS (bpt
)
4423 struct bp_location
*loc
;
4425 if (bpt
->type
!= bp_hardware_watchpoint
4426 && bpt
->type
!= bp_access_watchpoint
)
4429 if (!breakpoint_enabled (bpt
))
4432 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
4433 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4437 /* Check for intersection. */
4438 l
= max (loc
->address
, addr
);
4439 h
= min (loc
->address
+ loc
->length
, addr
+ len
);
4448 /* bpstat stuff. External routines' interfaces are documented
4452 is_catchpoint (struct breakpoint
*ep
)
4454 return (ep
->type
== bp_catchpoint
);
4457 /* Frees any storage that is part of a bpstat. Does not walk the
4461 bpstat_free (bpstat bs
)
4463 if (bs
->old_val
!= NULL
)
4464 value_free (bs
->old_val
);
4465 decref_counted_command_line (&bs
->commands
);
4466 decref_bp_location (&bs
->bp_location_at
);
4470 /* Clear a bpstat so that it says we are not at any breakpoint.
4471 Also free any storage that is part of a bpstat. */
4474 bpstat_clear (bpstat
*bsp
)
4491 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4492 is part of the bpstat is copied as well. */
4495 bpstat_copy (bpstat bs
)
4499 bpstat retval
= NULL
;
4504 for (; bs
!= NULL
; bs
= bs
->next
)
4506 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
4507 memcpy (tmp
, bs
, sizeof (*tmp
));
4508 incref_counted_command_line (tmp
->commands
);
4509 incref_bp_location (tmp
->bp_location_at
);
4510 if (bs
->old_val
!= NULL
)
4512 tmp
->old_val
= value_copy (bs
->old_val
);
4513 release_value (tmp
->old_val
);
4517 /* This is the first thing in the chain. */
4527 /* Find the bpstat associated with this breakpoint. */
4530 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4535 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4537 if (bsp
->breakpoint_at
== breakpoint
)
4543 /* See breakpoint.h. */
4546 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4548 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4550 if (bsp
->breakpoint_at
== NULL
)
4552 /* A moribund location can never explain a signal other than
4554 if (sig
== GDB_SIGNAL_TRAP
)
4559 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4568 /* Put in *NUM the breakpoint number of the first breakpoint we are
4569 stopped at. *BSP upon return is a bpstat which points to the
4570 remaining breakpoints stopped at (but which is not guaranteed to be
4571 good for anything but further calls to bpstat_num).
4573 Return 0 if passed a bpstat which does not indicate any breakpoints.
4574 Return -1 if stopped at a breakpoint that has been deleted since
4576 Return 1 otherwise. */
4579 bpstat_num (bpstat
*bsp
, int *num
)
4581 struct breakpoint
*b
;
4584 return 0; /* No more breakpoint values */
4586 /* We assume we'll never have several bpstats that correspond to a
4587 single breakpoint -- otherwise, this function might return the
4588 same number more than once and this will look ugly. */
4589 b
= (*bsp
)->breakpoint_at
;
4590 *bsp
= (*bsp
)->next
;
4592 return -1; /* breakpoint that's been deleted since */
4594 *num
= b
->number
; /* We have its number */
4598 /* See breakpoint.h. */
4601 bpstat_clear_actions (void)
4603 struct thread_info
*tp
;
4606 if (ptid_equal (inferior_ptid
, null_ptid
))
4609 tp
= find_thread_ptid (inferior_ptid
);
4613 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4615 decref_counted_command_line (&bs
->commands
);
4617 if (bs
->old_val
!= NULL
)
4619 value_free (bs
->old_val
);
4625 /* Called when a command is about to proceed the inferior. */
4628 breakpoint_about_to_proceed (void)
4630 if (!ptid_equal (inferior_ptid
, null_ptid
))
4632 struct thread_info
*tp
= inferior_thread ();
4634 /* Allow inferior function calls in breakpoint commands to not
4635 interrupt the command list. When the call finishes
4636 successfully, the inferior will be standing at the same
4637 breakpoint as if nothing happened. */
4638 if (tp
->control
.in_infcall
)
4642 breakpoint_proceeded
= 1;
4645 /* Stub for cleaning up our state if we error-out of a breakpoint
4648 cleanup_executing_breakpoints (void *ignore
)
4650 executing_breakpoint_commands
= 0;
4653 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4654 or its equivalent. */
4657 command_line_is_silent (struct command_line
*cmd
)
4659 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4662 /* Execute all the commands associated with all the breakpoints at
4663 this location. Any of these commands could cause the process to
4664 proceed beyond this point, etc. We look out for such changes by
4665 checking the global "breakpoint_proceeded" after each command.
4667 Returns true if a breakpoint command resumed the inferior. In that
4668 case, it is the caller's responsibility to recall it again with the
4669 bpstat of the current thread. */
4672 bpstat_do_actions_1 (bpstat
*bsp
)
4675 struct cleanup
*old_chain
;
4678 /* Avoid endless recursion if a `source' command is contained
4680 if (executing_breakpoint_commands
)
4683 executing_breakpoint_commands
= 1;
4684 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
4686 prevent_dont_repeat ();
4688 /* This pointer will iterate over the list of bpstat's. */
4691 breakpoint_proceeded
= 0;
4692 for (; bs
!= NULL
; bs
= bs
->next
)
4694 struct counted_command_line
*ccmd
;
4695 struct command_line
*cmd
;
4696 struct cleanup
*this_cmd_tree_chain
;
4698 /* Take ownership of the BSP's command tree, if it has one.
4700 The command tree could legitimately contain commands like
4701 'step' and 'next', which call clear_proceed_status, which
4702 frees stop_bpstat's command tree. To make sure this doesn't
4703 free the tree we're executing out from under us, we need to
4704 take ownership of the tree ourselves. Since a given bpstat's
4705 commands are only executed once, we don't need to copy it; we
4706 can clear the pointer in the bpstat, and make sure we free
4707 the tree when we're done. */
4708 ccmd
= bs
->commands
;
4709 bs
->commands
= NULL
;
4710 this_cmd_tree_chain
= make_cleanup_decref_counted_command_line (&ccmd
);
4711 cmd
= ccmd
? ccmd
->commands
: NULL
;
4712 if (command_line_is_silent (cmd
))
4714 /* The action has been already done by bpstat_stop_status. */
4720 execute_control_command (cmd
);
4722 if (breakpoint_proceeded
)
4728 /* We can free this command tree now. */
4729 do_cleanups (this_cmd_tree_chain
);
4731 if (breakpoint_proceeded
)
4733 if (current_ui
->async
)
4734 /* If we are in async mode, then the target might be still
4735 running, not stopped at any breakpoint, so nothing for
4736 us to do here -- just return to the event loop. */
4739 /* In sync mode, when execute_control_command returns
4740 we're already standing on the next breakpoint.
4741 Breakpoint commands for that stop were not run, since
4742 execute_command does not run breakpoint commands --
4743 only command_line_handler does, but that one is not
4744 involved in execution of breakpoint commands. So, we
4745 can now execute breakpoint commands. It should be
4746 noted that making execute_command do bpstat actions is
4747 not an option -- in this case we'll have recursive
4748 invocation of bpstat for each breakpoint with a
4749 command, and can easily blow up GDB stack. Instead, we
4750 return true, which will trigger the caller to recall us
4751 with the new stop_bpstat. */
4756 do_cleanups (old_chain
);
4761 bpstat_do_actions (void)
4763 struct cleanup
*cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
4765 /* Do any commands attached to breakpoint we are stopped at. */
4766 while (!ptid_equal (inferior_ptid
, null_ptid
)
4767 && target_has_execution
4768 && !is_exited (inferior_ptid
)
4769 && !is_executing (inferior_ptid
))
4770 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4771 and only return when it is stopped at the next breakpoint, we
4772 keep doing breakpoint actions until it returns false to
4773 indicate the inferior was not resumed. */
4774 if (!bpstat_do_actions_1 (&inferior_thread ()->control
.stop_bpstat
))
4777 discard_cleanups (cleanup_if_error
);
4780 /* Print out the (old or new) value associated with a watchpoint. */
4783 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4786 fprintf_unfiltered (stream
, _("<unreadable>"));
4789 struct value_print_options opts
;
4790 get_user_print_options (&opts
);
4791 value_print (val
, stream
, &opts
);
4795 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4796 debugging multiple threads. */
4799 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4801 if (ui_out_is_mi_like_p (uiout
))
4804 ui_out_text (uiout
, "\n");
4806 if (show_thread_that_caused_stop ())
4809 struct thread_info
*thr
= inferior_thread ();
4811 ui_out_text (uiout
, "Thread ");
4812 ui_out_field_fmt (uiout
, "thread-id", "%s", print_thread_id (thr
));
4814 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4817 ui_out_text (uiout
, " \"");
4818 ui_out_field_fmt (uiout
, "name", "%s", name
);
4819 ui_out_text (uiout
, "\"");
4822 ui_out_text (uiout
, " hit ");
4826 /* Generic routine for printing messages indicating why we
4827 stopped. The behavior of this function depends on the value
4828 'print_it' in the bpstat structure. Under some circumstances we
4829 may decide not to print anything here and delegate the task to
4832 static enum print_stop_action
4833 print_bp_stop_message (bpstat bs
)
4835 switch (bs
->print_it
)
4838 /* Nothing should be printed for this bpstat entry. */
4839 return PRINT_UNKNOWN
;
4843 /* We still want to print the frame, but we already printed the
4844 relevant messages. */
4845 return PRINT_SRC_AND_LOC
;
4848 case print_it_normal
:
4850 struct breakpoint
*b
= bs
->breakpoint_at
;
4852 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4853 which has since been deleted. */
4855 return PRINT_UNKNOWN
;
4857 /* Normal case. Call the breakpoint's print_it method. */
4858 return b
->ops
->print_it (bs
);
4863 internal_error (__FILE__
, __LINE__
,
4864 _("print_bp_stop_message: unrecognized enum value"));
4869 /* A helper function that prints a shared library stopped event. */
4872 print_solib_event (int is_catchpoint
)
4875 = !VEC_empty (char_ptr
, current_program_space
->deleted_solibs
);
4877 = !VEC_empty (so_list_ptr
, current_program_space
->added_solibs
);
4881 if (any_added
|| any_deleted
)
4882 ui_out_text (current_uiout
,
4883 _("Stopped due to shared library event:\n"));
4885 ui_out_text (current_uiout
,
4886 _("Stopped due to shared library event (no "
4887 "libraries added or removed)\n"));
4890 if (ui_out_is_mi_like_p (current_uiout
))
4891 ui_out_field_string (current_uiout
, "reason",
4892 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4896 struct cleanup
*cleanup
;
4900 ui_out_text (current_uiout
, _(" Inferior unloaded "));
4901 cleanup
= make_cleanup_ui_out_list_begin_end (current_uiout
,
4904 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
4909 ui_out_text (current_uiout
, " ");
4910 ui_out_field_string (current_uiout
, "library", name
);
4911 ui_out_text (current_uiout
, "\n");
4914 do_cleanups (cleanup
);
4919 struct so_list
*iter
;
4921 struct cleanup
*cleanup
;
4923 ui_out_text (current_uiout
, _(" Inferior loaded "));
4924 cleanup
= make_cleanup_ui_out_list_begin_end (current_uiout
,
4927 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
4932 ui_out_text (current_uiout
, " ");
4933 ui_out_field_string (current_uiout
, "library", iter
->so_name
);
4934 ui_out_text (current_uiout
, "\n");
4937 do_cleanups (cleanup
);
4941 /* Print a message indicating what happened. This is called from
4942 normal_stop(). The input to this routine is the head of the bpstat
4943 list - a list of the eventpoints that caused this stop. KIND is
4944 the target_waitkind for the stopping event. This
4945 routine calls the generic print routine for printing a message
4946 about reasons for stopping. This will print (for example) the
4947 "Breakpoint n," part of the output. The return value of this
4950 PRINT_UNKNOWN: Means we printed nothing.
4951 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4952 code to print the location. An example is
4953 "Breakpoint 1, " which should be followed by
4955 PRINT_SRC_ONLY: Means we printed something, but there is no need
4956 to also print the location part of the message.
4957 An example is the catch/throw messages, which
4958 don't require a location appended to the end.
4959 PRINT_NOTHING: We have done some printing and we don't need any
4960 further info to be printed. */
4962 enum print_stop_action
4963 bpstat_print (bpstat bs
, int kind
)
4965 enum print_stop_action val
;
4967 /* Maybe another breakpoint in the chain caused us to stop.
4968 (Currently all watchpoints go on the bpstat whether hit or not.
4969 That probably could (should) be changed, provided care is taken
4970 with respect to bpstat_explains_signal). */
4971 for (; bs
; bs
= bs
->next
)
4973 val
= print_bp_stop_message (bs
);
4974 if (val
== PRINT_SRC_ONLY
4975 || val
== PRINT_SRC_AND_LOC
4976 || val
== PRINT_NOTHING
)
4980 /* If we had hit a shared library event breakpoint,
4981 print_bp_stop_message would print out this message. If we hit an
4982 OS-level shared library event, do the same thing. */
4983 if (kind
== TARGET_WAITKIND_LOADED
)
4985 print_solib_event (0);
4986 return PRINT_NOTHING
;
4989 /* We reached the end of the chain, or we got a null BS to start
4990 with and nothing was printed. */
4991 return PRINT_UNKNOWN
;
4994 /* Evaluate the expression EXP and return 1 if value is zero.
4995 This returns the inverse of the condition because it is called
4996 from catch_errors which returns 0 if an exception happened, and if an
4997 exception happens we want execution to stop.
4998 The argument is a "struct expression *" that has been cast to a
4999 "void *" to make it pass through catch_errors. */
5002 breakpoint_cond_eval (void *exp
)
5004 struct value
*mark
= value_mark ();
5005 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
5007 value_free_to_mark (mark
);
5011 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
5014 bpstat_alloc (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
5018 bs
= (bpstat
) xmalloc (sizeof (*bs
));
5020 **bs_link_pointer
= bs
;
5021 *bs_link_pointer
= &bs
->next
;
5022 bs
->breakpoint_at
= bl
->owner
;
5023 bs
->bp_location_at
= bl
;
5024 incref_bp_location (bl
);
5025 /* If the condition is false, etc., don't do the commands. */
5026 bs
->commands
= NULL
;
5028 bs
->print_it
= print_it_normal
;
5032 /* The target has stopped with waitstatus WS. Check if any hardware
5033 watchpoints have triggered, according to the target. */
5036 watchpoints_triggered (struct target_waitstatus
*ws
)
5038 int stopped_by_watchpoint
= target_stopped_by_watchpoint ();
5040 struct breakpoint
*b
;
5042 if (!stopped_by_watchpoint
)
5044 /* We were not stopped by a watchpoint. Mark all watchpoints
5045 as not triggered. */
5047 if (is_hardware_watchpoint (b
))
5049 struct watchpoint
*w
= (struct watchpoint
*) b
;
5051 w
->watchpoint_triggered
= watch_triggered_no
;
5057 if (!target_stopped_data_address (¤t_target
, &addr
))
5059 /* We were stopped by a watchpoint, but we don't know where.
5060 Mark all watchpoints as unknown. */
5062 if (is_hardware_watchpoint (b
))
5064 struct watchpoint
*w
= (struct watchpoint
*) b
;
5066 w
->watchpoint_triggered
= watch_triggered_unknown
;
5072 /* The target could report the data address. Mark watchpoints
5073 affected by this data address as triggered, and all others as not
5077 if (is_hardware_watchpoint (b
))
5079 struct watchpoint
*w
= (struct watchpoint
*) b
;
5080 struct bp_location
*loc
;
5082 w
->watchpoint_triggered
= watch_triggered_no
;
5083 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
5085 if (is_masked_watchpoint (b
))
5087 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
5088 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
5090 if (newaddr
== start
)
5092 w
->watchpoint_triggered
= watch_triggered_yes
;
5096 /* Exact match not required. Within range is sufficient. */
5097 else if (target_watchpoint_addr_within_range (¤t_target
,
5101 w
->watchpoint_triggered
= watch_triggered_yes
;
5110 /* Possible return values for watchpoint_check (this can't be an enum
5111 because of check_errors). */
5112 /* The watchpoint has been deleted. */
5113 #define WP_DELETED 1
5114 /* The value has changed. */
5115 #define WP_VALUE_CHANGED 2
5116 /* The value has not changed. */
5117 #define WP_VALUE_NOT_CHANGED 3
5118 /* Ignore this watchpoint, no matter if the value changed or not. */
5121 #define BP_TEMPFLAG 1
5122 #define BP_HARDWAREFLAG 2
5124 /* Evaluate watchpoint condition expression and check if its value
5127 P should be a pointer to struct bpstat, but is defined as a void *
5128 in order for this function to be usable with catch_errors. */
5131 watchpoint_check (void *p
)
5133 bpstat bs
= (bpstat
) p
;
5134 struct watchpoint
*b
;
5135 struct frame_info
*fr
;
5136 int within_current_scope
;
5138 /* BS is built from an existing struct breakpoint. */
5139 gdb_assert (bs
->breakpoint_at
!= NULL
);
5140 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5142 /* If this is a local watchpoint, we only want to check if the
5143 watchpoint frame is in scope if the current thread is the thread
5144 that was used to create the watchpoint. */
5145 if (!watchpoint_in_thread_scope (b
))
5148 if (b
->exp_valid_block
== NULL
)
5149 within_current_scope
= 1;
5152 struct frame_info
*frame
= get_current_frame ();
5153 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
5154 CORE_ADDR frame_pc
= get_frame_pc (frame
);
5156 /* stack_frame_destroyed_p() returns a non-zero value if we're
5157 still in the function but the stack frame has already been
5158 invalidated. Since we can't rely on the values of local
5159 variables after the stack has been destroyed, we are treating
5160 the watchpoint in that state as `not changed' without further
5161 checking. Don't mark watchpoints as changed if the current
5162 frame is in an epilogue - even if they are in some other
5163 frame, our view of the stack is likely to be wrong and
5164 frame_find_by_id could error out. */
5165 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
5168 fr
= frame_find_by_id (b
->watchpoint_frame
);
5169 within_current_scope
= (fr
!= NULL
);
5171 /* If we've gotten confused in the unwinder, we might have
5172 returned a frame that can't describe this variable. */
5173 if (within_current_scope
)
5175 struct symbol
*function
;
5177 function
= get_frame_function (fr
);
5178 if (function
== NULL
5179 || !contained_in (b
->exp_valid_block
,
5180 SYMBOL_BLOCK_VALUE (function
)))
5181 within_current_scope
= 0;
5184 if (within_current_scope
)
5185 /* If we end up stopping, the current frame will get selected
5186 in normal_stop. So this call to select_frame won't affect
5191 if (within_current_scope
)
5193 /* We use value_{,free_to_}mark because it could be a *long*
5194 time before we return to the command level and call
5195 free_all_values. We can't call free_all_values because we
5196 might be in the middle of evaluating a function call. */
5200 struct value
*new_val
;
5202 if (is_masked_watchpoint (&b
->base
))
5203 /* Since we don't know the exact trigger address (from
5204 stopped_data_address), just tell the user we've triggered
5205 a mask watchpoint. */
5206 return WP_VALUE_CHANGED
;
5208 mark
= value_mark ();
5209 fetch_subexp_value (b
->exp
, &pc
, &new_val
, NULL
, NULL
, 0);
5211 if (b
->val_bitsize
!= 0)
5212 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
5214 /* We use value_equal_contents instead of value_equal because
5215 the latter coerces an array to a pointer, thus comparing just
5216 the address of the array instead of its contents. This is
5217 not what we want. */
5218 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
5219 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
, new_val
)))
5221 if (new_val
!= NULL
)
5223 release_value (new_val
);
5224 value_free_to_mark (mark
);
5226 bs
->old_val
= b
->val
;
5229 return WP_VALUE_CHANGED
;
5233 /* Nothing changed. */
5234 value_free_to_mark (mark
);
5235 return WP_VALUE_NOT_CHANGED
;
5240 struct switch_thru_all_uis state
;
5242 /* This seems like the only logical thing to do because
5243 if we temporarily ignored the watchpoint, then when
5244 we reenter the block in which it is valid it contains
5245 garbage (in the case of a function, it may have two
5246 garbage values, one before and one after the prologue).
5247 So we can't even detect the first assignment to it and
5248 watch after that (since the garbage may or may not equal
5249 the first value assigned). */
5250 /* We print all the stop information in
5251 breakpoint_ops->print_it, but in this case, by the time we
5252 call breakpoint_ops->print_it this bp will be deleted
5253 already. So we have no choice but print the information
5256 SWITCH_THRU_ALL_UIS (state
)
5258 struct ui_out
*uiout
= current_uiout
;
5260 if (ui_out_is_mi_like_p (uiout
))
5262 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5263 ui_out_text (uiout
, "\nWatchpoint ");
5264 ui_out_field_int (uiout
, "wpnum", b
->base
.number
);
5266 " deleted because the program has left the block in\n"
5267 "which its expression is valid.\n");
5270 /* Make sure the watchpoint's commands aren't executed. */
5271 decref_counted_command_line (&b
->base
.commands
);
5272 watchpoint_del_at_next_stop (b
);
5278 /* Return true if it looks like target has stopped due to hitting
5279 breakpoint location BL. This function does not check if we should
5280 stop, only if BL explains the stop. */
5283 bpstat_check_location (const struct bp_location
*bl
,
5284 struct address_space
*aspace
, CORE_ADDR bp_addr
,
5285 const struct target_waitstatus
*ws
)
5287 struct breakpoint
*b
= bl
->owner
;
5289 /* BL is from an existing breakpoint. */
5290 gdb_assert (b
!= NULL
);
5292 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5295 /* Determine if the watched values have actually changed, and we
5296 should stop. If not, set BS->stop to 0. */
5299 bpstat_check_watchpoint (bpstat bs
)
5301 const struct bp_location
*bl
;
5302 struct watchpoint
*b
;
5304 /* BS is built for existing struct breakpoint. */
5305 bl
= bs
->bp_location_at
;
5306 gdb_assert (bl
!= NULL
);
5307 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5308 gdb_assert (b
!= NULL
);
5311 int must_check_value
= 0;
5313 if (b
->base
.type
== bp_watchpoint
)
5314 /* For a software watchpoint, we must always check the
5316 must_check_value
= 1;
5317 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5318 /* We have a hardware watchpoint (read, write, or access)
5319 and the target earlier reported an address watched by
5321 must_check_value
= 1;
5322 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5323 && b
->base
.type
== bp_hardware_watchpoint
)
5324 /* We were stopped by a hardware watchpoint, but the target could
5325 not report the data address. We must check the watchpoint's
5326 value. Access and read watchpoints are out of luck; without
5327 a data address, we can't figure it out. */
5328 must_check_value
= 1;
5330 if (must_check_value
)
5333 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
5335 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
5336 int e
= catch_errors (watchpoint_check
, bs
, message
,
5338 do_cleanups (cleanups
);
5342 /* We've already printed what needs to be printed. */
5343 bs
->print_it
= print_it_done
;
5347 bs
->print_it
= print_it_noop
;
5350 case WP_VALUE_CHANGED
:
5351 if (b
->base
.type
== bp_read_watchpoint
)
5353 /* There are two cases to consider here:
5355 1. We're watching the triggered memory for reads.
5356 In that case, trust the target, and always report
5357 the watchpoint hit to the user. Even though
5358 reads don't cause value changes, the value may
5359 have changed since the last time it was read, and
5360 since we're not trapping writes, we will not see
5361 those, and as such we should ignore our notion of
5364 2. We're watching the triggered memory for both
5365 reads and writes. There are two ways this may
5368 2.1. This is a target that can't break on data
5369 reads only, but can break on accesses (reads or
5370 writes), such as e.g., x86. We detect this case
5371 at the time we try to insert read watchpoints.
5373 2.2. Otherwise, the target supports read
5374 watchpoints, but, the user set an access or write
5375 watchpoint watching the same memory as this read
5378 If we're watching memory writes as well as reads,
5379 ignore watchpoint hits when we find that the
5380 value hasn't changed, as reads don't cause
5381 changes. This still gives false positives when
5382 the program writes the same value to memory as
5383 what there was already in memory (we will confuse
5384 it for a read), but it's much better than
5387 int other_write_watchpoint
= 0;
5389 if (bl
->watchpoint_type
== hw_read
)
5391 struct breakpoint
*other_b
;
5393 ALL_BREAKPOINTS (other_b
)
5394 if (other_b
->type
== bp_hardware_watchpoint
5395 || other_b
->type
== bp_access_watchpoint
)
5397 struct watchpoint
*other_w
=
5398 (struct watchpoint
*) other_b
;
5400 if (other_w
->watchpoint_triggered
5401 == watch_triggered_yes
)
5403 other_write_watchpoint
= 1;
5409 if (other_write_watchpoint
5410 || bl
->watchpoint_type
== hw_access
)
5412 /* We're watching the same memory for writes,
5413 and the value changed since the last time we
5414 updated it, so this trap must be for a write.
5416 bs
->print_it
= print_it_noop
;
5421 case WP_VALUE_NOT_CHANGED
:
5422 if (b
->base
.type
== bp_hardware_watchpoint
5423 || b
->base
.type
== bp_watchpoint
)
5425 /* Don't stop: write watchpoints shouldn't fire if
5426 the value hasn't changed. */
5427 bs
->print_it
= print_it_noop
;
5435 /* Error from catch_errors. */
5437 struct switch_thru_all_uis state
;
5439 SWITCH_THRU_ALL_UIS (state
)
5441 printf_filtered (_("Watchpoint %d deleted.\n"),
5444 watchpoint_del_at_next_stop (b
);
5445 /* We've already printed what needs to be printed. */
5446 bs
->print_it
= print_it_done
;
5451 else /* must_check_value == 0 */
5453 /* This is a case where some watchpoint(s) triggered, but
5454 not at the address of this watchpoint, or else no
5455 watchpoint triggered after all. So don't print
5456 anything for this watchpoint. */
5457 bs
->print_it
= print_it_noop
;
5463 /* For breakpoints that are currently marked as telling gdb to stop,
5464 check conditions (condition proper, frame, thread and ignore count)
5465 of breakpoint referred to by BS. If we should not stop for this
5466 breakpoint, set BS->stop to 0. */
5469 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
5471 const struct bp_location
*bl
;
5472 struct breakpoint
*b
;
5473 int value_is_zero
= 0;
5474 struct expression
*cond
;
5476 gdb_assert (bs
->stop
);
5478 /* BS is built for existing struct breakpoint. */
5479 bl
= bs
->bp_location_at
;
5480 gdb_assert (bl
!= NULL
);
5481 b
= bs
->breakpoint_at
;
5482 gdb_assert (b
!= NULL
);
5484 /* Even if the target evaluated the condition on its end and notified GDB, we
5485 need to do so again since GDB does not know if we stopped due to a
5486 breakpoint or a single step breakpoint. */
5488 if (frame_id_p (b
->frame_id
)
5489 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5495 /* If this is a thread/task-specific breakpoint, don't waste cpu
5496 evaluating the condition if this isn't the specified
5498 if ((b
->thread
!= -1 && b
->thread
!= ptid_to_global_thread_id (ptid
))
5499 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (ptid
)))
5506 /* Evaluate extension language breakpoints that have a "stop" method
5508 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5510 if (is_watchpoint (b
))
5512 struct watchpoint
*w
= (struct watchpoint
*) b
;
5519 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5521 int within_current_scope
= 1;
5522 struct watchpoint
* w
;
5524 /* We use value_mark and value_free_to_mark because it could
5525 be a long time before we return to the command level and
5526 call free_all_values. We can't call free_all_values
5527 because we might be in the middle of evaluating a
5529 struct value
*mark
= value_mark ();
5531 if (is_watchpoint (b
))
5532 w
= (struct watchpoint
*) b
;
5536 /* Need to select the frame, with all that implies so that
5537 the conditions will have the right context. Because we
5538 use the frame, we will not see an inlined function's
5539 variables when we arrive at a breakpoint at the start
5540 of the inlined function; the current frame will be the
5542 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5543 select_frame (get_current_frame ());
5546 struct frame_info
*frame
;
5548 /* For local watchpoint expressions, which particular
5549 instance of a local is being watched matters, so we
5550 keep track of the frame to evaluate the expression
5551 in. To evaluate the condition however, it doesn't
5552 really matter which instantiation of the function
5553 where the condition makes sense triggers the
5554 watchpoint. This allows an expression like "watch
5555 global if q > 10" set in `func', catch writes to
5556 global on all threads that call `func', or catch
5557 writes on all recursive calls of `func' by a single
5558 thread. We simply always evaluate the condition in
5559 the innermost frame that's executing where it makes
5560 sense to evaluate the condition. It seems
5562 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5564 select_frame (frame
);
5566 within_current_scope
= 0;
5568 if (within_current_scope
)
5570 = catch_errors (breakpoint_cond_eval
, cond
,
5571 "Error in testing breakpoint condition:\n",
5575 warning (_("Watchpoint condition cannot be tested "
5576 "in the current scope"));
5577 /* If we failed to set the right context for this
5578 watchpoint, unconditionally report it. */
5581 /* FIXME-someday, should give breakpoint #. */
5582 value_free_to_mark (mark
);
5585 if (cond
&& value_is_zero
)
5589 else if (b
->ignore_count
> 0)
5593 /* Increase the hit count even though we don't stop. */
5595 observer_notify_breakpoint_modified (b
);
5599 /* Returns true if we need to track moribund locations of LOC's type
5600 on the current target. */
5603 need_moribund_for_location_type (struct bp_location
*loc
)
5605 return ((loc
->loc_type
== bp_loc_software_breakpoint
5606 && !target_supports_stopped_by_sw_breakpoint ())
5607 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5608 && !target_supports_stopped_by_hw_breakpoint ()));
5612 /* Get a bpstat associated with having just stopped at address
5613 BP_ADDR in thread PTID.
5615 Determine whether we stopped at a breakpoint, etc, or whether we
5616 don't understand this stop. Result is a chain of bpstat's such
5619 if we don't understand the stop, the result is a null pointer.
5621 if we understand why we stopped, the result is not null.
5623 Each element of the chain refers to a particular breakpoint or
5624 watchpoint at which we have stopped. (We may have stopped for
5625 several reasons concurrently.)
5627 Each element of the chain has valid next, breakpoint_at,
5628 commands, FIXME??? fields. */
5631 bpstat_stop_status (struct address_space
*aspace
,
5632 CORE_ADDR bp_addr
, ptid_t ptid
,
5633 const struct target_waitstatus
*ws
)
5635 struct breakpoint
*b
= NULL
;
5636 struct bp_location
*bl
;
5637 struct bp_location
*loc
;
5638 /* First item of allocated bpstat's. */
5639 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5640 /* Pointer to the last thing in the chain currently. */
5643 int need_remove_insert
;
5646 /* First, build the bpstat chain with locations that explain a
5647 target stop, while being careful to not set the target running,
5648 as that may invalidate locations (in particular watchpoint
5649 locations are recreated). Resuming will happen here with
5650 breakpoint conditions or watchpoint expressions that include
5651 inferior function calls. */
5655 if (!breakpoint_enabled (b
))
5658 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
5660 /* For hardware watchpoints, we look only at the first
5661 location. The watchpoint_check function will work on the
5662 entire expression, not the individual locations. For
5663 read watchpoints, the watchpoints_triggered function has
5664 checked all locations already. */
5665 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5668 if (!bl
->enabled
|| bl
->shlib_disabled
)
5671 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5674 /* Come here if it's a watchpoint, or if the break address
5677 bs
= bpstat_alloc (bl
, &bs_link
); /* Alloc a bpstat to
5680 /* Assume we stop. Should we find a watchpoint that is not
5681 actually triggered, or if the condition of the breakpoint
5682 evaluates as false, we'll reset 'stop' to 0. */
5686 /* If this is a scope breakpoint, mark the associated
5687 watchpoint as triggered so that we will handle the
5688 out-of-scope event. We'll get to the watchpoint next
5690 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5692 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5694 w
->watchpoint_triggered
= watch_triggered_yes
;
5699 /* Check if a moribund breakpoint explains the stop. */
5700 if (!target_supports_stopped_by_sw_breakpoint ()
5701 || !target_supports_stopped_by_hw_breakpoint ())
5703 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
5705 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5706 && need_moribund_for_location_type (loc
))
5708 bs
= bpstat_alloc (loc
, &bs_link
);
5709 /* For hits of moribund locations, we should just proceed. */
5712 bs
->print_it
= print_it_noop
;
5717 /* A bit of special processing for shlib breakpoints. We need to
5718 process solib loading here, so that the lists of loaded and
5719 unloaded libraries are correct before we handle "catch load" and
5721 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5723 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5725 handle_solib_event ();
5730 /* Now go through the locations that caused the target to stop, and
5731 check whether we're interested in reporting this stop to higher
5732 layers, or whether we should resume the target transparently. */
5736 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5741 b
= bs
->breakpoint_at
;
5742 b
->ops
->check_status (bs
);
5745 bpstat_check_breakpoint_conditions (bs
, ptid
);
5750 observer_notify_breakpoint_modified (b
);
5752 /* We will stop here. */
5753 if (b
->disposition
== disp_disable
)
5755 --(b
->enable_count
);
5756 if (b
->enable_count
<= 0)
5757 b
->enable_state
= bp_disabled
;
5762 bs
->commands
= b
->commands
;
5763 incref_counted_command_line (bs
->commands
);
5764 if (command_line_is_silent (bs
->commands
5765 ? bs
->commands
->commands
: NULL
))
5768 b
->ops
->after_condition_true (bs
);
5773 /* Print nothing for this entry if we don't stop or don't
5775 if (!bs
->stop
|| !bs
->print
)
5776 bs
->print_it
= print_it_noop
;
5779 /* If we aren't stopping, the value of some hardware watchpoint may
5780 not have changed, but the intermediate memory locations we are
5781 watching may have. Don't bother if we're stopping; this will get
5783 need_remove_insert
= 0;
5784 if (! bpstat_causes_stop (bs_head
))
5785 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5787 && bs
->breakpoint_at
5788 && is_hardware_watchpoint (bs
->breakpoint_at
))
5790 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5792 update_watchpoint (w
, 0 /* don't reparse. */);
5793 need_remove_insert
= 1;
5796 if (need_remove_insert
)
5797 update_global_location_list (UGLL_MAY_INSERT
);
5798 else if (removed_any
)
5799 update_global_location_list (UGLL_DONT_INSERT
);
5805 handle_jit_event (void)
5807 struct frame_info
*frame
;
5808 struct gdbarch
*gdbarch
;
5811 fprintf_unfiltered (gdb_stdlog
, "handling bp_jit_event\n");
5813 /* Switch terminal for any messages produced by
5814 breakpoint_re_set. */
5815 target_terminal_ours_for_output ();
5817 frame
= get_current_frame ();
5818 gdbarch
= get_frame_arch (frame
);
5820 jit_event_handler (gdbarch
);
5822 target_terminal_inferior ();
5825 /* Prepare WHAT final decision for infrun. */
5827 /* Decide what infrun needs to do with this bpstat. */
5830 bpstat_what (bpstat bs_head
)
5832 struct bpstat_what retval
;
5835 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5836 retval
.call_dummy
= STOP_NONE
;
5837 retval
.is_longjmp
= 0;
5839 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5841 /* Extract this BS's action. After processing each BS, we check
5842 if its action overrides all we've seem so far. */
5843 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5846 if (bs
->breakpoint_at
== NULL
)
5848 /* I suspect this can happen if it was a momentary
5849 breakpoint which has since been deleted. */
5853 bptype
= bs
->breakpoint_at
->type
;
5860 case bp_hardware_breakpoint
:
5861 case bp_single_step
:
5864 case bp_shlib_event
:
5868 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5870 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5873 this_action
= BPSTAT_WHAT_SINGLE
;
5876 case bp_hardware_watchpoint
:
5877 case bp_read_watchpoint
:
5878 case bp_access_watchpoint
:
5882 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5884 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5888 /* There was a watchpoint, but we're not stopping.
5889 This requires no further action. */
5893 case bp_longjmp_call_dummy
:
5897 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5898 retval
.is_longjmp
= bptype
!= bp_exception
;
5901 this_action
= BPSTAT_WHAT_SINGLE
;
5903 case bp_longjmp_resume
:
5904 case bp_exception_resume
:
5907 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5908 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5911 this_action
= BPSTAT_WHAT_SINGLE
;
5913 case bp_step_resume
:
5915 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5918 /* It is for the wrong frame. */
5919 this_action
= BPSTAT_WHAT_SINGLE
;
5922 case bp_hp_step_resume
:
5924 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5927 /* It is for the wrong frame. */
5928 this_action
= BPSTAT_WHAT_SINGLE
;
5931 case bp_watchpoint_scope
:
5932 case bp_thread_event
:
5933 case bp_overlay_event
:
5934 case bp_longjmp_master
:
5935 case bp_std_terminate_master
:
5936 case bp_exception_master
:
5937 this_action
= BPSTAT_WHAT_SINGLE
;
5943 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5945 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5949 /* There was a catchpoint, but we're not stopping.
5950 This requires no further action. */
5954 this_action
= BPSTAT_WHAT_SINGLE
;
5957 /* Make sure the action is stop (silent or noisy),
5958 so infrun.c pops the dummy frame. */
5959 retval
.call_dummy
= STOP_STACK_DUMMY
;
5960 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5962 case bp_std_terminate
:
5963 /* Make sure the action is stop (silent or noisy),
5964 so infrun.c pops the dummy frame. */
5965 retval
.call_dummy
= STOP_STD_TERMINATE
;
5966 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5969 case bp_fast_tracepoint
:
5970 case bp_static_tracepoint
:
5971 /* Tracepoint hits should not be reported back to GDB, and
5972 if one got through somehow, it should have been filtered
5974 internal_error (__FILE__
, __LINE__
,
5975 _("bpstat_what: tracepoint encountered"));
5977 case bp_gnu_ifunc_resolver
:
5978 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5979 this_action
= BPSTAT_WHAT_SINGLE
;
5981 case bp_gnu_ifunc_resolver_return
:
5982 /* The breakpoint will be removed, execution will restart from the
5983 PC of the former breakpoint. */
5984 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5989 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5991 this_action
= BPSTAT_WHAT_SINGLE
;
5995 internal_error (__FILE__
, __LINE__
,
5996 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5999 retval
.main_action
= max (retval
.main_action
, this_action
);
6006 bpstat_run_callbacks (bpstat bs_head
)
6010 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
6012 struct breakpoint
*b
= bs
->breakpoint_at
;
6019 handle_jit_event ();
6021 case bp_gnu_ifunc_resolver
:
6022 gnu_ifunc_resolver_stop (b
);
6024 case bp_gnu_ifunc_resolver_return
:
6025 gnu_ifunc_resolver_return_stop (b
);
6031 /* Nonzero if we should step constantly (e.g. watchpoints on machines
6032 without hardware support). This isn't related to a specific bpstat,
6033 just to things like whether watchpoints are set. */
6036 bpstat_should_step (void)
6038 struct breakpoint
*b
;
6041 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
6047 bpstat_causes_stop (bpstat bs
)
6049 for (; bs
!= NULL
; bs
= bs
->next
)
6058 /* Compute a string of spaces suitable to indent the next line
6059 so it starts at the position corresponding to the table column
6060 named COL_NAME in the currently active table of UIOUT. */
6063 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
6065 static char wrap_indent
[80];
6066 int i
, total_width
, width
, align
;
6070 for (i
= 1; ui_out_query_field (uiout
, i
, &width
, &align
, &text
); i
++)
6072 if (strcmp (text
, col_name
) == 0)
6074 gdb_assert (total_width
< sizeof wrap_indent
);
6075 memset (wrap_indent
, ' ', total_width
);
6076 wrap_indent
[total_width
] = 0;
6081 total_width
+= width
+ 1;
6087 /* Determine if the locations of this breakpoint will have their conditions
6088 evaluated by the target, host or a mix of both. Returns the following:
6090 "host": Host evals condition.
6091 "host or target": Host or Target evals condition.
6092 "target": Target evals condition.
6096 bp_condition_evaluator (struct breakpoint
*b
)
6098 struct bp_location
*bl
;
6099 char host_evals
= 0;
6100 char target_evals
= 0;
6105 if (!is_breakpoint (b
))
6108 if (gdb_evaluates_breakpoint_condition_p ()
6109 || !target_supports_evaluation_of_breakpoint_conditions ())
6110 return condition_evaluation_host
;
6112 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
6114 if (bl
->cond_bytecode
)
6120 if (host_evals
&& target_evals
)
6121 return condition_evaluation_both
;
6122 else if (target_evals
)
6123 return condition_evaluation_target
;
6125 return condition_evaluation_host
;
6128 /* Determine the breakpoint location's condition evaluator. This is
6129 similar to bp_condition_evaluator, but for locations. */
6132 bp_location_condition_evaluator (struct bp_location
*bl
)
6134 if (bl
&& !is_breakpoint (bl
->owner
))
6137 if (gdb_evaluates_breakpoint_condition_p ()
6138 || !target_supports_evaluation_of_breakpoint_conditions ())
6139 return condition_evaluation_host
;
6141 if (bl
&& bl
->cond_bytecode
)
6142 return condition_evaluation_target
;
6144 return condition_evaluation_host
;
6147 /* Print the LOC location out of the list of B->LOC locations. */
6150 print_breakpoint_location (struct breakpoint
*b
,
6151 struct bp_location
*loc
)
6153 struct ui_out
*uiout
= current_uiout
;
6154 struct cleanup
*old_chain
= save_current_program_space ();
6156 if (loc
!= NULL
&& loc
->shlib_disabled
)
6160 set_current_program_space (loc
->pspace
);
6162 if (b
->display_canonical
)
6163 ui_out_field_string (uiout
, "what",
6164 event_location_to_string (b
->location
));
6165 else if (loc
&& loc
->symtab
)
6168 = find_pc_sect_function (loc
->address
, loc
->section
);
6171 ui_out_text (uiout
, "in ");
6172 ui_out_field_string (uiout
, "func",
6173 SYMBOL_PRINT_NAME (sym
));
6174 ui_out_text (uiout
, " ");
6175 ui_out_wrap_hint (uiout
, wrap_indent_at_field (uiout
, "what"));
6176 ui_out_text (uiout
, "at ");
6178 ui_out_field_string (uiout
, "file",
6179 symtab_to_filename_for_display (loc
->symtab
));
6180 ui_out_text (uiout
, ":");
6182 if (ui_out_is_mi_like_p (uiout
))
6183 ui_out_field_string (uiout
, "fullname",
6184 symtab_to_fullname (loc
->symtab
));
6186 ui_out_field_int (uiout
, "line", loc
->line_number
);
6190 struct ui_file
*stb
= mem_fileopen ();
6191 struct cleanup
*stb_chain
= make_cleanup_ui_file_delete (stb
);
6193 print_address_symbolic (loc
->gdbarch
, loc
->address
, stb
,
6195 ui_out_field_stream (uiout
, "at", stb
);
6197 do_cleanups (stb_chain
);
6201 ui_out_field_string (uiout
, "pending",
6202 event_location_to_string (b
->location
));
6203 /* If extra_string is available, it could be holding a condition
6204 or dprintf arguments. In either case, make sure it is printed,
6205 too, but only for non-MI streams. */
6206 if (!ui_out_is_mi_like_p (uiout
) && b
->extra_string
!= NULL
)
6208 if (b
->type
== bp_dprintf
)
6209 ui_out_text (uiout
, ",");
6211 ui_out_text (uiout
, " ");
6212 ui_out_text (uiout
, b
->extra_string
);
6216 if (loc
&& is_breakpoint (b
)
6217 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6218 && bp_condition_evaluator (b
) == condition_evaluation_both
)
6220 ui_out_text (uiout
, " (");
6221 ui_out_field_string (uiout
, "evaluated-by",
6222 bp_location_condition_evaluator (loc
));
6223 ui_out_text (uiout
, ")");
6226 do_cleanups (old_chain
);
6230 bptype_string (enum bptype type
)
6232 struct ep_type_description
6237 static struct ep_type_description bptypes
[] =
6239 {bp_none
, "?deleted?"},
6240 {bp_breakpoint
, "breakpoint"},
6241 {bp_hardware_breakpoint
, "hw breakpoint"},
6242 {bp_single_step
, "sw single-step"},
6243 {bp_until
, "until"},
6244 {bp_finish
, "finish"},
6245 {bp_watchpoint
, "watchpoint"},
6246 {bp_hardware_watchpoint
, "hw watchpoint"},
6247 {bp_read_watchpoint
, "read watchpoint"},
6248 {bp_access_watchpoint
, "acc watchpoint"},
6249 {bp_longjmp
, "longjmp"},
6250 {bp_longjmp_resume
, "longjmp resume"},
6251 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6252 {bp_exception
, "exception"},
6253 {bp_exception_resume
, "exception resume"},
6254 {bp_step_resume
, "step resume"},
6255 {bp_hp_step_resume
, "high-priority step resume"},
6256 {bp_watchpoint_scope
, "watchpoint scope"},
6257 {bp_call_dummy
, "call dummy"},
6258 {bp_std_terminate
, "std::terminate"},
6259 {bp_shlib_event
, "shlib events"},
6260 {bp_thread_event
, "thread events"},
6261 {bp_overlay_event
, "overlay events"},
6262 {bp_longjmp_master
, "longjmp master"},
6263 {bp_std_terminate_master
, "std::terminate master"},
6264 {bp_exception_master
, "exception master"},
6265 {bp_catchpoint
, "catchpoint"},
6266 {bp_tracepoint
, "tracepoint"},
6267 {bp_fast_tracepoint
, "fast tracepoint"},
6268 {bp_static_tracepoint
, "static tracepoint"},
6269 {bp_dprintf
, "dprintf"},
6270 {bp_jit_event
, "jit events"},
6271 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6272 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6275 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6276 || ((int) type
!= bptypes
[(int) type
].type
))
6277 internal_error (__FILE__
, __LINE__
,
6278 _("bptypes table does not describe type #%d."),
6281 return bptypes
[(int) type
].description
;
6284 /* For MI, output a field named 'thread-groups' with a list as the value.
6285 For CLI, prefix the list with the string 'inf'. */
6288 output_thread_groups (struct ui_out
*uiout
,
6289 const char *field_name
,
6293 struct cleanup
*back_to
;
6294 int is_mi
= ui_out_is_mi_like_p (uiout
);
6298 /* For backward compatibility, don't display inferiors in CLI unless
6299 there are several. Always display them for MI. */
6300 if (!is_mi
&& mi_only
)
6303 back_to
= make_cleanup_ui_out_list_begin_end (uiout
, field_name
);
6305 for (i
= 0; VEC_iterate (int, inf_num
, i
, inf
); ++i
)
6311 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf
);
6312 ui_out_field_string (uiout
, NULL
, mi_group
);
6317 ui_out_text (uiout
, " inf ");
6319 ui_out_text (uiout
, ", ");
6321 ui_out_text (uiout
, plongest (inf
));
6325 do_cleanups (back_to
);
6328 /* Print B to gdb_stdout. */
6331 print_one_breakpoint_location (struct breakpoint
*b
,
6332 struct bp_location
*loc
,
6334 struct bp_location
**last_loc
,
6337 struct command_line
*l
;
6338 static char bpenables
[] = "nynny";
6340 struct ui_out
*uiout
= current_uiout
;
6341 int header_of_multiple
= 0;
6342 int part_of_multiple
= (loc
!= NULL
);
6343 struct value_print_options opts
;
6345 get_user_print_options (&opts
);
6347 gdb_assert (!loc
|| loc_number
!= 0);
6348 /* See comment in print_one_breakpoint concerning treatment of
6349 breakpoints with single disabled location. */
6352 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
6353 header_of_multiple
= 1;
6361 if (part_of_multiple
)
6364 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
6365 ui_out_field_string (uiout
, "number", formatted
);
6370 ui_out_field_int (uiout
, "number", b
->number
);
6375 if (part_of_multiple
)
6376 ui_out_field_skip (uiout
, "type");
6378 ui_out_field_string (uiout
, "type", bptype_string (b
->type
));
6382 if (part_of_multiple
)
6383 ui_out_field_skip (uiout
, "disp");
6385 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6390 if (part_of_multiple
)
6391 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
6393 ui_out_field_fmt (uiout
, "enabled", "%c",
6394 bpenables
[(int) b
->enable_state
]);
6395 ui_out_spaces (uiout
, 2);
6399 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6401 /* Although the print_one can possibly print all locations,
6402 calling it here is not likely to get any nice result. So,
6403 make sure there's just one location. */
6404 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
6405 b
->ops
->print_one (b
, last_loc
);
6411 internal_error (__FILE__
, __LINE__
,
6412 _("print_one_breakpoint: bp_none encountered\n"));
6416 case bp_hardware_watchpoint
:
6417 case bp_read_watchpoint
:
6418 case bp_access_watchpoint
:
6420 struct watchpoint
*w
= (struct watchpoint
*) b
;
6422 /* Field 4, the address, is omitted (which makes the columns
6423 not line up too nicely with the headers, but the effect
6424 is relatively readable). */
6425 if (opts
.addressprint
)
6426 ui_out_field_skip (uiout
, "addr");
6428 ui_out_field_string (uiout
, "what", w
->exp_string
);
6433 case bp_hardware_breakpoint
:
6434 case bp_single_step
:
6438 case bp_longjmp_resume
:
6439 case bp_longjmp_call_dummy
:
6441 case bp_exception_resume
:
6442 case bp_step_resume
:
6443 case bp_hp_step_resume
:
6444 case bp_watchpoint_scope
:
6446 case bp_std_terminate
:
6447 case bp_shlib_event
:
6448 case bp_thread_event
:
6449 case bp_overlay_event
:
6450 case bp_longjmp_master
:
6451 case bp_std_terminate_master
:
6452 case bp_exception_master
:
6454 case bp_fast_tracepoint
:
6455 case bp_static_tracepoint
:
6458 case bp_gnu_ifunc_resolver
:
6459 case bp_gnu_ifunc_resolver_return
:
6460 if (opts
.addressprint
)
6463 if (header_of_multiple
)
6464 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
6465 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6466 ui_out_field_string (uiout
, "addr", "<PENDING>");
6468 ui_out_field_core_addr (uiout
, "addr",
6469 loc
->gdbarch
, loc
->address
);
6472 if (!header_of_multiple
)
6473 print_breakpoint_location (b
, loc
);
6480 if (loc
!= NULL
&& !header_of_multiple
)
6482 struct inferior
*inf
;
6483 VEC(int) *inf_num
= NULL
;
6488 if (inf
->pspace
== loc
->pspace
)
6489 VEC_safe_push (int, inf_num
, inf
->num
);
6492 /* For backward compatibility, don't display inferiors in CLI unless
6493 there are several. Always display for MI. */
6495 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6496 && (number_of_program_spaces () > 1
6497 || number_of_inferiors () > 1)
6498 /* LOC is for existing B, it cannot be in
6499 moribund_locations and thus having NULL OWNER. */
6500 && loc
->owner
->type
!= bp_catchpoint
))
6502 output_thread_groups (uiout
, "thread-groups", inf_num
, mi_only
);
6503 VEC_free (int, inf_num
);
6506 if (!part_of_multiple
)
6508 if (b
->thread
!= -1)
6510 /* FIXME: This seems to be redundant and lost here; see the
6511 "stop only in" line a little further down. */
6512 ui_out_text (uiout
, " thread ");
6513 ui_out_field_int (uiout
, "thread", b
->thread
);
6515 else if (b
->task
!= 0)
6517 ui_out_text (uiout
, " task ");
6518 ui_out_field_int (uiout
, "task", b
->task
);
6522 ui_out_text (uiout
, "\n");
6524 if (!part_of_multiple
)
6525 b
->ops
->print_one_detail (b
, uiout
);
6527 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6530 ui_out_text (uiout
, "\tstop only in stack frame at ");
6531 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6533 ui_out_field_core_addr (uiout
, "frame",
6534 b
->gdbarch
, b
->frame_id
.stack_addr
);
6535 ui_out_text (uiout
, "\n");
6538 if (!part_of_multiple
&& b
->cond_string
)
6541 if (is_tracepoint (b
))
6542 ui_out_text (uiout
, "\ttrace only if ");
6544 ui_out_text (uiout
, "\tstop only if ");
6545 ui_out_field_string (uiout
, "cond", b
->cond_string
);
6547 /* Print whether the target is doing the breakpoint's condition
6548 evaluation. If GDB is doing the evaluation, don't print anything. */
6549 if (is_breakpoint (b
)
6550 && breakpoint_condition_evaluation_mode ()
6551 == condition_evaluation_target
)
6553 ui_out_text (uiout
, " (");
6554 ui_out_field_string (uiout
, "evaluated-by",
6555 bp_condition_evaluator (b
));
6556 ui_out_text (uiout
, " evals)");
6558 ui_out_text (uiout
, "\n");
6561 if (!part_of_multiple
&& b
->thread
!= -1)
6563 /* FIXME should make an annotation for this. */
6564 ui_out_text (uiout
, "\tstop only in thread ");
6565 if (ui_out_is_mi_like_p (uiout
))
6566 ui_out_field_int (uiout
, "thread", b
->thread
);
6569 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6571 ui_out_field_string (uiout
, "thread", print_thread_id (thr
));
6573 ui_out_text (uiout
, "\n");
6576 if (!part_of_multiple
)
6580 /* FIXME should make an annotation for this. */
6581 if (is_catchpoint (b
))
6582 ui_out_text (uiout
, "\tcatchpoint");
6583 else if (is_tracepoint (b
))
6584 ui_out_text (uiout
, "\ttracepoint");
6586 ui_out_text (uiout
, "\tbreakpoint");
6587 ui_out_text (uiout
, " already hit ");
6588 ui_out_field_int (uiout
, "times", b
->hit_count
);
6589 if (b
->hit_count
== 1)
6590 ui_out_text (uiout
, " time\n");
6592 ui_out_text (uiout
, " times\n");
6596 /* Output the count also if it is zero, but only if this is mi. */
6597 if (ui_out_is_mi_like_p (uiout
))
6598 ui_out_field_int (uiout
, "times", b
->hit_count
);
6602 if (!part_of_multiple
&& b
->ignore_count
)
6605 ui_out_text (uiout
, "\tignore next ");
6606 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
6607 ui_out_text (uiout
, " hits\n");
6610 /* Note that an enable count of 1 corresponds to "enable once"
6611 behavior, which is reported by the combination of enablement and
6612 disposition, so we don't need to mention it here. */
6613 if (!part_of_multiple
&& b
->enable_count
> 1)
6616 ui_out_text (uiout
, "\tdisable after ");
6617 /* Tweak the wording to clarify that ignore and enable counts
6618 are distinct, and have additive effect. */
6619 if (b
->ignore_count
)
6620 ui_out_text (uiout
, "additional ");
6622 ui_out_text (uiout
, "next ");
6623 ui_out_field_int (uiout
, "enable", b
->enable_count
);
6624 ui_out_text (uiout
, " hits\n");
6627 if (!part_of_multiple
&& is_tracepoint (b
))
6629 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6631 if (tp
->traceframe_usage
)
6633 ui_out_text (uiout
, "\ttrace buffer usage ");
6634 ui_out_field_int (uiout
, "traceframe-usage", tp
->traceframe_usage
);
6635 ui_out_text (uiout
, " bytes\n");
6639 l
= b
->commands
? b
->commands
->commands
: NULL
;
6640 if (!part_of_multiple
&& l
)
6642 struct cleanup
*script_chain
;
6645 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
6646 print_command_lines (uiout
, l
, 4);
6647 do_cleanups (script_chain
);
6650 if (is_tracepoint (b
))
6652 struct tracepoint
*t
= (struct tracepoint
*) b
;
6654 if (!part_of_multiple
&& t
->pass_count
)
6656 annotate_field (10);
6657 ui_out_text (uiout
, "\tpass count ");
6658 ui_out_field_int (uiout
, "pass", t
->pass_count
);
6659 ui_out_text (uiout
, " \n");
6662 /* Don't display it when tracepoint or tracepoint location is
6664 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6666 annotate_field (11);
6668 if (ui_out_is_mi_like_p (uiout
))
6669 ui_out_field_string (uiout
, "installed",
6670 loc
->inserted
? "y" : "n");
6674 ui_out_text (uiout
, "\t");
6676 ui_out_text (uiout
, "\tnot ");
6677 ui_out_text (uiout
, "installed on target\n");
6682 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
6684 if (is_watchpoint (b
))
6686 struct watchpoint
*w
= (struct watchpoint
*) b
;
6688 ui_out_field_string (uiout
, "original-location", w
->exp_string
);
6690 else if (b
->location
!= NULL
6691 && event_location_to_string (b
->location
) != NULL
)
6692 ui_out_field_string (uiout
, "original-location",
6693 event_location_to_string (b
->location
));
6698 print_one_breakpoint (struct breakpoint
*b
,
6699 struct bp_location
**last_loc
,
6702 struct cleanup
*bkpt_chain
;
6703 struct ui_out
*uiout
= current_uiout
;
6705 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
6707 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
);
6708 do_cleanups (bkpt_chain
);
6710 /* If this breakpoint has custom print function,
6711 it's already printed. Otherwise, print individual
6712 locations, if any. */
6713 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
6715 /* If breakpoint has a single location that is disabled, we
6716 print it as if it had several locations, since otherwise it's
6717 hard to represent "breakpoint enabled, location disabled"
6720 Note that while hardware watchpoints have several locations
6721 internally, that's not a property exposed to user. */
6723 && !is_hardware_watchpoint (b
)
6724 && (b
->loc
->next
|| !b
->loc
->enabled
))
6726 struct bp_location
*loc
;
6729 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
6731 struct cleanup
*inner2
=
6732 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
6733 print_one_breakpoint_location (b
, loc
, n
, last_loc
, allflag
);
6734 do_cleanups (inner2
);
6741 breakpoint_address_bits (struct breakpoint
*b
)
6743 int print_address_bits
= 0;
6744 struct bp_location
*loc
;
6746 /* Software watchpoints that aren't watching memory don't have an
6747 address to print. */
6748 if (is_no_memory_software_watchpoint (b
))
6751 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6755 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6756 if (addr_bit
> print_address_bits
)
6757 print_address_bits
= addr_bit
;
6760 return print_address_bits
;
6763 struct captured_breakpoint_query_args
6769 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
6771 struct captured_breakpoint_query_args
*args
6772 = (struct captured_breakpoint_query_args
*) data
;
6773 struct breakpoint
*b
;
6774 struct bp_location
*dummy_loc
= NULL
;
6778 if (args
->bnum
== b
->number
)
6780 print_one_breakpoint (b
, &dummy_loc
, 0);
6788 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
,
6789 char **error_message
)
6791 struct captured_breakpoint_query_args args
;
6794 /* For the moment we don't trust print_one_breakpoint() to not throw
6796 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
6797 error_message
, RETURN_MASK_ALL
) < 0)
6803 /* Return true if this breakpoint was set by the user, false if it is
6804 internal or momentary. */
6807 user_breakpoint_p (struct breakpoint
*b
)
6809 return b
->number
> 0;
6812 /* See breakpoint.h. */
6815 pending_breakpoint_p (struct breakpoint
*b
)
6817 return b
->loc
== NULL
;
6820 /* Print information on user settable breakpoint (watchpoint, etc)
6821 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6822 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6823 FILTER is non-NULL, call it on each breakpoint and only include the
6824 ones for which it returns non-zero. Return the total number of
6825 breakpoints listed. */
6828 breakpoint_1 (char *args
, int allflag
,
6829 int (*filter
) (const struct breakpoint
*))
6831 struct breakpoint
*b
;
6832 struct bp_location
*last_loc
= NULL
;
6833 int nr_printable_breakpoints
;
6834 struct cleanup
*bkpttbl_chain
;
6835 struct value_print_options opts
;
6836 int print_address_bits
= 0;
6837 int print_type_col_width
= 14;
6838 struct ui_out
*uiout
= current_uiout
;
6840 get_user_print_options (&opts
);
6842 /* Compute the number of rows in the table, as well as the size
6843 required for address fields. */
6844 nr_printable_breakpoints
= 0;
6847 /* If we have a filter, only list the breakpoints it accepts. */
6848 if (filter
&& !filter (b
))
6851 /* If we have an "args" string, it is a list of breakpoints to
6852 accept. Skip the others. */
6853 if (args
!= NULL
&& *args
!= '\0')
6855 if (allflag
&& parse_and_eval_long (args
) != b
->number
)
6857 if (!allflag
&& !number_is_in_list (args
, b
->number
))
6861 if (allflag
|| user_breakpoint_p (b
))
6863 int addr_bit
, type_len
;
6865 addr_bit
= breakpoint_address_bits (b
);
6866 if (addr_bit
> print_address_bits
)
6867 print_address_bits
= addr_bit
;
6869 type_len
= strlen (bptype_string (b
->type
));
6870 if (type_len
> print_type_col_width
)
6871 print_type_col_width
= type_len
;
6873 nr_printable_breakpoints
++;
6877 if (opts
.addressprint
)
6879 = make_cleanup_ui_out_table_begin_end (uiout
, 6,
6880 nr_printable_breakpoints
,
6884 = make_cleanup_ui_out_table_begin_end (uiout
, 5,
6885 nr_printable_breakpoints
,
6888 if (nr_printable_breakpoints
> 0)
6889 annotate_breakpoints_headers ();
6890 if (nr_printable_breakpoints
> 0)
6892 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
6893 if (nr_printable_breakpoints
> 0)
6895 ui_out_table_header (uiout
, print_type_col_width
, ui_left
,
6896 "type", "Type"); /* 2 */
6897 if (nr_printable_breakpoints
> 0)
6899 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
6900 if (nr_printable_breakpoints
> 0)
6902 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
6903 if (opts
.addressprint
)
6905 if (nr_printable_breakpoints
> 0)
6907 if (print_address_bits
<= 32)
6908 ui_out_table_header (uiout
, 10, ui_left
,
6909 "addr", "Address"); /* 5 */
6911 ui_out_table_header (uiout
, 18, ui_left
,
6912 "addr", "Address"); /* 5 */
6914 if (nr_printable_breakpoints
> 0)
6916 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
6917 ui_out_table_body (uiout
);
6918 if (nr_printable_breakpoints
> 0)
6919 annotate_breakpoints_table ();
6924 /* If we have a filter, only list the breakpoints it accepts. */
6925 if (filter
&& !filter (b
))
6928 /* If we have an "args" string, it is a list of breakpoints to
6929 accept. Skip the others. */
6931 if (args
!= NULL
&& *args
!= '\0')
6933 if (allflag
) /* maintenance info breakpoint */
6935 if (parse_and_eval_long (args
) != b
->number
)
6938 else /* all others */
6940 if (!number_is_in_list (args
, b
->number
))
6944 /* We only print out user settable breakpoints unless the
6946 if (allflag
|| user_breakpoint_p (b
))
6947 print_one_breakpoint (b
, &last_loc
, allflag
);
6950 do_cleanups (bkpttbl_chain
);
6952 if (nr_printable_breakpoints
== 0)
6954 /* If there's a filter, let the caller decide how to report
6958 if (args
== NULL
|| *args
== '\0')
6959 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
6961 ui_out_message (uiout
, 0,
6962 "No breakpoint or watchpoint matching '%s'.\n",
6968 if (last_loc
&& !server_command
)
6969 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6972 /* FIXME? Should this be moved up so that it is only called when
6973 there have been breakpoints? */
6974 annotate_breakpoints_table_end ();
6976 return nr_printable_breakpoints
;
6979 /* Display the value of default-collect in a way that is generally
6980 compatible with the breakpoint list. */
6983 default_collect_info (void)
6985 struct ui_out
*uiout
= current_uiout
;
6987 /* If it has no value (which is frequently the case), say nothing; a
6988 message like "No default-collect." gets in user's face when it's
6990 if (!*default_collect
)
6993 /* The following phrase lines up nicely with per-tracepoint collect
6995 ui_out_text (uiout
, "default collect ");
6996 ui_out_field_string (uiout
, "default-collect", default_collect
);
6997 ui_out_text (uiout
, " \n");
7001 breakpoints_info (char *args
, int from_tty
)
7003 breakpoint_1 (args
, 0, NULL
);
7005 default_collect_info ();
7009 watchpoints_info (char *args
, int from_tty
)
7011 int num_printed
= breakpoint_1 (args
, 0, is_watchpoint
);
7012 struct ui_out
*uiout
= current_uiout
;
7014 if (num_printed
== 0)
7016 if (args
== NULL
|| *args
== '\0')
7017 ui_out_message (uiout
, 0, "No watchpoints.\n");
7019 ui_out_message (uiout
, 0, "No watchpoint matching '%s'.\n", args
);
7024 maintenance_info_breakpoints (char *args
, int from_tty
)
7026 breakpoint_1 (args
, 1, NULL
);
7028 default_collect_info ();
7032 breakpoint_has_pc (struct breakpoint
*b
,
7033 struct program_space
*pspace
,
7034 CORE_ADDR pc
, struct obj_section
*section
)
7036 struct bp_location
*bl
= b
->loc
;
7038 for (; bl
; bl
= bl
->next
)
7040 if (bl
->pspace
== pspace
7041 && bl
->address
== pc
7042 && (!overlay_debugging
|| bl
->section
== section
))
7048 /* Print a message describing any user-breakpoints set at PC. This
7049 concerns with logical breakpoints, so we match program spaces, not
7053 describe_other_breakpoints (struct gdbarch
*gdbarch
,
7054 struct program_space
*pspace
, CORE_ADDR pc
,
7055 struct obj_section
*section
, int thread
)
7058 struct breakpoint
*b
;
7061 others
+= (user_breakpoint_p (b
)
7062 && breakpoint_has_pc (b
, pspace
, pc
, section
));
7066 printf_filtered (_("Note: breakpoint "));
7067 else /* if (others == ???) */
7068 printf_filtered (_("Note: breakpoints "));
7070 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
7073 printf_filtered ("%d", b
->number
);
7074 if (b
->thread
== -1 && thread
!= -1)
7075 printf_filtered (" (all threads)");
7076 else if (b
->thread
!= -1)
7077 printf_filtered (" (thread %d)", b
->thread
);
7078 printf_filtered ("%s%s ",
7079 ((b
->enable_state
== bp_disabled
7080 || b
->enable_state
== bp_call_disabled
)
7084 : ((others
== 1) ? " and" : ""));
7086 printf_filtered (_("also set at pc "));
7087 fputs_filtered (paddress (gdbarch
, pc
), gdb_stdout
);
7088 printf_filtered (".\n");
7093 /* Return true iff it is meaningful to use the address member of
7094 BPT locations. For some breakpoint types, the locations' address members
7095 are irrelevant and it makes no sense to attempt to compare them to other
7096 addresses (or use them for any other purpose either).
7098 More specifically, each of the following breakpoint types will
7099 always have a zero valued location address and we don't want to mark
7100 breakpoints of any of these types to be a duplicate of an actual
7101 breakpoint location at address zero:
7109 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
7111 enum bptype type
= bpt
->type
;
7113 return (type
!= bp_watchpoint
&& type
!= bp_catchpoint
);
7116 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
7117 true if LOC1 and LOC2 represent the same watchpoint location. */
7120 watchpoint_locations_match (struct bp_location
*loc1
,
7121 struct bp_location
*loc2
)
7123 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
7124 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
7126 /* Both of them must exist. */
7127 gdb_assert (w1
!= NULL
);
7128 gdb_assert (w2
!= NULL
);
7130 /* If the target can evaluate the condition expression in hardware,
7131 then we we need to insert both watchpoints even if they are at
7132 the same place. Otherwise the watchpoint will only trigger when
7133 the condition of whichever watchpoint was inserted evaluates to
7134 true, not giving a chance for GDB to check the condition of the
7135 other watchpoint. */
7137 && target_can_accel_watchpoint_condition (loc1
->address
,
7139 loc1
->watchpoint_type
,
7142 && target_can_accel_watchpoint_condition (loc2
->address
,
7144 loc2
->watchpoint_type
,
7148 /* Note that this checks the owner's type, not the location's. In
7149 case the target does not support read watchpoints, but does
7150 support access watchpoints, we'll have bp_read_watchpoint
7151 watchpoints with hw_access locations. Those should be considered
7152 duplicates of hw_read locations. The hw_read locations will
7153 become hw_access locations later. */
7154 return (loc1
->owner
->type
== loc2
->owner
->type
7155 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
7156 && loc1
->address
== loc2
->address
7157 && loc1
->length
== loc2
->length
);
7160 /* See breakpoint.h. */
7163 breakpoint_address_match (struct address_space
*aspace1
, CORE_ADDR addr1
,
7164 struct address_space
*aspace2
, CORE_ADDR addr2
)
7166 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7167 || aspace1
== aspace2
)
7171 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
7172 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
7173 matches ASPACE2. On targets that have global breakpoints, the address
7174 space doesn't really matter. */
7177 breakpoint_address_match_range (struct address_space
*aspace1
, CORE_ADDR addr1
,
7178 int len1
, struct address_space
*aspace2
,
7181 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7182 || aspace1
== aspace2
)
7183 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
7186 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
7187 a ranged breakpoint. In most targets, a match happens only if ASPACE
7188 matches the breakpoint's address space. On targets that have global
7189 breakpoints, the address space doesn't really matter. */
7192 breakpoint_location_address_match (struct bp_location
*bl
,
7193 struct address_space
*aspace
,
7196 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
7199 && breakpoint_address_match_range (bl
->pspace
->aspace
,
7200 bl
->address
, bl
->length
,
7204 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
7205 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
7206 match happens only if ASPACE matches the breakpoint's address
7207 space. On targets that have global breakpoints, the address space
7208 doesn't really matter. */
7211 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
7212 struct address_space
*aspace
,
7213 CORE_ADDR addr
, int len
)
7215 if (gdbarch_has_global_breakpoints (target_gdbarch ())
7216 || bl
->pspace
->aspace
== aspace
)
7218 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
7220 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
7226 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
7227 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
7228 true, otherwise returns false. */
7231 tracepoint_locations_match (struct bp_location
*loc1
,
7232 struct bp_location
*loc2
)
7234 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
7235 /* Since tracepoint locations are never duplicated with others', tracepoint
7236 locations at the same address of different tracepoints are regarded as
7237 different locations. */
7238 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
7243 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
7244 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
7245 represent the same location. */
7248 breakpoint_locations_match (struct bp_location
*loc1
,
7249 struct bp_location
*loc2
)
7251 int hw_point1
, hw_point2
;
7253 /* Both of them must not be in moribund_locations. */
7254 gdb_assert (loc1
->owner
!= NULL
);
7255 gdb_assert (loc2
->owner
!= NULL
);
7257 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
7258 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
7260 if (hw_point1
!= hw_point2
)
7263 return watchpoint_locations_match (loc1
, loc2
);
7264 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
7265 return tracepoint_locations_match (loc1
, loc2
);
7267 /* We compare bp_location.length in order to cover ranged breakpoints. */
7268 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7269 loc2
->pspace
->aspace
, loc2
->address
)
7270 && loc1
->length
== loc2
->length
);
7274 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7275 int bnum
, int have_bnum
)
7277 /* The longest string possibly returned by hex_string_custom
7278 is 50 chars. These must be at least that big for safety. */
7282 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7283 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7285 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7286 bnum
, astr1
, astr2
);
7288 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7291 /* Adjust a breakpoint's address to account for architectural
7292 constraints on breakpoint placement. Return the adjusted address.
7293 Note: Very few targets require this kind of adjustment. For most
7294 targets, this function is simply the identity function. */
7297 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7298 CORE_ADDR bpaddr
, enum bptype bptype
)
7300 if (!gdbarch_adjust_breakpoint_address_p (gdbarch
))
7302 /* Very few targets need any kind of breakpoint adjustment. */
7305 else if (bptype
== bp_watchpoint
7306 || bptype
== bp_hardware_watchpoint
7307 || bptype
== bp_read_watchpoint
7308 || bptype
== bp_access_watchpoint
7309 || bptype
== bp_catchpoint
)
7311 /* Watchpoints and the various bp_catch_* eventpoints should not
7312 have their addresses modified. */
7315 else if (bptype
== bp_single_step
)
7317 /* Single-step breakpoints should not have their addresses
7318 modified. If there's any architectural constrain that
7319 applies to this address, then it should have already been
7320 taken into account when the breakpoint was created in the
7321 first place. If we didn't do this, stepping through e.g.,
7322 Thumb-2 IT blocks would break. */
7327 CORE_ADDR adjusted_bpaddr
;
7329 /* Some targets have architectural constraints on the placement
7330 of breakpoint instructions. Obtain the adjusted address. */
7331 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7333 /* An adjusted breakpoint address can significantly alter
7334 a user's expectations. Print a warning if an adjustment
7336 if (adjusted_bpaddr
!= bpaddr
)
7337 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7339 return adjusted_bpaddr
;
7344 init_bp_location (struct bp_location
*loc
, const struct bp_location_ops
*ops
,
7345 struct breakpoint
*owner
)
7347 memset (loc
, 0, sizeof (*loc
));
7349 gdb_assert (ops
!= NULL
);
7354 loc
->cond_bytecode
= NULL
;
7355 loc
->shlib_disabled
= 0;
7358 switch (owner
->type
)
7361 case bp_single_step
:
7365 case bp_longjmp_resume
:
7366 case bp_longjmp_call_dummy
:
7368 case bp_exception_resume
:
7369 case bp_step_resume
:
7370 case bp_hp_step_resume
:
7371 case bp_watchpoint_scope
:
7373 case bp_std_terminate
:
7374 case bp_shlib_event
:
7375 case bp_thread_event
:
7376 case bp_overlay_event
:
7378 case bp_longjmp_master
:
7379 case bp_std_terminate_master
:
7380 case bp_exception_master
:
7381 case bp_gnu_ifunc_resolver
:
7382 case bp_gnu_ifunc_resolver_return
:
7384 loc
->loc_type
= bp_loc_software_breakpoint
;
7385 mark_breakpoint_location_modified (loc
);
7387 case bp_hardware_breakpoint
:
7388 loc
->loc_type
= bp_loc_hardware_breakpoint
;
7389 mark_breakpoint_location_modified (loc
);
7391 case bp_hardware_watchpoint
:
7392 case bp_read_watchpoint
:
7393 case bp_access_watchpoint
:
7394 loc
->loc_type
= bp_loc_hardware_watchpoint
;
7399 case bp_fast_tracepoint
:
7400 case bp_static_tracepoint
:
7401 loc
->loc_type
= bp_loc_other
;
7404 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7410 /* Allocate a struct bp_location. */
7412 static struct bp_location
*
7413 allocate_bp_location (struct breakpoint
*bpt
)
7415 return bpt
->ops
->allocate_location (bpt
);
7419 free_bp_location (struct bp_location
*loc
)
7421 loc
->ops
->dtor (loc
);
7425 /* Increment reference count. */
7428 incref_bp_location (struct bp_location
*bl
)
7433 /* Decrement reference count. If the reference count reaches 0,
7434 destroy the bp_location. Sets *BLP to NULL. */
7437 decref_bp_location (struct bp_location
**blp
)
7439 gdb_assert ((*blp
)->refc
> 0);
7441 if (--(*blp
)->refc
== 0)
7442 free_bp_location (*blp
);
7446 /* Add breakpoint B at the end of the global breakpoint chain. */
7449 add_to_breakpoint_chain (struct breakpoint
*b
)
7451 struct breakpoint
*b1
;
7453 /* Add this breakpoint to the end of the chain so that a list of
7454 breakpoints will come out in order of increasing numbers. */
7456 b1
= breakpoint_chain
;
7458 breakpoint_chain
= b
;
7467 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7470 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7471 struct gdbarch
*gdbarch
,
7473 const struct breakpoint_ops
*ops
)
7475 memset (b
, 0, sizeof (*b
));
7477 gdb_assert (ops
!= NULL
);
7481 b
->gdbarch
= gdbarch
;
7482 b
->language
= current_language
->la_language
;
7483 b
->input_radix
= input_radix
;
7485 b
->enable_state
= bp_enabled
;
7488 b
->ignore_count
= 0;
7490 b
->frame_id
= null_frame_id
;
7491 b
->condition_not_parsed
= 0;
7492 b
->py_bp_object
= NULL
;
7493 b
->related_breakpoint
= b
;
7497 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7498 that has type BPTYPE and has no locations as yet. */
7500 static struct breakpoint
*
7501 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7503 const struct breakpoint_ops
*ops
)
7505 struct breakpoint
*b
= XNEW (struct breakpoint
);
7507 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7508 add_to_breakpoint_chain (b
);
7512 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7513 resolutions should be made as the user specified the location explicitly
7517 set_breakpoint_location_function (struct bp_location
*loc
, int explicit_loc
)
7519 gdb_assert (loc
->owner
!= NULL
);
7521 if (loc
->owner
->type
== bp_breakpoint
7522 || loc
->owner
->type
== bp_hardware_breakpoint
7523 || is_tracepoint (loc
->owner
))
7526 const char *function_name
;
7527 CORE_ADDR func_addr
;
7529 find_pc_partial_function_gnu_ifunc (loc
->address
, &function_name
,
7530 &func_addr
, NULL
, &is_gnu_ifunc
);
7532 if (is_gnu_ifunc
&& !explicit_loc
)
7534 struct breakpoint
*b
= loc
->owner
;
7536 gdb_assert (loc
->pspace
== current_program_space
);
7537 if (gnu_ifunc_resolve_name (function_name
,
7538 &loc
->requested_address
))
7540 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7541 loc
->address
= adjust_breakpoint_address (loc
->gdbarch
,
7542 loc
->requested_address
,
7545 else if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7546 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7548 /* Create only the whole new breakpoint of this type but do not
7549 mess more complicated breakpoints with multiple locations. */
7550 b
->type
= bp_gnu_ifunc_resolver
;
7551 /* Remember the resolver's address for use by the return
7553 loc
->related_address
= func_addr
;
7558 loc
->function_name
= xstrdup (function_name
);
7562 /* Attempt to determine architecture of location identified by SAL. */
7564 get_sal_arch (struct symtab_and_line sal
)
7567 return get_objfile_arch (sal
.section
->objfile
);
7569 return get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
7574 /* Low level routine for partially initializing a breakpoint of type
7575 BPTYPE. The newly created breakpoint's address, section, source
7576 file name, and line number are provided by SAL.
7578 It is expected that the caller will complete the initialization of
7579 the newly created breakpoint struct as well as output any status
7580 information regarding the creation of a new breakpoint. */
7583 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7584 struct symtab_and_line sal
, enum bptype bptype
,
7585 const struct breakpoint_ops
*ops
)
7587 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7589 add_location_to_breakpoint (b
, &sal
);
7591 if (bptype
!= bp_catchpoint
)
7592 gdb_assert (sal
.pspace
!= NULL
);
7594 /* Store the program space that was used to set the breakpoint,
7595 except for ordinary breakpoints, which are independent of the
7597 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7598 b
->pspace
= sal
.pspace
;
7601 /* set_raw_breakpoint is a low level routine for allocating and
7602 partially initializing a breakpoint of type BPTYPE. The newly
7603 created breakpoint's address, section, source file name, and line
7604 number are provided by SAL. The newly created and partially
7605 initialized breakpoint is added to the breakpoint chain and
7606 is also returned as the value of this function.
7608 It is expected that the caller will complete the initialization of
7609 the newly created breakpoint struct as well as output any status
7610 information regarding the creation of a new breakpoint. In
7611 particular, set_raw_breakpoint does NOT set the breakpoint
7612 number! Care should be taken to not allow an error to occur
7613 prior to completing the initialization of the breakpoint. If this
7614 should happen, a bogus breakpoint will be left on the chain. */
7617 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7618 struct symtab_and_line sal
, enum bptype bptype
,
7619 const struct breakpoint_ops
*ops
)
7621 struct breakpoint
*b
= XNEW (struct breakpoint
);
7623 init_raw_breakpoint (b
, gdbarch
, sal
, bptype
, ops
);
7624 add_to_breakpoint_chain (b
);
7628 /* Call this routine when stepping and nexting to enable a breakpoint
7629 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7630 initiated the operation. */
7633 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7635 struct breakpoint
*b
, *b_tmp
;
7636 int thread
= tp
->global_num
;
7638 /* To avoid having to rescan all objfile symbols at every step,
7639 we maintain a list of continually-inserted but always disabled
7640 longjmp "master" breakpoints. Here, we simply create momentary
7641 clones of those and enable them for the requested thread. */
7642 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7643 if (b
->pspace
== current_program_space
7644 && (b
->type
== bp_longjmp_master
7645 || b
->type
== bp_exception_master
))
7647 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7648 struct breakpoint
*clone
;
7650 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7651 after their removal. */
7652 clone
= momentary_breakpoint_from_master (b
, type
,
7653 &longjmp_breakpoint_ops
, 1);
7654 clone
->thread
= thread
;
7657 tp
->initiating_frame
= frame
;
7660 /* Delete all longjmp breakpoints from THREAD. */
7662 delete_longjmp_breakpoint (int thread
)
7664 struct breakpoint
*b
, *b_tmp
;
7666 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7667 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7669 if (b
->thread
== thread
)
7670 delete_breakpoint (b
);
7675 delete_longjmp_breakpoint_at_next_stop (int thread
)
7677 struct breakpoint
*b
, *b_tmp
;
7679 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7680 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7682 if (b
->thread
== thread
)
7683 b
->disposition
= disp_del_at_next_stop
;
7687 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7688 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7689 pointer to any of them. Return NULL if this system cannot place longjmp
7693 set_longjmp_breakpoint_for_call_dummy (void)
7695 struct breakpoint
*b
, *retval
= NULL
;
7698 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7700 struct breakpoint
*new_b
;
7702 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7703 &momentary_breakpoint_ops
,
7705 new_b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
7707 /* Link NEW_B into the chain of RETVAL breakpoints. */
7709 gdb_assert (new_b
->related_breakpoint
== new_b
);
7712 new_b
->related_breakpoint
= retval
;
7713 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7714 retval
= retval
->related_breakpoint
;
7715 retval
->related_breakpoint
= new_b
;
7721 /* Verify all existing dummy frames and their associated breakpoints for
7722 TP. Remove those which can no longer be found in the current frame
7725 You should call this function only at places where it is safe to currently
7726 unwind the whole stack. Failed stack unwind would discard live dummy
7730 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7732 struct breakpoint
*b
, *b_tmp
;
7734 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7735 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7737 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7739 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7740 dummy_b
= dummy_b
->related_breakpoint
;
7741 if (dummy_b
->type
!= bp_call_dummy
7742 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7745 dummy_frame_discard (dummy_b
->frame_id
, tp
->ptid
);
7747 while (b
->related_breakpoint
!= b
)
7749 if (b_tmp
== b
->related_breakpoint
)
7750 b_tmp
= b
->related_breakpoint
->next
;
7751 delete_breakpoint (b
->related_breakpoint
);
7753 delete_breakpoint (b
);
7758 enable_overlay_breakpoints (void)
7760 struct breakpoint
*b
;
7763 if (b
->type
== bp_overlay_event
)
7765 b
->enable_state
= bp_enabled
;
7766 update_global_location_list (UGLL_MAY_INSERT
);
7767 overlay_events_enabled
= 1;
7772 disable_overlay_breakpoints (void)
7774 struct breakpoint
*b
;
7777 if (b
->type
== bp_overlay_event
)
7779 b
->enable_state
= bp_disabled
;
7780 update_global_location_list (UGLL_DONT_INSERT
);
7781 overlay_events_enabled
= 0;
7785 /* Set an active std::terminate breakpoint for each std::terminate
7786 master breakpoint. */
7788 set_std_terminate_breakpoint (void)
7790 struct breakpoint
*b
, *b_tmp
;
7792 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7793 if (b
->pspace
== current_program_space
7794 && b
->type
== bp_std_terminate_master
)
7796 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7797 &momentary_breakpoint_ops
, 1);
7801 /* Delete all the std::terminate breakpoints. */
7803 delete_std_terminate_breakpoint (void)
7805 struct breakpoint
*b
, *b_tmp
;
7807 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7808 if (b
->type
== bp_std_terminate
)
7809 delete_breakpoint (b
);
7813 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7815 struct breakpoint
*b
;
7817 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7818 &internal_breakpoint_ops
);
7820 b
->enable_state
= bp_enabled
;
7821 /* location has to be used or breakpoint_re_set will delete me. */
7822 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7824 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7829 struct lang_and_radix
7835 /* Create a breakpoint for JIT code registration and unregistration. */
7838 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7840 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7841 &internal_breakpoint_ops
);
7844 /* Remove JIT code registration and unregistration breakpoint(s). */
7847 remove_jit_event_breakpoints (void)
7849 struct breakpoint
*b
, *b_tmp
;
7851 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7852 if (b
->type
== bp_jit_event
7853 && b
->loc
->pspace
== current_program_space
)
7854 delete_breakpoint (b
);
7858 remove_solib_event_breakpoints (void)
7860 struct breakpoint
*b
, *b_tmp
;
7862 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7863 if (b
->type
== bp_shlib_event
7864 && b
->loc
->pspace
== current_program_space
)
7865 delete_breakpoint (b
);
7868 /* See breakpoint.h. */
7871 remove_solib_event_breakpoints_at_next_stop (void)
7873 struct breakpoint
*b
, *b_tmp
;
7875 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7876 if (b
->type
== bp_shlib_event
7877 && b
->loc
->pspace
== current_program_space
)
7878 b
->disposition
= disp_del_at_next_stop
;
7881 /* Helper for create_solib_event_breakpoint /
7882 create_and_insert_solib_event_breakpoint. Allows specifying which
7883 INSERT_MODE to pass through to update_global_location_list. */
7885 static struct breakpoint
*
7886 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7887 enum ugll_insert_mode insert_mode
)
7889 struct breakpoint
*b
;
7891 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7892 &internal_breakpoint_ops
);
7893 update_global_location_list_nothrow (insert_mode
);
7898 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7900 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7903 /* See breakpoint.h. */
7906 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7908 struct breakpoint
*b
;
7910 /* Explicitly tell update_global_location_list to insert
7912 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7913 if (!b
->loc
->inserted
)
7915 delete_breakpoint (b
);
7921 /* Disable any breakpoints that are on code in shared libraries. Only
7922 apply to enabled breakpoints, disabled ones can just stay disabled. */
7925 disable_breakpoints_in_shlibs (void)
7927 struct bp_location
*loc
, **locp_tmp
;
7929 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7931 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7932 struct breakpoint
*b
= loc
->owner
;
7934 /* We apply the check to all breakpoints, including disabled for
7935 those with loc->duplicate set. This is so that when breakpoint
7936 becomes enabled, or the duplicate is removed, gdb will try to
7937 insert all breakpoints. If we don't set shlib_disabled here,
7938 we'll try to insert those breakpoints and fail. */
7939 if (((b
->type
== bp_breakpoint
)
7940 || (b
->type
== bp_jit_event
)
7941 || (b
->type
== bp_hardware_breakpoint
)
7942 || (is_tracepoint (b
)))
7943 && loc
->pspace
== current_program_space
7944 && !loc
->shlib_disabled
7945 && solib_name_from_address (loc
->pspace
, loc
->address
)
7948 loc
->shlib_disabled
= 1;
7953 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7954 notification of unloaded_shlib. Only apply to enabled breakpoints,
7955 disabled ones can just stay disabled. */
7958 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7960 struct bp_location
*loc
, **locp_tmp
;
7961 int disabled_shlib_breaks
= 0;
7963 /* SunOS a.out shared libraries are always mapped, so do not
7964 disable breakpoints; they will only be reported as unloaded
7965 through clear_solib when GDB discards its shared library
7966 list. See clear_solib for more information. */
7967 if (exec_bfd
!= NULL
7968 && bfd_get_flavour (exec_bfd
) == bfd_target_aout_flavour
)
7971 ALL_BP_LOCATIONS (loc
, locp_tmp
)
7973 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7974 struct breakpoint
*b
= loc
->owner
;
7976 if (solib
->pspace
== loc
->pspace
7977 && !loc
->shlib_disabled
7978 && (((b
->type
== bp_breakpoint
7979 || b
->type
== bp_jit_event
7980 || b
->type
== bp_hardware_breakpoint
)
7981 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7982 || loc
->loc_type
== bp_loc_software_breakpoint
))
7983 || is_tracepoint (b
))
7984 && solib_contains_address_p (solib
, loc
->address
))
7986 loc
->shlib_disabled
= 1;
7987 /* At this point, we cannot rely on remove_breakpoint
7988 succeeding so we must mark the breakpoint as not inserted
7989 to prevent future errors occurring in remove_breakpoints. */
7992 /* This may cause duplicate notifications for the same breakpoint. */
7993 observer_notify_breakpoint_modified (b
);
7995 if (!disabled_shlib_breaks
)
7997 target_terminal_ours_for_output ();
7998 warning (_("Temporarily disabling breakpoints "
7999 "for unloaded shared library \"%s\""),
8002 disabled_shlib_breaks
= 1;
8007 /* Disable any breakpoints and tracepoints in OBJFILE upon
8008 notification of free_objfile. Only apply to enabled breakpoints,
8009 disabled ones can just stay disabled. */
8012 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
8014 struct breakpoint
*b
;
8016 if (objfile
== NULL
)
8019 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
8020 managed by the user with add-symbol-file/remove-symbol-file.
8021 Similarly to how breakpoints in shared libraries are handled in
8022 response to "nosharedlibrary", mark breakpoints in such modules
8023 shlib_disabled so they end up uninserted on the next global
8024 location list update. Shared libraries not loaded by the user
8025 aren't handled here -- they're already handled in
8026 disable_breakpoints_in_unloaded_shlib, called by solib.c's
8027 solib_unloaded observer. We skip objfiles that are not
8028 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
8030 if ((objfile
->flags
& OBJF_SHARED
) == 0
8031 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
8036 struct bp_location
*loc
;
8037 int bp_modified
= 0;
8039 if (!is_breakpoint (b
) && !is_tracepoint (b
))
8042 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
8044 CORE_ADDR loc_addr
= loc
->address
;
8046 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
8047 && loc
->loc_type
!= bp_loc_software_breakpoint
)
8050 if (loc
->shlib_disabled
!= 0)
8053 if (objfile
->pspace
!= loc
->pspace
)
8056 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
8057 && loc
->loc_type
!= bp_loc_software_breakpoint
)
8060 if (is_addr_in_objfile (loc_addr
, objfile
))
8062 loc
->shlib_disabled
= 1;
8063 /* At this point, we don't know whether the object was
8064 unmapped from the inferior or not, so leave the
8065 inserted flag alone. We'll handle failure to
8066 uninsert quietly, in case the object was indeed
8069 mark_breakpoint_location_modified (loc
);
8076 observer_notify_breakpoint_modified (b
);
8080 /* FORK & VFORK catchpoints. */
8082 /* An instance of this type is used to represent a fork or vfork
8083 catchpoint. It includes a "struct breakpoint" as a kind of base
8084 class; users downcast to "struct breakpoint *" when needed. A
8085 breakpoint is really of this type iff its ops pointer points to
8086 CATCH_FORK_BREAKPOINT_OPS. */
8088 struct fork_catchpoint
8090 /* The base class. */
8091 struct breakpoint base
;
8093 /* Process id of a child process whose forking triggered this
8094 catchpoint. This field is only valid immediately after this
8095 catchpoint has triggered. */
8096 ptid_t forked_inferior_pid
;
8099 /* Implement the "insert" breakpoint_ops method for fork
8103 insert_catch_fork (struct bp_location
*bl
)
8105 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid
));
8108 /* Implement the "remove" breakpoint_ops method for fork
8112 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
8114 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid
));
8117 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
8121 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
8122 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8123 const struct target_waitstatus
*ws
)
8125 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8127 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
8130 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8134 /* Implement the "print_it" breakpoint_ops method for fork
8137 static enum print_stop_action
8138 print_it_catch_fork (bpstat bs
)
8140 struct ui_out
*uiout
= current_uiout
;
8141 struct breakpoint
*b
= bs
->breakpoint_at
;
8142 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
8144 annotate_catchpoint (b
->number
);
8145 maybe_print_thread_hit_breakpoint (uiout
);
8146 if (b
->disposition
== disp_del
)
8147 ui_out_text (uiout
, "Temporary catchpoint ");
8149 ui_out_text (uiout
, "Catchpoint ");
8150 if (ui_out_is_mi_like_p (uiout
))
8152 ui_out_field_string (uiout
, "reason",
8153 async_reason_lookup (EXEC_ASYNC_FORK
));
8154 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8156 ui_out_field_int (uiout
, "bkptno", b
->number
);
8157 ui_out_text (uiout
, " (forked process ");
8158 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
8159 ui_out_text (uiout
, "), ");
8160 return PRINT_SRC_AND_LOC
;
8163 /* Implement the "print_one" breakpoint_ops method for fork
8167 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8169 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8170 struct value_print_options opts
;
8171 struct ui_out
*uiout
= current_uiout
;
8173 get_user_print_options (&opts
);
8175 /* Field 4, the address, is omitted (which makes the columns not
8176 line up too nicely with the headers, but the effect is relatively
8178 if (opts
.addressprint
)
8179 ui_out_field_skip (uiout
, "addr");
8181 ui_out_text (uiout
, "fork");
8182 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8184 ui_out_text (uiout
, ", process ");
8185 ui_out_field_int (uiout
, "what",
8186 ptid_get_pid (c
->forked_inferior_pid
));
8187 ui_out_spaces (uiout
, 1);
8190 if (ui_out_is_mi_like_p (uiout
))
8191 ui_out_field_string (uiout
, "catch-type", "fork");
8194 /* Implement the "print_mention" breakpoint_ops method for fork
8198 print_mention_catch_fork (struct breakpoint
*b
)
8200 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
8203 /* Implement the "print_recreate" breakpoint_ops method for fork
8207 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
8209 fprintf_unfiltered (fp
, "catch fork");
8210 print_recreate_thread (b
, fp
);
8213 /* The breakpoint_ops structure to be used in fork catchpoints. */
8215 static struct breakpoint_ops catch_fork_breakpoint_ops
;
8217 /* Implement the "insert" breakpoint_ops method for vfork
8221 insert_catch_vfork (struct bp_location
*bl
)
8223 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8226 /* Implement the "remove" breakpoint_ops method for vfork
8230 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
8232 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid
));
8235 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
8239 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
8240 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8241 const struct target_waitstatus
*ws
)
8243 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
8245 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
8248 c
->forked_inferior_pid
= ws
->value
.related_pid
;
8252 /* Implement the "print_it" breakpoint_ops method for vfork
8255 static enum print_stop_action
8256 print_it_catch_vfork (bpstat bs
)
8258 struct ui_out
*uiout
= current_uiout
;
8259 struct breakpoint
*b
= bs
->breakpoint_at
;
8260 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8262 annotate_catchpoint (b
->number
);
8263 maybe_print_thread_hit_breakpoint (uiout
);
8264 if (b
->disposition
== disp_del
)
8265 ui_out_text (uiout
, "Temporary catchpoint ");
8267 ui_out_text (uiout
, "Catchpoint ");
8268 if (ui_out_is_mi_like_p (uiout
))
8270 ui_out_field_string (uiout
, "reason",
8271 async_reason_lookup (EXEC_ASYNC_VFORK
));
8272 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8274 ui_out_field_int (uiout
, "bkptno", b
->number
);
8275 ui_out_text (uiout
, " (vforked process ");
8276 ui_out_field_int (uiout
, "newpid", ptid_get_pid (c
->forked_inferior_pid
));
8277 ui_out_text (uiout
, "), ");
8278 return PRINT_SRC_AND_LOC
;
8281 /* Implement the "print_one" breakpoint_ops method for vfork
8285 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
8287 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
8288 struct value_print_options opts
;
8289 struct ui_out
*uiout
= current_uiout
;
8291 get_user_print_options (&opts
);
8292 /* Field 4, the address, is omitted (which makes the columns not
8293 line up too nicely with the headers, but the effect is relatively
8295 if (opts
.addressprint
)
8296 ui_out_field_skip (uiout
, "addr");
8298 ui_out_text (uiout
, "vfork");
8299 if (!ptid_equal (c
->forked_inferior_pid
, null_ptid
))
8301 ui_out_text (uiout
, ", process ");
8302 ui_out_field_int (uiout
, "what",
8303 ptid_get_pid (c
->forked_inferior_pid
));
8304 ui_out_spaces (uiout
, 1);
8307 if (ui_out_is_mi_like_p (uiout
))
8308 ui_out_field_string (uiout
, "catch-type", "vfork");
8311 /* Implement the "print_mention" breakpoint_ops method for vfork
8315 print_mention_catch_vfork (struct breakpoint
*b
)
8317 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
8320 /* Implement the "print_recreate" breakpoint_ops method for vfork
8324 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
8326 fprintf_unfiltered (fp
, "catch vfork");
8327 print_recreate_thread (b
, fp
);
8330 /* The breakpoint_ops structure to be used in vfork catchpoints. */
8332 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
8334 /* An instance of this type is used to represent an solib catchpoint.
8335 It includes a "struct breakpoint" as a kind of base class; users
8336 downcast to "struct breakpoint *" when needed. A breakpoint is
8337 really of this type iff its ops pointer points to
8338 CATCH_SOLIB_BREAKPOINT_OPS. */
8340 struct solib_catchpoint
8342 /* The base class. */
8343 struct breakpoint base
;
8345 /* True for "catch load", false for "catch unload". */
8346 unsigned char is_load
;
8348 /* Regular expression to match, if any. COMPILED is only valid when
8349 REGEX is non-NULL. */
8355 dtor_catch_solib (struct breakpoint
*b
)
8357 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8360 regfree (&self
->compiled
);
8361 xfree (self
->regex
);
8363 base_breakpoint_ops
.dtor (b
);
8367 insert_catch_solib (struct bp_location
*ignore
)
8373 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8379 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8380 struct address_space
*aspace
,
8382 const struct target_waitstatus
*ws
)
8384 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8385 struct breakpoint
*other
;
8387 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8390 ALL_BREAKPOINTS (other
)
8392 struct bp_location
*other_bl
;
8394 if (other
== bl
->owner
)
8397 if (other
->type
!= bp_shlib_event
)
8400 if (self
->base
.pspace
!= NULL
&& other
->pspace
!= self
->base
.pspace
)
8403 for (other_bl
= other
->loc
; other_bl
!= NULL
; other_bl
= other_bl
->next
)
8405 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8414 check_status_catch_solib (struct bpstats
*bs
)
8416 struct solib_catchpoint
*self
8417 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8422 struct so_list
*iter
;
8425 VEC_iterate (so_list_ptr
, current_program_space
->added_solibs
,
8430 || regexec (&self
->compiled
, iter
->so_name
, 0, NULL
, 0) == 0)
8439 VEC_iterate (char_ptr
, current_program_space
->deleted_solibs
,
8444 || regexec (&self
->compiled
, iter
, 0, NULL
, 0) == 0)
8450 bs
->print_it
= print_it_noop
;
8453 static enum print_stop_action
8454 print_it_catch_solib (bpstat bs
)
8456 struct breakpoint
*b
= bs
->breakpoint_at
;
8457 struct ui_out
*uiout
= current_uiout
;
8459 annotate_catchpoint (b
->number
);
8460 maybe_print_thread_hit_breakpoint (uiout
);
8461 if (b
->disposition
== disp_del
)
8462 ui_out_text (uiout
, "Temporary catchpoint ");
8464 ui_out_text (uiout
, "Catchpoint ");
8465 ui_out_field_int (uiout
, "bkptno", b
->number
);
8466 ui_out_text (uiout
, "\n");
8467 if (ui_out_is_mi_like_p (uiout
))
8468 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8469 print_solib_event (1);
8470 return PRINT_SRC_AND_LOC
;
8474 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8476 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8477 struct value_print_options opts
;
8478 struct ui_out
*uiout
= current_uiout
;
8481 get_user_print_options (&opts
);
8482 /* Field 4, the address, is omitted (which makes the columns not
8483 line up too nicely with the headers, but the effect is relatively
8485 if (opts
.addressprint
)
8488 ui_out_field_skip (uiout
, "addr");
8495 msg
= xstrprintf (_("load of library matching %s"), self
->regex
);
8497 msg
= xstrdup (_("load of library"));
8502 msg
= xstrprintf (_("unload of library matching %s"), self
->regex
);
8504 msg
= xstrdup (_("unload of library"));
8506 ui_out_field_string (uiout
, "what", msg
);
8509 if (ui_out_is_mi_like_p (uiout
))
8510 ui_out_field_string (uiout
, "catch-type",
8511 self
->is_load
? "load" : "unload");
8515 print_mention_catch_solib (struct breakpoint
*b
)
8517 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8519 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8520 self
->is_load
? "load" : "unload");
8524 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8526 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8528 fprintf_unfiltered (fp
, "%s %s",
8529 b
->disposition
== disp_del
? "tcatch" : "catch",
8530 self
->is_load
? "load" : "unload");
8532 fprintf_unfiltered (fp
, " %s", self
->regex
);
8533 fprintf_unfiltered (fp
, "\n");
8536 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8538 /* Shared helper function (MI and CLI) for creating and installing
8539 a shared object event catchpoint. If IS_LOAD is non-zero then
8540 the events to be caught are load events, otherwise they are
8541 unload events. If IS_TEMP is non-zero the catchpoint is a
8542 temporary one. If ENABLED is non-zero the catchpoint is
8543 created in an enabled state. */
8546 add_solib_catchpoint (char *arg
, int is_load
, int is_temp
, int enabled
)
8548 struct solib_catchpoint
*c
;
8549 struct gdbarch
*gdbarch
= get_current_arch ();
8550 struct cleanup
*cleanup
;
8554 arg
= skip_spaces (arg
);
8556 c
= XCNEW (struct solib_catchpoint
);
8557 cleanup
= make_cleanup (xfree
, c
);
8563 errcode
= regcomp (&c
->compiled
, arg
, REG_NOSUB
);
8566 char *err
= get_regcomp_error (errcode
, &c
->compiled
);
8568 make_cleanup (xfree
, err
);
8569 error (_("Invalid regexp (%s): %s"), err
, arg
);
8571 c
->regex
= xstrdup (arg
);
8574 c
->is_load
= is_load
;
8575 init_catchpoint (&c
->base
, gdbarch
, is_temp
, NULL
,
8576 &catch_solib_breakpoint_ops
);
8578 c
->base
.enable_state
= enabled
? bp_enabled
: bp_disabled
;
8580 discard_cleanups (cleanup
);
8581 install_breakpoint (0, &c
->base
, 1);
8584 /* A helper function that does all the work for "catch load" and
8588 catch_load_or_unload (char *arg
, int from_tty
, int is_load
,
8589 struct cmd_list_element
*command
)
8592 const int enabled
= 1;
8594 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8596 add_solib_catchpoint (arg
, is_load
, tempflag
, enabled
);
8600 catch_load_command_1 (char *arg
, int from_tty
,
8601 struct cmd_list_element
*command
)
8603 catch_load_or_unload (arg
, from_tty
, 1, command
);
8607 catch_unload_command_1 (char *arg
, int from_tty
,
8608 struct cmd_list_element
*command
)
8610 catch_load_or_unload (arg
, from_tty
, 0, command
);
8613 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8614 is non-zero, then make the breakpoint temporary. If COND_STRING is
8615 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8616 the breakpoint_ops structure associated to the catchpoint. */
8619 init_catchpoint (struct breakpoint
*b
,
8620 struct gdbarch
*gdbarch
, int tempflag
,
8622 const struct breakpoint_ops
*ops
)
8624 struct symtab_and_line sal
;
8627 sal
.pspace
= current_program_space
;
8629 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8631 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8632 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
8636 install_breakpoint (int internal
, struct breakpoint
*b
, int update_gll
)
8638 add_to_breakpoint_chain (b
);
8639 set_breakpoint_number (internal
, b
);
8640 if (is_tracepoint (b
))
8641 set_tracepoint_count (breakpoint_count
);
8644 observer_notify_breakpoint_created (b
);
8647 update_global_location_list (UGLL_MAY_INSERT
);
8651 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8652 int tempflag
, char *cond_string
,
8653 const struct breakpoint_ops
*ops
)
8655 struct fork_catchpoint
*c
= XNEW (struct fork_catchpoint
);
8657 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
, ops
);
8659 c
->forked_inferior_pid
= null_ptid
;
8661 install_breakpoint (0, &c
->base
, 1);
8664 /* Exec catchpoints. */
8666 /* An instance of this type is used to represent an exec catchpoint.
8667 It includes a "struct breakpoint" as a kind of base class; users
8668 downcast to "struct breakpoint *" when needed. A breakpoint is
8669 really of this type iff its ops pointer points to
8670 CATCH_EXEC_BREAKPOINT_OPS. */
8672 struct exec_catchpoint
8674 /* The base class. */
8675 struct breakpoint base
;
8677 /* Filename of a program whose exec triggered this catchpoint.
8678 This field is only valid immediately after this catchpoint has
8680 char *exec_pathname
;
8683 /* Implement the "dtor" breakpoint_ops method for exec
8687 dtor_catch_exec (struct breakpoint
*b
)
8689 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8691 xfree (c
->exec_pathname
);
8693 base_breakpoint_ops
.dtor (b
);
8697 insert_catch_exec (struct bp_location
*bl
)
8699 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8703 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8705 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid
));
8709 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8710 struct address_space
*aspace
, CORE_ADDR bp_addr
,
8711 const struct target_waitstatus
*ws
)
8713 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8715 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8718 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8722 static enum print_stop_action
8723 print_it_catch_exec (bpstat bs
)
8725 struct ui_out
*uiout
= current_uiout
;
8726 struct breakpoint
*b
= bs
->breakpoint_at
;
8727 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8729 annotate_catchpoint (b
->number
);
8730 maybe_print_thread_hit_breakpoint (uiout
);
8731 if (b
->disposition
== disp_del
)
8732 ui_out_text (uiout
, "Temporary catchpoint ");
8734 ui_out_text (uiout
, "Catchpoint ");
8735 if (ui_out_is_mi_like_p (uiout
))
8737 ui_out_field_string (uiout
, "reason",
8738 async_reason_lookup (EXEC_ASYNC_EXEC
));
8739 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
8741 ui_out_field_int (uiout
, "bkptno", b
->number
);
8742 ui_out_text (uiout
, " (exec'd ");
8743 ui_out_field_string (uiout
, "new-exec", c
->exec_pathname
);
8744 ui_out_text (uiout
, "), ");
8746 return PRINT_SRC_AND_LOC
;
8750 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8752 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8753 struct value_print_options opts
;
8754 struct ui_out
*uiout
= current_uiout
;
8756 get_user_print_options (&opts
);
8758 /* Field 4, the address, is omitted (which makes the columns
8759 not line up too nicely with the headers, but the effect
8760 is relatively readable). */
8761 if (opts
.addressprint
)
8762 ui_out_field_skip (uiout
, "addr");
8764 ui_out_text (uiout
, "exec");
8765 if (c
->exec_pathname
!= NULL
)
8767 ui_out_text (uiout
, ", program \"");
8768 ui_out_field_string (uiout
, "what", c
->exec_pathname
);
8769 ui_out_text (uiout
, "\" ");
8772 if (ui_out_is_mi_like_p (uiout
))
8773 ui_out_field_string (uiout
, "catch-type", "exec");
8777 print_mention_catch_exec (struct breakpoint
*b
)
8779 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8782 /* Implement the "print_recreate" breakpoint_ops method for exec
8786 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8788 fprintf_unfiltered (fp
, "catch exec");
8789 print_recreate_thread (b
, fp
);
8792 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8795 hw_breakpoint_used_count (void)
8798 struct breakpoint
*b
;
8799 struct bp_location
*bl
;
8803 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8804 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8806 /* Special types of hardware breakpoints may use more than
8808 i
+= b
->ops
->resources_needed (bl
);
8815 /* Returns the resources B would use if it were a hardware
8819 hw_watchpoint_use_count (struct breakpoint
*b
)
8822 struct bp_location
*bl
;
8824 if (!breakpoint_enabled (b
))
8827 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
8829 /* Special types of hardware watchpoints may use more than
8831 i
+= b
->ops
->resources_needed (bl
);
8837 /* Returns the sum the used resources of all hardware watchpoints of
8838 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8839 the sum of the used resources of all hardware watchpoints of other
8840 types _not_ TYPE. */
8843 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8844 enum bptype type
, int *other_type_used
)
8847 struct breakpoint
*b
;
8849 *other_type_used
= 0;
8854 if (!breakpoint_enabled (b
))
8857 if (b
->type
== type
)
8858 i
+= hw_watchpoint_use_count (b
);
8859 else if (is_hardware_watchpoint (b
))
8860 *other_type_used
= 1;
8867 disable_watchpoints_before_interactive_call_start (void)
8869 struct breakpoint
*b
;
8873 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8875 b
->enable_state
= bp_call_disabled
;
8876 update_global_location_list (UGLL_DONT_INSERT
);
8882 enable_watchpoints_after_interactive_call_stop (void)
8884 struct breakpoint
*b
;
8888 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8890 b
->enable_state
= bp_enabled
;
8891 update_global_location_list (UGLL_MAY_INSERT
);
8897 disable_breakpoints_before_startup (void)
8899 current_program_space
->executing_startup
= 1;
8900 update_global_location_list (UGLL_DONT_INSERT
);
8904 enable_breakpoints_after_startup (void)
8906 current_program_space
->executing_startup
= 0;
8907 breakpoint_re_set ();
8910 /* Create a new single-step breakpoint for thread THREAD, with no
8913 static struct breakpoint
*
8914 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8916 struct breakpoint
*b
= XNEW (struct breakpoint
);
8918 init_raw_breakpoint_without_location (b
, gdbarch
, bp_single_step
,
8919 &momentary_breakpoint_ops
);
8921 b
->disposition
= disp_donttouch
;
8922 b
->frame_id
= null_frame_id
;
8925 gdb_assert (b
->thread
!= 0);
8927 add_to_breakpoint_chain (b
);
8932 /* Set a momentary breakpoint of type TYPE at address specified by
8933 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8937 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8938 struct frame_id frame_id
, enum bptype type
)
8940 struct breakpoint
*b
;
8942 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8944 gdb_assert (!frame_id_artificial_p (frame_id
));
8946 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8947 b
->enable_state
= bp_enabled
;
8948 b
->disposition
= disp_donttouch
;
8949 b
->frame_id
= frame_id
;
8951 /* If we're debugging a multi-threaded program, then we want
8952 momentary breakpoints to be active in only a single thread of
8954 if (in_thread_list (inferior_ptid
))
8955 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
8957 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8962 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8963 The new breakpoint will have type TYPE, use OPS as its
8964 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8966 static struct breakpoint
*
8967 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8969 const struct breakpoint_ops
*ops
,
8972 struct breakpoint
*copy
;
8974 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8975 copy
->loc
= allocate_bp_location (copy
);
8976 set_breakpoint_location_function (copy
->loc
, 1);
8978 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8979 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8980 copy
->loc
->address
= orig
->loc
->address
;
8981 copy
->loc
->section
= orig
->loc
->section
;
8982 copy
->loc
->pspace
= orig
->loc
->pspace
;
8983 copy
->loc
->probe
= orig
->loc
->probe
;
8984 copy
->loc
->line_number
= orig
->loc
->line_number
;
8985 copy
->loc
->symtab
= orig
->loc
->symtab
;
8986 copy
->loc
->enabled
= loc_enabled
;
8987 copy
->frame_id
= orig
->frame_id
;
8988 copy
->thread
= orig
->thread
;
8989 copy
->pspace
= orig
->pspace
;
8991 copy
->enable_state
= bp_enabled
;
8992 copy
->disposition
= disp_donttouch
;
8993 copy
->number
= internal_breakpoint_number
--;
8995 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8999 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
9003 clone_momentary_breakpoint (struct breakpoint
*orig
)
9005 /* If there's nothing to clone, then return nothing. */
9009 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
9013 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
9016 struct symtab_and_line sal
;
9018 sal
= find_pc_line (pc
, 0);
9020 sal
.section
= find_pc_overlay (pc
);
9021 sal
.explicit_pc
= 1;
9023 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
9027 /* Tell the user we have just set a breakpoint B. */
9030 mention (struct breakpoint
*b
)
9032 b
->ops
->print_mention (b
);
9033 if (ui_out_is_mi_like_p (current_uiout
))
9035 printf_filtered ("\n");
9039 static int bp_loc_is_permanent (struct bp_location
*loc
);
9041 static struct bp_location
*
9042 add_location_to_breakpoint (struct breakpoint
*b
,
9043 const struct symtab_and_line
*sal
)
9045 struct bp_location
*loc
, **tmp
;
9046 CORE_ADDR adjusted_address
;
9047 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
9049 if (loc_gdbarch
== NULL
)
9050 loc_gdbarch
= b
->gdbarch
;
9052 /* Adjust the breakpoint's address prior to allocating a location.
9053 Once we call allocate_bp_location(), that mostly uninitialized
9054 location will be placed on the location chain. Adjustment of the
9055 breakpoint may cause target_read_memory() to be called and we do
9056 not want its scan of the location chain to find a breakpoint and
9057 location that's only been partially initialized. */
9058 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
9061 /* Sort the locations by their ADDRESS. */
9062 loc
= allocate_bp_location (b
);
9063 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
9064 tmp
= &((*tmp
)->next
))
9069 loc
->requested_address
= sal
->pc
;
9070 loc
->address
= adjusted_address
;
9071 loc
->pspace
= sal
->pspace
;
9072 loc
->probe
.probe
= sal
->probe
;
9073 loc
->probe
.objfile
= sal
->objfile
;
9074 gdb_assert (loc
->pspace
!= NULL
);
9075 loc
->section
= sal
->section
;
9076 loc
->gdbarch
= loc_gdbarch
;
9077 loc
->line_number
= sal
->line
;
9078 loc
->symtab
= sal
->symtab
;
9080 set_breakpoint_location_function (loc
,
9081 sal
->explicit_pc
|| sal
->explicit_line
);
9083 /* While by definition, permanent breakpoints are already present in the
9084 code, we don't mark the location as inserted. Normally one would expect
9085 that GDB could rely on that breakpoint instruction to stop the program,
9086 thus removing the need to insert its own breakpoint, except that executing
9087 the breakpoint instruction can kill the target instead of reporting a
9088 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
9089 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
9090 with "Trap 0x02 while interrupts disabled, Error state". Letting the
9091 breakpoint be inserted normally results in QEMU knowing about the GDB
9092 breakpoint, and thus trap before the breakpoint instruction is executed.
9093 (If GDB later needs to continue execution past the permanent breakpoint,
9094 it manually increments the PC, thus avoiding executing the breakpoint
9096 if (bp_loc_is_permanent (loc
))
9103 /* See breakpoint.h. */
9106 program_breakpoint_here_p (struct gdbarch
*gdbarch
, CORE_ADDR address
)
9110 const gdb_byte
*bpoint
;
9111 gdb_byte
*target_mem
;
9112 struct cleanup
*cleanup
;
9116 bpoint
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
9118 /* Software breakpoints unsupported? */
9122 target_mem
= (gdb_byte
*) alloca (len
);
9124 /* Enable the automatic memory restoration from breakpoints while
9125 we read the memory. Otherwise we could say about our temporary
9126 breakpoints they are permanent. */
9127 cleanup
= make_show_memory_breakpoints_cleanup (0);
9129 if (target_read_memory (address
, target_mem
, len
) == 0
9130 && memcmp (target_mem
, bpoint
, len
) == 0)
9133 do_cleanups (cleanup
);
9138 /* Return 1 if LOC is pointing to a permanent breakpoint,
9139 return 0 otherwise. */
9142 bp_loc_is_permanent (struct bp_location
*loc
)
9144 struct cleanup
*cleanup
;
9147 gdb_assert (loc
!= NULL
);
9149 /* If we have a catchpoint or a watchpoint, just return 0. We should not
9150 attempt to read from the addresses the locations of these breakpoint types
9151 point to. program_breakpoint_here_p, below, will attempt to read
9153 if (!breakpoint_address_is_meaningful (loc
->owner
))
9156 cleanup
= save_current_space_and_thread ();
9157 switch_to_program_space_and_thread (loc
->pspace
);
9159 retval
= program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
9161 do_cleanups (cleanup
);
9166 /* Build a command list for the dprintf corresponding to the current
9167 settings of the dprintf style options. */
9170 update_dprintf_command_list (struct breakpoint
*b
)
9172 char *dprintf_args
= b
->extra_string
;
9173 char *printf_line
= NULL
;
9178 dprintf_args
= skip_spaces (dprintf_args
);
9180 /* Allow a comma, as it may have terminated a location, but don't
9182 if (*dprintf_args
== ',')
9184 dprintf_args
= skip_spaces (dprintf_args
);
9186 if (*dprintf_args
!= '"')
9187 error (_("Bad format string, missing '\"'."));
9189 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
9190 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9191 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
9193 if (!dprintf_function
)
9194 error (_("No function supplied for dprintf call"));
9196 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
9197 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
9202 printf_line
= xstrprintf ("call (void) %s (%s)",
9206 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
9208 if (target_can_run_breakpoint_commands ())
9209 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
9212 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
9213 printf_line
= xstrprintf ("printf %s", dprintf_args
);
9217 internal_error (__FILE__
, __LINE__
,
9218 _("Invalid dprintf style."));
9220 gdb_assert (printf_line
!= NULL
);
9221 /* Manufacture a printf sequence. */
9223 struct command_line
*printf_cmd_line
= XNEW (struct command_line
);
9225 printf_cmd_line
->control_type
= simple_control
;
9226 printf_cmd_line
->body_count
= 0;
9227 printf_cmd_line
->body_list
= NULL
;
9228 printf_cmd_line
->next
= NULL
;
9229 printf_cmd_line
->line
= printf_line
;
9231 breakpoint_set_commands (b
, printf_cmd_line
);
9235 /* Update all dprintf commands, making their command lists reflect
9236 current style settings. */
9239 update_dprintf_commands (char *args
, int from_tty
,
9240 struct cmd_list_element
*c
)
9242 struct breakpoint
*b
;
9246 if (b
->type
== bp_dprintf
)
9247 update_dprintf_command_list (b
);
9251 /* Create a breakpoint with SAL as location. Use LOCATION
9252 as a description of the location, and COND_STRING
9253 as condition expression. If LOCATION is NULL then create an
9254 "address location" from the address in the SAL. */
9257 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
9258 struct symtabs_and_lines sals
,
9259 struct event_location
*location
,
9260 char *filter
, char *cond_string
,
9262 enum bptype type
, enum bpdisp disposition
,
9263 int thread
, int task
, int ignore_count
,
9264 const struct breakpoint_ops
*ops
, int from_tty
,
9265 int enabled
, int internal
, unsigned flags
,
9266 int display_canonical
)
9270 if (type
== bp_hardware_breakpoint
)
9272 int target_resources_ok
;
9274 i
= hw_breakpoint_used_count ();
9275 target_resources_ok
=
9276 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9278 if (target_resources_ok
== 0)
9279 error (_("No hardware breakpoint support in the target."));
9280 else if (target_resources_ok
< 0)
9281 error (_("Hardware breakpoints used exceeds limit."));
9284 gdb_assert (sals
.nelts
> 0);
9286 for (i
= 0; i
< sals
.nelts
; ++i
)
9288 struct symtab_and_line sal
= sals
.sals
[i
];
9289 struct bp_location
*loc
;
9293 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
9295 loc_gdbarch
= gdbarch
;
9297 describe_other_breakpoints (loc_gdbarch
,
9298 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
9303 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
9307 b
->cond_string
= cond_string
;
9308 b
->extra_string
= extra_string
;
9309 b
->ignore_count
= ignore_count
;
9310 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9311 b
->disposition
= disposition
;
9313 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9314 b
->loc
->inserted
= 1;
9316 if (type
== bp_static_tracepoint
)
9318 struct tracepoint
*t
= (struct tracepoint
*) b
;
9319 struct static_tracepoint_marker marker
;
9321 if (strace_marker_p (b
))
9323 /* We already know the marker exists, otherwise, we
9324 wouldn't see a sal for it. */
9325 const char *p
= &event_location_to_string (b
->location
)[3];
9329 p
= skip_spaces_const (p
);
9331 endp
= skip_to_space_const (p
);
9333 marker_str
= savestring (p
, endp
- p
);
9334 t
->static_trace_marker_id
= marker_str
;
9336 printf_filtered (_("Probed static tracepoint "
9338 t
->static_trace_marker_id
);
9340 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
9342 t
->static_trace_marker_id
= xstrdup (marker
.str_id
);
9343 release_static_tracepoint_marker (&marker
);
9345 printf_filtered (_("Probed static tracepoint "
9347 t
->static_trace_marker_id
);
9350 warning (_("Couldn't determine the static "
9351 "tracepoint marker to probe"));
9358 loc
= add_location_to_breakpoint (b
, &sal
);
9359 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
9365 const char *arg
= b
->cond_string
;
9367 loc
->cond
= parse_exp_1 (&arg
, loc
->address
,
9368 block_for_pc (loc
->address
), 0);
9370 error (_("Garbage '%s' follows condition"), arg
);
9373 /* Dynamic printf requires and uses additional arguments on the
9374 command line, otherwise it's an error. */
9375 if (type
== bp_dprintf
)
9377 if (b
->extra_string
)
9378 update_dprintf_command_list (b
);
9380 error (_("Format string required"));
9382 else if (b
->extra_string
)
9383 error (_("Garbage '%s' at end of command"), b
->extra_string
);
9386 b
->display_canonical
= display_canonical
;
9387 if (location
!= NULL
)
9388 b
->location
= location
;
9391 const char *addr_string
= NULL
;
9392 int addr_string_len
= 0;
9394 if (location
!= NULL
)
9395 addr_string
= event_location_to_string (location
);
9396 if (addr_string
!= NULL
)
9397 addr_string_len
= strlen (addr_string
);
9399 b
->location
= new_address_location (b
->loc
->address
,
9400 addr_string
, addr_string_len
);
9406 create_breakpoint_sal (struct gdbarch
*gdbarch
,
9407 struct symtabs_and_lines sals
,
9408 struct event_location
*location
,
9409 char *filter
, char *cond_string
,
9411 enum bptype type
, enum bpdisp disposition
,
9412 int thread
, int task
, int ignore_count
,
9413 const struct breakpoint_ops
*ops
, int from_tty
,
9414 int enabled
, int internal
, unsigned flags
,
9415 int display_canonical
)
9417 struct breakpoint
*b
;
9418 struct cleanup
*old_chain
;
9420 if (is_tracepoint_type (type
))
9422 struct tracepoint
*t
;
9424 t
= XCNEW (struct tracepoint
);
9428 b
= XNEW (struct breakpoint
);
9430 old_chain
= make_cleanup (xfree
, b
);
9432 init_breakpoint_sal (b
, gdbarch
,
9434 filter
, cond_string
, extra_string
,
9436 thread
, task
, ignore_count
,
9438 enabled
, internal
, flags
,
9440 discard_cleanups (old_chain
);
9442 install_breakpoint (internal
, b
, 0);
9445 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9446 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9447 value. COND_STRING, if not NULL, specified the condition to be
9448 used for all breakpoints. Essentially the only case where
9449 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9450 function. In that case, it's still not possible to specify
9451 separate conditions for different overloaded functions, so
9452 we take just a single condition string.
9454 NOTE: If the function succeeds, the caller is expected to cleanup
9455 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9456 array contents). If the function fails (error() is called), the
9457 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9458 COND and SALS arrays and each of those arrays contents. */
9461 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9462 struct linespec_result
*canonical
,
9463 char *cond_string
, char *extra_string
,
9464 enum bptype type
, enum bpdisp disposition
,
9465 int thread
, int task
, int ignore_count
,
9466 const struct breakpoint_ops
*ops
, int from_tty
,
9467 int enabled
, int internal
, unsigned flags
)
9470 struct linespec_sals
*lsal
;
9472 if (canonical
->pre_expanded
)
9473 gdb_assert (VEC_length (linespec_sals
, canonical
->sals
) == 1);
9475 for (i
= 0; VEC_iterate (linespec_sals
, canonical
->sals
, i
, lsal
); ++i
)
9477 /* Note that 'location' can be NULL in the case of a plain
9478 'break', without arguments. */
9479 struct event_location
*location
9480 = (canonical
->location
!= NULL
9481 ? copy_event_location (canonical
->location
) : NULL
);
9482 char *filter_string
= lsal
->canonical
? xstrdup (lsal
->canonical
) : NULL
;
9483 struct cleanup
*inner
= make_cleanup_delete_event_location (location
);
9485 make_cleanup (xfree
, filter_string
);
9486 create_breakpoint_sal (gdbarch
, lsal
->sals
,
9489 cond_string
, extra_string
,
9491 thread
, task
, ignore_count
, ops
,
9492 from_tty
, enabled
, internal
, flags
,
9493 canonical
->special_display
);
9494 discard_cleanups (inner
);
9498 /* Parse LOCATION which is assumed to be a SAL specification possibly
9499 followed by conditionals. On return, SALS contains an array of SAL
9500 addresses found. LOCATION points to the end of the SAL (for
9501 linespec locations).
9503 The array and the line spec strings are allocated on the heap, it is
9504 the caller's responsibility to free them. */
9507 parse_breakpoint_sals (const struct event_location
*location
,
9508 struct linespec_result
*canonical
)
9510 struct symtab_and_line cursal
;
9512 if (event_location_type (location
) == LINESPEC_LOCATION
)
9514 const char *address
= get_linespec_location (location
);
9516 if (address
== NULL
)
9518 /* The last displayed codepoint, if it's valid, is our default
9519 breakpoint address. */
9520 if (last_displayed_sal_is_valid ())
9522 struct linespec_sals lsal
;
9523 struct symtab_and_line sal
;
9526 init_sal (&sal
); /* Initialize to zeroes. */
9527 lsal
.sals
.sals
= XNEW (struct symtab_and_line
);
9529 /* Set sal's pspace, pc, symtab, and line to the values
9530 corresponding to the last call to print_frame_info.
9531 Be sure to reinitialize LINE with NOTCURRENT == 0
9532 as the breakpoint line number is inappropriate otherwise.
9533 find_pc_line would adjust PC, re-set it back. */
9534 get_last_displayed_sal (&sal
);
9536 sal
= find_pc_line (pc
, 0);
9538 /* "break" without arguments is equivalent to "break *PC"
9539 where PC is the last displayed codepoint's address. So
9540 make sure to set sal.explicit_pc to prevent GDB from
9541 trying to expand the list of sals to include all other
9542 instances with the same symtab and line. */
9544 sal
.explicit_pc
= 1;
9546 lsal
.sals
.sals
[0] = sal
;
9547 lsal
.sals
.nelts
= 1;
9548 lsal
.canonical
= NULL
;
9550 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
9554 error (_("No default breakpoint address now."));
9558 /* Force almost all breakpoints to be in terms of the
9559 current_source_symtab (which is decode_line_1's default).
9560 This should produce the results we want almost all of the
9561 time while leaving default_breakpoint_* alone.
9563 ObjC: However, don't match an Objective-C method name which
9564 may have a '+' or '-' succeeded by a '['. */
9565 cursal
= get_current_source_symtab_and_line ();
9566 if (last_displayed_sal_is_valid ())
9568 const char *address
= NULL
;
9570 if (event_location_type (location
) == LINESPEC_LOCATION
)
9571 address
= get_linespec_location (location
);
9575 && strchr ("+-", address
[0]) != NULL
9576 && address
[1] != '['))
9578 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9579 get_last_displayed_symtab (),
9580 get_last_displayed_line (),
9581 canonical
, NULL
, NULL
);
9586 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9587 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9591 /* Convert each SAL into a real PC. Verify that the PC can be
9592 inserted as a breakpoint. If it can't throw an error. */
9595 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
)
9599 for (i
= 0; i
< sals
->nelts
; i
++)
9600 resolve_sal_pc (&sals
->sals
[i
]);
9603 /* Fast tracepoints may have restrictions on valid locations. For
9604 instance, a fast tracepoint using a jump instead of a trap will
9605 likely have to overwrite more bytes than a trap would, and so can
9606 only be placed where the instruction is longer than the jump, or a
9607 multi-instruction sequence does not have a jump into the middle of
9611 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9612 struct symtabs_and_lines
*sals
)
9615 struct symtab_and_line
*sal
;
9617 struct cleanup
*old_chain
;
9619 for (i
= 0; i
< sals
->nelts
; i
++)
9621 struct gdbarch
*sarch
;
9623 sal
= &sals
->sals
[i
];
9625 sarch
= get_sal_arch (*sal
);
9626 /* We fall back to GDBARCH if there is no architecture
9627 associated with SAL. */
9630 rslt
= gdbarch_fast_tracepoint_valid_at (sarch
, sal
->pc
, &msg
);
9631 old_chain
= make_cleanup (xfree
, msg
);
9634 error (_("May not have a fast tracepoint at 0x%s%s"),
9635 paddress (sarch
, sal
->pc
), (msg
? msg
: ""));
9637 do_cleanups (old_chain
);
9641 /* Given TOK, a string specification of condition and thread, as
9642 accepted by the 'break' command, extract the condition
9643 string and thread number and set *COND_STRING and *THREAD.
9644 PC identifies the context at which the condition should be parsed.
9645 If no condition is found, *COND_STRING is set to NULL.
9646 If no thread is found, *THREAD is set to -1. */
9649 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9650 char **cond_string
, int *thread
, int *task
,
9653 *cond_string
= NULL
;
9660 const char *end_tok
;
9662 const char *cond_start
= NULL
;
9663 const char *cond_end
= NULL
;
9665 tok
= skip_spaces_const (tok
);
9667 if ((*tok
== '"' || *tok
== ',') && rest
)
9669 *rest
= savestring (tok
, strlen (tok
));
9673 end_tok
= skip_to_space_const (tok
);
9675 toklen
= end_tok
- tok
;
9677 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9679 struct expression
*expr
;
9681 tok
= cond_start
= end_tok
+ 1;
9682 expr
= parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9685 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9687 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9690 struct thread_info
*thr
;
9693 thr
= parse_thread_id (tok
, &tmptok
);
9695 error (_("Junk after thread keyword."));
9696 *thread
= thr
->global_num
;
9699 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9704 *task
= strtol (tok
, &tmptok
, 0);
9706 error (_("Junk after task keyword."));
9707 if (!valid_task_id (*task
))
9708 error (_("Unknown task %d."), *task
);
9713 *rest
= savestring (tok
, strlen (tok
));
9717 error (_("Junk at end of arguments."));
9721 /* Decode a static tracepoint marker spec. */
9723 static struct symtabs_and_lines
9724 decode_static_tracepoint_spec (const char **arg_p
)
9726 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
9727 struct symtabs_and_lines sals
;
9728 struct cleanup
*old_chain
;
9729 const char *p
= &(*arg_p
)[3];
9734 p
= skip_spaces_const (p
);
9736 endp
= skip_to_space_const (p
);
9738 marker_str
= savestring (p
, endp
- p
);
9739 old_chain
= make_cleanup (xfree
, marker_str
);
9741 markers
= target_static_tracepoint_markers_by_strid (marker_str
);
9742 if (VEC_empty(static_tracepoint_marker_p
, markers
))
9743 error (_("No known static tracepoint marker named %s"), marker_str
);
9745 sals
.nelts
= VEC_length(static_tracepoint_marker_p
, markers
);
9746 sals
.sals
= XNEWVEC (struct symtab_and_line
, sals
.nelts
);
9748 for (i
= 0; i
< sals
.nelts
; i
++)
9750 struct static_tracepoint_marker
*marker
;
9752 marker
= VEC_index (static_tracepoint_marker_p
, markers
, i
);
9754 init_sal (&sals
.sals
[i
]);
9756 sals
.sals
[i
] = find_pc_line (marker
->address
, 0);
9757 sals
.sals
[i
].pc
= marker
->address
;
9759 release_static_tracepoint_marker (marker
);
9762 do_cleanups (old_chain
);
9768 /* See breakpoint.h. */
9771 create_breakpoint (struct gdbarch
*gdbarch
,
9772 const struct event_location
*location
, char *cond_string
,
9773 int thread
, char *extra_string
,
9775 int tempflag
, enum bptype type_wanted
,
9777 enum auto_boolean pending_break_support
,
9778 const struct breakpoint_ops
*ops
,
9779 int from_tty
, int enabled
, int internal
,
9782 struct linespec_result canonical
;
9783 struct cleanup
*old_chain
;
9784 struct cleanup
*bkpt_chain
= NULL
;
9787 int prev_bkpt_count
= breakpoint_count
;
9789 gdb_assert (ops
!= NULL
);
9791 /* If extra_string isn't useful, set it to NULL. */
9792 if (extra_string
!= NULL
&& *extra_string
== '\0')
9793 extra_string
= NULL
;
9795 init_linespec_result (&canonical
);
9799 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9801 CATCH (e
, RETURN_MASK_ERROR
)
9803 /* If caller is interested in rc value from parse, set
9805 if (e
.error
== NOT_FOUND_ERROR
)
9807 /* If pending breakpoint support is turned off, throw
9810 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9811 throw_exception (e
);
9813 exception_print (gdb_stderr
, e
);
9815 /* If pending breakpoint support is auto query and the user
9816 selects no, then simply return the error code. */
9817 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9818 && !nquery (_("Make %s pending on future shared library load? "),
9819 bptype_string (type_wanted
)))
9822 /* At this point, either the user was queried about setting
9823 a pending breakpoint and selected yes, or pending
9824 breakpoint behavior is on and thus a pending breakpoint
9825 is defaulted on behalf of the user. */
9829 throw_exception (e
);
9833 if (!pending
&& VEC_empty (linespec_sals
, canonical
.sals
))
9836 /* Create a chain of things that always need to be cleaned up. */
9837 old_chain
= make_cleanup_destroy_linespec_result (&canonical
);
9839 /* ----------------------------- SNIP -----------------------------
9840 Anything added to the cleanup chain beyond this point is assumed
9841 to be part of a breakpoint. If the breakpoint create succeeds
9842 then the memory is not reclaimed. */
9843 bkpt_chain
= make_cleanup (null_cleanup
, 0);
9845 /* Resolve all line numbers to PC's and verify that the addresses
9846 are ok for the target. */
9850 struct linespec_sals
*iter
;
9852 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
9853 breakpoint_sals_to_pc (&iter
->sals
);
9856 /* Fast tracepoints may have additional restrictions on location. */
9857 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9860 struct linespec_sals
*iter
;
9862 for (ix
= 0; VEC_iterate (linespec_sals
, canonical
.sals
, ix
, iter
); ++ix
)
9863 check_fast_tracepoint_sals (gdbarch
, &iter
->sals
);
9866 /* Verify that condition can be parsed, before setting any
9867 breakpoints. Allocate a separate condition expression for each
9874 struct linespec_sals
*lsal
;
9876 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
9878 /* Here we only parse 'arg' to separate condition
9879 from thread number, so parsing in context of first
9880 sal is OK. When setting the breakpoint we'll
9881 re-parse it in context of each sal. */
9883 find_condition_and_thread (extra_string
, lsal
->sals
.sals
[0].pc
,
9884 &cond_string
, &thread
, &task
, &rest
);
9886 make_cleanup (xfree
, cond_string
);
9888 make_cleanup (xfree
, rest
);
9890 extra_string
= rest
;
9892 extra_string
= NULL
;
9896 if (type_wanted
!= bp_dprintf
9897 && extra_string
!= NULL
&& *extra_string
!= '\0')
9898 error (_("Garbage '%s' at end of location"), extra_string
);
9900 /* Create a private copy of condition string. */
9903 cond_string
= xstrdup (cond_string
);
9904 make_cleanup (xfree
, cond_string
);
9906 /* Create a private copy of any extra string. */
9909 extra_string
= xstrdup (extra_string
);
9910 make_cleanup (xfree
, extra_string
);
9914 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9915 cond_string
, extra_string
, type_wanted
,
9916 tempflag
? disp_del
: disp_donttouch
,
9917 thread
, task
, ignore_count
, ops
,
9918 from_tty
, enabled
, internal
, flags
);
9922 struct breakpoint
*b
;
9924 if (is_tracepoint_type (type_wanted
))
9926 struct tracepoint
*t
;
9928 t
= XCNEW (struct tracepoint
);
9932 b
= XNEW (struct breakpoint
);
9934 init_raw_breakpoint_without_location (b
, gdbarch
, type_wanted
, ops
);
9935 b
->location
= copy_event_location (location
);
9938 b
->cond_string
= NULL
;
9941 /* Create a private copy of condition string. */
9944 cond_string
= xstrdup (cond_string
);
9945 make_cleanup (xfree
, cond_string
);
9947 b
->cond_string
= cond_string
;
9951 /* Create a private copy of any extra string. */
9952 if (extra_string
!= NULL
)
9954 extra_string
= xstrdup (extra_string
);
9955 make_cleanup (xfree
, extra_string
);
9957 b
->extra_string
= extra_string
;
9958 b
->ignore_count
= ignore_count
;
9959 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9960 b
->condition_not_parsed
= 1;
9961 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9962 if ((type_wanted
!= bp_breakpoint
9963 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9964 b
->pspace
= current_program_space
;
9966 install_breakpoint (internal
, b
, 0);
9969 if (VEC_length (linespec_sals
, canonical
.sals
) > 1)
9971 warning (_("Multiple breakpoints were set.\nUse the "
9972 "\"delete\" command to delete unwanted breakpoints."));
9973 prev_breakpoint_count
= prev_bkpt_count
;
9976 /* That's it. Discard the cleanups for data inserted into the
9978 discard_cleanups (bkpt_chain
);
9979 /* But cleanup everything else. */
9980 do_cleanups (old_chain
);
9982 /* error call may happen here - have BKPT_CHAIN already discarded. */
9983 update_global_location_list (UGLL_MAY_INSERT
);
9988 /* Set a breakpoint.
9989 ARG is a string describing breakpoint address,
9990 condition, and thread.
9991 FLAG specifies if a breakpoint is hardware on,
9992 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9996 break_command_1 (char *arg
, int flag
, int from_tty
)
9998 int tempflag
= flag
& BP_TEMPFLAG
;
9999 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
10000 ? bp_hardware_breakpoint
10002 struct breakpoint_ops
*ops
;
10003 struct event_location
*location
;
10004 struct cleanup
*cleanup
;
10006 location
= string_to_event_location (&arg
, current_language
);
10007 cleanup
= make_cleanup_delete_event_location (location
);
10009 /* Matching breakpoints on probes. */
10010 if (location
!= NULL
10011 && event_location_type (location
) == PROBE_LOCATION
)
10012 ops
= &bkpt_probe_breakpoint_ops
;
10014 ops
= &bkpt_breakpoint_ops
;
10016 create_breakpoint (get_current_arch (),
10018 NULL
, 0, arg
, 1 /* parse arg */,
10019 tempflag
, type_wanted
,
10020 0 /* Ignore count */,
10021 pending_break_support
,
10027 do_cleanups (cleanup
);
10030 /* Helper function for break_command_1 and disassemble_command. */
10033 resolve_sal_pc (struct symtab_and_line
*sal
)
10037 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
10039 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
10040 error (_("No line %d in file \"%s\"."),
10041 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
10044 /* If this SAL corresponds to a breakpoint inserted using a line
10045 number, then skip the function prologue if necessary. */
10046 if (sal
->explicit_line
)
10047 skip_prologue_sal (sal
);
10050 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
10052 const struct blockvector
*bv
;
10053 const struct block
*b
;
10054 struct symbol
*sym
;
10056 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
10057 SYMTAB_COMPUNIT (sal
->symtab
));
10060 sym
= block_linkage_function (b
);
10063 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
10064 sal
->section
= SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal
->symtab
),
10069 /* It really is worthwhile to have the section, so we'll
10070 just have to look harder. This case can be executed
10071 if we have line numbers but no functions (as can
10072 happen in assembly source). */
10074 struct bound_minimal_symbol msym
;
10075 struct cleanup
*old_chain
= save_current_space_and_thread ();
10077 switch_to_program_space_and_thread (sal
->pspace
);
10079 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
10081 sal
->section
= MSYMBOL_OBJ_SECTION (msym
.objfile
, msym
.minsym
);
10083 do_cleanups (old_chain
);
10090 break_command (char *arg
, int from_tty
)
10092 break_command_1 (arg
, 0, from_tty
);
10096 tbreak_command (char *arg
, int from_tty
)
10098 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
10102 hbreak_command (char *arg
, int from_tty
)
10104 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
10108 thbreak_command (char *arg
, int from_tty
)
10110 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
10114 stop_command (char *arg
, int from_tty
)
10116 printf_filtered (_("Specify the type of breakpoint to set.\n\
10117 Usage: stop in <function | address>\n\
10118 stop at <line>\n"));
10122 stopin_command (char *arg
, int from_tty
)
10126 if (arg
== (char *) NULL
)
10128 else if (*arg
!= '*')
10130 char *argptr
= arg
;
10133 /* Look for a ':'. If this is a line number specification, then
10134 say it is bad, otherwise, it should be an address or
10135 function/method name. */
10136 while (*argptr
&& !hasColon
)
10138 hasColon
= (*argptr
== ':');
10143 badInput
= (*argptr
!= ':'); /* Not a class::method */
10145 badInput
= isdigit (*arg
); /* a simple line number */
10149 printf_filtered (_("Usage: stop in <function | address>\n"));
10151 break_command_1 (arg
, 0, from_tty
);
10155 stopat_command (char *arg
, int from_tty
)
10159 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
10163 char *argptr
= arg
;
10166 /* Look for a ':'. If there is a '::' then get out, otherwise
10167 it is probably a line number. */
10168 while (*argptr
&& !hasColon
)
10170 hasColon
= (*argptr
== ':');
10175 badInput
= (*argptr
== ':'); /* we have class::method */
10177 badInput
= !isdigit (*arg
); /* not a line number */
10181 printf_filtered (_("Usage: stop at <line>\n"));
10183 break_command_1 (arg
, 0, from_tty
);
10186 /* The dynamic printf command is mostly like a regular breakpoint, but
10187 with a prewired command list consisting of a single output command,
10188 built from extra arguments supplied on the dprintf command
10192 dprintf_command (char *arg
, int from_tty
)
10194 struct event_location
*location
;
10195 struct cleanup
*cleanup
;
10197 location
= string_to_event_location (&arg
, current_language
);
10198 cleanup
= make_cleanup_delete_event_location (location
);
10200 /* If non-NULL, ARG should have been advanced past the location;
10201 the next character must be ','. */
10204 if (arg
[0] != ',' || arg
[1] == '\0')
10205 error (_("Format string required"));
10208 /* Skip the comma. */
10213 create_breakpoint (get_current_arch (),
10215 NULL
, 0, arg
, 1 /* parse arg */,
10217 0 /* Ignore count */,
10218 pending_break_support
,
10219 &dprintf_breakpoint_ops
,
10224 do_cleanups (cleanup
);
10228 agent_printf_command (char *arg
, int from_tty
)
10230 error (_("May only run agent-printf on the target"));
10233 /* Implement the "breakpoint_hit" breakpoint_ops method for
10234 ranged breakpoints. */
10237 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
10238 struct address_space
*aspace
,
10240 const struct target_waitstatus
*ws
)
10242 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
10243 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
10246 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
10247 bl
->length
, aspace
, bp_addr
);
10250 /* Implement the "resources_needed" breakpoint_ops method for
10251 ranged breakpoints. */
10254 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
10256 return target_ranged_break_num_registers ();
10259 /* Implement the "print_it" breakpoint_ops method for
10260 ranged breakpoints. */
10262 static enum print_stop_action
10263 print_it_ranged_breakpoint (bpstat bs
)
10265 struct breakpoint
*b
= bs
->breakpoint_at
;
10266 struct bp_location
*bl
= b
->loc
;
10267 struct ui_out
*uiout
= current_uiout
;
10269 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10271 /* Ranged breakpoints have only one location. */
10272 gdb_assert (bl
&& bl
->next
== NULL
);
10274 annotate_breakpoint (b
->number
);
10276 maybe_print_thread_hit_breakpoint (uiout
);
10278 if (b
->disposition
== disp_del
)
10279 ui_out_text (uiout
, "Temporary ranged breakpoint ");
10281 ui_out_text (uiout
, "Ranged breakpoint ");
10282 if (ui_out_is_mi_like_p (uiout
))
10284 ui_out_field_string (uiout
, "reason",
10285 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
10286 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
10288 ui_out_field_int (uiout
, "bkptno", b
->number
);
10289 ui_out_text (uiout
, ", ");
10291 return PRINT_SRC_AND_LOC
;
10294 /* Implement the "print_one" breakpoint_ops method for
10295 ranged breakpoints. */
10298 print_one_ranged_breakpoint (struct breakpoint
*b
,
10299 struct bp_location
**last_loc
)
10301 struct bp_location
*bl
= b
->loc
;
10302 struct value_print_options opts
;
10303 struct ui_out
*uiout
= current_uiout
;
10305 /* Ranged breakpoints have only one location. */
10306 gdb_assert (bl
&& bl
->next
== NULL
);
10308 get_user_print_options (&opts
);
10310 if (opts
.addressprint
)
10311 /* We don't print the address range here, it will be printed later
10312 by print_one_detail_ranged_breakpoint. */
10313 ui_out_field_skip (uiout
, "addr");
10314 annotate_field (5);
10315 print_breakpoint_location (b
, bl
);
10319 /* Implement the "print_one_detail" breakpoint_ops method for
10320 ranged breakpoints. */
10323 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
10324 struct ui_out
*uiout
)
10326 CORE_ADDR address_start
, address_end
;
10327 struct bp_location
*bl
= b
->loc
;
10328 struct ui_file
*stb
= mem_fileopen ();
10329 struct cleanup
*cleanup
= make_cleanup_ui_file_delete (stb
);
10333 address_start
= bl
->address
;
10334 address_end
= address_start
+ bl
->length
- 1;
10336 ui_out_text (uiout
, "\taddress range: ");
10337 fprintf_unfiltered (stb
, "[%s, %s]",
10338 print_core_address (bl
->gdbarch
, address_start
),
10339 print_core_address (bl
->gdbarch
, address_end
));
10340 ui_out_field_stream (uiout
, "addr", stb
);
10341 ui_out_text (uiout
, "\n");
10343 do_cleanups (cleanup
);
10346 /* Implement the "print_mention" breakpoint_ops method for
10347 ranged breakpoints. */
10350 print_mention_ranged_breakpoint (struct breakpoint
*b
)
10352 struct bp_location
*bl
= b
->loc
;
10353 struct ui_out
*uiout
= current_uiout
;
10356 gdb_assert (b
->type
== bp_hardware_breakpoint
);
10358 if (ui_out_is_mi_like_p (uiout
))
10361 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
10362 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
10363 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
10366 /* Implement the "print_recreate" breakpoint_ops method for
10367 ranged breakpoints. */
10370 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10372 fprintf_unfiltered (fp
, "break-range %s, %s",
10373 event_location_to_string (b
->location
),
10374 event_location_to_string (b
->location_range_end
));
10375 print_recreate_thread (b
, fp
);
10378 /* The breakpoint_ops structure to be used in ranged breakpoints. */
10380 static struct breakpoint_ops ranged_breakpoint_ops
;
10382 /* Find the address where the end of the breakpoint range should be
10383 placed, given the SAL of the end of the range. This is so that if
10384 the user provides a line number, the end of the range is set to the
10385 last instruction of the given line. */
10388 find_breakpoint_range_end (struct symtab_and_line sal
)
10392 /* If the user provided a PC value, use it. Otherwise,
10393 find the address of the end of the given location. */
10394 if (sal
.explicit_pc
)
10401 ret
= find_line_pc_range (sal
, &start
, &end
);
10403 error (_("Could not find location of the end of the range."));
10405 /* find_line_pc_range returns the start of the next line. */
10412 /* Implement the "break-range" CLI command. */
10415 break_range_command (char *arg
, int from_tty
)
10417 char *arg_start
, *addr_string_start
;
10418 struct linespec_result canonical_start
, canonical_end
;
10419 int bp_count
, can_use_bp
, length
;
10421 struct breakpoint
*b
;
10422 struct symtab_and_line sal_start
, sal_end
;
10423 struct cleanup
*cleanup_bkpt
;
10424 struct linespec_sals
*lsal_start
, *lsal_end
;
10425 struct event_location
*start_location
, *end_location
;
10427 /* We don't support software ranged breakpoints. */
10428 if (target_ranged_break_num_registers () < 0)
10429 error (_("This target does not support hardware ranged breakpoints."));
10431 bp_count
= hw_breakpoint_used_count ();
10432 bp_count
+= target_ranged_break_num_registers ();
10433 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
10435 if (can_use_bp
< 0)
10436 error (_("Hardware breakpoints used exceeds limit."));
10438 arg
= skip_spaces (arg
);
10439 if (arg
== NULL
|| arg
[0] == '\0')
10440 error(_("No address range specified."));
10442 init_linespec_result (&canonical_start
);
10445 start_location
= string_to_event_location (&arg
, current_language
);
10446 cleanup_bkpt
= make_cleanup_delete_event_location (start_location
);
10447 parse_breakpoint_sals (start_location
, &canonical_start
);
10448 make_cleanup_destroy_linespec_result (&canonical_start
);
10451 error (_("Too few arguments."));
10452 else if (VEC_empty (linespec_sals
, canonical_start
.sals
))
10453 error (_("Could not find location of the beginning of the range."));
10455 lsal_start
= VEC_index (linespec_sals
, canonical_start
.sals
, 0);
10457 if (VEC_length (linespec_sals
, canonical_start
.sals
) > 1
10458 || lsal_start
->sals
.nelts
!= 1)
10459 error (_("Cannot create a ranged breakpoint with multiple locations."));
10461 sal_start
= lsal_start
->sals
.sals
[0];
10462 addr_string_start
= savestring (arg_start
, arg
- arg_start
);
10463 make_cleanup (xfree
, addr_string_start
);
10465 arg
++; /* Skip the comma. */
10466 arg
= skip_spaces (arg
);
10468 /* Parse the end location. */
10470 init_linespec_result (&canonical_end
);
10473 /* We call decode_line_full directly here instead of using
10474 parse_breakpoint_sals because we need to specify the start location's
10475 symtab and line as the default symtab and line for the end of the
10476 range. This makes it possible to have ranges like "foo.c:27, +14",
10477 where +14 means 14 lines from the start location. */
10478 end_location
= string_to_event_location (&arg
, current_language
);
10479 make_cleanup_delete_event_location (end_location
);
10480 decode_line_full (end_location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
10481 sal_start
.symtab
, sal_start
.line
,
10482 &canonical_end
, NULL
, NULL
);
10484 make_cleanup_destroy_linespec_result (&canonical_end
);
10486 if (VEC_empty (linespec_sals
, canonical_end
.sals
))
10487 error (_("Could not find location of the end of the range."));
10489 lsal_end
= VEC_index (linespec_sals
, canonical_end
.sals
, 0);
10490 if (VEC_length (linespec_sals
, canonical_end
.sals
) > 1
10491 || lsal_end
->sals
.nelts
!= 1)
10492 error (_("Cannot create a ranged breakpoint with multiple locations."));
10494 sal_end
= lsal_end
->sals
.sals
[0];
10496 end
= find_breakpoint_range_end (sal_end
);
10497 if (sal_start
.pc
> end
)
10498 error (_("Invalid address range, end precedes start."));
10500 length
= end
- sal_start
.pc
+ 1;
10502 /* Length overflowed. */
10503 error (_("Address range too large."));
10504 else if (length
== 1)
10506 /* This range is simple enough to be handled by
10507 the `hbreak' command. */
10508 hbreak_command (addr_string_start
, 1);
10510 do_cleanups (cleanup_bkpt
);
10515 /* Now set up the breakpoint. */
10516 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10517 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10518 set_breakpoint_count (breakpoint_count
+ 1);
10519 b
->number
= breakpoint_count
;
10520 b
->disposition
= disp_donttouch
;
10521 b
->location
= copy_event_location (start_location
);
10522 b
->location_range_end
= copy_event_location (end_location
);
10523 b
->loc
->length
= length
;
10525 do_cleanups (cleanup_bkpt
);
10528 observer_notify_breakpoint_created (b
);
10529 update_global_location_list (UGLL_MAY_INSERT
);
10532 /* Return non-zero if EXP is verified as constant. Returned zero
10533 means EXP is variable. Also the constant detection may fail for
10534 some constant expressions and in such case still falsely return
10538 watchpoint_exp_is_const (const struct expression
*exp
)
10540 int i
= exp
->nelts
;
10546 /* We are only interested in the descriptor of each element. */
10547 operator_length (exp
, i
, &oplenp
, &argsp
);
10550 switch (exp
->elts
[i
].opcode
)
10560 case BINOP_LOGICAL_AND
:
10561 case BINOP_LOGICAL_OR
:
10562 case BINOP_BITWISE_AND
:
10563 case BINOP_BITWISE_IOR
:
10564 case BINOP_BITWISE_XOR
:
10566 case BINOP_NOTEQUAL
:
10593 case OP_OBJC_NSSTRING
:
10596 case UNOP_LOGICAL_NOT
:
10597 case UNOP_COMPLEMENT
:
10602 case UNOP_CAST_TYPE
:
10603 case UNOP_REINTERPRET_CAST
:
10604 case UNOP_DYNAMIC_CAST
:
10605 /* Unary, binary and ternary operators: We have to check
10606 their operands. If they are constant, then so is the
10607 result of that operation. For instance, if A and B are
10608 determined to be constants, then so is "A + B".
10610 UNOP_IND is one exception to the rule above, because the
10611 value of *ADDR is not necessarily a constant, even when
10616 /* Check whether the associated symbol is a constant.
10618 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10619 possible that a buggy compiler could mark a variable as
10620 constant even when it is not, and TYPE_CONST would return
10621 true in this case, while SYMBOL_CLASS wouldn't.
10623 We also have to check for function symbols because they
10624 are always constant. */
10626 struct symbol
*s
= exp
->elts
[i
+ 2].symbol
;
10628 if (SYMBOL_CLASS (s
) != LOC_BLOCK
10629 && SYMBOL_CLASS (s
) != LOC_CONST
10630 && SYMBOL_CLASS (s
) != LOC_CONST_BYTES
)
10635 /* The default action is to return 0 because we are using
10636 the optimistic approach here: If we don't know something,
10637 then it is not a constant. */
10646 /* Implement the "dtor" breakpoint_ops method for watchpoints. */
10649 dtor_watchpoint (struct breakpoint
*self
)
10651 struct watchpoint
*w
= (struct watchpoint
*) self
;
10653 xfree (w
->cond_exp
);
10655 xfree (w
->exp_string
);
10656 xfree (w
->exp_string_reparse
);
10657 value_free (w
->val
);
10659 base_breakpoint_ops
.dtor (self
);
10662 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10665 re_set_watchpoint (struct breakpoint
*b
)
10667 struct watchpoint
*w
= (struct watchpoint
*) b
;
10669 /* Watchpoint can be either on expression using entirely global
10670 variables, or it can be on local variables.
10672 Watchpoints of the first kind are never auto-deleted, and even
10673 persist across program restarts. Since they can use variables
10674 from shared libraries, we need to reparse expression as libraries
10675 are loaded and unloaded.
10677 Watchpoints on local variables can also change meaning as result
10678 of solib event. For example, if a watchpoint uses both a local
10679 and a global variables in expression, it's a local watchpoint,
10680 but unloading of a shared library will make the expression
10681 invalid. This is not a very common use case, but we still
10682 re-evaluate expression, to avoid surprises to the user.
10684 Note that for local watchpoints, we re-evaluate it only if
10685 watchpoints frame id is still valid. If it's not, it means the
10686 watchpoint is out of scope and will be deleted soon. In fact,
10687 I'm not sure we'll ever be called in this case.
10689 If a local watchpoint's frame id is still valid, then
10690 w->exp_valid_block is likewise valid, and we can safely use it.
10692 Don't do anything about disabled watchpoints, since they will be
10693 reevaluated again when enabled. */
10694 update_watchpoint (w
, 1 /* reparse */);
10697 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10700 insert_watchpoint (struct bp_location
*bl
)
10702 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10703 int length
= w
->exact
? 1 : bl
->length
;
10705 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10709 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10712 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10714 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10715 int length
= w
->exact
? 1 : bl
->length
;
10717 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10722 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10723 struct address_space
*aspace
, CORE_ADDR bp_addr
,
10724 const struct target_waitstatus
*ws
)
10726 struct breakpoint
*b
= bl
->owner
;
10727 struct watchpoint
*w
= (struct watchpoint
*) b
;
10729 /* Continuable hardware watchpoints are treated as non-existent if the
10730 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10731 some data address). Otherwise gdb won't stop on a break instruction
10732 in the code (not from a breakpoint) when a hardware watchpoint has
10733 been defined. Also skip watchpoints which we know did not trigger
10734 (did not match the data address). */
10735 if (is_hardware_watchpoint (b
)
10736 && w
->watchpoint_triggered
== watch_triggered_no
)
10743 check_status_watchpoint (bpstat bs
)
10745 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10747 bpstat_check_watchpoint (bs
);
10750 /* Implement the "resources_needed" breakpoint_ops method for
10751 hardware watchpoints. */
10754 resources_needed_watchpoint (const struct bp_location
*bl
)
10756 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10757 int length
= w
->exact
? 1 : bl
->length
;
10759 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10762 /* Implement the "works_in_software_mode" breakpoint_ops method for
10763 hardware watchpoints. */
10766 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10768 /* Read and access watchpoints only work with hardware support. */
10769 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10772 static enum print_stop_action
10773 print_it_watchpoint (bpstat bs
)
10775 struct cleanup
*old_chain
;
10776 struct breakpoint
*b
;
10777 struct ui_file
*stb
;
10778 enum print_stop_action result
;
10779 struct watchpoint
*w
;
10780 struct ui_out
*uiout
= current_uiout
;
10782 gdb_assert (bs
->bp_location_at
!= NULL
);
10784 b
= bs
->breakpoint_at
;
10785 w
= (struct watchpoint
*) b
;
10787 stb
= mem_fileopen ();
10788 old_chain
= make_cleanup_ui_file_delete (stb
);
10790 annotate_watchpoint (b
->number
);
10791 maybe_print_thread_hit_breakpoint (uiout
);
10795 case bp_watchpoint
:
10796 case bp_hardware_watchpoint
:
10797 if (ui_out_is_mi_like_p (uiout
))
10798 ui_out_field_string
10800 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10802 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10803 ui_out_text (uiout
, "\nOld value = ");
10804 watchpoint_value_print (bs
->old_val
, stb
);
10805 ui_out_field_stream (uiout
, "old", stb
);
10806 ui_out_text (uiout
, "\nNew value = ");
10807 watchpoint_value_print (w
->val
, stb
);
10808 ui_out_field_stream (uiout
, "new", stb
);
10809 ui_out_text (uiout
, "\n");
10810 /* More than one watchpoint may have been triggered. */
10811 result
= PRINT_UNKNOWN
;
10814 case bp_read_watchpoint
:
10815 if (ui_out_is_mi_like_p (uiout
))
10816 ui_out_field_string
10818 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10820 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10821 ui_out_text (uiout
, "\nValue = ");
10822 watchpoint_value_print (w
->val
, stb
);
10823 ui_out_field_stream (uiout
, "value", stb
);
10824 ui_out_text (uiout
, "\n");
10825 result
= PRINT_UNKNOWN
;
10828 case bp_access_watchpoint
:
10829 if (bs
->old_val
!= NULL
)
10831 if (ui_out_is_mi_like_p (uiout
))
10832 ui_out_field_string
10834 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10836 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10837 ui_out_text (uiout
, "\nOld value = ");
10838 watchpoint_value_print (bs
->old_val
, stb
);
10839 ui_out_field_stream (uiout
, "old", stb
);
10840 ui_out_text (uiout
, "\nNew value = ");
10845 if (ui_out_is_mi_like_p (uiout
))
10846 ui_out_field_string
10848 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10849 make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
10850 ui_out_text (uiout
, "\nValue = ");
10852 watchpoint_value_print (w
->val
, stb
);
10853 ui_out_field_stream (uiout
, "new", stb
);
10854 ui_out_text (uiout
, "\n");
10855 result
= PRINT_UNKNOWN
;
10858 result
= PRINT_UNKNOWN
;
10861 do_cleanups (old_chain
);
10865 /* Implement the "print_mention" breakpoint_ops method for hardware
10869 print_mention_watchpoint (struct breakpoint
*b
)
10871 struct cleanup
*ui_out_chain
;
10872 struct watchpoint
*w
= (struct watchpoint
*) b
;
10873 struct ui_out
*uiout
= current_uiout
;
10877 case bp_watchpoint
:
10878 ui_out_text (uiout
, "Watchpoint ");
10879 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
10881 case bp_hardware_watchpoint
:
10882 ui_out_text (uiout
, "Hardware watchpoint ");
10883 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
10885 case bp_read_watchpoint
:
10886 ui_out_text (uiout
, "Hardware read watchpoint ");
10887 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
10889 case bp_access_watchpoint
:
10890 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
10891 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
10894 internal_error (__FILE__
, __LINE__
,
10895 _("Invalid hardware watchpoint type."));
10898 ui_out_field_int (uiout
, "number", b
->number
);
10899 ui_out_text (uiout
, ": ");
10900 ui_out_field_string (uiout
, "exp", w
->exp_string
);
10901 do_cleanups (ui_out_chain
);
10904 /* Implement the "print_recreate" breakpoint_ops method for
10908 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10910 struct watchpoint
*w
= (struct watchpoint
*) b
;
10914 case bp_watchpoint
:
10915 case bp_hardware_watchpoint
:
10916 fprintf_unfiltered (fp
, "watch");
10918 case bp_read_watchpoint
:
10919 fprintf_unfiltered (fp
, "rwatch");
10921 case bp_access_watchpoint
:
10922 fprintf_unfiltered (fp
, "awatch");
10925 internal_error (__FILE__
, __LINE__
,
10926 _("Invalid watchpoint type."));
10929 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10930 print_recreate_thread (b
, fp
);
10933 /* Implement the "explains_signal" breakpoint_ops method for
10937 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10939 /* A software watchpoint cannot cause a signal other than
10940 GDB_SIGNAL_TRAP. */
10941 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10947 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10949 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10951 /* Implement the "insert" breakpoint_ops method for
10952 masked hardware watchpoints. */
10955 insert_masked_watchpoint (struct bp_location
*bl
)
10957 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10959 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10960 bl
->watchpoint_type
);
10963 /* Implement the "remove" breakpoint_ops method for
10964 masked hardware watchpoints. */
10967 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10969 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10971 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10972 bl
->watchpoint_type
);
10975 /* Implement the "resources_needed" breakpoint_ops method for
10976 masked hardware watchpoints. */
10979 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10981 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10983 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10986 /* Implement the "works_in_software_mode" breakpoint_ops method for
10987 masked hardware watchpoints. */
10990 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10995 /* Implement the "print_it" breakpoint_ops method for
10996 masked hardware watchpoints. */
10998 static enum print_stop_action
10999 print_it_masked_watchpoint (bpstat bs
)
11001 struct breakpoint
*b
= bs
->breakpoint_at
;
11002 struct ui_out
*uiout
= current_uiout
;
11004 /* Masked watchpoints have only one location. */
11005 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
11007 annotate_watchpoint (b
->number
);
11008 maybe_print_thread_hit_breakpoint (uiout
);
11012 case bp_hardware_watchpoint
:
11013 if (ui_out_is_mi_like_p (uiout
))
11014 ui_out_field_string
11016 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
11019 case bp_read_watchpoint
:
11020 if (ui_out_is_mi_like_p (uiout
))
11021 ui_out_field_string
11023 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
11026 case bp_access_watchpoint
:
11027 if (ui_out_is_mi_like_p (uiout
))
11028 ui_out_field_string
11030 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
11033 internal_error (__FILE__
, __LINE__
,
11034 _("Invalid hardware watchpoint type."));
11038 ui_out_text (uiout
, _("\n\
11039 Check the underlying instruction at PC for the memory\n\
11040 address and value which triggered this watchpoint.\n"));
11041 ui_out_text (uiout
, "\n");
11043 /* More than one watchpoint may have been triggered. */
11044 return PRINT_UNKNOWN
;
11047 /* Implement the "print_one_detail" breakpoint_ops method for
11048 masked hardware watchpoints. */
11051 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
11052 struct ui_out
*uiout
)
11054 struct watchpoint
*w
= (struct watchpoint
*) b
;
11056 /* Masked watchpoints have only one location. */
11057 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
11059 ui_out_text (uiout
, "\tmask ");
11060 ui_out_field_core_addr (uiout
, "mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
11061 ui_out_text (uiout
, "\n");
11064 /* Implement the "print_mention" breakpoint_ops method for
11065 masked hardware watchpoints. */
11068 print_mention_masked_watchpoint (struct breakpoint
*b
)
11070 struct watchpoint
*w
= (struct watchpoint
*) b
;
11071 struct ui_out
*uiout
= current_uiout
;
11072 struct cleanup
*ui_out_chain
;
11076 case bp_hardware_watchpoint
:
11077 ui_out_text (uiout
, "Masked hardware watchpoint ");
11078 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
11080 case bp_read_watchpoint
:
11081 ui_out_text (uiout
, "Masked hardware read watchpoint ");
11082 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
11084 case bp_access_watchpoint
:
11085 ui_out_text (uiout
, "Masked hardware access (read/write) watchpoint ");
11086 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
11089 internal_error (__FILE__
, __LINE__
,
11090 _("Invalid hardware watchpoint type."));
11093 ui_out_field_int (uiout
, "number", b
->number
);
11094 ui_out_text (uiout
, ": ");
11095 ui_out_field_string (uiout
, "exp", w
->exp_string
);
11096 do_cleanups (ui_out_chain
);
11099 /* Implement the "print_recreate" breakpoint_ops method for
11100 masked hardware watchpoints. */
11103 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
11105 struct watchpoint
*w
= (struct watchpoint
*) b
;
11110 case bp_hardware_watchpoint
:
11111 fprintf_unfiltered (fp
, "watch");
11113 case bp_read_watchpoint
:
11114 fprintf_unfiltered (fp
, "rwatch");
11116 case bp_access_watchpoint
:
11117 fprintf_unfiltered (fp
, "awatch");
11120 internal_error (__FILE__
, __LINE__
,
11121 _("Invalid hardware watchpoint type."));
11124 sprintf_vma (tmp
, w
->hw_wp_mask
);
11125 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
, tmp
);
11126 print_recreate_thread (b
, fp
);
11129 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
11131 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
11133 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
11136 is_masked_watchpoint (const struct breakpoint
*b
)
11138 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
11141 /* accessflag: hw_write: watch write,
11142 hw_read: watch read,
11143 hw_access: watch access (read or write) */
11145 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
11146 int just_location
, int internal
)
11148 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
11149 struct expression
*exp
;
11150 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
11151 struct value
*val
, *mark
, *result
;
11152 int saved_bitpos
= 0, saved_bitsize
= 0;
11153 struct frame_info
*frame
;
11154 const char *exp_start
= NULL
;
11155 const char *exp_end
= NULL
;
11156 const char *tok
, *end_tok
;
11158 const char *cond_start
= NULL
;
11159 const char *cond_end
= NULL
;
11160 enum bptype bp_type
;
11163 /* Flag to indicate whether we are going to use masks for
11164 the hardware watchpoint. */
11166 CORE_ADDR mask
= 0;
11167 struct watchpoint
*w
;
11169 struct cleanup
*back_to
;
11171 /* Make sure that we actually have parameters to parse. */
11172 if (arg
!= NULL
&& arg
[0] != '\0')
11174 const char *value_start
;
11176 exp_end
= arg
+ strlen (arg
);
11178 /* Look for "parameter value" pairs at the end
11179 of the arguments string. */
11180 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
11182 /* Skip whitespace at the end of the argument list. */
11183 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
11186 /* Find the beginning of the last token.
11187 This is the value of the parameter. */
11188 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
11190 value_start
= tok
+ 1;
11192 /* Skip whitespace. */
11193 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
11198 /* Find the beginning of the second to last token.
11199 This is the parameter itself. */
11200 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
11203 toklen
= end_tok
- tok
+ 1;
11205 if (toklen
== 6 && startswith (tok
, "thread"))
11207 struct thread_info
*thr
;
11208 /* At this point we've found a "thread" token, which means
11209 the user is trying to set a watchpoint that triggers
11210 only in a specific thread. */
11214 error(_("You can specify only one thread."));
11216 /* Extract the thread ID from the next token. */
11217 thr
= parse_thread_id (value_start
, &endp
);
11219 /* Check if the user provided a valid thread ID. */
11220 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
11221 invalid_thread_id_error (value_start
);
11223 thread
= thr
->global_num
;
11225 else if (toklen
== 4 && startswith (tok
, "mask"))
11227 /* We've found a "mask" token, which means the user wants to
11228 create a hardware watchpoint that is going to have the mask
11230 struct value
*mask_value
, *mark
;
11233 error(_("You can specify only one mask."));
11235 use_mask
= just_location
= 1;
11237 mark
= value_mark ();
11238 mask_value
= parse_to_comma_and_eval (&value_start
);
11239 mask
= value_as_address (mask_value
);
11240 value_free_to_mark (mark
);
11243 /* We didn't recognize what we found. We should stop here. */
11246 /* Truncate the string and get rid of the "parameter value" pair before
11247 the arguments string is parsed by the parse_exp_1 function. */
11254 /* Parse the rest of the arguments. From here on out, everything
11255 is in terms of a newly allocated string instead of the original
11257 innermost_block
= NULL
;
11258 expression
= savestring (arg
, exp_end
- arg
);
11259 back_to
= make_cleanup (xfree
, expression
);
11260 exp_start
= arg
= expression
;
11261 exp
= parse_exp_1 (&arg
, 0, 0, 0);
11263 /* Remove trailing whitespace from the expression before saving it.
11264 This makes the eventual display of the expression string a bit
11266 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
11269 /* Checking if the expression is not constant. */
11270 if (watchpoint_exp_is_const (exp
))
11274 len
= exp_end
- exp_start
;
11275 while (len
> 0 && isspace (exp_start
[len
- 1]))
11277 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
11280 exp_valid_block
= innermost_block
;
11281 mark
= value_mark ();
11282 fetch_subexp_value (exp
, &pc
, &val
, &result
, NULL
, just_location
);
11284 if (val
!= NULL
&& just_location
)
11286 saved_bitpos
= value_bitpos (val
);
11287 saved_bitsize
= value_bitsize (val
);
11294 exp_valid_block
= NULL
;
11295 val
= value_addr (result
);
11296 release_value (val
);
11297 value_free_to_mark (mark
);
11301 ret
= target_masked_watch_num_registers (value_as_address (val
),
11304 error (_("This target does not support masked watchpoints."));
11305 else if (ret
== -2)
11306 error (_("Invalid mask or memory region."));
11309 else if (val
!= NULL
)
11310 release_value (val
);
11312 tok
= skip_spaces_const (arg
);
11313 end_tok
= skip_to_space_const (tok
);
11315 toklen
= end_tok
- tok
;
11316 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
11318 struct expression
*cond
;
11320 innermost_block
= NULL
;
11321 tok
= cond_start
= end_tok
+ 1;
11322 cond
= parse_exp_1 (&tok
, 0, 0, 0);
11324 /* The watchpoint expression may not be local, but the condition
11325 may still be. E.g.: `watch global if local > 0'. */
11326 cond_exp_valid_block
= innermost_block
;
11332 error (_("Junk at end of command."));
11334 frame
= block_innermost_frame (exp_valid_block
);
11336 /* If the expression is "local", then set up a "watchpoint scope"
11337 breakpoint at the point where we've left the scope of the watchpoint
11338 expression. Create the scope breakpoint before the watchpoint, so
11339 that we will encounter it first in bpstat_stop_status. */
11340 if (exp_valid_block
&& frame
)
11342 if (frame_id_p (frame_unwind_caller_id (frame
)))
11345 = create_internal_breakpoint (frame_unwind_caller_arch (frame
),
11346 frame_unwind_caller_pc (frame
),
11347 bp_watchpoint_scope
,
11348 &momentary_breakpoint_ops
);
11350 scope_breakpoint
->enable_state
= bp_enabled
;
11352 /* Automatically delete the breakpoint when it hits. */
11353 scope_breakpoint
->disposition
= disp_del
;
11355 /* Only break in the proper frame (help with recursion). */
11356 scope_breakpoint
->frame_id
= frame_unwind_caller_id (frame
);
11358 /* Set the address at which we will stop. */
11359 scope_breakpoint
->loc
->gdbarch
11360 = frame_unwind_caller_arch (frame
);
11361 scope_breakpoint
->loc
->requested_address
11362 = frame_unwind_caller_pc (frame
);
11363 scope_breakpoint
->loc
->address
11364 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
11365 scope_breakpoint
->loc
->requested_address
,
11366 scope_breakpoint
->type
);
11370 /* Now set up the breakpoint. We create all watchpoints as hardware
11371 watchpoints here even if hardware watchpoints are turned off, a call
11372 to update_watchpoint later in this function will cause the type to
11373 drop back to bp_watchpoint (software watchpoint) if required. */
11375 if (accessflag
== hw_read
)
11376 bp_type
= bp_read_watchpoint
;
11377 else if (accessflag
== hw_access
)
11378 bp_type
= bp_access_watchpoint
;
11380 bp_type
= bp_hardware_watchpoint
;
11382 w
= XCNEW (struct watchpoint
);
11385 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
11386 &masked_watchpoint_breakpoint_ops
);
11388 init_raw_breakpoint_without_location (b
, NULL
, bp_type
,
11389 &watchpoint_breakpoint_ops
);
11390 b
->thread
= thread
;
11391 b
->disposition
= disp_donttouch
;
11392 b
->pspace
= current_program_space
;
11394 w
->exp_valid_block
= exp_valid_block
;
11395 w
->cond_exp_valid_block
= cond_exp_valid_block
;
11398 struct type
*t
= value_type (val
);
11399 CORE_ADDR addr
= value_as_address (val
);
11402 t
= check_typedef (TYPE_TARGET_TYPE (check_typedef (t
)));
11403 name
= type_to_string (t
);
11405 w
->exp_string_reparse
= xstrprintf ("* (%s *) %s", name
,
11406 core_addr_to_string (addr
));
11409 w
->exp_string
= xstrprintf ("-location %.*s",
11410 (int) (exp_end
- exp_start
), exp_start
);
11412 /* The above expression is in C. */
11413 b
->language
= language_c
;
11416 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
11420 w
->hw_wp_mask
= mask
;
11425 w
->val_bitpos
= saved_bitpos
;
11426 w
->val_bitsize
= saved_bitsize
;
11431 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
11433 b
->cond_string
= 0;
11437 w
->watchpoint_frame
= get_frame_id (frame
);
11438 w
->watchpoint_thread
= inferior_ptid
;
11442 w
->watchpoint_frame
= null_frame_id
;
11443 w
->watchpoint_thread
= null_ptid
;
11446 if (scope_breakpoint
!= NULL
)
11448 /* The scope breakpoint is related to the watchpoint. We will
11449 need to act on them together. */
11450 b
->related_breakpoint
= scope_breakpoint
;
11451 scope_breakpoint
->related_breakpoint
= b
;
11454 if (!just_location
)
11455 value_free_to_mark (mark
);
11459 /* Finally update the new watchpoint. This creates the locations
11460 that should be inserted. */
11461 update_watchpoint (w
, 1);
11463 CATCH (e
, RETURN_MASK_ALL
)
11465 delete_breakpoint (b
);
11466 throw_exception (e
);
11470 install_breakpoint (internal
, b
, 1);
11471 do_cleanups (back_to
);
11474 /* Return count of debug registers needed to watch the given expression.
11475 If the watchpoint cannot be handled in hardware return zero. */
11478 can_use_hardware_watchpoint (struct value
*v
)
11480 int found_memory_cnt
= 0;
11481 struct value
*head
= v
;
11483 /* Did the user specifically forbid us to use hardware watchpoints? */
11484 if (!can_use_hw_watchpoints
)
11487 /* Make sure that the value of the expression depends only upon
11488 memory contents, and values computed from them within GDB. If we
11489 find any register references or function calls, we can't use a
11490 hardware watchpoint.
11492 The idea here is that evaluating an expression generates a series
11493 of values, one holding the value of every subexpression. (The
11494 expression a*b+c has five subexpressions: a, b, a*b, c, and
11495 a*b+c.) GDB's values hold almost enough information to establish
11496 the criteria given above --- they identify memory lvalues,
11497 register lvalues, computed values, etcetera. So we can evaluate
11498 the expression, and then scan the chain of values that leaves
11499 behind to decide whether we can detect any possible change to the
11500 expression's final value using only hardware watchpoints.
11502 However, I don't think that the values returned by inferior
11503 function calls are special in any way. So this function may not
11504 notice that an expression involving an inferior function call
11505 can't be watched with hardware watchpoints. FIXME. */
11506 for (; v
; v
= value_next (v
))
11508 if (VALUE_LVAL (v
) == lval_memory
)
11510 if (v
!= head
&& value_lazy (v
))
11511 /* A lazy memory lvalue in the chain is one that GDB never
11512 needed to fetch; we either just used its address (e.g.,
11513 `a' in `a.b') or we never needed it at all (e.g., `a'
11514 in `a,b'). This doesn't apply to HEAD; if that is
11515 lazy then it was not readable, but watch it anyway. */
11519 /* Ahh, memory we actually used! Check if we can cover
11520 it with hardware watchpoints. */
11521 struct type
*vtype
= check_typedef (value_type (v
));
11523 /* We only watch structs and arrays if user asked for it
11524 explicitly, never if they just happen to appear in a
11525 middle of some value chain. */
11527 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
11528 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
11530 CORE_ADDR vaddr
= value_address (v
);
11534 len
= (target_exact_watchpoints
11535 && is_scalar_type_recursive (vtype
))?
11536 1 : TYPE_LENGTH (value_type (v
));
11538 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
11542 found_memory_cnt
+= num_regs
;
11546 else if (VALUE_LVAL (v
) != not_lval
11547 && deprecated_value_modifiable (v
) == 0)
11548 return 0; /* These are values from the history (e.g., $1). */
11549 else if (VALUE_LVAL (v
) == lval_register
)
11550 return 0; /* Cannot watch a register with a HW watchpoint. */
11553 /* The expression itself looks suitable for using a hardware
11554 watchpoint, but give the target machine a chance to reject it. */
11555 return found_memory_cnt
;
11559 watch_command_wrapper (char *arg
, int from_tty
, int internal
)
11561 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
11564 /* A helper function that looks for the "-location" argument and then
11565 calls watch_command_1. */
11568 watch_maybe_just_location (char *arg
, int accessflag
, int from_tty
)
11570 int just_location
= 0;
11573 && (check_for_argument (&arg
, "-location", sizeof ("-location") - 1)
11574 || check_for_argument (&arg
, "-l", sizeof ("-l") - 1)))
11576 arg
= skip_spaces (arg
);
11580 watch_command_1 (arg
, accessflag
, from_tty
, just_location
, 0);
11584 watch_command (char *arg
, int from_tty
)
11586 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11590 rwatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11592 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11596 rwatch_command (char *arg
, int from_tty
)
11598 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11602 awatch_command_wrapper (char *arg
, int from_tty
, int internal
)
11604 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11608 awatch_command (char *arg
, int from_tty
)
11610 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11614 /* Data for the FSM that manages the until(location)/advance commands
11615 in infcmd.c. Here because it uses the mechanisms of
11618 struct until_break_fsm
11620 /* The base class. */
11621 struct thread_fsm thread_fsm
;
11623 /* The thread that as current when the command was executed. */
11626 /* The breakpoint set at the destination location. */
11627 struct breakpoint
*location_breakpoint
;
11629 /* Breakpoint set at the return address in the caller frame. May be
11631 struct breakpoint
*caller_breakpoint
;
11634 static void until_break_fsm_clean_up (struct thread_fsm
*self
,
11635 struct thread_info
*thread
);
11636 static int until_break_fsm_should_stop (struct thread_fsm
*self
,
11637 struct thread_info
*thread
);
11638 static enum async_reply_reason
11639 until_break_fsm_async_reply_reason (struct thread_fsm
*self
);
11641 /* until_break_fsm's vtable. */
11643 static struct thread_fsm_ops until_break_fsm_ops
=
11646 until_break_fsm_clean_up
,
11647 until_break_fsm_should_stop
,
11648 NULL
, /* return_value */
11649 until_break_fsm_async_reply_reason
,
11652 /* Allocate a new until_break_command_fsm. */
11654 static struct until_break_fsm
*
11655 new_until_break_fsm (struct interp
*cmd_interp
, int thread
,
11656 struct breakpoint
*location_breakpoint
,
11657 struct breakpoint
*caller_breakpoint
)
11659 struct until_break_fsm
*sm
;
11661 sm
= XCNEW (struct until_break_fsm
);
11662 thread_fsm_ctor (&sm
->thread_fsm
, &until_break_fsm_ops
, cmd_interp
);
11664 sm
->thread
= thread
;
11665 sm
->location_breakpoint
= location_breakpoint
;
11666 sm
->caller_breakpoint
= caller_breakpoint
;
11671 /* Implementation of the 'should_stop' FSM method for the
11672 until(location)/advance commands. */
11675 until_break_fsm_should_stop (struct thread_fsm
*self
,
11676 struct thread_info
*tp
)
11678 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11680 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11681 sm
->location_breakpoint
) != NULL
11682 || (sm
->caller_breakpoint
!= NULL
11683 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11684 sm
->caller_breakpoint
) != NULL
))
11685 thread_fsm_set_finished (self
);
11690 /* Implementation of the 'clean_up' FSM method for the
11691 until(location)/advance commands. */
11694 until_break_fsm_clean_up (struct thread_fsm
*self
,
11695 struct thread_info
*thread
)
11697 struct until_break_fsm
*sm
= (struct until_break_fsm
*) self
;
11699 /* Clean up our temporary breakpoints. */
11700 if (sm
->location_breakpoint
!= NULL
)
11702 delete_breakpoint (sm
->location_breakpoint
);
11703 sm
->location_breakpoint
= NULL
;
11705 if (sm
->caller_breakpoint
!= NULL
)
11707 delete_breakpoint (sm
->caller_breakpoint
);
11708 sm
->caller_breakpoint
= NULL
;
11710 delete_longjmp_breakpoint (sm
->thread
);
11713 /* Implementation of the 'async_reply_reason' FSM method for the
11714 until(location)/advance commands. */
11716 static enum async_reply_reason
11717 until_break_fsm_async_reply_reason (struct thread_fsm
*self
)
11719 return EXEC_ASYNC_LOCATION_REACHED
;
11723 until_break_command (char *arg
, int from_tty
, int anywhere
)
11725 struct symtabs_and_lines sals
;
11726 struct symtab_and_line sal
;
11727 struct frame_info
*frame
;
11728 struct gdbarch
*frame_gdbarch
;
11729 struct frame_id stack_frame_id
;
11730 struct frame_id caller_frame_id
;
11731 struct breakpoint
*location_breakpoint
;
11732 struct breakpoint
*caller_breakpoint
= NULL
;
11733 struct cleanup
*old_chain
, *cleanup
;
11735 struct thread_info
*tp
;
11736 struct event_location
*location
;
11737 struct until_break_fsm
*sm
;
11739 clear_proceed_status (0);
11741 /* Set a breakpoint where the user wants it and at return from
11744 location
= string_to_event_location (&arg
, current_language
);
11745 cleanup
= make_cleanup_delete_event_location (location
);
11747 if (last_displayed_sal_is_valid ())
11748 sals
= decode_line_1 (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
11749 get_last_displayed_symtab (),
11750 get_last_displayed_line ());
11752 sals
= decode_line_1 (location
, DECODE_LINE_FUNFIRSTLINE
,
11753 NULL
, (struct symtab
*) NULL
, 0);
11755 if (sals
.nelts
!= 1)
11756 error (_("Couldn't get information on specified line."));
11758 sal
= sals
.sals
[0];
11759 xfree (sals
.sals
); /* malloc'd, so freed. */
11762 error (_("Junk at end of arguments."));
11764 resolve_sal_pc (&sal
);
11766 tp
= inferior_thread ();
11767 thread
= tp
->global_num
;
11769 old_chain
= make_cleanup (null_cleanup
, NULL
);
11771 /* Note linespec handling above invalidates the frame chain.
11772 Installing a breakpoint also invalidates the frame chain (as it
11773 may need to switch threads), so do any frame handling before
11776 frame
= get_selected_frame (NULL
);
11777 frame_gdbarch
= get_frame_arch (frame
);
11778 stack_frame_id
= get_stack_frame_id (frame
);
11779 caller_frame_id
= frame_unwind_caller_id (frame
);
11781 /* Keep within the current frame, or in frames called by the current
11784 if (frame_id_p (caller_frame_id
))
11786 struct symtab_and_line sal2
;
11787 struct gdbarch
*caller_gdbarch
;
11789 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11790 sal2
.pc
= frame_unwind_caller_pc (frame
);
11791 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11792 caller_breakpoint
= set_momentary_breakpoint (caller_gdbarch
,
11796 make_cleanup_delete_breakpoint (caller_breakpoint
);
11798 set_longjmp_breakpoint (tp
, caller_frame_id
);
11799 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
11802 /* set_momentary_breakpoint could invalidate FRAME. */
11806 /* If the user told us to continue until a specified location,
11807 we don't specify a frame at which we need to stop. */
11808 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11809 null_frame_id
, bp_until
);
11811 /* Otherwise, specify the selected frame, because we want to stop
11812 only at the very same frame. */
11813 location_breakpoint
= set_momentary_breakpoint (frame_gdbarch
, sal
,
11814 stack_frame_id
, bp_until
);
11815 make_cleanup_delete_breakpoint (location_breakpoint
);
11817 sm
= new_until_break_fsm (command_interp (), tp
->global_num
,
11818 location_breakpoint
, caller_breakpoint
);
11819 tp
->thread_fsm
= &sm
->thread_fsm
;
11821 discard_cleanups (old_chain
);
11823 proceed (-1, GDB_SIGNAL_DEFAULT
);
11825 do_cleanups (cleanup
);
11828 /* This function attempts to parse an optional "if <cond>" clause
11829 from the arg string. If one is not found, it returns NULL.
11831 Else, it returns a pointer to the condition string. (It does not
11832 attempt to evaluate the string against a particular block.) And,
11833 it updates arg to point to the first character following the parsed
11834 if clause in the arg string. */
11837 ep_parse_optional_if_clause (char **arg
)
11841 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11844 /* Skip the "if" keyword. */
11847 /* Skip any extra leading whitespace, and record the start of the
11848 condition string. */
11849 *arg
= skip_spaces (*arg
);
11850 cond_string
= *arg
;
11852 /* Assume that the condition occupies the remainder of the arg
11854 (*arg
) += strlen (cond_string
);
11856 return cond_string
;
11859 /* Commands to deal with catching events, such as signals, exceptions,
11860 process start/exit, etc. */
11864 catch_fork_temporary
, catch_vfork_temporary
,
11865 catch_fork_permanent
, catch_vfork_permanent
11870 catch_fork_command_1 (char *arg
, int from_tty
,
11871 struct cmd_list_element
*command
)
11873 struct gdbarch
*gdbarch
= get_current_arch ();
11874 char *cond_string
= NULL
;
11875 catch_fork_kind fork_kind
;
11878 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11879 tempflag
= (fork_kind
== catch_fork_temporary
11880 || fork_kind
== catch_vfork_temporary
);
11884 arg
= skip_spaces (arg
);
11886 /* The allowed syntax is:
11888 catch [v]fork if <cond>
11890 First, check if there's an if clause. */
11891 cond_string
= ep_parse_optional_if_clause (&arg
);
11893 if ((*arg
!= '\0') && !isspace (*arg
))
11894 error (_("Junk at end of arguments."));
11896 /* If this target supports it, create a fork or vfork catchpoint
11897 and enable reporting of such events. */
11900 case catch_fork_temporary
:
11901 case catch_fork_permanent
:
11902 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11903 &catch_fork_breakpoint_ops
);
11905 case catch_vfork_temporary
:
11906 case catch_vfork_permanent
:
11907 create_fork_vfork_event_catchpoint (gdbarch
, tempflag
, cond_string
,
11908 &catch_vfork_breakpoint_ops
);
11911 error (_("unsupported or unknown fork kind; cannot catch it"));
11917 catch_exec_command_1 (char *arg
, int from_tty
,
11918 struct cmd_list_element
*command
)
11920 struct exec_catchpoint
*c
;
11921 struct gdbarch
*gdbarch
= get_current_arch ();
11923 char *cond_string
= NULL
;
11925 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11929 arg
= skip_spaces (arg
);
11931 /* The allowed syntax is:
11933 catch exec if <cond>
11935 First, check if there's an if clause. */
11936 cond_string
= ep_parse_optional_if_clause (&arg
);
11938 if ((*arg
!= '\0') && !isspace (*arg
))
11939 error (_("Junk at end of arguments."));
11941 c
= XNEW (struct exec_catchpoint
);
11942 init_catchpoint (&c
->base
, gdbarch
, tempflag
, cond_string
,
11943 &catch_exec_breakpoint_ops
);
11944 c
->exec_pathname
= NULL
;
11946 install_breakpoint (0, &c
->base
, 1);
11950 init_ada_exception_breakpoint (struct breakpoint
*b
,
11951 struct gdbarch
*gdbarch
,
11952 struct symtab_and_line sal
,
11954 const struct breakpoint_ops
*ops
,
11961 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11963 loc_gdbarch
= gdbarch
;
11965 describe_other_breakpoints (loc_gdbarch
,
11966 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11967 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11968 version for exception catchpoints, because two catchpoints
11969 used for different exception names will use the same address.
11970 In this case, a "breakpoint ... also set at..." warning is
11971 unproductive. Besides, the warning phrasing is also a bit
11972 inappropriate, we should use the word catchpoint, and tell
11973 the user what type of catchpoint it is. The above is good
11974 enough for now, though. */
11977 init_raw_breakpoint (b
, gdbarch
, sal
, bp_breakpoint
, ops
);
11979 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11980 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11981 b
->location
= string_to_event_location (&addr_string
,
11982 language_def (language_ada
));
11983 b
->language
= language_ada
;
11987 catch_command (char *arg
, int from_tty
)
11989 error (_("Catch requires an event name."));
11994 tcatch_command (char *arg
, int from_tty
)
11996 error (_("Catch requires an event name."));
11999 /* A qsort comparison function that sorts breakpoints in order. */
12002 compare_breakpoints (const void *a
, const void *b
)
12004 const breakpoint_p
*ba
= (const breakpoint_p
*) a
;
12005 uintptr_t ua
= (uintptr_t) *ba
;
12006 const breakpoint_p
*bb
= (const breakpoint_p
*) b
;
12007 uintptr_t ub
= (uintptr_t) *bb
;
12009 if ((*ba
)->number
< (*bb
)->number
)
12011 else if ((*ba
)->number
> (*bb
)->number
)
12014 /* Now sort by address, in case we see, e..g, two breakpoints with
12018 return ua
> ub
? 1 : 0;
12021 /* Delete breakpoints by address or line. */
12024 clear_command (char *arg
, int from_tty
)
12026 struct breakpoint
*b
, *prev
;
12027 VEC(breakpoint_p
) *found
= 0;
12030 struct symtabs_and_lines sals
;
12031 struct symtab_and_line sal
;
12033 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
12037 sals
= decode_line_with_current_source (arg
,
12038 (DECODE_LINE_FUNFIRSTLINE
12039 | DECODE_LINE_LIST_MODE
));
12040 make_cleanup (xfree
, sals
.sals
);
12045 sals
.sals
= XNEW (struct symtab_and_line
);
12046 make_cleanup (xfree
, sals
.sals
);
12047 init_sal (&sal
); /* Initialize to zeroes. */
12049 /* Set sal's line, symtab, pc, and pspace to the values
12050 corresponding to the last call to print_frame_info. If the
12051 codepoint is not valid, this will set all the fields to 0. */
12052 get_last_displayed_sal (&sal
);
12053 if (sal
.symtab
== 0)
12054 error (_("No source file specified."));
12056 sals
.sals
[0] = sal
;
12062 /* We don't call resolve_sal_pc here. That's not as bad as it
12063 seems, because all existing breakpoints typically have both
12064 file/line and pc set. So, if clear is given file/line, we can
12065 match this to existing breakpoint without obtaining pc at all.
12067 We only support clearing given the address explicitly
12068 present in breakpoint table. Say, we've set breakpoint
12069 at file:line. There were several PC values for that file:line,
12070 due to optimization, all in one block.
12072 We've picked one PC value. If "clear" is issued with another
12073 PC corresponding to the same file:line, the breakpoint won't
12074 be cleared. We probably can still clear the breakpoint, but
12075 since the other PC value is never presented to user, user
12076 can only find it by guessing, and it does not seem important
12077 to support that. */
12079 /* For each line spec given, delete bps which correspond to it. Do
12080 it in two passes, solely to preserve the current behavior that
12081 from_tty is forced true if we delete more than one
12085 make_cleanup (VEC_cleanup (breakpoint_p
), &found
);
12086 for (i
= 0; i
< sals
.nelts
; i
++)
12088 const char *sal_fullname
;
12090 /* If exact pc given, clear bpts at that pc.
12091 If line given (pc == 0), clear all bpts on specified line.
12092 If defaulting, clear all bpts on default line
12095 defaulting sal.pc != 0 tests to do
12100 1 0 <can't happen> */
12102 sal
= sals
.sals
[i
];
12103 sal_fullname
= (sal
.symtab
== NULL
12104 ? NULL
: symtab_to_fullname (sal
.symtab
));
12106 /* Find all matching breakpoints and add them to 'found'. */
12107 ALL_BREAKPOINTS (b
)
12110 /* Are we going to delete b? */
12111 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
12113 struct bp_location
*loc
= b
->loc
;
12114 for (; loc
; loc
= loc
->next
)
12116 /* If the user specified file:line, don't allow a PC
12117 match. This matches historical gdb behavior. */
12118 int pc_match
= (!sal
.explicit_line
12120 && (loc
->pspace
== sal
.pspace
)
12121 && (loc
->address
== sal
.pc
)
12122 && (!section_is_overlay (loc
->section
)
12123 || loc
->section
== sal
.section
));
12124 int line_match
= 0;
12126 if ((default_match
|| sal
.explicit_line
)
12127 && loc
->symtab
!= NULL
12128 && sal_fullname
!= NULL
12129 && sal
.pspace
== loc
->pspace
12130 && loc
->line_number
== sal
.line
12131 && filename_cmp (symtab_to_fullname (loc
->symtab
),
12132 sal_fullname
) == 0)
12135 if (pc_match
|| line_match
)
12144 VEC_safe_push(breakpoint_p
, found
, b
);
12148 /* Now go thru the 'found' chain and delete them. */
12149 if (VEC_empty(breakpoint_p
, found
))
12152 error (_("No breakpoint at %s."), arg
);
12154 error (_("No breakpoint at this line."));
12157 /* Remove duplicates from the vec. */
12158 qsort (VEC_address (breakpoint_p
, found
),
12159 VEC_length (breakpoint_p
, found
),
12160 sizeof (breakpoint_p
),
12161 compare_breakpoints
);
12162 prev
= VEC_index (breakpoint_p
, found
, 0);
12163 for (ix
= 1; VEC_iterate (breakpoint_p
, found
, ix
, b
); ++ix
)
12167 VEC_ordered_remove (breakpoint_p
, found
, ix
);
12172 if (VEC_length(breakpoint_p
, found
) > 1)
12173 from_tty
= 1; /* Always report if deleted more than one. */
12176 if (VEC_length(breakpoint_p
, found
) == 1)
12177 printf_unfiltered (_("Deleted breakpoint "));
12179 printf_unfiltered (_("Deleted breakpoints "));
12182 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
12185 printf_unfiltered ("%d ", b
->number
);
12186 delete_breakpoint (b
);
12189 putchar_unfiltered ('\n');
12191 do_cleanups (cleanups
);
12194 /* Delete breakpoint in BS if they are `delete' breakpoints and
12195 all breakpoints that are marked for deletion, whether hit or not.
12196 This is called after any breakpoint is hit, or after errors. */
12199 breakpoint_auto_delete (bpstat bs
)
12201 struct breakpoint
*b
, *b_tmp
;
12203 for (; bs
; bs
= bs
->next
)
12204 if (bs
->breakpoint_at
12205 && bs
->breakpoint_at
->disposition
== disp_del
12207 delete_breakpoint (bs
->breakpoint_at
);
12209 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
12211 if (b
->disposition
== disp_del_at_next_stop
)
12212 delete_breakpoint (b
);
12216 /* A comparison function for bp_location AP and BP being interfaced to
12217 qsort. Sort elements primarily by their ADDRESS (no matter what
12218 does breakpoint_address_is_meaningful say for its OWNER),
12219 secondarily by ordering first permanent elements and
12220 terciarily just ensuring the array is sorted stable way despite
12221 qsort being an unstable algorithm. */
12224 bp_location_compare (const void *ap
, const void *bp
)
12226 const struct bp_location
*a
= *(const struct bp_location
**) ap
;
12227 const struct bp_location
*b
= *(const struct bp_location
**) bp
;
12229 if (a
->address
!= b
->address
)
12230 return (a
->address
> b
->address
) - (a
->address
< b
->address
);
12232 /* Sort locations at the same address by their pspace number, keeping
12233 locations of the same inferior (in a multi-inferior environment)
12236 if (a
->pspace
->num
!= b
->pspace
->num
)
12237 return ((a
->pspace
->num
> b
->pspace
->num
)
12238 - (a
->pspace
->num
< b
->pspace
->num
));
12240 /* Sort permanent breakpoints first. */
12241 if (a
->permanent
!= b
->permanent
)
12242 return (a
->permanent
< b
->permanent
) - (a
->permanent
> b
->permanent
);
12244 /* Make the internal GDB representation stable across GDB runs
12245 where A and B memory inside GDB can differ. Breakpoint locations of
12246 the same type at the same address can be sorted in arbitrary order. */
12248 if (a
->owner
->number
!= b
->owner
->number
)
12249 return ((a
->owner
->number
> b
->owner
->number
)
12250 - (a
->owner
->number
< b
->owner
->number
));
12252 return (a
> b
) - (a
< b
);
12255 /* Set bp_location_placed_address_before_address_max and
12256 bp_location_shadow_len_after_address_max according to the current
12257 content of the bp_location array. */
12260 bp_location_target_extensions_update (void)
12262 struct bp_location
*bl
, **blp_tmp
;
12264 bp_location_placed_address_before_address_max
= 0;
12265 bp_location_shadow_len_after_address_max
= 0;
12267 ALL_BP_LOCATIONS (bl
, blp_tmp
)
12269 CORE_ADDR start
, end
, addr
;
12271 if (!bp_location_has_shadow (bl
))
12274 start
= bl
->target_info
.placed_address
;
12275 end
= start
+ bl
->target_info
.shadow_len
;
12277 gdb_assert (bl
->address
>= start
);
12278 addr
= bl
->address
- start
;
12279 if (addr
> bp_location_placed_address_before_address_max
)
12280 bp_location_placed_address_before_address_max
= addr
;
12282 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
12284 gdb_assert (bl
->address
< end
);
12285 addr
= end
- bl
->address
;
12286 if (addr
> bp_location_shadow_len_after_address_max
)
12287 bp_location_shadow_len_after_address_max
= addr
;
12291 /* Download tracepoint locations if they haven't been. */
12294 download_tracepoint_locations (void)
12296 struct breakpoint
*b
;
12297 struct cleanup
*old_chain
;
12298 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
12300 old_chain
= save_current_space_and_thread ();
12302 ALL_TRACEPOINTS (b
)
12304 struct bp_location
*bl
;
12305 struct tracepoint
*t
;
12306 int bp_location_downloaded
= 0;
12308 if ((b
->type
== bp_fast_tracepoint
12309 ? !may_insert_fast_tracepoints
12310 : !may_insert_tracepoints
))
12313 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
12315 if (target_can_download_tracepoint ())
12316 can_download_tracepoint
= TRIBOOL_TRUE
;
12318 can_download_tracepoint
= TRIBOOL_FALSE
;
12321 if (can_download_tracepoint
== TRIBOOL_FALSE
)
12324 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
12326 /* In tracepoint, locations are _never_ duplicated, so
12327 should_be_inserted is equivalent to
12328 unduplicated_should_be_inserted. */
12329 if (!should_be_inserted (bl
) || bl
->inserted
)
12332 switch_to_program_space_and_thread (bl
->pspace
);
12334 target_download_tracepoint (bl
);
12337 bp_location_downloaded
= 1;
12339 t
= (struct tracepoint
*) b
;
12340 t
->number_on_target
= b
->number
;
12341 if (bp_location_downloaded
)
12342 observer_notify_breakpoint_modified (b
);
12345 do_cleanups (old_chain
);
12348 /* Swap the insertion/duplication state between two locations. */
12351 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
12353 const int left_inserted
= left
->inserted
;
12354 const int left_duplicate
= left
->duplicate
;
12355 const int left_needs_update
= left
->needs_update
;
12356 const struct bp_target_info left_target_info
= left
->target_info
;
12358 /* Locations of tracepoints can never be duplicated. */
12359 if (is_tracepoint (left
->owner
))
12360 gdb_assert (!left
->duplicate
);
12361 if (is_tracepoint (right
->owner
))
12362 gdb_assert (!right
->duplicate
);
12364 left
->inserted
= right
->inserted
;
12365 left
->duplicate
= right
->duplicate
;
12366 left
->needs_update
= right
->needs_update
;
12367 left
->target_info
= right
->target_info
;
12368 right
->inserted
= left_inserted
;
12369 right
->duplicate
= left_duplicate
;
12370 right
->needs_update
= left_needs_update
;
12371 right
->target_info
= left_target_info
;
12374 /* Force the re-insertion of the locations at ADDRESS. This is called
12375 once a new/deleted/modified duplicate location is found and we are evaluating
12376 conditions on the target's side. Such conditions need to be updated on
12380 force_breakpoint_reinsertion (struct bp_location
*bl
)
12382 struct bp_location
**locp
= NULL
, **loc2p
;
12383 struct bp_location
*loc
;
12384 CORE_ADDR address
= 0;
12387 address
= bl
->address
;
12388 pspace_num
= bl
->pspace
->num
;
12390 /* This is only meaningful if the target is
12391 evaluating conditions and if the user has
12392 opted for condition evaluation on the target's
12394 if (gdb_evaluates_breakpoint_condition_p ()
12395 || !target_supports_evaluation_of_breakpoint_conditions ())
12398 /* Flag all breakpoint locations with this address and
12399 the same program space as the location
12400 as "its condition has changed". We need to
12401 update the conditions on the target's side. */
12402 ALL_BP_LOCATIONS_AT_ADDR (loc2p
, locp
, address
)
12406 if (!is_breakpoint (loc
->owner
)
12407 || pspace_num
!= loc
->pspace
->num
)
12410 /* Flag the location appropriately. We use a different state to
12411 let everyone know that we already updated the set of locations
12412 with addr bl->address and program space bl->pspace. This is so
12413 we don't have to keep calling these functions just to mark locations
12414 that have already been marked. */
12415 loc
->condition_changed
= condition_updated
;
12417 /* Free the agent expression bytecode as well. We will compute
12419 if (loc
->cond_bytecode
)
12421 free_agent_expr (loc
->cond_bytecode
);
12422 loc
->cond_bytecode
= NULL
;
12426 /* Called whether new breakpoints are created, or existing breakpoints
12427 deleted, to update the global location list and recompute which
12428 locations are duplicate of which.
12430 The INSERT_MODE flag determines whether locations may not, may, or
12431 shall be inserted now. See 'enum ugll_insert_mode' for more
12435 update_global_location_list (enum ugll_insert_mode insert_mode
)
12437 struct breakpoint
*b
;
12438 struct bp_location
**locp
, *loc
;
12439 struct cleanup
*cleanups
;
12440 /* Last breakpoint location address that was marked for update. */
12441 CORE_ADDR last_addr
= 0;
12442 /* Last breakpoint location program space that was marked for update. */
12443 int last_pspace_num
= -1;
12445 /* Used in the duplicates detection below. When iterating over all
12446 bp_locations, points to the first bp_location of a given address.
12447 Breakpoints and watchpoints of different types are never
12448 duplicates of each other. Keep one pointer for each type of
12449 breakpoint/watchpoint, so we only need to loop over all locations
12451 struct bp_location
*bp_loc_first
; /* breakpoint */
12452 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
12453 struct bp_location
*awp_loc_first
; /* access watchpoint */
12454 struct bp_location
*rwp_loc_first
; /* read watchpoint */
12456 /* Saved former bp_location array which we compare against the newly
12457 built bp_location from the current state of ALL_BREAKPOINTS. */
12458 struct bp_location
**old_location
, **old_locp
;
12459 unsigned old_location_count
;
12461 old_location
= bp_location
;
12462 old_location_count
= bp_location_count
;
12463 bp_location
= NULL
;
12464 bp_location_count
= 0;
12465 cleanups
= make_cleanup (xfree
, old_location
);
12467 ALL_BREAKPOINTS (b
)
12468 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12469 bp_location_count
++;
12471 bp_location
= XNEWVEC (struct bp_location
*, bp_location_count
);
12472 locp
= bp_location
;
12473 ALL_BREAKPOINTS (b
)
12474 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
12476 qsort (bp_location
, bp_location_count
, sizeof (*bp_location
),
12477 bp_location_compare
);
12479 bp_location_target_extensions_update ();
12481 /* Identify bp_location instances that are no longer present in the
12482 new list, and therefore should be freed. Note that it's not
12483 necessary that those locations should be removed from inferior --
12484 if there's another location at the same address (previously
12485 marked as duplicate), we don't need to remove/insert the
12488 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12489 and former bp_location array state respectively. */
12491 locp
= bp_location
;
12492 for (old_locp
= old_location
; old_locp
< old_location
+ old_location_count
;
12495 struct bp_location
*old_loc
= *old_locp
;
12496 struct bp_location
**loc2p
;
12498 /* Tells if 'old_loc' is found among the new locations. If
12499 not, we have to free it. */
12500 int found_object
= 0;
12501 /* Tells if the location should remain inserted in the target. */
12502 int keep_in_target
= 0;
12505 /* Skip LOCP entries which will definitely never be needed.
12506 Stop either at or being the one matching OLD_LOC. */
12507 while (locp
< bp_location
+ bp_location_count
12508 && (*locp
)->address
< old_loc
->address
)
12512 (loc2p
< bp_location
+ bp_location_count
12513 && (*loc2p
)->address
== old_loc
->address
);
12516 /* Check if this is a new/duplicated location or a duplicated
12517 location that had its condition modified. If so, we want to send
12518 its condition to the target if evaluation of conditions is taking
12520 if ((*loc2p
)->condition_changed
== condition_modified
12521 && (last_addr
!= old_loc
->address
12522 || last_pspace_num
!= old_loc
->pspace
->num
))
12524 force_breakpoint_reinsertion (*loc2p
);
12525 last_pspace_num
= old_loc
->pspace
->num
;
12528 if (*loc2p
== old_loc
)
12532 /* We have already handled this address, update it so that we don't
12533 have to go through updates again. */
12534 last_addr
= old_loc
->address
;
12536 /* Target-side condition evaluation: Handle deleted locations. */
12538 force_breakpoint_reinsertion (old_loc
);
12540 /* If this location is no longer present, and inserted, look if
12541 there's maybe a new location at the same address. If so,
12542 mark that one inserted, and don't remove this one. This is
12543 needed so that we don't have a time window where a breakpoint
12544 at certain location is not inserted. */
12546 if (old_loc
->inserted
)
12548 /* If the location is inserted now, we might have to remove
12551 if (found_object
&& should_be_inserted (old_loc
))
12553 /* The location is still present in the location list,
12554 and still should be inserted. Don't do anything. */
12555 keep_in_target
= 1;
12559 /* This location still exists, but it won't be kept in the
12560 target since it may have been disabled. We proceed to
12561 remove its target-side condition. */
12563 /* The location is either no longer present, or got
12564 disabled. See if there's another location at the
12565 same address, in which case we don't need to remove
12566 this one from the target. */
12568 /* OLD_LOC comes from existing struct breakpoint. */
12569 if (breakpoint_address_is_meaningful (old_loc
->owner
))
12572 (loc2p
< bp_location
+ bp_location_count
12573 && (*loc2p
)->address
== old_loc
->address
);
12576 struct bp_location
*loc2
= *loc2p
;
12578 if (breakpoint_locations_match (loc2
, old_loc
))
12580 /* Read watchpoint locations are switched to
12581 access watchpoints, if the former are not
12582 supported, but the latter are. */
12583 if (is_hardware_watchpoint (old_loc
->owner
))
12585 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
12586 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
12589 /* loc2 is a duplicated location. We need to check
12590 if it should be inserted in case it will be
12592 if (loc2
!= old_loc
12593 && unduplicated_should_be_inserted (loc2
))
12595 swap_insertion (old_loc
, loc2
);
12596 keep_in_target
= 1;
12604 if (!keep_in_target
)
12606 if (remove_breakpoint (old_loc
))
12608 /* This is just about all we can do. We could keep
12609 this location on the global list, and try to
12610 remove it next time, but there's no particular
12611 reason why we will succeed next time.
12613 Note that at this point, old_loc->owner is still
12614 valid, as delete_breakpoint frees the breakpoint
12615 only after calling us. */
12616 printf_filtered (_("warning: Error removing "
12617 "breakpoint %d\n"),
12618 old_loc
->owner
->number
);
12626 if (removed
&& target_is_non_stop_p ()
12627 && need_moribund_for_location_type (old_loc
))
12629 /* This location was removed from the target. In
12630 non-stop mode, a race condition is possible where
12631 we've removed a breakpoint, but stop events for that
12632 breakpoint are already queued and will arrive later.
12633 We apply an heuristic to be able to distinguish such
12634 SIGTRAPs from other random SIGTRAPs: we keep this
12635 breakpoint location for a bit, and will retire it
12636 after we see some number of events. The theory here
12637 is that reporting of events should, "on the average",
12638 be fair, so after a while we'll see events from all
12639 threads that have anything of interest, and no longer
12640 need to keep this breakpoint location around. We
12641 don't hold locations forever so to reduce chances of
12642 mistaking a non-breakpoint SIGTRAP for a breakpoint
12645 The heuristic failing can be disastrous on
12646 decr_pc_after_break targets.
12648 On decr_pc_after_break targets, like e.g., x86-linux,
12649 if we fail to recognize a late breakpoint SIGTRAP,
12650 because events_till_retirement has reached 0 too
12651 soon, we'll fail to do the PC adjustment, and report
12652 a random SIGTRAP to the user. When the user resumes
12653 the inferior, it will most likely immediately crash
12654 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12655 corrupted, because of being resumed e.g., in the
12656 middle of a multi-byte instruction, or skipped a
12657 one-byte instruction. This was actually seen happen
12658 on native x86-linux, and should be less rare on
12659 targets that do not support new thread events, like
12660 remote, due to the heuristic depending on
12663 Mistaking a random SIGTRAP for a breakpoint trap
12664 causes similar symptoms (PC adjustment applied when
12665 it shouldn't), but then again, playing with SIGTRAPs
12666 behind the debugger's back is asking for trouble.
12668 Since hardware watchpoint traps are always
12669 distinguishable from other traps, so we don't need to
12670 apply keep hardware watchpoint moribund locations
12671 around. We simply always ignore hardware watchpoint
12672 traps we can no longer explain. */
12674 old_loc
->events_till_retirement
= 3 * (thread_count () + 1);
12675 old_loc
->owner
= NULL
;
12677 VEC_safe_push (bp_location_p
, moribund_locations
, old_loc
);
12681 old_loc
->owner
= NULL
;
12682 decref_bp_location (&old_loc
);
12687 /* Rescan breakpoints at the same address and section, marking the
12688 first one as "first" and any others as "duplicates". This is so
12689 that the bpt instruction is only inserted once. If we have a
12690 permanent breakpoint at the same place as BPT, make that one the
12691 official one, and the rest as duplicates. Permanent breakpoints
12692 are sorted first for the same address.
12694 Do the same for hardware watchpoints, but also considering the
12695 watchpoint's type (regular/access/read) and length. */
12697 bp_loc_first
= NULL
;
12698 wp_loc_first
= NULL
;
12699 awp_loc_first
= NULL
;
12700 rwp_loc_first
= NULL
;
12701 ALL_BP_LOCATIONS (loc
, locp
)
12703 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12705 struct bp_location
**loc_first_p
;
12708 if (!unduplicated_should_be_inserted (loc
)
12709 || !breakpoint_address_is_meaningful (b
)
12710 /* Don't detect duplicate for tracepoint locations because they are
12711 never duplicated. See the comments in field `duplicate' of
12712 `struct bp_location'. */
12713 || is_tracepoint (b
))
12715 /* Clear the condition modification flag. */
12716 loc
->condition_changed
= condition_unchanged
;
12720 if (b
->type
== bp_hardware_watchpoint
)
12721 loc_first_p
= &wp_loc_first
;
12722 else if (b
->type
== bp_read_watchpoint
)
12723 loc_first_p
= &rwp_loc_first
;
12724 else if (b
->type
== bp_access_watchpoint
)
12725 loc_first_p
= &awp_loc_first
;
12727 loc_first_p
= &bp_loc_first
;
12729 if (*loc_first_p
== NULL
12730 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12731 || !breakpoint_locations_match (loc
, *loc_first_p
))
12733 *loc_first_p
= loc
;
12734 loc
->duplicate
= 0;
12736 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12738 loc
->needs_update
= 1;
12739 /* Clear the condition modification flag. */
12740 loc
->condition_changed
= condition_unchanged
;
12746 /* This and the above ensure the invariant that the first location
12747 is not duplicated, and is the inserted one.
12748 All following are marked as duplicated, and are not inserted. */
12750 swap_insertion (loc
, *loc_first_p
);
12751 loc
->duplicate
= 1;
12753 /* Clear the condition modification flag. */
12754 loc
->condition_changed
= condition_unchanged
;
12757 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12759 if (insert_mode
!= UGLL_DONT_INSERT
)
12760 insert_breakpoint_locations ();
12763 /* Even though the caller told us to not insert new
12764 locations, we may still need to update conditions on the
12765 target's side of breakpoints that were already inserted
12766 if the target is evaluating breakpoint conditions. We
12767 only update conditions for locations that are marked
12769 update_inserted_breakpoint_locations ();
12773 if (insert_mode
!= UGLL_DONT_INSERT
)
12774 download_tracepoint_locations ();
12776 do_cleanups (cleanups
);
12780 breakpoint_retire_moribund (void)
12782 struct bp_location
*loc
;
12785 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
12786 if (--(loc
->events_till_retirement
) == 0)
12788 decref_bp_location (&loc
);
12789 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
12795 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12800 update_global_location_list (insert_mode
);
12802 CATCH (e
, RETURN_MASK_ERROR
)
12808 /* Clear BKP from a BPS. */
12811 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12815 for (bs
= bps
; bs
; bs
= bs
->next
)
12816 if (bs
->breakpoint_at
== bpt
)
12818 bs
->breakpoint_at
= NULL
;
12819 bs
->old_val
= NULL
;
12820 /* bs->commands will be freed later. */
12824 /* Callback for iterate_over_threads. */
12826 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12828 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12830 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12834 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12838 say_where (struct breakpoint
*b
)
12840 struct value_print_options opts
;
12842 get_user_print_options (&opts
);
12844 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12846 if (b
->loc
== NULL
)
12848 /* For pending locations, the output differs slightly based
12849 on b->extra_string. If this is non-NULL, it contains either
12850 a condition or dprintf arguments. */
12851 if (b
->extra_string
== NULL
)
12853 printf_filtered (_(" (%s) pending."),
12854 event_location_to_string (b
->location
));
12856 else if (b
->type
== bp_dprintf
)
12858 printf_filtered (_(" (%s,%s) pending."),
12859 event_location_to_string (b
->location
),
12864 printf_filtered (_(" (%s %s) pending."),
12865 event_location_to_string (b
->location
),
12871 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12873 printf_filtered (" at ");
12874 fputs_filtered (paddress (b
->loc
->gdbarch
, b
->loc
->address
),
12877 if (b
->loc
->symtab
!= NULL
)
12879 /* If there is a single location, we can print the location
12881 if (b
->loc
->next
== NULL
)
12882 printf_filtered (": file %s, line %d.",
12883 symtab_to_filename_for_display (b
->loc
->symtab
),
12884 b
->loc
->line_number
);
12886 /* This is not ideal, but each location may have a
12887 different file name, and this at least reflects the
12888 real situation somewhat. */
12889 printf_filtered (": %s.",
12890 event_location_to_string (b
->location
));
12895 struct bp_location
*loc
= b
->loc
;
12897 for (; loc
; loc
= loc
->next
)
12899 printf_filtered (" (%d locations)", n
);
12904 /* Default bp_location_ops methods. */
12907 bp_location_dtor (struct bp_location
*self
)
12909 xfree (self
->cond
);
12910 if (self
->cond_bytecode
)
12911 free_agent_expr (self
->cond_bytecode
);
12912 xfree (self
->function_name
);
12914 VEC_free (agent_expr_p
, self
->target_info
.conditions
);
12915 VEC_free (agent_expr_p
, self
->target_info
.tcommands
);
12918 static const struct bp_location_ops bp_location_ops
=
12923 /* Default breakpoint_ops methods all breakpoint_ops ultimately
12927 base_breakpoint_dtor (struct breakpoint
*self
)
12929 decref_counted_command_line (&self
->commands
);
12930 xfree (self
->cond_string
);
12931 xfree (self
->extra_string
);
12932 xfree (self
->filter
);
12933 delete_event_location (self
->location
);
12934 delete_event_location (self
->location_range_end
);
12937 static struct bp_location
*
12938 base_breakpoint_allocate_location (struct breakpoint
*self
)
12940 struct bp_location
*loc
;
12942 loc
= XNEW (struct bp_location
);
12943 init_bp_location (loc
, &bp_location_ops
, self
);
12948 base_breakpoint_re_set (struct breakpoint
*b
)
12950 /* Nothing to re-set. */
12953 #define internal_error_pure_virtual_called() \
12954 gdb_assert_not_reached ("pure virtual function called")
12957 base_breakpoint_insert_location (struct bp_location
*bl
)
12959 internal_error_pure_virtual_called ();
12963 base_breakpoint_remove_location (struct bp_location
*bl
,
12964 enum remove_bp_reason reason
)
12966 internal_error_pure_virtual_called ();
12970 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12971 struct address_space
*aspace
,
12973 const struct target_waitstatus
*ws
)
12975 internal_error_pure_virtual_called ();
12979 base_breakpoint_check_status (bpstat bs
)
12984 /* A "works_in_software_mode" breakpoint_ops method that just internal
12988 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12990 internal_error_pure_virtual_called ();
12993 /* A "resources_needed" breakpoint_ops method that just internal
12997 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12999 internal_error_pure_virtual_called ();
13002 static enum print_stop_action
13003 base_breakpoint_print_it (bpstat bs
)
13005 internal_error_pure_virtual_called ();
13009 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
13010 struct ui_out
*uiout
)
13016 base_breakpoint_print_mention (struct breakpoint
*b
)
13018 internal_error_pure_virtual_called ();
13022 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
13024 internal_error_pure_virtual_called ();
13028 base_breakpoint_create_sals_from_location
13029 (const struct event_location
*location
,
13030 struct linespec_result
*canonical
,
13031 enum bptype type_wanted
)
13033 internal_error_pure_virtual_called ();
13037 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13038 struct linespec_result
*c
,
13040 char *extra_string
,
13041 enum bptype type_wanted
,
13042 enum bpdisp disposition
,
13044 int task
, int ignore_count
,
13045 const struct breakpoint_ops
*o
,
13046 int from_tty
, int enabled
,
13047 int internal
, unsigned flags
)
13049 internal_error_pure_virtual_called ();
13053 base_breakpoint_decode_location (struct breakpoint
*b
,
13054 const struct event_location
*location
,
13055 struct program_space
*search_pspace
,
13056 struct symtabs_and_lines
*sals
)
13058 internal_error_pure_virtual_called ();
13061 /* The default 'explains_signal' method. */
13064 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
13069 /* The default "after_condition_true" method. */
13072 base_breakpoint_after_condition_true (struct bpstats
*bs
)
13074 /* Nothing to do. */
13077 struct breakpoint_ops base_breakpoint_ops
=
13079 base_breakpoint_dtor
,
13080 base_breakpoint_allocate_location
,
13081 base_breakpoint_re_set
,
13082 base_breakpoint_insert_location
,
13083 base_breakpoint_remove_location
,
13084 base_breakpoint_breakpoint_hit
,
13085 base_breakpoint_check_status
,
13086 base_breakpoint_resources_needed
,
13087 base_breakpoint_works_in_software_mode
,
13088 base_breakpoint_print_it
,
13090 base_breakpoint_print_one_detail
,
13091 base_breakpoint_print_mention
,
13092 base_breakpoint_print_recreate
,
13093 base_breakpoint_create_sals_from_location
,
13094 base_breakpoint_create_breakpoints_sal
,
13095 base_breakpoint_decode_location
,
13096 base_breakpoint_explains_signal
,
13097 base_breakpoint_after_condition_true
,
13100 /* Default breakpoint_ops methods. */
13103 bkpt_re_set (struct breakpoint
*b
)
13105 /* FIXME: is this still reachable? */
13106 if (breakpoint_event_location_empty_p (b
))
13108 /* Anything without a location can't be re-set. */
13109 delete_breakpoint (b
);
13113 breakpoint_re_set_default (b
);
13117 bkpt_insert_location (struct bp_location
*bl
)
13119 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
13120 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13122 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13126 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
13128 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
13129 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
13131 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
13135 bkpt_breakpoint_hit (const struct bp_location
*bl
,
13136 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13137 const struct target_waitstatus
*ws
)
13139 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
13140 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
13143 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
13147 if (overlay_debugging
/* unmapped overlay section */
13148 && section_is_overlay (bl
->section
)
13149 && !section_is_mapped (bl
->section
))
13156 dprintf_breakpoint_hit (const struct bp_location
*bl
,
13157 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13158 const struct target_waitstatus
*ws
)
13160 if (dprintf_style
== dprintf_style_agent
13161 && target_can_run_breakpoint_commands ())
13163 /* An agent-style dprintf never causes a stop. If we see a trap
13164 for this address it must be for a breakpoint that happens to
13165 be set at the same address. */
13169 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
13173 bkpt_resources_needed (const struct bp_location
*bl
)
13175 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
13180 static enum print_stop_action
13181 bkpt_print_it (bpstat bs
)
13183 struct breakpoint
*b
;
13184 const struct bp_location
*bl
;
13186 struct ui_out
*uiout
= current_uiout
;
13188 gdb_assert (bs
->bp_location_at
!= NULL
);
13190 bl
= bs
->bp_location_at
;
13191 b
= bs
->breakpoint_at
;
13193 bp_temp
= b
->disposition
== disp_del
;
13194 if (bl
->address
!= bl
->requested_address
)
13195 breakpoint_adjustment_warning (bl
->requested_address
,
13198 annotate_breakpoint (b
->number
);
13199 maybe_print_thread_hit_breakpoint (uiout
);
13202 ui_out_text (uiout
, "Temporary breakpoint ");
13204 ui_out_text (uiout
, "Breakpoint ");
13205 if (ui_out_is_mi_like_p (uiout
))
13207 ui_out_field_string (uiout
, "reason",
13208 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
13209 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
13211 ui_out_field_int (uiout
, "bkptno", b
->number
);
13212 ui_out_text (uiout
, ", ");
13214 return PRINT_SRC_AND_LOC
;
13218 bkpt_print_mention (struct breakpoint
*b
)
13220 if (ui_out_is_mi_like_p (current_uiout
))
13225 case bp_breakpoint
:
13226 case bp_gnu_ifunc_resolver
:
13227 if (b
->disposition
== disp_del
)
13228 printf_filtered (_("Temporary breakpoint"));
13230 printf_filtered (_("Breakpoint"));
13231 printf_filtered (_(" %d"), b
->number
);
13232 if (b
->type
== bp_gnu_ifunc_resolver
)
13233 printf_filtered (_(" at gnu-indirect-function resolver"));
13235 case bp_hardware_breakpoint
:
13236 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
13239 printf_filtered (_("Dprintf %d"), b
->number
);
13247 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13249 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
13250 fprintf_unfiltered (fp
, "tbreak");
13251 else if (tp
->type
== bp_breakpoint
)
13252 fprintf_unfiltered (fp
, "break");
13253 else if (tp
->type
== bp_hardware_breakpoint
13254 && tp
->disposition
== disp_del
)
13255 fprintf_unfiltered (fp
, "thbreak");
13256 else if (tp
->type
== bp_hardware_breakpoint
)
13257 fprintf_unfiltered (fp
, "hbreak");
13259 internal_error (__FILE__
, __LINE__
,
13260 _("unhandled breakpoint type %d"), (int) tp
->type
);
13262 fprintf_unfiltered (fp
, " %s",
13263 event_location_to_string (tp
->location
));
13265 /* Print out extra_string if this breakpoint is pending. It might
13266 contain, for example, conditions that were set by the user. */
13267 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
13268 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
13270 print_recreate_thread (tp
, fp
);
13274 bkpt_create_sals_from_location (const struct event_location
*location
,
13275 struct linespec_result
*canonical
,
13276 enum bptype type_wanted
)
13278 create_sals_from_location_default (location
, canonical
, type_wanted
);
13282 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13283 struct linespec_result
*canonical
,
13285 char *extra_string
,
13286 enum bptype type_wanted
,
13287 enum bpdisp disposition
,
13289 int task
, int ignore_count
,
13290 const struct breakpoint_ops
*ops
,
13291 int from_tty
, int enabled
,
13292 int internal
, unsigned flags
)
13294 create_breakpoints_sal_default (gdbarch
, canonical
,
13295 cond_string
, extra_string
,
13297 disposition
, thread
, task
,
13298 ignore_count
, ops
, from_tty
,
13299 enabled
, internal
, flags
);
13303 bkpt_decode_location (struct breakpoint
*b
,
13304 const struct event_location
*location
,
13305 struct program_space
*search_pspace
,
13306 struct symtabs_and_lines
*sals
)
13308 decode_location_default (b
, location
, search_pspace
, sals
);
13311 /* Virtual table for internal breakpoints. */
13314 internal_bkpt_re_set (struct breakpoint
*b
)
13318 /* Delete overlay event and longjmp master breakpoints; they
13319 will be reset later by breakpoint_re_set. */
13320 case bp_overlay_event
:
13321 case bp_longjmp_master
:
13322 case bp_std_terminate_master
:
13323 case bp_exception_master
:
13324 delete_breakpoint (b
);
13327 /* This breakpoint is special, it's set up when the inferior
13328 starts and we really don't want to touch it. */
13329 case bp_shlib_event
:
13331 /* Like bp_shlib_event, this breakpoint type is special. Once
13332 it is set up, we do not want to touch it. */
13333 case bp_thread_event
:
13339 internal_bkpt_check_status (bpstat bs
)
13341 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
13343 /* If requested, stop when the dynamic linker notifies GDB of
13344 events. This allows the user to get control and place
13345 breakpoints in initializer routines for dynamically loaded
13346 objects (among other things). */
13347 bs
->stop
= stop_on_solib_events
;
13348 bs
->print
= stop_on_solib_events
;
13354 static enum print_stop_action
13355 internal_bkpt_print_it (bpstat bs
)
13357 struct breakpoint
*b
;
13359 b
= bs
->breakpoint_at
;
13363 case bp_shlib_event
:
13364 /* Did we stop because the user set the stop_on_solib_events
13365 variable? (If so, we report this as a generic, "Stopped due
13366 to shlib event" message.) */
13367 print_solib_event (0);
13370 case bp_thread_event
:
13371 /* Not sure how we will get here.
13372 GDB should not stop for these breakpoints. */
13373 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
13376 case bp_overlay_event
:
13377 /* By analogy with the thread event, GDB should not stop for these. */
13378 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
13381 case bp_longjmp_master
:
13382 /* These should never be enabled. */
13383 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
13386 case bp_std_terminate_master
:
13387 /* These should never be enabled. */
13388 printf_filtered (_("std::terminate Master Breakpoint: "
13389 "gdb should not stop!\n"));
13392 case bp_exception_master
:
13393 /* These should never be enabled. */
13394 printf_filtered (_("Exception Master Breakpoint: "
13395 "gdb should not stop!\n"));
13399 return PRINT_NOTHING
;
13403 internal_bkpt_print_mention (struct breakpoint
*b
)
13405 /* Nothing to mention. These breakpoints are internal. */
13408 /* Virtual table for momentary breakpoints */
13411 momentary_bkpt_re_set (struct breakpoint
*b
)
13413 /* Keep temporary breakpoints, which can be encountered when we step
13414 over a dlopen call and solib_add is resetting the breakpoints.
13415 Otherwise these should have been blown away via the cleanup chain
13416 or by breakpoint_init_inferior when we rerun the executable. */
13420 momentary_bkpt_check_status (bpstat bs
)
13422 /* Nothing. The point of these breakpoints is causing a stop. */
13425 static enum print_stop_action
13426 momentary_bkpt_print_it (bpstat bs
)
13428 return PRINT_UNKNOWN
;
13432 momentary_bkpt_print_mention (struct breakpoint
*b
)
13434 /* Nothing to mention. These breakpoints are internal. */
13437 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13439 It gets cleared already on the removal of the first one of such placed
13440 breakpoints. This is OK as they get all removed altogether. */
13443 longjmp_bkpt_dtor (struct breakpoint
*self
)
13445 struct thread_info
*tp
= find_thread_global_id (self
->thread
);
13448 tp
->initiating_frame
= null_frame_id
;
13450 momentary_breakpoint_ops
.dtor (self
);
13453 /* Specific methods for probe breakpoints. */
13456 bkpt_probe_insert_location (struct bp_location
*bl
)
13458 int v
= bkpt_insert_location (bl
);
13462 /* The insertion was successful, now let's set the probe's semaphore
13464 if (bl
->probe
.probe
->pops
->set_semaphore
!= NULL
)
13465 bl
->probe
.probe
->pops
->set_semaphore (bl
->probe
.probe
,
13474 bkpt_probe_remove_location (struct bp_location
*bl
,
13475 enum remove_bp_reason reason
)
13477 /* Let's clear the semaphore before removing the location. */
13478 if (bl
->probe
.probe
->pops
->clear_semaphore
!= NULL
)
13479 bl
->probe
.probe
->pops
->clear_semaphore (bl
->probe
.probe
,
13483 return bkpt_remove_location (bl
, reason
);
13487 bkpt_probe_create_sals_from_location (const struct event_location
*location
,
13488 struct linespec_result
*canonical
,
13489 enum bptype type_wanted
)
13491 struct linespec_sals lsal
;
13493 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
13494 lsal
.canonical
= xstrdup (event_location_to_string (canonical
->location
));
13495 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13499 bkpt_probe_decode_location (struct breakpoint
*b
,
13500 const struct event_location
*location
,
13501 struct program_space
*search_pspace
,
13502 struct symtabs_and_lines
*sals
)
13504 *sals
= parse_probes (location
, search_pspace
, NULL
);
13506 error (_("probe not found"));
13509 /* The breakpoint_ops structure to be used in tracepoints. */
13512 tracepoint_re_set (struct breakpoint
*b
)
13514 breakpoint_re_set_default (b
);
13518 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
13519 struct address_space
*aspace
, CORE_ADDR bp_addr
,
13520 const struct target_waitstatus
*ws
)
13522 /* By definition, the inferior does not report stops at
13528 tracepoint_print_one_detail (const struct breakpoint
*self
,
13529 struct ui_out
*uiout
)
13531 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13532 if (tp
->static_trace_marker_id
)
13534 gdb_assert (self
->type
== bp_static_tracepoint
);
13536 ui_out_text (uiout
, "\tmarker id is ");
13537 ui_out_field_string (uiout
, "static-tracepoint-marker-string-id",
13538 tp
->static_trace_marker_id
);
13539 ui_out_text (uiout
, "\n");
13544 tracepoint_print_mention (struct breakpoint
*b
)
13546 if (ui_out_is_mi_like_p (current_uiout
))
13551 case bp_tracepoint
:
13552 printf_filtered (_("Tracepoint"));
13553 printf_filtered (_(" %d"), b
->number
);
13555 case bp_fast_tracepoint
:
13556 printf_filtered (_("Fast tracepoint"));
13557 printf_filtered (_(" %d"), b
->number
);
13559 case bp_static_tracepoint
:
13560 printf_filtered (_("Static tracepoint"));
13561 printf_filtered (_(" %d"), b
->number
);
13564 internal_error (__FILE__
, __LINE__
,
13565 _("unhandled tracepoint type %d"), (int) b
->type
);
13572 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
13574 struct tracepoint
*tp
= (struct tracepoint
*) self
;
13576 if (self
->type
== bp_fast_tracepoint
)
13577 fprintf_unfiltered (fp
, "ftrace");
13578 else if (self
->type
== bp_static_tracepoint
)
13579 fprintf_unfiltered (fp
, "strace");
13580 else if (self
->type
== bp_tracepoint
)
13581 fprintf_unfiltered (fp
, "trace");
13583 internal_error (__FILE__
, __LINE__
,
13584 _("unhandled tracepoint type %d"), (int) self
->type
);
13586 fprintf_unfiltered (fp
, " %s",
13587 event_location_to_string (self
->location
));
13588 print_recreate_thread (self
, fp
);
13590 if (tp
->pass_count
)
13591 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
13595 tracepoint_create_sals_from_location (const struct event_location
*location
,
13596 struct linespec_result
*canonical
,
13597 enum bptype type_wanted
)
13599 create_sals_from_location_default (location
, canonical
, type_wanted
);
13603 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13604 struct linespec_result
*canonical
,
13606 char *extra_string
,
13607 enum bptype type_wanted
,
13608 enum bpdisp disposition
,
13610 int task
, int ignore_count
,
13611 const struct breakpoint_ops
*ops
,
13612 int from_tty
, int enabled
,
13613 int internal
, unsigned flags
)
13615 create_breakpoints_sal_default (gdbarch
, canonical
,
13616 cond_string
, extra_string
,
13618 disposition
, thread
, task
,
13619 ignore_count
, ops
, from_tty
,
13620 enabled
, internal
, flags
);
13624 tracepoint_decode_location (struct breakpoint
*b
,
13625 const struct event_location
*location
,
13626 struct program_space
*search_pspace
,
13627 struct symtabs_and_lines
*sals
)
13629 decode_location_default (b
, location
, search_pspace
, sals
);
13632 struct breakpoint_ops tracepoint_breakpoint_ops
;
13634 /* The breakpoint_ops structure to be use on tracepoints placed in a
13638 tracepoint_probe_create_sals_from_location
13639 (const struct event_location
*location
,
13640 struct linespec_result
*canonical
,
13641 enum bptype type_wanted
)
13643 /* We use the same method for breakpoint on probes. */
13644 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
13648 tracepoint_probe_decode_location (struct breakpoint
*b
,
13649 const struct event_location
*location
,
13650 struct program_space
*search_pspace
,
13651 struct symtabs_and_lines
*sals
)
13653 /* We use the same method for breakpoint on probes. */
13654 bkpt_probe_decode_location (b
, location
, search_pspace
, sals
);
13657 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
13659 /* Dprintf breakpoint_ops methods. */
13662 dprintf_re_set (struct breakpoint
*b
)
13664 breakpoint_re_set_default (b
);
13666 /* extra_string should never be non-NULL for dprintf. */
13667 gdb_assert (b
->extra_string
!= NULL
);
13669 /* 1 - connect to target 1, that can run breakpoint commands.
13670 2 - create a dprintf, which resolves fine.
13671 3 - disconnect from target 1
13672 4 - connect to target 2, that can NOT run breakpoint commands.
13674 After steps #3/#4, you'll want the dprintf command list to
13675 be updated, because target 1 and 2 may well return different
13676 answers for target_can_run_breakpoint_commands().
13677 Given absence of finer grained resetting, we get to do
13678 it all the time. */
13679 if (b
->extra_string
!= NULL
)
13680 update_dprintf_command_list (b
);
13683 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13686 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13688 fprintf_unfiltered (fp
, "dprintf %s,%s",
13689 event_location_to_string (tp
->location
),
13691 print_recreate_thread (tp
, fp
);
13694 /* Implement the "after_condition_true" breakpoint_ops method for
13697 dprintf's are implemented with regular commands in their command
13698 list, but we run the commands here instead of before presenting the
13699 stop to the user, as dprintf's don't actually cause a stop. This
13700 also makes it so that the commands of multiple dprintfs at the same
13701 address are all handled. */
13704 dprintf_after_condition_true (struct bpstats
*bs
)
13706 struct cleanup
*old_chain
;
13707 struct bpstats tmp_bs
= { NULL
};
13708 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13710 /* dprintf's never cause a stop. This wasn't set in the
13711 check_status hook instead because that would make the dprintf's
13712 condition not be evaluated. */
13715 /* Run the command list here. Take ownership of it instead of
13716 copying. We never want these commands to run later in
13717 bpstat_do_actions, if a breakpoint that causes a stop happens to
13718 be set at same address as this dprintf, or even if running the
13719 commands here throws. */
13720 tmp_bs
.commands
= bs
->commands
;
13721 bs
->commands
= NULL
;
13722 old_chain
= make_cleanup_decref_counted_command_line (&tmp_bs
.commands
);
13724 bpstat_do_actions_1 (&tmp_bs_p
);
13726 /* 'tmp_bs.commands' will usually be NULL by now, but
13727 bpstat_do_actions_1 may return early without processing the whole
13729 do_cleanups (old_chain
);
13732 /* The breakpoint_ops structure to be used on static tracepoints with
13736 strace_marker_create_sals_from_location (const struct event_location
*location
,
13737 struct linespec_result
*canonical
,
13738 enum bptype type_wanted
)
13740 struct linespec_sals lsal
;
13741 const char *arg_start
, *arg
;
13743 struct cleanup
*cleanup
;
13745 arg
= arg_start
= get_linespec_location (location
);
13746 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13748 str
= savestring (arg_start
, arg
- arg_start
);
13749 cleanup
= make_cleanup (xfree
, str
);
13750 canonical
->location
= new_linespec_location (&str
);
13751 do_cleanups (cleanup
);
13753 lsal
.canonical
= xstrdup (event_location_to_string (canonical
->location
));
13754 VEC_safe_push (linespec_sals
, canonical
->sals
, &lsal
);
13758 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13759 struct linespec_result
*canonical
,
13761 char *extra_string
,
13762 enum bptype type_wanted
,
13763 enum bpdisp disposition
,
13765 int task
, int ignore_count
,
13766 const struct breakpoint_ops
*ops
,
13767 int from_tty
, int enabled
,
13768 int internal
, unsigned flags
)
13771 struct linespec_sals
*lsal
= VEC_index (linespec_sals
,
13772 canonical
->sals
, 0);
13774 /* If the user is creating a static tracepoint by marker id
13775 (strace -m MARKER_ID), then store the sals index, so that
13776 breakpoint_re_set can try to match up which of the newly
13777 found markers corresponds to this one, and, don't try to
13778 expand multiple locations for each sal, given than SALS
13779 already should contain all sals for MARKER_ID. */
13781 for (i
= 0; i
< lsal
->sals
.nelts
; ++i
)
13783 struct symtabs_and_lines expanded
;
13784 struct tracepoint
*tp
;
13785 struct cleanup
*old_chain
;
13786 struct event_location
*location
;
13788 expanded
.nelts
= 1;
13789 expanded
.sals
= &lsal
->sals
.sals
[i
];
13791 location
= copy_event_location (canonical
->location
);
13792 old_chain
= make_cleanup_delete_event_location (location
);
13794 tp
= XCNEW (struct tracepoint
);
13795 init_breakpoint_sal (&tp
->base
, gdbarch
, expanded
,
13797 cond_string
, extra_string
,
13798 type_wanted
, disposition
,
13799 thread
, task
, ignore_count
, ops
,
13800 from_tty
, enabled
, internal
, flags
,
13801 canonical
->special_display
);
13802 /* Given that its possible to have multiple markers with
13803 the same string id, if the user is creating a static
13804 tracepoint by marker id ("strace -m MARKER_ID"), then
13805 store the sals index, so that breakpoint_re_set can
13806 try to match up which of the newly found markers
13807 corresponds to this one */
13808 tp
->static_trace_marker_id_idx
= i
;
13810 install_breakpoint (internal
, &tp
->base
, 0);
13812 discard_cleanups (old_chain
);
13817 strace_marker_decode_location (struct breakpoint
*b
,
13818 const struct event_location
*location
,
13819 struct program_space
*search_pspace
,
13820 struct symtabs_and_lines
*sals
)
13822 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13823 const char *s
= get_linespec_location (location
);
13825 *sals
= decode_static_tracepoint_spec (&s
);
13826 if (sals
->nelts
> tp
->static_trace_marker_id_idx
)
13828 sals
->sals
[0] = sals
->sals
[tp
->static_trace_marker_id_idx
];
13832 error (_("marker %s not found"), tp
->static_trace_marker_id
);
13835 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13838 strace_marker_p (struct breakpoint
*b
)
13840 return b
->ops
== &strace_marker_breakpoint_ops
;
13843 /* Delete a breakpoint and clean up all traces of it in the data
13847 delete_breakpoint (struct breakpoint
*bpt
)
13849 struct breakpoint
*b
;
13851 gdb_assert (bpt
!= NULL
);
13853 /* Has this bp already been deleted? This can happen because
13854 multiple lists can hold pointers to bp's. bpstat lists are
13857 One example of this happening is a watchpoint's scope bp. When
13858 the scope bp triggers, we notice that the watchpoint is out of
13859 scope, and delete it. We also delete its scope bp. But the
13860 scope bp is marked "auto-deleting", and is already on a bpstat.
13861 That bpstat is then checked for auto-deleting bp's, which are
13864 A real solution to this problem might involve reference counts in
13865 bp's, and/or giving them pointers back to their referencing
13866 bpstat's, and teaching delete_breakpoint to only free a bp's
13867 storage when no more references were extent. A cheaper bandaid
13869 if (bpt
->type
== bp_none
)
13872 /* At least avoid this stale reference until the reference counting
13873 of breakpoints gets resolved. */
13874 if (bpt
->related_breakpoint
!= bpt
)
13876 struct breakpoint
*related
;
13877 struct watchpoint
*w
;
13879 if (bpt
->type
== bp_watchpoint_scope
)
13880 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13881 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13882 w
= (struct watchpoint
*) bpt
;
13886 watchpoint_del_at_next_stop (w
);
13888 /* Unlink bpt from the bpt->related_breakpoint ring. */
13889 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13890 related
= related
->related_breakpoint
);
13891 related
->related_breakpoint
= bpt
->related_breakpoint
;
13892 bpt
->related_breakpoint
= bpt
;
13895 /* watch_command_1 creates a watchpoint but only sets its number if
13896 update_watchpoint succeeds in creating its bp_locations. If there's
13897 a problem in that process, we'll be asked to delete the half-created
13898 watchpoint. In that case, don't announce the deletion. */
13900 observer_notify_breakpoint_deleted (bpt
);
13902 if (breakpoint_chain
== bpt
)
13903 breakpoint_chain
= bpt
->next
;
13905 ALL_BREAKPOINTS (b
)
13906 if (b
->next
== bpt
)
13908 b
->next
= bpt
->next
;
13912 /* Be sure no bpstat's are pointing at the breakpoint after it's
13914 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13915 in all threads for now. Note that we cannot just remove bpstats
13916 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13917 commands are associated with the bpstat; if we remove it here,
13918 then the later call to bpstat_do_actions (&stop_bpstat); in
13919 event-top.c won't do anything, and temporary breakpoints with
13920 commands won't work. */
13922 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13924 /* Now that breakpoint is removed from breakpoint list, update the
13925 global location list. This will remove locations that used to
13926 belong to this breakpoint. Do this before freeing the breakpoint
13927 itself, since remove_breakpoint looks at location's owner. It
13928 might be better design to have location completely
13929 self-contained, but it's not the case now. */
13930 update_global_location_list (UGLL_DONT_INSERT
);
13932 bpt
->ops
->dtor (bpt
);
13933 /* On the chance that someone will soon try again to delete this
13934 same bp, we mark it as deleted before freeing its storage. */
13935 bpt
->type
= bp_none
;
13940 do_delete_breakpoint_cleanup (void *b
)
13942 delete_breakpoint ((struct breakpoint
*) b
);
13946 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
13948 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
13951 /* Iterator function to call a user-provided callback function once
13952 for each of B and its related breakpoints. */
13955 iterate_over_related_breakpoints (struct breakpoint
*b
,
13956 void (*function
) (struct breakpoint
*,
13960 struct breakpoint
*related
;
13965 struct breakpoint
*next
;
13967 /* FUNCTION may delete RELATED. */
13968 next
= related
->related_breakpoint
;
13970 if (next
== related
)
13972 /* RELATED is the last ring entry. */
13973 function (related
, data
);
13975 /* FUNCTION may have deleted it, so we'd never reach back to
13976 B. There's nothing left to do anyway, so just break
13981 function (related
, data
);
13985 while (related
!= b
);
13989 do_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
13991 delete_breakpoint (b
);
13994 /* A callback for map_breakpoint_numbers that calls
13995 delete_breakpoint. */
13998 do_map_delete_breakpoint (struct breakpoint
*b
, void *ignore
)
14000 iterate_over_related_breakpoints (b
, do_delete_breakpoint
, NULL
);
14004 delete_command (char *arg
, int from_tty
)
14006 struct breakpoint
*b
, *b_tmp
;
14012 int breaks_to_delete
= 0;
14014 /* Delete all breakpoints if no argument. Do not delete
14015 internal breakpoints, these have to be deleted with an
14016 explicit breakpoint number argument. */
14017 ALL_BREAKPOINTS (b
)
14018 if (user_breakpoint_p (b
))
14020 breaks_to_delete
= 1;
14024 /* Ask user only if there are some breakpoints to delete. */
14026 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
14028 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14029 if (user_breakpoint_p (b
))
14030 delete_breakpoint (b
);
14034 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
14037 /* Return true if all locations of B bound to PSPACE are pending. If
14038 PSPACE is NULL, all locations of all program spaces are
14042 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
14044 struct bp_location
*loc
;
14046 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
14047 if ((pspace
== NULL
14048 || loc
->pspace
== pspace
)
14049 && !loc
->shlib_disabled
14050 && !loc
->pspace
->executing_startup
)
14055 /* Subroutine of update_breakpoint_locations to simplify it.
14056 Return non-zero if multiple fns in list LOC have the same name.
14057 Null names are ignored. */
14060 ambiguous_names_p (struct bp_location
*loc
)
14062 struct bp_location
*l
;
14063 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
14064 (int (*) (const void *,
14065 const void *)) streq
,
14066 NULL
, xcalloc
, xfree
);
14068 for (l
= loc
; l
!= NULL
; l
= l
->next
)
14071 const char *name
= l
->function_name
;
14073 /* Allow for some names to be NULL, ignore them. */
14077 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
14079 /* NOTE: We can assume slot != NULL here because xcalloc never
14083 htab_delete (htab
);
14089 htab_delete (htab
);
14093 /* When symbols change, it probably means the sources changed as well,
14094 and it might mean the static tracepoint markers are no longer at
14095 the same address or line numbers they used to be at last we
14096 checked. Losing your static tracepoints whenever you rebuild is
14097 undesirable. This function tries to resync/rematch gdb static
14098 tracepoints with the markers on the target, for static tracepoints
14099 that have not been set by marker id. Static tracepoint that have
14100 been set by marker id are reset by marker id in breakpoint_re_set.
14103 1) For a tracepoint set at a specific address, look for a marker at
14104 the old PC. If one is found there, assume to be the same marker.
14105 If the name / string id of the marker found is different from the
14106 previous known name, assume that means the user renamed the marker
14107 in the sources, and output a warning.
14109 2) For a tracepoint set at a given line number, look for a marker
14110 at the new address of the old line number. If one is found there,
14111 assume to be the same marker. If the name / string id of the
14112 marker found is different from the previous known name, assume that
14113 means the user renamed the marker in the sources, and output a
14116 3) If a marker is no longer found at the same address or line, it
14117 may mean the marker no longer exists. But it may also just mean
14118 the code changed a bit. Maybe the user added a few lines of code
14119 that made the marker move up or down (in line number terms). Ask
14120 the target for info about the marker with the string id as we knew
14121 it. If found, update line number and address in the matching
14122 static tracepoint. This will get confused if there's more than one
14123 marker with the same ID (possible in UST, although unadvised
14124 precisely because it confuses tools). */
14126 static struct symtab_and_line
14127 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
14129 struct tracepoint
*tp
= (struct tracepoint
*) b
;
14130 struct static_tracepoint_marker marker
;
14135 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
14137 if (target_static_tracepoint_marker_at (pc
, &marker
))
14139 if (strcmp (tp
->static_trace_marker_id
, marker
.str_id
) != 0)
14140 warning (_("static tracepoint %d changed probed marker from %s to %s"),
14142 tp
->static_trace_marker_id
, marker
.str_id
);
14144 xfree (tp
->static_trace_marker_id
);
14145 tp
->static_trace_marker_id
= xstrdup (marker
.str_id
);
14146 release_static_tracepoint_marker (&marker
);
14151 /* Old marker wasn't found on target at lineno. Try looking it up
14153 if (!sal
.explicit_pc
14155 && sal
.symtab
!= NULL
14156 && tp
->static_trace_marker_id
!= NULL
)
14158 VEC(static_tracepoint_marker_p
) *markers
;
14161 = target_static_tracepoint_markers_by_strid (tp
->static_trace_marker_id
);
14163 if (!VEC_empty(static_tracepoint_marker_p
, markers
))
14165 struct symtab_and_line sal2
;
14166 struct symbol
*sym
;
14167 struct static_tracepoint_marker
*tpmarker
;
14168 struct ui_out
*uiout
= current_uiout
;
14169 struct explicit_location explicit_loc
;
14171 tpmarker
= VEC_index (static_tracepoint_marker_p
, markers
, 0);
14173 xfree (tp
->static_trace_marker_id
);
14174 tp
->static_trace_marker_id
= xstrdup (tpmarker
->str_id
);
14176 warning (_("marker for static tracepoint %d (%s) not "
14177 "found at previous line number"),
14178 b
->number
, tp
->static_trace_marker_id
);
14182 sal2
.pc
= tpmarker
->address
;
14184 sal2
= find_pc_line (tpmarker
->address
, 0);
14185 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
14186 ui_out_text (uiout
, "Now in ");
14189 ui_out_field_string (uiout
, "func",
14190 SYMBOL_PRINT_NAME (sym
));
14191 ui_out_text (uiout
, " at ");
14193 ui_out_field_string (uiout
, "file",
14194 symtab_to_filename_for_display (sal2
.symtab
));
14195 ui_out_text (uiout
, ":");
14197 if (ui_out_is_mi_like_p (uiout
))
14199 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
14201 ui_out_field_string (uiout
, "fullname", fullname
);
14204 ui_out_field_int (uiout
, "line", sal2
.line
);
14205 ui_out_text (uiout
, "\n");
14207 b
->loc
->line_number
= sal2
.line
;
14208 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
14210 delete_event_location (b
->location
);
14211 initialize_explicit_location (&explicit_loc
);
14212 explicit_loc
.source_filename
14213 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
14214 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
14215 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
14216 b
->location
= new_explicit_location (&explicit_loc
);
14218 /* Might be nice to check if function changed, and warn if
14221 release_static_tracepoint_marker (tpmarker
);
14227 /* Returns 1 iff locations A and B are sufficiently same that
14228 we don't need to report breakpoint as changed. */
14231 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
14235 if (a
->address
!= b
->address
)
14238 if (a
->shlib_disabled
!= b
->shlib_disabled
)
14241 if (a
->enabled
!= b
->enabled
)
14248 if ((a
== NULL
) != (b
== NULL
))
14254 /* Split all locations of B that are bound to PSPACE out of B's
14255 location list to a separate list and return that list's head. If
14256 PSPACE is NULL, hoist out all locations of B. */
14258 static struct bp_location
*
14259 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
14261 struct bp_location head
;
14262 struct bp_location
*i
= b
->loc
;
14263 struct bp_location
**i_link
= &b
->loc
;
14264 struct bp_location
*hoisted
= &head
;
14266 if (pspace
== NULL
)
14277 if (i
->pspace
== pspace
)
14292 /* Create new breakpoint locations for B (a hardware or software
14293 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
14294 zero, then B is a ranged breakpoint. Only recreates locations for
14295 FILTER_PSPACE. Locations of other program spaces are left
14299 update_breakpoint_locations (struct breakpoint
*b
,
14300 struct program_space
*filter_pspace
,
14301 struct symtabs_and_lines sals
,
14302 struct symtabs_and_lines sals_end
)
14305 struct bp_location
*existing_locations
;
14307 if (sals_end
.nelts
!= 0 && (sals
.nelts
!= 1 || sals_end
.nelts
!= 1))
14309 /* Ranged breakpoints have only one start location and one end
14311 b
->enable_state
= bp_disabled
;
14312 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
14313 "multiple locations found\n"),
14318 /* If there's no new locations, and all existing locations are
14319 pending, don't do anything. This optimizes the common case where
14320 all locations are in the same shared library, that was unloaded.
14321 We'd like to retain the location, so that when the library is
14322 loaded again, we don't loose the enabled/disabled status of the
14323 individual locations. */
14324 if (all_locations_are_pending (b
, filter_pspace
) && sals
.nelts
== 0)
14327 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
14329 for (i
= 0; i
< sals
.nelts
; ++i
)
14331 struct bp_location
*new_loc
;
14333 switch_to_program_space_and_thread (sals
.sals
[i
].pspace
);
14335 new_loc
= add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
14337 /* Reparse conditions, they might contain references to the
14339 if (b
->cond_string
!= NULL
)
14343 s
= b
->cond_string
;
14346 new_loc
->cond
= parse_exp_1 (&s
, sals
.sals
[i
].pc
,
14347 block_for_pc (sals
.sals
[i
].pc
),
14350 CATCH (e
, RETURN_MASK_ERROR
)
14352 warning (_("failed to reevaluate condition "
14353 "for breakpoint %d: %s"),
14354 b
->number
, e
.message
);
14355 new_loc
->enabled
= 0;
14360 if (sals_end
.nelts
)
14362 CORE_ADDR end
= find_breakpoint_range_end (sals_end
.sals
[0]);
14364 new_loc
->length
= end
- sals
.sals
[0].pc
+ 1;
14368 /* If possible, carry over 'disable' status from existing
14371 struct bp_location
*e
= existing_locations
;
14372 /* If there are multiple breakpoints with the same function name,
14373 e.g. for inline functions, comparing function names won't work.
14374 Instead compare pc addresses; this is just a heuristic as things
14375 may have moved, but in practice it gives the correct answer
14376 often enough until a better solution is found. */
14377 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
14379 for (; e
; e
= e
->next
)
14381 if (!e
->enabled
&& e
->function_name
)
14383 struct bp_location
*l
= b
->loc
;
14384 if (have_ambiguous_names
)
14386 for (; l
; l
= l
->next
)
14387 if (breakpoint_locations_match (e
, l
))
14395 for (; l
; l
= l
->next
)
14396 if (l
->function_name
14397 && strcmp (e
->function_name
, l
->function_name
) == 0)
14407 if (!locations_are_equal (existing_locations
, b
->loc
))
14408 observer_notify_breakpoint_modified (b
);
14411 /* Find the SaL locations corresponding to the given LOCATION.
14412 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
14414 static struct symtabs_and_lines
14415 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
14416 struct program_space
*search_pspace
, int *found
)
14418 struct symtabs_and_lines sals
= {0};
14419 struct gdb_exception exception
= exception_none
;
14421 gdb_assert (b
->ops
!= NULL
);
14425 b
->ops
->decode_location (b
, location
, search_pspace
, &sals
);
14427 CATCH (e
, RETURN_MASK_ERROR
)
14429 int not_found_and_ok
= 0;
14433 /* For pending breakpoints, it's expected that parsing will
14434 fail until the right shared library is loaded. User has
14435 already told to create pending breakpoints and don't need
14436 extra messages. If breakpoint is in bp_shlib_disabled
14437 state, then user already saw the message about that
14438 breakpoint being disabled, and don't want to see more
14440 if (e
.error
== NOT_FOUND_ERROR
14441 && (b
->condition_not_parsed
14443 && search_pspace
!= NULL
14444 && b
->loc
->pspace
!= search_pspace
)
14445 || (b
->loc
&& b
->loc
->shlib_disabled
)
14446 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
14447 || b
->enable_state
== bp_disabled
))
14448 not_found_and_ok
= 1;
14450 if (!not_found_and_ok
)
14452 /* We surely don't want to warn about the same breakpoint
14453 10 times. One solution, implemented here, is disable
14454 the breakpoint on error. Another solution would be to
14455 have separate 'warning emitted' flag. Since this
14456 happens only when a binary has changed, I don't know
14457 which approach is better. */
14458 b
->enable_state
= bp_disabled
;
14459 throw_exception (e
);
14464 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
14468 for (i
= 0; i
< sals
.nelts
; ++i
)
14469 resolve_sal_pc (&sals
.sals
[i
]);
14470 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
14472 char *cond_string
, *extra_string
;
14475 find_condition_and_thread (b
->extra_string
, sals
.sals
[0].pc
,
14476 &cond_string
, &thread
, &task
,
14478 gdb_assert (b
->cond_string
== NULL
);
14480 b
->cond_string
= cond_string
;
14481 b
->thread
= thread
;
14485 xfree (b
->extra_string
);
14486 b
->extra_string
= extra_string
;
14488 b
->condition_not_parsed
= 0;
14491 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
14492 sals
.sals
[0] = update_static_tracepoint (b
, sals
.sals
[0]);
14502 /* The default re_set method, for typical hardware or software
14503 breakpoints. Reevaluate the breakpoint and recreate its
14507 breakpoint_re_set_default (struct breakpoint
*b
)
14510 struct symtabs_and_lines sals
, sals_end
;
14511 struct symtabs_and_lines expanded
= {0};
14512 struct symtabs_and_lines expanded_end
= {0};
14513 struct program_space
*filter_pspace
= current_program_space
;
14515 sals
= location_to_sals (b
, b
->location
, filter_pspace
, &found
);
14518 make_cleanup (xfree
, sals
.sals
);
14522 if (b
->location_range_end
!= NULL
)
14524 sals_end
= location_to_sals (b
, b
->location_range_end
,
14525 filter_pspace
, &found
);
14528 make_cleanup (xfree
, sals_end
.sals
);
14529 expanded_end
= sals_end
;
14533 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
14536 /* Default method for creating SALs from an address string. It basically
14537 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14540 create_sals_from_location_default (const struct event_location
*location
,
14541 struct linespec_result
*canonical
,
14542 enum bptype type_wanted
)
14544 parse_breakpoint_sals (location
, canonical
);
14547 /* Call create_breakpoints_sal for the given arguments. This is the default
14548 function for the `create_breakpoints_sal' method of
14552 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
14553 struct linespec_result
*canonical
,
14555 char *extra_string
,
14556 enum bptype type_wanted
,
14557 enum bpdisp disposition
,
14559 int task
, int ignore_count
,
14560 const struct breakpoint_ops
*ops
,
14561 int from_tty
, int enabled
,
14562 int internal
, unsigned flags
)
14564 create_breakpoints_sal (gdbarch
, canonical
, cond_string
,
14566 type_wanted
, disposition
,
14567 thread
, task
, ignore_count
, ops
, from_tty
,
14568 enabled
, internal
, flags
);
14571 /* Decode the line represented by S by calling decode_line_full. This is the
14572 default function for the `decode_location' method of breakpoint_ops. */
14575 decode_location_default (struct breakpoint
*b
,
14576 const struct event_location
*location
,
14577 struct program_space
*search_pspace
,
14578 struct symtabs_and_lines
*sals
)
14580 struct linespec_result canonical
;
14582 init_linespec_result (&canonical
);
14583 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
14584 (struct symtab
*) NULL
, 0,
14585 &canonical
, multiple_symbols_all
,
14588 /* We should get 0 or 1 resulting SALs. */
14589 gdb_assert (VEC_length (linespec_sals
, canonical
.sals
) < 2);
14591 if (VEC_length (linespec_sals
, canonical
.sals
) > 0)
14593 struct linespec_sals
*lsal
;
14595 lsal
= VEC_index (linespec_sals
, canonical
.sals
, 0);
14596 *sals
= lsal
->sals
;
14597 /* Arrange it so the destructor does not free the
14599 lsal
->sals
.sals
= NULL
;
14602 destroy_linespec_result (&canonical
);
14605 /* Prepare the global context for a re-set of breakpoint B. */
14607 static struct cleanup
*
14608 prepare_re_set_context (struct breakpoint
*b
)
14610 input_radix
= b
->input_radix
;
14611 set_language (b
->language
);
14613 return make_cleanup (null_cleanup
, NULL
);
14616 /* Reset a breakpoint given it's struct breakpoint * BINT.
14617 The value we return ends up being the return value from catch_errors.
14618 Unused in this case. */
14621 breakpoint_re_set_one (void *bint
)
14623 /* Get past catch_errs. */
14624 struct breakpoint
*b
= (struct breakpoint
*) bint
;
14625 struct cleanup
*cleanups
;
14627 cleanups
= prepare_re_set_context (b
);
14628 b
->ops
->re_set (b
);
14629 do_cleanups (cleanups
);
14633 /* Re-set breakpoint locations for the current program space.
14634 Locations bound to other program spaces are left untouched. */
14637 breakpoint_re_set (void)
14639 struct breakpoint
*b
, *b_tmp
;
14640 enum language save_language
;
14641 int save_input_radix
;
14642 struct cleanup
*old_chain
;
14644 save_language
= current_language
->la_language
;
14645 save_input_radix
= input_radix
;
14646 old_chain
= save_current_space_and_thread ();
14648 /* Note: we must not try to insert locations until after all
14649 breakpoints have been re-set. Otherwise, e.g., when re-setting
14650 breakpoint 1, we'd insert the locations of breakpoint 2, which
14651 hadn't been re-set yet, and thus may have stale locations. */
14653 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
14655 /* Format possible error msg. */
14656 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
14658 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
14659 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
14660 do_cleanups (cleanups
);
14662 set_language (save_language
);
14663 input_radix
= save_input_radix
;
14665 jit_breakpoint_re_set ();
14667 do_cleanups (old_chain
);
14669 create_overlay_event_breakpoint ();
14670 create_longjmp_master_breakpoint ();
14671 create_std_terminate_master_breakpoint ();
14672 create_exception_master_breakpoint ();
14674 /* Now we can insert. */
14675 update_global_location_list (UGLL_MAY_INSERT
);
14678 /* Reset the thread number of this breakpoint:
14680 - If the breakpoint is for all threads, leave it as-is.
14681 - Else, reset it to the current thread for inferior_ptid. */
14683 breakpoint_re_set_thread (struct breakpoint
*b
)
14685 if (b
->thread
!= -1)
14687 if (in_thread_list (inferior_ptid
))
14688 b
->thread
= ptid_to_global_thread_id (inferior_ptid
);
14690 /* We're being called after following a fork. The new fork is
14691 selected as current, and unless this was a vfork will have a
14692 different program space from the original thread. Reset that
14694 b
->loc
->pspace
= current_program_space
;
14698 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14699 If from_tty is nonzero, it prints a message to that effect,
14700 which ends with a period (no newline). */
14703 set_ignore_count (int bptnum
, int count
, int from_tty
)
14705 struct breakpoint
*b
;
14710 ALL_BREAKPOINTS (b
)
14711 if (b
->number
== bptnum
)
14713 if (is_tracepoint (b
))
14715 if (from_tty
&& count
!= 0)
14716 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14721 b
->ignore_count
= count
;
14725 printf_filtered (_("Will stop next time "
14726 "breakpoint %d is reached."),
14728 else if (count
== 1)
14729 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14732 printf_filtered (_("Will ignore next %d "
14733 "crossings of breakpoint %d."),
14736 observer_notify_breakpoint_modified (b
);
14740 error (_("No breakpoint number %d."), bptnum
);
14743 /* Command to set ignore-count of breakpoint N to COUNT. */
14746 ignore_command (char *args
, int from_tty
)
14752 error_no_arg (_("a breakpoint number"));
14754 num
= get_number (&p
);
14756 error (_("bad breakpoint number: '%s'"), args
);
14758 error (_("Second argument (specified ignore-count) is missing."));
14760 set_ignore_count (num
,
14761 longest_to_int (value_as_long (parse_and_eval (p
))),
14764 printf_filtered ("\n");
14767 /* Call FUNCTION on each of the breakpoints
14768 whose numbers are given in ARGS. */
14771 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*,
14776 struct breakpoint
*b
, *tmp
;
14778 struct get_number_or_range_state state
;
14780 if (args
== 0 || *args
== '\0')
14781 error_no_arg (_("one or more breakpoint numbers"));
14783 init_number_or_range (&state
, args
);
14785 while (!state
.finished
)
14787 const char *p
= state
.string
;
14791 num
= get_number_or_range (&state
);
14794 warning (_("bad breakpoint number at or near '%s'"), p
);
14798 ALL_BREAKPOINTS_SAFE (b
, tmp
)
14799 if (b
->number
== num
)
14802 function (b
, data
);
14806 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
14811 static struct bp_location
*
14812 find_location_by_number (char *number
)
14814 char *dot
= strchr (number
, '.');
14818 struct breakpoint
*b
;
14819 struct bp_location
*loc
;
14824 bp_num
= get_number (&p1
);
14826 error (_("Bad breakpoint number '%s'"), number
);
14828 ALL_BREAKPOINTS (b
)
14829 if (b
->number
== bp_num
)
14834 if (!b
|| b
->number
!= bp_num
)
14835 error (_("Bad breakpoint number '%s'"), number
);
14838 loc_num
= get_number (&p1
);
14840 error (_("Bad breakpoint location number '%s'"), number
);
14844 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
14847 error (_("Bad breakpoint location number '%s'"), dot
+1);
14853 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14854 If from_tty is nonzero, it prints a message to that effect,
14855 which ends with a period (no newline). */
14858 disable_breakpoint (struct breakpoint
*bpt
)
14860 /* Never disable a watchpoint scope breakpoint; we want to
14861 hit them when we leave scope so we can delete both the
14862 watchpoint and its scope breakpoint at that time. */
14863 if (bpt
->type
== bp_watchpoint_scope
)
14866 bpt
->enable_state
= bp_disabled
;
14868 /* Mark breakpoint locations modified. */
14869 mark_breakpoint_modified (bpt
);
14871 if (target_supports_enable_disable_tracepoint ()
14872 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14874 struct bp_location
*location
;
14876 for (location
= bpt
->loc
; location
; location
= location
->next
)
14877 target_disable_tracepoint (location
);
14880 update_global_location_list (UGLL_DONT_INSERT
);
14882 observer_notify_breakpoint_modified (bpt
);
14885 /* A callback for iterate_over_related_breakpoints. */
14888 do_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
14890 disable_breakpoint (b
);
14893 /* A callback for map_breakpoint_numbers that calls
14894 disable_breakpoint. */
14897 do_map_disable_breakpoint (struct breakpoint
*b
, void *ignore
)
14899 iterate_over_related_breakpoints (b
, do_disable_breakpoint
, NULL
);
14903 disable_command (char *args
, int from_tty
)
14907 struct breakpoint
*bpt
;
14909 ALL_BREAKPOINTS (bpt
)
14910 if (user_breakpoint_p (bpt
))
14911 disable_breakpoint (bpt
);
14915 char *num
= extract_arg (&args
);
14919 if (strchr (num
, '.'))
14921 struct bp_location
*loc
= find_location_by_number (num
);
14928 mark_breakpoint_location_modified (loc
);
14930 if (target_supports_enable_disable_tracepoint ()
14931 && current_trace_status ()->running
&& loc
->owner
14932 && is_tracepoint (loc
->owner
))
14933 target_disable_tracepoint (loc
);
14935 update_global_location_list (UGLL_DONT_INSERT
);
14938 map_breakpoint_numbers (num
, do_map_disable_breakpoint
, NULL
);
14939 num
= extract_arg (&args
);
14945 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14948 int target_resources_ok
;
14950 if (bpt
->type
== bp_hardware_breakpoint
)
14953 i
= hw_breakpoint_used_count ();
14954 target_resources_ok
=
14955 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14957 if (target_resources_ok
== 0)
14958 error (_("No hardware breakpoint support in the target."));
14959 else if (target_resources_ok
< 0)
14960 error (_("Hardware breakpoints used exceeds limit."));
14963 if (is_watchpoint (bpt
))
14965 /* Initialize it just to avoid a GCC false warning. */
14966 enum enable_state orig_enable_state
= bp_disabled
;
14970 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14972 orig_enable_state
= bpt
->enable_state
;
14973 bpt
->enable_state
= bp_enabled
;
14974 update_watchpoint (w
, 1 /* reparse */);
14976 CATCH (e
, RETURN_MASK_ALL
)
14978 bpt
->enable_state
= orig_enable_state
;
14979 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14986 bpt
->enable_state
= bp_enabled
;
14988 /* Mark breakpoint locations modified. */
14989 mark_breakpoint_modified (bpt
);
14991 if (target_supports_enable_disable_tracepoint ()
14992 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14994 struct bp_location
*location
;
14996 for (location
= bpt
->loc
; location
; location
= location
->next
)
14997 target_enable_tracepoint (location
);
15000 bpt
->disposition
= disposition
;
15001 bpt
->enable_count
= count
;
15002 update_global_location_list (UGLL_MAY_INSERT
);
15004 observer_notify_breakpoint_modified (bpt
);
15009 enable_breakpoint (struct breakpoint
*bpt
)
15011 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
15015 do_enable_breakpoint (struct breakpoint
*bpt
, void *arg
)
15017 enable_breakpoint (bpt
);
15020 /* A callback for map_breakpoint_numbers that calls
15021 enable_breakpoint. */
15024 do_map_enable_breakpoint (struct breakpoint
*b
, void *ignore
)
15026 iterate_over_related_breakpoints (b
, do_enable_breakpoint
, NULL
);
15029 /* The enable command enables the specified breakpoints (or all defined
15030 breakpoints) so they once again become (or continue to be) effective
15031 in stopping the inferior. */
15034 enable_command (char *args
, int from_tty
)
15038 struct breakpoint
*bpt
;
15040 ALL_BREAKPOINTS (bpt
)
15041 if (user_breakpoint_p (bpt
))
15042 enable_breakpoint (bpt
);
15046 char *num
= extract_arg (&args
);
15050 if (strchr (num
, '.'))
15052 struct bp_location
*loc
= find_location_by_number (num
);
15059 mark_breakpoint_location_modified (loc
);
15061 if (target_supports_enable_disable_tracepoint ()
15062 && current_trace_status ()->running
&& loc
->owner
15063 && is_tracepoint (loc
->owner
))
15064 target_enable_tracepoint (loc
);
15066 update_global_location_list (UGLL_MAY_INSERT
);
15069 map_breakpoint_numbers (num
, do_map_enable_breakpoint
, NULL
);
15070 num
= extract_arg (&args
);
15075 /* This struct packages up disposition data for application to multiple
15085 do_enable_breakpoint_disp (struct breakpoint
*bpt
, void *arg
)
15087 struct disp_data disp_data
= *(struct disp_data
*) arg
;
15089 enable_breakpoint_disp (bpt
, disp_data
.disp
, disp_data
.count
);
15093 do_map_enable_once_breakpoint (struct breakpoint
*bpt
, void *ignore
)
15095 struct disp_data disp
= { disp_disable
, 1 };
15097 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15101 enable_once_command (char *args
, int from_tty
)
15103 map_breakpoint_numbers (args
, do_map_enable_once_breakpoint
, NULL
);
15107 do_map_enable_count_breakpoint (struct breakpoint
*bpt
, void *countptr
)
15109 struct disp_data disp
= { disp_disable
, *(int *) countptr
};
15111 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15115 enable_count_command (char *args
, int from_tty
)
15120 error_no_arg (_("hit count"));
15122 count
= get_number (&args
);
15124 map_breakpoint_numbers (args
, do_map_enable_count_breakpoint
, &count
);
15128 do_map_enable_delete_breakpoint (struct breakpoint
*bpt
, void *ignore
)
15130 struct disp_data disp
= { disp_del
, 1 };
15132 iterate_over_related_breakpoints (bpt
, do_enable_breakpoint_disp
, &disp
);
15136 enable_delete_command (char *args
, int from_tty
)
15138 map_breakpoint_numbers (args
, do_map_enable_delete_breakpoint
, NULL
);
15142 set_breakpoint_cmd (char *args
, int from_tty
)
15147 show_breakpoint_cmd (char *args
, int from_tty
)
15151 /* Invalidate last known value of any hardware watchpoint if
15152 the memory which that value represents has been written to by
15156 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
15157 CORE_ADDR addr
, ssize_t len
,
15158 const bfd_byte
*data
)
15160 struct breakpoint
*bp
;
15162 ALL_BREAKPOINTS (bp
)
15163 if (bp
->enable_state
== bp_enabled
15164 && bp
->type
== bp_hardware_watchpoint
)
15166 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
15168 if (wp
->val_valid
&& wp
->val
)
15170 struct bp_location
*loc
;
15172 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
15173 if (loc
->loc_type
== bp_loc_hardware_watchpoint
15174 && loc
->address
+ loc
->length
> addr
15175 && addr
+ len
> loc
->address
)
15177 value_free (wp
->val
);
15185 /* Create and insert a breakpoint for software single step. */
15188 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
15189 struct address_space
*aspace
,
15192 struct thread_info
*tp
= inferior_thread ();
15193 struct symtab_and_line sal
;
15194 CORE_ADDR pc
= next_pc
;
15196 if (tp
->control
.single_step_breakpoints
== NULL
)
15198 tp
->control
.single_step_breakpoints
15199 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
15202 sal
= find_pc_line (pc
, 0);
15204 sal
.section
= find_pc_overlay (pc
);
15205 sal
.explicit_pc
= 1;
15206 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
15208 update_global_location_list (UGLL_INSERT
);
15211 /* See breakpoint.h. */
15214 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
15215 struct address_space
*aspace
,
15218 struct bp_location
*loc
;
15220 for (loc
= bp
->loc
; loc
!= NULL
; loc
= loc
->next
)
15222 && breakpoint_location_address_match (loc
, aspace
, pc
))
15228 /* Check whether a software single-step breakpoint is inserted at
15232 single_step_breakpoint_inserted_here_p (struct address_space
*aspace
,
15235 struct breakpoint
*bpt
;
15237 ALL_BREAKPOINTS (bpt
)
15239 if (bpt
->type
== bp_single_step
15240 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
15246 /* Tracepoint-specific operations. */
15248 /* Set tracepoint count to NUM. */
15250 set_tracepoint_count (int num
)
15252 tracepoint_count
= num
;
15253 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
15257 trace_command (char *arg
, int from_tty
)
15259 struct breakpoint_ops
*ops
;
15260 struct event_location
*location
;
15261 struct cleanup
*back_to
;
15263 location
= string_to_event_location (&arg
, current_language
);
15264 back_to
= make_cleanup_delete_event_location (location
);
15265 if (location
!= NULL
15266 && event_location_type (location
) == PROBE_LOCATION
)
15267 ops
= &tracepoint_probe_breakpoint_ops
;
15269 ops
= &tracepoint_breakpoint_ops
;
15271 create_breakpoint (get_current_arch (),
15273 NULL
, 0, arg
, 1 /* parse arg */,
15275 bp_tracepoint
/* type_wanted */,
15276 0 /* Ignore count */,
15277 pending_break_support
,
15281 0 /* internal */, 0);
15282 do_cleanups (back_to
);
15286 ftrace_command (char *arg
, int from_tty
)
15288 struct event_location
*location
;
15289 struct cleanup
*back_to
;
15291 location
= string_to_event_location (&arg
, current_language
);
15292 back_to
= make_cleanup_delete_event_location (location
);
15293 create_breakpoint (get_current_arch (),
15295 NULL
, 0, arg
, 1 /* parse arg */,
15297 bp_fast_tracepoint
/* type_wanted */,
15298 0 /* Ignore count */,
15299 pending_break_support
,
15300 &tracepoint_breakpoint_ops
,
15303 0 /* internal */, 0);
15304 do_cleanups (back_to
);
15307 /* strace command implementation. Creates a static tracepoint. */
15310 strace_command (char *arg
, int from_tty
)
15312 struct breakpoint_ops
*ops
;
15313 struct event_location
*location
;
15314 struct cleanup
*back_to
;
15316 /* Decide if we are dealing with a static tracepoint marker (`-m'),
15317 or with a normal static tracepoint. */
15318 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
15320 ops
= &strace_marker_breakpoint_ops
;
15321 location
= new_linespec_location (&arg
);
15325 ops
= &tracepoint_breakpoint_ops
;
15326 location
= string_to_event_location (&arg
, current_language
);
15329 back_to
= make_cleanup_delete_event_location (location
);
15330 create_breakpoint (get_current_arch (),
15332 NULL
, 0, arg
, 1 /* parse arg */,
15334 bp_static_tracepoint
/* type_wanted */,
15335 0 /* Ignore count */,
15336 pending_break_support
,
15340 0 /* internal */, 0);
15341 do_cleanups (back_to
);
15344 /* Set up a fake reader function that gets command lines from a linked
15345 list that was acquired during tracepoint uploading. */
15347 static struct uploaded_tp
*this_utp
;
15348 static int next_cmd
;
15351 read_uploaded_action (void)
15355 VEC_iterate (char_ptr
, this_utp
->cmd_strings
, next_cmd
, rslt
);
15362 /* Given information about a tracepoint as recorded on a target (which
15363 can be either a live system or a trace file), attempt to create an
15364 equivalent GDB tracepoint. This is not a reliable process, since
15365 the target does not necessarily have all the information used when
15366 the tracepoint was originally defined. */
15368 struct tracepoint
*
15369 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
15371 char *addr_str
, small_buf
[100];
15372 struct tracepoint
*tp
;
15373 struct event_location
*location
;
15374 struct cleanup
*cleanup
;
15376 if (utp
->at_string
)
15377 addr_str
= utp
->at_string
;
15380 /* In the absence of a source location, fall back to raw
15381 address. Since there is no way to confirm that the address
15382 means the same thing as when the trace was started, warn the
15384 warning (_("Uploaded tracepoint %d has no "
15385 "source location, using raw address"),
15387 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
15388 addr_str
= small_buf
;
15391 /* There's not much we can do with a sequence of bytecodes. */
15392 if (utp
->cond
&& !utp
->cond_string
)
15393 warning (_("Uploaded tracepoint %d condition "
15394 "has no source form, ignoring it"),
15397 location
= string_to_event_location (&addr_str
, current_language
);
15398 cleanup
= make_cleanup_delete_event_location (location
);
15399 if (!create_breakpoint (get_current_arch (),
15401 utp
->cond_string
, -1, addr_str
,
15402 0 /* parse cond/thread */,
15404 utp
->type
/* type_wanted */,
15405 0 /* Ignore count */,
15406 pending_break_support
,
15407 &tracepoint_breakpoint_ops
,
15409 utp
->enabled
/* enabled */,
15411 CREATE_BREAKPOINT_FLAGS_INSERTED
))
15413 do_cleanups (cleanup
);
15417 do_cleanups (cleanup
);
15419 /* Get the tracepoint we just created. */
15420 tp
= get_tracepoint (tracepoint_count
);
15421 gdb_assert (tp
!= NULL
);
15425 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
15428 trace_pass_command (small_buf
, 0);
15431 /* If we have uploaded versions of the original commands, set up a
15432 special-purpose "reader" function and call the usual command line
15433 reader, then pass the result to the breakpoint command-setting
15435 if (!VEC_empty (char_ptr
, utp
->cmd_strings
))
15437 struct command_line
*cmd_list
;
15442 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
, NULL
);
15444 breakpoint_set_commands (&tp
->base
, cmd_list
);
15446 else if (!VEC_empty (char_ptr
, utp
->actions
)
15447 || !VEC_empty (char_ptr
, utp
->step_actions
))
15448 warning (_("Uploaded tracepoint %d actions "
15449 "have no source form, ignoring them"),
15452 /* Copy any status information that might be available. */
15453 tp
->base
.hit_count
= utp
->hit_count
;
15454 tp
->traceframe_usage
= utp
->traceframe_usage
;
15459 /* Print information on tracepoint number TPNUM_EXP, or all if
15463 tracepoints_info (char *args
, int from_tty
)
15465 struct ui_out
*uiout
= current_uiout
;
15468 num_printed
= breakpoint_1 (args
, 0, is_tracepoint
);
15470 if (num_printed
== 0)
15472 if (args
== NULL
|| *args
== '\0')
15473 ui_out_message (uiout
, 0, "No tracepoints.\n");
15475 ui_out_message (uiout
, 0, "No tracepoint matching '%s'.\n", args
);
15478 default_collect_info ();
15481 /* The 'enable trace' command enables tracepoints.
15482 Not supported by all targets. */
15484 enable_trace_command (char *args
, int from_tty
)
15486 enable_command (args
, from_tty
);
15489 /* The 'disable trace' command disables tracepoints.
15490 Not supported by all targets. */
15492 disable_trace_command (char *args
, int from_tty
)
15494 disable_command (args
, from_tty
);
15497 /* Remove a tracepoint (or all if no argument). */
15499 delete_trace_command (char *arg
, int from_tty
)
15501 struct breakpoint
*b
, *b_tmp
;
15507 int breaks_to_delete
= 0;
15509 /* Delete all breakpoints if no argument.
15510 Do not delete internal or call-dummy breakpoints, these
15511 have to be deleted with an explicit breakpoint number
15513 ALL_TRACEPOINTS (b
)
15514 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15516 breaks_to_delete
= 1;
15520 /* Ask user only if there are some breakpoints to delete. */
15522 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
15524 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15525 if (is_tracepoint (b
) && user_breakpoint_p (b
))
15526 delete_breakpoint (b
);
15530 map_breakpoint_numbers (arg
, do_map_delete_breakpoint
, NULL
);
15533 /* Helper function for trace_pass_command. */
15536 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
15538 tp
->pass_count
= count
;
15539 observer_notify_breakpoint_modified (&tp
->base
);
15541 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15542 tp
->base
.number
, count
);
15545 /* Set passcount for tracepoint.
15547 First command argument is passcount, second is tracepoint number.
15548 If tracepoint number omitted, apply to most recently defined.
15549 Also accepts special argument "all". */
15552 trace_pass_command (char *args
, int from_tty
)
15554 struct tracepoint
*t1
;
15555 unsigned int count
;
15557 if (args
== 0 || *args
== 0)
15558 error (_("passcount command requires an "
15559 "argument (count + optional TP num)"));
15561 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
15563 args
= skip_spaces (args
);
15564 if (*args
&& strncasecmp (args
, "all", 3) == 0)
15566 struct breakpoint
*b
;
15568 args
+= 3; /* Skip special argument "all". */
15570 error (_("Junk at end of arguments."));
15572 ALL_TRACEPOINTS (b
)
15574 t1
= (struct tracepoint
*) b
;
15575 trace_pass_set_count (t1
, count
, from_tty
);
15578 else if (*args
== '\0')
15580 t1
= get_tracepoint_by_number (&args
, NULL
);
15582 trace_pass_set_count (t1
, count
, from_tty
);
15586 struct get_number_or_range_state state
;
15588 init_number_or_range (&state
, args
);
15589 while (!state
.finished
)
15591 t1
= get_tracepoint_by_number (&args
, &state
);
15593 trace_pass_set_count (t1
, count
, from_tty
);
15598 struct tracepoint
*
15599 get_tracepoint (int num
)
15601 struct breakpoint
*t
;
15603 ALL_TRACEPOINTS (t
)
15604 if (t
->number
== num
)
15605 return (struct tracepoint
*) t
;
15610 /* Find the tracepoint with the given target-side number (which may be
15611 different from the tracepoint number after disconnecting and
15614 struct tracepoint
*
15615 get_tracepoint_by_number_on_target (int num
)
15617 struct breakpoint
*b
;
15619 ALL_TRACEPOINTS (b
)
15621 struct tracepoint
*t
= (struct tracepoint
*) b
;
15623 if (t
->number_on_target
== num
)
15630 /* Utility: parse a tracepoint number and look it up in the list.
15631 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15632 If the argument is missing, the most recent tracepoint
15633 (tracepoint_count) is returned. */
15635 struct tracepoint
*
15636 get_tracepoint_by_number (char **arg
,
15637 struct get_number_or_range_state
*state
)
15639 struct breakpoint
*t
;
15641 char *instring
= arg
== NULL
? NULL
: *arg
;
15645 gdb_assert (!state
->finished
);
15646 tpnum
= get_number_or_range (state
);
15648 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
15649 tpnum
= tracepoint_count
;
15651 tpnum
= get_number (arg
);
15655 if (instring
&& *instring
)
15656 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15659 printf_filtered (_("No previous tracepoint\n"));
15663 ALL_TRACEPOINTS (t
)
15664 if (t
->number
== tpnum
)
15666 return (struct tracepoint
*) t
;
15669 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
15674 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
15676 if (b
->thread
!= -1)
15677 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
15680 fprintf_unfiltered (fp
, " task %d", b
->task
);
15682 fprintf_unfiltered (fp
, "\n");
15685 /* Save information on user settable breakpoints (watchpoints, etc) to
15686 a new script file named FILENAME. If FILTER is non-NULL, call it
15687 on each breakpoint and only include the ones for which it returns
15691 save_breakpoints (char *filename
, int from_tty
,
15692 int (*filter
) (const struct breakpoint
*))
15694 struct breakpoint
*tp
;
15696 struct cleanup
*cleanup
;
15697 struct ui_file
*fp
;
15698 int extra_trace_bits
= 0;
15700 if (filename
== 0 || *filename
== 0)
15701 error (_("Argument required (file name in which to save)"));
15703 /* See if we have anything to save. */
15704 ALL_BREAKPOINTS (tp
)
15706 /* Skip internal and momentary breakpoints. */
15707 if (!user_breakpoint_p (tp
))
15710 /* If we have a filter, only save the breakpoints it accepts. */
15711 if (filter
&& !filter (tp
))
15716 if (is_tracepoint (tp
))
15718 extra_trace_bits
= 1;
15720 /* We can stop searching. */
15727 warning (_("Nothing to save."));
15731 filename
= tilde_expand (filename
);
15732 cleanup
= make_cleanup (xfree
, filename
);
15733 fp
= gdb_fopen (filename
, "w");
15735 error (_("Unable to open file '%s' for saving (%s)"),
15736 filename
, safe_strerror (errno
));
15737 make_cleanup_ui_file_delete (fp
);
15739 if (extra_trace_bits
)
15740 save_trace_state_variables (fp
);
15742 ALL_BREAKPOINTS (tp
)
15744 /* Skip internal and momentary breakpoints. */
15745 if (!user_breakpoint_p (tp
))
15748 /* If we have a filter, only save the breakpoints it accepts. */
15749 if (filter
&& !filter (tp
))
15752 tp
->ops
->print_recreate (tp
, fp
);
15754 /* Note, we can't rely on tp->number for anything, as we can't
15755 assume the recreated breakpoint numbers will match. Use $bpnum
15758 if (tp
->cond_string
)
15759 fprintf_unfiltered (fp
, " condition $bpnum %s\n", tp
->cond_string
);
15761 if (tp
->ignore_count
)
15762 fprintf_unfiltered (fp
, " ignore $bpnum %d\n", tp
->ignore_count
);
15764 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15766 fprintf_unfiltered (fp
, " commands\n");
15768 ui_out_redirect (current_uiout
, fp
);
15771 print_command_lines (current_uiout
, tp
->commands
->commands
, 2);
15773 CATCH (ex
, RETURN_MASK_ALL
)
15775 ui_out_redirect (current_uiout
, NULL
);
15776 throw_exception (ex
);
15780 ui_out_redirect (current_uiout
, NULL
);
15781 fprintf_unfiltered (fp
, " end\n");
15784 if (tp
->enable_state
== bp_disabled
)
15785 fprintf_unfiltered (fp
, "disable $bpnum\n");
15787 /* If this is a multi-location breakpoint, check if the locations
15788 should be individually disabled. Watchpoint locations are
15789 special, and not user visible. */
15790 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15792 struct bp_location
*loc
;
15795 for (loc
= tp
->loc
; loc
!= NULL
; loc
= loc
->next
, n
++)
15797 fprintf_unfiltered (fp
, "disable $bpnum.%d\n", n
);
15801 if (extra_trace_bits
&& *default_collect
)
15802 fprintf_unfiltered (fp
, "set default-collect %s\n", default_collect
);
15805 printf_filtered (_("Saved to file '%s'.\n"), filename
);
15806 do_cleanups (cleanup
);
15809 /* The `save breakpoints' command. */
15812 save_breakpoints_command (char *args
, int from_tty
)
15814 save_breakpoints (args
, from_tty
, NULL
);
15817 /* The `save tracepoints' command. */
15820 save_tracepoints_command (char *args
, int from_tty
)
15822 save_breakpoints (args
, from_tty
, is_tracepoint
);
15825 /* Create a vector of all tracepoints. */
15827 VEC(breakpoint_p
) *
15828 all_tracepoints (void)
15830 VEC(breakpoint_p
) *tp_vec
= 0;
15831 struct breakpoint
*tp
;
15833 ALL_TRACEPOINTS (tp
)
15835 VEC_safe_push (breakpoint_p
, tp_vec
, tp
);
15842 /* This help string is used to consolidate all the help string for specifying
15843 locations used by several commands. */
15845 #define LOCATION_HELP_STRING \
15846 "Linespecs are colon-separated lists of location parameters, such as\n\
15847 source filename, function name, label name, and line number.\n\
15848 Example: To specify the start of a label named \"the_top\" in the\n\
15849 function \"fact\" in the file \"factorial.c\", use\n\
15850 \"factorial.c:fact:the_top\".\n\
15852 Address locations begin with \"*\" and specify an exact address in the\n\
15853 program. Example: To specify the fourth byte past the start function\n\
15854 \"main\", use \"*main + 4\".\n\
15856 Explicit locations are similar to linespecs but use an option/argument\n\
15857 syntax to specify location parameters.\n\
15858 Example: To specify the start of the label named \"the_top\" in the\n\
15859 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15860 -function fact -label the_top\".\n"
15862 /* This help string is used for the break, hbreak, tbreak and thbreak
15863 commands. It is defined as a macro to prevent duplication.
15864 COMMAND should be a string constant containing the name of the
15867 #define BREAK_ARGS_HELP(command) \
15868 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15869 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15870 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15871 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15872 `-probe-dtrace' (for a DTrace probe).\n\
15873 LOCATION may be a linespec, address, or explicit location as described\n\
15876 With no LOCATION, uses current execution address of the selected\n\
15877 stack frame. This is useful for breaking on return to a stack frame.\n\
15879 THREADNUM is the number from \"info threads\".\n\
15880 CONDITION is a boolean expression.\n\
15881 \n" LOCATION_HELP_STRING "\n\
15882 Multiple breakpoints at one place are permitted, and useful if their\n\
15883 conditions are different.\n\
15885 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15887 /* List of subcommands for "catch". */
15888 static struct cmd_list_element
*catch_cmdlist
;
15890 /* List of subcommands for "tcatch". */
15891 static struct cmd_list_element
*tcatch_cmdlist
;
15894 add_catch_command (char *name
, char *docstring
,
15895 cmd_sfunc_ftype
*sfunc
,
15896 completer_ftype
*completer
,
15897 void *user_data_catch
,
15898 void *user_data_tcatch
)
15900 struct cmd_list_element
*command
;
15902 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
15904 set_cmd_sfunc (command
, sfunc
);
15905 set_cmd_context (command
, user_data_catch
);
15906 set_cmd_completer (command
, completer
);
15908 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
15910 set_cmd_sfunc (command
, sfunc
);
15911 set_cmd_context (command
, user_data_tcatch
);
15912 set_cmd_completer (command
, completer
);
15916 save_command (char *arg
, int from_tty
)
15918 printf_unfiltered (_("\"save\" must be followed by "
15919 "the name of a save subcommand.\n"));
15920 help_list (save_cmdlist
, "save ", all_commands
, gdb_stdout
);
15923 struct breakpoint
*
15924 iterate_over_breakpoints (int (*callback
) (struct breakpoint
*, void *),
15927 struct breakpoint
*b
, *b_tmp
;
15929 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
15931 if ((*callback
) (b
, data
))
15938 /* Zero if any of the breakpoint's locations could be a location where
15939 functions have been inlined, nonzero otherwise. */
15942 is_non_inline_function (struct breakpoint
*b
)
15944 /* The shared library event breakpoint is set on the address of a
15945 non-inline function. */
15946 if (b
->type
== bp_shlib_event
)
15952 /* Nonzero if the specified PC cannot be a location where functions
15953 have been inlined. */
15956 pc_at_non_inline_function (struct address_space
*aspace
, CORE_ADDR pc
,
15957 const struct target_waitstatus
*ws
)
15959 struct breakpoint
*b
;
15960 struct bp_location
*bl
;
15962 ALL_BREAKPOINTS (b
)
15964 if (!is_non_inline_function (b
))
15967 for (bl
= b
->loc
; bl
!= NULL
; bl
= bl
->next
)
15969 if (!bl
->shlib_disabled
15970 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15978 /* Remove any references to OBJFILE which is going to be freed. */
15981 breakpoint_free_objfile (struct objfile
*objfile
)
15983 struct bp_location
**locp
, *loc
;
15985 ALL_BP_LOCATIONS (loc
, locp
)
15986 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15987 loc
->symtab
= NULL
;
15991 initialize_breakpoint_ops (void)
15993 static int initialized
= 0;
15995 struct breakpoint_ops
*ops
;
16001 /* The breakpoint_ops structure to be inherit by all kinds of
16002 breakpoints (real breakpoints, i.e., user "break" breakpoints,
16003 internal and momentary breakpoints, etc.). */
16004 ops
= &bkpt_base_breakpoint_ops
;
16005 *ops
= base_breakpoint_ops
;
16006 ops
->re_set
= bkpt_re_set
;
16007 ops
->insert_location
= bkpt_insert_location
;
16008 ops
->remove_location
= bkpt_remove_location
;
16009 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
16010 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
16011 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
16012 ops
->decode_location
= bkpt_decode_location
;
16014 /* The breakpoint_ops structure to be used in regular breakpoints. */
16015 ops
= &bkpt_breakpoint_ops
;
16016 *ops
= bkpt_base_breakpoint_ops
;
16017 ops
->re_set
= bkpt_re_set
;
16018 ops
->resources_needed
= bkpt_resources_needed
;
16019 ops
->print_it
= bkpt_print_it
;
16020 ops
->print_mention
= bkpt_print_mention
;
16021 ops
->print_recreate
= bkpt_print_recreate
;
16023 /* Ranged breakpoints. */
16024 ops
= &ranged_breakpoint_ops
;
16025 *ops
= bkpt_breakpoint_ops
;
16026 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
16027 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
16028 ops
->print_it
= print_it_ranged_breakpoint
;
16029 ops
->print_one
= print_one_ranged_breakpoint
;
16030 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
16031 ops
->print_mention
= print_mention_ranged_breakpoint
;
16032 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
16034 /* Internal breakpoints. */
16035 ops
= &internal_breakpoint_ops
;
16036 *ops
= bkpt_base_breakpoint_ops
;
16037 ops
->re_set
= internal_bkpt_re_set
;
16038 ops
->check_status
= internal_bkpt_check_status
;
16039 ops
->print_it
= internal_bkpt_print_it
;
16040 ops
->print_mention
= internal_bkpt_print_mention
;
16042 /* Momentary breakpoints. */
16043 ops
= &momentary_breakpoint_ops
;
16044 *ops
= bkpt_base_breakpoint_ops
;
16045 ops
->re_set
= momentary_bkpt_re_set
;
16046 ops
->check_status
= momentary_bkpt_check_status
;
16047 ops
->print_it
= momentary_bkpt_print_it
;
16048 ops
->print_mention
= momentary_bkpt_print_mention
;
16050 /* Momentary breakpoints for bp_longjmp and bp_exception. */
16051 ops
= &longjmp_breakpoint_ops
;
16052 *ops
= momentary_breakpoint_ops
;
16053 ops
->dtor
= longjmp_bkpt_dtor
;
16055 /* Probe breakpoints. */
16056 ops
= &bkpt_probe_breakpoint_ops
;
16057 *ops
= bkpt_breakpoint_ops
;
16058 ops
->insert_location
= bkpt_probe_insert_location
;
16059 ops
->remove_location
= bkpt_probe_remove_location
;
16060 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
16061 ops
->decode_location
= bkpt_probe_decode_location
;
16064 ops
= &watchpoint_breakpoint_ops
;
16065 *ops
= base_breakpoint_ops
;
16066 ops
->dtor
= dtor_watchpoint
;
16067 ops
->re_set
= re_set_watchpoint
;
16068 ops
->insert_location
= insert_watchpoint
;
16069 ops
->remove_location
= remove_watchpoint
;
16070 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
16071 ops
->check_status
= check_status_watchpoint
;
16072 ops
->resources_needed
= resources_needed_watchpoint
;
16073 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
16074 ops
->print_it
= print_it_watchpoint
;
16075 ops
->print_mention
= print_mention_watchpoint
;
16076 ops
->print_recreate
= print_recreate_watchpoint
;
16077 ops
->explains_signal
= explains_signal_watchpoint
;
16079 /* Masked watchpoints. */
16080 ops
= &masked_watchpoint_breakpoint_ops
;
16081 *ops
= watchpoint_breakpoint_ops
;
16082 ops
->insert_location
= insert_masked_watchpoint
;
16083 ops
->remove_location
= remove_masked_watchpoint
;
16084 ops
->resources_needed
= resources_needed_masked_watchpoint
;
16085 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
16086 ops
->print_it
= print_it_masked_watchpoint
;
16087 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
16088 ops
->print_mention
= print_mention_masked_watchpoint
;
16089 ops
->print_recreate
= print_recreate_masked_watchpoint
;
16092 ops
= &tracepoint_breakpoint_ops
;
16093 *ops
= base_breakpoint_ops
;
16094 ops
->re_set
= tracepoint_re_set
;
16095 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
16096 ops
->print_one_detail
= tracepoint_print_one_detail
;
16097 ops
->print_mention
= tracepoint_print_mention
;
16098 ops
->print_recreate
= tracepoint_print_recreate
;
16099 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
16100 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
16101 ops
->decode_location
= tracepoint_decode_location
;
16103 /* Probe tracepoints. */
16104 ops
= &tracepoint_probe_breakpoint_ops
;
16105 *ops
= tracepoint_breakpoint_ops
;
16106 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
16107 ops
->decode_location
= tracepoint_probe_decode_location
;
16109 /* Static tracepoints with marker (`-m'). */
16110 ops
= &strace_marker_breakpoint_ops
;
16111 *ops
= tracepoint_breakpoint_ops
;
16112 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
16113 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
16114 ops
->decode_location
= strace_marker_decode_location
;
16116 /* Fork catchpoints. */
16117 ops
= &catch_fork_breakpoint_ops
;
16118 *ops
= base_breakpoint_ops
;
16119 ops
->insert_location
= insert_catch_fork
;
16120 ops
->remove_location
= remove_catch_fork
;
16121 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
16122 ops
->print_it
= print_it_catch_fork
;
16123 ops
->print_one
= print_one_catch_fork
;
16124 ops
->print_mention
= print_mention_catch_fork
;
16125 ops
->print_recreate
= print_recreate_catch_fork
;
16127 /* Vfork catchpoints. */
16128 ops
= &catch_vfork_breakpoint_ops
;
16129 *ops
= base_breakpoint_ops
;
16130 ops
->insert_location
= insert_catch_vfork
;
16131 ops
->remove_location
= remove_catch_vfork
;
16132 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
16133 ops
->print_it
= print_it_catch_vfork
;
16134 ops
->print_one
= print_one_catch_vfork
;
16135 ops
->print_mention
= print_mention_catch_vfork
;
16136 ops
->print_recreate
= print_recreate_catch_vfork
;
16138 /* Exec catchpoints. */
16139 ops
= &catch_exec_breakpoint_ops
;
16140 *ops
= base_breakpoint_ops
;
16141 ops
->dtor
= dtor_catch_exec
;
16142 ops
->insert_location
= insert_catch_exec
;
16143 ops
->remove_location
= remove_catch_exec
;
16144 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
16145 ops
->print_it
= print_it_catch_exec
;
16146 ops
->print_one
= print_one_catch_exec
;
16147 ops
->print_mention
= print_mention_catch_exec
;
16148 ops
->print_recreate
= print_recreate_catch_exec
;
16150 /* Solib-related catchpoints. */
16151 ops
= &catch_solib_breakpoint_ops
;
16152 *ops
= base_breakpoint_ops
;
16153 ops
->dtor
= dtor_catch_solib
;
16154 ops
->insert_location
= insert_catch_solib
;
16155 ops
->remove_location
= remove_catch_solib
;
16156 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
16157 ops
->check_status
= check_status_catch_solib
;
16158 ops
->print_it
= print_it_catch_solib
;
16159 ops
->print_one
= print_one_catch_solib
;
16160 ops
->print_mention
= print_mention_catch_solib
;
16161 ops
->print_recreate
= print_recreate_catch_solib
;
16163 ops
= &dprintf_breakpoint_ops
;
16164 *ops
= bkpt_base_breakpoint_ops
;
16165 ops
->re_set
= dprintf_re_set
;
16166 ops
->resources_needed
= bkpt_resources_needed
;
16167 ops
->print_it
= bkpt_print_it
;
16168 ops
->print_mention
= bkpt_print_mention
;
16169 ops
->print_recreate
= dprintf_print_recreate
;
16170 ops
->after_condition_true
= dprintf_after_condition_true
;
16171 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
16174 /* Chain containing all defined "enable breakpoint" subcommands. */
16176 static struct cmd_list_element
*enablebreaklist
= NULL
;
16179 _initialize_breakpoint (void)
16181 struct cmd_list_element
*c
;
16183 initialize_breakpoint_ops ();
16185 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
16186 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile
);
16187 observer_attach_memory_changed (invalidate_bp_value_on_memory_change
);
16189 breakpoint_objfile_key
16190 = register_objfile_data_with_cleanup (NULL
, free_breakpoint_probes
);
16192 breakpoint_chain
= 0;
16193 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
16194 before a breakpoint is set. */
16195 breakpoint_count
= 0;
16197 tracepoint_count
= 0;
16199 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
16200 Set ignore-count of breakpoint number N to COUNT.\n\
16201 Usage is `ignore N COUNT'."));
16203 add_com ("commands", class_breakpoint
, commands_command
, _("\
16204 Set commands to be executed when a breakpoint is hit.\n\
16205 Give breakpoint number as argument after \"commands\".\n\
16206 With no argument, the targeted breakpoint is the last one set.\n\
16207 The commands themselves follow starting on the next line.\n\
16208 Type a line containing \"end\" to indicate the end of them.\n\
16209 Give \"silent\" as the first line to make the breakpoint silent;\n\
16210 then no output is printed when it is hit, except what the commands print."));
16212 c
= add_com ("condition", class_breakpoint
, condition_command
, _("\
16213 Specify breakpoint number N to break only if COND is true.\n\
16214 Usage is `condition N COND', where N is an integer and COND is an\n\
16215 expression to be evaluated whenever breakpoint N is reached."));
16216 set_cmd_completer (c
, condition_completer
);
16218 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
16219 Set a temporary breakpoint.\n\
16220 Like \"break\" except the breakpoint is only temporary,\n\
16221 so it will be deleted when hit. Equivalent to \"break\" followed\n\
16222 by using \"enable delete\" on the breakpoint number.\n\
16224 BREAK_ARGS_HELP ("tbreak")));
16225 set_cmd_completer (c
, location_completer
);
16227 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
16228 Set a hardware assisted breakpoint.\n\
16229 Like \"break\" except the breakpoint requires hardware support,\n\
16230 some target hardware may not have this support.\n\
16232 BREAK_ARGS_HELP ("hbreak")));
16233 set_cmd_completer (c
, location_completer
);
16235 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
16236 Set a temporary hardware assisted breakpoint.\n\
16237 Like \"hbreak\" except the breakpoint is only temporary,\n\
16238 so it will be deleted when hit.\n\
16240 BREAK_ARGS_HELP ("thbreak")));
16241 set_cmd_completer (c
, location_completer
);
16243 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
16244 Enable some breakpoints.\n\
16245 Give breakpoint numbers (separated by spaces) as arguments.\n\
16246 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16247 This is used to cancel the effect of the \"disable\" command.\n\
16248 With a subcommand you can enable temporarily."),
16249 &enablelist
, "enable ", 1, &cmdlist
);
16251 add_com_alias ("en", "enable", class_breakpoint
, 1);
16253 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
16254 Enable some breakpoints.\n\
16255 Give breakpoint numbers (separated by spaces) as arguments.\n\
16256 This is used to cancel the effect of the \"disable\" command.\n\
16257 May be abbreviated to simply \"enable\".\n"),
16258 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
16260 add_cmd ("once", no_class
, enable_once_command
, _("\
16261 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16262 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16265 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16266 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16267 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16270 add_cmd ("count", no_class
, enable_count_command
, _("\
16271 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16272 If a breakpoint is hit while enabled in this fashion,\n\
16273 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16276 add_cmd ("delete", no_class
, enable_delete_command
, _("\
16277 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16278 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16281 add_cmd ("once", no_class
, enable_once_command
, _("\
16282 Enable breakpoints for one hit. Give breakpoint numbers.\n\
16283 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16286 add_cmd ("count", no_class
, enable_count_command
, _("\
16287 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16288 If a breakpoint is hit while enabled in this fashion,\n\
16289 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16292 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
16293 Disable some breakpoints.\n\
16294 Arguments are breakpoint numbers with spaces in between.\n\
16295 To disable all breakpoints, give no argument.\n\
16296 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
16297 &disablelist
, "disable ", 1, &cmdlist
);
16298 add_com_alias ("dis", "disable", class_breakpoint
, 1);
16299 add_com_alias ("disa", "disable", class_breakpoint
, 1);
16301 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
16302 Disable some breakpoints.\n\
16303 Arguments are breakpoint numbers with spaces in between.\n\
16304 To disable all breakpoints, give no argument.\n\
16305 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
16306 This command may be abbreviated \"disable\"."),
16309 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
16310 Delete some breakpoints or auto-display expressions.\n\
16311 Arguments are breakpoint numbers with spaces in between.\n\
16312 To delete all breakpoints, give no argument.\n\
16314 Also a prefix command for deletion of other GDB objects.\n\
16315 The \"unset\" command is also an alias for \"delete\"."),
16316 &deletelist
, "delete ", 1, &cmdlist
);
16317 add_com_alias ("d", "delete", class_breakpoint
, 1);
16318 add_com_alias ("del", "delete", class_breakpoint
, 1);
16320 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
16321 Delete some breakpoints or auto-display expressions.\n\
16322 Arguments are breakpoint numbers with spaces in between.\n\
16323 To delete all breakpoints, give no argument.\n\
16324 This command may be abbreviated \"delete\"."),
16327 add_com ("clear", class_breakpoint
, clear_command
, _("\
16328 Clear breakpoint at specified location.\n\
16329 Argument may be a linespec, explicit, or address location as described below.\n\
16331 With no argument, clears all breakpoints in the line that the selected frame\n\
16332 is executing in.\n"
16333 "\n" LOCATION_HELP_STRING
"\n\
16334 See also the \"delete\" command which clears breakpoints by number."));
16335 add_com_alias ("cl", "clear", class_breakpoint
, 1);
16337 c
= add_com ("break", class_breakpoint
, break_command
, _("\
16338 Set breakpoint at specified location.\n"
16339 BREAK_ARGS_HELP ("break")));
16340 set_cmd_completer (c
, location_completer
);
16342 add_com_alias ("b", "break", class_run
, 1);
16343 add_com_alias ("br", "break", class_run
, 1);
16344 add_com_alias ("bre", "break", class_run
, 1);
16345 add_com_alias ("brea", "break", class_run
, 1);
16349 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
16350 Break in function/address or break at a line in the current file."),
16351 &stoplist
, "stop ", 1, &cmdlist
);
16352 add_cmd ("in", class_breakpoint
, stopin_command
,
16353 _("Break in function or address."), &stoplist
);
16354 add_cmd ("at", class_breakpoint
, stopat_command
,
16355 _("Break at a line in the current file."), &stoplist
);
16356 add_com ("status", class_info
, breakpoints_info
, _("\
16357 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16358 The \"Type\" column indicates one of:\n\
16359 \tbreakpoint - normal breakpoint\n\
16360 \twatchpoint - watchpoint\n\
16361 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16362 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16363 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16364 address and file/line number respectively.\n\
16366 Convenience variable \"$_\" and default examine address for \"x\"\n\
16367 are set to the address of the last breakpoint listed unless the command\n\
16368 is prefixed with \"server \".\n\n\
16369 Convenience variable \"$bpnum\" contains the number of the last\n\
16370 breakpoint set."));
16373 add_info ("breakpoints", breakpoints_info
, _("\
16374 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
16375 The \"Type\" column indicates one of:\n\
16376 \tbreakpoint - normal breakpoint\n\
16377 \twatchpoint - watchpoint\n\
16378 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16379 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16380 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16381 address and file/line number respectively.\n\
16383 Convenience variable \"$_\" and default examine address for \"x\"\n\
16384 are set to the address of the last breakpoint listed unless the command\n\
16385 is prefixed with \"server \".\n\n\
16386 Convenience variable \"$bpnum\" contains the number of the last\n\
16387 breakpoint set."));
16389 add_info_alias ("b", "breakpoints", 1);
16391 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
16392 Status of all breakpoints, or breakpoint number NUMBER.\n\
16393 The \"Type\" column indicates one of:\n\
16394 \tbreakpoint - normal breakpoint\n\
16395 \twatchpoint - watchpoint\n\
16396 \tlongjmp - internal breakpoint used to step through longjmp()\n\
16397 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16398 \tuntil - internal breakpoint used by the \"until\" command\n\
16399 \tfinish - internal breakpoint used by the \"finish\" command\n\
16400 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16401 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16402 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
16403 address and file/line number respectively.\n\
16405 Convenience variable \"$_\" and default examine address for \"x\"\n\
16406 are set to the address of the last breakpoint listed unless the command\n\
16407 is prefixed with \"server \".\n\n\
16408 Convenience variable \"$bpnum\" contains the number of the last\n\
16410 &maintenanceinfolist
);
16412 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
16413 Set catchpoints to catch events."),
16414 &catch_cmdlist
, "catch ",
16415 0/*allow-unknown*/, &cmdlist
);
16417 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
16418 Set temporary catchpoints to catch events."),
16419 &tcatch_cmdlist
, "tcatch ",
16420 0/*allow-unknown*/, &cmdlist
);
16422 add_catch_command ("fork", _("Catch calls to fork."),
16423 catch_fork_command_1
,
16425 (void *) (uintptr_t) catch_fork_permanent
,
16426 (void *) (uintptr_t) catch_fork_temporary
);
16427 add_catch_command ("vfork", _("Catch calls to vfork."),
16428 catch_fork_command_1
,
16430 (void *) (uintptr_t) catch_vfork_permanent
,
16431 (void *) (uintptr_t) catch_vfork_temporary
);
16432 add_catch_command ("exec", _("Catch calls to exec."),
16433 catch_exec_command_1
,
16437 add_catch_command ("load", _("Catch loads of shared libraries.\n\
16438 Usage: catch load [REGEX]\n\
16439 If REGEX is given, only stop for libraries matching the regular expression."),
16440 catch_load_command_1
,
16444 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16445 Usage: catch unload [REGEX]\n\
16446 If REGEX is given, only stop for libraries matching the regular expression."),
16447 catch_unload_command_1
,
16452 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
16453 Set a watchpoint for an expression.\n\
16454 Usage: watch [-l|-location] EXPRESSION\n\
16455 A watchpoint stops execution of your program whenever the value of\n\
16456 an expression changes.\n\
16457 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16458 the memory to which it refers."));
16459 set_cmd_completer (c
, expression_completer
);
16461 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
16462 Set a read watchpoint for an expression.\n\
16463 Usage: rwatch [-l|-location] EXPRESSION\n\
16464 A watchpoint stops execution of your program whenever the value of\n\
16465 an expression is read.\n\
16466 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16467 the memory to which it refers."));
16468 set_cmd_completer (c
, expression_completer
);
16470 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
16471 Set a watchpoint for an expression.\n\
16472 Usage: awatch [-l|-location] EXPRESSION\n\
16473 A watchpoint stops execution of your program whenever the value of\n\
16474 an expression is either read or written.\n\
16475 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16476 the memory to which it refers."));
16477 set_cmd_completer (c
, expression_completer
);
16479 add_info ("watchpoints", watchpoints_info
, _("\
16480 Status of specified watchpoints (all watchpoints if no argument)."));
16482 /* XXX: cagney/2005-02-23: This should be a boolean, and should
16483 respond to changes - contrary to the description. */
16484 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
16485 &can_use_hw_watchpoints
, _("\
16486 Set debugger's willingness to use watchpoint hardware."), _("\
16487 Show debugger's willingness to use watchpoint hardware."), _("\
16488 If zero, gdb will not use hardware for new watchpoints, even if\n\
16489 such is available. (However, any hardware watchpoints that were\n\
16490 created before setting this to nonzero, will continue to use watchpoint\n\
16493 show_can_use_hw_watchpoints
,
16494 &setlist
, &showlist
);
16496 can_use_hw_watchpoints
= 1;
16498 /* Tracepoint manipulation commands. */
16500 c
= add_com ("trace", class_breakpoint
, trace_command
, _("\
16501 Set a tracepoint at specified location.\n\
16503 BREAK_ARGS_HELP ("trace") "\n\
16504 Do \"help tracepoints\" for info on other tracepoint commands."));
16505 set_cmd_completer (c
, location_completer
);
16507 add_com_alias ("tp", "trace", class_alias
, 0);
16508 add_com_alias ("tr", "trace", class_alias
, 1);
16509 add_com_alias ("tra", "trace", class_alias
, 1);
16510 add_com_alias ("trac", "trace", class_alias
, 1);
16512 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
16513 Set a fast tracepoint at specified location.\n\
16515 BREAK_ARGS_HELP ("ftrace") "\n\
16516 Do \"help tracepoints\" for info on other tracepoint commands."));
16517 set_cmd_completer (c
, location_completer
);
16519 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
16520 Set a static tracepoint at location or marker.\n\
16522 strace [LOCATION] [if CONDITION]\n\
16523 LOCATION may be a linespec, explicit, or address location (described below) \n\
16524 or -m MARKER_ID.\n\n\
16525 If a marker id is specified, probe the marker with that name. With\n\
16526 no LOCATION, uses current execution address of the selected stack frame.\n\
16527 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16528 This collects arbitrary user data passed in the probe point call to the\n\
16529 tracing library. You can inspect it when analyzing the trace buffer,\n\
16530 by printing the $_sdata variable like any other convenience variable.\n\
16532 CONDITION is a boolean expression.\n\
16533 \n" LOCATION_HELP_STRING
"\n\
16534 Multiple tracepoints at one place are permitted, and useful if their\n\
16535 conditions are different.\n\
16537 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16538 Do \"help tracepoints\" for info on other tracepoint commands."));
16539 set_cmd_completer (c
, location_completer
);
16541 add_info ("tracepoints", tracepoints_info
, _("\
16542 Status of specified tracepoints (all tracepoints if no argument).\n\
16543 Convenience variable \"$tpnum\" contains the number of the\n\
16544 last tracepoint set."));
16546 add_info_alias ("tp", "tracepoints", 1);
16548 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
16549 Delete specified tracepoints.\n\
16550 Arguments are tracepoint numbers, separated by spaces.\n\
16551 No argument means delete all tracepoints."),
16553 add_alias_cmd ("tr", "tracepoints", class_trace
, 1, &deletelist
);
16555 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
16556 Disable specified tracepoints.\n\
16557 Arguments are tracepoint numbers, separated by spaces.\n\
16558 No argument means disable all tracepoints."),
16560 deprecate_cmd (c
, "disable");
16562 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
16563 Enable specified tracepoints.\n\
16564 Arguments are tracepoint numbers, separated by spaces.\n\
16565 No argument means enable all tracepoints."),
16567 deprecate_cmd (c
, "enable");
16569 add_com ("passcount", class_trace
, trace_pass_command
, _("\
16570 Set the passcount for a tracepoint.\n\
16571 The trace will end when the tracepoint has been passed 'count' times.\n\
16572 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16573 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16575 add_prefix_cmd ("save", class_breakpoint
, save_command
,
16576 _("Save breakpoint definitions as a script."),
16577 &save_cmdlist
, "save ",
16578 0/*allow-unknown*/, &cmdlist
);
16580 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
16581 Save current breakpoint definitions as a script.\n\
16582 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16583 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16584 session to restore them."),
16586 set_cmd_completer (c
, filename_completer
);
16588 c
= add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
16589 Save current tracepoint definitions as a script.\n\
16590 Use the 'source' command in another debug session to restore them."),
16592 set_cmd_completer (c
, filename_completer
);
16594 c
= add_com_alias ("save-tracepoints", "save tracepoints", class_trace
, 0);
16595 deprecate_cmd (c
, "save tracepoints");
16597 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
16598 Breakpoint specific settings\n\
16599 Configure various breakpoint-specific variables such as\n\
16600 pending breakpoint behavior"),
16601 &breakpoint_set_cmdlist
, "set breakpoint ",
16602 0/*allow-unknown*/, &setlist
);
16603 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
16604 Breakpoint specific settings\n\
16605 Configure various breakpoint-specific variables such as\n\
16606 pending breakpoint behavior"),
16607 &breakpoint_show_cmdlist
, "show breakpoint ",
16608 0/*allow-unknown*/, &showlist
);
16610 add_setshow_auto_boolean_cmd ("pending", no_class
,
16611 &pending_break_support
, _("\
16612 Set debugger's behavior regarding pending breakpoints."), _("\
16613 Show debugger's behavior regarding pending breakpoints."), _("\
16614 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16615 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16616 an error. If auto, an unrecognized breakpoint location results in a\n\
16617 user-query to see if a pending breakpoint should be created."),
16619 show_pending_break_support
,
16620 &breakpoint_set_cmdlist
,
16621 &breakpoint_show_cmdlist
);
16623 pending_break_support
= AUTO_BOOLEAN_AUTO
;
16625 add_setshow_boolean_cmd ("auto-hw", no_class
,
16626 &automatic_hardware_breakpoints
, _("\
16627 Set automatic usage of hardware breakpoints."), _("\
16628 Show automatic usage of hardware breakpoints."), _("\
16629 If set, the debugger will automatically use hardware breakpoints for\n\
16630 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16631 a warning will be emitted for such breakpoints."),
16633 show_automatic_hardware_breakpoints
,
16634 &breakpoint_set_cmdlist
,
16635 &breakpoint_show_cmdlist
);
16637 add_setshow_boolean_cmd ("always-inserted", class_support
,
16638 &always_inserted_mode
, _("\
16639 Set mode for inserting breakpoints."), _("\
16640 Show mode for inserting breakpoints."), _("\
16641 When this mode is on, breakpoints are inserted immediately as soon as\n\
16642 they're created, kept inserted even when execution stops, and removed\n\
16643 only when the user deletes them. When this mode is off (the default),\n\
16644 breakpoints are inserted only when execution continues, and removed\n\
16645 when execution stops."),
16647 &show_always_inserted_mode
,
16648 &breakpoint_set_cmdlist
,
16649 &breakpoint_show_cmdlist
);
16651 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
16652 condition_evaluation_enums
,
16653 &condition_evaluation_mode_1
, _("\
16654 Set mode of breakpoint condition evaluation."), _("\
16655 Show mode of breakpoint condition evaluation."), _("\
16656 When this is set to \"host\", breakpoint conditions will be\n\
16657 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16658 breakpoint conditions will be downloaded to the target (if the target\n\
16659 supports such feature) and conditions will be evaluated on the target's side.\n\
16660 If this is set to \"auto\" (default), this will be automatically set to\n\
16661 \"target\" if it supports condition evaluation, otherwise it will\n\
16662 be set to \"gdb\""),
16663 &set_condition_evaluation_mode
,
16664 &show_condition_evaluation_mode
,
16665 &breakpoint_set_cmdlist
,
16666 &breakpoint_show_cmdlist
);
16668 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
16669 Set a breakpoint for an address range.\n\
16670 break-range START-LOCATION, END-LOCATION\n\
16671 where START-LOCATION and END-LOCATION can be one of the following:\n\
16672 LINENUM, for that line in the current file,\n\
16673 FILE:LINENUM, for that line in that file,\n\
16674 +OFFSET, for that number of lines after the current line\n\
16675 or the start of the range\n\
16676 FUNCTION, for the first line in that function,\n\
16677 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16678 *ADDRESS, for the instruction at that address.\n\
16680 The breakpoint will stop execution of the inferior whenever it executes\n\
16681 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16682 range (including START-LOCATION and END-LOCATION)."));
16684 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16685 Set a dynamic printf at specified location.\n\
16686 dprintf location,format string,arg1,arg2,...\n\
16687 location may be a linespec, explicit, or address location.\n"
16688 "\n" LOCATION_HELP_STRING
));
16689 set_cmd_completer (c
, location_completer
);
16691 add_setshow_enum_cmd ("dprintf-style", class_support
,
16692 dprintf_style_enums
, &dprintf_style
, _("\
16693 Set the style of usage for dynamic printf."), _("\
16694 Show the style of usage for dynamic printf."), _("\
16695 This setting chooses how GDB will do a dynamic printf.\n\
16696 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16697 console, as with the \"printf\" command.\n\
16698 If the value is \"call\", the print is done by calling a function in your\n\
16699 program; by default printf(), but you can choose a different function or\n\
16700 output stream by setting dprintf-function and dprintf-channel."),
16701 update_dprintf_commands
, NULL
,
16702 &setlist
, &showlist
);
16704 dprintf_function
= xstrdup ("printf");
16705 add_setshow_string_cmd ("dprintf-function", class_support
,
16706 &dprintf_function
, _("\
16707 Set the function to use for dynamic printf"), _("\
16708 Show the function to use for dynamic printf"), NULL
,
16709 update_dprintf_commands
, NULL
,
16710 &setlist
, &showlist
);
16712 dprintf_channel
= xstrdup ("");
16713 add_setshow_string_cmd ("dprintf-channel", class_support
,
16714 &dprintf_channel
, _("\
16715 Set the channel to use for dynamic printf"), _("\
16716 Show the channel to use for dynamic printf"), NULL
,
16717 update_dprintf_commands
, NULL
,
16718 &setlist
, &showlist
);
16720 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16721 &disconnected_dprintf
, _("\
16722 Set whether dprintf continues after GDB disconnects."), _("\
16723 Show whether dprintf continues after GDB disconnects."), _("\
16724 Use this to let dprintf commands continue to hit and produce output\n\
16725 even if GDB disconnects or detaches from the target."),
16728 &setlist
, &showlist
);
16730 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16731 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16732 (target agent only) This is useful for formatted output in user-defined commands."));
16734 automatic_hardware_breakpoints
= 1;
16736 observer_attach_about_to_proceed (breakpoint_about_to_proceed
);
16737 observer_attach_thread_exit (remove_threaded_breakpoints
);