1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "breakpoint.h"
29 #include "expression.h"
35 #include "gdbthread.h"
38 #include "gdb_string.h"
45 #include "completer.h"
48 #include "cli/cli-script.h"
49 #include "gdb_assert.h"
54 #include "exceptions.h"
61 #include "mi/mi-common.h"
63 /* Arguments to pass as context to some catch command handlers. */
64 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
65 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
67 /* Prototypes for local functions. */
69 static void enable_delete_command (char *, int);
71 static void enable_delete_breakpoint (struct breakpoint
*);
73 static void enable_once_command (char *, int);
75 static void enable_once_breakpoint (struct breakpoint
*);
77 static void disable_command (char *, int);
79 static void enable_command (char *, int);
81 static void map_breakpoint_numbers (char *, void (*)(struct breakpoint
*));
83 static void ignore_command (char *, int);
85 static int breakpoint_re_set_one (void *);
87 static void clear_command (char *, int);
89 static void catch_command (char *, int);
91 static void watch_command (char *, int);
93 static int can_use_hardware_watchpoint (struct value
*);
95 static void break_command_1 (char *, int, int);
97 static void mention (struct breakpoint
*);
99 struct breakpoint
*set_raw_breakpoint (struct symtab_and_line
, enum bptype
);
101 static void check_duplicates (struct breakpoint
*);
103 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
105 static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr
,
108 static void describe_other_breakpoints (CORE_ADDR
, struct obj_section
*, int);
110 static void breakpoints_info (char *, int);
112 static void breakpoint_1 (int, int);
114 static bpstat
bpstat_alloc (const struct bp_location
*, bpstat
);
116 static int breakpoint_cond_eval (void *);
118 static void cleanup_executing_breakpoints (void *);
120 static void commands_command (char *, int);
122 static void condition_command (char *, int);
124 static int get_number_trailer (char **, int);
126 void set_breakpoint_count (int);
135 static int remove_breakpoint (struct bp_location
*, insertion_state_t
);
137 static enum print_stop_action
print_it_typical (bpstat
);
139 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
141 static int watchpoint_check (void *);
143 static void maintenance_info_breakpoints (char *, int);
145 static void create_overlay_event_breakpoint (char *);
147 static int hw_breakpoint_used_count (void);
149 static int hw_watchpoint_used_count (enum bptype
, int *);
151 static void hbreak_command (char *, int);
153 static void thbreak_command (char *, int);
155 static void watch_command_1 (char *, int, int);
157 static void rwatch_command (char *, int);
159 static void awatch_command (char *, int);
161 static void do_enable_breakpoint (struct breakpoint
*, enum bpdisp
);
163 static void stop_command (char *arg
, int from_tty
);
165 static void stopin_command (char *arg
, int from_tty
);
167 static void stopat_command (char *arg
, int from_tty
);
169 static char *ep_parse_optional_if_clause (char **arg
);
171 static char *ep_parse_optional_filename (char **arg
);
173 static void catch_exception_command_1 (enum exception_event_kind ex_event
,
174 char *arg
, int tempflag
, int from_tty
);
176 static void tcatch_command (char *arg
, int from_tty
);
178 static void ep_skip_leading_whitespace (char **s
);
180 static int single_step_breakpoint_inserted_here_p (CORE_ADDR pc
);
182 static void free_bp_location (struct bp_location
*loc
);
184 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
186 static void update_global_location_list (int);
188 static void update_global_location_list_nothrow (int);
190 static int is_hardware_watchpoint (struct breakpoint
*bpt
);
192 static void insert_breakpoint_locations (void);
195 bpdisp_text (enum bpdisp disp
)
197 /* NOTE: the following values are a part of MI protocol and represent
198 values of 'disp' field returned when inferior stops at a breakpoint. */
199 static char *bpdisps
[] = {"del", "dstp", "dis", "keep"};
200 return bpdisps
[(int) disp
];
203 /* Prototypes for exported functions. */
204 /* If FALSE, gdb will not use hardware support for watchpoints, even
205 if such is available. */
206 static int can_use_hw_watchpoints
;
209 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
210 struct cmd_list_element
*c
,
213 fprintf_filtered (file
, _("\
214 Debugger's willingness to use watchpoint hardware is %s.\n"),
218 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
219 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
220 for unrecognized breakpoint locations.
221 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
222 static enum auto_boolean pending_break_support
;
224 show_pending_break_support (struct ui_file
*file
, int from_tty
,
225 struct cmd_list_element
*c
,
228 fprintf_filtered (file
, _("\
229 Debugger's behavior regarding pending breakpoints is %s.\n"),
233 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
234 set with "break" but falling in read-only memory.
235 If 0, gdb will warn about such breakpoints, but won't automatically
236 use hardware breakpoints. */
237 static int automatic_hardware_breakpoints
;
239 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
240 struct cmd_list_element
*c
,
243 fprintf_filtered (file
, _("\
244 Automatic usage of hardware breakpoints is %s.\n"),
248 /* If on, gdb will keep breakpoints inserted even as inferior is
249 stopped, and immediately insert any new breakpoints. If off, gdb
250 will insert breakpoints into inferior only when resuming it, and
251 will remove breakpoints upon stop. If auto, GDB will behave as ON
252 if in non-stop mode, and as OFF if all-stop mode.*/
254 static const char always_inserted_auto
[] = "auto";
255 static const char always_inserted_on
[] = "on";
256 static const char always_inserted_off
[] = "off";
257 static const char *always_inserted_enums
[] = {
258 always_inserted_auto
,
263 static const char *always_inserted_mode
= always_inserted_auto
;
265 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
266 struct cmd_list_element
*c
, const char *value
)
268 if (always_inserted_mode
== always_inserted_auto
)
269 fprintf_filtered (file
, _("\
270 Always inserted breakpoint mode is %s (currently %s).\n"),
272 breakpoints_always_inserted_mode () ? "on" : "off");
274 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"), value
);
278 breakpoints_always_inserted_mode (void)
280 return (always_inserted_mode
== always_inserted_on
281 || (always_inserted_mode
== always_inserted_auto
&& non_stop
));
284 void _initialize_breakpoint (void);
286 /* Are we executing breakpoint commands? */
287 static int executing_breakpoint_commands
;
289 /* Are overlay event breakpoints enabled? */
290 static int overlay_events_enabled
;
292 /* Walk the following statement or block through all breakpoints.
293 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
296 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
298 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
299 for (B = breakpoint_chain; \
300 B ? (TMP=B->next, 1): 0; \
303 /* Similar iterators for the low-level breakpoints. */
305 #define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->global_next)
307 #define ALL_BP_LOCATIONS_SAFE(B,TMP) \
308 for (B = bp_location_chain; \
309 B ? (TMP=B->global_next, 1): 0; \
312 /* Chains of all breakpoints defined. */
314 struct breakpoint
*breakpoint_chain
;
316 struct bp_location
*bp_location_chain
;
318 /* The locations that no longer correspond to any breakpoint,
319 unlinked from bp_location_chain, but for which a hit
320 may still be reported by a target. */
321 VEC(bp_location_p
) *moribund_locations
= NULL
;
323 /* Number of last breakpoint made. */
325 int breakpoint_count
;
327 /* Return whether a breakpoint is an active enabled breakpoint. */
329 breakpoint_enabled (struct breakpoint
*b
)
331 return (b
->enable_state
== bp_enabled
);
334 /* Set breakpoint count to NUM. */
337 set_breakpoint_count (int num
)
339 breakpoint_count
= num
;
340 set_internalvar (lookup_internalvar ("bpnum"),
341 value_from_longest (builtin_type_int32
, (LONGEST
) num
));
344 /* Used in run_command to zero the hit count when a new run starts. */
347 clear_breakpoint_hit_counts (void)
349 struct breakpoint
*b
;
355 /* Default address, symtab and line to put a breakpoint at
356 for "break" command with no arg.
357 if default_breakpoint_valid is zero, the other three are
358 not valid, and "break" with no arg is an error.
360 This set by print_stack_frame, which calls set_default_breakpoint. */
362 int default_breakpoint_valid
;
363 CORE_ADDR default_breakpoint_address
;
364 struct symtab
*default_breakpoint_symtab
;
365 int default_breakpoint_line
;
367 /* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
368 Advance *PP after the string and any trailing whitespace.
370 Currently the string can either be a number or "$" followed by the name
371 of a convenience variable. Making it an expression wouldn't work well
372 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
374 If the string is a NULL pointer, that denotes the last breakpoint.
376 TRAILER is a character which can be found after the number; most
377 commonly this is `-'. If you don't want a trailer, use \0. */
379 get_number_trailer (char **pp
, int trailer
)
381 int retval
= 0; /* default */
385 /* Empty line means refer to the last breakpoint. */
386 return breakpoint_count
;
389 /* Make a copy of the name, so we can null-terminate it
390 to pass to lookup_internalvar(). */
395 while (isalnum (*p
) || *p
== '_')
397 varname
= (char *) alloca (p
- start
+ 1);
398 strncpy (varname
, start
, p
- start
);
399 varname
[p
- start
] = '\0';
400 val
= value_of_internalvar (lookup_internalvar (varname
));
401 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INT
)
402 retval
= (int) value_as_long (val
);
405 printf_filtered (_("Convenience variable must have integer value.\n"));
413 while (*p
>= '0' && *p
<= '9')
416 /* There is no number here. (e.g. "cond a == b"). */
418 /* Skip non-numeric token */
419 while (*p
&& !isspace((int) *p
))
421 /* Return zero, which caller must interpret as error. */
427 if (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
429 /* Trailing junk: return 0 and let caller print error msg. */
430 while (!(isspace (*p
) || *p
== '\0' || *p
== trailer
))
441 /* Like get_number_trailer, but don't allow a trailer. */
443 get_number (char **pp
)
445 return get_number_trailer (pp
, '\0');
448 /* Parse a number or a range.
449 * A number will be of the form handled by get_number.
450 * A range will be of the form <number1> - <number2>, and
451 * will represent all the integers between number1 and number2,
454 * While processing a range, this fuction is called iteratively;
455 * At each call it will return the next value in the range.
457 * At the beginning of parsing a range, the char pointer PP will
458 * be advanced past <number1> and left pointing at the '-' token.
459 * Subsequent calls will not advance the pointer until the range
460 * is completed. The call that completes the range will advance
461 * pointer PP past <number2>.
465 get_number_or_range (char **pp
)
467 static int last_retval
, end_value
;
468 static char *end_ptr
;
469 static int in_range
= 0;
473 /* Default case: pp is pointing either to a solo number,
474 or to the first number of a range. */
475 last_retval
= get_number_trailer (pp
, '-');
480 /* This is the start of a range (<number1> - <number2>).
481 Skip the '-', parse and remember the second number,
482 and also remember the end of the final token. */
486 while (isspace ((int) *end_ptr
))
487 end_ptr
++; /* skip white space */
488 end_value
= get_number (temp
);
489 if (end_value
< last_retval
)
491 error (_("inverted range"));
493 else if (end_value
== last_retval
)
495 /* degenerate range (number1 == number2). Advance the
496 token pointer so that the range will be treated as a
505 error (_("negative value"));
508 /* pp points to the '-' that betokens a range. All
509 number-parsing has already been done. Return the next
510 integer value (one greater than the saved previous value).
511 Do not advance the token pointer 'pp' until the end of range
514 if (++last_retval
== end_value
)
516 /* End of range reached; advance token pointer. */
526 /* condition N EXP -- set break condition of breakpoint N to EXP. */
529 condition_command (char *arg
, int from_tty
)
531 struct breakpoint
*b
;
536 error_no_arg (_("breakpoint number"));
539 bnum
= get_number (&p
);
541 error (_("Bad breakpoint argument: '%s'"), arg
);
544 if (b
->number
== bnum
)
546 struct bp_location
*loc
= b
->loc
;
547 for (; loc
; loc
= loc
->next
)
555 if (b
->cond_string
!= NULL
)
556 xfree (b
->cond_string
);
560 b
->cond_string
= NULL
;
562 printf_filtered (_("Breakpoint %d now unconditional.\n"), bnum
);
567 /* I don't know if it matters whether this is the string the user
568 typed in or the decompiled expression. */
569 b
->cond_string
= savestring (arg
, strlen (arg
));
570 b
->condition_not_parsed
= 0;
571 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
575 parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
577 error (_("Junk at end of expression"));
580 breakpoints_changed ();
581 observer_notify_breakpoint_modified (b
->number
);
585 error (_("No breakpoint number %d."), bnum
);
589 commands_command (char *arg
, int from_tty
)
591 struct breakpoint
*b
;
594 struct command_line
*l
;
596 /* If we allowed this, we would have problems with when to
597 free the storage, if we change the commands currently
600 if (executing_breakpoint_commands
)
601 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
604 bnum
= get_number (&p
);
607 error (_("Unexpected extra arguments following breakpoint number."));
610 if (b
->number
== bnum
)
612 char *tmpbuf
= xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
614 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
615 l
= read_command_lines (tmpbuf
, from_tty
, 1);
616 do_cleanups (cleanups
);
617 free_command_lines (&b
->commands
);
619 breakpoints_changed ();
620 observer_notify_breakpoint_modified (b
->number
);
623 error (_("No breakpoint number %d."), bnum
);
626 /* Like commands_command, but instead of reading the commands from
627 input stream, takes them from an already parsed command structure.
629 This is used by cli-script.c to DTRT with breakpoint commands
630 that are part of if and while bodies. */
631 enum command_control_type
632 commands_from_control_command (char *arg
, struct command_line
*cmd
)
634 struct breakpoint
*b
;
638 /* If we allowed this, we would have problems with when to
639 free the storage, if we change the commands currently
642 if (executing_breakpoint_commands
)
643 error (_("Can't use the \"commands\" command among a breakpoint's commands."));
645 /* An empty string for the breakpoint number means the last
646 breakpoint, but get_number expects a NULL pointer. */
651 bnum
= get_number (&p
);
654 error (_("Unexpected extra arguments following breakpoint number."));
657 if (b
->number
== bnum
)
659 free_command_lines (&b
->commands
);
660 if (cmd
->body_count
!= 1)
661 error (_("Invalid \"commands\" block structure."));
662 /* We need to copy the commands because if/while will free the
663 list after it finishes execution. */
664 b
->commands
= copy_command_lines (cmd
->body_list
[0]);
665 breakpoints_changed ();
666 observer_notify_breakpoint_modified (b
->number
);
667 return simple_control
;
669 error (_("No breakpoint number %d."), bnum
);
672 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
673 by replacing any memory breakpoints with their shadowed contents. */
676 breakpoint_restore_shadows (gdb_byte
*buf
, ULONGEST memaddr
, LONGEST len
)
678 struct bp_location
*b
;
679 CORE_ADDR bp_addr
= 0;
685 if (b
->owner
->type
== bp_none
)
686 warning (_("reading through apparently deleted breakpoint #%d?"),
689 if (b
->loc_type
!= bp_loc_software_breakpoint
)
693 /* Addresses and length of the part of the breakpoint that
695 bp_addr
= b
->target_info
.placed_address
;
696 bp_size
= b
->target_info
.shadow_len
;
698 /* bp isn't valid, or doesn't shadow memory. */
701 if (bp_addr
+ bp_size
<= memaddr
)
702 /* The breakpoint is entirely before the chunk of memory we
706 if (bp_addr
>= memaddr
+ len
)
707 /* The breakpoint is entirely after the chunk of memory we are
711 /* Offset within shadow_contents. */
712 if (bp_addr
< memaddr
)
714 /* Only copy the second part of the breakpoint. */
715 bp_size
-= memaddr
- bp_addr
;
716 bptoffset
= memaddr
- bp_addr
;
720 if (bp_addr
+ bp_size
> memaddr
+ len
)
722 /* Only copy the first part of the breakpoint. */
723 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
726 memcpy (buf
+ bp_addr
- memaddr
,
727 b
->target_info
.shadow_contents
+ bptoffset
, bp_size
);
732 /* A wrapper function for inserting catchpoints. */
734 insert_catchpoint (struct ui_out
*uo
, void *args
)
736 struct breakpoint
*b
= (struct breakpoint
*) args
;
739 gdb_assert (b
->type
== bp_catchpoint
);
740 gdb_assert (b
->ops
!= NULL
&& b
->ops
->insert
!= NULL
);
746 is_hardware_watchpoint (struct breakpoint
*bpt
)
748 return (bpt
->type
== bp_hardware_watchpoint
749 || bpt
->type
== bp_read_watchpoint
750 || bpt
->type
== bp_access_watchpoint
);
753 /* Find the current value of a watchpoint on EXP. Return the value in
754 *VALP and *RESULTP and the chain of intermediate and final values
755 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
758 If an error occurs while evaluating the expression, *RESULTP will
759 be set to NULL. *RESULTP may be a lazy value, if the result could
760 not be read from memory. It is used to determine whether a value
761 is user-specified (we should watch the whole value) or intermediate
762 (we should watch only the bit used to locate the final value).
764 If the final value, or any intermediate value, could not be read
765 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
766 set to any referenced values. *VALP will never be a lazy value.
767 This is the value which we store in struct breakpoint.
769 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
770 value chain. The caller must free the values individually. If
771 VAL_CHAIN is NULL, all generated values will be left on the value
775 fetch_watchpoint_value (struct expression
*exp
, struct value
**valp
,
776 struct value
**resultp
, struct value
**val_chain
)
778 struct value
*mark
, *new_mark
, *result
;
786 /* Evaluate the expression. */
787 mark
= value_mark ();
789 gdb_evaluate_expression (exp
, &result
);
790 new_mark
= value_mark ();
791 if (mark
== new_mark
)
796 /* Make sure it's not lazy, so that after the target stops again we
797 have a non-lazy previous value to compare with. */
799 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
804 /* Return the chain of intermediate values. We use this to
805 decide which addresses to watch. */
806 *val_chain
= new_mark
;
807 value_release_to_mark (mark
);
811 /* Assuming that B is a hardware watchpoint:
812 - Reparse watchpoint expression, is REPARSE is non-zero
813 - Evaluate expression and store the result in B->val
814 - Update the list of values that must be watched in B->loc.
816 If the watchpoint is disabled, do nothing. If this is
817 local watchpoint that is out of scope, delete it. */
819 update_watchpoint (struct breakpoint
*b
, int reparse
)
821 int within_current_scope
;
822 struct frame_id saved_frame_id
;
823 struct bp_location
*loc
;
826 /* We don't free locations. They are stored in
827 bp_location_chain and update_global_locations will
828 eventually delete them and remove breakpoints if
832 if (b
->disposition
== disp_del_at_next_stop
)
835 /* Save the current frame's ID so we can restore it after
836 evaluating the watchpoint expression on its own frame. */
837 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
838 took a frame parameter, so that we didn't have to change the
840 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
842 /* Determine if the watchpoint is within scope. */
843 if (b
->exp_valid_block
== NULL
)
844 within_current_scope
= 1;
847 struct frame_info
*fi
;
848 fi
= frame_find_by_id (b
->watchpoint_frame
);
849 within_current_scope
= (fi
!= NULL
);
850 if (within_current_scope
)
854 if (within_current_scope
&& reparse
)
863 b
->exp
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
864 /* If the meaning of expression itself changed, the old value is
865 no longer relevant. We don't want to report a watchpoint hit
866 to the user when the old value and the new value may actually
867 be completely different objects. */
873 /* If we failed to parse the expression, for example because
874 it refers to a global variable in a not-yet-loaded shared library,
875 don't try to insert watchpoint. We don't automatically delete
876 such watchpoint, though, since failure to parse expression
877 is different from out-of-scope watchpoint. */
878 if (within_current_scope
&& b
->exp
)
880 struct value
*val_chain
, *v
, *result
, *next
;
882 fetch_watchpoint_value (b
->exp
, &v
, &result
, &val_chain
);
884 /* Avoid setting b->val if it's already set. The meaning of
885 b->val is 'the last value' user saw, and we should update
886 it only if we reported that last value to user. As it
887 happens, the code that reports it updates b->val directly. */
894 /* Change the type of breakpoint between hardware assisted or an
895 ordinary watchpoint depending on the hardware support and free
896 hardware slots. REPARSE is set when the inferior is started. */
897 if ((b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
)
900 int i
, mem_cnt
, target_resources_ok
, other_type_used
;
902 i
= hw_watchpoint_used_count (bp_hardware_watchpoint
,
904 mem_cnt
= can_use_hardware_watchpoint (val_chain
);
907 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT
908 (bp_hardware_watchpoint
, i
+ mem_cnt
, other_type_used
);
909 if (!mem_cnt
|| target_resources_ok
<= 0)
910 b
->type
= bp_watchpoint
;
912 b
->type
= bp_hardware_watchpoint
;
915 /* Look at each value on the value chain. */
916 for (v
= val_chain
; v
; v
= next
)
918 /* If it's a memory location, and GDB actually needed
919 its contents to evaluate the expression, then we
920 must watch it. If the first value returned is
921 still lazy, that means an error occurred reading it;
922 watch it anyway in case it becomes readable. */
923 if (VALUE_LVAL (v
) == lval_memory
924 && (v
== val_chain
|| ! value_lazy (v
)))
926 struct type
*vtype
= check_typedef (value_type (v
));
928 /* We only watch structs and arrays if user asked
929 for it explicitly, never if they just happen to
930 appear in the middle of some value chain. */
932 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
933 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
937 struct bp_location
*loc
, **tmp
;
939 addr
= VALUE_ADDRESS (v
) + value_offset (v
);
940 len
= TYPE_LENGTH (value_type (v
));
942 if (b
->type
== bp_read_watchpoint
)
944 else if (b
->type
== bp_access_watchpoint
)
947 loc
= allocate_bp_location (b
);
948 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
953 loc
->watchpoint_type
= type
;
957 next
= value_next (v
);
962 /* We just regenerated the list of breakpoint locations.
963 The new location does not have its condition field set to anything
964 and therefore, we must always reparse the cond_string, independently
965 of the value of the reparse flag. */
966 if (b
->cond_string
!= NULL
)
968 char *s
= b
->cond_string
;
969 b
->loc
->cond
= parse_exp_1 (&s
, b
->exp_valid_block
, 0);
972 else if (!within_current_scope
)
974 printf_filtered (_("\
975 Hardware watchpoint %d deleted because the program has left the block \n\
976 in which its expression is valid.\n"),
978 if (b
->related_breakpoint
)
979 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
980 b
->disposition
= disp_del_at_next_stop
;
983 /* Restore the selected frame. */
984 select_frame (frame_find_by_id (saved_frame_id
));
988 /* Returns 1 iff breakpoint location should be
989 inserted in the inferior. */
991 should_be_inserted (struct bp_location
*bpt
)
993 if (!breakpoint_enabled (bpt
->owner
))
996 if (bpt
->owner
->disposition
== disp_del_at_next_stop
)
999 if (!bpt
->enabled
|| bpt
->shlib_disabled
|| bpt
->duplicate
)
1005 /* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
1006 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
1007 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
1009 NOTE drow/2003-09-09: This routine could be broken down to an object-style
1010 method for each breakpoint or catchpoint type. */
1012 insert_bp_location (struct bp_location
*bpt
,
1013 struct ui_file
*tmp_error_stream
,
1014 int *disabled_breaks
, int *process_warning
,
1015 int *hw_breakpoint_error
)
1019 if (!should_be_inserted (bpt
) || bpt
->inserted
)
1022 /* Initialize the target-specific information. */
1023 memset (&bpt
->target_info
, 0, sizeof (bpt
->target_info
));
1024 bpt
->target_info
.placed_address
= bpt
->address
;
1026 if (bpt
->loc_type
== bp_loc_software_breakpoint
1027 || bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1029 if (bpt
->owner
->type
!= bp_hardware_breakpoint
)
1031 /* If the explicitly specified breakpoint type
1032 is not hardware breakpoint, check the memory map to see
1033 if the breakpoint address is in read only memory or not.
1034 Two important cases are:
1035 - location type is not hardware breakpoint, memory
1036 is readonly. We change the type of the location to
1037 hardware breakpoint.
1038 - location type is hardware breakpoint, memory is read-write.
1039 This means we've previously made the location hardware one, but
1040 then the memory map changed, so we undo.
1042 When breakpoints are removed, remove_breakpoints will
1043 use location types we've just set here, the only possible
1044 problem is that memory map has changed during running program,
1045 but it's not going to work anyway with current gdb. */
1046 struct mem_region
*mr
1047 = lookup_mem_region (bpt
->target_info
.placed_address
);
1051 if (automatic_hardware_breakpoints
)
1054 enum bp_loc_type new_type
;
1056 if (mr
->attrib
.mode
!= MEM_RW
)
1057 new_type
= bp_loc_hardware_breakpoint
;
1059 new_type
= bp_loc_software_breakpoint
;
1061 if (new_type
!= bpt
->loc_type
)
1063 static int said
= 0;
1064 bpt
->loc_type
= new_type
;
1067 fprintf_filtered (gdb_stdout
, _("\
1068 Note: automatically using hardware breakpoints for read-only addresses.\n"));
1073 else if (bpt
->loc_type
== bp_loc_software_breakpoint
1074 && mr
->attrib
.mode
!= MEM_RW
)
1075 warning (_("cannot set software breakpoint at readonly address %s"),
1076 paddr (bpt
->address
));
1080 /* First check to see if we have to handle an overlay. */
1081 if (overlay_debugging
== ovly_off
1082 || bpt
->section
== NULL
1083 || !(section_is_overlay (bpt
->section
)))
1085 /* No overlay handling: just set the breakpoint. */
1087 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1088 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1090 val
= target_insert_breakpoint (&bpt
->target_info
);
1094 /* This breakpoint is in an overlay section.
1095 Shall we set a breakpoint at the LMA? */
1096 if (!overlay_events_enabled
)
1098 /* Yes -- overlay event support is not active,
1099 so we must try to set a breakpoint at the LMA.
1100 This will not work for a hardware breakpoint. */
1101 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1102 warning (_("hardware breakpoint %d not supported in overlay!"),
1103 bpt
->owner
->number
);
1106 CORE_ADDR addr
= overlay_unmapped_address (bpt
->address
,
1108 /* Set a software (trap) breakpoint at the LMA. */
1109 bpt
->overlay_target_info
= bpt
->target_info
;
1110 bpt
->overlay_target_info
.placed_address
= addr
;
1111 val
= target_insert_breakpoint (&bpt
->overlay_target_info
);
1113 fprintf_unfiltered (tmp_error_stream
,
1114 "Overlay breakpoint %d failed: in ROM?",
1115 bpt
->owner
->number
);
1118 /* Shall we set a breakpoint at the VMA? */
1119 if (section_is_mapped (bpt
->section
))
1121 /* Yes. This overlay section is mapped into memory. */
1122 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1123 val
= target_insert_hw_breakpoint (&bpt
->target_info
);
1125 val
= target_insert_breakpoint (&bpt
->target_info
);
1129 /* No. This breakpoint will not be inserted.
1130 No error, but do not mark the bp as 'inserted'. */
1137 /* Can't set the breakpoint. */
1138 if (solib_address (bpt
->address
))
1140 /* See also: disable_breakpoints_in_shlibs. */
1142 bpt
->shlib_disabled
= 1;
1143 if (!*disabled_breaks
)
1145 fprintf_unfiltered (tmp_error_stream
,
1146 "Cannot insert breakpoint %d.\n",
1147 bpt
->owner
->number
);
1148 fprintf_unfiltered (tmp_error_stream
,
1149 "Temporarily disabling shared library breakpoints:\n");
1151 *disabled_breaks
= 1;
1152 fprintf_unfiltered (tmp_error_stream
,
1153 "breakpoint #%d\n", bpt
->owner
->number
);
1157 #ifdef ONE_PROCESS_WRITETEXT
1158 *process_warning
= 1;
1160 if (bpt
->loc_type
== bp_loc_hardware_breakpoint
)
1162 *hw_breakpoint_error
= 1;
1163 fprintf_unfiltered (tmp_error_stream
,
1164 "Cannot insert hardware breakpoint %d.\n",
1165 bpt
->owner
->number
);
1169 fprintf_unfiltered (tmp_error_stream
,
1170 "Cannot insert breakpoint %d.\n",
1171 bpt
->owner
->number
);
1172 fprintf_filtered (tmp_error_stream
,
1173 "Error accessing memory address ");
1174 fputs_filtered (paddress (bpt
->address
), tmp_error_stream
);
1175 fprintf_filtered (tmp_error_stream
, ": %s.\n",
1176 safe_strerror (val
));
1187 else if (bpt
->loc_type
== bp_loc_hardware_watchpoint
1188 /* NOTE drow/2003-09-08: This state only exists for removing
1189 watchpoints. It's not clear that it's necessary... */
1190 && bpt
->owner
->disposition
!= disp_del_at_next_stop
)
1192 val
= target_insert_watchpoint (bpt
->address
,
1194 bpt
->watchpoint_type
);
1195 bpt
->inserted
= (val
!= -1);
1198 else if (bpt
->owner
->type
== bp_catchpoint
)
1200 struct gdb_exception e
= catch_exception (uiout
, insert_catchpoint
,
1201 bpt
->owner
, RETURN_MASK_ERROR
);
1202 exception_fprintf (gdb_stderr
, e
, "warning: inserting catchpoint %d: ",
1203 bpt
->owner
->number
);
1205 bpt
->owner
->enable_state
= bp_disabled
;
1209 /* We've already printed an error message if there was a problem
1210 inserting this catchpoint, and we've disabled the catchpoint,
1211 so just return success. */
1218 /* Make sure all breakpoints are inserted in inferior.
1219 Throws exception on any error.
1220 A breakpoint that is already inserted won't be inserted
1221 again, so calling this function twice is safe. */
1223 insert_breakpoints (void)
1225 struct breakpoint
*bpt
;
1227 ALL_BREAKPOINTS (bpt
)
1228 if (is_hardware_watchpoint (bpt
))
1229 update_watchpoint (bpt
, 0 /* don't reparse. */);
1231 update_global_location_list (1);
1233 if (!breakpoints_always_inserted_mode ()
1234 && (target_has_execution
1235 || (gdbarch_has_global_solist (target_gdbarch
)
1236 && target_supports_multi_process ())))
1237 /* update_global_location_list does not insert breakpoints
1238 when always_inserted_mode is not enabled. Explicitly
1240 insert_breakpoint_locations ();
1243 /* insert_breakpoints is used when starting or continuing the program.
1244 remove_breakpoints is used when the program stops.
1245 Both return zero if successful,
1246 or an `errno' value if could not write the inferior. */
1249 insert_breakpoint_locations (void)
1251 struct breakpoint
*bpt
;
1252 struct bp_location
*b
, *temp
;
1255 int disabled_breaks
= 0;
1256 int hw_breakpoint_error
= 0;
1257 int process_warning
= 0;
1259 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1260 make_cleanup_ui_file_delete (tmp_error_stream
);
1262 /* Explicitly mark the warning -- this will only be printed if
1263 there was an error. */
1264 fprintf_unfiltered (tmp_error_stream
, "Warning:\n");
1266 ALL_BP_LOCATIONS_SAFE (b
, temp
)
1268 if (!should_be_inserted (b
) || b
->inserted
)
1271 /* There is no point inserting thread-specific breakpoints if the
1272 thread no longer exists. */
1273 if (b
->owner
->thread
!= -1
1274 && !valid_thread_id (b
->owner
->thread
))
1277 val
= insert_bp_location (b
, tmp_error_stream
,
1278 &disabled_breaks
, &process_warning
,
1279 &hw_breakpoint_error
);
1284 /* If we failed to insert all locations of a watchpoint,
1285 remove them, as half-inserted watchpoint is of limited use. */
1286 ALL_BREAKPOINTS (bpt
)
1288 int some_failed
= 0;
1289 struct bp_location
*loc
;
1291 if (!is_hardware_watchpoint (bpt
))
1294 if (!breakpoint_enabled (bpt
))
1297 if (bpt
->disposition
== disp_del_at_next_stop
)
1300 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1308 for (loc
= bpt
->loc
; loc
; loc
= loc
->next
)
1310 remove_breakpoint (loc
, mark_uninserted
);
1312 hw_breakpoint_error
= 1;
1313 fprintf_unfiltered (tmp_error_stream
,
1314 "Could not insert hardware watchpoint %d.\n",
1322 /* If a hardware breakpoint or watchpoint was inserted, add a
1323 message about possibly exhausted resources. */
1324 if (hw_breakpoint_error
)
1326 fprintf_unfiltered (tmp_error_stream
,
1327 "Could not insert hardware breakpoints:\n\
1328 You may have requested too many hardware breakpoints/watchpoints.\n");
1330 #ifdef ONE_PROCESS_WRITETEXT
1331 if (process_warning
)
1332 fprintf_unfiltered (tmp_error_stream
,
1333 "The same program may be running in another process.");
1335 target_terminal_ours_for_output ();
1336 error_stream (tmp_error_stream
);
1341 remove_breakpoints (void)
1343 struct bp_location
*b
;
1346 ALL_BP_LOCATIONS (b
)
1350 val
= remove_breakpoint (b
, mark_uninserted
);
1359 remove_hw_watchpoints (void)
1361 struct bp_location
*b
;
1364 ALL_BP_LOCATIONS (b
)
1366 if (b
->inserted
&& b
->loc_type
== bp_loc_hardware_watchpoint
)
1368 val
= remove_breakpoint (b
, mark_uninserted
);
1377 reattach_breakpoints (int pid
)
1379 struct bp_location
*b
;
1381 struct cleanup
*old_chain
= save_inferior_ptid ();
1382 struct ui_file
*tmp_error_stream
= mem_fileopen ();
1383 int dummy1
= 0, dummy2
= 0, dummy3
= 0;
1385 make_cleanup_ui_file_delete (tmp_error_stream
);
1387 inferior_ptid
= pid_to_ptid (pid
);
1388 ALL_BP_LOCATIONS (b
)
1393 val
= insert_bp_location (b
, tmp_error_stream
,
1394 &dummy1
, &dummy2
, &dummy3
);
1397 do_cleanups (old_chain
);
1402 do_cleanups (old_chain
);
1407 update_breakpoints_after_exec (void)
1409 struct breakpoint
*b
;
1410 struct breakpoint
*temp
;
1411 struct bp_location
*bploc
;
1413 /* We're about to delete breakpoints from GDB's lists. If the
1414 INSERTED flag is true, GDB will try to lift the breakpoints by
1415 writing the breakpoints' "shadow contents" back into memory. The
1416 "shadow contents" are NOT valid after an exec, so GDB should not
1417 do that. Instead, the target is responsible from marking
1418 breakpoints out as soon as it detects an exec. We don't do that
1419 here instead, because there may be other attempts to delete
1420 breakpoints after detecting an exec and before reaching here. */
1421 ALL_BP_LOCATIONS (bploc
)
1422 gdb_assert (!bploc
->inserted
);
1424 ALL_BREAKPOINTS_SAFE (b
, temp
)
1426 /* Solib breakpoints must be explicitly reset after an exec(). */
1427 if (b
->type
== bp_shlib_event
)
1429 delete_breakpoint (b
);
1433 /* Thread event breakpoints must be set anew after an exec(),
1434 as must overlay event breakpoints. */
1435 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
1437 delete_breakpoint (b
);
1441 /* Step-resume breakpoints are meaningless after an exec(). */
1442 if (b
->type
== bp_step_resume
)
1444 delete_breakpoint (b
);
1448 /* Longjmp and longjmp-resume breakpoints are also meaningless
1450 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
)
1452 delete_breakpoint (b
);
1456 if (b
->type
== bp_catchpoint
)
1458 /* For now, none of the bp_catchpoint breakpoints need to
1459 do anything at this point. In the future, if some of
1460 the catchpoints need to something, we will need to add
1461 a new method, and call this method from here. */
1465 /* bp_finish is a special case. The only way we ought to be able
1466 to see one of these when an exec() has happened, is if the user
1467 caught a vfork, and then said "finish". Ordinarily a finish just
1468 carries them to the call-site of the current callee, by setting
1469 a temporary bp there and resuming. But in this case, the finish
1470 will carry them entirely through the vfork & exec.
1472 We don't want to allow a bp_finish to remain inserted now. But
1473 we can't safely delete it, 'cause finish_command has a handle to
1474 the bp on a bpstat, and will later want to delete it. There's a
1475 chance (and I've seen it happen) that if we delete the bp_finish
1476 here, that its storage will get reused by the time finish_command
1477 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1478 We really must allow finish_command to delete a bp_finish.
1480 In the absense of a general solution for the "how do we know
1481 it's safe to delete something others may have handles to?"
1482 problem, what we'll do here is just uninsert the bp_finish, and
1483 let finish_command delete it.
1485 (We know the bp_finish is "doomed" in the sense that it's
1486 momentary, and will be deleted as soon as finish_command sees
1487 the inferior stopped. So it doesn't matter that the bp's
1488 address is probably bogus in the new a.out, unlike e.g., the
1489 solib breakpoints.) */
1491 if (b
->type
== bp_finish
)
1496 /* Without a symbolic address, we have little hope of the
1497 pre-exec() address meaning the same thing in the post-exec()
1499 if (b
->addr_string
== NULL
)
1501 delete_breakpoint (b
);
1505 /* FIXME what about longjmp breakpoints? Re-create them here? */
1506 create_overlay_event_breakpoint ("_ovly_debug_event");
1510 detach_breakpoints (int pid
)
1512 struct bp_location
*b
;
1514 struct cleanup
*old_chain
= save_inferior_ptid ();
1516 if (pid
== PIDGET (inferior_ptid
))
1517 error (_("Cannot detach breakpoints of inferior_ptid"));
1519 /* Set inferior_ptid; remove_breakpoint uses this global. */
1520 inferior_ptid
= pid_to_ptid (pid
);
1521 ALL_BP_LOCATIONS (b
)
1525 val
= remove_breakpoint (b
, mark_inserted
);
1528 do_cleanups (old_chain
);
1533 do_cleanups (old_chain
);
1538 remove_breakpoint (struct bp_location
*b
, insertion_state_t is
)
1542 if (b
->owner
->enable_state
== bp_permanent
)
1543 /* Permanent breakpoints cannot be inserted or removed. */
1546 /* The type of none suggests that owner is actually deleted.
1547 This should not ever happen. */
1548 gdb_assert (b
->owner
->type
!= bp_none
);
1550 if (b
->loc_type
== bp_loc_software_breakpoint
1551 || b
->loc_type
== bp_loc_hardware_breakpoint
)
1553 /* "Normal" instruction breakpoint: either the standard
1554 trap-instruction bp (bp_breakpoint), or a
1555 bp_hardware_breakpoint. */
1557 /* First check to see if we have to handle an overlay. */
1558 if (overlay_debugging
== ovly_off
1559 || b
->section
== NULL
1560 || !(section_is_overlay (b
->section
)))
1562 /* No overlay handling: just remove the breakpoint. */
1564 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1565 val
= target_remove_hw_breakpoint (&b
->target_info
);
1567 val
= target_remove_breakpoint (&b
->target_info
);
1571 /* This breakpoint is in an overlay section.
1572 Did we set a breakpoint at the LMA? */
1573 if (!overlay_events_enabled
)
1575 /* Yes -- overlay event support is not active, so we
1576 should have set a breakpoint at the LMA. Remove it.
1578 /* Ignore any failures: if the LMA is in ROM, we will
1579 have already warned when we failed to insert it. */
1580 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1581 target_remove_hw_breakpoint (&b
->overlay_target_info
);
1583 target_remove_breakpoint (&b
->overlay_target_info
);
1585 /* Did we set a breakpoint at the VMA?
1586 If so, we will have marked the breakpoint 'inserted'. */
1589 /* Yes -- remove it. Previously we did not bother to
1590 remove the breakpoint if the section had been
1591 unmapped, but let's not rely on that being safe. We
1592 don't know what the overlay manager might do. */
1593 if (b
->loc_type
== bp_loc_hardware_breakpoint
)
1594 val
= target_remove_hw_breakpoint (&b
->target_info
);
1596 /* However, we should remove *software* breakpoints only
1597 if the section is still mapped, or else we overwrite
1598 wrong code with the saved shadow contents. */
1599 else if (section_is_mapped (b
->section
))
1600 val
= target_remove_breakpoint (&b
->target_info
);
1606 /* No -- not inserted, so no need to remove. No error. */
1611 /* In some cases, we might not be able to remove a breakpoint
1612 in a shared library that has already been removed, but we
1613 have not yet processed the shlib unload event. */
1614 if (val
&& solib_address (b
->address
))
1619 b
->inserted
= (is
== mark_inserted
);
1621 else if (b
->loc_type
== bp_loc_hardware_watchpoint
)
1626 b
->inserted
= (is
== mark_inserted
);
1627 val
= target_remove_watchpoint (b
->address
, b
->length
,
1628 b
->watchpoint_type
);
1630 /* Failure to remove any of the hardware watchpoints comes here. */
1631 if ((is
== mark_uninserted
) && (b
->inserted
))
1632 warning (_("Could not remove hardware watchpoint %d."),
1635 else if (b
->owner
->type
== bp_catchpoint
1636 && breakpoint_enabled (b
->owner
)
1639 gdb_assert (b
->owner
->ops
!= NULL
&& b
->owner
->ops
->remove
!= NULL
);
1641 val
= b
->owner
->ops
->remove (b
->owner
);
1644 b
->inserted
= (is
== mark_inserted
);
1650 /* Clear the "inserted" flag in all breakpoints. */
1653 mark_breakpoints_out (void)
1655 struct bp_location
*bpt
;
1657 ALL_BP_LOCATIONS (bpt
)
1661 /* Clear the "inserted" flag in all breakpoints and delete any
1662 breakpoints which should go away between runs of the program.
1664 Plus other such housekeeping that has to be done for breakpoints
1667 Note: this function gets called at the end of a run (by
1668 generic_mourn_inferior) and when a run begins (by
1669 init_wait_for_inferior). */
1674 breakpoint_init_inferior (enum inf_context context
)
1676 struct breakpoint
*b
, *temp
;
1677 struct bp_location
*bpt
;
1680 /* If breakpoint locations are shared across processes, then there's
1682 if (gdbarch_has_global_solist (target_gdbarch
))
1685 ALL_BP_LOCATIONS (bpt
)
1686 if (bpt
->owner
->enable_state
!= bp_permanent
)
1689 ALL_BREAKPOINTS_SAFE (b
, temp
)
1694 case bp_watchpoint_scope
:
1696 /* If the call dummy breakpoint is at the entry point it will
1697 cause problems when the inferior is rerun, so we better
1700 Also get rid of scope breakpoints. */
1701 delete_breakpoint (b
);
1705 case bp_hardware_watchpoint
:
1706 case bp_read_watchpoint
:
1707 case bp_access_watchpoint
:
1709 /* Likewise for watchpoints on local expressions. */
1710 if (b
->exp_valid_block
!= NULL
)
1711 delete_breakpoint (b
);
1712 else if (context
== inf_starting
)
1714 /* Reset val field to force reread of starting value
1715 in insert_breakpoints. */
1717 value_free (b
->val
);
1727 /* Get rid of the moribund locations. */
1728 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, bpt
); ++ix
)
1729 free_bp_location (bpt
);
1730 VEC_free (bp_location_p
, moribund_locations
);
1733 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1734 exists at PC. It returns ordinary_breakpoint_here if it's an
1735 ordinary breakpoint, or permanent_breakpoint_here if it's a
1736 permanent breakpoint.
1737 - When continuing from a location with an ordinary breakpoint, we
1738 actually single step once before calling insert_breakpoints.
1739 - When continuing from a localion with a permanent breakpoint, we
1740 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1741 the target, to advance the PC past the breakpoint. */
1743 enum breakpoint_here
1744 breakpoint_here_p (CORE_ADDR pc
)
1746 const struct bp_location
*bpt
;
1747 int any_breakpoint_here
= 0;
1749 ALL_BP_LOCATIONS (bpt
)
1751 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1752 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1755 if ((breakpoint_enabled (bpt
->owner
)
1756 || bpt
->owner
->enable_state
== bp_permanent
)
1757 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1759 if (overlay_debugging
1760 && section_is_overlay (bpt
->section
)
1761 && !section_is_mapped (bpt
->section
))
1762 continue; /* unmapped overlay -- can't be a match */
1763 else if (bpt
->owner
->enable_state
== bp_permanent
)
1764 return permanent_breakpoint_here
;
1766 any_breakpoint_here
= 1;
1770 return any_breakpoint_here
? ordinary_breakpoint_here
: 0;
1773 /* Return true if there's a moribund breakpoint at PC. */
1776 moribund_breakpoint_here_p (CORE_ADDR pc
)
1778 struct bp_location
*loc
;
1781 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
1782 if (loc
->address
== pc
)
1788 /* Returns non-zero if there's a breakpoint inserted at PC, which is
1789 inserted using regular breakpoint_chain/bp_location_chain mechanism.
1790 This does not check for single-step breakpoints, which are
1791 inserted and removed using direct target manipulation. */
1794 regular_breakpoint_inserted_here_p (CORE_ADDR pc
)
1796 const struct bp_location
*bpt
;
1798 ALL_BP_LOCATIONS (bpt
)
1800 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1801 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1805 && bpt
->address
== pc
) /* bp is inserted and matches pc */
1807 if (overlay_debugging
1808 && section_is_overlay (bpt
->section
)
1809 && !section_is_mapped (bpt
->section
))
1810 continue; /* unmapped overlay -- can't be a match */
1818 /* Returns non-zero iff there's either regular breakpoint
1819 or a single step breakpoint inserted at PC. */
1822 breakpoint_inserted_here_p (CORE_ADDR pc
)
1824 if (regular_breakpoint_inserted_here_p (pc
))
1827 if (single_step_breakpoint_inserted_here_p (pc
))
1833 /* This function returns non-zero iff there is a software breakpoint
1837 software_breakpoint_inserted_here_p (CORE_ADDR pc
)
1839 const struct bp_location
*bpt
;
1840 int any_breakpoint_here
= 0;
1842 ALL_BP_LOCATIONS (bpt
)
1844 if (bpt
->loc_type
!= bp_loc_software_breakpoint
)
1848 && bpt
->address
== pc
) /* bp is enabled and matches pc */
1850 if (overlay_debugging
1851 && section_is_overlay (bpt
->section
)
1852 && !section_is_mapped (bpt
->section
))
1853 continue; /* unmapped overlay -- can't be a match */
1859 /* Also check for software single-step breakpoints. */
1860 if (single_step_breakpoint_inserted_here_p (pc
))
1866 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1867 PC is valid for process/thread PTID. */
1870 breakpoint_thread_match (CORE_ADDR pc
, ptid_t ptid
)
1872 const struct bp_location
*bpt
;
1875 thread
= pid_to_thread_id (ptid
);
1877 ALL_BP_LOCATIONS (bpt
)
1879 if (bpt
->loc_type
!= bp_loc_software_breakpoint
1880 && bpt
->loc_type
!= bp_loc_hardware_breakpoint
)
1883 if ((breakpoint_enabled (bpt
->owner
)
1884 || bpt
->owner
->enable_state
== bp_permanent
)
1885 && bpt
->address
== pc
1886 && (bpt
->owner
->thread
== -1 || bpt
->owner
->thread
== thread
))
1888 if (overlay_debugging
1889 && section_is_overlay (bpt
->section
)
1890 && !section_is_mapped (bpt
->section
))
1891 continue; /* unmapped overlay -- can't be a match */
1901 /* bpstat stuff. External routines' interfaces are documented
1905 ep_is_catchpoint (struct breakpoint
*ep
)
1907 return (ep
->type
== bp_catchpoint
);
1911 bpstat_free (bpstat bs
)
1913 if (bs
->old_val
!= NULL
)
1914 value_free (bs
->old_val
);
1915 free_command_lines (&bs
->commands
);
1919 /* Clear a bpstat so that it says we are not at any breakpoint.
1920 Also free any storage that is part of a bpstat. */
1923 bpstat_clear (bpstat
*bsp
)
1940 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1941 is part of the bpstat is copied as well. */
1944 bpstat_copy (bpstat bs
)
1948 bpstat retval
= NULL
;
1953 for (; bs
!= NULL
; bs
= bs
->next
)
1955 tmp
= (bpstat
) xmalloc (sizeof (*tmp
));
1956 memcpy (tmp
, bs
, sizeof (*tmp
));
1957 if (bs
->commands
!= NULL
)
1958 tmp
->commands
= copy_command_lines (bs
->commands
);
1959 if (bs
->old_val
!= NULL
)
1961 tmp
->old_val
= value_copy (bs
->old_val
);
1962 release_value (tmp
->old_val
);
1966 /* This is the first thing in the chain. */
1976 /* Find the bpstat associated with this breakpoint */
1979 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
1984 for (; bsp
!= NULL
; bsp
= bsp
->next
)
1986 if (bsp
->breakpoint_at
&& bsp
->breakpoint_at
->owner
== breakpoint
)
1992 /* Find a step_resume breakpoint associated with this bpstat.
1993 (If there are multiple step_resume bp's on the list, this function
1994 will arbitrarily pick one.)
1996 It is an error to use this function if BPSTAT doesn't contain a
1997 step_resume breakpoint.
1999 See wait_for_inferior's use of this function. */
2001 bpstat_find_step_resume_breakpoint (bpstat bsp
)
2005 gdb_assert (bsp
!= NULL
);
2007 current_thread
= pid_to_thread_id (inferior_ptid
);
2009 for (; bsp
!= NULL
; bsp
= bsp
->next
)
2011 if ((bsp
->breakpoint_at
!= NULL
) &&
2012 (bsp
->breakpoint_at
->owner
->type
== bp_step_resume
) &&
2013 (bsp
->breakpoint_at
->owner
->thread
== current_thread
||
2014 bsp
->breakpoint_at
->owner
->thread
== -1))
2015 return bsp
->breakpoint_at
->owner
;
2018 internal_error (__FILE__
, __LINE__
, _("No step_resume breakpoint found."));
2022 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
2023 at. *BSP upon return is a bpstat which points to the remaining
2024 breakpoints stopped at (but which is not guaranteed to be good for
2025 anything but further calls to bpstat_num).
2026 Return 0 if passed a bpstat which does not indicate any breakpoints.
2027 Return -1 if stopped at a breakpoint that has been deleted since
2029 Return 1 otherwise. */
2032 bpstat_num (bpstat
*bsp
, int *num
)
2034 struct breakpoint
*b
;
2037 return 0; /* No more breakpoint values */
2039 /* We assume we'll never have several bpstats that
2040 correspond to a single breakpoint -- otherwise,
2041 this function might return the same number more
2042 than once and this will look ugly. */
2043 b
= (*bsp
)->breakpoint_at
? (*bsp
)->breakpoint_at
->owner
: NULL
;
2044 *bsp
= (*bsp
)->next
;
2046 return -1; /* breakpoint that's been deleted since */
2048 *num
= b
->number
; /* We have its number */
2052 /* Modify BS so that the actions will not be performed. */
2055 bpstat_clear_actions (bpstat bs
)
2057 for (; bs
!= NULL
; bs
= bs
->next
)
2059 free_command_lines (&bs
->commands
);
2060 if (bs
->old_val
!= NULL
)
2062 value_free (bs
->old_val
);
2068 /* Stub for cleaning up our state if we error-out of a breakpoint command */
2070 cleanup_executing_breakpoints (void *ignore
)
2072 executing_breakpoint_commands
= 0;
2075 /* Execute all the commands associated with all the breakpoints at this
2076 location. Any of these commands could cause the process to proceed
2077 beyond this point, etc. We look out for such changes by checking
2078 the global "breakpoint_proceeded" after each command.
2080 Returns true if a breakpoint command resumed the inferior. In that
2081 case, it is the caller's responsibility to recall it again with the
2082 bpstat of the current thread. */
2085 bpstat_do_actions_1 (bpstat
*bsp
)
2088 struct cleanup
*old_chain
;
2091 /* Avoid endless recursion if a `source' command is contained
2093 if (executing_breakpoint_commands
)
2096 executing_breakpoint_commands
= 1;
2097 old_chain
= make_cleanup (cleanup_executing_breakpoints
, 0);
2099 /* This pointer will iterate over the list of bpstat's. */
2102 breakpoint_proceeded
= 0;
2103 for (; bs
!= NULL
; bs
= bs
->next
)
2105 struct command_line
*cmd
;
2106 struct cleanup
*this_cmd_tree_chain
;
2108 /* Take ownership of the BSP's command tree, if it has one.
2110 The command tree could legitimately contain commands like
2111 'step' and 'next', which call clear_proceed_status, which
2112 frees stop_bpstat's command tree. To make sure this doesn't
2113 free the tree we're executing out from under us, we need to
2114 take ownership of the tree ourselves. Since a given bpstat's
2115 commands are only executed once, we don't need to copy it; we
2116 can clear the pointer in the bpstat, and make sure we free
2117 the tree when we're done. */
2120 this_cmd_tree_chain
= make_cleanup_free_command_lines (&cmd
);
2124 execute_control_command (cmd
);
2126 if (breakpoint_proceeded
)
2132 /* We can free this command tree now. */
2133 do_cleanups (this_cmd_tree_chain
);
2135 if (breakpoint_proceeded
)
2137 if (target_can_async_p ())
2138 /* If we are in async mode, then the target might be still
2139 running, not stopped at any breakpoint, so nothing for
2140 us to do here -- just return to the event loop. */
2143 /* In sync mode, when execute_control_command returns
2144 we're already standing on the next breakpoint.
2145 Breakpoint commands for that stop were not run, since
2146 execute_command does not run breakpoint commands --
2147 only command_line_handler does, but that one is not
2148 involved in execution of breakpoint commands. So, we
2149 can now execute breakpoint commands. It should be
2150 noted that making execute_command do bpstat actions is
2151 not an option -- in this case we'll have recursive
2152 invocation of bpstat for each breakpoint with a
2153 command, and can easily blow up GDB stack. Instead, we
2154 return true, which will trigger the caller to recall us
2155 with the new stop_bpstat. */
2160 do_cleanups (old_chain
);
2165 bpstat_do_actions (void)
2167 /* Do any commands attached to breakpoint we are stopped at. */
2168 while (!ptid_equal (inferior_ptid
, null_ptid
)
2169 && target_has_execution
2170 && !is_exited (inferior_ptid
)
2171 && !is_executing (inferior_ptid
))
2172 /* Since in sync mode, bpstat_do_actions may resume the inferior,
2173 and only return when it is stopped at the next breakpoint, we
2174 keep doing breakpoint actions until it returns false to
2175 indicate the inferior was not resumed. */
2176 if (!bpstat_do_actions_1 (&inferior_thread ()->stop_bpstat
))
2180 /* Print out the (old or new) value associated with a watchpoint. */
2183 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
2186 fprintf_unfiltered (stream
, _("<unreadable>"));
2189 struct value_print_options opts
;
2190 get_user_print_options (&opts
);
2191 value_print (val
, stream
, &opts
);
2195 /* This is the normal print function for a bpstat. In the future,
2196 much of this logic could (should?) be moved to bpstat_stop_status,
2197 by having it set different print_it values.
2199 Current scheme: When we stop, bpstat_print() is called. It loops
2200 through the bpstat list of things causing this stop, calling the
2201 print_bp_stop_message function on each one. The behavior of the
2202 print_bp_stop_message function depends on the print_it field of
2203 bpstat. If such field so indicates, call this function here.
2205 Return values from this routine (ultimately used by bpstat_print()
2206 and normal_stop() to decide what to do):
2207 PRINT_NOTHING: Means we already printed all we needed to print,
2208 don't print anything else.
2209 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2210 that something to be followed by a location.
2211 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2212 that something to be followed by a location.
2213 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2216 static enum print_stop_action
2217 print_it_typical (bpstat bs
)
2219 struct cleanup
*old_chain
, *ui_out_chain
;
2220 struct breakpoint
*b
;
2221 const struct bp_location
*bl
;
2222 struct ui_stream
*stb
;
2224 stb
= ui_out_stream_new (uiout
);
2225 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
2226 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2227 which has since been deleted. */
2228 if (bs
->breakpoint_at
== NULL
)
2229 return PRINT_UNKNOWN
;
2230 bl
= bs
->breakpoint_at
;
2236 case bp_hardware_breakpoint
:
2237 bp_temp
= bs
->breakpoint_at
->owner
->disposition
== disp_del
;
2238 if (bl
->address
!= bl
->requested_address
)
2239 breakpoint_adjustment_warning (bl
->requested_address
,
2242 annotate_breakpoint (b
->number
);
2244 ui_out_text (uiout
, "\nTemporary breakpoint ");
2246 ui_out_text (uiout
, "\nBreakpoint ");
2247 if (ui_out_is_mi_like_p (uiout
))
2249 ui_out_field_string (uiout
, "reason",
2250 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
2251 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
2253 ui_out_field_int (uiout
, "bkptno", b
->number
);
2254 ui_out_text (uiout
, ", ");
2255 return PRINT_SRC_AND_LOC
;
2258 case bp_shlib_event
:
2259 /* Did we stop because the user set the stop_on_solib_events
2260 variable? (If so, we report this as a generic, "Stopped due
2261 to shlib event" message.) */
2262 printf_filtered (_("Stopped due to shared library event\n"));
2263 return PRINT_NOTHING
;
2266 case bp_thread_event
:
2267 /* Not sure how we will get here.
2268 GDB should not stop for these breakpoints. */
2269 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
2270 return PRINT_NOTHING
;
2273 case bp_overlay_event
:
2274 /* By analogy with the thread event, GDB should not stop for these. */
2275 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
2276 return PRINT_NOTHING
;
2280 case bp_hardware_watchpoint
:
2281 annotate_watchpoint (b
->number
);
2282 if (ui_out_is_mi_like_p (uiout
))
2285 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
2287 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2288 ui_out_text (uiout
, "\nOld value = ");
2289 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2290 ui_out_field_stream (uiout
, "old", stb
);
2291 ui_out_text (uiout
, "\nNew value = ");
2292 watchpoint_value_print (b
->val
, stb
->stream
);
2293 ui_out_field_stream (uiout
, "new", stb
);
2294 do_cleanups (ui_out_chain
);
2295 ui_out_text (uiout
, "\n");
2296 /* More than one watchpoint may have been triggered. */
2297 return PRINT_UNKNOWN
;
2300 case bp_read_watchpoint
:
2301 if (ui_out_is_mi_like_p (uiout
))
2304 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
2306 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2307 ui_out_text (uiout
, "\nValue = ");
2308 watchpoint_value_print (b
->val
, stb
->stream
);
2309 ui_out_field_stream (uiout
, "value", stb
);
2310 do_cleanups (ui_out_chain
);
2311 ui_out_text (uiout
, "\n");
2312 return PRINT_UNKNOWN
;
2315 case bp_access_watchpoint
:
2316 if (bs
->old_val
!= NULL
)
2318 annotate_watchpoint (b
->number
);
2319 if (ui_out_is_mi_like_p (uiout
))
2322 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2324 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2325 ui_out_text (uiout
, "\nOld value = ");
2326 watchpoint_value_print (bs
->old_val
, stb
->stream
);
2327 ui_out_field_stream (uiout
, "old", stb
);
2328 ui_out_text (uiout
, "\nNew value = ");
2333 if (ui_out_is_mi_like_p (uiout
))
2336 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
2337 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "value");
2338 ui_out_text (uiout
, "\nValue = ");
2340 watchpoint_value_print (b
->val
, stb
->stream
);
2341 ui_out_field_stream (uiout
, "new", stb
);
2342 do_cleanups (ui_out_chain
);
2343 ui_out_text (uiout
, "\n");
2344 return PRINT_UNKNOWN
;
2347 /* Fall through, we don't deal with these types of breakpoints
2351 if (ui_out_is_mi_like_p (uiout
))
2354 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED
));
2355 return PRINT_UNKNOWN
;
2359 if (ui_out_is_mi_like_p (uiout
))
2362 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED
));
2363 return PRINT_UNKNOWN
;
2368 case bp_longjmp_resume
:
2369 case bp_step_resume
:
2370 case bp_watchpoint_scope
:
2373 return PRINT_UNKNOWN
;
2377 /* Generic routine for printing messages indicating why we
2378 stopped. The behavior of this function depends on the value
2379 'print_it' in the bpstat structure. Under some circumstances we
2380 may decide not to print anything here and delegate the task to
2383 static enum print_stop_action
2384 print_bp_stop_message (bpstat bs
)
2386 switch (bs
->print_it
)
2389 /* Nothing should be printed for this bpstat entry. */
2390 return PRINT_UNKNOWN
;
2394 /* We still want to print the frame, but we already printed the
2395 relevant messages. */
2396 return PRINT_SRC_AND_LOC
;
2399 case print_it_normal
:
2401 const struct bp_location
*bl
= bs
->breakpoint_at
;
2402 struct breakpoint
*b
= bl
? bl
->owner
: NULL
;
2404 /* Normal case. Call the breakpoint's print_it method, or
2405 print_it_typical. */
2406 /* FIXME: how breakpoint can ever be NULL here? */
2407 if (b
!= NULL
&& b
->ops
!= NULL
&& b
->ops
->print_it
!= NULL
)
2408 return b
->ops
->print_it (b
);
2410 return print_it_typical (bs
);
2415 internal_error (__FILE__
, __LINE__
,
2416 _("print_bp_stop_message: unrecognized enum value"));
2421 /* Print a message indicating what happened. This is called from
2422 normal_stop(). The input to this routine is the head of the bpstat
2423 list - a list of the eventpoints that caused this stop. This
2424 routine calls the generic print routine for printing a message
2425 about reasons for stopping. This will print (for example) the
2426 "Breakpoint n," part of the output. The return value of this
2429 PRINT_UNKNOWN: Means we printed nothing
2430 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
2431 code to print the location. An example is
2432 "Breakpoint 1, " which should be followed by
2434 PRINT_SRC_ONLY: Means we printed something, but there is no need
2435 to also print the location part of the message.
2436 An example is the catch/throw messages, which
2437 don't require a location appended to the end.
2438 PRINT_NOTHING: We have done some printing and we don't need any
2439 further info to be printed.*/
2441 enum print_stop_action
2442 bpstat_print (bpstat bs
)
2446 /* Maybe another breakpoint in the chain caused us to stop.
2447 (Currently all watchpoints go on the bpstat whether hit or not.
2448 That probably could (should) be changed, provided care is taken
2449 with respect to bpstat_explains_signal). */
2450 for (; bs
; bs
= bs
->next
)
2452 val
= print_bp_stop_message (bs
);
2453 if (val
== PRINT_SRC_ONLY
2454 || val
== PRINT_SRC_AND_LOC
2455 || val
== PRINT_NOTHING
)
2459 /* We reached the end of the chain, or we got a null BS to start
2460 with and nothing was printed. */
2461 return PRINT_UNKNOWN
;
2464 /* Evaluate the expression EXP and return 1 if value is zero.
2465 This is used inside a catch_errors to evaluate the breakpoint condition.
2466 The argument is a "struct expression *" that has been cast to char * to
2467 make it pass through catch_errors. */
2470 breakpoint_cond_eval (void *exp
)
2472 struct value
*mark
= value_mark ();
2473 int i
= !value_true (evaluate_expression ((struct expression
*) exp
));
2474 value_free_to_mark (mark
);
2478 /* Allocate a new bpstat and chain it to the current one. */
2481 bpstat_alloc (const struct bp_location
*bl
, bpstat cbs
/* Current "bs" value */ )
2485 bs
= (bpstat
) xmalloc (sizeof (*bs
));
2487 bs
->breakpoint_at
= bl
;
2488 /* If the condition is false, etc., don't do the commands. */
2489 bs
->commands
= NULL
;
2491 bs
->print_it
= print_it_normal
;
2495 /* The target has stopped with waitstatus WS. Check if any hardware
2496 watchpoints have triggered, according to the target. */
2499 watchpoints_triggered (struct target_waitstatus
*ws
)
2501 int stopped_by_watchpoint
= STOPPED_BY_WATCHPOINT (*ws
);
2503 struct breakpoint
*b
;
2505 if (!stopped_by_watchpoint
)
2507 /* We were not stopped by a watchpoint. Mark all watchpoints
2508 as not triggered. */
2510 if (b
->type
== bp_hardware_watchpoint
2511 || b
->type
== bp_read_watchpoint
2512 || b
->type
== bp_access_watchpoint
)
2513 b
->watchpoint_triggered
= watch_triggered_no
;
2518 if (!target_stopped_data_address (¤t_target
, &addr
))
2520 /* We were stopped by a watchpoint, but we don't know where.
2521 Mark all watchpoints as unknown. */
2523 if (b
->type
== bp_hardware_watchpoint
2524 || b
->type
== bp_read_watchpoint
2525 || b
->type
== bp_access_watchpoint
)
2526 b
->watchpoint_triggered
= watch_triggered_unknown
;
2528 return stopped_by_watchpoint
;
2531 /* The target could report the data address. Mark watchpoints
2532 affected by this data address as triggered, and all others as not
2536 if (b
->type
== bp_hardware_watchpoint
2537 || b
->type
== bp_read_watchpoint
2538 || b
->type
== bp_access_watchpoint
)
2540 struct bp_location
*loc
;
2543 b
->watchpoint_triggered
= watch_triggered_no
;
2544 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
2545 /* Exact match not required. Within range is
2547 if (target_watchpoint_addr_within_range (¤t_target
,
2551 b
->watchpoint_triggered
= watch_triggered_yes
;
2559 /* Possible return values for watchpoint_check (this can't be an enum
2560 because of check_errors). */
2561 /* The watchpoint has been deleted. */
2562 #define WP_DELETED 1
2563 /* The value has changed. */
2564 #define WP_VALUE_CHANGED 2
2565 /* The value has not changed. */
2566 #define WP_VALUE_NOT_CHANGED 3
2568 #define BP_TEMPFLAG 1
2569 #define BP_HARDWAREFLAG 2
2571 /* Check watchpoint condition. */
2574 watchpoint_check (void *p
)
2576 bpstat bs
= (bpstat
) p
;
2577 struct breakpoint
*b
;
2578 struct frame_info
*fr
;
2579 int within_current_scope
;
2581 b
= bs
->breakpoint_at
->owner
;
2583 if (b
->exp_valid_block
== NULL
)
2584 within_current_scope
= 1;
2587 /* There is no current frame at this moment. If we're going to have
2588 any chance of handling watchpoints on local variables, we'll need
2589 the frame chain (so we can determine if we're in scope). */
2590 reinit_frame_cache ();
2591 fr
= frame_find_by_id (b
->watchpoint_frame
);
2592 within_current_scope
= (fr
!= NULL
);
2594 /* If we've gotten confused in the unwinder, we might have
2595 returned a frame that can't describe this variable. */
2596 if (within_current_scope
2597 && (block_linkage_function (b
->exp_valid_block
)
2598 != get_frame_function (fr
)))
2599 within_current_scope
= 0;
2601 /* in_function_epilogue_p() returns a non-zero value if we're still
2602 in the function but the stack frame has already been invalidated.
2603 Since we can't rely on the values of local variables after the
2604 stack has been destroyed, we are treating the watchpoint in that
2605 state as `not changed' without further checking.
2607 vinschen/2003-09-04: The former implementation left out the case
2608 that the watchpoint frame couldn't be found by frame_find_by_id()
2609 because the current PC is currently in an epilogue. Calling
2610 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
2611 if ((!within_current_scope
|| fr
== get_current_frame ())
2612 && gdbarch_in_function_epilogue_p (current_gdbarch
, read_pc ()))
2613 return WP_VALUE_NOT_CHANGED
;
2614 if (fr
&& within_current_scope
)
2615 /* If we end up stopping, the current frame will get selected
2616 in normal_stop. So this call to select_frame won't affect
2621 if (within_current_scope
)
2623 /* We use value_{,free_to_}mark because it could be a
2624 *long* time before we return to the command level and
2625 call free_all_values. We can't call free_all_values because
2626 we might be in the middle of evaluating a function call. */
2628 struct value
*mark
= value_mark ();
2629 struct value
*new_val
;
2631 fetch_watchpoint_value (b
->exp
, &new_val
, NULL
, NULL
);
2632 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
2633 || (b
->val
!= NULL
&& !value_equal (b
->val
, new_val
)))
2635 if (new_val
!= NULL
)
2637 release_value (new_val
);
2638 value_free_to_mark (mark
);
2640 bs
->old_val
= b
->val
;
2643 /* We will stop here */
2644 return WP_VALUE_CHANGED
;
2648 /* Nothing changed, don't do anything. */
2649 value_free_to_mark (mark
);
2650 /* We won't stop here */
2651 return WP_VALUE_NOT_CHANGED
;
2656 /* This seems like the only logical thing to do because
2657 if we temporarily ignored the watchpoint, then when
2658 we reenter the block in which it is valid it contains
2659 garbage (in the case of a function, it may have two
2660 garbage values, one before and one after the prologue).
2661 So we can't even detect the first assignment to it and
2662 watch after that (since the garbage may or may not equal
2663 the first value assigned). */
2664 /* We print all the stop information in print_it_typical(), but
2665 in this case, by the time we call print_it_typical() this bp
2666 will be deleted already. So we have no choice but print the
2667 information here. */
2668 if (ui_out_is_mi_like_p (uiout
))
2670 (uiout
, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
2671 ui_out_text (uiout
, "\nWatchpoint ");
2672 ui_out_field_int (uiout
, "wpnum", b
->number
);
2673 ui_out_text (uiout
, " deleted because the program has left the block in\n\
2674 which its expression is valid.\n");
2676 if (b
->related_breakpoint
)
2677 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2678 b
->disposition
= disp_del_at_next_stop
;
2684 /* Return true if it looks like target has stopped due to hitting
2685 breakpoint location BL. This function does not check if we
2686 should stop, only if BL explains the stop. */
2688 bpstat_check_location (const struct bp_location
*bl
, CORE_ADDR bp_addr
)
2690 struct breakpoint
*b
= bl
->owner
;
2692 if (b
->type
!= bp_watchpoint
2693 && b
->type
!= bp_hardware_watchpoint
2694 && b
->type
!= bp_read_watchpoint
2695 && b
->type
!= bp_access_watchpoint
2696 && b
->type
!= bp_hardware_breakpoint
2697 && b
->type
!= bp_catchpoint
) /* a non-watchpoint bp */
2699 if (bl
->address
!= bp_addr
) /* address doesn't match */
2701 if (overlay_debugging
/* unmapped overlay section */
2702 && section_is_overlay (bl
->section
)
2703 && !section_is_mapped (bl
->section
))
2707 /* Continuable hardware watchpoints are treated as non-existent if the
2708 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2709 some data address). Otherwise gdb won't stop on a break instruction
2710 in the code (not from a breakpoint) when a hardware watchpoint has
2711 been defined. Also skip watchpoints which we know did not trigger
2712 (did not match the data address). */
2714 if ((b
->type
== bp_hardware_watchpoint
2715 || b
->type
== bp_read_watchpoint
2716 || b
->type
== bp_access_watchpoint
)
2717 && b
->watchpoint_triggered
== watch_triggered_no
)
2720 if (b
->type
== bp_hardware_breakpoint
)
2722 if (bl
->address
!= bp_addr
)
2724 if (overlay_debugging
/* unmapped overlay section */
2725 && section_is_overlay (bl
->section
)
2726 && !section_is_mapped (bl
->section
))
2730 if (b
->type
== bp_catchpoint
)
2732 gdb_assert (b
->ops
!= NULL
&& b
->ops
->breakpoint_hit
!= NULL
);
2733 if (!b
->ops
->breakpoint_hit (b
))
2740 /* If BS refers to a watchpoint, determine if the watched values
2741 has actually changed, and we should stop. If not, set BS->stop
2744 bpstat_check_watchpoint (bpstat bs
)
2746 const struct bp_location
*bl
= bs
->breakpoint_at
;
2747 struct breakpoint
*b
= bl
->owner
;
2749 if (b
->type
== bp_watchpoint
2750 || b
->type
== bp_read_watchpoint
2751 || b
->type
== bp_access_watchpoint
2752 || b
->type
== bp_hardware_watchpoint
)
2756 int must_check_value
= 0;
2758 if (b
->type
== bp_watchpoint
)
2759 /* For a software watchpoint, we must always check the
2761 must_check_value
= 1;
2762 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
2763 /* We have a hardware watchpoint (read, write, or access)
2764 and the target earlier reported an address watched by
2766 must_check_value
= 1;
2767 else if (b
->watchpoint_triggered
== watch_triggered_unknown
2768 && b
->type
== bp_hardware_watchpoint
)
2769 /* We were stopped by a hardware watchpoint, but the target could
2770 not report the data address. We must check the watchpoint's
2771 value. Access and read watchpoints are out of luck; without
2772 a data address, we can't figure it out. */
2773 must_check_value
= 1;
2775 if (must_check_value
)
2777 char *message
= xstrprintf ("Error evaluating expression for watchpoint %d\n",
2779 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
2780 int e
= catch_errors (watchpoint_check
, bs
, message
,
2782 do_cleanups (cleanups
);
2786 /* We've already printed what needs to be printed. */
2787 bs
->print_it
= print_it_done
;
2790 case WP_VALUE_CHANGED
:
2791 if (b
->type
== bp_read_watchpoint
)
2793 /* Don't stop: read watchpoints shouldn't fire if
2794 the value has changed. This is for targets
2795 which cannot set read-only watchpoints. */
2796 bs
->print_it
= print_it_noop
;
2800 case WP_VALUE_NOT_CHANGED
:
2801 if (b
->type
== bp_hardware_watchpoint
2802 || b
->type
== bp_watchpoint
)
2804 /* Don't stop: write watchpoints shouldn't fire if
2805 the value hasn't changed. */
2806 bs
->print_it
= print_it_noop
;
2814 /* Error from catch_errors. */
2815 printf_filtered (_("Watchpoint %d deleted.\n"), b
->number
);
2816 if (b
->related_breakpoint
)
2817 b
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
2818 b
->disposition
= disp_del_at_next_stop
;
2819 /* We've already printed what needs to be printed. */
2820 bs
->print_it
= print_it_done
;
2824 else /* must_check_value == 0 */
2826 /* This is a case where some watchpoint(s) triggered, but
2827 not at the address of this watchpoint, or else no
2828 watchpoint triggered after all. So don't print
2829 anything for this watchpoint. */
2830 bs
->print_it
= print_it_noop
;
2837 /* Check conditions (condition proper, frame, thread and ignore count)
2838 of breakpoint referred to by BS. If we should not stop for this
2839 breakpoint, set BS->stop to 0. */
2841 bpstat_check_breakpoint_conditions (bpstat bs
, ptid_t ptid
)
2843 int thread_id
= pid_to_thread_id (ptid
);
2844 const struct bp_location
*bl
= bs
->breakpoint_at
;
2845 struct breakpoint
*b
= bl
->owner
;
2847 if (frame_id_p (b
->frame_id
)
2848 && !frame_id_eq (b
->frame_id
, get_frame_id (get_current_frame ())))
2852 int value_is_zero
= 0;
2854 /* If this is a scope breakpoint, mark the associated
2855 watchpoint as triggered so that we will handle the
2856 out-of-scope event. We'll get to the watchpoint next
2858 if (b
->type
== bp_watchpoint_scope
)
2859 b
->related_breakpoint
->watchpoint_triggered
= watch_triggered_yes
;
2861 if (bl
->cond
&& bl
->owner
->disposition
!= disp_del_at_next_stop
)
2863 /* Need to select the frame, with all that implies
2864 so that the conditions will have the right context. */
2865 select_frame (get_current_frame ());
2867 = catch_errors (breakpoint_cond_eval
, (bl
->cond
),
2868 "Error in testing breakpoint condition:\n",
2870 /* FIXME-someday, should give breakpoint # */
2873 if (bl
->cond
&& value_is_zero
)
2877 else if (b
->thread
!= -1 && b
->thread
!= thread_id
)
2881 else if (b
->ignore_count
> 0)
2884 annotate_ignore_count_change ();
2886 /* Increase the hit count even though we don't
2894 /* Get a bpstat associated with having just stopped at address
2895 BP_ADDR in thread PTID.
2897 Determine whether we stopped at a breakpoint, etc, or whether we
2898 don't understand this stop. Result is a chain of bpstat's such that:
2900 if we don't understand the stop, the result is a null pointer.
2902 if we understand why we stopped, the result is not null.
2904 Each element of the chain refers to a particular breakpoint or
2905 watchpoint at which we have stopped. (We may have stopped for
2906 several reasons concurrently.)
2908 Each element of the chain has valid next, breakpoint_at,
2909 commands, FIXME??? fields. */
2912 bpstat_stop_status (CORE_ADDR bp_addr
, ptid_t ptid
)
2914 struct breakpoint
*b
= NULL
;
2915 const struct bp_location
*bl
;
2916 struct bp_location
*loc
;
2917 /* Root of the chain of bpstat's */
2918 struct bpstats root_bs
[1];
2919 /* Pointer to the last thing in the chain currently. */
2920 bpstat bs
= root_bs
;
2922 int need_remove_insert
;
2924 ALL_BP_LOCATIONS (bl
)
2928 if (!breakpoint_enabled (b
) && b
->enable_state
!= bp_permanent
)
2931 /* For hardware watchpoints, we look only at the first location.
2932 The watchpoint_check function will work on entire expression,
2933 not the individual locations. For read watchopints, the
2934 watchpoints_triggered function have checked all locations
2937 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
2940 if (!bpstat_check_location (bl
, bp_addr
))
2943 /* Come here if it's a watchpoint, or if the break address matches */
2945 bs
= bpstat_alloc (bl
, bs
); /* Alloc a bpstat to explain stop */
2947 /* Assume we stop. Should we find watchpoint that is not actually
2948 triggered, or if condition of breakpoint is false, we'll reset
2953 bpstat_check_watchpoint (bs
);
2957 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
)
2958 /* We do not stop for these. */
2961 bpstat_check_breakpoint_conditions (bs
, ptid
);
2967 /* We will stop here */
2968 if (b
->disposition
== disp_disable
)
2970 if (b
->enable_state
!= bp_permanent
)
2971 b
->enable_state
= bp_disabled
;
2972 update_global_location_list (0);
2976 bs
->commands
= b
->commands
;
2978 (strcmp ("silent", bs
->commands
->line
) == 0
2979 || (xdb_commands
&& strcmp ("Q", bs
->commands
->line
) == 0)))
2981 bs
->commands
= bs
->commands
->next
;
2984 bs
->commands
= copy_command_lines (bs
->commands
);
2987 /* Print nothing for this entry if we dont stop or if we dont print. */
2988 if (bs
->stop
== 0 || bs
->print
== 0)
2989 bs
->print_it
= print_it_noop
;
2992 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
2994 if (loc
->address
== bp_addr
)
2996 bs
= bpstat_alloc (loc
, bs
);
2997 /* For hits of moribund locations, we should just proceed. */
3000 bs
->print_it
= print_it_noop
;
3004 bs
->next
= NULL
; /* Terminate the chain */
3005 bs
= root_bs
->next
; /* Re-grab the head of the chain */
3007 /* If we aren't stopping, the value of some hardware watchpoint may
3008 not have changed, but the intermediate memory locations we are
3009 watching may have. Don't bother if we're stopping; this will get
3011 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3015 need_remove_insert
= 0;
3017 for (bs
= root_bs
->next
; bs
!= NULL
; bs
= bs
->next
)
3019 && bs
->breakpoint_at
->owner
3020 && (bs
->breakpoint_at
->owner
->type
== bp_hardware_watchpoint
3021 || bs
->breakpoint_at
->owner
->type
== bp_read_watchpoint
3022 || bs
->breakpoint_at
->owner
->type
== bp_access_watchpoint
))
3024 /* remove/insert can invalidate bs->breakpoint_at, if this
3025 location is no longer used by the watchpoint. Prevent
3026 further code from trying to use it. */
3027 bs
->breakpoint_at
= NULL
;
3028 need_remove_insert
= 1;
3031 if (need_remove_insert
)
3033 remove_breakpoints ();
3034 insert_breakpoints ();
3037 return root_bs
->next
;
3040 /* Tell what to do about this bpstat. */
3042 bpstat_what (bpstat bs
)
3044 /* Classify each bpstat as one of the following. */
3047 /* This bpstat element has no effect on the main_action. */
3050 /* There was a watchpoint, stop but don't print. */
3053 /* There was a watchpoint, stop and print. */
3056 /* There was a breakpoint but we're not stopping. */
3059 /* There was a breakpoint, stop but don't print. */
3062 /* There was a breakpoint, stop and print. */
3065 /* We hit the longjmp breakpoint. */
3068 /* We hit the longjmp_resume breakpoint. */
3071 /* We hit the step_resume breakpoint. */
3074 /* We hit the shared library event breakpoint. */
3077 /* This is just used to count how many enums there are. */
3081 /* Here is the table which drives this routine. So that we can
3082 format it pretty, we define some abbreviations for the
3083 enum bpstat_what codes. */
3084 #define kc BPSTAT_WHAT_KEEP_CHECKING
3085 #define ss BPSTAT_WHAT_STOP_SILENT
3086 #define sn BPSTAT_WHAT_STOP_NOISY
3087 #define sgl BPSTAT_WHAT_SINGLE
3088 #define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
3089 #define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
3090 #define sr BPSTAT_WHAT_STEP_RESUME
3091 #define shl BPSTAT_WHAT_CHECK_SHLIBS
3093 /* "Can't happen." Might want to print an error message.
3094 abort() is not out of the question, but chances are GDB is just
3095 a bit confused, not unusable. */
3096 #define err BPSTAT_WHAT_STOP_NOISY
3098 /* Given an old action and a class, come up with a new action. */
3099 /* One interesting property of this table is that wp_silent is the same
3100 as bp_silent and wp_noisy is the same as bp_noisy. That is because
3101 after stopping, the check for whether to step over a breakpoint
3102 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
3103 reference to how we stopped. We retain separate wp_silent and
3104 bp_silent codes in case we want to change that someday.
3106 Another possibly interesting property of this table is that
3107 there's a partial ordering, priority-like, of the actions. Once
3108 you've decided that some action is appropriate, you'll never go
3109 back and decide something of a lower priority is better. The
3112 kc < clr sgl shl slr sn sr ss
3113 sgl < shl slr sn sr ss
3114 slr < err shl sn sr ss
3115 clr < err shl sn sr ss
3121 What I think this means is that we don't need a damned table
3122 here. If you just put the rows and columns in the right order,
3123 it'd look awfully regular. We could simply walk the bpstat list
3124 and choose the highest priority action we find, with a little
3125 logic to handle the 'err' cases. */
3127 /* step_resume entries: a step resume breakpoint overrides another
3128 breakpoint of signal handling (see comment in wait_for_inferior
3129 at where we set the step_resume breakpoint). */
3131 static const enum bpstat_what_main_action
3132 table
[(int) class_last
][(int) BPSTAT_WHAT_LAST
] =
3135 /* kc ss sn sgl slr clr sr shl
3138 {kc
, ss
, sn
, sgl
, slr
, clr
, sr
, shl
},
3140 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3142 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3144 {sgl
, ss
, sn
, sgl
, slr
, slr
, sr
, shl
},
3146 {ss
, ss
, sn
, ss
, ss
, ss
, sr
, shl
},
3148 {sn
, sn
, sn
, sn
, sn
, sn
, sr
, shl
},
3150 {slr
, ss
, sn
, slr
, slr
, err
, sr
, shl
},
3152 {clr
, ss
, sn
, err
, err
, err
, sr
, shl
},
3154 {sr
, sr
, sr
, sr
, sr
, sr
, sr
, sr
},
3156 {shl
, shl
, shl
, shl
, shl
, shl
, sr
, shl
}
3169 enum bpstat_what_main_action current_action
= BPSTAT_WHAT_KEEP_CHECKING
;
3170 struct bpstat_what retval
;
3172 retval
.call_dummy
= 0;
3173 for (; bs
!= NULL
; bs
= bs
->next
)
3175 enum class bs_class
= no_effect
;
3176 if (bs
->breakpoint_at
== NULL
)
3177 /* I suspect this can happen if it was a momentary breakpoint
3178 which has since been deleted. */
3180 if (bs
->breakpoint_at
->owner
== NULL
)
3181 bs_class
= bp_nostop
;
3183 switch (bs
->breakpoint_at
->owner
->type
)
3189 case bp_hardware_breakpoint
:
3195 bs_class
= bp_noisy
;
3197 bs_class
= bp_silent
;
3200 bs_class
= bp_nostop
;
3203 case bp_hardware_watchpoint
:
3204 case bp_read_watchpoint
:
3205 case bp_access_watchpoint
:
3209 bs_class
= wp_noisy
;
3211 bs_class
= wp_silent
;
3214 /* There was a watchpoint, but we're not stopping.
3215 This requires no further action. */
3216 bs_class
= no_effect
;
3219 bs_class
= long_jump
;
3221 case bp_longjmp_resume
:
3222 bs_class
= long_resume
;
3224 case bp_step_resume
:
3227 bs_class
= step_resume
;
3230 /* It is for the wrong frame. */
3231 bs_class
= bp_nostop
;
3233 case bp_watchpoint_scope
:
3234 bs_class
= bp_nostop
;
3236 case bp_shlib_event
:
3237 bs_class
= shlib_event
;
3239 case bp_thread_event
:
3240 case bp_overlay_event
:
3241 bs_class
= bp_nostop
;
3247 bs_class
= bp_noisy
;
3249 bs_class
= bp_silent
;
3252 /* There was a catchpoint, but we're not stopping.
3253 This requires no further action. */
3254 bs_class
= no_effect
;
3257 /* Make sure the action is stop (silent or noisy),
3258 so infrun.c pops the dummy frame. */
3259 bs_class
= bp_silent
;
3260 retval
.call_dummy
= 1;
3263 current_action
= table
[(int) bs_class
][(int) current_action
];
3265 retval
.main_action
= current_action
;
3269 /* Nonzero if we should step constantly (e.g. watchpoints on machines
3270 without hardware support). This isn't related to a specific bpstat,
3271 just to things like whether watchpoints are set. */
3274 bpstat_should_step (void)
3276 struct breakpoint
*b
;
3278 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
)
3285 static void print_breakpoint_location (struct breakpoint
*b
,
3286 struct bp_location
*loc
,
3288 struct ui_stream
*stb
)
3293 = find_pc_sect_function (loc
->address
, loc
->section
);
3296 ui_out_text (uiout
, "in ");
3297 ui_out_field_string (uiout
, "func",
3298 SYMBOL_PRINT_NAME (sym
));
3299 ui_out_wrap_hint (uiout
, wrap_indent
);
3300 ui_out_text (uiout
, " at ");
3302 ui_out_field_string (uiout
, "file", b
->source_file
);
3303 ui_out_text (uiout
, ":");
3305 if (ui_out_is_mi_like_p (uiout
))
3307 struct symtab_and_line sal
= find_pc_line (loc
->address
, 0);
3308 char *fullname
= symtab_to_fullname (sal
.symtab
);
3311 ui_out_field_string (uiout
, "fullname", fullname
);
3314 ui_out_field_int (uiout
, "line", b
->line_number
);
3318 ui_out_field_string (uiout
, "pending", b
->addr_string
);
3322 print_address_symbolic (loc
->address
, stb
->stream
, demangle
, "");
3323 ui_out_field_stream (uiout
, "at", stb
);
3327 /* Print B to gdb_stdout. */
3329 print_one_breakpoint_location (struct breakpoint
*b
,
3330 struct bp_location
*loc
,
3332 CORE_ADDR
*last_addr
)
3334 struct command_line
*l
;
3336 struct ep_type_description
3341 static struct ep_type_description bptypes
[] =
3343 {bp_none
, "?deleted?"},
3344 {bp_breakpoint
, "breakpoint"},
3345 {bp_hardware_breakpoint
, "hw breakpoint"},
3346 {bp_until
, "until"},
3347 {bp_finish
, "finish"},
3348 {bp_watchpoint
, "watchpoint"},
3349 {bp_hardware_watchpoint
, "hw watchpoint"},
3350 {bp_read_watchpoint
, "read watchpoint"},
3351 {bp_access_watchpoint
, "acc watchpoint"},
3352 {bp_longjmp
, "longjmp"},
3353 {bp_longjmp_resume
, "longjmp resume"},
3354 {bp_step_resume
, "step resume"},
3355 {bp_watchpoint_scope
, "watchpoint scope"},
3356 {bp_call_dummy
, "call dummy"},
3357 {bp_shlib_event
, "shlib events"},
3358 {bp_thread_event
, "thread events"},
3359 {bp_overlay_event
, "overlay events"},
3360 {bp_catchpoint
, "catchpoint"},
3363 static char bpenables
[] = "nynny";
3364 char wrap_indent
[80];
3365 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
3366 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
3367 struct cleanup
*bkpt_chain
;
3369 int header_of_multiple
= 0;
3370 int part_of_multiple
= (loc
!= NULL
);
3371 struct value_print_options opts
;
3373 get_user_print_options (&opts
);
3375 gdb_assert (!loc
|| loc_number
!= 0);
3376 /* See comment in print_one_breakpoint concerning
3377 treatment of breakpoints with single disabled
3381 && (b
->loc
->next
!= NULL
|| !b
->loc
->enabled
)))
3382 header_of_multiple
= 1;
3387 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "bkpt");
3391 if (part_of_multiple
)
3394 formatted
= xstrprintf ("%d.%d", b
->number
, loc_number
);
3395 ui_out_field_string (uiout
, "number", formatted
);
3400 ui_out_field_int (uiout
, "number", b
->number
);
3405 if (part_of_multiple
)
3406 ui_out_field_skip (uiout
, "type");
3409 if (((int) b
->type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
3410 || ((int) b
->type
!= bptypes
[(int) b
->type
].type
))
3411 internal_error (__FILE__
, __LINE__
,
3412 _("bptypes table does not describe type #%d."),
3414 ui_out_field_string (uiout
, "type", bptypes
[(int) b
->type
].description
);
3419 if (part_of_multiple
)
3420 ui_out_field_skip (uiout
, "disp");
3422 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
3427 if (part_of_multiple
)
3428 ui_out_field_string (uiout
, "enabled", loc
->enabled
? "y" : "n");
3430 ui_out_field_fmt (uiout
, "enabled", "%c",
3431 bpenables
[(int) b
->enable_state
]);
3432 ui_out_spaces (uiout
, 2);
3436 strcpy (wrap_indent
, " ");
3437 if (opts
.addressprint
)
3439 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3440 strcat (wrap_indent
, " ");
3442 strcat (wrap_indent
, " ");
3445 if (b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
3447 /* Although the print_one can possibly print
3448 all locations, calling it here is not likely
3449 to get any nice result. So, make sure there's
3450 just one location. */
3451 gdb_assert (b
->loc
== NULL
|| b
->loc
->next
== NULL
);
3452 b
->ops
->print_one (b
, last_addr
);
3458 internal_error (__FILE__
, __LINE__
,
3459 _("print_one_breakpoint: bp_none encountered\n"));
3463 case bp_hardware_watchpoint
:
3464 case bp_read_watchpoint
:
3465 case bp_access_watchpoint
:
3466 /* Field 4, the address, is omitted (which makes the columns
3467 not line up too nicely with the headers, but the effect
3468 is relatively readable). */
3469 if (opts
.addressprint
)
3470 ui_out_field_skip (uiout
, "addr");
3472 print_expression (b
->exp
, stb
->stream
);
3473 ui_out_field_stream (uiout
, "what", stb
);
3477 case bp_hardware_breakpoint
:
3481 case bp_longjmp_resume
:
3482 case bp_step_resume
:
3483 case bp_watchpoint_scope
:
3485 case bp_shlib_event
:
3486 case bp_thread_event
:
3487 case bp_overlay_event
:
3488 if (opts
.addressprint
)
3491 if (header_of_multiple
)
3492 ui_out_field_string (uiout
, "addr", "<MULTIPLE>");
3493 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
3494 ui_out_field_string (uiout
, "addr", "<PENDING>");
3496 ui_out_field_core_addr (uiout
, "addr", loc
->address
);
3499 if (!header_of_multiple
)
3500 print_breakpoint_location (b
, loc
, wrap_indent
, stb
);
3502 *last_addr
= b
->loc
->address
;
3506 if (!part_of_multiple
&& b
->thread
!= -1)
3508 /* FIXME: This seems to be redundant and lost here; see the
3509 "stop only in" line a little further down. */
3510 ui_out_text (uiout
, " thread ");
3511 ui_out_field_int (uiout
, "thread", b
->thread
);
3514 ui_out_text (uiout
, "\n");
3516 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
3519 ui_out_text (uiout
, "\tstop only in stack frame at ");
3520 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3522 ui_out_field_core_addr (uiout
, "frame", b
->frame_id
.stack_addr
);
3523 ui_out_text (uiout
, "\n");
3526 if (!part_of_multiple
&& b
->cond_string
&& !ada_exception_catchpoint_p (b
))
3528 /* We do not print the condition for Ada exception catchpoints
3529 because the condition is an internal implementation detail
3530 that we do not want to expose to the user. */
3532 ui_out_text (uiout
, "\tstop only if ");
3533 ui_out_field_string (uiout
, "cond", b
->cond_string
);
3534 ui_out_text (uiout
, "\n");
3537 if (!part_of_multiple
&& b
->thread
!= -1)
3539 /* FIXME should make an annotation for this */
3540 ui_out_text (uiout
, "\tstop only in thread ");
3541 ui_out_field_int (uiout
, "thread", b
->thread
);
3542 ui_out_text (uiout
, "\n");
3545 if (!part_of_multiple
&& b
->hit_count
)
3547 /* FIXME should make an annotation for this */
3548 if (ep_is_catchpoint (b
))
3549 ui_out_text (uiout
, "\tcatchpoint");
3551 ui_out_text (uiout
, "\tbreakpoint");
3552 ui_out_text (uiout
, " already hit ");
3553 ui_out_field_int (uiout
, "times", b
->hit_count
);
3554 if (b
->hit_count
== 1)
3555 ui_out_text (uiout
, " time\n");
3557 ui_out_text (uiout
, " times\n");
3560 /* Output the count also if it is zero, but only if this is
3561 mi. FIXME: Should have a better test for this. */
3562 if (ui_out_is_mi_like_p (uiout
))
3563 if (!part_of_multiple
&& b
->hit_count
== 0)
3564 ui_out_field_int (uiout
, "times", b
->hit_count
);
3566 if (!part_of_multiple
&& b
->ignore_count
)
3569 ui_out_text (uiout
, "\tignore next ");
3570 ui_out_field_int (uiout
, "ignore", b
->ignore_count
);
3571 ui_out_text (uiout
, " hits\n");
3574 if (!part_of_multiple
&& (l
= b
->commands
))
3576 struct cleanup
*script_chain
;
3579 script_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "script");
3580 print_command_lines (uiout
, l
, 4);
3581 do_cleanups (script_chain
);
3584 if (ui_out_is_mi_like_p (uiout
) && !part_of_multiple
)
3587 ui_out_field_string (uiout
, "original-location", b
->addr_string
);
3588 else if (b
->exp_string
)
3589 ui_out_field_string (uiout
, "original-location", b
->exp_string
);
3592 do_cleanups (bkpt_chain
);
3593 do_cleanups (old_chain
);
3597 print_one_breakpoint (struct breakpoint
*b
,
3598 CORE_ADDR
*last_addr
)
3600 print_one_breakpoint_location (b
, NULL
, 0, last_addr
);
3602 /* If this breakpoint has custom print function,
3603 it's already printed. Otherwise, print individual
3604 locations, if any. */
3605 if (b
->ops
== NULL
|| b
->ops
->print_one
== NULL
)
3607 /* If breakpoint has a single location that is
3608 disabled, we print it as if it had
3609 several locations, since otherwise it's hard to
3610 represent "breakpoint enabled, location disabled"
3612 Note that while hardware watchpoints have
3613 several locations internally, that's no a property
3616 && !is_hardware_watchpoint (b
)
3617 && (b
->loc
->next
|| !b
->loc
->enabled
)
3618 && !ui_out_is_mi_like_p (uiout
))
3620 struct bp_location
*loc
;
3622 for (loc
= b
->loc
; loc
; loc
= loc
->next
, ++n
)
3623 print_one_breakpoint_location (b
, loc
, n
, last_addr
);
3629 struct captured_breakpoint_query_args
3635 do_captured_breakpoint_query (struct ui_out
*uiout
, void *data
)
3637 struct captured_breakpoint_query_args
*args
= data
;
3638 struct breakpoint
*b
;
3639 CORE_ADDR dummy_addr
= 0;
3642 if (args
->bnum
== b
->number
)
3644 print_one_breakpoint (b
, &dummy_addr
);
3652 gdb_breakpoint_query (struct ui_out
*uiout
, int bnum
, char **error_message
)
3654 struct captured_breakpoint_query_args args
;
3656 /* For the moment we don't trust print_one_breakpoint() to not throw
3658 if (catch_exceptions_with_msg (uiout
, do_captured_breakpoint_query
, &args
,
3659 error_message
, RETURN_MASK_ALL
) < 0)
3665 /* Return non-zero if B is user settable (breakpoints, watchpoints,
3666 catchpoints, et.al.). */
3669 user_settable_breakpoint (const struct breakpoint
*b
)
3671 return (b
->type
== bp_breakpoint
3672 || b
->type
== bp_catchpoint
3673 || b
->type
== bp_hardware_breakpoint
3674 || b
->type
== bp_watchpoint
3675 || b
->type
== bp_read_watchpoint
3676 || b
->type
== bp_access_watchpoint
3677 || b
->type
== bp_hardware_watchpoint
);
3680 /* Print information on user settable breakpoint (watchpoint, etc)
3681 number BNUM. If BNUM is -1 print all user settable breakpoints.
3682 If ALLFLAG is non-zero, include non- user settable breakpoints. */
3685 breakpoint_1 (int bnum
, int allflag
)
3687 struct breakpoint
*b
;
3688 CORE_ADDR last_addr
= (CORE_ADDR
) -1;
3689 int nr_printable_breakpoints
;
3690 struct cleanup
*bkpttbl_chain
;
3691 struct value_print_options opts
;
3693 get_user_print_options (&opts
);
3695 /* Compute the number of rows in the table. */
3696 nr_printable_breakpoints
= 0;
3699 || bnum
== b
->number
)
3701 if (allflag
|| user_settable_breakpoint (b
))
3702 nr_printable_breakpoints
++;
3705 if (opts
.addressprint
)
3707 = make_cleanup_ui_out_table_begin_end (uiout
, 6, nr_printable_breakpoints
,
3711 = make_cleanup_ui_out_table_begin_end (uiout
, 5, nr_printable_breakpoints
,
3714 if (nr_printable_breakpoints
> 0)
3715 annotate_breakpoints_headers ();
3716 if (nr_printable_breakpoints
> 0)
3718 ui_out_table_header (uiout
, 7, ui_left
, "number", "Num"); /* 1 */
3719 if (nr_printable_breakpoints
> 0)
3721 ui_out_table_header (uiout
, 14, ui_left
, "type", "Type"); /* 2 */
3722 if (nr_printable_breakpoints
> 0)
3724 ui_out_table_header (uiout
, 4, ui_left
, "disp", "Disp"); /* 3 */
3725 if (nr_printable_breakpoints
> 0)
3727 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb"); /* 4 */
3728 if (opts
.addressprint
)
3730 if (nr_printable_breakpoints
> 0)
3732 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
3733 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");/* 5 */
3735 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");/* 5 */
3737 if (nr_printable_breakpoints
> 0)
3739 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What"); /* 6 */
3740 ui_out_table_body (uiout
);
3741 if (nr_printable_breakpoints
> 0)
3742 annotate_breakpoints_table ();
3746 || bnum
== b
->number
)
3748 /* We only print out user settable breakpoints unless the
3750 if (allflag
|| user_settable_breakpoint (b
))
3751 print_one_breakpoint (b
, &last_addr
);
3754 do_cleanups (bkpttbl_chain
);
3756 if (nr_printable_breakpoints
== 0)
3759 ui_out_message (uiout
, 0, "No breakpoints or watchpoints.\n");
3761 ui_out_message (uiout
, 0, "No breakpoint or watchpoint number %d.\n",
3766 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3767 that a comparison of an unsigned with -1 is always false. */
3768 if (last_addr
!= (CORE_ADDR
) -1 && !server_command
)
3769 set_next_address (current_gdbarch
, last_addr
);
3772 /* FIXME? Should this be moved up so that it is only called when
3773 there have been breakpoints? */
3774 annotate_breakpoints_table_end ();
3778 breakpoints_info (char *bnum_exp
, int from_tty
)
3783 bnum
= parse_and_eval_long (bnum_exp
);
3785 breakpoint_1 (bnum
, 0);
3789 maintenance_info_breakpoints (char *bnum_exp
, int from_tty
)
3794 bnum
= parse_and_eval_long (bnum_exp
);
3796 breakpoint_1 (bnum
, 1);
3800 breakpoint_has_pc (struct breakpoint
*b
,
3801 CORE_ADDR pc
, struct obj_section
*section
)
3803 struct bp_location
*bl
= b
->loc
;
3804 for (; bl
; bl
= bl
->next
)
3806 if (bl
->address
== pc
3807 && (!overlay_debugging
|| bl
->section
== section
))
3813 /* Print a message describing any breakpoints set at PC. */
3816 describe_other_breakpoints (CORE_ADDR pc
, struct obj_section
*section
,
3820 struct breakpoint
*b
;
3823 others
+= breakpoint_has_pc (b
, pc
, section
);
3827 printf_filtered (_("Note: breakpoint "));
3828 else /* if (others == ???) */
3829 printf_filtered (_("Note: breakpoints "));
3831 if (breakpoint_has_pc (b
, pc
, section
))
3834 printf_filtered ("%d", b
->number
);
3835 if (b
->thread
== -1 && thread
!= -1)
3836 printf_filtered (" (all threads)");
3837 else if (b
->thread
!= -1)
3838 printf_filtered (" (thread %d)", b
->thread
);
3839 printf_filtered ("%s%s ",
3840 ((b
->enable_state
== bp_disabled
||
3841 b
->enable_state
== bp_call_disabled
)
3843 : b
->enable_state
== bp_permanent
3847 : ((others
== 1) ? " and" : ""));
3849 printf_filtered (_("also set at pc "));
3850 fputs_filtered (paddress (pc
), gdb_stdout
);
3851 printf_filtered (".\n");
3855 /* Set the default place to put a breakpoint
3856 for the `break' command with no arguments. */
3859 set_default_breakpoint (int valid
, CORE_ADDR addr
, struct symtab
*symtab
,
3862 default_breakpoint_valid
= valid
;
3863 default_breakpoint_address
= addr
;
3864 default_breakpoint_symtab
= symtab
;
3865 default_breakpoint_line
= line
;
3868 /* Return true iff it is meaningful to use the address member of
3869 BPT. For some breakpoint types, the address member is irrelevant
3870 and it makes no sense to attempt to compare it to other addresses
3871 (or use it for any other purpose either).
3873 More specifically, each of the following breakpoint types will always
3874 have a zero valued address and we don't want check_duplicates() to mark
3875 breakpoints of any of these types to be a duplicate of an actual
3876 breakpoint at address zero:
3879 bp_hardware_watchpoint
3881 bp_access_watchpoint
3885 breakpoint_address_is_meaningful (struct breakpoint
*bpt
)
3887 enum bptype type
= bpt
->type
;
3889 return (type
!= bp_watchpoint
3890 && type
!= bp_hardware_watchpoint
3891 && type
!= bp_read_watchpoint
3892 && type
!= bp_access_watchpoint
3893 && type
!= bp_catchpoint
);
3896 /* Rescan breakpoints at the same address and section as BPT,
3897 marking the first one as "first" and any others as "duplicates".
3898 This is so that the bpt instruction is only inserted once.
3899 If we have a permanent breakpoint at the same place as BPT, make
3900 that one the official one, and the rest as duplicates. */
3903 check_duplicates_for (CORE_ADDR address
, struct obj_section
*section
)
3905 struct bp_location
*b
;
3907 struct bp_location
*perm_bp
= 0;
3909 ALL_BP_LOCATIONS (b
)
3910 if (b
->owner
->enable_state
!= bp_disabled
3911 && b
->owner
->enable_state
!= bp_call_disabled
3913 && !b
->shlib_disabled
3914 && b
->address
== address
/* address / overlay match */
3915 && (!overlay_debugging
|| b
->section
== section
)
3916 && breakpoint_address_is_meaningful (b
->owner
))
3918 /* Have we found a permanent breakpoint? */
3919 if (b
->owner
->enable_state
== bp_permanent
)
3926 b
->duplicate
= count
> 1;
3929 /* If we found a permanent breakpoint at this address, go over the
3930 list again and declare all the other breakpoints there to be the
3934 perm_bp
->duplicate
= 0;
3936 /* Permanent breakpoint should always be inserted. */
3937 if (! perm_bp
->inserted
)
3938 internal_error (__FILE__
, __LINE__
,
3939 _("allegedly permanent breakpoint is not "
3940 "actually inserted"));
3942 ALL_BP_LOCATIONS (b
)
3945 if (b
->owner
->enable_state
!= bp_disabled
3946 && b
->owner
->enable_state
!= bp_call_disabled
3947 && b
->enabled
&& !b
->shlib_disabled
3948 && b
->address
== address
/* address / overlay match */
3949 && (!overlay_debugging
|| b
->section
== section
)
3950 && breakpoint_address_is_meaningful (b
->owner
))
3953 internal_error (__FILE__
, __LINE__
,
3954 _("another breakpoint was inserted on top of "
3955 "a permanent breakpoint"));
3964 check_duplicates (struct breakpoint
*bpt
)
3966 struct bp_location
*bl
= bpt
->loc
;
3968 if (! breakpoint_address_is_meaningful (bpt
))
3971 for (; bl
; bl
= bl
->next
)
3972 check_duplicates_for (bl
->address
, bl
->section
);
3976 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
3977 int bnum
, int have_bnum
)
3982 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
3983 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
3985 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
3986 bnum
, astr1
, astr2
);
3988 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
3991 /* Adjust a breakpoint's address to account for architectural constraints
3992 on breakpoint placement. Return the adjusted address. Note: Very
3993 few targets require this kind of adjustment. For most targets,
3994 this function is simply the identity function. */
3997 adjust_breakpoint_address (CORE_ADDR bpaddr
, enum bptype bptype
)
3999 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch
))
4001 /* Very few targets need any kind of breakpoint adjustment. */
4004 else if (bptype
== bp_watchpoint
4005 || bptype
== bp_hardware_watchpoint
4006 || bptype
== bp_read_watchpoint
4007 || bptype
== bp_access_watchpoint
4008 || bptype
== bp_catchpoint
)
4010 /* Watchpoints and the various bp_catch_* eventpoints should not
4011 have their addresses modified. */
4016 CORE_ADDR adjusted_bpaddr
;
4018 /* Some targets have architectural constraints on the placement
4019 of breakpoint instructions. Obtain the adjusted address. */
4020 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (current_gdbarch
,
4023 /* An adjusted breakpoint address can significantly alter
4024 a user's expectations. Print a warning if an adjustment
4026 if (adjusted_bpaddr
!= bpaddr
)
4027 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
4029 return adjusted_bpaddr
;
4033 /* Allocate a struct bp_location. */
4035 static struct bp_location
*
4036 allocate_bp_location (struct breakpoint
*bpt
)
4038 struct bp_location
*loc
, *loc_p
;
4040 loc
= xmalloc (sizeof (struct bp_location
));
4041 memset (loc
, 0, sizeof (*loc
));
4045 loc
->shlib_disabled
= 0;
4054 case bp_longjmp_resume
:
4055 case bp_step_resume
:
4056 case bp_watchpoint_scope
:
4058 case bp_shlib_event
:
4059 case bp_thread_event
:
4060 case bp_overlay_event
:
4061 loc
->loc_type
= bp_loc_software_breakpoint
;
4063 case bp_hardware_breakpoint
:
4064 loc
->loc_type
= bp_loc_hardware_breakpoint
;
4066 case bp_hardware_watchpoint
:
4067 case bp_read_watchpoint
:
4068 case bp_access_watchpoint
:
4069 loc
->loc_type
= bp_loc_hardware_watchpoint
;
4073 loc
->loc_type
= bp_loc_other
;
4076 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
4082 static void free_bp_location (struct bp_location
*loc
)
4087 if (loc
->function_name
)
4088 xfree (loc
->function_name
);
4093 /* Helper to set_raw_breakpoint below. Creates a breakpoint
4094 that has type BPTYPE and has no locations as yet. */
4096 static struct breakpoint
*
4097 set_raw_breakpoint_without_location (enum bptype bptype
)
4099 struct breakpoint
*b
, *b1
;
4101 b
= (struct breakpoint
*) xmalloc (sizeof (struct breakpoint
));
4102 memset (b
, 0, sizeof (*b
));
4105 b
->language
= current_language
->la_language
;
4106 b
->input_radix
= input_radix
;
4108 b
->enable_state
= bp_enabled
;
4111 b
->ignore_count
= 0;
4113 b
->frame_id
= null_frame_id
;
4114 b
->forked_inferior_pid
= null_ptid
;
4115 b
->exec_pathname
= NULL
;
4117 b
->condition_not_parsed
= 0;
4119 /* Add this breakpoint to the end of the chain
4120 so that a list of breakpoints will come out in order
4121 of increasing numbers. */
4123 b1
= breakpoint_chain
;
4125 breakpoint_chain
= b
;
4135 /* Initialize loc->function_name. */
4137 set_breakpoint_location_function (struct bp_location
*loc
)
4139 if (loc
->owner
->type
== bp_breakpoint
4140 || loc
->owner
->type
== bp_hardware_breakpoint
)
4142 find_pc_partial_function (loc
->address
, &(loc
->function_name
),
4144 if (loc
->function_name
)
4145 loc
->function_name
= xstrdup (loc
->function_name
);
4149 /* set_raw_breakpoint is a low level routine for allocating and
4150 partially initializing a breakpoint of type BPTYPE. The newly
4151 created breakpoint's address, section, source file name, and line
4152 number are provided by SAL. The newly created and partially
4153 initialized breakpoint is added to the breakpoint chain and
4154 is also returned as the value of this function.
4156 It is expected that the caller will complete the initialization of
4157 the newly created breakpoint struct as well as output any status
4158 information regarding the creation of a new breakpoint. In
4159 particular, set_raw_breakpoint does NOT set the breakpoint
4160 number! Care should be taken to not allow an error to occur
4161 prior to completing the initialization of the breakpoint. If this
4162 should happen, a bogus breakpoint will be left on the chain. */
4165 set_raw_breakpoint (struct symtab_and_line sal
, enum bptype bptype
)
4167 struct breakpoint
*b
= set_raw_breakpoint_without_location (bptype
);
4168 CORE_ADDR adjusted_address
;
4170 /* Adjust the breakpoint's address prior to allocating a location.
4171 Once we call allocate_bp_location(), that mostly uninitialized
4172 location will be placed on the location chain. Adjustment of the
4173 breakpoint may cause target_read_memory() to be called and we do
4174 not want its scan of the location chain to find a breakpoint and
4175 location that's only been partially initialized. */
4176 adjusted_address
= adjust_breakpoint_address (sal
.pc
, b
->type
);
4178 b
->loc
= allocate_bp_location (b
);
4179 b
->loc
->requested_address
= sal
.pc
;
4180 b
->loc
->address
= adjusted_address
;
4182 if (sal
.symtab
== NULL
)
4183 b
->source_file
= NULL
;
4185 b
->source_file
= savestring (sal
.symtab
->filename
,
4186 strlen (sal
.symtab
->filename
));
4187 b
->loc
->section
= sal
.section
;
4188 b
->line_number
= sal
.line
;
4190 set_breakpoint_location_function (b
->loc
);
4192 breakpoints_changed ();
4198 /* Note that the breakpoint object B describes a permanent breakpoint
4199 instruction, hard-wired into the inferior's code. */
4201 make_breakpoint_permanent (struct breakpoint
*b
)
4203 struct bp_location
*bl
;
4204 b
->enable_state
= bp_permanent
;
4206 /* By definition, permanent breakpoints are already present in the code.
4207 Mark all locations as inserted. For now, make_breakpoint_permanent
4208 is called in just one place, so it's hard to say if it's reasonable
4209 to have permanent breakpoint with multiple locations or not,
4210 but it's easy to implmement. */
4211 for (bl
= b
->loc
; bl
; bl
= bl
->next
)
4215 static struct breakpoint
*
4216 create_internal_breakpoint (CORE_ADDR address
, enum bptype type
)
4218 static int internal_breakpoint_number
= -1;
4219 struct symtab_and_line sal
;
4220 struct breakpoint
*b
;
4222 init_sal (&sal
); /* initialize to zeroes */
4225 sal
.section
= find_pc_overlay (sal
.pc
);
4227 b
= set_raw_breakpoint (sal
, type
);
4228 b
->number
= internal_breakpoint_number
--;
4229 b
->disposition
= disp_donttouch
;
4236 create_longjmp_breakpoint (char *func_name
)
4238 struct minimal_symbol
*m
;
4240 if ((m
= lookup_minimal_symbol_text (func_name
, NULL
)) == NULL
)
4242 set_momentary_breakpoint_at_pc (SYMBOL_VALUE_ADDRESS (m
), bp_longjmp
);
4243 update_global_location_list (1);
4246 /* Call this routine when stepping and nexting to enable a breakpoint
4247 if we do a longjmp(). When we hit that breakpoint, call
4248 set_longjmp_resume_breakpoint() to figure out where we are going. */
4251 set_longjmp_breakpoint (void)
4253 if (gdbarch_get_longjmp_target_p (current_gdbarch
))
4255 create_longjmp_breakpoint ("longjmp");
4256 create_longjmp_breakpoint ("_longjmp");
4257 create_longjmp_breakpoint ("siglongjmp");
4258 create_longjmp_breakpoint ("_siglongjmp");
4262 /* Delete all longjmp breakpoints from THREAD. */
4264 delete_longjmp_breakpoint (int thread
)
4266 struct breakpoint
*b
, *temp
;
4268 ALL_BREAKPOINTS_SAFE (b
, temp
)
4269 if (b
->type
== bp_longjmp
)
4271 if (b
->thread
== thread
)
4272 delete_breakpoint (b
);
4277 create_overlay_event_breakpoint_1 (char *func_name
, struct objfile
*objfile
)
4279 struct breakpoint
*b
;
4280 struct minimal_symbol
*m
;
4282 if ((m
= lookup_minimal_symbol_text (func_name
, objfile
)) == NULL
)
4285 b
= create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m
),
4287 b
->addr_string
= xstrdup (func_name
);
4289 if (overlay_debugging
== ovly_auto
)
4291 b
->enable_state
= bp_enabled
;
4292 overlay_events_enabled
= 1;
4296 b
->enable_state
= bp_disabled
;
4297 overlay_events_enabled
= 0;
4299 update_global_location_list (1);
4303 create_overlay_event_breakpoint (char *func_name
)
4305 struct objfile
*objfile
;
4306 ALL_OBJFILES (objfile
)
4307 create_overlay_event_breakpoint_1 (func_name
, objfile
);
4311 enable_overlay_breakpoints (void)
4313 struct breakpoint
*b
;
4316 if (b
->type
== bp_overlay_event
)
4318 b
->enable_state
= bp_enabled
;
4319 update_global_location_list (1);
4320 overlay_events_enabled
= 1;
4325 disable_overlay_breakpoints (void)
4327 struct breakpoint
*b
;
4330 if (b
->type
== bp_overlay_event
)
4332 b
->enable_state
= bp_disabled
;
4333 update_global_location_list (0);
4334 overlay_events_enabled
= 0;
4339 create_thread_event_breakpoint (CORE_ADDR address
)
4341 struct breakpoint
*b
;
4343 b
= create_internal_breakpoint (address
, bp_thread_event
);
4345 b
->enable_state
= bp_enabled
;
4346 /* addr_string has to be used or breakpoint_re_set will delete me. */
4347 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
4349 update_global_location_list_nothrow (1);
4355 remove_thread_event_breakpoints (void)
4357 struct breakpoint
*b
, *temp
;
4359 ALL_BREAKPOINTS_SAFE (b
, temp
)
4360 if (b
->type
== bp_thread_event
)
4361 delete_breakpoint (b
);
4364 struct captured_parse_breakpoint_args
4367 struct symtabs_and_lines
*sals_p
;
4368 char ***addr_string_p
;
4372 struct lang_and_radix
4380 remove_solib_event_breakpoints (void)
4382 struct breakpoint
*b
, *temp
;
4384 ALL_BREAKPOINTS_SAFE (b
, temp
)
4385 if (b
->type
== bp_shlib_event
)
4386 delete_breakpoint (b
);
4390 create_solib_event_breakpoint (CORE_ADDR address
)
4392 struct breakpoint
*b
;
4394 b
= create_internal_breakpoint (address
, bp_shlib_event
);
4395 update_global_location_list_nothrow (1);
4399 /* Disable any breakpoints that are on code in shared libraries. Only
4400 apply to enabled breakpoints, disabled ones can just stay disabled. */
4403 disable_breakpoints_in_shlibs (void)
4405 struct bp_location
*loc
;
4406 int disabled_shlib_breaks
= 0;
4408 ALL_BP_LOCATIONS (loc
)
4410 struct breakpoint
*b
= loc
->owner
;
4411 /* We apply the check to all breakpoints, including disabled
4412 for those with loc->duplicate set. This is so that when breakpoint
4413 becomes enabled, or the duplicate is removed, gdb will try to insert
4414 all breakpoints. If we don't set shlib_disabled here, we'll try
4415 to insert those breakpoints and fail. */
4416 if (((b
->type
== bp_breakpoint
) || (b
->type
== bp_hardware_breakpoint
))
4417 && !loc
->shlib_disabled
4419 && PC_SOLIB (loc
->address
)
4421 && solib_address (loc
->address
)
4425 loc
->shlib_disabled
= 1;
4430 /* Disable any breakpoints that are in in an unloaded shared library. Only
4431 apply to enabled breakpoints, disabled ones can just stay disabled. */
4434 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
4436 struct bp_location
*loc
;
4437 int disabled_shlib_breaks
= 0;
4439 ALL_BP_LOCATIONS (loc
)
4441 struct breakpoint
*b
= loc
->owner
;
4442 if ((loc
->loc_type
== bp_loc_hardware_breakpoint
4443 || loc
->loc_type
== bp_loc_software_breakpoint
)
4444 && !loc
->shlib_disabled
)
4447 char *so_name
= PC_SOLIB (loc
->address
);
4449 char *so_name
= solib_address (loc
->address
);
4451 if (so_name
&& !strcmp (so_name
, solib
->so_name
))
4453 loc
->shlib_disabled
= 1;
4454 /* At this point, we cannot rely on remove_breakpoint
4455 succeeding so we must mark the breakpoint as not inserted
4456 to prevent future errors occurring in remove_breakpoints. */
4458 if (!disabled_shlib_breaks
)
4460 target_terminal_ours_for_output ();
4461 warning (_("Temporarily disabling breakpoints for unloaded shared library \"%s\""),
4464 disabled_shlib_breaks
= 1;
4470 /* FORK & VFORK catchpoints. */
4472 /* Implement the "insert" breakpoint_ops method for fork catchpoints. */
4475 insert_catch_fork (struct breakpoint
*b
)
4477 target_insert_fork_catchpoint (PIDGET (inferior_ptid
));
4480 /* Implement the "remove" breakpoint_ops method for fork catchpoints. */
4483 remove_catch_fork (struct breakpoint
*b
)
4485 return target_remove_fork_catchpoint (PIDGET (inferior_ptid
));
4488 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
4492 breakpoint_hit_catch_fork (struct breakpoint
*b
)
4494 return inferior_has_forked (inferior_ptid
, &b
->forked_inferior_pid
);
4497 /* Implement the "print_it" breakpoint_ops method for fork catchpoints. */
4499 static enum print_stop_action
4500 print_it_catch_fork (struct breakpoint
*b
)
4502 annotate_catchpoint (b
->number
);
4503 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
4504 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4505 return PRINT_SRC_AND_LOC
;
4508 /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
4511 print_one_catch_fork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4513 struct value_print_options opts
;
4515 get_user_print_options (&opts
);
4517 /* Field 4, the address, is omitted (which makes the columns
4518 not line up too nicely with the headers, but the effect
4519 is relatively readable). */
4520 if (opts
.addressprint
)
4521 ui_out_field_skip (uiout
, "addr");
4523 ui_out_text (uiout
, "fork");
4524 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4526 ui_out_text (uiout
, ", process ");
4527 ui_out_field_int (uiout
, "what",
4528 ptid_get_pid (b
->forked_inferior_pid
));
4529 ui_out_spaces (uiout
, 1);
4533 /* Implement the "print_mention" breakpoint_ops method for fork
4537 print_mention_catch_fork (struct breakpoint
*b
)
4539 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
4542 /* The breakpoint_ops structure to be used in fork catchpoints. */
4544 static struct breakpoint_ops catch_fork_breakpoint_ops
=
4548 breakpoint_hit_catch_fork
,
4549 print_it_catch_fork
,
4550 print_one_catch_fork
,
4551 print_mention_catch_fork
4554 /* Implement the "insert" breakpoint_ops method for vfork catchpoints. */
4557 insert_catch_vfork (struct breakpoint
*b
)
4559 target_insert_vfork_catchpoint (PIDGET (inferior_ptid
));
4562 /* Implement the "remove" breakpoint_ops method for vfork catchpoints. */
4565 remove_catch_vfork (struct breakpoint
*b
)
4567 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid
));
4570 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
4574 breakpoint_hit_catch_vfork (struct breakpoint
*b
)
4576 return inferior_has_vforked (inferior_ptid
, &b
->forked_inferior_pid
);
4579 /* Implement the "print_it" breakpoint_ops method for vfork catchpoints. */
4581 static enum print_stop_action
4582 print_it_catch_vfork (struct breakpoint
*b
)
4584 annotate_catchpoint (b
->number
);
4585 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
4586 b
->number
, ptid_get_pid (b
->forked_inferior_pid
));
4587 return PRINT_SRC_AND_LOC
;
4590 /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
4593 print_one_catch_vfork (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4595 struct value_print_options opts
;
4597 get_user_print_options (&opts
);
4598 /* Field 4, the address, is omitted (which makes the columns
4599 not line up too nicely with the headers, but the effect
4600 is relatively readable). */
4601 if (opts
.addressprint
)
4602 ui_out_field_skip (uiout
, "addr");
4604 ui_out_text (uiout
, "vfork");
4605 if (!ptid_equal (b
->forked_inferior_pid
, null_ptid
))
4607 ui_out_text (uiout
, ", process ");
4608 ui_out_field_int (uiout
, "what",
4609 ptid_get_pid (b
->forked_inferior_pid
));
4610 ui_out_spaces (uiout
, 1);
4614 /* Implement the "print_mention" breakpoint_ops method for vfork
4618 print_mention_catch_vfork (struct breakpoint
*b
)
4620 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
4623 /* The breakpoint_ops structure to be used in vfork catchpoints. */
4625 static struct breakpoint_ops catch_vfork_breakpoint_ops
=
4629 breakpoint_hit_catch_vfork
,
4630 print_it_catch_vfork
,
4631 print_one_catch_vfork
,
4632 print_mention_catch_vfork
4635 /* Create a new breakpoint of the bp_catchpoint kind and return it.
4637 If TEMPFLAG is non-zero, then make the breakpoint temporary.
4638 If COND_STRING is not NULL, then store it in the breakpoint.
4639 OPS, if not NULL, is the breakpoint_ops structure associated
4640 to the catchpoint. */
4642 static struct breakpoint
*
4643 create_catchpoint (int tempflag
, char *cond_string
,
4644 struct breakpoint_ops
*ops
)
4646 struct symtab_and_line sal
;
4647 struct breakpoint
*b
;
4654 b
= set_raw_breakpoint (sal
, bp_catchpoint
);
4655 set_breakpoint_count (breakpoint_count
+ 1);
4656 b
->number
= breakpoint_count
;
4658 b
->cond_string
= (cond_string
== NULL
) ?
4659 NULL
: savestring (cond_string
, strlen (cond_string
));
4661 b
->addr_string
= NULL
;
4662 b
->enable_state
= bp_enabled
;
4663 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
4667 update_global_location_list (1);
4673 create_fork_vfork_event_catchpoint (int tempflag
, char *cond_string
,
4674 struct breakpoint_ops
*ops
)
4676 struct breakpoint
*b
= create_catchpoint (tempflag
, cond_string
, ops
);
4678 /* FIXME: We should put this information in a breakpoint private data
4680 b
->forked_inferior_pid
= null_ptid
;
4683 /* Exec catchpoints. */
4686 insert_catch_exec (struct breakpoint
*b
)
4688 target_insert_exec_catchpoint (PIDGET (inferior_ptid
));
4692 remove_catch_exec (struct breakpoint
*b
)
4694 return target_remove_exec_catchpoint (PIDGET (inferior_ptid
));
4698 breakpoint_hit_catch_exec (struct breakpoint
*b
)
4700 return inferior_has_execd (inferior_ptid
, &b
->exec_pathname
);
4703 static enum print_stop_action
4704 print_it_catch_exec (struct breakpoint
*b
)
4706 annotate_catchpoint (b
->number
);
4707 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b
->number
,
4709 return PRINT_SRC_AND_LOC
;
4713 print_one_catch_exec (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
4715 struct value_print_options opts
;
4717 get_user_print_options (&opts
);
4719 /* Field 4, the address, is omitted (which makes the columns
4720 not line up too nicely with the headers, but the effect
4721 is relatively readable). */
4722 if (opts
.addressprint
)
4723 ui_out_field_skip (uiout
, "addr");
4725 ui_out_text (uiout
, "exec");
4726 if (b
->exec_pathname
!= NULL
)
4728 ui_out_text (uiout
, ", program \"");
4729 ui_out_field_string (uiout
, "what", b
->exec_pathname
);
4730 ui_out_text (uiout
, "\" ");
4735 print_mention_catch_exec (struct breakpoint
*b
)
4737 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
4740 static struct breakpoint_ops catch_exec_breakpoint_ops
=
4744 breakpoint_hit_catch_exec
,
4745 print_it_catch_exec
,
4746 print_one_catch_exec
,
4747 print_mention_catch_exec
4751 hw_breakpoint_used_count (void)
4753 struct breakpoint
*b
;
4758 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
4766 hw_watchpoint_used_count (enum bptype type
, int *other_type_used
)
4768 struct breakpoint
*b
;
4771 *other_type_used
= 0;
4774 if (breakpoint_enabled (b
))
4776 if (b
->type
== type
)
4778 else if ((b
->type
== bp_hardware_watchpoint
||
4779 b
->type
== bp_read_watchpoint
||
4780 b
->type
== bp_access_watchpoint
))
4781 *other_type_used
= 1;
4788 disable_watchpoints_before_interactive_call_start (void)
4790 struct breakpoint
*b
;
4794 if (((b
->type
== bp_watchpoint
)
4795 || (b
->type
== bp_hardware_watchpoint
)
4796 || (b
->type
== bp_read_watchpoint
)
4797 || (b
->type
== bp_access_watchpoint
))
4798 && breakpoint_enabled (b
))
4800 b
->enable_state
= bp_call_disabled
;
4801 update_global_location_list (0);
4807 enable_watchpoints_after_interactive_call_stop (void)
4809 struct breakpoint
*b
;
4813 if (((b
->type
== bp_watchpoint
)
4814 || (b
->type
== bp_hardware_watchpoint
)
4815 || (b
->type
== bp_read_watchpoint
)
4816 || (b
->type
== bp_access_watchpoint
))
4817 && (b
->enable_state
== bp_call_disabled
))
4819 b
->enable_state
= bp_enabled
;
4820 update_global_location_list (1);
4826 /* Set a breakpoint that will evaporate an end of command
4827 at address specified by SAL.
4828 Restrict it to frame FRAME if FRAME is nonzero. */
4831 set_momentary_breakpoint (struct symtab_and_line sal
, struct frame_id frame_id
,
4834 struct breakpoint
*b
;
4835 b
= set_raw_breakpoint (sal
, type
);
4836 b
->enable_state
= bp_enabled
;
4837 b
->disposition
= disp_donttouch
;
4838 b
->frame_id
= frame_id
;
4840 /* If we're debugging a multi-threaded program, then we
4841 want momentary breakpoints to be active in only a
4842 single thread of control. */
4843 if (in_thread_list (inferior_ptid
))
4844 b
->thread
= pid_to_thread_id (inferior_ptid
);
4846 update_global_location_list_nothrow (1);
4852 set_momentary_breakpoint_at_pc (CORE_ADDR pc
, enum bptype type
)
4854 struct symtab_and_line sal
;
4856 sal
= find_pc_line (pc
, 0);
4858 sal
.section
= find_pc_overlay (pc
);
4859 sal
.explicit_pc
= 1;
4861 return set_momentary_breakpoint (sal
, null_frame_id
, type
);
4865 /* Tell the user we have just set a breakpoint B. */
4868 mention (struct breakpoint
*b
)
4871 struct cleanup
*old_chain
, *ui_out_chain
;
4872 struct ui_stream
*stb
;
4873 struct value_print_options opts
;
4875 get_user_print_options (&opts
);
4877 stb
= ui_out_stream_new (uiout
);
4878 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4880 /* FIXME: This is misplaced; mention() is called by things (like
4881 hitting a watchpoint) other than breakpoint creation. It should
4882 be possible to clean this up and at the same time replace the
4883 random calls to breakpoint_changed with this hook. */
4884 observer_notify_breakpoint_created (b
->number
);
4886 if (b
->ops
!= NULL
&& b
->ops
->print_mention
!= NULL
)
4887 b
->ops
->print_mention (b
);
4892 printf_filtered (_("(apparently deleted?) Eventpoint %d: "), b
->number
);
4895 ui_out_text (uiout
, "Watchpoint ");
4896 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4897 ui_out_field_int (uiout
, "number", b
->number
);
4898 ui_out_text (uiout
, ": ");
4899 print_expression (b
->exp
, stb
->stream
);
4900 ui_out_field_stream (uiout
, "exp", stb
);
4901 do_cleanups (ui_out_chain
);
4903 case bp_hardware_watchpoint
:
4904 ui_out_text (uiout
, "Hardware watchpoint ");
4905 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "wpt");
4906 ui_out_field_int (uiout
, "number", b
->number
);
4907 ui_out_text (uiout
, ": ");
4908 print_expression (b
->exp
, stb
->stream
);
4909 ui_out_field_stream (uiout
, "exp", stb
);
4910 do_cleanups (ui_out_chain
);
4912 case bp_read_watchpoint
:
4913 ui_out_text (uiout
, "Hardware read watchpoint ");
4914 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-rwpt");
4915 ui_out_field_int (uiout
, "number", b
->number
);
4916 ui_out_text (uiout
, ": ");
4917 print_expression (b
->exp
, stb
->stream
);
4918 ui_out_field_stream (uiout
, "exp", stb
);
4919 do_cleanups (ui_out_chain
);
4921 case bp_access_watchpoint
:
4922 ui_out_text (uiout
, "Hardware access (read/write) watchpoint ");
4923 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "hw-awpt");
4924 ui_out_field_int (uiout
, "number", b
->number
);
4925 ui_out_text (uiout
, ": ");
4926 print_expression (b
->exp
, stb
->stream
);
4927 ui_out_field_stream (uiout
, "exp", stb
);
4928 do_cleanups (ui_out_chain
);
4931 if (ui_out_is_mi_like_p (uiout
))
4936 if (b
->disposition
== disp_del
)
4937 printf_filtered (_("Temporary breakpoint"));
4939 printf_filtered (_("Breakpoint"));
4940 printf_filtered (_(" %d"), b
->number
);
4943 case bp_hardware_breakpoint
:
4944 if (ui_out_is_mi_like_p (uiout
))
4949 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
4956 case bp_longjmp_resume
:
4957 case bp_step_resume
:
4959 case bp_watchpoint_scope
:
4960 case bp_shlib_event
:
4961 case bp_thread_event
:
4962 case bp_overlay_event
:
4968 /* i18n: cagney/2005-02-11: Below needs to be merged into a
4972 printf_filtered (_(" (%s) pending."), b
->addr_string
);
4976 if (opts
.addressprint
|| b
->source_file
== NULL
)
4978 printf_filtered (" at ");
4979 fputs_filtered (paddress (b
->loc
->address
), gdb_stdout
);
4982 printf_filtered (": file %s, line %d.",
4983 b
->source_file
, b
->line_number
);
4987 struct bp_location
*loc
= b
->loc
;
4989 for (; loc
; loc
= loc
->next
)
4991 printf_filtered (" (%d locations)", n
);
4996 do_cleanups (old_chain
);
4997 if (ui_out_is_mi_like_p (uiout
))
4999 printf_filtered ("\n");
5003 static struct bp_location
*
5004 add_location_to_breakpoint (struct breakpoint
*b
,
5005 const struct symtab_and_line
*sal
)
5007 struct bp_location
*loc
, **tmp
;
5009 loc
= allocate_bp_location (b
);
5010 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
5013 loc
->requested_address
= sal
->pc
;
5014 loc
->address
= adjust_breakpoint_address (loc
->requested_address
, b
->type
);
5015 loc
->section
= sal
->section
;
5017 set_breakpoint_location_function (loc
);
5022 /* Return 1 if LOC is pointing to a permanent breakpoint,
5023 return 0 otherwise. */
5026 bp_loc_is_permanent (struct bp_location
*loc
)
5030 const gdb_byte
*brk
;
5031 gdb_byte
*target_mem
;
5032 struct cleanup
*cleanup
;
5035 gdb_assert (loc
!= NULL
);
5037 addr
= loc
->address
;
5038 brk
= gdbarch_breakpoint_from_pc (current_gdbarch
, &addr
, &len
);
5040 /* Software breakpoints unsupported? */
5044 target_mem
= alloca (len
);
5046 /* Enable the automatic memory restoration from breakpoints while
5047 we read the memory. Otherwise we could say about our temporary
5048 breakpoints they are permanent. */
5049 cleanup
= make_show_memory_breakpoints_cleanup (0);
5051 if (target_read_memory (loc
->address
, target_mem
, len
) == 0
5052 && memcmp (target_mem
, brk
, len
) == 0)
5055 do_cleanups (cleanup
);
5062 /* Create a breakpoint with SAL as location. Use ADDR_STRING
5063 as textual description of the location, and COND_STRING
5064 as condition expression. */
5067 create_breakpoint (struct symtabs_and_lines sals
, char *addr_string
,
5069 enum bptype type
, enum bpdisp disposition
,
5070 int thread
, int ignore_count
,
5071 struct breakpoint_ops
*ops
, int from_tty
)
5073 struct breakpoint
*b
= NULL
;
5076 if (type
== bp_hardware_breakpoint
)
5078 int i
= hw_breakpoint_used_count ();
5079 int target_resources_ok
=
5080 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
5082 if (target_resources_ok
== 0)
5083 error (_("No hardware breakpoint support in the target."));
5084 else if (target_resources_ok
< 0)
5085 error (_("Hardware breakpoints used exceeds limit."));
5088 for (i
= 0; i
< sals
.nelts
; ++i
)
5090 struct symtab_and_line sal
= sals
.sals
[i
];
5091 struct bp_location
*loc
;
5094 describe_other_breakpoints (sal
.pc
, sal
.section
, thread
);
5098 b
= set_raw_breakpoint (sal
, type
);
5099 set_breakpoint_count (breakpoint_count
+ 1);
5100 b
->number
= breakpoint_count
;
5103 b
->cond_string
= cond_string
;
5104 b
->ignore_count
= ignore_count
;
5105 b
->enable_state
= bp_enabled
;
5106 b
->disposition
= disposition
;
5112 loc
= add_location_to_breakpoint (b
, &sal
);
5115 if (bp_loc_is_permanent (loc
))
5116 make_breakpoint_permanent (b
);
5120 char *arg
= b
->cond_string
;
5121 loc
->cond
= parse_exp_1 (&arg
, block_for_pc (loc
->address
), 0);
5123 error (_("Garbage %s follows condition"), arg
);
5128 b
->addr_string
= addr_string
;
5130 /* addr_string has to be used or breakpoint_re_set will delete
5132 b
->addr_string
= xstrprintf ("*0x%s", paddr (b
->loc
->address
));
5138 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
5139 elements to fill the void space. */
5140 static void remove_sal (struct symtabs_and_lines
*sal
, int index_to_remove
)
5142 int i
= index_to_remove
+1;
5143 int last_index
= sal
->nelts
-1;
5145 for (;i
<= last_index
; ++i
)
5146 sal
->sals
[i
-1] = sal
->sals
[i
];
5151 /* If appropriate, obtains all sals that correspond
5152 to the same file and line as SAL. This is done
5153 only if SAL does not have explicit PC and has
5154 line and file information. If we got just a single
5155 expanded sal, return the original.
5157 Otherwise, if SAL.explicit_line is not set, filter out
5158 all sals for which the name of enclosing function
5159 is different from SAL. This makes sure that if we have
5160 breakpoint originally set in template instantiation, say
5161 foo<int>(), we won't expand SAL to locations at the same
5162 line in all existing instantiations of 'foo'.
5165 struct symtabs_and_lines
5166 expand_line_sal_maybe (struct symtab_and_line sal
)
5168 struct symtabs_and_lines expanded
;
5169 CORE_ADDR original_pc
= sal
.pc
;
5170 char *original_function
= NULL
;
5174 /* If we have explicit pc, don't expand.
5175 If we have no line number, we can't expand. */
5176 if (sal
.explicit_pc
|| sal
.line
== 0 || sal
.symtab
== NULL
)
5179 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5180 expanded
.sals
[0] = sal
;
5185 find_pc_partial_function (original_pc
, &original_function
, NULL
, NULL
);
5187 expanded
= expand_line_sal (sal
);
5188 if (expanded
.nelts
== 1)
5190 /* We had one sal, we got one sal. Without futher
5191 processing, just return the original sal. */
5192 xfree (expanded
.sals
);
5194 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5195 sal
.pc
= original_pc
;
5196 expanded
.sals
[0] = sal
;
5200 if (!sal
.explicit_line
)
5202 CORE_ADDR func_addr
, func_end
;
5203 for (i
= 0; i
< expanded
.nelts
; ++i
)
5205 CORE_ADDR pc
= expanded
.sals
[i
].pc
;
5206 char *this_function
;
5207 if (find_pc_partial_function (pc
, &this_function
,
5208 &func_addr
, &func_end
))
5210 if (this_function
&&
5211 strcmp (this_function
, original_function
) != 0)
5213 remove_sal (&expanded
, i
);
5216 else if (func_addr
== pc
)
5218 /* We're at beginning of a function, and should
5220 struct symbol
*sym
= find_pc_function (pc
);
5222 expanded
.sals
[i
] = find_function_start_sal (sym
, 1);
5225 = gdbarch_skip_prologue (current_gdbarch
, pc
);
5232 if (expanded
.nelts
<= 1)
5234 /* This is un ugly workaround. If we get zero
5235 expanded sals then something is really wrong.
5236 Fix that by returnign the original sal. */
5237 xfree (expanded
.sals
);
5239 expanded
.sals
= xmalloc (sizeof (struct symtab_and_line
));
5240 sal
.pc
= original_pc
;
5241 expanded
.sals
[0] = sal
;
5248 for (i
= 0; i
< expanded
.nelts
; ++i
)
5249 if (expanded
.sals
[i
].pc
== original_pc
)
5260 /* Add SALS.nelts breakpoints to the breakpoint table. For each
5261 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
5262 value. COND_STRING, if not NULL, specified the condition to be
5263 used for all breakpoints. Essentially the only case where
5264 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
5265 function. In that case, it's still not possible to specify
5266 separate conditions for different overloaded functions, so
5267 we take just a single condition string.
5269 NOTE: If the function succeeds, the caller is expected to cleanup
5270 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
5271 array contents). If the function fails (error() is called), the
5272 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
5273 COND and SALS arrays and each of those arrays contents. */
5276 create_breakpoints (struct symtabs_and_lines sals
, char **addr_string
,
5278 enum bptype type
, enum bpdisp disposition
,
5279 int thread
, int ignore_count
,
5280 struct breakpoint_ops
*ops
, int from_tty
)
5283 for (i
= 0; i
< sals
.nelts
; ++i
)
5285 struct symtabs_and_lines expanded
=
5286 expand_line_sal_maybe (sals
.sals
[i
]);
5288 create_breakpoint (expanded
, addr_string
[i
],
5289 cond_string
, type
, disposition
,
5290 thread
, ignore_count
, ops
, from_tty
);
5293 update_global_location_list (1);
5296 /* Parse ARG which is assumed to be a SAL specification possibly
5297 followed by conditionals. On return, SALS contains an array of SAL
5298 addresses found. ADDR_STRING contains a vector of (canonical)
5299 address strings. ARG points to the end of the SAL. */
5302 parse_breakpoint_sals (char **address
,
5303 struct symtabs_and_lines
*sals
,
5304 char ***addr_string
,
5307 char *addr_start
= *address
;
5308 *addr_string
= NULL
;
5309 /* If no arg given, or if first arg is 'if ', use the default
5311 if ((*address
) == NULL
5312 || (strncmp ((*address
), "if", 2) == 0 && isspace ((*address
)[2])))
5314 if (default_breakpoint_valid
)
5316 struct symtab_and_line sal
;
5317 init_sal (&sal
); /* initialize to zeroes */
5318 sals
->sals
= (struct symtab_and_line
*)
5319 xmalloc (sizeof (struct symtab_and_line
));
5320 sal
.pc
= default_breakpoint_address
;
5321 sal
.line
= default_breakpoint_line
;
5322 sal
.symtab
= default_breakpoint_symtab
;
5323 sal
.section
= find_pc_overlay (sal
.pc
);
5324 sals
->sals
[0] = sal
;
5328 error (_("No default breakpoint address now."));
5332 /* Force almost all breakpoints to be in terms of the
5333 current_source_symtab (which is decode_line_1's default). This
5334 should produce the results we want almost all of the time while
5335 leaving default_breakpoint_* alone.
5336 ObjC: However, don't match an Objective-C method name which
5337 may have a '+' or '-' succeeded by a '[' */
5339 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
5341 if (default_breakpoint_valid
5343 || ((strchr ("+-", (*address
)[0]) != NULL
)
5344 && ((*address
)[1] != '['))))
5345 *sals
= decode_line_1 (address
, 1, default_breakpoint_symtab
,
5346 default_breakpoint_line
, addr_string
,
5349 *sals
= decode_line_1 (address
, 1, (struct symtab
*) NULL
, 0,
5350 addr_string
, not_found_ptr
);
5352 /* For any SAL that didn't have a canonical string, fill one in. */
5353 if (sals
->nelts
> 0 && *addr_string
== NULL
)
5354 *addr_string
= xcalloc (sals
->nelts
, sizeof (char **));
5355 if (addr_start
!= (*address
))
5358 for (i
= 0; i
< sals
->nelts
; i
++)
5360 /* Add the string if not present. */
5361 if ((*addr_string
)[i
] == NULL
)
5362 (*addr_string
)[i
] = savestring (addr_start
, (*address
) - addr_start
);
5368 /* Convert each SAL into a real PC. Verify that the PC can be
5369 inserted as a breakpoint. If it can't throw an error. */
5372 breakpoint_sals_to_pc (struct symtabs_and_lines
*sals
,
5376 for (i
= 0; i
< sals
->nelts
; i
++)
5377 resolve_sal_pc (&sals
->sals
[i
]);
5381 do_captured_parse_breakpoint (struct ui_out
*ui
, void *data
)
5383 struct captured_parse_breakpoint_args
*args
= data
;
5385 parse_breakpoint_sals (args
->arg_p
, args
->sals_p
, args
->addr_string_p
,
5386 args
->not_found_ptr
);
5389 /* Given TOK, a string specification of condition and thread, as
5390 accepted by the 'break' command, extract the condition
5391 string and thread number and set *COND_STRING and *THREAD.
5392 PC identifies the context at which the condition should be parsed.
5393 If no condition is found, *COND_STRING is set to NULL.
5394 If no thread is found, *THREAD is set to -1. */
5396 find_condition_and_thread (char *tok
, CORE_ADDR pc
,
5397 char **cond_string
, int *thread
)
5399 *cond_string
= NULL
;
5405 char *cond_start
= NULL
;
5406 char *cond_end
= NULL
;
5407 while (*tok
== ' ' || *tok
== '\t')
5412 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5415 toklen
= end_tok
- tok
;
5417 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5419 tok
= cond_start
= end_tok
+ 1;
5420 parse_exp_1 (&tok
, block_for_pc (pc
), 0);
5422 *cond_string
= savestring (cond_start
,
5423 cond_end
- cond_start
);
5425 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5431 *thread
= strtol (tok
, &tok
, 0);
5433 error (_("Junk after thread keyword."));
5434 if (!valid_thread_id (*thread
))
5435 error (_("Unknown thread %d."), *thread
);
5438 error (_("Junk at end of arguments."));
5442 /* Set a breakpoint. This function is shared between
5443 CLI and MI functions for setting a breakpoint.
5444 This function has two major modes of operations,
5445 selected by the PARSE_CONDITION_AND_THREAD parameter.
5446 If non-zero, the function will parse arg, extracting
5447 breakpoint location, address and thread. Otherwise,
5448 ARG is just the location of breakpoint, with condition
5449 and thread specified by the COND_STRING and THREAD
5453 break_command_really (char *arg
, char *cond_string
, int thread
,
5454 int parse_condition_and_thread
,
5455 int tempflag
, int hardwareflag
,
5457 enum auto_boolean pending_break_support
,
5458 struct breakpoint_ops
*ops
,
5461 struct gdb_exception e
;
5462 struct symtabs_and_lines sals
;
5463 struct symtab_and_line pending_sal
;
5466 char *addr_start
= arg
;
5468 struct cleanup
*old_chain
;
5469 struct cleanup
*breakpoint_chain
= NULL
;
5470 struct captured_parse_breakpoint_args parse_args
;
5479 parse_args
.arg_p
= &arg
;
5480 parse_args
.sals_p
= &sals
;
5481 parse_args
.addr_string_p
= &addr_string
;
5482 parse_args
.not_found_ptr
= ¬_found
;
5484 e
= catch_exception (uiout
, do_captured_parse_breakpoint
,
5485 &parse_args
, RETURN_MASK_ALL
);
5487 /* If caller is interested in rc value from parse, set value. */
5491 throw_exception (e
);
5495 case NOT_FOUND_ERROR
:
5497 /* If pending breakpoint support is turned off, throw
5500 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
5501 throw_exception (e
);
5503 exception_print (gdb_stderr
, e
);
5505 /* If pending breakpoint support is auto query and the user
5506 selects no, then simply return the error code. */
5507 if (pending_break_support
== AUTO_BOOLEAN_AUTO
&&
5508 !nquery ("Make breakpoint pending on future shared library load? "))
5511 /* At this point, either the user was queried about setting
5512 a pending breakpoint and selected yes, or pending
5513 breakpoint behavior is on and thus a pending breakpoint
5514 is defaulted on behalf of the user. */
5515 copy_arg
= xstrdup (addr_start
);
5516 addr_string
= ©_arg
;
5518 sals
.sals
= &pending_sal
;
5523 throw_exception (e
);
5530 /* Create a chain of things that always need to be cleaned up. */
5531 old_chain
= make_cleanup (null_cleanup
, 0);
5535 /* Make sure that all storage allocated to SALS gets freed. */
5536 make_cleanup (xfree
, sals
.sals
);
5538 /* Cleanup the addr_string array but not its contents. */
5539 make_cleanup (xfree
, addr_string
);
5542 /* ----------------------------- SNIP -----------------------------
5543 Anything added to the cleanup chain beyond this point is assumed
5544 to be part of a breakpoint. If the breakpoint create succeeds
5545 then the memory is not reclaimed. */
5546 breakpoint_chain
= make_cleanup (null_cleanup
, 0);
5548 /* Mark the contents of the addr_string for cleanup. These go on
5549 the breakpoint_chain and only occure if the breakpoint create
5551 for (i
= 0; i
< sals
.nelts
; i
++)
5553 if (addr_string
[i
] != NULL
)
5554 make_cleanup (xfree
, addr_string
[i
]);
5557 /* Resolve all line numbers to PC's and verify that the addresses
5558 are ok for the target. */
5560 breakpoint_sals_to_pc (&sals
, addr_start
);
5562 /* Verify that condition can be parsed, before setting any
5563 breakpoints. Allocate a separate condition expression for each
5567 if (parse_condition_and_thread
)
5569 /* Here we only parse 'arg' to separate condition
5570 from thread number, so parsing in context of first
5571 sal is OK. When setting the breakpoint we'll
5572 re-parse it in context of each sal. */
5575 find_condition_and_thread (arg
, sals
.sals
[0].pc
, &cond_string
, &thread
);
5577 make_cleanup (xfree
, cond_string
);
5581 /* Create a private copy of condition string. */
5584 cond_string
= xstrdup (cond_string
);
5585 make_cleanup (xfree
, cond_string
);
5588 create_breakpoints (sals
, addr_string
, cond_string
,
5589 hardwareflag
? bp_hardware_breakpoint
5591 tempflag
? disp_del
: disp_donttouch
,
5592 thread
, ignore_count
, ops
, from_tty
);
5596 struct symtab_and_line sal
= {0};
5597 struct breakpoint
*b
;
5599 make_cleanup (xfree
, copy_arg
);
5601 b
= set_raw_breakpoint_without_location (hardwareflag
5602 ? bp_hardware_breakpoint
5604 set_breakpoint_count (breakpoint_count
+ 1);
5605 b
->number
= breakpoint_count
;
5607 b
->addr_string
= addr_string
[0];
5608 b
->cond_string
= NULL
;
5609 b
->ignore_count
= ignore_count
;
5610 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
5611 b
->condition_not_parsed
= 1;
5614 update_global_location_list (1);
5619 warning (_("Multiple breakpoints were set.\n"
5620 "Use the \"delete\" command to delete unwanted breakpoints."));
5621 /* That's it. Discard the cleanups for data inserted into the
5623 discard_cleanups (breakpoint_chain
);
5624 /* But cleanup everything else. */
5625 do_cleanups (old_chain
);
5628 /* Set a breakpoint.
5629 ARG is a string describing breakpoint address,
5630 condition, and thread.
5631 FLAG specifies if a breakpoint is hardware on,
5632 and if breakpoint is temporary, using BP_HARDWARE_FLAG
5636 break_command_1 (char *arg
, int flag
, int from_tty
)
5638 int hardwareflag
= flag
& BP_HARDWAREFLAG
;
5639 int tempflag
= flag
& BP_TEMPFLAG
;
5641 break_command_really (arg
,
5642 NULL
, 0, 1 /* parse arg */,
5643 tempflag
, hardwareflag
,
5644 0 /* Ignore count */,
5645 pending_break_support
,
5646 NULL
/* breakpoint_ops */,
5652 set_breakpoint (char *address
, char *condition
,
5653 int hardwareflag
, int tempflag
,
5654 int thread
, int ignore_count
,
5657 break_command_really (address
, condition
, thread
,
5658 0 /* condition and thread are valid. */,
5659 tempflag
, hardwareflag
,
5662 ? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
5666 /* Adjust SAL to the first instruction past the function prologue.
5667 The end of the prologue is determined using the line table from
5668 the debugging information.
5670 If SAL is already past the prologue, then do nothing. */
5673 skip_prologue_sal (struct symtab_and_line
*sal
)
5675 struct symbol
*sym
= find_pc_function (sal
->pc
);
5676 struct symtab_and_line start_sal
;
5681 start_sal
= find_function_start_sal (sym
, 1);
5682 if (sal
->pc
< start_sal
.pc
)
5686 /* Helper function for break_command_1 and disassemble_command. */
5689 resolve_sal_pc (struct symtab_and_line
*sal
)
5693 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
5695 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
5696 error (_("No line %d in file \"%s\"."),
5697 sal
->line
, sal
->symtab
->filename
);
5700 /* If this SAL corresponds to a breakpoint inserted using
5701 a line number, then skip the function prologue if necessary. */
5702 if (sal
->explicit_line
)
5703 skip_prologue_sal (sal
);
5706 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
5708 struct blockvector
*bv
;
5712 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
, sal
->symtab
);
5715 sym
= block_linkage_function (b
);
5718 fixup_symbol_section (sym
, sal
->symtab
->objfile
);
5719 sal
->section
= SYMBOL_OBJ_SECTION (sym
);
5723 /* It really is worthwhile to have the section, so we'll just
5724 have to look harder. This case can be executed if we have
5725 line numbers but no functions (as can happen in assembly
5728 struct minimal_symbol
*msym
;
5730 msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
5732 sal
->section
= SYMBOL_OBJ_SECTION (msym
);
5739 break_command (char *arg
, int from_tty
)
5741 break_command_1 (arg
, 0, from_tty
);
5745 tbreak_command (char *arg
, int from_tty
)
5747 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
5751 hbreak_command (char *arg
, int from_tty
)
5753 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
5757 thbreak_command (char *arg
, int from_tty
)
5759 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
5763 stop_command (char *arg
, int from_tty
)
5765 printf_filtered (_("Specify the type of breakpoint to set.\n\
5766 Usage: stop in <function | address>\n\
5767 stop at <line>\n"));
5771 stopin_command (char *arg
, int from_tty
)
5775 if (arg
== (char *) NULL
)
5777 else if (*arg
!= '*')
5782 /* look for a ':'. If this is a line number specification, then
5783 say it is bad, otherwise, it should be an address or
5784 function/method name */
5785 while (*argptr
&& !hasColon
)
5787 hasColon
= (*argptr
== ':');
5792 badInput
= (*argptr
!= ':'); /* Not a class::method */
5794 badInput
= isdigit (*arg
); /* a simple line number */
5798 printf_filtered (_("Usage: stop in <function | address>\n"));
5800 break_command_1 (arg
, 0, from_tty
);
5804 stopat_command (char *arg
, int from_tty
)
5808 if (arg
== (char *) NULL
|| *arg
== '*') /* no line number */
5815 /* look for a ':'. If there is a '::' then get out, otherwise
5816 it is probably a line number. */
5817 while (*argptr
&& !hasColon
)
5819 hasColon
= (*argptr
== ':');
5824 badInput
= (*argptr
== ':'); /* we have class::method */
5826 badInput
= !isdigit (*arg
); /* not a line number */
5830 printf_filtered (_("Usage: stop at <line>\n"));
5832 break_command_1 (arg
, 0, from_tty
);
5835 /* accessflag: hw_write: watch write,
5836 hw_read: watch read,
5837 hw_access: watch access (read or write) */
5839 watch_command_1 (char *arg
, int accessflag
, int from_tty
)
5841 struct breakpoint
*b
, *scope_breakpoint
= NULL
;
5842 struct symtab_and_line sal
;
5843 struct expression
*exp
;
5844 struct block
*exp_valid_block
;
5845 struct value
*val
, *mark
;
5846 struct frame_info
*frame
;
5847 struct frame_info
*prev_frame
= NULL
;
5848 char *exp_start
= NULL
;
5849 char *exp_end
= NULL
;
5850 char *tok
, *id_tok_start
, *end_tok
;
5852 char *cond_start
= NULL
;
5853 char *cond_end
= NULL
;
5854 struct expression
*cond
= NULL
;
5855 int i
, other_type_used
, target_resources_ok
= 0;
5856 enum bptype bp_type
;
5860 init_sal (&sal
); /* initialize to zeroes */
5862 /* Make sure that we actually have parameters to parse. */
5863 if (arg
!= NULL
&& arg
[0] != '\0')
5865 toklen
= strlen (arg
); /* Size of argument list. */
5867 /* Points tok to the end of the argument list. */
5868 tok
= arg
+ toklen
- 1;
5870 /* Go backwards in the parameters list. Skip the last parameter.
5871 If we're expecting a 'thread <thread_num>' parameter, this should
5872 be the thread identifier. */
5873 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5875 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5878 /* Points end_tok to the beginning of the last token. */
5879 id_tok_start
= tok
+ 1;
5881 /* Go backwards in the parameters list. Skip one more parameter.
5882 If we're expecting a 'thread <thread_num>' parameter, we should
5883 reach a "thread" token. */
5884 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
5889 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
5892 /* Move the pointer forward to skip the whitespace and
5893 calculate the length of the token. */
5895 toklen
= end_tok
- tok
;
5897 if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
5899 /* At this point we've found a "thread" token, which means
5900 the user is trying to set a watchpoint that triggers
5901 only in a specific thread. */
5904 /* Extract the thread ID from the next token. */
5905 thread
= strtol (id_tok_start
, &endp
, 0);
5907 /* Check if the user provided a valid numeric value for the
5909 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
5910 error (_("Invalid thread ID specification %s."), id_tok_start
);
5912 /* Check if the thread actually exists. */
5913 if (!valid_thread_id (thread
))
5914 error (_("Unknown thread %d."), thread
);
5916 /* Truncate the string and get rid of the thread <thread_num>
5917 parameter before the parameter list is parsed by the
5918 evaluate_expression() function. */
5923 /* Parse the rest of the arguments. */
5924 innermost_block
= NULL
;
5926 exp
= parse_exp_1 (&arg
, 0, 0);
5928 exp_valid_block
= innermost_block
;
5929 mark
= value_mark ();
5930 fetch_watchpoint_value (exp
, &val
, NULL
, NULL
);
5932 release_value (val
);
5935 while (*tok
== ' ' || *tok
== '\t')
5939 while (*end_tok
!= ' ' && *end_tok
!= '\t' && *end_tok
!= '\000')
5942 toklen
= end_tok
- tok
;
5943 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
5945 tok
= cond_start
= end_tok
+ 1;
5946 cond
= parse_exp_1 (&tok
, 0, 0);
5950 error (_("Junk at end of command."));
5952 if (accessflag
== hw_read
)
5953 bp_type
= bp_read_watchpoint
;
5954 else if (accessflag
== hw_access
)
5955 bp_type
= bp_access_watchpoint
;
5957 bp_type
= bp_hardware_watchpoint
;
5959 mem_cnt
= can_use_hardware_watchpoint (val
);
5960 if (mem_cnt
== 0 && bp_type
!= bp_hardware_watchpoint
)
5961 error (_("Expression cannot be implemented with read/access watchpoint."));
5964 i
= hw_watchpoint_used_count (bp_type
, &other_type_used
);
5965 target_resources_ok
=
5966 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type
, i
+ mem_cnt
,
5968 if (target_resources_ok
== 0 && bp_type
!= bp_hardware_watchpoint
)
5969 error (_("Target does not support this type of hardware watchpoint."));
5971 if (target_resources_ok
< 0 && bp_type
!= bp_hardware_watchpoint
)
5972 error (_("Target can only support one kind of HW watchpoint at a time."));
5975 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5976 watchpoint could not be set. */
5977 if (!mem_cnt
|| target_resources_ok
<= 0)
5978 bp_type
= bp_watchpoint
;
5980 frame
= block_innermost_frame (exp_valid_block
);
5982 prev_frame
= get_prev_frame (frame
);
5986 /* If the expression is "local", then set up a "watchpoint scope"
5987 breakpoint at the point where we've left the scope of the watchpoint
5988 expression. Create the scope breakpoint before the watchpoint, so
5989 that we will encounter it first in bpstat_stop_status. */
5990 if (innermost_block
&& prev_frame
)
5992 scope_breakpoint
= create_internal_breakpoint (get_frame_pc (prev_frame
),
5993 bp_watchpoint_scope
);
5995 scope_breakpoint
->enable_state
= bp_enabled
;
5997 /* Automatically delete the breakpoint when it hits. */
5998 scope_breakpoint
->disposition
= disp_del
;
6000 /* Only break in the proper frame (help with recursion). */
6001 scope_breakpoint
->frame_id
= get_frame_id (prev_frame
);
6003 /* Set the address at which we will stop. */
6004 scope_breakpoint
->loc
->requested_address
6005 = get_frame_pc (prev_frame
);
6006 scope_breakpoint
->loc
->address
6007 = adjust_breakpoint_address (scope_breakpoint
->loc
->requested_address
,
6008 scope_breakpoint
->type
);
6011 /* Now set up the breakpoint. */
6012 b
= set_raw_breakpoint (sal
, bp_type
);
6013 set_breakpoint_count (breakpoint_count
+ 1);
6014 b
->number
= breakpoint_count
;
6016 b
->disposition
= disp_donttouch
;
6018 b
->exp_valid_block
= exp_valid_block
;
6019 b
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
6022 b
->loc
->cond
= cond
;
6024 b
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
6029 b
->watchpoint_frame
= get_frame_id (frame
);
6031 b
->watchpoint_frame
= null_frame_id
;
6033 if (scope_breakpoint
!= NULL
)
6035 /* The scope breakpoint is related to the watchpoint. We will
6036 need to act on them together. */
6037 b
->related_breakpoint
= scope_breakpoint
;
6038 scope_breakpoint
->related_breakpoint
= b
;
6041 value_free_to_mark (mark
);
6043 update_global_location_list (1);
6046 /* Return count of locations need to be watched and can be handled
6047 in hardware. If the watchpoint can not be handled
6048 in hardware return zero. */
6051 can_use_hardware_watchpoint (struct value
*v
)
6053 int found_memory_cnt
= 0;
6054 struct value
*head
= v
;
6056 /* Did the user specifically forbid us to use hardware watchpoints? */
6057 if (!can_use_hw_watchpoints
)
6060 /* Make sure that the value of the expression depends only upon
6061 memory contents, and values computed from them within GDB. If we
6062 find any register references or function calls, we can't use a
6063 hardware watchpoint.
6065 The idea here is that evaluating an expression generates a series
6066 of values, one holding the value of every subexpression. (The
6067 expression a*b+c has five subexpressions: a, b, a*b, c, and
6068 a*b+c.) GDB's values hold almost enough information to establish
6069 the criteria given above --- they identify memory lvalues,
6070 register lvalues, computed values, etcetera. So we can evaluate
6071 the expression, and then scan the chain of values that leaves
6072 behind to decide whether we can detect any possible change to the
6073 expression's final value using only hardware watchpoints.
6075 However, I don't think that the values returned by inferior
6076 function calls are special in any way. So this function may not
6077 notice that an expression involving an inferior function call
6078 can't be watched with hardware watchpoints. FIXME. */
6079 for (; v
; v
= value_next (v
))
6081 if (VALUE_LVAL (v
) == lval_memory
)
6084 /* A lazy memory lvalue is one that GDB never needed to fetch;
6085 we either just used its address (e.g., `a' in `a.b') or
6086 we never needed it at all (e.g., `a' in `a,b'). */
6090 /* Ahh, memory we actually used! Check if we can cover
6091 it with hardware watchpoints. */
6092 struct type
*vtype
= check_typedef (value_type (v
));
6094 /* We only watch structs and arrays if user asked for it
6095 explicitly, never if they just happen to appear in a
6096 middle of some value chain. */
6098 || (TYPE_CODE (vtype
) != TYPE_CODE_STRUCT
6099 && TYPE_CODE (vtype
) != TYPE_CODE_ARRAY
))
6101 CORE_ADDR vaddr
= VALUE_ADDRESS (v
) + value_offset (v
);
6102 int len
= TYPE_LENGTH (value_type (v
));
6104 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr
, len
))
6111 else if (VALUE_LVAL (v
) != not_lval
6112 && deprecated_value_modifiable (v
) == 0)
6113 return 0; /* ??? What does this represent? */
6114 else if (VALUE_LVAL (v
) == lval_register
)
6115 return 0; /* cannot watch a register with a HW watchpoint */
6118 /* The expression itself looks suitable for using a hardware
6119 watchpoint, but give the target machine a chance to reject it. */
6120 return found_memory_cnt
;
6124 watch_command_wrapper (char *arg
, int from_tty
)
6126 watch_command (arg
, from_tty
);
6130 watch_command (char *arg
, int from_tty
)
6132 watch_command_1 (arg
, hw_write
, from_tty
);
6136 rwatch_command_wrapper (char *arg
, int from_tty
)
6138 rwatch_command (arg
, from_tty
);
6142 rwatch_command (char *arg
, int from_tty
)
6144 watch_command_1 (arg
, hw_read
, from_tty
);
6148 awatch_command_wrapper (char *arg
, int from_tty
)
6150 awatch_command (arg
, from_tty
);
6154 awatch_command (char *arg
, int from_tty
)
6156 watch_command_1 (arg
, hw_access
, from_tty
);
6160 /* Helper routines for the until_command routine in infcmd.c. Here
6161 because it uses the mechanisms of breakpoints. */
6163 struct until_break_command_continuation_args
6165 struct breakpoint
*breakpoint
;
6166 struct breakpoint
*breakpoint2
;
6169 /* This function is called by fetch_inferior_event via the
6170 cmd_continuation pointer, to complete the until command. It takes
6171 care of cleaning up the temporary breakpoints set up by the until
6174 until_break_command_continuation (void *arg
)
6176 struct until_break_command_continuation_args
*a
= arg
;
6178 delete_breakpoint (a
->breakpoint
);
6180 delete_breakpoint (a
->breakpoint2
);
6184 until_break_command (char *arg
, int from_tty
, int anywhere
)
6186 struct symtabs_and_lines sals
;
6187 struct symtab_and_line sal
;
6188 struct frame_info
*frame
= get_selected_frame (NULL
);
6189 struct frame_info
*prev_frame
= get_prev_frame (frame
);
6190 struct breakpoint
*breakpoint
;
6191 struct breakpoint
*breakpoint2
= NULL
;
6192 struct cleanup
*old_chain
;
6194 clear_proceed_status ();
6196 /* Set a breakpoint where the user wants it and at return from
6199 if (default_breakpoint_valid
)
6200 sals
= decode_line_1 (&arg
, 1, default_breakpoint_symtab
,
6201 default_breakpoint_line
, (char ***) NULL
, NULL
);
6203 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
6204 0, (char ***) NULL
, NULL
);
6206 if (sals
.nelts
!= 1)
6207 error (_("Couldn't get information on specified line."));
6210 xfree (sals
.sals
); /* malloc'd, so freed */
6213 error (_("Junk at end of arguments."));
6215 resolve_sal_pc (&sal
);
6218 /* If the user told us to continue until a specified location,
6219 we don't specify a frame at which we need to stop. */
6220 breakpoint
= set_momentary_breakpoint (sal
, null_frame_id
, bp_until
);
6222 /* Otherwise, specify the current frame, because we want to stop only
6223 at the very same frame. */
6224 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
6227 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
6229 /* Keep within the current frame, or in frames called by the current
6233 sal
= find_pc_line (get_frame_pc (prev_frame
), 0);
6234 sal
.pc
= get_frame_pc (prev_frame
);
6235 breakpoint2
= set_momentary_breakpoint (sal
, get_frame_id (prev_frame
),
6237 make_cleanup_delete_breakpoint (breakpoint2
);
6240 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
6242 /* If we are running asynchronously, and proceed call above has actually
6243 managed to start the target, arrange for breakpoints to be
6244 deleted when the target stops. Otherwise, we're already stopped and
6245 delete breakpoints via cleanup chain. */
6247 if (target_can_async_p () && is_running (inferior_ptid
))
6249 struct until_break_command_continuation_args
*args
;
6250 args
= xmalloc (sizeof (*args
));
6252 args
->breakpoint
= breakpoint
;
6253 args
->breakpoint2
= breakpoint2
;
6255 discard_cleanups (old_chain
);
6256 add_continuation (inferior_thread (),
6257 until_break_command_continuation
, args
,
6261 do_cleanups (old_chain
);
6265 ep_skip_leading_whitespace (char **s
)
6267 if ((s
== NULL
) || (*s
== NULL
))
6269 while (isspace (**s
))
6273 /* This function attempts to parse an optional "if <cond>" clause
6274 from the arg string. If one is not found, it returns NULL.
6276 Else, it returns a pointer to the condition string. (It does not
6277 attempt to evaluate the string against a particular block.) And,
6278 it updates arg to point to the first character following the parsed
6279 if clause in the arg string. */
6282 ep_parse_optional_if_clause (char **arg
)
6286 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
6289 /* Skip the "if" keyword. */
6292 /* Skip any extra leading whitespace, and record the start of the
6293 condition string. */
6294 ep_skip_leading_whitespace (arg
);
6297 /* Assume that the condition occupies the remainder of the arg string. */
6298 (*arg
) += strlen (cond_string
);
6303 /* This function attempts to parse an optional filename from the arg
6304 string. If one is not found, it returns NULL.
6306 Else, it returns a pointer to the parsed filename. (This function
6307 makes no attempt to verify that a file of that name exists, or is
6308 accessible.) And, it updates arg to point to the first character
6309 following the parsed filename in the arg string.
6311 Note that clients needing to preserve the returned filename for
6312 future access should copy it to their own buffers. */
6314 ep_parse_optional_filename (char **arg
)
6316 static char filename
[1024];
6321 if ((*arg_p
== '\0') || isspace (*arg_p
))
6339 /* Commands to deal with catching events, such as signals, exceptions,
6340 process start/exit, etc. */
6344 catch_fork_temporary
, catch_vfork_temporary
,
6345 catch_fork_permanent
, catch_vfork_permanent
6350 catch_fork_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6352 char *cond_string
= NULL
;
6353 catch_fork_kind fork_kind
;
6356 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
6357 tempflag
= (fork_kind
== catch_fork_temporary
6358 || fork_kind
== catch_vfork_temporary
);
6362 ep_skip_leading_whitespace (&arg
);
6364 /* The allowed syntax is:
6366 catch [v]fork if <cond>
6368 First, check if there's an if clause. */
6369 cond_string
= ep_parse_optional_if_clause (&arg
);
6371 if ((*arg
!= '\0') && !isspace (*arg
))
6372 error (_("Junk at end of arguments."));
6374 /* If this target supports it, create a fork or vfork catchpoint
6375 and enable reporting of such events. */
6378 case catch_fork_temporary
:
6379 case catch_fork_permanent
:
6380 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6381 &catch_fork_breakpoint_ops
);
6383 case catch_vfork_temporary
:
6384 case catch_vfork_permanent
:
6385 create_fork_vfork_event_catchpoint (tempflag
, cond_string
,
6386 &catch_vfork_breakpoint_ops
);
6389 error (_("unsupported or unknown fork kind; cannot catch it"));
6395 catch_exec_command_1 (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6398 char *cond_string
= NULL
;
6400 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6404 ep_skip_leading_whitespace (&arg
);
6406 /* The allowed syntax is:
6408 catch exec if <cond>
6410 First, check if there's an if clause. */
6411 cond_string
= ep_parse_optional_if_clause (&arg
);
6413 if ((*arg
!= '\0') && !isspace (*arg
))
6414 error (_("Junk at end of arguments."));
6416 /* If this target supports it, create an exec catchpoint
6417 and enable reporting of such events. */
6418 create_catchpoint (tempflag
, cond_string
, &catch_exec_breakpoint_ops
);
6421 static enum print_stop_action
6422 print_exception_catchpoint (struct breakpoint
*b
)
6424 int bp_temp
, bp_throw
;
6426 annotate_catchpoint (b
->number
);
6428 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6429 if (b
->loc
->address
!= b
->loc
->requested_address
)
6430 breakpoint_adjustment_warning (b
->loc
->requested_address
,
6433 bp_temp
= b
->loc
->owner
->disposition
== disp_del
;
6435 bp_temp
? "Temporary catchpoint "
6437 if (!ui_out_is_mi_like_p (uiout
))
6438 ui_out_field_int (uiout
, "bkptno", b
->number
);
6440 bp_throw
? " (exception thrown), "
6441 : " (exception caught), ");
6442 if (ui_out_is_mi_like_p (uiout
))
6444 ui_out_field_string (uiout
, "reason",
6445 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
6446 ui_out_field_string (uiout
, "disp", bpdisp_text (b
->disposition
));
6447 ui_out_field_int (uiout
, "bkptno", b
->number
);
6449 return PRINT_SRC_AND_LOC
;
6453 print_one_exception_catchpoint (struct breakpoint
*b
, CORE_ADDR
*last_addr
)
6455 struct value_print_options opts
;
6456 get_user_print_options (&opts
);
6457 if (opts
.addressprint
)
6460 if (b
->loc
== NULL
|| b
->loc
->shlib_disabled
)
6461 ui_out_field_string (uiout
, "addr", "<PENDING>");
6463 ui_out_field_core_addr (uiout
, "addr", b
->loc
->address
);
6467 *last_addr
= b
->loc
->address
;
6468 if (strstr (b
->addr_string
, "throw") != NULL
)
6469 ui_out_field_string (uiout
, "what", "exception throw");
6471 ui_out_field_string (uiout
, "what", "exception catch");
6475 print_mention_exception_catchpoint (struct breakpoint
*b
)
6480 bp_temp
= b
->loc
->owner
->disposition
== disp_del
;
6481 bp_throw
= strstr (b
->addr_string
, "throw") != NULL
;
6482 ui_out_text (uiout
, bp_temp
? _("Temporary catchpoint ")
6483 : _("Catchpoint "));
6484 ui_out_field_int (uiout
, "bkptno", b
->number
);
6485 ui_out_text (uiout
, bp_throw
? _(" (throw)")
6489 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops
= {
6492 NULL
, /* breakpoint_hit */
6493 print_exception_catchpoint
,
6494 print_one_exception_catchpoint
,
6495 print_mention_exception_catchpoint
6499 handle_gnu_v3_exceptions (int tempflag
, char *cond_string
,
6500 enum exception_event_kind ex_event
, int from_tty
)
6502 char *trigger_func_name
;
6504 if (ex_event
== EX_EVENT_CATCH
)
6505 trigger_func_name
= "__cxa_begin_catch";
6507 trigger_func_name
= "__cxa_throw";
6509 break_command_really (trigger_func_name
, cond_string
, -1,
6510 0 /* condition and thread are valid. */,
6513 AUTO_BOOLEAN_TRUE
/* pending */,
6514 &gnu_v3_exception_catchpoint_ops
, from_tty
);
6519 /* Deal with "catch catch" and "catch throw" commands */
6522 catch_exception_command_1 (enum exception_event_kind ex_event
, char *arg
,
6523 int tempflag
, int from_tty
)
6525 char *cond_string
= NULL
;
6526 struct symtab_and_line
*sal
= NULL
;
6530 ep_skip_leading_whitespace (&arg
);
6532 cond_string
= ep_parse_optional_if_clause (&arg
);
6534 if ((*arg
!= '\0') && !isspace (*arg
))
6535 error (_("Junk at end of arguments."));
6537 if ((ex_event
!= EX_EVENT_THROW
) &&
6538 (ex_event
!= EX_EVENT_CATCH
))
6539 error (_("Unsupported or unknown exception event; cannot catch it"));
6541 if (handle_gnu_v3_exceptions (tempflag
, cond_string
, ex_event
, from_tty
))
6544 warning (_("Unsupported with this platform/compiler combination."));
6547 /* Implementation of "catch catch" command. */
6550 catch_catch_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6552 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6553 catch_exception_command_1 (EX_EVENT_CATCH
, arg
, tempflag
, from_tty
);
6556 /* Implementation of "catch throw" command. */
6559 catch_throw_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6561 int tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6562 catch_exception_command_1 (EX_EVENT_THROW
, arg
, tempflag
, from_tty
);
6565 /* Create a breakpoint struct for Ada exception catchpoints. */
6568 create_ada_exception_breakpoint (struct symtab_and_line sal
,
6572 struct expression
*cond
,
6573 struct breakpoint_ops
*ops
,
6577 struct breakpoint
*b
;
6581 describe_other_breakpoints (sal
.pc
, sal
.section
, -1);
6582 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
6583 version for exception catchpoints, because two catchpoints
6584 used for different exception names will use the same address.
6585 In this case, a "breakpoint ... also set at..." warning is
6586 unproductive. Besides. the warning phrasing is also a bit
6587 inapropriate, we should use the word catchpoint, and tell
6588 the user what type of catchpoint it is. The above is good
6589 enough for now, though. */
6592 b
= set_raw_breakpoint (sal
, bp_breakpoint
);
6593 set_breakpoint_count (breakpoint_count
+ 1);
6595 b
->enable_state
= bp_enabled
;
6596 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
6597 b
->number
= breakpoint_count
;
6598 b
->ignore_count
= 0;
6599 b
->loc
->cond
= cond
;
6600 b
->addr_string
= addr_string
;
6601 b
->language
= language_ada
;
6602 b
->cond_string
= cond_string
;
6603 b
->exp_string
= exp_string
;
6608 update_global_location_list (1);
6611 /* Implement the "catch exception" command. */
6614 catch_ada_exception_command (char *arg
, int from_tty
,
6615 struct cmd_list_element
*command
)
6618 struct symtab_and_line sal
;
6620 char *addr_string
= NULL
;
6621 char *exp_string
= NULL
;
6622 char *cond_string
= NULL
;
6623 struct expression
*cond
= NULL
;
6624 struct breakpoint_ops
*ops
= NULL
;
6626 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6630 sal
= ada_decode_exception_location (arg
, &addr_string
, &exp_string
,
6631 &cond_string
, &cond
, &ops
);
6632 create_ada_exception_breakpoint (sal
, addr_string
, exp_string
,
6633 cond_string
, cond
, ops
, tempflag
,
6637 /* Implement the "catch assert" command. */
6640 catch_assert_command (char *arg
, int from_tty
, struct cmd_list_element
*command
)
6643 struct symtab_and_line sal
;
6644 char *addr_string
= NULL
;
6645 struct breakpoint_ops
*ops
= NULL
;
6647 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
6651 sal
= ada_decode_assert_location (arg
, &addr_string
, &ops
);
6652 create_ada_exception_breakpoint (sal
, addr_string
, NULL
, NULL
, NULL
, ops
,
6653 tempflag
, from_tty
);
6657 catch_command (char *arg
, int from_tty
)
6659 error (_("Catch requires an event name."));
6664 tcatch_command (char *arg
, int from_tty
)
6666 error (_("Catch requires an event name."));
6669 /* Delete breakpoints by address or line. */
6672 clear_command (char *arg
, int from_tty
)
6674 struct breakpoint
*b
;
6675 VEC(breakpoint_p
) *found
= 0;
6678 struct symtabs_and_lines sals
;
6679 struct symtab_and_line sal
;
6684 sals
= decode_line_spec (arg
, 1);
6689 sals
.sals
= (struct symtab_and_line
*)
6690 xmalloc (sizeof (struct symtab_and_line
));
6691 make_cleanup (xfree
, sals
.sals
);
6692 init_sal (&sal
); /* initialize to zeroes */
6693 sal
.line
= default_breakpoint_line
;
6694 sal
.symtab
= default_breakpoint_symtab
;
6695 sal
.pc
= default_breakpoint_address
;
6696 if (sal
.symtab
== 0)
6697 error (_("No source file specified."));
6705 /* We don't call resolve_sal_pc here. That's not
6706 as bad as it seems, because all existing breakpoints
6707 typically have both file/line and pc set. So, if
6708 clear is given file/line, we can match this to existing
6709 breakpoint without obtaining pc at all.
6711 We only support clearing given the address explicitly
6712 present in breakpoint table. Say, we've set breakpoint
6713 at file:line. There were several PC values for that file:line,
6714 due to optimization, all in one block.
6715 We've picked one PC value. If "clear" is issued with another
6716 PC corresponding to the same file:line, the breakpoint won't
6717 be cleared. We probably can still clear the breakpoint, but
6718 since the other PC value is never presented to user, user
6719 can only find it by guessing, and it does not seem important
6722 /* For each line spec given, delete bps which correspond
6723 to it. Do it in two passes, solely to preserve the current
6724 behavior that from_tty is forced true if we delete more than
6728 for (i
= 0; i
< sals
.nelts
; i
++)
6730 /* If exact pc given, clear bpts at that pc.
6731 If line given (pc == 0), clear all bpts on specified line.
6732 If defaulting, clear all bpts on default line
6735 defaulting sal.pc != 0 tests to do
6740 1 0 <can't happen> */
6744 /* Find all matching breakpoints and add them to
6749 /* Are we going to delete b? */
6750 if (b
->type
!= bp_none
6751 && b
->type
!= bp_watchpoint
6752 && b
->type
!= bp_hardware_watchpoint
6753 && b
->type
!= bp_read_watchpoint
6754 && b
->type
!= bp_access_watchpoint
)
6756 struct bp_location
*loc
= b
->loc
;
6757 for (; loc
; loc
= loc
->next
)
6759 int pc_match
= sal
.pc
6760 && (loc
->address
== sal
.pc
)
6761 && (!section_is_overlay (loc
->section
)
6762 || loc
->section
== sal
.section
);
6763 int line_match
= ((default_match
|| (0 == sal
.pc
))
6764 && b
->source_file
!= NULL
6765 && sal
.symtab
!= NULL
6766 && strcmp (b
->source_file
, sal
.symtab
->filename
) == 0
6767 && b
->line_number
== sal
.line
);
6768 if (pc_match
|| line_match
)
6777 VEC_safe_push(breakpoint_p
, found
, b
);
6780 /* Now go thru the 'found' chain and delete them. */
6781 if (VEC_empty(breakpoint_p
, found
))
6784 error (_("No breakpoint at %s."), arg
);
6786 error (_("No breakpoint at this line."));
6789 if (VEC_length(breakpoint_p
, found
) > 1)
6790 from_tty
= 1; /* Always report if deleted more than one */
6793 if (VEC_length(breakpoint_p
, found
) == 1)
6794 printf_unfiltered (_("Deleted breakpoint "));
6796 printf_unfiltered (_("Deleted breakpoints "));
6798 breakpoints_changed ();
6800 for (ix
= 0; VEC_iterate(breakpoint_p
, found
, ix
, b
); ix
++)
6803 printf_unfiltered ("%d ", b
->number
);
6804 delete_breakpoint (b
);
6807 putchar_unfiltered ('\n');
6810 /* Delete breakpoint in BS if they are `delete' breakpoints and
6811 all breakpoints that are marked for deletion, whether hit or not.
6812 This is called after any breakpoint is hit, or after errors. */
6815 breakpoint_auto_delete (bpstat bs
)
6817 struct breakpoint
*b
, *temp
;
6819 for (; bs
; bs
= bs
->next
)
6820 if (bs
->breakpoint_at
6821 && bs
->breakpoint_at
->owner
6822 && bs
->breakpoint_at
->owner
->disposition
== disp_del
6824 delete_breakpoint (bs
->breakpoint_at
->owner
);
6826 ALL_BREAKPOINTS_SAFE (b
, temp
)
6828 if (b
->disposition
== disp_del_at_next_stop
)
6829 delete_breakpoint (b
);
6833 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
6834 into the inferior, only remove already-inserted locations that no
6835 longer should be inserted. Functions that delete a breakpoint or
6836 breakpoints should pass false, so that deleting a breakpoint
6837 doesn't have the side effect of inserting the locations of other
6838 breakpoints that are marked not-inserted, but should_be_inserted
6839 returns true on them.
6841 This behaviour is useful is situations close to tear-down -- e.g.,
6842 after an exec, while the target still has execution, but breakpoint
6843 shadows of the previous executable image should *NOT* be restored
6844 to the new image; or before detaching, where the target still has
6845 execution and wants to delete breakpoints from GDB's lists, and all
6846 breakpoints had already been removed from the inferior. */
6849 update_global_location_list (int should_insert
)
6851 struct breakpoint
*b
;
6852 struct bp_location
**next
= &bp_location_chain
;
6853 struct bp_location
*loc
;
6854 struct bp_location
*loc2
;
6855 struct gdb_exception e
;
6856 VEC(bp_location_p
) *old_locations
= NULL
;
6860 /* Store old locations for future reference. */
6861 for (loc
= bp_location_chain
; loc
; loc
= loc
->global_next
)
6862 VEC_safe_push (bp_location_p
, old_locations
, loc
);
6864 bp_location_chain
= NULL
;
6867 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
6870 next
= &(loc
->global_next
);
6875 /* Identify bp_location instances that are no longer present in the new
6876 list, and therefore should be freed. Note that it's not necessary that
6877 those locations should be removed from inferior -- if there's another
6878 location at the same address (previously marked as duplicate),
6879 we don't need to remove/insert the location. */
6880 for (ix
= 0; VEC_iterate(bp_location_p
, old_locations
, ix
, loc
); ++ix
)
6882 /* Tells if 'loc' is found amoung the new locations. If not, we
6884 int found_object
= 0;
6885 /* Tells if the location should remain inserted in the target. */
6886 int keep_in_target
= 0;
6888 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
6895 /* If this location is no longer present, and inserted, look if there's
6896 maybe a new location at the same address. If so, mark that one
6897 inserted, and don't remove this one. This is needed so that we
6898 don't have a time window where a breakpoint at certain location is not
6903 /* If the location is inserted now, we might have to remove it. */
6905 if (found_object
&& should_be_inserted (loc
))
6907 /* The location is still present in the location list, and still
6908 should be inserted. Don't do anything. */
6913 /* The location is either no longer present, or got disabled.
6914 See if there's another location at the same address, in which
6915 case we don't need to remove this one from the target. */
6916 if (breakpoint_address_is_meaningful (loc
->owner
))
6917 for (loc2
= bp_location_chain
; loc2
; loc2
= loc2
->global_next
)
6919 /* For the sake of should_insert_location. The
6920 call to check_duplicates will fix up this later. */
6921 loc2
->duplicate
= 0;
6922 if (should_be_inserted (loc2
)
6923 && loc2
!= loc
&& loc2
->address
== loc
->address
)
6926 loc2
->target_info
= loc
->target_info
;
6933 if (!keep_in_target
)
6935 if (remove_breakpoint (loc
, mark_uninserted
))
6937 /* This is just about all we can do. We could keep this
6938 location on the global list, and try to remove it next
6939 time, but there's no particular reason why we will
6942 Note that at this point, loc->owner is still valid,
6943 as delete_breakpoint frees the breakpoint only
6944 after calling us. */
6945 printf_filtered (_("warning: Error removing breakpoint %d\n"),
6946 loc
->owner
->number
);
6954 if (removed
&& non_stop
)
6956 /* This location was removed from the targets. In non-stop mode,
6957 a race condition is possible where we've removed a breakpoint,
6958 but stop events for that breakpoint are already queued and will
6959 arrive later. To suppress spurious SIGTRAPs reported to user,
6960 we keep this breakpoint location for a bit, and will retire it
6961 after we see 3 * thread_count events.
6962 The theory here is that reporting of events should,
6963 "on the average", be fair, so after that many event we'll see
6964 events from all threads that have anything of interest, and no
6965 longer need to keep this breakpoint. This is just a
6966 heuristic, but if it's wrong, we'll report unexpected SIGTRAP,
6967 which is usability issue, but not a correctness problem. */
6968 loc
->events_till_retirement
= 3 * (thread_count () + 1);
6971 VEC_safe_push (bp_location_p
, moribund_locations
, loc
);
6974 free_bp_location (loc
);
6980 check_duplicates (b
);
6983 if (breakpoints_always_inserted_mode () && should_insert
6984 && (target_has_execution
6985 || (gdbarch_has_global_solist (target_gdbarch
)
6986 && target_supports_multi_process ())))
6987 insert_breakpoint_locations ();
6991 breakpoint_retire_moribund (void)
6993 struct bp_location
*loc
;
6996 for (ix
= 0; VEC_iterate (bp_location_p
, moribund_locations
, ix
, loc
); ++ix
)
6997 if (--(loc
->events_till_retirement
) == 0)
6999 free_bp_location (loc
);
7000 VEC_unordered_remove (bp_location_p
, moribund_locations
, ix
);
7006 update_global_location_list_nothrow (int inserting
)
7008 struct gdb_exception e
;
7009 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7010 update_global_location_list (inserting
);
7013 /* Clear BPT from a BPS. */
7015 bpstat_remove_breakpoint (bpstat bps
, struct breakpoint
*bpt
)
7018 for (bs
= bps
; bs
; bs
= bs
->next
)
7019 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->owner
== bpt
)
7021 bs
->breakpoint_at
= NULL
;
7023 /* bs->commands will be freed later. */
7027 /* Callback for iterate_over_threads. */
7029 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
7031 struct breakpoint
*bpt
= data
;
7032 bpstat_remove_breakpoint (th
->stop_bpstat
, bpt
);
7036 /* Delete a breakpoint and clean up all traces of it in the data
7040 delete_breakpoint (struct breakpoint
*bpt
)
7042 struct breakpoint
*b
;
7043 struct bp_location
*loc
, *next
;
7045 gdb_assert (bpt
!= NULL
);
7047 /* Has this bp already been deleted? This can happen because multiple
7048 lists can hold pointers to bp's. bpstat lists are especial culprits.
7050 One example of this happening is a watchpoint's scope bp. When the
7051 scope bp triggers, we notice that the watchpoint is out of scope, and
7052 delete it. We also delete its scope bp. But the scope bp is marked
7053 "auto-deleting", and is already on a bpstat. That bpstat is then
7054 checked for auto-deleting bp's, which are deleted.
7056 A real solution to this problem might involve reference counts in bp's,
7057 and/or giving them pointers back to their referencing bpstat's, and
7058 teaching delete_breakpoint to only free a bp's storage when no more
7059 references were extent. A cheaper bandaid was chosen. */
7060 if (bpt
->type
== bp_none
)
7063 observer_notify_breakpoint_deleted (bpt
->number
);
7065 if (breakpoint_chain
== bpt
)
7066 breakpoint_chain
= bpt
->next
;
7071 b
->next
= bpt
->next
;
7075 free_command_lines (&bpt
->commands
);
7076 if (bpt
->cond_string
!= NULL
)
7077 xfree (bpt
->cond_string
);
7078 if (bpt
->addr_string
!= NULL
)
7079 xfree (bpt
->addr_string
);
7080 if (bpt
->exp
!= NULL
)
7082 if (bpt
->exp_string
!= NULL
)
7083 xfree (bpt
->exp_string
);
7084 if (bpt
->val
!= NULL
)
7085 value_free (bpt
->val
);
7086 if (bpt
->source_file
!= NULL
)
7087 xfree (bpt
->source_file
);
7088 if (bpt
->exec_pathname
!= NULL
)
7089 xfree (bpt
->exec_pathname
);
7091 /* Be sure no bpstat's are pointing at it after it's been freed. */
7092 /* FIXME, how can we find all bpstat's?
7093 We just check stop_bpstat for now. Note that we cannot just
7094 remove bpstats pointing at bpt from the stop_bpstat list
7095 entirely, as breakpoint commands are associated with the bpstat;
7096 if we remove it here, then the later call to
7097 bpstat_do_actions (&stop_bpstat);
7098 in event-top.c won't do anything, and temporary breakpoints
7099 with commands won't work. */
7101 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
7103 /* Now that breakpoint is removed from breakpoint
7104 list, update the global location list. This
7105 will remove locations that used to belong to
7106 this breakpoint. Do this before freeing
7107 the breakpoint itself, since remove_breakpoint
7108 looks at location's owner. It might be better
7109 design to have location completely self-contained,
7110 but it's not the case now. */
7111 update_global_location_list (0);
7114 /* On the chance that someone will soon try again to delete this same
7115 bp, we mark it as deleted before freeing its storage. */
7116 bpt
->type
= bp_none
;
7122 do_delete_breakpoint_cleanup (void *b
)
7124 delete_breakpoint (b
);
7128 make_cleanup_delete_breakpoint (struct breakpoint
*b
)
7130 return make_cleanup (do_delete_breakpoint_cleanup
, b
);
7134 delete_command (char *arg
, int from_tty
)
7136 struct breakpoint
*b
, *temp
;
7142 int breaks_to_delete
= 0;
7144 /* Delete all breakpoints if no argument.
7145 Do not delete internal or call-dummy breakpoints, these
7146 have to be deleted with an explicit breakpoint number argument. */
7149 if (b
->type
!= bp_call_dummy
&&
7150 b
->type
!= bp_shlib_event
&&
7151 b
->type
!= bp_thread_event
&&
7152 b
->type
!= bp_overlay_event
&&
7155 breaks_to_delete
= 1;
7160 /* Ask user only if there are some breakpoints to delete. */
7162 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
7164 ALL_BREAKPOINTS_SAFE (b
, temp
)
7166 if (b
->type
!= bp_call_dummy
&&
7167 b
->type
!= bp_shlib_event
&&
7168 b
->type
!= bp_thread_event
&&
7169 b
->type
!= bp_overlay_event
&&
7171 delete_breakpoint (b
);
7176 map_breakpoint_numbers (arg
, delete_breakpoint
);
7180 all_locations_are_pending (struct bp_location
*loc
)
7182 for (; loc
; loc
= loc
->next
)
7183 if (!loc
->shlib_disabled
)
7188 /* Subroutine of update_breakpoint_locations to simplify it.
7189 Return non-zero if multiple fns in list LOC have the same name.
7190 Null names are ignored. */
7193 ambiguous_names_p (struct bp_location
*loc
)
7195 struct bp_location
*l
;
7196 htab_t htab
= htab_create_alloc (13, htab_hash_string
,
7197 (int (*) (const void *, const void *)) streq
,
7198 NULL
, xcalloc
, xfree
);
7200 for (l
= loc
; l
!= NULL
; l
= l
->next
)
7203 const char *name
= l
->function_name
;
7205 /* Allow for some names to be NULL, ignore them. */
7209 slot
= (const char **) htab_find_slot (htab
, (const void *) name
,
7211 /* NOTE: We can assume slot != NULL here because xcalloc never returns
7226 update_breakpoint_locations (struct breakpoint
*b
,
7227 struct symtabs_and_lines sals
)
7231 struct bp_location
*existing_locations
= b
->loc
;
7233 /* If there's no new locations, and all existing locations
7234 are pending, don't do anything. This optimizes
7235 the common case where all locations are in the same
7236 shared library, that was unloaded. We'd like to
7237 retain the location, so that when the library
7238 is loaded again, we don't loose the enabled/disabled
7239 status of the individual locations. */
7240 if (all_locations_are_pending (existing_locations
) && sals
.nelts
== 0)
7245 for (i
= 0; i
< sals
.nelts
; ++i
)
7247 struct bp_location
*new_loc
=
7248 add_location_to_breakpoint (b
, &(sals
.sals
[i
]));
7250 /* Reparse conditions, they might contain references to the
7252 if (b
->cond_string
!= NULL
)
7254 struct gdb_exception e
;
7257 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7259 new_loc
->cond
= parse_exp_1 (&s
, block_for_pc (sals
.sals
[i
].pc
),
7264 warning (_("failed to reevaluate condition for breakpoint %d: %s"),
7265 b
->number
, e
.message
);
7266 new_loc
->enabled
= 0;
7270 if (b
->source_file
!= NULL
)
7271 xfree (b
->source_file
);
7272 if (sals
.sals
[i
].symtab
== NULL
)
7273 b
->source_file
= NULL
;
7276 savestring (sals
.sals
[i
].symtab
->filename
,
7277 strlen (sals
.sals
[i
].symtab
->filename
));
7279 if (b
->line_number
== 0)
7280 b
->line_number
= sals
.sals
[i
].line
;
7283 /* Update locations of permanent breakpoints. */
7284 if (b
->enable_state
== bp_permanent
)
7285 make_breakpoint_permanent (b
);
7287 /* If possible, carry over 'disable' status from existing breakpoints. */
7289 struct bp_location
*e
= existing_locations
;
7290 /* If there are multiple breakpoints with the same function name,
7291 e.g. for inline functions, comparing function names won't work.
7292 Instead compare pc addresses; this is just a heuristic as things
7293 may have moved, but in practice it gives the correct answer
7294 often enough until a better solution is found. */
7295 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
7297 for (; e
; e
= e
->next
)
7299 if (!e
->enabled
&& e
->function_name
)
7301 struct bp_location
*l
= b
->loc
;
7302 if (have_ambiguous_names
)
7304 for (; l
; l
= l
->next
)
7305 if (e
->address
== l
->address
)
7313 for (; l
; l
= l
->next
)
7314 if (l
->function_name
7315 && strcmp (e
->function_name
, l
->function_name
) == 0)
7325 update_global_location_list (1);
7329 /* Reset a breakpoint given it's struct breakpoint * BINT.
7330 The value we return ends up being the return value from catch_errors.
7331 Unused in this case. */
7334 breakpoint_re_set_one (void *bint
)
7336 /* get past catch_errs */
7337 struct breakpoint
*b
= (struct breakpoint
*) bint
;
7341 int *not_found_ptr
= ¬_found
;
7342 struct symtabs_and_lines sals
= {};
7343 struct symtabs_and_lines expanded
;
7345 enum enable_state save_enable
;
7346 struct gdb_exception e
;
7352 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
7356 case bp_hardware_breakpoint
:
7357 if (b
->addr_string
== NULL
)
7359 /* Anything without a string can't be re-set. */
7360 delete_breakpoint (b
);
7364 set_language (b
->language
);
7365 input_radix
= b
->input_radix
;
7367 TRY_CATCH (e
, RETURN_MASK_ERROR
)
7369 sals
= decode_line_1 (&s
, 1, (struct symtab
*) NULL
, 0, (char ***) NULL
,
7374 int not_found_and_ok
= 0;
7375 /* For pending breakpoints, it's expected that parsing
7376 will fail until the right shared library is loaded.
7377 User has already told to create pending breakpoints and
7378 don't need extra messages. If breakpoint is in bp_shlib_disabled
7379 state, then user already saw the message about that breakpoint
7380 being disabled, and don't want to see more errors. */
7382 && (b
->condition_not_parsed
7383 || (b
->loc
&& b
->loc
->shlib_disabled
)
7384 || b
->enable_state
== bp_disabled
))
7385 not_found_and_ok
= 1;
7387 if (!not_found_and_ok
)
7389 /* We surely don't want to warn about the same breakpoint
7390 10 times. One solution, implemented here, is disable
7391 the breakpoint on error. Another solution would be to
7392 have separate 'warning emitted' flag. Since this
7393 happens only when a binary has changed, I don't know
7394 which approach is better. */
7395 b
->enable_state
= bp_disabled
;
7396 throw_exception (e
);
7403 gdb_assert (sals
.nelts
== 1);
7404 resolve_sal_pc (&sals
.sals
[0]);
7405 if (b
->condition_not_parsed
&& s
&& s
[0])
7407 char *cond_string
= 0;
7409 find_condition_and_thread (s
, sals
.sals
[0].pc
,
7410 &cond_string
, &thread
);
7412 b
->cond_string
= cond_string
;
7414 b
->condition_not_parsed
= 0;
7416 expanded
= expand_line_sal_maybe (sals
.sals
[0]);
7417 update_breakpoint_locations (b
, expanded
);
7423 case bp_hardware_watchpoint
:
7424 case bp_read_watchpoint
:
7425 case bp_access_watchpoint
:
7426 /* Watchpoint can be either on expression using entirely global variables,
7427 or it can be on local variables.
7429 Watchpoints of the first kind are never auto-deleted, and even persist
7430 across program restarts. Since they can use variables from shared
7431 libraries, we need to reparse expression as libraries are loaded
7434 Watchpoints on local variables can also change meaning as result
7435 of solib event. For example, if a watchpoint uses both a local and
7436 a global variables in expression, it's a local watchpoint, but
7437 unloading of a shared library will make the expression invalid.
7438 This is not a very common use case, but we still re-evaluate
7439 expression, to avoid surprises to the user.
7441 Note that for local watchpoints, we re-evaluate it only if
7442 watchpoints frame id is still valid. If it's not, it means
7443 the watchpoint is out of scope and will be deleted soon. In fact,
7444 I'm not sure we'll ever be called in this case.
7446 If a local watchpoint's frame id is still valid, then
7447 b->exp_valid_block is likewise valid, and we can safely use it.
7449 Don't do anything about disabled watchpoints, since they will
7450 be reevaluated again when enabled. */
7451 update_watchpoint (b
, 1 /* reparse */);
7453 /* We needn't really do anything to reset these, since the mask
7454 that requests them is unaffected by e.g., new libraries being
7460 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b
->type
);
7462 /* Delete overlay event breakpoints; they will be reset later by
7463 breakpoint_re_set. */
7464 case bp_overlay_event
:
7465 delete_breakpoint (b
);
7468 /* This breakpoint is special, it's set up when the inferior
7469 starts and we really don't want to touch it. */
7470 case bp_shlib_event
:
7472 /* Like bp_shlib_event, this breakpoint type is special.
7473 Once it is set up, we do not want to touch it. */
7474 case bp_thread_event
:
7476 /* Keep temporary breakpoints, which can be encountered when we step
7477 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7478 Otherwise these should have been blown away via the cleanup chain
7479 or by breakpoint_init_inferior when we rerun the executable. */
7482 case bp_watchpoint_scope
:
7484 case bp_step_resume
:
7486 case bp_longjmp_resume
:
7493 /* Re-set all breakpoints after symbols have been re-loaded. */
7495 breakpoint_re_set (void)
7497 struct breakpoint
*b
, *temp
;
7498 enum language save_language
;
7499 int save_input_radix
;
7501 save_language
= current_language
->la_language
;
7502 save_input_radix
= input_radix
;
7503 ALL_BREAKPOINTS_SAFE (b
, temp
)
7505 /* Format possible error msg */
7506 char *message
= xstrprintf ("Error in re-setting breakpoint %d: ",
7508 struct cleanup
*cleanups
= make_cleanup (xfree
, message
);
7509 catch_errors (breakpoint_re_set_one
, b
, message
, RETURN_MASK_ALL
);
7510 do_cleanups (cleanups
);
7512 set_language (save_language
);
7513 input_radix
= save_input_radix
;
7515 create_overlay_event_breakpoint ("_ovly_debug_event");
7518 /* Reset the thread number of this breakpoint:
7520 - If the breakpoint is for all threads, leave it as-is.
7521 - Else, reset it to the current thread for inferior_ptid. */
7523 breakpoint_re_set_thread (struct breakpoint
*b
)
7525 if (b
->thread
!= -1)
7527 if (in_thread_list (inferior_ptid
))
7528 b
->thread
= pid_to_thread_id (inferior_ptid
);
7532 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7533 If from_tty is nonzero, it prints a message to that effect,
7534 which ends with a period (no newline). */
7537 set_ignore_count (int bptnum
, int count
, int from_tty
)
7539 struct breakpoint
*b
;
7545 if (b
->number
== bptnum
)
7547 b
->ignore_count
= count
;
7551 printf_filtered (_("Will stop next time breakpoint %d is reached."),
7553 else if (count
== 1)
7554 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
7557 printf_filtered (_("Will ignore next %d crossings of breakpoint %d."),
7560 breakpoints_changed ();
7561 observer_notify_breakpoint_modified (b
->number
);
7565 error (_("No breakpoint number %d."), bptnum
);
7569 make_breakpoint_silent (struct breakpoint
*b
)
7571 /* Silence the breakpoint. */
7575 /* Command to set ignore-count of breakpoint N to COUNT. */
7578 ignore_command (char *args
, int from_tty
)
7584 error_no_arg (_("a breakpoint number"));
7586 num
= get_number (&p
);
7588 error (_("bad breakpoint number: '%s'"), args
);
7590 error (_("Second argument (specified ignore-count) is missing."));
7592 set_ignore_count (num
,
7593 longest_to_int (value_as_long (parse_and_eval (p
))),
7596 printf_filtered ("\n");
7599 /* Call FUNCTION on each of the breakpoints
7600 whose numbers are given in ARGS. */
7603 map_breakpoint_numbers (char *args
, void (*function
) (struct breakpoint
*))
7608 struct breakpoint
*b
, *tmp
;
7612 error_no_arg (_("one or more breakpoint numbers"));
7619 num
= get_number_or_range (&p1
);
7622 warning (_("bad breakpoint number at or near '%s'"), p
);
7626 ALL_BREAKPOINTS_SAFE (b
, tmp
)
7627 if (b
->number
== num
)
7629 struct breakpoint
*related_breakpoint
= b
->related_breakpoint
;
7632 if (related_breakpoint
)
7633 function (related_breakpoint
);
7637 printf_unfiltered (_("No breakpoint number %d.\n"), num
);
7643 static struct bp_location
*
7644 find_location_by_number (char *number
)
7646 char *dot
= strchr (number
, '.');
7650 struct breakpoint
*b
;
7651 struct bp_location
*loc
;
7656 bp_num
= get_number_or_range (&p1
);
7658 error (_("Bad breakpoint number '%s'"), number
);
7661 if (b
->number
== bp_num
)
7666 if (!b
|| b
->number
!= bp_num
)
7667 error (_("Bad breakpoint number '%s'"), number
);
7670 loc_num
= get_number_or_range (&p1
);
7672 error (_("Bad breakpoint location number '%s'"), number
);
7676 for (;loc_num
&& loc
; --loc_num
, loc
= loc
->next
)
7679 error (_("Bad breakpoint location number '%s'"), dot
+1);
7685 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
7686 If from_tty is nonzero, it prints a message to that effect,
7687 which ends with a period (no newline). */
7690 disable_breakpoint (struct breakpoint
*bpt
)
7692 /* Never disable a watchpoint scope breakpoint; we want to
7693 hit them when we leave scope so we can delete both the
7694 watchpoint and its scope breakpoint at that time. */
7695 if (bpt
->type
== bp_watchpoint_scope
)
7698 /* You can't disable permanent breakpoints. */
7699 if (bpt
->enable_state
== bp_permanent
)
7702 bpt
->enable_state
= bp_disabled
;
7704 update_global_location_list (0);
7706 observer_notify_breakpoint_modified (bpt
->number
);
7710 disable_command (char *args
, int from_tty
)
7712 struct breakpoint
*bpt
;
7714 ALL_BREAKPOINTS (bpt
)
7718 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
7723 case bp_hardware_breakpoint
:
7725 case bp_hardware_watchpoint
:
7726 case bp_read_watchpoint
:
7727 case bp_access_watchpoint
:
7728 disable_breakpoint (bpt
);
7732 else if (strchr (args
, '.'))
7734 struct bp_location
*loc
= find_location_by_number (args
);
7737 update_global_location_list (0);
7740 map_breakpoint_numbers (args
, disable_breakpoint
);
7744 do_enable_breakpoint (struct breakpoint
*bpt
, enum bpdisp disposition
)
7746 int target_resources_ok
, other_type_used
;
7749 if (bpt
->type
== bp_hardware_breakpoint
)
7752 i
= hw_breakpoint_used_count ();
7753 target_resources_ok
=
7754 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint
,
7756 if (target_resources_ok
== 0)
7757 error (_("No hardware breakpoint support in the target."));
7758 else if (target_resources_ok
< 0)
7759 error (_("Hardware breakpoints used exceeds limit."));
7762 if (bpt
->type
== bp_watchpoint
||
7763 bpt
->type
== bp_hardware_watchpoint
||
7764 bpt
->type
== bp_read_watchpoint
||
7765 bpt
->type
== bp_access_watchpoint
)
7767 struct frame_id saved_frame_id
;
7769 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
7770 if (bpt
->exp_valid_block
!= NULL
)
7772 struct frame_info
*fr
=
7773 fr
= frame_find_by_id (bpt
->watchpoint_frame
);
7776 printf_filtered (_("\
7777 Cannot enable watchpoint %d because the block in which its expression\n\
7778 is valid is not currently in scope.\n"), bpt
->number
);
7785 value_free (bpt
->val
);
7786 mark
= value_mark ();
7787 fetch_watchpoint_value (bpt
->exp
, &bpt
->val
, NULL
, NULL
);
7789 release_value (bpt
->val
);
7792 if (bpt
->type
== bp_hardware_watchpoint
||
7793 bpt
->type
== bp_read_watchpoint
||
7794 bpt
->type
== bp_access_watchpoint
)
7796 int i
= hw_watchpoint_used_count (bpt
->type
, &other_type_used
);
7797 int mem_cnt
= can_use_hardware_watchpoint (bpt
->val
);
7799 /* Hack around 'unused var' error for some targets here */
7800 (void) mem_cnt
, (void) i
;
7801 target_resources_ok
= TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7802 bpt
->type
, i
+ mem_cnt
, other_type_used
);
7803 /* we can consider of type is bp_hardware_watchpoint, convert to
7804 bp_watchpoint in the following condition */
7805 if (target_resources_ok
< 0)
7807 printf_filtered (_("\
7808 Cannot enable watchpoint %d because target watch resources\n\
7809 have been allocated for other watchpoints.\n"), bpt
->number
);
7810 value_free_to_mark (mark
);
7815 select_frame (frame_find_by_id (saved_frame_id
));
7816 value_free_to_mark (mark
);
7819 if (bpt
->enable_state
!= bp_permanent
)
7820 bpt
->enable_state
= bp_enabled
;
7821 bpt
->disposition
= disposition
;
7822 update_global_location_list (1);
7823 breakpoints_changed ();
7825 observer_notify_breakpoint_modified (bpt
->number
);
7830 enable_breakpoint (struct breakpoint
*bpt
)
7832 do_enable_breakpoint (bpt
, bpt
->disposition
);
7835 /* The enable command enables the specified breakpoints (or all defined
7836 breakpoints) so they once again become (or continue to be) effective
7837 in stopping the inferior. */
7840 enable_command (char *args
, int from_tty
)
7842 struct breakpoint
*bpt
;
7844 ALL_BREAKPOINTS (bpt
)
7848 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
7853 case bp_hardware_breakpoint
:
7855 case bp_hardware_watchpoint
:
7856 case bp_read_watchpoint
:
7857 case bp_access_watchpoint
:
7858 enable_breakpoint (bpt
);
7862 else if (strchr (args
, '.'))
7864 struct bp_location
*loc
= find_location_by_number (args
);
7867 update_global_location_list (1);
7870 map_breakpoint_numbers (args
, enable_breakpoint
);
7874 enable_once_breakpoint (struct breakpoint
*bpt
)
7876 do_enable_breakpoint (bpt
, disp_disable
);
7880 enable_once_command (char *args
, int from_tty
)
7882 map_breakpoint_numbers (args
, enable_once_breakpoint
);
7886 enable_delete_breakpoint (struct breakpoint
*bpt
)
7888 do_enable_breakpoint (bpt
, disp_del
);
7892 enable_delete_command (char *args
, int from_tty
)
7894 map_breakpoint_numbers (args
, enable_delete_breakpoint
);
7898 set_breakpoint_cmd (char *args
, int from_tty
)
7903 show_breakpoint_cmd (char *args
, int from_tty
)
7907 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
7909 struct symtabs_and_lines
7910 decode_line_spec_1 (char *string
, int funfirstline
)
7912 struct symtabs_and_lines sals
;
7914 error (_("Empty line specification."));
7915 if (default_breakpoint_valid
)
7916 sals
= decode_line_1 (&string
, funfirstline
,
7917 default_breakpoint_symtab
,
7918 default_breakpoint_line
,
7919 (char ***) NULL
, NULL
);
7921 sals
= decode_line_1 (&string
, funfirstline
,
7922 (struct symtab
*) NULL
, 0, (char ***) NULL
, NULL
);
7924 error (_("Junk at end of line specification: %s"), string
);
7928 /* Create and insert a raw software breakpoint at PC. Return an
7929 identifier, which should be used to remove the breakpoint later.
7930 In general, places which call this should be using something on the
7931 breakpoint chain instead; this function should be eliminated
7935 deprecated_insert_raw_breakpoint (CORE_ADDR pc
)
7937 struct bp_target_info
*bp_tgt
;
7939 bp_tgt
= xmalloc (sizeof (struct bp_target_info
));
7940 memset (bp_tgt
, 0, sizeof (struct bp_target_info
));
7942 bp_tgt
->placed_address
= pc
;
7943 if (target_insert_breakpoint (bp_tgt
) != 0)
7945 /* Could not insert the breakpoint. */
7953 /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
7956 deprecated_remove_raw_breakpoint (void *bp
)
7958 struct bp_target_info
*bp_tgt
= bp
;
7961 ret
= target_remove_breakpoint (bp_tgt
);
7967 /* One (or perhaps two) breakpoints used for software single stepping. */
7969 static void *single_step_breakpoints
[2];
7971 /* Create and insert a breakpoint for software single step. */
7974 insert_single_step_breakpoint (CORE_ADDR next_pc
)
7978 if (single_step_breakpoints
[0] == NULL
)
7979 bpt_p
= &single_step_breakpoints
[0];
7982 gdb_assert (single_step_breakpoints
[1] == NULL
);
7983 bpt_p
= &single_step_breakpoints
[1];
7986 /* NOTE drow/2006-04-11: A future improvement to this function would be
7987 to only create the breakpoints once, and actually put them on the
7988 breakpoint chain. That would let us use set_raw_breakpoint. We could
7989 adjust the addresses each time they were needed. Doing this requires
7990 corresponding changes elsewhere where single step breakpoints are
7991 handled, however. So, for now, we use this. */
7993 *bpt_p
= deprecated_insert_raw_breakpoint (next_pc
);
7995 error (_("Could not insert single-step breakpoint at 0x%s"),
7996 paddr_nz (next_pc
));
7999 /* Remove and delete any breakpoints used for software single step. */
8002 remove_single_step_breakpoints (void)
8004 gdb_assert (single_step_breakpoints
[0] != NULL
);
8006 /* See insert_single_step_breakpoint for more about this deprecated
8008 deprecated_remove_raw_breakpoint (single_step_breakpoints
[0]);
8009 single_step_breakpoints
[0] = NULL
;
8011 if (single_step_breakpoints
[1] != NULL
)
8013 deprecated_remove_raw_breakpoint (single_step_breakpoints
[1]);
8014 single_step_breakpoints
[1] = NULL
;
8018 /* Check whether a software single-step breakpoint is inserted at PC. */
8021 single_step_breakpoint_inserted_here_p (CORE_ADDR pc
)
8025 for (i
= 0; i
< 2; i
++)
8027 struct bp_target_info
*bp_tgt
= single_step_breakpoints
[i
];
8028 if (bp_tgt
&& bp_tgt
->placed_address
== pc
)
8036 /* This help string is used for the break, hbreak, tbreak and thbreak commands.
8037 It is defined as a macro to prevent duplication.
8038 COMMAND should be a string constant containing the name of the command. */
8039 #define BREAK_ARGS_HELP(command) \
8040 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
8041 LOCATION may be a line number, function name, or \"*\" and an address.\n\
8042 If a line number is specified, break at start of code for that line.\n\
8043 If a function is specified, break at start of code for that function.\n\
8044 If an address is specified, break at that exact address.\n\
8045 With no LOCATION, uses current execution address of selected stack frame.\n\
8046 This is useful for breaking on return to a stack frame.\n\
8048 THREADNUM is the number from \"info threads\".\n\
8049 CONDITION is a boolean expression.\n\
8051 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
8053 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
8055 /* List of subcommands for "catch". */
8056 static struct cmd_list_element
*catch_cmdlist
;
8058 /* List of subcommands for "tcatch". */
8059 static struct cmd_list_element
*tcatch_cmdlist
;
8061 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
8062 lists, and pass some additional user data to the command function. */
8064 add_catch_command (char *name
, char *docstring
,
8065 void (*sfunc
) (char *args
, int from_tty
,
8066 struct cmd_list_element
*command
),
8067 void *user_data_catch
,
8068 void *user_data_tcatch
)
8070 struct cmd_list_element
*command
;
8072 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8074 set_cmd_sfunc (command
, sfunc
);
8075 set_cmd_context (command
, user_data_catch
);
8077 command
= add_cmd (name
, class_breakpoint
, NULL
, docstring
,
8079 set_cmd_sfunc (command
, sfunc
);
8080 set_cmd_context (command
, user_data_tcatch
);
8084 _initialize_breakpoint (void)
8086 static struct cmd_list_element
*breakpoint_set_cmdlist
;
8087 static struct cmd_list_element
*breakpoint_show_cmdlist
;
8088 struct cmd_list_element
*c
;
8090 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib
);
8092 breakpoint_chain
= 0;
8093 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
8094 before a breakpoint is set. */
8095 breakpoint_count
= 0;
8097 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
8098 Set ignore-count of breakpoint number N to COUNT.\n\
8099 Usage is `ignore N COUNT'."));
8101 add_com_alias ("bc", "ignore", class_breakpoint
, 1);
8103 add_com ("commands", class_breakpoint
, commands_command
, _("\
8104 Set commands to be executed when a breakpoint is hit.\n\
8105 Give breakpoint number as argument after \"commands\".\n\
8106 With no argument, the targeted breakpoint is the last one set.\n\
8107 The commands themselves follow starting on the next line.\n\
8108 Type a line containing \"end\" to indicate the end of them.\n\
8109 Give \"silent\" as the first line to make the breakpoint silent;\n\
8110 then no output is printed when it is hit, except what the commands print."));
8112 add_com ("condition", class_breakpoint
, condition_command
, _("\
8113 Specify breakpoint number N to break only if COND is true.\n\
8114 Usage is `condition N COND', where N is an integer and COND is an\n\
8115 expression to be evaluated whenever breakpoint N is reached."));
8117 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
8118 Set a temporary breakpoint.\n\
8119 Like \"break\" except the breakpoint is only temporary,\n\
8120 so it will be deleted when hit. Equivalent to \"break\" followed\n\
8121 by using \"enable delete\" on the breakpoint number.\n\
8123 BREAK_ARGS_HELP ("tbreak")));
8124 set_cmd_completer (c
, location_completer
);
8126 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
8127 Set a hardware assisted breakpoint.\n\
8128 Like \"break\" except the breakpoint requires hardware support,\n\
8129 some target hardware may not have this support.\n\
8131 BREAK_ARGS_HELP ("hbreak")));
8132 set_cmd_completer (c
, location_completer
);
8134 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
8135 Set a temporary hardware assisted breakpoint.\n\
8136 Like \"hbreak\" except the breakpoint is only temporary,\n\
8137 so it will be deleted when hit.\n\
8139 BREAK_ARGS_HELP ("thbreak")));
8140 set_cmd_completer (c
, location_completer
);
8142 add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
8143 Enable some breakpoints.\n\
8144 Give breakpoint numbers (separated by spaces) as arguments.\n\
8145 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8146 This is used to cancel the effect of the \"disable\" command.\n\
8147 With a subcommand you can enable temporarily."),
8148 &enablelist
, "enable ", 1, &cmdlist
);
8150 add_com ("ab", class_breakpoint
, enable_command
, _("\
8151 Enable some breakpoints.\n\
8152 Give breakpoint numbers (separated by spaces) as arguments.\n\
8153 With no subcommand, breakpoints are enabled until you command otherwise.\n\
8154 This is used to cancel the effect of the \"disable\" command.\n\
8155 With a subcommand you can enable temporarily."));
8157 add_com_alias ("en", "enable", class_breakpoint
, 1);
8159 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
8160 Enable some breakpoints.\n\
8161 Give breakpoint numbers (separated by spaces) as arguments.\n\
8162 This is used to cancel the effect of the \"disable\" command.\n\
8163 May be abbreviated to simply \"enable\".\n"),
8164 &enablebreaklist
, "enable breakpoints ", 1, &enablelist
);
8166 add_cmd ("once", no_class
, enable_once_command
, _("\
8167 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8168 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8171 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8172 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8173 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8176 add_cmd ("delete", no_class
, enable_delete_command
, _("\
8177 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
8178 If a breakpoint is hit while enabled in this fashion, it is deleted."),
8181 add_cmd ("once", no_class
, enable_once_command
, _("\
8182 Enable breakpoints for one hit. Give breakpoint numbers.\n\
8183 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
8186 add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
8187 Disable some breakpoints.\n\
8188 Arguments are breakpoint numbers with spaces in between.\n\
8189 To disable all breakpoints, give no argument.\n\
8190 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
8191 &disablelist
, "disable ", 1, &cmdlist
);
8192 add_com_alias ("dis", "disable", class_breakpoint
, 1);
8193 add_com_alias ("disa", "disable", class_breakpoint
, 1);
8195 add_com ("sb", class_breakpoint
, disable_command
, _("\
8196 Disable some breakpoints.\n\
8197 Arguments are breakpoint numbers with spaces in between.\n\
8198 To disable all breakpoints, give no argument.\n\
8199 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
8201 add_cmd ("breakpoints", class_alias
, disable_command
, _("\
8202 Disable some breakpoints.\n\
8203 Arguments are breakpoint numbers with spaces in between.\n\
8204 To disable all breakpoints, give no argument.\n\
8205 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
8206 This command may be abbreviated \"disable\"."),
8209 add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
8210 Delete some breakpoints or auto-display expressions.\n\
8211 Arguments are breakpoint numbers with spaces in between.\n\
8212 To delete all breakpoints, give no argument.\n\
8214 Also a prefix command for deletion of other GDB objects.\n\
8215 The \"unset\" command is also an alias for \"delete\"."),
8216 &deletelist
, "delete ", 1, &cmdlist
);
8217 add_com_alias ("d", "delete", class_breakpoint
, 1);
8218 add_com_alias ("del", "delete", class_breakpoint
, 1);
8220 add_com ("db", class_breakpoint
, delete_command
, _("\
8221 Delete some breakpoints.\n\
8222 Arguments are breakpoint numbers with spaces in between.\n\
8223 To delete all breakpoints, give no argument.\n"));
8225 add_cmd ("breakpoints", class_alias
, delete_command
, _("\
8226 Delete some breakpoints or auto-display expressions.\n\
8227 Arguments are breakpoint numbers with spaces in between.\n\
8228 To delete all breakpoints, give no argument.\n\
8229 This command may be abbreviated \"delete\"."),
8232 add_com ("clear", class_breakpoint
, clear_command
, _("\
8233 Clear breakpoint at specified line or function.\n\
8234 Argument may be line number, function name, or \"*\" and an address.\n\
8235 If line number is specified, all breakpoints in that line are cleared.\n\
8236 If function is specified, breakpoints at beginning of function are cleared.\n\
8237 If an address is specified, breakpoints at that address are cleared.\n\
8239 With no argument, clears all breakpoints in the line that the selected frame\n\
8242 See also the \"delete\" command which clears breakpoints by number."));
8244 c
= add_com ("break", class_breakpoint
, break_command
, _("\
8245 Set breakpoint at specified line or function.\n"
8246 BREAK_ARGS_HELP ("break")));
8247 set_cmd_completer (c
, location_completer
);
8249 add_com_alias ("b", "break", class_run
, 1);
8250 add_com_alias ("br", "break", class_run
, 1);
8251 add_com_alias ("bre", "break", class_run
, 1);
8252 add_com_alias ("brea", "break", class_run
, 1);
8256 add_com_alias ("ba", "break", class_breakpoint
, 1);
8257 add_com_alias ("bu", "ubreak", class_breakpoint
, 1);
8262 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
8263 Break in function/address or break at a line in the current file."),
8264 &stoplist
, "stop ", 1, &cmdlist
);
8265 add_cmd ("in", class_breakpoint
, stopin_command
,
8266 _("Break in function or address."), &stoplist
);
8267 add_cmd ("at", class_breakpoint
, stopat_command
,
8268 _("Break at a line in the current file."), &stoplist
);
8269 add_com ("status", class_info
, breakpoints_info
, _("\
8270 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8271 The \"Type\" column indicates one of:\n\
8272 \tbreakpoint - normal breakpoint\n\
8273 \twatchpoint - watchpoint\n\
8274 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8275 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8276 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8277 address and file/line number respectively.\n\
8279 Convenience variable \"$_\" and default examine address for \"x\"\n\
8280 are set to the address of the last breakpoint listed unless the command\n\
8281 is prefixed with \"server \".\n\n\
8282 Convenience variable \"$bpnum\" contains the number of the last\n\
8286 add_info ("breakpoints", breakpoints_info
, _("\
8287 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8288 The \"Type\" column indicates one of:\n\
8289 \tbreakpoint - normal breakpoint\n\
8290 \twatchpoint - watchpoint\n\
8291 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8292 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8293 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8294 address and file/line number respectively.\n\
8296 Convenience variable \"$_\" and default examine address for \"x\"\n\
8297 are set to the address of the last breakpoint listed unless the command\n\
8298 is prefixed with \"server \".\n\n\
8299 Convenience variable \"$bpnum\" contains the number of the last\n\
8303 add_com ("lb", class_breakpoint
, breakpoints_info
, _("\
8304 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
8305 The \"Type\" column indicates one of:\n\
8306 \tbreakpoint - normal breakpoint\n\
8307 \twatchpoint - watchpoint\n\
8308 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8309 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8310 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8311 address and file/line number respectively.\n\
8313 Convenience variable \"$_\" and default examine address for \"x\"\n\
8314 are set to the address of the last breakpoint listed unless the command\n\
8315 is prefixed with \"server \".\n\n\
8316 Convenience variable \"$bpnum\" contains the number of the last\n\
8319 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
8320 Status of all breakpoints, or breakpoint number NUMBER.\n\
8321 The \"Type\" column indicates one of:\n\
8322 \tbreakpoint - normal breakpoint\n\
8323 \twatchpoint - watchpoint\n\
8324 \tlongjmp - internal breakpoint used to step through longjmp()\n\
8325 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
8326 \tuntil - internal breakpoint used by the \"until\" command\n\
8327 \tfinish - internal breakpoint used by the \"finish\" command\n\
8328 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
8329 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
8330 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
8331 address and file/line number respectively.\n\
8333 Convenience variable \"$_\" and default examine address for \"x\"\n\
8334 are set to the address of the last breakpoint listed unless the command\n\
8335 is prefixed with \"server \".\n\n\
8336 Convenience variable \"$bpnum\" contains the number of the last\n\
8338 &maintenanceinfolist
);
8340 add_prefix_cmd ("catch", class_breakpoint
, catch_command
, _("\
8341 Set catchpoints to catch events."),
8342 &catch_cmdlist
, "catch ",
8343 0/*allow-unknown*/, &cmdlist
);
8345 add_prefix_cmd ("tcatch", class_breakpoint
, tcatch_command
, _("\
8346 Set temporary catchpoints to catch events."),
8347 &tcatch_cmdlist
, "tcatch ",
8348 0/*allow-unknown*/, &cmdlist
);
8350 /* Add catch and tcatch sub-commands. */
8351 add_catch_command ("catch", _("\
8352 Catch an exception, when caught.\n\
8353 With an argument, catch only exceptions with the given name."),
8354 catch_catch_command
,
8357 add_catch_command ("throw", _("\
8358 Catch an exception, when thrown.\n\
8359 With an argument, catch only exceptions with the given name."),
8360 catch_throw_command
,
8363 add_catch_command ("fork", _("Catch calls to fork."),
8364 catch_fork_command_1
,
8365 (void *) (uintptr_t) catch_fork_permanent
,
8366 (void *) (uintptr_t) catch_fork_temporary
);
8367 add_catch_command ("vfork", _("Catch calls to vfork."),
8368 catch_fork_command_1
,
8369 (void *) (uintptr_t) catch_vfork_permanent
,
8370 (void *) (uintptr_t) catch_vfork_temporary
);
8371 add_catch_command ("exec", _("Catch calls to exec."),
8372 catch_exec_command_1
,
8375 add_catch_command ("exception", _("\
8376 Catch Ada exceptions, when raised.\n\
8377 With an argument, catch only exceptions with the given name."),
8378 catch_ada_exception_command
,
8381 add_catch_command ("assert", _("\
8382 Catch failed Ada assertions, when raised.\n\
8383 With an argument, catch only exceptions with the given name."),
8384 catch_assert_command
,
8388 c
= add_com ("watch", class_breakpoint
, watch_command
, _("\
8389 Set a watchpoint for an expression.\n\
8390 A watchpoint stops execution of your program whenever the value of\n\
8391 an expression changes."));
8392 set_cmd_completer (c
, expression_completer
);
8394 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
, _("\
8395 Set a read watchpoint for an expression.\n\
8396 A watchpoint stops execution of your program whenever the value of\n\
8397 an expression is read."));
8398 set_cmd_completer (c
, expression_completer
);
8400 c
= add_com ("awatch", class_breakpoint
, awatch_command
, _("\
8401 Set a watchpoint for an expression.\n\
8402 A watchpoint stops execution of your program whenever the value of\n\
8403 an expression is either read or written."));
8404 set_cmd_completer (c
, expression_completer
);
8406 add_info ("watchpoints", breakpoints_info
,
8407 _("Synonym for ``info breakpoints''."));
8410 /* XXX: cagney/2005-02-23: This should be a boolean, and should
8411 respond to changes - contrary to the description. */
8412 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
8413 &can_use_hw_watchpoints
, _("\
8414 Set debugger's willingness to use watchpoint hardware."), _("\
8415 Show debugger's willingness to use watchpoint hardware."), _("\
8416 If zero, gdb will not use hardware for new watchpoints, even if\n\
8417 such is available. (However, any hardware watchpoints that were\n\
8418 created before setting this to nonzero, will continue to use watchpoint\n\
8421 show_can_use_hw_watchpoints
,
8422 &setlist
, &showlist
);
8424 can_use_hw_watchpoints
= 1;
8426 add_prefix_cmd ("breakpoint", class_maintenance
, set_breakpoint_cmd
, _("\
8427 Breakpoint specific settings\n\
8428 Configure various breakpoint-specific variables such as\n\
8429 pending breakpoint behavior"),
8430 &breakpoint_set_cmdlist
, "set breakpoint ",
8431 0/*allow-unknown*/, &setlist
);
8432 add_prefix_cmd ("breakpoint", class_maintenance
, show_breakpoint_cmd
, _("\
8433 Breakpoint specific settings\n\
8434 Configure various breakpoint-specific variables such as\n\
8435 pending breakpoint behavior"),
8436 &breakpoint_show_cmdlist
, "show breakpoint ",
8437 0/*allow-unknown*/, &showlist
);
8439 add_setshow_auto_boolean_cmd ("pending", no_class
,
8440 &pending_break_support
, _("\
8441 Set debugger's behavior regarding pending breakpoints."), _("\
8442 Show debugger's behavior regarding pending breakpoints."), _("\
8443 If on, an unrecognized breakpoint location will cause gdb to create a\n\
8444 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
8445 an error. If auto, an unrecognized breakpoint location results in a\n\
8446 user-query to see if a pending breakpoint should be created."),
8448 show_pending_break_support
,
8449 &breakpoint_set_cmdlist
,
8450 &breakpoint_show_cmdlist
);
8452 pending_break_support
= AUTO_BOOLEAN_AUTO
;
8454 add_setshow_boolean_cmd ("auto-hw", no_class
,
8455 &automatic_hardware_breakpoints
, _("\
8456 Set automatic usage of hardware breakpoints."), _("\
8457 Show automatic usage of hardware breakpoints."), _("\
8458 If set, the debugger will automatically use hardware breakpoints for\n\
8459 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
8460 a warning will be emitted for such breakpoints."),
8462 show_automatic_hardware_breakpoints
,
8463 &breakpoint_set_cmdlist
,
8464 &breakpoint_show_cmdlist
);
8466 add_setshow_enum_cmd ("always-inserted", class_support
,
8467 always_inserted_enums
, &always_inserted_mode
, _("\
8468 Set mode for inserting breakpoints."), _("\
8469 Show mode for inserting breakpoints."), _("\
8470 When this mode is off, breakpoints are inserted in inferior when it is\n\
8471 resumed, and removed when execution stops. When this mode is on,\n\
8472 breakpoints are inserted immediately and removed only when the user\n\
8473 deletes the breakpoint. When this mode is auto (which is the default),\n\
8474 the behaviour depends on the non-stop setting (see help set non-stop).\n\
8475 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
8476 behaves as if always-inserted mode is on; if gdb is controlling the\n\
8477 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
8479 &show_always_inserted_mode
,
8480 &breakpoint_set_cmdlist
,
8481 &breakpoint_show_cmdlist
);
8483 automatic_hardware_breakpoints
= 1;