1 /* Everything about breakpoints, for GDB.
2
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6
7 This file is part of GDB.
8
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.
13
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.
18
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/>. */
21
22 #include "defs.h"
23 #include "arch-utils.h"
24 #include <ctype.h>
25 #include "hashtab.h"
26 #include "symtab.h"
27 #include "frame.h"
28 #include "breakpoint.h"
29 #include "tracepoint.h"
30 #include "gdbtypes.h"
31 #include "expression.h"
32 #include "gdbcore.h"
33 #include "gdbcmd.h"
34 #include "value.h"
35 #include "command.h"
36 #include "inferior.h"
37 #include "gdbthread.h"
38 #include "target.h"
39 #include "language.h"
40 #include "gdb_string.h"
41 #include "demangle.h"
42 #include "filenames.h"
43 #include "annotate.h"
44 #include "symfile.h"
45 #include "objfiles.h"
46 #include "source.h"
47 #include "linespec.h"
48 #include "completer.h"
49 #include "gdb.h"
50 #include "ui-out.h"
51 #include "cli/cli-script.h"
52 #include "gdb_assert.h"
53 #include "block.h"
54 #include "solib.h"
55 #include "solist.h"
56 #include "observer.h"
57 #include "exceptions.h"
58 #include "memattr.h"
59 #include "ada-lang.h"
60 #include "top.h"
61 #include "wrapper.h"
62 #include "valprint.h"
63 #include "jit.h"
64 #include "xml-syscall.h"
65 #include "parser-defs.h"
66 #include "cli/cli-utils.h"
67
68 /* readline include files */
69 #include "readline/readline.h"
70 #include "readline/history.h"
71
72 /* readline defines this. */
73 #undef savestring
74
75 #include "mi/mi-common.h"
76 #include "python/python.h"
77
78 /* Arguments to pass as context to some catch command handlers. */
79 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
80 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
81
82 /* Prototypes for local functions. */
83
84 static void enable_delete_command (char *, int);
85
86 static void enable_once_command (char *, int);
87
88 static void disable_command (char *, int);
89
90 static void enable_command (char *, int);
91
92 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint *,
93 void *),
94 void *);
95
96 static void ignore_command (char *, int);
97
98 static int breakpoint_re_set_one (void *);
99
100 static void clear_command (char *, int);
101
102 static void catch_command (char *, int);
103
104 static int can_use_hardware_watchpoint (struct value *, int);
105
106 static void break_command_1 (char *, int, int);
107
108 static void mention (struct breakpoint *);
109
110 /* This function is used in gdbtk sources and thus can not be made
111 static. */
112 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
113 struct symtab_and_line,
114 enum bptype);
115
116 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
117
118 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
119 CORE_ADDR bpaddr,
120 enum bptype bptype);
121
122 static void describe_other_breakpoints (struct gdbarch *,
123 struct program_space *, CORE_ADDR,
124 struct obj_section *, int);
125
126 static int breakpoint_address_match (struct address_space *aspace1,
127 CORE_ADDR addr1,
128 struct address_space *aspace2,
129 CORE_ADDR addr2);
130
131 static int watchpoint_locations_match (struct bp_location *loc1,
132 struct bp_location *loc2);
133
134 static int breakpoint_location_address_match (struct bp_location *bl,
135 struct address_space *aspace,
136 CORE_ADDR addr);
137
138 static void breakpoints_info (char *, int);
139
140 static void watchpoints_info (char *, int);
141
142 static int breakpoint_1 (char *, int,
143 int (*) (const struct breakpoint *));
144
145 static int breakpoint_cond_eval (void *);
146
147 static void cleanup_executing_breakpoints (void *);
148
149 static void commands_command (char *, int);
150
151 static void condition_command (char *, int);
152
153 typedef enum
154 {
155 mark_inserted,
156 mark_uninserted
157 }
158 insertion_state_t;
159
160 static int remove_breakpoint (struct bp_location *, insertion_state_t);
161 static int remove_breakpoint_1 (struct bp_location *, insertion_state_t);
162
163 static enum print_stop_action print_it_typical (bpstat);
164
165 static enum print_stop_action print_bp_stop_message (bpstat bs);
166
167 static int watchpoint_check (void *);
168
169 static void maintenance_info_breakpoints (char *, int);
170
171 static int hw_breakpoint_used_count (void);
172
173 static int hw_watchpoint_used_count (enum bptype, int *);
174
175 static void hbreak_command (char *, int);
176
177 static void thbreak_command (char *, int);
178
179 static void do_enable_breakpoint (struct breakpoint *, enum bpdisp);
180
181 static void stop_command (char *arg, int from_tty);
182
183 static void stopin_command (char *arg, int from_tty);
184
185 static void stopat_command (char *arg, int from_tty);
186
187 static char *ep_parse_optional_if_clause (char **arg);
188
189 static void catch_exception_command_1 (enum exception_event_kind ex_event,
190 char *arg, int tempflag, int from_tty);
191
192 static void tcatch_command (char *arg, int from_tty);
193
194 static void detach_single_step_breakpoints (void);
195
196 static int single_step_breakpoint_inserted_here_p (struct address_space *,
197 CORE_ADDR pc);
198
199 static void free_bp_location (struct bp_location *loc);
200 static void incref_bp_location (struct bp_location *loc);
201 static void decref_bp_location (struct bp_location **loc);
202
203 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
204
205 static void update_global_location_list (int);
206
207 static void update_global_location_list_nothrow (int);
208
209 static int is_hardware_watchpoint (const struct breakpoint *bpt);
210
211 static int is_watchpoint (const struct breakpoint *bpt);
212
213 static void insert_breakpoint_locations (void);
214
215 static int syscall_catchpoint_p (struct breakpoint *b);
216
217 static void tracepoints_info (char *, int);
218
219 static void delete_trace_command (char *, int);
220
221 static void enable_trace_command (char *, int);
222
223 static void disable_trace_command (char *, int);
224
225 static void trace_pass_command (char *, int);
226
227 /* Assuming we're creating a static tracepoint, does S look like a
228 static tracepoint marker spec ("-m MARKER_ID")? */
229 #define is_marker_spec(s) \
230 (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
231
232 /* A reference-counted struct command_line. This lets multiple
233 breakpoints share a single command list. */
234 struct counted_command_line
235 {
236 /* The reference count. */
237 int refc;
238
239 /* The command list. */
240 struct command_line *commands;
241 };
242
243 struct command_line *
breakpoint_commands(struct breakpoint * b)244 breakpoint_commands (struct breakpoint *b)
245 {
246 return b->commands ? b->commands->commands : NULL;
247 }
248
249 /* Flag indicating that a command has proceeded the inferior past the
250 current breakpoint. */
251
252 static int breakpoint_proceeded;
253
254 const char *
bpdisp_text(enum bpdisp disp)255 bpdisp_text (enum bpdisp disp)
256 {
257 /* NOTE: the following values are a part of MI protocol and
258 represent values of 'disp' field returned when inferior stops at
259 a breakpoint. */
260 static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
261
262 return bpdisps[(int) disp];
263 }
264
265 /* Prototypes for exported functions. */
266 /* If FALSE, gdb will not use hardware support for watchpoints, even
267 if such is available. */
268 static int can_use_hw_watchpoints;
269
270 static void
show_can_use_hw_watchpoints(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)271 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
272 struct cmd_list_element *c,
273 const char *value)
274 {
275 fprintf_filtered (file,
276 _("Debugger's willingness to use "
277 "watchpoint hardware is %s.\n"),
278 value);
279 }
280
281 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
282 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
283 for unrecognized breakpoint locations.
284 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
285 static enum auto_boolean pending_break_support;
286 static void
show_pending_break_support(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)287 show_pending_break_support (struct ui_file *file, int from_tty,
288 struct cmd_list_element *c,
289 const char *value)
290 {
291 fprintf_filtered (file,
292 _("Debugger's behavior regarding "
293 "pending breakpoints is %s.\n"),
294 value);
295 }
296
297 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
298 set with "break" but falling in read-only memory.
299 If 0, gdb will warn about such breakpoints, but won't automatically
300 use hardware breakpoints. */
301 static int automatic_hardware_breakpoints;
302 static void
show_automatic_hardware_breakpoints(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)303 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
304 struct cmd_list_element *c,
305 const char *value)
306 {
307 fprintf_filtered (file,
308 _("Automatic usage of hardware breakpoints is %s.\n"),
309 value);
310 }
311
312 /* If on, gdb will keep breakpoints inserted even as inferior is
313 stopped, and immediately insert any new breakpoints. If off, gdb
314 will insert breakpoints into inferior only when resuming it, and
315 will remove breakpoints upon stop. If auto, GDB will behave as ON
316 if in non-stop mode, and as OFF if all-stop mode.*/
317
318 static const char always_inserted_auto[] = "auto";
319 static const char always_inserted_on[] = "on";
320 static const char always_inserted_off[] = "off";
321 static const char *always_inserted_enums[] = {
322 always_inserted_auto,
323 always_inserted_off,
324 always_inserted_on,
325 NULL
326 };
327 static const char *always_inserted_mode = always_inserted_auto;
328 static void
show_always_inserted_mode(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)329 show_always_inserted_mode (struct ui_file *file, int from_tty,
330 struct cmd_list_element *c, const char *value)
331 {
332 if (always_inserted_mode == always_inserted_auto)
333 fprintf_filtered (file,
334 _("Always inserted breakpoint "
335 "mode is %s (currently %s).\n"),
336 value,
337 breakpoints_always_inserted_mode () ? "on" : "off");
338 else
339 fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
340 value);
341 }
342
343 int
breakpoints_always_inserted_mode(void)344 breakpoints_always_inserted_mode (void)
345 {
346 return (always_inserted_mode == always_inserted_on
347 || (always_inserted_mode == always_inserted_auto && non_stop));
348 }
349
350 void _initialize_breakpoint (void);
351
352 /* Are we executing breakpoint commands? */
353 static int executing_breakpoint_commands;
354
355 /* Are overlay event breakpoints enabled? */
356 static int overlay_events_enabled;
357
358 /* See description in breakpoint.h. */
359 int target_exact_watchpoints = 0;
360
361 /* Walk the following statement or block through all breakpoints.
362 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the
363 current breakpoint. */
364
365 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
366
367 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
368 for (B = breakpoint_chain; \
369 B ? (TMP=B->next, 1): 0; \
370 B = TMP)
371
372 /* Similar iterator for the low-level breakpoints. SAFE variant is
373 not provided so update_global_location_list must not be called
374 while executing the block of ALL_BP_LOCATIONS. */
375
376 #define ALL_BP_LOCATIONS(B,BP_TMP) \
377 for (BP_TMP = bp_location; \
378 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
379 BP_TMP++)
380
381 /* Iterator for tracepoints only. */
382
383 #define ALL_TRACEPOINTS(B) \
384 for (B = breakpoint_chain; B; B = B->next) \
385 if (is_tracepoint (B))
386
387 /* Chains of all breakpoints defined. */
388
389 struct breakpoint *breakpoint_chain;
390
391 /* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
392
393 static struct bp_location **bp_location;
394
395 /* Number of elements of BP_LOCATION. */
396
397 static unsigned bp_location_count;
398
399 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
400 ADDRESS for the current elements of BP_LOCATION which get a valid
401 result from bp_location_has_shadow. You can use it for roughly
402 limiting the subrange of BP_LOCATION to scan for shadow bytes for
403 an address you need to read. */
404
405 static CORE_ADDR bp_location_placed_address_before_address_max;
406
407 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
408 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
409 BP_LOCATION which get a valid result from bp_location_has_shadow.
410 You can use it for roughly limiting the subrange of BP_LOCATION to
411 scan for shadow bytes for an address you need to read. */
412
413 static CORE_ADDR bp_location_shadow_len_after_address_max;
414
415 /* The locations that no longer correspond to any breakpoint, unlinked
416 from bp_location array, but for which a hit may still be reported
417 by a target. */
418 VEC(bp_location_p) *moribund_locations = NULL;
419
420 /* Number of last breakpoint made. */
421
422 static int breakpoint_count;
423
424 /* The value of `breakpoint_count' before the last command that
425 created breakpoints. If the last (break-like) command created more
426 than one breakpoint, then the difference between BREAKPOINT_COUNT
427 and PREV_BREAKPOINT_COUNT is more than one. */
428 static int prev_breakpoint_count;
429
430 /* Number of last tracepoint made. */
431
432 static int tracepoint_count;
433
434 static struct cmd_list_element *breakpoint_set_cmdlist;
435 static struct cmd_list_element *breakpoint_show_cmdlist;
436 struct cmd_list_element *save_cmdlist;
437
438 /* Return whether a breakpoint is an active enabled breakpoint. */
439 static int
breakpoint_enabled(struct breakpoint * b)440 breakpoint_enabled (struct breakpoint *b)
441 {
442 return (b->enable_state == bp_enabled);
443 }
444
445 /* Set breakpoint count to NUM. */
446
447 static void
set_breakpoint_count(int num)448 set_breakpoint_count (int num)
449 {
450 prev_breakpoint_count = breakpoint_count;
451 breakpoint_count = num;
452 set_internalvar_integer (lookup_internalvar ("bpnum"), num);
453 }
454
455 /* Used by `start_rbreak_breakpoints' below, to record the current
456 breakpoint count before "rbreak" creates any breakpoint. */
457 static int rbreak_start_breakpoint_count;
458
459 /* Called at the start an "rbreak" command to record the first
460 breakpoint made. */
461
462 void
start_rbreak_breakpoints(void)463 start_rbreak_breakpoints (void)
464 {
465 rbreak_start_breakpoint_count = breakpoint_count;
466 }
467
468 /* Called at the end of an "rbreak" command to record the last
469 breakpoint made. */
470
471 void
end_rbreak_breakpoints(void)472 end_rbreak_breakpoints (void)
473 {
474 prev_breakpoint_count = rbreak_start_breakpoint_count;
475 }
476
477 /* Used in run_command to zero the hit count when a new run starts. */
478
479 void
clear_breakpoint_hit_counts(void)480 clear_breakpoint_hit_counts (void)
481 {
482 struct breakpoint *b;
483
484 ALL_BREAKPOINTS (b)
485 b->hit_count = 0;
486 }
487
488 /* Allocate a new counted_command_line with reference count of 1.
489 The new structure owns COMMANDS. */
490
491 static struct counted_command_line *
alloc_counted_command_line(struct command_line * commands)492 alloc_counted_command_line (struct command_line *commands)
493 {
494 struct counted_command_line *result
495 = xmalloc (sizeof (struct counted_command_line));
496
497 result->refc = 1;
498 result->commands = commands;
499 return result;
500 }
501
502 /* Increment reference count. This does nothing if CMD is NULL. */
503
504 static void
incref_counted_command_line(struct counted_command_line * cmd)505 incref_counted_command_line (struct counted_command_line *cmd)
506 {
507 if (cmd)
508 ++cmd->refc;
509 }
510
511 /* Decrement reference count. If the reference count reaches 0,
512 destroy the counted_command_line. Sets *CMDP to NULL. This does
513 nothing if *CMDP is NULL. */
514
515 static void
decref_counted_command_line(struct counted_command_line ** cmdp)516 decref_counted_command_line (struct counted_command_line **cmdp)
517 {
518 if (*cmdp)
519 {
520 if (--(*cmdp)->refc == 0)
521 {
522 free_command_lines (&(*cmdp)->commands);
523 xfree (*cmdp);
524 }
525 *cmdp = NULL;
526 }
527 }
528
529 /* A cleanup function that calls decref_counted_command_line. */
530
531 static void
do_cleanup_counted_command_line(void * arg)532 do_cleanup_counted_command_line (void *arg)
533 {
534 decref_counted_command_line (arg);
535 }
536
537 /* Create a cleanup that calls decref_counted_command_line on the
538 argument. */
539
540 static struct cleanup *
make_cleanup_decref_counted_command_line(struct counted_command_line ** cmdp)541 make_cleanup_decref_counted_command_line (struct counted_command_line **cmdp)
542 {
543 return make_cleanup (do_cleanup_counted_command_line, cmdp);
544 }
545
546 /* Default address, symtab and line to put a breakpoint at
547 for "break" command with no arg.
548 If default_breakpoint_valid is zero, the other three are
549 not valid, and "break" with no arg is an error.
550
551 This set by print_stack_frame, which calls set_default_breakpoint. */
552
553 int default_breakpoint_valid;
554 CORE_ADDR default_breakpoint_address;
555 struct symtab *default_breakpoint_symtab;
556 int default_breakpoint_line;
557 struct program_space *default_breakpoint_pspace;
558
559
560 /* Return the breakpoint with the specified number, or NULL
561 if the number does not refer to an existing breakpoint. */
562
563 struct breakpoint *
get_breakpoint(int num)564 get_breakpoint (int num)
565 {
566 struct breakpoint *b;
567
568 ALL_BREAKPOINTS (b)
569 if (b->number == num)
570 return b;
571
572 return NULL;
573 }
574
575
576
577 void
set_breakpoint_condition(struct breakpoint * b,char * exp,int from_tty)578 set_breakpoint_condition (struct breakpoint *b, char *exp,
579 int from_tty)
580 {
581 struct bp_location *loc = b->loc;
582
583 for (; loc; loc = loc->next)
584 {
585 xfree (loc->cond);
586 loc->cond = NULL;
587 }
588 xfree (b->cond_string);
589 b->cond_string = NULL;
590 xfree (b->cond_exp);
591 b->cond_exp = NULL;
592
593 if (*exp == 0)
594 {
595 if (from_tty)
596 printf_filtered (_("Breakpoint %d now unconditional.\n"), b->number);
597 }
598 else
599 {
600 char *arg = exp;
601
602 /* I don't know if it matters whether this is the string the user
603 typed in or the decompiled expression. */
604 b->cond_string = xstrdup (arg);
605 b->condition_not_parsed = 0;
606
607 if (is_watchpoint (b))
608 {
609 innermost_block = NULL;
610 arg = exp;
611 b->cond_exp = parse_exp_1 (&arg, 0, 0);
612 if (*arg)
613 error (_("Junk at end of expression"));
614 b->cond_exp_valid_block = innermost_block;
615 }
616 else
617 {
618 for (loc = b->loc; loc; loc = loc->next)
619 {
620 arg = exp;
621 loc->cond =
622 parse_exp_1 (&arg, block_for_pc (loc->address), 0);
623 if (*arg)
624 error (_("Junk at end of expression"));
625 }
626 }
627 }
628 breakpoints_changed ();
629 observer_notify_breakpoint_modified (b->number);
630 }
631
632 /* condition N EXP -- set break condition of breakpoint N to EXP. */
633
634 static void
condition_command(char * arg,int from_tty)635 condition_command (char *arg, int from_tty)
636 {
637 struct breakpoint *b;
638 char *p;
639 int bnum;
640
641 if (arg == 0)
642 error_no_arg (_("breakpoint number"));
643
644 p = arg;
645 bnum = get_number (&p);
646 if (bnum == 0)
647 error (_("Bad breakpoint argument: '%s'"), arg);
648
649 ALL_BREAKPOINTS (b)
650 if (b->number == bnum)
651 {
652 /* Check if this breakpoint has a Python object assigned to
653 it, and if it has a definition of the "stop"
654 method. This method and conditions entered into GDB from
655 the CLI are mutually exclusive. */
656 if (b->py_bp_object
657 && gdbpy_breakpoint_has_py_cond (b->py_bp_object))
658 error (_("Cannot set a condition where a Python 'stop' "
659 "method has been defined in the breakpoint."));
660 set_breakpoint_condition (b, p, from_tty);
661 return;
662 }
663
664 error (_("No breakpoint number %d."), bnum);
665 }
666
667 /* Check that COMMAND do not contain commands that are suitable
668 only for tracepoints and not suitable for ordinary breakpoints.
669 Throw if any such commands is found. */
670
671 static void
check_no_tracepoint_commands(struct command_line * commands)672 check_no_tracepoint_commands (struct command_line *commands)
673 {
674 struct command_line *c;
675
676 for (c = commands; c; c = c->next)
677 {
678 int i;
679
680 if (c->control_type == while_stepping_control)
681 error (_("The 'while-stepping' command can "
682 "only be used for tracepoints"));
683
684 for (i = 0; i < c->body_count; ++i)
685 check_no_tracepoint_commands ((c->body_list)[i]);
686
687 /* Not that command parsing removes leading whitespace and comment
688 lines and also empty lines. So, we only need to check for
689 command directly. */
690 if (strstr (c->line, "collect ") == c->line)
691 error (_("The 'collect' command can only be used for tracepoints"));
692
693 if (strstr (c->line, "teval ") == c->line)
694 error (_("The 'teval' command can only be used for tracepoints"));
695 }
696 }
697
698 /* Encapsulate tests for different types of tracepoints. */
699
700 int
is_tracepoint(const struct breakpoint * b)701 is_tracepoint (const struct breakpoint *b)
702 {
703 return (b->type == bp_tracepoint
704 || b->type == bp_fast_tracepoint
705 || b->type == bp_static_tracepoint);
706 }
707
708 /* A helper function that validsates that COMMANDS are valid for a
709 breakpoint. This function will throw an exception if a problem is
710 found. */
711
712 static void
validate_commands_for_breakpoint(struct breakpoint * b,struct command_line * commands)713 validate_commands_for_breakpoint (struct breakpoint *b,
714 struct command_line *commands)
715 {
716 if (is_tracepoint (b))
717 {
718 /* We need to verify that each top-level element of commands is
719 valid for tracepoints, that there's at most one
720 while-stepping element, and that while-stepping's body has
721 valid tracing commands excluding nested while-stepping. */
722 struct command_line *c;
723 struct command_line *while_stepping = 0;
724 for (c = commands; c; c = c->next)
725 {
726 if (c->control_type == while_stepping_control)
727 {
728 if (b->type == bp_fast_tracepoint)
729 error (_("The 'while-stepping' command "
730 "cannot be used for fast tracepoint"));
731 else if (b->type == bp_static_tracepoint)
732 error (_("The 'while-stepping' command "
733 "cannot be used for static tracepoint"));
734
735 if (while_stepping)
736 error (_("The 'while-stepping' command "
737 "can be used only once"));
738 else
739 while_stepping = c;
740 }
741 }
742 if (while_stepping)
743 {
744 struct command_line *c2;
745
746 gdb_assert (while_stepping->body_count == 1);
747 c2 = while_stepping->body_list[0];
748 for (; c2; c2 = c2->next)
749 {
750 if (c2->control_type == while_stepping_control)
751 error (_("The 'while-stepping' command cannot be nested"));
752 }
753 }
754 }
755 else
756 {
757 check_no_tracepoint_commands (commands);
758 }
759 }
760
761 /* Return a vector of all the static tracepoints set at ADDR. The
762 caller is responsible for releasing the vector. */
763
VEC(breakpoint_p)764 VEC(breakpoint_p) *
765 static_tracepoints_here (CORE_ADDR addr)
766 {
767 struct breakpoint *b;
768 VEC(breakpoint_p) *found = 0;
769 struct bp_location *loc;
770
771 ALL_BREAKPOINTS (b)
772 if (b->type == bp_static_tracepoint)
773 {
774 for (loc = b->loc; loc; loc = loc->next)
775 if (loc->address == addr)
776 VEC_safe_push(breakpoint_p, found, b);
777 }
778
779 return found;
780 }
781
782 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
783 validate that only allowed commands are included. */
784
785 void
breakpoint_set_commands(struct breakpoint * b,struct command_line * commands)786 breakpoint_set_commands (struct breakpoint *b,
787 struct command_line *commands)
788 {
789 validate_commands_for_breakpoint (b, commands);
790
791 decref_counted_command_line (&b->commands);
792 b->commands = alloc_counted_command_line (commands);
793 breakpoints_changed ();
794 observer_notify_breakpoint_modified (b->number);
795 }
796
797 /* Set the internal `silent' flag on the breakpoint. Note that this
798 is not the same as the "silent" that may appear in the breakpoint's
799 commands. */
800
801 void
breakpoint_set_silent(struct breakpoint * b,int silent)802 breakpoint_set_silent (struct breakpoint *b, int silent)
803 {
804 int old_silent = b->silent;
805
806 b->silent = silent;
807 if (old_silent != silent)
808 observer_notify_breakpoint_modified (b->number);
809 }
810
811 /* Set the thread for this breakpoint. If THREAD is -1, make the
812 breakpoint work for any thread. */
813
814 void
breakpoint_set_thread(struct breakpoint * b,int thread)815 breakpoint_set_thread (struct breakpoint *b, int thread)
816 {
817 int old_thread = b->thread;
818
819 b->thread = thread;
820 if (old_thread != thread)
821 observer_notify_breakpoint_modified (b->number);
822 }
823
824 /* Set the task for this breakpoint. If TASK is 0, make the
825 breakpoint work for any task. */
826
827 void
breakpoint_set_task(struct breakpoint * b,int task)828 breakpoint_set_task (struct breakpoint *b, int task)
829 {
830 int old_task = b->task;
831
832 b->task = task;
833 if (old_task != task)
834 observer_notify_breakpoint_modified (b->number);
835 }
836
837 void
check_tracepoint_command(char * line,void * closure)838 check_tracepoint_command (char *line, void *closure)
839 {
840 struct breakpoint *b = closure;
841
842 validate_actionline (&line, b);
843 }
844
845 /* A structure used to pass information through
846 map_breakpoint_numbers. */
847
848 struct commands_info
849 {
850 /* True if the command was typed at a tty. */
851 int from_tty;
852
853 /* The breakpoint range spec. */
854 char *arg;
855
856 /* Non-NULL if the body of the commands are being read from this
857 already-parsed command. */
858 struct command_line *control;
859
860 /* The command lines read from the user, or NULL if they have not
861 yet been read. */
862 struct counted_command_line *cmd;
863 };
864
865 /* A callback for map_breakpoint_numbers that sets the commands for
866 commands_command. */
867
868 static void
do_map_commands_command(struct breakpoint * b,void * data)869 do_map_commands_command (struct breakpoint *b, void *data)
870 {
871 struct commands_info *info = data;
872
873 if (info->cmd == NULL)
874 {
875 struct command_line *l;
876
877 if (info->control != NULL)
878 l = copy_command_lines (info->control->body_list[0]);
879 else
880 {
881 struct cleanup *old_chain;
882 char *str;
883
884 str = xstrprintf (_("Type commands for breakpoint(s) "
885 "%s, one per line."),
886 info->arg);
887
888 old_chain = make_cleanup (xfree, str);
889
890 l = read_command_lines (str,
891 info->from_tty, 1,
892 (is_tracepoint (b)
893 ? check_tracepoint_command : 0),
894 b);
895
896 do_cleanups (old_chain);
897 }
898
899 info->cmd = alloc_counted_command_line (l);
900 }
901
902 /* If a breakpoint was on the list more than once, we don't need to
903 do anything. */
904 if (b->commands != info->cmd)
905 {
906 validate_commands_for_breakpoint (b, info->cmd->commands);
907 incref_counted_command_line (info->cmd);
908 decref_counted_command_line (&b->commands);
909 b->commands = info->cmd;
910 breakpoints_changed ();
911 observer_notify_breakpoint_modified (b->number);
912 }
913 }
914
915 static void
commands_command_1(char * arg,int from_tty,struct command_line * control)916 commands_command_1 (char *arg, int from_tty,
917 struct command_line *control)
918 {
919 struct cleanup *cleanups;
920 struct commands_info info;
921
922 info.from_tty = from_tty;
923 info.control = control;
924 info.cmd = NULL;
925 /* If we read command lines from the user, then `info' will hold an
926 extra reference to the commands that we must clean up. */
927 cleanups = make_cleanup_decref_counted_command_line (&info.cmd);
928
929 if (arg == NULL || !*arg)
930 {
931 if (breakpoint_count - prev_breakpoint_count > 1)
932 arg = xstrprintf ("%d-%d", prev_breakpoint_count + 1,
933 breakpoint_count);
934 else if (breakpoint_count > 0)
935 arg = xstrprintf ("%d", breakpoint_count);
936 else
937 {
938 /* So that we don't try to free the incoming non-NULL
939 argument in the cleanup below. Mapping breakpoint
940 numbers will fail in this case. */
941 arg = NULL;
942 }
943 }
944 else
945 /* The command loop has some static state, so we need to preserve
946 our argument. */
947 arg = xstrdup (arg);
948
949 if (arg != NULL)
950 make_cleanup (xfree, arg);
951
952 info.arg = arg;
953
954 map_breakpoint_numbers (arg, do_map_commands_command, &info);
955
956 if (info.cmd == NULL)
957 error (_("No breakpoints specified."));
958
959 do_cleanups (cleanups);
960 }
961
962 static void
commands_command(char * arg,int from_tty)963 commands_command (char *arg, int from_tty)
964 {
965 commands_command_1 (arg, from_tty, NULL);
966 }
967
968 /* Like commands_command, but instead of reading the commands from
969 input stream, takes them from an already parsed command structure.
970
971 This is used by cli-script.c to DTRT with breakpoint commands
972 that are part of if and while bodies. */
973 enum command_control_type
commands_from_control_command(char * arg,struct command_line * cmd)974 commands_from_control_command (char *arg, struct command_line *cmd)
975 {
976 commands_command_1 (arg, 0, cmd);
977 return simple_control;
978 }
979
980 /* Return non-zero if BL->TARGET_INFO contains valid information. */
981
982 static int
bp_location_has_shadow(struct bp_location * bl)983 bp_location_has_shadow (struct bp_location *bl)
984 {
985 if (bl->loc_type != bp_loc_software_breakpoint)
986 return 0;
987 if (!bl->inserted)
988 return 0;
989 if (bl->target_info.shadow_len == 0)
990 /* bp isn't valid, or doesn't shadow memory. */
991 return 0;
992 return 1;
993 }
994
995 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
996 by replacing any memory breakpoints with their shadowed contents.
997
998 The range of shadowed area by each bp_location is:
999 bl->address - bp_location_placed_address_before_address_max
1000 up to bl->address + bp_location_shadow_len_after_address_max
1001 The range we were requested to resolve shadows for is:
1002 memaddr ... memaddr + len
1003 Thus the safe cutoff boundaries for performance optimization are
1004 memaddr + len <= (bl->address
1005 - bp_location_placed_address_before_address_max)
1006 and:
1007 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
1008
1009 void
breakpoint_restore_shadows(gdb_byte * buf,ULONGEST memaddr,LONGEST len)1010 breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, LONGEST len)
1011 {
1012 /* Left boundary, right boundary and median element of our binary
1013 search. */
1014 unsigned bc_l, bc_r, bc;
1015
1016 /* Find BC_L which is a leftmost element which may affect BUF
1017 content. It is safe to report lower value but a failure to
1018 report higher one. */
1019
1020 bc_l = 0;
1021 bc_r = bp_location_count;
1022 while (bc_l + 1 < bc_r)
1023 {
1024 struct bp_location *bl;
1025
1026 bc = (bc_l + bc_r) / 2;
1027 bl = bp_location[bc];
1028
1029 /* Check first BL->ADDRESS will not overflow due to the added
1030 constant. Then advance the left boundary only if we are sure
1031 the BC element can in no way affect the BUF content (MEMADDR
1032 to MEMADDR + LEN range).
1033
1034 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1035 offset so that we cannot miss a breakpoint with its shadow
1036 range tail still reaching MEMADDR. */
1037
1038 if ((bl->address + bp_location_shadow_len_after_address_max
1039 >= bl->address)
1040 && (bl->address + bp_location_shadow_len_after_address_max
1041 <= memaddr))
1042 bc_l = bc;
1043 else
1044 bc_r = bc;
1045 }
1046
1047 /* Due to the binary search above, we need to make sure we pick the
1048 first location that's at BC_L's address. E.g., if there are
1049 multiple locations at the same address, BC_L may end up pointing
1050 at a duplicate location, and miss the "master"/"inserted"
1051 location. Say, given locations L1, L2 and L3 at addresses A and
1052 B:
1053
1054 L1@A, L2@A, L3@B, ...
1055
1056 BC_L could end up pointing at location L2, while the "master"
1057 location could be L1. Since the `loc->inserted' flag is only set
1058 on "master" locations, we'd forget to restore the shadow of L1
1059 and L2. */
1060 while (bc_l > 0
1061 && bp_location[bc_l]->address == bp_location[bc_l - 1]->address)
1062 bc_l--;
1063
1064 /* Now do full processing of the found relevant range of elements. */
1065
1066 for (bc = bc_l; bc < bp_location_count; bc++)
1067 {
1068 struct bp_location *bl = bp_location[bc];
1069 CORE_ADDR bp_addr = 0;
1070 int bp_size = 0;
1071 int bptoffset = 0;
1072
1073 /* bp_location array has BL->OWNER always non-NULL. */
1074 if (bl->owner->type == bp_none)
1075 warning (_("reading through apparently deleted breakpoint #%d?"),
1076 bl->owner->number);
1077
1078 /* Performance optimization: any futher element can no longer affect BUF
1079 content. */
1080
1081 if (bl->address >= bp_location_placed_address_before_address_max
1082 && memaddr + len <= (bl->address
1083 - bp_location_placed_address_before_address_max))
1084 break;
1085
1086 if (!bp_location_has_shadow (bl))
1087 continue;
1088 if (!breakpoint_address_match (bl->target_info.placed_address_space, 0,
1089 current_program_space->aspace, 0))
1090 continue;
1091
1092 /* Addresses and length of the part of the breakpoint that
1093 we need to copy. */
1094 bp_addr = bl->target_info.placed_address;
1095 bp_size = bl->target_info.shadow_len;
1096
1097 if (bp_addr + bp_size <= memaddr)
1098 /* The breakpoint is entirely before the chunk of memory we
1099 are reading. */
1100 continue;
1101
1102 if (bp_addr >= memaddr + len)
1103 /* The breakpoint is entirely after the chunk of memory we are
1104 reading. */
1105 continue;
1106
1107 /* Offset within shadow_contents. */
1108 if (bp_addr < memaddr)
1109 {
1110 /* Only copy the second part of the breakpoint. */
1111 bp_size -= memaddr - bp_addr;
1112 bptoffset = memaddr - bp_addr;
1113 bp_addr = memaddr;
1114 }
1115
1116 if (bp_addr + bp_size > memaddr + len)
1117 {
1118 /* Only copy the first part of the breakpoint. */
1119 bp_size -= (bp_addr + bp_size) - (memaddr + len);
1120 }
1121
1122 memcpy (buf + bp_addr - memaddr,
1123 bl->target_info.shadow_contents + bptoffset, bp_size);
1124 }
1125 }
1126
1127
1128 /* Return true if BPT is of any hardware watchpoint kind. */
1129
1130 static int
is_hardware_watchpoint(const struct breakpoint * bpt)1131 is_hardware_watchpoint (const struct breakpoint *bpt)
1132 {
1133 return (bpt->type == bp_hardware_watchpoint
1134 || bpt->type == bp_read_watchpoint
1135 || bpt->type == bp_access_watchpoint);
1136 }
1137
1138 /* Return true if BPT is of any watchpoint kind, hardware or
1139 software. */
1140
1141 static int
is_watchpoint(const struct breakpoint * bpt)1142 is_watchpoint (const struct breakpoint *bpt)
1143 {
1144 return (is_hardware_watchpoint (bpt)
1145 || bpt->type == bp_watchpoint);
1146 }
1147
1148 /* Assuming that B is a watchpoint: returns true if the current thread
1149 and its running state are safe to evaluate or update watchpoint B.
1150 Watchpoints on local expressions need to be evaluated in the
1151 context of the thread that was current when the watchpoint was
1152 created, and, that thread needs to be stopped to be able to select
1153 the correct frame context. Watchpoints on global expressions can
1154 be evaluated on any thread, and in any state. It is presently left
1155 to the target allowing memory accesses when threads are
1156 running. */
1157
1158 static int
watchpoint_in_thread_scope(struct breakpoint * b)1159 watchpoint_in_thread_scope (struct breakpoint *b)
1160 {
1161 return (ptid_equal (b->watchpoint_thread, null_ptid)
1162 || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1163 && !is_executing (inferior_ptid)));
1164 }
1165
1166 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1167 associated bp_watchpoint_scope breakpoint. */
1168
1169 static void
watchpoint_del_at_next_stop(struct breakpoint * b)1170 watchpoint_del_at_next_stop (struct breakpoint *b)
1171 {
1172 gdb_assert (is_watchpoint (b));
1173
1174 if (b->related_breakpoint != b)
1175 {
1176 gdb_assert (b->related_breakpoint->type == bp_watchpoint_scope);
1177 gdb_assert (b->related_breakpoint->related_breakpoint == b);
1178 b->related_breakpoint->disposition = disp_del_at_next_stop;
1179 b->related_breakpoint->related_breakpoint = b->related_breakpoint;
1180 b->related_breakpoint = b;
1181 }
1182 b->disposition = disp_del_at_next_stop;
1183 }
1184
1185 /* Assuming that B is a watchpoint:
1186 - Reparse watchpoint expression, if REPARSE is non-zero
1187 - Evaluate expression and store the result in B->val
1188 - Evaluate the condition if there is one, and store the result
1189 in b->loc->cond.
1190 - Update the list of values that must be watched in B->loc.
1191
1192 If the watchpoint disposition is disp_del_at_next_stop, then do
1193 nothing. If this is local watchpoint that is out of scope, delete
1194 it.
1195
1196 Even with `set breakpoint always-inserted on' the watchpoints are
1197 removed + inserted on each stop here. Normal breakpoints must
1198 never be removed because they might be missed by a running thread
1199 when debugging in non-stop mode. On the other hand, hardware
1200 watchpoints (is_hardware_watchpoint; processed here) are specific
1201 to each LWP since they are stored in each LWP's hardware debug
1202 registers. Therefore, such LWP must be stopped first in order to
1203 be able to modify its hardware watchpoints.
1204
1205 Hardware watchpoints must be reset exactly once after being
1206 presented to the user. It cannot be done sooner, because it would
1207 reset the data used to present the watchpoint hit to the user. And
1208 it must not be done later because it could display the same single
1209 watchpoint hit during multiple GDB stops. Note that the latter is
1210 relevant only to the hardware watchpoint types bp_read_watchpoint
1211 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1212 not user-visible - its hit is suppressed if the memory content has
1213 not changed.
1214
1215 The following constraints influence the location where we can reset
1216 hardware watchpoints:
1217
1218 * target_stopped_by_watchpoint and target_stopped_data_address are
1219 called several times when GDB stops.
1220
1221 [linux]
1222 * Multiple hardware watchpoints can be hit at the same time,
1223 causing GDB to stop. GDB only presents one hardware watchpoint
1224 hit at a time as the reason for stopping, and all the other hits
1225 are presented later, one after the other, each time the user
1226 requests the execution to be resumed. Execution is not resumed
1227 for the threads still having pending hit event stored in
1228 LWP_INFO->STATUS. While the watchpoint is already removed from
1229 the inferior on the first stop the thread hit event is kept being
1230 reported from its cached value by linux_nat_stopped_data_address
1231 until the real thread resume happens after the watchpoint gets
1232 presented and thus its LWP_INFO->STATUS gets reset.
1233
1234 Therefore the hardware watchpoint hit can get safely reset on the
1235 watchpoint removal from inferior. */
1236
1237 static void
update_watchpoint(struct breakpoint * b,int reparse)1238 update_watchpoint (struct breakpoint *b, int reparse)
1239 {
1240 int within_current_scope;
1241 struct frame_id saved_frame_id;
1242 int frame_saved;
1243
1244 gdb_assert (is_watchpoint (b));
1245
1246 /* If this is a local watchpoint, we only want to check if the
1247 watchpoint frame is in scope if the current thread is the thread
1248 that was used to create the watchpoint. */
1249 if (!watchpoint_in_thread_scope (b))
1250 return;
1251
1252 if (b->disposition == disp_del_at_next_stop)
1253 return;
1254
1255 frame_saved = 0;
1256
1257 /* Determine if the watchpoint is within scope. */
1258 if (b->exp_valid_block == NULL)
1259 within_current_scope = 1;
1260 else
1261 {
1262 struct frame_info *fi = get_current_frame ();
1263 struct gdbarch *frame_arch = get_frame_arch (fi);
1264 CORE_ADDR frame_pc = get_frame_pc (fi);
1265
1266 /* If we're in a function epilogue, unwinding may not work
1267 properly, so do not attempt to recreate locations at this
1268 point. See similar comments in watchpoint_check. */
1269 if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
1270 return;
1271
1272 /* Save the current frame's ID so we can restore it after
1273 evaluating the watchpoint expression on its own frame. */
1274 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1275 took a frame parameter, so that we didn't have to change the
1276 selected frame. */
1277 frame_saved = 1;
1278 saved_frame_id = get_frame_id (get_selected_frame (NULL));
1279
1280 fi = frame_find_by_id (b->watchpoint_frame);
1281 within_current_scope = (fi != NULL);
1282 if (within_current_scope)
1283 select_frame (fi);
1284 }
1285
1286 /* We don't free locations. They are stored in the bp_location array
1287 and update_global_location_list will eventually delete them and
1288 remove breakpoints if needed. */
1289 b->loc = NULL;
1290
1291 if (within_current_scope && reparse)
1292 {
1293 char *s;
1294
1295 if (b->exp)
1296 {
1297 xfree (b->exp);
1298 b->exp = NULL;
1299 }
1300 s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1301 b->exp = parse_exp_1 (&s, b->exp_valid_block, 0);
1302 /* If the meaning of expression itself changed, the old value is
1303 no longer relevant. We don't want to report a watchpoint hit
1304 to the user when the old value and the new value may actually
1305 be completely different objects. */
1306 value_free (b->val);
1307 b->val = NULL;
1308 b->val_valid = 0;
1309
1310 /* Note that unlike with breakpoints, the watchpoint's condition
1311 expression is stored in the breakpoint object, not in the
1312 locations (re)created below. */
1313 if (b->cond_string != NULL)
1314 {
1315 if (b->cond_exp != NULL)
1316 {
1317 xfree (b->cond_exp);
1318 b->cond_exp = NULL;
1319 }
1320
1321 s = b->cond_string;
1322 b->cond_exp = parse_exp_1 (&s, b->cond_exp_valid_block, 0);
1323 }
1324 }
1325
1326 /* If we failed to parse the expression, for example because
1327 it refers to a global variable in a not-yet-loaded shared library,
1328 don't try to insert watchpoint. We don't automatically delete
1329 such watchpoint, though, since failure to parse expression
1330 is different from out-of-scope watchpoint. */
1331 if ( !target_has_execution)
1332 {
1333 /* Without execution, memory can't change. No use to try and
1334 set watchpoint locations. The watchpoint will be reset when
1335 the target gains execution, through breakpoint_re_set. */
1336 }
1337 else if (within_current_scope && b->exp)
1338 {
1339 int pc = 0;
1340 struct value *val_chain, *v, *result, *next;
1341 struct program_space *frame_pspace;
1342
1343 fetch_subexp_value (b->exp, &pc, &v, &result, &val_chain);
1344
1345 /* Avoid setting b->val if it's already set. The meaning of
1346 b->val is 'the last value' user saw, and we should update
1347 it only if we reported that last value to user. As it
1348 happens, the code that reports it updates b->val directly. */
1349 if (!b->val_valid)
1350 {
1351 b->val = v;
1352 b->val_valid = 1;
1353 }
1354
1355 frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1356
1357 /* Look at each value on the value chain. */
1358 for (v = val_chain; v; v = value_next (v))
1359 {
1360 /* If it's a memory location, and GDB actually needed
1361 its contents to evaluate the expression, then we
1362 must watch it. If the first value returned is
1363 still lazy, that means an error occurred reading it;
1364 watch it anyway in case it becomes readable. */
1365 if (VALUE_LVAL (v) == lval_memory
1366 && (v == val_chain || ! value_lazy (v)))
1367 {
1368 struct type *vtype = check_typedef (value_type (v));
1369
1370 /* We only watch structs and arrays if user asked
1371 for it explicitly, never if they just happen to
1372 appear in the middle of some value chain. */
1373 if (v == result
1374 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1375 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1376 {
1377 CORE_ADDR addr;
1378 int len, type;
1379 struct bp_location *loc, **tmp;
1380
1381 addr = value_address (v);
1382 len = TYPE_LENGTH (value_type (v));
1383 type = hw_write;
1384 if (b->type == bp_read_watchpoint)
1385 type = hw_read;
1386 else if (b->type == bp_access_watchpoint)
1387 type = hw_access;
1388
1389 loc = allocate_bp_location (b);
1390 for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
1391 ;
1392 *tmp = loc;
1393 loc->gdbarch = get_type_arch (value_type (v));
1394
1395 loc->pspace = frame_pspace;
1396 loc->address = addr;
1397 loc->length = len;
1398 loc->watchpoint_type = type;
1399 }
1400 }
1401 }
1402
1403 /* Change the type of breakpoint between hardware assisted or
1404 an ordinary watchpoint depending on the hardware support
1405 and free hardware slots. REPARSE is set when the inferior
1406 is started. */
1407 if ((b->type == bp_watchpoint || b->type == bp_hardware_watchpoint)
1408 && reparse)
1409 {
1410 int reg_cnt;
1411 enum bp_loc_type loc_type;
1412 struct bp_location *bl;
1413
1414 reg_cnt = can_use_hardware_watchpoint (val_chain, b->exact);
1415
1416 if (reg_cnt)
1417 {
1418 int i, target_resources_ok, other_type_used;
1419 enum enable_state orig_enable_state;
1420
1421 /* We need to determine how many resources are already
1422 used for all other hardware watchpoints plus this one
1423 to see if we still have enough resources to also fit
1424 this watchpoint in as well. To guarantee the
1425 hw_watchpoint_used_count call below counts this
1426 watchpoint, make sure that it is marked as a hardware
1427 watchpoint. */
1428 b->type = bp_hardware_watchpoint;
1429
1430 /* hw_watchpoint_used_count ignores disabled watchpoints,
1431 and b might be disabled if we're being called from
1432 do_enable_breakpoint. */
1433 orig_enable_state = b->enable_state;
1434 b->enable_state = bp_enabled;
1435
1436 i = hw_watchpoint_used_count (bp_hardware_watchpoint,
1437 &other_type_used);
1438
1439 b->enable_state = orig_enable_state;
1440
1441 target_resources_ok = target_can_use_hardware_watchpoint
1442 (bp_hardware_watchpoint, i, other_type_used);
1443 if (target_resources_ok <= 0)
1444 b->type = bp_watchpoint;
1445 }
1446 else
1447 b->type = bp_watchpoint;
1448
1449 loc_type = (b->type == bp_watchpoint? bp_loc_other
1450 : bp_loc_hardware_watchpoint);
1451 for (bl = b->loc; bl; bl = bl->next)
1452 bl->loc_type = loc_type;
1453 }
1454
1455 for (v = val_chain; v; v = next)
1456 {
1457 next = value_next (v);
1458 if (v != b->val)
1459 value_free (v);
1460 }
1461
1462 /* If a software watchpoint is not watching any memory, then the
1463 above left it without any location set up. But,
1464 bpstat_stop_status requires a location to be able to report
1465 stops, so make sure there's at least a dummy one. */
1466 if (b->type == bp_watchpoint && b->loc == NULL)
1467 {
1468 b->loc = allocate_bp_location (b);
1469 b->loc->pspace = frame_pspace;
1470 b->loc->address = -1;
1471 b->loc->length = -1;
1472 b->loc->watchpoint_type = -1;
1473 }
1474 }
1475 else if (!within_current_scope)
1476 {
1477 printf_filtered (_("\
1478 Watchpoint %d deleted because the program has left the block\n\
1479 in which its expression is valid.\n"),
1480 b->number);
1481 watchpoint_del_at_next_stop (b);
1482 }
1483
1484 /* Restore the selected frame. */
1485 if (frame_saved)
1486 select_frame (frame_find_by_id (saved_frame_id));
1487 }
1488
1489
1490 /* Returns 1 iff breakpoint location should be
1491 inserted in the inferior. */
1492 static int
should_be_inserted(struct bp_location * bl)1493 should_be_inserted (struct bp_location *bl)
1494 {
1495 if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
1496 return 0;
1497
1498 if (bl->owner->disposition == disp_del_at_next_stop)
1499 return 0;
1500
1501 if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
1502 return 0;
1503
1504 /* This is set for example, when we're attached to the parent of a
1505 vfork, and have detached from the child. The child is running
1506 free, and we expect it to do an exec or exit, at which point the
1507 OS makes the parent schedulable again (and the target reports
1508 that the vfork is done). Until the child is done with the shared
1509 memory region, do not insert breakpoints in the parent, otherwise
1510 the child could still trip on the parent's breakpoints. Since
1511 the parent is blocked anyway, it won't miss any breakpoint. */
1512 if (bl->pspace->breakpoints_not_allowed)
1513 return 0;
1514
1515 /* Tracepoints are inserted by the target at a time of its choosing,
1516 not by us. */
1517 if (is_tracepoint (bl->owner))
1518 return 0;
1519
1520 return 1;
1521 }
1522
1523 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
1524 location. Any error messages are printed to TMP_ERROR_STREAM; and
1525 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
1526
1527 NOTE drow/2003-09-09: This routine could be broken down to an
1528 object-style method for each breakpoint or catchpoint type. */
1529 static int
insert_bp_location(struct bp_location * bl,struct ui_file * tmp_error_stream,int * disabled_breaks,int * hw_breakpoint_error)1530 insert_bp_location (struct bp_location *bl,
1531 struct ui_file *tmp_error_stream,
1532 int *disabled_breaks,
1533 int *hw_breakpoint_error)
1534 {
1535 int val = 0;
1536
1537 if (!should_be_inserted (bl) || bl->inserted)
1538 return 0;
1539
1540 /* Initialize the target-specific information. */
1541 memset (&bl->target_info, 0, sizeof (bl->target_info));
1542 bl->target_info.placed_address = bl->address;
1543 bl->target_info.placed_address_space = bl->pspace->aspace;
1544 bl->target_info.length = bl->length;
1545
1546 if (bl->loc_type == bp_loc_software_breakpoint
1547 || bl->loc_type == bp_loc_hardware_breakpoint)
1548 {
1549 if (bl->owner->type != bp_hardware_breakpoint)
1550 {
1551 /* If the explicitly specified breakpoint type
1552 is not hardware breakpoint, check the memory map to see
1553 if the breakpoint address is in read only memory or not.
1554
1555 Two important cases are:
1556 - location type is not hardware breakpoint, memory
1557 is readonly. We change the type of the location to
1558 hardware breakpoint.
1559 - location type is hardware breakpoint, memory is
1560 read-write. This means we've previously made the
1561 location hardware one, but then the memory map changed,
1562 so we undo.
1563
1564 When breakpoints are removed, remove_breakpoints will use
1565 location types we've just set here, the only possible
1566 problem is that memory map has changed during running
1567 program, but it's not going to work anyway with current
1568 gdb. */
1569 struct mem_region *mr
1570 = lookup_mem_region (bl->target_info.placed_address);
1571
1572 if (mr)
1573 {
1574 if (automatic_hardware_breakpoints)
1575 {
1576 enum bp_loc_type new_type;
1577
1578 if (mr->attrib.mode != MEM_RW)
1579 new_type = bp_loc_hardware_breakpoint;
1580 else
1581 new_type = bp_loc_software_breakpoint;
1582
1583 if (new_type != bl->loc_type)
1584 {
1585 static int said = 0;
1586
1587 bl->loc_type = new_type;
1588 if (!said)
1589 {
1590 fprintf_filtered (gdb_stdout,
1591 _("Note: automatically using "
1592 "hardware breakpoints for "
1593 "read-only addresses.\n"));
1594 said = 1;
1595 }
1596 }
1597 }
1598 else if (bl->loc_type == bp_loc_software_breakpoint
1599 && mr->attrib.mode != MEM_RW)
1600 warning (_("cannot set software breakpoint "
1601 "at readonly address %s"),
1602 paddress (bl->gdbarch, bl->address));
1603 }
1604 }
1605
1606 /* First check to see if we have to handle an overlay. */
1607 if (overlay_debugging == ovly_off
1608 || bl->section == NULL
1609 || !(section_is_overlay (bl->section)))
1610 {
1611 /* No overlay handling: just set the breakpoint. */
1612
1613 if (bl->loc_type == bp_loc_hardware_breakpoint)
1614 val = target_insert_hw_breakpoint (bl->gdbarch,
1615 &bl->target_info);
1616 else
1617 val = target_insert_breakpoint (bl->gdbarch,
1618 &bl->target_info);
1619 }
1620 else
1621 {
1622 /* This breakpoint is in an overlay section.
1623 Shall we set a breakpoint at the LMA? */
1624 if (!overlay_events_enabled)
1625 {
1626 /* Yes -- overlay event support is not active,
1627 so we must try to set a breakpoint at the LMA.
1628 This will not work for a hardware breakpoint. */
1629 if (bl->loc_type == bp_loc_hardware_breakpoint)
1630 warning (_("hardware breakpoint %d not supported in overlay!"),
1631 bl->owner->number);
1632 else
1633 {
1634 CORE_ADDR addr = overlay_unmapped_address (bl->address,
1635 bl->section);
1636 /* Set a software (trap) breakpoint at the LMA. */
1637 bl->overlay_target_info = bl->target_info;
1638 bl->overlay_target_info.placed_address = addr;
1639 val = target_insert_breakpoint (bl->gdbarch,
1640 &bl->overlay_target_info);
1641 if (val != 0)
1642 fprintf_unfiltered (tmp_error_stream,
1643 "Overlay breakpoint %d "
1644 "failed: in ROM?\n",
1645 bl->owner->number);
1646 }
1647 }
1648 /* Shall we set a breakpoint at the VMA? */
1649 if (section_is_mapped (bl->section))
1650 {
1651 /* Yes. This overlay section is mapped into memory. */
1652 if (bl->loc_type == bp_loc_hardware_breakpoint)
1653 val = target_insert_hw_breakpoint (bl->gdbarch,
1654 &bl->target_info);
1655 else
1656 val = target_insert_breakpoint (bl->gdbarch,
1657 &bl->target_info);
1658 }
1659 else
1660 {
1661 /* No. This breakpoint will not be inserted.
1662 No error, but do not mark the bp as 'inserted'. */
1663 return 0;
1664 }
1665 }
1666
1667 if (val)
1668 {
1669 /* Can't set the breakpoint. */
1670 if (solib_name_from_address (bl->pspace, bl->address))
1671 {
1672 /* See also: disable_breakpoints_in_shlibs. */
1673 val = 0;
1674 bl->shlib_disabled = 1;
1675 if (!*disabled_breaks)
1676 {
1677 fprintf_unfiltered (tmp_error_stream,
1678 "Cannot insert breakpoint %d.\n",
1679 bl->owner->number);
1680 fprintf_unfiltered (tmp_error_stream,
1681 "Temporarily disabling shared "
1682 "library breakpoints:\n");
1683 }
1684 *disabled_breaks = 1;
1685 fprintf_unfiltered (tmp_error_stream,
1686 "breakpoint #%d\n", bl->owner->number);
1687 }
1688 else
1689 {
1690 if (bl->loc_type == bp_loc_hardware_breakpoint)
1691 {
1692 *hw_breakpoint_error = 1;
1693 fprintf_unfiltered (tmp_error_stream,
1694 "Cannot insert hardware "
1695 "breakpoint %d.\n",
1696 bl->owner->number);
1697 }
1698 else
1699 {
1700 fprintf_unfiltered (tmp_error_stream,
1701 "Cannot insert breakpoint %d.\n",
1702 bl->owner->number);
1703 fprintf_filtered (tmp_error_stream,
1704 "Error accessing memory address ");
1705 fputs_filtered (paddress (bl->gdbarch, bl->address),
1706 tmp_error_stream);
1707 fprintf_filtered (tmp_error_stream, ": %s.\n",
1708 safe_strerror (val));
1709 }
1710
1711 }
1712 }
1713 else
1714 bl->inserted = 1;
1715
1716 return val;
1717 }
1718
1719 else if (bl->loc_type == bp_loc_hardware_watchpoint
1720 /* NOTE drow/2003-09-08: This state only exists for removing
1721 watchpoints. It's not clear that it's necessary... */
1722 && bl->owner->disposition != disp_del_at_next_stop)
1723 {
1724 gdb_assert (bl->owner->ops != NULL
1725 && bl->owner->ops->insert_location != NULL);
1726
1727 val = bl->owner->ops->insert_location (bl);
1728
1729 /* If trying to set a read-watchpoint, and it turns out it's not
1730 supported, try emulating one with an access watchpoint. */
1731 if (val == 1 && bl->watchpoint_type == hw_read)
1732 {
1733 struct bp_location *loc, **loc_temp;
1734
1735 /* But don't try to insert it, if there's already another
1736 hw_access location that would be considered a duplicate
1737 of this one. */
1738 ALL_BP_LOCATIONS (loc, loc_temp)
1739 if (loc != bl
1740 && loc->watchpoint_type == hw_access
1741 && watchpoint_locations_match (bl, loc))
1742 {
1743 bl->duplicate = 1;
1744 bl->inserted = 1;
1745 bl->target_info = loc->target_info;
1746 bl->watchpoint_type = hw_access;
1747 val = 0;
1748 break;
1749 }
1750
1751 if (val == 1)
1752 {
1753 bl->watchpoint_type = hw_access;
1754 val = bl->owner->ops->insert_location (bl);
1755
1756 if (val)
1757 /* Back to the original value. */
1758 bl->watchpoint_type = hw_read;
1759 }
1760 }
1761
1762 bl->inserted = (val == 0);
1763 }
1764
1765 else if (bl->owner->type == bp_catchpoint)
1766 {
1767 gdb_assert (bl->owner->ops != NULL
1768 && bl->owner->ops->insert_location != NULL);
1769
1770 val = bl->owner->ops->insert_location (bl);
1771 if (val)
1772 {
1773 bl->owner->enable_state = bp_disabled;
1774
1775 if (val == 1)
1776 warning (_("\
1777 Error inserting catchpoint %d: Your system does not support this type\n\
1778 of catchpoint."), bl->owner->number);
1779 else
1780 warning (_("Error inserting catchpoint %d."), bl->owner->number);
1781 }
1782
1783 bl->inserted = (val == 0);
1784
1785 /* We've already printed an error message if there was a problem
1786 inserting this catchpoint, and we've disabled the catchpoint,
1787 so just return success. */
1788 return 0;
1789 }
1790
1791 return 0;
1792 }
1793
1794 /* This function is called when program space PSPACE is about to be
1795 deleted. It takes care of updating breakpoints to not reference
1796 PSPACE anymore. */
1797
1798 void
breakpoint_program_space_exit(struct program_space * pspace)1799 breakpoint_program_space_exit (struct program_space *pspace)
1800 {
1801 struct breakpoint *b, *b_temp;
1802 struct bp_location *loc, **loc_temp;
1803
1804 /* Remove any breakpoint that was set through this program space. */
1805 ALL_BREAKPOINTS_SAFE (b, b_temp)
1806 {
1807 if (b->pspace == pspace)
1808 delete_breakpoint (b);
1809 }
1810
1811 /* Breakpoints set through other program spaces could have locations
1812 bound to PSPACE as well. Remove those. */
1813 ALL_BP_LOCATIONS (loc, loc_temp)
1814 {
1815 struct bp_location *tmp;
1816
1817 if (loc->pspace == pspace)
1818 {
1819 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
1820 if (loc->owner->loc == loc)
1821 loc->owner->loc = loc->next;
1822 else
1823 for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
1824 if (tmp->next == loc)
1825 {
1826 tmp->next = loc->next;
1827 break;
1828 }
1829 }
1830 }
1831
1832 /* Now update the global location list to permanently delete the
1833 removed locations above. */
1834 update_global_location_list (0);
1835 }
1836
1837 /* Make sure all breakpoints are inserted in inferior.
1838 Throws exception on any error.
1839 A breakpoint that is already inserted won't be inserted
1840 again, so calling this function twice is safe. */
1841 void
insert_breakpoints(void)1842 insert_breakpoints (void)
1843 {
1844 struct breakpoint *bpt;
1845
1846 ALL_BREAKPOINTS (bpt)
1847 if (is_hardware_watchpoint (bpt))
1848 update_watchpoint (bpt, 0 /* don't reparse. */);
1849
1850 update_global_location_list (1);
1851
1852 /* update_global_location_list does not insert breakpoints when
1853 always_inserted_mode is not enabled. Explicitly insert them
1854 now. */
1855 if (!breakpoints_always_inserted_mode ())
1856 insert_breakpoint_locations ();
1857 }
1858
1859 /* insert_breakpoints is used when starting or continuing the program.
1860 remove_breakpoints is used when the program stops.
1861 Both return zero if successful,
1862 or an `errno' value if could not write the inferior. */
1863
1864 static void
insert_breakpoint_locations(void)1865 insert_breakpoint_locations (void)
1866 {
1867 struct breakpoint *bpt;
1868 struct bp_location *bl, **blp_tmp;
1869 int error = 0;
1870 int val = 0;
1871 int disabled_breaks = 0;
1872 int hw_breakpoint_error = 0;
1873
1874 struct ui_file *tmp_error_stream = mem_fileopen ();
1875 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
1876
1877 /* Explicitly mark the warning -- this will only be printed if
1878 there was an error. */
1879 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
1880
1881 save_current_space_and_thread ();
1882
1883 ALL_BP_LOCATIONS (bl, blp_tmp)
1884 {
1885 if (!should_be_inserted (bl) || bl->inserted)
1886 continue;
1887
1888 /* There is no point inserting thread-specific breakpoints if
1889 the thread no longer exists. ALL_BP_LOCATIONS bp_location
1890 has BL->OWNER always non-NULL. */
1891 if (bl->owner->thread != -1
1892 && !valid_thread_id (bl->owner->thread))
1893 continue;
1894
1895 switch_to_program_space_and_thread (bl->pspace);
1896
1897 /* For targets that support global breakpoints, there's no need
1898 to select an inferior to insert breakpoint to. In fact, even
1899 if we aren't attached to any process yet, we should still
1900 insert breakpoints. */
1901 if (!gdbarch_has_global_breakpoints (target_gdbarch)
1902 && ptid_equal (inferior_ptid, null_ptid))
1903 continue;
1904
1905 val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
1906 &hw_breakpoint_error);
1907 if (val)
1908 error = val;
1909 }
1910
1911 /* If we failed to insert all locations of a watchpoint, remove
1912 them, as half-inserted watchpoint is of limited use. */
1913 ALL_BREAKPOINTS (bpt)
1914 {
1915 int some_failed = 0;
1916 struct bp_location *loc;
1917
1918 if (!is_hardware_watchpoint (bpt))
1919 continue;
1920
1921 if (!breakpoint_enabled (bpt))
1922 continue;
1923
1924 if (bpt->disposition == disp_del_at_next_stop)
1925 continue;
1926
1927 for (loc = bpt->loc; loc; loc = loc->next)
1928 if (!loc->inserted && should_be_inserted (loc))
1929 {
1930 some_failed = 1;
1931 break;
1932 }
1933 if (some_failed)
1934 {
1935 for (loc = bpt->loc; loc; loc = loc->next)
1936 if (loc->inserted)
1937 remove_breakpoint (loc, mark_uninserted);
1938
1939 hw_breakpoint_error = 1;
1940 fprintf_unfiltered (tmp_error_stream,
1941 "Could not insert hardware watchpoint %d.\n",
1942 bpt->number);
1943 error = -1;
1944 }
1945 }
1946
1947 if (error)
1948 {
1949 /* If a hardware breakpoint or watchpoint was inserted, add a
1950 message about possibly exhausted resources. */
1951 if (hw_breakpoint_error)
1952 {
1953 fprintf_unfiltered (tmp_error_stream,
1954 "Could not insert hardware breakpoints:\n\
1955 You may have requested too many hardware breakpoints/watchpoints.\n");
1956 }
1957 target_terminal_ours_for_output ();
1958 error_stream (tmp_error_stream);
1959 }
1960
1961 do_cleanups (cleanups);
1962 }
1963
1964 int
remove_breakpoints(void)1965 remove_breakpoints (void)
1966 {
1967 struct bp_location *bl, **blp_tmp;
1968 int val = 0;
1969
1970 ALL_BP_LOCATIONS (bl, blp_tmp)
1971 {
1972 if (bl->inserted)
1973 val |= remove_breakpoint (bl, mark_uninserted);
1974 }
1975 return val;
1976 }
1977
1978 /* Remove breakpoints of process PID. */
1979
1980 int
remove_breakpoints_pid(int pid)1981 remove_breakpoints_pid (int pid)
1982 {
1983 struct bp_location *bl, **blp_tmp;
1984 int val;
1985 struct inferior *inf = find_inferior_pid (pid);
1986
1987 ALL_BP_LOCATIONS (bl, blp_tmp)
1988 {
1989 if (bl->pspace != inf->pspace)
1990 continue;
1991
1992 if (bl->inserted)
1993 {
1994 val = remove_breakpoint (bl, mark_uninserted);
1995 if (val != 0)
1996 return val;
1997 }
1998 }
1999 return 0;
2000 }
2001
2002 int
remove_hw_watchpoints(void)2003 remove_hw_watchpoints (void)
2004 {
2005 struct bp_location *bl, **blp_tmp;
2006 int val = 0;
2007
2008 ALL_BP_LOCATIONS (bl, blp_tmp)
2009 {
2010 if (bl->inserted && bl->loc_type == bp_loc_hardware_watchpoint)
2011 val |= remove_breakpoint (bl, mark_uninserted);
2012 }
2013 return val;
2014 }
2015
2016 int
reattach_breakpoints(int pid)2017 reattach_breakpoints (int pid)
2018 {
2019 struct cleanup *old_chain;
2020 struct bp_location *bl, **blp_tmp;
2021 int val;
2022 struct ui_file *tmp_error_stream;
2023 int dummy1 = 0, dummy2 = 0;
2024 struct inferior *inf;
2025 struct thread_info *tp;
2026
2027 tp = any_live_thread_of_process (pid);
2028 if (tp == NULL)
2029 return 1;
2030
2031 inf = find_inferior_pid (pid);
2032 old_chain = save_inferior_ptid ();
2033
2034 inferior_ptid = tp->ptid;
2035
2036 tmp_error_stream = mem_fileopen ();
2037 make_cleanup_ui_file_delete (tmp_error_stream);
2038
2039 ALL_BP_LOCATIONS (bl, blp_tmp)
2040 {
2041 if (bl->pspace != inf->pspace)
2042 continue;
2043
2044 if (bl->inserted)
2045 {
2046 bl->inserted = 0;
2047 val = insert_bp_location (bl, tmp_error_stream, &dummy1, &dummy2);
2048 if (val != 0)
2049 {
2050 do_cleanups (old_chain);
2051 return val;
2052 }
2053 }
2054 }
2055 do_cleanups (old_chain);
2056 return 0;
2057 }
2058
2059 static int internal_breakpoint_number = -1;
2060
2061 /* Set the breakpoint number of B, depending on the value of INTERNAL.
2062 If INTERNAL is non-zero, the breakpoint number will be populated
2063 from internal_breakpoint_number and that variable decremented.
2064 Otherwis the breakpoint number will be populated from
2065 breakpoint_count and that value incremented. Internal breakpoints
2066 do not set the internal var bpnum. */
2067 static void
set_breakpoint_number(int internal,struct breakpoint * b)2068 set_breakpoint_number (int internal, struct breakpoint *b)
2069 {
2070 if (internal)
2071 b->number = internal_breakpoint_number--;
2072 else
2073 {
2074 set_breakpoint_count (breakpoint_count + 1);
2075 b->number = breakpoint_count;
2076 }
2077 }
2078
2079 static struct breakpoint *
create_internal_breakpoint(struct gdbarch * gdbarch,CORE_ADDR address,enum bptype type)2080 create_internal_breakpoint (struct gdbarch *gdbarch,
2081 CORE_ADDR address, enum bptype type)
2082 {
2083 struct symtab_and_line sal;
2084 struct breakpoint *b;
2085
2086 init_sal (&sal); /* Initialize to zeroes. */
2087
2088 sal.pc = address;
2089 sal.section = find_pc_overlay (sal.pc);
2090 sal.pspace = current_program_space;
2091
2092 b = set_raw_breakpoint (gdbarch, sal, type);
2093 b->number = internal_breakpoint_number--;
2094 b->disposition = disp_donttouch;
2095
2096 return b;
2097 }
2098
2099 static const char *const longjmp_names[] =
2100 {
2101 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
2102 };
2103 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
2104
2105 /* Per-objfile data private to breakpoint.c. */
2106 struct breakpoint_objfile_data
2107 {
2108 /* Minimal symbol for "_ovly_debug_event" (if any). */
2109 struct minimal_symbol *overlay_msym;
2110
2111 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
2112 struct minimal_symbol *longjmp_msym[NUM_LONGJMP_NAMES];
2113
2114 /* Minimal symbol for "std::terminate()" (if any). */
2115 struct minimal_symbol *terminate_msym;
2116
2117 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
2118 struct minimal_symbol *exception_msym;
2119 };
2120
2121 static const struct objfile_data *breakpoint_objfile_key;
2122
2123 /* Minimal symbol not found sentinel. */
2124 static struct minimal_symbol msym_not_found;
2125
2126 /* Returns TRUE if MSYM point to the "not found" sentinel. */
2127
2128 static int
msym_not_found_p(const struct minimal_symbol * msym)2129 msym_not_found_p (const struct minimal_symbol *msym)
2130 {
2131 return msym == &msym_not_found;
2132 }
2133
2134 /* Return per-objfile data needed by breakpoint.c.
2135 Allocate the data if necessary. */
2136
2137 static struct breakpoint_objfile_data *
get_breakpoint_objfile_data(struct objfile * objfile)2138 get_breakpoint_objfile_data (struct objfile *objfile)
2139 {
2140 struct breakpoint_objfile_data *bp_objfile_data;
2141
2142 bp_objfile_data = objfile_data (objfile, breakpoint_objfile_key);
2143 if (bp_objfile_data == NULL)
2144 {
2145 bp_objfile_data = obstack_alloc (&objfile->objfile_obstack,
2146 sizeof (*bp_objfile_data));
2147
2148 memset (bp_objfile_data, 0, sizeof (*bp_objfile_data));
2149 set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
2150 }
2151 return bp_objfile_data;
2152 }
2153
2154 static void
create_overlay_event_breakpoint(void)2155 create_overlay_event_breakpoint (void)
2156 {
2157 struct objfile *objfile;
2158 const char *const func_name = "_ovly_debug_event";
2159
2160 ALL_OBJFILES (objfile)
2161 {
2162 struct breakpoint *b;
2163 struct breakpoint_objfile_data *bp_objfile_data;
2164 CORE_ADDR addr;
2165
2166 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2167
2168 if (msym_not_found_p (bp_objfile_data->overlay_msym))
2169 continue;
2170
2171 if (bp_objfile_data->overlay_msym == NULL)
2172 {
2173 struct minimal_symbol *m;
2174
2175 m = lookup_minimal_symbol_text (func_name, objfile);
2176 if (m == NULL)
2177 {
2178 /* Avoid future lookups in this objfile. */
2179 bp_objfile_data->overlay_msym = &msym_not_found;
2180 continue;
2181 }
2182 bp_objfile_data->overlay_msym = m;
2183 }
2184
2185 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
2186 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
2187 bp_overlay_event);
2188 b->addr_string = xstrdup (func_name);
2189
2190 if (overlay_debugging == ovly_auto)
2191 {
2192 b->enable_state = bp_enabled;
2193 overlay_events_enabled = 1;
2194 }
2195 else
2196 {
2197 b->enable_state = bp_disabled;
2198 overlay_events_enabled = 0;
2199 }
2200 }
2201 update_global_location_list (1);
2202 }
2203
2204 static void
create_longjmp_master_breakpoint(void)2205 create_longjmp_master_breakpoint (void)
2206 {
2207 struct program_space *pspace;
2208 struct cleanup *old_chain;
2209
2210 old_chain = save_current_program_space ();
2211
2212 ALL_PSPACES (pspace)
2213 {
2214 struct objfile *objfile;
2215
2216 set_current_program_space (pspace);
2217
2218 ALL_OBJFILES (objfile)
2219 {
2220 int i;
2221 struct gdbarch *gdbarch;
2222 struct breakpoint_objfile_data *bp_objfile_data;
2223
2224 gdbarch = get_objfile_arch (objfile);
2225 if (!gdbarch_get_longjmp_target_p (gdbarch))
2226 continue;
2227
2228 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2229
2230 for (i = 0; i < NUM_LONGJMP_NAMES; i++)
2231 {
2232 struct breakpoint *b;
2233 const char *func_name;
2234 CORE_ADDR addr;
2235
2236 if (msym_not_found_p (bp_objfile_data->longjmp_msym[i]))
2237 continue;
2238
2239 func_name = longjmp_names[i];
2240 if (bp_objfile_data->longjmp_msym[i] == NULL)
2241 {
2242 struct minimal_symbol *m;
2243
2244 m = lookup_minimal_symbol_text (func_name, objfile);
2245 if (m == NULL)
2246 {
2247 /* Prevent future lookups in this objfile. */
2248 bp_objfile_data->longjmp_msym[i] = &msym_not_found;
2249 continue;
2250 }
2251 bp_objfile_data->longjmp_msym[i] = m;
2252 }
2253
2254 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
2255 b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master);
2256 b->addr_string = xstrdup (func_name);
2257 b->enable_state = bp_disabled;
2258 }
2259 }
2260 }
2261 update_global_location_list (1);
2262
2263 do_cleanups (old_chain);
2264 }
2265
2266 /* Create a master std::terminate breakpoint. */
2267 static void
create_std_terminate_master_breakpoint(void)2268 create_std_terminate_master_breakpoint (void)
2269 {
2270 struct program_space *pspace;
2271 struct cleanup *old_chain;
2272 const char *const func_name = "std::terminate()";
2273
2274 old_chain = save_current_program_space ();
2275
2276 ALL_PSPACES (pspace)
2277 {
2278 struct objfile *objfile;
2279 CORE_ADDR addr;
2280
2281 set_current_program_space (pspace);
2282
2283 ALL_OBJFILES (objfile)
2284 {
2285 struct breakpoint *b;
2286 struct breakpoint_objfile_data *bp_objfile_data;
2287
2288 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2289
2290 if (msym_not_found_p (bp_objfile_data->terminate_msym))
2291 continue;
2292
2293 if (bp_objfile_data->terminate_msym == NULL)
2294 {
2295 struct minimal_symbol *m;
2296
2297 m = lookup_minimal_symbol (func_name, NULL, objfile);
2298 if (m == NULL || (MSYMBOL_TYPE (m) != mst_text
2299 && MSYMBOL_TYPE (m) != mst_file_text))
2300 {
2301 /* Prevent future lookups in this objfile. */
2302 bp_objfile_data->terminate_msym = &msym_not_found;
2303 continue;
2304 }
2305 bp_objfile_data->terminate_msym = m;
2306 }
2307
2308 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
2309 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
2310 bp_std_terminate_master);
2311 b->addr_string = xstrdup (func_name);
2312 b->enable_state = bp_disabled;
2313 }
2314 }
2315
2316 update_global_location_list (1);
2317
2318 do_cleanups (old_chain);
2319 }
2320
2321 /* Install a master breakpoint on the unwinder's debug hook. */
2322
2323 void
create_exception_master_breakpoint(void)2324 create_exception_master_breakpoint (void)
2325 {
2326 struct objfile *objfile;
2327 const char *const func_name = "_Unwind_DebugHook";
2328
2329 ALL_OBJFILES (objfile)
2330 {
2331 struct breakpoint *b;
2332 struct gdbarch *gdbarch;
2333 struct breakpoint_objfile_data *bp_objfile_data;
2334 CORE_ADDR addr;
2335
2336 bp_objfile_data = get_breakpoint_objfile_data (objfile);
2337
2338 if (msym_not_found_p (bp_objfile_data->exception_msym))
2339 continue;
2340
2341 gdbarch = get_objfile_arch (objfile);
2342
2343 if (bp_objfile_data->exception_msym == NULL)
2344 {
2345 struct minimal_symbol *debug_hook;
2346
2347 debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
2348 if (debug_hook == NULL)
2349 {
2350 bp_objfile_data->exception_msym = &msym_not_found;
2351 continue;
2352 }
2353
2354 bp_objfile_data->exception_msym = debug_hook;
2355 }
2356
2357 addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
2358 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
2359 ¤t_target);
2360 b = create_internal_breakpoint (gdbarch, addr, bp_exception_master);
2361 b->addr_string = xstrdup (func_name);
2362 b->enable_state = bp_disabled;
2363 }
2364
2365 update_global_location_list (1);
2366 }
2367
2368 void
update_breakpoints_after_exec(void)2369 update_breakpoints_after_exec (void)
2370 {
2371 struct breakpoint *b, *b_tmp;
2372 struct bp_location *bploc, **bplocp_tmp;
2373
2374 /* We're about to delete breakpoints from GDB's lists. If the
2375 INSERTED flag is true, GDB will try to lift the breakpoints by
2376 writing the breakpoints' "shadow contents" back into memory. The
2377 "shadow contents" are NOT valid after an exec, so GDB should not
2378 do that. Instead, the target is responsible from marking
2379 breakpoints out as soon as it detects an exec. We don't do that
2380 here instead, because there may be other attempts to delete
2381 breakpoints after detecting an exec and before reaching here. */
2382 ALL_BP_LOCATIONS (bploc, bplocp_tmp)
2383 if (bploc->pspace == current_program_space)
2384 gdb_assert (!bploc->inserted);
2385
2386 ALL_BREAKPOINTS_SAFE (b, b_tmp)
2387 {
2388 if (b->pspace != current_program_space)
2389 continue;
2390
2391 /* Solib breakpoints must be explicitly reset after an exec(). */
2392 if (b->type == bp_shlib_event)
2393 {
2394 delete_breakpoint (b);
2395 continue;
2396 }
2397
2398 /* JIT breakpoints must be explicitly reset after an exec(). */
2399 if (b->type == bp_jit_event)
2400 {
2401 delete_breakpoint (b);
2402 continue;
2403 }
2404
2405 /* Thread event breakpoints must be set anew after an exec(),
2406 as must overlay event and longjmp master breakpoints. */
2407 if (b->type == bp_thread_event || b->type == bp_overlay_event
2408 || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
2409 || b->type == bp_exception_master)
2410 {
2411 delete_breakpoint (b);
2412 continue;
2413 }
2414
2415 /* Step-resume breakpoints are meaningless after an exec(). */
2416 if (b->type == bp_step_resume)
2417 {
2418 delete_breakpoint (b);
2419 continue;
2420 }
2421
2422 /* Longjmp and longjmp-resume breakpoints are also meaningless
2423 after an exec. */
2424 if (b->type == bp_longjmp || b->type == bp_longjmp_resume
2425 || b->type == bp_exception || b->type == bp_exception_resume)
2426 {
2427 delete_breakpoint (b);
2428 continue;
2429 }
2430
2431 if (b->type == bp_catchpoint)
2432 {
2433 /* For now, none of the bp_catchpoint breakpoints need to
2434 do anything at this point. In the future, if some of
2435 the catchpoints need to something, we will need to add
2436 a new method, and call this method from here. */
2437 continue;
2438 }
2439
2440 /* bp_finish is a special case. The only way we ought to be able
2441 to see one of these when an exec() has happened, is if the user
2442 caught a vfork, and then said "finish". Ordinarily a finish just
2443 carries them to the call-site of the current callee, by setting
2444 a temporary bp there and resuming. But in this case, the finish
2445 will carry them entirely through the vfork & exec.
2446
2447 We don't want to allow a bp_finish to remain inserted now. But
2448 we can't safely delete it, 'cause finish_command has a handle to
2449 the bp on a bpstat, and will later want to delete it. There's a
2450 chance (and I've seen it happen) that if we delete the bp_finish
2451 here, that its storage will get reused by the time finish_command
2452 gets 'round to deleting the "use to be a bp_finish" breakpoint.
2453 We really must allow finish_command to delete a bp_finish.
2454
2455 In the absense of a general solution for the "how do we know
2456 it's safe to delete something others may have handles to?"
2457 problem, what we'll do here is just uninsert the bp_finish, and
2458 let finish_command delete it.
2459
2460 (We know the bp_finish is "doomed" in the sense that it's
2461 momentary, and will be deleted as soon as finish_command sees
2462 the inferior stopped. So it doesn't matter that the bp's
2463 address is probably bogus in the new a.out, unlike e.g., the
2464 solib breakpoints.) */
2465
2466 if (b->type == bp_finish)
2467 {
2468 continue;
2469 }
2470
2471 /* Without a symbolic address, we have little hope of the
2472 pre-exec() address meaning the same thing in the post-exec()
2473 a.out. */
2474 if (b->addr_string == NULL)
2475 {
2476 delete_breakpoint (b);
2477 continue;
2478 }
2479 }
2480 /* FIXME what about longjmp breakpoints? Re-create them here? */
2481 create_overlay_event_breakpoint ();
2482 create_longjmp_master_breakpoint ();
2483 create_std_terminate_master_breakpoint ();
2484 create_exception_master_breakpoint ();
2485 }
2486
2487 int
detach_breakpoints(int pid)2488 detach_breakpoints (int pid)
2489 {
2490 struct bp_location *bl, **blp_tmp;
2491 int val = 0;
2492 struct cleanup *old_chain = save_inferior_ptid ();
2493 struct inferior *inf = current_inferior ();
2494
2495 if (pid == PIDGET (inferior_ptid))
2496 error (_("Cannot detach breakpoints of inferior_ptid"));
2497
2498 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
2499 inferior_ptid = pid_to_ptid (pid);
2500 ALL_BP_LOCATIONS (bl, blp_tmp)
2501 {
2502 if (bl->pspace != inf->pspace)
2503 continue;
2504
2505 if (bl->inserted)
2506 val |= remove_breakpoint_1 (bl, mark_inserted);
2507 }
2508
2509 /* Detach single-step breakpoints as well. */
2510 detach_single_step_breakpoints ();
2511
2512 do_cleanups (old_chain);
2513 return val;
2514 }
2515
2516 /* Remove the breakpoint location BL from the current address space.
2517 Note that this is used to detach breakpoints from a child fork.
2518 When we get here, the child isn't in the inferior list, and neither
2519 do we have objects to represent its address space --- we should
2520 *not* look at bl->pspace->aspace here. */
2521
2522 static int
remove_breakpoint_1(struct bp_location * bl,insertion_state_t is)2523 remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is)
2524 {
2525 int val;
2526
2527 /* BL is never in moribund_locations by our callers. */
2528 gdb_assert (bl->owner != NULL);
2529
2530 if (bl->owner->enable_state == bp_permanent)
2531 /* Permanent breakpoints cannot be inserted or removed. */
2532 return 0;
2533
2534 /* The type of none suggests that owner is actually deleted.
2535 This should not ever happen. */
2536 gdb_assert (bl->owner->type != bp_none);
2537
2538 if (bl->loc_type == bp_loc_software_breakpoint
2539 || bl->loc_type == bp_loc_hardware_breakpoint)
2540 {
2541 /* "Normal" instruction breakpoint: either the standard
2542 trap-instruction bp (bp_breakpoint), or a
2543 bp_hardware_breakpoint. */
2544
2545 /* First check to see if we have to handle an overlay. */
2546 if (overlay_debugging == ovly_off
2547 || bl->section == NULL
2548 || !(section_is_overlay (bl->section)))
2549 {
2550 /* No overlay handling: just remove the breakpoint. */
2551
2552 if (bl->loc_type == bp_loc_hardware_breakpoint)
2553 val = target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
2554 else
2555 val = target_remove_breakpoint (bl->gdbarch, &bl->target_info);
2556 }
2557 else
2558 {
2559 /* This breakpoint is in an overlay section.
2560 Did we set a breakpoint at the LMA? */
2561 if (!overlay_events_enabled)
2562 {
2563 /* Yes -- overlay event support is not active, so we
2564 should have set a breakpoint at the LMA. Remove it.
2565 */
2566 /* Ignore any failures: if the LMA is in ROM, we will
2567 have already warned when we failed to insert it. */
2568 if (bl->loc_type == bp_loc_hardware_breakpoint)
2569 target_remove_hw_breakpoint (bl->gdbarch,
2570 &bl->overlay_target_info);
2571 else
2572 target_remove_breakpoint (bl->gdbarch,
2573 &bl->overlay_target_info);
2574 }
2575 /* Did we set a breakpoint at the VMA?
2576 If so, we will have marked the breakpoint 'inserted'. */
2577 if (bl->inserted)
2578 {
2579 /* Yes -- remove it. Previously we did not bother to
2580 remove the breakpoint if the section had been
2581 unmapped, but let's not rely on that being safe. We
2582 don't know what the overlay manager might do. */
2583 if (bl->loc_type == bp_loc_hardware_breakpoint)
2584 val = target_remove_hw_breakpoint (bl->gdbarch,
2585 &bl->target_info);
2586
2587 /* However, we should remove *software* breakpoints only
2588 if the section is still mapped, or else we overwrite
2589 wrong code with the saved shadow contents. */
2590 else if (section_is_mapped (bl->section))
2591 val = target_remove_breakpoint (bl->gdbarch,
2592 &bl->target_info);
2593 else
2594 val = 0;
2595 }
2596 else
2597 {
2598 /* No -- not inserted, so no need to remove. No error. */
2599 val = 0;
2600 }
2601 }
2602
2603 /* In some cases, we might not be able to remove a breakpoint
2604 in a shared library that has already been removed, but we
2605 have not yet processed the shlib unload event. */
2606 if (val && solib_name_from_address (bl->pspace, bl->address))
2607 val = 0;
2608
2609 if (val)
2610 return val;
2611 bl->inserted = (is == mark_inserted);
2612 }
2613 else if (bl->loc_type == bp_loc_hardware_watchpoint)
2614 {
2615 gdb_assert (bl->owner->ops != NULL
2616 && bl->owner->ops->remove_location != NULL);
2617
2618 bl->inserted = (is == mark_inserted);
2619 bl->owner->ops->remove_location (bl);
2620
2621 /* Failure to remove any of the hardware watchpoints comes here. */
2622 if ((is == mark_uninserted) && (bl->inserted))
2623 warning (_("Could not remove hardware watchpoint %d."),
2624 bl->owner->number);
2625 }
2626 else if (bl->owner->type == bp_catchpoint
2627 && breakpoint_enabled (bl->owner)
2628 && !bl->duplicate)
2629 {
2630 gdb_assert (bl->owner->ops != NULL
2631 && bl->owner->ops->remove_location != NULL);
2632
2633 val = bl->owner->ops->remove_location (bl);
2634 if (val)
2635 return val;
2636
2637 bl->inserted = (is == mark_inserted);
2638 }
2639
2640 return 0;
2641 }
2642
2643 static int
remove_breakpoint(struct bp_location * bl,insertion_state_t is)2644 remove_breakpoint (struct bp_location *bl, insertion_state_t is)
2645 {
2646 int ret;
2647 struct cleanup *old_chain;
2648
2649 /* BL is never in moribund_locations by our callers. */
2650 gdb_assert (bl->owner != NULL);
2651
2652 if (bl->owner->enable_state == bp_permanent)
2653 /* Permanent breakpoints cannot be inserted or removed. */
2654 return 0;
2655
2656 /* The type of none suggests that owner is actually deleted.
2657 This should not ever happen. */
2658 gdb_assert (bl->owner->type != bp_none);
2659
2660 old_chain = save_current_space_and_thread ();
2661
2662 switch_to_program_space_and_thread (bl->pspace);
2663
2664 ret = remove_breakpoint_1 (bl, is);
2665
2666 do_cleanups (old_chain);
2667 return ret;
2668 }
2669
2670 /* Clear the "inserted" flag in all breakpoints. */
2671
2672 void
mark_breakpoints_out(void)2673 mark_breakpoints_out (void)
2674 {
2675 struct bp_location *bl, **blp_tmp;
2676
2677 ALL_BP_LOCATIONS (bl, blp_tmp)
2678 if (bl->pspace == current_program_space)
2679 bl->inserted = 0;
2680 }
2681
2682 /* Clear the "inserted" flag in all breakpoints and delete any
2683 breakpoints which should go away between runs of the program.
2684
2685 Plus other such housekeeping that has to be done for breakpoints
2686 between runs.
2687
2688 Note: this function gets called at the end of a run (by
2689 generic_mourn_inferior) and when a run begins (by
2690 init_wait_for_inferior). */
2691
2692
2693
2694 void
breakpoint_init_inferior(enum inf_context context)2695 breakpoint_init_inferior (enum inf_context context)
2696 {
2697 struct breakpoint *b, *b_tmp;
2698 struct bp_location *bl, **blp_tmp;
2699 int ix;
2700 struct program_space *pspace = current_program_space;
2701
2702 /* If breakpoint locations are shared across processes, then there's
2703 nothing to do. */
2704 if (gdbarch_has_global_breakpoints (target_gdbarch))
2705 return;
2706
2707 ALL_BP_LOCATIONS (bl, blp_tmp)
2708 {
2709 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2710 if (bl->pspace == pspace
2711 && bl->owner->enable_state != bp_permanent)
2712 bl->inserted = 0;
2713 }
2714
2715 ALL_BREAKPOINTS_SAFE (b, b_tmp)
2716 {
2717 if (b->loc && b->loc->pspace != pspace)
2718 continue;
2719
2720 switch (b->type)
2721 {
2722 case bp_call_dummy:
2723
2724 /* If the call dummy breakpoint is at the entry point it will
2725 cause problems when the inferior is rerun, so we better get
2726 rid of it. */
2727
2728 case bp_watchpoint_scope:
2729
2730 /* Also get rid of scope breakpoints. */
2731
2732 case bp_shlib_event:
2733
2734 /* Also remove solib event breakpoints. Their addresses may
2735 have changed since the last time we ran the program.
2736 Actually we may now be debugging against different target;
2737 and so the solib backend that installed this breakpoint may
2738 not be used in by the target. E.g.,
2739
2740 (gdb) file prog-linux
2741 (gdb) run # native linux target
2742 ...
2743 (gdb) kill
2744 (gdb) file prog-win.exe
2745 (gdb) tar rem :9999 # remote Windows gdbserver.
2746 */
2747
2748 delete_breakpoint (b);
2749 break;
2750
2751 case bp_watchpoint:
2752 case bp_hardware_watchpoint:
2753 case bp_read_watchpoint:
2754 case bp_access_watchpoint:
2755
2756 /* Likewise for watchpoints on local expressions. */
2757 if (b->exp_valid_block != NULL)
2758 delete_breakpoint (b);
2759 else if (context == inf_starting)
2760 {
2761 /* Reset val field to force reread of starting value in
2762 insert_breakpoints. */
2763 if (b->val)
2764 value_free (b->val);
2765 b->val = NULL;
2766 b->val_valid = 0;
2767 }
2768 break;
2769 default:
2770 break;
2771 }
2772 }
2773
2774 /* Get rid of the moribund locations. */
2775 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
2776 decref_bp_location (&bl);
2777 VEC_free (bp_location_p, moribund_locations);
2778 }
2779
2780 /* These functions concern about actual breakpoints inserted in the
2781 target --- to e.g. check if we need to do decr_pc adjustment or if
2782 we need to hop over the bkpt --- so we check for address space
2783 match, not program space. */
2784
2785 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
2786 exists at PC. It returns ordinary_breakpoint_here if it's an
2787 ordinary breakpoint, or permanent_breakpoint_here if it's a
2788 permanent breakpoint.
2789 - When continuing from a location with an ordinary breakpoint, we
2790 actually single step once before calling insert_breakpoints.
2791 - When continuing from a localion with a permanent breakpoint, we
2792 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
2793 the target, to advance the PC past the breakpoint. */
2794
2795 enum breakpoint_here
breakpoint_here_p(struct address_space * aspace,CORE_ADDR pc)2796 breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
2797 {
2798 struct bp_location *bl, **blp_tmp;
2799 int any_breakpoint_here = 0;
2800
2801 ALL_BP_LOCATIONS (bl, blp_tmp)
2802 {
2803 if (bl->loc_type != bp_loc_software_breakpoint
2804 && bl->loc_type != bp_loc_hardware_breakpoint)
2805 continue;
2806
2807 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
2808 if ((breakpoint_enabled (bl->owner)
2809 || bl->owner->enable_state == bp_permanent)
2810 && breakpoint_location_address_match (bl, aspace, pc))
2811 {
2812 if (overlay_debugging
2813 && section_is_overlay (bl->section)
2814 && !section_is_mapped (bl->section))
2815 continue; /* unmapped overlay -- can't be a match */
2816 else if (bl->owner->enable_state == bp_permanent)
2817 return permanent_breakpoint_here;
2818 else
2819 any_breakpoint_here = 1;
2820 }
2821 }
2822
2823 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
2824 }
2825
2826 /* Return true if there's a moribund breakpoint at PC. */
2827
2828 int
moribund_breakpoint_here_p(struct address_space * aspace,CORE_ADDR pc)2829 moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
2830 {
2831 struct bp_location *loc;
2832 int ix;
2833
2834 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
2835 if (breakpoint_location_address_match (loc, aspace, pc))
2836 return 1;
2837
2838 return 0;
2839 }
2840
2841 /* Returns non-zero if there's a breakpoint inserted at PC, which is
2842 inserted using regular breakpoint_chain / bp_location array
2843 mechanism. This does not check for single-step breakpoints, which
2844 are inserted and removed using direct target manipulation. */
2845
2846 int
regular_breakpoint_inserted_here_p(struct address_space * aspace,CORE_ADDR pc)2847 regular_breakpoint_inserted_here_p (struct address_space *aspace,
2848 CORE_ADDR pc)
2849 {
2850 struct bp_location *bl, **blp_tmp;
2851
2852 ALL_BP_LOCATIONS (bl, blp_tmp)
2853 {
2854 if (bl->loc_type != bp_loc_software_breakpoint
2855 && bl->loc_type != bp_loc_hardware_breakpoint)
2856 continue;
2857
2858 if (bl->inserted
2859 && breakpoint_location_address_match (bl, aspace, pc))
2860 {
2861 if (overlay_debugging
2862 && section_is_overlay (bl->section)
2863 && !section_is_mapped (bl->section))
2864 continue; /* unmapped overlay -- can't be a match */
2865 else
2866 return 1;
2867 }
2868 }
2869 return 0;
2870 }
2871
2872 /* Returns non-zero iff there's either regular breakpoint
2873 or a single step breakpoint inserted at PC. */
2874
2875 int
breakpoint_inserted_here_p(struct address_space * aspace,CORE_ADDR pc)2876 breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
2877 {
2878 if (regular_breakpoint_inserted_here_p (aspace, pc))
2879 return 1;
2880
2881 if (single_step_breakpoint_inserted_here_p (aspace, pc))
2882 return 1;
2883
2884 return 0;
2885 }
2886
2887 /* This function returns non-zero iff there is a software breakpoint
2888 inserted at PC. */
2889
2890 int
software_breakpoint_inserted_here_p(struct address_space * aspace,CORE_ADDR pc)2891 software_breakpoint_inserted_here_p (struct address_space *aspace,
2892 CORE_ADDR pc)
2893 {
2894 struct bp_location *bl, **blp_tmp;
2895
2896 ALL_BP_LOCATIONS (bl, blp_tmp)
2897 {
2898 if (bl->loc_type != bp_loc_software_breakpoint)
2899 continue;
2900
2901 if (bl->inserted
2902 && breakpoint_address_match (bl->pspace->aspace, bl->address,
2903 aspace, pc))
2904 {
2905 if (overlay_debugging
2906 && section_is_overlay (bl->section)
2907 && !section_is_mapped (bl->section))
2908 continue; /* unmapped overlay -- can't be a match */
2909 else
2910 return 1;
2911 }
2912 }
2913
2914 /* Also check for software single-step breakpoints. */
2915 if (single_step_breakpoint_inserted_here_p (aspace, pc))
2916 return 1;
2917
2918 return 0;
2919 }
2920
2921 int
hardware_watchpoint_inserted_in_range(struct address_space * aspace,CORE_ADDR addr,ULONGEST len)2922 hardware_watchpoint_inserted_in_range (struct address_space *aspace,
2923 CORE_ADDR addr, ULONGEST len)
2924 {
2925 struct breakpoint *bpt;
2926
2927 ALL_BREAKPOINTS (bpt)
2928 {
2929 struct bp_location *loc;
2930
2931 if (bpt->type != bp_hardware_watchpoint
2932 && bpt->type != bp_access_watchpoint)
2933 continue;
2934
2935 if (!breakpoint_enabled (bpt))
2936 continue;
2937
2938 for (loc = bpt->loc; loc; loc = loc->next)
2939 if (loc->pspace->aspace == aspace && loc->inserted)
2940 {
2941 CORE_ADDR l, h;
2942
2943 /* Check for intersection. */
2944 l = max (loc->address, addr);
2945 h = min (loc->address + loc->length, addr + len);
2946 if (l < h)
2947 return 1;
2948 }
2949 }
2950 return 0;
2951 }
2952
2953 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
2954 PC is valid for process/thread PTID. */
2955
2956 int
breakpoint_thread_match(struct address_space * aspace,CORE_ADDR pc,ptid_t ptid)2957 breakpoint_thread_match (struct address_space *aspace, CORE_ADDR pc,
2958 ptid_t ptid)
2959 {
2960 struct bp_location *bl, **blp_tmp;
2961 /* The thread and task IDs associated to PTID, computed lazily. */
2962 int thread = -1;
2963 int task = 0;
2964
2965 ALL_BP_LOCATIONS (bl, blp_tmp)
2966 {
2967 if (bl->loc_type != bp_loc_software_breakpoint
2968 && bl->loc_type != bp_loc_hardware_breakpoint)
2969 continue;
2970
2971 /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
2972 if (!breakpoint_enabled (bl->owner)
2973 && bl->owner->enable_state != bp_permanent)
2974 continue;
2975
2976 if (!breakpoint_location_address_match (bl, aspace, pc))
2977 continue;
2978
2979 if (bl->owner->thread != -1)
2980 {
2981 /* This is a thread-specific breakpoint. Check that ptid
2982 matches that thread. If thread hasn't been computed yet,
2983 it is now time to do so. */
2984 if (thread == -1)
2985 thread = pid_to_thread_id (ptid);
2986 if (bl->owner->thread != thread)
2987 continue;
2988 }
2989
2990 if (bl->owner->task != 0)
2991 {
2992 /* This is a task-specific breakpoint. Check that ptid
2993 matches that task. If task hasn't been computed yet,
2994 it is now time to do so. */
2995 if (task == 0)
2996 task = ada_get_task_number (ptid);
2997 if (bl->owner->task != task)
2998 continue;
2999 }
3000
3001 if (overlay_debugging
3002 && section_is_overlay (bl->section)
3003 && !section_is_mapped (bl->section))
3004 continue; /* unmapped overlay -- can't be a match */
3005
3006 return 1;
3007 }
3008
3009 return 0;
3010 }
3011
3012
3013 /* bpstat stuff. External routines' interfaces are documented
3014 in breakpoint.h. */
3015
3016 int
ep_is_catchpoint(struct breakpoint * ep)3017 ep_is_catchpoint (struct breakpoint *ep)
3018 {
3019 return (ep->type == bp_catchpoint);
3020 }
3021
3022 /* Frees any storage that is part of a bpstat. Does not walk the
3023 'next' chain. */
3024
3025 static void
bpstat_free(bpstat bs)3026 bpstat_free (bpstat bs)
3027 {
3028 if (bs->old_val != NULL)
3029 value_free (bs->old_val);
3030 decref_counted_command_line (&bs->commands);
3031 decref_bp_location (&bs->bp_location_at);
3032 xfree (bs);
3033 }
3034
3035 /* Clear a bpstat so that it says we are not at any breakpoint.
3036 Also free any storage that is part of a bpstat. */
3037
3038 void
bpstat_clear(bpstat * bsp)3039 bpstat_clear (bpstat *bsp)
3040 {
3041 bpstat p;
3042 bpstat q;
3043
3044 if (bsp == 0)
3045 return;
3046 p = *bsp;
3047 while (p != NULL)
3048 {
3049 q = p->next;
3050 bpstat_free (p);
3051 p = q;
3052 }
3053 *bsp = NULL;
3054 }
3055
3056 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
3057 is part of the bpstat is copied as well. */
3058
3059 bpstat
bpstat_copy(bpstat bs)3060 bpstat_copy (bpstat bs)
3061 {
3062 bpstat p = NULL;
3063 bpstat tmp;
3064 bpstat retval = NULL;
3065
3066 if (bs == NULL)
3067 return bs;
3068
3069 for (; bs != NULL; bs = bs->next)
3070 {
3071 tmp = (bpstat) xmalloc (sizeof (*tmp));
3072 memcpy (tmp, bs, sizeof (*tmp));
3073 incref_counted_command_line (tmp->commands);
3074 incref_bp_location (tmp->bp_location_at);
3075 if (bs->old_val != NULL)
3076 {
3077 tmp->old_val = value_copy (bs->old_val);
3078 release_value (tmp->old_val);
3079 }
3080
3081 if (p == NULL)
3082 /* This is the first thing in the chain. */
3083 retval = tmp;
3084 else
3085 p->next = tmp;
3086 p = tmp;
3087 }
3088 p->next = NULL;
3089 return retval;
3090 }
3091
3092 /* Find the bpstat associated with this breakpoint. */
3093
3094 bpstat
bpstat_find_breakpoint(bpstat bsp,struct breakpoint * breakpoint)3095 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
3096 {
3097 if (bsp == NULL)
3098 return NULL;
3099
3100 for (; bsp != NULL; bsp = bsp->next)
3101 {
3102 if (bsp->breakpoint_at == breakpoint)
3103 return bsp;
3104 }
3105 return NULL;
3106 }
3107
3108 /* Put in *NUM the breakpoint number of the first breakpoint we are
3109 stopped at. *BSP upon return is a bpstat which points to the
3110 remaining breakpoints stopped at (but which is not guaranteed to be
3111 good for anything but further calls to bpstat_num).
3112
3113 Return 0 if passed a bpstat which does not indicate any breakpoints.
3114 Return -1 if stopped at a breakpoint that has been deleted since
3115 we set it.
3116 Return 1 otherwise. */
3117
3118 int
bpstat_num(bpstat * bsp,int * num)3119 bpstat_num (bpstat *bsp, int *num)
3120 {
3121 struct breakpoint *b;
3122
3123 if ((*bsp) == NULL)
3124 return 0; /* No more breakpoint values */
3125
3126 /* We assume we'll never have several bpstats that correspond to a
3127 single breakpoint -- otherwise, this function might return the
3128 same number more than once and this will look ugly. */
3129 b = (*bsp)->breakpoint_at;
3130 *bsp = (*bsp)->next;
3131 if (b == NULL)
3132 return -1; /* breakpoint that's been deleted since */
3133
3134 *num = b->number; /* We have its number */
3135 return 1;
3136 }
3137
3138 /* Modify BS so that the actions will not be performed. */
3139
3140 void
bpstat_clear_actions(bpstat bs)3141 bpstat_clear_actions (bpstat bs)
3142 {
3143 for (; bs != NULL; bs = bs->next)
3144 {
3145 decref_counted_command_line (&bs->commands);
3146 bs->commands_left = NULL;
3147 if (bs->old_val != NULL)
3148 {
3149 value_free (bs->old_val);
3150 bs->old_val = NULL;
3151 }
3152 }
3153 }
3154
3155 /* Called when a command is about to proceed the inferior. */
3156
3157 static void
breakpoint_about_to_proceed(void)3158 breakpoint_about_to_proceed (void)
3159 {
3160 if (!ptid_equal (inferior_ptid, null_ptid))
3161 {
3162 struct thread_info *tp = inferior_thread ();
3163
3164 /* Allow inferior function calls in breakpoint commands to not
3165 interrupt the command list. When the call finishes
3166 successfully, the inferior will be standing at the same
3167 breakpoint as if nothing happened. */
3168 if (tp->control.in_infcall)
3169 return;
3170 }
3171
3172 breakpoint_proceeded = 1;
3173 }
3174
3175 /* Stub for cleaning up our state if we error-out of a breakpoint
3176 command. */
3177 static void
cleanup_executing_breakpoints(void * ignore)3178 cleanup_executing_breakpoints (void *ignore)
3179 {
3180 executing_breakpoint_commands = 0;
3181 }
3182
3183 /* Execute all the commands associated with all the breakpoints at
3184 this location. Any of these commands could cause the process to
3185 proceed beyond this point, etc. We look out for such changes by
3186 checking the global "breakpoint_proceeded" after each command.
3187
3188 Returns true if a breakpoint command resumed the inferior. In that
3189 case, it is the caller's responsibility to recall it again with the
3190 bpstat of the current thread. */
3191
3192 static int
bpstat_do_actions_1(bpstat * bsp)3193 bpstat_do_actions_1 (bpstat *bsp)
3194 {
3195 bpstat bs;
3196 struct cleanup *old_chain;
3197 int again = 0;
3198
3199 /* Avoid endless recursion if a `source' command is contained
3200 in bs->commands. */
3201 if (executing_breakpoint_commands)
3202 return 0;
3203
3204 executing_breakpoint_commands = 1;
3205 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
3206
3207 /* This pointer will iterate over the list of bpstat's. */
3208 bs = *bsp;
3209
3210 breakpoint_proceeded = 0;
3211 for (; bs != NULL; bs = bs->next)
3212 {
3213 struct counted_command_line *ccmd;
3214 struct command_line *cmd;
3215 struct cleanup *this_cmd_tree_chain;
3216
3217 /* Take ownership of the BSP's command tree, if it has one.
3218
3219 The command tree could legitimately contain commands like
3220 'step' and 'next', which call clear_proceed_status, which
3221 frees stop_bpstat's command tree. To make sure this doesn't
3222 free the tree we're executing out from under us, we need to
3223 take ownership of the tree ourselves. Since a given bpstat's
3224 commands are only executed once, we don't need to copy it; we
3225 can clear the pointer in the bpstat, and make sure we free
3226 the tree when we're done. */
3227 ccmd = bs->commands;
3228 bs->commands = NULL;
3229 this_cmd_tree_chain
3230 = make_cleanup_decref_counted_command_line (&ccmd);
3231 cmd = bs->commands_left;
3232 bs->commands_left = NULL;
3233
3234 while (cmd != NULL)
3235 {
3236 execute_control_command (cmd);
3237
3238 if (breakpoint_proceeded)
3239 break;
3240 else
3241 cmd = cmd->next;
3242 }
3243
3244 /* We can free this command tree now. */
3245 do_cleanups (this_cmd_tree_chain);
3246
3247 if (breakpoint_proceeded)
3248 {
3249 if (target_can_async_p ())
3250 /* If we are in async mode, then the target might be still
3251 running, not stopped at any breakpoint, so nothing for
3252 us to do here -- just return to the event loop. */
3253 ;
3254 else
3255 /* In sync mode, when execute_control_command returns
3256 we're already standing on the next breakpoint.
3257 Breakpoint commands for that stop were not run, since
3258 execute_command does not run breakpoint commands --
3259 only command_line_handler does, but that one is not
3260 involved in execution of breakpoint commands. So, we
3261 can now execute breakpoint commands. It should be
3262 noted that making execute_command do bpstat actions is
3263 not an option -- in this case we'll have recursive
3264 invocation of bpstat for each breakpoint with a
3265 command, and can easily blow up GDB stack. Instead, we
3266 return true, which will trigger the caller to recall us
3267 with the new stop_bpstat. */
3268 again = 1;
3269 break;
3270 }
3271 }
3272 do_cleanups (old_chain);
3273 return again;
3274 }
3275
3276 void
bpstat_do_actions(void)3277 bpstat_do_actions (void)
3278 {
3279 /* Do any commands attached to breakpoint we are stopped at. */
3280 while (!ptid_equal (inferior_ptid, null_ptid)
3281 && target_has_execution
3282 && !is_exited (inferior_ptid)
3283 && !is_executing (inferior_ptid))
3284 /* Since in sync mode, bpstat_do_actions may resume the inferior,
3285 and only return when it is stopped at the next breakpoint, we
3286 keep doing breakpoint actions until it returns false to
3287 indicate the inferior was not resumed. */
3288 if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
3289 break;
3290 }
3291
3292 /* Print out the (old or new) value associated with a watchpoint. */
3293
3294 static void
watchpoint_value_print(struct value * val,struct ui_file * stream)3295 watchpoint_value_print (struct value *val, struct ui_file *stream)
3296 {
3297 if (val == NULL)
3298 fprintf_unfiltered (stream, _("<unreadable>"));
3299 else
3300 {
3301 struct value_print_options opts;
3302 get_user_print_options (&opts);
3303 value_print (val, stream, &opts);
3304 }
3305 }
3306
3307 /* This is the normal print function for a bpstat. In the future,
3308 much of this logic could (should?) be moved to bpstat_stop_status,
3309 by having it set different print_it values.
3310
3311 Current scheme: When we stop, bpstat_print() is called. It loops
3312 through the bpstat list of things causing this stop, calling the
3313 print_bp_stop_message function on each one. The behavior of the
3314 print_bp_stop_message function depends on the print_it field of
3315 bpstat. If such field so indicates, call this function here.
3316
3317 Return values from this routine (ultimately used by bpstat_print()
3318 and normal_stop() to decide what to do):
3319 PRINT_NOTHING: Means we already printed all we needed to print,
3320 don't print anything else.
3321 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
3322 that something to be followed by a location.
3323 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
3324 that something to be followed by a location.
3325 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
3326 analysis. */
3327
3328 static enum print_stop_action
print_it_typical(bpstat bs)3329 print_it_typical (bpstat bs)
3330 {
3331 struct cleanup *old_chain;
3332 struct breakpoint *b;
3333 const struct bp_location *bl;
3334 struct ui_stream *stb;
3335 int bp_temp = 0;
3336 enum print_stop_action result;
3337
3338 gdb_assert (bs->bp_location_at != NULL);
3339
3340 bl = bs->bp_location_at;
3341 b = bs->breakpoint_at;
3342
3343 stb = ui_out_stream_new (uiout);
3344 old_chain = make_cleanup_ui_out_stream_delete (stb);
3345
3346 switch (b->type)
3347 {
3348 case bp_breakpoint:
3349 case bp_hardware_breakpoint:
3350 bp_temp = b->disposition == disp_del;
3351 if (bl->address != bl->requested_address)
3352 breakpoint_adjustment_warning (bl->requested_address,
3353 bl->address,
3354 b->number, 1);
3355 annotate_breakpoint (b->number);
3356 if (bp_temp)
3357 ui_out_text (uiout, "\nTemporary breakpoint ");
3358 else
3359 ui_out_text (uiout, "\nBreakpoint ");
3360 if (ui_out_is_mi_like_p (uiout))
3361 {
3362 ui_out_field_string (uiout, "reason",
3363 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
3364 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
3365 }
3366 ui_out_field_int (uiout, "bkptno", b->number);
3367 ui_out_text (uiout, ", ");
3368 result = PRINT_SRC_AND_LOC;
3369 break;
3370
3371 case bp_shlib_event:
3372 /* Did we stop because the user set the stop_on_solib_events
3373 variable? (If so, we report this as a generic, "Stopped due
3374 to shlib event" message.) */
3375 printf_filtered (_("Stopped due to shared library event\n"));
3376 result = PRINT_NOTHING;
3377 break;
3378
3379 case bp_thread_event:
3380 /* Not sure how we will get here.
3381 GDB should not stop for these breakpoints. */
3382 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
3383 result = PRINT_NOTHING;
3384 break;
3385
3386 case bp_overlay_event:
3387 /* By analogy with the thread event, GDB should not stop for these. */
3388 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
3389 result = PRINT_NOTHING;
3390 break;
3391
3392 case bp_longjmp_master:
3393 /* These should never be enabled. */
3394 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
3395 result = PRINT_NOTHING;
3396 break;
3397
3398 case bp_std_terminate_master:
3399 /* These should never be enabled. */
3400 printf_filtered (_("std::terminate Master Breakpoint: "
3401 "gdb should not stop!\n"));
3402 result = PRINT_NOTHING;
3403 break;
3404
3405 case bp_exception_master:
3406 /* These should never be enabled. */
3407 printf_filtered (_("Exception Master Breakpoint: "
3408 "gdb should not stop!\n"));
3409 result = PRINT_NOTHING;
3410 break;
3411
3412 case bp_watchpoint:
3413 case bp_hardware_watchpoint:
3414 annotate_watchpoint (b->number);
3415 if (ui_out_is_mi_like_p (uiout))
3416 ui_out_field_string
3417 (uiout, "reason",
3418 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
3419 mention (b);
3420 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3421 ui_out_text (uiout, "\nOld value = ");
3422 watchpoint_value_print (bs->old_val, stb->stream);
3423 ui_out_field_stream (uiout, "old", stb);
3424 ui_out_text (uiout, "\nNew value = ");
3425 watchpoint_value_print (b->val, stb->stream);
3426 ui_out_field_stream (uiout, "new", stb);
3427 ui_out_text (uiout, "\n");
3428 /* More than one watchpoint may have been triggered. */
3429 result = PRINT_UNKNOWN;
3430 break;
3431
3432 case bp_read_watchpoint:
3433 if (ui_out_is_mi_like_p (uiout))
3434 ui_out_field_string
3435 (uiout, "reason",
3436 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
3437 mention (b);
3438 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3439 ui_out_text (uiout, "\nValue = ");
3440 watchpoint_value_print (b->val, stb->stream);
3441 ui_out_field_stream (uiout, "value", stb);
3442 ui_out_text (uiout, "\n");
3443 result = PRINT_UNKNOWN;
3444 break;
3445
3446 case bp_access_watchpoint:
3447 if (bs->old_val != NULL)
3448 {
3449 annotate_watchpoint (b->number);
3450 if (ui_out_is_mi_like_p (uiout))
3451 ui_out_field_string
3452 (uiout, "reason",
3453 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
3454 mention (b);
3455 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3456 ui_out_text (uiout, "\nOld value = ");
3457 watchpoint_value_print (bs->old_val, stb->stream);
3458 ui_out_field_stream (uiout, "old", stb);
3459 ui_out_text (uiout, "\nNew value = ");
3460 }
3461 else
3462 {
3463 mention (b);
3464 if (ui_out_is_mi_like_p (uiout))
3465 ui_out_field_string
3466 (uiout, "reason",
3467 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
3468 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
3469 ui_out_text (uiout, "\nValue = ");
3470 }
3471 watchpoint_value_print (b->val, stb->stream);
3472 ui_out_field_stream (uiout, "new", stb);
3473 ui_out_text (uiout, "\n");
3474 result = PRINT_UNKNOWN;
3475 break;
3476
3477 /* Fall through, we don't deal with these types of breakpoints
3478 here. */
3479
3480 case bp_finish:
3481 if (ui_out_is_mi_like_p (uiout))
3482 ui_out_field_string
3483 (uiout, "reason",
3484 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED));
3485 result = PRINT_UNKNOWN;
3486 break;
3487
3488 case bp_until:
3489 if (ui_out_is_mi_like_p (uiout))
3490 ui_out_field_string
3491 (uiout, "reason",
3492 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED));
3493 result = PRINT_UNKNOWN;
3494 break;
3495
3496 case bp_none:
3497 case bp_longjmp:
3498 case bp_longjmp_resume:
3499 case bp_exception:
3500 case bp_exception_resume:
3501 case bp_step_resume:
3502 case bp_watchpoint_scope:
3503 case bp_call_dummy:
3504 case bp_std_terminate:
3505 case bp_tracepoint:
3506 case bp_fast_tracepoint:
3507 case bp_jit_event:
3508 case bp_gnu_ifunc_resolver:
3509 case bp_gnu_ifunc_resolver_return:
3510 default:
3511 result = PRINT_UNKNOWN;
3512 break;
3513 }
3514
3515 do_cleanups (old_chain);
3516 return result;
3517 }
3518
3519 /* Generic routine for printing messages indicating why we
3520 stopped. The behavior of this function depends on the value
3521 'print_it' in the bpstat structure. Under some circumstances we
3522 may decide not to print anything here and delegate the task to
3523 normal_stop(). */
3524
3525 static enum print_stop_action
print_bp_stop_message(bpstat bs)3526 print_bp_stop_message (bpstat bs)
3527 {
3528 switch (bs->print_it)
3529 {
3530 case print_it_noop:
3531 /* Nothing should be printed for this bpstat entry. */
3532 return PRINT_UNKNOWN;
3533 break;
3534
3535 case print_it_done:
3536 /* We still want to print the frame, but we already printed the
3537 relevant messages. */
3538 return PRINT_SRC_AND_LOC;
3539 break;
3540
3541 case print_it_normal:
3542 {
3543 struct breakpoint *b = bs->breakpoint_at;
3544
3545 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
3546 which has since been deleted. */
3547 if (b == NULL)
3548 return PRINT_UNKNOWN;
3549
3550 /* Normal case. Call the breakpoint's print_it method, or
3551 print_it_typical. */
3552 if (b->ops != NULL && b->ops->print_it != NULL)
3553 return b->ops->print_it (b);
3554 else
3555 return print_it_typical (bs);
3556 }
3557 break;
3558
3559 default:
3560 internal_error (__FILE__, __LINE__,
3561 _("print_bp_stop_message: unrecognized enum value"));
3562 break;
3563 }
3564 }
3565
3566 /* Print a message indicating what happened. This is called from
3567 normal_stop(). The input to this routine is the head of the bpstat
3568 list - a list of the eventpoints that caused this stop. This
3569 routine calls the generic print routine for printing a message
3570 about reasons for stopping. This will print (for example) the
3571 "Breakpoint n," part of the output. The return value of this
3572 routine is one of:
3573
3574 PRINT_UNKNOWN: Means we printed nothing.
3575 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
3576 code to print the location. An example is
3577 "Breakpoint 1, " which should be followed by
3578 the location.
3579 PRINT_SRC_ONLY: Means we printed something, but there is no need
3580 to also print the location part of the message.
3581 An example is the catch/throw messages, which
3582 don't require a location appended to the end.
3583 PRINT_NOTHING: We have done some printing and we don't need any
3584 further info to be printed. */
3585
3586 enum print_stop_action
bpstat_print(bpstat bs)3587 bpstat_print (bpstat bs)
3588 {
3589 int val;
3590
3591 /* Maybe another breakpoint in the chain caused us to stop.
3592 (Currently all watchpoints go on the bpstat whether hit or not.
3593 That probably could (should) be changed, provided care is taken
3594 with respect to bpstat_explains_signal). */
3595 for (; bs; bs = bs->next)
3596 {
3597 val = print_bp_stop_message (bs);
3598 if (val == PRINT_SRC_ONLY
3599 || val == PRINT_SRC_AND_LOC
3600 || val == PRINT_NOTHING)
3601 return val;
3602 }
3603
3604 /* We reached the end of the chain, or we got a null BS to start
3605 with and nothing was printed. */
3606 return PRINT_UNKNOWN;
3607 }
3608
3609 /* Evaluate the expression EXP and return 1 if value is zero. This is
3610 used inside a catch_errors to evaluate the breakpoint condition.
3611 The argument is a "struct expression *" that has been cast to a
3612 "char *" to make it pass through catch_errors. */
3613
3614 static int
breakpoint_cond_eval(void * exp)3615 breakpoint_cond_eval (void *exp)
3616 {
3617 struct value *mark = value_mark ();
3618 int i = !value_true (evaluate_expression ((struct expression *) exp));
3619
3620 value_free_to_mark (mark);
3621 return i;
3622 }
3623
3624 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
3625
3626 static bpstat
bpstat_alloc(struct bp_location * bl,bpstat ** bs_link_pointer)3627 bpstat_alloc (struct bp_location *bl, bpstat **bs_link_pointer)
3628 {
3629 bpstat bs;
3630
3631 bs = (bpstat) xmalloc (sizeof (*bs));
3632 bs->next = NULL;
3633 **bs_link_pointer = bs;
3634 *bs_link_pointer = &bs->next;
3635 bs->breakpoint_at = bl->owner;
3636 bs->bp_location_at = bl;
3637 incref_bp_location (bl);
3638 /* If the condition is false, etc., don't do the commands. */
3639 bs->commands = NULL;
3640 bs->commands_left = NULL;
3641 bs->old_val = NULL;
3642 bs->print_it = print_it_normal;
3643 return bs;
3644 }
3645
3646 /* The target has stopped with waitstatus WS. Check if any hardware
3647 watchpoints have triggered, according to the target. */
3648
3649 int
watchpoints_triggered(struct target_waitstatus * ws)3650 watchpoints_triggered (struct target_waitstatus *ws)
3651 {
3652 int stopped_by_watchpoint = target_stopped_by_watchpoint ();
3653 CORE_ADDR addr;
3654 struct breakpoint *b;
3655
3656 if (!stopped_by_watchpoint)
3657 {
3658 /* We were not stopped by a watchpoint. Mark all watchpoints
3659 as not triggered. */
3660 ALL_BREAKPOINTS (b)
3661 if (is_hardware_watchpoint (b))
3662 b->watchpoint_triggered = watch_triggered_no;
3663
3664 return 0;
3665 }
3666
3667 if (!target_stopped_data_address (¤t_target, &addr))
3668 {
3669 /* We were stopped by a watchpoint, but we don't know where.
3670 Mark all watchpoints as unknown. */
3671 ALL_BREAKPOINTS (b)
3672 if (is_hardware_watchpoint (b))
3673 b->watchpoint_triggered = watch_triggered_unknown;
3674
3675 return stopped_by_watchpoint;
3676 }
3677
3678 /* The target could report the data address. Mark watchpoints
3679 affected by this data address as triggered, and all others as not
3680 triggered. */
3681
3682 ALL_BREAKPOINTS (b)
3683 if (is_hardware_watchpoint (b))
3684 {
3685 struct bp_location *loc;
3686
3687 b->watchpoint_triggered = watch_triggered_no;
3688 for (loc = b->loc; loc; loc = loc->next)
3689 /* Exact match not required. Within range is
3690 sufficient. */
3691 if (target_watchpoint_addr_within_range (¤t_target,
3692 addr, loc->address,
3693 loc->length))
3694 {
3695 b->watchpoint_triggered = watch_triggered_yes;
3696 break;
3697 }
3698 }
3699
3700 return 1;
3701 }
3702
3703 /* Possible return values for watchpoint_check (this can't be an enum
3704 because of check_errors). */
3705 /* The watchpoint has been deleted. */
3706 #define WP_DELETED 1
3707 /* The value has changed. */
3708 #define WP_VALUE_CHANGED 2
3709 /* The value has not changed. */
3710 #define WP_VALUE_NOT_CHANGED 3
3711 /* Ignore this watchpoint, no matter if the value changed or not. */
3712 #define WP_IGNORE 4
3713
3714 #define BP_TEMPFLAG 1
3715 #define BP_HARDWAREFLAG 2
3716
3717 /* Evaluate watchpoint condition expression and check if its value
3718 changed.
3719
3720 P should be a pointer to struct bpstat, but is defined as a void *
3721 in order for this function to be usable with catch_errors. */
3722
3723 static int
watchpoint_check(void * p)3724 watchpoint_check (void *p)
3725 {
3726 bpstat bs = (bpstat) p;
3727 struct breakpoint *b;
3728 struct frame_info *fr;
3729 int within_current_scope;
3730
3731 /* BS is built from an existing struct breakpoint. */
3732 gdb_assert (bs->breakpoint_at != NULL);
3733 b = bs->breakpoint_at;
3734
3735 gdb_assert (is_watchpoint (b));
3736
3737 /* If this is a local watchpoint, we only want to check if the
3738 watchpoint frame is in scope if the current thread is the thread
3739 that was used to create the watchpoint. */
3740 if (!watchpoint_in_thread_scope (b))
3741 return WP_IGNORE;
3742
3743 if (b->exp_valid_block == NULL)
3744 within_current_scope = 1;
3745 else
3746 {
3747 struct frame_info *frame = get_current_frame ();
3748 struct gdbarch *frame_arch = get_frame_arch (frame);
3749 CORE_ADDR frame_pc = get_frame_pc (frame);
3750
3751 /* in_function_epilogue_p() returns a non-zero value if we're
3752 still in the function but the stack frame has already been
3753 invalidated. Since we can't rely on the values of local
3754 variables after the stack has been destroyed, we are treating
3755 the watchpoint in that state as `not changed' without further
3756 checking. Don't mark watchpoints as changed if the current
3757 frame is in an epilogue - even if they are in some other
3758 frame, our view of the stack is likely to be wrong and
3759 frame_find_by_id could error out. */
3760 if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
3761 return WP_IGNORE;
3762
3763 fr = frame_find_by_id (b->watchpoint_frame);
3764 within_current_scope = (fr != NULL);
3765
3766 /* If we've gotten confused in the unwinder, we might have
3767 returned a frame that can't describe this variable. */
3768 if (within_current_scope)
3769 {
3770 struct symbol *function;
3771
3772 function = get_frame_function (fr);
3773 if (function == NULL
3774 || !contained_in (b->exp_valid_block,
3775 SYMBOL_BLOCK_VALUE (function)))
3776 within_current_scope = 0;
3777 }
3778
3779 if (within_current_scope)
3780 /* If we end up stopping, the current frame will get selected
3781 in normal_stop. So this call to select_frame won't affect
3782 the user. */
3783 select_frame (fr);
3784 }
3785
3786 if (within_current_scope)
3787 {
3788 /* We use value_{,free_to_}mark because it could be a *long*
3789 time before we return to the command level and call
3790 free_all_values. We can't call free_all_values because we
3791 might be in the middle of evaluating a function call. */
3792
3793 int pc = 0;
3794 struct value *mark = value_mark ();
3795 struct value *new_val;
3796
3797 fetch_subexp_value (b->exp, &pc, &new_val, NULL, NULL);
3798
3799 /* We use value_equal_contents instead of value_equal because
3800 the latter coerces an array to a pointer, thus comparing just
3801 the address of the array instead of its contents. This is
3802 not what we want. */
3803 if ((b->val != NULL) != (new_val != NULL)
3804 || (b->val != NULL && !value_equal_contents (b->val, new_val)))
3805 {
3806 if (new_val != NULL)
3807 {
3808 release_value (new_val);
3809 value_free_to_mark (mark);
3810 }
3811 bs->old_val = b->val;
3812 b->val = new_val;
3813 b->val_valid = 1;
3814 return WP_VALUE_CHANGED;
3815 }
3816 else
3817 {
3818 /* Nothing changed. */
3819 value_free_to_mark (mark);
3820 return WP_VALUE_NOT_CHANGED;
3821 }
3822 }
3823 else
3824 {
3825 /* This seems like the only logical thing to do because
3826 if we temporarily ignored the watchpoint, then when
3827 we reenter the block in which it is valid it contains
3828 garbage (in the case of a function, it may have two
3829 garbage values, one before and one after the prologue).
3830 So we can't even detect the first assignment to it and
3831 watch after that (since the garbage may or may not equal
3832 the first value assigned). */
3833 /* We print all the stop information in print_it_typical(), but
3834 in this case, by the time we call print_it_typical() this bp
3835 will be deleted already. So we have no choice but print the
3836 information here. */
3837 if (ui_out_is_mi_like_p (uiout))
3838 ui_out_field_string
3839 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
3840 ui_out_text (uiout, "\nWatchpoint ");
3841 ui_out_field_int (uiout, "wpnum", b->number);
3842 ui_out_text (uiout,
3843 " deleted because the program has left the block in\n\
3844 which its expression is valid.\n");
3845
3846 watchpoint_del_at_next_stop (b);
3847
3848 return WP_DELETED;
3849 }
3850 }
3851
3852 /* Return true if it looks like target has stopped due to hitting
3853 breakpoint location BL. This function does not check if we
3854 should stop, only if BL explains the stop. */
3855 static int
bpstat_check_location(const struct bp_location * bl,struct address_space * aspace,CORE_ADDR bp_addr)3856 bpstat_check_location (const struct bp_location *bl,
3857 struct address_space *aspace, CORE_ADDR bp_addr)
3858 {
3859 struct breakpoint *b = bl->owner;
3860
3861 /* BL is from existing struct breakpoint. */
3862 gdb_assert (b != NULL);
3863
3864 if (b->ops && b->ops->breakpoint_hit)
3865 return b->ops->breakpoint_hit (bl, aspace, bp_addr);
3866
3867 /* By definition, the inferior does not report stops at
3868 tracepoints. */
3869 if (is_tracepoint (b))
3870 return 0;
3871
3872 if (!is_watchpoint (b)
3873 && b->type != bp_hardware_breakpoint
3874 && b->type != bp_catchpoint) /* a non-watchpoint bp */
3875 {
3876 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
3877 aspace, bp_addr))
3878 return 0;
3879 if (overlay_debugging /* unmapped overlay section */
3880 && section_is_overlay (bl->section)
3881 && !section_is_mapped (bl->section))
3882 return 0;
3883 }
3884
3885 /* Continuable hardware watchpoints are treated as non-existent if the
3886 reason we stopped wasn't a hardware watchpoint (we didn't stop on
3887 some data address). Otherwise gdb won't stop on a break instruction
3888 in the code (not from a breakpoint) when a hardware watchpoint has
3889 been defined. Also skip watchpoints which we know did not trigger
3890 (did not match the data address). */
3891
3892 if (is_hardware_watchpoint (b)
3893 && b->watchpoint_triggered == watch_triggered_no)
3894 return 0;
3895
3896 if (b->type == bp_hardware_breakpoint)
3897 {
3898 if (bl->address != bp_addr)
3899 return 0;
3900 if (overlay_debugging /* unmapped overlay section */
3901 && section_is_overlay (bl->section)
3902 && !section_is_mapped (bl->section))
3903 return 0;
3904 }
3905
3906 return 1;
3907 }
3908
3909 /* If BS refers to a watchpoint, determine if the watched values
3910 has actually changed, and we should stop. If not, set BS->stop
3911 to 0. */
3912 static void
bpstat_check_watchpoint(bpstat bs)3913 bpstat_check_watchpoint (bpstat bs)
3914 {
3915 const struct bp_location *bl;
3916 struct breakpoint *b;
3917
3918 /* BS is built for existing struct breakpoint. */
3919 bl = bs->bp_location_at;
3920 gdb_assert (bl != NULL);
3921 b = bs->breakpoint_at;
3922 gdb_assert (b != NULL);
3923
3924 if (is_watchpoint (b))
3925 {
3926 int must_check_value = 0;
3927
3928 if (b->type == bp_watchpoint)
3929 /* For a software watchpoint, we must always check the
3930 watched value. */
3931 must_check_value = 1;
3932 else if (b->watchpoint_triggered == watch_triggered_yes)
3933 /* We have a hardware watchpoint (read, write, or access)
3934 and the target earlier reported an address watched by
3935 this watchpoint. */
3936 must_check_value = 1;
3937 else if (b->watchpoint_triggered == watch_triggered_unknown
3938 && b->type == bp_hardware_watchpoint)
3939 /* We were stopped by a hardware watchpoint, but the target could
3940 not report the data address. We must check the watchpoint's
3941 value. Access and read watchpoints are out of luck; without
3942 a data address, we can't figure it out. */
3943 must_check_value = 1;
3944
3945 if (must_check_value)
3946 {
3947 char *message
3948 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3949 b->number);
3950 struct cleanup *cleanups = make_cleanup (xfree, message);
3951 int e = catch_errors (watchpoint_check, bs, message,
3952 RETURN_MASK_ALL);
3953 do_cleanups (cleanups);
3954 switch (e)
3955 {
3956 case WP_DELETED:
3957 /* We've already printed what needs to be printed. */
3958 bs->print_it = print_it_done;
3959 /* Stop. */
3960 break;
3961 case WP_IGNORE:
3962 bs->print_it = print_it_noop;
3963 bs->stop = 0;
3964 break;
3965 case WP_VALUE_CHANGED:
3966 if (b->type == bp_read_watchpoint)
3967 {
3968 /* There are two cases to consider here:
3969
3970 1. We're watching the triggered memory for reads.
3971 In that case, trust the target, and always report
3972 the watchpoint hit to the user. Even though
3973 reads don't cause value changes, the value may
3974 have changed since the last time it was read, and
3975 since we're not trapping writes, we will not see
3976 those, and as such we should ignore our notion of
3977 old value.
3978
3979 2. We're watching the triggered memory for both
3980 reads and writes. There are two ways this may
3981 happen:
3982
3983 2.1. This is a target that can't break on data
3984 reads only, but can break on accesses (reads or
3985 writes), such as e.g., x86. We detect this case
3986 at the time we try to insert read watchpoints.
3987
3988 2.2. Otherwise, the target supports read
3989 watchpoints, but, the user set an access or write
3990 watchpoint watching the same memory as this read
3991 watchpoint.
3992
3993 If we're watching memory writes as well as reads,
3994 ignore watchpoint hits when we find that the
3995 value hasn't changed, as reads don't cause
3996 changes. This still gives false positives when
3997 the program writes the same value to memory as
3998 what there was already in memory (we will confuse
3999 it for a read), but it's much better than
4000 nothing. */
4001
4002 int other_write_watchpoint = 0;
4003
4004 if (bl->watchpoint_type == hw_read)
4005 {
4006 struct breakpoint *other_b;
4007
4008 ALL_BREAKPOINTS (other_b)
4009 if ((other_b->type == bp_hardware_watchpoint
4010 || other_b->type == bp_access_watchpoint)
4011 && (other_b->watchpoint_triggered
4012 == watch_triggered_yes))
4013 {
4014 other_write_watchpoint = 1;
4015 break;
4016 }
4017 }
4018
4019 if (other_write_watchpoint
4020 || bl->watchpoint_type == hw_access)
4021 {
4022 /* We're watching the same memory for writes,
4023 and the value changed since the last time we
4024 updated it, so this trap must be for a write.
4025 Ignore it. */
4026 bs->print_it = print_it_noop;
4027 bs->stop = 0;
4028 }
4029 }
4030 break;
4031 case WP_VALUE_NOT_CHANGED:
4032 if (b->type == bp_hardware_watchpoint
4033 || b->type == bp_watchpoint)
4034 {
4035 /* Don't stop: write watchpoints shouldn't fire if
4036 the value hasn't changed. */
4037 bs->print_it = print_it_noop;
4038 bs->stop = 0;
4039 }
4040 /* Stop. */
4041 break;
4042 default:
4043 /* Can't happen. */
4044 case 0:
4045 /* Error from catch_errors. */
4046 printf_filtered (_("Watchpoint %d deleted.\n"), b->number);
4047 watchpoint_del_at_next_stop (b);
4048 /* We've already printed what needs to be printed. */
4049 bs->print_it = print_it_done;
4050 break;
4051 }
4052 }
4053 else /* must_check_value == 0 */
4054 {
4055 /* This is a case where some watchpoint(s) triggered, but
4056 not at the address of this watchpoint, or else no
4057 watchpoint triggered after all. So don't print
4058 anything for this watchpoint. */
4059 bs->print_it = print_it_noop;
4060 bs->stop = 0;
4061 }
4062 }
4063 }
4064
4065
4066 /* Check conditions (condition proper, frame, thread and ignore count)
4067 of breakpoint referred to by BS. If we should not stop for this
4068 breakpoint, set BS->stop to 0. */
4069
4070 static void
bpstat_check_breakpoint_conditions(bpstat bs,ptid_t ptid)4071 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
4072 {
4073 int thread_id = pid_to_thread_id (ptid);
4074 const struct bp_location *bl;
4075 struct breakpoint *b;
4076
4077 /* BS is built for existing struct breakpoint. */
4078 bl = bs->bp_location_at;
4079 gdb_assert (bl != NULL);
4080 b = bs->breakpoint_at;
4081 gdb_assert (b != NULL);
4082
4083 if (frame_id_p (b->frame_id)
4084 && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
4085 bs->stop = 0;
4086 else if (bs->stop)
4087 {
4088 int value_is_zero = 0;
4089 struct expression *cond;
4090
4091 /* Evaluate Python breakpoints that have a "stop"
4092 method implemented. */
4093 if (b->py_bp_object)
4094 bs->stop = gdbpy_should_stop (b->py_bp_object);
4095
4096 if (is_watchpoint (b))
4097 cond = b->cond_exp;
4098 else
4099 cond = bl->cond;
4100
4101 if (cond && b->disposition != disp_del_at_next_stop)
4102 {
4103 int within_current_scope = 1;
4104
4105 /* We use value_mark and value_free_to_mark because it could
4106 be a long time before we return to the command level and
4107 call free_all_values. We can't call free_all_values
4108 because we might be in the middle of evaluating a
4109 function call. */
4110 struct value *mark = value_mark ();
4111
4112 /* Need to select the frame, with all that implies so that
4113 the conditions will have the right context. Because we
4114 use the frame, we will not see an inlined function's
4115 variables when we arrive at a breakpoint at the start
4116 of the inlined function; the current frame will be the
4117 call site. */
4118 if (!is_watchpoint (b) || b->cond_exp_valid_block == NULL)
4119 select_frame (get_current_frame ());
4120 else
4121 {
4122 struct frame_info *frame;
4123
4124 /* For local watchpoint expressions, which particular
4125 instance of a local is being watched matters, so we
4126 keep track of the frame to evaluate the expression
4127 in. To evaluate the condition however, it doesn't
4128 really matter which instantiation of the function
4129 where the condition makes sense triggers the
4130 watchpoint. This allows an expression like "watch
4131 global if q > 10" set in `func', catch writes to
4132 global on all threads that call `func', or catch
4133 writes on all recursive calls of `func' by a single
4134 thread. We simply always evaluate the condition in
4135 the innermost frame that's executing where it makes
4136 sense to evaluate the condition. It seems
4137 intuitive. */
4138 frame = block_innermost_frame (b->cond_exp_valid_block);
4139 if (frame != NULL)
4140 select_frame (frame);
4141 else
4142 within_current_scope = 0;
4143 }
4144 if (within_current_scope)
4145 value_is_zero
4146 = catch_errors (breakpoint_cond_eval, cond,
4147 "Error in testing breakpoint condition:\n",
4148 RETURN_MASK_ALL);
4149 else
4150 {
4151 warning (_("Watchpoint condition cannot be tested "
4152 "in the current scope"));
4153 /* If we failed to set the right context for this
4154 watchpoint, unconditionally report it. */
4155 value_is_zero = 0;
4156 }
4157 /* FIXME-someday, should give breakpoint #. */
4158 value_free_to_mark (mark);
4159 }
4160
4161 if (cond && value_is_zero)
4162 {
4163 bs->stop = 0;
4164 }
4165 else if (b->thread != -1 && b->thread != thread_id)
4166 {
4167 bs->stop = 0;
4168 }
4169 else if (b->ignore_count > 0)
4170 {
4171 b->ignore_count--;
4172 annotate_ignore_count_change ();
4173 bs->stop = 0;
4174 /* Increase the hit count even though we don't stop. */
4175 ++(b->hit_count);
4176 }
4177 }
4178 }
4179
4180
4181 /* Get a bpstat associated with having just stopped at address
4182 BP_ADDR in thread PTID.
4183
4184 Determine whether we stopped at a breakpoint, etc, or whether we
4185 don't understand this stop. Result is a chain of bpstat's such
4186 that:
4187
4188 if we don't understand the stop, the result is a null pointer.
4189
4190 if we understand why we stopped, the result is not null.
4191
4192 Each element of the chain refers to a particular breakpoint or
4193 watchpoint at which we have stopped. (We may have stopped for
4194 several reasons concurrently.)
4195
4196 Each element of the chain has valid next, breakpoint_at,
4197 commands, FIXME??? fields. */
4198
4199 bpstat
bpstat_stop_status(struct address_space * aspace,CORE_ADDR bp_addr,ptid_t ptid)4200 bpstat_stop_status (struct address_space *aspace,
4201 CORE_ADDR bp_addr, ptid_t ptid)
4202 {
4203 struct breakpoint *b = NULL;
4204 struct bp_location *bl;
4205 struct bp_location *loc;
4206 /* First item of allocated bpstat's. */
4207 bpstat bs_head = NULL, *bs_link = &bs_head;
4208 /* Pointer to the last thing in the chain currently. */
4209 bpstat bs;
4210 int ix;
4211 int need_remove_insert;
4212 int removed_any;
4213
4214 /* First, build the bpstat chain with locations that explain a
4215 target stop, while being careful to not set the target running,
4216 as that may invalidate locations (in particular watchpoint
4217 locations are recreated). Resuming will happen here with
4218 breakpoint conditions or watchpoint expressions that include
4219 inferior function calls. */
4220
4221 ALL_BREAKPOINTS (b)
4222 {
4223 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
4224 continue;
4225
4226 for (bl = b->loc; bl != NULL; bl = bl->next)
4227 {
4228 /* For hardware watchpoints, we look only at the first
4229 location. The watchpoint_check function will work on the
4230 entire expression, not the individual locations. For
4231 read watchpoints, the watchpoints_triggered function has
4232 checked all locations already. */
4233 if (b->type == bp_hardware_watchpoint && bl != b->loc)
4234 break;
4235
4236 if (bl->shlib_disabled)
4237 continue;
4238
4239 if (!bpstat_check_location (bl, aspace, bp_addr))
4240 continue;
4241
4242 /* Come here if it's a watchpoint, or if the break address
4243 matches. */
4244
4245 bs = bpstat_alloc (bl, &bs_link); /* Alloc a bpstat to
4246 explain stop. */
4247
4248 /* Assume we stop. Should we find a watchpoint that is not
4249 actually triggered, or if the condition of the breakpoint
4250 evaluates as false, we'll reset 'stop' to 0. */
4251 bs->stop = 1;
4252 bs->print = 1;
4253
4254 /* If this is a scope breakpoint, mark the associated
4255 watchpoint as triggered so that we will handle the
4256 out-of-scope event. We'll get to the watchpoint next
4257 iteration. */
4258 if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
4259 b->related_breakpoint->watchpoint_triggered = watch_triggered_yes;
4260 }
4261 }
4262
4263 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
4264 {
4265 if (breakpoint_location_address_match (loc, aspace, bp_addr))
4266 {
4267 bs = bpstat_alloc (loc, &bs_link);
4268 /* For hits of moribund locations, we should just proceed. */
4269 bs->stop = 0;
4270 bs->print = 0;
4271 bs->print_it = print_it_noop;
4272 }
4273 }
4274
4275 /* Now go through the locations that caused the target to stop, and
4276 check whether we're interested in reporting this stop to higher
4277 layers, or whether we should resume the target transparently. */
4278
4279 removed_any = 0;
4280
4281 for (bs = bs_head; bs != NULL; bs = bs->next)
4282 {
4283 if (!bs->stop)
4284 continue;
4285
4286 bpstat_check_watchpoint (bs);
4287 if (!bs->stop)
4288 continue;
4289
4290 b = bs->breakpoint_at;
4291
4292 if (b->type == bp_thread_event || b->type == bp_overlay_event
4293 || b->type == bp_longjmp_master
4294 || b->type == bp_std_terminate_master
4295 || b->type == bp_exception_master)
4296 /* We do not stop for these. */
4297 bs->stop = 0;
4298 else
4299 bpstat_check_breakpoint_conditions (bs, ptid);
4300
4301 if (bs->stop)
4302 {
4303 ++(b->hit_count);
4304
4305 /* We will stop here. */
4306 if (b->disposition == disp_disable)
4307 {
4308 if (b->enable_state != bp_permanent)
4309 b->enable_state = bp_disabled;
4310 removed_any = 1;
4311 }
4312 if (b->silent)
4313 bs->print = 0;
4314 bs->commands = b->commands;
4315 incref_counted_command_line (bs->commands);
4316 bs->commands_left = bs->commands ? bs->commands->commands : NULL;
4317 if (bs->commands_left
4318 && (strcmp ("silent", bs->commands_left->line) == 0
4319 || (xdb_commands
4320 && strcmp ("Q",
4321 bs->commands_left->line) == 0)))
4322 {
4323 bs->commands_left = bs->commands_left->next;
4324 bs->print = 0;
4325 }
4326 }
4327
4328 /* Print nothing for this entry if we dont stop or dont print. */
4329 if (bs->stop == 0 || bs->print == 0)
4330 bs->print_it = print_it_noop;
4331 }
4332
4333 /* If we aren't stopping, the value of some hardware watchpoint may
4334 not have changed, but the intermediate memory locations we are
4335 watching may have. Don't bother if we're stopping; this will get
4336 done later. */
4337 need_remove_insert = 0;
4338 if (! bpstat_causes_stop (bs_head))
4339 for (bs = bs_head; bs != NULL; bs = bs->next)
4340 if (!bs->stop
4341 && bs->breakpoint_at
4342 && is_hardware_watchpoint (bs->breakpoint_at))
4343 {
4344 update_watchpoint (bs->breakpoint_at, 0 /* don't reparse. */);
4345 need_remove_insert = 1;
4346 }
4347
4348 if (need_remove_insert)
4349 update_global_location_list (1);
4350 else if (removed_any)
4351 update_global_location_list (0);
4352
4353 return bs_head;
4354 }
4355
4356 static void
handle_jit_event(void)4357 handle_jit_event (void)
4358 {
4359 struct frame_info *frame;
4360 struct gdbarch *gdbarch;
4361
4362 /* Switch terminal for any messages produced by
4363 breakpoint_re_set. */
4364 target_terminal_ours_for_output ();
4365
4366 frame = get_current_frame ();
4367 gdbarch = get_frame_arch (frame);
4368
4369 jit_event_handler (gdbarch);
4370
4371 target_terminal_inferior ();
4372 }
4373
4374 /* Prepare WHAT final decision for infrun. */
4375
4376 /* Decide what infrun needs to do with this bpstat. */
4377
4378 struct bpstat_what
bpstat_what(bpstat bs_head)4379 bpstat_what (bpstat bs_head)
4380 {
4381 struct bpstat_what retval;
4382 /* We need to defer calling `solib_add', as adding new symbols
4383 resets breakpoints, which in turn deletes breakpoint locations,
4384 and hence may clear unprocessed entries in the BS chain. */
4385 int shlib_event = 0;
4386 int jit_event = 0;
4387 bpstat bs;
4388
4389 retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
4390 retval.call_dummy = STOP_NONE;
4391 retval.is_longjmp = 0;
4392
4393 for (bs = bs_head; bs != NULL; bs = bs->next)
4394 {
4395 /* Extract this BS's action. After processing each BS, we check
4396 if its action overrides all we've seem so far. */
4397 enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
4398 enum bptype bptype;
4399
4400 if (bs->breakpoint_at == NULL)
4401 {
4402 /* I suspect this can happen if it was a momentary
4403 breakpoint which has since been deleted. */
4404 bptype = bp_none;
4405 }
4406 else if (bs->breakpoint_at == NULL)
4407 bptype = bp_none;
4408 else
4409 bptype = bs->breakpoint_at->type;
4410
4411 switch (bptype)
4412 {
4413 case bp_none:
4414 break;
4415 case bp_breakpoint:
4416 case bp_hardware_breakpoint:
4417 case bp_until:
4418 case bp_finish:
4419 if (bs->stop)
4420 {
4421 if (bs->print)
4422 this_action = BPSTAT_WHAT_STOP_NOISY;
4423 else
4424 this_action = BPSTAT_WHAT_STOP_SILENT;
4425 }
4426 else
4427 this_action = BPSTAT_WHAT_SINGLE;
4428 break;
4429 case bp_watchpoint:
4430 case bp_hardware_watchpoint:
4431 case bp_read_watchpoint:
4432 case bp_access_watchpoint:
4433 if (bs->stop)
4434 {
4435 if (bs->print)
4436 this_action = BPSTAT_WHAT_STOP_NOISY;
4437 else
4438 this_action = BPSTAT_WHAT_STOP_SILENT;
4439 }
4440 else
4441 {
4442 /* There was a watchpoint, but we're not stopping.
4443 This requires no further action. */
4444 }
4445 break;
4446 case bp_longjmp:
4447 case bp_exception:
4448 this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
4449 retval.is_longjmp = bptype == bp_longjmp;
4450 break;
4451 case bp_longjmp_resume:
4452 case bp_exception_resume:
4453 this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
4454 retval.is_longjmp = bptype == bp_longjmp_resume;
4455 break;
4456 case bp_step_resume:
4457 if (bs->stop)
4458 this_action = BPSTAT_WHAT_STEP_RESUME;
4459 else
4460 {
4461 /* It is for the wrong frame. */
4462 this_action = BPSTAT_WHAT_SINGLE;
4463 }
4464 break;
4465 case bp_watchpoint_scope:
4466 case bp_thread_event:
4467 case bp_overlay_event:
4468 case bp_longjmp_master:
4469 case bp_std_terminate_master:
4470 case bp_exception_master:
4471 this_action = BPSTAT_WHAT_SINGLE;
4472 break;
4473 case bp_catchpoint:
4474 if (bs->stop)
4475 {
4476 if (bs->print)
4477 this_action = BPSTAT_WHAT_STOP_NOISY;
4478 else
4479 this_action = BPSTAT_WHAT_STOP_SILENT;
4480 }
4481 else
4482 {
4483 /* There was a catchpoint, but we're not stopping.
4484 This requires no further action. */
4485 }
4486 break;
4487 case bp_shlib_event:
4488 shlib_event = 1;
4489
4490 /* If requested, stop when the dynamic linker notifies GDB
4491 of events. This allows the user to get control and place
4492 breakpoints in initializer routines for dynamically
4493 loaded objects (among other things). */
4494 if (stop_on_solib_events)
4495 this_action = BPSTAT_WHAT_STOP_NOISY;
4496 else
4497 this_action = BPSTAT_WHAT_SINGLE;
4498 break;
4499 case bp_jit_event:
4500 jit_event = 1;
4501 this_action = BPSTAT_WHAT_SINGLE;
4502 break;
4503 case bp_call_dummy:
4504 /* Make sure the action is stop (silent or noisy),
4505 so infrun.c pops the dummy frame. */
4506 retval.call_dummy = STOP_STACK_DUMMY;
4507 this_action = BPSTAT_WHAT_STOP_SILENT;
4508 break;
4509 case bp_std_terminate:
4510 /* Make sure the action is stop (silent or noisy),
4511 so infrun.c pops the dummy frame. */
4512 retval.call_dummy = STOP_STD_TERMINATE;
4513 this_action = BPSTAT_WHAT_STOP_SILENT;
4514 break;
4515 case bp_tracepoint:
4516 case bp_fast_tracepoint:
4517 case bp_static_tracepoint:
4518 /* Tracepoint hits should not be reported back to GDB, and
4519 if one got through somehow, it should have been filtered
4520 out already. */
4521 internal_error (__FILE__, __LINE__,
4522 _("bpstat_what: tracepoint encountered"));
4523 break;
4524 case bp_gnu_ifunc_resolver:
4525 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
4526 this_action = BPSTAT_WHAT_SINGLE;
4527 break;
4528 case bp_gnu_ifunc_resolver_return:
4529 /* The breakpoint will be removed, execution will restart from the
4530 PC of the former breakpoint. */
4531 this_action = BPSTAT_WHAT_KEEP_CHECKING;
4532 break;
4533 default:
4534 internal_error (__FILE__, __LINE__,
4535 _("bpstat_what: unhandled bptype %d"), (int) bptype);
4536 }
4537
4538 retval.main_action = max (retval.main_action, this_action);
4539 }
4540
4541 /* These operations may affect the bs->breakpoint_at state so they are
4542 delayed after MAIN_ACTION is decided above. */
4543
4544 if (shlib_event)
4545 {
4546 if (debug_infrun)
4547 fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_shlib_event\n");
4548
4549 /* Check for any newly added shared libraries if we're supposed
4550 to be adding them automatically. */
4551
4552 /* Switch terminal for any messages produced by
4553 breakpoint_re_set. */
4554 target_terminal_ours_for_output ();
4555
4556 #ifdef SOLIB_ADD
4557 SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add);
4558 #else
4559 solib_add (NULL, 0, ¤t_target, auto_solib_add);
4560 #endif
4561
4562 target_terminal_inferior ();
4563 }
4564
4565 if (jit_event)
4566 {
4567 if (debug_infrun)
4568 fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_jit_event\n");
4569
4570 handle_jit_event ();
4571 }
4572
4573 for (bs = bs_head; bs != NULL; bs = bs->next)
4574 {
4575 struct breakpoint *b = bs->breakpoint_at;
4576
4577 if (b == NULL)
4578 continue;
4579 switch (b->type)
4580 {
4581 case bp_gnu_ifunc_resolver:
4582 gnu_ifunc_resolver_stop (b);
4583 break;
4584 case bp_gnu_ifunc_resolver_return:
4585 gnu_ifunc_resolver_return_stop (b);
4586 break;
4587 }
4588 }
4589
4590 return retval;
4591 }
4592
4593 /* Nonzero if we should step constantly (e.g. watchpoints on machines
4594 without hardware support). This isn't related to a specific bpstat,
4595 just to things like whether watchpoints are set. */
4596
4597 int
bpstat_should_step(void)4598 bpstat_should_step (void)
4599 {
4600 struct breakpoint *b;
4601
4602 ALL_BREAKPOINTS (b)
4603 if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
4604 return 1;
4605 return 0;
4606 }
4607
4608 int
bpstat_causes_stop(bpstat bs)4609 bpstat_causes_stop (bpstat bs)
4610 {
4611 for (; bs != NULL; bs = bs->next)
4612 if (bs->stop)
4613 return 1;
4614
4615 return 0;
4616 }
4617
4618
4619
4620 /* Compute a string of spaces suitable to indent the next line
4621 so it starts at the position corresponding to the table column
4622 named COL_NAME in the currently active table of UIOUT. */
4623
4624 static char *
wrap_indent_at_field(struct ui_out * uiout,const char * col_name)4625 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
4626 {
4627 static char wrap_indent[80];
4628 int i, total_width, width, align;
4629 char *text;
4630
4631 total_width = 0;
4632 for (i = 1; ui_out_query_field (uiout, i, &width, &align, &text); i++)
4633 {
4634 if (strcmp (text, col_name) == 0)
4635 {
4636 gdb_assert (total_width < sizeof wrap_indent);
4637 memset (wrap_indent, ' ', total_width);
4638 wrap_indent[total_width] = 0;
4639
4640 return wrap_indent;
4641 }
4642
4643 total_width += width + 1;
4644 }
4645
4646 return NULL;
4647 }
4648
4649 /* Print the LOC location out of the list of B->LOC locations. */
4650
4651 static void
print_breakpoint_location(struct breakpoint * b,struct bp_location * loc)4652 print_breakpoint_location (struct breakpoint *b,
4653 struct bp_location *loc)
4654 {
4655 struct cleanup *old_chain = save_current_program_space ();
4656
4657 if (loc != NULL && loc->shlib_disabled)
4658 loc = NULL;
4659
4660 if (loc != NULL)
4661 set_current_program_space (loc->pspace);
4662
4663 if (b->display_canonical)
4664 ui_out_field_string (uiout, "what", b->addr_string);
4665 else if (b->source_file && loc)
4666 {
4667 struct symbol *sym
4668 = find_pc_sect_function (loc->address, loc->section);
4669 if (sym)
4670 {
4671 ui_out_text (uiout, "in ");
4672 ui_out_field_string (uiout, "func",
4673 SYMBOL_PRINT_NAME (sym));
4674 ui_out_text (uiout, " ");
4675 ui_out_wrap_hint (uiout, wrap_indent_at_field (uiout, "what"));
4676 ui_out_text (uiout, "at ");
4677 }
4678 ui_out_field_string (uiout, "file", b->source_file);
4679 ui_out_text (uiout, ":");
4680
4681 if (ui_out_is_mi_like_p (uiout))
4682 {
4683 struct symtab_and_line sal = find_pc_line (loc->address, 0);
4684 char *fullname = symtab_to_fullname (sal.symtab);
4685
4686 if (fullname)
4687 ui_out_field_string (uiout, "fullname", fullname);
4688 }
4689
4690 ui_out_field_int (uiout, "line", b->line_number);
4691 }
4692 else if (loc)
4693 {
4694 struct ui_stream *stb = ui_out_stream_new (uiout);
4695 struct cleanup *stb_chain = make_cleanup_ui_out_stream_delete (stb);
4696
4697 print_address_symbolic (loc->gdbarch, loc->address, stb->stream,
4698 demangle, "");
4699 ui_out_field_stream (uiout, "at", stb);
4700
4701 do_cleanups (stb_chain);
4702 }
4703 else
4704 ui_out_field_string (uiout, "pending", b->addr_string);
4705
4706 do_cleanups (old_chain);
4707 }
4708
4709 static const char *
bptype_string(enum bptype type)4710 bptype_string (enum bptype type)
4711 {
4712 struct ep_type_description
4713 {
4714 enum bptype type;
4715 char *description;
4716 };
4717 static struct ep_type_description bptypes[] =
4718 {
4719 {bp_none, "?deleted?"},
4720 {bp_breakpoint, "breakpoint"},
4721 {bp_hardware_breakpoint, "hw breakpoint"},
4722 {bp_until, "until"},
4723 {bp_finish, "finish"},
4724 {bp_watchpoint, "watchpoint"},
4725 {bp_hardware_watchpoint, "hw watchpoint"},
4726 {bp_read_watchpoint, "read watchpoint"},
4727 {bp_access_watchpoint, "acc watchpoint"},
4728 {bp_longjmp, "longjmp"},
4729 {bp_longjmp_resume, "longjmp resume"},
4730 {bp_exception, "exception"},
4731 {bp_exception_resume, "exception resume"},
4732 {bp_step_resume, "step resume"},
4733 {bp_watchpoint_scope, "watchpoint scope"},
4734 {bp_call_dummy, "call dummy"},
4735 {bp_std_terminate, "std::terminate"},
4736 {bp_shlib_event, "shlib events"},
4737 {bp_thread_event, "thread events"},
4738 {bp_overlay_event, "overlay events"},
4739 {bp_longjmp_master, "longjmp master"},
4740 {bp_std_terminate_master, "std::terminate master"},
4741 {bp_exception_master, "exception master"},
4742 {bp_catchpoint, "catchpoint"},
4743 {bp_tracepoint, "tracepoint"},
4744 {bp_fast_tracepoint, "fast tracepoint"},
4745 {bp_static_tracepoint, "static tracepoint"},
4746 {bp_jit_event, "jit events"},
4747 {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
4748 {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
4749 };
4750
4751 if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
4752 || ((int) type != bptypes[(int) type].type))
4753 internal_error (__FILE__, __LINE__,
4754 _("bptypes table does not describe type #%d."),
4755 (int) type);
4756
4757 return bptypes[(int) type].description;
4758 }
4759
4760 /* Print B to gdb_stdout. */
4761
4762 static void
print_one_breakpoint_location(struct breakpoint * b,struct bp_location * loc,int loc_number,struct bp_location ** last_loc,int allflag)4763 print_one_breakpoint_location (struct breakpoint *b,
4764 struct bp_location *loc,
4765 int loc_number,
4766 struct bp_location **last_loc,
4767 int allflag)
4768 {
4769 struct command_line *l;
4770 static char bpenables[] = "nynny";
4771 struct cleanup *bkpt_chain;
4772
4773 int header_of_multiple = 0;
4774 int part_of_multiple = (loc != NULL);
4775 struct value_print_options opts;
4776
4777 get_user_print_options (&opts);
4778
4779 gdb_assert (!loc || loc_number != 0);
4780 /* See comment in print_one_breakpoint concerning treatment of
4781 breakpoints with single disabled location. */
4782 if (loc == NULL
4783 && (b->loc != NULL
4784 && (b->loc->next != NULL || !b->loc->enabled)))
4785 header_of_multiple = 1;
4786 if (loc == NULL)
4787 loc = b->loc;
4788
4789 annotate_record ();
4790 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
4791
4792 /* 1 */
4793 annotate_field (0);
4794 if (part_of_multiple)
4795 {
4796 char *formatted;
4797 formatted = xstrprintf ("%d.%d", b->number, loc_number);
4798 ui_out_field_string (uiout, "number", formatted);
4799 xfree (formatted);
4800 }
4801 else
4802 {
4803 ui_out_field_int (uiout, "number", b->number);
4804 }
4805
4806 /* 2 */
4807 annotate_field (1);
4808 if (part_of_multiple)
4809 ui_out_field_skip (uiout, "type");
4810 else
4811 ui_out_field_string (uiout, "type", bptype_string (b->type));
4812
4813 /* 3 */
4814 annotate_field (2);
4815 if (part_of_multiple)
4816 ui_out_field_skip (uiout, "disp");
4817 else
4818 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
4819
4820
4821 /* 4 */
4822 annotate_field (3);
4823 if (part_of_multiple)
4824 ui_out_field_string (uiout, "enabled", loc->enabled ? "y" : "n");
4825 else
4826 ui_out_field_fmt (uiout, "enabled", "%c",
4827 bpenables[(int) b->enable_state]);
4828 ui_out_spaces (uiout, 2);
4829
4830
4831 /* 5 and 6 */
4832 if (b->ops != NULL && b->ops->print_one != NULL)
4833 {
4834 /* Although the print_one can possibly print all locations,
4835 calling it here is not likely to get any nice result. So,
4836 make sure there's just one location. */
4837 gdb_assert (b->loc == NULL || b->loc->next == NULL);
4838 b->ops->print_one (b, last_loc);
4839 }
4840 else
4841 switch (b->type)
4842 {
4843 case bp_none:
4844 internal_error (__FILE__, __LINE__,
4845 _("print_one_breakpoint: bp_none encountered\n"));
4846 break;
4847
4848 case bp_watchpoint:
4849 case bp_hardware_watchpoint:
4850 case bp_read_watchpoint:
4851 case bp_access_watchpoint:
4852 /* Field 4, the address, is omitted (which makes the columns
4853 not line up too nicely with the headers, but the effect
4854 is relatively readable). */
4855 if (opts.addressprint)
4856 ui_out_field_skip (uiout, "addr");
4857 annotate_field (5);
4858 ui_out_field_string (uiout, "what", b->exp_string);
4859 break;
4860
4861 case bp_breakpoint:
4862 case bp_hardware_breakpoint:
4863 case bp_until:
4864 case bp_finish:
4865 case bp_longjmp:
4866 case bp_longjmp_resume:
4867 case bp_exception:
4868 case bp_exception_resume:
4869 case bp_step_resume:
4870 case bp_watchpoint_scope:
4871 case bp_call_dummy:
4872 case bp_std_terminate:
4873 case bp_shlib_event:
4874 case bp_thread_event:
4875 case bp_overlay_event:
4876 case bp_longjmp_master:
4877 case bp_std_terminate_master:
4878 case bp_exception_master:
4879 case bp_tracepoint:
4880 case bp_fast_tracepoint:
4881 case bp_static_tracepoint:
4882 case bp_jit_event:
4883 case bp_gnu_ifunc_resolver:
4884 case bp_gnu_ifunc_resolver_return:
4885 if (opts.addressprint)
4886 {
4887 annotate_field (4);
4888 if (header_of_multiple)
4889 ui_out_field_string (uiout, "addr", "<MULTIPLE>");
4890 else if (b->loc == NULL || loc->shlib_disabled)
4891 ui_out_field_string (uiout, "addr", "<PENDING>");
4892 else
4893 ui_out_field_core_addr (uiout, "addr",
4894 loc->gdbarch, loc->address);
4895 }
4896 annotate_field (5);
4897 if (!header_of_multiple)
4898 print_breakpoint_location (b, loc);
4899 if (b->loc)
4900 *last_loc = b->loc;
4901 break;
4902 }
4903
4904
4905 /* For backward compatibility, don't display inferiors unless there
4906 are several. */
4907 if (loc != NULL
4908 && !header_of_multiple
4909 && (allflag
4910 || (!gdbarch_has_global_breakpoints (target_gdbarch)
4911 && (number_of_program_spaces () > 1
4912 || number_of_inferiors () > 1)
4913 /* LOC is for existing B, it cannot be in
4914 moribund_locations and thus having NULL OWNER. */
4915 && loc->owner->type != bp_catchpoint)))
4916 {
4917 struct inferior *inf;
4918 int first = 1;
4919
4920 for (inf = inferior_list; inf != NULL; inf = inf->next)
4921 {
4922 if (inf->pspace == loc->pspace)
4923 {
4924 if (first)
4925 {
4926 first = 0;
4927 ui_out_text (uiout, " inf ");
4928 }
4929 else
4930 ui_out_text (uiout, ", ");
4931 ui_out_text (uiout, plongest (inf->num));
4932 }
4933 }
4934 }
4935
4936 if (!part_of_multiple)
4937 {
4938 if (b->thread != -1)
4939 {
4940 /* FIXME: This seems to be redundant and lost here; see the
4941 "stop only in" line a little further down. */
4942 ui_out_text (uiout, " thread ");
4943 ui_out_field_int (uiout, "thread", b->thread);
4944 }
4945 else if (b->task != 0)
4946 {
4947 ui_out_text (uiout, " task ");
4948 ui_out_field_int (uiout, "task", b->task);
4949 }
4950 }
4951
4952 ui_out_text (uiout, "\n");
4953
4954 if (!part_of_multiple && b->ops && b->ops->print_one_detail)
4955 b->ops->print_one_detail (b, uiout);
4956
4957 if (!part_of_multiple && b->static_trace_marker_id)
4958 {
4959 gdb_assert (b->type == bp_static_tracepoint);
4960
4961 ui_out_text (uiout, "\tmarker id is ");
4962 ui_out_field_string (uiout, "static-tracepoint-marker-string-id",
4963 b->static_trace_marker_id);
4964 ui_out_text (uiout, "\n");
4965 }
4966
4967 if (part_of_multiple && frame_id_p (b->frame_id))
4968 {
4969 annotate_field (6);
4970 ui_out_text (uiout, "\tstop only in stack frame at ");
4971 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
4972 the frame ID. */
4973 ui_out_field_core_addr (uiout, "frame",
4974 b->gdbarch, b->frame_id.stack_addr);
4975 ui_out_text (uiout, "\n");
4976 }
4977
4978 if (!part_of_multiple && b->cond_string && !ada_exception_catchpoint_p (b))
4979 {
4980 /* We do not print the condition for Ada exception catchpoints
4981 because the condition is an internal implementation detail
4982 that we do not want to expose to the user. */
4983 annotate_field (7);
4984 if (is_tracepoint (b))
4985 ui_out_text (uiout, "\ttrace only if ");
4986 else
4987 ui_out_text (uiout, "\tstop only if ");
4988 ui_out_field_string (uiout, "cond", b->cond_string);
4989 ui_out_text (uiout, "\n");
4990 }
4991
4992 if (!part_of_multiple && b->thread != -1)
4993 {
4994 /* FIXME should make an annotation for this. */
4995 ui_out_text (uiout, "\tstop only in thread ");
4996 ui_out_field_int (uiout, "thread", b->thread);
4997 ui_out_text (uiout, "\n");
4998 }
4999
5000 if (!part_of_multiple && b->hit_count)
5001 {
5002 /* FIXME should make an annotation for this. */
5003 if (ep_is_catchpoint (b))
5004 ui_out_text (uiout, "\tcatchpoint");
5005 else
5006 ui_out_text (uiout, "\tbreakpoint");
5007 ui_out_text (uiout, " already hit ");
5008 ui_out_field_int (uiout, "times", b->hit_count);
5009 if (b->hit_count == 1)
5010 ui_out_text (uiout, " time\n");
5011 else
5012 ui_out_text (uiout, " times\n");
5013 }
5014
5015 /* Output the count also if it is zero, but only if this is mi.
5016 FIXME: Should have a better test for this. */
5017 if (ui_out_is_mi_like_p (uiout))
5018 if (!part_of_multiple && b->hit_count == 0)
5019 ui_out_field_int (uiout, "times", b->hit_count);
5020
5021 if (!part_of_multiple && b->ignore_count)
5022 {
5023 annotate_field (8);
5024 ui_out_text (uiout, "\tignore next ");
5025 ui_out_field_int (uiout, "ignore", b->ignore_count);
5026 ui_out_text (uiout, " hits\n");
5027 }
5028
5029 l = b->commands ? b->commands->commands : NULL;
5030 if (!part_of_multiple && l)
5031 {
5032 struct cleanup *script_chain;
5033
5034 annotate_field (9);
5035 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
5036 print_command_lines (uiout, l, 4);
5037 do_cleanups (script_chain);
5038 }
5039
5040 if (!part_of_multiple && b->pass_count)
5041 {
5042 annotate_field (10);
5043 ui_out_text (uiout, "\tpass count ");
5044 ui_out_field_int (uiout, "pass", b->pass_count);
5045 ui_out_text (uiout, " \n");
5046 }
5047
5048 if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
5049 {
5050 if (b->addr_string)
5051 ui_out_field_string (uiout, "original-location", b->addr_string);
5052 else if (b->exp_string)
5053 ui_out_field_string (uiout, "original-location", b->exp_string);
5054 }
5055
5056 do_cleanups (bkpt_chain);
5057 }
5058
5059 static void
print_one_breakpoint(struct breakpoint * b,struct bp_location ** last_loc,int allflag)5060 print_one_breakpoint (struct breakpoint *b,
5061 struct bp_location **last_loc,
5062 int allflag)
5063 {
5064 print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
5065
5066 /* If this breakpoint has custom print function,
5067 it's already printed. Otherwise, print individual
5068 locations, if any. */
5069 if (b->ops == NULL || b->ops->print_one == NULL)
5070 {
5071 /* If breakpoint has a single location that is disabled, we
5072 print it as if it had several locations, since otherwise it's
5073 hard to represent "breakpoint enabled, location disabled"
5074 situation.
5075
5076 Note that while hardware watchpoints have several locations
5077 internally, that's not a property exposed to user. */
5078 if (b->loc
5079 && !is_hardware_watchpoint (b)
5080 && (b->loc->next || !b->loc->enabled)
5081 && !ui_out_is_mi_like_p (uiout))
5082 {
5083 struct bp_location *loc;
5084 int n = 1;
5085 for (loc = b->loc; loc; loc = loc->next, ++n)
5086 print_one_breakpoint_location (b, loc, n, last_loc, allflag);
5087 }
5088 }
5089 }
5090
5091 static int
breakpoint_address_bits(struct breakpoint * b)5092 breakpoint_address_bits (struct breakpoint *b)
5093 {
5094 int print_address_bits = 0;
5095 struct bp_location *loc;
5096
5097 for (loc = b->loc; loc; loc = loc->next)
5098 {
5099 int addr_bit;
5100
5101 /* Software watchpoints that aren't watching memory don't have
5102 an address to print. */
5103 if (b->type == bp_watchpoint && loc->watchpoint_type == -1)
5104 continue;
5105
5106 addr_bit = gdbarch_addr_bit (loc->gdbarch);
5107 if (addr_bit > print_address_bits)
5108 print_address_bits = addr_bit;
5109 }
5110
5111 return print_address_bits;
5112 }
5113
5114 struct captured_breakpoint_query_args
5115 {
5116 int bnum;
5117 };
5118
5119 static int
do_captured_breakpoint_query(struct ui_out * uiout,void * data)5120 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
5121 {
5122 struct captured_breakpoint_query_args *args = data;
5123 struct breakpoint *b;
5124 struct bp_location *dummy_loc = NULL;
5125
5126 ALL_BREAKPOINTS (b)
5127 {
5128 if (args->bnum == b->number)
5129 {
5130 print_one_breakpoint (b, &dummy_loc, 0);
5131 return GDB_RC_OK;
5132 }
5133 }
5134 return GDB_RC_NONE;
5135 }
5136
5137 enum gdb_rc
gdb_breakpoint_query(struct ui_out * uiout,int bnum,char ** error_message)5138 gdb_breakpoint_query (struct ui_out *uiout, int bnum,
5139 char **error_message)
5140 {
5141 struct captured_breakpoint_query_args args;
5142
5143 args.bnum = bnum;
5144 /* For the moment we don't trust print_one_breakpoint() to not throw
5145 an error. */
5146 if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
5147 error_message, RETURN_MASK_ALL) < 0)
5148 return GDB_RC_FAIL;
5149 else
5150 return GDB_RC_OK;
5151 }
5152
5153 /* Return non-zero if B is user settable (breakpoints, watchpoints,
5154 catchpoints, et.al.). */
5155
5156 static int
user_settable_breakpoint(const struct breakpoint * b)5157 user_settable_breakpoint (const struct breakpoint *b)
5158 {
5159 return (b->type == bp_breakpoint
5160 || b->type == bp_catchpoint
5161 || b->type == bp_hardware_breakpoint
5162 || is_tracepoint (b)
5163 || is_watchpoint (b)
5164 || b->type == bp_gnu_ifunc_resolver);
5165 }
5166
5167 /* Return true if this breakpoint was set by the user, false if it is
5168 internal or momentary. */
5169
5170 int
user_breakpoint_p(struct breakpoint * b)5171 user_breakpoint_p (struct breakpoint *b)
5172 {
5173 return user_settable_breakpoint (b) && b->number > 0;
5174 }
5175
5176 /* Print information on user settable breakpoint (watchpoint, etc)
5177 number BNUM. If BNUM is -1 print all user-settable breakpoints.
5178 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
5179 FILTER is non-NULL, call it on each breakpoint and only include the
5180 ones for which it returns non-zero. Return the total number of
5181 breakpoints listed. */
5182
5183 static int
breakpoint_1(char * args,int allflag,int (* filter)(const struct breakpoint *))5184 breakpoint_1 (char *args, int allflag,
5185 int (*filter) (const struct breakpoint *))
5186 {
5187 struct breakpoint *b;
5188 struct bp_location *last_loc = NULL;
5189 int nr_printable_breakpoints;
5190 struct cleanup *bkpttbl_chain;
5191 struct value_print_options opts;
5192 int print_address_bits = 0;
5193 int print_type_col_width = 14;
5194
5195 get_user_print_options (&opts);
5196
5197 /* Compute the number of rows in the table, as well as the size
5198 required for address fields. */
5199 nr_printable_breakpoints = 0;
5200 ALL_BREAKPOINTS (b)
5201 {
5202 /* If we have a filter, only list the breakpoints it accepts. */
5203 if (filter && !filter (b))
5204 continue;
5205
5206 /* If we have an "args" string, it is a list of breakpoints to
5207 accept. Skip the others. */
5208 if (args != NULL && *args != '\0')
5209 {
5210 if (allflag && parse_and_eval_long (args) != b->number)
5211 continue;
5212 if (!allflag && !number_is_in_list (args, b->number))
5213 continue;
5214 }
5215
5216 if (allflag || user_breakpoint_p (b))
5217 {
5218 int addr_bit, type_len;
5219
5220 addr_bit = breakpoint_address_bits (b);
5221 if (addr_bit > print_address_bits)
5222 print_address_bits = addr_bit;
5223
5224 type_len = strlen (bptype_string (b->type));
5225 if (type_len > print_type_col_width)
5226 print_type_col_width = type_len;
5227
5228 nr_printable_breakpoints++;
5229 }
5230 }
5231
5232 if (opts.addressprint)
5233 bkpttbl_chain
5234 = make_cleanup_ui_out_table_begin_end (uiout, 6,
5235 nr_printable_breakpoints,
5236 "BreakpointTable");
5237 else
5238 bkpttbl_chain
5239 = make_cleanup_ui_out_table_begin_end (uiout, 5,
5240 nr_printable_breakpoints,
5241 "BreakpointTable");
5242
5243 if (nr_printable_breakpoints > 0)
5244 annotate_breakpoints_headers ();
5245 if (nr_printable_breakpoints > 0)
5246 annotate_field (0);
5247 ui_out_table_header (uiout, 7, ui_left, "number", "Num"); /* 1 */
5248 if (nr_printable_breakpoints > 0)
5249 annotate_field (1);
5250 ui_out_table_header (uiout, print_type_col_width, ui_left,
5251 "type", "Type"); /* 2 */
5252 if (nr_printable_breakpoints > 0)
5253 annotate_field (2);
5254 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
5255 if (nr_printable_breakpoints > 0)
5256 annotate_field (3);
5257 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
5258 if (opts.addressprint)
5259 {
5260 if (nr_printable_breakpoints > 0)
5261 annotate_field (4);
5262 if (print_address_bits <= 32)
5263 ui_out_table_header (uiout, 10, ui_left,
5264 "addr", "Address"); /* 5 */
5265 else
5266 ui_out_table_header (uiout, 18, ui_left,
5267 "addr", "Address"); /* 5 */
5268 }
5269 if (nr_printable_breakpoints > 0)
5270 annotate_field (5);
5271 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
5272 ui_out_table_body (uiout);
5273 if (nr_printable_breakpoints > 0)
5274 annotate_breakpoints_table ();
5275
5276 ALL_BREAKPOINTS (b)
5277 {
5278 QUIT;
5279 /* If we have a filter, only list the breakpoints it accepts. */
5280 if (filter && !filter (b))
5281 continue;
5282
5283 /* If we have an "args" string, it is a list of breakpoints to
5284 accept. Skip the others. */
5285
5286 if (args != NULL && *args != '\0')
5287 {
5288 if (allflag) /* maintenance info breakpoint */
5289 {
5290 if (parse_and_eval_long (args) != b->number)
5291 continue;
5292 }
5293 else /* all others */
5294 {
5295 if (!number_is_in_list (args, b->number))
5296 continue;
5297 }
5298 }
5299 /* We only print out user settable breakpoints unless the
5300 allflag is set. */
5301 if (allflag || user_breakpoint_p (b))
5302 print_one_breakpoint (b, &last_loc, allflag);
5303 }
5304
5305 do_cleanups (bkpttbl_chain);
5306
5307 if (nr_printable_breakpoints == 0)
5308 {
5309 /* If there's a filter, let the caller decide how to report
5310 empty list. */
5311 if (!filter)
5312 {
5313 if (args == NULL || *args == '\0')
5314 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
5315 else
5316 ui_out_message (uiout, 0,
5317 "No breakpoint or watchpoint matching '%s'.\n",
5318 args);
5319 }
5320 }
5321 else
5322 {
5323 if (last_loc && !server_command)
5324 set_next_address (last_loc->gdbarch, last_loc->address);
5325 }
5326
5327 /* FIXME? Should this be moved up so that it is only called when
5328 there have been breakpoints? */
5329 annotate_breakpoints_table_end ();
5330
5331 return nr_printable_breakpoints;
5332 }
5333
5334 /* Display the value of default-collect in a way that is generally
5335 compatible with the breakpoint list. */
5336
5337 static void
default_collect_info(void)5338 default_collect_info (void)
5339 {
5340 /* If it has no value (which is frequently the case), say nothing; a
5341 message like "No default-collect." gets in user's face when it's
5342 not wanted. */
5343 if (!*default_collect)
5344 return;
5345
5346 /* The following phrase lines up nicely with per-tracepoint collect
5347 actions. */
5348 ui_out_text (uiout, "default collect ");
5349 ui_out_field_string (uiout, "default-collect", default_collect);
5350 ui_out_text (uiout, " \n");
5351 }
5352
5353 static void
breakpoints_info(char * args,int from_tty)5354 breakpoints_info (char *args, int from_tty)
5355 {
5356 breakpoint_1 (args, 0, NULL);
5357
5358 default_collect_info ();
5359 }
5360
5361 static void
watchpoints_info(char * args,int from_tty)5362 watchpoints_info (char *args, int from_tty)
5363 {
5364 int num_printed = breakpoint_1 (args, 0, is_watchpoint);
5365
5366 if (num_printed == 0)
5367 {
5368 if (args == NULL || *args == '\0')
5369 ui_out_message (uiout, 0, "No watchpoints.\n");
5370 else
5371 ui_out_message (uiout, 0, "No watchpoint matching '%s'.\n", args);
5372 }
5373 }
5374
5375 static void
maintenance_info_breakpoints(char * args,int from_tty)5376 maintenance_info_breakpoints (char *args, int from_tty)
5377 {
5378 breakpoint_1 (args, 1, NULL);
5379
5380 default_collect_info ();
5381 }
5382
5383 static int
breakpoint_has_pc(struct breakpoint * b,struct program_space * pspace,CORE_ADDR pc,struct obj_section * section)5384 breakpoint_has_pc (struct breakpoint *b,
5385 struct program_space *pspace,
5386 CORE_ADDR pc, struct obj_section *section)
5387 {
5388 struct bp_location *bl = b->loc;
5389
5390 for (; bl; bl = bl->next)
5391 {
5392 if (bl->pspace == pspace
5393 && bl->address == pc
5394 && (!overlay_debugging || bl->section == section))
5395 return 1;
5396 }
5397 return 0;
5398 }
5399
5400 /* Print a message describing any breakpoints set at PC. This
5401 concerns with logical breakpoints, so we match program spaces, not
5402 address spaces. */
5403
5404 static void
describe_other_breakpoints(struct gdbarch * gdbarch,struct program_space * pspace,CORE_ADDR pc,struct obj_section * section,int thread)5405 describe_other_breakpoints (struct gdbarch *gdbarch,
5406 struct program_space *pspace, CORE_ADDR pc,
5407 struct obj_section *section, int thread)
5408 {
5409 int others = 0;
5410 struct breakpoint *b;
5411
5412 ALL_BREAKPOINTS (b)
5413 others += breakpoint_has_pc (b, pspace, pc, section);
5414 if (others > 0)
5415 {
5416 if (others == 1)
5417 printf_filtered (_("Note: breakpoint "));
5418 else /* if (others == ???) */
5419 printf_filtered (_("Note: breakpoints "));
5420 ALL_BREAKPOINTS (b)
5421 if (breakpoint_has_pc (b, pspace, pc, section))
5422 {
5423 others--;
5424 printf_filtered ("%d", b->number);
5425 if (b->thread == -1 && thread != -1)
5426 printf_filtered (" (all threads)");
5427 else if (b->thread != -1)
5428 printf_filtered (" (thread %d)", b->thread);
5429 printf_filtered ("%s%s ",
5430 ((b->enable_state == bp_disabled
5431 || b->enable_state == bp_call_disabled
5432 || b->enable_state == bp_startup_disabled)
5433 ? " (disabled)"
5434 : b->enable_state == bp_permanent
5435 ? " (permanent)"
5436 : ""),
5437 (others > 1) ? ","
5438 : ((others == 1) ? " and" : ""));
5439 }
5440 printf_filtered (_("also set at pc "));
5441 fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
5442 printf_filtered (".\n");
5443 }
5444 }
5445
5446 /* Set the default place to put a breakpoint
5447 for the `break' command with no arguments. */
5448
5449 void
set_default_breakpoint(int valid,struct program_space * pspace,CORE_ADDR addr,struct symtab * symtab,int line)5450 set_default_breakpoint (int valid, struct program_space *pspace,
5451 CORE_ADDR addr, struct symtab *symtab,
5452 int line)
5453 {
5454 default_breakpoint_valid = valid;
5455 default_breakpoint_pspace = pspace;
5456 default_breakpoint_address = addr;
5457 default_breakpoint_symtab = symtab;
5458 default_breakpoint_line = line;
5459 }
5460
5461 /* Return true iff it is meaningful to use the address member of
5462 BPT. For some breakpoint types, the address member is irrelevant
5463 and it makes no sense to attempt to compare it to other addresses
5464 (or use it for any other purpose either).
5465
5466 More specifically, each of the following breakpoint types will
5467 always have a zero valued address and we don't want to mark
5468 breakpoints of any of these types to be a duplicate of an actual
5469 breakpoint at address zero:
5470
5471 bp_watchpoint
5472 bp_catchpoint
5473
5474 */
5475
5476 static int
breakpoint_address_is_meaningful(struct breakpoint * bpt)5477 breakpoint_address_is_meaningful (struct breakpoint *bpt)
5478 {
5479 enum bptype type = bpt->type;
5480
5481 return (type != bp_watchpoint && type != bp_catchpoint);
5482 }
5483
5484 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
5485 true if LOC1 and LOC2 represent the same watchpoint location. */
5486
5487 static int
watchpoint_locations_match(struct bp_location * loc1,struct bp_location * loc2)5488 watchpoint_locations_match (struct bp_location *loc1,
5489 struct bp_location *loc2)
5490 {
5491 /* Both of them must not be in moribund_locations. */
5492 gdb_assert (loc1->owner != NULL);
5493 gdb_assert (loc2->owner != NULL);
5494
5495 /* If the target can evaluate the condition expression in hardware,
5496 then we we need to insert both watchpoints even if they are at
5497 the same place. Otherwise the watchpoint will only trigger when
5498 the condition of whichever watchpoint was inserted evaluates to
5499 true, not giving a chance for GDB to check the condition of the
5500 other watchpoint. */
5501 if ((loc1->owner->cond_exp
5502 && target_can_accel_watchpoint_condition (loc1->address,
5503 loc1->length,
5504 loc1->watchpoint_type,
5505 loc1->owner->cond_exp))
5506 || (loc2->owner->cond_exp
5507 && target_can_accel_watchpoint_condition (loc2->address,
5508 loc2->length,
5509 loc2->watchpoint_type,
5510 loc2->owner->cond_exp)))
5511 return 0;
5512
5513 /* Note that this checks the owner's type, not the location's. In
5514 case the target does not support read watchpoints, but does
5515 support access watchpoints, we'll have bp_read_watchpoint
5516 watchpoints with hw_access locations. Those should be considered
5517 duplicates of hw_read locations. The hw_read locations will
5518 become hw_access locations later. */
5519 return (loc1->owner->type == loc2->owner->type
5520 && loc1->pspace->aspace == loc2->pspace->aspace
5521 && loc1->address == loc2->address
5522 && loc1->length == loc2->length);
5523 }
5524
5525 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
5526 same breakpoint location. In most targets, this can only be true
5527 if ASPACE1 matches ASPACE2. On targets that have global
5528 breakpoints, the address space doesn't really matter. */
5529
5530 static int
breakpoint_address_match(struct address_space * aspace1,CORE_ADDR addr1,struct address_space * aspace2,CORE_ADDR addr2)5531 breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
5532 struct address_space *aspace2, CORE_ADDR addr2)
5533 {
5534 return ((gdbarch_has_global_breakpoints (target_gdbarch)
5535 || aspace1 == aspace2)
5536 && addr1 == addr2);
5537 }
5538
5539 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
5540 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
5541 matches ASPACE2. On targets that have global breakpoints, the address
5542 space doesn't really matter. */
5543
5544 static int
breakpoint_address_match_range(struct address_space * aspace1,CORE_ADDR addr1,int len1,struct address_space * aspace2,CORE_ADDR addr2)5545 breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
5546 int len1, struct address_space *aspace2,
5547 CORE_ADDR addr2)
5548 {
5549 return ((gdbarch_has_global_breakpoints (target_gdbarch)
5550 || aspace1 == aspace2)
5551 && addr2 >= addr1 && addr2 < addr1 + len1);
5552 }
5553
5554 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
5555 a ranged breakpoint. In most targets, a match happens only if ASPACE
5556 matches the breakpoint's address space. On targets that have global
5557 breakpoints, the address space doesn't really matter. */
5558
5559 static int
breakpoint_location_address_match(struct bp_location * bl,struct address_space * aspace,CORE_ADDR addr)5560 breakpoint_location_address_match (struct bp_location *bl,
5561 struct address_space *aspace,
5562 CORE_ADDR addr)
5563 {
5564 return (breakpoint_address_match (bl->pspace->aspace, bl->address,
5565 aspace, addr)
5566 || (bl->length
5567 && breakpoint_address_match_range (bl->pspace->aspace,
5568 bl->address, bl->length,
5569 aspace, addr)));
5570 }
5571
5572 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
5573 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
5574 represent the same location. */
5575
5576 static int
breakpoint_locations_match(struct bp_location * loc1,struct bp_location * loc2)5577 breakpoint_locations_match (struct bp_location *loc1,
5578 struct bp_location *loc2)
5579 {
5580 int hw_point1, hw_point2;
5581
5582 /* Both of them must not be in moribund_locations. */
5583 gdb_assert (loc1->owner != NULL);
5584 gdb_assert (loc2->owner != NULL);
5585
5586 hw_point1 = is_hardware_watchpoint (loc1->owner);
5587 hw_point2 = is_hardware_watchpoint (loc2->owner);
5588
5589 if (hw_point1 != hw_point2)
5590 return 0;
5591 else if (hw_point1)
5592 return watchpoint_locations_match (loc1, loc2);
5593 else
5594 /* We compare bp_location.length in order to cover ranged breakpoints. */
5595 return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
5596 loc2->pspace->aspace, loc2->address)
5597 && loc1->length == loc2->length);
5598 }
5599
5600 static void
breakpoint_adjustment_warning(CORE_ADDR from_addr,CORE_ADDR to_addr,int bnum,int have_bnum)5601 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
5602 int bnum, int have_bnum)
5603 {
5604 /* The longest string possibly returned by hex_string_custom
5605 is 50 chars. These must be at least that big for safety. */
5606 char astr1[64];
5607 char astr2[64];
5608
5609 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
5610 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
5611 if (have_bnum)
5612 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
5613 bnum, astr1, astr2);
5614 else
5615 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
5616 }
5617
5618 /* Adjust a breakpoint's address to account for architectural
5619 constraints on breakpoint placement. Return the adjusted address.
5620 Note: Very few targets require this kind of adjustment. For most
5621 targets, this function is simply the identity function. */
5622
5623 static CORE_ADDR
adjust_breakpoint_address(struct gdbarch * gdbarch,CORE_ADDR bpaddr,enum bptype bptype)5624 adjust_breakpoint_address (struct gdbarch *gdbarch,
5625 CORE_ADDR bpaddr, enum bptype bptype)
5626 {
5627 if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
5628 {
5629 /* Very few targets need any kind of breakpoint adjustment. */
5630 return bpaddr;
5631 }
5632 else if (bptype == bp_watchpoint
5633 || bptype == bp_hardware_watchpoint
5634 || bptype == bp_read_watchpoint
5635 || bptype == bp_access_watchpoint
5636 || bptype == bp_catchpoint)
5637 {
5638 /* Watchpoints and the various bp_catch_* eventpoints should not
5639 have their addresses modified. */
5640 return bpaddr;
5641 }
5642 else
5643 {
5644 CORE_ADDR adjusted_bpaddr;
5645
5646 /* Some targets have architectural constraints on the placement
5647 of breakpoint instructions. Obtain the adjusted address. */
5648 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
5649
5650 /* An adjusted breakpoint address can significantly alter
5651 a user's expectations. Print a warning if an adjustment
5652 is required. */
5653 if (adjusted_bpaddr != bpaddr)
5654 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
5655
5656 return adjusted_bpaddr;
5657 }
5658 }
5659
5660 /* Allocate a struct bp_location. */
5661
5662 static struct bp_location *
allocate_bp_location(struct breakpoint * bpt)5663 allocate_bp_location (struct breakpoint *bpt)
5664 {
5665 struct bp_location *loc;
5666
5667 loc = xmalloc (sizeof (struct bp_location));
5668 memset (loc, 0, sizeof (*loc));
5669
5670 loc->owner = bpt;
5671 loc->cond = NULL;
5672 loc->shlib_disabled = 0;
5673 loc->enabled = 1;
5674
5675 switch (bpt->type)
5676 {
5677 case bp_breakpoint:
5678 case bp_until:
5679 case bp_finish:
5680 case bp_longjmp:
5681 case bp_longjmp_resume:
5682 case bp_exception:
5683 case bp_exception_resume:
5684 case bp_step_resume:
5685 case bp_watchpoint_scope:
5686 case bp_call_dummy:
5687 case bp_std_terminate:
5688 case bp_shlib_event:
5689 case bp_thread_event:
5690 case bp_overlay_event:
5691 case bp_jit_event:
5692 case bp_longjmp_master:
5693 case bp_std_terminate_master:
5694 case bp_exception_master:
5695 case bp_gnu_ifunc_resolver:
5696 case bp_gnu_ifunc_resolver_return:
5697 loc->loc_type = bp_loc_software_breakpoint;
5698 break;
5699 case bp_hardware_breakpoint:
5700 loc->loc_type = bp_loc_hardware_breakpoint;
5701 break;
5702 case bp_hardware_watchpoint:
5703 case bp_read_watchpoint:
5704 case bp_access_watchpoint:
5705 loc->loc_type = bp_loc_hardware_watchpoint;
5706 break;
5707 case bp_watchpoint:
5708 case bp_catchpoint:
5709 case bp_tracepoint:
5710 case bp_fast_tracepoint:
5711 case bp_static_tracepoint:
5712 loc->loc_type = bp_loc_other;
5713 break;
5714 default:
5715 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
5716 }
5717
5718 loc->refc = 1;
5719 return loc;
5720 }
5721
5722 static void
free_bp_location(struct bp_location * loc)5723 free_bp_location (struct bp_location *loc)
5724 {
5725 if (loc->cond)
5726 xfree (loc->cond);
5727
5728 if (loc->function_name)
5729 xfree (loc->function_name);
5730
5731 xfree (loc);
5732 }
5733
5734 /* Increment reference count. */
5735
5736 static void
incref_bp_location(struct bp_location * bl)5737 incref_bp_location (struct bp_location *bl)
5738 {
5739 ++bl->refc;
5740 }
5741
5742 /* Decrement reference count. If the reference count reaches 0,
5743 destroy the bp_location. Sets *BLP to NULL. */
5744
5745 static void
decref_bp_location(struct bp_location ** blp)5746 decref_bp_location (struct bp_location **blp)
5747 {
5748 gdb_assert ((*blp)->refc > 0);
5749
5750 if (--(*blp)->refc == 0)
5751 free_bp_location (*blp);
5752 *blp = NULL;
5753 }
5754
5755 /* Helper to set_raw_breakpoint below. Creates a breakpoint that has
5756 type BPTYPE and has no locations as yet. */
5757 /* This function is used in gdbtk sources and thus can not be made
5758 static. */
5759
5760 static struct breakpoint *
set_raw_breakpoint_without_location(struct gdbarch * gdbarch,enum bptype bptype)5761 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
5762 enum bptype bptype)
5763 {
5764 struct breakpoint *b, *b1;
5765
5766 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
5767 memset (b, 0, sizeof (*b));
5768
5769 b->type = bptype;
5770 b->gdbarch = gdbarch;
5771 b->language = current_language->la_language;
5772 b->input_radix = input_radix;
5773 b->thread = -1;
5774 b->enable_state = bp_enabled;
5775 b->next = 0;
5776 b->silent = 0;
5777 b->ignore_count = 0;
5778 b->commands = NULL;
5779 b->frame_id = null_frame_id;
5780 b->forked_inferior_pid = null_ptid;
5781 b->exec_pathname = NULL;
5782 b->syscalls_to_be_caught = NULL;
5783 b->ops = NULL;
5784 b->condition_not_parsed = 0;
5785 b->py_bp_object = NULL;
5786 b->related_breakpoint = b;
5787
5788 /* Add this breakpoint to the end of the chain so that a list of
5789 breakpoints will come out in order of increasing numbers. */
5790
5791 b1 = breakpoint_chain;
5792 if (b1 == 0)
5793 breakpoint_chain = b;
5794 else
5795 {
5796 while (b1->next)
5797 b1 = b1->next;
5798 b1->next = b;
5799 }
5800 return b;
5801 }
5802
5803 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
5804 resolutions should be made as the user specified the location explicitly
5805 enough. */
5806
5807 static void
set_breakpoint_location_function(struct bp_location * loc,int explicit_loc)5808 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
5809 {
5810 gdb_assert (loc->owner != NULL);
5811
5812 if (loc->owner->type == bp_breakpoint
5813 || loc->owner->type == bp_hardware_breakpoint
5814 || is_tracepoint (loc->owner))
5815 {
5816 int is_gnu_ifunc;
5817
5818 find_pc_partial_function_gnu_ifunc (loc->address, &loc->function_name,
5819 NULL, NULL, &is_gnu_ifunc);
5820
5821 if (is_gnu_ifunc && !explicit_loc)
5822 {
5823 struct breakpoint *b = loc->owner;
5824
5825 gdb_assert (loc->pspace == current_program_space);
5826 if (gnu_ifunc_resolve_name (loc->function_name,
5827 &loc->requested_address))
5828 {
5829 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
5830 loc->address = adjust_breakpoint_address (loc->gdbarch,
5831 loc->requested_address,
5832 b->type);
5833 }
5834 else if (b->type == bp_breakpoint && b->loc == loc
5835 && loc->next == NULL && b->related_breakpoint == b)
5836 {
5837 /* Create only the whole new breakpoint of this type but do not
5838 mess more complicated breakpoints with multiple locations. */
5839 b->type = bp_gnu_ifunc_resolver;
5840 }
5841 }
5842
5843 if (loc->function_name)
5844 loc->function_name = xstrdup (loc->function_name);
5845 }
5846 }
5847
5848 /* Attempt to determine architecture of location identified by SAL. */
5849 static struct gdbarch *
get_sal_arch(struct symtab_and_line sal)5850 get_sal_arch (struct symtab_and_line sal)
5851 {
5852 if (sal.section)
5853 return get_objfile_arch (sal.section->objfile);
5854 if (sal.symtab)
5855 return get_objfile_arch (sal.symtab->objfile);
5856
5857 return NULL;
5858 }
5859
5860 /* set_raw_breakpoint is a low level routine for allocating and
5861 partially initializing a breakpoint of type BPTYPE. The newly
5862 created breakpoint's address, section, source file name, and line
5863 number are provided by SAL. The newly created and partially
5864 initialized breakpoint is added to the breakpoint chain and
5865 is also returned as the value of this function.
5866
5867 It is expected that the caller will complete the initialization of
5868 the newly created breakpoint struct as well as output any status
5869 information regarding the creation of a new breakpoint. In
5870 particular, set_raw_breakpoint does NOT set the breakpoint
5871 number! Care should be taken to not allow an error to occur
5872 prior to completing the initialization of the breakpoint. If this
5873 should happen, a bogus breakpoint will be left on the chain. */
5874
5875 struct breakpoint *
set_raw_breakpoint(struct gdbarch * gdbarch,struct symtab_and_line sal,enum bptype bptype)5876 set_raw_breakpoint (struct gdbarch *gdbarch,
5877 struct symtab_and_line sal, enum bptype bptype)
5878 {
5879 struct breakpoint *b = set_raw_breakpoint_without_location (gdbarch,
5880 bptype);
5881 CORE_ADDR adjusted_address;
5882 struct gdbarch *loc_gdbarch;
5883
5884 loc_gdbarch = get_sal_arch (sal);
5885 if (!loc_gdbarch)
5886 loc_gdbarch = b->gdbarch;
5887
5888 if (bptype != bp_catchpoint)
5889 gdb_assert (sal.pspace != NULL);
5890
5891 /* Adjust the breakpoint's address prior to allocating a location.
5892 Once we call allocate_bp_location(), that mostly uninitialized
5893 location will be placed on the location chain. Adjustment of the
5894 breakpoint may cause target_read_memory() to be called and we do
5895 not want its scan of the location chain to find a breakpoint and
5896 location that's only been partially initialized. */
5897 adjusted_address = adjust_breakpoint_address (loc_gdbarch,
5898 sal.pc, b->type);
5899
5900 b->loc = allocate_bp_location (b);
5901 b->loc->gdbarch = loc_gdbarch;
5902 b->loc->requested_address = sal.pc;
5903 b->loc->address = adjusted_address;
5904 b->loc->pspace = sal.pspace;
5905
5906 /* Store the program space that was used to set the breakpoint, for
5907 breakpoint resetting. */
5908 b->pspace = sal.pspace;
5909
5910 if (sal.symtab == NULL)
5911 b->source_file = NULL;
5912 else
5913 b->source_file = xstrdup (sal.symtab->filename);
5914 b->loc->section = sal.section;
5915 b->line_number = sal.line;
5916
5917 set_breakpoint_location_function (b->loc,
5918 sal.explicit_pc || sal.explicit_line);
5919
5920 breakpoints_changed ();
5921
5922 return b;
5923 }
5924
5925
5926 /* Note that the breakpoint object B describes a permanent breakpoint
5927 instruction, hard-wired into the inferior's code. */
5928 void
make_breakpoint_permanent(struct breakpoint * b)5929 make_breakpoint_permanent (struct breakpoint *b)
5930 {
5931 struct bp_location *bl;
5932
5933 b->enable_state = bp_permanent;
5934
5935 /* By definition, permanent breakpoints are already present in the
5936 code. Mark all locations as inserted. For now,
5937 make_breakpoint_permanent is called in just one place, so it's
5938 hard to say if it's reasonable to have permanent breakpoint with
5939 multiple locations or not, but it's easy to implmement. */
5940 for (bl = b->loc; bl; bl = bl->next)
5941 bl->inserted = 1;
5942 }
5943
5944 /* Call this routine when stepping and nexting to enable a breakpoint
5945 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
5946 initiated the operation. */
5947
5948 void
set_longjmp_breakpoint(struct thread_info * tp,struct frame_id frame)5949 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
5950 {
5951 struct breakpoint *b, *b_tmp;
5952 int thread = tp->num;
5953
5954 /* To avoid having to rescan all objfile symbols at every step,
5955 we maintain a list of continually-inserted but always disabled
5956 longjmp "master" breakpoints. Here, we simply create momentary
5957 clones of those and enable them for the requested thread. */
5958 ALL_BREAKPOINTS_SAFE (b, b_tmp)
5959 if (b->pspace == current_program_space
5960 && (b->type == bp_longjmp_master
5961 || b->type == bp_exception_master))
5962 {
5963 struct breakpoint *clone = clone_momentary_breakpoint (b);
5964
5965 clone->type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
5966 clone->thread = thread;
5967 }
5968
5969 tp->initiating_frame = frame;
5970 }
5971
5972 /* Delete all longjmp breakpoints from THREAD. */
5973 void
delete_longjmp_breakpoint(int thread)5974 delete_longjmp_breakpoint (int thread)
5975 {
5976 struct breakpoint *b, *b_tmp;
5977
5978 ALL_BREAKPOINTS_SAFE (b, b_tmp)
5979 if (b->type == bp_longjmp || b->type == bp_exception)
5980 {
5981 if (b->thread == thread)
5982 delete_breakpoint (b);
5983 }
5984 }
5985
5986 void
enable_overlay_breakpoints(void)5987 enable_overlay_breakpoints (void)
5988 {
5989 struct breakpoint *b;
5990
5991 ALL_BREAKPOINTS (b)
5992 if (b->type == bp_overlay_event)
5993 {
5994 b->enable_state = bp_enabled;
5995 update_global_location_list (1);
5996 overlay_events_enabled = 1;
5997 }
5998 }
5999
6000 void
disable_overlay_breakpoints(void)6001 disable_overlay_breakpoints (void)
6002 {
6003 struct breakpoint *b;
6004
6005 ALL_BREAKPOINTS (b)
6006 if (b->type == bp_overlay_event)
6007 {
6008 b->enable_state = bp_disabled;
6009 update_global_location_list (0);
6010 overlay_events_enabled = 0;
6011 }
6012 }
6013
6014 /* Set an active std::terminate breakpoint for each std::terminate
6015 master breakpoint. */
6016 void
set_std_terminate_breakpoint(void)6017 set_std_terminate_breakpoint (void)
6018 {
6019 struct breakpoint *b, *b_tmp;
6020
6021 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6022 if (b->pspace == current_program_space
6023 && b->type == bp_std_terminate_master)
6024 {
6025 struct breakpoint *clone = clone_momentary_breakpoint (b);
6026 clone->type = bp_std_terminate;
6027 }
6028 }
6029
6030 /* Delete all the std::terminate breakpoints. */
6031 void
delete_std_terminate_breakpoint(void)6032 delete_std_terminate_breakpoint (void)
6033 {
6034 struct breakpoint *b, *b_tmp;
6035
6036 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6037 if (b->type == bp_std_terminate)
6038 delete_breakpoint (b);
6039 }
6040
6041 struct breakpoint *
create_thread_event_breakpoint(struct gdbarch * gdbarch,CORE_ADDR address)6042 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6043 {
6044 struct breakpoint *b;
6045
6046 b = create_internal_breakpoint (gdbarch, address, bp_thread_event);
6047
6048 b->enable_state = bp_enabled;
6049 /* addr_string has to be used or breakpoint_re_set will delete me. */
6050 b->addr_string
6051 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
6052
6053 update_global_location_list_nothrow (1);
6054
6055 return b;
6056 }
6057
6058 void
remove_thread_event_breakpoints(void)6059 remove_thread_event_breakpoints (void)
6060 {
6061 struct breakpoint *b, *b_tmp;
6062
6063 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6064 if (b->type == bp_thread_event
6065 && b->loc->pspace == current_program_space)
6066 delete_breakpoint (b);
6067 }
6068
6069 struct captured_parse_breakpoint_args
6070 {
6071 char **arg_p;
6072 struct symtabs_and_lines *sals_p;
6073 struct linespec_result *canonical_p;
6074 };
6075
6076 struct lang_and_radix
6077 {
6078 enum language lang;
6079 int radix;
6080 };
6081
6082 /* Create a breakpoint for JIT code registration and unregistration. */
6083
6084 struct breakpoint *
create_jit_event_breakpoint(struct gdbarch * gdbarch,CORE_ADDR address)6085 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6086 {
6087 struct breakpoint *b;
6088
6089 b = create_internal_breakpoint (gdbarch, address, bp_jit_event);
6090 update_global_location_list_nothrow (1);
6091 return b;
6092 }
6093
6094 /* Remove JIT code registration and unregistration breakpoint(s). */
6095
6096 void
remove_jit_event_breakpoints(void)6097 remove_jit_event_breakpoints (void)
6098 {
6099 struct breakpoint *b, *b_tmp;
6100
6101 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6102 if (b->type == bp_jit_event
6103 && b->loc->pspace == current_program_space)
6104 delete_breakpoint (b);
6105 }
6106
6107 void
remove_solib_event_breakpoints(void)6108 remove_solib_event_breakpoints (void)
6109 {
6110 struct breakpoint *b, *b_tmp;
6111
6112 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6113 if (b->type == bp_shlib_event
6114 && b->loc->pspace == current_program_space)
6115 delete_breakpoint (b);
6116 }
6117
6118 struct breakpoint *
create_solib_event_breakpoint(struct gdbarch * gdbarch,CORE_ADDR address)6119 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
6120 {
6121 struct breakpoint *b;
6122
6123 b = create_internal_breakpoint (gdbarch, address, bp_shlib_event);
6124 update_global_location_list_nothrow (1);
6125 return b;
6126 }
6127
6128 /* Disable any breakpoints that are on code in shared libraries. Only
6129 apply to enabled breakpoints, disabled ones can just stay disabled. */
6130
6131 void
disable_breakpoints_in_shlibs(void)6132 disable_breakpoints_in_shlibs (void)
6133 {
6134 struct bp_location *loc, **locp_tmp;
6135
6136 ALL_BP_LOCATIONS (loc, locp_tmp)
6137 {
6138 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6139 struct breakpoint *b = loc->owner;
6140
6141 /* We apply the check to all breakpoints, including disabled for
6142 those with loc->duplicate set. This is so that when breakpoint
6143 becomes enabled, or the duplicate is removed, gdb will try to
6144 insert all breakpoints. If we don't set shlib_disabled here,
6145 we'll try to insert those breakpoints and fail. */
6146 if (((b->type == bp_breakpoint)
6147 || (b->type == bp_jit_event)
6148 || (b->type == bp_hardware_breakpoint)
6149 || (is_tracepoint (b)))
6150 && loc->pspace == current_program_space
6151 && !loc->shlib_disabled
6152 #ifdef PC_SOLIB
6153 && PC_SOLIB (loc->address)
6154 #else
6155 && solib_name_from_address (loc->pspace, loc->address)
6156 #endif
6157 )
6158 {
6159 loc->shlib_disabled = 1;
6160 }
6161 }
6162 }
6163
6164 /* Disable any breakpoints that are in in an unloaded shared library.
6165 Only apply to enabled breakpoints, disabled ones can just stay
6166 disabled. */
6167
6168 static void
disable_breakpoints_in_unloaded_shlib(struct so_list * solib)6169 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
6170 {
6171 struct bp_location *loc, **locp_tmp;
6172 int disabled_shlib_breaks = 0;
6173
6174 /* SunOS a.out shared libraries are always mapped, so do not
6175 disable breakpoints; they will only be reported as unloaded
6176 through clear_solib when GDB discards its shared library
6177 list. See clear_solib for more information. */
6178 if (exec_bfd != NULL
6179 && bfd_get_flavour (exec_bfd) == bfd_target_aout_flavour)
6180 return;
6181
6182 ALL_BP_LOCATIONS (loc, locp_tmp)
6183 {
6184 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6185 struct breakpoint *b = loc->owner;
6186
6187 if ((loc->loc_type == bp_loc_hardware_breakpoint
6188 || loc->loc_type == bp_loc_software_breakpoint)
6189 && solib->pspace == loc->pspace
6190 && !loc->shlib_disabled
6191 && (b->type == bp_breakpoint
6192 || b->type == bp_jit_event
6193 || b->type == bp_hardware_breakpoint)
6194 && solib_contains_address_p (solib, loc->address))
6195 {
6196 loc->shlib_disabled = 1;
6197 /* At this point, we cannot rely on remove_breakpoint
6198 succeeding so we must mark the breakpoint as not inserted
6199 to prevent future errors occurring in remove_breakpoints. */
6200 loc->inserted = 0;
6201 if (!disabled_shlib_breaks)
6202 {
6203 target_terminal_ours_for_output ();
6204 warning (_("Temporarily disabling breakpoints "
6205 "for unloaded shared library \"%s\""),
6206 solib->so_name);
6207 }
6208 disabled_shlib_breaks = 1;
6209 }
6210 }
6211 }
6212
6213 /* FORK & VFORK catchpoints. */
6214
6215 /* Implement the "insert" breakpoint_ops method for fork
6216 catchpoints. */
6217
6218 static int
insert_catch_fork(struct bp_location * bl)6219 insert_catch_fork (struct bp_location *bl)
6220 {
6221 return target_insert_fork_catchpoint (PIDGET (inferior_ptid));
6222 }
6223
6224 /* Implement the "remove" breakpoint_ops method for fork
6225 catchpoints. */
6226
6227 static int
remove_catch_fork(struct bp_location * bl)6228 remove_catch_fork (struct bp_location *bl)
6229 {
6230 return target_remove_fork_catchpoint (PIDGET (inferior_ptid));
6231 }
6232
6233 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
6234 catchpoints. */
6235
6236 static int
breakpoint_hit_catch_fork(const struct bp_location * bl,struct address_space * aspace,CORE_ADDR bp_addr)6237 breakpoint_hit_catch_fork (const struct bp_location *bl,
6238 struct address_space *aspace, CORE_ADDR bp_addr)
6239 {
6240 return inferior_has_forked (inferior_ptid, &bl->owner->forked_inferior_pid);
6241 }
6242
6243 /* Implement the "print_it" breakpoint_ops method for fork
6244 catchpoints. */
6245
6246 static enum print_stop_action
print_it_catch_fork(struct breakpoint * b)6247 print_it_catch_fork (struct breakpoint *b)
6248 {
6249 annotate_catchpoint (b->number);
6250 printf_filtered (_("\nCatchpoint %d (forked process %d), "),
6251 b->number, ptid_get_pid (b->forked_inferior_pid));
6252 return PRINT_SRC_AND_LOC;
6253 }
6254
6255 /* Implement the "print_one" breakpoint_ops method for fork
6256 catchpoints. */
6257
6258 static void
print_one_catch_fork(struct breakpoint * b,struct bp_location ** last_loc)6259 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
6260 {
6261 struct value_print_options opts;
6262
6263 get_user_print_options (&opts);
6264
6265 /* Field 4, the address, is omitted (which makes the columns not
6266 line up too nicely with the headers, but the effect is relatively
6267 readable). */
6268 if (opts.addressprint)
6269 ui_out_field_skip (uiout, "addr");
6270 annotate_field (5);
6271 ui_out_text (uiout, "fork");
6272 if (!ptid_equal (b->forked_inferior_pid, null_ptid))
6273 {
6274 ui_out_text (uiout, ", process ");
6275 ui_out_field_int (uiout, "what",
6276 ptid_get_pid (b->forked_inferior_pid));
6277 ui_out_spaces (uiout, 1);
6278 }
6279 }
6280
6281 /* Implement the "print_mention" breakpoint_ops method for fork
6282 catchpoints. */
6283
6284 static void
print_mention_catch_fork(struct breakpoint * b)6285 print_mention_catch_fork (struct breakpoint *b)
6286 {
6287 printf_filtered (_("Catchpoint %d (fork)"), b->number);
6288 }
6289
6290 /* Implement the "print_recreate" breakpoint_ops method for fork
6291 catchpoints. */
6292
6293 static void
print_recreate_catch_fork(struct breakpoint * b,struct ui_file * fp)6294 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
6295 {
6296 fprintf_unfiltered (fp, "catch fork");
6297 }
6298
6299 /* The breakpoint_ops structure to be used in fork catchpoints. */
6300
6301 static struct breakpoint_ops catch_fork_breakpoint_ops =
6302 {
6303 insert_catch_fork,
6304 remove_catch_fork,
6305 breakpoint_hit_catch_fork,
6306 NULL, /* resources_needed */
6307 print_it_catch_fork,
6308 print_one_catch_fork,
6309 NULL, /* print_one_detail */
6310 print_mention_catch_fork,
6311 print_recreate_catch_fork
6312 };
6313
6314 /* Implement the "insert" breakpoint_ops method for vfork
6315 catchpoints. */
6316
6317 static int
insert_catch_vfork(struct bp_location * bl)6318 insert_catch_vfork (struct bp_location *bl)
6319 {
6320 return target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
6321 }
6322
6323 /* Implement the "remove" breakpoint_ops method for vfork
6324 catchpoints. */
6325
6326 static int
remove_catch_vfork(struct bp_location * bl)6327 remove_catch_vfork (struct bp_location *bl)
6328 {
6329 return target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
6330 }
6331
6332 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
6333 catchpoints. */
6334
6335 static int
breakpoint_hit_catch_vfork(const struct bp_location * bl,struct address_space * aspace,CORE_ADDR bp_addr)6336 breakpoint_hit_catch_vfork (const struct bp_location *bl,
6337 struct address_space *aspace, CORE_ADDR bp_addr)
6338 {
6339 return inferior_has_vforked (inferior_ptid, &bl->owner->forked_inferior_pid);
6340 }
6341
6342 /* Implement the "print_it" breakpoint_ops method for vfork
6343 catchpoints. */
6344
6345 static enum print_stop_action
print_it_catch_vfork(struct breakpoint * b)6346 print_it_catch_vfork (struct breakpoint *b)
6347 {
6348 annotate_catchpoint (b->number);
6349 printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
6350 b->number, ptid_get_pid (b->forked_inferior_pid));
6351 return PRINT_SRC_AND_LOC;
6352 }
6353
6354 /* Implement the "print_one" breakpoint_ops method for vfork
6355 catchpoints. */
6356
6357 static void
print_one_catch_vfork(struct breakpoint * b,struct bp_location ** last_loc)6358 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
6359 {
6360 struct value_print_options opts;
6361
6362 get_user_print_options (&opts);
6363 /* Field 4, the address, is omitted (which makes the columns not
6364 line up too nicely with the headers, but the effect is relatively
6365 readable). */
6366 if (opts.addressprint)
6367 ui_out_field_skip (uiout, "addr");
6368 annotate_field (5);
6369 ui_out_text (uiout, "vfork");
6370 if (!ptid_equal (b->forked_inferior_pid, null_ptid))
6371 {
6372 ui_out_text (uiout, ", process ");
6373 ui_out_field_int (uiout, "what",
6374 ptid_get_pid (b->forked_inferior_pid));
6375 ui_out_spaces (uiout, 1);
6376 }
6377 }
6378
6379 /* Implement the "print_mention" breakpoint_ops method for vfork
6380 catchpoints. */
6381
6382 static void
print_mention_catch_vfork(struct breakpoint * b)6383 print_mention_catch_vfork (struct breakpoint *b)
6384 {
6385 printf_filtered (_("Catchpoint %d (vfork)"), b->number);
6386 }
6387
6388 /* Implement the "print_recreate" breakpoint_ops method for vfork
6389 catchpoints. */
6390
6391 static void
print_recreate_catch_vfork(struct breakpoint * b,struct ui_file * fp)6392 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
6393 {
6394 fprintf_unfiltered (fp, "catch vfork");
6395 }
6396
6397 /* The breakpoint_ops structure to be used in vfork catchpoints. */
6398
6399 static struct breakpoint_ops catch_vfork_breakpoint_ops =
6400 {
6401 insert_catch_vfork,
6402 remove_catch_vfork,
6403 breakpoint_hit_catch_vfork,
6404 NULL, /* resources_needed */
6405 print_it_catch_vfork,
6406 print_one_catch_vfork,
6407 NULL, /* print_one_detail */
6408 print_mention_catch_vfork,
6409 print_recreate_catch_vfork
6410 };
6411
6412 /* Implement the "insert" breakpoint_ops method for syscall
6413 catchpoints. */
6414
6415 static int
insert_catch_syscall(struct bp_location * bl)6416 insert_catch_syscall (struct bp_location *bl)
6417 {
6418 struct inferior *inf = current_inferior ();
6419
6420 ++inf->total_syscalls_count;
6421 if (!bl->owner->syscalls_to_be_caught)
6422 ++inf->any_syscall_count;
6423 else
6424 {
6425 int i, iter;
6426
6427 for (i = 0;
6428 VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter);
6429 i++)
6430 {
6431 int elem;
6432
6433 if (iter >= VEC_length (int, inf->syscalls_counts))
6434 {
6435 int old_size = VEC_length (int, inf->syscalls_counts);
6436 uintptr_t vec_addr_offset
6437 = old_size * ((uintptr_t) sizeof (int));
6438 uintptr_t vec_addr;
6439 VEC_safe_grow (int, inf->syscalls_counts, iter + 1);
6440 vec_addr = (uintptr_t) VEC_address (int, inf->syscalls_counts) +
6441 vec_addr_offset;
6442 memset ((void *) vec_addr, 0,
6443 (iter + 1 - old_size) * sizeof (int));
6444 }
6445 elem = VEC_index (int, inf->syscalls_counts, iter);
6446 VEC_replace (int, inf->syscalls_counts, iter, ++elem);
6447 }
6448 }
6449
6450 return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
6451 inf->total_syscalls_count != 0,
6452 inf->any_syscall_count,
6453 VEC_length (int, inf->syscalls_counts),
6454 VEC_address (int, inf->syscalls_counts));
6455 }
6456
6457 /* Implement the "remove" breakpoint_ops method for syscall
6458 catchpoints. */
6459
6460 static int
remove_catch_syscall(struct bp_location * bl)6461 remove_catch_syscall (struct bp_location *bl)
6462 {
6463 struct inferior *inf = current_inferior ();
6464
6465 --inf->total_syscalls_count;
6466 if (!bl->owner->syscalls_to_be_caught)
6467 --inf->any_syscall_count;
6468 else
6469 {
6470 int i, iter;
6471
6472 for (i = 0;
6473 VEC_iterate (int, bl->owner->syscalls_to_be_caught, i, iter);
6474 i++)
6475 {
6476 int elem;
6477 if (iter >= VEC_length (int, inf->syscalls_counts))
6478 /* Shouldn't happen. */
6479 continue;
6480 elem = VEC_index (int, inf->syscalls_counts, iter);
6481 VEC_replace (int, inf->syscalls_counts, iter, --elem);
6482 }
6483 }
6484
6485 return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
6486 inf->total_syscalls_count != 0,
6487 inf->any_syscall_count,
6488 VEC_length (int, inf->syscalls_counts),
6489 VEC_address (int,
6490 inf->syscalls_counts));
6491 }
6492
6493 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
6494 catchpoints. */
6495
6496 static int
breakpoint_hit_catch_syscall(const struct bp_location * bl,struct address_space * aspace,CORE_ADDR bp_addr)6497 breakpoint_hit_catch_syscall (const struct bp_location *bl,
6498 struct address_space *aspace, CORE_ADDR bp_addr)
6499 {
6500 /* We must check if we are catching specific syscalls in this
6501 breakpoint. If we are, then we must guarantee that the called
6502 syscall is the same syscall we are catching. */
6503 int syscall_number = 0;
6504 const struct breakpoint *b = bl->owner;
6505
6506 if (!inferior_has_called_syscall (inferior_ptid, &syscall_number))
6507 return 0;
6508
6509 /* Now, checking if the syscall is the same. */
6510 if (b->syscalls_to_be_caught)
6511 {
6512 int i, iter;
6513
6514 for (i = 0;
6515 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6516 i++)
6517 if (syscall_number == iter)
6518 break;
6519 /* Not the same. */
6520 if (!iter)
6521 return 0;
6522 }
6523
6524 return 1;
6525 }
6526
6527 /* Implement the "print_it" breakpoint_ops method for syscall
6528 catchpoints. */
6529
6530 static enum print_stop_action
print_it_catch_syscall(struct breakpoint * b)6531 print_it_catch_syscall (struct breakpoint *b)
6532 {
6533 /* These are needed because we want to know in which state a
6534 syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
6535 or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
6536 must print "called syscall" or "returned from syscall". */
6537 ptid_t ptid;
6538 struct target_waitstatus last;
6539 struct syscall s;
6540 struct cleanup *old_chain;
6541 char *syscall_id;
6542
6543 get_last_target_status (&ptid, &last);
6544
6545 get_syscall_by_number (last.value.syscall_number, &s);
6546
6547 annotate_catchpoint (b->number);
6548
6549 if (s.name == NULL)
6550 syscall_id = xstrprintf ("%d", last.value.syscall_number);
6551 else
6552 syscall_id = xstrprintf ("'%s'", s.name);
6553
6554 old_chain = make_cleanup (xfree, syscall_id);
6555
6556 if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
6557 printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
6558 b->number, syscall_id);
6559 else if (last.kind == TARGET_WAITKIND_SYSCALL_RETURN)
6560 printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
6561 b->number, syscall_id);
6562
6563 do_cleanups (old_chain);
6564
6565 return PRINT_SRC_AND_LOC;
6566 }
6567
6568 /* Implement the "print_one" breakpoint_ops method for syscall
6569 catchpoints. */
6570
6571 static void
print_one_catch_syscall(struct breakpoint * b,struct bp_location ** last_loc)6572 print_one_catch_syscall (struct breakpoint *b,
6573 struct bp_location **last_loc)
6574 {
6575 struct value_print_options opts;
6576
6577 get_user_print_options (&opts);
6578 /* Field 4, the address, is omitted (which makes the columns not
6579 line up too nicely with the headers, but the effect is relatively
6580 readable). */
6581 if (opts.addressprint)
6582 ui_out_field_skip (uiout, "addr");
6583 annotate_field (5);
6584
6585 if (b->syscalls_to_be_caught
6586 && VEC_length (int, b->syscalls_to_be_caught) > 1)
6587 ui_out_text (uiout, "syscalls \"");
6588 else
6589 ui_out_text (uiout, "syscall \"");
6590
6591 if (b->syscalls_to_be_caught)
6592 {
6593 int i, iter;
6594 char *text = xstrprintf ("%s", "");
6595
6596 for (i = 0;
6597 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6598 i++)
6599 {
6600 char *x = text;
6601 struct syscall s;
6602 get_syscall_by_number (iter, &s);
6603
6604 if (s.name != NULL)
6605 text = xstrprintf ("%s%s, ", text, s.name);
6606 else
6607 text = xstrprintf ("%s%d, ", text, iter);
6608
6609 /* We have to xfree the last 'text' (now stored at 'x')
6610 because xstrprintf dinamically allocates new space for it
6611 on every call. */
6612 xfree (x);
6613 }
6614 /* Remove the last comma. */
6615 text[strlen (text) - 2] = '\0';
6616 ui_out_field_string (uiout, "what", text);
6617 }
6618 else
6619 ui_out_field_string (uiout, "what", "<any syscall>");
6620 ui_out_text (uiout, "\" ");
6621 }
6622
6623 /* Implement the "print_mention" breakpoint_ops method for syscall
6624 catchpoints. */
6625
6626 static void
print_mention_catch_syscall(struct breakpoint * b)6627 print_mention_catch_syscall (struct breakpoint *b)
6628 {
6629 if (b->syscalls_to_be_caught)
6630 {
6631 int i, iter;
6632
6633 if (VEC_length (int, b->syscalls_to_be_caught) > 1)
6634 printf_filtered (_("Catchpoint %d (syscalls"), b->number);
6635 else
6636 printf_filtered (_("Catchpoint %d (syscall"), b->number);
6637
6638 for (i = 0;
6639 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6640 i++)
6641 {
6642 struct syscall s;
6643 get_syscall_by_number (iter, &s);
6644
6645 if (s.name)
6646 printf_filtered (" '%s' [%d]", s.name, s.number);
6647 else
6648 printf_filtered (" %d", s.number);
6649 }
6650 printf_filtered (")");
6651 }
6652 else
6653 printf_filtered (_("Catchpoint %d (any syscall)"),
6654 b->number);
6655 }
6656
6657 /* Implement the "print_recreate" breakpoint_ops method for syscall
6658 catchpoints. */
6659
6660 static void
print_recreate_catch_syscall(struct breakpoint * b,struct ui_file * fp)6661 print_recreate_catch_syscall (struct breakpoint *b, struct ui_file *fp)
6662 {
6663 fprintf_unfiltered (fp, "catch syscall");
6664
6665 if (b->syscalls_to_be_caught)
6666 {
6667 int i, iter;
6668
6669 for (i = 0;
6670 VEC_iterate (int, b->syscalls_to_be_caught, i, iter);
6671 i++)
6672 {
6673 struct syscall s;
6674
6675 get_syscall_by_number (iter, &s);
6676 if (s.name)
6677 fprintf_unfiltered (fp, " %s", s.name);
6678 else
6679 fprintf_unfiltered (fp, " %d", s.number);
6680 }
6681 }
6682 }
6683
6684 /* The breakpoint_ops structure to be used in syscall catchpoints. */
6685
6686 static struct breakpoint_ops catch_syscall_breakpoint_ops =
6687 {
6688 insert_catch_syscall,
6689 remove_catch_syscall,
6690 breakpoint_hit_catch_syscall,
6691 NULL, /* resources_needed */
6692 print_it_catch_syscall,
6693 print_one_catch_syscall,
6694 NULL, /* print_one_detail */
6695 print_mention_catch_syscall,
6696 print_recreate_catch_syscall
6697 };
6698
6699 /* Returns non-zero if 'b' is a syscall catchpoint. */
6700
6701 static int
syscall_catchpoint_p(struct breakpoint * b)6702 syscall_catchpoint_p (struct breakpoint *b)
6703 {
6704 return (b->ops == &catch_syscall_breakpoint_ops);
6705 }
6706
6707 /* Create a new breakpoint of the bp_catchpoint kind and return it,
6708 but does NOT mention it nor update the global location list.
6709 This is useful if you need to fill more fields in the
6710 struct breakpoint before calling mention.
6711
6712 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6713 If COND_STRING is not NULL, then store it in the breakpoint.
6714 OPS, if not NULL, is the breakpoint_ops structure associated
6715 to the catchpoint. */
6716
6717 static struct breakpoint *
create_catchpoint_without_mention(struct gdbarch * gdbarch,int tempflag,char * cond_string,struct breakpoint_ops * ops)6718 create_catchpoint_without_mention (struct gdbarch *gdbarch, int tempflag,
6719 char *cond_string,
6720 struct breakpoint_ops *ops)
6721 {
6722 struct symtab_and_line sal;
6723 struct breakpoint *b;
6724
6725 init_sal (&sal);
6726 sal.pspace = current_program_space;
6727
6728 b = set_raw_breakpoint (gdbarch, sal, bp_catchpoint);
6729 set_breakpoint_count (breakpoint_count + 1);
6730 b->number = breakpoint_count;
6731
6732 b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
6733 b->thread = -1;
6734 b->addr_string = NULL;
6735 b->enable_state = bp_enabled;
6736 b->disposition = tempflag ? disp_del : disp_donttouch;
6737 b->ops = ops;
6738
6739 return b;
6740 }
6741
6742 /* Create a new breakpoint of the bp_catchpoint kind and return it.
6743
6744 If TEMPFLAG is non-zero, then make the breakpoint temporary.
6745 If COND_STRING is not NULL, then store it in the breakpoint.
6746 OPS, if not NULL, is the breakpoint_ops structure associated
6747 to the catchpoint. */
6748
6749 static struct breakpoint *
create_catchpoint(struct gdbarch * gdbarch,int tempflag,char * cond_string,struct breakpoint_ops * ops)6750 create_catchpoint (struct gdbarch *gdbarch, int tempflag,
6751 char *cond_string, struct breakpoint_ops *ops)
6752 {
6753 struct breakpoint *b =
6754 create_catchpoint_without_mention (gdbarch, tempflag, cond_string, ops);
6755
6756 mention (b);
6757 update_global_location_list (1);
6758
6759 return b;
6760 }
6761
6762 static void
create_fork_vfork_event_catchpoint(struct gdbarch * gdbarch,int tempflag,char * cond_string,struct breakpoint_ops * ops)6763 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
6764 int tempflag, char *cond_string,
6765 struct breakpoint_ops *ops)
6766 {
6767 struct breakpoint *b
6768 = create_catchpoint (gdbarch, tempflag, cond_string, ops);
6769
6770 /* FIXME: We should put this information in a breakpoint private data
6771 area. */
6772 b->forked_inferior_pid = null_ptid;
6773 }
6774
6775 /* Exec catchpoints. */
6776
6777 static int
insert_catch_exec(struct bp_location * bl)6778 insert_catch_exec (struct bp_location *bl)
6779 {
6780 return target_insert_exec_catchpoint (PIDGET (inferior_ptid));
6781 }
6782
6783 static int
remove_catch_exec(struct bp_location * bl)6784 remove_catch_exec (struct bp_location *bl)
6785 {
6786 return target_remove_exec_catchpoint (PIDGET (inferior_ptid));
6787 }
6788
6789 static int
breakpoint_hit_catch_exec(const struct bp_location * bl,struct address_space * aspace,CORE_ADDR bp_addr)6790 breakpoint_hit_catch_exec (const struct bp_location *bl,
6791 struct address_space *aspace, CORE_ADDR bp_addr)
6792 {
6793 return inferior_has_execd (inferior_ptid, &bl->owner->exec_pathname);
6794 }
6795
6796 static enum print_stop_action
print_it_catch_exec(struct breakpoint * b)6797 print_it_catch_exec (struct breakpoint *b)
6798 {
6799 annotate_catchpoint (b->number);
6800 printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b->number,
6801 b->exec_pathname);
6802 return PRINT_SRC_AND_LOC;
6803 }
6804
6805 static void
print_one_catch_exec(struct breakpoint * b,struct bp_location ** last_loc)6806 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
6807 {
6808 struct value_print_options opts;
6809
6810 get_user_print_options (&opts);
6811
6812 /* Field 4, the address, is omitted (which makes the columns
6813 not line up too nicely with the headers, but the effect
6814 is relatively readable). */
6815 if (opts.addressprint)
6816 ui_out_field_skip (uiout, "addr");
6817 annotate_field (5);
6818 ui_out_text (uiout, "exec");
6819 if (b->exec_pathname != NULL)
6820 {
6821 ui_out_text (uiout, ", program \"");
6822 ui_out_field_string (uiout, "what", b->exec_pathname);
6823 ui_out_text (uiout, "\" ");
6824 }
6825 }
6826
6827 static void
print_mention_catch_exec(struct breakpoint * b)6828 print_mention_catch_exec (struct breakpoint *b)
6829 {
6830 printf_filtered (_("Catchpoint %d (exec)"), b->number);
6831 }
6832
6833 /* Implement the "print_recreate" breakpoint_ops method for exec
6834 catchpoints. */
6835
6836 static void
print_recreate_catch_exec(struct breakpoint * b,struct ui_file * fp)6837 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
6838 {
6839 fprintf_unfiltered (fp, "catch exec");
6840 }
6841
6842 static struct breakpoint_ops catch_exec_breakpoint_ops =
6843 {
6844 insert_catch_exec,
6845 remove_catch_exec,
6846 breakpoint_hit_catch_exec,
6847 NULL, /* resources_needed */
6848 print_it_catch_exec,
6849 print_one_catch_exec,
6850 NULL, /* print_one_detail */
6851 print_mention_catch_exec,
6852 print_recreate_catch_exec
6853 };
6854
6855 static void
create_syscall_event_catchpoint(int tempflag,VEC (int)* filter,struct breakpoint_ops * ops)6856 create_syscall_event_catchpoint (int tempflag, VEC(int) *filter,
6857 struct breakpoint_ops *ops)
6858 {
6859 struct gdbarch *gdbarch = get_current_arch ();
6860 struct breakpoint *b =
6861 create_catchpoint_without_mention (gdbarch, tempflag, NULL, ops);
6862
6863 b->syscalls_to_be_caught = filter;
6864
6865 /* Now, we have to mention the breakpoint and update the global
6866 location list. */
6867 mention (b);
6868 update_global_location_list (1);
6869 }
6870
6871 static int
hw_breakpoint_used_count(void)6872 hw_breakpoint_used_count (void)
6873 {
6874 int i = 0;
6875 struct breakpoint *b;
6876 struct bp_location *bl;
6877
6878 ALL_BREAKPOINTS (b)
6879 {
6880 if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
6881 for (bl = b->loc; bl; bl = bl->next)
6882 {
6883 /* Special types of hardware breakpoints may use more than
6884 one register. */
6885 if (b->ops && b->ops->resources_needed)
6886 i += b->ops->resources_needed (bl);
6887 else
6888 i++;
6889 }
6890 }
6891
6892 return i;
6893 }
6894
6895 static int
hw_watchpoint_used_count(enum bptype type,int * other_type_used)6896 hw_watchpoint_used_count (enum bptype type, int *other_type_used)
6897 {
6898 int i = 0;
6899 struct breakpoint *b;
6900 struct bp_location *bl;
6901
6902 *other_type_used = 0;
6903 ALL_BREAKPOINTS (b)
6904 {
6905 if (!breakpoint_enabled (b))
6906 continue;
6907
6908 if (b->type == type)
6909 for (bl = b->loc; bl; bl = bl->next)
6910 {
6911 /* Special types of hardware watchpoints may use more than
6912 one register. */
6913 if (b->ops && b->ops->resources_needed)
6914 i += b->ops->resources_needed (bl);
6915 else
6916 i++;
6917 }
6918 else if (is_hardware_watchpoint (b))
6919 *other_type_used = 1;
6920 }
6921
6922 return i;
6923 }
6924
6925 void
disable_watchpoints_before_interactive_call_start(void)6926 disable_watchpoints_before_interactive_call_start (void)
6927 {
6928 struct breakpoint *b;
6929
6930 ALL_BREAKPOINTS (b)
6931 {
6932 if (is_watchpoint (b) && breakpoint_enabled (b))
6933 {
6934 b->enable_state = bp_call_disabled;
6935 update_global_location_list (0);
6936 }
6937 }
6938 }
6939
6940 void
enable_watchpoints_after_interactive_call_stop(void)6941 enable_watchpoints_after_interactive_call_stop (void)
6942 {
6943 struct breakpoint *b;
6944
6945 ALL_BREAKPOINTS (b)
6946 {
6947 if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
6948 {
6949 b->enable_state = bp_enabled;
6950 update_global_location_list (1);
6951 }
6952 }
6953 }
6954
6955 void
disable_breakpoints_before_startup(void)6956 disable_breakpoints_before_startup (void)
6957 {
6958 struct breakpoint *b;
6959 int found = 0;
6960
6961 ALL_BREAKPOINTS (b)
6962 {
6963 if (b->pspace != current_program_space)
6964 continue;
6965
6966 if ((b->type == bp_breakpoint
6967 || b->type == bp_hardware_breakpoint)
6968 && breakpoint_enabled (b))
6969 {
6970 b->enable_state = bp_startup_disabled;
6971 found = 1;
6972 }
6973 }
6974
6975 if (found)
6976 update_global_location_list (0);
6977
6978 current_program_space->executing_startup = 1;
6979 }
6980
6981 void
enable_breakpoints_after_startup(void)6982 enable_breakpoints_after_startup (void)
6983 {
6984 struct breakpoint *b;
6985 int found = 0;
6986
6987 current_program_space->executing_startup = 0;
6988
6989 ALL_BREAKPOINTS (b)
6990 {
6991 if (b->pspace != current_program_space)
6992 continue;
6993
6994 if ((b->type == bp_breakpoint
6995 || b->type == bp_hardware_breakpoint)
6996 && b->enable_state == bp_startup_disabled)
6997 {
6998 b->enable_state = bp_enabled;
6999 found = 1;
7000 }
7001 }
7002
7003 if (found)
7004 breakpoint_re_set ();
7005 }
7006
7007
7008 /* Set a breakpoint that will evaporate an end of command
7009 at address specified by SAL.
7010 Restrict it to frame FRAME if FRAME is nonzero. */
7011
7012 struct breakpoint *
set_momentary_breakpoint(struct gdbarch * gdbarch,struct symtab_and_line sal,struct frame_id frame_id,enum bptype type)7013 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
7014 struct frame_id frame_id, enum bptype type)
7015 {
7016 struct breakpoint *b;
7017
7018 /* If FRAME_ID is valid, it should be a real frame, not an inlined
7019 one. */
7020 gdb_assert (!frame_id_inlined_p (frame_id));
7021
7022 b = set_raw_breakpoint (gdbarch, sal, type);
7023 b->enable_state = bp_enabled;
7024 b->disposition = disp_donttouch;
7025 b->frame_id = frame_id;
7026
7027 /* If we're debugging a multi-threaded program, then we want
7028 momentary breakpoints to be active in only a single thread of
7029 control. */
7030 if (in_thread_list (inferior_ptid))
7031 b->thread = pid_to_thread_id (inferior_ptid);
7032
7033 update_global_location_list_nothrow (1);
7034
7035 return b;
7036 }
7037
7038 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
7039 ORIG is NULL. */
7040
7041 struct breakpoint *
clone_momentary_breakpoint(struct breakpoint * orig)7042 clone_momentary_breakpoint (struct breakpoint *orig)
7043 {
7044 struct breakpoint *copy;
7045
7046 /* If there's nothing to clone, then return nothing. */
7047 if (orig == NULL)
7048 return NULL;
7049
7050 copy = set_raw_breakpoint_without_location (orig->gdbarch, orig->type);
7051 copy->loc = allocate_bp_location (copy);
7052 set_breakpoint_location_function (copy->loc, 1);
7053
7054 copy->loc->gdbarch = orig->loc->gdbarch;
7055 copy->loc->requested_address = orig->loc->requested_address;
7056 copy->loc->address = orig->loc->address;
7057 copy->loc->section = orig->loc->section;
7058 copy->loc->pspace = orig->loc->pspace;
7059
7060 if (orig->source_file == NULL)
7061 copy->source_file = NULL;
7062 else
7063 copy->source_file = xstrdup (orig->source_file);
7064
7065 copy->line_number = orig->line_number;
7066 copy->frame_id = orig->frame_id;
7067 copy->thread = orig->thread;
7068 copy->pspace = orig->pspace;
7069
7070 copy->enable_state = bp_enabled;
7071 copy->disposition = disp_donttouch;
7072 copy->number = internal_breakpoint_number--;
7073
7074 update_global_location_list_nothrow (0);
7075 return copy;
7076 }
7077
7078 struct breakpoint *
set_momentary_breakpoint_at_pc(struct gdbarch * gdbarch,CORE_ADDR pc,enum bptype type)7079 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
7080 enum bptype type)
7081 {
7082 struct symtab_and_line sal;
7083
7084 sal = find_pc_line (pc, 0);
7085 sal.pc = pc;
7086 sal.section = find_pc_overlay (pc);
7087 sal.explicit_pc = 1;
7088
7089 return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
7090 }
7091
7092
7093 /* Tell the user we have just set a breakpoint B. */
7094
7095 static void
mention(struct breakpoint * b)7096 mention (struct breakpoint *b)
7097 {
7098 int say_where = 0;
7099 struct cleanup *ui_out_chain;
7100 struct value_print_options opts;
7101
7102 get_user_print_options (&opts);
7103
7104 /* FIXME: This is misplaced; mention() is called by things (like
7105 hitting a watchpoint) other than breakpoint creation. It should
7106 be possible to clean this up and at the same time replace the
7107 random calls to breakpoint_changed with this hook. */
7108 observer_notify_breakpoint_created (b->number);
7109
7110 if (b->ops != NULL && b->ops->print_mention != NULL)
7111 b->ops->print_mention (b);
7112 else
7113 switch (b->type)
7114 {
7115 case bp_none:
7116 printf_filtered (_("(apparently deleted?) Eventpoint %d: "),
7117 b->number);
7118 break;
7119 case bp_watchpoint:
7120 ui_out_text (uiout, "Watchpoint ");
7121 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
7122 ui_out_field_int (uiout, "number", b->number);
7123 ui_out_text (uiout, ": ");
7124 ui_out_field_string (uiout, "exp", b->exp_string);
7125 do_cleanups (ui_out_chain);
7126 break;
7127 case bp_hardware_watchpoint:
7128 ui_out_text (uiout, "Hardware watchpoint ");
7129 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
7130 ui_out_field_int (uiout, "number", b->number);
7131 ui_out_text (uiout, ": ");
7132 ui_out_field_string (uiout, "exp", b->exp_string);
7133 do_cleanups (ui_out_chain);
7134 break;
7135 case bp_read_watchpoint:
7136 ui_out_text (uiout, "Hardware read watchpoint ");
7137 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
7138 ui_out_field_int (uiout, "number", b->number);
7139 ui_out_text (uiout, ": ");
7140 ui_out_field_string (uiout, "exp", b->exp_string);
7141 do_cleanups (ui_out_chain);
7142 break;
7143 case bp_access_watchpoint:
7144 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
7145 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
7146 ui_out_field_int (uiout, "number", b->number);
7147 ui_out_text (uiout, ": ");
7148 ui_out_field_string (uiout, "exp", b->exp_string);
7149 do_cleanups (ui_out_chain);
7150 break;
7151 case bp_breakpoint:
7152 case bp_gnu_ifunc_resolver:
7153 if (ui_out_is_mi_like_p (uiout))
7154 {
7155 say_where = 0;
7156 break;
7157 }
7158 if (b->disposition == disp_del)
7159 printf_filtered (_("Temporary breakpoint"));
7160 else
7161 printf_filtered (_("Breakpoint"));
7162 printf_filtered (_(" %d"), b->number);
7163 if (b->type == bp_gnu_ifunc_resolver)
7164 printf_filtered (_(" at gnu-indirect-function resolver"));
7165 say_where = 1;
7166 break;
7167 case bp_hardware_breakpoint:
7168 if (ui_out_is_mi_like_p (uiout))
7169 {
7170 say_where = 0;
7171 break;
7172 }
7173 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
7174 say_where = 1;
7175 break;
7176 case bp_tracepoint:
7177 if (ui_out_is_mi_like_p (uiout))
7178 {
7179 say_where = 0;
7180 break;
7181 }
7182 printf_filtered (_("Tracepoint"));
7183 printf_filtered (_(" %d"), b->number);
7184 say_where = 1;
7185 break;
7186 case bp_fast_tracepoint:
7187 if (ui_out_is_mi_like_p (uiout))
7188 {
7189 say_where = 0;
7190 break;
7191 }
7192 printf_filtered (_("Fast tracepoint"));
7193 printf_filtered (_(" %d"), b->number);
7194 say_where = 1;
7195 break;
7196 case bp_static_tracepoint:
7197 if (ui_out_is_mi_like_p (uiout))
7198 {
7199 say_where = 0;
7200 break;
7201 }
7202 printf_filtered (_("Static tracepoint"));
7203 printf_filtered (_(" %d"), b->number);
7204 say_where = 1;
7205 break;
7206
7207 case bp_until:
7208 case bp_finish:
7209 case bp_longjmp:
7210 case bp_longjmp_resume:
7211 case bp_exception:
7212 case bp_exception_resume:
7213 case bp_step_resume:
7214 case bp_call_dummy:
7215 case bp_std_terminate:
7216 case bp_watchpoint_scope:
7217 case bp_shlib_event:
7218 case bp_thread_event:
7219 case bp_overlay_event:
7220 case bp_jit_event:
7221 case bp_longjmp_master:
7222 case bp_std_terminate_master:
7223 case bp_exception_master:
7224 case bp_gnu_ifunc_resolver_return:
7225 break;
7226 }
7227
7228 if (say_where)
7229 {
7230 /* i18n: cagney/2005-02-11: Below needs to be merged into a
7231 single string. */
7232 if (b->loc == NULL)
7233 {
7234 printf_filtered (_(" (%s) pending."), b->addr_string);
7235 }
7236 else
7237 {
7238 if (opts.addressprint || b->source_file == NULL)
7239 {
7240 printf_filtered (" at ");
7241 fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
7242 gdb_stdout);
7243 }
7244 if (b->source_file)
7245 printf_filtered (": file %s, line %d.",
7246 b->source_file, b->line_number);
7247
7248 if (b->loc->next)
7249 {
7250 struct bp_location *loc = b->loc;
7251 int n = 0;
7252 for (; loc; loc = loc->next)
7253 ++n;
7254 printf_filtered (" (%d locations)", n);
7255 }
7256
7257 }
7258 }
7259 if (ui_out_is_mi_like_p (uiout))
7260 return;
7261 printf_filtered ("\n");
7262 }
7263
7264
7265 static struct bp_location *
add_location_to_breakpoint(struct breakpoint * b,const struct symtab_and_line * sal)7266 add_location_to_breakpoint (struct breakpoint *b,
7267 const struct symtab_and_line *sal)
7268 {
7269 struct bp_location *loc, **tmp;
7270
7271 loc = allocate_bp_location (b);
7272 for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
7273 ;
7274 *tmp = loc;
7275 loc->gdbarch = get_sal_arch (*sal);
7276 if (!loc->gdbarch)
7277 loc->gdbarch = b->gdbarch;
7278 loc->requested_address = sal->pc;
7279 loc->address = adjust_breakpoint_address (loc->gdbarch,
7280 loc->requested_address, b->type);
7281 loc->pspace = sal->pspace;
7282 gdb_assert (loc->pspace != NULL);
7283 loc->section = sal->section;
7284
7285 set_breakpoint_location_function (loc,
7286 sal->explicit_pc || sal->explicit_line);
7287 return loc;
7288 }
7289
7290
7291 /* Return 1 if LOC is pointing to a permanent breakpoint,
7292 return 0 otherwise. */
7293
7294 static int
bp_loc_is_permanent(struct bp_location * loc)7295 bp_loc_is_permanent (struct bp_location *loc)
7296 {
7297 int len;
7298 CORE_ADDR addr;
7299 const gdb_byte *brk;
7300 gdb_byte *target_mem;
7301 struct cleanup *cleanup;
7302 int retval = 0;
7303
7304 gdb_assert (loc != NULL);
7305
7306 addr = loc->address;
7307 brk = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
7308
7309 /* Software breakpoints unsupported? */
7310 if (brk == NULL)
7311 return 0;
7312
7313 target_mem = alloca (len);
7314
7315 /* Enable the automatic memory restoration from breakpoints while
7316 we read the memory. Otherwise we could say about our temporary
7317 breakpoints they are permanent. */
7318 cleanup = save_current_space_and_thread ();
7319
7320 switch_to_program_space_and_thread (loc->pspace);
7321 make_show_memory_breakpoints_cleanup (0);
7322
7323 if (target_read_memory (loc->address, target_mem, len) == 0
7324 && memcmp (target_mem, brk, len) == 0)
7325 retval = 1;
7326
7327 do_cleanups (cleanup);
7328
7329 return retval;
7330 }
7331
7332
7333
7334 /* Create a breakpoint with SAL as location. Use ADDR_STRING
7335 as textual description of the location, and COND_STRING
7336 as condition expression. */
7337
7338 static void
create_breakpoint_sal(struct gdbarch * gdbarch,struct symtabs_and_lines sals,char * addr_string,char * cond_string,enum bptype type,enum bpdisp disposition,int thread,int task,int ignore_count,struct breakpoint_ops * ops,int from_tty,int enabled,int internal,int display_canonical)7339 create_breakpoint_sal (struct gdbarch *gdbarch,
7340 struct symtabs_and_lines sals, char *addr_string,
7341 char *cond_string,
7342 enum bptype type, enum bpdisp disposition,
7343 int thread, int task, int ignore_count,
7344 struct breakpoint_ops *ops, int from_tty,
7345 int enabled, int internal, int display_canonical)
7346 {
7347 struct breakpoint *b = NULL;
7348 int i;
7349
7350 if (type == bp_hardware_breakpoint)
7351 {
7352 int i = hw_breakpoint_used_count ();
7353 int target_resources_ok =
7354 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
7355 i + 1, 0);
7356 if (target_resources_ok == 0)
7357 error (_("No hardware breakpoint support in the target."));
7358 else if (target_resources_ok < 0)
7359 error (_("Hardware breakpoints used exceeds limit."));
7360 }
7361
7362 gdb_assert (sals.nelts > 0);
7363
7364 for (i = 0; i < sals.nelts; ++i)
7365 {
7366 struct symtab_and_line sal = sals.sals[i];
7367 struct bp_location *loc;
7368
7369 if (from_tty)
7370 {
7371 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
7372 if (!loc_gdbarch)
7373 loc_gdbarch = gdbarch;
7374
7375 describe_other_breakpoints (loc_gdbarch,
7376 sal.pspace, sal.pc, sal.section, thread);
7377 }
7378
7379 if (i == 0)
7380 {
7381 b = set_raw_breakpoint (gdbarch, sal, type);
7382 set_breakpoint_number (internal, b);
7383 b->thread = thread;
7384 b->task = task;
7385
7386 b->cond_string = cond_string;
7387 b->ignore_count = ignore_count;
7388 b->enable_state = enabled ? bp_enabled : bp_disabled;
7389 b->disposition = disposition;
7390 b->pspace = sals.sals[0].pspace;
7391
7392 if (type == bp_static_tracepoint)
7393 {
7394 struct static_tracepoint_marker marker;
7395
7396 if (is_marker_spec (addr_string))
7397 {
7398 /* We already know the marker exists, otherwise, we
7399 wouldn't see a sal for it. */
7400 char *p = &addr_string[3];
7401 char *endp;
7402 char *marker_str;
7403 int i;
7404
7405 p = skip_spaces (p);
7406
7407 endp = skip_to_space (p);
7408
7409 marker_str = savestring (p, endp - p);
7410 b->static_trace_marker_id = marker_str;
7411
7412 printf_filtered (_("Probed static tracepoint "
7413 "marker \"%s\"\n"),
7414 b->static_trace_marker_id);
7415 }
7416 else if (target_static_tracepoint_marker_at (sal.pc, &marker))
7417 {
7418 b->static_trace_marker_id = xstrdup (marker.str_id);
7419 release_static_tracepoint_marker (&marker);
7420
7421 printf_filtered (_("Probed static tracepoint "
7422 "marker \"%s\"\n"),
7423 b->static_trace_marker_id);
7424 }
7425 else
7426 warning (_("Couldn't determine the static "
7427 "tracepoint marker to probe"));
7428 }
7429
7430 if (enabled && b->pspace->executing_startup
7431 && (b->type == bp_breakpoint
7432 || b->type == bp_hardware_breakpoint))
7433 b->enable_state = bp_startup_disabled;
7434
7435 loc = b->loc;
7436 }
7437 else
7438 {
7439 loc = add_location_to_breakpoint (b, &sal);
7440 }
7441
7442 if (bp_loc_is_permanent (loc))
7443 make_breakpoint_permanent (b);
7444
7445 if (b->cond_string)
7446 {
7447 char *arg = b->cond_string;
7448 loc->cond = parse_exp_1 (&arg, block_for_pc (loc->address), 0);
7449 if (*arg)
7450 error (_("Garbage %s follows condition"), arg);
7451 }
7452 }
7453
7454 b->display_canonical = display_canonical;
7455 if (addr_string)
7456 b->addr_string = addr_string;
7457 else
7458 /* addr_string has to be used or breakpoint_re_set will delete
7459 me. */
7460 b->addr_string
7461 = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
7462
7463 b->ops = ops;
7464 if (internal)
7465 /* Do not mention breakpoints with a negative number, but do
7466 notify observers. */
7467 observer_notify_breakpoint_created (b->number);
7468 else
7469 mention (b);
7470 }
7471
7472 /* Remove element at INDEX_TO_REMOVE from SAL, shifting other
7473 elements to fill the void space. */
7474 static void
remove_sal(struct symtabs_and_lines * sal,int index_to_remove)7475 remove_sal (struct symtabs_and_lines *sal, int index_to_remove)
7476 {
7477 int i = index_to_remove+1;
7478 int last_index = sal->nelts-1;
7479
7480 for (;i <= last_index; ++i)
7481 sal->sals[i-1] = sal->sals[i];
7482
7483 --(sal->nelts);
7484 }
7485
7486 /* If appropriate, obtains all sals that correspond to the same file
7487 and line as SAL, in all program spaces. Users debugging with IDEs,
7488 will want to set a breakpoint at foo.c:line, and not really care
7489 about program spaces. This is done only if SAL does not have
7490 explicit PC and has line and file information. If we got just a
7491 single expanded sal, return the original.
7492
7493 Otherwise, if SAL.explicit_line is not set, filter out all sals for
7494 which the name of enclosing function is different from SAL. This
7495 makes sure that if we have breakpoint originally set in template
7496 instantiation, say foo<int>(), we won't expand SAL to locations at
7497 the same line in all existing instantiations of 'foo'. */
7498
7499 static struct symtabs_and_lines
expand_line_sal_maybe(struct symtab_and_line sal)7500 expand_line_sal_maybe (struct symtab_and_line sal)
7501 {
7502 struct symtabs_and_lines expanded;
7503 CORE_ADDR original_pc = sal.pc;
7504 char *original_function = NULL;
7505 int found;
7506 int i;
7507 struct cleanup *old_chain;
7508
7509 /* If we have explicit pc, don't expand.
7510 If we have no line number, we can't expand. */
7511 if (sal.explicit_pc || sal.line == 0 || sal.symtab == NULL)
7512 {
7513 expanded.nelts = 1;
7514 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7515 expanded.sals[0] = sal;
7516 return expanded;
7517 }
7518
7519 sal.pc = 0;
7520
7521 old_chain = save_current_space_and_thread ();
7522
7523 switch_to_program_space_and_thread (sal.pspace);
7524
7525 find_pc_partial_function (original_pc, &original_function, NULL, NULL);
7526
7527 /* Note that expand_line_sal visits *all* program spaces. */
7528 expanded = expand_line_sal (sal);
7529
7530 if (expanded.nelts == 1)
7531 {
7532 /* We had one sal, we got one sal. Return that sal, adjusting it
7533 past the function prologue if necessary. */
7534 xfree (expanded.sals);
7535 expanded.nelts = 1;
7536 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7537 sal.pc = original_pc;
7538 expanded.sals[0] = sal;
7539 skip_prologue_sal (&expanded.sals[0]);
7540 do_cleanups (old_chain);
7541 return expanded;
7542 }
7543
7544 if (!sal.explicit_line)
7545 {
7546 CORE_ADDR func_addr, func_end;
7547 for (i = 0; i < expanded.nelts; ++i)
7548 {
7549 CORE_ADDR pc = expanded.sals[i].pc;
7550 char *this_function;
7551
7552 /* We need to switch threads as well since we're about to
7553 read memory. */
7554 switch_to_program_space_and_thread (expanded.sals[i].pspace);
7555
7556 if (find_pc_partial_function (pc, &this_function,
7557 &func_addr, &func_end))
7558 {
7559 if (this_function
7560 && strcmp (this_function, original_function) != 0)
7561 {
7562 remove_sal (&expanded, i);
7563 --i;
7564 }
7565 }
7566 }
7567 }
7568
7569 /* Skip the function prologue if necessary. */
7570 for (i = 0; i < expanded.nelts; ++i)
7571 skip_prologue_sal (&expanded.sals[i]);
7572
7573 do_cleanups (old_chain);
7574
7575 if (expanded.nelts <= 1)
7576 {
7577 /* This is un ugly workaround. If we get zero expanded sals
7578 then something is really wrong. Fix that by returning the
7579 original sal. */
7580
7581 xfree (expanded.sals);
7582 expanded.nelts = 1;
7583 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
7584 sal.pc = original_pc;
7585 expanded.sals[0] = sal;
7586 return expanded;
7587 }
7588
7589 if (original_pc)
7590 {
7591 found = 0;
7592 for (i = 0; i < expanded.nelts; ++i)
7593 if (expanded.sals[i].pc == original_pc)
7594 {
7595 found = 1;
7596 break;
7597 }
7598 gdb_assert (found);
7599 }
7600
7601 return expanded;
7602 }
7603
7604 /* Add SALS.nelts breakpoints to the breakpoint table. For each
7605 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
7606 value. COND_STRING, if not NULL, specified the condition to be
7607 used for all breakpoints. Essentially the only case where
7608 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
7609 function. In that case, it's still not possible to specify
7610 separate conditions for different overloaded functions, so
7611 we take just a single condition string.
7612
7613 NOTE: If the function succeeds, the caller is expected to cleanup
7614 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
7615 array contents). If the function fails (error() is called), the
7616 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
7617 COND and SALS arrays and each of those arrays contents. */
7618
7619 static void
create_breakpoints_sal(struct gdbarch * gdbarch,struct symtabs_and_lines sals,struct linespec_result * canonical,char * cond_string,enum bptype type,enum bpdisp disposition,int thread,int task,int ignore_count,struct breakpoint_ops * ops,int from_tty,int enabled,int internal)7620 create_breakpoints_sal (struct gdbarch *gdbarch,
7621 struct symtabs_and_lines sals,
7622 struct linespec_result *canonical,
7623 char *cond_string,
7624 enum bptype type, enum bpdisp disposition,
7625 int thread, int task, int ignore_count,
7626 struct breakpoint_ops *ops, int from_tty,
7627 int enabled, int internal)
7628 {
7629 int i;
7630
7631 for (i = 0; i < sals.nelts; ++i)
7632 {
7633 struct symtabs_and_lines expanded =
7634 expand_line_sal_maybe (sals.sals[i]);
7635
7636 create_breakpoint_sal (gdbarch, expanded, canonical->canonical[i],
7637 cond_string, type, disposition,
7638 thread, task, ignore_count, ops,
7639 from_tty, enabled, internal,
7640 canonical->special_display);
7641 }
7642 }
7643
7644 /* Parse ADDRESS which is assumed to be a SAL specification possibly
7645 followed by conditionals. On return, SALS contains an array of SAL
7646 addresses found. ADDR_STRING contains a vector of (canonical)
7647 address strings. ADDRESS points to the end of the SAL.
7648
7649 The array and the line spec strings are allocated on the heap, it is
7650 the caller's responsibility to free them. */
7651
7652 static void
parse_breakpoint_sals(char ** address,struct symtabs_and_lines * sals,struct linespec_result * canonical)7653 parse_breakpoint_sals (char **address,
7654 struct symtabs_and_lines *sals,
7655 struct linespec_result *canonical)
7656 {
7657 char *addr_start = *address;
7658
7659 /* If no arg given, or if first arg is 'if ', use the default
7660 breakpoint. */
7661 if ((*address) == NULL
7662 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
7663 {
7664 if (default_breakpoint_valid)
7665 {
7666 struct symtab_and_line sal;
7667
7668 init_sal (&sal); /* Initialize to zeroes. */
7669 sals->sals = (struct symtab_and_line *)
7670 xmalloc (sizeof (struct symtab_and_line));
7671 sal.pc = default_breakpoint_address;
7672 sal.line = default_breakpoint_line;
7673 sal.symtab = default_breakpoint_symtab;
7674 sal.pspace = default_breakpoint_pspace;
7675 sal.section = find_pc_overlay (sal.pc);
7676
7677 /* "break" without arguments is equivalent to "break *PC"
7678 where PC is the default_breakpoint_address. So make sure
7679 to set sal.explicit_pc to prevent GDB from trying to
7680 expand the list of sals to include all other instances
7681 with the same symtab and line. */
7682 sal.explicit_pc = 1;
7683
7684 sals->sals[0] = sal;
7685 sals->nelts = 1;
7686 }
7687 else
7688 error (_("No default breakpoint address now."));
7689 }
7690 else
7691 {
7692 /* Force almost all breakpoints to be in terms of the
7693 current_source_symtab (which is decode_line_1's default).
7694 This should produce the results we want almost all of the
7695 time while leaving default_breakpoint_* alone.
7696
7697 ObjC: However, don't match an Objective-C method name which
7698 may have a '+' or '-' succeeded by a '[' */
7699
7700 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
7701
7702 if (default_breakpoint_valid
7703 && (!cursal.symtab
7704 || ((strchr ("+-", (*address)[0]) != NULL)
7705 && ((*address)[1] != '['))))
7706 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
7707 default_breakpoint_line, canonical);
7708 else
7709 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
7710 canonical);
7711 }
7712 /* For any SAL that didn't have a canonical string, fill one in. */
7713 if (sals->nelts > 0 && canonical->canonical == NULL)
7714 canonical->canonical = xcalloc (sals->nelts, sizeof (char **));
7715 if (addr_start != (*address))
7716 {
7717 int i;
7718
7719 for (i = 0; i < sals->nelts; i++)
7720 {
7721 /* Add the string if not present. */
7722 if (canonical->canonical[i] == NULL)
7723 canonical->canonical[i] = savestring (addr_start,
7724 (*address) - addr_start);
7725 }
7726 }
7727 }
7728
7729
7730 /* Convert each SAL into a real PC. Verify that the PC can be
7731 inserted as a breakpoint. If it can't throw an error. */
7732
7733 static void
breakpoint_sals_to_pc(struct symtabs_and_lines * sals)7734 breakpoint_sals_to_pc (struct symtabs_and_lines *sals)
7735 {
7736 int i;
7737
7738 for (i = 0; i < sals->nelts; i++)
7739 resolve_sal_pc (&sals->sals[i]);
7740 }
7741
7742 /* Fast tracepoints may have restrictions on valid locations. For
7743 instance, a fast tracepoint using a jump instead of a trap will
7744 likely have to overwrite more bytes than a trap would, and so can
7745 only be placed where the instruction is longer than the jump, or a
7746 multi-instruction sequence does not have a jump into the middle of
7747 it, etc. */
7748
7749 static void
check_fast_tracepoint_sals(struct gdbarch * gdbarch,struct symtabs_and_lines * sals)7750 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
7751 struct symtabs_and_lines *sals)
7752 {
7753 int i, rslt;
7754 struct symtab_and_line *sal;
7755 char *msg;
7756 struct cleanup *old_chain;
7757
7758 for (i = 0; i < sals->nelts; i++)
7759 {
7760 sal = &sals->sals[i];
7761
7762 rslt = gdbarch_fast_tracepoint_valid_at (gdbarch, sal->pc,
7763 NULL, &msg);
7764 old_chain = make_cleanup (xfree, msg);
7765
7766 if (!rslt)
7767 error (_("May not have a fast tracepoint at 0x%s%s"),
7768 paddress (gdbarch, sal->pc), (msg ? msg : ""));
7769
7770 do_cleanups (old_chain);
7771 }
7772 }
7773
7774 static void
do_captured_parse_breakpoint(struct ui_out * ui,void * data)7775 do_captured_parse_breakpoint (struct ui_out *ui, void *data)
7776 {
7777 struct captured_parse_breakpoint_args *args = data;
7778
7779 parse_breakpoint_sals (args->arg_p, args->sals_p, args->canonical_p);
7780 }
7781
7782 /* Given TOK, a string specification of condition and thread, as
7783 accepted by the 'break' command, extract the condition
7784 string and thread number and set *COND_STRING and *THREAD.
7785 PC identifies the context at which the condition should be parsed.
7786 If no condition is found, *COND_STRING is set to NULL.
7787 If no thread is found, *THREAD is set to -1. */
7788 static void
find_condition_and_thread(char * tok,CORE_ADDR pc,char ** cond_string,int * thread,int * task)7789 find_condition_and_thread (char *tok, CORE_ADDR pc,
7790 char **cond_string, int *thread, int *task)
7791 {
7792 *cond_string = NULL;
7793 *thread = -1;
7794 while (tok && *tok)
7795 {
7796 char *end_tok;
7797 int toklen;
7798 char *cond_start = NULL;
7799 char *cond_end = NULL;
7800
7801 tok = skip_spaces (tok);
7802
7803 end_tok = skip_to_space (tok);
7804
7805 toklen = end_tok - tok;
7806
7807 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
7808 {
7809 struct expression *expr;
7810
7811 tok = cond_start = end_tok + 1;
7812 expr = parse_exp_1 (&tok, block_for_pc (pc), 0);
7813 xfree (expr);
7814 cond_end = tok;
7815 *cond_string = savestring (cond_start,
7816 cond_end - cond_start);
7817 }
7818 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
7819 {
7820 char *tmptok;
7821
7822 tok = end_tok + 1;
7823 tmptok = tok;
7824 *thread = strtol (tok, &tok, 0);
7825 if (tok == tmptok)
7826 error (_("Junk after thread keyword."));
7827 if (!valid_thread_id (*thread))
7828 error (_("Unknown thread %d."), *thread);
7829 }
7830 else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
7831 {
7832 char *tmptok;
7833
7834 tok = end_tok + 1;
7835 tmptok = tok;
7836 *task = strtol (tok, &tok, 0);
7837 if (tok == tmptok)
7838 error (_("Junk after task keyword."));
7839 if (!valid_task_id (*task))
7840 error (_("Unknown task %d."), *task);
7841 }
7842 else
7843 error (_("Junk at end of arguments."));
7844 }
7845 }
7846
7847 /* Decode a static tracepoint marker spec. */
7848
7849 static struct symtabs_and_lines
decode_static_tracepoint_spec(char ** arg_p)7850 decode_static_tracepoint_spec (char **arg_p)
7851 {
7852 VEC(static_tracepoint_marker_p) *markers = NULL;
7853 struct symtabs_and_lines sals;
7854 struct symtab_and_line sal;
7855 struct symbol *sym;
7856 struct cleanup *old_chain;
7857 char *p = &(*arg_p)[3];
7858 char *endp;
7859 char *marker_str;
7860 int i;
7861
7862 p = skip_spaces (p);
7863
7864 endp = skip_to_space (p);
7865
7866 marker_str = savestring (p, endp - p);
7867 old_chain = make_cleanup (xfree, marker_str);
7868
7869 markers = target_static_tracepoint_markers_by_strid (marker_str);
7870 if (VEC_empty(static_tracepoint_marker_p, markers))
7871 error (_("No known static tracepoint marker named %s"), marker_str);
7872
7873 sals.nelts = VEC_length(static_tracepoint_marker_p, markers);
7874 sals.sals = xmalloc (sizeof *sals.sals * sals.nelts);
7875
7876 for (i = 0; i < sals.nelts; i++)
7877 {
7878 struct static_tracepoint_marker *marker;
7879
7880 marker = VEC_index (static_tracepoint_marker_p, markers, i);
7881
7882 init_sal (&sals.sals[i]);
7883
7884 sals.sals[i] = find_pc_line (marker->address, 0);
7885 sals.sals[i].pc = marker->address;
7886
7887 release_static_tracepoint_marker (marker);
7888 }
7889
7890 do_cleanups (old_chain);
7891
7892 *arg_p = endp;
7893 return sals;
7894 }
7895
7896 /* Set a breakpoint. This function is shared between CLI and MI
7897 functions for setting a breakpoint. This function has two major
7898 modes of operations, selected by the PARSE_CONDITION_AND_THREAD
7899 parameter. If non-zero, the function will parse arg, extracting
7900 breakpoint location, address and thread. Otherwise, ARG is just
7901 the location of breakpoint, with condition and thread specified by
7902 the COND_STRING and THREAD parameters. If INTERNAL is non-zero,
7903 the breakpoint number will be allocated from the internal
7904 breakpoint count. Returns true if any breakpoint was created;
7905 false otherwise. */
7906
7907 int
create_breakpoint(struct gdbarch * gdbarch,char * arg,char * cond_string,int thread,int parse_condition_and_thread,int tempflag,enum bptype type_wanted,int ignore_count,enum auto_boolean pending_break_support,struct breakpoint_ops * ops,int from_tty,int enabled,int internal)7908 create_breakpoint (struct gdbarch *gdbarch,
7909 char *arg, char *cond_string, int thread,
7910 int parse_condition_and_thread,
7911 int tempflag, enum bptype type_wanted,
7912 int ignore_count,
7913 enum auto_boolean pending_break_support,
7914 struct breakpoint_ops *ops,
7915 int from_tty, int enabled, int internal)
7916 {
7917 struct gdb_exception e;
7918 struct symtabs_and_lines sals;
7919 struct symtab_and_line pending_sal;
7920 char *copy_arg;
7921 char *addr_start = arg;
7922 struct linespec_result canonical;
7923 struct cleanup *old_chain;
7924 struct cleanup *bkpt_chain = NULL;
7925 struct captured_parse_breakpoint_args parse_args;
7926 int i;
7927 int pending = 0;
7928 int task = 0;
7929 int prev_bkpt_count = breakpoint_count;
7930
7931 sals.sals = NULL;
7932 sals.nelts = 0;
7933 init_linespec_result (&canonical);
7934
7935 parse_args.arg_p = &arg;
7936 parse_args.sals_p = &sals;
7937 parse_args.canonical_p = &canonical;
7938
7939 if (type_wanted == bp_static_tracepoint && is_marker_spec (arg))
7940 {
7941 int i;
7942
7943 sals = decode_static_tracepoint_spec (&arg);
7944
7945 copy_arg = savestring (addr_start, arg - addr_start);
7946 canonical.canonical = xcalloc (sals.nelts, sizeof (char **));
7947 for (i = 0; i < sals.nelts; i++)
7948 canonical.canonical[i] = xstrdup (copy_arg);
7949 goto done;
7950 }
7951
7952 e = catch_exception (uiout, do_captured_parse_breakpoint,
7953 &parse_args, RETURN_MASK_ALL);
7954
7955 /* If caller is interested in rc value from parse, set value. */
7956 switch (e.reason)
7957 {
7958 case RETURN_QUIT:
7959 throw_exception (e);
7960 case RETURN_ERROR:
7961 switch (e.error)
7962 {
7963 case NOT_FOUND_ERROR:
7964
7965 /* If pending breakpoint support is turned off, throw
7966 error. */
7967
7968 if (pending_break_support == AUTO_BOOLEAN_FALSE)
7969 throw_exception (e);
7970
7971 exception_print (gdb_stderr, e);
7972
7973 /* If pending breakpoint support is auto query and the user
7974 selects no, then simply return the error code. */
7975 if (pending_break_support == AUTO_BOOLEAN_AUTO
7976 && !nquery (_("Make breakpoint pending on "
7977 "future shared library load? ")))
7978 return 0;
7979
7980 /* At this point, either the user was queried about setting
7981 a pending breakpoint and selected yes, or pending
7982 breakpoint behavior is on and thus a pending breakpoint
7983 is defaulted on behalf of the user. */
7984 copy_arg = xstrdup (addr_start);
7985 canonical.canonical = ©_arg;
7986 sals.nelts = 1;
7987 sals.sals = &pending_sal;
7988 pending_sal.pc = 0;
7989 pending = 1;
7990 break;
7991 default:
7992 throw_exception (e);
7993 }
7994 break;
7995 default:
7996 if (!sals.nelts)
7997 return 0;
7998 }
7999
8000 done:
8001
8002 /* Create a chain of things that always need to be cleaned up. */
8003 old_chain = make_cleanup (null_cleanup, 0);
8004
8005 if (!pending)
8006 {
8007 /* Make sure that all storage allocated to SALS gets freed. */
8008 make_cleanup (xfree, sals.sals);
8009
8010 /* Cleanup the canonical array but not its contents. */
8011 make_cleanup (xfree, canonical.canonical);
8012 }
8013
8014 /* ----------------------------- SNIP -----------------------------
8015 Anything added to the cleanup chain beyond this point is assumed
8016 to be part of a breakpoint. If the breakpoint create succeeds
8017 then the memory is not reclaimed. */
8018 bkpt_chain = make_cleanup (null_cleanup, 0);
8019
8020 /* Mark the contents of the canonical for cleanup. These go on
8021 the bkpt_chain and only occur if the breakpoint create fails. */
8022 for (i = 0; i < sals.nelts; i++)
8023 {
8024 if (canonical.canonical[i] != NULL)
8025 make_cleanup (xfree, canonical.canonical[i]);
8026 }
8027
8028 /* Resolve all line numbers to PC's and verify that the addresses
8029 are ok for the target. */
8030 if (!pending)
8031 breakpoint_sals_to_pc (&sals);
8032
8033 /* Fast tracepoints may have additional restrictions on location. */
8034 if (type_wanted == bp_fast_tracepoint)
8035 check_fast_tracepoint_sals (gdbarch, &sals);
8036
8037 /* Verify that condition can be parsed, before setting any
8038 breakpoints. Allocate a separate condition expression for each
8039 breakpoint. */
8040 if (!pending)
8041 {
8042 if (parse_condition_and_thread)
8043 {
8044 /* Here we only parse 'arg' to separate condition
8045 from thread number, so parsing in context of first
8046 sal is OK. When setting the breakpoint we'll
8047 re-parse it in context of each sal. */
8048 cond_string = NULL;
8049 thread = -1;
8050 find_condition_and_thread (arg, sals.sals[0].pc, &cond_string,
8051 &thread, &task);
8052 if (cond_string)
8053 make_cleanup (xfree, cond_string);
8054 }
8055 else
8056 {
8057 /* Create a private copy of condition string. */
8058 if (cond_string)
8059 {
8060 cond_string = xstrdup (cond_string);
8061 make_cleanup (xfree, cond_string);
8062 }
8063 }
8064
8065 /* If the user is creating a static tracepoint by marker id
8066 (strace -m MARKER_ID), then store the sals index, so that
8067 breakpoint_re_set can try to match up which of the newly
8068 found markers corresponds to this one, and, don't try to
8069 expand multiple locations for each sal, given than SALS
8070 already should contain all sals for MARKER_ID. */
8071 if (type_wanted == bp_static_tracepoint
8072 && is_marker_spec (canonical.canonical[0]))
8073 {
8074 int i;
8075
8076 for (i = 0; i < sals.nelts; ++i)
8077 {
8078 struct symtabs_and_lines expanded;
8079 struct breakpoint *tp;
8080 struct cleanup *old_chain;
8081
8082 expanded.nelts = 1;
8083 expanded.sals = xmalloc (sizeof (struct symtab_and_line));
8084 expanded.sals[0] = sals.sals[i];
8085 old_chain = make_cleanup (xfree, expanded.sals);
8086
8087 create_breakpoint_sal (gdbarch, expanded, canonical.canonical[i],
8088 cond_string, type_wanted,
8089 tempflag ? disp_del : disp_donttouch,
8090 thread, task, ignore_count, ops,
8091 from_tty, enabled, internal,
8092 canonical.special_display);
8093
8094 do_cleanups (old_chain);
8095
8096 /* Get the tracepoint we just created. */
8097 if (internal)
8098 tp = get_breakpoint (internal_breakpoint_number);
8099 else
8100 tp = get_breakpoint (breakpoint_count);
8101 gdb_assert (tp != NULL);
8102
8103 /* Given that its possible to have multiple markers with
8104 the same string id, if the user is creating a static
8105 tracepoint by marker id ("strace -m MARKER_ID"), then
8106 store the sals index, so that breakpoint_re_set can
8107 try to match up which of the newly found markers
8108 corresponds to this one */
8109 tp->static_trace_marker_id_idx = i;
8110 }
8111 }
8112 else
8113 create_breakpoints_sal (gdbarch, sals, &canonical, cond_string,
8114 type_wanted,
8115 tempflag ? disp_del : disp_donttouch,
8116 thread, task, ignore_count, ops, from_tty,
8117 enabled, internal);
8118 }
8119 else
8120 {
8121 struct breakpoint *b;
8122
8123 make_cleanup (xfree, copy_arg);
8124
8125 b = set_raw_breakpoint_without_location (gdbarch, type_wanted);
8126 set_breakpoint_number (internal, b);
8127 b->thread = -1;
8128 b->addr_string = canonical.canonical[0];
8129 b->cond_string = NULL;
8130 b->ignore_count = ignore_count;
8131 b->disposition = tempflag ? disp_del : disp_donttouch;
8132 b->condition_not_parsed = 1;
8133 b->ops = ops;
8134 b->enable_state = enabled ? bp_enabled : bp_disabled;
8135 b->pspace = current_program_space;
8136 b->py_bp_object = NULL;
8137
8138 if (enabled && b->pspace->executing_startup
8139 && (b->type == bp_breakpoint
8140 || b->type == bp_hardware_breakpoint))
8141 b->enable_state = bp_startup_disabled;
8142
8143 if (internal)
8144 /* Do not mention breakpoints with a negative number,
8145 but do notify observers. */
8146 observer_notify_breakpoint_created (b->number);
8147 else
8148 mention (b);
8149 }
8150
8151 if (sals.nelts > 1)
8152 {
8153 warning (_("Multiple breakpoints were set.\nUse the "
8154 "\"delete\" command to delete unwanted breakpoints."));
8155 prev_breakpoint_count = prev_bkpt_count;
8156 }
8157
8158 /* That's it. Discard the cleanups for data inserted into the
8159 breakpoint. */
8160 discard_cleanups (bkpt_chain);
8161 /* But cleanup everything else. */
8162 do_cleanups (old_chain);
8163
8164 /* error call may happen here - have BKPT_CHAIN already discarded. */
8165 update_global_location_list (1);
8166
8167 return 1;
8168 }
8169
8170 /* Set a breakpoint.
8171 ARG is a string describing breakpoint address,
8172 condition, and thread.
8173 FLAG specifies if a breakpoint is hardware on,
8174 and if breakpoint is temporary, using BP_HARDWARE_FLAG
8175 and BP_TEMPFLAG. */
8176
8177 static void
break_command_1(char * arg,int flag,int from_tty)8178 break_command_1 (char *arg, int flag, int from_tty)
8179 {
8180 int tempflag = flag & BP_TEMPFLAG;
8181 enum bptype type_wanted = (flag & BP_HARDWAREFLAG
8182 ? bp_hardware_breakpoint
8183 : bp_breakpoint);
8184
8185 create_breakpoint (get_current_arch (),
8186 arg,
8187 NULL, 0, 1 /* parse arg */,
8188 tempflag, type_wanted,
8189 0 /* Ignore count */,
8190 pending_break_support,
8191 NULL /* breakpoint_ops */,
8192 from_tty,
8193 1 /* enabled */,
8194 0 /* internal */);
8195 }
8196
8197
8198 /* Helper function for break_command_1 and disassemble_command. */
8199
8200 void
resolve_sal_pc(struct symtab_and_line * sal)8201 resolve_sal_pc (struct symtab_and_line *sal)
8202 {
8203 CORE_ADDR pc;
8204
8205 if (sal->pc == 0 && sal->symtab != NULL)
8206 {
8207 if (!find_line_pc (sal->symtab, sal->line, &pc))
8208 error (_("No line %d in file \"%s\"."),
8209 sal->line, sal->symtab->filename);
8210 sal->pc = pc;
8211
8212 /* If this SAL corresponds to a breakpoint inserted using a line
8213 number, then skip the function prologue if necessary. */
8214 if (sal->explicit_line)
8215 skip_prologue_sal (sal);
8216 }
8217
8218 if (sal->section == 0 && sal->symtab != NULL)
8219 {
8220 struct blockvector *bv;
8221 struct block *b;
8222 struct symbol *sym;
8223
8224 bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
8225 if (bv != NULL)
8226 {
8227 sym = block_linkage_function (b);
8228 if (sym != NULL)
8229 {
8230 fixup_symbol_section (sym, sal->symtab->objfile);
8231 sal->section = SYMBOL_OBJ_SECTION (sym);
8232 }
8233 else
8234 {
8235 /* It really is worthwhile to have the section, so we'll
8236 just have to look harder. This case can be executed
8237 if we have line numbers but no functions (as can
8238 happen in assembly source). */
8239
8240 struct minimal_symbol *msym;
8241 struct cleanup *old_chain = save_current_space_and_thread ();
8242
8243 switch_to_program_space_and_thread (sal->pspace);
8244
8245 msym = lookup_minimal_symbol_by_pc (sal->pc);
8246 if (msym)
8247 sal->section = SYMBOL_OBJ_SECTION (msym);
8248
8249 do_cleanups (old_chain);
8250 }
8251 }
8252 }
8253 }
8254
8255 void
break_command(char * arg,int from_tty)8256 break_command (char *arg, int from_tty)
8257 {
8258 break_command_1 (arg, 0, from_tty);
8259 }
8260
8261 void
tbreak_command(char * arg,int from_tty)8262 tbreak_command (char *arg, int from_tty)
8263 {
8264 break_command_1 (arg, BP_TEMPFLAG, from_tty);
8265 }
8266
8267 static void
hbreak_command(char * arg,int from_tty)8268 hbreak_command (char *arg, int from_tty)
8269 {
8270 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
8271 }
8272
8273 static void
thbreak_command(char * arg,int from_tty)8274 thbreak_command (char *arg, int from_tty)
8275 {
8276 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
8277 }
8278
8279 static void
stop_command(char * arg,int from_tty)8280 stop_command (char *arg, int from_tty)
8281 {
8282 printf_filtered (_("Specify the type of breakpoint to set.\n\
8283 Usage: stop in <function | address>\n\
8284 stop at <line>\n"));
8285 }
8286
8287 static void
stopin_command(char * arg,int from_tty)8288 stopin_command (char *arg, int from_tty)
8289 {
8290 int badInput = 0;
8291
8292 if (arg == (char *) NULL)
8293 badInput = 1;
8294 else if (*arg != '*')
8295 {
8296 char *argptr = arg;
8297 int hasColon = 0;
8298
8299 /* Look for a ':'. If this is a line number specification, then
8300 say it is bad, otherwise, it should be an address or
8301 function/method name. */
8302 while (*argptr && !hasColon)
8303 {
8304 hasColon = (*argptr == ':');
8305 argptr++;
8306 }
8307
8308 if (hasColon)
8309 badInput = (*argptr != ':'); /* Not a class::method */
8310 else
8311 badInput = isdigit (*arg); /* a simple line number */
8312 }
8313
8314 if (badInput)
8315 printf_filtered (_("Usage: stop in <function | address>\n"));
8316 else
8317 break_command_1 (arg, 0, from_tty);
8318 }
8319
8320 static void
stopat_command(char * arg,int from_tty)8321 stopat_command (char *arg, int from_tty)
8322 {
8323 int badInput = 0;
8324
8325 if (arg == (char *) NULL || *arg == '*') /* no line number */
8326 badInput = 1;
8327 else
8328 {
8329 char *argptr = arg;
8330 int hasColon = 0;
8331
8332 /* Look for a ':'. If there is a '::' then get out, otherwise
8333 it is probably a line number. */
8334 while (*argptr && !hasColon)
8335 {
8336 hasColon = (*argptr == ':');
8337 argptr++;
8338 }
8339
8340 if (hasColon)
8341 badInput = (*argptr == ':'); /* we have class::method */
8342 else
8343 badInput = !isdigit (*arg); /* not a line number */
8344 }
8345
8346 if (badInput)
8347 printf_filtered (_("Usage: stop at <line>\n"));
8348 else
8349 break_command_1 (arg, 0, from_tty);
8350 }
8351
8352 /* Implement the "breakpoint_hit" breakpoint_ops method for
8353 ranged breakpoints. */
8354
8355 static int
breakpoint_hit_ranged_breakpoint(const struct bp_location * bl,struct address_space * aspace,CORE_ADDR bp_addr)8356 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
8357 struct address_space *aspace,
8358 CORE_ADDR bp_addr)
8359 {
8360 return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
8361 bl->length, aspace, bp_addr);
8362 }
8363
8364 /* Implement the "resources_needed" breakpoint_ops method for
8365 ranged breakpoints. */
8366
8367 static int
resources_needed_ranged_breakpoint(const struct bp_location * bl)8368 resources_needed_ranged_breakpoint (const struct bp_location *bl)
8369 {
8370 return target_ranged_break_num_registers ();
8371 }
8372
8373 /* Implement the "print_it" breakpoint_ops method for
8374 ranged breakpoints. */
8375
8376 static enum print_stop_action
print_it_ranged_breakpoint(struct breakpoint * b)8377 print_it_ranged_breakpoint (struct breakpoint *b)
8378 {
8379 struct bp_location *bl = b->loc;
8380
8381 gdb_assert (b->type == bp_hardware_breakpoint);
8382
8383 /* Ranged breakpoints have only one location. */
8384 gdb_assert (bl && bl->next == NULL);
8385
8386 annotate_breakpoint (b->number);
8387 if (b->disposition == disp_del)
8388 ui_out_text (uiout, "\nTemporary ranged breakpoint ");
8389 else
8390 ui_out_text (uiout, "\nRanged breakpoint ");
8391 if (ui_out_is_mi_like_p (uiout))
8392 {
8393 ui_out_field_string (uiout, "reason",
8394 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
8395 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8396 }
8397 ui_out_field_int (uiout, "bkptno", b->number);
8398 ui_out_text (uiout, ", ");
8399
8400 return PRINT_SRC_AND_LOC;
8401 }
8402
8403 /* Implement the "print_one" breakpoint_ops method for
8404 ranged breakpoints. */
8405
8406 static void
print_one_ranged_breakpoint(struct breakpoint * b,struct bp_location ** last_loc)8407 print_one_ranged_breakpoint (struct breakpoint *b,
8408 struct bp_location **last_loc)
8409 {
8410 struct bp_location *bl = b->loc;
8411 struct value_print_options opts;
8412
8413 /* Ranged breakpoints have only one location. */
8414 gdb_assert (bl && bl->next == NULL);
8415
8416 get_user_print_options (&opts);
8417
8418 if (opts.addressprint)
8419 /* We don't print the address range here, it will be printed later
8420 by print_one_detail_ranged_breakpoint. */
8421 ui_out_field_skip (uiout, "addr");
8422 annotate_field (5);
8423 print_breakpoint_location (b, bl);
8424 *last_loc = bl;
8425 }
8426
8427 /* Implement the "print_one_detail" breakpoint_ops method for
8428 ranged breakpoints. */
8429
8430 static void
print_one_detail_ranged_breakpoint(const struct breakpoint * b,struct ui_out * uiout)8431 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
8432 struct ui_out *uiout)
8433 {
8434 CORE_ADDR address_start, address_end;
8435 struct bp_location *bl = b->loc;
8436 struct ui_stream *stb = ui_out_stream_new (uiout);
8437 struct cleanup *cleanup = make_cleanup_ui_out_stream_delete (stb);
8438
8439 gdb_assert (bl);
8440
8441 address_start = bl->address;
8442 address_end = address_start + bl->length - 1;
8443
8444 ui_out_text (uiout, "\taddress range: ");
8445 fprintf_unfiltered (stb->stream, "[%s, %s]",
8446 print_core_address (bl->gdbarch, address_start),
8447 print_core_address (bl->gdbarch, address_end));
8448 ui_out_field_stream (uiout, "addr", stb);
8449 ui_out_text (uiout, "\n");
8450
8451 do_cleanups (cleanup);
8452 }
8453
8454 /* Implement the "print_mention" breakpoint_ops method for
8455 ranged breakpoints. */
8456
8457 static void
print_mention_ranged_breakpoint(struct breakpoint * b)8458 print_mention_ranged_breakpoint (struct breakpoint *b)
8459 {
8460 struct bp_location *bl = b->loc;
8461
8462 gdb_assert (bl);
8463 gdb_assert (b->type == bp_hardware_breakpoint);
8464
8465 if (ui_out_is_mi_like_p (uiout))
8466 return;
8467
8468 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
8469 b->number, paddress (bl->gdbarch, bl->address),
8470 paddress (bl->gdbarch, bl->address + bl->length - 1));
8471 }
8472
8473 /* Implement the "print_recreate" breakpoint_ops method for
8474 ranged breakpoints. */
8475
8476 static void
print_recreate_ranged_breakpoint(struct breakpoint * b,struct ui_file * fp)8477 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
8478 {
8479 fprintf_unfiltered (fp, "break-range %s, %s", b->addr_string,
8480 b->addr_string_range_end);
8481 }
8482
8483 /* The breakpoint_ops structure to be used in ranged breakpoints. */
8484
8485 static struct breakpoint_ops ranged_breakpoint_ops =
8486 {
8487 NULL, /* insert */
8488 NULL, /* remove */
8489 breakpoint_hit_ranged_breakpoint,
8490 resources_needed_ranged_breakpoint,
8491 print_it_ranged_breakpoint,
8492 print_one_ranged_breakpoint,
8493 print_one_detail_ranged_breakpoint,
8494 print_mention_ranged_breakpoint,
8495 print_recreate_ranged_breakpoint
8496 };
8497
8498 /* Find the address where the end of the breakpoint range should be
8499 placed, given the SAL of the end of the range. This is so that if
8500 the user provides a line number, the end of the range is set to the
8501 last instruction of the given line. */
8502
8503 static CORE_ADDR
find_breakpoint_range_end(struct symtab_and_line sal)8504 find_breakpoint_range_end (struct symtab_and_line sal)
8505 {
8506 CORE_ADDR end;
8507
8508 /* If the user provided a PC value, use it. Otherwise,
8509 find the address of the end of the given location. */
8510 if (sal.explicit_pc)
8511 end = sal.pc;
8512 else
8513 {
8514 int ret;
8515 CORE_ADDR start;
8516
8517 ret = find_line_pc_range (sal, &start, &end);
8518 if (!ret)
8519 error (_("Could not find location of the end of the range."));
8520
8521 /* find_line_pc_range returns the start of the next line. */
8522 end--;
8523 }
8524
8525 return end;
8526 }
8527
8528 /* Implement the "break-range" CLI command. */
8529
8530 static void
break_range_command(char * arg,int from_tty)8531 break_range_command (char *arg, int from_tty)
8532 {
8533 char *arg_start, *addr_string_start, *addr_string_end;
8534 struct linespec_result canonical_start, canonical_end;
8535 int bp_count, can_use_bp, length;
8536 CORE_ADDR end;
8537 struct breakpoint *b;
8538 struct symtab_and_line sal_start, sal_end;
8539 struct symtabs_and_lines sals_start, sals_end;
8540 struct cleanup *cleanup_bkpt;
8541
8542 /* We don't support software ranged breakpoints. */
8543 if (target_ranged_break_num_registers () < 0)
8544 error (_("This target does not support hardware ranged breakpoints."));
8545
8546 bp_count = hw_breakpoint_used_count ();
8547 bp_count += target_ranged_break_num_registers ();
8548 can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
8549 bp_count, 0);
8550 if (can_use_bp < 0)
8551 error (_("Hardware breakpoints used exceeds limit."));
8552
8553 if (arg == NULL || arg[0] == '\0')
8554 error(_("No address range specified."));
8555
8556 sals_start.sals = NULL;
8557 sals_start.nelts = 0;
8558 init_linespec_result (&canonical_start);
8559
8560 while (*arg == ' ' || *arg == '\t')
8561 arg++;
8562
8563 parse_breakpoint_sals (&arg, &sals_start, &canonical_start);
8564
8565 sal_start = sals_start.sals[0];
8566 addr_string_start = canonical_start.canonical[0];
8567 cleanup_bkpt = make_cleanup (xfree, addr_string_start);
8568 xfree (sals_start.sals);
8569 xfree (canonical_start.canonical);
8570
8571 if (arg[0] != ',')
8572 error (_("Too few arguments."));
8573 else if (sals_start.nelts == 0)
8574 error (_("Could not find location of the beginning of the range."));
8575 else if (sals_start.nelts != 1)
8576 error (_("Cannot create a ranged breakpoint with multiple locations."));
8577
8578 resolve_sal_pc (&sal_start);
8579
8580 arg++; /* Skip the comma. */
8581 while (*arg == ' ' || *arg == '\t')
8582 arg++;
8583
8584 /* Parse the end location. */
8585
8586 sals_end.sals = NULL;
8587 sals_end.nelts = 0;
8588 init_linespec_result (&canonical_end);
8589 arg_start = arg;
8590
8591 /* We call decode_line_1 directly here instead of using
8592 parse_breakpoint_sals because we need to specify the start location's
8593 symtab and line as the default symtab and line for the end of the
8594 range. This makes it possible to have ranges like "foo.c:27, +14",
8595 where +14 means 14 lines from the start location. */
8596 sals_end = decode_line_1 (&arg, 1, sal_start.symtab, sal_start.line,
8597 &canonical_end);
8598
8599 /* canonical_end can be NULL if it was of the form "*0xdeadbeef". */
8600 if (canonical_end.canonical == NULL)
8601 canonical_end.canonical = xcalloc (1, sizeof (char **));
8602 /* Add the string if not present. */
8603 if (arg_start != arg && canonical_end.canonical[0] == NULL)
8604 canonical_end.canonical[0] = savestring (arg_start, arg - arg_start);
8605
8606 sal_end = sals_end.sals[0];
8607 addr_string_end = canonical_end.canonical[0];
8608 make_cleanup (xfree, addr_string_end);
8609 xfree (sals_end.sals);
8610 xfree (canonical_end.canonical);
8611
8612 if (sals_end.nelts == 0)
8613 error (_("Could not find location of the end of the range."));
8614 else if (sals_end.nelts != 1)
8615 error (_("Cannot create a ranged breakpoint with multiple locations."));
8616
8617 resolve_sal_pc (&sal_end);
8618
8619 end = find_breakpoint_range_end (sal_end);
8620 if (sal_start.pc > end)
8621 error (_("Invalid address range, end preceeds start."));
8622
8623 length = end - sal_start.pc + 1;
8624 if (length < 0)
8625 /* Length overflowed. */
8626 error (_("Address range too large."));
8627 else if (length == 1)
8628 {
8629 /* This range is simple enough to be handled by
8630 the `hbreak' command. */
8631 hbreak_command (addr_string_start, 1);
8632
8633 do_cleanups (cleanup_bkpt);
8634
8635 return;
8636 }
8637
8638 /* Now set up the breakpoint. */
8639 b = set_raw_breakpoint (get_current_arch (), sal_start,
8640 bp_hardware_breakpoint);
8641 set_breakpoint_count (breakpoint_count + 1);
8642 b->number = breakpoint_count;
8643 b->disposition = disp_donttouch;
8644 b->addr_string = addr_string_start;
8645 b->addr_string_range_end = addr_string_end;
8646 b->ops = &ranged_breakpoint_ops;
8647 b->loc->length = length;
8648
8649 discard_cleanups (cleanup_bkpt);
8650
8651 mention (b);
8652 update_global_location_list (1);
8653 }
8654
8655 /* Return non-zero if EXP is verified as constant. Returned zero
8656 means EXP is variable. Also the constant detection may fail for
8657 some constant expressions and in such case still falsely return
8658 zero. */
8659 static int
watchpoint_exp_is_const(const struct expression * exp)8660 watchpoint_exp_is_const (const struct expression *exp)
8661 {
8662 int i = exp->nelts;
8663
8664 while (i > 0)
8665 {
8666 int oplenp, argsp;
8667
8668 /* We are only interested in the descriptor of each element. */
8669 operator_length (exp, i, &oplenp, &argsp);
8670 i -= oplenp;
8671
8672 switch (exp->elts[i].opcode)
8673 {
8674 case BINOP_ADD:
8675 case BINOP_SUB:
8676 case BINOP_MUL:
8677 case BINOP_DIV:
8678 case BINOP_REM:
8679 case BINOP_MOD:
8680 case BINOP_LSH:
8681 case BINOP_RSH:
8682 case BINOP_LOGICAL_AND:
8683 case BINOP_LOGICAL_OR:
8684 case BINOP_BITWISE_AND:
8685 case BINOP_BITWISE_IOR:
8686 case BINOP_BITWISE_XOR:
8687 case BINOP_EQUAL:
8688 case BINOP_NOTEQUAL:
8689 case BINOP_LESS:
8690 case BINOP_GTR:
8691 case BINOP_LEQ:
8692 case BINOP_GEQ:
8693 case BINOP_REPEAT:
8694 case BINOP_COMMA:
8695 case BINOP_EXP:
8696 case BINOP_MIN:
8697 case BINOP_MAX:
8698 case BINOP_INTDIV:
8699 case BINOP_CONCAT:
8700 case BINOP_IN:
8701 case BINOP_RANGE:
8702 case TERNOP_COND:
8703 case TERNOP_SLICE:
8704 case TERNOP_SLICE_COUNT:
8705
8706 case OP_LONG:
8707 case OP_DOUBLE:
8708 case OP_DECFLOAT:
8709 case OP_LAST:
8710 case OP_COMPLEX:
8711 case OP_STRING:
8712 case OP_BITSTRING:
8713 case OP_ARRAY:
8714 case OP_TYPE:
8715 case OP_NAME:
8716 case OP_OBJC_NSSTRING:
8717
8718 case UNOP_NEG:
8719 case UNOP_LOGICAL_NOT:
8720 case UNOP_COMPLEMENT:
8721 case UNOP_ADDR:
8722 case UNOP_HIGH:
8723 /* Unary, binary and ternary operators: We have to check
8724 their operands. If they are constant, then so is the
8725 result of that operation. For instance, if A and B are
8726 determined to be constants, then so is "A + B".
8727
8728 UNOP_IND is one exception to the rule above, because the
8729 value of *ADDR is not necessarily a constant, even when
8730 ADDR is. */
8731 break;
8732
8733 case OP_VAR_VALUE:
8734 /* Check whether the associated symbol is a constant.
8735
8736 We use SYMBOL_CLASS rather than TYPE_CONST because it's
8737 possible that a buggy compiler could mark a variable as
8738 constant even when it is not, and TYPE_CONST would return
8739 true in this case, while SYMBOL_CLASS wouldn't.
8740
8741 We also have to check for function symbols because they
8742 are always constant. */
8743 {
8744 struct symbol *s = exp->elts[i + 2].symbol;
8745
8746 if (SYMBOL_CLASS (s) != LOC_BLOCK
8747 && SYMBOL_CLASS (s) != LOC_CONST
8748 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
8749 return 0;
8750 break;
8751 }
8752
8753 /* The default action is to return 0 because we are using
8754 the optimistic approach here: If we don't know something,
8755 then it is not a constant. */
8756 default:
8757 return 0;
8758 }
8759 }
8760
8761 return 1;
8762 }
8763
8764 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
8765
8766 static int
insert_watchpoint(struct bp_location * bl)8767 insert_watchpoint (struct bp_location *bl)
8768 {
8769 int length = bl->owner->exact? 1 : bl->length;
8770
8771 return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
8772 bl->owner->cond_exp);
8773 }
8774
8775 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
8776
8777 static int
remove_watchpoint(struct bp_location * bl)8778 remove_watchpoint (struct bp_location *bl)
8779 {
8780 int length = bl->owner->exact? 1 : bl->length;
8781
8782 return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
8783 bl->owner->cond_exp);
8784 }
8785
8786 /* Implement the "resources_needed" breakpoint_ops method for
8787 hardware watchpoints. */
8788
8789 static int
resources_needed_watchpoint(const struct bp_location * bl)8790 resources_needed_watchpoint (const struct bp_location *bl)
8791 {
8792 int length = bl->owner->exact? 1 : bl->length;
8793
8794 return target_region_ok_for_hw_watchpoint (bl->address, length);
8795 }
8796
8797 /* The breakpoint_ops structure to be used in hardware watchpoints. */
8798
8799 static struct breakpoint_ops watchpoint_breakpoint_ops =
8800 {
8801 insert_watchpoint,
8802 remove_watchpoint,
8803 NULL, /* breakpoint_hit */
8804 resources_needed_watchpoint,
8805 NULL, /* print_it */
8806 NULL, /* print_one */
8807 NULL, /* print_one_detail */
8808 NULL, /* print_mention */
8809 NULL /* print_recreate */
8810 };
8811
8812 /* accessflag: hw_write: watch write,
8813 hw_read: watch read,
8814 hw_access: watch access (read or write) */
8815 static void
watch_command_1(char * arg,int accessflag,int from_tty,int just_location,int internal)8816 watch_command_1 (char *arg, int accessflag, int from_tty,
8817 int just_location, int internal)
8818 {
8819 struct breakpoint *b, *scope_breakpoint = NULL;
8820 struct expression *exp;
8821 struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
8822 struct value *val, *mark, *result;
8823 struct frame_info *frame;
8824 char *exp_start = NULL;
8825 char *exp_end = NULL;
8826 char *tok, *id_tok_start, *end_tok;
8827 int toklen;
8828 char *cond_start = NULL;
8829 char *cond_end = NULL;
8830 int i, other_type_used, target_resources_ok = 0;
8831 enum bptype bp_type;
8832 int reg_cnt = 0;
8833 int thread = -1;
8834 int pc = 0;
8835
8836 /* Make sure that we actually have parameters to parse. */
8837 if (arg != NULL && arg[0] != '\0')
8838 {
8839 toklen = strlen (arg); /* Size of argument list. */
8840
8841 /* Points tok to the end of the argument list. */
8842 tok = arg + toklen - 1;
8843
8844 /* Go backwards in the parameters list. Skip the last
8845 parameter. If we're expecting a 'thread <thread_num>'
8846 parameter, this should be the thread identifier. */
8847 while (tok > arg && (*tok == ' ' || *tok == '\t'))
8848 tok--;
8849 while (tok > arg && (*tok != ' ' && *tok != '\t'))
8850 tok--;
8851
8852 /* Points end_tok to the beginning of the last token. */
8853 id_tok_start = tok + 1;
8854
8855 /* Go backwards in the parameters list. Skip one more
8856 parameter. If we're expecting a 'thread <thread_num>'
8857 parameter, we should reach a "thread" token. */
8858 while (tok > arg && (*tok == ' ' || *tok == '\t'))
8859 tok--;
8860
8861 end_tok = tok;
8862
8863 while (tok > arg && (*tok != ' ' && *tok != '\t'))
8864 tok--;
8865
8866 /* Move the pointer forward to skip the whitespace and
8867 calculate the length of the token. */
8868 tok++;
8869 toklen = end_tok - tok;
8870
8871 if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
8872 {
8873 /* At this point we've found a "thread" token, which means
8874 the user is trying to set a watchpoint that triggers
8875 only in a specific thread. */
8876 char *endp;
8877
8878 /* Extract the thread ID from the next token. */
8879 thread = strtol (id_tok_start, &endp, 0);
8880
8881 /* Check if the user provided a valid numeric value for the
8882 thread ID. */
8883 if (*endp != ' ' && *endp != '\t' && *endp != '\0')
8884 error (_("Invalid thread ID specification %s."), id_tok_start);
8885
8886 /* Check if the thread actually exists. */
8887 if (!valid_thread_id (thread))
8888 error (_("Unknown thread %d."), thread);
8889
8890 /* Truncate the string and get rid of the thread <thread_num>
8891 parameter before the parameter list is parsed by the
8892 evaluate_expression() function. */
8893 *tok = '\0';
8894 }
8895 }
8896
8897 /* Parse the rest of the arguments. */
8898 innermost_block = NULL;
8899 exp_start = arg;
8900 exp = parse_exp_1 (&arg, 0, 0);
8901 exp_end = arg;
8902 /* Remove trailing whitespace from the expression before saving it.
8903 This makes the eventual display of the expression string a bit
8904 prettier. */
8905 while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
8906 --exp_end;
8907
8908 /* Checking if the expression is not constant. */
8909 if (watchpoint_exp_is_const (exp))
8910 {
8911 int len;
8912
8913 len = exp_end - exp_start;
8914 while (len > 0 && isspace (exp_start[len - 1]))
8915 len--;
8916 error (_("Cannot watch constant value `%.*s'."), len, exp_start);
8917 }
8918
8919 exp_valid_block = innermost_block;
8920 mark = value_mark ();
8921 fetch_subexp_value (exp, &pc, &val, &result, NULL);
8922
8923 if (just_location)
8924 {
8925 exp_valid_block = NULL;
8926 val = value_addr (result);
8927 release_value (val);
8928 value_free_to_mark (mark);
8929 }
8930 else if (val != NULL)
8931 release_value (val);
8932
8933 tok = skip_spaces (arg);
8934 end_tok = skip_to_space (tok);
8935
8936 toklen = end_tok - tok;
8937 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
8938 {
8939 struct expression *cond;
8940
8941 innermost_block = NULL;
8942 tok = cond_start = end_tok + 1;
8943 cond = parse_exp_1 (&tok, 0, 0);
8944
8945 /* The watchpoint expression may not be local, but the condition
8946 may still be. E.g.: `watch global if local > 0'. */
8947 cond_exp_valid_block = innermost_block;
8948
8949 xfree (cond);
8950 cond_end = tok;
8951 }
8952 if (*tok)
8953 error (_("Junk at end of command."));
8954
8955 if (accessflag == hw_read)
8956 bp_type = bp_read_watchpoint;
8957 else if (accessflag == hw_access)
8958 bp_type = bp_access_watchpoint;
8959 else
8960 bp_type = bp_hardware_watchpoint;
8961
8962 reg_cnt = can_use_hardware_watchpoint (val, target_exact_watchpoints);
8963 if (reg_cnt == 0 && bp_type != bp_hardware_watchpoint)
8964 error (_("Expression cannot be implemented with read/access watchpoint."));
8965 if (reg_cnt != 0)
8966 {
8967 i = hw_watchpoint_used_count (bp_type, &other_type_used);
8968 target_resources_ok =
8969 target_can_use_hardware_watchpoint (bp_type, i + reg_cnt,
8970 other_type_used);
8971 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
8972 error (_("Target does not support this type of hardware watchpoint."));
8973
8974 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
8975 error (_("Target can only support one kind "
8976 "of HW watchpoint at a time."));
8977 }
8978
8979 /* Change the type of breakpoint to an ordinary watchpoint if a
8980 hardware watchpoint could not be set. */
8981 if (!reg_cnt || target_resources_ok <= 0)
8982 bp_type = bp_watchpoint;
8983
8984 frame = block_innermost_frame (exp_valid_block);
8985
8986 /* If the expression is "local", then set up a "watchpoint scope"
8987 breakpoint at the point where we've left the scope of the watchpoint
8988 expression. Create the scope breakpoint before the watchpoint, so
8989 that we will encounter it first in bpstat_stop_status. */
8990 if (exp_valid_block && frame)
8991 {
8992 if (frame_id_p (frame_unwind_caller_id (frame)))
8993 {
8994 scope_breakpoint
8995 = create_internal_breakpoint (frame_unwind_caller_arch (frame),
8996 frame_unwind_caller_pc (frame),
8997 bp_watchpoint_scope);
8998
8999 scope_breakpoint->enable_state = bp_enabled;
9000
9001 /* Automatically delete the breakpoint when it hits. */
9002 scope_breakpoint->disposition = disp_del;
9003
9004 /* Only break in the proper frame (help with recursion). */
9005 scope_breakpoint->frame_id = frame_unwind_caller_id (frame);
9006
9007 /* Set the address at which we will stop. */
9008 scope_breakpoint->loc->gdbarch
9009 = frame_unwind_caller_arch (frame);
9010 scope_breakpoint->loc->requested_address
9011 = frame_unwind_caller_pc (frame);
9012 scope_breakpoint->loc->address
9013 = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
9014 scope_breakpoint->loc->requested_address,
9015 scope_breakpoint->type);
9016 }
9017 }
9018
9019 /* Now set up the breakpoint. */
9020 b = set_raw_breakpoint_without_location (NULL, bp_type);
9021 set_breakpoint_number (internal, b);
9022 b->thread = thread;
9023 b->disposition = disp_donttouch;
9024 b->exp = exp;
9025 b->exp_valid_block = exp_valid_block;
9026 b->cond_exp_valid_block = cond_exp_valid_block;
9027 if (just_location)
9028 {
9029 struct type *t = value_type (val);
9030 CORE_ADDR addr = value_as_address (val);
9031 char *name;
9032
9033 t = check_typedef (TYPE_TARGET_TYPE (check_typedef (t)));
9034 name = type_to_string (t);
9035
9036 b->exp_string_reparse = xstrprintf ("* (%s *) %s", name,
9037 core_addr_to_string (addr));
9038 xfree (name);
9039
9040 b->exp_string = xstrprintf ("-location %.*s",
9041 (int) (exp_end - exp_start), exp_start);
9042
9043 /* The above expression is in C. */
9044 b->language = language_c;
9045 }
9046 else
9047 b->exp_string = savestring (exp_start, exp_end - exp_start);
9048 b->val = val;
9049 b->val_valid = 1;
9050 b->ops = &watchpoint_breakpoint_ops;
9051
9052 /* Use an exact watchpoint when there's only one memory region to be
9053 watched, and only one debug register is needed to watch it. */
9054 b->exact = target_exact_watchpoints && reg_cnt == 1;
9055
9056 if (cond_start)
9057 b->cond_string = savestring (cond_start, cond_end - cond_start);
9058 else
9059 b->cond_string = 0;
9060
9061 if (frame)
9062 {
9063 b->watchpoint_frame = get_frame_id (frame);
9064 b->watchpoint_thread = inferior_ptid;
9065 }
9066 else
9067 {
9068 b->watchpoint_frame = null_frame_id;
9069 b->watchpoint_thread = null_ptid;
9070 }
9071
9072 if (scope_breakpoint != NULL)
9073 {
9074 /* The scope breakpoint is related to the watchpoint. We will
9075 need to act on them together. */
9076 b->related_breakpoint = scope_breakpoint;
9077 scope_breakpoint->related_breakpoint = b;
9078 }
9079
9080 if (!just_location)
9081 value_free_to_mark (mark);
9082
9083 /* Finally update the new watchpoint. This creates the locations
9084 that should be inserted. */
9085 update_watchpoint (b, 1);
9086 if (internal)
9087 /* Do not mention breakpoints with a negative number, but do
9088 notify observers. */
9089 observer_notify_breakpoint_created (b->number);
9090 else
9091 mention (b);
9092 update_global_location_list (1);
9093 }
9094
9095 /* Return count of debug registers needed to watch the given expression.
9096 If EXACT_WATCHPOINTS is 1, then consider that only the address of
9097 the start of the watched region will be monitored (i.e., all accesses
9098 will be aligned). This uses less debug registers on some targets.
9099
9100 If the watchpoint cannot be handled in hardware return zero. */
9101
9102 static int
can_use_hardware_watchpoint(struct value * v,int exact_watchpoints)9103 can_use_hardware_watchpoint (struct value *v, int exact_watchpoints)
9104 {
9105 int found_memory_cnt = 0;
9106 struct value *head = v;
9107
9108 /* Did the user specifically forbid us to use hardware watchpoints? */
9109 if (!can_use_hw_watchpoints)
9110 return 0;
9111
9112 /* Make sure that the value of the expression depends only upon
9113 memory contents, and values computed from them within GDB. If we
9114 find any register references or function calls, we can't use a
9115 hardware watchpoint.
9116
9117 The idea here is that evaluating an expression generates a series
9118 of values, one holding the value of every subexpression. (The
9119 expression a*b+c has five subexpressions: a, b, a*b, c, and
9120 a*b+c.) GDB's values hold almost enough information to establish
9121 the criteria given above --- they identify memory lvalues,
9122 register lvalues, computed values, etcetera. So we can evaluate
9123 the expression, and then scan the chain of values that leaves
9124 behind to decide whether we can detect any possible change to the
9125 expression's final value using only hardware watchpoints.
9126
9127 However, I don't think that the values returned by inferior
9128 function calls are special in any way. So this function may not
9129 notice that an expression involving an inferior function call
9130 can't be watched with hardware watchpoints. FIXME. */
9131 for (; v; v = value_next (v))
9132 {
9133 if (VALUE_LVAL (v) == lval_memory)
9134 {
9135 if (v != head && value_lazy (v))
9136 /* A lazy memory lvalue in the chain is one that GDB never
9137 needed to fetch; we either just used its address (e.g.,
9138 `a' in `a.b') or we never needed it at all (e.g., `a'
9139 in `a,b'). This doesn't apply to HEAD; if that is
9140 lazy then it was not readable, but watch it anyway. */
9141 ;
9142 else
9143 {
9144 /* Ahh, memory we actually used! Check if we can cover
9145 it with hardware watchpoints. */
9146 struct type *vtype = check_typedef (value_type (v));
9147
9148 /* We only watch structs and arrays if user asked for it
9149 explicitly, never if they just happen to appear in a
9150 middle of some value chain. */
9151 if (v == head
9152 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
9153 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
9154 {
9155 CORE_ADDR vaddr = value_address (v);
9156 int len;
9157 int num_regs;
9158
9159 len = (exact_watchpoints
9160 && is_scalar_type_recursive (vtype))?
9161 1 : TYPE_LENGTH (value_type (v));
9162
9163 num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
9164 if (!num_regs)
9165 return 0;
9166 else
9167 found_memory_cnt += num_regs;
9168 }
9169 }
9170 }
9171 else if (VALUE_LVAL (v) != not_lval
9172 && deprecated_value_modifiable (v) == 0)
9173 return 0; /* These are values from the history (e.g., $1). */
9174 else if (VALUE_LVAL (v) == lval_register)
9175 return 0; /* Cannot watch a register with a HW watchpoint. */
9176 }
9177
9178 /* The expression itself looks suitable for using a hardware
9179 watchpoint, but give the target machine a chance to reject it. */
9180 return found_memory_cnt;
9181 }
9182
9183 void
watch_command_wrapper(char * arg,int from_tty,int internal)9184 watch_command_wrapper (char *arg, int from_tty, int internal)
9185 {
9186 watch_command_1 (arg, hw_write, from_tty, 0, internal);
9187 }
9188
9189 /* A helper function that looks for an argument at the start of a
9190 string. The argument must also either be at the end of the string,
9191 or be followed by whitespace. Returns 1 if it finds the argument,
9192 0 otherwise. If the argument is found, it updates *STR. */
9193
9194 static int
check_for_argument(char ** str,char * arg,int arg_len)9195 check_for_argument (char **str, char *arg, int arg_len)
9196 {
9197 if (strncmp (*str, arg, arg_len) == 0
9198 && ((*str)[arg_len] == '\0' || isspace ((*str)[arg_len])))
9199 {
9200 *str += arg_len;
9201 return 1;
9202 }
9203 return 0;
9204 }
9205
9206 /* A helper function that looks for the "-location" argument and then
9207 calls watch_command_1. */
9208
9209 static void
watch_maybe_just_location(char * arg,int accessflag,int from_tty)9210 watch_maybe_just_location (char *arg, int accessflag, int from_tty)
9211 {
9212 int just_location = 0;
9213
9214 if (arg
9215 && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
9216 || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
9217 {
9218 arg = skip_spaces (arg);
9219 just_location = 1;
9220 }
9221
9222 watch_command_1 (arg, accessflag, from_tty, just_location, 0);
9223 }
9224
9225 static void
watch_command(char * arg,int from_tty)9226 watch_command (char *arg, int from_tty)
9227 {
9228 watch_maybe_just_location (arg, hw_write, from_tty);
9229 }
9230
9231 void
rwatch_command_wrapper(char * arg,int from_tty,int internal)9232 rwatch_command_wrapper (char *arg, int from_tty, int internal)
9233 {
9234 watch_command_1 (arg, hw_read, from_tty, 0, internal);
9235 }
9236
9237 static void
rwatch_command(char * arg,int from_tty)9238 rwatch_command (char *arg, int from_tty)
9239 {
9240 watch_maybe_just_location (arg, hw_read, from_tty);
9241 }
9242
9243 void
awatch_command_wrapper(char * arg,int from_tty,int internal)9244 awatch_command_wrapper (char *arg, int from_tty, int internal)
9245 {
9246 watch_command_1 (arg, hw_access, from_tty, 0, internal);
9247 }
9248
9249 static void
awatch_command(char * arg,int from_tty)9250 awatch_command (char *arg, int from_tty)
9251 {
9252 watch_maybe_just_location (arg, hw_access, from_tty);
9253 }
9254
9255
9256 /* Helper routines for the until_command routine in infcmd.c. Here
9257 because it uses the mechanisms of breakpoints. */
9258
9259 struct until_break_command_continuation_args
9260 {
9261 struct breakpoint *breakpoint;
9262 struct breakpoint *breakpoint2;
9263 int thread_num;
9264 };
9265
9266 /* This function is called by fetch_inferior_event via the
9267 cmd_continuation pointer, to complete the until command. It takes
9268 care of cleaning up the temporary breakpoints set up by the until
9269 command. */
9270 static void
until_break_command_continuation(void * arg)9271 until_break_command_continuation (void *arg)
9272 {
9273 struct until_break_command_continuation_args *a = arg;
9274
9275 delete_breakpoint (a->breakpoint);
9276 if (a->breakpoint2)
9277 delete_breakpoint (a->breakpoint2);
9278 delete_longjmp_breakpoint (a->thread_num);
9279 }
9280
9281 void
until_break_command(char * arg,int from_tty,int anywhere)9282 until_break_command (char *arg, int from_tty, int anywhere)
9283 {
9284 struct symtabs_and_lines sals;
9285 struct symtab_and_line sal;
9286 struct frame_info *frame = get_selected_frame (NULL);
9287 struct breakpoint *breakpoint;
9288 struct breakpoint *breakpoint2 = NULL;
9289 struct cleanup *old_chain;
9290 int thread;
9291 struct thread_info *tp;
9292
9293 clear_proceed_status ();
9294
9295 /* Set a breakpoint where the user wants it and at return from
9296 this function. */
9297
9298 if (default_breakpoint_valid)
9299 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
9300 default_breakpoint_line, NULL);
9301 else
9302 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, NULL);
9303
9304 if (sals.nelts != 1)
9305 error (_("Couldn't get information on specified line."));
9306
9307 sal = sals.sals[0];
9308 xfree (sals.sals); /* malloc'd, so freed. */
9309
9310 if (*arg)
9311 error (_("Junk at end of arguments."));
9312
9313 resolve_sal_pc (&sal);
9314
9315 if (anywhere)
9316 /* If the user told us to continue until a specified location,
9317 we don't specify a frame at which we need to stop. */
9318 breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
9319 null_frame_id, bp_until);
9320 else
9321 /* Otherwise, specify the selected frame, because we want to stop
9322 only at the very same frame. */
9323 breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
9324 get_stack_frame_id (frame),
9325 bp_until);
9326
9327 old_chain = make_cleanup_delete_breakpoint (breakpoint);
9328
9329 tp = inferior_thread ();
9330 thread = tp->num;
9331
9332 /* Keep within the current frame, or in frames called by the current
9333 one. */
9334
9335 if (frame_id_p (frame_unwind_caller_id (frame)))
9336 {
9337 sal = find_pc_line (frame_unwind_caller_pc (frame), 0);
9338 sal.pc = frame_unwind_caller_pc (frame);
9339 breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
9340 sal,
9341 frame_unwind_caller_id (frame),
9342 bp_until);
9343 make_cleanup_delete_breakpoint (breakpoint2);
9344
9345 set_longjmp_breakpoint (tp, frame_unwind_caller_id (frame));
9346 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
9347 }
9348
9349 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
9350
9351 /* If we are running asynchronously, and proceed call above has
9352 actually managed to start the target, arrange for breakpoints to
9353 be deleted when the target stops. Otherwise, we're already
9354 stopped and delete breakpoints via cleanup chain. */
9355
9356 if (target_can_async_p () && is_running (inferior_ptid))
9357 {
9358 struct until_break_command_continuation_args *args;
9359 args = xmalloc (sizeof (*args));
9360
9361 args->breakpoint = breakpoint;
9362 args->breakpoint2 = breakpoint2;
9363 args->thread_num = thread;
9364
9365 discard_cleanups (old_chain);
9366 add_continuation (inferior_thread (),
9367 until_break_command_continuation, args,
9368 xfree);
9369 }
9370 else
9371 do_cleanups (old_chain);
9372 }
9373
9374 /* This function attempts to parse an optional "if <cond>" clause
9375 from the arg string. If one is not found, it returns NULL.
9376
9377 Else, it returns a pointer to the condition string. (It does not
9378 attempt to evaluate the string against a particular block.) And,
9379 it updates arg to point to the first character following the parsed
9380 if clause in the arg string. */
9381
9382 static char *
ep_parse_optional_if_clause(char ** arg)9383 ep_parse_optional_if_clause (char **arg)
9384 {
9385 char *cond_string;
9386
9387 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
9388 return NULL;
9389
9390 /* Skip the "if" keyword. */
9391 (*arg) += 2;
9392
9393 /* Skip any extra leading whitespace, and record the start of the
9394 condition string. */
9395 *arg = skip_spaces (*arg);
9396 cond_string = *arg;
9397
9398 /* Assume that the condition occupies the remainder of the arg
9399 string. */
9400 (*arg) += strlen (cond_string);
9401
9402 return cond_string;
9403 }
9404
9405 /* Commands to deal with catching events, such as signals, exceptions,
9406 process start/exit, etc. */
9407
9408 typedef enum
9409 {
9410 catch_fork_temporary, catch_vfork_temporary,
9411 catch_fork_permanent, catch_vfork_permanent
9412 }
9413 catch_fork_kind;
9414
9415 static void
catch_fork_command_1(char * arg,int from_tty,struct cmd_list_element * command)9416 catch_fork_command_1 (char *arg, int from_tty,
9417 struct cmd_list_element *command)
9418 {
9419 struct gdbarch *gdbarch = get_current_arch ();
9420 char *cond_string = NULL;
9421 catch_fork_kind fork_kind;
9422 int tempflag;
9423
9424 fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
9425 tempflag = (fork_kind == catch_fork_temporary
9426 || fork_kind == catch_vfork_temporary);
9427
9428 if (!arg)
9429 arg = "";
9430 arg = skip_spaces (arg);
9431
9432 /* The allowed syntax is:
9433 catch [v]fork
9434 catch [v]fork if <cond>
9435
9436 First, check if there's an if clause. */
9437 cond_string = ep_parse_optional_if_clause (&arg);
9438
9439 if ((*arg != '\0') && !isspace (*arg))
9440 error (_("Junk at end of arguments."));
9441
9442 /* If this target supports it, create a fork or vfork catchpoint
9443 and enable reporting of such events. */
9444 switch (fork_kind)
9445 {
9446 case catch_fork_temporary:
9447 case catch_fork_permanent:
9448 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
9449 &catch_fork_breakpoint_ops);
9450 break;
9451 case catch_vfork_temporary:
9452 case catch_vfork_permanent:
9453 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
9454 &catch_vfork_breakpoint_ops);
9455 break;
9456 default:
9457 error (_("unsupported or unknown fork kind; cannot catch it"));
9458 break;
9459 }
9460 }
9461
9462 static void
catch_exec_command_1(char * arg,int from_tty,struct cmd_list_element * command)9463 catch_exec_command_1 (char *arg, int from_tty,
9464 struct cmd_list_element *command)
9465 {
9466 struct gdbarch *gdbarch = get_current_arch ();
9467 int tempflag;
9468 char *cond_string = NULL;
9469
9470 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9471
9472 if (!arg)
9473 arg = "";
9474 arg = skip_spaces (arg);
9475
9476 /* The allowed syntax is:
9477 catch exec
9478 catch exec if <cond>
9479
9480 First, check if there's an if clause. */
9481 cond_string = ep_parse_optional_if_clause (&arg);
9482
9483 if ((*arg != '\0') && !isspace (*arg))
9484 error (_("Junk at end of arguments."));
9485
9486 /* If this target supports it, create an exec catchpoint
9487 and enable reporting of such events. */
9488 create_catchpoint (gdbarch, tempflag, cond_string,
9489 &catch_exec_breakpoint_ops);
9490 }
9491
9492 static enum print_stop_action
print_exception_catchpoint(struct breakpoint * b)9493 print_exception_catchpoint (struct breakpoint *b)
9494 {
9495 int bp_temp, bp_throw;
9496
9497 annotate_catchpoint (b->number);
9498
9499 bp_throw = strstr (b->addr_string, "throw") != NULL;
9500 if (b->loc->address != b->loc->requested_address)
9501 breakpoint_adjustment_warning (b->loc->requested_address,
9502 b->loc->address,
9503 b->number, 1);
9504 bp_temp = b->disposition == disp_del;
9505 ui_out_text (uiout,
9506 bp_temp ? "Temporary catchpoint "
9507 : "Catchpoint ");
9508 if (!ui_out_is_mi_like_p (uiout))
9509 ui_out_field_int (uiout, "bkptno", b->number);
9510 ui_out_text (uiout,
9511 bp_throw ? " (exception thrown), "
9512 : " (exception caught), ");
9513 if (ui_out_is_mi_like_p (uiout))
9514 {
9515 ui_out_field_string (uiout, "reason",
9516 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9517 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
9518 ui_out_field_int (uiout, "bkptno", b->number);
9519 }
9520 return PRINT_SRC_AND_LOC;
9521 }
9522
9523 static void
print_one_exception_catchpoint(struct breakpoint * b,struct bp_location ** last_loc)9524 print_one_exception_catchpoint (struct breakpoint *b,
9525 struct bp_location **last_loc)
9526 {
9527 struct value_print_options opts;
9528
9529 get_user_print_options (&opts);
9530 if (opts.addressprint)
9531 {
9532 annotate_field (4);
9533 if (b->loc == NULL || b->loc->shlib_disabled)
9534 ui_out_field_string (uiout, "addr", "<PENDING>");
9535 else
9536 ui_out_field_core_addr (uiout, "addr",
9537 b->loc->gdbarch, b->loc->address);
9538 }
9539 annotate_field (5);
9540 if (b->loc)
9541 *last_loc = b->loc;
9542 if (strstr (b->addr_string, "throw") != NULL)
9543 ui_out_field_string (uiout, "what", "exception throw");
9544 else
9545 ui_out_field_string (uiout, "what", "exception catch");
9546 }
9547
9548 static void
print_mention_exception_catchpoint(struct breakpoint * b)9549 print_mention_exception_catchpoint (struct breakpoint *b)
9550 {
9551 int bp_temp;
9552 int bp_throw;
9553
9554 bp_temp = b->disposition == disp_del;
9555 bp_throw = strstr (b->addr_string, "throw") != NULL;
9556 ui_out_text (uiout, bp_temp ? _("Temporary catchpoint ")
9557 : _("Catchpoint "));
9558 ui_out_field_int (uiout, "bkptno", b->number);
9559 ui_out_text (uiout, bp_throw ? _(" (throw)")
9560 : _(" (catch)"));
9561 }
9562
9563 /* Implement the "print_recreate" breakpoint_ops method for throw and
9564 catch catchpoints. */
9565
9566 static void
print_recreate_exception_catchpoint(struct breakpoint * b,struct ui_file * fp)9567 print_recreate_exception_catchpoint (struct breakpoint *b,
9568 struct ui_file *fp)
9569 {
9570 int bp_temp;
9571 int bp_throw;
9572
9573 bp_temp = b->disposition == disp_del;
9574 bp_throw = strstr (b->addr_string, "throw") != NULL;
9575 fprintf_unfiltered (fp, bp_temp ? "tcatch " : "catch ");
9576 fprintf_unfiltered (fp, bp_throw ? "throw" : "catch");
9577 }
9578
9579 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
9580 NULL, /* insert */
9581 NULL, /* remove */
9582 NULL, /* breakpoint_hit */
9583 NULL, /* resources_needed */
9584 print_exception_catchpoint,
9585 print_one_exception_catchpoint,
9586 NULL, /* print_one_detail */
9587 print_mention_exception_catchpoint,
9588 print_recreate_exception_catchpoint
9589 };
9590
9591 static int
handle_gnu_v3_exceptions(int tempflag,char * cond_string,enum exception_event_kind ex_event,int from_tty)9592 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
9593 enum exception_event_kind ex_event, int from_tty)
9594 {
9595 char *trigger_func_name;
9596
9597 if (ex_event == EX_EVENT_CATCH)
9598 trigger_func_name = "__cxa_begin_catch";
9599 else
9600 trigger_func_name = "__cxa_throw";
9601
9602 create_breakpoint (get_current_arch (),
9603 trigger_func_name, cond_string, -1,
9604 0 /* condition and thread are valid. */,
9605 tempflag, bp_breakpoint,
9606 0,
9607 AUTO_BOOLEAN_TRUE /* pending */,
9608 &gnu_v3_exception_catchpoint_ops, from_tty,
9609 1 /* enabled */,
9610 0 /* internal */);
9611
9612 return 1;
9613 }
9614
9615 /* Deal with "catch catch" and "catch throw" commands. */
9616
9617 static void
catch_exception_command_1(enum exception_event_kind ex_event,char * arg,int tempflag,int from_tty)9618 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
9619 int tempflag, int from_tty)
9620 {
9621 char *cond_string = NULL;
9622
9623 if (!arg)
9624 arg = "";
9625 arg = skip_spaces (arg);
9626
9627 cond_string = ep_parse_optional_if_clause (&arg);
9628
9629 if ((*arg != '\0') && !isspace (*arg))
9630 error (_("Junk at end of arguments."));
9631
9632 if (ex_event != EX_EVENT_THROW
9633 && ex_event != EX_EVENT_CATCH)
9634 error (_("Unsupported or unknown exception event; cannot catch it"));
9635
9636 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
9637 return;
9638
9639 warning (_("Unsupported with this platform/compiler combination."));
9640 }
9641
9642 /* Implementation of "catch catch" command. */
9643
9644 static void
catch_catch_command(char * arg,int from_tty,struct cmd_list_element * command)9645 catch_catch_command (char *arg, int from_tty, struct cmd_list_element *command)
9646 {
9647 int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9648
9649 catch_exception_command_1 (EX_EVENT_CATCH, arg, tempflag, from_tty);
9650 }
9651
9652 /* Implementation of "catch throw" command. */
9653
9654 static void
catch_throw_command(char * arg,int from_tty,struct cmd_list_element * command)9655 catch_throw_command (char *arg, int from_tty, struct cmd_list_element *command)
9656 {
9657 int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9658
9659 catch_exception_command_1 (EX_EVENT_THROW, arg, tempflag, from_tty);
9660 }
9661
9662 /* Create a breakpoint struct for Ada exception catchpoints. */
9663
9664 static void
create_ada_exception_breakpoint(struct gdbarch * gdbarch,struct symtab_and_line sal,char * addr_string,char * exp_string,char * cond_string,struct expression * cond,struct breakpoint_ops * ops,int tempflag,int from_tty)9665 create_ada_exception_breakpoint (struct gdbarch *gdbarch,
9666 struct symtab_and_line sal,
9667 char *addr_string,
9668 char *exp_string,
9669 char *cond_string,
9670 struct expression *cond,
9671 struct breakpoint_ops *ops,
9672 int tempflag,
9673 int from_tty)
9674 {
9675 struct breakpoint *b;
9676
9677 if (from_tty)
9678 {
9679 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
9680 if (!loc_gdbarch)
9681 loc_gdbarch = gdbarch;
9682
9683 describe_other_breakpoints (loc_gdbarch,
9684 sal.pspace, sal.pc, sal.section, -1);
9685 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
9686 version for exception catchpoints, because two catchpoints
9687 used for different exception names will use the same address.
9688 In this case, a "breakpoint ... also set at..." warning is
9689 unproductive. Besides, the warning phrasing is also a bit
9690 inapropriate, we should use the word catchpoint, and tell
9691 the user what type of catchpoint it is. The above is good
9692 enough for now, though. */
9693 }
9694
9695 b = set_raw_breakpoint (gdbarch, sal, bp_breakpoint);
9696 set_breakpoint_count (breakpoint_count + 1);
9697
9698 b->enable_state = bp_enabled;
9699 b->disposition = tempflag ? disp_del : disp_donttouch;
9700 b->number = breakpoint_count;
9701 b->ignore_count = 0;
9702 b->loc->cond = cond;
9703 b->addr_string = addr_string;
9704 b->language = language_ada;
9705 b->cond_string = cond_string;
9706 b->exp_string = exp_string;
9707 b->thread = -1;
9708 b->ops = ops;
9709
9710 mention (b);
9711 update_global_location_list (1);
9712 }
9713
9714 /* Implement the "catch exception" command. */
9715
9716 static void
catch_ada_exception_command(char * arg,int from_tty,struct cmd_list_element * command)9717 catch_ada_exception_command (char *arg, int from_tty,
9718 struct cmd_list_element *command)
9719 {
9720 struct gdbarch *gdbarch = get_current_arch ();
9721 int tempflag;
9722 struct symtab_and_line sal;
9723 char *addr_string = NULL;
9724 char *exp_string = NULL;
9725 char *cond_string = NULL;
9726 struct expression *cond = NULL;
9727 struct breakpoint_ops *ops = NULL;
9728
9729 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9730
9731 if (!arg)
9732 arg = "";
9733 sal = ada_decode_exception_location (arg, &addr_string, &exp_string,
9734 &cond_string, &cond, &ops);
9735 create_ada_exception_breakpoint (gdbarch, sal, addr_string, exp_string,
9736 cond_string, cond, ops, tempflag,
9737 from_tty);
9738 }
9739
9740 /* Cleanup function for a syscall filter list. */
9741 static void
clean_up_filters(void * arg)9742 clean_up_filters (void *arg)
9743 {
9744 VEC(int) *iter = *(VEC(int) **) arg;
9745 VEC_free (int, iter);
9746 }
9747
9748 /* Splits the argument using space as delimiter. Returns an xmalloc'd
9749 filter list, or NULL if no filtering is required. */
VEC(int)9750 static VEC(int) *
9751 catch_syscall_split_args (char *arg)
9752 {
9753 VEC(int) *result = NULL;
9754 struct cleanup *cleanup = make_cleanup (clean_up_filters, &result);
9755
9756 while (*arg != '\0')
9757 {
9758 int i, syscall_number;
9759 char *endptr;
9760 char cur_name[128];
9761 struct syscall s;
9762
9763 /* Skip whitespace. */
9764 while (isspace (*arg))
9765 arg++;
9766
9767 for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
9768 cur_name[i] = arg[i];
9769 cur_name[i] = '\0';
9770 arg += i;
9771
9772 /* Check if the user provided a syscall name or a number. */
9773 syscall_number = (int) strtol (cur_name, &endptr, 0);
9774 if (*endptr == '\0')
9775 get_syscall_by_number (syscall_number, &s);
9776 else
9777 {
9778 /* We have a name. Let's check if it's valid and convert it
9779 to a number. */
9780 get_syscall_by_name (cur_name, &s);
9781
9782 if (s.number == UNKNOWN_SYSCALL)
9783 /* Here we have to issue an error instead of a warning,
9784 because GDB cannot do anything useful if there's no
9785 syscall number to be caught. */
9786 error (_("Unknown syscall name '%s'."), cur_name);
9787 }
9788
9789 /* Ok, it's valid. */
9790 VEC_safe_push (int, result, s.number);
9791 }
9792
9793 discard_cleanups (cleanup);
9794 return result;
9795 }
9796
9797 /* Implement the "catch syscall" command. */
9798
9799 static void
catch_syscall_command_1(char * arg,int from_tty,struct cmd_list_element * command)9800 catch_syscall_command_1 (char *arg, int from_tty,
9801 struct cmd_list_element *command)
9802 {
9803 int tempflag;
9804 VEC(int) *filter;
9805 struct syscall s;
9806 struct gdbarch *gdbarch = get_current_arch ();
9807
9808 /* Checking if the feature if supported. */
9809 if (gdbarch_get_syscall_number_p (gdbarch) == 0)
9810 error (_("The feature 'catch syscall' is not supported on \
9811 this architecture yet."));
9812
9813 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9814
9815 arg = skip_spaces (arg);
9816
9817 /* We need to do this first "dummy" translation in order
9818 to get the syscall XML file loaded or, most important,
9819 to display a warning to the user if there's no XML file
9820 for his/her architecture. */
9821 get_syscall_by_number (0, &s);
9822
9823 /* The allowed syntax is:
9824 catch syscall
9825 catch syscall <name | number> [<name | number> ... <name | number>]
9826
9827 Let's check if there's a syscall name. */
9828
9829 if (arg != NULL)
9830 filter = catch_syscall_split_args (arg);
9831 else
9832 filter = NULL;
9833
9834 create_syscall_event_catchpoint (tempflag, filter,
9835 &catch_syscall_breakpoint_ops);
9836 }
9837
9838 /* Implement the "catch assert" command. */
9839
9840 static void
catch_assert_command(char * arg,int from_tty,struct cmd_list_element * command)9841 catch_assert_command (char *arg, int from_tty,
9842 struct cmd_list_element *command)
9843 {
9844 struct gdbarch *gdbarch = get_current_arch ();
9845 int tempflag;
9846 struct symtab_and_line sal;
9847 char *addr_string = NULL;
9848 struct breakpoint_ops *ops = NULL;
9849
9850 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
9851
9852 if (!arg)
9853 arg = "";
9854 sal = ada_decode_assert_location (arg, &addr_string, &ops);
9855 create_ada_exception_breakpoint (gdbarch, sal, addr_string, NULL, NULL, NULL,
9856 ops, tempflag, from_tty);
9857 }
9858
9859 static void
catch_command(char * arg,int from_tty)9860 catch_command (char *arg, int from_tty)
9861 {
9862 error (_("Catch requires an event name."));
9863 }
9864
9865
9866 static void
tcatch_command(char * arg,int from_tty)9867 tcatch_command (char *arg, int from_tty)
9868 {
9869 error (_("Catch requires an event name."));
9870 }
9871
9872 /* Delete breakpoints by address or line. */
9873
9874 static void
clear_command(char * arg,int from_tty)9875 clear_command (char *arg, int from_tty)
9876 {
9877 struct breakpoint *b;
9878 VEC(breakpoint_p) *found = 0;
9879 int ix;
9880 int default_match;
9881 struct symtabs_and_lines sals;
9882 struct symtab_and_line sal;
9883 int i;
9884
9885 if (arg)
9886 {
9887 sals = decode_line_spec (arg, 1);
9888 default_match = 0;
9889 }
9890 else
9891 {
9892 sals.sals = (struct symtab_and_line *)
9893 xmalloc (sizeof (struct symtab_and_line));
9894 make_cleanup (xfree, sals.sals);
9895 init_sal (&sal); /* Initialize to zeroes. */
9896 sal.line = default_breakpoint_line;
9897 sal.symtab = default_breakpoint_symtab;
9898 sal.pc = default_breakpoint_address;
9899 sal.pspace = default_breakpoint_pspace;
9900 if (sal.symtab == 0)
9901 error (_("No source file specified."));
9902
9903 sals.sals[0] = sal;
9904 sals.nelts = 1;
9905
9906 default_match = 1;
9907 }
9908
9909 /* We don't call resolve_sal_pc here. That's not as bad as it
9910 seems, because all existing breakpoints typically have both
9911 file/line and pc set. So, if clear is given file/line, we can
9912 match this to existing breakpoint without obtaining pc at all.
9913
9914 We only support clearing given the address explicitly
9915 present in breakpoint table. Say, we've set breakpoint
9916 at file:line. There were several PC values for that file:line,
9917 due to optimization, all in one block.
9918
9919 We've picked one PC value. If "clear" is issued with another
9920 PC corresponding to the same file:line, the breakpoint won't
9921 be cleared. We probably can still clear the breakpoint, but
9922 since the other PC value is never presented to user, user
9923 can only find it by guessing, and it does not seem important
9924 to support that. */
9925
9926 /* For each line spec given, delete bps which correspond to it. Do
9927 it in two passes, solely to preserve the current behavior that
9928 from_tty is forced true if we delete more than one
9929 breakpoint. */
9930
9931 found = NULL;
9932 for (i = 0; i < sals.nelts; i++)
9933 {
9934 /* If exact pc given, clear bpts at that pc.
9935 If line given (pc == 0), clear all bpts on specified line.
9936 If defaulting, clear all bpts on default line
9937 or at default pc.
9938
9939 defaulting sal.pc != 0 tests to do
9940
9941 0 1 pc
9942 1 1 pc _and_ line
9943 0 0 line
9944 1 0 <can't happen> */
9945
9946 sal = sals.sals[i];
9947
9948 /* Find all matching breakpoints and add them to 'found'. */
9949 ALL_BREAKPOINTS (b)
9950 {
9951 int match = 0;
9952 /* Are we going to delete b? */
9953 if (b->type != bp_none && !is_watchpoint (b))
9954 {
9955 struct bp_location *loc = b->loc;
9956 for (; loc; loc = loc->next)
9957 {
9958 int pc_match = sal.pc
9959 && (loc->pspace == sal.pspace)
9960 && (loc->address == sal.pc)
9961 && (!section_is_overlay (loc->section)
9962 || loc->section == sal.section);
9963 int line_match = ((default_match || (0 == sal.pc))
9964 && b->source_file != NULL
9965 && sal.symtab != NULL
9966 && sal.pspace == loc->pspace
9967 && filename_cmp (b->source_file,
9968 sal.symtab->filename) == 0
9969 && b->line_number == sal.line);
9970 if (pc_match || line_match)
9971 {
9972 match = 1;
9973 break;
9974 }
9975 }
9976 }
9977
9978 if (match)
9979 VEC_safe_push(breakpoint_p, found, b);
9980 }
9981 }
9982 /* Now go thru the 'found' chain and delete them. */
9983 if (VEC_empty(breakpoint_p, found))
9984 {
9985 if (arg)
9986 error (_("No breakpoint at %s."), arg);
9987 else
9988 error (_("No breakpoint at this line."));
9989 }
9990
9991 if (VEC_length(breakpoint_p, found) > 1)
9992 from_tty = 1; /* Always report if deleted more than one. */
9993 if (from_tty)
9994 {
9995 if (VEC_length(breakpoint_p, found) == 1)
9996 printf_unfiltered (_("Deleted breakpoint "));
9997 else
9998 printf_unfiltered (_("Deleted breakpoints "));
9999 }
10000 breakpoints_changed ();
10001
10002 for (ix = 0; VEC_iterate(breakpoint_p, found, ix, b); ix++)
10003 {
10004 if (from_tty)
10005 printf_unfiltered ("%d ", b->number);
10006 delete_breakpoint (b);
10007 }
10008 if (from_tty)
10009 putchar_unfiltered ('\n');
10010 }
10011
10012 /* Delete breakpoint in BS if they are `delete' breakpoints and
10013 all breakpoints that are marked for deletion, whether hit or not.
10014 This is called after any breakpoint is hit, or after errors. */
10015
10016 void
breakpoint_auto_delete(bpstat bs)10017 breakpoint_auto_delete (bpstat bs)
10018 {
10019 struct breakpoint *b, *b_tmp;
10020
10021 for (; bs; bs = bs->next)
10022 if (bs->breakpoint_at
10023 && bs->breakpoint_at->disposition == disp_del
10024 && bs->stop)
10025 delete_breakpoint (bs->breakpoint_at);
10026
10027 ALL_BREAKPOINTS_SAFE (b, b_tmp)
10028 {
10029 if (b->disposition == disp_del_at_next_stop)
10030 delete_breakpoint (b);
10031 }
10032 }
10033
10034 /* A comparison function for bp_location AP and BP being interfaced to
10035 qsort. Sort elements primarily by their ADDRESS (no matter what
10036 does breakpoint_address_is_meaningful say for its OWNER),
10037 secondarily by ordering first bp_permanent OWNERed elements and
10038 terciarily just ensuring the array is sorted stable way despite
10039 qsort being an instable algorithm. */
10040
10041 static int
bp_location_compare(const void * ap,const void * bp)10042 bp_location_compare (const void *ap, const void *bp)
10043 {
10044 struct bp_location *a = *(void **) ap;
10045 struct bp_location *b = *(void **) bp;
10046 /* A and B come from existing breakpoints having non-NULL OWNER. */
10047 int a_perm = a->owner->enable_state == bp_permanent;
10048 int b_perm = b->owner->enable_state == bp_permanent;
10049
10050 if (a->address != b->address)
10051 return (a->address > b->address) - (a->address < b->address);
10052
10053 /* Sort permanent breakpoints first. */
10054 if (a_perm != b_perm)
10055 return (a_perm < b_perm) - (a_perm > b_perm);
10056
10057 /* Make the user-visible order stable across GDB runs. Locations of
10058 the same breakpoint can be sorted in arbitrary order. */
10059
10060 if (a->owner->number != b->owner->number)
10061 return (a->owner->number > b->owner->number)
10062 - (a->owner->number < b->owner->number);
10063
10064 return (a > b) - (a < b);
10065 }
10066
10067 /* Set bp_location_placed_address_before_address_max and
10068 bp_location_shadow_len_after_address_max according to the current
10069 content of the bp_location array. */
10070
10071 static void
bp_location_target_extensions_update(void)10072 bp_location_target_extensions_update (void)
10073 {
10074 struct bp_location *bl, **blp_tmp;
10075
10076 bp_location_placed_address_before_address_max = 0;
10077 bp_location_shadow_len_after_address_max = 0;
10078
10079 ALL_BP_LOCATIONS (bl, blp_tmp)
10080 {
10081 CORE_ADDR start, end, addr;
10082
10083 if (!bp_location_has_shadow (bl))
10084 continue;
10085
10086 start = bl->target_info.placed_address;
10087 end = start + bl->target_info.shadow_len;
10088
10089 gdb_assert (bl->address >= start);
10090 addr = bl->address - start;
10091 if (addr > bp_location_placed_address_before_address_max)
10092 bp_location_placed_address_before_address_max = addr;
10093
10094 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
10095
10096 gdb_assert (bl->address < end);
10097 addr = end - bl->address;
10098 if (addr > bp_location_shadow_len_after_address_max)
10099 bp_location_shadow_len_after_address_max = addr;
10100 }
10101 }
10102
10103 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
10104 into the inferior, only remove already-inserted locations that no
10105 longer should be inserted. Functions that delete a breakpoint or
10106 breakpoints should pass false, so that deleting a breakpoint
10107 doesn't have the side effect of inserting the locations of other
10108 breakpoints that are marked not-inserted, but should_be_inserted
10109 returns true on them.
10110
10111 This behaviour is useful is situations close to tear-down -- e.g.,
10112 after an exec, while the target still has execution, but breakpoint
10113 shadows of the previous executable image should *NOT* be restored
10114 to the new image; or before detaching, where the target still has
10115 execution and wants to delete breakpoints from GDB's lists, and all
10116 breakpoints had already been removed from the inferior. */
10117
10118 static void
update_global_location_list(int should_insert)10119 update_global_location_list (int should_insert)
10120 {
10121 struct breakpoint *b;
10122 struct bp_location **locp, *loc;
10123 struct cleanup *cleanups;
10124
10125 /* Used in the duplicates detection below. When iterating over all
10126 bp_locations, points to the first bp_location of a given address.
10127 Breakpoints and watchpoints of different types are never
10128 duplicates of each other. Keep one pointer for each type of
10129 breakpoint/watchpoint, so we only need to loop over all locations
10130 once. */
10131 struct bp_location *bp_loc_first; /* breakpoint */
10132 struct bp_location *wp_loc_first; /* hardware watchpoint */
10133 struct bp_location *awp_loc_first; /* access watchpoint */
10134 struct bp_location *rwp_loc_first; /* read watchpoint */
10135
10136 /* Saved former bp_location array which we compare against the newly
10137 built bp_location from the current state of ALL_BREAKPOINTS. */
10138 struct bp_location **old_location, **old_locp;
10139 unsigned old_location_count;
10140
10141 old_location = bp_location;
10142 old_location_count = bp_location_count;
10143 bp_location = NULL;
10144 bp_location_count = 0;
10145 cleanups = make_cleanup (xfree, old_location);
10146
10147 ALL_BREAKPOINTS (b)
10148 for (loc = b->loc; loc; loc = loc->next)
10149 bp_location_count++;
10150
10151 bp_location = xmalloc (sizeof (*bp_location) * bp_location_count);
10152 locp = bp_location;
10153 ALL_BREAKPOINTS (b)
10154 for (loc = b->loc; loc; loc = loc->next)
10155 *locp++ = loc;
10156 qsort (bp_location, bp_location_count, sizeof (*bp_location),
10157 bp_location_compare);
10158
10159 bp_location_target_extensions_update ();
10160
10161 /* Identify bp_location instances that are no longer present in the
10162 new list, and therefore should be freed. Note that it's not
10163 necessary that those locations should be removed from inferior --
10164 if there's another location at the same address (previously
10165 marked as duplicate), we don't need to remove/insert the
10166 location.
10167
10168 LOCP is kept in sync with OLD_LOCP, each pointing to the current
10169 and former bp_location array state respectively. */
10170
10171 locp = bp_location;
10172 for (old_locp = old_location; old_locp < old_location + old_location_count;
10173 old_locp++)
10174 {
10175 struct bp_location *old_loc = *old_locp;
10176 struct bp_location **loc2p;
10177
10178 /* Tells if 'old_loc' is found amoung the new locations. If
10179 not, we have to free it. */
10180 int found_object = 0;
10181 /* Tells if the location should remain inserted in the target. */
10182 int keep_in_target = 0;
10183 int removed = 0;
10184
10185 /* Skip LOCP entries which will definitely never be needed.
10186 Stop either at or being the one matching OLD_LOC. */
10187 while (locp < bp_location + bp_location_count
10188 && (*locp)->address < old_loc->address)
10189 locp++;
10190
10191 for (loc2p = locp;
10192 (loc2p < bp_location + bp_location_count
10193 && (*loc2p)->address == old_loc->address);
10194 loc2p++)
10195 {
10196 if (*loc2p == old_loc)
10197 {
10198 found_object = 1;
10199 break;
10200 }
10201 }
10202
10203 /* If this location is no longer present, and inserted, look if
10204 there's maybe a new location at the same address. If so,
10205 mark that one inserted, and don't remove this one. This is
10206 needed so that we don't have a time window where a breakpoint
10207 at certain location is not inserted. */
10208
10209 if (old_loc->inserted)
10210 {
10211 /* If the location is inserted now, we might have to remove
10212 it. */
10213
10214 if (found_object && should_be_inserted (old_loc))
10215 {
10216 /* The location is still present in the location list,
10217 and still should be inserted. Don't do anything. */
10218 keep_in_target = 1;
10219 }
10220 else
10221 {
10222 /* The location is either no longer present, or got
10223 disabled. See if there's another location at the
10224 same address, in which case we don't need to remove
10225 this one from the target. */
10226
10227 /* OLD_LOC comes from existing struct breakpoint. */
10228 if (breakpoint_address_is_meaningful (old_loc->owner))
10229 {
10230 for (loc2p = locp;
10231 (loc2p < bp_location + bp_location_count
10232 && (*loc2p)->address == old_loc->address);
10233 loc2p++)
10234 {
10235 struct bp_location *loc2 = *loc2p;
10236
10237 if (breakpoint_locations_match (loc2, old_loc))
10238 {
10239 /* For the sake of should_be_inserted.
10240 Duplicates check below will fix up this
10241 later. */
10242 loc2->duplicate = 0;
10243
10244 /* Read watchpoint locations are switched to
10245 access watchpoints, if the former are not
10246 supported, but the latter are. */
10247 if (is_hardware_watchpoint (old_loc->owner))
10248 {
10249 gdb_assert (is_hardware_watchpoint (loc2->owner));
10250 loc2->watchpoint_type = old_loc->watchpoint_type;
10251 }
10252
10253 if (loc2 != old_loc && should_be_inserted (loc2))
10254 {
10255 loc2->inserted = 1;
10256 loc2->target_info = old_loc->target_info;
10257 keep_in_target = 1;
10258 break;
10259 }
10260 }
10261 }
10262 }
10263 }
10264
10265 if (!keep_in_target)
10266 {
10267 if (remove_breakpoint (old_loc, mark_uninserted))
10268 {
10269 /* This is just about all we can do. We could keep
10270 this location on the global list, and try to
10271 remove it next time, but there's no particular
10272 reason why we will succeed next time.
10273
10274 Note that at this point, old_loc->owner is still
10275 valid, as delete_breakpoint frees the breakpoint
10276 only after calling us. */
10277 printf_filtered (_("warning: Error removing "
10278 "breakpoint %d\n"),
10279 old_loc->owner->number);
10280 }
10281 removed = 1;
10282 }
10283 }
10284
10285 if (!found_object)
10286 {
10287 if (removed && non_stop
10288 && breakpoint_address_is_meaningful (old_loc->owner)
10289 && !is_hardware_watchpoint (old_loc->owner))
10290 {
10291 /* This location was removed from the target. In
10292 non-stop mode, a race condition is possible where
10293 we've removed a breakpoint, but stop events for that
10294 breakpoint are already queued and will arrive later.
10295 We apply an heuristic to be able to distinguish such
10296 SIGTRAPs from other random SIGTRAPs: we keep this
10297 breakpoint location for a bit, and will retire it
10298 after we see some number of events. The theory here
10299 is that reporting of events should, "on the average",
10300 be fair, so after a while we'll see events from all
10301 threads that have anything of interest, and no longer
10302 need to keep this breakpoint location around. We
10303 don't hold locations forever so to reduce chances of
10304 mistaking a non-breakpoint SIGTRAP for a breakpoint
10305 SIGTRAP.
10306
10307 The heuristic failing can be disastrous on
10308 decr_pc_after_break targets.
10309
10310 On decr_pc_after_break targets, like e.g., x86-linux,
10311 if we fail to recognize a late breakpoint SIGTRAP,
10312 because events_till_retirement has reached 0 too
10313 soon, we'll fail to do the PC adjustment, and report
10314 a random SIGTRAP to the user. When the user resumes
10315 the inferior, it will most likely immediately crash
10316 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
10317 corrupted, because of being resumed e.g., in the
10318 middle of a multi-byte instruction, or skipped a
10319 one-byte instruction. This was actually seen happen
10320 on native x86-linux, and should be less rare on
10321 targets that do not support new thread events, like
10322 remote, due to the heuristic depending on
10323 thread_count.
10324
10325 Mistaking a random SIGTRAP for a breakpoint trap
10326 causes similar symptoms (PC adjustment applied when
10327 it shouldn't), but then again, playing with SIGTRAPs
10328 behind the debugger's back is asking for trouble.
10329
10330 Since hardware watchpoint traps are always
10331 distinguishable from other traps, so we don't need to
10332 apply keep hardware watchpoint moribund locations
10333 around. We simply always ignore hardware watchpoint
10334 traps we can no longer explain. */
10335
10336 old_loc->events_till_retirement = 3 * (thread_count () + 1);
10337 old_loc->owner = NULL;
10338
10339 VEC_safe_push (bp_location_p, moribund_locations, old_loc);
10340 }
10341 else
10342 {
10343 old_loc->owner = NULL;
10344 decref_bp_location (&old_loc);
10345 }
10346 }
10347 }
10348
10349 /* Rescan breakpoints at the same address and section, marking the
10350 first one as "first" and any others as "duplicates". This is so
10351 that the bpt instruction is only inserted once. If we have a
10352 permanent breakpoint at the same place as BPT, make that one the
10353 official one, and the rest as duplicates. Permanent breakpoints
10354 are sorted first for the same address.
10355
10356 Do the same for hardware watchpoints, but also considering the
10357 watchpoint's type (regular/access/read) and length. */
10358
10359 bp_loc_first = NULL;
10360 wp_loc_first = NULL;
10361 awp_loc_first = NULL;
10362 rwp_loc_first = NULL;
10363 ALL_BP_LOCATIONS (loc, locp)
10364 {
10365 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
10366 non-NULL. */
10367 struct breakpoint *b = loc->owner;
10368 struct bp_location **loc_first_p;
10369
10370 if (b->enable_state == bp_disabled
10371 || b->enable_state == bp_call_disabled
10372 || b->enable_state == bp_startup_disabled
10373 || !loc->enabled
10374 || loc->shlib_disabled
10375 || !breakpoint_address_is_meaningful (b)
10376 || is_tracepoint (b))
10377 continue;
10378
10379 /* Permanent breakpoint should always be inserted. */
10380 if (b->enable_state == bp_permanent && ! loc->inserted)
10381 internal_error (__FILE__, __LINE__,
10382 _("allegedly permanent breakpoint is not "
10383 "actually inserted"));
10384
10385 if (b->type == bp_hardware_watchpoint)
10386 loc_first_p = &wp_loc_first;
10387 else if (b->type == bp_read_watchpoint)
10388 loc_first_p = &rwp_loc_first;
10389 else if (b->type == bp_access_watchpoint)
10390 loc_first_p = &awp_loc_first;
10391 else
10392 loc_first_p = &bp_loc_first;
10393
10394 if (*loc_first_p == NULL
10395 || (overlay_debugging && loc->section != (*loc_first_p)->section)
10396 || !breakpoint_locations_match (loc, *loc_first_p))
10397 {
10398 *loc_first_p = loc;
10399 loc->duplicate = 0;
10400 continue;
10401 }
10402
10403 loc->duplicate = 1;
10404
10405 if ((*loc_first_p)->owner->enable_state == bp_permanent && loc->inserted
10406 && b->enable_state != bp_permanent)
10407 internal_error (__FILE__, __LINE__,
10408 _("another breakpoint was inserted on top of "
10409 "a permanent breakpoint"));
10410 }
10411
10412 if (breakpoints_always_inserted_mode () && should_insert
10413 && (have_live_inferiors ()
10414 || (gdbarch_has_global_breakpoints (target_gdbarch))))
10415 insert_breakpoint_locations ();
10416
10417 do_cleanups (cleanups);
10418 }
10419
10420 void
breakpoint_retire_moribund(void)10421 breakpoint_retire_moribund (void)
10422 {
10423 struct bp_location *loc;
10424 int ix;
10425
10426 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
10427 if (--(loc->events_till_retirement) == 0)
10428 {
10429 decref_bp_location (&loc);
10430 VEC_unordered_remove (bp_location_p, moribund_locations, ix);
10431 --ix;
10432 }
10433 }
10434
10435 static void
update_global_location_list_nothrow(int inserting)10436 update_global_location_list_nothrow (int inserting)
10437 {
10438 struct gdb_exception e;
10439
10440 TRY_CATCH (e, RETURN_MASK_ERROR)
10441 update_global_location_list (inserting);
10442 }
10443
10444 /* Clear BKP from a BPS. */
10445
10446 static void
bpstat_remove_bp_location(bpstat bps,struct breakpoint * bpt)10447 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
10448 {
10449 bpstat bs;
10450
10451 for (bs = bps; bs; bs = bs->next)
10452 if (bs->breakpoint_at == bpt)
10453 {
10454 bs->breakpoint_at = NULL;
10455 bs->old_val = NULL;
10456 /* bs->commands will be freed later. */
10457 }
10458 }
10459
10460 /* Callback for iterate_over_threads. */
10461 static int
bpstat_remove_breakpoint_callback(struct thread_info * th,void * data)10462 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
10463 {
10464 struct breakpoint *bpt = data;
10465
10466 bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
10467 return 0;
10468 }
10469
10470 /* Delete a breakpoint and clean up all traces of it in the data
10471 structures. */
10472
10473 void
delete_breakpoint(struct breakpoint * bpt)10474 delete_breakpoint (struct breakpoint *bpt)
10475 {
10476 struct breakpoint *b;
10477
10478 gdb_assert (bpt != NULL);
10479
10480 /* Has this bp already been deleted? This can happen because
10481 multiple lists can hold pointers to bp's. bpstat lists are
10482 especial culprits.
10483
10484 One example of this happening is a watchpoint's scope bp. When
10485 the scope bp triggers, we notice that the watchpoint is out of
10486 scope, and delete it. We also delete its scope bp. But the
10487 scope bp is marked "auto-deleting", and is already on a bpstat.
10488 That bpstat is then checked for auto-deleting bp's, which are
10489 deleted.
10490
10491 A real solution to this problem might involve reference counts in
10492 bp's, and/or giving them pointers back to their referencing
10493 bpstat's, and teaching delete_breakpoint to only free a bp's
10494 storage when no more references were extent. A cheaper bandaid
10495 was chosen. */
10496 if (bpt->type == bp_none)
10497 return;
10498
10499 /* At least avoid this stale reference until the reference counting
10500 of breakpoints gets resolved. */
10501 if (bpt->related_breakpoint != bpt)
10502 {
10503 struct breakpoint *related;
10504
10505 if (bpt->type == bp_watchpoint_scope)
10506 watchpoint_del_at_next_stop (bpt->related_breakpoint);
10507 else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
10508 watchpoint_del_at_next_stop (bpt);
10509
10510 /* Unlink bpt from the bpt->related_breakpoint ring. */
10511 for (related = bpt; related->related_breakpoint != bpt;
10512 related = related->related_breakpoint);
10513 related->related_breakpoint = bpt->related_breakpoint;
10514 bpt->related_breakpoint = bpt;
10515 }
10516
10517 observer_notify_breakpoint_deleted (bpt->number);
10518
10519 if (breakpoint_chain == bpt)
10520 breakpoint_chain = bpt->next;
10521
10522 ALL_BREAKPOINTS (b)
10523 if (b->next == bpt)
10524 {
10525 b->next = bpt->next;
10526 break;
10527 }
10528
10529 decref_counted_command_line (&bpt->commands);
10530 xfree (bpt->cond_string);
10531 xfree (bpt->cond_exp);
10532 xfree (bpt->addr_string);
10533 xfree (bpt->addr_string_range_end);
10534 xfree (bpt->exp);
10535 xfree (bpt->exp_string);
10536 xfree (bpt->exp_string_reparse);
10537 value_free (bpt->val);
10538 xfree (bpt->source_file);
10539 xfree (bpt->exec_pathname);
10540 clean_up_filters (&bpt->syscalls_to_be_caught);
10541
10542
10543 /* Be sure no bpstat's are pointing at the breakpoint after it's
10544 been freed. */
10545 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
10546 in all threeds for now. Note that we cannot just remove bpstats
10547 pointing at bpt from the stop_bpstat list entirely, as breakpoint
10548 commands are associated with the bpstat; if we remove it here,
10549 then the later call to bpstat_do_actions (&stop_bpstat); in
10550 event-top.c won't do anything, and temporary breakpoints with
10551 commands won't work. */
10552
10553 iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
10554
10555 /* Now that breakpoint is removed from breakpoint list, update the
10556 global location list. This will remove locations that used to
10557 belong to this breakpoint. Do this before freeing the breakpoint
10558 itself, since remove_breakpoint looks at location's owner. It
10559 might be better design to have location completely
10560 self-contained, but it's not the case now. */
10561 update_global_location_list (0);
10562
10563
10564 /* On the chance that someone will soon try again to delete this
10565 same bp, we mark it as deleted before freeing its storage. */
10566 bpt->type = bp_none;
10567
10568 xfree (bpt);
10569 }
10570
10571 static void
do_delete_breakpoint_cleanup(void * b)10572 do_delete_breakpoint_cleanup (void *b)
10573 {
10574 delete_breakpoint (b);
10575 }
10576
10577 struct cleanup *
make_cleanup_delete_breakpoint(struct breakpoint * b)10578 make_cleanup_delete_breakpoint (struct breakpoint *b)
10579 {
10580 return make_cleanup (do_delete_breakpoint_cleanup, b);
10581 }
10582
10583 /* A callback for map_breakpoint_numbers that calls
10584 delete_breakpoint. */
10585
10586 static void
do_delete_breakpoint(struct breakpoint * b,void * ignore)10587 do_delete_breakpoint (struct breakpoint *b, void *ignore)
10588 {
10589 delete_breakpoint (b);
10590 }
10591
10592 void
delete_command(char * arg,int from_tty)10593 delete_command (char *arg, int from_tty)
10594 {
10595 struct breakpoint *b, *b_tmp;
10596
10597 dont_repeat ();
10598
10599 if (arg == 0)
10600 {
10601 int breaks_to_delete = 0;
10602
10603 /* Delete all breakpoints if no argument.
10604 Do not delete internal or call-dummy breakpoints, these have
10605 to be deleted with an explicit breakpoint number argument. */
10606 ALL_BREAKPOINTS (b)
10607 {
10608 if (b->type != bp_call_dummy
10609 && b->type != bp_std_terminate
10610 && b->type != bp_shlib_event
10611 && b->type != bp_jit_event
10612 && b->type != bp_thread_event
10613 && b->type != bp_overlay_event
10614 && b->type != bp_longjmp_master
10615 && b->type != bp_std_terminate_master
10616 && b->type != bp_exception_master
10617 && b->number >= 0)
10618 {
10619 breaks_to_delete = 1;
10620 break;
10621 }
10622 }
10623
10624 /* Ask user only if there are some breakpoints to delete. */
10625 if (!from_tty
10626 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
10627 {
10628 ALL_BREAKPOINTS_SAFE (b, b_tmp)
10629 {
10630 if (b->type != bp_call_dummy
10631 && b->type != bp_std_terminate
10632 && b->type != bp_shlib_event
10633 && b->type != bp_thread_event
10634 && b->type != bp_jit_event
10635 && b->type != bp_overlay_event
10636 && b->type != bp_longjmp_master
10637 && b->type != bp_std_terminate_master
10638 && b->type != bp_exception_master
10639 && b->number >= 0)
10640 delete_breakpoint (b);
10641 }
10642 }
10643 }
10644 else
10645 map_breakpoint_numbers (arg, do_delete_breakpoint, NULL);
10646 }
10647
10648 static int
all_locations_are_pending(struct bp_location * loc)10649 all_locations_are_pending (struct bp_location *loc)
10650 {
10651 for (; loc; loc = loc->next)
10652 if (!loc->shlib_disabled)
10653 return 0;
10654 return 1;
10655 }
10656
10657 /* Subroutine of update_breakpoint_locations to simplify it.
10658 Return non-zero if multiple fns in list LOC have the same name.
10659 Null names are ignored. */
10660
10661 static int
ambiguous_names_p(struct bp_location * loc)10662 ambiguous_names_p (struct bp_location *loc)
10663 {
10664 struct bp_location *l;
10665 htab_t htab = htab_create_alloc (13, htab_hash_string,
10666 (int (*) (const void *,
10667 const void *)) streq,
10668 NULL, xcalloc, xfree);
10669
10670 for (l = loc; l != NULL; l = l->next)
10671 {
10672 const char **slot;
10673 const char *name = l->function_name;
10674
10675 /* Allow for some names to be NULL, ignore them. */
10676 if (name == NULL)
10677 continue;
10678
10679 slot = (const char **) htab_find_slot (htab, (const void *) name,
10680 INSERT);
10681 /* NOTE: We can assume slot != NULL here because xcalloc never
10682 returns NULL. */
10683 if (*slot != NULL)
10684 {
10685 htab_delete (htab);
10686 return 1;
10687 }
10688 *slot = name;
10689 }
10690
10691 htab_delete (htab);
10692 return 0;
10693 }
10694
10695 /* When symbols change, it probably means the sources changed as well,
10696 and it might mean the static tracepoint markers are no longer at
10697 the same address or line numbers they used to be at last we
10698 checked. Losing your static tracepoints whenever you rebuild is
10699 undesirable. This function tries to resync/rematch gdb static
10700 tracepoints with the markers on the target, for static tracepoints
10701 that have not been set by marker id. Static tracepoint that have
10702 been set by marker id are reset by marker id in breakpoint_re_set.
10703 The heuristic is:
10704
10705 1) For a tracepoint set at a specific address, look for a marker at
10706 the old PC. If one is found there, assume to be the same marker.
10707 If the name / string id of the marker found is different from the
10708 previous known name, assume that means the user renamed the marker
10709 in the sources, and output a warning.
10710
10711 2) For a tracepoint set at a given line number, look for a marker
10712 at the new address of the old line number. If one is found there,
10713 assume to be the same marker. If the name / string id of the
10714 marker found is different from the previous known name, assume that
10715 means the user renamed the marker in the sources, and output a
10716 warning.
10717
10718 3) If a marker is no longer found at the same address or line, it
10719 may mean the marker no longer exists. But it may also just mean
10720 the code changed a bit. Maybe the user added a few lines of code
10721 that made the marker move up or down (in line number terms). Ask
10722 the target for info about the marker with the string id as we knew
10723 it. If found, update line number and address in the matching
10724 static tracepoint. This will get confused if there's more than one
10725 marker with the same ID (possible in UST, although unadvised
10726 precisely because it confuses tools). */
10727
10728 static struct symtab_and_line
update_static_tracepoint(struct breakpoint * b,struct symtab_and_line sal)10729 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
10730 {
10731 struct static_tracepoint_marker marker;
10732 CORE_ADDR pc;
10733 int i;
10734
10735 pc = sal.pc;
10736 if (sal.line)
10737 find_line_pc (sal.symtab, sal.line, &pc);
10738
10739 if (target_static_tracepoint_marker_at (pc, &marker))
10740 {
10741 if (strcmp (b->static_trace_marker_id, marker.str_id) != 0)
10742 warning (_("static tracepoint %d changed probed marker from %s to %s"),
10743 b->number,
10744 b->static_trace_marker_id, marker.str_id);
10745
10746 xfree (b->static_trace_marker_id);
10747 b->static_trace_marker_id = xstrdup (marker.str_id);
10748 release_static_tracepoint_marker (&marker);
10749
10750 return sal;
10751 }
10752
10753 /* Old marker wasn't found on target at lineno. Try looking it up
10754 by string ID. */
10755 if (!sal.explicit_pc
10756 && sal.line != 0
10757 && sal.symtab != NULL
10758 && b->static_trace_marker_id != NULL)
10759 {
10760 VEC(static_tracepoint_marker_p) *markers;
10761
10762 markers
10763 = target_static_tracepoint_markers_by_strid (b->static_trace_marker_id);
10764
10765 if (!VEC_empty(static_tracepoint_marker_p, markers))
10766 {
10767 struct symtab_and_line sal;
10768 struct symbol *sym;
10769 struct static_tracepoint_marker *marker;
10770
10771 marker = VEC_index (static_tracepoint_marker_p, markers, 0);
10772
10773 xfree (b->static_trace_marker_id);
10774 b->static_trace_marker_id = xstrdup (marker->str_id);
10775
10776 warning (_("marker for static tracepoint %d (%s) not "
10777 "found at previous line number"),
10778 b->number, b->static_trace_marker_id);
10779
10780 init_sal (&sal);
10781
10782 sal.pc = marker->address;
10783
10784 sal = find_pc_line (marker->address, 0);
10785 sym = find_pc_sect_function (marker->address, NULL);
10786 ui_out_text (uiout, "Now in ");
10787 if (sym)
10788 {
10789 ui_out_field_string (uiout, "func",
10790 SYMBOL_PRINT_NAME (sym));
10791 ui_out_text (uiout, " at ");
10792 }
10793 ui_out_field_string (uiout, "file", sal.symtab->filename);
10794 ui_out_text (uiout, ":");
10795
10796 if (ui_out_is_mi_like_p (uiout))
10797 {
10798 char *fullname = symtab_to_fullname (sal.symtab);
10799
10800 if (fullname)
10801 ui_out_field_string (uiout, "fullname", fullname);
10802 }
10803
10804 ui_out_field_int (uiout, "line", sal.line);
10805 ui_out_text (uiout, "\n");
10806
10807 b->line_number = sal.line;
10808
10809 xfree (b->source_file);
10810 if (sym)
10811 b->source_file = xstrdup (sal.symtab->filename);
10812 else
10813 b->source_file = NULL;
10814
10815 xfree (b->addr_string);
10816 b->addr_string = xstrprintf ("%s:%d",
10817 sal.symtab->filename, b->line_number);
10818
10819 /* Might be nice to check if function changed, and warn if
10820 so. */
10821
10822 release_static_tracepoint_marker (marker);
10823 }
10824 }
10825 return sal;
10826 }
10827
10828 /* Create new breakpoint locations for B (a hardware or software breakpoint)
10829 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
10830 a ranged breakpoint. */
10831
10832 void
update_breakpoint_locations(struct breakpoint * b,struct symtabs_and_lines sals,struct symtabs_and_lines sals_end)10833 update_breakpoint_locations (struct breakpoint *b,
10834 struct symtabs_and_lines sals,
10835 struct symtabs_and_lines sals_end)
10836 {
10837 int i;
10838 struct bp_location *existing_locations = b->loc;
10839
10840 /* Ranged breakpoints have only one start location and one end location. */
10841 gdb_assert (sals_end.nelts == 0 || (sals.nelts == 1 && sals_end.nelts == 1));
10842
10843 /* If there's no new locations, and all existing locations are
10844 pending, don't do anything. This optimizes the common case where
10845 all locations are in the same shared library, that was unloaded.
10846 We'd like to retain the location, so that when the library is
10847 loaded again, we don't loose the enabled/disabled status of the
10848 individual locations. */
10849 if (all_locations_are_pending (existing_locations) && sals.nelts == 0)
10850 return;
10851
10852 b->loc = NULL;
10853
10854 for (i = 0; i < sals.nelts; ++i)
10855 {
10856 struct bp_location *new_loc =
10857 add_location_to_breakpoint (b, &(sals.sals[i]));
10858
10859 /* Reparse conditions, they might contain references to the
10860 old symtab. */
10861 if (b->cond_string != NULL)
10862 {
10863 char *s;
10864 struct gdb_exception e;
10865
10866 s = b->cond_string;
10867 TRY_CATCH (e, RETURN_MASK_ERROR)
10868 {
10869 new_loc->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc),
10870 0);
10871 }
10872 if (e.reason < 0)
10873 {
10874 warning (_("failed to reevaluate condition "
10875 "for breakpoint %d: %s"),
10876 b->number, e.message);
10877 new_loc->enabled = 0;
10878 }
10879 }
10880
10881 if (b->source_file != NULL)
10882 xfree (b->source_file);
10883 if (sals.sals[i].symtab == NULL)
10884 b->source_file = NULL;
10885 else
10886 b->source_file = xstrdup (sals.sals[i].symtab->filename);
10887
10888 if (b->line_number == 0)
10889 b->line_number = sals.sals[i].line;
10890
10891 if (sals_end.nelts)
10892 {
10893 CORE_ADDR end = find_breakpoint_range_end (sals_end.sals[0]);
10894
10895 new_loc->length = end - sals.sals[0].pc + 1;
10896 }
10897 }
10898
10899 /* Update locations of permanent breakpoints. */
10900 if (b->enable_state == bp_permanent)
10901 make_breakpoint_permanent (b);
10902
10903 /* If possible, carry over 'disable' status from existing
10904 breakpoints. */
10905 {
10906 struct bp_location *e = existing_locations;
10907 /* If there are multiple breakpoints with the same function name,
10908 e.g. for inline functions, comparing function names won't work.
10909 Instead compare pc addresses; this is just a heuristic as things
10910 may have moved, but in practice it gives the correct answer
10911 often enough until a better solution is found. */
10912 int have_ambiguous_names = ambiguous_names_p (b->loc);
10913
10914 for (; e; e = e->next)
10915 {
10916 if (!e->enabled && e->function_name)
10917 {
10918 struct bp_location *l = b->loc;
10919 if (have_ambiguous_names)
10920 {
10921 for (; l; l = l->next)
10922 if (breakpoint_locations_match (e, l))
10923 {
10924 l->enabled = 0;
10925 break;
10926 }
10927 }
10928 else
10929 {
10930 for (; l; l = l->next)
10931 if (l->function_name
10932 && strcmp (e->function_name, l->function_name) == 0)
10933 {
10934 l->enabled = 0;
10935 break;
10936 }
10937 }
10938 }
10939 }
10940 }
10941
10942 update_global_location_list (1);
10943 }
10944
10945 /* Find the SaL locations corresponding to the given ADDR_STRING.
10946 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
10947
10948 static struct symtabs_and_lines
addr_string_to_sals(struct breakpoint * b,char * addr_string,int * found)10949 addr_string_to_sals (struct breakpoint *b, char *addr_string, int *found)
10950 {
10951 char *s;
10952 int marker_spec;
10953 struct symtabs_and_lines sals = {0};
10954 struct gdb_exception e;
10955
10956 s = addr_string;
10957 marker_spec = b->type == bp_static_tracepoint && is_marker_spec (s);
10958
10959 TRY_CATCH (e, RETURN_MASK_ERROR)
10960 {
10961 if (marker_spec)
10962 {
10963 sals = decode_static_tracepoint_spec (&s);
10964 if (sals.nelts > b->static_trace_marker_id_idx)
10965 {
10966 sals.sals[0] = sals.sals[b->static_trace_marker_id_idx];
10967 sals.nelts = 1;
10968 }
10969 else
10970 error (_("marker %s not found"), b->static_trace_marker_id);
10971 }
10972 else
10973 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, NULL);
10974 }
10975 if (e.reason < 0)
10976 {
10977 int not_found_and_ok = 0;
10978 /* For pending breakpoints, it's expected that parsing will
10979 fail until the right shared library is loaded. User has
10980 already told to create pending breakpoints and don't need
10981 extra messages. If breakpoint is in bp_shlib_disabled
10982 state, then user already saw the message about that
10983 breakpoint being disabled, and don't want to see more
10984 errors. */
10985 if (e.error == NOT_FOUND_ERROR
10986 && (b->condition_not_parsed
10987 || (b->loc && b->loc->shlib_disabled)
10988 || b->enable_state == bp_disabled))
10989 not_found_and_ok = 1;
10990
10991 if (!not_found_and_ok)
10992 {
10993 /* We surely don't want to warn about the same breakpoint
10994 10 times. One solution, implemented here, is disable
10995 the breakpoint on error. Another solution would be to
10996 have separate 'warning emitted' flag. Since this
10997 happens only when a binary has changed, I don't know
10998 which approach is better. */
10999 b->enable_state = bp_disabled;
11000 throw_exception (e);
11001 }
11002 }
11003
11004 if (e.reason == 0 || e.error != NOT_FOUND_ERROR)
11005 {
11006 gdb_assert (sals.nelts == 1);
11007
11008 resolve_sal_pc (&sals.sals[0]);
11009 if (b->condition_not_parsed && s && s[0])
11010 {
11011 char *cond_string = 0;
11012 int thread = -1;
11013 int task = 0;
11014
11015 find_condition_and_thread (s, sals.sals[0].pc,
11016 &cond_string, &thread, &task);
11017 if (cond_string)
11018 b->cond_string = cond_string;
11019 b->thread = thread;
11020 b->task = task;
11021 b->condition_not_parsed = 0;
11022 }
11023
11024 if (b->type == bp_static_tracepoint && !marker_spec)
11025 sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
11026
11027 *found = 1;
11028 }
11029 else
11030 *found = 0;
11031
11032 return sals;
11033 }
11034
11035 /* Reevaluate a hardware or software breakpoint and recreate its locations.
11036 This is necessary after symbols are read (e.g., an executable or DSO
11037 was loaded, or the inferior just started). */
11038
11039 static void
re_set_breakpoint(struct breakpoint * b)11040 re_set_breakpoint (struct breakpoint *b)
11041 {
11042 int found;
11043 struct symtabs_and_lines sals, sals_end;
11044 struct symtabs_and_lines expanded = {0};
11045 struct symtabs_and_lines expanded_end = {0};
11046 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
11047
11048 input_radix = b->input_radix;
11049 save_current_space_and_thread ();
11050 switch_to_program_space_and_thread (b->pspace);
11051 set_language (b->language);
11052
11053 sals = addr_string_to_sals (b, b->addr_string, &found);
11054 if (found)
11055 {
11056 make_cleanup (xfree, sals.sals);
11057 expanded = expand_line_sal_maybe (sals.sals[0]);
11058 }
11059
11060 if (b->addr_string_range_end)
11061 {
11062 sals_end = addr_string_to_sals (b, b->addr_string_range_end, &found);
11063 if (found)
11064 {
11065 make_cleanup (xfree, sals_end.sals);
11066 expanded_end = expand_line_sal_maybe (sals_end.sals[0]);
11067 }
11068 }
11069
11070 update_breakpoint_locations (b, expanded, expanded_end);
11071 do_cleanups (cleanups);
11072 }
11073
11074 /* Reset a breakpoint given it's struct breakpoint * BINT.
11075 The value we return ends up being the return value from catch_errors.
11076 Unused in this case. */
11077
11078 static int
breakpoint_re_set_one(void * bint)11079 breakpoint_re_set_one (void *bint)
11080 {
11081 /* Get past catch_errs. */
11082 struct breakpoint *b = (struct breakpoint *) bint;
11083
11084 switch (b->type)
11085 {
11086 case bp_none:
11087 warning (_("attempted to reset apparently deleted breakpoint #%d?"),
11088 b->number);
11089 return 0;
11090 case bp_breakpoint:
11091 case bp_hardware_breakpoint:
11092 case bp_tracepoint:
11093 case bp_fast_tracepoint:
11094 case bp_static_tracepoint:
11095 case bp_gnu_ifunc_resolver:
11096 /* Do not attempt to re-set breakpoints disabled during startup. */
11097 if (b->enable_state == bp_startup_disabled)
11098 return 0;
11099
11100 if (b->addr_string == NULL)
11101 {
11102 /* Anything without a string can't be re-set. */
11103 delete_breakpoint (b);
11104 return 0;
11105 }
11106
11107 re_set_breakpoint (b);
11108 break;
11109
11110 case bp_watchpoint:
11111 case bp_hardware_watchpoint:
11112 case bp_read_watchpoint:
11113 case bp_access_watchpoint:
11114 /* Watchpoint can be either on expression using entirely global
11115 variables, or it can be on local variables.
11116
11117 Watchpoints of the first kind are never auto-deleted, and
11118 even persist across program restarts. Since they can use
11119 variables from shared libraries, we need to reparse
11120 expression as libraries are loaded and unloaded.
11121
11122 Watchpoints on local variables can also change meaning as
11123 result of solib event. For example, if a watchpoint uses
11124 both a local and a global variables in expression, it's a
11125 local watchpoint, but unloading of a shared library will make
11126 the expression invalid. This is not a very common use case,
11127 but we still re-evaluate expression, to avoid surprises to
11128 the user.
11129
11130 Note that for local watchpoints, we re-evaluate it only if
11131 watchpoints frame id is still valid. If it's not, it means
11132 the watchpoint is out of scope and will be deleted soon. In
11133 fact, I'm not sure we'll ever be called in this case.
11134
11135 If a local watchpoint's frame id is still valid, then
11136 b->exp_valid_block is likewise valid, and we can safely use it.
11137
11138 Don't do anything about disabled watchpoints, since they will
11139 be reevaluated again when enabled. */
11140 update_watchpoint (b, 1 /* reparse */);
11141 break;
11142 /* We needn't really do anything to reset these, since the mask
11143 that requests them is unaffected by e.g., new libraries being
11144 loaded. */
11145 case bp_catchpoint:
11146 break;
11147
11148 default:
11149 printf_filtered (_("Deleting unknown breakpoint type %d\n"), b->type);
11150 /* fall through */
11151 /* Delete overlay event and longjmp master breakpoints; they will be
11152 reset later by breakpoint_re_set. */
11153 case bp_overlay_event:
11154 case bp_longjmp_master:
11155 case bp_std_terminate_master:
11156 case bp_exception_master:
11157 delete_breakpoint (b);
11158 break;
11159
11160 /* This breakpoint is special, it's set up when the inferior
11161 starts and we really don't want to touch it. */
11162 case bp_shlib_event:
11163
11164 /* Like bp_shlib_event, this breakpoint type is special.
11165 Once it is set up, we do not want to touch it. */
11166 case bp_thread_event:
11167
11168 /* Keep temporary breakpoints, which can be encountered when we
11169 step over a dlopen call and SOLIB_ADD is resetting the
11170 breakpoints. Otherwise these should have been blown away via
11171 the cleanup chain or by breakpoint_init_inferior when we
11172 rerun the executable. */
11173 case bp_until:
11174 case bp_finish:
11175 case bp_watchpoint_scope:
11176 case bp_call_dummy:
11177 case bp_std_terminate:
11178 case bp_step_resume:
11179 case bp_longjmp:
11180 case bp_longjmp_resume:
11181 case bp_exception:
11182 case bp_exception_resume:
11183 case bp_jit_event:
11184 case bp_gnu_ifunc_resolver_return:
11185 break;
11186 }
11187
11188 return 0;
11189 }
11190
11191 /* Re-set all breakpoints after symbols have been re-loaded. */
11192 void
breakpoint_re_set(void)11193 breakpoint_re_set (void)
11194 {
11195 struct breakpoint *b, *b_tmp;
11196 enum language save_language;
11197 int save_input_radix;
11198 struct cleanup *old_chain;
11199
11200 save_language = current_language->la_language;
11201 save_input_radix = input_radix;
11202 old_chain = save_current_program_space ();
11203
11204 ALL_BREAKPOINTS_SAFE (b, b_tmp)
11205 {
11206 /* Format possible error msg. */
11207 char *message = xstrprintf ("Error in re-setting breakpoint %d: ",
11208 b->number);
11209 struct cleanup *cleanups = make_cleanup (xfree, message);
11210 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
11211 do_cleanups (cleanups);
11212 }
11213 set_language (save_language);
11214 input_radix = save_input_radix;
11215
11216 jit_breakpoint_re_set ();
11217
11218 do_cleanups (old_chain);
11219
11220 create_overlay_event_breakpoint ();
11221 create_longjmp_master_breakpoint ();
11222 create_std_terminate_master_breakpoint ();
11223 create_exception_master_breakpoint ();
11224 }
11225
11226 /* Reset the thread number of this breakpoint:
11227
11228 - If the breakpoint is for all threads, leave it as-is.
11229 - Else, reset it to the current thread for inferior_ptid. */
11230 void
breakpoint_re_set_thread(struct breakpoint * b)11231 breakpoint_re_set_thread (struct breakpoint *b)
11232 {
11233 if (b->thread != -1)
11234 {
11235 if (in_thread_list (inferior_ptid))
11236 b->thread = pid_to_thread_id (inferior_ptid);
11237
11238 /* We're being called after following a fork. The new fork is
11239 selected as current, and unless this was a vfork will have a
11240 different program space from the original thread. Reset that
11241 as well. */
11242 b->loc->pspace = current_program_space;
11243 }
11244 }
11245
11246 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11247 If from_tty is nonzero, it prints a message to that effect,
11248 which ends with a period (no newline). */
11249
11250 void
set_ignore_count(int bptnum,int count,int from_tty)11251 set_ignore_count (int bptnum, int count, int from_tty)
11252 {
11253 struct breakpoint *b;
11254
11255 if (count < 0)
11256 count = 0;
11257
11258 ALL_BREAKPOINTS (b)
11259 if (b->number == bptnum)
11260 {
11261 if (is_tracepoint (b))
11262 {
11263 if (from_tty && count != 0)
11264 printf_filtered (_("Ignore count ignored for tracepoint %d."),
11265 bptnum);
11266 return;
11267 }
11268
11269 b->ignore_count = count;
11270 if (from_tty)
11271 {
11272 if (count == 0)
11273 printf_filtered (_("Will stop next time "
11274 "breakpoint %d is reached."),
11275 bptnum);
11276 else if (count == 1)
11277 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
11278 bptnum);
11279 else
11280 printf_filtered (_("Will ignore next %d "
11281 "crossings of breakpoint %d."),
11282 count, bptnum);
11283 }
11284 breakpoints_changed ();
11285 observer_notify_breakpoint_modified (b->number);
11286 return;
11287 }
11288
11289 error (_("No breakpoint number %d."), bptnum);
11290 }
11291
11292 /* Command to set ignore-count of breakpoint N to COUNT. */
11293
11294 static void
ignore_command(char * args,int from_tty)11295 ignore_command (char *args, int from_tty)
11296 {
11297 char *p = args;
11298 int num;
11299
11300 if (p == 0)
11301 error_no_arg (_("a breakpoint number"));
11302
11303 num = get_number (&p);
11304 if (num == 0)
11305 error (_("bad breakpoint number: '%s'"), args);
11306 if (*p == 0)
11307 error (_("Second argument (specified ignore-count) is missing."));
11308
11309 set_ignore_count (num,
11310 longest_to_int (value_as_long (parse_and_eval (p))),
11311 from_tty);
11312 if (from_tty)
11313 printf_filtered ("\n");
11314 }
11315
11316 /* Call FUNCTION on each of the breakpoints
11317 whose numbers are given in ARGS. */
11318
11319 static void
map_breakpoint_numbers(char * args,void (* function)(struct breakpoint *,void *),void * data)11320 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *,
11321 void *),
11322 void *data)
11323 {
11324 int num;
11325 struct breakpoint *b, *tmp;
11326 int match;
11327 struct get_number_or_range_state state;
11328
11329 if (args == 0)
11330 error_no_arg (_("one or more breakpoint numbers"));
11331
11332 init_number_or_range (&state, args);
11333
11334 while (!state.finished)
11335 {
11336 char *p = state.string;
11337
11338 match = 0;
11339
11340 num = get_number_or_range (&state);
11341 if (num == 0)
11342 {
11343 warning (_("bad breakpoint number at or near '%s'"), p);
11344 }
11345 else
11346 {
11347 ALL_BREAKPOINTS_SAFE (b, tmp)
11348 if (b->number == num)
11349 {
11350 struct breakpoint *related_breakpoint;
11351
11352 match = 1;
11353 related_breakpoint = b;
11354 do
11355 {
11356 struct breakpoint *next_related_b;
11357
11358 /* FUNCTION can be also delete_breakpoint. */
11359 next_related_b = related_breakpoint->related_breakpoint;
11360 function (related_breakpoint, data);
11361
11362 /* For delete_breakpoint of the last entry of the ring we
11363 were traversing we would never get back to B. */
11364 if (next_related_b == related_breakpoint)
11365 break;
11366 related_breakpoint = next_related_b;
11367 }
11368 while (related_breakpoint != b);
11369 break;
11370 }
11371 if (match == 0)
11372 printf_unfiltered (_("No breakpoint number %d.\n"), num);
11373 }
11374 }
11375 }
11376
11377 static struct bp_location *
find_location_by_number(char * number)11378 find_location_by_number (char *number)
11379 {
11380 char *dot = strchr (number, '.');
11381 char *p1;
11382 int bp_num;
11383 int loc_num;
11384 struct breakpoint *b;
11385 struct bp_location *loc;
11386
11387 *dot = '\0';
11388
11389 p1 = number;
11390 bp_num = get_number (&p1);
11391 if (bp_num == 0)
11392 error (_("Bad breakpoint number '%s'"), number);
11393
11394 ALL_BREAKPOINTS (b)
11395 if (b->number == bp_num)
11396 {
11397 break;
11398 }
11399
11400 if (!b || b->number != bp_num)
11401 error (_("Bad breakpoint number '%s'"), number);
11402
11403 p1 = dot+1;
11404 loc_num = get_number (&p1);
11405 if (loc_num == 0)
11406 error (_("Bad breakpoint location number '%s'"), number);
11407
11408 --loc_num;
11409 loc = b->loc;
11410 for (;loc_num && loc; --loc_num, loc = loc->next)
11411 ;
11412 if (!loc)
11413 error (_("Bad breakpoint location number '%s'"), dot+1);
11414
11415 return loc;
11416 }
11417
11418
11419 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
11420 If from_tty is nonzero, it prints a message to that effect,
11421 which ends with a period (no newline). */
11422
11423 void
disable_breakpoint(struct breakpoint * bpt)11424 disable_breakpoint (struct breakpoint *bpt)
11425 {
11426 /* Never disable a watchpoint scope breakpoint; we want to
11427 hit them when we leave scope so we can delete both the
11428 watchpoint and its scope breakpoint at that time. */
11429 if (bpt->type == bp_watchpoint_scope)
11430 return;
11431
11432 /* You can't disable permanent breakpoints. */
11433 if (bpt->enable_state == bp_permanent)
11434 return;
11435
11436 bpt->enable_state = bp_disabled;
11437
11438 update_global_location_list (0);
11439
11440 observer_notify_breakpoint_modified (bpt->number);
11441 }
11442
11443 /* A callback for map_breakpoint_numbers that calls
11444 disable_breakpoint. */
11445
11446 static void
do_map_disable_breakpoint(struct breakpoint * b,void * ignore)11447 do_map_disable_breakpoint (struct breakpoint *b, void *ignore)
11448 {
11449 disable_breakpoint (b);
11450 }
11451
11452 static void
disable_command(char * args,int from_tty)11453 disable_command (char *args, int from_tty)
11454 {
11455 struct breakpoint *bpt;
11456
11457 if (args == 0)
11458 ALL_BREAKPOINTS (bpt)
11459 switch (bpt->type)
11460 {
11461 case bp_none:
11462 warning (_("attempted to disable apparently deleted breakpoint #%d?"),
11463 bpt->number);
11464 break;
11465 case bp_breakpoint:
11466 case bp_tracepoint:
11467 case bp_fast_tracepoint:
11468 case bp_static_tracepoint:
11469 case bp_catchpoint:
11470 case bp_hardware_breakpoint:
11471 case bp_watchpoint:
11472 case bp_hardware_watchpoint:
11473 case bp_read_watchpoint:
11474 case bp_access_watchpoint:
11475 disable_breakpoint (bpt);
11476 break;
11477 default:
11478 break;
11479 }
11480 else if (strchr (args, '.'))
11481 {
11482 struct bp_location *loc = find_location_by_number (args);
11483 if (loc)
11484 loc->enabled = 0;
11485 update_global_location_list (0);
11486 }
11487 else
11488 map_breakpoint_numbers (args, do_map_disable_breakpoint, NULL);
11489 }
11490
11491 static void
do_enable_breakpoint(struct breakpoint * bpt,enum bpdisp disposition)11492 do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
11493 {
11494 int target_resources_ok;
11495
11496 if (bpt->type == bp_hardware_breakpoint)
11497 {
11498 int i;
11499 i = hw_breakpoint_used_count ();
11500 target_resources_ok =
11501 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
11502 i + 1, 0);
11503 if (target_resources_ok == 0)
11504 error (_("No hardware breakpoint support in the target."));
11505 else if (target_resources_ok < 0)
11506 error (_("Hardware breakpoints used exceeds limit."));
11507 }
11508
11509 if (is_watchpoint (bpt))
11510 {
11511 struct gdb_exception e;
11512
11513 TRY_CATCH (e, RETURN_MASK_ALL)
11514 {
11515 update_watchpoint (bpt, 1 /* reparse */);
11516 }
11517 if (e.reason < 0)
11518 {
11519 exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
11520 bpt->number);
11521 return;
11522 }
11523 }
11524
11525 if (bpt->enable_state != bp_permanent)
11526 bpt->enable_state = bp_enabled;
11527 bpt->disposition = disposition;
11528 update_global_location_list (1);
11529 breakpoints_changed ();
11530
11531 observer_notify_breakpoint_modified (bpt->number);
11532 }
11533
11534
11535 void
enable_breakpoint(struct breakpoint * bpt)11536 enable_breakpoint (struct breakpoint *bpt)
11537 {
11538 do_enable_breakpoint (bpt, bpt->disposition);
11539 }
11540
11541 /* A callback for map_breakpoint_numbers that calls
11542 enable_breakpoint. */
11543
11544 static void
do_map_enable_breakpoint(struct breakpoint * b,void * ignore)11545 do_map_enable_breakpoint (struct breakpoint *b, void *ignore)
11546 {
11547 enable_breakpoint (b);
11548 }
11549
11550 /* The enable command enables the specified breakpoints (or all defined
11551 breakpoints) so they once again become (or continue to be) effective
11552 in stopping the inferior. */
11553
11554 static void
enable_command(char * args,int from_tty)11555 enable_command (char *args, int from_tty)
11556 {
11557 struct breakpoint *bpt;
11558
11559 if (args == 0)
11560 ALL_BREAKPOINTS (bpt)
11561 switch (bpt->type)
11562 {
11563 case bp_none:
11564 warning (_("attempted to enable apparently deleted breakpoint #%d?"),
11565 bpt->number);
11566 break;
11567 case bp_breakpoint:
11568 case bp_tracepoint:
11569 case bp_fast_tracepoint:
11570 case bp_static_tracepoint:
11571 case bp_catchpoint:
11572 case bp_hardware_breakpoint:
11573 case bp_watchpoint:
11574 case bp_hardware_watchpoint:
11575 case bp_read_watchpoint:
11576 case bp_access_watchpoint:
11577 enable_breakpoint (bpt);
11578 break;
11579 default:
11580 break;
11581 }
11582 else if (strchr (args, '.'))
11583 {
11584 struct bp_location *loc = find_location_by_number (args);
11585 if (loc)
11586 loc->enabled = 1;
11587 update_global_location_list (1);
11588 }
11589 else
11590 map_breakpoint_numbers (args, do_map_enable_breakpoint, NULL);
11591 }
11592
11593 static void
enable_once_breakpoint(struct breakpoint * bpt,void * ignore)11594 enable_once_breakpoint (struct breakpoint *bpt, void *ignore)
11595 {
11596 do_enable_breakpoint (bpt, disp_disable);
11597 }
11598
11599 static void
enable_once_command(char * args,int from_tty)11600 enable_once_command (char *args, int from_tty)
11601 {
11602 map_breakpoint_numbers (args, enable_once_breakpoint, NULL);
11603 }
11604
11605 static void
enable_delete_breakpoint(struct breakpoint * bpt,void * ignore)11606 enable_delete_breakpoint (struct breakpoint *bpt, void *ignore)
11607 {
11608 do_enable_breakpoint (bpt, disp_del);
11609 }
11610
11611 static void
enable_delete_command(char * args,int from_tty)11612 enable_delete_command (char *args, int from_tty)
11613 {
11614 map_breakpoint_numbers (args, enable_delete_breakpoint, NULL);
11615 }
11616
11617 static void
set_breakpoint_cmd(char * args,int from_tty)11618 set_breakpoint_cmd (char *args, int from_tty)
11619 {
11620 }
11621
11622 static void
show_breakpoint_cmd(char * args,int from_tty)11623 show_breakpoint_cmd (char *args, int from_tty)
11624 {
11625 }
11626
11627 /* Invalidate last known value of any hardware watchpoint if
11628 the memory which that value represents has been written to by
11629 GDB itself. */
11630
11631 static void
invalidate_bp_value_on_memory_change(CORE_ADDR addr,int len,const bfd_byte * data)11632 invalidate_bp_value_on_memory_change (CORE_ADDR addr, int len,
11633 const bfd_byte *data)
11634 {
11635 struct breakpoint *bp;
11636
11637 ALL_BREAKPOINTS (bp)
11638 if (bp->enable_state == bp_enabled
11639 && bp->type == bp_hardware_watchpoint
11640 && bp->val_valid && bp->val)
11641 {
11642 struct bp_location *loc;
11643
11644 for (loc = bp->loc; loc != NULL; loc = loc->next)
11645 if (loc->loc_type == bp_loc_hardware_watchpoint
11646 && loc->address + loc->length > addr
11647 && addr + len > loc->address)
11648 {
11649 value_free (bp->val);
11650 bp->val = NULL;
11651 bp->val_valid = 0;
11652 }
11653 }
11654 }
11655
11656 /* Use default_breakpoint_'s, or nothing if they aren't valid. */
11657
11658 struct symtabs_and_lines
decode_line_spec_1(char * string,int funfirstline)11659 decode_line_spec_1 (char *string, int funfirstline)
11660 {
11661 struct symtabs_and_lines sals;
11662
11663 if (string == 0)
11664 error (_("Empty line specification."));
11665 if (default_breakpoint_valid)
11666 sals = decode_line_1 (&string, funfirstline,
11667 default_breakpoint_symtab,
11668 default_breakpoint_line,
11669 NULL);
11670 else
11671 sals = decode_line_1 (&string, funfirstline,
11672 (struct symtab *) NULL, 0, NULL);
11673 if (*string)
11674 error (_("Junk at end of line specification: %s"), string);
11675 return sals;
11676 }
11677
11678 /* Create and insert a raw software breakpoint at PC. Return an
11679 identifier, which should be used to remove the breakpoint later.
11680 In general, places which call this should be using something on the
11681 breakpoint chain instead; this function should be eliminated
11682 someday. */
11683
11684 void *
deprecated_insert_raw_breakpoint(struct gdbarch * gdbarch,struct address_space * aspace,CORE_ADDR pc)11685 deprecated_insert_raw_breakpoint (struct gdbarch *gdbarch,
11686 struct address_space *aspace, CORE_ADDR pc)
11687 {
11688 struct bp_target_info *bp_tgt;
11689
11690 bp_tgt = XZALLOC (struct bp_target_info);
11691
11692 bp_tgt->placed_address_space = aspace;
11693 bp_tgt->placed_address = pc;
11694
11695 if (target_insert_breakpoint (gdbarch, bp_tgt) != 0)
11696 {
11697 /* Could not insert the breakpoint. */
11698 xfree (bp_tgt);
11699 return NULL;
11700 }
11701
11702 return bp_tgt;
11703 }
11704
11705 /* Remove a breakpoint BP inserted by
11706 deprecated_insert_raw_breakpoint. */
11707
11708 int
deprecated_remove_raw_breakpoint(struct gdbarch * gdbarch,void * bp)11709 deprecated_remove_raw_breakpoint (struct gdbarch *gdbarch, void *bp)
11710 {
11711 struct bp_target_info *bp_tgt = bp;
11712 int ret;
11713
11714 ret = target_remove_breakpoint (gdbarch, bp_tgt);
11715 xfree (bp_tgt);
11716
11717 return ret;
11718 }
11719
11720 /* One (or perhaps two) breakpoints used for software single
11721 stepping. */
11722
11723 static void *single_step_breakpoints[2];
11724 static struct gdbarch *single_step_gdbarch[2];
11725
11726 /* Create and insert a breakpoint for software single step. */
11727
11728 void
insert_single_step_breakpoint(struct gdbarch * gdbarch,struct address_space * aspace,CORE_ADDR next_pc)11729 insert_single_step_breakpoint (struct gdbarch *gdbarch,
11730 struct address_space *aspace,
11731 CORE_ADDR next_pc)
11732 {
11733 void **bpt_p;
11734
11735 if (single_step_breakpoints[0] == NULL)
11736 {
11737 bpt_p = &single_step_breakpoints[0];
11738 single_step_gdbarch[0] = gdbarch;
11739 }
11740 else
11741 {
11742 gdb_assert (single_step_breakpoints[1] == NULL);
11743 bpt_p = &single_step_breakpoints[1];
11744 single_step_gdbarch[1] = gdbarch;
11745 }
11746
11747 /* NOTE drow/2006-04-11: A future improvement to this function would
11748 be to only create the breakpoints once, and actually put them on
11749 the breakpoint chain. That would let us use set_raw_breakpoint.
11750 We could adjust the addresses each time they were needed. Doing
11751 this requires corresponding changes elsewhere where single step
11752 breakpoints are handled, however. So, for now, we use this. */
11753
11754 *bpt_p = deprecated_insert_raw_breakpoint (gdbarch, aspace, next_pc);
11755 if (*bpt_p == NULL)
11756 error (_("Could not insert single-step breakpoint at %s"),
11757 paddress (gdbarch, next_pc));
11758 }
11759
11760 /* Check if the breakpoints used for software single stepping
11761 were inserted or not. */
11762
11763 int
single_step_breakpoints_inserted(void)11764 single_step_breakpoints_inserted (void)
11765 {
11766 return (single_step_breakpoints[0] != NULL
11767 || single_step_breakpoints[1] != NULL);
11768 }
11769
11770 /* Remove and delete any breakpoints used for software single step. */
11771
11772 void
remove_single_step_breakpoints(void)11773 remove_single_step_breakpoints (void)
11774 {
11775 gdb_assert (single_step_breakpoints[0] != NULL);
11776
11777 /* See insert_single_step_breakpoint for more about this deprecated
11778 call. */
11779 deprecated_remove_raw_breakpoint (single_step_gdbarch[0],
11780 single_step_breakpoints[0]);
11781 single_step_gdbarch[0] = NULL;
11782 single_step_breakpoints[0] = NULL;
11783
11784 if (single_step_breakpoints[1] != NULL)
11785 {
11786 deprecated_remove_raw_breakpoint (single_step_gdbarch[1],
11787 single_step_breakpoints[1]);
11788 single_step_gdbarch[1] = NULL;
11789 single_step_breakpoints[1] = NULL;
11790 }
11791 }
11792
11793 /* Delete software single step breakpoints without removing them from
11794 the inferior. This is intended to be used if the inferior's address
11795 space where they were inserted is already gone, e.g. after exit or
11796 exec. */
11797
11798 void
cancel_single_step_breakpoints(void)11799 cancel_single_step_breakpoints (void)
11800 {
11801 int i;
11802
11803 for (i = 0; i < 2; i++)
11804 if (single_step_breakpoints[i])
11805 {
11806 xfree (single_step_breakpoints[i]);
11807 single_step_breakpoints[i] = NULL;
11808 single_step_gdbarch[i] = NULL;
11809 }
11810 }
11811
11812 /* Detach software single-step breakpoints from INFERIOR_PTID without
11813 removing them. */
11814
11815 static void
detach_single_step_breakpoints(void)11816 detach_single_step_breakpoints (void)
11817 {
11818 int i;
11819
11820 for (i = 0; i < 2; i++)
11821 if (single_step_breakpoints[i])
11822 target_remove_breakpoint (single_step_gdbarch[i],
11823 single_step_breakpoints[i]);
11824 }
11825
11826 /* Check whether a software single-step breakpoint is inserted at
11827 PC. */
11828
11829 static int
single_step_breakpoint_inserted_here_p(struct address_space * aspace,CORE_ADDR pc)11830 single_step_breakpoint_inserted_here_p (struct address_space *aspace,
11831 CORE_ADDR pc)
11832 {
11833 int i;
11834
11835 for (i = 0; i < 2; i++)
11836 {
11837 struct bp_target_info *bp_tgt = single_step_breakpoints[i];
11838 if (bp_tgt
11839 && breakpoint_address_match (bp_tgt->placed_address_space,
11840 bp_tgt->placed_address,
11841 aspace, pc))
11842 return 1;
11843 }
11844
11845 return 0;
11846 }
11847
11848 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
11849 non-zero otherwise. */
11850 static int
is_syscall_catchpoint_enabled(struct breakpoint * bp)11851 is_syscall_catchpoint_enabled (struct breakpoint *bp)
11852 {
11853 if (syscall_catchpoint_p (bp)
11854 && bp->enable_state != bp_disabled
11855 && bp->enable_state != bp_call_disabled)
11856 return 1;
11857 else
11858 return 0;
11859 }
11860
11861 int
catch_syscall_enabled(void)11862 catch_syscall_enabled (void)
11863 {
11864 struct inferior *inf = current_inferior ();
11865
11866 return inf->total_syscalls_count != 0;
11867 }
11868
11869 int
catching_syscall_number(int syscall_number)11870 catching_syscall_number (int syscall_number)
11871 {
11872 struct breakpoint *bp;
11873
11874 ALL_BREAKPOINTS (bp)
11875 if (is_syscall_catchpoint_enabled (bp))
11876 {
11877 if (bp->syscalls_to_be_caught)
11878 {
11879 int i, iter;
11880 for (i = 0;
11881 VEC_iterate (int, bp->syscalls_to_be_caught, i, iter);
11882 i++)
11883 if (syscall_number == iter)
11884 return 1;
11885 }
11886 else
11887 return 1;
11888 }
11889
11890 return 0;
11891 }
11892
11893 /* Complete syscall names. Used by "catch syscall". */
11894 static char **
catch_syscall_completer(struct cmd_list_element * cmd,char * text,char * word)11895 catch_syscall_completer (struct cmd_list_element *cmd,
11896 char *text, char *word)
11897 {
11898 const char **list = get_syscall_names ();
11899 char **retlist
11900 = (list == NULL) ? NULL : complete_on_enum (list, text, word);
11901
11902 xfree (list);
11903 return retlist;
11904 }
11905
11906 /* Tracepoint-specific operations. */
11907
11908 /* Set tracepoint count to NUM. */
11909 static void
set_tracepoint_count(int num)11910 set_tracepoint_count (int num)
11911 {
11912 tracepoint_count = num;
11913 set_internalvar_integer (lookup_internalvar ("tpnum"), num);
11914 }
11915
11916 void
trace_command(char * arg,int from_tty)11917 trace_command (char *arg, int from_tty)
11918 {
11919 if (create_breakpoint (get_current_arch (),
11920 arg,
11921 NULL, 0, 1 /* parse arg */,
11922 0 /* tempflag */,
11923 bp_tracepoint /* type_wanted */,
11924 0 /* Ignore count */,
11925 pending_break_support,
11926 NULL,
11927 from_tty,
11928 1 /* enabled */,
11929 0 /* internal */))
11930 set_tracepoint_count (breakpoint_count);
11931 }
11932
11933 void
ftrace_command(char * arg,int from_tty)11934 ftrace_command (char *arg, int from_tty)
11935 {
11936 if (create_breakpoint (get_current_arch (),
11937 arg,
11938 NULL, 0, 1 /* parse arg */,
11939 0 /* tempflag */,
11940 bp_fast_tracepoint /* type_wanted */,
11941 0 /* Ignore count */,
11942 pending_break_support,
11943 NULL,
11944 from_tty,
11945 1 /* enabled */,
11946 0 /* internal */))
11947 set_tracepoint_count (breakpoint_count);
11948 }
11949
11950 /* strace command implementation. Creates a static tracepoint. */
11951
11952 void
strace_command(char * arg,int from_tty)11953 strace_command (char *arg, int from_tty)
11954 {
11955 if (create_breakpoint (get_current_arch (),
11956 arg,
11957 NULL, 0, 1 /* parse arg */,
11958 0 /* tempflag */,
11959 bp_static_tracepoint /* type_wanted */,
11960 0 /* Ignore count */,
11961 pending_break_support,
11962 NULL,
11963 from_tty,
11964 1 /* enabled */,
11965 0 /* internal */))
11966 set_tracepoint_count (breakpoint_count);
11967 }
11968
11969 /* Set up a fake reader function that gets command lines from a linked
11970 list that was acquired during tracepoint uploading. */
11971
11972 static struct uploaded_tp *this_utp;
11973 static int next_cmd;
11974
11975 static char *
read_uploaded_action(void)11976 read_uploaded_action (void)
11977 {
11978 char *rslt;
11979
11980 VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
11981
11982 next_cmd++;
11983
11984 return rslt;
11985 }
11986
11987 /* Given information about a tracepoint as recorded on a target (which
11988 can be either a live system or a trace file), attempt to create an
11989 equivalent GDB tracepoint. This is not a reliable process, since
11990 the target does not necessarily have all the information used when
11991 the tracepoint was originally defined. */
11992
11993 struct breakpoint *
create_tracepoint_from_upload(struct uploaded_tp * utp)11994 create_tracepoint_from_upload (struct uploaded_tp *utp)
11995 {
11996 char *addr_str, small_buf[100];
11997 struct breakpoint *tp;
11998
11999 if (utp->at_string)
12000 addr_str = utp->at_string;
12001 else
12002 {
12003 /* In the absence of a source location, fall back to raw
12004 address. Since there is no way to confirm that the address
12005 means the same thing as when the trace was started, warn the
12006 user. */
12007 warning (_("Uploaded tracepoint %d has no "
12008 "source location, using raw address"),
12009 utp->number);
12010 sprintf (small_buf, "*%s", hex_string (utp->addr));
12011 addr_str = small_buf;
12012 }
12013
12014 /* There's not much we can do with a sequence of bytecodes. */
12015 if (utp->cond && !utp->cond_string)
12016 warning (_("Uploaded tracepoint %d condition "
12017 "has no source form, ignoring it"),
12018 utp->number);
12019
12020 if (!create_breakpoint (get_current_arch (),
12021 addr_str,
12022 utp->cond_string, -1, 0 /* parse cond/thread */,
12023 0 /* tempflag */,
12024 utp->type /* type_wanted */,
12025 0 /* Ignore count */,
12026 pending_break_support,
12027 NULL,
12028 0 /* from_tty */,
12029 utp->enabled /* enabled */,
12030 0 /* internal */))
12031 return NULL;
12032
12033 set_tracepoint_count (breakpoint_count);
12034
12035 /* Get the tracepoint we just created. */
12036 tp = get_tracepoint (tracepoint_count);
12037 gdb_assert (tp != NULL);
12038
12039 if (utp->pass > 0)
12040 {
12041 sprintf (small_buf, "%d %d", utp->pass, tp->number);
12042
12043 trace_pass_command (small_buf, 0);
12044 }
12045
12046 /* If we have uploaded versions of the original commands, set up a
12047 special-purpose "reader" function and call the usual command line
12048 reader, then pass the result to the breakpoint command-setting
12049 function. */
12050 if (!VEC_empty (char_ptr, utp->cmd_strings))
12051 {
12052 struct command_line *cmd_list;
12053
12054 this_utp = utp;
12055 next_cmd = 0;
12056
12057 cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
12058
12059 breakpoint_set_commands (tp, cmd_list);
12060 }
12061 else if (!VEC_empty (char_ptr, utp->actions)
12062 || !VEC_empty (char_ptr, utp->step_actions))
12063 warning (_("Uploaded tracepoint %d actions "
12064 "have no source form, ignoring them"),
12065 utp->number);
12066
12067 return tp;
12068 }
12069
12070 /* Print information on tracepoint number TPNUM_EXP, or all if
12071 omitted. */
12072
12073 static void
tracepoints_info(char * args,int from_tty)12074 tracepoints_info (char *args, int from_tty)
12075 {
12076 int num_printed;
12077
12078 num_printed = breakpoint_1 (args, 0, is_tracepoint);
12079
12080 if (num_printed == 0)
12081 {
12082 if (args == NULL || *args == '\0')
12083 ui_out_message (uiout, 0, "No tracepoints.\n");
12084 else
12085 ui_out_message (uiout, 0, "No tracepoint matching '%s'.\n", args);
12086 }
12087
12088 default_collect_info ();
12089 }
12090
12091 /* The 'enable trace' command enables tracepoints.
12092 Not supported by all targets. */
12093 static void
enable_trace_command(char * args,int from_tty)12094 enable_trace_command (char *args, int from_tty)
12095 {
12096 enable_command (args, from_tty);
12097 }
12098
12099 /* The 'disable trace' command disables tracepoints.
12100 Not supported by all targets. */
12101 static void
disable_trace_command(char * args,int from_tty)12102 disable_trace_command (char *args, int from_tty)
12103 {
12104 disable_command (args, from_tty);
12105 }
12106
12107 /* Remove a tracepoint (or all if no argument). */
12108 static void
delete_trace_command(char * arg,int from_tty)12109 delete_trace_command (char *arg, int from_tty)
12110 {
12111 struct breakpoint *b, *b_tmp;
12112
12113 dont_repeat ();
12114
12115 if (arg == 0)
12116 {
12117 int breaks_to_delete = 0;
12118
12119 /* Delete all breakpoints if no argument.
12120 Do not delete internal or call-dummy breakpoints, these
12121 have to be deleted with an explicit breakpoint number
12122 argument. */
12123 ALL_TRACEPOINTS (b)
12124 {
12125 if (b->number >= 0)
12126 {
12127 breaks_to_delete = 1;
12128 break;
12129 }
12130 }
12131
12132 /* Ask user only if there are some breakpoints to delete. */
12133 if (!from_tty
12134 || (breaks_to_delete && query (_("Delete all tracepoints? "))))
12135 {
12136 ALL_BREAKPOINTS_SAFE (b, b_tmp)
12137 {
12138 if (is_tracepoint (b)
12139 && b->number >= 0)
12140 delete_breakpoint (b);
12141 }
12142 }
12143 }
12144 else
12145 map_breakpoint_numbers (arg, do_delete_breakpoint, NULL);
12146 }
12147
12148 /* Helper function for trace_pass_command. */
12149
12150 static void
trace_pass_set_count(struct breakpoint * bp,int count,int from_tty)12151 trace_pass_set_count (struct breakpoint *bp, int count, int from_tty)
12152 {
12153 bp->pass_count = count;
12154 observer_notify_tracepoint_modified (bp->number);
12155 if (from_tty)
12156 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
12157 bp->number, count);
12158 }
12159
12160 /* Set passcount for tracepoint.
12161
12162 First command argument is passcount, second is tracepoint number.
12163 If tracepoint number omitted, apply to most recently defined.
12164 Also accepts special argument "all". */
12165
12166 static void
trace_pass_command(char * args,int from_tty)12167 trace_pass_command (char *args, int from_tty)
12168 {
12169 struct breakpoint *t1;
12170 unsigned int count;
12171
12172 if (args == 0 || *args == 0)
12173 error (_("passcount command requires an "
12174 "argument (count + optional TP num)"));
12175
12176 count = strtoul (args, &args, 10); /* Count comes first, then TP num. */
12177
12178 while (*args && isspace ((int) *args))
12179 args++;
12180
12181 if (*args && strncasecmp (args, "all", 3) == 0)
12182 {
12183 args += 3; /* Skip special argument "all". */
12184 if (*args)
12185 error (_("Junk at end of arguments."));
12186
12187 ALL_TRACEPOINTS (t1)
12188 {
12189 trace_pass_set_count (t1, count, from_tty);
12190 }
12191 }
12192 else if (*args == '\0')
12193 {
12194 t1 = get_tracepoint_by_number (&args, NULL, 1);
12195 if (t1)
12196 trace_pass_set_count (t1, count, from_tty);
12197 }
12198 else
12199 {
12200 struct get_number_or_range_state state;
12201
12202 init_number_or_range (&state, args);
12203 while (!state.finished)
12204 {
12205 t1 = get_tracepoint_by_number (&args, &state, 1);
12206 if (t1)
12207 trace_pass_set_count (t1, count, from_tty);
12208 }
12209 }
12210 }
12211
12212 struct breakpoint *
get_tracepoint(int num)12213 get_tracepoint (int num)
12214 {
12215 struct breakpoint *t;
12216
12217 ALL_TRACEPOINTS (t)
12218 if (t->number == num)
12219 return t;
12220
12221 return NULL;
12222 }
12223
12224 /* Find the tracepoint with the given target-side number (which may be
12225 different from the tracepoint number after disconnecting and
12226 reconnecting). */
12227
12228 struct breakpoint *
get_tracepoint_by_number_on_target(int num)12229 get_tracepoint_by_number_on_target (int num)
12230 {
12231 struct breakpoint *t;
12232
12233 ALL_TRACEPOINTS (t)
12234 if (t->number_on_target == num)
12235 return t;
12236
12237 return NULL;
12238 }
12239
12240 /* Utility: parse a tracepoint number and look it up in the list.
12241 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
12242 If OPTIONAL_P is true, then if the argument is missing, the most
12243 recent tracepoint (tracepoint_count) is returned. */
12244 struct breakpoint *
get_tracepoint_by_number(char ** arg,struct get_number_or_range_state * state,int optional_p)12245 get_tracepoint_by_number (char **arg,
12246 struct get_number_or_range_state *state,
12247 int optional_p)
12248 {
12249 extern int tracepoint_count;
12250 struct breakpoint *t;
12251 int tpnum;
12252 char *instring = arg == NULL ? NULL : *arg;
12253
12254 if (state)
12255 {
12256 gdb_assert (!state->finished);
12257 tpnum = get_number_or_range (state);
12258 }
12259 else if (arg == NULL || *arg == NULL || ! **arg)
12260 {
12261 if (optional_p)
12262 tpnum = tracepoint_count;
12263 else
12264 error_no_arg (_("tracepoint number"));
12265 }
12266 else
12267 tpnum = get_number (arg);
12268
12269 if (tpnum <= 0)
12270 {
12271 if (instring && *instring)
12272 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
12273 instring);
12274 else
12275 printf_filtered (_("Tracepoint argument missing "
12276 "and no previous tracepoint\n"));
12277 return NULL;
12278 }
12279
12280 ALL_TRACEPOINTS (t)
12281 if (t->number == tpnum)
12282 {
12283 return t;
12284 }
12285
12286 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
12287 return NULL;
12288 }
12289
12290 /* Save information on user settable breakpoints (watchpoints, etc) to
12291 a new script file named FILENAME. If FILTER is non-NULL, call it
12292 on each breakpoint and only include the ones for which it returns
12293 non-zero. */
12294
12295 static void
save_breakpoints(char * filename,int from_tty,int (* filter)(const struct breakpoint *))12296 save_breakpoints (char *filename, int from_tty,
12297 int (*filter) (const struct breakpoint *))
12298 {
12299 struct breakpoint *tp;
12300 int any = 0;
12301 char *pathname;
12302 struct cleanup *cleanup;
12303 struct ui_file *fp;
12304 int extra_trace_bits = 0;
12305
12306 if (filename == 0 || *filename == 0)
12307 error (_("Argument required (file name in which to save)"));
12308
12309 /* See if we have anything to save. */
12310 ALL_BREAKPOINTS (tp)
12311 {
12312 /* Skip internal and momentary breakpoints. */
12313 if (!user_breakpoint_p (tp))
12314 continue;
12315
12316 /* If we have a filter, only save the breakpoints it accepts. */
12317 if (filter && !filter (tp))
12318 continue;
12319
12320 any = 1;
12321
12322 if (is_tracepoint (tp))
12323 {
12324 extra_trace_bits = 1;
12325
12326 /* We can stop searching. */
12327 break;
12328 }
12329 }
12330
12331 if (!any)
12332 {
12333 warning (_("Nothing to save."));
12334 return;
12335 }
12336
12337 pathname = tilde_expand (filename);
12338 cleanup = make_cleanup (xfree, pathname);
12339 fp = gdb_fopen (pathname, "w");
12340 if (!fp)
12341 error (_("Unable to open file '%s' for saving (%s)"),
12342 filename, safe_strerror (errno));
12343 make_cleanup_ui_file_delete (fp);
12344
12345 if (extra_trace_bits)
12346 save_trace_state_variables (fp);
12347
12348 ALL_BREAKPOINTS (tp)
12349 {
12350 /* Skip internal and momentary breakpoints. */
12351 if (!user_breakpoint_p (tp))
12352 continue;
12353
12354 /* If we have a filter, only save the breakpoints it accepts. */
12355 if (filter && !filter (tp))
12356 continue;
12357
12358 if (tp->ops != NULL && tp->ops->print_recreate != NULL)
12359 (tp->ops->print_recreate) (tp, fp);
12360 else
12361 {
12362 if (tp->type == bp_fast_tracepoint)
12363 fprintf_unfiltered (fp, "ftrace");
12364 if (tp->type == bp_static_tracepoint)
12365 fprintf_unfiltered (fp, "strace");
12366 else if (tp->type == bp_tracepoint)
12367 fprintf_unfiltered (fp, "trace");
12368 else if (tp->type == bp_breakpoint && tp->disposition == disp_del)
12369 fprintf_unfiltered (fp, "tbreak");
12370 else if (tp->type == bp_breakpoint)
12371 fprintf_unfiltered (fp, "break");
12372 else if (tp->type == bp_hardware_breakpoint
12373 && tp->disposition == disp_del)
12374 fprintf_unfiltered (fp, "thbreak");
12375 else if (tp->type == bp_hardware_breakpoint)
12376 fprintf_unfiltered (fp, "hbreak");
12377 else if (tp->type == bp_watchpoint)
12378 fprintf_unfiltered (fp, "watch");
12379 else if (tp->type == bp_hardware_watchpoint)
12380 fprintf_unfiltered (fp, "watch");
12381 else if (tp->type == bp_read_watchpoint)
12382 fprintf_unfiltered (fp, "rwatch");
12383 else if (tp->type == bp_access_watchpoint)
12384 fprintf_unfiltered (fp, "awatch");
12385 else
12386 internal_error (__FILE__, __LINE__,
12387 _("unhandled breakpoint type %d"), (int) tp->type);
12388
12389 if (tp->exp_string)
12390 fprintf_unfiltered (fp, " %s", tp->exp_string);
12391 else if (tp->addr_string)
12392 fprintf_unfiltered (fp, " %s", tp->addr_string);
12393 else
12394 {
12395 char tmp[40];
12396
12397 sprintf_vma (tmp, tp->loc->address);
12398 fprintf_unfiltered (fp, " *0x%s", tmp);
12399 }
12400 }
12401
12402 if (tp->thread != -1)
12403 fprintf_unfiltered (fp, " thread %d", tp->thread);
12404
12405 if (tp->task != 0)
12406 fprintf_unfiltered (fp, " task %d", tp->task);
12407
12408 fprintf_unfiltered (fp, "\n");
12409
12410 /* Note, we can't rely on tp->number for anything, as we can't
12411 assume the recreated breakpoint numbers will match. Use $bpnum
12412 instead. */
12413
12414 if (tp->cond_string)
12415 fprintf_unfiltered (fp, " condition $bpnum %s\n", tp->cond_string);
12416
12417 if (tp->ignore_count)
12418 fprintf_unfiltered (fp, " ignore $bpnum %d\n", tp->ignore_count);
12419
12420 if (tp->pass_count)
12421 fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
12422
12423 if (tp->commands)
12424 {
12425 volatile struct gdb_exception ex;
12426
12427 fprintf_unfiltered (fp, " commands\n");
12428
12429 ui_out_redirect (uiout, fp);
12430 TRY_CATCH (ex, RETURN_MASK_ALL)
12431 {
12432 print_command_lines (uiout, tp->commands->commands, 2);
12433 }
12434 ui_out_redirect (uiout, NULL);
12435
12436 if (ex.reason < 0)
12437 throw_exception (ex);
12438
12439 fprintf_unfiltered (fp, " end\n");
12440 }
12441
12442 if (tp->enable_state == bp_disabled)
12443 fprintf_unfiltered (fp, "disable\n");
12444
12445 /* If this is a multi-location breakpoint, check if the locations
12446 should be individually disabled. Watchpoint locations are
12447 special, and not user visible. */
12448 if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
12449 {
12450 struct bp_location *loc;
12451 int n = 1;
12452
12453 for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
12454 if (!loc->enabled)
12455 fprintf_unfiltered (fp, "disable $bpnum.%d\n", n);
12456 }
12457 }
12458
12459 if (extra_trace_bits && *default_collect)
12460 fprintf_unfiltered (fp, "set default-collect %s\n", default_collect);
12461
12462 do_cleanups (cleanup);
12463 if (from_tty)
12464 printf_filtered (_("Saved to file '%s'.\n"), filename);
12465 }
12466
12467 /* The `save breakpoints' command. */
12468
12469 static void
save_breakpoints_command(char * args,int from_tty)12470 save_breakpoints_command (char *args, int from_tty)
12471 {
12472 save_breakpoints (args, from_tty, NULL);
12473 }
12474
12475 /* The `save tracepoints' command. */
12476
12477 static void
save_tracepoints_command(char * args,int from_tty)12478 save_tracepoints_command (char *args, int from_tty)
12479 {
12480 save_breakpoints (args, from_tty, is_tracepoint);
12481 }
12482
12483 /* Create a vector of all tracepoints. */
12484
VEC(breakpoint_p)12485 VEC(breakpoint_p) *
12486 all_tracepoints (void)
12487 {
12488 VEC(breakpoint_p) *tp_vec = 0;
12489 struct breakpoint *tp;
12490
12491 ALL_TRACEPOINTS (tp)
12492 {
12493 VEC_safe_push (breakpoint_p, tp_vec, tp);
12494 }
12495
12496 return tp_vec;
12497 }
12498
12499
12500 /* This help string is used for the break, hbreak, tbreak and thbreak
12501 commands. It is defined as a macro to prevent duplication.
12502 COMMAND should be a string constant containing the name of the
12503 command. */
12504 #define BREAK_ARGS_HELP(command) \
12505 command" [LOCATION] [thread THREADNUM] [if CONDITION]\n\
12506 LOCATION may be a line number, function name, or \"*\" and an address.\n\
12507 If a line number is specified, break at start of code for that line.\n\
12508 If a function is specified, break at start of code for that function.\n\
12509 If an address is specified, break at that exact address.\n\
12510 With no LOCATION, uses current execution address of the selected\n\
12511 stack frame. This is useful for breaking on return to a stack frame.\n\
12512 \n\
12513 THREADNUM is the number from \"info threads\".\n\
12514 CONDITION is a boolean expression.\n\
12515 \n\
12516 Multiple breakpoints at one place are permitted, and useful if their\n\
12517 conditions are different.\n\
12518 \n\
12519 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
12520
12521 /* List of subcommands for "catch". */
12522 static struct cmd_list_element *catch_cmdlist;
12523
12524 /* List of subcommands for "tcatch". */
12525 static struct cmd_list_element *tcatch_cmdlist;
12526
12527 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
12528 lists, and pass some additional user data to the command function. */
12529 static void
add_catch_command(char * name,char * docstring,void (* sfunc)(char * args,int from_tty,struct cmd_list_element * command),char ** (* completer)(struct cmd_list_element * cmd,char * text,char * word),void * user_data_catch,void * user_data_tcatch)12530 add_catch_command (char *name, char *docstring,
12531 void (*sfunc) (char *args, int from_tty,
12532 struct cmd_list_element *command),
12533 char **(*completer) (struct cmd_list_element *cmd,
12534 char *text, char *word),
12535 void *user_data_catch,
12536 void *user_data_tcatch)
12537 {
12538 struct cmd_list_element *command;
12539
12540 command = add_cmd (name, class_breakpoint, NULL, docstring,
12541 &catch_cmdlist);
12542 set_cmd_sfunc (command, sfunc);
12543 set_cmd_context (command, user_data_catch);
12544 set_cmd_completer (command, completer);
12545
12546 command = add_cmd (name, class_breakpoint, NULL, docstring,
12547 &tcatch_cmdlist);
12548 set_cmd_sfunc (command, sfunc);
12549 set_cmd_context (command, user_data_tcatch);
12550 set_cmd_completer (command, completer);
12551 }
12552
12553 static void
clear_syscall_counts(struct inferior * inf)12554 clear_syscall_counts (struct inferior *inf)
12555 {
12556 inf->total_syscalls_count = 0;
12557 inf->any_syscall_count = 0;
12558 VEC_free (int, inf->syscalls_counts);
12559 }
12560
12561 static void
save_command(char * arg,int from_tty)12562 save_command (char *arg, int from_tty)
12563 {
12564 printf_unfiltered (_("\"save\" must be followed by "
12565 "the name of a save subcommand.\n"));
12566 help_list (save_cmdlist, "save ", -1, gdb_stdout);
12567 }
12568
12569 struct breakpoint *
iterate_over_breakpoints(int (* callback)(struct breakpoint *,void *),void * data)12570 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
12571 void *data)
12572 {
12573 struct breakpoint *b, *b_tmp;
12574
12575 ALL_BREAKPOINTS_SAFE (b, b_tmp)
12576 {
12577 if ((*callback) (b, data))
12578 return b;
12579 }
12580
12581 return NULL;
12582 }
12583
12584 void
_initialize_breakpoint(void)12585 _initialize_breakpoint (void)
12586 {
12587 struct cmd_list_element *c;
12588
12589 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
12590 observer_attach_inferior_exit (clear_syscall_counts);
12591 observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
12592
12593 breakpoint_objfile_key = register_objfile_data ();
12594
12595 breakpoint_chain = 0;
12596 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
12597 before a breakpoint is set. */
12598 breakpoint_count = 0;
12599
12600 tracepoint_count = 0;
12601
12602 add_com ("ignore", class_breakpoint, ignore_command, _("\
12603 Set ignore-count of breakpoint number N to COUNT.\n\
12604 Usage is `ignore N COUNT'."));
12605 if (xdb_commands)
12606 add_com_alias ("bc", "ignore", class_breakpoint, 1);
12607
12608 add_com ("commands", class_breakpoint, commands_command, _("\
12609 Set commands to be executed when a breakpoint is hit.\n\
12610 Give breakpoint number as argument after \"commands\".\n\
12611 With no argument, the targeted breakpoint is the last one set.\n\
12612 The commands themselves follow starting on the next line.\n\
12613 Type a line containing \"end\" to indicate the end of them.\n\
12614 Give \"silent\" as the first line to make the breakpoint silent;\n\
12615 then no output is printed when it is hit, except what the commands print."));
12616
12617 add_com ("condition", class_breakpoint, condition_command, _("\
12618 Specify breakpoint number N to break only if COND is true.\n\
12619 Usage is `condition N COND', where N is an integer and COND is an\n\
12620 expression to be evaluated whenever breakpoint N is reached."));
12621
12622 c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
12623 Set a temporary breakpoint.\n\
12624 Like \"break\" except the breakpoint is only temporary,\n\
12625 so it will be deleted when hit. Equivalent to \"break\" followed\n\
12626 by using \"enable delete\" on the breakpoint number.\n\
12627 \n"
12628 BREAK_ARGS_HELP ("tbreak")));
12629 set_cmd_completer (c, location_completer);
12630
12631 c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
12632 Set a hardware assisted breakpoint.\n\
12633 Like \"break\" except the breakpoint requires hardware support,\n\
12634 some target hardware may not have this support.\n\
12635 \n"
12636 BREAK_ARGS_HELP ("hbreak")));
12637 set_cmd_completer (c, location_completer);
12638
12639 c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
12640 Set a temporary hardware assisted breakpoint.\n\
12641 Like \"hbreak\" except the breakpoint is only temporary,\n\
12642 so it will be deleted when hit.\n\
12643 \n"
12644 BREAK_ARGS_HELP ("thbreak")));
12645 set_cmd_completer (c, location_completer);
12646
12647 add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
12648 Enable some breakpoints.\n\
12649 Give breakpoint numbers (separated by spaces) as arguments.\n\
12650 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12651 This is used to cancel the effect of the \"disable\" command.\n\
12652 With a subcommand you can enable temporarily."),
12653 &enablelist, "enable ", 1, &cmdlist);
12654 if (xdb_commands)
12655 add_com ("ab", class_breakpoint, enable_command, _("\
12656 Enable some breakpoints.\n\
12657 Give breakpoint numbers (separated by spaces) as arguments.\n\
12658 With no subcommand, breakpoints are enabled until you command otherwise.\n\
12659 This is used to cancel the effect of the \"disable\" command.\n\
12660 With a subcommand you can enable temporarily."));
12661
12662 add_com_alias ("en", "enable", class_breakpoint, 1);
12663
12664 add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
12665 Enable some breakpoints.\n\
12666 Give breakpoint numbers (separated by spaces) as arguments.\n\
12667 This is used to cancel the effect of the \"disable\" command.\n\
12668 May be abbreviated to simply \"enable\".\n"),
12669 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
12670
12671 add_cmd ("once", no_class, enable_once_command, _("\
12672 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12673 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12674 &enablebreaklist);
12675
12676 add_cmd ("delete", no_class, enable_delete_command, _("\
12677 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12678 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12679 &enablebreaklist);
12680
12681 add_cmd ("delete", no_class, enable_delete_command, _("\
12682 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
12683 If a breakpoint is hit while enabled in this fashion, it is deleted."),
12684 &enablelist);
12685
12686 add_cmd ("once", no_class, enable_once_command, _("\
12687 Enable breakpoints for one hit. Give breakpoint numbers.\n\
12688 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
12689 &enablelist);
12690
12691 add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
12692 Disable some breakpoints.\n\
12693 Arguments are breakpoint numbers with spaces in between.\n\
12694 To disable all breakpoints, give no argument.\n\
12695 A disabled breakpoint is not forgotten, but has no effect until reenabled."),
12696 &disablelist, "disable ", 1, &cmdlist);
12697 add_com_alias ("dis", "disable", class_breakpoint, 1);
12698 add_com_alias ("disa", "disable", class_breakpoint, 1);
12699 if (xdb_commands)
12700 add_com ("sb", class_breakpoint, disable_command, _("\
12701 Disable some breakpoints.\n\
12702 Arguments are breakpoint numbers with spaces in between.\n\
12703 To disable all breakpoints, give no argument.\n\
12704 A disabled breakpoint is not forgotten, but has no effect until reenabled."));
12705
12706 add_cmd ("breakpoints", class_alias, disable_command, _("\
12707 Disable some breakpoints.\n\
12708 Arguments are breakpoint numbers with spaces in between.\n\
12709 To disable all breakpoints, give no argument.\n\
12710 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
12711 This command may be abbreviated \"disable\"."),
12712 &disablelist);
12713
12714 add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
12715 Delete some breakpoints or auto-display expressions.\n\
12716 Arguments are breakpoint numbers with spaces in between.\n\
12717 To delete all breakpoints, give no argument.\n\
12718 \n\
12719 Also a prefix command for deletion of other GDB objects.\n\
12720 The \"unset\" command is also an alias for \"delete\"."),
12721 &deletelist, "delete ", 1, &cmdlist);
12722 add_com_alias ("d", "delete", class_breakpoint, 1);
12723 add_com_alias ("del", "delete", class_breakpoint, 1);
12724 if (xdb_commands)
12725 add_com ("db", class_breakpoint, delete_command, _("\
12726 Delete some breakpoints.\n\
12727 Arguments are breakpoint numbers with spaces in between.\n\
12728 To delete all breakpoints, give no argument.\n"));
12729
12730 add_cmd ("breakpoints", class_alias, delete_command, _("\
12731 Delete some breakpoints or auto-display expressions.\n\
12732 Arguments are breakpoint numbers with spaces in between.\n\
12733 To delete all breakpoints, give no argument.\n\
12734 This command may be abbreviated \"delete\"."),
12735 &deletelist);
12736
12737 add_com ("clear", class_breakpoint, clear_command, _("\
12738 Clear breakpoint at specified line or function.\n\
12739 Argument may be line number, function name, or \"*\" and an address.\n\
12740 If line number is specified, all breakpoints in that line are cleared.\n\
12741 If function is specified, breakpoints at beginning of function are cleared.\n\
12742 If an address is specified, breakpoints at that address are cleared.\n\
12743 \n\
12744 With no argument, clears all breakpoints in the line that the selected frame\n\
12745 is executing in.\n\
12746 \n\
12747 See also the \"delete\" command which clears breakpoints by number."));
12748 add_com_alias ("cl", "clear", class_breakpoint, 1);
12749
12750 c = add_com ("break", class_breakpoint, break_command, _("\
12751 Set breakpoint at specified line or function.\n"
12752 BREAK_ARGS_HELP ("break")));
12753 set_cmd_completer (c, location_completer);
12754
12755 add_com_alias ("b", "break", class_run, 1);
12756 add_com_alias ("br", "break", class_run, 1);
12757 add_com_alias ("bre", "break", class_run, 1);
12758 add_com_alias ("brea", "break", class_run, 1);
12759
12760 if (xdb_commands)
12761 add_com_alias ("ba", "break", class_breakpoint, 1);
12762
12763 if (dbx_commands)
12764 {
12765 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
12766 Break in function/address or break at a line in the current file."),
12767 &stoplist, "stop ", 1, &cmdlist);
12768 add_cmd ("in", class_breakpoint, stopin_command,
12769 _("Break in function or address."), &stoplist);
12770 add_cmd ("at", class_breakpoint, stopat_command,
12771 _("Break at a line in the current file."), &stoplist);
12772 add_com ("status", class_info, breakpoints_info, _("\
12773 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12774 The \"Type\" column indicates one of:\n\
12775 \tbreakpoint - normal breakpoint\n\
12776 \twatchpoint - watchpoint\n\
12777 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12778 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12779 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12780 address and file/line number respectively.\n\
12781 \n\
12782 Convenience variable \"$_\" and default examine address for \"x\"\n\
12783 are set to the address of the last breakpoint listed unless the command\n\
12784 is prefixed with \"server \".\n\n\
12785 Convenience variable \"$bpnum\" contains the number of the last\n\
12786 breakpoint set."));
12787 }
12788
12789 add_info ("breakpoints", breakpoints_info, _("\
12790 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
12791 The \"Type\" column indicates one of:\n\
12792 \tbreakpoint - normal breakpoint\n\
12793 \twatchpoint - watchpoint\n\
12794 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12795 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12796 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12797 address and file/line number respectively.\n\
12798 \n\
12799 Convenience variable \"$_\" and default examine address for \"x\"\n\
12800 are set to the address of the last breakpoint listed unless the command\n\
12801 is prefixed with \"server \".\n\n\
12802 Convenience variable \"$bpnum\" contains the number of the last\n\
12803 breakpoint set."));
12804
12805 add_info_alias ("b", "breakpoints", 1);
12806
12807 if (xdb_commands)
12808 add_com ("lb", class_breakpoint, breakpoints_info, _("\
12809 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
12810 The \"Type\" column indicates one of:\n\
12811 \tbreakpoint - normal breakpoint\n\
12812 \twatchpoint - watchpoint\n\
12813 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12814 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12815 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12816 address and file/line number respectively.\n\
12817 \n\
12818 Convenience variable \"$_\" and default examine address for \"x\"\n\
12819 are set to the address of the last breakpoint listed unless the command\n\
12820 is prefixed with \"server \".\n\n\
12821 Convenience variable \"$bpnum\" contains the number of the last\n\
12822 breakpoint set."));
12823
12824 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
12825 Status of all breakpoints, or breakpoint number NUMBER.\n\
12826 The \"Type\" column indicates one of:\n\
12827 \tbreakpoint - normal breakpoint\n\
12828 \twatchpoint - watchpoint\n\
12829 \tlongjmp - internal breakpoint used to step through longjmp()\n\
12830 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
12831 \tuntil - internal breakpoint used by the \"until\" command\n\
12832 \tfinish - internal breakpoint used by the \"finish\" command\n\
12833 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
12834 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
12835 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
12836 address and file/line number respectively.\n\
12837 \n\
12838 Convenience variable \"$_\" and default examine address for \"x\"\n\
12839 are set to the address of the last breakpoint listed unless the command\n\
12840 is prefixed with \"server \".\n\n\
12841 Convenience variable \"$bpnum\" contains the number of the last\n\
12842 breakpoint set."),
12843 &maintenanceinfolist);
12844
12845 add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
12846 Set catchpoints to catch events."),
12847 &catch_cmdlist, "catch ",
12848 0/*allow-unknown*/, &cmdlist);
12849
12850 add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
12851 Set temporary catchpoints to catch events."),
12852 &tcatch_cmdlist, "tcatch ",
12853 0/*allow-unknown*/, &cmdlist);
12854
12855 /* Add catch and tcatch sub-commands. */
12856 add_catch_command ("catch", _("\
12857 Catch an exception, when caught.\n\
12858 With an argument, catch only exceptions with the given name."),
12859 catch_catch_command,
12860 NULL,
12861 CATCH_PERMANENT,
12862 CATCH_TEMPORARY);
12863 add_catch_command ("throw", _("\
12864 Catch an exception, when thrown.\n\
12865 With an argument, catch only exceptions with the given name."),
12866 catch_throw_command,
12867 NULL,
12868 CATCH_PERMANENT,
12869 CATCH_TEMPORARY);
12870 add_catch_command ("fork", _("Catch calls to fork."),
12871 catch_fork_command_1,
12872 NULL,
12873 (void *) (uintptr_t) catch_fork_permanent,
12874 (void *) (uintptr_t) catch_fork_temporary);
12875 add_catch_command ("vfork", _("Catch calls to vfork."),
12876 catch_fork_command_1,
12877 NULL,
12878 (void *) (uintptr_t) catch_vfork_permanent,
12879 (void *) (uintptr_t) catch_vfork_temporary);
12880 add_catch_command ("exec", _("Catch calls to exec."),
12881 catch_exec_command_1,
12882 NULL,
12883 CATCH_PERMANENT,
12884 CATCH_TEMPORARY);
12885 add_catch_command ("syscall", _("\
12886 Catch system calls by their names and/or numbers.\n\
12887 Arguments say which system calls to catch. If no arguments\n\
12888 are given, every system call will be caught.\n\
12889 Arguments, if given, should be one or more system call names\n\
12890 (if your system supports that), or system call numbers."),
12891 catch_syscall_command_1,
12892 catch_syscall_completer,
12893 CATCH_PERMANENT,
12894 CATCH_TEMPORARY);
12895 add_catch_command ("exception", _("\
12896 Catch Ada exceptions, when raised.\n\
12897 With an argument, catch only exceptions with the given name."),
12898 catch_ada_exception_command,
12899 NULL,
12900 CATCH_PERMANENT,
12901 CATCH_TEMPORARY);
12902 add_catch_command ("assert", _("\
12903 Catch failed Ada assertions, when raised.\n\
12904 With an argument, catch only exceptions with the given name."),
12905 catch_assert_command,
12906 NULL,
12907 CATCH_PERMANENT,
12908 CATCH_TEMPORARY);
12909
12910 c = add_com ("watch", class_breakpoint, watch_command, _("\
12911 Set a watchpoint for an expression.\n\
12912 Usage: watch [-l|-location] EXPRESSION\n\
12913 A watchpoint stops execution of your program whenever the value of\n\
12914 an expression changes.\n\
12915 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12916 the memory to which it refers."));
12917 set_cmd_completer (c, expression_completer);
12918
12919 c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
12920 Set a read watchpoint for an expression.\n\
12921 Usage: rwatch [-l|-location] EXPRESSION\n\
12922 A watchpoint stops execution of your program whenever the value of\n\
12923 an expression is read.\n\
12924 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12925 the memory to which it refers."));
12926 set_cmd_completer (c, expression_completer);
12927
12928 c = add_com ("awatch", class_breakpoint, awatch_command, _("\
12929 Set a watchpoint for an expression.\n\
12930 Usage: awatch [-l|-location] EXPRESSION\n\
12931 A watchpoint stops execution of your program whenever the value of\n\
12932 an expression is either read or written.\n\
12933 If -l or -location is given, this evaluates EXPRESSION and watches\n\
12934 the memory to which it refers."));
12935 set_cmd_completer (c, expression_completer);
12936
12937 add_info ("watchpoints", watchpoints_info, _("\
12938 Status of specified watchpoints (all watchpoints if no argument)."));
12939
12940 /* XXX: cagney/2005-02-23: This should be a boolean, and should
12941 respond to changes - contrary to the description. */
12942 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
12943 &can_use_hw_watchpoints, _("\
12944 Set debugger's willingness to use watchpoint hardware."), _("\
12945 Show debugger's willingness to use watchpoint hardware."), _("\
12946 If zero, gdb will not use hardware for new watchpoints, even if\n\
12947 such is available. (However, any hardware watchpoints that were\n\
12948 created before setting this to nonzero, will continue to use watchpoint\n\
12949 hardware.)"),
12950 NULL,
12951 show_can_use_hw_watchpoints,
12952 &setlist, &showlist);
12953
12954 can_use_hw_watchpoints = 1;
12955
12956 /* Tracepoint manipulation commands. */
12957
12958 c = add_com ("trace", class_breakpoint, trace_command, _("\
12959 Set a tracepoint at specified line or function.\n\
12960 \n"
12961 BREAK_ARGS_HELP ("trace") "\n\
12962 Do \"help tracepoints\" for info on other tracepoint commands."));
12963 set_cmd_completer (c, location_completer);
12964
12965 add_com_alias ("tp", "trace", class_alias, 0);
12966 add_com_alias ("tr", "trace", class_alias, 1);
12967 add_com_alias ("tra", "trace", class_alias, 1);
12968 add_com_alias ("trac", "trace", class_alias, 1);
12969
12970 c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
12971 Set a fast tracepoint at specified line or function.\n\
12972 \n"
12973 BREAK_ARGS_HELP ("ftrace") "\n\
12974 Do \"help tracepoints\" for info on other tracepoint commands."));
12975 set_cmd_completer (c, location_completer);
12976
12977 c = add_com ("strace", class_breakpoint, strace_command, _("\
12978 Set a static tracepoint at specified line, function or marker.\n\
12979 \n\
12980 strace [LOCATION] [if CONDITION]\n\
12981 LOCATION may be a line number, function name, \"*\" and an address,\n\
12982 or -m MARKER_ID.\n\
12983 If a line number is specified, probe the marker at start of code\n\
12984 for that line. If a function is specified, probe the marker at start\n\
12985 of code for that function. If an address is specified, probe the marker\n\
12986 at that exact address. If a marker id is specified, probe the marker\n\
12987 with that name. With no LOCATION, uses current execution address of\n\
12988 the selected stack frame.\n\
12989 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
12990 This collects arbitrary user data passed in the probe point call to the\n\
12991 tracing library. You can inspect it when analyzing the trace buffer,\n\
12992 by printing the $_sdata variable like any other convenience variable.\n\
12993 \n\
12994 CONDITION is a boolean expression.\n\
12995 \n\
12996 Multiple tracepoints at one place are permitted, and useful if their\n\
12997 conditions are different.\n\
12998 \n\
12999 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
13000 Do \"help tracepoints\" for info on other tracepoint commands."));
13001 set_cmd_completer (c, location_completer);
13002
13003 add_info ("tracepoints", tracepoints_info, _("\
13004 Status of specified tracepoints (all tracepoints if no argument).\n\
13005 Convenience variable \"$tpnum\" contains the number of the\n\
13006 last tracepoint set."));
13007
13008 add_info_alias ("tp", "tracepoints", 1);
13009
13010 add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
13011 Delete specified tracepoints.\n\
13012 Arguments are tracepoint numbers, separated by spaces.\n\
13013 No argument means delete all tracepoints."),
13014 &deletelist);
13015
13016 c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
13017 Disable specified tracepoints.\n\
13018 Arguments are tracepoint numbers, separated by spaces.\n\
13019 No argument means disable all tracepoints."),
13020 &disablelist);
13021 deprecate_cmd (c, "disable");
13022
13023 c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
13024 Enable specified tracepoints.\n\
13025 Arguments are tracepoint numbers, separated by spaces.\n\
13026 No argument means enable all tracepoints."),
13027 &enablelist);
13028 deprecate_cmd (c, "enable");
13029
13030 add_com ("passcount", class_trace, trace_pass_command, _("\
13031 Set the passcount for a tracepoint.\n\
13032 The trace will end when the tracepoint has been passed 'count' times.\n\
13033 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
13034 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
13035
13036 add_prefix_cmd ("save", class_breakpoint, save_command,
13037 _("Save breakpoint definitions as a script."),
13038 &save_cmdlist, "save ",
13039 0/*allow-unknown*/, &cmdlist);
13040
13041 c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
13042 Save current breakpoint definitions as a script.\n\
13043 This includes all types of breakpoints (breakpoints, watchpoints,\n\
13044 catchpoints, tracepoints). Use the 'source' command in another debug\n\
13045 session to restore them."),
13046 &save_cmdlist);
13047 set_cmd_completer (c, filename_completer);
13048
13049 c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
13050 Save current tracepoint definitions as a script.\n\
13051 Use the 'source' command in another debug session to restore them."),
13052 &save_cmdlist);
13053 set_cmd_completer (c, filename_completer);
13054
13055 c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
13056 deprecate_cmd (c, "save tracepoints");
13057
13058 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
13059 Breakpoint specific settings\n\
13060 Configure various breakpoint-specific variables such as\n\
13061 pending breakpoint behavior"),
13062 &breakpoint_set_cmdlist, "set breakpoint ",
13063 0/*allow-unknown*/, &setlist);
13064 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
13065 Breakpoint specific settings\n\
13066 Configure various breakpoint-specific variables such as\n\
13067 pending breakpoint behavior"),
13068 &breakpoint_show_cmdlist, "show breakpoint ",
13069 0/*allow-unknown*/, &showlist);
13070
13071 add_setshow_auto_boolean_cmd ("pending", no_class,
13072 &pending_break_support, _("\
13073 Set debugger's behavior regarding pending breakpoints."), _("\
13074 Show debugger's behavior regarding pending breakpoints."), _("\
13075 If on, an unrecognized breakpoint location will cause gdb to create a\n\
13076 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
13077 an error. If auto, an unrecognized breakpoint location results in a\n\
13078 user-query to see if a pending breakpoint should be created."),
13079 NULL,
13080 show_pending_break_support,
13081 &breakpoint_set_cmdlist,
13082 &breakpoint_show_cmdlist);
13083
13084 pending_break_support = AUTO_BOOLEAN_AUTO;
13085
13086 add_setshow_boolean_cmd ("auto-hw", no_class,
13087 &automatic_hardware_breakpoints, _("\
13088 Set automatic usage of hardware breakpoints."), _("\
13089 Show automatic usage of hardware breakpoints."), _("\
13090 If set, the debugger will automatically use hardware breakpoints for\n\
13091 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
13092 a warning will be emitted for such breakpoints."),
13093 NULL,
13094 show_automatic_hardware_breakpoints,
13095 &breakpoint_set_cmdlist,
13096 &breakpoint_show_cmdlist);
13097
13098 add_setshow_enum_cmd ("always-inserted", class_support,
13099 always_inserted_enums, &always_inserted_mode, _("\
13100 Set mode for inserting breakpoints."), _("\
13101 Show mode for inserting breakpoints."), _("\
13102 When this mode is off, breakpoints are inserted in inferior when it is\n\
13103 resumed, and removed when execution stops. When this mode is on,\n\
13104 breakpoints are inserted immediately and removed only when the user\n\
13105 deletes the breakpoint. When this mode is auto (which is the default),\n\
13106 the behaviour depends on the non-stop setting (see help set non-stop).\n\
13107 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
13108 behaves as if always-inserted mode is on; if gdb is controlling the\n\
13109 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
13110 NULL,
13111 &show_always_inserted_mode,
13112 &breakpoint_set_cmdlist,
13113 &breakpoint_show_cmdlist);
13114
13115 add_com ("break-range", class_breakpoint, break_range_command, _("\
13116 Set a breakpoint for an address range.\n\
13117 break-range START-LOCATION, END-LOCATION\n\
13118 where START-LOCATION and END-LOCATION can be one of the following:\n\
13119 LINENUM, for that line in the current file,\n\
13120 FILE:LINENUM, for that line in that file,\n\
13121 +OFFSET, for that number of lines after the current line\n\
13122 or the start of the range\n\
13123 FUNCTION, for the first line in that function,\n\
13124 FILE:FUNCTION, to distinguish among like-named static functions.\n\
13125 *ADDRESS, for the instruction at that address.\n\
13126 \n\
13127 The breakpoint will stop execution of the inferior whenever it executes\n\
13128 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
13129 range (including START-LOCATION and END-LOCATION)."));
13130
13131 automatic_hardware_breakpoints = 1;
13132
13133 observer_attach_about_to_proceed (breakpoint_about_to_proceed);
13134 }
13135