GDB (xrefs)

/tmp/gdb-8.1/gdb/breakpoint.c
Go to the documentation of this file.
1 /* Everything about breakpoints, for GDB.
2
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include <ctype.h>
23 #include "hashtab.h"
24 #include "symtab.h"
25 #include "frame.h"
26 #include "breakpoint.h"
27 #include "tracepoint.h"
28 #include "gdbtypes.h"
29 #include "expression.h"
30 #include "gdbcore.h"
31 #include "gdbcmd.h"
32 #include "value.h"
33 #include "command.h"
34 #include "inferior.h"
35 #include "infrun.h"
36 #include "gdbthread.h"
37 #include "target.h"
38 #include "language.h"
39 #include "gdb-demangle.h"
40 #include "filenames.h"
41 #include "annotate.h"
42 #include "symfile.h"
43 #include "objfiles.h"
44 #include "source.h"
45 #include "linespec.h"
46 #include "completer.h"
47 #include "ui-out.h"
48 #include "cli/cli-script.h"
49 #include "block.h"
50 #include "solib.h"
51 #include "solist.h"
52 #include "observer.h"
53 #include "memattr.h"
54 #include "ada-lang.h"
55 #include "top.h"
56 #include "valprint.h"
57 #include "jit.h"
58 #include "parser-defs.h"
59 #include "gdb_regex.h"
60 #include "probe.h"
61 #include "cli/cli-utils.h"
62 #include "continuations.h"
63 #include "stack.h"
64 #include "skip.h"
65 #include "ax-gdb.h"
66 #include "dummy-frame.h"
67 #include "interps.h"
68 #include "format.h"
69 #include "thread-fsm.h"
70 #include "tid-parse.h"
71
72 /* readline include files */
73 #include "readline/readline.h"
74 #include "readline/history.h"
75
76 /* readline defines this. */
77 #undef savestring
78
79 #include "mi/mi-common.h"
80 #include "extension.h"
81 #include <algorithm>
82 #include "progspace-and-thread.h"
83 #include "common/array-view.h"
84 #include "common/gdb_optional.h"
85
86 /* Enums for exception-handling support. */
87 enum exception_event_kind
88 {
89 EX_EVENT_THROW,
90 EX_EVENT_RETHROW,
91 EX_EVENT_CATCH
92 };
93
94 /* Prototypes for local functions. */
95
96 static void map_breakpoint_numbers (const char *,
97 gdb::function_view<void (breakpoint *)>);
98
99 static void breakpoint_re_set_default (struct breakpoint *);
100
101 static void
102 create_sals_from_location_default (const struct event_location *location,
103 struct linespec_result *canonical,
104 enum bptype type_wanted);
105
106 static void create_breakpoints_sal_default (struct gdbarch *,
107 struct linespec_result *,
108 gdb::unique_xmalloc_ptr<char>,
109 gdb::unique_xmalloc_ptr<char>,
110 enum bptype,
111 enum bpdisp, int, int,
112 int,
113 const struct breakpoint_ops *,
114 int, int, int, unsigned);
115
116 static std::vector<symtab_and_line> decode_location_default
117 (struct breakpoint *b, const struct event_location *location,
118 struct program_space *search_pspace);
119
120 static int can_use_hardware_watchpoint (struct value *);
121
122 static void mention (struct breakpoint *);
123
124 static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
125 enum bptype,
126 const struct breakpoint_ops *);
127 static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
128 const struct symtab_and_line *);
129
130 /* This function is used in gdbtk sources and thus can not be made
131 static. */
132 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
133 struct symtab_and_line,
134 enum bptype,
135 const struct breakpoint_ops *);
136
137 static struct breakpoint *
138 momentary_breakpoint_from_master (struct breakpoint *orig,
139 enum bptype type,
140 const struct breakpoint_ops *ops,
141 int loc_enabled);
142
143 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
144
145 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
146 CORE_ADDR bpaddr,
147 enum bptype bptype);
148
149 static void describe_other_breakpoints (struct gdbarch *,
150 struct program_space *, CORE_ADDR,
151 struct obj_section *, int);
152
153 static int watchpoint_locations_match (struct bp_location *loc1,
154 struct bp_location *loc2);
155
156 static int breakpoint_location_address_match (struct bp_location *bl,
157 const struct address_space *aspace,
158 CORE_ADDR addr);
159
160 static int breakpoint_location_address_range_overlap (struct bp_location *,
161 const address_space *,
162 CORE_ADDR, int);
163
164 static int remove_breakpoint (struct bp_location *);
165 static int remove_breakpoint_1 (struct bp_location *, enum remove_bp_reason);
166
167 static enum print_stop_action print_bp_stop_message (bpstat bs);
168
169 static int hw_breakpoint_used_count (void);
170
171 static int hw_watchpoint_use_count (struct breakpoint *);
172
173 static int hw_watchpoint_used_count_others (struct breakpoint *except,
174 enum bptype type,
175 int *other_type_used);
176
177 static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
178 int count);
179
180 static void free_bp_location (struct bp_location *loc);
181 static void incref_bp_location (struct bp_location *loc);
182 static void decref_bp_location (struct bp_location **loc);
183
184 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
185
186 /* update_global_location_list's modes of operation wrt to whether to
187 insert locations now. */
188 enum ugll_insert_mode
189 {
190 /* Don't insert any breakpoint locations into the inferior, only
191 remove already-inserted locations that no longer should be
192 inserted. Functions that delete a breakpoint or breakpoints
193 should specify this mode, so that deleting a breakpoint doesn't
194 have the side effect of inserting the locations of other
195 breakpoints that are marked not-inserted, but should_be_inserted
196 returns true on them.
197
198 This behavior is useful is situations close to tear-down -- e.g.,
199 after an exec, while the target still has execution, but
200 breakpoint shadows of the previous executable image should *NOT*
201 be restored to the new image; or before detaching, where the
202 target still has execution and wants to delete breakpoints from
203 GDB's lists, and all breakpoints had already been removed from
204 the inferior. */
205 UGLL_DONT_INSERT,
206
207 /* May insert breakpoints iff breakpoints_should_be_inserted_now
208 claims breakpoints should be inserted now. */
209 UGLL_MAY_INSERT,
210
211 /* Insert locations now, irrespective of
212 breakpoints_should_be_inserted_now. E.g., say all threads are
213 stopped right now, and the user did "continue". We need to
214 insert breakpoints _before_ resuming the target, but
215 UGLL_MAY_INSERT wouldn't insert them, because
216 breakpoints_should_be_inserted_now returns false at that point,
217 as no thread is running yet. */
218 UGLL_INSERT
219 };
220
221 static void update_global_location_list (enum ugll_insert_mode);
222
223 static void update_global_location_list_nothrow (enum ugll_insert_mode);
224
225 static int is_hardware_watchpoint (const struct breakpoint *bpt);
226
227 static void insert_breakpoint_locations (void);
228
229 static void trace_pass_command (const char *, int);
230
231 static void set_tracepoint_count (int num);
232
233 static int is_masked_watchpoint (const struct breakpoint *b);
234
235 static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
236
237 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
238 otherwise. */
239
240 static int strace_marker_p (struct breakpoint *b);
241
242 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
243 that are implemented on top of software or hardware breakpoints
244 (user breakpoints, internal and momentary breakpoints, etc.). */
245 static struct breakpoint_ops bkpt_base_breakpoint_ops;
246
247 /* Internal breakpoints class type. */
248 static struct breakpoint_ops internal_breakpoint_ops;
249
250 /* Momentary breakpoints class type. */
251 static struct breakpoint_ops momentary_breakpoint_ops;
252
253 /* The breakpoint_ops structure to be used in regular user created
254 breakpoints. */
255 struct breakpoint_ops bkpt_breakpoint_ops;
256
257 /* Breakpoints set on probes. */
258 static struct breakpoint_ops bkpt_probe_breakpoint_ops;
259
260 /* Dynamic printf class type. */
261 struct breakpoint_ops dprintf_breakpoint_ops;
262
263 /* The style in which to perform a dynamic printf. This is a user
264 option because different output options have different tradeoffs;
265 if GDB does the printing, there is better error handling if there
266 is a problem with any of the arguments, but using an inferior
267 function lets you have special-purpose printers and sending of
268 output to the same place as compiled-in print functions. */
269
270 static const char dprintf_style_gdb[] = "gdb";
271 static const char dprintf_style_call[] = "call";
272 static const char dprintf_style_agent[] = "agent";
273 static const char *const dprintf_style_enums[] = {
274 dprintf_style_gdb,
275 dprintf_style_call,
276 dprintf_style_agent,
277 NULL
278 };
279 static const char *dprintf_style = dprintf_style_gdb;
280
281 /* The function to use for dynamic printf if the preferred style is to
282 call into the inferior. The value is simply a string that is
283 copied into the command, so it can be anything that GDB can
284 evaluate to a callable address, not necessarily a function name. */
285
286 static char *dprintf_function;
287
288 /* The channel to use for dynamic printf if the preferred style is to
289 call into the inferior; if a nonempty string, it will be passed to
290 the call as the first argument, with the format string as the
291 second. As with the dprintf function, this can be anything that
292 GDB knows how to evaluate, so in addition to common choices like
293 "stderr", this could be an app-specific expression like
294 "mystreams[curlogger]". */
295
296 static char *dprintf_channel;
297
298 /* True if dprintf commands should continue to operate even if GDB
299 has disconnected. */
300 static int disconnected_dprintf = 1;
301
302 struct command_line *
303 breakpoint_commands (struct breakpoint *b)
304 {
305 return b->commands ? b->commands.get () : NULL;
306 }
307
308 /* Flag indicating that a command has proceeded the inferior past the
309 current breakpoint. */
310
311 static int breakpoint_proceeded;
312
313 const char *
314 bpdisp_text (enum bpdisp disp)
315 {
316 /* NOTE: the following values are a part of MI protocol and
317 represent values of 'disp' field returned when inferior stops at
318 a breakpoint. */
319 static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
320
321 return bpdisps[(int) disp];
322 }
323
324 /* Prototypes for exported functions. */
325 /* If FALSE, gdb will not use hardware support for watchpoints, even
326 if such is available. */
327 static int can_use_hw_watchpoints;
328
329 static void
330 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
331 struct cmd_list_element *c,
332 const char *value)
333 {
334 fprintf_filtered (file,
335 _("Debugger's willingness to use "
336 "watchpoint hardware is %s.\n"),
337 value);
338 }
339
340 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
341 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
342 for unrecognized breakpoint locations.
343 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
344 static enum auto_boolean pending_break_support;
345 static void
346 show_pending_break_support (struct ui_file *file, int from_tty,
347 struct cmd_list_element *c,
348 const char *value)
349 {
350 fprintf_filtered (file,
351 _("Debugger's behavior regarding "
352 "pending breakpoints is %s.\n"),
353 value);
354 }
355
356 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
357 set with "break" but falling in read-only memory.
358 If 0, gdb will warn about such breakpoints, but won't automatically
359 use hardware breakpoints. */
360 static int automatic_hardware_breakpoints;
361 static void
362 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
363 struct cmd_list_element *c,
364 const char *value)
365 {
366 fprintf_filtered (file,
367 _("Automatic usage of hardware breakpoints is %s.\n"),
368 value);
369 }
370
371 /* If on, GDB keeps breakpoints inserted even if the inferior is
372 stopped, and immediately inserts any new breakpoints as soon as
373 they're created. If off (default), GDB keeps breakpoints off of
374 the target as long as possible. That is, it delays inserting
375 breakpoints until the next resume, and removes them again when the
376 target fully stops. This is a bit safer in case GDB crashes while
377 processing user input. */
378 static int always_inserted_mode = 0;
379
380 static void
381 show_always_inserted_mode (struct ui_file *file, int from_tty,
382 struct cmd_list_element *c, const char *value)
383 {
384 fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
385 value);
386 }
387
388 /* See breakpoint.h. */
389
390 int
391 breakpoints_should_be_inserted_now (void)
392 {
393 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
394 {
395 /* If breakpoints are global, they should be inserted even if no
396 thread under gdb's control is running, or even if there are
397 no threads under GDB's control yet. */
398 return 1;
399 }
400 else if (target_has_execution)
401 {
402 struct thread_info *tp;
403
404 if (always_inserted_mode)
405 {
406 /* The user wants breakpoints inserted even if all threads
407 are stopped. */
408 return 1;
409 }
410
411 if (threads_are_executing ())
412 return 1;
413
414 /* Don't remove breakpoints yet if, even though all threads are
415 stopped, we still have events to process. */
416 ALL_NON_EXITED_THREADS (tp)
417 if (tp->resumed
418 && tp->suspend.waitstatus_pending_p)
419 return 1;
420 }
421 return 0;
422 }
423
424 static const char condition_evaluation_both[] = "host or target";
425
426 /* Modes for breakpoint condition evaluation. */
427 static const char condition_evaluation_auto[] = "auto";
428 static const char condition_evaluation_host[] = "host";
429 static const char condition_evaluation_target[] = "target";
430 static const char *const condition_evaluation_enums[] = {
431 condition_evaluation_auto,
432 condition_evaluation_host,
433 condition_evaluation_target,
434 NULL
435 };
436
437 /* Global that holds the current mode for breakpoint condition evaluation. */
438 static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
439
440 /* Global that we use to display information to the user (gets its value from
441 condition_evaluation_mode_1. */
442 static const char *condition_evaluation_mode = condition_evaluation_auto;
443
444 /* Translate a condition evaluation mode MODE into either "host"
445 or "target". This is used mostly to translate from "auto" to the
446 real setting that is being used. It returns the translated
447 evaluation mode. */
448
449 static const char *
450 translate_condition_evaluation_mode (const char *mode)
451 {
452 if (mode == condition_evaluation_auto)
453 {
454 if (target_supports_evaluation_of_breakpoint_conditions ())
455 return condition_evaluation_target;
456 else
457 return condition_evaluation_host;
458 }
459 else
460 return mode;
461 }
462
463 /* Discovers what condition_evaluation_auto translates to. */
464
465 static const char *
466 breakpoint_condition_evaluation_mode (void)
467 {
468 return translate_condition_evaluation_mode (condition_evaluation_mode);
469 }
470
471 /* Return true if GDB should evaluate breakpoint conditions or false
472 otherwise. */
473
474 static int
475 gdb_evaluates_breakpoint_condition_p (void)
476 {
477 const char *mode = breakpoint_condition_evaluation_mode ();
478
479 return (mode == condition_evaluation_host);
480 }
481
482 /* Are we executing breakpoint commands? */
483 static int executing_breakpoint_commands;
484
485 /* Are overlay event breakpoints enabled? */
486 static int overlay_events_enabled;
487
488 /* See description in breakpoint.h. */
489 int target_exact_watchpoints = 0;
490
491 /* Walk the following statement or block through all breakpoints.
492 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
493 current breakpoint. */
494
495 #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
496
497 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
498 for (B = breakpoint_chain; \
499 B ? (TMP=B->next, 1): 0; \
500 B = TMP)
501
502 /* Similar iterator for the low-level breakpoints. SAFE variant is
503 not provided so update_global_location_list must not be called
504 while executing the block of ALL_BP_LOCATIONS. */
505
506 #define ALL_BP_LOCATIONS(B,BP_TMP) \
507 for (BP_TMP = bp_locations; \
508 BP_TMP < bp_locations + bp_locations_count && (B = *BP_TMP);\
509 BP_TMP++)
510
511 /* Iterates through locations with address ADDRESS for the currently selected
512 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
513 to where the loop should start from.
514 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
515 appropriate location to start with. */
516
517 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
518 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
519 BP_LOCP_TMP = BP_LOCP_START; \
520 BP_LOCP_START \
521 && (BP_LOCP_TMP < bp_locations + bp_locations_count \
522 && (*BP_LOCP_TMP)->address == ADDRESS); \
523 BP_LOCP_TMP++)
524
525 /* Iterator for tracepoints only. */
526
527 #define ALL_TRACEPOINTS(B) \
528 for (B = breakpoint_chain; B; B = B->next) \
529 if (is_tracepoint (B))
530
531 /* Chains of all breakpoints defined. */
532
533 struct breakpoint *breakpoint_chain;
534
535 /* Array is sorted by bp_locations_compare - primarily by the ADDRESS. */
536
537 static struct bp_location **bp_locations;
538
539 /* Number of elements of BP_LOCATIONS. */
540
541 static unsigned bp_locations_count;
542
543 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
544 ADDRESS for the current elements of BP_LOCATIONS which get a valid
545 result from bp_location_has_shadow. You can use it for roughly
546 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
547 an address you need to read. */
548
549 static CORE_ADDR bp_locations_placed_address_before_address_max;
550
551 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
552 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
553 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
554 You can use it for roughly limiting the subrange of BP_LOCATIONS to
555 scan for shadow bytes for an address you need to read. */
556
557 static CORE_ADDR bp_locations_shadow_len_after_address_max;
558
559 /* The locations that no longer correspond to any breakpoint, unlinked
560 from the bp_locations array, but for which a hit may still be
561 reported by a target. */
562 VEC(bp_location_p) *moribund_locations = NULL;
563
564 /* Number of last breakpoint made. */
565
566 static int breakpoint_count;
567
568 /* The value of `breakpoint_count' before the last command that
569 created breakpoints. If the last (break-like) command created more
570 than one breakpoint, then the difference between BREAKPOINT_COUNT
571 and PREV_BREAKPOINT_COUNT is more than one. */
572 static int prev_breakpoint_count;
573
574 /* Number of last tracepoint made. */
575
576 static int tracepoint_count;
577
578 static struct cmd_list_element *breakpoint_set_cmdlist;
579 static struct cmd_list_element *breakpoint_show_cmdlist;
580 struct cmd_list_element *save_cmdlist;
581
582 /* See declaration at breakpoint.h. */
583
584 struct breakpoint *
585 breakpoint_find_if (int (*func) (struct breakpoint *b, void *d),
586 void *user_data)
587 {
588 struct breakpoint *b = NULL;
589
590 ALL_BREAKPOINTS (b)
591 {
592 if (func (b, user_data) != 0)
593 break;
594 }
595
596 return b;
597 }
598
599 /* Return whether a breakpoint is an active enabled breakpoint. */
600 static int
601 breakpoint_enabled (struct breakpoint *b)
602 {
603 return (b->enable_state == bp_enabled);
604 }
605
606 /* Set breakpoint count to NUM. */
607
608 static void
609 set_breakpoint_count (int num)
610 {
611 prev_breakpoint_count = breakpoint_count;
612 breakpoint_count = num;
613 set_internalvar_integer (lookup_internalvar ("bpnum"), num);
614 }
615
616 /* Used by `start_rbreak_breakpoints' below, to record the current
617 breakpoint count before "rbreak" creates any breakpoint. */
618 static int rbreak_start_breakpoint_count;
619
620 /* Called at the start an "rbreak" command to record the first
621 breakpoint made. */
622
623 scoped_rbreak_breakpoints::scoped_rbreak_breakpoints ()
624 {
625 rbreak_start_breakpoint_count = breakpoint_count;
626 }
627
628 /* Called at the end of an "rbreak" command to record the last
629 breakpoint made. */
630
631 scoped_rbreak_breakpoints::~scoped_rbreak_breakpoints ()
632 {
633 prev_breakpoint_count = rbreak_start_breakpoint_count;
634 }
635
636 /* Used in run_command to zero the hit count when a new run starts. */
637
638 void
639 clear_breakpoint_hit_counts (void)
640 {
641 struct breakpoint *b;
642
643 ALL_BREAKPOINTS (b)
644 b->hit_count = 0;
645 }
646
647
648 /* Return the breakpoint with the specified number, or NULL
649 if the number does not refer to an existing breakpoint. */
650
651 struct breakpoint *
652 get_breakpoint (int num)
653 {
654 struct breakpoint *b;
655
656 ALL_BREAKPOINTS (b)
657 if (b->number == num)
658 return b;
659
660 return NULL;
661 }
662
663
664
665 /* Mark locations as "conditions have changed" in case the target supports
666 evaluating conditions on its side. */
667
668 static void
669 mark_breakpoint_modified (struct breakpoint *b)
670 {
671 struct bp_location *loc;
672
673 /* This is only meaningful if the target is
674 evaluating conditions and if the user has
675 opted for condition evaluation on the target's
676 side. */
677 if (gdb_evaluates_breakpoint_condition_p ()
678 || !target_supports_evaluation_of_breakpoint_conditions ())
679 return;
680
681 if (!is_breakpoint (b))
682 return;
683
684 for (loc = b->loc; loc; loc = loc->next)
685 loc->condition_changed = condition_modified;
686 }
687
688 /* Mark location as "conditions have changed" in case the target supports
689 evaluating conditions on its side. */
690
691 static void
692 mark_breakpoint_location_modified (struct bp_location *loc)
693 {
694 /* This is only meaningful if the target is
695 evaluating conditions and if the user has
696 opted for condition evaluation on the target's
697 side. */
698 if (gdb_evaluates_breakpoint_condition_p ()
699 || !target_supports_evaluation_of_breakpoint_conditions ())
700
701 return;
702
703 if (!is_breakpoint (loc->owner))
704 return;
705
706 loc->condition_changed = condition_modified;
707 }
708
709 /* Sets the condition-evaluation mode using the static global
710 condition_evaluation_mode. */
711
712 static void
713 set_condition_evaluation_mode (const char *args, int from_tty,
714 struct cmd_list_element *c)
715 {
716 const char *old_mode, *new_mode;
717
718 if ((condition_evaluation_mode_1 == condition_evaluation_target)
719 && !target_supports_evaluation_of_breakpoint_conditions ())
720 {
721 condition_evaluation_mode_1 = condition_evaluation_mode;
722 warning (_("Target does not support breakpoint condition evaluation.\n"
723 "Using host evaluation mode instead."));
724 return;
725 }
726
727 new_mode = translate_condition_evaluation_mode (condition_evaluation_mode_1);
728 old_mode = translate_condition_evaluation_mode (condition_evaluation_mode);
729
730 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
731 settings was "auto". */
732 condition_evaluation_mode = condition_evaluation_mode_1;
733
734 /* Only update the mode if the user picked a different one. */
735 if (new_mode != old_mode)
736 {
737 struct bp_location *loc, **loc_tmp;
738 /* If the user switched to a different evaluation mode, we
739 need to synch the changes with the target as follows:
740
741 "host" -> "target": Send all (valid) conditions to the target.
742 "target" -> "host": Remove all the conditions from the target.
743 */
744
745 if (new_mode == condition_evaluation_target)
746 {
747 /* Mark everything modified and synch conditions with the
748 target. */
749 ALL_BP_LOCATIONS (loc, loc_tmp)
750 mark_breakpoint_location_modified (loc);
751 }
752 else
753 {
754 /* Manually mark non-duplicate locations to synch conditions
755 with the target. We do this to remove all the conditions the
756 target knows about. */
757 ALL_BP_LOCATIONS (loc, loc_tmp)
758 if (is_breakpoint (loc->owner) && loc->inserted)
759 loc->needs_update = 1;
760 }
761
762 /* Do the update. */
763 update_global_location_list (UGLL_MAY_INSERT);
764 }
765
766 return;
767 }
768
769 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
770 what "auto" is translating to. */
771
772 static void
773 show_condition_evaluation_mode (struct ui_file *file, int from_tty,
774 struct cmd_list_element *c, const char *value)
775 {
776 if (condition_evaluation_mode == condition_evaluation_auto)
777 fprintf_filtered (file,
778 _("Breakpoint condition evaluation "
779 "mode is %s (currently %s).\n"),
780 value,
781 breakpoint_condition_evaluation_mode ());
782 else
783 fprintf_filtered (file, _("Breakpoint condition evaluation mode is %s.\n"),
784 value);
785 }
786
787 /* A comparison function for bp_location AP and BP that is used by
788 bsearch. This comparison function only cares about addresses, unlike
789 the more general bp_locations_compare function. */
790
791 static int
792 bp_locations_compare_addrs (const void *ap, const void *bp)
793 {
794 const struct bp_location *a = *(const struct bp_location **) ap;
795 const struct bp_location *b = *(const struct bp_location **) bp;
796
797 if (a->address == b->address)
798 return 0;
799 else
800 return ((a->address > b->address) - (a->address < b->address));
801 }
802
803 /* Helper function to skip all bp_locations with addresses
804 less than ADDRESS. It returns the first bp_location that
805 is greater than or equal to ADDRESS. If none is found, just
806 return NULL. */
807
808 static struct bp_location **
809 get_first_locp_gte_addr (CORE_ADDR address)
810 {
811 struct bp_location dummy_loc;
812 struct bp_location *dummy_locp = &dummy_loc;
813 struct bp_location **locp_found = NULL;
814
815 /* Initialize the dummy location's address field. */
816 dummy_loc.address = address;
817
818 /* Find a close match to the first location at ADDRESS. */
819 locp_found = ((struct bp_location **)
820 bsearch (&dummy_locp, bp_locations, bp_locations_count,
821 sizeof (struct bp_location **),
822 bp_locations_compare_addrs));
823
824 /* Nothing was found, nothing left to do. */
825 if (locp_found == NULL)
826 return NULL;
827
828 /* We may have found a location that is at ADDRESS but is not the first in the
829 location's list. Go backwards (if possible) and locate the first one. */
830 while ((locp_found - 1) >= bp_locations
831 && (*(locp_found - 1))->address == address)
832 locp_found--;
833
834 return locp_found;
835 }
836
837 void
838 set_breakpoint_condition (struct breakpoint *b, const char *exp,
839 int from_tty)
840 {
841 xfree (b->cond_string);
842 b->cond_string = NULL;
843
844 if (is_watchpoint (b))
845 {
846 struct watchpoint *w = (struct watchpoint *) b;
847
848 w->cond_exp.reset ();
849 }
850 else
851 {
852 struct bp_location *loc;
853
854 for (loc = b->loc; loc; loc = loc->next)
855 {
856 loc->cond.reset ();
857
858 /* No need to free the condition agent expression
859 bytecode (if we have one). We will handle this
860 when we go through update_global_location_list. */
861 }
862 }
863
864 if (*exp == 0)
865 {
866 if (from_tty)
867 printf_filtered (_("Breakpoint %d now unconditional.\n"), b->number);
868 }
869 else
870 {
871 const char *arg = exp;
872
873 /* I don't know if it matters whether this is the string the user
874 typed in or the decompiled expression. */
875 b->cond_string = xstrdup (arg);
876 b->condition_not_parsed = 0;
877
878 if (is_watchpoint (b))
879 {
880 struct watchpoint *w = (struct watchpoint *) b;
881
882 innermost_block = NULL;
883 arg = exp;
884 w->cond_exp = parse_exp_1 (&arg, 0, 0, 0);
885 if (*arg)
886 error (_("Junk at end of expression"));
887 w->cond_exp_valid_block = innermost_block;
888 }
889 else
890 {
891 struct bp_location *loc;
892
893 for (loc = b->loc; loc; loc = loc->next)
894 {
895 arg = exp;
896 loc->cond =
897 parse_exp_1 (&arg, loc->address,
898 block_for_pc (loc->address), 0);
899 if (*arg)
900 error (_("Junk at end of expression"));
901 }
902 }
903 }
904 mark_breakpoint_modified (b);
905
906 observer_notify_breakpoint_modified (b);
907 }
908
909 /* Completion for the "condition" command. */
910
911 static void
912 condition_completer (struct cmd_list_element *cmd,
913 completion_tracker &tracker,
914 const char *text, const char *word)
915 {
916 const char *space;
917
918 text = skip_spaces (text);
919 space = skip_to_space (text);
920 if (*space == '\0')
921 {
922 int len;
923 struct breakpoint *b;
924
925 if (text[0] == '$')
926 {
927 /* We don't support completion of history indices. */
928 if (!isdigit (text[1]))
929 complete_internalvar (tracker, &text[1]);
930 return;
931 }
932
933 /* We're completing the breakpoint number. */
934 len = strlen (text);
935
936 ALL_BREAKPOINTS (b)
937 {
938 char number[50];
939
940 xsnprintf (number, sizeof (number), "%d", b->number);
941
942 if (strncmp (number, text, len) == 0)
943 {
944 gdb::unique_xmalloc_ptr<char> copy (xstrdup (number));
945 tracker.add_completion (std::move (copy));
946 }
947 }
948
949 return;
950 }
951
952 /* We're completing the expression part. */
953 text = skip_spaces (space);
954 expression_completer (cmd, tracker, text, word);
955 }
956
957 /* condition N EXP -- set break condition of breakpoint N to EXP. */
958
959 static void
960 condition_command (const char *arg, int from_tty)
961 {
962 struct breakpoint *b;
963 const char *p;
964 int bnum;
965
966 if (arg == 0)
967 error_no_arg (_("breakpoint number"));
968
969 p = arg;
970 bnum = get_number (&p);
971 if (bnum == 0)
972 error (_("Bad breakpoint argument: '%s'"), arg);
973
974 ALL_BREAKPOINTS (b)
975 if (b->number == bnum)
976 {
977 /* Check if this breakpoint has a "stop" method implemented in an
978 extension language. This method and conditions entered into GDB
979 from the CLI are mutually exclusive. */
980 const struct extension_language_defn *extlang
981 = get_breakpoint_cond_ext_lang (b, EXT_LANG_NONE);
982
983 if (extlang != NULL)
984 {
985 error (_("Only one stop condition allowed. There is currently"
986 " a %s stop condition defined for this breakpoint."),
987 ext_lang_capitalized_name (extlang));
988 }
989 set_breakpoint_condition (b, p, from_tty);
990
991 if (is_breakpoint (b))
992 update_global_location_list (UGLL_MAY_INSERT);
993
994 return;
995 }
996
997 error (_("No breakpoint number %d."), bnum);
998 }
999
1000 /* Check that COMMAND do not contain commands that are suitable
1001 only for tracepoints and not suitable for ordinary breakpoints.
1002 Throw if any such commands is found. */
1003
1004 static void
1005 check_no_tracepoint_commands (struct command_line *commands)
1006 {
1007 struct command_line *c;
1008
1009 for (c = commands; c; c = c->next)
1010 {
1011 int i;
1012
1013 if (c->control_type == while_stepping_control)
1014 error (_("The 'while-stepping' command can "
1015 "only be used for tracepoints"));
1016
1017 for (i = 0; i < c->body_count; ++i)
1018 check_no_tracepoint_commands ((c->body_list)[i]);
1019
1020 /* Not that command parsing removes leading whitespace and comment
1021 lines and also empty lines. So, we only need to check for
1022 command directly. */
1023 if (strstr (c->line, "collect ") == c->line)
1024 error (_("The 'collect' command can only be used for tracepoints"));
1025
1026 if (strstr (c->line, "teval ") == c->line)
1027 error (_("The 'teval' command can only be used for tracepoints"));
1028 }
1029 }
1030
1031 struct longjmp_breakpoint : public breakpoint
1032 {
1033 ~longjmp_breakpoint () override;
1034 };
1035
1036 /* Encapsulate tests for different types of tracepoints. */
1037
1038 static bool
1039 is_tracepoint_type (bptype type)
1040 {
1041 return (type == bp_tracepoint
1042 || type == bp_fast_tracepoint
1043 || type == bp_static_tracepoint);
1044 }
1045
1046 static bool
1047 is_longjmp_type (bptype type)
1048 {
1049 return type == bp_longjmp || type == bp_exception;
1050 }
1051
1052 int
1053 is_tracepoint (const struct breakpoint *b)
1054 {
1055 return is_tracepoint_type (b->type);
1056 }
1057
1058 /* Factory function to create an appropriate instance of breakpoint given
1059 TYPE. */
1060
1061 static std::unique_ptr<breakpoint>
1062 new_breakpoint_from_type (bptype type)
1063 {
1064 breakpoint *b;
1065
1066 if (is_tracepoint_type (type))
1067 b = new tracepoint ();
1068 else if (is_longjmp_type (type))
1069 b = new longjmp_breakpoint ();
1070 else
1071 b = new breakpoint ();
1072
1073 return std::unique_ptr<breakpoint> (b);
1074 }
1075
1076 /* A helper function that validates that COMMANDS are valid for a
1077 breakpoint. This function will throw an exception if a problem is
1078 found. */
1079
1080 static void
1081 validate_commands_for_breakpoint (struct breakpoint *b,
1082 struct command_line *commands)
1083 {
1084 if (is_tracepoint (b))
1085 {
1086 struct tracepoint *t = (struct tracepoint *) b;
1087 struct command_line *c;
1088 struct command_line *while_stepping = 0;
1089
1090 /* Reset the while-stepping step count. The previous commands
1091 might have included a while-stepping action, while the new
1092 ones might not. */
1093 t->step_count = 0;
1094
1095 /* We need to verify that each top-level element of commands is
1096 valid for tracepoints, that there's at most one
1097 while-stepping element, and that the while-stepping's body
1098 has valid tracing commands excluding nested while-stepping.
1099 We also need to validate the tracepoint action line in the
1100 context of the tracepoint --- validate_actionline actually
1101 has side effects, like setting the tracepoint's
1102 while-stepping STEP_COUNT, in addition to checking if the
1103 collect/teval actions parse and make sense in the
1104 tracepoint's context. */
1105 for (c = commands; c; c = c->next)
1106 {
1107 if (c->control_type == while_stepping_control)
1108 {
1109 if (b->type == bp_fast_tracepoint)
1110 error (_("The 'while-stepping' command "
1111 "cannot be used for fast tracepoint"));
1112 else if (b->type == bp_static_tracepoint)
1113 error (_("The 'while-stepping' command "
1114 "cannot be used for static tracepoint"));
1115
1116 if (while_stepping)
1117 error (_("The 'while-stepping' command "
1118 "can be used only once"));
1119 else
1120 while_stepping = c;
1121 }
1122
1123 validate_actionline (c->line, b);
1124 }
1125 if (while_stepping)
1126 {
1127 struct command_line *c2;
1128
1129 gdb_assert (while_stepping->body_count == 1);
1130 c2 = while_stepping->body_list[0];
1131 for (; c2; c2 = c2->next)
1132 {
1133 if (c2->control_type == while_stepping_control)
1134 error (_("The 'while-stepping' command cannot be nested"));
1135 }
1136 }
1137 }
1138 else
1139 {
1140 check_no_tracepoint_commands (commands);
1141 }
1142 }
1143
1144 /* Return a vector of all the static tracepoints set at ADDR. The
1145 caller is responsible for releasing the vector. */
1146
1147 VEC(breakpoint_p) *
1148 static_tracepoints_here (CORE_ADDR addr)
1149 {
1150 struct breakpoint *b;
1151 VEC(breakpoint_p) *found = 0;
1152 struct bp_location *loc;
1153
1154 ALL_BREAKPOINTS (b)
1155 if (b->type == bp_static_tracepoint)
1156 {
1157 for (loc = b->loc; loc; loc = loc->next)
1158 if (loc->address == addr)
1159 VEC_safe_push(breakpoint_p, found, b);
1160 }
1161
1162 return found;
1163 }
1164
1165 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1166 validate that only allowed commands are included. */
1167
1168 void
1169 breakpoint_set_commands (struct breakpoint *b,
1170 command_line_up &&commands)
1171 {
1172 validate_commands_for_breakpoint (b, commands.get ());
1173
1174 b->commands = std::move (commands);
1175 observer_notify_breakpoint_modified (b);
1176 }
1177
1178 /* Set the internal `silent' flag on the breakpoint. Note that this
1179 is not the same as the "silent" that may appear in the breakpoint's
1180 commands. */
1181
1182 void
1183 breakpoint_set_silent (struct breakpoint *b, int silent)
1184 {
1185 int old_silent = b->silent;
1186
1187 b->silent = silent;
1188 if (old_silent != silent)
1189 observer_notify_breakpoint_modified (b);
1190 }
1191
1192 /* Set the thread for this breakpoint. If THREAD is -1, make the
1193 breakpoint work for any thread. */
1194
1195 void
1196 breakpoint_set_thread (struct breakpoint *b, int thread)
1197 {
1198 int old_thread = b->thread;
1199
1200 b->thread = thread;
1201 if (old_thread != thread)
1202 observer_notify_breakpoint_modified (b);
1203 }
1204
1205 /* Set the task for this breakpoint. If TASK is 0, make the
1206 breakpoint work for any task. */
1207
1208 void
1209 breakpoint_set_task (struct breakpoint *b, int task)
1210 {
1211 int old_task = b->task;
1212
1213 b->task = task;
1214 if (old_task != task)
1215 observer_notify_breakpoint_modified (b);
1216 }
1217
1218 void
1219 check_tracepoint_command (char *line, void *closure)
1220 {
1221 struct breakpoint *b = (struct breakpoint *) closure;
1222
1223 validate_actionline (line, b);
1224 }
1225
1226 static void
1227 commands_command_1 (const char *arg, int from_tty,
1228 struct command_line *control)
1229 {
1230 counted_command_line cmd;
1231
1232 std::string new_arg;
1233
1234 if (arg == NULL || !*arg)
1235 {
1236 if (breakpoint_count - prev_breakpoint_count > 1)
1237 new_arg = string_printf ("%d-%d", prev_breakpoint_count + 1,
1238 breakpoint_count);
1239 else if (breakpoint_count > 0)
1240 new_arg = string_printf ("%d", breakpoint_count);
1241 arg = new_arg.c_str ();
1242 }
1243
1244 map_breakpoint_numbers
1245 (arg, [&] (breakpoint *b)
1246 {
1247 if (cmd == NULL)
1248 {
1249 if (control != NULL)
1250 cmd = copy_command_lines (control->body_list[0]);
1251 else
1252 {
1253 std::string str
1254 = string_printf (_("Type commands for breakpoint(s) "
1255 "%s, one per line."),
1256 arg);
1257
1258 cmd = read_command_lines (&str[0],
1259 from_tty, 1,
1260 (is_tracepoint (b)
1261 ? check_tracepoint_command : 0),
1262 b);
1263 }
1264 }
1265
1266 /* If a breakpoint was on the list more than once, we don't need to
1267 do anything. */
1268 if (b->commands != cmd)
1269 {
1270 validate_commands_for_breakpoint (b, cmd.get ());
1271 b->commands = cmd;
1272 observer_notify_breakpoint_modified (b);
1273 }
1274 });
1275 }
1276
1277 static void
1278 commands_command (const char *arg, int from_tty)
1279 {
1280 commands_command_1 (arg, from_tty, NULL);
1281 }
1282
1283 /* Like commands_command, but instead of reading the commands from
1284 input stream, takes them from an already parsed command structure.
1285
1286 This is used by cli-script.c to DTRT with breakpoint commands
1287 that are part of if and while bodies. */
1288 enum command_control_type
1289 commands_from_control_command (const char *arg, struct command_line *cmd)
1290 {
1291 commands_command_1 (arg, 0, cmd);
1292 return simple_control;
1293 }
1294
1295 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1296
1297 static int
1298 bp_location_has_shadow (struct bp_location *bl)
1299 {
1300 if (bl->loc_type != bp_loc_software_breakpoint)
1301 return 0;
1302 if (!bl->inserted)
1303 return 0;
1304 if (bl->target_info.shadow_len == 0)
1305 /* BL isn't valid, or doesn't shadow memory. */
1306 return 0;
1307 return 1;
1308 }
1309
1310 /* Update BUF, which is LEN bytes read from the target address
1311 MEMADDR, by replacing a memory breakpoint with its shadowed
1312 contents.
1313
1314 If READBUF is not NULL, this buffer must not overlap with the of
1315 the breakpoint location's shadow_contents buffer. Otherwise, a
1316 failed assertion internal error will be raised. */
1317
1318 static void
1319 one_breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1320 const gdb_byte *writebuf_org,
1321 ULONGEST memaddr, LONGEST len,
1322 struct bp_target_info *target_info,
1323 struct gdbarch *gdbarch)
1324 {
1325 /* Now do full processing of the found relevant range of elements. */
1326 CORE_ADDR bp_addr = 0;
1327 int bp_size = 0;
1328 int bptoffset = 0;
1329
1330 if (!breakpoint_address_match (target_info->placed_address_space, 0,
1331 current_program_space->aspace, 0))
1332 {
1333 /* The breakpoint is inserted in a different address space. */
1334 return;
1335 }
1336
1337 /* Addresses and length of the part of the breakpoint that
1338 we need to copy. */
1339 bp_addr = target_info->placed_address;
1340 bp_size = target_info->shadow_len;
1341
1342 if (bp_addr + bp_size <= memaddr)
1343 {
1344 /* The breakpoint is entirely before the chunk of memory we are
1345 reading. */
1346 return;
1347 }
1348
1349 if (bp_addr >= memaddr + len)
1350 {
1351 /* The breakpoint is entirely after the chunk of memory we are
1352 reading. */
1353 return;
1354 }
1355
1356 /* Offset within shadow_contents. */
1357 if (bp_addr < memaddr)
1358 {
1359 /* Only copy the second part of the breakpoint. */
1360 bp_size -= memaddr - bp_addr;
1361 bptoffset = memaddr - bp_addr;
1362 bp_addr = memaddr;
1363 }
1364
1365 if (bp_addr + bp_size > memaddr + len)
1366 {
1367 /* Only copy the first part of the breakpoint. */
1368 bp_size -= (bp_addr + bp_size) - (memaddr + len);
1369 }
1370
1371 if (readbuf != NULL)
1372 {
1373 /* Verify that the readbuf buffer does not overlap with the
1374 shadow_contents buffer. */
1375 gdb_assert (target_info->shadow_contents >= readbuf + len
1376 || readbuf >= (target_info->shadow_contents
1377 + target_info->shadow_len));
1378
1379 /* Update the read buffer with this inserted breakpoint's
1380 shadow. */
1381 memcpy (readbuf + bp_addr - memaddr,
1382 target_info->shadow_contents + bptoffset, bp_size);
1383 }
1384 else
1385 {
1386 const unsigned char *bp;
1387 CORE_ADDR addr = target_info->reqstd_address;
1388 int placed_size;
1389
1390 /* Update the shadow with what we want to write to memory. */
1391 memcpy (target_info->shadow_contents + bptoffset,
1392 writebuf_org + bp_addr - memaddr, bp_size);
1393
1394 /* Determine appropriate breakpoint contents and size for this
1395 address. */
1396 bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &placed_size);
1397
1398 /* Update the final write buffer with this inserted
1399 breakpoint's INSN. */
1400 memcpy (writebuf + bp_addr - memaddr, bp + bptoffset, bp_size);
1401 }
1402 }
1403
1404 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1405 by replacing any memory breakpoints with their shadowed contents.
1406
1407 If READBUF is not NULL, this buffer must not overlap with any of
1408 the breakpoint location's shadow_contents buffers. Otherwise,
1409 a failed assertion internal error will be raised.
1410
1411 The range of shadowed area by each bp_location is:
1412 bl->address - bp_locations_placed_address_before_address_max
1413 up to bl->address + bp_locations_shadow_len_after_address_max
1414 The range we were requested to resolve shadows for is:
1415 memaddr ... memaddr + len
1416 Thus the safe cutoff boundaries for performance optimization are
1417 memaddr + len <= (bl->address
1418 - bp_locations_placed_address_before_address_max)
1419 and:
1420 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1421
1422 void
1423 breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1424 const gdb_byte *writebuf_org,
1425 ULONGEST memaddr, LONGEST len)
1426 {
1427 /* Left boundary, right boundary and median element of our binary
1428 search. */
1429 unsigned bc_l, bc_r, bc;
1430
1431 /* Find BC_L which is a leftmost element which may affect BUF
1432 content. It is safe to report lower value but a failure to
1433 report higher one. */
1434
1435 bc_l = 0;
1436 bc_r = bp_locations_count;
1437 while (bc_l + 1 < bc_r)
1438 {
1439 struct bp_location *bl;
1440
1441 bc = (bc_l + bc_r) / 2;
1442 bl = bp_locations[bc];
1443
1444 /* Check first BL->ADDRESS will not overflow due to the added
1445 constant. Then advance the left boundary only if we are sure
1446 the BC element can in no way affect the BUF content (MEMADDR
1447 to MEMADDR + LEN range).
1448
1449 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1450 offset so that we cannot miss a breakpoint with its shadow
1451 range tail still reaching MEMADDR. */
1452
1453 if ((bl->address + bp_locations_shadow_len_after_address_max
1454 >= bl->address)
1455 && (bl->address + bp_locations_shadow_len_after_address_max
1456 <= memaddr))
1457 bc_l = bc;
1458 else
1459 bc_r = bc;
1460 }
1461
1462 /* Due to the binary search above, we need to make sure we pick the
1463 first location that's at BC_L's address. E.g., if there are
1464 multiple locations at the same address, BC_L may end up pointing
1465 at a duplicate location, and miss the "master"/"inserted"
1466 location. Say, given locations L1, L2 and L3 at addresses A and
1467 B:
1468
1469 L1@A, L2@A, L3@B, ...
1470
1471 BC_L could end up pointing at location L2, while the "master"
1472 location could be L1. Since the `loc->inserted' flag is only set
1473 on "master" locations, we'd forget to restore the shadow of L1
1474 and L2. */
1475 while (bc_l > 0
1476 && bp_locations[bc_l]->address == bp_locations[bc_l - 1]->address)
1477 bc_l--;
1478
1479 /* Now do full processing of the found relevant range of elements. */
1480
1481 for (bc = bc_l; bc < bp_locations_count; bc++)
1482 {
1483 struct bp_location *bl = bp_locations[bc];
1484
1485 /* bp_location array has BL->OWNER always non-NULL. */
1486 if (bl->owner->type == bp_none)
1487 warning (_("reading through apparently deleted breakpoint #%d?"),
1488 bl->owner->number);
1489
1490 /* Performance optimization: any further element can no longer affect BUF
1491 content. */
1492
1493 if (bl->address >= bp_locations_placed_address_before_address_max
1494 && memaddr + len <= (bl->address
1495 - bp_locations_placed_address_before_address_max))
1496 break;
1497
1498 if (!bp_location_has_shadow (bl))
1499 continue;
1500
1501 one_breakpoint_xfer_memory (readbuf, writebuf, writebuf_org,
1502 memaddr, len, &bl->target_info, bl->gdbarch);
1503 }
1504 }
1505
1506
1507
1508 /* Return true if BPT is either a software breakpoint or a hardware
1509 breakpoint. */
1510
1511 int
1512 is_breakpoint (const struct breakpoint *bpt)
1513 {
1514 return (bpt->type == bp_breakpoint
1515 || bpt->type == bp_hardware_breakpoint
1516 || bpt->type == bp_dprintf);
1517 }
1518
1519 /* Return true if BPT is of any hardware watchpoint kind. */
1520
1521 static int
1522 is_hardware_watchpoint (const struct breakpoint *bpt)
1523 {
1524 return (bpt->type == bp_hardware_watchpoint
1525 || bpt->type == bp_read_watchpoint
1526 || bpt->type == bp_access_watchpoint);
1527 }
1528
1529 /* Return true if BPT is of any watchpoint kind, hardware or
1530 software. */
1531
1532 int
1533 is_watchpoint (const struct breakpoint *bpt)
1534 {
1535 return (is_hardware_watchpoint (bpt)
1536 || bpt->type == bp_watchpoint);
1537 }
1538
1539 /* Returns true if the current thread and its running state are safe
1540 to evaluate or update watchpoint B. Watchpoints on local
1541 expressions need to be evaluated in the context of the thread that
1542 was current when the watchpoint was created, and, that thread needs
1543 to be stopped to be able to select the correct frame context.
1544 Watchpoints on global expressions can be evaluated on any thread,
1545 and in any state. It is presently left to the target allowing
1546 memory accesses when threads are running. */
1547
1548 static int
1549 watchpoint_in_thread_scope (struct watchpoint *b)
1550 {
1551 return (b->pspace == current_program_space
1552 && (ptid_equal (b->watchpoint_thread, null_ptid)
1553 || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1554 && !is_executing (inferior_ptid))));
1555 }
1556
1557 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1558 associated bp_watchpoint_scope breakpoint. */
1559
1560 static void
1561 watchpoint_del_at_next_stop (struct watchpoint *w)
1562 {
1563 if (w->related_breakpoint != w)
1564 {
1565 gdb_assert (w->related_breakpoint->type == bp_watchpoint_scope);
1566 gdb_assert (w->related_breakpoint->related_breakpoint == w);
1567 w->related_breakpoint->disposition = disp_del_at_next_stop;
1568 w->related_breakpoint->related_breakpoint = w->related_breakpoint;
1569 w->related_breakpoint = w;
1570 }
1571 w->disposition = disp_del_at_next_stop;
1572 }
1573
1574 /* Extract a bitfield value from value VAL using the bit parameters contained in
1575 watchpoint W. */
1576
1577 static struct value *
1578 extract_bitfield_from_watchpoint_value (struct watchpoint *w, struct value *val)
1579 {
1580 struct value *bit_val;
1581
1582 if (val == NULL)
1583 return NULL;
1584
1585 bit_val = allocate_value (value_type (val));
1586
1587 unpack_value_bitfield (bit_val,
1588 w->val_bitpos,
1589 w->val_bitsize,
1590 value_contents_for_printing (val),
1591 value_offset (val),
1592 val);
1593
1594 return bit_val;
1595 }
1596
1597 /* Allocate a dummy location and add it to B, which must be a software
1598 watchpoint. This is required because even if a software watchpoint
1599 is not watching any memory, bpstat_stop_status requires a location
1600 to be able to report stops. */
1601
1602 static void
1603 software_watchpoint_add_no_memory_location (struct breakpoint *b,
1604 struct program_space *pspace)
1605 {
1606 gdb_assert (b->type == bp_watchpoint && b->loc == NULL);
1607
1608 b->loc = allocate_bp_location (b);
1609 b->loc->pspace = pspace;
1610 b->loc->address = -1;
1611 b->loc->length = -1;
1612 }
1613
1614 /* Returns true if B is a software watchpoint that is not watching any
1615 memory (e.g., "watch $pc"). */
1616
1617 static int
1618 is_no_memory_software_watchpoint (struct breakpoint *b)
1619 {
1620 return (b->type == bp_watchpoint
1621 && b->loc != NULL
1622 && b->loc->next == NULL
1623 && b->loc->address == -1
1624 && b->loc->length == -1);
1625 }
1626
1627 /* Assuming that B is a watchpoint:
1628 - Reparse watchpoint expression, if REPARSE is non-zero
1629 - Evaluate expression and store the result in B->val
1630 - Evaluate the condition if there is one, and store the result
1631 in b->loc->cond.
1632 - Update the list of values that must be watched in B->loc.
1633
1634 If the watchpoint disposition is disp_del_at_next_stop, then do
1635 nothing. If this is local watchpoint that is out of scope, delete
1636 it.
1637
1638 Even with `set breakpoint always-inserted on' the watchpoints are
1639 removed + inserted on each stop here. Normal breakpoints must
1640 never be removed because they might be missed by a running thread
1641 when debugging in non-stop mode. On the other hand, hardware
1642 watchpoints (is_hardware_watchpoint; processed here) are specific
1643 to each LWP since they are stored in each LWP's hardware debug
1644 registers. Therefore, such LWP must be stopped first in order to
1645 be able to modify its hardware watchpoints.
1646
1647 Hardware watchpoints must be reset exactly once after being
1648 presented to the user. It cannot be done sooner, because it would
1649 reset the data used to present the watchpoint hit to the user. And
1650 it must not be done later because it could display the same single
1651 watchpoint hit during multiple GDB stops. Note that the latter is
1652 relevant only to the hardware watchpoint types bp_read_watchpoint
1653 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1654 not user-visible - its hit is suppressed if the memory content has
1655 not changed.
1656
1657 The following constraints influence the location where we can reset
1658 hardware watchpoints:
1659
1660 * target_stopped_by_watchpoint and target_stopped_data_address are
1661 called several times when GDB stops.
1662
1663 [linux]
1664 * Multiple hardware watchpoints can be hit at the same time,
1665 causing GDB to stop. GDB only presents one hardware watchpoint
1666 hit at a time as the reason for stopping, and all the other hits
1667 are presented later, one after the other, each time the user
1668 requests the execution to be resumed. Execution is not resumed
1669 for the threads still having pending hit event stored in
1670 LWP_INFO->STATUS. While the watchpoint is already removed from
1671 the inferior on the first stop the thread hit event is kept being
1672 reported from its cached value by linux_nat_stopped_data_address
1673 until the real thread resume happens after the watchpoint gets
1674 presented and thus its LWP_INFO->STATUS gets reset.
1675
1676 Therefore the hardware watchpoint hit can get safely reset on the
1677 watchpoint removal from inferior. */
1678
1679 static void
1680 update_watchpoint (struct watchpoint *b, int reparse)
1681 {
1682 int within_current_scope;
1683 struct frame_id saved_frame_id;
1684 int frame_saved;
1685
1686 /* If this is a local watchpoint, we only want to check if the
1687 watchpoint frame is in scope if the current thread is the thread
1688 that was used to create the watchpoint. */
1689 if (!watchpoint_in_thread_scope (b))
1690 return;
1691
1692 if (b->disposition == disp_del_at_next_stop)
1693 return;
1694
1695 frame_saved = 0;
1696
1697 /* Determine if the watchpoint is within scope. */
1698 if (b->exp_valid_block == NULL)
1699 within_current_scope = 1;
1700 else
1701 {
1702 struct frame_info *fi = get_current_frame ();
1703 struct gdbarch *frame_arch = get_frame_arch (fi);
1704 CORE_ADDR frame_pc = get_frame_pc (fi);
1705
1706 /* If we're at a point where the stack has been destroyed
1707 (e.g. in a function epilogue), unwinding may not work
1708 properly. Do not attempt to recreate locations at this
1709 point. See similar comments in watchpoint_check. */
1710 if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
1711 return;
1712
1713 /* Save the current frame's ID so we can restore it after
1714 evaluating the watchpoint expression on its own frame. */
1715 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1716 took a frame parameter, so that we didn't have to change the
1717 selected frame. */
1718 frame_saved = 1;
1719 saved_frame_id = get_frame_id (get_selected_frame (NULL));
1720
1721 fi = frame_find_by_id (b->watchpoint_frame);
1722 within_current_scope = (fi != NULL);
1723 if (within_current_scope)
1724 select_frame (fi);
1725 }
1726
1727 /* We don't free locations. They are stored in the bp_location array
1728 and update_global_location_list will eventually delete them and
1729 remove breakpoints if needed. */
1730 b->loc = NULL;
1731
1732 if (within_current_scope && reparse)
1733 {
1734 const char *s;
1735
1736 b->exp.reset ();
1737 s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1738 b->exp = parse_exp_1 (&s, 0, b->exp_valid_block, 0);
1739 /* If the meaning of expression itself changed, the old value is
1740 no longer relevant. We don't want to report a watchpoint hit
1741 to the user when the old value and the new value may actually
1742 be completely different objects. */
1743 value_free (b->val);
1744 b->val = NULL;
1745 b->val_valid = 0;
1746
1747 /* Note that unlike with breakpoints, the watchpoint's condition
1748 expression is stored in the breakpoint object, not in the
1749 locations (re)created below. */
1750 if (b->cond_string != NULL)
1751 {
1752 b->cond_exp.reset ();
1753
1754 s = b->cond_string;
1755 b->cond_exp = parse_exp_1 (&s, 0, b->cond_exp_valid_block, 0);
1756 }
1757 }
1758
1759 /* If we failed to parse the expression, for example because
1760 it refers to a global variable in a not-yet-loaded shared library,
1761 don't try to insert watchpoint. We don't automatically delete
1762 such watchpoint, though, since failure to parse expression
1763 is different from out-of-scope watchpoint. */
1764 if (!target_has_execution)
1765 {
1766 /* Without execution, memory can't change. No use to try and
1767 set watchpoint locations. The watchpoint will be reset when
1768 the target gains execution, through breakpoint_re_set. */
1769 if (!can_use_hw_watchpoints)
1770 {
1771 if (b->ops->works_in_software_mode (b))
1772 b->type = bp_watchpoint;
1773 else
1774 error (_("Can't set read/access watchpoint when "
1775 "hardware watchpoints are disabled."));
1776 }
1777 }
1778 else if (within_current_scope && b->exp)
1779 {
1780 int pc = 0;
1781 struct value *val_chain, *v, *result, *next;
1782 struct program_space *frame_pspace;
1783
1784 fetch_subexp_value (b->exp.get (), &pc, &v, &result, &val_chain, 0);
1785
1786 /* Avoid setting b->val if it's already set. The meaning of
1787 b->val is 'the last value' user saw, and we should update
1788 it only if we reported that last value to user. As it
1789 happens, the code that reports it updates b->val directly.
1790 We don't keep track of the memory value for masked
1791 watchpoints. */
1792 if (!b->val_valid && !is_masked_watchpoint (b))
1793 {
1794 if (b->val_bitsize != 0)
1795 {
1796 v = extract_bitfield_from_watchpoint_value (b, v);
1797 if (v != NULL)
1798 release_value (v);
1799 }
1800 b->val = v;
1801 b->val_valid = 1;
1802 }
1803
1804 frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1805
1806 /* Look at each value on the value chain. */
1807 for (v = val_chain; v; v = value_next (v))
1808 {
1809 /* If it's a memory location, and GDB actually needed
1810 its contents to evaluate the expression, then we
1811 must watch it. If the first value returned is
1812 still lazy, that means an error occurred reading it;
1813 watch it anyway in case it becomes readable. */
1814 if (VALUE_LVAL (v) == lval_memory
1815 && (v == val_chain || ! value_lazy (v)))
1816 {
1817 struct type *vtype = check_typedef (value_type (v));
1818
1819 /* We only watch structs and arrays if user asked
1820 for it explicitly, never if they just happen to
1821 appear in the middle of some value chain. */
1822 if (v == result
1823 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1824 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1825 {
1826 CORE_ADDR addr;
1827 enum target_hw_bp_type type;
1828 struct bp_location *loc, **tmp;
1829 int bitpos = 0, bitsize = 0;
1830
1831 if (value_bitsize (v) != 0)
1832 {
1833 /* Extract the bit parameters out from the bitfield
1834 sub-expression. */
1835 bitpos = value_bitpos (v);
1836 bitsize = value_bitsize (v);
1837 }
1838 else if (v == result && b->val_bitsize != 0)
1839 {
1840 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1841 lvalue whose bit parameters are saved in the fields
1842 VAL_BITPOS and VAL_BITSIZE. */
1843 bitpos = b->val_bitpos;
1844 bitsize = b->val_bitsize;
1845 }
1846
1847 addr = value_address (v);
1848 if (bitsize != 0)
1849 {
1850 /* Skip the bytes that don't contain the bitfield. */
1851 addr += bitpos / 8;
1852 }
1853
1854 type = hw_write;
1855 if (b->type == bp_read_watchpoint)
1856 type = hw_read;
1857 else if (b->type == bp_access_watchpoint)
1858 type = hw_access;
1859
1860 loc = allocate_bp_location (b);
1861 for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
1862 ;
1863 *tmp = loc;
1864 loc->gdbarch = get_type_arch (value_type (v));
1865
1866 loc->pspace = frame_pspace;
1867 loc->address = address_significant (loc->gdbarch, addr);
1868
1869 if (bitsize != 0)
1870 {
1871 /* Just cover the bytes that make up the bitfield. */
1872 loc->length = ((bitpos % 8) + bitsize + 7) / 8;
1873 }
1874 else
1875 loc->length = TYPE_LENGTH (value_type (v));
1876
1877 loc->watchpoint_type = type;
1878 }
1879 }
1880 }
1881
1882 /* Change the type of breakpoint between hardware assisted or
1883 an ordinary watchpoint depending on the hardware support
1884 and free hardware slots. REPARSE is set when the inferior
1885 is started. */
1886 if (reparse)
1887 {
1888 int reg_cnt;
1889 enum bp_loc_type loc_type;
1890 struct bp_location *bl;
1891
1892 reg_cnt = can_use_hardware_watchpoint (val_chain);
1893
1894 if (reg_cnt)
1895 {
1896 int i, target_resources_ok, other_type_used;
1897 enum bptype type;
1898
1899 /* Use an exact watchpoint when there's only one memory region to be
1900 watched, and only one debug register is needed to watch it. */
1901 b->exact = target_exact_watchpoints && reg_cnt == 1;
1902
1903 /* We need to determine how many resources are already
1904 used for all other hardware watchpoints plus this one
1905 to see if we still have enough resources to also fit
1906 this watchpoint in as well. */
1907
1908 /* If this is a software watchpoint, we try to turn it
1909 to a hardware one -- count resources as if B was of
1910 hardware watchpoint type. */
1911 type = b->type;
1912 if (type == bp_watchpoint)
1913 type = bp_hardware_watchpoint;
1914
1915 /* This watchpoint may or may not have been placed on
1916 the list yet at this point (it won't be in the list
1917 if we're trying to create it for the first time,
1918 through watch_command), so always account for it
1919 manually. */
1920
1921 /* Count resources used by all watchpoints except B. */
1922 i = hw_watchpoint_used_count_others (b, type, &other_type_used);
1923
1924 /* Add in the resources needed for B. */
1925 i += hw_watchpoint_use_count (b);
1926
1927 target_resources_ok
1928 = target_can_use_hardware_watchpoint (type, i, other_type_used);
1929 if (target_resources_ok <= 0)
1930 {
1931 int sw_mode = b->ops->works_in_software_mode (b);
1932
1933 if (target_resources_ok == 0 && !sw_mode)
1934 error (_("Target does not support this type of "
1935 "hardware watchpoint."));
1936 else if (target_resources_ok < 0 && !sw_mode)
1937 error (_("There are not enough available hardware "
1938 "resources for this watchpoint."));
1939
1940 /* Downgrade to software watchpoint. */
1941 b->type = bp_watchpoint;
1942 }
1943 else
1944 {
1945 /* If this was a software watchpoint, we've just
1946 found we have enough resources to turn it to a
1947 hardware watchpoint. Otherwise, this is a
1948 nop. */
1949 b->type = type;
1950 }
1951 }
1952 else if (!b->ops->works_in_software_mode (b))
1953 {
1954 if (!can_use_hw_watchpoints)
1955 error (_("Can't set read/access watchpoint when "
1956 "hardware watchpoints are disabled."));
1957 else
1958 error (_("Expression cannot be implemented with "
1959 "read/access watchpoint."));
1960 }
1961 else
1962 b->type = bp_watchpoint;
1963
1964 loc_type = (b->type == bp_watchpoint? bp_loc_other
1965 : bp_loc_hardware_watchpoint);
1966 for (bl = b->loc; bl; bl = bl->next)
1967 bl->loc_type = loc_type;
1968 }
1969
1970 for (v = val_chain; v; v = next)
1971 {
1972 next = value_next (v);
1973 if (v != b->val)
1974 value_free (v);
1975 }
1976
1977 /* If a software watchpoint is not watching any memory, then the
1978 above left it without any location set up. But,
1979 bpstat_stop_status requires a location to be able to report
1980 stops, so make sure there's at least a dummy one. */
1981 if (b->type == bp_watchpoint && b->loc == NULL)
1982 software_watchpoint_add_no_memory_location (b, frame_pspace);
1983 }
1984 else if (!within_current_scope)
1985 {
1986 printf_filtered (_("\
1987 Watchpoint %d deleted because the program has left the block\n\
1988 in which its expression is valid.\n"),
1989 b->number);
1990 watchpoint_del_at_next_stop (b);
1991 }
1992
1993 /* Restore the selected frame. */
1994 if (frame_saved)
1995 select_frame (frame_find_by_id (saved_frame_id));
1996 }
1997
1998
1999 /* Returns 1 iff breakpoint location should be
2000 inserted in the inferior. We don't differentiate the type of BL's owner
2001 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2002 breakpoint_ops is not defined, because in insert_bp_location,
2003 tracepoint's insert_location will not be called. */
2004 static int
2005 should_be_inserted (struct bp_location *bl)
2006 {
2007 if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
2008 return 0;
2009
2010 if (bl->owner->disposition == disp_del_at_next_stop)
2011 return 0;
2012
2013 if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
2014 return 0;
2015
2016 if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
2017 return 0;
2018
2019 /* This is set for example, when we're attached to the parent of a
2020 vfork, and have detached from the child. The child is running
2021 free, and we expect it to do an exec or exit, at which point the
2022 OS makes the parent schedulable again (and the target reports
2023 that the vfork is done). Until the child is done with the shared
2024 memory region, do not insert breakpoints in the parent, otherwise
2025 the child could still trip on the parent's breakpoints. Since
2026 the parent is blocked anyway, it won't miss any breakpoint. */
2027 if (bl->pspace->breakpoints_not_allowed)
2028 return 0;
2029
2030 /* Don't insert a breakpoint if we're trying to step past its
2031 location, except if the breakpoint is a single-step breakpoint,
2032 and the breakpoint's thread is the thread which is stepping past
2033 a breakpoint. */
2034 if ((bl->loc_type == bp_loc_software_breakpoint
2035 || bl->loc_type == bp_loc_hardware_breakpoint)
2036 && stepping_past_instruction_at (bl->pspace->aspace,
2037 bl->address)
2038 /* The single-step breakpoint may be inserted at the location
2039 we're trying to step if the instruction branches to itself.
2040 However, the instruction won't be executed at all and it may
2041 break the semantics of the instruction, for example, the
2042 instruction is a conditional branch or updates some flags.
2043 We can't fix it unless GDB is able to emulate the instruction
2044 or switch to displaced stepping. */
2045 && !(bl->owner->type == bp_single_step
2046 && thread_is_stepping_over_breakpoint (bl->owner->thread)))
2047 {
2048 if (debug_infrun)
2049 {
2050 fprintf_unfiltered (gdb_stdlog,
2051 "infrun: skipping breakpoint: "
2052 "stepping past insn at: %s\n",
2053 paddress (bl->gdbarch, bl->address));
2054 }
2055 return 0;
2056 }
2057
2058 /* Don't insert watchpoints if we're trying to step past the
2059 instruction that triggered one. */
2060 if ((bl->loc_type == bp_loc_hardware_watchpoint)
2061 && stepping_past_nonsteppable_watchpoint ())
2062 {
2063 if (debug_infrun)
2064 {
2065 fprintf_unfiltered (gdb_stdlog,
2066 "infrun: stepping past non-steppable watchpoint. "
2067 "skipping watchpoint at %s:%d\n",
2068 paddress (bl->gdbarch, bl->address),
2069 bl->length);
2070 }
2071 return 0;
2072 }
2073
2074 return 1;
2075 }
2076
2077 /* Same as should_be_inserted but does the check assuming
2078 that the location is not duplicated. */
2079
2080 static int
2081 unduplicated_should_be_inserted (struct bp_location *bl)
2082 {
2083 int result;
2084 const int save_duplicate = bl->duplicate;
2085
2086 bl->duplicate = 0;
2087 result = should_be_inserted (bl);
2088 bl->duplicate = save_duplicate;
2089 return result;
2090 }
2091
2092 /* Parses a conditional described by an expression COND into an
2093 agent expression bytecode suitable for evaluation
2094 by the bytecode interpreter. Return NULL if there was
2095 any error during parsing. */
2096
2097 static agent_expr_up
2098 parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
2099 {
2100 if (cond == NULL)
2101 return NULL;
2102
2103 agent_expr_up aexpr;
2104
2105 /* We don't want to stop processing, so catch any errors
2106 that may show up. */
2107 TRY
2108 {
2109 aexpr = gen_eval_for_expr (scope, cond);
2110 }
2111
2112 CATCH (ex, RETURN_MASK_ERROR)
2113 {
2114 /* If we got here, it means the condition could not be parsed to a valid
2115 bytecode expression and thus can't be evaluated on the target's side.
2116 It's no use iterating through the conditions. */
2117 }
2118 END_CATCH
2119
2120 /* We have a valid agent expression. */
2121 return aexpr;
2122 }
2123
2124 /* Based on location BL, create a list of breakpoint conditions to be
2125 passed on to the target. If we have duplicated locations with different
2126 conditions, we will add such conditions to the list. The idea is that the
2127 target will evaluate the list of conditions and will only notify GDB when
2128 one of them is true. */
2129
2130 static void
2131 build_target_condition_list (struct bp_location *bl)
2132 {
2133 struct bp_location **locp = NULL, **loc2p;
2134 int null_condition_or_parse_error = 0;
2135 int modified = bl->needs_update;
2136 struct bp_location *loc;
2137
2138 /* Release conditions left over from a previous insert. */
2139 bl->target_info.conditions.clear ();
2140
2141 /* This is only meaningful if the target is
2142 evaluating conditions and if the user has
2143 opted for condition evaluation on the target's
2144 side. */
2145 if (gdb_evaluates_breakpoint_condition_p ()
2146 || !target_supports_evaluation_of_breakpoint_conditions ())
2147 return;
2148
2149 /* Do a first pass to check for locations with no assigned
2150 conditions or conditions that fail to parse to a valid agent expression
2151 bytecode. If any of these happen, then it's no use to send conditions
2152 to the target since this location will always trigger and generate a
2153 response back to GDB. */
2154 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2155 {
2156 loc = (*loc2p);
2157 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2158 {
2159 if (modified)
2160 {
2161 /* Re-parse the conditions since something changed. In that
2162 case we already freed the condition bytecodes (see
2163 force_breakpoint_reinsertion). We just
2164 need to parse the condition to bytecodes again. */
2165 loc->cond_bytecode = parse_cond_to_aexpr (bl->address,
2166 loc->cond.get ());
2167 }
2168
2169 /* If we have a NULL bytecode expression, it means something
2170 went wrong or we have a null condition expression. */
2171 if (!loc->cond_bytecode)
2172 {
2173 null_condition_or_parse_error = 1;
2174 break;
2175 }
2176 }
2177 }
2178
2179 /* If any of these happened, it means we will have to evaluate the conditions
2180 for the location's address on gdb's side. It is no use keeping bytecodes
2181 for all the other duplicate locations, thus we free all of them here.
2182
2183 This is so we have a finer control over which locations' conditions are
2184 being evaluated by GDB or the remote stub. */
2185 if (null_condition_or_parse_error)
2186 {
2187 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2188 {
2189 loc = (*loc2p);
2190 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2191 {
2192 /* Only go as far as the first NULL bytecode is
2193 located. */
2194 if (!loc->cond_bytecode)
2195 return;
2196
2197 loc->cond_bytecode.reset ();
2198 }
2199 }
2200 }
2201
2202 /* No NULL conditions or failed bytecode generation. Build a condition list
2203 for this location's address. */
2204 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2205 {
2206 loc = (*loc2p);
2207 if (loc->cond
2208 && is_breakpoint (loc->owner)
2209 && loc->pspace->num == bl->pspace->num
2210 && loc->owner->enable_state == bp_enabled
2211 && loc->enabled)
2212 {
2213 /* Add the condition to the vector. This will be used later
2214 to send the conditions to the target. */
2215 bl->target_info.conditions.push_back (loc->cond_bytecode.get ());
2216 }
2217 }
2218
2219 return;
2220 }
2221
2222 /* Parses a command described by string CMD into an agent expression
2223 bytecode suitable for evaluation by the bytecode interpreter.
2224 Return NULL if there was any error during parsing. */
2225
2226 static agent_expr_up
2227 parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
2228 {
2229 const char *cmdrest;
2230 const char *format_start, *format_end;
2231 struct gdbarch *gdbarch = get_current_arch ();
2232
2233 if (cmd == NULL)
2234 return NULL;
2235
2236 cmdrest = cmd;
2237
2238 if (*cmdrest == ',')
2239 ++cmdrest;
2240 cmdrest = skip_spaces (cmdrest);
2241
2242 if (*cmdrest++ != '"')
2243 error (_("No format string following the location"));
2244
2245 format_start = cmdrest;
2246
2247 format_pieces fpieces (&cmdrest);
2248
2249 format_end = cmdrest;
2250
2251 if (*cmdrest++ != '"')
2252 error (_("Bad format string, non-terminated '\"'."));
2253
2254 cmdrest = skip_spaces (cmdrest);
2255
2256 if (!(*cmdrest == ',' || *cmdrest == '\0'))
2257 error (_("Invalid argument syntax"));
2258
2259 if (*cmdrest == ',')
2260 cmdrest++;
2261 cmdrest = skip_spaces (cmdrest);
2262
2263 /* For each argument, make an expression. */
2264
2265 std::vector<struct expression *> argvec;
2266 while (*cmdrest != '\0')
2267 {
2268 const char *cmd1;
2269
2270 cmd1 = cmdrest;
2271 expression_up expr = parse_exp_1 (&cmd1, scope, block_for_pc (scope), 1);
2272 argvec.push_back (expr.release ());
2273 cmdrest = cmd1;
2274 if (*cmdrest == ',')
2275 ++cmdrest;
2276 }
2277
2278 agent_expr_up aexpr;
2279
2280 /* We don't want to stop processing, so catch any errors
2281 that may show up. */
2282 TRY
2283 {
2284 aexpr = gen_printf (scope, gdbarch, 0, 0,
2285 format_start, format_end - format_start,
2286 argvec.size (), argvec.data ());
2287 }
2288 CATCH (ex, RETURN_MASK_ERROR)
2289 {
2290 /* If we got here, it means the command could not be parsed to a valid
2291 bytecode expression and thus can't be evaluated on the target's side.
2292 It's no use iterating through the other commands. */
2293 }
2294 END_CATCH
2295
2296 /* We have a valid agent expression, return it. */
2297 return aexpr;
2298 }
2299
2300 /* Based on location BL, create a list of breakpoint commands to be
2301 passed on to the target. If we have duplicated locations with
2302 different commands, we will add any such to the list. */
2303
2304 static void
2305 build_target_command_list (struct bp_location *bl)
2306 {
2307 struct bp_location **locp = NULL, **loc2p;
2308 int null_command_or_parse_error = 0;
2309 int modified = bl->needs_update;
2310 struct bp_location *loc;
2311
2312 /* Clear commands left over from a previous insert. */
2313 bl->target_info.tcommands.clear ();
2314
2315 if (!target_can_run_breakpoint_commands ())
2316 return;
2317
2318 /* For now, limit to agent-style dprintf breakpoints. */
2319 if (dprintf_style != dprintf_style_agent)
2320 return;
2321
2322 /* For now, if we have any duplicate location that isn't a dprintf,
2323 don't install the target-side commands, as that would make the
2324 breakpoint not be reported to the core, and we'd lose
2325 control. */
2326 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2327 {
2328 loc = (*loc2p);
2329 if (is_breakpoint (loc->owner)
2330 && loc->pspace->num == bl->pspace->num
2331 && loc->owner->type != bp_dprintf)
2332 return;
2333 }
2334
2335 /* Do a first pass to check for locations with no assigned
2336 conditions or conditions that fail to parse to a valid agent expression
2337 bytecode. If any of these happen, then it's no use to send conditions
2338 to the target since this location will always trigger and generate a
2339 response back to GDB. */
2340 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2341 {
2342 loc = (*loc2p);
2343 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2344 {
2345 if (modified)
2346 {
2347 /* Re-parse the commands since something changed. In that
2348 case we already freed the command bytecodes (see
2349 force_breakpoint_reinsertion). We just
2350 need to parse the command to bytecodes again. */
2351 loc->cmd_bytecode
2352 = parse_cmd_to_aexpr (bl->address,
2353 loc->owner->extra_string);
2354 }
2355
2356 /* If we have a NULL bytecode expression, it means something
2357 went wrong or we have a null command expression. */
2358 if (!loc->cmd_bytecode)
2359 {
2360 null_command_or_parse_error = 1;
2361 break;
2362 }
2363 }
2364 }
2365
2366 /* If anything failed, then we're not doing target-side commands,
2367 and so clean up. */
2368 if (null_command_or_parse_error)
2369 {
2370 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2371 {
2372 loc = (*loc2p);
2373 if (is_breakpoint (loc->owner)
2374 && loc->pspace->num == bl->pspace->num)
2375 {
2376 /* Only go as far as the first NULL bytecode is
2377 located. */
2378 if (loc->cmd_bytecode == NULL)
2379 return;
2380
2381 loc->cmd_bytecode.reset ();
2382 }
2383 }
2384 }
2385
2386 /* No NULL commands or failed bytecode generation. Build a command list
2387 for this location's address. */
2388 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2389 {
2390 loc = (*loc2p);
2391 if (loc->owner->extra_string
2392 && is_breakpoint (loc->owner)
2393 && loc->pspace->num == bl->pspace->num
2394 && loc->owner->enable_state == bp_enabled
2395 && loc->enabled)
2396 {
2397 /* Add the command to the vector. This will be used later
2398 to send the commands to the target. */
2399 bl->target_info.tcommands.push_back (loc->cmd_bytecode.get ());
2400 }
2401 }
2402
2403 bl->target_info.persist = 0;
2404 /* Maybe flag this location as persistent. */
2405 if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2406 bl->target_info.persist = 1;
2407 }
2408
2409 /* Return the kind of breakpoint on address *ADDR. Get the kind
2410 of breakpoint according to ADDR except single-step breakpoint.
2411 Get the kind of single-step breakpoint according to the current
2412 registers state. */
2413
2414 static int
2415 breakpoint_kind (struct bp_location *bl, CORE_ADDR *addr)
2416 {
2417 if (bl->owner->type == bp_single_step)
2418 {
2419 struct thread_info *thr = find_thread_global_id (bl->owner->thread);
2420 struct regcache *regcache;
2421
2422 regcache = get_thread_regcache (thr->ptid);
2423
2424 return gdbarch_breakpoint_kind_from_current_state (bl->gdbarch,
2425 regcache, addr);
2426 }
2427 else
2428 return gdbarch_breakpoint_kind_from_pc (bl->gdbarch, addr);
2429 }
2430
2431 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2432 location. Any error messages are printed to TMP_ERROR_STREAM; and
2433 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2434 Returns 0 for success, 1 if the bp_location type is not supported or
2435 -1 for failure.
2436
2437 NOTE drow/2003-09-09: This routine could be broken down to an
2438 object-style method for each breakpoint or catchpoint type. */
2439 static int
2440 insert_bp_location (struct bp_location *bl,
2441 struct ui_file *tmp_error_stream,
2442 int *disabled_breaks,
2443 int *hw_breakpoint_error,
2444 int *hw_bp_error_explained_already)
2445 {
2446 gdb_exception bp_excpt = exception_none;
2447
2448 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2449 return 0;
2450
2451 /* Note we don't initialize bl->target_info, as that wipes out
2452 the breakpoint location's shadow_contents if the breakpoint
2453 is still inserted at that location. This in turn breaks
2454 target_read_memory which depends on these buffers when
2455 a memory read is requested at the breakpoint location:
2456 Once the target_info has been wiped, we fail to see that
2457 we have a breakpoint inserted at that address and thus
2458 read the breakpoint instead of returning the data saved in
2459 the breakpoint location's shadow contents. */
2460 bl->target_info.reqstd_address = bl->address;
2461 bl->target_info.placed_address_space = bl->pspace->aspace;
2462 bl->target_info.length = bl->length;
2463
2464 /* When working with target-side conditions, we must pass all the conditions
2465 for the same breakpoint address down to the target since GDB will not
2466 insert those locations. With a list of breakpoint conditions, the target
2467 can decide when to stop and notify GDB. */
2468
2469 if (is_breakpoint (bl->owner))
2470 {
2471 build_target_condition_list (bl);
2472 build_target_command_list (bl);
2473 /* Reset the modification marker. */
2474 bl->needs_update = 0;
2475 }
2476
2477 if (bl->loc_type == bp_loc_software_breakpoint
2478 || bl->loc_type == bp_loc_hardware_breakpoint)
2479 {
2480 if (bl->owner->type != bp_hardware_breakpoint)
2481 {
2482 /* If the explicitly specified breakpoint type
2483 is not hardware breakpoint, check the memory map to see
2484 if the breakpoint address is in read only memory or not.
2485
2486 Two important cases are:
2487 - location type is not hardware breakpoint, memory
2488 is readonly. We change the type of the location to
2489 hardware breakpoint.
2490 - location type is hardware breakpoint, memory is
2491 read-write. This means we've previously made the
2492 location hardware one, but then the memory map changed,
2493 so we undo.
2494
2495 When breakpoints are removed, remove_breakpoints will use
2496 location types we've just set here, the only possible
2497 problem is that memory map has changed during running
2498 program, but it's not going to work anyway with current
2499 gdb. */
2500 struct mem_region *mr
2501 = lookup_mem_region (bl->target_info.reqstd_address);
2502
2503 if (mr)
2504 {
2505 if (automatic_hardware_breakpoints)
2506 {
2507 enum bp_loc_type new_type;
2508
2509 if (mr->attrib.mode != MEM_RW)
2510 new_type = bp_loc_hardware_breakpoint;
2511 else
2512 new_type = bp_loc_software_breakpoint;
2513
2514 if (new_type != bl->loc_type)
2515 {
2516 static int said = 0;
2517
2518 bl->loc_type = new_type;
2519 if (!said)
2520 {
2521 fprintf_filtered (gdb_stdout,
2522 _("Note: automatically using "
2523 "hardware breakpoints for "
2524 "read-only addresses.\n"));
2525 said = 1;
2526 }
2527 }
2528 }
2529 else if (bl->loc_type == bp_loc_software_breakpoint
2530 && mr->attrib.mode != MEM_RW)
2531 {
2532 fprintf_unfiltered (tmp_error_stream,
2533 _("Cannot insert breakpoint %d.\n"
2534 "Cannot set software breakpoint "
2535 "at read-only address %s\n"),
2536 bl->owner->number,
2537 paddress (bl->gdbarch, bl->address));
2538 return 1;
2539 }
2540 }
2541 }
2542
2543 /* First check to see if we have to handle an overlay. */
2544 if (overlay_debugging == ovly_off
2545 || bl->section == NULL
2546 || !(section_is_overlay (bl->section)))
2547 {
2548 /* No overlay handling: just set the breakpoint. */
2549 TRY
2550 {
2551 int val;
2552
2553 val = bl->owner->ops->insert_location (bl);
2554 if (val)
2555 bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2556 }
2557 CATCH (e, RETURN_MASK_ALL)
2558 {
2559 bp_excpt = e;
2560 }
2561 END_CATCH
2562 }
2563 else
2564 {
2565 /* This breakpoint is in an overlay section.
2566 Shall we set a breakpoint at the LMA? */
2567 if (!overlay_events_enabled)
2568 {
2569 /* Yes -- overlay event support is not active,
2570 so we must try to set a breakpoint at the LMA.
2571 This will not work for a hardware breakpoint. */
2572 if (bl->loc_type == bp_loc_hardware_breakpoint)
2573 warning (_("hardware breakpoint %d not supported in overlay!"),
2574 bl->owner->number);
2575 else
2576 {
2577 CORE_ADDR addr = overlay_unmapped_address (bl->address,
2578 bl->section);
2579 /* Set a software (trap) breakpoint at the LMA. */
2580 bl->overlay_target_info = bl->target_info;
2581 bl->overlay_target_info.reqstd_address = addr;
2582
2583 /* No overlay handling: just set the breakpoint. */
2584 TRY
2585 {
2586 int val;
2587
2588 bl->overlay_target_info.kind
2589 = breakpoint_kind (bl, &addr);
2590 bl->overlay_target_info.placed_address = addr;
2591 val = target_insert_breakpoint (bl->gdbarch,
2592 &bl->overlay_target_info);
2593 if (val)
2594 bp_excpt
2595 = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2596 }
2597 CATCH (e, RETURN_MASK_ALL)
2598 {
2599 bp_excpt = e;
2600 }
2601 END_CATCH
2602
2603 if (bp_excpt.reason != 0)
2604 fprintf_unfiltered (tmp_error_stream,
2605 "Overlay breakpoint %d "
2606 "failed: in ROM?\n",
2607 bl->owner->number);
2608 }
2609 }
2610 /* Shall we set a breakpoint at the VMA? */
2611 if (section_is_mapped (bl->section))
2612 {
2613 /* Yes. This overlay section is mapped into memory. */
2614 TRY
2615 {
2616 int val;
2617
2618 val = bl->owner->ops->insert_location (bl);
2619 if (val)
2620 bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2621 }
2622 CATCH (e, RETURN_MASK_ALL)
2623 {
2624 bp_excpt = e;
2625 }
2626 END_CATCH
2627 }
2628 else
2629 {
2630 /* No. This breakpoint will not be inserted.
2631 No error, but do not mark the bp as 'inserted'. */
2632 return 0;
2633 }
2634 }
2635
2636 if (bp_excpt.reason != 0)
2637 {
2638 /* Can't set the breakpoint. */
2639
2640 /* In some cases, we might not be able to insert a
2641 breakpoint in a shared library that has already been
2642 removed, but we have not yet processed the shlib unload
2643 event. Unfortunately, some targets that implement
2644 breakpoint insertion themselves can't tell why the
2645 breakpoint insertion failed (e.g., the remote target
2646 doesn't define error codes), so we must treat generic
2647 errors as memory errors. */
2648 if (bp_excpt.reason == RETURN_ERROR
2649 && (bp_excpt.error == GENERIC_ERROR
2650 || bp_excpt.error == MEMORY_ERROR)
2651 && bl->loc_type == bp_loc_software_breakpoint
2652 && (solib_name_from_address (bl->pspace, bl->address)
2653 || shared_objfile_contains_address_p (bl->pspace,
2654 bl->address)))
2655 {
2656 /* See also: disable_breakpoints_in_shlibs. */
2657 bl->shlib_disabled = 1;
2658 observer_notify_breakpoint_modified (bl->owner);
2659 if (!*disabled_breaks)
2660 {
2661 fprintf_unfiltered (tmp_error_stream,
2662 "Cannot insert breakpoint %d.\n",
2663 bl->owner->number);
2664 fprintf_unfiltered (tmp_error_stream,
2665 "Temporarily disabling shared "
2666 "library breakpoints:\n");
2667 }
2668 *disabled_breaks = 1;
2669 fprintf_unfiltered (tmp_error_stream,
2670 "breakpoint #%d\n", bl->owner->number);
2671 return 0;
2672 }
2673 else
2674 {
2675 if (bl->loc_type == bp_loc_hardware_breakpoint)
2676 {
2677 *hw_breakpoint_error = 1;
2678 *hw_bp_error_explained_already = bp_excpt.message != NULL;
2679 fprintf_unfiltered (tmp_error_stream,
2680 "Cannot insert hardware breakpoint %d%s",
2681 bl->owner->number,
2682 bp_excpt.message ? ":" : ".\n");
2683 if (bp_excpt.message != NULL)
2684 fprintf_unfiltered (tmp_error_stream, "%s.\n",
2685 bp_excpt.message);
2686 }
2687 else
2688 {
2689 if (bp_excpt.message == NULL)
2690 {
2691 std::string message
2692 = memory_error_message (TARGET_XFER_E_IO,
2693 bl->gdbarch, bl->address);
2694
2695 fprintf_unfiltered (tmp_error_stream,
2696 "Cannot insert breakpoint %d.\n"
2697 "%s\n",
2698 bl->owner->number, message.c_str ());
2699 }
2700 else
2701 {
2702 fprintf_unfiltered (tmp_error_stream,
2703 "Cannot insert breakpoint %d: %s\n",
2704 bl->owner->number,
2705 bp_excpt.message);
2706 }
2707 }
2708 return 1;
2709
2710 }
2711 }
2712 else
2713 bl->inserted = 1;
2714
2715 return 0;
2716 }
2717
2718 else if (bl->loc_type == bp_loc_hardware_watchpoint
2719 /* NOTE drow/2003-09-08: This state only exists for removing
2720 watchpoints. It's not clear that it's necessary... */
2721 && bl->owner->disposition != disp_del_at_next_stop)
2722 {
2723 int val;
2724
2725 gdb_assert (bl->owner->ops != NULL
2726 && bl->owner->ops->insert_location != NULL);
2727
2728 val = bl->owner->ops->insert_location (bl);
2729
2730 /* If trying to set a read-watchpoint, and it turns out it's not
2731 supported, try emulating one with an access watchpoint. */
2732 if (val == 1 && bl->watchpoint_type == hw_read)
2733 {
2734 struct bp_location *loc, **loc_temp;
2735
2736 /* But don't try to insert it, if there's already another
2737 hw_access location that would be considered a duplicate
2738 of this one. */
2739 ALL_BP_LOCATIONS (loc, loc_temp)
2740 if (loc != bl
2741 && loc->watchpoint_type == hw_access
2742 && watchpoint_locations_match (bl, loc))
2743 {
2744 bl->duplicate = 1;
2745 bl->inserted = 1;
2746 bl->target_info = loc->target_info;
2747 bl->watchpoint_type = hw_access;
2748 val = 0;
2749 break;
2750 }
2751
2752 if (val == 1)
2753 {
2754 bl->watchpoint_type = hw_access;
2755 val = bl->owner->ops->insert_location (bl);
2756
2757 if (val)
2758 /* Back to the original value. */
2759 bl->watchpoint_type = hw_read;
2760 }
2761 }
2762
2763 bl->inserted = (val == 0);
2764 }
2765
2766 else if (bl->owner->type == bp_catchpoint)
2767 {
2768 int val;
2769
2770 gdb_assert (bl->owner->ops != NULL
2771 && bl->owner->ops->insert_location != NULL);
2772
2773 val = bl->owner->ops->insert_location (bl);
2774 if (val)
2775 {
2776 bl->owner->enable_state = bp_disabled;
2777
2778 if (val == 1)
2779 warning (_("\
2780 Error inserting catchpoint %d: Your system does not support this type\n\
2781 of catchpoint."), bl->owner->number);
2782 else
2783 warning (_("Error inserting catchpoint %d."), bl->owner->number);
2784 }
2785
2786 bl->inserted = (val == 0);
2787
2788 /* We've already printed an error message if there was a problem
2789 inserting this catchpoint, and we've disabled the catchpoint,
2790 so just return success. */
2791 return 0;
2792 }
2793
2794 return 0;
2795 }
2796
2797 /* This function is called when program space PSPACE is about to be
2798 deleted. It takes care of updating breakpoints to not reference
2799 PSPACE anymore. */
2800
2801 void
2802 breakpoint_program_space_exit (struct program_space *pspace)
2803 {
2804 struct breakpoint *b, *b_temp;
2805 struct bp_location *loc, **loc_temp;
2806
2807 /* Remove any breakpoint that was set through this program space. */
2808 ALL_BREAKPOINTS_SAFE (b, b_temp)
2809 {
2810 if (b->pspace == pspace)
2811 delete_breakpoint (b);
2812 }
2813
2814 /* Breakpoints set through other program spaces could have locations
2815 bound to PSPACE as well. Remove those. */
2816 ALL_BP_LOCATIONS (loc, loc_temp)
2817 {
2818 struct bp_location *tmp;
2819
2820 if (loc->pspace == pspace)
2821 {
2822 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2823 if (loc->owner->loc == loc)
2824 loc->owner->loc = loc->next;
2825 else
2826 for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
2827 if (tmp->next == loc)
2828 {
2829 tmp->next = loc->next;
2830 break;
2831 }
2832 }
2833 }
2834
2835 /* Now update the global location list to permanently delete the
2836 removed locations above. */
2837 update_global_location_list (UGLL_DONT_INSERT);
2838 }
2839
2840 /* Make sure all breakpoints are inserted in inferior.
2841 Throws exception on any error.
2842 A breakpoint that is already inserted won't be inserted
2843 again, so calling this function twice is safe. */
2844 void
2845 insert_breakpoints (void)
2846 {
2847 struct breakpoint *bpt;
2848
2849 ALL_BREAKPOINTS (bpt)
2850 if (is_hardware_watchpoint (bpt))
2851 {
2852 struct watchpoint *w = (struct watchpoint *) bpt;
2853
2854 update_watchpoint (w, 0 /* don't reparse. */);
2855 }
2856
2857 /* Updating watchpoints creates new locations, so update the global
2858 location list. Explicitly tell ugll to insert locations and
2859 ignore breakpoints_always_inserted_mode. */
2860 update_global_location_list (UGLL_INSERT);
2861 }
2862
2863 /* Invoke CALLBACK for each of bp_location. */
2864
2865 void
2866 iterate_over_bp_locations (walk_bp_location_callback callback)
2867 {
2868 struct bp_location *loc, **loc_tmp;
2869
2870 ALL_BP_LOCATIONS (loc, loc_tmp)
2871 {
2872 callback (loc, NULL);
2873 }
2874 }
2875
2876 /* This is used when we need to synch breakpoint conditions between GDB and the
2877 target. It is the case with deleting and disabling of breakpoints when using
2878 always-inserted mode. */
2879
2880 static void
2881 update_inserted_breakpoint_locations (void)
2882 {
2883 struct bp_location *bl, **blp_tmp;
2884 int error_flag = 0;
2885 int val = 0;
2886 int disabled_breaks = 0;
2887 int hw_breakpoint_error = 0;
2888 int hw_bp_details_reported = 0;
2889
2890 string_file tmp_error_stream;
2891
2892 /* Explicitly mark the warning -- this will only be printed if
2893 there was an error. */
2894 tmp_error_stream.puts ("Warning:\n");
2895
2896 scoped_restore_current_pspace_and_thread restore_pspace_thread;
2897
2898 ALL_BP_LOCATIONS (bl, blp_tmp)
2899 {
2900 /* We only want to update software breakpoints and hardware
2901 breakpoints. */
2902 if (!is_breakpoint (bl->owner))
2903 continue;
2904
2905 /* We only want to update locations that are already inserted
2906 and need updating. This is to avoid unwanted insertion during
2907 deletion of breakpoints. */
2908 if (!bl->inserted || (bl->inserted && !bl->needs_update))
2909 continue;
2910
2911 switch_to_program_space_and_thread (bl->pspace);
2912
2913 /* For targets that support global breakpoints, there's no need
2914 to select an inferior to insert breakpoint to. In fact, even
2915 if we aren't attached to any process yet, we should still
2916 insert breakpoints. */
2917 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2918 && ptid_equal (inferior_ptid, null_ptid))
2919 continue;
2920
2921 val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
2922 &hw_breakpoint_error, &hw_bp_details_reported);
2923 if (val)
2924 error_flag = val;
2925 }
2926
2927 if (error_flag)
2928 {
2929 target_terminal::ours_for_output ();
2930 error_stream (tmp_error_stream);
2931 }
2932 }
2933
2934 /* Used when starting or continuing the program. */
2935
2936 static void
2937 insert_breakpoint_locations (void)
2938 {
2939 struct breakpoint *bpt;
2940 struct bp_location *bl, **blp_tmp;
2941 int error_flag = 0;
2942 int val = 0;
2943 int disabled_breaks = 0;
2944 int hw_breakpoint_error = 0;
2945 int hw_bp_error_explained_already = 0;
2946
2947 string_file tmp_error_stream;
2948
2949 /* Explicitly mark the warning -- this will only be printed if
2950 there was an error. */
2951 tmp_error_stream.puts ("Warning:\n");
2952
2953 scoped_restore_current_pspace_and_thread restore_pspace_thread;
2954
2955 ALL_BP_LOCATIONS (bl, blp_tmp)
2956 {
2957 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2958 continue;
2959
2960 /* There is no point inserting thread-specific breakpoints if
2961 the thread no longer exists. ALL_BP_LOCATIONS bp_location
2962 has BL->OWNER always non-NULL. */
2963 if (bl->owner->thread != -1
2964 && !valid_global_thread_id (bl->owner->thread))
2965 continue;
2966
2967 switch_to_program_space_and_thread (bl->pspace);
2968
2969 /* For targets that support global breakpoints, there's no need
2970 to select an inferior to insert breakpoint to. In fact, even
2971 if we aren't attached to any process yet, we should still
2972 insert breakpoints. */
2973 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2974 && ptid_equal (inferior_ptid, null_ptid))
2975 continue;
2976
2977 val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
2978 &hw_breakpoint_error, &hw_bp_error_explained_already);
2979 if (val)
2980 error_flag = val;
2981 }
2982
2983 /* If we failed to insert all locations of a watchpoint, remove
2984 them, as half-inserted watchpoint is of limited use. */
2985 ALL_BREAKPOINTS (bpt)
2986 {
2987 int some_failed = 0;
2988 struct bp_location *loc;
2989
2990 if (!is_hardware_watchpoint (bpt))
2991 continue;
2992
2993 if (!breakpoint_enabled (bpt))
2994 continue;
2995
2996 if (bpt->disposition == disp_del_at_next_stop)
2997 continue;
2998
2999 for (loc = bpt->loc; loc; loc = loc->next)
3000 if (!loc->inserted && should_be_inserted (loc))
3001 {
3002 some_failed = 1;
3003 break;
3004 }
3005 if (some_failed)
3006 {
3007 for (loc = bpt->loc; loc; loc = loc->next)
3008 if (loc->inserted)
3009 remove_breakpoint (loc);
3010
3011 hw_breakpoint_error = 1;
3012 tmp_error_stream.printf ("Could not insert "
3013 "hardware watchpoint %d.\n",
3014 bpt->number);
3015 error_flag = -1;
3016 }
3017 }
3018
3019 if (error_flag)
3020 {
3021 /* If a hardware breakpoint or watchpoint was inserted, add a
3022 message about possibly exhausted resources. */
3023 if (hw_breakpoint_error && !hw_bp_error_explained_already)
3024 {
3025 tmp_error_stream.printf ("Could not insert hardware breakpoints:\n\
3026 You may have requested too many hardware breakpoints/watchpoints.\n");
3027 }
3028 target_terminal::ours_for_output ();
3029 error_stream (tmp_error_stream);
3030 }
3031 }
3032
3033 /* Used when the program stops.
3034 Returns zero if successful, or non-zero if there was a problem
3035 removing a breakpoint location. */
3036
3037 int
3038 remove_breakpoints (void)
3039 {
3040 struct bp_location *bl, **blp_tmp;
3041 int val = 0;
3042
3043 ALL_BP_LOCATIONS (bl, blp_tmp)
3044 {
3045 if (bl->inserted && !is_tracepoint (bl->owner))
3046 val |= remove_breakpoint (bl);
3047 }
3048 return val;
3049 }
3050
3051 /* When a thread exits, remove breakpoints that are related to
3052 that thread. */
3053
3054 static void
3055 remove_threaded_breakpoints (struct thread_info *tp, int silent)
3056 {
3057 struct breakpoint *b, *b_tmp;
3058
3059 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3060 {
3061 if (b->thread == tp->global_num && user_breakpoint_p (b))
3062 {
3063 b->disposition = disp_del_at_next_stop;
3064
3065 printf_filtered (_("\
3066 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3067 b->number, print_thread_id (tp));
3068
3069 /* Hide it from the user. */
3070 b->number = 0;
3071 }
3072 }
3073 }
3074
3075 /* Remove breakpoints of process PID. */
3076
3077 int
3078 remove_breakpoints_pid (int pid)
3079 {
3080 struct bp_location *bl, **blp_tmp;
3081 int val;
3082 struct inferior *inf = find_inferior_pid (pid);
3083
3084 ALL_BP_LOCATIONS (bl, blp_tmp)
3085 {
3086 if (bl->pspace != inf->pspace)
3087 continue;
3088
3089 if (bl->inserted && !bl->target_info.persist)
3090 {
3091 val = remove_breakpoint (bl);
3092 if (val != 0)
3093 return val;
3094 }
3095 }
3096 return 0;
3097 }
3098
3099 static int internal_breakpoint_number = -1;
3100
3101 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3102 If INTERNAL is non-zero, the breakpoint number will be populated
3103 from internal_breakpoint_number and that variable decremented.
3104 Otherwise the breakpoint number will be populated from
3105 breakpoint_count and that value incremented. Internal breakpoints
3106 do not set the internal var bpnum. */
3107 static void
3108 set_breakpoint_number (int internal, struct breakpoint *b)
3109 {
3110 if (internal)
3111 b->number = internal_breakpoint_number--;
3112 else
3113 {
3114 set_breakpoint_count (breakpoint_count + 1);
3115 b->number = breakpoint_count;
3116 }
3117 }
3118
3119 static struct breakpoint *
3120 create_internal_breakpoint (struct gdbarch *gdbarch,
3121 CORE_ADDR address, enum bptype type,
3122 const struct breakpoint_ops *ops)
3123 {
3124 symtab_and_line sal;
3125 sal.pc = address;
3126 sal.section = find_pc_overlay (sal.pc);
3127 sal.pspace = current_program_space;
3128
3129 breakpoint *b = set_raw_breakpoint (gdbarch, sal, type, ops);
3130 b->number = internal_breakpoint_number--;
3131 b->disposition = disp_donttouch;
3132
3133 return b;
3134 }
3135
3136 static const char *const longjmp_names[] =
3137 {
3138 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3139 };
3140 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3141
3142 /* Per-objfile data private to breakpoint.c. */
3143 struct breakpoint_objfile_data
3144 {
3145 /* Minimal symbol for "_ovly_debug_event" (if any). */
3146 struct bound_minimal_symbol overlay_msym {};
3147
3148 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3149 struct bound_minimal_symbol longjmp_msym[NUM_LONGJMP_NAMES] {};
3150
3151 /* True if we have looked for longjmp probes. */
3152 int longjmp_searched = 0;
3153
3154 /* SystemTap probe points for longjmp (if any). These are non-owning
3155 references. */
3156 std::vector<probe *> longjmp_probes;
3157
3158 /* Minimal symbol for "std::terminate()" (if any). */
3159 struct bound_minimal_symbol terminate_msym {};
3160
3161 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3162 struct bound_minimal_symbol exception_msym {};
3163
3164 /* True if we have looked for exception probes. */
3165 int exception_searched = 0;
3166
3167 /* SystemTap probe points for unwinding (if any). These are non-owning
3168 references. */
3169 std::vector<probe *> exception_probes;
3170 };
3171
3172 static const struct objfile_data *breakpoint_objfile_key;
3173
3174 /* Minimal symbol not found sentinel. */
3175 static struct minimal_symbol msym_not_found;
3176
3177 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3178
3179 static int
3180 msym_not_found_p (const struct minimal_symbol *msym)
3181 {
3182 return msym == &msym_not_found;
3183 }
3184
3185 /* Return per-objfile data needed by breakpoint.c.
3186 Allocate the data if necessary. */
3187
3188 static struct breakpoint_objfile_data *
3189 get_breakpoint_objfile_data (struct objfile *objfile)
3190 {
3191 struct breakpoint_objfile_data *bp_objfile_data;
3192
3193 bp_objfile_data = ((struct breakpoint_objfile_data *)
3194 objfile_data (objfile, breakpoint_objfile_key));
3195 if (bp_objfile_data == NULL)
3196 {
3197 bp_objfile_data = new breakpoint_objfile_data ();
3198 set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
3199 }
3200 return bp_objfile_data;
3201 }
3202
3203 static void
3204 free_breakpoint_objfile_data (struct objfile *obj, void *data)
3205 {
3206 struct breakpoint_objfile_data *bp_objfile_data
3207 = (struct breakpoint_objfile_data *) data;
3208
3209 delete bp_objfile_data;
3210 }
3211
3212 static void
3213 create_overlay_event_breakpoint (void)
3214 {
3215 struct objfile *objfile;
3216 const char *const func_name = "_ovly_debug_event";
3217
3218 ALL_OBJFILES (objfile)
3219 {
3220 struct breakpoint *b;
3221 struct breakpoint_objfile_data *bp_objfile_data;
3222 CORE_ADDR addr;
3223 struct explicit_location explicit_loc;
3224
3225 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3226
3227 if (msym_not_found_p (bp_objfile_data->overlay_msym.minsym))
3228 continue;
3229
3230 if (bp_objfile_data->overlay_msym.minsym == NULL)
3231 {
3232 struct bound_minimal_symbol m;
3233
3234 m = lookup_minimal_symbol_text (func_name, objfile);
3235 if (m.minsym == NULL)
3236 {
3237 /* Avoid future lookups in this objfile. */
3238 bp_objfile_data->overlay_msym.minsym = &msym_not_found;
3239 continue;
3240 }
3241 bp_objfile_data->overlay_msym = m;
3242 }
3243
3244 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
3245 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3246 bp_overlay_event,
3247 &internal_breakpoint_ops);
3248 initialize_explicit_location (&explicit_loc);
3249 explicit_loc.function_name = ASTRDUP (func_name);
3250 b->location = new_explicit_location (&explicit_loc);
3251
3252 if (overlay_debugging == ovly_auto)
3253 {
3254 b->enable_state = bp_enabled;
3255 overlay_events_enabled = 1;
3256 }
3257 else
3258 {
3259 b->enable_state = bp_disabled;
3260 overlay_events_enabled = 0;
3261 }
3262 }
3263 }
3264
3265 static void
3266 create_longjmp_master_breakpoint (void)
3267 {
3268 struct program_space *pspace;
3269
3270 scoped_restore_current_program_space restore_pspace;
3271
3272 ALL_PSPACES (pspace)
3273 {
3274 struct objfile *objfile;
3275
3276 set_current_program_space (pspace);
3277
3278 ALL_OBJFILES (objfile)
3279 {
3280 int i;
3281 struct gdbarch *gdbarch;
3282 struct breakpoint_objfile_data *bp_objfile_data;
3283
3284 gdbarch = get_objfile_arch (objfile);
3285
3286 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3287
3288 if (!bp_objfile_data->longjmp_searched)
3289 {
3290 std::vector<probe *> ret
3291 = find_probes_in_objfile (objfile, "libc", "longjmp");
3292
3293 if (!ret.empty ())
3294 {
3295 /* We are only interested in checking one element. */
3296 probe *p = ret[0];
3297
3298 if (!p->can_evaluate_arguments ())
3299 {
3300 /* We cannot use the probe interface here, because it does
3301 not know how to evaluate arguments. */
3302 ret.clear ();
3303 }
3304 }
3305 bp_objfile_data->longjmp_probes = ret;
3306 bp_objfile_data->longjmp_searched = 1;
3307 }
3308
3309 if (!bp_objfile_data->longjmp_probes.empty ())
3310 {
3311 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3312
3313 for (probe *p : bp_objfile_data->longjmp_probes)
3314 {
3315 struct breakpoint *b;
3316
3317 b = create_internal_breakpoint (gdbarch,
3318 p->get_relocated_address (objfile),
3319 bp_longjmp_master,
3320 &internal_breakpoint_ops);
3321 b->location = new_probe_location ("-probe-stap libc:longjmp");
3322 b->enable_state = bp_disabled;
3323 }
3324
3325 continue;
3326 }
3327
3328 if (!gdbarch_get_longjmp_target_p (gdbarch))
3329 continue;
3330
3331 for (i = 0; i < NUM_LONGJMP_NAMES; i++)
3332 {
3333 struct breakpoint *b;
3334 const char *func_name;
3335 CORE_ADDR addr;
3336 struct explicit_location explicit_loc;
3337
3338 if (msym_not_found_p (bp_objfile_data->longjmp_msym[i].minsym))
3339 continue;
3340
3341 func_name = longjmp_names[i];
3342 if (bp_objfile_data->longjmp_msym[i].minsym == NULL)
3343 {
3344 struct bound_minimal_symbol m;
3345
3346 m = lookup_minimal_symbol_text (func_name, objfile);
3347 if (m.minsym == NULL)
3348 {
3349 /* Prevent future lookups in this objfile. */
3350 bp_objfile_data->longjmp_msym[i].minsym = &msym_not_found;
3351 continue;
3352 }
3353 bp_objfile_data->longjmp_msym[i] = m;
3354 }
3355
3356 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
3357 b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3358 &internal_breakpoint_ops);
3359 initialize_explicit_location (&explicit_loc);
3360 explicit_loc.function_name = ASTRDUP (func_name);
3361 b->location = new_explicit_location (&explicit_loc);
3362 b->enable_state = bp_disabled;
3363 }
3364 }
3365 }
3366 }
3367
3368 /* Create a master std::terminate breakpoint. */
3369 static void
3370 create_std_terminate_master_breakpoint (void)
3371 {
3372 struct program_space *pspace;
3373 const char *const func_name = "std::terminate()";
3374
3375 scoped_restore_current_program_space restore_pspace;
3376
3377 ALL_PSPACES (pspace)
3378 {
3379 struct objfile *objfile;
3380 CORE_ADDR addr;
3381
3382 set_current_program_space (pspace);
3383
3384 ALL_OBJFILES (objfile)
3385 {
3386 struct breakpoint *b;
3387 struct breakpoint_objfile_data *bp_objfile_data;
3388 struct explicit_location explicit_loc;
3389
3390 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3391
3392 if (msym_not_found_p (bp_objfile_data->terminate_msym.minsym))
3393 continue;
3394
3395 if (bp_objfile_data->terminate_msym.minsym == NULL)
3396 {
3397 struct bound_minimal_symbol m;
3398
3399 m = lookup_minimal_symbol (func_name, NULL, objfile);
3400 if (m.minsym == NULL || (MSYMBOL_TYPE (m.minsym) != mst_text
3401 && MSYMBOL_TYPE (m.minsym) != mst_file_text))
3402 {
3403 /* Prevent future lookups in this objfile. */
3404 bp_objfile_data->terminate_msym.minsym = &msym_not_found;
3405 continue;
3406 }
3407 bp_objfile_data->terminate_msym = m;
3408 }
3409
3410 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
3411 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3412 bp_std_terminate_master,
3413 &internal_breakpoint_ops);
3414 initialize_explicit_location (&explicit_loc);
3415 explicit_loc.function_name = ASTRDUP (func_name);
3416 b->location = new_explicit_location (&explicit_loc);
3417 b->enable_state = bp_disabled;
3418 }
3419 }
3420 }
3421
3422 /* Install a master breakpoint on the unwinder's debug hook. */
3423
3424 static void
3425 create_exception_master_breakpoint (void)
3426 {
3427 struct objfile *objfile;
3428 const char *const func_name = "_Unwind_DebugHook";
3429
3430 ALL_OBJFILES (objfile)
3431 {
3432 struct breakpoint *b;
3433 struct gdbarch *gdbarch;
3434 struct breakpoint_objfile_data *bp_objfile_data;
3435 CORE_ADDR addr;
3436 struct explicit_location explicit_loc;
3437
3438 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3439
3440 /* We prefer the SystemTap probe point if it exists. */
3441 if (!bp_objfile_data->exception_searched)
3442 {
3443 std::vector<probe *> ret
3444 = find_probes_in_objfile (objfile, "libgcc", "unwind");
3445
3446 if (!ret.empty ())
3447 {
3448 /* We are only interested in checking one element. */
3449 probe *p = ret[0];
3450
3451 if (!p->can_evaluate_arguments ())
3452 {
3453 /* We cannot use the probe interface here, because it does
3454 not know how to evaluate arguments. */
3455 ret.clear ();
3456 }
3457 }
3458 bp_objfile_data->exception_probes = ret;
3459 bp_objfile_data->exception_searched = 1;
3460 }
3461
3462 if (!bp_objfile_data->exception_probes.empty ())
3463 {
3464 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3465
3466 for (probe *p : bp_objfile_data->exception_probes)
3467 {
3468 struct breakpoint *b;
3469
3470 b = create_internal_breakpoint (gdbarch,
3471 p->get_relocated_address (objfile),
3472 bp_exception_master,
3473 &internal_breakpoint_ops);
3474 b->location = new_probe_location ("-probe-stap libgcc:unwind");
3475 b->enable_state = bp_disabled;
3476 }
3477
3478 continue;
3479 }
3480
3481 /* Otherwise, try the hook function. */
3482
3483 if (msym_not_found_p (bp_objfile_data->exception_msym.minsym))
3484 continue;
3485
3486 gdbarch = get_objfile_arch (objfile);
3487
3488 if (bp_objfile_data->exception_msym.minsym == NULL)
3489 {
3490 struct bound_minimal_symbol debug_hook;
3491
3492 debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3493 if (debug_hook.minsym == NULL)
3494 {
3495 bp_objfile_data->exception_msym.minsym = &msym_not_found;
3496 continue;
3497 }
3498
3499 bp_objfile_data->exception_msym = debug_hook;
3500 }
3501
3502 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
3503 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3504 &current_target);
3505 b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3506 &internal_breakpoint_ops);
3507 initialize_explicit_location (&explicit_loc);
3508 explicit_loc.function_name = ASTRDUP (func_name);
3509 b->location = new_explicit_location (&explicit_loc);
3510 b->enable_state = bp_disabled;
3511 }
3512 }
3513
3514 /* Does B have a location spec? */
3515
3516 static int
3517 breakpoint_event_location_empty_p (const struct breakpoint *b)
3518 {
3519 return b->location != NULL && event_location_empty_p (b->location.get ());
3520 }
3521
3522 void
3523 update_breakpoints_after_exec (void)
3524 {
3525 struct breakpoint *b, *b_tmp;
3526 struct bp_location *bploc, **bplocp_tmp;
3527
3528 /* We're about to delete breakpoints from GDB's lists. If the
3529 INSERTED flag is true, GDB will try to lift the breakpoints by
3530 writing the breakpoints' "shadow contents" back into memory. The
3531 "shadow contents" are NOT valid after an exec, so GDB should not
3532 do that. Instead, the target is responsible from marking
3533 breakpoints out as soon as it detects an exec. We don't do that
3534 here instead, because there may be other attempts to delete
3535 breakpoints after detecting an exec and before reaching here. */
3536 ALL_BP_LOCATIONS (bploc, bplocp_tmp)
3537 if (bploc->pspace == current_program_space)
3538 gdb_assert (!bploc->inserted);
3539
3540 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3541 {
3542 if (b->pspace != current_program_space)
3543 continue;
3544
3545 /* Solib breakpoints must be explicitly reset after an exec(). */
3546 if (b->type == bp_shlib_event)
3547 {
3548 delete_breakpoint (b);
3549 continue;
3550 }
3551
3552 /* JIT breakpoints must be explicitly reset after an exec(). */
3553 if (b->type == bp_jit_event)
3554 {
3555 delete_breakpoint (b);
3556 continue;
3557 }
3558
3559 /* Thread event breakpoints must be set anew after an exec(),
3560 as must overlay event and longjmp master breakpoints. */
3561 if (b->type == bp_thread_event || b->type == bp_overlay_event
3562 || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3563 || b->type == bp_exception_master)
3564 {
3565 delete_breakpoint (b);
3566 continue;
3567 }
3568
3569 /* Step-resume breakpoints are meaningless after an exec(). */
3570 if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
3571 {
3572 delete_breakpoint (b);
3573 continue;
3574 }
3575
3576 /* Just like single-step breakpoints. */
3577 if (b->type == bp_single_step)
3578 {
3579 delete_breakpoint (b);
3580 continue;
3581 }
3582
3583 /* Longjmp and longjmp-resume breakpoints are also meaningless
3584 after an exec. */
3585 if (b->type == bp_longjmp || b->type == bp_longjmp_resume
3586 || b->type == bp_longjmp_call_dummy
3587 || b->type == bp_exception || b->type == bp_exception_resume)
3588 {
3589 delete_breakpoint (b);
3590 continue;
3591 }
3592
3593 if (b->type == bp_catchpoint)
3594 {
3595 /* For now, none of the bp_catchpoint breakpoints need to
3596 do anything at this point. In the future, if some of
3597 the catchpoints need to something, we will need to add
3598 a new method, and call this method from here. */
3599 continue;
3600 }
3601
3602 /* bp_finish is a special case. The only way we ought to be able
3603 to see one of these when an exec() has happened, is if the user
3604 caught a vfork, and then said "finish". Ordinarily a finish just
3605 carries them to the call-site of the current callee, by setting
3606 a temporary bp there and resuming. But in this case, the finish
3607 will carry them entirely through the vfork & exec.
3608
3609 We don't want to allow a bp_finish to remain inserted now. But
3610 we can't safely delete it, 'cause finish_command has a handle to
3611 the bp on a bpstat, and will later want to delete it. There's a
3612 chance (and I've seen it happen) that if we delete the bp_finish
3613 here, that its storage will get reused by the time finish_command
3614 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3615 We really must allow finish_command to delete a bp_finish.
3616
3617 In the absence of a general solution for the "how do we know
3618 it's safe to delete something others may have handles to?"
3619 problem, what we'll do here is just uninsert the bp_finish, and
3620 let finish_command delete it.
3621
3622 (We know the bp_finish is "doomed" in the sense that it's
3623 momentary, and will be deleted as soon as finish_command sees
3624 the inferior stopped. So it doesn't matter that the bp's
3625 address is probably bogus in the new a.out, unlike e.g., the
3626 solib breakpoints.) */
3627
3628 if (b->type == bp_finish)
3629 {
3630 continue;
3631 }
3632
3633 /* Without a symbolic address, we have little hope of the
3634 pre-exec() address meaning the same thing in the post-exec()
3635 a.out. */
3636 if (breakpoint_event_location_empty_p (b))
3637 {
3638 delete_breakpoint (b);
3639 continue;
3640 }
3641 }
3642 }
3643
3644 int
3645 detach_breakpoints (ptid_t ptid)
3646 {
3647 struct bp_location *bl, **blp_tmp;
3648 int val = 0;
3649 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
3650 struct inferior *inf = current_inferior ();
3651
3652 if (ptid_get_pid (ptid) == ptid_get_pid (inferior_ptid))
3653 error (_("Cannot detach breakpoints of inferior_ptid"));
3654
3655 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3656 inferior_ptid = ptid;
3657 ALL_BP_LOCATIONS (bl, blp_tmp)
3658 {
3659 if (bl->pspace != inf->pspace)
3660 continue;
3661
3662 /* This function must physically remove breakpoints locations
3663 from the specified ptid, without modifying the breakpoint
3664 package's state. Locations of type bp_loc_other are only
3665 maintained at GDB side. So, there is no need to remove
3666 these bp_loc_other locations. Moreover, removing these
3667 would modify the breakpoint package's state. */
3668 if (bl->loc_type == bp_loc_other)
3669 continue;
3670
3671 if (bl->inserted)
3672 val |= remove_breakpoint_1 (bl, DETACH_BREAKPOINT);
3673 }
3674
3675 return val;
3676 }
3677
3678 /* Remove the breakpoint location BL from the current address space.
3679 Note that this is used to detach breakpoints from a child fork.
3680 When we get here, the child isn't in the inferior list, and neither
3681 do we have objects to represent its address space --- we should
3682 *not* look at bl->pspace->aspace here. */
3683
3684 static int
3685 remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason)
3686 {
3687 int val;
3688
3689 /* BL is never in moribund_locations by our callers. */
3690 gdb_assert (bl->owner != NULL);
3691
3692 /* The type of none suggests that owner is actually deleted.
3693 This should not ever happen. */
3694 gdb_assert (bl->owner->type != bp_none);
3695
3696 if (bl->loc_type == bp_loc_software_breakpoint
3697 || bl->loc_type == bp_loc_hardware_breakpoint)
3698 {
3699 /* "Normal" instruction breakpoint: either the standard
3700 trap-instruction bp (bp_breakpoint), or a
3701 bp_hardware_breakpoint. */
3702
3703 /* First check to see if we have to handle an overlay. */
3704 if (overlay_debugging == ovly_off
3705 || bl->section == NULL
3706 || !(section_is_overlay (bl->section)))
3707 {
3708 /* No overlay handling: just remove the breakpoint. */
3709
3710 /* If we're trying to uninsert a memory breakpoint that we
3711 know is set in a dynamic object that is marked
3712 shlib_disabled, then either the dynamic object was
3713 removed with "remove-symbol-file" or with
3714 "nosharedlibrary". In the former case, we don't know
3715 whether another dynamic object might have loaded over the
3716 breakpoint's address -- the user might well let us know
3717 about it next with add-symbol-file (the whole point of
3718 add-symbol-file is letting the user manually maintain a
3719 list of dynamically loaded objects). If we have the
3720 breakpoint's shadow memory, that is, this is a software
3721 breakpoint managed by GDB, check whether the breakpoint
3722 is still inserted in memory, to avoid overwriting wrong
3723 code with stale saved shadow contents. Note that HW
3724 breakpoints don't have shadow memory, as they're
3725 implemented using a mechanism that is not dependent on
3726 being able to modify the target's memory, and as such
3727 they should always be removed. */
3728 if (bl->shlib_disabled
3729 && bl->target_info.shadow_len != 0
3730 && !memory_validate_breakpoint (bl->gdbarch, &bl->target_info))
3731 val = 0;
3732 else
3733 val = bl->owner->ops->remove_location (bl, reason);
3734 }
3735 else
3736 {
3737 /* This breakpoint is in an overlay section.
3738 Did we set a breakpoint at the LMA? */
3739 if (!overlay_events_enabled)
3740 {
3741 /* Yes -- overlay event support is not active, so we
3742 should have set a breakpoint at the LMA. Remove it.
3743 */
3744 /* Ignore any failures: if the LMA is in ROM, we will
3745 have already warned when we failed to insert it. */
3746 if (bl->loc_type == bp_loc_hardware_breakpoint)
3747 target_remove_hw_breakpoint (bl->gdbarch,
3748 &bl->overlay_target_info);
3749 else
3750 target_remove_breakpoint (bl->gdbarch,
3751 &bl->overlay_target_info,
3752 reason);
3753 }
3754 /* Did we set a breakpoint at the VMA?
3755 If so, we will have marked the breakpoint 'inserted'. */
3756 if (bl->inserted)
3757 {
3758 /* Yes -- remove it. Previously we did not bother to
3759 remove the breakpoint if the section had been
3760 unmapped, but let's not rely on that being safe. We
3761 don't know what the overlay manager might do. */
3762
3763 /* However, we should remove *software* breakpoints only
3764 if the section is still mapped, or else we overwrite
3765 wrong code with the saved shadow contents. */
3766 if (bl->loc_type == bp_loc_hardware_breakpoint
3767 || section_is_mapped (bl->section))
3768 val = bl->owner->ops->remove_location (bl, reason);
3769 else
3770 val = 0;
3771 }
3772 else
3773 {
3774 /* No -- not inserted, so no need to remove. No error. */
3775 val = 0;
3776 }
3777 }
3778
3779 /* In some cases, we might not be able to remove a breakpoint in
3780 a shared library that has already been removed, but we have
3781 not yet processed the shlib unload event. Similarly for an
3782 unloaded add-symbol-file object - the user might not yet have
3783 had the chance to remove-symbol-file it. shlib_disabled will
3784 be set if the library/object has already been removed, but
3785 the breakpoint hasn't been uninserted yet, e.g., after
3786 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3787 always-inserted mode. */
3788 if (val
3789 && (bl->loc_type == bp_loc_software_breakpoint
3790 && (bl->shlib_disabled
3791 || solib_name_from_address (bl->pspace, bl->address)
3792 || shared_objfile_contains_address_p (bl->pspace,
3793 bl->address))))
3794 val = 0;
3795
3796 if (val)
3797 return val;
3798 bl->inserted = (reason == DETACH_BREAKPOINT);
3799 }
3800 else if (bl->loc_type == bp_loc_hardware_watchpoint)
3801 {
3802 gdb_assert (bl->owner->ops != NULL
3803 && bl->owner->ops->remove_location != NULL);
3804
3805 bl->inserted = (reason == DETACH_BREAKPOINT);
3806 bl->owner->ops->remove_location (bl, reason);
3807
3808 /* Failure to remove any of the hardware watchpoints comes here. */
3809 if (reason == REMOVE_BREAKPOINT && bl->inserted)
3810 warning (_("Could not remove hardware watchpoint %d."),
3811 bl->owner->number);
3812 }
3813 else if (bl->owner->type == bp_catchpoint
3814 && breakpoint_enabled (bl->owner)
3815 && !bl->duplicate)
3816 {
3817 gdb_assert (bl->owner->ops != NULL
3818 && bl->owner->ops->remove_location != NULL);
3819
3820 val = bl->owner->ops->remove_location (bl, reason);
3821 if (val)
3822 return val;
3823
3824 bl->inserted = (reason == DETACH_BREAKPOINT);
3825 }
3826
3827 return 0;
3828 }
3829
3830 static int
3831 remove_breakpoint (struct bp_location *bl)
3832 {
3833 /* BL is never in moribund_locations by our callers. */
3834 gdb_assert (bl->owner != NULL);
3835
3836 /* The type of none suggests that owner is actually deleted.
3837 This should not ever happen. */
3838 gdb_assert (bl->owner->type != bp_none);
3839
3840 scoped_restore_current_pspace_and_thread restore_pspace_thread;
3841
3842 switch_to_program_space_and_thread (bl->pspace);
3843
3844 return remove_breakpoint_1 (bl, REMOVE_BREAKPOINT);
3845 }
3846
3847 /* Clear the "inserted" flag in all breakpoints. */
3848
3849 void
3850 mark_breakpoints_out (void)
3851 {
3852 struct bp_location *bl, **blp_tmp;
3853
3854 ALL_BP_LOCATIONS (bl, blp_tmp)
3855 if (bl->pspace == current_program_space)
3856 bl->inserted = 0;
3857 }
3858
3859 /* Clear the "inserted" flag in all breakpoints and delete any
3860 breakpoints which should go away between runs of the program.
3861
3862 Plus other such housekeeping that has to be done for breakpoints
3863 between runs.
3864
3865 Note: this function gets called at the end of a run (by
3866 generic_mourn_inferior) and when a run begins (by
3867 init_wait_for_inferior). */
3868
3869
3870
3871 void
3872 breakpoint_init_inferior (enum inf_context context)
3873 {
3874 struct breakpoint *b, *b_tmp;
3875 struct bp_location *bl;
3876 int ix;
3877 struct program_space *pspace = current_program_space;
3878
3879 /* If breakpoint locations are shared across processes, then there's
3880 nothing to do. */
3881 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3882 return;
3883
3884 mark_breakpoints_out ();
3885
3886 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3887 {
3888 if (b->loc && b->loc->pspace != pspace)
3889 continue;
3890
3891 switch (b->type)
3892 {
3893 case bp_call_dummy:
3894 case bp_longjmp_call_dummy:
3895
3896 /* If the call dummy breakpoint is at the entry point it will
3897 cause problems when the inferior is rerun, so we better get
3898 rid of it. */
3899
3900 case bp_watchpoint_scope:
3901
3902 /* Also get rid of scope breakpoints. */
3903
3904 case bp_shlib_event:
3905
3906 /* Also remove solib event breakpoints. Their addresses may
3907 have changed since the last time we ran the program.
3908 Actually we may now be debugging against different target;
3909 and so the solib backend that installed this breakpoint may
3910 not be used in by the target. E.g.,
3911
3912 (gdb) file prog-linux
3913 (gdb) run # native linux target
3914 ...
3915 (gdb) kill
3916 (gdb) file prog-win.exe
3917 (gdb) tar rem :9999 # remote Windows gdbserver.
3918 */
3919
3920 case bp_step_resume:
3921
3922 /* Also remove step-resume breakpoints. */
3923
3924 case bp_single_step:
3925
3926 /* Also remove single-step breakpoints. */
3927
3928 delete_breakpoint (b);
3929 break;
3930
3931 case bp_watchpoint:
3932 case bp_hardware_watchpoint:
3933 case bp_read_watchpoint:
3934 case bp_access_watchpoint:
3935 {
3936 struct watchpoint *w = (struct watchpoint *) b;
3937
3938 /* Likewise for watchpoints on local expressions. */
3939 if (w->exp_valid_block != NULL)
3940 delete_breakpoint (b);
3941 else
3942 {
3943 /* Get rid of existing locations, which are no longer
3944 valid. New ones will be created in
3945 update_watchpoint, when the inferior is restarted.
3946 The next update_global_location_list call will
3947 garbage collect them. */
3948 b->loc = NULL;
3949
3950 if (context == inf_starting)
3951 {
3952 /* Reset val field to force reread of starting value in
3953 insert_breakpoints. */
3954 if (w->val)
3955 value_free (w->val);
3956 w->val = NULL;
3957 w->val_valid = 0;
3958 }
3959 }
3960 }
3961 break;
3962 default:
3963 break;
3964 }
3965 }
3966
3967 /* Get rid of the moribund locations. */
3968 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
3969 decref_bp_location (&bl);
3970 VEC_free (bp_location_p, moribund_locations);
3971 }
3972
3973 /* These functions concern about actual breakpoints inserted in the
3974 target --- to e.g. check if we need to do decr_pc adjustment or if
3975 we need to hop over the bkpt --- so we check for address space
3976 match, not program space. */
3977
3978 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3979 exists at PC. It returns ordinary_breakpoint_here if it's an
3980 ordinary breakpoint, or permanent_breakpoint_here if it's a
3981 permanent breakpoint.
3982 - When continuing from a location with an ordinary breakpoint, we
3983 actually single step once before calling insert_breakpoints.
3984 - When continuing from a location with a permanent breakpoint, we
3985 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3986 the target, to advance the PC past the breakpoint. */
3987
3988 enum breakpoint_here
3989 breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
3990 {
3991 struct bp_location *bl, **blp_tmp;
3992 int any_breakpoint_here = 0;
3993
3994 ALL_BP_LOCATIONS (bl, blp_tmp)
3995 {
3996 if (bl->loc_type != bp_loc_software_breakpoint
3997 && bl->loc_type != bp_loc_hardware_breakpoint)
3998 continue;
3999
4000 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4001 if ((breakpoint_enabled (bl->owner)
4002 || bl->permanent)
4003 && breakpoint_location_address_match (bl, aspace, pc))
4004 {
4005 if (overlay_debugging
4006 && section_is_overlay (bl->section)
4007 && !section_is_mapped (bl->section))
4008 continue; /* unmapped overlay -- can't be a match */
4009 else if (bl->permanent)
4010 return permanent_breakpoint_here;
4011 else
4012 any_breakpoint_here = 1;
4013 }
4014 }
4015
4016 return any_breakpoint_here ? ordinary_breakpoint_here : no_breakpoint_here;
4017 }
4018
4019 /* See breakpoint.h. */
4020
4021 int
4022 breakpoint_in_range_p (const address_space *aspace,
4023 CORE_ADDR addr, ULONGEST len)
4024 {
4025 struct bp_location *bl, **blp_tmp;
4026
4027 ALL_BP_LOCATIONS (bl, blp_tmp)
4028 {
4029 if (bl->loc_type != bp_loc_software_breakpoint
4030 && bl->loc_type != bp_loc_hardware_breakpoint)
4031 continue;
4032
4033 if ((breakpoint_enabled (bl->owner)
4034 || bl->permanent)
4035 && breakpoint_location_address_range_overlap (bl, aspace,
4036 addr, len))
4037 {
4038 if (overlay_debugging
4039 && section_is_overlay (bl->section)
4040 && !section_is_mapped (bl->section))
4041 {
4042 /* Unmapped overlay -- can't be a match. */
4043 continue;
4044 }
4045
4046 return 1;
4047 }
4048 }
4049
4050 return 0;
4051 }
4052
4053 /* Return true if there's a moribund breakpoint at PC. */
4054
4055 int
4056 moribund_breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
4057 {
4058 struct bp_location *loc;
4059 int ix;
4060
4061 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
4062 if (breakpoint_location_address_match (loc, aspace, pc))
4063 return 1;
4064
4065 return 0;
4066 }
4067
4068 /* Returns non-zero iff BL is inserted at PC, in address space
4069 ASPACE. */
4070
4071 static int
4072 bp_location_inserted_here_p (struct bp_location *bl,
4073 const address_space *aspace, CORE_ADDR pc)
4074 {
4075 if (bl->inserted
4076 && breakpoint_address_match (bl->pspace->aspace, bl->address,
4077 aspace, pc))
4078 {
4079 if (overlay_debugging
4080 && section_is_overlay (bl->section)
4081 && !section_is_mapped (bl->section))
4082 return 0; /* unmapped overlay -- can't be a match */
4083 else
4084 return 1;
4085 }
4086 return 0;
4087 }
4088
4089 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4090
4091 int
4092 breakpoint_inserted_here_p (const address_space *aspace, CORE_ADDR pc)
4093 {
4094 struct bp_location **blp, **blp_tmp = NULL;
4095
4096 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4097 {
4098 struct bp_location *bl = *blp;
4099
4100 if (bl->loc_type != bp_loc_software_breakpoint
4101 && bl->loc_type != bp_loc_hardware_breakpoint)
4102 continue;
4103
4104 if (bp_location_inserted_here_p (bl, aspace, pc))
4105 return 1;
4106 }
4107 return 0;
4108 }
4109
4110 /* This function returns non-zero iff there is a software breakpoint
4111 inserted at PC. */
4112
4113 int
4114 software_breakpoint_inserted_here_p (const address_space *aspace,
4115 CORE_ADDR pc)
4116 {
4117 struct bp_location **blp, **blp_tmp = NULL;
4118
4119 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4120 {
4121 struct bp_location *bl = *blp;
4122
4123 if (bl->loc_type != bp_loc_software_breakpoint)
4124 continue;
4125
4126 if (bp_location_inserted_here_p (bl, aspace, pc))
4127 return 1;
4128 }
4129
4130 return 0;
4131 }
4132
4133 /* See breakpoint.h. */
4134
4135 int
4136 hardware_breakpoint_inserted_here_p (const address_space *aspace,
4137 CORE_ADDR pc)
4138 {
4139 struct bp_location **blp, **blp_tmp = NULL;
4140
4141 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4142 {
4143 struct bp_location *bl = *blp;
4144
4145 if (bl->loc_type != bp_loc_hardware_breakpoint)
4146 continue;
4147
4148 if (bp_location_inserted_here_p (bl, aspace, pc))
4149 return 1;
4150 }
4151
4152 return 0;
4153 }
4154
4155 int
4156 hardware_watchpoint_inserted_in_range (const address_space *aspace,
4157 CORE_ADDR addr, ULONGEST len)
4158 {
4159 struct breakpoint *bpt;
4160
4161 ALL_BREAKPOINTS (bpt)
4162 {
4163 struct bp_location *loc;
4164
4165 if (bpt->type != bp_hardware_watchpoint
4166 && bpt->type != bp_access_watchpoint)
4167 continue;
4168
4169 if (!breakpoint_enabled (bpt))
4170 continue;
4171
4172 for (loc = bpt->loc; loc; loc = loc->next)
4173 if (loc->pspace->aspace == aspace && loc->inserted)
4174 {
4175 CORE_ADDR l, h;
4176
4177 /* Check for intersection. */
4178 l = std::max<CORE_ADDR> (loc->address, addr);
4179 h = std::min<CORE_ADDR> (loc->address + loc->length, addr + len);
4180 if (l < h)
4181 return 1;
4182 }
4183 }
4184 return 0;
4185 }
4186
4187
4188 /* bpstat stuff. External routines' interfaces are documented
4189 in breakpoint.h. */
4190
4191 int
4192 is_catchpoint (struct breakpoint *ep)
4193 {
4194 return (ep->type == bp_catchpoint);
4195 }
4196
4197 /* Frees any storage that is part of a bpstat. Does not walk the
4198 'next' chain. */
4199
4200 bpstats::~bpstats ()
4201 {
4202 if (old_val != NULL)
4203 value_free (old_val);
4204 if (bp_location_at != NULL)
4205 decref_bp_location (&bp_location_at);
4206 }
4207
4208 /* Clear a bpstat so that it says we are not at any breakpoint.
4209 Also free any storage that is part of a bpstat. */
4210
4211 void
4212 bpstat_clear (bpstat *bsp)
4213 {
4214 bpstat p;
4215 bpstat q;
4216
4217 if (bsp == 0)
4218 return;
4219 p = *bsp;
4220 while (p != NULL)
4221 {
4222 q = p->next;
4223 delete p;
4224 p = q;
4225 }
4226 *bsp = NULL;
4227 }
4228
4229 bpstats::bpstats (const bpstats &other)
4230 : next (NULL),
4231 bp_location_at (other.bp_location_at),
4232 breakpoint_at (other.breakpoint_at),
4233 commands (other.commands),
4234 old_val (other.old_val),
4235 print (other.print),
4236 stop (other.stop),
4237 print_it (other.print_it)
4238 {
4239 if (old_val != NULL)
4240 {
4241 old_val = value_copy (old_val);
4242 release_value (old_val);
4243 }
4244 incref_bp_location (bp_location_at);
4245 }
4246
4247 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4248 is part of the bpstat is copied as well. */
4249
4250 bpstat
4251 bpstat_copy (bpstat bs)
4252 {
4253 bpstat p = NULL;
4254 bpstat tmp;
4255 bpstat retval = NULL;
4256
4257 if (bs == NULL)
4258 return bs;
4259
4260 for (; bs != NULL; bs = bs->next)
4261 {
4262 tmp = new bpstats (*bs);
4263
4264 if (p == NULL)
4265 /* This is the first thing in the chain. */
4266 retval = tmp;
4267 else
4268 p->next = tmp;
4269 p = tmp;
4270 }
4271 p->next = NULL;
4272 return retval;
4273 }
4274
4275 /* Find the bpstat associated with this breakpoint. */
4276
4277 bpstat
4278 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
4279 {
4280 if (bsp == NULL)
4281 return NULL;
4282
4283 for (; bsp != NULL; bsp = bsp->next)
4284 {
4285 if (bsp->breakpoint_at == breakpoint)
4286 return bsp;
4287 }
4288 return NULL;
4289 }
4290
4291 /* See breakpoint.h. */
4292
4293 int
4294 bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
4295 {
4296 for (; bsp != NULL; bsp = bsp->next)
4297 {
4298 if (bsp->breakpoint_at == NULL)
4299 {
4300 /* A moribund location can never explain a signal other than
4301 GDB_SIGNAL_TRAP. */
4302 if (sig == GDB_SIGNAL_TRAP)
4303 return 1;
4304 }
4305 else
4306 {
4307 if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
4308 sig))
4309 return 1;
4310 }
4311 }
4312
4313 return 0;
4314 }
4315
4316 /* Put in *NUM the breakpoint number of the first breakpoint we are
4317 stopped at. *BSP upon return is a bpstat which points to the
4318 remaining breakpoints stopped at (but which is not guaranteed to be
4319 good for anything but further calls to bpstat_num).
4320
4321 Return 0 if passed a bpstat which does not indicate any breakpoints.
4322 Return -1 if stopped at a breakpoint that has been deleted since
4323 we set it.
4324 Return 1 otherwise. */
4325
4326 int
4327 bpstat_num (bpstat *bsp, int *num)
4328 {
4329 struct breakpoint *b;
4330
4331 if ((*bsp) == NULL)
4332 return 0; /* No more breakpoint values */
4333
4334 /* We assume we'll never have several bpstats that correspond to a
4335 single breakpoint -- otherwise, this function might return the
4336 same number more than once and this will look ugly. */
4337 b = (*bsp)->breakpoint_at;
4338 *bsp = (*bsp)->next;
4339 if (b == NULL)
4340 return -1; /* breakpoint that's been deleted since */
4341
4342 *num = b->number; /* We have its number */
4343 return 1;
4344 }
4345
4346 /* See breakpoint.h. */
4347
4348 void
4349 bpstat_clear_actions (void)
4350 {
4351 struct thread_info *tp;
4352 bpstat bs;
4353
4354 if (ptid_equal (inferior_ptid, null_ptid))
4355 return;
4356
4357 tp = find_thread_ptid (inferior_ptid);
4358 if (tp == NULL)
4359 return;
4360
4361 for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
4362 {
4363 bs->commands = NULL;
4364
4365 if (bs->old_val != NULL)
4366 {
4367 value_free (bs->old_val);
4368 bs->old_val = NULL;
4369 }
4370 }
4371 }
4372
4373 /* Called when a command is about to proceed the inferior. */
4374
4375 static void
4376 breakpoint_about_to_proceed (void)
4377 {
4378 if (!ptid_equal (inferior_ptid, null_ptid))
4379 {
4380 struct thread_info *tp = inferior_thread ();
4381
4382 /* Allow inferior function calls in breakpoint commands to not
4383 interrupt the command list. When the call finishes
4384 successfully, the inferior will be standing at the same
4385 breakpoint as if nothing happened. */
4386 if (tp->control.in_infcall)
4387 return;
4388 }
4389
4390 breakpoint_proceeded = 1;
4391 }
4392
4393 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4394 or its equivalent. */
4395
4396 static int
4397 command_line_is_silent (struct command_line *cmd)
4398 {
4399 return cmd && (strcmp ("silent", cmd->line) == 0);
4400 }
4401
4402 /* Execute all the commands associated with all the breakpoints at
4403 this location. Any of these commands could cause the process to
4404 proceed beyond this point, etc. We look out for such changes by
4405 checking the global "breakpoint_proceeded" after each command.
4406
4407 Returns true if a breakpoint command resumed the inferior. In that
4408 case, it is the caller's responsibility to recall it again with the
4409 bpstat of the current thread. */
4410
4411 static int
4412 bpstat_do_actions_1 (bpstat *bsp)
4413 {
4414 bpstat bs;
4415 int again = 0;
4416
4417 /* Avoid endless recursion if a `source' command is contained
4418 in bs->commands. */
4419 if (executing_breakpoint_commands)
4420 return 0;
4421
4422 scoped_restore save_executing
4423 = make_scoped_restore (&executing_breakpoint_commands, 1);
4424
4425 scoped_restore preventer = prevent_dont_repeat ();
4426
4427 /* This pointer will iterate over the list of bpstat's. */
4428 bs = *bsp;
4429
4430 breakpoint_proceeded = 0;
4431 for (; bs != NULL; bs = bs->next)
4432 {
4433 struct command_line *cmd = NULL;
4434
4435 /* Take ownership of the BSP's command tree, if it has one.
4436
4437 The command tree could legitimately contain commands like
4438 'step' and 'next', which call clear_proceed_status, which
4439 frees stop_bpstat's command tree. To make sure this doesn't
4440 free the tree we're executing out from under us, we need to
4441 take ownership of the tree ourselves. Since a given bpstat's
4442 commands are only executed once, we don't need to copy it; we
4443 can clear the pointer in the bpstat, and make sure we free
4444 the tree when we're done. */
4445 counted_command_line ccmd = bs->commands;
4446 bs->commands = NULL;
4447 if (ccmd != NULL)
4448 cmd = ccmd.get ();
4449 if (command_line_is_silent (cmd))
4450 {
4451 /* The action has been already done by bpstat_stop_status. */
4452 cmd = cmd->next;
4453 }
4454
4455 while (cmd != NULL)
4456 {
4457 execute_control_command (cmd);
4458
4459 if (breakpoint_proceeded)
4460 break;
4461 else
4462 cmd = cmd->next;
4463 }
4464
4465 if (breakpoint_proceeded)
4466 {
4467 if (current_ui->async)
4468 /* If we are in async mode, then the target might be still
4469 running, not stopped at any breakpoint, so nothing for
4470 us to do here -- just return to the event loop. */
4471 ;
4472 else
4473 /* In sync mode, when execute_control_command returns
4474 we're already standing on the next breakpoint.
4475 Breakpoint commands for that stop were not run, since
4476 execute_command does not run breakpoint commands --
4477 only command_line_handler does, but that one is not
4478 involved in execution of breakpoint commands. So, we
4479 can now execute breakpoint commands. It should be
4480 noted that making execute_command do bpstat actions is
4481 not an option -- in this case we'll have recursive
4482 invocation of bpstat for each breakpoint with a
4483 command, and can easily blow up GDB stack. Instead, we
4484 return true, which will trigger the caller to recall us
4485 with the new stop_bpstat. */
4486 again = 1;
4487 break;
4488 }
4489 }
4490 return again;
4491 }
4492
4493 void
4494 bpstat_do_actions (void)
4495 {
4496 struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
4497
4498 /* Do any commands attached to breakpoint we are stopped at. */
4499 while (!ptid_equal (inferior_ptid, null_ptid)
4500 && target_has_execution
4501 && !is_exited (inferior_ptid)
4502 && !is_executing (inferior_ptid))
4503 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4504 and only return when it is stopped at the next breakpoint, we
4505 keep doing breakpoint actions until it returns false to
4506 indicate the inferior was not resumed. */
4507 if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
4508 break;
4509
4510 discard_cleanups (cleanup_if_error);
4511 }
4512
4513 /* Print out the (old or new) value associated with a watchpoint. */
4514
4515 static void
4516 watchpoint_value_print (struct value *val, struct ui_file *stream)
4517 {
4518 if (val == NULL)
4519 fprintf_unfiltered (stream, _("<unreadable>"));
4520 else
4521 {
4522 struct value_print_options opts;
4523 get_user_print_options (&opts);
4524 value_print (val, stream, &opts);
4525 }
4526 }
4527
4528 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4529 debugging multiple threads. */
4530
4531 void
4532 maybe_print_thread_hit_breakpoint (struct ui_out *uiout)
4533 {
4534 if (uiout->is_mi_like_p ())
4535 return;
4536
4537 uiout->text ("\n");
4538
4539 if (show_thread_that_caused_stop ())
4540 {
4541 const char *name;
4542 struct thread_info *thr = inferior_thread ();
4543
4544 uiout->text ("Thread ");
4545 uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
4546
4547 name = thr->name != NULL ? thr->name : target_thread_name (thr);
4548 if (name != NULL)
4549 {
4550 uiout->text (" \"");
4551 uiout->field_fmt ("name", "%s", name);
4552 uiout->text ("\"");
4553 }
4554
4555 uiout->text (" hit ");
4556 }
4557 }
4558
4559 /* Generic routine for printing messages indicating why we
4560 stopped. The behavior of this function depends on the value
4561 'print_it' in the bpstat structure. Under some circumstances we
4562 may decide not to print anything here and delegate the task to
4563 normal_stop(). */
4564
4565 static enum print_stop_action
4566 print_bp_stop_message (bpstat bs)
4567 {
4568 switch (bs->print_it)
4569 {
4570 case print_it_noop:
4571 /* Nothing should be printed for this bpstat entry. */
4572 return PRINT_UNKNOWN;
4573 break;
4574
4575 case print_it_done:
4576 /* We still want to print the frame, but we already printed the
4577 relevant messages. */
4578 return PRINT_SRC_AND_LOC;
4579 break;
4580
4581 case print_it_normal:
4582 {
4583 struct breakpoint *b = bs->breakpoint_at;
4584
4585 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4586 which has since been deleted. */
4587 if (b == NULL)
4588 return PRINT_UNKNOWN;
4589
4590 /* Normal case. Call the breakpoint's print_it method. */
4591 return b->ops->print_it (bs);
4592 }
4593 break;
4594
4595 default:
4596 internal_error (__FILE__, __LINE__,
4597 _("print_bp_stop_message: unrecognized enum value"));
4598 break;
4599 }
4600 }
4601
4602 /* A helper function that prints a shared library stopped event. */
4603
4604 static void
4605 print_solib_event (int is_catchpoint)
4606 {
4607 int any_deleted
4608 = !VEC_empty (char_ptr, current_program_space->deleted_solibs);
4609 int any_added
4610 = !VEC_empty (so_list_ptr, current_program_space->added_solibs);
4611
4612 if (!is_catchpoint)
4613 {
4614 if (any_added || any_deleted)
4615 current_uiout->text (_("Stopped due to shared library event:\n"));
4616 else
4617 current_uiout->text (_("Stopped due to shared library event (no "
4618 "libraries added or removed)\n"));
4619 }
4620
4621 if (current_uiout->is_mi_like_p ())
4622 current_uiout->field_string ("reason",
4623 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
4624
4625 if (any_deleted)
4626 {
4627 char *name;
4628 int ix;
4629
4630 current_uiout->text (_(" Inferior unloaded "));
4631 ui_out_emit_list list_emitter (current_uiout, "removed");
4632 for (ix = 0;
4633 VEC_iterate (char_ptr, current_program_space->deleted_solibs,
4634 ix, name);
4635 ++ix)
4636 {
4637 if (ix > 0)
4638 current_uiout->text (" ");
4639 current_uiout->field_string ("library", name);
4640 current_uiout->text ("\n");
4641 }
4642 }
4643
4644 if (any_added)
4645 {
4646 struct so_list *iter;
4647 int ix;
4648
4649 current_uiout->text (_(" Inferior loaded "));
4650 ui_out_emit_list list_emitter (current_uiout, "added");
4651 for (ix = 0;
4652 VEC_iterate (so_list_ptr, current_program_space->added_solibs,
4653 ix, iter);
4654 ++ix)
4655 {
4656 if (ix > 0)
4657 current_uiout->text (" ");
4658 current_uiout->field_string ("library", iter->so_name);
4659 current_uiout->text ("\n");
4660 }
4661 }
4662 }
4663
4664 /* Print a message indicating what happened. This is called from
4665 normal_stop(). The input to this routine is the head of the bpstat
4666 list - a list of the eventpoints that caused this stop. KIND is
4667 the target_waitkind for the stopping event. This
4668 routine calls the generic print routine for printing a message
4669 about reasons for stopping. This will print (for example) the
4670 "Breakpoint n," part of the output. The return value of this
4671 routine is one of:
4672
4673 PRINT_UNKNOWN: Means we printed nothing.
4674 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4675 code to print the location. An example is
4676 "Breakpoint 1, " which should be followed by
4677 the location.
4678 PRINT_SRC_ONLY: Means we printed something, but there is no need
4679 to also print the location part of the message.
4680 An example is the catch/throw messages, which
4681 don't require a location appended to the end.
4682 PRINT_NOTHING: We have done some printing and we don't need any
4683 further info to be printed. */
4684
4685 enum print_stop_action
4686 bpstat_print (bpstat bs, int kind)
4687 {
4688 enum print_stop_action val;
4689
4690 /* Maybe another breakpoint in the chain caused us to stop.
4691 (Currently all watchpoints go on the bpstat whether hit or not.
4692 That probably could (should) be changed, provided care is taken
4693 with respect to bpstat_explains_signal). */
4694 for (; bs; bs = bs->next)
4695 {
4696 val = print_bp_stop_message (bs);
4697 if (val == PRINT_SRC_ONLY
4698 || val == PRINT_SRC_AND_LOC
4699 || val == PRINT_NOTHING)
4700 return val;
4701 }
4702
4703 /* If we had hit a shared library event breakpoint,
4704 print_bp_stop_message would print out this message. If we hit an
4705 OS-level shared library event, do the same thing. */
4706 if (kind == TARGET_WAITKIND_LOADED)
4707 {
4708 print_solib_event (0);
4709 return PRINT_NOTHING;
4710 }
4711
4712 /* We reached the end of the chain, or we got a null BS to start
4713 with and nothing was printed. */
4714 return PRINT_UNKNOWN;
4715 }
4716
4717 /* Evaluate the boolean expression EXP and return the result. */
4718
4719 static bool
4720 breakpoint_cond_eval (expression *exp)
4721 {
4722 struct value *mark = value_mark ();
4723 bool res = value_true (evaluate_expression (exp));
4724
4725 value_free_to_mark (mark);
4726 return res;
4727 }
4728
4729 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4730
4731 bpstats::bpstats (struct bp_location *bl, bpstat **bs_link_pointer)
4732 : next (NULL),
4733 bp_location_at (bl),
4734 breakpoint_at (bl->owner),
4735 commands (NULL),
4736 old_val (NULL),
4737 print (0),
4738 stop (0),
4739 print_it (print_it_normal)
4740 {
4741 incref_bp_location (bl);
4742 **bs_link_pointer = this;
4743 *bs_link_pointer = &next;
4744 }
4745
4746 bpstats::bpstats ()
4747 : next (NULL),
4748 bp_location_at (NULL),
4749 breakpoint_at (NULL),
4750 commands (NULL),
4751 old_val (NULL),
4752 print (0),
4753 stop (0),
4754 print_it (print_it_normal)
4755 {
4756 }
4757
4758 /* The target has stopped with waitstatus WS. Check if any hardware
4759 watchpoints have triggered, according to the target. */
4760
4761 int
4762 watchpoints_triggered (struct target_waitstatus *ws)
4763 {
4764 int stopped_by_watchpoint = target_stopped_by_watchpoint ();
4765 CORE_ADDR addr;
4766 struct breakpoint *b;
4767
4768 if (!stopped_by_watchpoint)
4769 {
4770 /* We were not stopped by a watchpoint. Mark all watchpoints
4771 as not triggered. */
4772 ALL_BREAKPOINTS (b)
4773 if (is_hardware_watchpoint (b))
4774 {
4775 struct watchpoint *w = (struct watchpoint *) b;
4776
4777 w->watchpoint_triggered = watch_triggered_no;
4778 }
4779
4780 return 0;
4781 }
4782
4783 if (!target_stopped_data_address (&current_target, &addr))
4784 {
4785 /* We were stopped by a watchpoint, but we don't know where.
4786 Mark all watchpoints as unknown. */
4787 ALL_BREAKPOINTS (b)
4788 if (is_hardware_watchpoint (b))
4789 {
4790 struct watchpoint *w = (struct watchpoint *) b;
4791
4792 w->watchpoint_triggered = watch_triggered_unknown;
4793 }
4794
4795 return 1;
4796 }
4797
4798 /* The target could report the data address. Mark watchpoints
4799 affected by this data address as triggered, and all others as not
4800 triggered. */
4801
4802 ALL_BREAKPOINTS (b)
4803 if (is_hardware_watchpoint (b))
4804 {
4805 struct watchpoint *w = (struct watchpoint *) b;
4806 struct bp_location *loc;
4807
4808 w->watchpoint_triggered = watch_triggered_no;
4809 for (loc = b->loc; loc; loc = loc->next)
4810 {
4811 if (is_masked_watchpoint (b))
4812 {
4813 CORE_ADDR newaddr = addr & w->hw_wp_mask;
4814 CORE_ADDR start = loc->address & w->hw_wp_mask;
4815
4816 if (newaddr == start)
4817 {
4818 w->watchpoint_triggered = watch_triggered_yes;
4819 break;
4820 }
4821 }
4822 /* Exact match not required. Within range is sufficient. */
4823 else if (target_watchpoint_addr_within_range (&current_target,
4824 addr, loc->address,
4825 loc->length))
4826 {
4827 w->watchpoint_triggered = watch_triggered_yes;
4828 break;
4829 }
4830 }
4831 }
4832
4833 return 1;
4834 }
4835
4836 /* Possible return values for watchpoint_check. */
4837 enum wp_check_result
4838 {
4839 /* The watchpoint has been deleted. */
4840 WP_DELETED = 1,
4841
4842 /* The value has changed. */
4843 WP_VALUE_CHANGED = 2,
4844
4845 /* The value has not changed. */
4846 WP_VALUE_NOT_CHANGED = 3,
4847
4848 /* Ignore this watchpoint, no matter if the value changed or not. */
4849 WP_IGNORE = 4,
4850 };
4851
4852 #define BP_TEMPFLAG 1
4853 #define BP_HARDWAREFLAG 2
4854
4855 /* Evaluate watchpoint condition expression and check if its value
4856 changed. */
4857
4858 static wp_check_result
4859 watchpoint_check (bpstat bs)
4860 {
4861 struct watchpoint *b;
4862 struct frame_info *fr;
4863 int within_current_scope;
4864
4865 /* BS is built from an existing struct breakpoint. */
4866 gdb_assert (bs->breakpoint_at != NULL);
4867 b = (struct watchpoint *) bs->breakpoint_at;
4868
4869 /* If this is a local watchpoint, we only want to check if the
4870 watchpoint frame is in scope if the current thread is the thread
4871 that was used to create the watchpoint. */
4872 if (!watchpoint_in_thread_scope (b))
4873 return WP_IGNORE;
4874
4875 if (b->exp_valid_block == NULL)
4876 within_current_scope = 1;
4877 else
4878 {
4879 struct frame_info *frame = get_current_frame ();
4880 struct gdbarch *frame_arch = get_frame_arch (frame);
4881 CORE_ADDR frame_pc = get_frame_pc (frame);
4882
4883 /* stack_frame_destroyed_p() returns a non-zero value if we're
4884 still in the function but the stack frame has already been
4885 invalidated. Since we can't rely on the values of local
4886 variables after the stack has been destroyed, we are treating
4887 the watchpoint in that state as `not changed' without further
4888 checking. Don't mark watchpoints as changed if the current
4889 frame is in an epilogue - even if they are in some other
4890 frame, our view of the stack is likely to be wrong and
4891 frame_find_by_id could error out. */
4892 if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
4893 return WP_IGNORE;
4894
4895 fr = frame_find_by_id (b->watchpoint_frame);
4896 within_current_scope = (fr != NULL);
4897
4898 /* If we've gotten confused in the unwinder, we might have
4899 returned a frame that can't describe this variable. */
4900 if (within_current_scope)
4901 {
4902 struct symbol *function;
4903
4904 function = get_frame_function (fr);
4905 if (function == NULL
4906 || !contained_in (b->exp_valid_block,
4907 SYMBOL_BLOCK_VALUE (function)))
4908 within_current_scope = 0;
4909 }
4910
4911 if (within_current_scope)
4912 /* If we end up stopping, the current frame will get selected
4913 in normal_stop. So this call to select_frame won't affect
4914 the user. */
4915 select_frame (fr);
4916 }
4917
4918 if (within_current_scope)
4919 {
4920 /* We use value_{,free_to_}mark because it could be a *long*
4921 time before we return to the command level and call
4922 free_all_values. We can't call free_all_values because we
4923 might be in the middle of evaluating a function call. */
4924
4925 int pc = 0;
4926 struct value *mark;
4927 struct value *new_val;
4928
4929 if (is_masked_watchpoint (b))
4930 /* Since we don't know the exact trigger address (from
4931 stopped_data_address), just tell the user we've triggered
4932 a mask watchpoint. */
4933 return WP_VALUE_CHANGED;
4934
4935 mark = value_mark ();
4936 fetch_subexp_value (b->exp.get (), &pc, &new_val, NULL, NULL, 0);
4937
4938 if (b->val_bitsize != 0)
4939 new_val = extract_bitfield_from_watchpoint_value (b, new_val);
4940
4941 /* We use value_equal_contents instead of value_equal because
4942 the latter coerces an array to a pointer, thus comparing just
4943 the address of the array instead of its contents. This is
4944 not what we want. */
4945 if ((b->val != NULL) != (new_val != NULL)
4946 || (b->val != NULL && !value_equal_contents (b->val, new_val)))
4947 {
4948 if (new_val != NULL)
4949 {
4950 release_value (new_val);
4951 value_free_to_mark (mark);
4952 }
4953 bs->old_val = b->val;
4954 b->val = new_val;
4955 b->val_valid = 1;
4956 return WP_VALUE_CHANGED;
4957 }
4958 else
4959 {
4960 /* Nothing changed. */
4961 value_free_to_mark (mark);
4962 return WP_VALUE_NOT_CHANGED;
4963 }
4964 }
4965 else
4966 {
4967 /* This seems like the only logical thing to do because
4968 if we temporarily ignored the watchpoint, then when
4969 we reenter the block in which it is valid it contains
4970 garbage (in the case of a function, it may have two
4971 garbage values, one before and one after the prologue).
4972 So we can't even detect the first assignment to it and
4973 watch after that (since the garbage may or may not equal
4974 the first value assigned). */
4975 /* We print all the stop information in
4976 breakpoint_ops->print_it, but in this case, by the time we
4977 call breakpoint_ops->print_it this bp will be deleted
4978 already. So we have no choice but print the information
4979 here. */
4980
4981 SWITCH_THRU_ALL_UIS ()
4982 {
4983 struct ui_out *uiout = current_uiout;
4984
4985 if (uiout->is_mi_like_p ())
4986 uiout->field_string
4987 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
4988 uiout->text ("\nWatchpoint ");
4989 uiout->field_int ("wpnum", b->number);
4990 uiout->text (" deleted because the program has left the block in\n"
4991 "which its expression is valid.\n");
4992 }
4993
4994 /* Make sure the watchpoint's commands aren't executed. */
4995 b->commands = NULL;
4996 watchpoint_del_at_next_stop (b);
4997
4998 return WP_DELETED;
4999 }
5000 }
5001
5002 /* Return true if it looks like target has stopped due to hitting
5003 breakpoint location BL. This function does not check if we should
5004 stop, only if BL explains the stop. */
5005
5006 static int
5007 bpstat_check_location (const struct bp_location *bl,
5008 const address_space *aspace, CORE_ADDR bp_addr,
5009 const struct target_waitstatus *ws)
5010 {
5011 struct breakpoint *b = bl->owner;
5012
5013 /* BL is from an existing breakpoint. */
5014 gdb_assert (b != NULL);
5015
5016 return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
5017 }
5018
5019 /* Determine if the watched values have actually changed, and we
5020 should stop. If not, set BS->stop to 0. */
5021
5022 static void
5023 bpstat_check_watchpoint (bpstat bs)
5024 {
5025 const struct bp_location *bl;
5026 struct watchpoint *b;
5027
5028 /* BS is built for existing struct breakpoint. */
5029 bl = bs->bp_location_at;
5030 gdb_assert (bl != NULL);
5031 b = (struct watchpoint *) bs->breakpoint_at;
5032 gdb_assert (b != NULL);
5033
5034 {
5035 int must_check_value = 0;
5036
5037 if (b->type == bp_watchpoint)
5038 /* For a software watchpoint, we must always check the
5039 watched value. */
5040 must_check_value = 1;
5041 else if (b->watchpoint_triggered == watch_triggered_yes)
5042 /* We have a hardware watchpoint (read, write, or access)
5043 and the target earlier reported an address watched by
5044 this watchpoint. */
5045 must_check_value = 1;
5046 else if (b->watchpoint_triggered == watch_triggered_unknown
5047 && b->type == bp_hardware_watchpoint)
5048 /* We were stopped by a hardware watchpoint, but the target could
5049 not report the data address. We must check the watchpoint's
5050 value. Access and read watchpoints are out of luck; without
5051 a data address, we can't figure it out. */
5052 must_check_value = 1;
5053
5054 if (must_check_value)
5055 {
5056 wp_check_result e;
5057
5058 TRY
5059 {
5060 e = watchpoint_check (bs);
5061 }
5062 CATCH (ex, RETURN_MASK_ALL)
5063 {
5064 exception_fprintf (gdb_stderr, ex,
5065 "Error evaluating expression "
5066 "for watchpoint %d\n",
5067 b->number);
5068
5069 SWITCH_THRU_ALL_UIS ()
5070 {
5071 printf_filtered (_("Watchpoint %d deleted.\n"),
5072 b->number);
5073 }
5074 watchpoint_del_at_next_stop (b);
5075 e = WP_DELETED;
5076 }
5077 END_CATCH
5078
5079 switch (e)
5080 {
5081 case WP_DELETED:
5082 /* We've already printed what needs to be printed. */
5083 bs->print_it = print_it_done;
5084 /* Stop. */
5085 break;
5086 case WP_IGNORE:
5087 bs->print_it = print_it_noop;
5088 bs->stop = 0;
5089 break;
5090 case WP_VALUE_CHANGED:
5091 if (b->type == bp_read_watchpoint)
5092 {
5093 /* There are two cases to consider here:
5094
5095 1. We're watching the triggered memory for reads.
5096 In that case, trust the target, and always report
5097 the watchpoint hit to the user. Even though
5098 reads don't cause value changes, the value may
5099 have changed since the last time it was read, and
5100 since we're not trapping writes, we will not see
5101 those, and as such we should ignore our notion of
5102 old value.
5103
5104 2. We're watching the triggered memory for both
5105 reads and writes. There are two ways this may
5106 happen:
5107
5108 2.1. This is a target that can't break on data
5109 reads only, but can break on accesses (reads or
5110 writes), such as e.g., x86. We detect this case
5111 at the time we try to insert read watchpoints.
5112
5113 2.2. Otherwise, the target supports read
5114 watchpoints, but, the user set an access or write
5115 watchpoint watching the same memory as this read
5116 watchpoint.
5117
5118 If we're watching memory writes as well as reads,
5119 ignore watchpoint hits when we find that the
5120 value hasn't changed, as reads don't cause
5121 changes. This still gives false positives when
5122 the program writes the same value to memory as
5123 what there was already in memory (we will confuse
5124 it for a read), but it's much better than
5125 nothing. */
5126
5127 int other_write_watchpoint = 0;
5128
5129 if (bl->watchpoint_type == hw_read)
5130 {
5131 struct breakpoint *other_b;
5132
5133 ALL_BREAKPOINTS (other_b)
5134 if (other_b->type == bp_hardware_watchpoint
5135 || other_b->type == bp_access_watchpoint)
5136 {
5137 struct watchpoint *other_w =
5138 (struct watchpoint *) other_b;
5139
5140 if (other_w->watchpoint_triggered
5141 == watch_triggered_yes)
5142 {
5143 other_write_watchpoint = 1;
5144 break;
5145 }
5146 }
5147 }
5148
5149 if (other_write_watchpoint
5150 || bl->watchpoint_type == hw_access)
5151 {
5152 /* We're watching the same memory for writes,
5153 and the value changed since the last time we
5154 updated it, so this trap must be for a write.
5155 Ignore it. */
5156 bs->print_it = print_it_noop;
5157 bs->stop = 0;
5158 }
5159 }
5160 break;
5161 case WP_VALUE_NOT_CHANGED:
5162 if (b->type == bp_hardware_watchpoint
5163 || b->type == bp_watchpoint)
5164 {
5165 /* Don't stop: write watchpoints shouldn't fire if
5166 the value hasn't changed. */
5167 bs->print_it = print_it_noop;
5168 bs->stop = 0;
5169 }
5170 /* Stop. */
5171 break;
5172 default:
5173 /* Can't happen. */
5174 break;
5175 }
5176 }
5177 else /* must_check_value == 0 */
5178 {
5179 /* This is a case where some watchpoint(s) triggered, but
5180 not at the address of this watchpoint, or else no
5181 watchpoint triggered after all. So don't print
5182 anything for this watchpoint. */
5183 bs->print_it = print_it_noop;
5184 bs->stop = 0;
5185 }
5186 }
5187 }
5188
5189 /* For breakpoints that are currently marked as telling gdb to stop,
5190 check conditions (condition proper, frame, thread and ignore count)
5191 of breakpoint referred to by BS. If we should not stop for this
5192 breakpoint, set BS->stop to 0. */
5193
5194 static void
5195 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
5196 {
5197 const struct bp_location *bl;
5198 struct breakpoint *b;
5199 /* Assume stop. */
5200 bool condition_result = true;
5201 struct expression *cond;
5202
5203 gdb_assert (bs->stop);
5204
5205 /* BS is built for existing struct breakpoint. */
5206 bl = bs->bp_location_at;
5207 gdb_assert (bl != NULL);
5208 b = bs->breakpoint_at;
5209 gdb_assert (b != NULL);
5210
5211 /* Even if the target evaluated the condition on its end and notified GDB, we
5212 need to do so again since GDB does not know if we stopped due to a
5213 breakpoint or a single step breakpoint. */
5214
5215 if (frame_id_p (b->frame_id)
5216 && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
5217 {
5218 bs->stop = 0;
5219 return;
5220 }
5221
5222 /* If this is a thread/task-specific breakpoint, don't waste cpu
5223 evaluating the condition if this isn't the specified
5224 thread/task. */
5225 if ((b->thread != -1 && b->thread != ptid_to_global_thread_id (ptid))
5226 || (b->task != 0 && b->task != ada_get_task_number (ptid)))
5227
5228 {
5229 bs->stop = 0;
5230 return;
5231 }
5232
5233 /* Evaluate extension language breakpoints that have a "stop" method
5234 implemented. */
5235 bs->stop = breakpoint_ext_lang_cond_says_stop (b);
5236
5237 if (is_watchpoint (b))
5238 {
5239 struct watchpoint *w = (struct watchpoint *) b;
5240
5241 cond = w->cond_exp.get ();
5242 }
5243 else
5244 cond = bl->cond.get ();
5245
5246 if (cond && b->disposition != disp_del_at_next_stop)
5247 {
5248 int within_current_scope = 1;
5249 struct watchpoint * w;
5250
5251 /* We use value_mark and value_free_to_mark because it could
5252 be a long time before we return to the command level and
5253 call free_all_values. We can't call free_all_values
5254 because we might be in the middle of evaluating a
5255 function call. */
5256 struct value *mark = value_mark ();
5257
5258 if (is_watchpoint (b))
5259 w = (struct watchpoint *) b;
5260 else
5261 w = NULL;
5262
5263 /* Need to select the frame, with all that implies so that
5264 the conditions will have the right context. Because we
5265 use the frame, we will not see an inlined function's
5266 variables when we arrive at a breakpoint at the start
5267 of the inlined function; the current frame will be the
5268 call site. */
5269 if (w == NULL || w->cond_exp_valid_block == NULL)
5270 select_frame (get_current_frame ());
5271 else
5272 {
5273 struct frame_info *frame;
5274
5275 /* For local watchpoint expressions, which particular
5276 instance of a local is being watched matters, so we
5277 keep track of the frame to evaluate the expression
5278 in. To evaluate the condition however, it doesn't
5279 really matter which instantiation of the function
5280 where the condition makes sense triggers the
5281 watchpoint. This allows an expression like "watch
5282 global if q > 10" set in `func', catch writes to
5283 global on all threads that call `func', or catch
5284 writes on all recursive calls of `func' by a single
5285 thread. We simply always evaluate the condition in
5286 the innermost frame that's executing where it makes
5287 sense to evaluate the condition. It seems
5288 intuitive. */
5289 frame = block_innermost_frame (w->cond_exp_valid_block);
5290 if (frame != NULL)
5291 select_frame (frame);
5292 else
5293 within_current_scope = 0;
5294 }
5295 if (within_current_scope)
5296 {
5297 TRY
5298 {
5299 condition_result = breakpoint_cond_eval (cond);
5300 }
5301 CATCH (ex, RETURN_MASK_ALL)
5302 {
5303 exception_fprintf (gdb_stderr, ex,
5304 "Error in testing breakpoint condition:\n");
5305 }
5306 END_CATCH
5307 }
5308 else
5309 {
5310 warning (_("Watchpoint condition cannot be tested "
5311 "in the current scope"));
5312 /* If we failed to set the right context for this
5313 watchpoint, unconditionally report it. */
5314 }
5315 /* FIXME-someday, should give breakpoint #. */
5316 value_free_to_mark (mark);
5317 }
5318
5319 if (cond && !condition_result)
5320 {
5321 bs->stop = 0;
5322 }
5323 else if (b->ignore_count > 0)
5324 {
5325 b->ignore_count--;
5326 bs->stop = 0;
5327 /* Increase the hit count even though we don't stop. */
5328 ++(b->hit_count);
5329 observer_notify_breakpoint_modified (b);
5330 }
5331 }
5332
5333 /* Returns true if we need to track moribund locations of LOC's type
5334 on the current target. */
5335
5336 static int
5337 need_moribund_for_location_type (struct bp_location *loc)
5338 {
5339 return ((loc->loc_type == bp_loc_software_breakpoint
5340 && !target_supports_stopped_by_sw_breakpoint ())
5341 || (loc->loc_type == bp_loc_hardware_breakpoint
5342 && !target_supports_stopped_by_hw_breakpoint ()));
5343 }
5344
5345
5346 /* Get a bpstat associated with having just stopped at address
5347 BP_ADDR in thread PTID.
5348
5349 Determine whether we stopped at a breakpoint, etc, or whether we
5350 don't understand this stop. Result is a chain of bpstat's such
5351 that:
5352
5353 if we don't understand the stop, the result is a null pointer.
5354
5355 if we understand why we stopped, the result is not null.
5356
5357 Each element of the chain refers to a particular breakpoint or
5358 watchpoint at which we have stopped. (We may have stopped for
5359 several reasons concurrently.)
5360
5361 Each element of the chain has valid next, breakpoint_at,
5362 commands, FIXME??? fields. */
5363
5364 bpstat
5365 bpstat_stop_status (const address_space *aspace,
5366 CORE_ADDR bp_addr, ptid_t ptid,
5367 const struct target_waitstatus *ws)
5368 {
5369 struct breakpoint *b = NULL;
5370 struct bp_location *bl;
5371 struct bp_location *loc;
5372 /* First item of allocated bpstat's. */
5373 bpstat bs_head = NULL, *bs_link = &bs_head;
5374 /* Pointer to the last thing in the chain currently. */
5375 bpstat bs;
5376 int ix;
5377 int need_remove_insert;
5378 int removed_any;
5379
5380 /* First, build the bpstat chain with locations that explain a
5381 target stop, while being careful to not set the target running,
5382 as that may invalidate locations (in particular watchpoint
5383 locations are recreated). Resuming will happen here with
5384 breakpoint conditions or watchpoint expressions that include
5385 inferior function calls. */
5386
5387 ALL_BREAKPOINTS (b)
5388 {
5389 if (!breakpoint_enabled (b))
5390 continue;
5391
5392 for (bl = b->loc; bl != NULL; bl = bl->next)
5393 {
5394 /* For hardware watchpoints, we look only at the first
5395 location. The watchpoint_check function will work on the
5396 entire expression, not the individual locations. For
5397 read watchpoints, the watchpoints_triggered function has
5398 checked all locations already. */
5399 if (b->type == bp_hardware_watchpoint && bl != b->loc)
5400 break;
5401
5402 if (!bl->enabled || bl->shlib_disabled)
5403 continue;
5404
5405 if (!bpstat_check_location (bl, aspace, bp_addr, ws))
5406 continue;
5407
5408 /* Come here if it's a watchpoint, or if the break address
5409 matches. */
5410
5411 bs = new bpstats (bl, &bs_link); /* Alloc a bpstat to
5412 explain stop. */
5413
5414 /* Assume we stop. Should we find a watchpoint that is not
5415 actually triggered, or if the condition of the breakpoint
5416 evaluates as false, we'll reset 'stop' to 0. */
5417 bs->stop = 1;
5418 bs->print = 1;
5419
5420 /* If this is a scope breakpoint, mark the associated
5421 watchpoint as triggered so that we will handle the
5422 out-of-scope event. We'll get to the watchpoint next
5423 iteration. */
5424 if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
5425 {
5426 struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5427
5428 w->watchpoint_triggered = watch_triggered_yes;
5429 }
5430 }
5431 }
5432
5433 /* Check if a moribund breakpoint explains the stop. */
5434 if (!target_supports_stopped_by_sw_breakpoint ()
5435 || !target_supports_stopped_by_hw_breakpoint ())
5436 {
5437 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
5438 {
5439 if (breakpoint_location_address_match (loc, aspace, bp_addr)
5440 && need_moribund_for_location_type (loc))
5441 {
5442 bs = new bpstats (loc, &bs_link);
5443 /* For hits of moribund locations, we should just proceed. */
5444 bs->stop = 0;
5445 bs->print = 0;
5446 bs->print_it = print_it_noop;
5447 }
5448 }
5449 }
5450
5451 /* A bit of special processing for shlib breakpoints. We need to
5452 process solib loading here, so that the lists of loaded and
5453 unloaded libraries are correct before we handle "catch load" and
5454 "catch unload". */
5455 for (bs = bs_head; bs != NULL; bs = bs->next)
5456 {
5457 if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
5458 {
5459 handle_solib_event ();
5460 break;
5461 }
5462 }
5463
5464 /* Now go through the locations that caused the target to stop, and
5465 check whether we're interested in reporting this stop to higher
5466 layers, or whether we should resume the target transparently. */
5467
5468 removed_any = 0;
5469
5470 for (bs = bs_head; bs != NULL; bs = bs->next)
5471 {
5472 if (!bs->stop)
5473 continue;
5474
5475 b = bs->breakpoint_at;
5476 b->ops->check_status (bs);
5477 if (bs->stop)
5478 {
5479 bpstat_check_breakpoint_conditions (bs, ptid);
5480
5481 if (bs->stop)
5482 {
5483 ++(b->hit_count);
5484 observer_notify_breakpoint_modified (b);
5485
5486 /* We will stop here. */
5487 if (b->disposition == disp_disable)
5488 {
5489 --(b->enable_count);
5490 if (b->enable_count <= 0)
5491 b->enable_state = bp_disabled;
5492 removed_any = 1;
5493 }
5494 if (b->silent)
5495 bs->print = 0;
5496 bs->commands = b->commands;
5497 if (command_line_is_silent (bs->commands
5498 ? bs->commands.get () : NULL))
5499 bs->print = 0;
5500
5501 b->ops->after_condition_true (bs);
5502 }
5503
5504 }
5505
5506 /* Print nothing for this entry if we don't stop or don't
5507 print. */
5508 if (!bs->stop || !bs->print)
5509 bs->print_it = print_it_noop;
5510 }
5511
5512 /* If we aren't stopping, the value of some hardware watchpoint may
5513 not have changed, but the intermediate memory locations we are
5514 watching may have. Don't bother if we're stopping; this will get
5515 done later. */
5516 need_remove_insert = 0;
5517 if (! bpstat_causes_stop (bs_head))
5518 for (bs = bs_head; bs != NULL; bs = bs->next)
5519 if (!bs->stop
5520 && bs->breakpoint_at
5521 && is_hardware_watchpoint (bs->breakpoint_at))
5522 {
5523 struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5524
5525 update_watchpoint (w, 0 /* don't reparse. */);
5526 need_remove_insert = 1;
5527 }
5528
5529 if (need_remove_insert)
5530 update_global_location_list (UGLL_MAY_INSERT);
5531 else if (removed_any)
5532 update_global_location_list (UGLL_DONT_INSERT);
5533
5534 return bs_head;
5535 }
5536
5537 static void
5538 handle_jit_event (void)
5539 {
5540 struct frame_info *frame;
5541 struct gdbarch *gdbarch;
5542
5543 if (debug_infrun)
5544 fprintf_unfiltered (gdb_stdlog, "handling bp_jit_event\n");
5545
5546 /* Switch terminal for any messages produced by
5547 breakpoint_re_set. */
5548 target_terminal::ours_for_output ();
5549
5550 frame = get_current_frame ();
5551 gdbarch = get_frame_arch (frame);
5552
5553 jit_event_handler (gdbarch);
5554
5555 target_terminal::inferior ();
5556 }
5557
5558 /* Prepare WHAT final decision for infrun. */
5559
5560 /* Decide what infrun needs to do with this bpstat. */
5561
5562 struct bpstat_what
5563 bpstat_what (bpstat bs_head)
5564 {
5565 struct bpstat_what retval;
5566 bpstat bs;
5567
5568 retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
5569 retval.call_dummy = STOP_NONE;
5570 retval.is_longjmp = 0;
5571
5572 for (bs = bs_head; bs != NULL; bs = bs->next)
5573 {
5574 /* Extract this BS's action. After processing each BS, we check
5575 if its action overrides all we've seem so far. */
5576 enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5577 enum bptype bptype;
5578
5579 if (bs->breakpoint_at == NULL)
5580 {
5581 /* I suspect this can happen if it was a momentary
5582 breakpoint which has since been deleted. */
5583 bptype = bp_none;
5584 }
5585 else
5586 bptype = bs->breakpoint_at->type;
5587
5588 switch (bptype)
5589 {
5590 case bp_none:
5591 break;
5592 case bp_breakpoint:
5593 case bp_hardware_breakpoint:
5594 case bp_single_step:
5595 case bp_until:
5596 case bp_finish:
5597 case bp_shlib_event:
5598 if (bs->stop)
5599 {
5600 if (bs->print)
5601 this_action = BPSTAT_WHAT_STOP_NOISY;
5602 else
5603 this_action = BPSTAT_WHAT_STOP_SILENT;
5604 }
5605 else
5606 this_action = BPSTAT_WHAT_SINGLE;
5607 break;
5608 case bp_watchpoint:
5609 case bp_hardware_watchpoint:
5610 case bp_read_watchpoint:
5611 case bp_access_watchpoint:
5612 if (bs->stop)
5613 {
5614 if (bs->print)
5615 this_action = BPSTAT_WHAT_STOP_NOISY;
5616 else
5617 this_action = BPSTAT_WHAT_STOP_SILENT;
5618 }
5619 else
5620 {
5621 /* There was a watchpoint, but we're not stopping.
5622 This requires no further action. */
5623 }
5624 break;
5625 case bp_longjmp:
5626 case bp_longjmp_call_dummy:
5627 case bp_exception:
5628 if (bs->stop)
5629 {
5630 this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5631 retval.is_longjmp = bptype != bp_exception;
5632 }
5633 else
5634 this_action = BPSTAT_WHAT_SINGLE;
5635 break;
5636 case bp_longjmp_resume:
5637 case bp_exception_resume:
5638 if (bs->stop)
5639 {
5640 this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5641 retval.is_longjmp = bptype == bp_longjmp_resume;
5642 }
5643 else
5644 this_action = BPSTAT_WHAT_SINGLE;
5645 break;
5646 case bp_step_resume:
5647 if (bs->stop)
5648 this_action = BPSTAT_WHAT_STEP_RESUME;
5649 else
5650 {
5651 /* It is for the wrong frame. */
5652 this_action = BPSTAT_WHAT_SINGLE;
5653 }
5654 break;
5655 case bp_hp_step_resume:
5656 if (bs->stop)
5657 this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5658 else
5659 {
5660 /* It is for the wrong frame. */
5661 this_action = BPSTAT_WHAT_SINGLE;
5662 }
5663 break;
5664 case bp_watchpoint_scope:
5665 case bp_thread_event:
5666 case bp_overlay_event:
5667 case bp_longjmp_master:
5668 case bp_std_terminate_master:
5669 case bp_exception_master:
5670 this_action = BPSTAT_WHAT_SINGLE;
5671 break;
5672 case bp_catchpoint:
5673 if (bs->stop)
5674 {
5675 if (bs->print)
5676 this_action = BPSTAT_WHAT_STOP_NOISY;
5677 else
5678 this_action = BPSTAT_WHAT_STOP_SILENT;
5679 }
5680 else
5681 {
5682 /* There was a catchpoint, but we're not stopping.
5683 This requires no further action. */
5684 }
5685 break;
5686 case bp_jit_event:
5687 this_action = BPSTAT_WHAT_SINGLE;
5688 break;
5689 case bp_call_dummy:
5690 /* Make sure the action is stop (silent or noisy),
5691 so infrun.c pops the dummy frame. */
5692 retval.call_dummy = STOP_STACK_DUMMY;
5693 this_action = BPSTAT_WHAT_STOP_SILENT;
5694 break;
5695 case bp_std_terminate:
5696 /* Make sure the action is stop (silent or noisy),
5697 so infrun.c pops the dummy frame. */
5698 retval.call_dummy = STOP_STD_TERMINATE;
5699 this_action = BPSTAT_WHAT_STOP_SILENT;
5700 break;
5701 case bp_tracepoint:
5702 case bp_fast_tracepoint:
5703 case bp_static_tracepoint:
5704 /* Tracepoint hits should not be reported back to GDB, and
5705 if one got through somehow, it should have been filtered
5706 out already. */
5707 internal_error (__FILE__, __LINE__,
5708 _("bpstat_what: tracepoint encountered"));
5709 break;
5710 case bp_gnu_ifunc_resolver:
5711 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5712 this_action = BPSTAT_WHAT_SINGLE;
5713 break;
5714 case bp_gnu_ifunc_resolver_return:
5715 /* The breakpoint will be removed, execution will restart from the
5716 PC of the former breakpoint. */
5717 this_action = BPSTAT_WHAT_KEEP_CHECKING;
5718 break;
5719
5720 case bp_dprintf:
5721 if (bs->stop)
5722 this_action = BPSTAT_WHAT_STOP_SILENT;
5723 else
5724 this_action = BPSTAT_WHAT_SINGLE;
5725 break;
5726
5727 default:
5728 internal_error (__FILE__, __LINE__,
5729 _("bpstat_what: unhandled bptype %d"), (int) bptype);
5730 }
5731
5732 retval.main_action = std::max (retval.main_action, this_action);
5733 }
5734
5735 return retval;
5736 }
5737
5738 void
5739 bpstat_run_callbacks (bpstat bs_head)
5740 {
5741 bpstat bs;
5742
5743 for (bs = bs_head; bs != NULL; bs = bs->next)
5744 {
5745 struct breakpoint *b = bs->breakpoint_at;
5746
5747 if (b == NULL)
5748 continue;
5749 switch (b->type)
5750 {
5751 case bp_jit_event:
5752 handle_jit_event ();
5753 break;
5754 case bp_gnu_ifunc_resolver:
5755 gnu_ifunc_resolver_stop (b);
5756 break;
5757 case bp_gnu_ifunc_resolver_return:
5758 gnu_ifunc_resolver_return_stop (b);
5759 break;
5760 }
5761 }
5762 }
5763
5764 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5765 without hardware support). This isn't related to a specific bpstat,
5766 just to things like whether watchpoints are set. */
5767
5768 int
5769 bpstat_should_step (void)
5770 {
5771 struct breakpoint *b;
5772
5773 ALL_BREAKPOINTS (b)
5774 if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
5775 return 1;
5776 return 0;
5777 }
5778
5779 int
5780 bpstat_causes_stop (bpstat bs)
5781 {
5782 for (; bs != NULL; bs = bs->next)
5783 if (bs->stop)
5784 return 1;
5785
5786 return 0;
5787 }
5788
5789
5790
5791 /* Compute a string of spaces suitable to indent the next line
5792 so it starts at the position corresponding to the table column
5793 named COL_NAME in the currently active table of UIOUT. */
5794
5795 static char *
5796 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
5797 {
5798 static char wrap_indent[80];
5799 int i, total_width, width, align;
5800 const char *text;
5801
5802 total_width = 0;
5803 for (i = 1; uiout->query_table_field (i, &width, &align, &text); i++)
5804 {
5805 if (strcmp (text, col_name) == 0)
5806 {
5807 gdb_assert (total_width < sizeof wrap_indent);
5808 memset (wrap_indent, ' ', total_width);
5809 wrap_indent[total_width] = 0;
5810
5811 return wrap_indent;
5812 }
5813
5814 total_width += width + 1;
5815 }
5816
5817 return NULL;
5818 }
5819
5820 /* Determine if the locations of this breakpoint will have their conditions
5821 evaluated by the target, host or a mix of both. Returns the following:
5822
5823 "host": Host evals condition.
5824 "host or target": Host or Target evals condition.
5825 "target": Target evals condition.
5826 */
5827
5828 static const char *
5829 bp_condition_evaluator (struct breakpoint *b)
5830 {
5831 struct bp_location *bl;
5832 char host_evals = 0;
5833 char target_evals = 0;
5834
5835 if (!b)
5836 return NULL;
5837
5838 if (!is_breakpoint (b))
5839 return NULL;
5840
5841 if (gdb_evaluates_breakpoint_condition_p ()
5842 || !target_supports_evaluation_of_breakpoint_conditions ())
5843 return condition_evaluation_host;
5844
5845 for (bl = b->loc; bl; bl = bl->next)
5846 {
5847 if (bl->cond_bytecode)
5848 target_evals++;
5849 else
5850 host_evals++;
5851 }
5852
5853 if (host_evals && target_evals)
5854 return condition_evaluation_both;
5855 else if (target_evals)
5856 return condition_evaluation_target;
5857 else
5858 return condition_evaluation_host;
5859 }
5860
5861 /* Determine the breakpoint location's condition evaluator. This is
5862 similar to bp_condition_evaluator, but for locations. */
5863
5864 static const char *
5865 bp_location_condition_evaluator (struct bp_location *bl)
5866 {
5867 if (bl && !is_breakpoint (bl->owner))
5868 return NULL;
5869
5870 if (gdb_evaluates_breakpoint_condition_p ()
5871 || !target_supports_evaluation_of_breakpoint_conditions ())
5872 return condition_evaluation_host;
5873
5874 if (bl && bl->cond_bytecode)
5875 return condition_evaluation_target;
5876 else
5877 return condition_evaluation_host;
5878 }
5879
5880 /* Print the LOC location out of the list of B->LOC locations. */
5881
5882 static void
5883 print_breakpoint_location (struct breakpoint *b,
5884 struct bp_location *loc)
5885 {
5886 struct ui_out *uiout = current_uiout;
5887
5888 scoped_restore_current_program_space restore_pspace;
5889
5890 if (loc != NULL && loc->shlib_disabled)
5891 loc = NULL;
5892
5893 if (loc != NULL)
5894 set_current_program_space (loc->pspace);
5895
5896 if (b->display_canonical)
5897 uiout->field_string ("what", event_location_to_string (b->location.get ()));
5898 else if (loc && loc->symtab)
5899 {
5900 const struct symbol *sym = loc->symbol;
5901
5902 if (sym == NULL)
5903 sym = find_pc_sect_function (loc->address, loc->section);
5904
5905 if (sym)
5906 {
5907 uiout->text ("in ");
5908 uiout->field_string ("func", SYMBOL_PRINT_NAME (sym));
5909 uiout->text (" ");
5910 uiout->wrap_hint (wrap_indent_at_field (uiout, "what"));
5911 uiout->text ("at ");
5912 }
5913 uiout->field_string ("file",
5914 symtab_to_filename_for_display (loc->symtab));
5915 uiout->text (":");
5916
5917 if (uiout->is_mi_like_p ())
5918 uiout->field_string ("fullname", symtab_to_fullname (loc->symtab));
5919
5920 uiout->field_int ("line", loc->line_number);
5921 }
5922 else if (loc)
5923 {
5924 string_file stb;
5925
5926 print_address_symbolic (loc->gdbarch, loc->address, &stb,
5927 demangle, "");
5928 uiout->field_stream ("at", stb);
5929 }
5930 else
5931 {
5932 uiout->field_string ("pending",
5933 event_location_to_string (b->location.get ()));
5934 /* If extra_string is available, it could be holding a condition
5935 or dprintf arguments. In either case, make sure it is printed,
5936 too, but only for non-MI streams. */
5937 if (!uiout->is_mi_like_p () && b->extra_string != NULL)
5938 {
5939 if (b->type == bp_dprintf)
5940 uiout->text (",");
5941 else
5942 uiout->text (" ");
5943 uiout->text (b->extra_string);
5944 }
5945 }
5946
5947 if (loc && is_breakpoint (b)
5948 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5949 && bp_condition_evaluator (b) == condition_evaluation_both)
5950 {
5951 uiout->text (" (");
5952 uiout->field_string ("evaluated-by",
5953 bp_location_condition_evaluator (loc));
5954 uiout->text (")");
5955 }
5956 }
5957
5958 static const char *
5959 bptype_string (enum bptype type)
5960 {
5961 struct ep_type_description
5962 {
5963 enum bptype type;
5964 const char *description;
5965 };
5966 static struct ep_type_description bptypes[] =
5967 {
5968 {bp_none, "?deleted?"},
5969 {bp_breakpoint, "breakpoint"},
5970 {bp_hardware_breakpoint, "hw breakpoint"},
5971 {bp_single_step, "sw single-step"},
5972 {bp_until, "until"},
5973 {bp_finish, "finish"},
5974 {bp_watchpoint, "watchpoint"},
5975 {bp_hardware_watchpoint, "hw watchpoint"},
5976 {bp_read_watchpoint, "read watchpoint"},
5977 {bp_access_watchpoint, "acc watchpoint"},
5978 {bp_longjmp, "longjmp"},
5979 {bp_longjmp_resume, "longjmp resume"},
5980 {bp_longjmp_call_dummy, "longjmp for call dummy"},
5981 {bp_exception, "exception"},
5982 {bp_exception_resume, "exception resume"},
5983 {bp_step_resume, "step resume"},
5984 {bp_hp_step_resume, "high-priority step resume"},
5985 {bp_watchpoint_scope, "watchpoint scope"},
5986 {bp_call_dummy, "call dummy"},
5987 {bp_std_terminate, "std::terminate"},
5988 {bp_shlib_event, "shlib events"},
5989 {bp_thread_event, "thread events"},
5990 {bp_overlay_event, "overlay events"},
5991 {bp_longjmp_master, "longjmp master"},
5992 {bp_std_terminate_master, "std::terminate master"},
5993 {bp_exception_master, "exception master"},
5994 {bp_catchpoint, "catchpoint"},
5995 {bp_tracepoint, "tracepoint"},
5996 {bp_fast_tracepoint, "fast tracepoint"},
5997 {bp_static_tracepoint, "static tracepoint"},
5998 {bp_dprintf, "dprintf"},
5999 {bp_jit_event, "jit events"},
6000 {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
6001 {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
6002 };
6003
6004 if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
6005 || ((int) type != bptypes[(int) type].type))
6006 internal_error (__FILE__, __LINE__,
6007 _("bptypes table does not describe type #%d."),
6008 (int) type);
6009
6010 return bptypes[(int) type].description;
6011 }
6012
6013 /* For MI, output a field named 'thread-groups' with a list as the value.
6014 For CLI, prefix the list with the string 'inf'. */
6015
6016 static void
6017 output_thread_groups (struct ui_out *uiout,
6018 const char *field_name,
6019 const std::vector<int> &inf_nums,
6020 int mi_only)
6021 {
6022 int is_mi = uiout->is_mi_like_p ();
6023
6024 /* For backward compatibility, don't display inferiors in CLI unless
6025 there are several. Always display them for MI. */
6026 if (!is_mi && mi_only)
6027 return;
6028
6029 ui_out_emit_list list_emitter (uiout, field_name);
6030
6031 for (size_t i = 0; i < inf_nums.size (); i++)
6032 {
6033 if (is_mi)
6034 {
6035 char mi_group[10];
6036
6037 xsnprintf (mi_group, sizeof (mi_group), "i%d", inf_nums[i]);
6038 uiout->field_string (NULL, mi_group);
6039 }
6040 else
6041 {
6042 if (i == 0)
6043 uiout->text (" inf ");
6044 else
6045 uiout->text (", ");
6046
6047 uiout->text (plongest (inf_nums[i]));
6048 }
6049 }
6050 }
6051
6052 /* Print B to gdb_stdout. */
6053
6054 static void
6055 print_one_breakpoint_location (struct breakpoint *b,
6056 struct bp_location *loc,
6057 int loc_number,
6058 struct bp_location **last_loc,
6059 int allflag)
6060 {
6061 struct command_line *l;
6062 static char bpenables[] = "nynny";
6063
6064 struct ui_out *uiout = current_uiout;
6065 int header_of_multiple = 0;
6066 int part_of_multiple = (loc != NULL);
6067 struct value_print_options opts;
6068
6069 get_user_print_options (&opts);
6070
6071 gdb_assert (!loc || loc_number != 0);
6072 /* See comment in print_one_breakpoint concerning treatment of
6073 breakpoints with single disabled location. */
6074 if (loc == NULL
6075 && (b->loc != NULL
6076 && (b->loc->next != NULL || !b->loc->enabled)))
6077 header_of_multiple = 1;
6078 if (loc == NULL)
6079 loc = b->loc;
6080
6081 annotate_record ();
6082
6083 /* 1 */
6084 annotate_field (0);
6085 if (part_of_multiple)
6086 {
6087 char *formatted;
6088 formatted = xstrprintf ("%d.%d", b->number, loc_number);
6089 uiout->field_string ("number", formatted);
6090 xfree (formatted);
6091 }
6092 else
6093 {
6094 uiout->field_int ("number", b->number);
6095 }
6096
6097 /* 2 */
6098 annotate_field (1);
6099 if (part_of_multiple)
6100 uiout->field_skip ("type");
6101 else
6102 uiout->field_string ("type", bptype_string (b->type));
6103
6104 /* 3 */
6105 annotate_field (2);
6106 if (part_of_multiple)
6107 uiout->field_skip ("disp");
6108 else
6109 uiout->field_string ("disp", bpdisp_text (b->disposition));
6110
6111
6112 /* 4 */
6113 annotate_field (3);
6114 if (part_of_multiple)
6115 uiout->field_string ("enabled", loc->enabled ? "y" : "n");
6116 else
6117 uiout->field_fmt ("enabled", "%c", bpenables[(int) b->enable_state]);
6118 uiout->spaces (2);
6119
6120
6121 /* 5 and 6 */
6122 if (b->ops != NULL && b->ops->print_one != NULL)
6123 {
6124 /* Although the print_one can possibly print all locations,
6125 calling it here is not likely to get any nice result. So,
6126 make sure there's just one location. */
6127 gdb_assert (b->loc == NULL || b->loc->next == NULL);
6128 b->ops->print_one (b, last_loc);
6129 }
6130 else
6131 switch (b->type)
6132 {
6133 case bp_none:
6134 internal_error (__FILE__, __LINE__,
6135 _("print_one_breakpoint: bp_none encountered\n"));
6136 break;
6137
6138 case bp_watchpoint:
6139 case bp_hardware_watchpoint:
6140 case bp_read_watchpoint:
6141 case bp_access_watchpoint:
6142 {
6143 struct watchpoint *w = (struct watchpoint *) b;
6144
6145 /* Field 4, the address, is omitted (which makes the columns
6146 not line up too nicely with the headers, but the effect
6147 is relatively readable). */
6148 if (opts.addressprint)
6149 uiout->field_skip ("addr");
6150 annotate_field (5);
6151 uiout->field_string ("what", w->exp_string);
6152 }
6153 break;
6154
6155 case bp_breakpoint:
6156 case bp_hardware_breakpoint:
6157 case bp_single_step:
6158 case bp_until:
6159 case bp_finish:
6160 case bp_longjmp:
6161 case bp_longjmp_resume:
6162 case bp_longjmp_call_dummy:
6163 case bp_exception:
6164 case bp_exception_resume:
6165 case bp_step_resume:
6166 case bp_hp_step_resume:
6167 case bp_watchpoint_scope:
6168 case bp_call_dummy:
6169 case bp_std_terminate:
6170 case bp_shlib_event:
6171 case bp_thread_event:
6172 case bp_overlay_event:
6173 case bp_longjmp_master:
6174 case bp_std_terminate_master:
6175 case bp_exception_master:
6176 case bp_tracepoint:
6177 case bp_fast_tracepoint:
6178 case bp_static_tracepoint:
6179 case bp_dprintf:
6180 case bp_jit_event:
6181 case bp_gnu_ifunc_resolver:
6182 case bp_gnu_ifunc_resolver_return:
6183 if (opts.addressprint)
6184 {
6185 annotate_field (4);
6186 if (header_of_multiple)
6187 uiout->field_string ("addr", "<MULTIPLE>");
6188 else if (b->loc == NULL || loc->shlib_disabled)
6189 uiout->field_string ("addr", "<PENDING>");
6190 else
6191 uiout->field_core_addr ("addr",
6192 loc->gdbarch, loc->address);
6193 }
6194 annotate_field (5);
6195 if (!header_of_multiple)
6196 print_breakpoint_location (b, loc);
6197 if (b->loc)
6198 *last_loc = b->loc;
6199 break;
6200 }
6201
6202
6203 if (loc != NULL && !header_of_multiple)
6204 {
6205 struct inferior *inf;
6206 std::vector<int> inf_nums;
6207 int mi_only = 1;
6208
6209 ALL_INFERIORS (inf)
6210 {
6211 if (inf->pspace == loc->pspace)
6212 inf_nums.push_back (inf->num);
6213 }
6214
6215 /* For backward compatibility, don't display inferiors in CLI unless
6216 there are several. Always display for MI. */
6217 if (allflag
6218 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6219 && (number_of_program_spaces () > 1
6220 || number_of_inferiors () > 1)
6221 /* LOC is for existing B, it cannot be in
6222 moribund_locations and thus having NULL OWNER. */
6223 && loc->owner->type != bp_catchpoint))
6224 mi_only = 0;
6225 output_thread_groups (uiout, "thread-groups", inf_nums, mi_only);
6226 }
6227
6228 if (!part_of_multiple)
6229 {
6230 if (b->thread != -1)
6231 {
6232 /* FIXME: This seems to be redundant and lost here; see the
6233 "stop only in" line a little further down. */
6234 uiout->text (" thread ");
6235 uiout->field_int ("thread", b->thread);
6236 }
6237 else if (b->task != 0)
6238 {
6239 uiout->text (" task ");
6240 uiout->field_int ("task", b->task);
6241 }
6242 }
6243
6244 uiout->text ("\n");
6245
6246 if (!part_of_multiple)
6247 b->ops->print_one_detail (b, uiout);
6248
6249 if (part_of_multiple && frame_id_p (b->frame_id))
6250 {
6251 annotate_field (6);
6252 uiout->text ("\tstop only in stack frame at ");
6253 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6254 the frame ID. */
6255 uiout->field_core_addr ("frame",
6256 b->gdbarch, b->frame_id.stack_addr);
6257 uiout->text ("\n");
6258 }
6259
6260 if (!part_of_multiple && b->cond_string)
6261 {
6262 annotate_field (7);
6263 if (is_tracepoint (b))
6264 uiout->text ("\ttrace only if ");
6265 else
6266 uiout->text ("\tstop only if ");
6267 uiout->field_string ("cond", b->cond_string);
6268
6269 /* Print whether the target is doing the breakpoint's condition
6270 evaluation. If GDB is doing the evaluation, don't print anything. */
6271 if (is_breakpoint (b)
6272 && breakpoint_condition_evaluation_mode ()
6273 == condition_evaluation_target)
6274 {
6275 uiout->text (" (");
6276 uiout->field_string ("evaluated-by",
6277 bp_condition_evaluator (b));
6278 uiout->text (" evals)");
6279 }
6280 uiout->text ("\n");
6281 }
6282
6283 if (!part_of_multiple && b->thread != -1)
6284 {
6285 /* FIXME should make an annotation for this. */
6286 uiout->text ("\tstop only in thread ");
6287 if (uiout->is_mi_like_p ())
6288 uiout->field_int ("thread", b->thread);
6289 else
6290 {
6291 struct thread_info *thr = find_thread_global_id (b->thread);
6292
6293 uiout->field_string ("thread", print_thread_id (thr));
6294 }
6295 uiout->text ("\n");
6296 }
6297
6298 if (!part_of_multiple)
6299 {
6300 if (b->hit_count)
6301 {
6302 /* FIXME should make an annotation for this. */
6303 if (is_catchpoint (b))
6304 uiout->text ("\tcatchpoint");
6305 else if (is_tracepoint (b))
6306 uiout->text ("\ttracepoint");
6307 else
6308 uiout->text ("\tbreakpoint");
6309 uiout->text (" already hit ");
6310 uiout->field_int ("times", b->hit_count);
6311 if (b->hit_count == 1)
6312 uiout->text (" time\n");
6313 else
6314 uiout->text (" times\n");
6315 }
6316 else
6317 {
6318 /* Output the count also if it is zero, but only if this is mi. */
6319 if (uiout->is_mi_like_p ())
6320 uiout->field_int ("times", b->hit_count);
6321 }
6322 }
6323
6324 if (!part_of_multiple && b->ignore_count)
6325 {
6326 annotate_field (8);
6327 uiout->text ("\tignore next ");
6328 uiout->field_int ("ignore", b->ignore_count);
6329 uiout->text (" hits\n");
6330 }
6331
6332 /* Note that an enable count of 1 corresponds to "enable once"
6333 behavior, which is reported by the combination of enablement and
6334 disposition, so we don't need to mention it here. */
6335 if (!part_of_multiple && b->enable_count > 1)
6336 {
6337 annotate_field (8);
6338 uiout->text ("\tdisable after ");
6339 /* Tweak the wording to clarify that ignore and enable counts
6340 are distinct, and have additive effect. */
6341 if (b->ignore_count)
6342 uiout->text ("additional ");
6343 else
6344 uiout->text ("next ");
6345 uiout->field_int ("enable", b->enable_count);
6346 uiout->text (" hits\n");
6347 }
6348
6349 if (!part_of_multiple && is_tracepoint (b))
6350 {
6351 struct tracepoint *tp = (struct tracepoint *) b;
6352
6353 if (tp->traceframe_usage)
6354 {
6355 uiout->text ("\ttrace buffer usage ");
6356 uiout->field_int ("traceframe-usage", tp->traceframe_usage);
6357 uiout->text (" bytes\n");
6358 }
6359 }
6360
6361 l = b->commands ? b->commands.get () : NULL;
6362 if (!part_of_multiple && l)
6363 {
6364 annotate_field (9);
6365 ui_out_emit_tuple tuple_emitter (uiout, "script");
6366 print_command_lines (uiout, l, 4);
6367 }
6368
6369 if (is_tracepoint (b))
6370 {
6371 struct tracepoint *t = (struct tracepoint *) b;
6372
6373 if (!part_of_multiple && t->pass_count)
6374 {
6375 annotate_field (10);
6376 uiout->text ("\tpass count ");
6377 uiout->field_int ("pass", t->pass_count);
6378 uiout->text (" \n");
6379 }
6380
6381 /* Don't display it when tracepoint or tracepoint location is
6382 pending. */
6383 if (!header_of_multiple && loc != NULL && !loc->shlib_disabled)
6384 {
6385 annotate_field (11);
6386
6387 if (uiout->is_mi_like_p ())
6388 uiout->field_string ("installed",
6389 loc->inserted ? "y" : "n");
6390 else
6391 {
6392 if (loc->inserted)
6393 uiout->text ("\t");
6394 else
6395 uiout->text ("\tnot ");
6396 uiout->text ("installed on target\n");
6397 }
6398 }
6399 }
6400
6401 if (uiout->is_mi_like_p () && !part_of_multiple)
6402 {
6403 if (is_watchpoint (b))
6404 {
6405 struct watchpoint *w = (struct watchpoint *) b;
6406
6407 uiout->field_string ("original-location", w->exp_string);
6408 }
6409 else if (b->location != NULL
6410 && event_location_to_string (b->location.get ()) != NULL)
6411 uiout->field_string ("original-location",
6412 event_location_to_string (b->location.get ()));
6413 }
6414 }
6415
6416 static void
6417 print_one_breakpoint (struct breakpoint *b,
6418 struct bp_location **last_loc,
6419 int allflag)
6420 {
6421 struct ui_out *uiout = current_uiout;
6422
6423 {
6424 ui_out_emit_tuple tuple_emitter (uiout, "bkpt");
6425
6426 print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
6427 }
6428
6429 /* If this breakpoint has custom print function,
6430 it's already printed. Otherwise, print individual
6431 locations, if any. */
6432 if (b->ops == NULL || b->ops->print_one == NULL)
6433 {
6434 /* If breakpoint has a single location that is disabled, we
6435 print it as if it had several locations, since otherwise it's
6436 hard to represent "breakpoint enabled, location disabled"
6437 situation.
6438
6439 Note that while hardware watchpoints have several locations
6440 internally, that's not a property exposed to user. */
6441 if (b->loc
6442 && !is_hardware_watchpoint (b)
6443 && (b->loc->next || !b->loc->enabled))
6444 {
6445 struct bp_location *loc;
6446 int n = 1;
6447
6448 for (loc = b->loc; loc; loc = loc->next, ++n)
6449 {
6450 ui_out_emit_tuple tuple_emitter (uiout, NULL);
6451 print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6452 }
6453 }
6454 }
6455 }
6456
6457 static int
6458 breakpoint_address_bits (struct breakpoint *b)
6459 {
6460 int print_address_bits = 0;
6461 struct bp_location *loc;
6462
6463 /* Software watchpoints that aren't watching memory don't have an
6464 address to print. */
6465 if (is_no_memory_software_watchpoint (b))
6466 return 0;
6467
6468 for (loc = b->loc; loc; loc = loc->next)
6469 {
6470 int addr_bit;
6471
6472 addr_bit = gdbarch_addr_bit (loc->gdbarch);
6473 if (addr_bit > print_address_bits)
6474 print_address_bits = addr_bit;
6475 }
6476
6477 return print_address_bits;
6478 }
6479
6480 /* See breakpoint.h. */
6481
6482 void
6483 print_breakpoint (breakpoint *b)
6484 {
6485 struct bp_location *dummy_loc = NULL;
6486 print_one_breakpoint (b, &dummy_loc, 0);
6487 }
6488
6489 /* Return true if this breakpoint was set by the user, false if it is
6490 internal or momentary. */
6491
6492 int
6493 user_breakpoint_p (struct breakpoint *b)
6494 {
6495 return b->number > 0;
6496 }
6497
6498 /* See breakpoint.h. */
6499
6500 int
6501 pending_breakpoint_p (struct breakpoint *b)
6502 {
6503 return b->loc == NULL;
6504 }
6505
6506 /* Print information on user settable breakpoint (watchpoint, etc)
6507 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6508 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6509 FILTER is non-NULL, call it on each breakpoint and only include the
6510 ones for which it returns non-zero. Return the total number of
6511 breakpoints listed. */
6512
6513 static int
6514 breakpoint_1 (const char *args, int allflag,
6515 int (*filter) (const struct breakpoint *))
6516 {
6517 struct breakpoint *b;
6518 struct bp_location *last_loc = NULL;
6519 int nr_printable_breakpoints;
6520 struct value_print_options opts;
6521 int print_address_bits = 0;
6522 int print_type_col_width = 14;
6523 struct ui_out *uiout = current_uiout;
6524
6525 get_user_print_options (&opts);
6526
6527 /* Compute the number of rows in the table, as well as the size
6528 required for address fields. */
6529 nr_printable_breakpoints = 0;
6530 ALL_BREAKPOINTS (b)
6531 {
6532 /* If we have a filter, only list the breakpoints it accepts. */
6533 if (filter && !filter (b))
6534 continue;
6535
6536 /* If we have an "args" string, it is a list of breakpoints to
6537 accept. Skip the others. */
6538 if (args != NULL && *args != '\0')
6539 {
6540 if (allflag && parse_and_eval_long (args) != b->number)
6541 continue;
6542 if (!allflag && !number_is_in_list (args, b->number))
6543 continue;
6544 }
6545
6546 if (allflag || user_breakpoint_p (b))
6547 {
6548 int addr_bit, type_len;
6549
6550 addr_bit = breakpoint_address_bits (b);
6551 if (addr_bit > print_address_bits)
6552 print_address_bits = addr_bit;
6553
6554 type_len = strlen (bptype_string (b->type));
6555 if (type_len > print_type_col_width)
6556 print_type_col_width = type_len;
6557
6558 nr_printable_breakpoints++;
6559 }
6560 }
6561
6562 {
6563 ui_out_emit_table table_emitter (uiout,
6564 opts.addressprint ? 6 : 5,
6565 nr_printable_breakpoints,
6566 "BreakpointTable");
6567
6568 if (nr_printable_breakpoints > 0)
6569 annotate_breakpoints_headers ();
6570 if (nr_printable_breakpoints > 0)
6571 annotate_field (0);
6572 uiout->table_header (7, ui_left, "number", "Num"); /* 1 */
6573 if (nr_printable_breakpoints > 0)
6574 annotate_field (1);
6575 uiout->table_header (print_type_col_width, ui_left, "type", "Type"); /* 2 */
6576 if (nr_printable_breakpoints > 0)
6577 annotate_field (2);
6578 uiout->table_header (4, ui_left, "disp", "Disp"); /* 3 */
6579 if (nr_printable_breakpoints > 0)
6580 annotate_field (3);
6581 uiout->table_header (3, ui_left, "enabled", "Enb"); /* 4 */
6582 if (opts.addressprint)
6583 {
6584 if (nr_printable_breakpoints > 0)
6585 annotate_field (4);
6586 if (print_address_bits <= 32)
6587 uiout->table_header (10, ui_left, "addr", "Address"); /* 5 */
6588 else
6589 uiout->table_header (18, ui_left, "addr", "Address"); /* 5 */
6590 }
6591 if (nr_printable_breakpoints > 0)
6592 annotate_field (5);
6593 uiout->table_header (40, ui_noalign, "what", "What"); /* 6 */
6594 uiout->table_body ();
6595 if (nr_printable_breakpoints > 0)
6596 annotate_breakpoints_table ();
6597
6598 ALL_BREAKPOINTS (b)
6599 {
6600 QUIT;
6601 /* If we have a filter, only list the breakpoints it accepts. */
6602 if (filter && !filter (b))
6603 continue;
6604
6605 /* If we have an "args" string, it is a list of breakpoints to
6606 accept. Skip the others. */
6607
6608 if (args != NULL && *args != '\0')
6609 {
6610 if (allflag) /* maintenance info breakpoint */
6611 {
6612 if (parse_and_eval_long (args) != b->number)
6613 continue;
6614 }
6615 else /* all others */
6616 {
6617 if (!number_is_in_list (args, b->number))
6618 continue;
6619 }
6620 }
6621 /* We only print out user settable breakpoints unless the
6622 allflag is set. */
6623 if (allflag || user_breakpoint_p (b))
6624 print_one_breakpoint (b, &last_loc, allflag);
6625 }
6626 }
6627
6628 if (nr_printable_breakpoints == 0)
6629 {
6630 /* If there's a filter, let the caller decide how to report
6631 empty list. */
6632 if (!filter)
6633 {
6634 if (args == NULL || *args == '\0')
6635 uiout->message ("No breakpoints or watchpoints.\n");
6636 else
6637 uiout->message ("No breakpoint or watchpoint matching '%s'.\n",
6638 args);
6639 }
6640 }
6641 else
6642 {
6643 if (last_loc && !server_command)
6644 set_next_address (last_loc->gdbarch, last_loc->address);
6645 }
6646
6647 /* FIXME? Should this be moved up so that it is only called when
6648 there have been breakpoints? */
6649 annotate_breakpoints_table_end ();
6650
6651 return nr_printable_breakpoints;
6652 }
6653
6654 /* Display the value of default-collect in a way that is generally
6655 compatible with the breakpoint list. */
6656
6657 static void
6658 default_collect_info (void)
6659 {
6660 struct ui_out *uiout = current_uiout;
6661
6662 /* If it has no value (which is frequently the case), say nothing; a
6663 message like "No default-collect." gets in user's face when it's
6664 not wanted. */
6665 if (!*default_collect)
6666 return;
6667
6668 /* The following phrase lines up nicely with per-tracepoint collect
6669 actions. */
6670 uiout->text ("default collect ");
6671 uiout->field_string ("default-collect", default_collect);
6672 uiout->text (" \n");
6673 }
6674
6675 static void
6676 info_breakpoints_command (const char *args, int from_tty)
6677 {
6678 breakpoint_1 (args, 0, NULL);
6679
6680 default_collect_info ();
6681 }
6682
6683 static void
6684 info_watchpoints_command (const char *args, int from_tty)
6685 {
6686 int num_printed = breakpoint_1 (args, 0, is_watchpoint);
6687 struct ui_out *uiout = current_uiout;
6688
6689 if (num_printed == 0)
6690 {
6691 if (args == NULL || *args == '\0')
6692 uiout->message ("No watchpoints.\n");
6693 else
6694 uiout->message ("No watchpoint matching '%s'.\n", args);
6695 }
6696 }
6697
6698 static void
6699 maintenance_info_breakpoints (const char *args, int from_tty)
6700 {
6701 breakpoint_1 (args, 1, NULL);
6702
6703 default_collect_info ();
6704 }
6705
6706 static int
6707 breakpoint_has_pc (struct breakpoint *b,
6708 struct program_space *pspace,
6709 CORE_ADDR pc, struct obj_section *section)
6710 {
6711 struct bp_location *bl = b->loc;
6712
6713 for (; bl; bl = bl->next)
6714 {
6715 if (bl->pspace == pspace
6716 && bl->address == pc
6717 && (!overlay_debugging || bl->section == section))
6718 return 1;
6719 }
6720 return 0;
6721 }
6722
6723 /* Print a message describing any user-breakpoints set at PC. This
6724 concerns with logical breakpoints, so we match program spaces, not
6725 address spaces. */
6726
6727 static void
6728 describe_other_breakpoints (struct gdbarch *gdbarch,
6729 struct program_space *pspace, CORE_ADDR pc,
6730 struct obj_section *section, int thread)
6731 {
6732 int others = 0;
6733 struct breakpoint *b;
6734
6735 ALL_BREAKPOINTS (b)
6736 others += (user_breakpoint_p (b)
6737 && breakpoint_has_pc (b, pspace, pc, section));
6738 if (others > 0)
6739 {
6740 if (others == 1)
6741 printf_filtered (_("Note: breakpoint "));
6742 else /* if (others == ???) */
6743 printf_filtered (_("Note: breakpoints "));
6744 ALL_BREAKPOINTS (b)
6745 if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
6746 {
6747 others--;
6748 printf_filtered ("%d", b->number);
6749 if (b->thread == -1 && thread != -1)
6750 printf_filtered (" (all threads)");
6751 else if (b->thread != -1)
6752 printf_filtered (" (thread %d)", b->thread);
6753 printf_filtered ("%s%s ",
6754 ((b->enable_state == bp_disabled
6755 || b->enable_state == bp_call_disabled)
6756 ? " (disabled)"
6757 : ""),
6758 (others > 1) ? ","
6759 : ((others == 1) ? " and" : ""));
6760 }
6761 printf_filtered (_("also set at pc "));
6762 fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
6763 printf_filtered (".\n");
6764 }
6765 }
6766
6767
6768 /* Return true iff it is meaningful to use the address member of
6769 BPT locations. For some breakpoint types, the locations' address members
6770 are irrelevant and it makes no sense to attempt to compare them to other
6771 addresses (or use them for any other purpose either).
6772
6773 More specifically, each of the following breakpoint types will
6774 always have a zero valued location address and we don't want to mark
6775 breakpoints of any of these types to be a duplicate of an actual
6776 breakpoint location at address zero:
6777
6778 bp_watchpoint
6779 bp_catchpoint
6780
6781 */
6782
6783 static int
6784 breakpoint_address_is_meaningful (struct breakpoint *bpt)
6785 {
6786 enum bptype type = bpt->type;
6787
6788 return (type != bp_watchpoint && type != bp_catchpoint);
6789 }
6790
6791 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6792 true if LOC1 and LOC2 represent the same watchpoint location. */
6793
6794 static int
6795 watchpoint_locations_match (struct bp_location *loc1,
6796 struct bp_location *loc2)
6797 {
6798 struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
6799 struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
6800
6801 /* Both of them must exist. */
6802 gdb_assert (w1 != NULL);
6803 gdb_assert (w2 != NULL);
6804
6805 /* If the target can evaluate the condition expression in hardware,
6806 then we we need to insert both watchpoints even if they are at
6807 the same place. Otherwise the watchpoint will only trigger when
6808 the condition of whichever watchpoint was inserted evaluates to
6809 true, not giving a chance for GDB to check the condition of the
6810 other watchpoint. */
6811 if ((w1->cond_exp
6812 && target_can_accel_watchpoint_condition (loc1->address,
6813 loc1->length,
6814 loc1->watchpoint_type,
6815 w1->cond_exp.get ()))
6816 || (w2->cond_exp
6817 && target_can_accel_watchpoint_condition (loc2->address,
6818 loc2->length,
6819 loc2->watchpoint_type,
6820 w2->cond_exp.get ())))
6821 return 0;
6822
6823 /* Note that this checks the owner's type, not the location's. In
6824 case the target does not support read watchpoints, but does
6825 support access watchpoints, we'll have bp_read_watchpoint
6826 watchpoints with hw_access locations. Those should be considered
6827 duplicates of hw_read locations. The hw_read locations will
6828 become hw_access locations later. */
6829 return (loc1->owner->type == loc2->owner->type
6830 && loc1->pspace->aspace == loc2->pspace->aspace
6831 && loc1->address == loc2->address
6832 && loc1->length == loc2->length);
6833 }
6834
6835 /* See breakpoint.h. */
6836
6837 int
6838 breakpoint_address_match (const address_space *aspace1, CORE_ADDR addr1,
6839 const address_space *aspace2, CORE_ADDR addr2)
6840 {
6841 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6842 || aspace1 == aspace2)
6843 && addr1 == addr2);
6844 }
6845
6846 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6847 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6848 matches ASPACE2. On targets that have global breakpoints, the address
6849 space doesn't really matter. */
6850
6851 static int
6852 breakpoint_address_match_range (const address_space *aspace1,
6853 CORE_ADDR addr1,
6854 int len1, const address_space *aspace2,
6855 CORE_ADDR addr2)
6856 {
6857 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6858 || aspace1 == aspace2)
6859 && addr2 >= addr1 && addr2 < addr1 + len1);
6860 }
6861
6862 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6863 a ranged breakpoint. In most targets, a match happens only if ASPACE
6864 matches the breakpoint's address space. On targets that have global
6865 breakpoints, the address space doesn't really matter. */
6866
6867 static int
6868 breakpoint_location_address_match (struct bp_location *bl,
6869 const address_space *aspace,
6870 CORE_ADDR addr)
6871 {
6872 return (breakpoint_address_match (bl->pspace->aspace, bl->address,
6873 aspace, addr)
6874 || (bl->length
6875 && breakpoint_address_match_range (bl->pspace->aspace,
6876 bl->address, bl->length,
6877 aspace, addr)));
6878 }
6879
6880 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6881 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6882 match happens only if ASPACE matches the breakpoint's address
6883 space. On targets that have global breakpoints, the address space
6884 doesn't really matter. */
6885
6886 static int
6887 breakpoint_location_address_range_overlap (struct bp_location *bl,
6888 const address_space *aspace,
6889 CORE_ADDR addr, int len)
6890 {
6891 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6892 || bl->pspace->aspace == aspace)
6893 {
6894 int bl_len = bl->length != 0 ? bl->length : 1;
6895
6896 if (mem_ranges_overlap (addr, len, bl->address, bl_len))
6897 return 1;
6898 }
6899 return 0;
6900 }
6901
6902 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6903 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6904 true, otherwise returns false. */
6905
6906 static int
6907 tracepoint_locations_match (struct bp_location *loc1,
6908 struct bp_location *loc2)
6909 {
6910 if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
6911 /* Since tracepoint locations are never duplicated with others', tracepoint
6912 locations at the same address of different tracepoints are regarded as
6913 different locations. */
6914 return (loc1->address == loc2->address && loc1->owner == loc2->owner);
6915 else
6916 return 0;
6917 }
6918
6919 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6920 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6921 represent the same location. */
6922
6923 static int
6924 breakpoint_locations_match (struct bp_location *loc1,
6925 struct bp_location *loc2)
6926 {
6927 int hw_point1, hw_point2;
6928
6929 /* Both of them must not be in moribund_locations. */
6930 gdb_assert (loc1->owner != NULL);
6931 gdb_assert (loc2->owner != NULL);
6932
6933 hw_point1 = is_hardware_watchpoint (loc1->owner);
6934 hw_point2 = is_hardware_watchpoint (loc2->owner);
6935
6936 if (hw_point1 != hw_point2)
6937 return 0;
6938 else if (hw_point1)
6939 return watchpoint_locations_match (loc1, loc2);
6940 else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
6941 return tracepoint_locations_match (loc1, loc2);
6942 else
6943 /* We compare bp_location.length in order to cover ranged breakpoints. */
6944 return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
6945 loc2->pspace->aspace, loc2->address)
6946 && loc1->length == loc2->length);
6947 }
6948
6949 static void
6950 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
6951 int bnum, int have_bnum)
6952 {
6953 /* The longest string possibly returned by hex_string_custom
6954 is 50 chars. These must be at least that big for safety. */
6955 char astr1[64];
6956 char astr2[64];
6957
6958 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
6959 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
6960 if (have_bnum)
6961 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6962 bnum, astr1, astr2);
6963 else
6964 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
6965 }
6966
6967 /* Adjust a breakpoint's address to account for architectural
6968 constraints on breakpoint placement. Return the adjusted address.
6969 Note: Very few targets require this kind of adjustment. For most
6970 targets, this function is simply the identity function. */
6971
6972 static CORE_ADDR
6973 adjust_breakpoint_address (struct gdbarch *gdbarch,
6974 CORE_ADDR bpaddr, enum bptype bptype)
6975 {
6976 if (bptype == bp_watchpoint
6977 || bptype == bp_hardware_watchpoint
6978 || bptype == bp_read_watchpoint
6979 || bptype == bp_access_watchpoint
6980 || bptype == bp_catchpoint)
6981 {
6982 /* Watchpoints and the various bp_catch_* eventpoints should not
6983 have their addresses modified. */
6984 return bpaddr;
6985 }
6986 else if (bptype == bp_single_step)
6987 {
6988 /* Single-step breakpoints should not have their addresses
6989 modified. If there's any architectural constrain that
6990 applies to this address, then it should have already been
6991 taken into account when the breakpoint was created in the
6992 first place. If we didn't do this, stepping through e.g.,
6993 Thumb-2 IT blocks would break. */
6994 return bpaddr;
6995 }
6996 else
6997 {
6998 CORE_ADDR adjusted_bpaddr = bpaddr;
6999
7000 if (gdbarch_adjust_breakpoint_address_p (gdbarch))
7001 {
7002 /* Some targets have architectural constraints on the placement
7003 of breakpoint instructions. Obtain the adjusted address. */
7004 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
7005 }
7006
7007 adjusted_bpaddr = address_significant (gdbarch, adjusted_bpaddr);
7008
7009 /* An adjusted breakpoint address can significantly alter
7010 a user's expectations. Print a warning if an adjustment
7011 is required. */
7012 if (adjusted_bpaddr != bpaddr)
7013 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
7014
7015 return adjusted_bpaddr;
7016 }
7017 }
7018
7019 bp_location::bp_location (const bp_location_ops *ops, breakpoint *owner)
7020 {
7021 bp_location *loc = this;
7022
7023 gdb_assert (ops != NULL);
7024
7025 loc->ops = ops;
7026 loc->owner = owner;
7027 loc->cond_bytecode = NULL;
7028 loc->shlib_disabled = 0;
7029 loc->enabled = 1;
7030
7031 switch (owner->type)
7032 {
7033 case bp_breakpoint:
7034 case bp_single_step:
7035 case bp_until:
7036 case bp_finish:
7037 case bp_longjmp:
7038 case bp_longjmp_resume:
7039 case bp_longjmp_call_dummy:
7040 case bp_exception:
7041 case bp_exception_resume:
7042 case bp_step_resume:
7043 case bp_hp_step_resume:
7044 case bp_watchpoint_scope:
7045 case bp_call_dummy:
7046 case bp_std_terminate:
7047 case bp_shlib_event:
7048 case bp_thread_event:
7049 case bp_overlay_event:
7050 case bp_jit_event:
7051 case bp_longjmp_master:
7052 case bp_std_terminate_master:
7053 case bp_exception_master:
7054 case bp_gnu_ifunc_resolver:
7055 case bp_gnu_ifunc_resolver_return:
7056 case bp_dprintf:
7057 loc->loc_type = bp_loc_software_breakpoint;
7058 mark_breakpoint_location_modified (loc);
7059 break;
7060 case bp_hardware_breakpoint:
7061 loc->loc_type = bp_loc_hardware_breakpoint;
7062 mark_breakpoint_location_modified (loc);
7063 break;
7064 case bp_hardware_watchpoint:
7065 case bp_read_watchpoint:
7066 case bp_access_watchpoint:
7067 loc->loc_type = bp_loc_hardware_watchpoint;
7068 break;
7069 case bp_watchpoint:
7070 case bp_catchpoint:
7071 case bp_tracepoint:
7072 case bp_fast_tracepoint:
7073 case bp_static_tracepoint:
7074 loc->loc_type = bp_loc_other;
7075 break;
7076 default:
7077 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
7078 }
7079
7080 loc->refc = 1;
7081 }
7082
7083 /* Allocate a struct bp_location. */
7084
7085 static struct bp_location *
7086 allocate_bp_location (struct breakpoint *bpt)
7087 {
7088 return bpt->ops->allocate_location (bpt);
7089 }
7090
7091 static void
7092 free_bp_location (struct bp_location *loc)
7093 {
7094 loc->ops->dtor (loc);
7095 delete loc;
7096 }
7097
7098 /* Increment reference count. */
7099
7100 static void
7101 incref_bp_location (struct bp_location *bl)
7102 {
7103 ++bl->refc;
7104 }
7105
7106 /* Decrement reference count. If the reference count reaches 0,
7107 destroy the bp_location. Sets *BLP to NULL. */
7108
7109 static void
7110 decref_bp_location (struct bp_location **blp)
7111 {
7112 gdb_assert ((*blp)->refc > 0);
7113
7114 if (--(*blp)->refc == 0)
7115 free_bp_location (*blp);
7116 *blp = NULL;
7117 }
7118
7119 /* Add breakpoint B at the end of the global breakpoint chain. */
7120
7121 static breakpoint *
7122 add_to_breakpoint_chain (std::unique_ptr<breakpoint> &&b)
7123 {
7124 struct breakpoint *b1;
7125 struct breakpoint *result = b.get ();
7126
7127 /* Add this breakpoint to the end of the chain so that a list of
7128 breakpoints will come out in order of increasing numbers. */
7129
7130 b1 = breakpoint_chain;
7131 if (b1 == 0)
7132 breakpoint_chain = b.release ();
7133 else
7134 {
7135 while (b1->next)
7136 b1 = b1->next;
7137 b1->next = b.release ();
7138 }
7139
7140 return result;
7141 }
7142
7143 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7144
7145 static void
7146 init_raw_breakpoint_without_location (struct breakpoint *b,
7147 struct gdbarch *gdbarch,
7148 enum bptype bptype,
7149 const struct breakpoint_ops *ops)
7150 {
7151 gdb_assert (ops != NULL);
7152
7153 b->ops = ops;
7154 b->type = bptype;
7155 b->gdbarch = gdbarch;
7156 b->language = current_language->la_language;
7157 b->input_radix = input_radix;
7158 b->related_breakpoint = b;
7159 }
7160
7161 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7162 that has type BPTYPE and has no locations as yet. */
7163
7164 static struct breakpoint *
7165 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
7166 enum bptype bptype,
7167 const struct breakpoint_ops *ops)
7168 {
7169 std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7170
7171 init_raw_breakpoint_without_location (b.get (), gdbarch, bptype, ops);
7172 return add_to_breakpoint_chain (std::move (b));
7173 }
7174
7175 /* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7176 resolutions should be made as the user specified the location explicitly
7177 enough. */
7178
7179 static void
7180 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
7181 {
7182 gdb_assert (loc->owner != NULL);
7183
7184 if (loc->owner->type == bp_breakpoint
7185 || loc->owner->type == bp_hardware_breakpoint
7186 || is_tracepoint (loc->owner))
7187 {
7188 int is_gnu_ifunc;
7189 const char *function_name;
7190 CORE_ADDR func_addr;
7191
7192 find_pc_partial_function_gnu_ifunc (loc->address, &function_name,
7193 &func_addr, NULL, &is_gnu_ifunc);
7194
7195 if (is_gnu_ifunc && !explicit_loc)
7196 {
7197 struct breakpoint *b = loc->owner;
7198
7199 gdb_assert (loc->pspace == current_program_space);
7200 if (gnu_ifunc_resolve_name (function_name,
7201 &loc->requested_address))
7202 {
7203 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7204 loc->address = adjust_breakpoint_address (loc->gdbarch,
7205 loc->requested_address,
7206 b->type);
7207 }
7208 else if (b->type == bp_breakpoint && b->loc == loc
7209 && loc->next == NULL && b->related_breakpoint == b)
7210 {
7211 /* Create only the whole new breakpoint of this type but do not
7212 mess more complicated breakpoints with multiple locations. */
7213 b->type = bp_gnu_ifunc_resolver;
7214 /* Remember the resolver's address for use by the return
7215 breakpoint. */
7216 loc->related_address = func_addr;
7217 }
7218 }
7219
7220 if (function_name)
7221 loc->function_name = xstrdup (function_name);
7222 }
7223 }
7224
7225 /* Attempt to determine architecture of location identified by SAL. */
7226 struct gdbarch *
7227 get_sal_arch (struct symtab_and_line sal)
7228 {
7229 if (sal.section)
7230 return get_objfile_arch (sal.section->objfile);
7231 if (sal.symtab)
7232 return get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
7233
7234 return NULL;
7235 }
7236
7237 /* Low level routine for partially initializing a breakpoint of type
7238 BPTYPE. The newly created breakpoint's address, section, source
7239 file name, and line number are provided by SAL.
7240
7241 It is expected that the caller will complete the initialization of
7242 the newly created breakpoint struct as well as output any status
7243 information regarding the creation of a new breakpoint. */
7244
7245 static void
7246 init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
7247 struct symtab_and_line sal, enum bptype bptype,
7248 const struct breakpoint_ops *ops)
7249 {
7250 init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
7251
7252 add_location_to_breakpoint (b, &sal);
7253
7254 if (bptype != bp_catchpoint)
7255 gdb_assert (sal.pspace != NULL);
7256
7257 /* Store the program space that was used to set the breakpoint,
7258 except for ordinary breakpoints, which are independent of the
7259 program space. */
7260 if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
7261 b->pspace = sal.pspace;
7262 }
7263
7264 /* set_raw_breakpoint is a low level routine for allocating and
7265 partially initializing a breakpoint of type BPTYPE. The newly
7266 created breakpoint's address, section, source file name, and line
7267 number are provided by SAL. The newly created and partially
7268 initialized breakpoint is added to the breakpoint chain and
7269 is also returned as the value of this function.
7270
7271 It is expected that the caller will complete the initialization of
7272 the newly created breakpoint struct as well as output any status
7273 information regarding the creation of a new breakpoint. In
7274 particular, set_raw_breakpoint does NOT set the breakpoint
7275 number! Care should be taken to not allow an error to occur
7276 prior to completing the initialization of the breakpoint. If this
7277 should happen, a bogus breakpoint will be left on the chain. */
7278
7279 struct breakpoint *
7280 set_raw_breakpoint (struct gdbarch *gdbarch,
7281 struct symtab_and_line sal, enum bptype bptype,
7282 const struct breakpoint_ops *ops)
7283 {
7284 std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7285
7286 init_raw_breakpoint (b.get (), gdbarch, sal, bptype, ops);
7287 return add_to_breakpoint_chain (std::move (b));
7288 }
7289
7290 /* Call this routine when stepping and nexting to enable a breakpoint
7291 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7292 initiated the operation. */
7293
7294 void
7295 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
7296 {
7297 struct breakpoint *b, *b_tmp;
7298 int thread = tp->global_num;
7299
7300 /* To avoid having to rescan all objfile symbols at every step,
7301 we maintain a list of continually-inserted but always disabled
7302 longjmp "master" breakpoints. Here, we simply create momentary
7303 clones of those and enable them for the requested thread. */
7304 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7305 if (b->pspace == current_program_space
7306 && (b->type == bp_longjmp_master
7307 || b->type == bp_exception_master))
7308 {
7309 enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7310 struct breakpoint *clone;
7311
7312 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7313 after their removal. */
7314 clone = momentary_breakpoint_from_master (b, type,
7315 &momentary_breakpoint_ops, 1);
7316 clone->thread = thread;
7317 }
7318
7319 tp->initiating_frame = frame;
7320 }
7321
7322 /* Delete all longjmp breakpoints from THREAD. */
7323 void
7324 delete_longjmp_breakpoint (int thread)
7325 {
7326 struct breakpoint *b, *b_tmp;
7327
7328 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7329 if (b->type == bp_longjmp || b->type == bp_exception)
7330 {
7331 if (b->thread == thread)
7332 delete_breakpoint (b);
7333 }
7334 }
7335
7336 void
7337 delete_longjmp_breakpoint_at_next_stop (int thread)
7338 {
7339 struct breakpoint *b, *b_tmp;
7340
7341 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7342 if (b->type == bp_longjmp || b->type == bp_exception)
7343 {
7344 if (b->thread == thread)
7345 b->disposition = disp_del_at_next_stop;
7346 }
7347 }
7348
7349 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7350 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7351 pointer to any of them. Return NULL if this system cannot place longjmp
7352 breakpoints. */
7353
7354 struct breakpoint *
7355 set_longjmp_breakpoint_for_call_dummy (void)
7356 {
7357 struct breakpoint *b, *retval = NULL;
7358
7359 ALL_BREAKPOINTS (b)
7360 if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7361 {
7362 struct breakpoint *new_b;
7363
7364 new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
7365 &momentary_breakpoint_ops,
7366 1);
7367 new_b->thread = ptid_to_global_thread_id (inferior_ptid);
7368
7369 /* Link NEW_B into the chain of RETVAL breakpoints. */
7370
7371 gdb_assert (new_b->related_breakpoint == new_b);
7372 if (retval == NULL)
7373 retval = new_b;
7374 new_b->related_breakpoint = retval;
7375 while (retval->related_breakpoint != new_b->related_breakpoint)
7376 retval = retval->related_breakpoint;
7377 retval->related_breakpoint = new_b;
7378 }
7379
7380 return retval;
7381 }
7382
7383 /* Verify all existing dummy frames and their associated breakpoints for
7384 TP. Remove those which can no longer be found in the current frame
7385 stack.
7386
7387 You should call this function only at places where it is safe to currently
7388 unwind the whole stack. Failed stack unwind would discard live dummy
7389 frames. */
7390
7391 void
7392 check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp)
7393 {
7394 struct breakpoint *b, *b_tmp;
7395
7396 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7397 if (b->type == bp_longjmp_call_dummy && b->thread == tp->global_num)
7398 {
7399 struct breakpoint *dummy_b = b->related_breakpoint;
7400
7401 while (dummy_b != b && dummy_b->type != bp_call_dummy)
7402 dummy_b = dummy_b->related_breakpoint;
7403 if (dummy_b->type != bp_call_dummy
7404 || frame_find_by_id (dummy_b->frame_id) != NULL)
7405 continue;
7406
7407 dummy_frame_discard (dummy_b->frame_id, tp->ptid);
7408
7409 while (b->related_breakpoint != b)
7410 {
7411 if (b_tmp == b->related_breakpoint)
7412 b_tmp = b->related_breakpoint->next;
7413 delete_breakpoint (b->related_breakpoint);
7414 }
7415 delete_breakpoint (b);
7416 }
7417 }
7418
7419 void
7420 enable_overlay_breakpoints (void)
7421 {
7422 struct breakpoint *b;
7423
7424 ALL_BREAKPOINTS (b)
7425 if (b->type == bp_overlay_event)
7426 {
7427 b->enable_state = bp_enabled;
7428 update_global_location_list (UGLL_MAY_INSERT);
7429 overlay_events_enabled = 1;
7430 }
7431 }
7432
7433 void
7434 disable_overlay_breakpoints (void)
7435 {
7436 struct breakpoint *b;
7437
7438 ALL_BREAKPOINTS (b)
7439 if (b->type == bp_overlay_event)
7440 {
7441 b->enable_state = bp_disabled;
7442 update_global_location_list (UGLL_DONT_INSERT);
7443 overlay_events_enabled = 0;
7444 }
7445 }
7446
7447 /* Set an active std::terminate breakpoint for each std::terminate
7448 master breakpoint. */
7449 void
7450 set_std_terminate_breakpoint (void)
7451 {
7452 struct breakpoint *b, *b_tmp;
7453
7454 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7455 if (b->pspace == current_program_space
7456 && b->type == bp_std_terminate_master)
7457 {
7458 momentary_breakpoint_from_master (b, bp_std_terminate,
7459 &momentary_breakpoint_ops, 1);
7460 }
7461 }
7462
7463 /* Delete all the std::terminate breakpoints. */
7464 void
7465 delete_std_terminate_breakpoint (void)
7466 {
7467 struct breakpoint *b, *b_tmp;
7468
7469 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7470 if (b->type == bp_std_terminate)
7471 delete_breakpoint (b);
7472 }
7473
7474 struct breakpoint *
7475 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7476 {
7477 struct breakpoint *b;
7478
7479 b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7480 &internal_breakpoint_ops);
7481
7482 b->enable_state = bp_enabled;
7483 /* location has to be used or breakpoint_re_set will delete me. */
7484 b->location = new_address_location (b->loc->address, NULL, 0);
7485
7486 update_global_location_list_nothrow (UGLL_MAY_INSERT);
7487
7488 return b;
7489 }
7490
7491 struct lang_and_radix
7492 {
7493 enum language lang;
7494 int radix;
7495 };
7496
7497 /* Create a breakpoint for JIT code registration and unregistration. */
7498
7499 struct breakpoint *
7500 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7501 {
7502 return create_internal_breakpoint (gdbarch, address, bp_jit_event,
7503 &internal_breakpoint_ops);
7504 }
7505
7506 /* Remove JIT code registration and unregistration breakpoint(s). */
7507
7508 void
7509 remove_jit_event_breakpoints (void)
7510 {
7511 struct breakpoint *b, *b_tmp;
7512
7513 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7514 if (b->type == bp_jit_event
7515 && b->loc->pspace == current_program_space)
7516 delete_breakpoint (b);
7517 }
7518
7519 void
7520 remove_solib_event_breakpoints (void)
7521 {
7522 struct breakpoint *b, *b_tmp;
7523
7524 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7525 if (b->type == bp_shlib_event
7526 && b->loc->pspace == current_program_space)
7527 delete_breakpoint (b);
7528 }
7529
7530 /* See breakpoint.h. */
7531
7532 void
7533 remove_solib_event_breakpoints_at_next_stop (void)
7534 {
7535 struct breakpoint *b, *b_tmp;
7536
7537 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7538 if (b->type == bp_shlib_event
7539 && b->loc->pspace == current_program_space)
7540 b->disposition = disp_del_at_next_stop;
7541 }
7542
7543 /* Helper for create_solib_event_breakpoint /
7544 create_and_insert_solib_event_breakpoint. Allows specifying which
7545 INSERT_MODE to pass through to update_global_location_list. */
7546
7547 static struct breakpoint *
7548 create_solib_event_breakpoint_1 (struct gdbarch *gdbarch, CORE_ADDR address,
7549 enum ugll_insert_mode insert_mode)
7550 {
7551 struct breakpoint *b;
7552
7553 b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7554 &internal_breakpoint_ops);
7555 update_global_location_list_nothrow (insert_mode);
7556 return b;
7557 }
7558
7559 struct breakpoint *
7560 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7561 {
7562 return create_solib_event_breakpoint_1 (gdbarch, address, UGLL_MAY_INSERT);
7563 }
7564
7565 /* See breakpoint.h. */
7566
7567 struct breakpoint *
7568 create_and_insert_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7569 {
7570 struct breakpoint *b;
7571
7572 /* Explicitly tell update_global_location_list to insert
7573 locations. */
7574 b = create_solib_event_breakpoint_1 (gdbarch, address, UGLL_INSERT);
7575 if (!b->loc->inserted)
7576 {
7577 delete_breakpoint (b);
7578 return NULL;
7579 }
7580 return b;
7581 }
7582
7583 /* Disable any breakpoints that are on code in shared libraries. Only
7584 apply to enabled breakpoints, disabled ones can just stay disabled. */
7585
7586 void
7587 disable_breakpoints_in_shlibs (void)
7588 {
7589 struct bp_location *loc, **locp_tmp;
7590
7591 ALL_BP_LOCATIONS (loc, locp_tmp)
7592 {
7593 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7594 struct breakpoint *b = loc->owner;
7595
7596 /* We apply the check to all breakpoints, including disabled for
7597 those with loc->duplicate set. This is so that when breakpoint
7598 becomes enabled, or the duplicate is removed, gdb will try to
7599 insert all breakpoints. If we don't set shlib_disabled here,
7600 we'll try to insert those breakpoints and fail. */
7601 if (((b->type == bp_breakpoint)
7602 || (b->type == bp_jit_event)
7603 || (b->type == bp_hardware_breakpoint)
7604 || (is_tracepoint (b)))
7605 && loc->pspace == current_program_space
7606 && !loc->shlib_disabled
7607 && solib_name_from_address (loc->pspace, loc->address)
7608 )
7609 {
7610 loc->shlib_disabled = 1;
7611 }
7612 }
7613 }
7614
7615 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7616 notification of unloaded_shlib. Only apply to enabled breakpoints,
7617 disabled ones can just stay disabled. */
7618
7619 static void
7620 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7621 {
7622 struct bp_location *loc, **locp_tmp;
7623 int disabled_shlib_breaks = 0;
7624
7625 ALL_BP_LOCATIONS (loc, locp_tmp)
7626 {
7627 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7628 struct breakpoint *b = loc->owner;
7629
7630 if (solib->pspace == loc->pspace
7631 && !loc->shlib_disabled
7632 && (((b->type == bp_breakpoint
7633 || b->type == bp_jit_event
7634 || b->type == bp_hardware_breakpoint)
7635 && (loc->loc_type == bp_loc_hardware_breakpoint
7636 || loc->loc_type == bp_loc_software_breakpoint))
7637 || is_tracepoint (b))
7638 && solib_contains_address_p (solib, loc->address))
7639 {
7640 loc->shlib_disabled = 1;
7641 /* At this point, we cannot rely on remove_breakpoint
7642 succeeding so we must mark the breakpoint as not inserted
7643 to prevent future errors occurring in remove_breakpoints. */
7644 loc->inserted = 0;
7645
7646 /* This may cause duplicate notifications for the same breakpoint. */
7647 observer_notify_breakpoint_modified (b);
7648
7649 if (!disabled_shlib_breaks)
7650 {
7651 target_terminal::ours_for_output ();
7652 warning (_("Temporarily disabling breakpoints "
7653 "for unloaded shared library \"%s\""),
7654 solib->so_name);
7655 }
7656 disabled_shlib_breaks = 1;
7657 }
7658 }
7659 }
7660
7661 /* Disable any breakpoints and tracepoints in OBJFILE upon
7662 notification of free_objfile. Only apply to enabled breakpoints,
7663 disabled ones can just stay disabled. */
7664
7665 static void
7666 disable_breakpoints_in_freed_objfile (struct objfile *objfile)
7667 {
7668 struct breakpoint *b;
7669
7670 if (objfile == NULL)
7671 return;
7672
7673 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7674 managed by the user with add-symbol-file/remove-symbol-file.
7675 Similarly to how breakpoints in shared libraries are handled in
7676 response to "nosharedlibrary", mark breakpoints in such modules
7677 shlib_disabled so they end up uninserted on the next global
7678 location list update. Shared libraries not loaded by the user
7679 aren't handled here -- they're already handled in
7680 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7681 solib_unloaded observer. We skip objfiles that are not
7682 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7683 main objfile). */
7684 if ((objfile->flags & OBJF_SHARED) == 0
7685 || (objfile->flags & OBJF_USERLOADED) == 0)
7686 return;
7687
7688 ALL_BREAKPOINTS (b)
7689 {
7690 struct bp_location *loc;
7691 int bp_modified = 0;
7692
7693 if (!is_breakpoint (b) && !is_tracepoint (b))
7694 continue;
7695
7696 for (loc = b->loc; loc != NULL; loc = loc->next)
7697 {
7698 CORE_ADDR loc_addr = loc->address;
7699
7700 if (loc->loc_type != bp_loc_hardware_breakpoint
7701 && loc->loc_type != bp_loc_software_breakpoint)
7702 continue;
7703
7704 if (loc->shlib_disabled != 0)
7705 continue;
7706
7707 if (objfile->pspace != loc->pspace)
7708 continue;
7709
7710 if (loc->loc_type != bp_loc_hardware_breakpoint
7711 && loc->loc_type != bp_loc_software_breakpoint)
7712 continue;
7713
7714 if (is_addr_in_objfile (loc_addr, objfile))
7715 {
7716 loc->shlib_disabled = 1;
7717 /* At this point, we don't know whether the object was
7718 unmapped from the inferior or not, so leave the
7719 inserted flag alone. We'll handle failure to
7720 uninsert quietly, in case the object was indeed
7721 unmapped. */
7722
7723 mark_breakpoint_location_modified (loc);
7724
7725 bp_modified = 1;
7726 }
7727 }
7728
7729 if (bp_modified)
7730 observer_notify_breakpoint_modified (b);
7731 }
7732 }
7733
7734 /* FORK & VFORK catchpoints. */
7735
7736 /* An instance of this type is used to represent a fork or vfork
7737 catchpoint. A breakpoint is really of this type iff its ops pointer points
7738 to CATCH_FORK_BREAKPOINT_OPS. */
7739
7740 struct fork_catchpoint : public breakpoint
7741 {
7742 /* Process id of a child process whose forking triggered this
7743 catchpoint. This field is only valid immediately after this
7744 catchpoint has triggered. */
7745 ptid_t forked_inferior_pid;
7746 };
7747
7748 /* Implement the "insert" breakpoint_ops method for fork
7749 catchpoints. */
7750
7751 static int
7752 insert_catch_fork (struct bp_location *bl)
7753 {
7754 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid));
7755 }
7756
7757 /* Implement the "remove" breakpoint_ops method for fork
7758 catchpoints. */
7759
7760 static int
7761 remove_catch_fork (struct bp_location *bl, enum remove_bp_reason reason)
7762 {
7763 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid));
7764 }
7765
7766 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7767 catchpoints. */
7768
7769 static int
7770 breakpoint_hit_catch_fork (const struct bp_location *bl,
7771 const address_space *aspace, CORE_ADDR bp_addr,
7772 const struct target_waitstatus *ws)
7773 {
7774 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7775
7776 if (ws->kind != TARGET_WAITKIND_FORKED)
7777 return 0;
7778
7779 c->forked_inferior_pid = ws->value.related_pid;
7780 return 1;
7781 }
7782
7783 /* Implement the "print_it" breakpoint_ops method for fork
7784 catchpoints. */
7785
7786 static enum print_stop_action
7787 print_it_catch_fork (bpstat bs)
7788 {
7789 struct ui_out *uiout = current_uiout;
7790 struct breakpoint *b = bs->breakpoint_at;
7791 struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
7792
7793 annotate_catchpoint (b->number);
7794 maybe_print_thread_hit_breakpoint (uiout);
7795 if (b->disposition == disp_del)
7796 uiout->text ("Temporary catchpoint ");
7797 else
7798 uiout->text ("Catchpoint ");
7799 if (uiout->is_mi_like_p ())
7800 {
7801 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK));
7802 uiout->field_string ("disp", bpdisp_text (b->disposition));
7803 }
7804 uiout->field_int ("bkptno", b->number);
7805 uiout->text (" (forked process ");
7806 uiout->field_int ("newpid", ptid_get_pid (c->forked_inferior_pid));
7807 uiout->text ("), ");
7808 return PRINT_SRC_AND_LOC;
7809 }
7810
7811 /* Implement the "print_one" breakpoint_ops method for fork
7812 catchpoints. */
7813
7814 static void
7815 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
7816 {
7817 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7818 struct value_print_options opts;
7819 struct ui_out *uiout = current_uiout;
7820
7821 get_user_print_options (&opts);
7822
7823 /* Field 4, the address, is omitted (which makes the columns not
7824 line up too nicely with the headers, but the effect is relatively
7825 readable). */
7826 if (opts.addressprint)
7827 uiout->field_skip ("addr");
7828 annotate_field (5);
7829 uiout->text ("fork");
7830 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7831 {
7832 uiout->text (", process ");
7833 uiout->field_int ("what", ptid_get_pid (c->forked_inferior_pid));
7834 uiout->spaces (1);
7835 }
7836
7837 if (uiout->is_mi_like_p ())
7838 uiout->field_string ("catch-type", "fork");
7839 }
7840
7841 /* Implement the "print_mention" breakpoint_ops method for fork
7842 catchpoints. */
7843
7844 static void
7845 print_mention_catch_fork (struct breakpoint *b)
7846 {
7847 printf_filtered (_("Catchpoint %d (fork)"), b->number);
7848 }
7849
7850 /* Implement the "print_recreate" breakpoint_ops method for fork
7851 catchpoints. */
7852
7853 static void
7854 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
7855 {
7856 fprintf_unfiltered (fp, "catch fork");
7857 print_recreate_thread (b, fp);
7858 }
7859
7860 /* The breakpoint_ops structure to be used in fork catchpoints. */
7861
7862 static struct breakpoint_ops catch_fork_breakpoint_ops;
7863
7864 /* Implement the "insert" breakpoint_ops method for vfork
7865 catchpoints. */
7866
7867 static int
7868 insert_catch_vfork (struct bp_location *bl)
7869 {
7870 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid));
7871 }
7872
7873 /* Implement the "remove" breakpoint_ops method for vfork
7874 catchpoints. */
7875
7876 static int
7877 remove_catch_vfork (struct bp_location *bl, enum remove_bp_reason reason)
7878 {
7879 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid));
7880 }
7881
7882 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7883 catchpoints. */
7884
7885 static int
7886 breakpoint_hit_catch_vfork (const struct bp_location *bl,
7887 const address_space *aspace, CORE_ADDR bp_addr,
7888 const struct target_waitstatus *ws)
7889 {
7890 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7891
7892 if (ws->kind != TARGET_WAITKIND_VFORKED)
7893 return 0;
7894
7895 c->forked_inferior_pid = ws->value.related_pid;
7896 return 1;
7897 }
7898
7899 /* Implement the "print_it" breakpoint_ops method for vfork
7900 catchpoints. */
7901
7902 static enum print_stop_action
7903 print_it_catch_vfork (bpstat bs)
7904 {
7905 struct ui_out *uiout = current_uiout;
7906 struct breakpoint *b = bs->breakpoint_at;
7907 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7908
7909 annotate_catchpoint (b->number);
7910 maybe_print_thread_hit_breakpoint (uiout);
7911 if (b->disposition == disp_del)
7912 uiout->text ("Temporary catchpoint ");
7913 else
7914 uiout->text ("Catchpoint ");
7915 if (uiout->is_mi_like_p ())
7916 {
7917 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK));
7918 uiout->field_string ("disp", bpdisp_text (b->disposition));
7919 }
7920 uiout->field_int ("bkptno", b->number);
7921 uiout->text (" (vforked process ");
7922 uiout->field_int ("newpid", ptid_get_pid (c->forked_inferior_pid));
7923 uiout->text ("), ");
7924 return PRINT_SRC_AND_LOC;
7925 }
7926
7927 /* Implement the "print_one" breakpoint_ops method for vfork
7928 catchpoints. */
7929
7930 static void
7931 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
7932 {
7933 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7934 struct value_print_options opts;
7935 struct ui_out *uiout = current_uiout;
7936
7937 get_user_print_options (&opts);
7938 /* Field 4, the address, is omitted (which makes the columns not
7939 line up too nicely with the headers, but the effect is relatively
7940 readable). */
7941 if (opts.addressprint)
7942 uiout->field_skip ("addr");
7943 annotate_field (5);
7944 uiout->text ("vfork");
7945 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7946 {
7947 uiout->text (", process ");
7948 uiout->field_int ("what", ptid_get_pid (c->forked_inferior_pid));
7949 uiout->spaces (1);
7950 }
7951
7952 if (uiout->is_mi_like_p ())
7953 uiout->field_string ("catch-type", "vfork");
7954 }
7955
7956 /* Implement the "print_mention" breakpoint_ops method for vfork
7957 catchpoints. */
7958
7959 static void
7960 print_mention_catch_vfork (struct breakpoint *b)
7961 {
7962 printf_filtered (_("Catchpoint %d (vfork)"), b->number);
7963 }
7964
7965 /* Implement the "print_recreate" breakpoint_ops method for vfork
7966 catchpoints. */
7967
7968 static void
7969 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
7970 {
7971 fprintf_unfiltered (fp, "catch vfork");
7972 print_recreate_thread (b, fp);
7973 }
7974
7975 /* The breakpoint_ops structure to be used in vfork catchpoints. */
7976
7977 static struct breakpoint_ops catch_vfork_breakpoint_ops;
7978
7979 /* An instance of this type is used to represent an solib catchpoint.
7980 A breakpoint is really of this type iff its ops pointer points to
7981 CATCH_SOLIB_BREAKPOINT_OPS. */
7982
7983 struct solib_catchpoint : public breakpoint
7984 {
7985 ~solib_catchpoint () override;
7986
7987 /* True for "catch load", false for "catch unload". */
7988 unsigned char is_load;
7989
7990 /* Regular expression to match, if any. COMPILED is only valid when
7991 REGEX is non-NULL. */
7992 char *regex;
7993 std::unique_ptr<compiled_regex> compiled;
7994 };
7995
7996 solib_catchpoint::~solib_catchpoint ()
7997 {
7998 xfree (this->regex);
7999 }
8000
8001 static int
8002 insert_catch_solib (struct bp_location *ignore)
8003 {
8004 return 0;
8005 }
8006
8007 static int
8008 remove_catch_solib (struct bp_location *ignore, enum remove_bp_reason reason)
8009 {
8010 return 0;
8011 }
8012
8013 static int
8014 breakpoint_hit_catch_solib (const struct bp_location *bl,
8015 const address_space *aspace,
8016 CORE_ADDR bp_addr,
8017 const struct target_waitstatus *ws)
8018 {
8019 struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
8020 struct breakpoint *other;
8021
8022 if (ws->kind == TARGET_WAITKIND_LOADED)
8023 return 1;
8024
8025 ALL_BREAKPOINTS (other)
8026 {
8027 struct bp_location *other_bl;
8028
8029 if (other == bl->owner)
8030 continue;
8031
8032 if (other->type != bp_shlib_event)
8033 continue;
8034
8035 if (self->pspace != NULL && other->pspace != self->pspace)
8036 continue;
8037
8038 for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
8039 {
8040 if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
8041 return 1;
8042 }
8043 }
8044
8045 return 0;
8046 }
8047
8048 static void
8049 check_status_catch_solib (struct bpstats *bs)
8050 {
8051 struct solib_catchpoint *self
8052 = (struct solib_catchpoint *) bs->breakpoint_at;
8053 int ix;
8054
8055 if (self->is_load)
8056 {
8057 struct so_list *iter;
8058
8059 for (ix = 0;
8060 VEC_iterate (so_list_ptr, current_program_space->added_solibs,
8061 ix, iter);
8062 ++ix)
8063 {
8064 if (!self->regex
8065 || self->compiled->exec (iter->so_name, 0, NULL, 0) == 0)
8066 return;
8067 }
8068 }
8069 else
8070 {
8071 char *iter;
8072
8073 for (ix = 0;
8074 VEC_iterate (char_ptr, current_program_space->deleted_solibs,
8075 ix, iter);
8076 ++ix)
8077 {
8078 if (!self->regex
8079 || self->compiled->exec (iter, 0, NULL, 0) == 0)
8080 return;
8081 }
8082 }
8083
8084 bs->stop = 0;
8085 bs->print_it = print_it_noop;
8086 }
8087
8088 static enum print_stop_action
8089 print_it_catch_solib (bpstat bs)
8090 {
8091 struct breakpoint *b = bs->breakpoint_at;
8092 struct ui_out *uiout = current_uiout;
8093
8094 annotate_catchpoint (b->number);
8095 maybe_print_thread_hit_breakpoint (uiout);
8096 if (b->disposition == disp_del)
8097 uiout->text ("Temporary catchpoint ");
8098 else
8099 uiout->text ("Catchpoint ");
8100 uiout->field_int ("bkptno", b->number);
8101 uiout->text ("\n");
8102 if (uiout->is_mi_like_p ())
8103 uiout->field_string ("disp", bpdisp_text (b->disposition));
8104 print_solib_event (1);
8105 return PRINT_SRC_AND_LOC;
8106 }
8107
8108 static void
8109 print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
8110 {
8111 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8112 struct value_print_options opts;
8113 struct ui_out *uiout = current_uiout;
8114 char *msg;
8115
8116 get_user_print_options (&opts);
8117 /* Field 4, the address, is omitted (which makes the columns not
8118 line up too nicely with the headers, but the effect is relatively
8119 readable). */
8120 if (opts.addressprint)
8121 {
8122 annotate_field (4);
8123 uiout->field_skip ("addr");
8124 }
8125
8126 annotate_field (5);
8127 if (self->is_load)
8128 {
8129 if (self->regex)
8130 msg = xstrprintf (_("load of library matching %s"), self->regex);
8131 else
8132 msg = xstrdup (_("load of library"));
8133 }
8134 else
8135 {
8136 if (self->regex)
8137 msg = xstrprintf (_("unload of library matching %s"), self->regex);
8138 else
8139 msg = xstrdup (_("unload of library"));
8140 }
8141 uiout->field_string ("what", msg);
8142 xfree (msg);
8143
8144 if (uiout->is_mi_like_p ())
8145 uiout->field_string ("catch-type", self->is_load ? "load" : "unload");
8146 }
8147
8148 static void
8149 print_mention_catch_solib (struct breakpoint *b)
8150 {
8151 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8152
8153 printf_filtered (_("Catchpoint %d (%s)"), b->number,
8154 self->is_load ? "load" : "unload");
8155 }
8156
8157 static void
8158 print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
8159 {
8160 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8161
8162 fprintf_unfiltered (fp, "%s %s",
8163 b->disposition == disp_del ? "tcatch" : "catch",
8164 self->is_load ? "load" : "unload");
8165 if (self->regex)
8166 fprintf_unfiltered (fp, " %s", self->regex);
8167 fprintf_unfiltered (fp, "\n");
8168 }
8169
8170 static struct breakpoint_ops catch_solib_breakpoint_ops;
8171
8172 /* Shared helper function (MI and CLI) for creating and installing
8173 a shared object event catchpoint. If IS_LOAD is non-zero then
8174 the events to be caught are load events, otherwise they are
8175 unload events. If IS_TEMP is non-zero the catchpoint is a
8176 temporary one. If ENABLED is non-zero the catchpoint is
8177 created in an enabled state. */
8178
8179 void
8180 add_solib_catchpoint (const char *arg, int is_load, int is_temp, int enabled)
8181 {
8182 struct gdbarch *gdbarch = get_current_arch ();
8183
8184 if (!arg)
8185 arg = "";
8186 arg = skip_spaces (arg);
8187
8188 std::unique_ptr<solib_catchpoint> c (new solib_catchpoint ());
8189
8190 if (*arg != '\0')
8191 {
8192 c->compiled.reset (new compiled_regex (arg, REG_NOSUB,
8193 _("Invalid regexp")));
8194 c->regex = xstrdup (arg);
8195 }
8196
8197 c->is_load = is_load;
8198 init_catchpoint (c.get (), gdbarch, is_temp, NULL,
8199 &catch_solib_breakpoint_ops);
8200
8201 c->enable_state = enabled ? bp_enabled : bp_disabled;
8202
8203 install_breakpoint (0, std::move (c), 1);
8204 }
8205
8206 /* A helper function that does all the work for "catch load" and
8207 "catch unload". */
8208
8209 static void
8210 catch_load_or_unload (const char *arg, int from_tty, int is_load,
8211 struct cmd_list_element *command)
8212 {
8213 int tempflag;
8214 const int enabled = 1;
8215
8216 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8217
8218 add_solib_catchpoint (arg, is_load, tempflag, enabled);
8219 }
8220
8221 static void
8222 catch_load_command_1 (const char *arg, int from_tty,
8223 struct cmd_list_element *command)
8224 {
8225 catch_load_or_unload (arg, from_tty, 1, command);
8226 }
8227
8228 static void
8229 catch_unload_command_1 (const char *arg, int from_tty,
8230 struct cmd_list_element *command)
8231 {
8232 catch_load_or_unload (arg, from_tty, 0, command);
8233 }
8234
8235 /* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8236 is non-zero, then make the breakpoint temporary. If COND_STRING is
8237 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8238 the breakpoint_ops structure associated to the catchpoint. */
8239
8240 void
8241 init_catchpoint (struct breakpoint *b,
8242 struct gdbarch *gdbarch, int tempflag,
8243 const char *cond_string,
8244 const struct breakpoint_ops *ops)
8245 {
8246 symtab_and_line sal;
8247 sal.pspace = current_program_space;
8248
8249 init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
8250
8251 b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
8252 b->disposition = tempflag ? disp_del : disp_donttouch;
8253 }
8254
8255 void
8256 install_breakpoint (int internal, std::unique_ptr<breakpoint> &&arg, int update_gll)
8257 {
8258 breakpoint *b = add_to_breakpoint_chain (std::move (arg));
8259 set_breakpoint_number (internal, b);
8260 if (is_tracepoint (b))
8261 set_tracepoint_count (breakpoint_count);
8262 if (!internal)
8263 mention (b);
8264 observer_notify_breakpoint_created (b);
8265
8266 if (update_gll)
8267 update_global_location_list (UGLL_MAY_INSERT);
8268 }
8269
8270 static void
8271 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
8272 int tempflag, const char *cond_string,
8273 const struct breakpoint_ops *ops)
8274 {
8275 std::unique_ptr<fork_catchpoint> c (new fork_catchpoint ());
8276
8277 init_catchpoint (c.get (), gdbarch, tempflag, cond_string, ops);
8278
8279 c->forked_inferior_pid = null_ptid;
8280
8281 install_breakpoint (0, std::move (c), 1);
8282 }
8283
8284 /* Exec catchpoints. */
8285
8286 /* An instance of this type is used to represent an exec catchpoint.
8287 A breakpoint is really of this type iff its ops pointer points to
8288 CATCH_EXEC_BREAKPOINT_OPS. */
8289
8290 struct exec_catchpoint : public breakpoint
8291 {
8292 ~exec_catchpoint () override;
8293
8294 /* Filename of a program whose exec triggered this catchpoint.
8295 This field is only valid immediately after this catchpoint has
8296 triggered. */
8297 char *exec_pathname;
8298 };
8299
8300 /* Exec catchpoint destructor. */
8301
8302 exec_catchpoint::~exec_catchpoint ()
8303 {
8304 xfree (this->exec_pathname);
8305 }
8306
8307 static int
8308 insert_catch_exec (struct bp_location *bl)
8309 {
8310 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid));
8311 }
8312
8313 static int
8314 remove_catch_exec (struct bp_location *bl, enum remove_bp_reason reason)
8315 {
8316 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid));
8317 }
8318
8319 static int
8320 breakpoint_hit_catch_exec (const struct bp_location *bl,
8321 const address_space *aspace, CORE_ADDR bp_addr,
8322 const struct target_waitstatus *ws)
8323 {
8324 struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8325
8326 if (ws->kind != TARGET_WAITKIND_EXECD)
8327 return 0;
8328
8329 c->exec_pathname = xstrdup (ws->value.execd_pathname);
8330 return 1;
8331 }
8332
8333 static enum print_stop_action
8334 print_it_catch_exec (bpstat bs)
8335 {
8336 struct ui_out *uiout = current_uiout;
8337 struct breakpoint *b = bs->breakpoint_at;
8338 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8339
8340 annotate_catchpoint (b->number);
8341 maybe_print_thread_hit_breakpoint (uiout);
8342 if (b->disposition == disp_del)
8343 uiout->text ("Temporary catchpoint ");
8344 else
8345 uiout->text ("Catchpoint ");
8346 if (uiout->is_mi_like_p ())
8347 {
8348 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC));
8349 uiout->field_string ("disp", bpdisp_text (b->disposition));
8350 }
8351 uiout->field_int ("bkptno", b->number);
8352 uiout->text (" (exec'd ");
8353 uiout->field_string ("new-exec", c->exec_pathname);
8354 uiout->text ("), ");
8355
8356 return PRINT_SRC_AND_LOC;
8357 }
8358
8359 static void
8360 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
8361 {
8362 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8363 struct value_print_options opts;
8364 struct ui_out *uiout = current_uiout;
8365
8366 get_user_print_options (&opts);
8367
8368 /* Field 4, the address, is omitted (which makes the columns
8369 not line up too nicely with the headers, but the effect
8370 is relatively readable). */
8371 if (opts.addressprint)
8372 uiout->field_skip ("addr");
8373 annotate_field (5);
8374 uiout->text ("exec");
8375 if (c->exec_pathname != NULL)
8376 {
8377 uiout->text (", program \"");
8378 uiout->field_string ("what", c->exec_pathname);
8379 uiout->text ("\" ");
8380 }
8381
8382 if (uiout->is_mi_like_p ())
8383 uiout->field_string ("catch-type", "exec");
8384 }
8385
8386 static void
8387 print_mention_catch_exec (struct breakpoint *b)
8388 {
8389 printf_filtered (_("Catchpoint %d (exec)"), b->number);
8390 }
8391
8392 /* Implement the "print_recreate" breakpoint_ops method for exec
8393 catchpoints. */
8394
8395 static void
8396 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8397 {
8398 fprintf_unfiltered (fp, "catch exec");
8399 print_recreate_thread (b, fp);
8400 }
8401
8402 static struct breakpoint_ops catch_exec_breakpoint_ops;
8403
8404 static int
8405 hw_breakpoint_used_count (void)
8406 {
8407 int i = 0;
8408 struct breakpoint *b;
8409 struct bp_location *bl;
8410
8411 ALL_BREAKPOINTS (b)
8412 {
8413 if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
8414 for (bl = b->loc; bl; bl = bl->next)
8415 {
8416 /* Special types of hardware breakpoints may use more than
8417 one register. */
8418 i += b->ops->resources_needed (bl);
8419 }
8420 }
8421
8422 return i;
8423 }
8424
8425 /* Returns the resources B would use if it were a hardware
8426 watchpoint. */
8427
8428 static int
8429 hw_watchpoint_use_count (struct breakpoint *b)
8430 {
8431 int i = 0;
8432 struct bp_location *bl;
8433
8434 if (!breakpoint_enabled (b))
8435 return 0;
8436
8437 for (bl = b->loc; bl; bl = bl->next)
8438 {
8439 /* Special types of hardware watchpoints may use more than
8440 one register. */
8441 i += b->ops->resources_needed (bl);
8442 }
8443
8444 return i;
8445 }
8446
8447 /* Returns the sum the used resources of all hardware watchpoints of
8448 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8449 the sum of the used resources of all hardware watchpoints of other
8450 types _not_ TYPE. */
8451
8452 static int
8453 hw_watchpoint_used_count_others (struct breakpoint *except,
8454 enum bptype type, int *other_type_used)
8455 {
8456 int i = 0;
8457 struct breakpoint *b;
8458
8459 *other_type_used = 0;
8460 ALL_BREAKPOINTS (b)
8461 {
8462 if (b == except)
8463 continue;
8464 if (!breakpoint_enabled (b))
8465 continue;
8466
8467 if (b->type == type)
8468 i += hw_watchpoint_use_count (b);
8469 else if (is_hardware_watchpoint (b))
8470 *other_type_used = 1;
8471 }
8472
8473 return i;
8474 }
8475
8476 void
8477 disable_watchpoints_before_interactive_call_start (void)
8478 {
8479 struct breakpoint *b;
8480
8481 ALL_BREAKPOINTS (b)
8482 {
8483 if (is_watchpoint (b) && breakpoint_enabled (b))
8484 {
8485 b->enable_state = bp_call_disabled;
8486 update_global_location_list (UGLL_DONT_INSERT);
8487 }
8488 }
8489 }
8490
8491 void
8492 enable_watchpoints_after_interactive_call_stop (void)
8493 {
8494 struct breakpoint *b;
8495
8496 ALL_BREAKPOINTS (b)
8497 {
8498 if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
8499 {
8500 b->enable_state = bp_enabled;
8501 update_global_location_list (UGLL_MAY_INSERT);
8502 }
8503 }
8504 }
8505
8506 void
8507 disable_breakpoints_before_startup (void)
8508 {
8509 current_program_space->executing_startup = 1;
8510 update_global_location_list (UGLL_DONT_INSERT);
8511 }
8512
8513 void
8514 enable_breakpoints_after_startup (void)
8515 {
8516 current_program_space->executing_startup = 0;
8517 breakpoint_re_set ();
8518 }
8519
8520 /* Create a new single-step breakpoint for thread THREAD, with no
8521 locations. */
8522
8523 static struct breakpoint *
8524 new_single_step_breakpoint (int thread, struct gdbarch *gdbarch)
8525 {
8526 std::unique_ptr<breakpoint> b (new breakpoint ());
8527
8528 init_raw_breakpoint_without_location (b.get (), gdbarch, bp_single_step,
8529 &momentary_breakpoint_ops);
8530
8531 b->disposition = disp_donttouch;
8532 b->frame_id = null_frame_id;
8533
8534 b->thread = thread;
8535 gdb_assert (b->thread != 0);
8536
8537 return add_to_breakpoint_chain (std::move (b));
8538 }
8539
8540 /* Set a momentary breakpoint of type TYPE at address specified by
8541 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8542 frame. */
8543
8544 breakpoint_up
8545 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8546 struct frame_id frame_id, enum bptype type)
8547 {
8548 struct breakpoint *b;
8549
8550 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8551 tail-called one. */
8552 gdb_assert (!frame_id_artificial_p (frame_id));
8553
8554 b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
8555 b->enable_state = bp_enabled;
8556 b->disposition = disp_donttouch;
8557 b->frame_id = frame_id;
8558
8559 /* If we're debugging a multi-threaded program, then we want
8560 momentary breakpoints to be active in only a single thread of
8561 control. */
8562 if (in_thread_list (inferior_ptid))
8563 b->thread = ptid_to_global_thread_id (inferior_ptid);
8564
8565 update_global_location_list_nothrow (UGLL_MAY_INSERT);
8566
8567 return breakpoint_up (b);
8568 }
8569
8570 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8571 The new breakpoint will have type TYPE, use OPS as its
8572 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8573
8574 static struct breakpoint *
8575 momentary_breakpoint_from_master (struct breakpoint *orig,
8576 enum bptype type,
8577 const struct breakpoint_ops *ops,
8578 int loc_enabled)
8579 {
8580 struct breakpoint *copy;
8581
8582 copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
8583 copy->loc = allocate_bp_location (copy);
8584 set_breakpoint_location_function (copy->loc, 1);
8585
8586 copy->loc->gdbarch = orig->loc->gdbarch;
8587 copy->loc->requested_address = orig->loc->requested_address;
8588 copy->loc->address = orig->loc->address;
8589 copy->loc->section = orig->loc->section;
8590 copy->loc->pspace = orig->loc->pspace;
8591 copy->loc->probe = orig->loc->probe;
8592 copy->loc->line_number = orig->loc->line_number;
8593 copy->loc->symtab = orig->loc->symtab;
8594 copy->loc->enabled = loc_enabled;
8595 copy->frame_id = orig->frame_id;
8596 copy->thread = orig->thread;
8597 copy->pspace = orig->pspace;
8598
8599 copy->enable_state = bp_enabled;
8600 copy->disposition = disp_donttouch;
8601 copy->number = internal_breakpoint_number--;
8602
8603 update_global_location_list_nothrow (UGLL_DONT_INSERT);
8604 return copy;
8605 }
8606
8607 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8608 ORIG is NULL. */
8609
8610 struct breakpoint *
8611 clone_momentary_breakpoint (struct breakpoint *orig)
8612 {
8613 /* If there's nothing to clone, then return nothing. */
8614 if (orig == NULL)
8615 return NULL;
8616
8617 return momentary_breakpoint_from_master (orig, orig->type, orig->ops, 0);
8618 }
8619
8620 breakpoint_up
8621 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8622 enum bptype type)
8623 {
8624 struct symtab_and_line sal;
8625
8626 sal = find_pc_line (pc, 0);
8627 sal.pc = pc;
8628 sal.section = find_pc_overlay (pc);
8629 sal.explicit_pc = 1;
8630
8631 return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
8632 }
8633
8634
8635 /* Tell the user we have just set a breakpoint B. */
8636
8637 static void
8638 mention (struct breakpoint *b)
8639 {
8640 b->ops->print_mention (b);
8641 if (current_uiout->is_mi_like_p ())
8642 return;
8643 printf_filtered ("\n");
8644 }
8645
8646
8647 static int bp_loc_is_permanent (struct bp_location *loc);
8648
8649 static struct bp_location *
8650 add_location_to_breakpoint (struct breakpoint *b,
8651 const struct symtab_and_line *sal)
8652 {
8653 struct bp_location *loc, **tmp;
8654 CORE_ADDR adjusted_address;
8655 struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
8656
8657 if (loc_gdbarch == NULL)
8658 loc_gdbarch = b->gdbarch;
8659
8660 /* Adjust the breakpoint's address prior to allocating a location.
8661 Once we call allocate_bp_location(), that mostly uninitialized
8662 location will be placed on the location chain. Adjustment of the
8663 breakpoint may cause target_read_memory() to be called and we do
8664 not want its scan of the location chain to find a breakpoint and
8665 location that's only been partially initialized. */
8666 adjusted_address = adjust_breakpoint_address (loc_gdbarch,
8667 sal->pc, b->type);
8668
8669 /* Sort the locations by their ADDRESS. */
8670 loc = allocate_bp_location (b);
8671 for (tmp = &(b->loc); *tmp != NULL && (*tmp)->address <= adjusted_address;
8672 tmp = &((*tmp)->next))
8673 ;
8674 loc->next = *tmp;
8675 *tmp = loc;
8676
8677 loc->requested_address = sal->pc;
8678 loc->address = adjusted_address;
8679 loc->pspace = sal->pspace;
8680 loc->probe.prob = sal->prob;
8681 loc->probe.objfile = sal->objfile;
8682 gdb_assert (loc->pspace != NULL);
8683 loc->section = sal->section;
8684 loc->gdbarch = loc_gdbarch;
8685 loc->line_number = sal->line;
8686 loc->symtab = sal->symtab;
8687 loc->symbol = sal->symbol;
8688
8689 set_breakpoint_location_function (loc,
8690 sal->explicit_pc || sal->explicit_line);
8691
8692 /* While by definition, permanent breakpoints are already present in the
8693 code, we don't mark the location as inserted. Normally one would expect
8694 that GDB could rely on that breakpoint instruction to stop the program,
8695 thus removing the need to insert its own breakpoint, except that executing
8696 the breakpoint instruction can kill the target instead of reporting a
8697 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8698 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8699 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8700 breakpoint be inserted normally results in QEMU knowing about the GDB
8701 breakpoint, and thus trap before the breakpoint instruction is executed.
8702 (If GDB later needs to continue execution past the permanent breakpoint,
8703 it manually increments the PC, thus avoiding executing the breakpoint
8704 instruction.) */
8705 if (bp_loc_is_permanent (loc))
8706 loc->permanent = 1;
8707
8708 return loc;
8709 }
8710
8711
8712 /* See breakpoint.h. */
8713
8714 int
8715 program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address)
8716 {
8717 int len;
8718 CORE_ADDR addr;
8719 const gdb_byte *bpoint;
8720 gdb_byte *target_mem;
8721
8722 addr = address;
8723 bpoint = gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
8724
8725 /* Software breakpoints unsupported? */
8726 if (bpoint == NULL)
8727 return 0;
8728
8729 target_mem = (gdb_byte *) alloca (len);
8730
8731 /* Enable the automatic memory restoration from breakpoints while
8732 we read the memory. Otherwise we could say about our temporary
8733 breakpoints they are permanent. */
8734 scoped_restore restore_memory
8735 = make_scoped_restore_show_memory_breakpoints (0);
8736
8737 if (target_read_memory (address, target_mem, len) == 0
8738 && memcmp (target_mem, bpoint, len) == 0)
8739 return 1;
8740
8741 return 0;
8742 }
8743
8744 /* Return 1 if LOC is pointing to a permanent breakpoint,
8745 return 0 otherwise. */
8746
8747 static int
8748 bp_loc_is_permanent (struct bp_location *loc)
8749 {
8750 gdb_assert (loc != NULL);
8751
8752 /* If we have a catchpoint or a watchpoint, just return 0. We should not
8753 attempt to read from the addresses the locations of these breakpoint types
8754 point to. program_breakpoint_here_p, below, will attempt to read
8755 memory. */
8756 if (!breakpoint_address_is_meaningful (loc->owner))
8757 return 0;
8758
8759 scoped_restore_current_pspace_and_thread restore_pspace_thread;
8760 switch_to_program_space_and_thread (loc->pspace);
8761 return program_breakpoint_here_p (loc->gdbarch, loc->address);
8762 }
8763
8764 /* Build a command list for the dprintf corresponding to the current
8765 settings of the dprintf style options. */
8766
8767 static void
8768 update_dprintf_command_list (struct breakpoint *b)
8769 {
8770 char *dprintf_args = b->extra_string;
8771 char *printf_line = NULL;
8772
8773 if (!dprintf_args)
8774 return;
8775
8776 dprintf_args = skip_spaces (dprintf_args);
8777
8778 /* Allow a comma, as it may have terminated a location, but don't
8779 insist on it. */
8780 if (*dprintf_args == ',')
8781 ++dprintf_args;
8782 dprintf_args = skip_spaces (dprintf_args);
8783
8784 if (*dprintf_args != '"')
8785 error (_("Bad format string, missing '\"'."));
8786
8787 if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
8788 printf_line = xstrprintf ("printf %s", dprintf_args);
8789 else if (strcmp (dprintf_style, dprintf_style_call) == 0)
8790 {
8791 if (!dprintf_function)
8792 error (_("No function supplied for dprintf call"));
8793
8794 if (dprintf_channel && strlen (dprintf_channel) > 0)
8795 printf_line = xstrprintf ("call (void) %s (%s,%s)",
8796 dprintf_function,
8797 dprintf_channel,
8798 dprintf_args);
8799 else
8800 printf_line = xstrprintf ("call (void) %s (%s)",
8801 dprintf_function,
8802 dprintf_args);
8803 }
8804 else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
8805 {
8806 if (target_can_run_breakpoint_commands ())
8807 printf_line = xstrprintf ("agent-printf %s", dprintf_args);
8808 else
8809 {
8810 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8811 printf_line = xstrprintf ("printf %s", dprintf_args);
8812 }
8813 }
8814 else
8815 internal_error (__FILE__, __LINE__,
8816 _("Invalid dprintf style."));
8817
8818 gdb_assert (printf_line != NULL);
8819 /* Manufacture a printf sequence. */
8820 {
8821 struct command_line *printf_cmd_line = XNEW (struct command_line);
8822
8823 printf_cmd_line->control_type = simple_control;
8824 printf_cmd_line->body_count = 0;
8825 printf_cmd_line->body_list = NULL;
8826 printf_cmd_line->next = NULL;
8827 printf_cmd_line->line = printf_line;
8828
8829 breakpoint_set_commands (b, command_line_up (printf_cmd_line));
8830 }
8831 }
8832
8833 /* Update all dprintf commands, making their command lists reflect
8834 current style settings. */
8835
8836 static void
8837 update_dprintf_commands (const char *args, int from_tty,
8838 struct cmd_list_element *c)
8839 {
8840 struct breakpoint *b;
8841
8842 ALL_BREAKPOINTS (b)
8843 {
8844 if (b->type == bp_dprintf)
8845 update_dprintf_command_list (b);
8846 }
8847 }
8848
8849 /* Create a breakpoint with SAL as location. Use LOCATION
8850 as a description of the location, and COND_STRING
8851 as condition expression. If LOCATION is NULL then create an
8852 "address location" from the address in the SAL. */
8853
8854 static void
8855 init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
8856 gdb::array_view<const symtab_and_line> sals,
8857 event_location_up &&location,
8858 gdb::unique_xmalloc_ptr<char> filter,
8859 gdb::unique_xmalloc_ptr<char> cond_string,
8860 gdb::unique_xmalloc_ptr<char> extra_string,
8861 enum bptype type, enum bpdisp disposition,
8862 int thread, int task, int ignore_count,
8863 const struct breakpoint_ops *ops, int from_tty,
8864 int enabled, int internal, unsigned flags,
8865 int display_canonical)
8866 {
8867 int i;
8868
8869 if (type == bp_hardware_breakpoint)
8870 {
8871 int target_resources_ok;
8872
8873 i = hw_breakpoint_used_count ();
8874 target_resources_ok =
8875 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
8876 i + 1, 0);
8877 if (target_resources_ok == 0)
8878 error (_("No hardware breakpoint support in the target."));
8879 else if (target_resources_ok < 0)
8880 error (_("Hardware breakpoints used exceeds limit."));
8881 }
8882
8883 gdb_assert (!sals.empty ());
8884
8885 for (const auto &sal : sals)
8886 {
8887 struct bp_location *loc;
8888
8889 if (from_tty)
8890 {
8891 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
8892 if (!loc_gdbarch)
8893 loc_gdbarch = gdbarch;
8894
8895 describe_other_breakpoints (loc_gdbarch,
8896 sal.pspace, sal.pc, sal.section, thread);
8897 }
8898
8899 if (&sal == &sals[0])
8900 {
8901 init_raw_breakpoint (b, gdbarch, sal, type, ops);
8902 b->thread = thread;
8903 b->task = task;
8904
8905 b->cond_string = cond_string.release ();
8906 b->extra_string = extra_string.release ();
8907 b->ignore_count = ignore_count;
8908 b->enable_state = enabled ? bp_enabled : bp_disabled;
8909 b->disposition = disposition;
8910
8911 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8912 b->loc->inserted = 1;
8913
8914 if (type == bp_static_tracepoint)
8915 {
8916 struct tracepoint *t = (struct tracepoint *) b;
8917 struct static_tracepoint_marker marker;
8918
8919 if (strace_marker_p (b))
8920 {
8921 /* We already know the marker exists, otherwise, we
8922 wouldn't see a sal for it. */
8923 const char *p
8924 = &event_location_to_string (b->location.get ())[3];
8925 const char *endp;
8926 char *marker_str;
8927
8928 p = skip_spaces (p);
8929
8930 endp = skip_to_space (p);
8931
8932 marker_str = savestring (p, endp - p);
8933 t->static_trace_marker_id = marker_str;
8934
8935 printf_filtered (_("Probed static tracepoint "
8936 "marker \"%s\"\n"),
8937 t->static_trace_marker_id);
8938 }
8939 else if (target_static_tracepoint_marker_at (sal.pc, &marker))
8940 {
8941 t->static_trace_marker_id = xstrdup (marker.str_id);
8942 release_static_tracepoint_marker (&marker);
8943
8944 printf_filtered (_("Probed static tracepoint "
8945 "marker \"%s\"\n"),
8946 t->static_trace_marker_id);
8947 }
8948 else
8949 warning (_("Couldn't determine the static "
8950 "tracepoint marker to probe"));
8951 }
8952
8953 loc = b->loc;
8954 }
8955 else
8956 {
8957 loc = add_location_to_breakpoint (b, &sal);
8958 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8959 loc->inserted = 1;
8960 }
8961
8962 if (b->cond_string)
8963 {
8964 const char *arg = b->cond_string;
8965
8966 loc->cond = parse_exp_1 (&arg, loc->address,
8967 block_for_pc (loc->address), 0);
8968 if (*arg)
8969 error (_("Garbage '%s' follows condition"), arg);
8970 }
8971
8972 /* Dynamic printf requires and uses additional arguments on the
8973 command line, otherwise it's an error. */
8974 if (type == bp_dprintf)
8975 {
8976 if (b->extra_string)
8977 update_dprintf_command_list (b);
8978 else
8979 error (_("Format string required"));
8980 }
8981 else if (b->extra_string)
8982 error (_("Garbage '%s' at end of command"), b->extra_string);
8983 }
8984
8985 b->display_canonical = display_canonical;
8986 if (location != NULL)
8987 b->location = std::move (location);
8988 else
8989 b->location = new_address_location (b->loc->address, NULL, 0);
8990 b->filter = filter.release ();
8991 }
8992
8993 static void
8994 create_breakpoint_sal (struct gdbarch *gdbarch,
8995 gdb::array_view<const symtab_and_line> sals,
8996 event_location_up &&location,
8997 gdb::unique_xmalloc_ptr<char> filter,
8998 gdb::unique_xmalloc_ptr<char> cond_string,
8999 gdb::unique_xmalloc_ptr<char> extra_string,
9000 enum bptype type, enum bpdisp disposition,
9001 int thread, int task, int ignore_count,
9002 const struct breakpoint_ops *ops, int from_tty,
9003 int enabled, int internal, unsigned flags,
9004 int display_canonical)
9005 {
9006 std::unique_ptr<breakpoint> b = new_breakpoint_from_type (type);
9007
9008 init_breakpoint_sal (b.get (), gdbarch,
9009 sals, std::move (location),
9010 std::move (filter),
9011 std::move (cond_string),
9012 std::move (extra_string),
9013 type, disposition,
9014 thread, task, ignore_count,
9015 ops, from_tty,
9016 enabled, internal, flags,
9017 display_canonical);
9018
9019 install_breakpoint (internal, std::move (b), 0);
9020 }
9021
9022 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9023 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9024 value. COND_STRING, if not NULL, specified the condition to be
9025 used for all breakpoints. Essentially the only case where
9026 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9027 function. In that case, it's still not possible to specify
9028 separate conditions for different overloaded functions, so
9029 we take just a single condition string.
9030
9031 NOTE: If the function succeeds, the caller is expected to cleanup
9032 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9033 array contents). If the function fails (error() is called), the
9034 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9035 COND and SALS arrays and each of those arrays contents. */
9036
9037 static void
9038 create_breakpoints_sal (struct gdbarch *gdbarch,
9039 struct linespec_result *canonical,
9040 gdb::unique_xmalloc_ptr<char> cond_string,
9041 gdb::unique_xmalloc_ptr<char> extra_string,
9042 enum bptype type, enum bpdisp disposition,
9043 int thread, int task, int ignore_count,
9044 const struct breakpoint_ops *ops, int from_tty,
9045 int enabled, int internal, unsigned flags)
9046 {
9047 if (canonical->pre_expanded)
9048 gdb_assert (canonical->lsals.size () == 1);
9049
9050 for (const auto &lsal : canonical->lsals)
9051 {
9052 /* Note that 'location' can be NULL in the case of a plain
9053 'break', without arguments. */
9054 event_location_up location
9055 = (canonical->location != NULL
9056 ? copy_event_location (canonical->location.get ()) : NULL);
9057 gdb::unique_xmalloc_ptr<char> filter_string
9058 (lsal.canonical != NULL ? xstrdup (lsal.canonical) : NULL);
9059
9060 create_breakpoint_sal (gdbarch, lsal.sals,
9061 std::move (location),
9062 std::move (filter_string),
9063 std::move (cond_string),
9064 std::move (extra_string),
9065 type, disposition,
9066 thread, task, ignore_count, ops,
9067 from_tty, enabled, internal, flags,
9068 canonical->special_display);
9069 }
9070 }
9071
9072 /* Parse LOCATION which is assumed to be a SAL specification possibly
9073 followed by conditionals. On return, SALS contains an array of SAL
9074 addresses found. LOCATION points to the end of the SAL (for
9075 linespec locations).
9076
9077 The array and the line spec strings are allocated on the heap, it is
9078 the caller's responsibility to free them. */
9079
9080 static void
9081 parse_breakpoint_sals (const struct event_location *location,
9082 struct linespec_result *canonical)
9083 {
9084 struct symtab_and_line cursal;
9085
9086 if (event_location_type (location) == LINESPEC_LOCATION)
9087 {
9088 const char *spec = get_linespec_location (location)->spec_string;
9089
9090 if (spec == NULL)
9091 {
9092 /* The last displayed codepoint, if it's valid, is our default
9093 breakpoint address. */
9094 if (last_displayed_sal_is_valid ())
9095 {
9096 /* Set sal's pspace, pc, symtab, and line to the values
9097 corresponding to the last call to print_frame_info.
9098 Be sure to reinitialize LINE with NOTCURRENT == 0
9099 as the breakpoint line number is inappropriate otherwise.
9100 find_pc_line would adjust PC, re-set it back. */
9101 symtab_and_line sal = get_last_displayed_sal ();
9102 CORE_ADDR pc = sal.pc;
9103
9104 sal = find_pc_line (pc, 0);
9105
9106 /* "break" without arguments is equivalent to "break *PC"
9107 where PC is the last displayed codepoint's address. So
9108 make sure to set sal.explicit_pc to prevent GDB from
9109 trying to expand the list of sals to include all other
9110 instances with the same symtab and line. */
9111 sal.pc = pc;
9112 sal.explicit_pc = 1;
9113
9114 struct linespec_sals lsal;
9115 lsal.sals = {sal};
9116 lsal.canonical = NULL;
9117
9118 canonical->lsals.push_back (std::move (lsal));
9119 return;
9120 }
9121 else
9122 error (_("No default breakpoint address now."));
9123 }
9124 }
9125
9126 /* Force almost all breakpoints to be in terms of the
9127 current_source_symtab (which is decode_line_1's default).
9128 This should produce the results we want almost all of the
9129 time while leaving default_breakpoint_* alone.
9130
9131 ObjC: However, don't match an Objective-C method name which
9132 may have a '+' or '-' succeeded by a '['. */
9133 cursal = get_current_source_symtab_and_line ();
9134 if (last_displayed_sal_is_valid ())
9135 {
9136 const char *spec = NULL;
9137
9138 if (event_location_type (location) == LINESPEC_LOCATION)
9139 spec = get_linespec_location (location)->spec_string;
9140
9141 if (!cursal.symtab
9142 || (spec != NULL
9143 && strchr ("+-", spec[0]) != NULL
9144 && spec[1] != '['))
9145 {
9146 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9147 get_last_displayed_symtab (),
9148 get_last_displayed_line (),
9149 canonical, NULL, NULL);
9150 return;
9151 }
9152 }
9153
9154 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9155 cursal.symtab, cursal.line, canonical, NULL, NULL);
9156 }
9157
9158
9159 /* Convert each SAL into a real PC. Verify that the PC can be
9160 inserted as a breakpoint. If it can't throw an error. */
9161
9162 static void
9163 breakpoint_sals_to_pc (std::vector<symtab_and_line> &sals)
9164 {
9165 for (auto &sal : sals)
9166 resolve_sal_pc (&sal);
9167 }
9168
9169 /* Fast tracepoints may have restrictions on valid locations. For
9170 instance, a fast tracepoint using a jump instead of a trap will
9171 likely have to overwrite more bytes than a trap would, and so can
9172 only be placed where the instruction is longer than the jump, or a
9173 multi-instruction sequence does not have a jump into the middle of
9174 it, etc. */
9175
9176 static void
9177 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9178 gdb::array_view<const symtab_and_line> sals)
9179 {
9180 int rslt;
9181 char *msg;
9182 struct cleanup *old_chain;
9183
9184 for (const auto &sal : sals)
9185 {
9186 struct gdbarch *sarch;
9187
9188 sarch = get_sal_arch (sal);
9189 /* We fall back to GDBARCH if there is no architecture
9190 associated with SAL. */
9191 if (sarch == NULL)
9192 sarch = gdbarch;
9193 rslt = gdbarch_fast_tracepoint_valid_at (sarch, sal.pc, &msg);
9194 old_chain = make_cleanup (xfree, msg);
9195
9196 if (!rslt)
9197 error (_("May not have a fast tracepoint at %s%s"),
9198 paddress (sarch, sal.pc), (msg ? msg : ""));
9199
9200 do_cleanups (old_chain);
9201 }
9202 }
9203
9204 /* Given TOK, a string specification of condition and thread, as
9205 accepted by the 'break' command, extract the condition
9206 string and thread number and set *COND_STRING and *THREAD.
9207 PC identifies the context at which the condition should be parsed.
9208 If no condition is found, *COND_STRING is set to NULL.
9209 If no thread is found, *THREAD is set to -1. */
9210
9211 static void
9212 find_condition_and_thread (const char *tok, CORE_ADDR pc,
9213 char **cond_string, int *thread, int *task,
9214 char **rest)
9215 {
9216 *cond_string = NULL;
9217 *thread = -1;
9218 *task = 0;
9219 *rest = NULL;
9220
9221 while (tok && *tok)
9222 {
9223 const char *end_tok;
9224 int toklen;
9225 const char *cond_start = NULL;
9226 const char *cond_end = NULL;
9227
9228 tok = skip_spaces (tok);
9229
9230 if ((*tok == '"' || *tok == ',') && rest)
9231 {
9232 *rest = savestring (tok, strlen (tok));
9233 return;
9234 }
9235
9236 end_tok = skip_to_space (tok);
9237
9238 toklen = end_tok - tok;
9239
9240 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9241 {
9242 tok = cond_start = end_tok + 1;
9243 parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
9244 cond_end = tok;
9245 *cond_string = savestring (cond_start, cond_end - cond_start);
9246 }
9247 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9248 {
9249 const char *tmptok;
9250 struct thread_info *thr;
9251
9252 tok = end_tok + 1;
9253 thr = parse_thread_id (tok, &tmptok);
9254 if (tok == tmptok)
9255 error (_("Junk after thread keyword."));
9256 *thread = thr->global_num;
9257 tok = tmptok;
9258 }
9259 else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9260 {
9261 char *tmptok;
9262
9263 tok = end_tok + 1;
9264 *task = strtol (tok, &tmptok, 0);
9265 if (tok == tmptok)
9266 error (_("Junk after task keyword."));
9267 if (!valid_task_id (*task))
9268 error (_("Unknown task %d."), *task);
9269 tok = tmptok;
9270 }
9271 else if (rest)
9272 {
9273 *rest = savestring (tok, strlen (tok));
9274 return;
9275 }
9276 else
9277 error (_("Junk at end of arguments."));
9278 }
9279 }
9280
9281 /* Decode a static tracepoint marker spec. */
9282
9283 static std::vector<symtab_and_line>
9284 decode_static_tracepoint_spec (const char **arg_p)
9285 {
9286 VEC(static_tracepoint_marker_p) *markers = NULL;
9287 const char *p = &(*arg_p)[3];
9288 const char *endp;
9289 int i;
9290
9291 p = skip_spaces (p);
9292
9293 endp = skip_to_space (p);
9294
9295 std::string marker_str (p, endp - p);
9296
9297 markers = target_static_tracepoint_markers_by_strid (marker_str.c_str ());
9298 if (VEC_empty(static_tracepoint_marker_p, markers))
9299 error (_("No known static tracepoint marker named %s"),
9300 marker_str.c_str ());
9301
9302 std::vector<symtab_and_line> sals;
9303 sals.reserve (VEC_length(static_tracepoint_marker_p, markers));
9304
9305 for (i = 0; i < VEC_length(static_tracepoint_marker_p, markers); i++)
9306 {
9307 struct static_tracepoint_marker *marker;
9308
9309 marker = VEC_index (static_tracepoint_marker_p, markers, i);
9310
9311 symtab_and_line sal = find_pc_line (marker->address, 0);
9312 sal.pc = marker->address;
9313 sals.push_back (sal);
9314
9315 release_static_tracepoint_marker (marker);
9316 }
9317
9318 *arg_p = endp;
9319 return sals;
9320 }
9321
9322 /* See breakpoint.h. */
9323
9324 int
9325 create_breakpoint (struct gdbarch *gdbarch,
9326 const struct event_location *location,
9327 const char *cond_string,
9328 int thread, const char *extra_string,
9329 int parse_extra,
9330 int tempflag, enum bptype type_wanted,
9331 int ignore_count,
9332 enum auto_boolean pending_break_support,
9333 const struct breakpoint_ops *ops,
9334 int from_tty, int enabled, int internal,
9335 unsigned flags)
9336 {
9337 struct linespec_result canonical;
9338 struct cleanup *bkpt_chain = NULL;
9339 int pending = 0;
9340 int task = 0;
9341 int prev_bkpt_count = breakpoint_count;
9342
9343 gdb_assert (ops != NULL);
9344
9345 /* If extra_string isn't useful, set it to NULL. */
9346 if (extra_string != NULL && *extra_string == '\0')
9347 extra_string = NULL;
9348
9349 TRY
9350 {
9351 ops->create_sals_from_location (location, &canonical, type_wanted);
9352 }
9353 CATCH (e, RETURN_MASK_ERROR)
9354 {
9355 /* If caller is interested in rc value from parse, set
9356 value. */
9357 if (e.error == NOT_FOUND_ERROR)
9358 {
9359 /* If pending breakpoint support is turned off, throw
9360 error. */
9361
9362 if (pending_break_support == AUTO_BOOLEAN_FALSE)
9363 throw_exception (e);
9364
9365 exception_print (gdb_stderr, e);
9366
9367 /* If pending breakpoint support is auto query and the user
9368 selects no, then simply return the error code. */
9369 if (pending_break_support == AUTO_BOOLEAN_AUTO
9370 && !nquery (_("Make %s pending on future shared library load? "),
9371 bptype_string (type_wanted)))
9372 return 0;
9373
9374 /* At this point, either the user was queried about setting
9375 a pending breakpoint and selected yes, or pending
9376 breakpoint behavior is on and thus a pending breakpoint
9377 is defaulted on behalf of the user. */
9378 pending = 1;
9379 }
9380 else
9381 throw_exception (e);
9382 }
9383 END_CATCH
9384
9385 if (!pending && canonical.lsals.empty ())
9386 return 0;
9387
9388 /* ----------------------------- SNIP -----------------------------
9389 Anything added to the cleanup chain beyond this point is assumed
9390 to be part of a breakpoint. If the breakpoint create succeeds
9391 then the memory is not reclaimed. */
9392 bkpt_chain = make_cleanup (null_cleanup, 0);
9393
9394 /* Resolve all line numbers to PC's and verify that the addresses
9395 are ok for the target. */
9396 if (!pending)
9397 {
9398 for (auto &lsal : canonical.lsals)
9399 breakpoint_sals_to_pc (lsal.sals);
9400 }
9401
9402 /* Fast tracepoints may have additional restrictions on location. */
9403 if (!pending && type_wanted == bp_fast_tracepoint)
9404 {
9405 for (const auto &lsal : canonical.lsals)
9406 check_fast_tracepoint_sals (gdbarch, lsal.sals);
9407 }
9408
9409 /* Verify that condition can be parsed, before setting any
9410 breakpoints. Allocate a separate condition expression for each
9411 breakpoint. */
9412 if (!pending)
9413 {
9414 gdb::unique_xmalloc_ptr<char> cond_string_copy;
9415 gdb::unique_xmalloc_ptr<char> extra_string_copy;
9416
9417 if (parse_extra)
9418 {
9419 char *rest;
9420 char *cond;
9421
9422 const linespec_sals &lsal = canonical.lsals[0];
9423
9424 /* Here we only parse 'arg' to separate condition
9425 from thread number, so parsing in context of first
9426 sal is OK. When setting the breakpoint we'll
9427 re-parse it in context of each sal. */
9428
9429 find_condition_and_thread (extra_string, lsal.sals[0].pc,
9430 &cond, &thread, &task, &rest);
9431 cond_string_copy.reset (cond);
9432 extra_string_copy.reset (rest);
9433 }
9434 else
9435 {
9436 if (type_wanted != bp_dprintf
9437 && extra_string != NULL && *extra_string != '\0')
9438 error (_("Garbage '%s' at end of location"), extra_string);
9439
9440 /* Create a private copy of condition string. */
9441 if (cond_string)
9442 cond_string_copy.reset (xstrdup (cond_string));
9443 /* Create a private copy of any extra string. */
9444 if (extra_string)
9445 extra_string_copy.reset (xstrdup (extra_string));
9446 }
9447
9448 ops->create_breakpoints_sal (gdbarch, &canonical,
9449 std::move (cond_string_copy),
9450 std::move (extra_string_copy),
9451 type_wanted,
9452 tempflag ? disp_del : disp_donttouch,
9453 thread, task, ignore_count, ops,
9454 from_tty, enabled, internal, flags);
9455 }
9456 else
9457 {
9458 std::unique_ptr <breakpoint> b = new_breakpoint_from_type (type_wanted);
9459
9460 init_raw_breakpoint_without_location (b.get (), gdbarch, type_wanted, ops);
9461 b->location = copy_event_location (location);
9462
9463 if (parse_extra)
9464 b->cond_string = NULL;
9465 else
9466 {
9467 /* Create a private copy of condition string. */
9468 b->cond_string = cond_string != NULL ? xstrdup (cond_string) : NULL;
9469 b->thread = thread;
9470 }
9471
9472 /* Create a private copy of any extra string. */
9473 b->extra_string = extra_string != NULL ? xstrdup (extra_string) : NULL;
9474 b->ignore_count = ignore_count;
9475 b->disposition = tempflag ? disp_del : disp_donttouch;
9476 b->condition_not_parsed = 1;
9477 b->enable_state = enabled ? bp_enabled : bp_disabled;
9478 if ((type_wanted != bp_breakpoint
9479 && type_wanted != bp_hardware_breakpoint) || thread != -1)
9480 b->pspace = current_program_space;
9481
9482 install_breakpoint (internal, std::move (b), 0);
9483 }
9484
9485 if (canonical.lsals.size () > 1)
9486 {
9487 warning (_("Multiple breakpoints were set.\nUse the "
9488 "\"delete\" command to delete unwanted breakpoints."));
9489 prev_breakpoint_count = prev_bkpt_count;
9490 }
9491
9492 /* That's it. Discard the cleanups for data inserted into the
9493 breakpoint. */
9494 discard_cleanups (bkpt_chain);
9495
9496 /* error call may happen here - have BKPT_CHAIN already discarded. */
9497 update_global_location_list (UGLL_MAY_INSERT);
9498
9499 return 1;
9500 }
9501
9502 /* Set a breakpoint.
9503 ARG is a string describing breakpoint address,
9504 condition, and thread.
9505 FLAG specifies if a breakpoint is hardware on,
9506 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9507 and BP_TEMPFLAG. */
9508
9509 static void
9510 break_command_1 (const char *arg, int flag, int from_tty)
9511 {
9512 int tempflag = flag & BP_TEMPFLAG;
9513 enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9514 ? bp_hardware_breakpoint
9515 : bp_breakpoint);
9516 struct breakpoint_ops *ops;
9517
9518 event_location_up location = string_to_event_location (&arg, current_language);
9519
9520 /* Matching breakpoints on probes. */
9521 if (location != NULL
9522 && event_location_type (location.get ()) == PROBE_LOCATION)
9523 ops = &bkpt_probe_breakpoint_ops;
9524 else
9525 ops = &bkpt_breakpoint_ops;
9526
9527 create_breakpoint (get_current_arch (),
9528 location.get (),
9529 NULL, 0, arg, 1 /* parse arg */,
9530 tempflag, type_wanted,
9531 0 /* Ignore count */,
9532 pending_break_support,
9533 ops,
9534 from_tty,
9535 1 /* enabled */,
9536 0 /* internal */,
9537 0);
9538 }
9539
9540 /* Helper function for break_command_1 and disassemble_command. */
9541
9542 void
9543 resolve_sal_pc (struct symtab_and_line *sal)
9544 {
9545 CORE_ADDR pc;
9546
9547 if (sal->pc == 0 && sal->symtab != NULL)
9548 {
9549 if (!find_line_pc (sal->symtab, sal->line, &pc))
9550 error (_("No line %d in file \"%s\"."),
9551 sal->line, symtab_to_filename_for_display (sal->symtab));
9552 sal->pc = pc;
9553
9554 /* If this SAL corresponds to a breakpoint inserted using a line
9555 number, then skip the function prologue if necessary. */
9556 if (sal->explicit_line)
9557 skip_prologue_sal (sal);
9558 }
9559
9560 if (sal->section == 0 && sal->symtab != NULL)
9561 {
9562 const struct blockvector *bv;
9563 const struct block *b;
9564 struct symbol *sym;
9565
9566 bv = blockvector_for_pc_sect (sal->pc, 0, &b,
9567 SYMTAB_COMPUNIT (sal->symtab));
9568 if (bv != NULL)
9569 {
9570 sym = block_linkage_function (b);
9571 if (sym != NULL)
9572 {
9573 fixup_symbol_section (sym, SYMTAB_OBJFILE (sal->symtab));
9574 sal->section = SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal->symtab),
9575 sym);
9576 }
9577 else
9578 {
9579 /* It really is worthwhile to have the section, so we'll
9580 just have to look harder. This case can be executed
9581 if we have line numbers but no functions (as can
9582 happen in assembly source). */
9583
9584 scoped_restore_current_pspace_and_thread restore_pspace_thread;
9585 switch_to_program_space_and_thread (sal->pspace);
9586
9587 bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (sal->pc);
9588 if (msym.minsym)
9589 sal->section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
9590 }
9591 }
9592 }
9593 }
9594
9595 void
9596 break_command (const char *arg, int from_tty)
9597 {
9598 break_command_1 (arg, 0, from_tty);
9599 }
9600
9601 void
9602 tbreak_command (const char *arg, int from_tty)
9603 {
9604 break_command_1 (arg, BP_TEMPFLAG, from_tty);
9605 }
9606
9607 static void
9608 hbreak_command (const char *arg, int from_tty)
9609 {
9610 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
9611 }
9612
9613 static void
9614 thbreak_command (const char *arg, int from_tty)
9615 {
9616 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
9617 }
9618
9619 static void
9620 stop_command (const char *arg, int from_tty)
9621 {
9622 printf_filtered (_("Specify the type of breakpoint to set.\n\
9623 Usage: stop in <function | address>\n\
9624 stop at <line>\n"));
9625 }
9626
9627 static void
9628 stopin_command (const char *arg, int from_tty)
9629 {
9630 int badInput = 0;
9631
9632 if (arg == (char *) NULL)
9633 badInput = 1;
9634 else if (*arg != '*')
9635 {
9636 const char *argptr = arg;
9637 int hasColon = 0;
9638
9639 /* Look for a ':'. If this is a line number specification, then
9640 say it is bad, otherwise, it should be an address or
9641 function/method name. */
9642 while (*argptr && !hasColon)
9643 {
9644 hasColon = (*argptr == ':');
9645 argptr++;
9646 }
9647
9648 if (hasColon)
9649 badInput = (*argptr != ':'); /* Not a class::method */
9650 else
9651 badInput = isdigit (*arg); /* a simple line number */
9652 }
9653
9654 if (badInput)
9655 printf_filtered (_("Usage: stop in <function | address>\n"));
9656 else
9657 break_command_1 (arg, 0, from_tty);
9658 }
9659
9660 static void
9661 stopat_command (const char *arg, int from_tty)
9662 {
9663 int badInput = 0;
9664
9665 if (arg == (char *) NULL || *arg == '*') /* no line number */
9666 badInput = 1;
9667 else
9668 {
9669 const char *argptr = arg;
9670 int hasColon = 0;
9671
9672 /* Look for a ':'. If there is a '::' then get out, otherwise
9673 it is probably a line number. */
9674 while (*argptr && !hasColon)
9675 {
9676 hasColon = (*argptr == ':');
9677 argptr++;
9678 }
9679
9680 if (hasColon)
9681 badInput = (*argptr == ':'); /* we have class::method */
9682 else
9683 badInput = !isdigit (*arg); /* not a line number */
9684 }
9685
9686 if (badInput)
9687 printf_filtered (_("Usage: stop at <line>\n"));
9688 else
9689 break_command_1 (arg, 0, from_tty);
9690 }
9691
9692 /* The dynamic printf command is mostly like a regular breakpoint, but
9693 with a prewired command list consisting of a single output command,
9694 built from extra arguments supplied on the dprintf command
9695 line. */
9696
9697 static void
9698 dprintf_command (const char *arg, int from_tty)
9699 {
9700 event_location_up location = string_to_event_location (&arg, current_language);
9701
9702 /* If non-NULL, ARG should have been advanced past the location;
9703 the next character must be ','. */
9704 if (arg != NULL)
9705 {
9706 if (arg[0] != ',' || arg[1] == '\0')
9707 error (_("Format string required"));
9708 else
9709 {
9710 /* Skip the comma. */
9711 ++arg;
9712 }
9713 }
9714
9715 create_breakpoint (get_current_arch (),
9716 location.get (),
9717 NULL, 0, arg, 1 /* parse arg */,
9718 0, bp_dprintf,
9719 0 /* Ignore count */,
9720 pending_break_support,
9721 &dprintf_breakpoint_ops,
9722 from_tty,
9723 1 /* enabled */,
9724 0 /* internal */,
9725 0);
9726 }
9727
9728 static void
9729 agent_printf_command (const char *arg, int from_tty)
9730 {
9731 error (_("May only run agent-printf on the target"));
9732 }
9733
9734 /* Implement the "breakpoint_hit" breakpoint_ops method for
9735 ranged breakpoints. */
9736
9737 static int
9738 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
9739 const address_space *aspace,
9740 CORE_ADDR bp_addr,
9741 const struct target_waitstatus *ws)
9742 {
9743 if (ws->kind != TARGET_WAITKIND_STOPPED
9744 || ws->value.sig != GDB_SIGNAL_TRAP)
9745 return 0;
9746
9747 return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
9748 bl->length, aspace, bp_addr);
9749 }
9750
9751 /* Implement the "resources_needed" breakpoint_ops method for
9752 ranged breakpoints. */
9753
9754 static int
9755 resources_needed_ranged_breakpoint (const struct bp_location *bl)
9756 {
9757 return target_ranged_break_num_registers ();
9758 }
9759
9760 /* Implement the "print_it" breakpoint_ops method for
9761 ranged breakpoints. */
9762
9763 static enum print_stop_action
9764 print_it_ranged_breakpoint (bpstat bs)
9765 {
9766 struct breakpoint *b = bs->breakpoint_at;
9767 struct bp_location *bl = b->loc;
9768 struct ui_out *uiout = current_uiout;
9769
9770 gdb_assert (b->type == bp_hardware_breakpoint);
9771
9772 /* Ranged breakpoints have only one location. */
9773 gdb_assert (bl && bl->next == NULL);
9774
9775 annotate_breakpoint (b->number);
9776
9777 maybe_print_thread_hit_breakpoint (uiout);
9778
9779 if (b->disposition == disp_del)
9780 uiout->text ("Temporary ranged breakpoint ");
9781 else
9782 uiout->text ("Ranged breakpoint ");
9783 if (uiout->is_mi_like_p ())
9784 {
9785 uiout->field_string ("reason",
9786 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9787 uiout->field_string ("disp", bpdisp_text (b->disposition));
9788 }
9789 uiout->field_int ("bkptno", b->number);
9790 uiout->text (", ");
9791
9792 return PRINT_SRC_AND_LOC;
9793 }
9794
9795 /* Implement the "print_one" breakpoint_ops method for
9796 ranged breakpoints. */
9797
9798 static void
9799 print_one_ranged_breakpoint (struct breakpoint *b,
9800 struct bp_location **last_loc)
9801 {
9802 struct bp_location *bl = b->loc;
9803 struct value_print_options opts;
9804 struct ui_out *uiout = current_uiout;
9805
9806 /* Ranged breakpoints have only one location. */
9807 gdb_assert (bl && bl->next == NULL);
9808
9809 get_user_print_options (&opts);
9810
9811 if (opts.addressprint)
9812 /* We don't print the address range here, it will be printed later
9813 by print_one_detail_ranged_breakpoint. */
9814 uiout->field_skip ("addr");
9815 annotate_field (5);
9816 print_breakpoint_location (b, bl);
9817 *last_loc = bl;
9818 }
9819
9820 /* Implement the "print_one_detail" breakpoint_ops method for
9821 ranged breakpoints. */
9822
9823 static void
9824 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
9825 struct ui_out *uiout)
9826 {
9827 CORE_ADDR address_start, address_end;
9828 struct bp_location *bl = b->loc;
9829 string_file stb;
9830
9831 gdb_assert (bl);
9832
9833 address_start = bl->address;
9834 address_end = address_start + bl->length - 1;
9835
9836 uiout->text ("\taddress range: ");
9837 stb.printf ("[%s, %s]",
9838 print_core_address (bl->gdbarch, address_start),
9839 print_core_address (bl->gdbarch, address_end));
9840 uiout->field_stream ("addr", stb);
9841 uiout->text ("\n");
9842 }
9843
9844 /* Implement the "print_mention" breakpoint_ops method for
9845 ranged breakpoints. */
9846
9847 static void
9848 print_mention_ranged_breakpoint (struct breakpoint *b)
9849 {
9850 struct bp_location *bl = b->loc;
9851 struct ui_out *uiout = current_uiout;
9852
9853 gdb_assert (bl);
9854 gdb_assert (b->type == bp_hardware_breakpoint);
9855
9856 if (uiout->is_mi_like_p ())
9857 return;
9858
9859 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9860 b->number, paddress (bl->gdbarch, bl->address),
9861 paddress (bl->gdbarch, bl->address + bl->length - 1));
9862 }
9863
9864 /* Implement the "print_recreate" breakpoint_ops method for
9865 ranged breakpoints. */
9866
9867 static void
9868 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
9869 {
9870 fprintf_unfiltered (fp, "break-range %s, %s",
9871 event_location_to_string (b->location.get ()),
9872 event_location_to_string (b->location_range_end.get ()));
9873 print_recreate_thread (b, fp);
9874 }
9875
9876 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9877
9878 static struct breakpoint_ops ranged_breakpoint_ops;
9879
9880 /* Find the address where the end of the breakpoint range should be
9881 placed, given the SAL of the end of the range. This is so that if
9882 the user provides a line number, the end of the range is set to the
9883 last instruction of the given line. */
9884
9885 static CORE_ADDR
9886 find_breakpoint_range_end (struct symtab_and_line sal)
9887 {
9888 CORE_ADDR end;
9889
9890 /* If the user provided a PC value, use it. Otherwise,
9891 find the address of the end of the given location. */
9892 if (sal.explicit_pc)
9893 end = sal.pc;
9894 else
9895 {
9896 int ret;
9897 CORE_ADDR start;
9898
9899 ret = find_line_pc_range (sal, &start, &end);
9900 if (!ret)
9901 error (_("Could not find location of the end of the range."));
9902
9903 /* find_line_pc_range returns the start of the next line. */
9904 end--;
9905 }
9906
9907 return end;
9908 }
9909
9910 /* Implement the "break-range" CLI command. */
9911
9912 static void
9913 break_range_command (const char *arg, int from_tty)
9914 {
9915 const char *arg_start;
9916 struct linespec_result canonical_start, canonical_end;
9917 int bp_count, can_use_bp, length;
9918 CORE_ADDR end;
9919 struct breakpoint *b;
9920
9921 /* We don't support software ranged breakpoints. */
9922 if (target_ranged_break_num_registers () < 0)
9923 error (_("This target does not support hardware ranged breakpoints."));
9924
9925 bp_count = hw_breakpoint_used_count ();
9926 bp_count += target_ranged_break_num_registers ();
9927 can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
9928 bp_count, 0);
9929 if (can_use_bp < 0)
9930 error (_("Hardware breakpoints used exceeds limit."));
9931
9932 arg = skip_spaces (arg);
9933 if (arg == NULL || arg[0] == '\0')
9934 error(_("No address range specified."));
9935
9936 arg_start = arg;
9937 event_location_up start_location = string_to_event_location (&arg,
9938 current_language);
9939 parse_breakpoint_sals (start_location.get (), &canonical_start);
9940
9941 if (arg[0] != ',')
9942 error (_("Too few arguments."));
9943 else if (canonical_start.lsals.empty ())
9944 error (_("Could not find location of the beginning of the range."));
9945
9946 const linespec_sals &lsal_start = canonical_start.lsals[0];
9947
9948 if (canonical_start.lsals.size () > 1
9949 || lsal_start.sals.size () != 1)
9950 error (_("Cannot create a ranged breakpoint with multiple locations."));
9951
9952 const symtab_and_line &sal_start = lsal_start.sals[0];
9953 std::string addr_string_start (arg_start, arg - arg_start);
9954
9955 arg++; /* Skip the comma. */
9956 arg = skip_spaces (arg);
9957
9958 /* Parse the end location. */
9959
9960 arg_start = arg;
9961
9962 /* We call decode_line_full directly here instead of using
9963 parse_breakpoint_sals because we need to specify the start location's
9964 symtab and line as the default symtab and line for the end of the
9965 range. This makes it possible to have ranges like "foo.c:27, +14",
9966 where +14 means 14 lines from the start location. */
9967 event_location_up end_location = string_to_event_location (&arg,
9968 current_language);
9969 decode_line_full (end_location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
9970 sal_start.symtab, sal_start.line,
9971 &canonical_end, NULL, NULL);
9972
9973 if (canonical_end.lsals.empty ())
9974 error (_("Could not find location of the end of the range."));
9975
9976 const linespec_sals &lsal_end = canonical_end.lsals[0];
9977 if (canonical_end.lsals.size () > 1
9978 || lsal_end.sals.size () != 1)
9979 error (_("Cannot create a ranged breakpoint with multiple locations."));
9980
9981 const symtab_and_line &sal_end = lsal_end.sals[0];
9982
9983 end = find_breakpoint_range_end (sal_end);
9984 if (sal_start.pc > end)
9985 error (_("Invalid address range, end precedes start."));
9986
9987 length = end - sal_start.pc + 1;
9988 if (length < 0)
9989 /* Length overflowed. */
9990 error (_("Address range too large."));
9991 else if (length == 1)
9992 {
9993 /* This range is simple enough to be handled by
9994 the `hbreak' command. */
9995 hbreak_command (&addr_string_start[0], 1);
9996
9997 return;
9998 }
9999
10000 /* Now set up the breakpoint. */
10001 b = set_raw_breakpoint (get_current_arch (), sal_start,
10002 bp_hardware_breakpoint, &ranged_breakpoint_ops);
10003 set_breakpoint_count (breakpoint_count + 1);
10004 b->number = breakpoint_count;
10005 b->disposition = disp_donttouch;
10006 b->location = std::move (start_location);
10007 b->location_range_end = std::move (end_location);
10008 b->loc->length = length;
10009
10010 mention (b);
10011 observer_notify_breakpoint_created (b);
10012 update_global_location_list (UGLL_MAY_INSERT);
10013 }
10014
10015 /* Return non-zero if EXP is verified as constant. Returned zero
10016 means EXP is variable. Also the constant detection may fail for
10017 some constant expressions and in such case still falsely return
10018 zero. */
10019
10020 static int
10021 watchpoint_exp_is_const (const struct expression *exp)
10022 {
10023 int i = exp->nelts;
10024
10025 while (i > 0)
10026 {
10027 int oplenp, argsp;
10028
10029 /* We are only interested in the descriptor of each element. */
10030 operator_length (exp, i, &oplenp, &argsp);
10031 i -= oplenp;
10032
10033 switch (exp->elts[i].opcode)
10034 {
10035 case BINOP_ADD:
10036 case BINOP_SUB:
10037 case BINOP_MUL:
10038 case BINOP_DIV:
10039 case BINOP_REM:
10040 case BINOP_MOD:
10041 case BINOP_LSH:
10042 case BINOP_RSH:
10043 case BINOP_LOGICAL_AND:
10044 case BINOP_LOGICAL_OR:
10045 case BINOP_BITWISE_AND:
10046 case BINOP_BITWISE_IOR:
10047 case BINOP_BITWISE_XOR:
10048 case BINOP_EQUAL:
10049 case BINOP_NOTEQUAL:
10050 case BINOP_LESS:
10051 case BINOP_GTR:
10052 case BINOP_LEQ:
10053 case BINOP_GEQ:
10054 case BINOP_REPEAT:
10055 case BINOP_COMMA:
10056 case BINOP_EXP:
10057 case BINOP_MIN:
10058 case BINOP_MAX:
10059 case BINOP_INTDIV:
10060 case BINOP_CONCAT:
10061 case TERNOP_COND:
10062 case TERNOP_SLICE:
10063
10064 case OP_LONG:
10065 case OP_FLOAT:
10066 case OP_LAST:
10067 case OP_COMPLEX:
10068 case OP_STRING:
10069 case OP_ARRAY:
10070 case OP_TYPE:
10071 case OP_TYPEOF:
10072 case OP_DECLTYPE:
10073 case OP_TYPEID:
10074 case OP_NAME:
10075 case OP_OBJC_NSSTRING:
10076
10077 case UNOP_NEG:
10078 case UNOP_LOGICAL_NOT:
10079 case UNOP_COMPLEMENT:
10080 case UNOP_ADDR:
10081 case UNOP_HIGH:
10082 case UNOP_CAST:
10083
10084 case UNOP_CAST_TYPE:
10085 case UNOP_REINTERPRET_CAST:
10086 case UNOP_DYNAMIC_CAST:
10087 /* Unary, binary and ternary operators: We have to check
10088 their operands. If they are constant, then so is the
10089 result of that operation. For instance, if A and B are
10090 determined to be constants, then so is "A + B".
10091
10092 UNOP_IND is one exception to the rule above, because the
10093 value of *ADDR is not necessarily a constant, even when
10094 ADDR is. */
10095 break;
10096
10097 case OP_VAR_VALUE:
10098 /* Check whether the associated symbol is a constant.
10099
10100 We use SYMBOL_CLASS rather than TYPE_CONST because it's
10101 possible that a buggy compiler could mark a variable as
10102 constant even when it is not, and TYPE_CONST would return
10103 true in this case, while SYMBOL_CLASS wouldn't.
10104
10105 We also have to check for function symbols because they
10106 are always constant. */
10107 {
10108 struct symbol *s = exp->elts[i + 2].symbol;
10109
10110 if (SYMBOL_CLASS (s) != LOC_BLOCK
10111 && SYMBOL_CLASS (s) != LOC_CONST
10112 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
10113 return 0;
10114 break;
10115 }
10116
10117 /* The default action is to return 0 because we are using
10118 the optimistic approach here: If we don't know something,
10119 then it is not a constant. */
10120 default:
10121 return 0;
10122 }
10123 }
10124
10125 return 1;
10126 }
10127
10128 /* Watchpoint destructor. */
10129
10130 watchpoint::~watchpoint ()
10131 {
10132 xfree (this->exp_string);
10133 xfree (this->exp_string_reparse);
10134 value_free (this->val);
10135 }
10136
10137 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10138
10139 static void
10140 re_set_watchpoint (struct breakpoint *b)
10141 {
10142 struct watchpoint *w = (struct watchpoint *) b;
10143
10144 /* Watchpoint can be either on expression using entirely global
10145 variables, or it can be on local variables.
10146
10147 Watchpoints of the first kind are never auto-deleted, and even
10148 persist across program restarts. Since they can use variables
10149 from shared libraries, we need to reparse expression as libraries
10150 are loaded and unloaded.
10151
10152 Watchpoints on local variables can also change meaning as result
10153 of solib event. For example, if a watchpoint uses both a local
10154 and a global variables in expression, it's a local watchpoint,
10155 but unloading of a shared library will make the expression
10156 invalid. This is not a very common use case, but we still
10157 re-evaluate expression, to avoid surprises to the user.
10158
10159 Note that for local watchpoints, we re-evaluate it only if
10160 watchpoints frame id is still valid. If it's not, it means the
10161 watchpoint is out of scope and will be deleted soon. In fact,
10162 I'm not sure we'll ever be called in this case.
10163
10164 If a local watchpoint's frame id is still valid, then
10165 w->exp_valid_block is likewise valid, and we can safely use it.
10166
10167 Don't do anything about disabled watchpoints, since they will be
10168 reevaluated again when enabled. */
10169 update_watchpoint (w, 1 /* reparse */);
10170 }
10171
10172 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10173
10174 static int
10175 insert_watchpoint (struct bp_location *bl)
10176 {
10177 struct watchpoint *w = (struct watchpoint *) bl->owner;
10178 int length = w->exact ? 1 : bl->length;
10179
10180 return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
10181 w->cond_exp.get ());
10182 }
10183
10184 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10185
10186 static int
10187 remove_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10188 {
10189 struct watchpoint *w = (struct watchpoint *) bl->owner;
10190 int length = w->exact ? 1 : bl->length;
10191
10192 return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
10193 w->cond_exp.get ());
10194 }
10195
10196 static int
10197 breakpoint_hit_watchpoint (const struct bp_location *bl,
10198 const address_space *aspace, CORE_ADDR bp_addr,
10199 const struct target_waitstatus *ws)
10200 {
10201 struct breakpoint *b = bl->owner;
10202 struct watchpoint *w = (struct watchpoint *) b;
10203
10204 /* Continuable hardware watchpoints are treated as non-existent if the
10205 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10206 some data address). Otherwise gdb won't stop on a break instruction
10207 in the code (not from a breakpoint) when a hardware watchpoint has
10208 been defined. Also skip watchpoints which we know did not trigger
10209 (did not match the data address). */
10210 if (is_hardware_watchpoint (b)
10211 && w->watchpoint_triggered == watch_triggered_no)
10212 return 0;
10213
10214 return 1;
10215 }
10216
10217 static void
10218 check_status_watchpoint (bpstat bs)
10219 {
10220 gdb_assert (is_watchpoint (bs->breakpoint_at));
10221
10222 bpstat_check_watchpoint (bs);
10223 }
10224
10225 /* Implement the "resources_needed" breakpoint_ops method for
10226 hardware watchpoints. */
10227
10228 static int
10229 resources_needed_watchpoint (const struct bp_location *bl)
10230 {
10231 struct watchpoint *w = (struct watchpoint *) bl->owner;
10232 int length = w->exact? 1 : bl->length;
10233
10234 return target_region_ok_for_hw_watchpoint (bl->address, length);
10235 }
10236
10237 /* Implement the "works_in_software_mode" breakpoint_ops method for
10238 hardware watchpoints. */
10239
10240 static int
10241 works_in_software_mode_watchpoint (const struct breakpoint *b)
10242 {
10243 /* Read and access watchpoints only work with hardware support. */
10244 return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
10245 }
10246
10247 static enum print_stop_action
10248 print_it_watchpoint (bpstat bs)
10249 {
10250 struct breakpoint *b;
10251 enum print_stop_action result;
10252 struct watchpoint *w;
10253 struct ui_out *uiout = current_uiout;
10254
10255 gdb_assert (bs->bp_location_at != NULL);
10256
10257 b = bs->breakpoint_at;
10258 w = (struct watchpoint *) b;
10259
10260 annotate_watchpoint (b->number);
10261 maybe_print_thread_hit_breakpoint (uiout);
10262
10263 string_file stb;
10264
10265 gdb::optional<ui_out_emit_tuple> tuple_emitter;
10266 switch (b->type)
10267 {
10268 case bp_watchpoint:
10269 case bp_hardware_watchpoint:
10270 if (uiout->is_mi_like_p ())
10271 uiout->field_string
10272 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10273 mention (b);
10274 tuple_emitter.emplace (uiout, "value");
10275 uiout->text ("\nOld value = ");
10276 watchpoint_value_print (bs->old_val, &stb);
10277 uiout->field_stream ("old", stb);
10278 uiout->text ("\nNew value = ");
10279 watchpoint_value_print (w->val, &stb);
10280 uiout->field_stream ("new", stb);
10281 uiout->text ("\n");
10282 /* More than one watchpoint may have been triggered. */
10283 result = PRINT_UNKNOWN;
10284 break;
10285
10286 case bp_read_watchpoint:
10287 if (uiout->is_mi_like_p ())
10288 uiout->field_string
10289 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10290 mention (b);
10291 tuple_emitter.emplace (uiout, "value");
10292 uiout->text ("\nValue = ");
10293 watchpoint_value_print (w->val, &stb);
10294 uiout->field_stream ("value", stb);
10295 uiout->text ("\n");
10296 result = PRINT_UNKNOWN;
10297 break;
10298
10299 case bp_access_watchpoint:
10300 if (bs->old_val != NULL)
10301 {
10302 if (uiout->is_mi_like_p ())
10303 uiout->field_string
10304 ("reason",
10305 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10306 mention (b);
10307 tuple_emitter.emplace (uiout, "value");
10308 uiout->text ("\nOld value = ");
10309 watchpoint_value_print (bs->old_val, &stb);
10310 uiout->field_stream ("old", stb);
10311 uiout->text ("\nNew value = ");
10312 }
10313 else
10314 {
10315 mention (b);
10316 if (uiout->is_mi_like_p ())
10317 uiout->field_string
10318 ("reason",
10319 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10320 tuple_emitter.emplace (uiout, "value");
10321 uiout->text ("\nValue = ");
10322 }
10323 watchpoint_value_print (w->val, &stb);
10324 uiout->field_stream ("new", stb);
10325 uiout->text ("\n");
10326 result = PRINT_UNKNOWN;
10327 break;
10328 default:
10329 result = PRINT_UNKNOWN;
10330 }
10331
10332 return result;
10333 }
10334
10335 /* Implement the "print_mention" breakpoint_ops method for hardware
10336 watchpoints. */
10337
10338 static void
10339 print_mention_watchpoint (struct breakpoint *b)
10340 {
10341 struct watchpoint *w = (struct watchpoint *) b;
10342 struct ui_out *uiout = current_uiout;
10343 const char *tuple_name;
10344
10345 switch (b->type)
10346 {
10347 case bp_watchpoint:
10348 uiout->text ("Watchpoint ");
10349 tuple_name = "wpt";
10350 break;
10351 case bp_hardware_watchpoint:
10352 uiout->text ("Hardware watchpoint ");
10353 tuple_name = "wpt";
10354 break;
10355 case bp_read_watchpoint:
10356 uiout->text ("Hardware read watchpoint ");
10357 tuple_name = "hw-rwpt";
10358 break;
10359 case bp_access_watchpoint:
10360 uiout->text ("Hardware access (read/write) watchpoint ");
10361 tuple_name = "hw-awpt";
10362 break;
10363 default:
10364 internal_error (__FILE__, __LINE__,
10365 _("Invalid hardware watchpoint type."));
10366 }
10367
10368 ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10369 uiout->field_int ("number", b->number);
10370 uiout->text (": ");
10371 uiout->field_string ("exp", w->exp_string);
10372 }
10373
10374 /* Implement the "print_recreate" breakpoint_ops method for
10375 watchpoints. */
10376
10377 static void
10378 print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10379 {
10380 struct watchpoint *w = (struct watchpoint *) b;
10381
10382 switch (b->type)
10383 {
10384 case bp_watchpoint:
10385 case bp_hardware_watchpoint:
10386 fprintf_unfiltered (fp, "watch");
10387 break;
10388 case bp_read_watchpoint:
10389 fprintf_unfiltered (fp, "rwatch");
10390 break;
10391 case bp_access_watchpoint:
10392 fprintf_unfiltered (fp, "awatch");
10393 break;
10394 default:
10395 internal_error (__FILE__, __LINE__,
10396 _("Invalid watchpoint type."));
10397 }
10398
10399 fprintf_unfiltered (fp, " %s", w->exp_string);
10400 print_recreate_thread (b, fp);
10401 }
10402
10403 /* Implement the "explains_signal" breakpoint_ops method for
10404 watchpoints. */
10405
10406 static int
10407 explains_signal_watchpoint (struct breakpoint *b, enum gdb_signal sig)
10408 {
10409 /* A software watchpoint cannot cause a signal other than
10410 GDB_SIGNAL_TRAP. */
10411 if (b->type == bp_watchpoint && sig != GDB_SIGNAL_TRAP)
10412 return 0;
10413
10414 return 1;
10415 }
10416
10417 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10418
10419 static struct breakpoint_ops watchpoint_breakpoint_ops;
10420
10421 /* Implement the "insert" breakpoint_ops method for
10422 masked hardware watchpoints. */
10423
10424 static int
10425 insert_masked_watchpoint (struct bp_location *bl)
10426 {
10427 struct watchpoint *w = (struct watchpoint *) bl->owner;
10428
10429 return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
10430 bl->watchpoint_type);
10431 }
10432
10433 /* Implement the "remove" breakpoint_ops method for
10434 masked hardware watchpoints. */
10435
10436 static int
10437 remove_masked_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10438 {
10439 struct watchpoint *w = (struct watchpoint *) bl->owner;
10440
10441 return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
10442 bl->watchpoint_type);
10443 }
10444
10445 /* Implement the "resources_needed" breakpoint_ops method for
10446 masked hardware watchpoints. */
10447
10448 static int
10449 resources_needed_masked_watchpoint (const struct bp_location *bl)
10450 {
10451 struct watchpoint *w = (struct watchpoint *) bl->owner;
10452
10453 return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
10454 }
10455
10456 /* Implement the "works_in_software_mode" breakpoint_ops method for
10457 masked hardware watchpoints. */
10458
10459 static int
10460 works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10461 {
10462 return 0;
10463 }
10464
10465 /* Implement the "print_it" breakpoint_ops method for
10466 masked hardware watchpoints. */
10467
10468 static enum print_stop_action
10469 print_it_masked_watchpoint (bpstat bs)
10470 {
10471 struct breakpoint *b = bs->breakpoint_at;
10472 struct ui_out *uiout = current_uiout;
10473
10474 /* Masked watchpoints have only one location. */
10475 gdb_assert (b->loc && b->loc->next == NULL);
10476
10477 annotate_watchpoint (b->number);
10478 maybe_print_thread_hit_breakpoint (uiout);
10479
10480 switch (b->type)
10481 {
10482 case bp_hardware_watchpoint:
10483 if (uiout->is_mi_like_p ())
10484 uiout->field_string
10485 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10486 break;
10487
10488 case bp_read_watchpoint:
10489 if (uiout->is_mi_like_p ())
10490 uiout->field_string
10491 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10492 break;
10493
10494 case bp_access_watchpoint:
10495 if (uiout->is_mi_like_p ())
10496 uiout->field_string
10497 ("reason",
10498 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10499 break;
10500 default:
10501 internal_error (__FILE__, __LINE__,
10502 _("Invalid hardware watchpoint type."));
10503 }
10504
10505 mention (b);
10506 uiout->text (_("\n\
10507 Check the underlying instruction at PC for the memory\n\
10508 address and value which triggered this watchpoint.\n"));
10509 uiout->text ("\n");
10510
10511 /* More than one watchpoint may have been triggered. */
10512 return PRINT_UNKNOWN;
10513 }
10514
10515 /* Implement the "print_one_detail" breakpoint_ops method for
10516 masked hardware watchpoints. */
10517
10518 static void
10519 print_one_detail_masked_watchpoint (const struct breakpoint *b,
10520 struct ui_out *uiout)
10521 {
10522 struct watchpoint *w = (struct watchpoint *) b;
10523
10524 /* Masked watchpoints have only one location. */
10525 gdb_assert (b->loc && b->loc->next == NULL);
10526
10527 uiout->text ("\tmask ");
10528 uiout->field_core_addr ("mask", b->loc->gdbarch, w->hw_wp_mask);
10529 uiout->text ("\n");
10530 }
10531
10532 /* Implement the "print_mention" breakpoint_ops method for
10533 masked hardware watchpoints. */
10534
10535 static void
10536 print_mention_masked_watchpoint (struct breakpoint *b)
10537 {
10538 struct watchpoint *w = (struct watchpoint *) b;
10539 struct ui_out *uiout = current_uiout;
10540 const char *tuple_name;
10541
10542 switch (b->type)
10543 {
10544 case bp_hardware_watchpoint:
10545 uiout->text ("Masked hardware watchpoint ");
10546 tuple_name = "wpt";
10547 break;
10548 case bp_read_watchpoint:
10549 uiout->text ("Masked hardware read watchpoint ");
10550 tuple_name = "hw-rwpt";
10551 break;
10552 case bp_access_watchpoint:
10553 uiout->text ("Masked hardware access (read/write) watchpoint ");
10554 tuple_name = "hw-awpt";
10555 break;
10556 default:
10557 internal_error (__FILE__, __LINE__,
10558 _("Invalid hardware watchpoint type."));
10559 }
10560
10561 ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10562 uiout->field_int ("number", b->number);
10563 uiout->text (": ");
10564 uiout->field_string ("exp", w->exp_string);
10565 }
10566
10567 /* Implement the "print_recreate" breakpoint_ops method for
10568 masked hardware watchpoints. */
10569
10570 static void
10571 print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
10572 {
10573 struct watchpoint *w = (struct watchpoint *) b;
10574 char tmp[40];
10575
10576 switch (b->type)
10577 {
10578 case bp_hardware_watchpoint:
10579 fprintf_unfiltered (fp, "watch");
10580 break;
10581 case bp_read_watchpoint:
10582 fprintf_unfiltered (fp, "rwatch");
10583 break;
10584 case bp_access_watchpoint:
10585 fprintf_unfiltered (fp, "awatch");
10586 break;
10587 default:
10588 internal_error (__FILE__, __LINE__,
10589 _("Invalid hardware watchpoint type."));
10590 }
10591
10592 sprintf_vma (tmp, w->hw_wp_mask);
10593 fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
10594 print_recreate_thread (b, fp);
10595 }
10596
10597 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10598
10599 static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
10600
10601 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10602
10603 static int
10604 is_masked_watchpoint (const struct breakpoint *b)
10605 {
10606 return b->ops == &masked_watchpoint_breakpoint_ops;
10607 }
10608
10609 /* accessflag: hw_write: watch write,
10610 hw_read: watch read,
10611 hw_access: watch access (read or write) */
10612 static void
10613 watch_command_1 (const char *arg, int accessflag, int from_tty,
10614 int just_location, int internal)
10615 {
10616 struct breakpoint *scope_breakpoint = NULL;
10617 const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
10618 struct value *val, *mark, *result;
10619 int saved_bitpos = 0, saved_bitsize = 0;
10620 const char *exp_start = NULL;
10621 const char *exp_end = NULL;
10622 const char *tok, *end_tok;
10623 int toklen = -1;
10624 const char *cond_start = NULL;
10625 const char *cond_end = NULL;
10626 enum bptype bp_type;
10627 int thread = -1;
10628 int pc = 0;
10629 /* Flag to indicate whether we are going to use masks for
10630 the hardware watchpoint. */
10631 int use_mask = 0;
10632 CORE_ADDR mask = 0;
10633
10634 /* Make sure that we actually have parameters to parse. */
10635 if (arg != NULL && arg[0] != '\0')
10636 {
10637 const char *value_start;
10638
10639 exp_end = arg + strlen (arg);
10640
10641 /* Look for "parameter value" pairs at the end
10642 of the arguments string. */
10643 for (tok = exp_end - 1; tok > arg; tok--)
10644 {
10645 /* Skip whitespace at the end of the argument list. */
10646 while (tok > arg && (*tok == ' ' || *tok == '\t'))
10647 tok--;
10648
10649 /* Find the beginning of the last token.
10650 This is the value of the parameter. */
10651 while (tok > arg && (*tok != ' ' && *tok != '\t'))
10652 tok--;
10653 value_start = tok + 1;
10654
10655 /* Skip whitespace. */
10656 while (tok > arg && (*tok == ' ' || *tok == '\t'))
10657 tok--;
10658
10659 end_tok = tok;
10660
10661 /* Find the beginning of the second to last token.
10662 This is the parameter itself. */
10663 while (tok > arg && (*tok != ' ' && *tok != '\t'))
10664 tok--;
10665 tok++;
10666 toklen = end_tok - tok + 1;
10667
10668 if (toklen == 6 && startswith (tok, "thread"))
10669 {
10670 struct thread_info *thr;
10671 /* At this point we've found a "thread" token, which means
10672 the user is trying to set a watchpoint that triggers
10673 only in a specific thread. */
10674 const char *endp;
10675
10676 if (thread != -1)
10677 error(_("You can specify only one thread."));
10678
10679 /* Extract the thread ID from the next token. */
10680 thr = parse_thread_id (value_start, &endp);
10681
10682 /* Check if the user provided a valid thread ID. */
10683 if (*endp != ' ' && *endp != '\t' && *endp != '\0')
10684 invalid_thread_id_error (value_start);
10685
10686 thread = thr->global_num;
10687 }
10688 else if (toklen == 4 && startswith (tok, "mask"))
10689 {
10690 /* We've found a "mask" token, which means the user wants to
10691 create a hardware watchpoint that is going to have the mask
10692 facility. */
10693 struct value *mask_value, *mark;
10694
10695 if (use_mask)
10696 error(_("You can specify only one mask."));
10697
10698 use_mask = just_location = 1;
10699
10700 mark = value_mark ();
10701 mask_value = parse_to_comma_and_eval (&value_start);
10702 mask = value_as_address (mask_value);
10703 value_free_to_mark (mark);
10704 }
10705 else
10706 /* We didn't recognize what we found. We should stop here. */
10707 break;
10708
10709 /* Truncate the string and get rid of the "parameter value" pair before
10710 the arguments string is parsed by the parse_exp_1 function. */
10711 exp_end = tok;
10712 }
10713 }
10714 else
10715 exp_end = arg;
10716
10717 /* Parse the rest of the arguments. From here on out, everything
10718 is in terms of a newly allocated string instead of the original
10719 ARG. */
10720 innermost_block = NULL;
10721 std::string expression (arg, exp_end - arg);
10722 exp_start = arg = expression.c_str ();
10723 expression_up exp = parse_exp_1 (&arg, 0, 0, 0);
10724 exp_end = arg;
10725 /* Remove trailing whitespace from the expression before saving it.
10726 This makes the eventual display of the expression string a bit
10727 prettier. */
10728 while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
10729 --exp_end;
10730
10731 /* Checking if the expression is not constant. */
10732 if (watchpoint_exp_is_const (exp.get ()))
10733 {
10734 int len;
10735
10736 len = exp_end - exp_start;
10737 while (len > 0 && isspace (exp_start[len - 1]))
10738 len--;
10739 error (_("Cannot watch constant value `%.*s'."), len, exp_start);
10740 }
10741
10742 exp_valid_block = innermost_block;
10743 mark = value_mark ();
10744 fetch_subexp_value (exp.get (), &pc, &val, &result, NULL, just_location);
10745
10746 if (val != NULL && just_location)
10747 {
10748 saved_bitpos = value_bitpos (val);
10749 saved_bitsize = value_bitsize (val);
10750 }
10751
10752 if (just_location)
10753 {
10754 int ret;
10755
10756 exp_valid_block = NULL;
10757 val = value_addr (result);
10758 release_value (val);
10759 value_free_to_mark (mark);
10760
10761 if (use_mask)
10762 {
10763 ret = target_masked_watch_num_registers (value_as_address (val),
10764 mask);
10765 if (ret == -1)
10766 error (_("This target does not support masked watchpoints."));
10767 else if (ret == -2)
10768 error (_("Invalid mask or memory region."));
10769 }
10770 }
10771 else if (val != NULL)
10772 release_value (val);
10773
10774 tok = skip_spaces (arg);
10775 end_tok = skip_to_space (tok);
10776
10777 toklen = end_tok - tok;
10778 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
10779 {
10780 innermost_block = NULL;
10781 tok = cond_start = end_tok + 1;
10782 parse_exp_1 (&tok, 0, 0, 0);
10783
10784 /* The watchpoint expression may not be local, but the condition
10785 may still be. E.g.: `watch global if local > 0'. */
10786 cond_exp_valid_block = innermost_block;
10787
10788 cond_end = tok;
10789 }
10790 if (*tok)
10791 error (_("Junk at end of command."));
10792
10793 frame_info *wp_frame = block_innermost_frame (exp_valid_block);
10794
10795 /* Save this because create_internal_breakpoint below invalidates
10796 'wp_frame'. */
10797 frame_id watchpoint_frame = get_frame_id (wp_frame);
10798
10799 /* If the expression is "local", then set up a "watchpoint scope"
10800 breakpoint at the point where we've left the scope of the watchpoint
10801 expression. Create the scope breakpoint before the watchpoint, so
10802 that we will encounter it first in bpstat_stop_status. */
10803 if (exp_valid_block != NULL && wp_frame != NULL)
10804 {
10805 frame_id caller_frame_id = frame_unwind_caller_id (wp_frame);
10806
10807 if (frame_id_p (caller_frame_id))
10808 {
10809 gdbarch *caller_arch = frame_unwind_caller_arch (wp_frame);
10810 CORE_ADDR caller_pc = frame_unwind_caller_pc (wp_frame);
10811
10812 scope_breakpoint
10813 = create_internal_breakpoint (caller_arch, caller_pc,
10814 bp_watchpoint_scope,
10815 &momentary_breakpoint_ops);
10816
10817 /* create_internal_breakpoint could invalidate WP_FRAME. */
10818 wp_frame = NULL;
10819
10820 scope_breakpoint->enable_state = bp_enabled;
10821
10822 /* Automatically delete the breakpoint when it hits. */
10823 scope_breakpoint->disposition = disp_del;
10824
10825 /* Only break in the proper frame (help with recursion). */
10826 scope_breakpoint->frame_id = caller_frame_id;
10827
10828 /* Set the address at which we will stop. */
10829 scope_breakpoint->loc->gdbarch = caller_arch;
10830 scope_breakpoint->loc->requested_address = caller_pc;
10831 scope_breakpoint->loc->address
10832 = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
10833 scope_breakpoint->loc->requested_address,
10834 scope_breakpoint->type);
10835 }
10836 }
10837
10838 /* Now set up the breakpoint. We create all watchpoints as hardware
10839 watchpoints here even if hardware watchpoints are turned off, a call
10840 to update_watchpoint later in this function will cause the type to
10841 drop back to bp_watchpoint (software watchpoint) if required. */
10842
10843 if (accessflag == hw_read)
10844 bp_type = bp_read_watchpoint;
10845 else if (accessflag == hw_access)
10846 bp_type = bp_access_watchpoint;
10847 else
10848 bp_type = bp_hardware_watchpoint;
10849
10850 std::unique_ptr<watchpoint> w (new watchpoint ());
10851
10852 if (use_mask)
10853 init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10854 &masked_watchpoint_breakpoint_ops);
10855 else
10856 init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10857 &watchpoint_breakpoint_ops);
10858 w->thread = thread;
10859 w->disposition = disp_donttouch;
10860 w->pspace = current_program_space;
10861 w->exp = std::move (exp);
10862 w->exp_valid_block = exp_valid_block;
10863 w->cond_exp_valid_block = cond_exp_valid_block;
10864 if (just_location)
10865 {
10866 struct type *t = value_type (val);
10867 CORE_ADDR addr = value_as_address (val);
10868
10869 w->exp_string_reparse
10870 = current_language->la_watch_location_expression (t, addr).release ();
10871
10872 w->exp_string = xstrprintf ("-location %.*s",
10873 (int) (exp_end - exp_start), exp_start);
10874 }
10875 else
10876 w->exp_string = savestring (exp_start, exp_end - exp_start);
10877
10878 if (use_mask)
10879 {
10880 w->hw_wp_mask = mask;
10881 }
10882 else
10883 {
10884 w->val = val;
10885 w->val_bitpos = saved_bitpos;
10886 w->val_bitsize = saved_bitsize;
10887 w->val_valid = 1;
10888 }
10889
10890 if (cond_start)
10891 w->cond_string = savestring (cond_start, cond_end - cond_start);
10892 else
10893 w->cond_string = 0;
10894
10895 if (frame_id_p (watchpoint_frame))
10896 {
10897 w->watchpoint_frame = watchpoint_frame;
10898 w->watchpoint_thread = inferior_ptid;
10899 }
10900 else
10901 {
10902 w->watchpoint_frame = null_frame_id;
10903 w->watchpoint_thread = null_ptid;
10904 }
10905
10906 if (scope_breakpoint != NULL)
10907 {
10908 /* The scope breakpoint is related to the watchpoint. We will
10909 need to act on them together. */
10910 w->related_breakpoint = scope_breakpoint;
10911 scope_breakpoint->related_breakpoint = w.get ();
10912 }
10913
10914 if (!just_location)
10915 value_free_to_mark (mark);
10916
10917 /* Finally update the new watchpoint. This creates the locations
10918 that should be inserted. */
10919 update_watchpoint (w.get (), 1);
10920
10921 install_breakpoint (internal, std::move (w), 1);
10922 }
10923
10924 /* Return count of debug registers needed to watch the given expression.
10925 If the watchpoint cannot be handled in hardware return zero. */
10926
10927 static int
10928 can_use_hardware_watchpoint (struct value *v)
10929 {
10930 int found_memory_cnt = 0;
10931 struct value *head = v;
10932
10933 /* Did the user specifically forbid us to use hardware watchpoints? */
10934 if (!can_use_hw_watchpoints)
10935 return 0;
10936
10937 /* Make sure that the value of the expression depends only upon
10938 memory contents, and values computed from them within GDB. If we
10939 find any register references or function calls, we can't use a
10940 hardware watchpoint.
10941
10942 The idea here is that evaluating an expression generates a series
10943 of values, one holding the value of every subexpression. (The
10944 expression a*b+c has five subexpressions: a, b, a*b, c, and
10945 a*b+c.) GDB's values hold almost enough information to establish
10946 the criteria given above --- they identify memory lvalues,
10947 register lvalues, computed values, etcetera. So we can evaluate
10948 the expression, and then scan the chain of values that leaves
10949 behind to decide whether we can detect any possible change to the
10950 expression's final value using only hardware watchpoints.
10951
10952 However, I don't think that the values returned by inferior
10953 function calls are special in any way. So this function may not
10954 notice that an expression involving an inferior function call
10955 can't be watched with hardware watchpoints. FIXME. */
10956 for (; v; v = value_next (v))
10957 {
10958 if (VALUE_LVAL (v) == lval_memory)
10959 {
10960 if (v != head && value_lazy (v))
10961 /* A lazy memory lvalue in the chain is one that GDB never
10962 needed to fetch; we either just used its address (e.g.,
10963 `a' in `a.b') or we never needed it at all (e.g., `a'
10964 in `a,b'). This doesn't apply to HEAD; if that is
10965 lazy then it was not readable, but watch it anyway. */
10966 ;
10967 else
10968 {
10969 /* Ahh, memory we actually used! Check if we can cover
10970 it with hardware watchpoints. */
10971 struct type *vtype = check_typedef (value_type (v));
10972
10973 /* We only watch structs and arrays if user asked for it
10974 explicitly, never if they just happen to appear in a
10975 middle of some value chain. */
10976 if (v == head
10977 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
10978 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
10979 {
10980 CORE_ADDR vaddr = value_address (v);
10981 int len;
10982 int num_regs;
10983
10984 len = (target_exact_watchpoints
10985 && is_scalar_type_recursive (vtype))?
10986 1 : TYPE_LENGTH (value_type (v));
10987
10988 num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
10989 if (!num_regs)
10990 return 0;
10991 else
10992 found_memory_cnt += num_regs;
10993 }
10994 }
10995 }
10996 else if (VALUE_LVAL (v) != not_lval
10997 && deprecated_value_modifiable (v) == 0)
10998 return 0; /* These are values from the history (e.g., $1). */
10999 else if (VALUE_LVAL (v) == lval_register)
11000 return 0; /* Cannot watch a register with a HW watchpoint. */
11001 }
11002
11003 /* The expression itself looks suitable for using a hardware
11004 watchpoint, but give the target machine a chance to reject it. */
11005 return found_memory_cnt;
11006 }
11007
11008 void
11009 watch_command_wrapper (const char *arg, int from_tty, int internal)
11010 {
11011 watch_command_1 (arg, hw_write, from_tty, 0, internal);
11012 }
11013
11014 /* A helper function that looks for the "-location" argument and then
11015 calls watch_command_1. */
11016
11017 static void
11018 watch_maybe_just_location (const char *arg, int accessflag, int from_tty)
11019 {
11020 int just_location = 0;
11021
11022 if (arg
11023 && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
11024 || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
11025 {
11026 arg = skip_spaces (arg);
11027 just_location = 1;
11028 }
11029
11030 watch_command_1 (arg, accessflag, from_tty, just_location, 0);
11031 }
11032
11033 static void
11034 watch_command (const char *arg, int from_tty)
11035 {
11036 watch_maybe_just_location (arg, hw_write, from_tty);
11037 }
11038
11039 void
11040 rwatch_command_wrapper (const char *arg, int from_tty, int internal)
11041 {
11042 watch_command_1 (arg, hw_read, from_tty, 0, internal);
11043 }
11044
11045 static void
11046 rwatch_command (const char *arg, int from_tty)
11047 {
11048 watch_maybe_just_location (arg, hw_read, from_tty);
11049 }
11050
11051 void
11052 awatch_command_wrapper (const char *arg, int from_tty, int internal)
11053 {
11054 watch_command_1 (arg, hw_access, from_tty, 0, internal);
11055 }
11056
11057 static void
11058 awatch_command (const char *arg, int from_tty)
11059 {
11060 watch_maybe_just_location (arg, hw_access, from_tty);
11061 }
11062
11063
11064 /* Data for the FSM that manages the until(location)/advance commands
11065 in infcmd.c. Here because it uses the mechanisms of
11066 breakpoints. */
11067
11068 struct until_break_fsm
11069 {
11070 /* The base class. */
11071 struct thread_fsm thread_fsm;
11072
11073 /* The thread that as current when the command was executed. */
11074 int thread;
11075
11076 /* The breakpoint set at the destination location. */
11077 struct breakpoint *location_breakpoint;
11078
11079 /* Breakpoint set at the return address in the caller frame. May be
11080 NULL. */
11081 struct breakpoint *caller_breakpoint;
11082 };
11083
11084 static void until_break_fsm_clean_up (struct thread_fsm *self,
11085 struct thread_info *thread);
11086 static int until_break_fsm_should_stop (struct thread_fsm *self,
11087 struct thread_info *thread);
11088 static enum async_reply_reason
11089 until_break_fsm_async_reply_reason (struct thread_fsm *self);
11090
11091 /* until_break_fsm's vtable. */
11092
11093 static struct thread_fsm_ops until_break_fsm_ops =
11094 {
11095 NULL, /* dtor */
11096 until_break_fsm_clean_up,
11097 until_break_fsm_should_stop,
11098 NULL, /* return_value */
11099 until_break_fsm_async_reply_reason,
11100 };
11101
11102 /* Allocate a new until_break_command_fsm. */
11103
11104 static struct until_break_fsm *
11105 new_until_break_fsm (struct interp *cmd_interp, int thread,
11106 breakpoint_up &&location_breakpoint,
11107 breakpoint_up &&caller_breakpoint)
11108 {
11109 struct until_break_fsm *sm;
11110
11111 sm = XCNEW (struct until_break_fsm);
11112 thread_fsm_ctor (&sm->thread_fsm, &until_break_fsm_ops, cmd_interp);
11113
11114 sm->thread = thread;
11115 sm->location_breakpoint = location_breakpoint.release ();
11116 sm->caller_breakpoint = caller_breakpoint.release ();
11117
11118 return sm;
11119 }
11120
11121 /* Implementation of the 'should_stop' FSM method for the
11122 until(location)/advance commands. */
11123
11124 static int
11125 until_break_fsm_should_stop (struct thread_fsm *self,
11126 struct thread_info *tp)
11127 {
11128 struct until_break_fsm *sm = (struct until_break_fsm *) self;
11129
11130 if (bpstat_find_breakpoint (tp->control.stop_bpstat,
11131 sm->location_breakpoint) != NULL
11132 || (sm->caller_breakpoint != NULL
11133 && bpstat_find_breakpoint (tp->control.stop_bpstat,
11134 sm->caller_breakpoint) != NULL))
11135 thread_fsm_set_finished (self);
11136
11137 return 1;
11138 }
11139
11140 /* Implementation of the 'clean_up' FSM method for the
11141 until(location)/advance commands. */
11142
11143 static void
11144 until_break_fsm_clean_up (struct thread_fsm *self,
11145 struct thread_info *thread)
11146 {
11147 struct until_break_fsm *sm = (struct until_break_fsm *) self;
11148
11149 /* Clean up our temporary breakpoints. */
11150 if (sm->location_breakpoint != NULL)
11151 {
11152 delete_breakpoint (sm->location_breakpoint);
11153 sm->location_breakpoint = NULL;
11154 }
11155 if (sm->caller_breakpoint != NULL)
11156 {
11157 delete_breakpoint (sm->caller_breakpoint);
11158 sm->caller_breakpoint = NULL;
11159 }
11160 delete_longjmp_breakpoint (sm->thread);
11161 }
11162
11163 /* Implementation of the 'async_reply_reason' FSM method for the
11164 until(location)/advance commands. */
11165
11166 static enum async_reply_reason
11167 until_break_fsm_async_reply_reason (struct thread_fsm *self)
11168 {
11169 return EXEC_ASYNC_LOCATION_REACHED;
11170 }
11171
11172 void
11173 until_break_command (const char *arg, int from_tty, int anywhere)
11174 {
11175 struct frame_info *frame;
11176 struct gdbarch *frame_gdbarch;
11177 struct frame_id stack_frame_id;
11178 struct frame_id caller_frame_id;
11179 struct cleanup *old_chain;
11180 int thread;
11181 struct thread_info *tp;
11182 struct until_break_fsm *sm;
11183
11184 clear_proceed_status (0);
11185
11186 /* Set a breakpoint where the user wants it and at return from
11187 this function. */
11188
11189 event_location_up location = string_to_event_location (&arg, current_language);
11190
11191 std::vector<symtab_and_line> sals
11192 = (last_displayed_sal_is_valid ()
11193 ? decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
11194 get_last_displayed_symtab (),
11195 get_last_displayed_line ())
11196 : decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
11197 NULL, (struct symtab *) NULL, 0));
11198
11199 if (sals.size () != 1)
11200 error (_("Couldn't get information on specified line."));
11201
11202 symtab_and_line &sal = sals[0];
11203
11204 if (*arg)
11205 error (_("Junk at end of arguments."));
11206
11207 resolve_sal_pc (&sal);
11208
11209 tp = inferior_thread ();
11210 thread = tp->global_num;
11211
11212 old_chain = make_cleanup (null_cleanup, NULL);
11213
11214 /* Note linespec handling above invalidates the frame chain.
11215 Installing a breakpoint also invalidates the frame chain (as it
11216 may need to switch threads), so do any frame handling before
11217 that. */
11218
11219 frame = get_selected_frame (NULL);
11220 frame_gdbarch = get_frame_arch (frame);
11221 stack_frame_id = get_stack_frame_id (frame);
11222 caller_frame_id = frame_unwind_caller_id (frame);
11223
11224 /* Keep within the current frame, or in frames called by the current
11225 one. */
11226
11227 breakpoint_up caller_breakpoint;
11228 if (frame_id_p (caller_frame_id))
11229 {
11230 struct symtab_and_line sal2;
11231 struct gdbarch *caller_gdbarch;
11232
11233 sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11234 sal2.pc = frame_unwind_caller_pc (frame);
11235 caller_gdbarch = frame_unwind_caller_arch (frame);
11236 caller_breakpoint = set_momentary_breakpoint (caller_gdbarch,
11237 sal2,
11238 caller_frame_id,
11239 bp_until);
11240
11241 set_longjmp_breakpoint (tp, caller_frame_id);
11242 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
11243 }
11244
11245 /* set_momentary_breakpoint could invalidate FRAME. */
11246 frame = NULL;
11247
11248 breakpoint_up location_breakpoint;
11249 if (anywhere)
11250 /* If the user told us to continue until a specified location,
11251 we don't specify a frame at which we need to stop. */
11252 location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11253 null_frame_id, bp_until);
11254 else
11255 /* Otherwise, specify the selected frame, because we want to stop
11256 only at the very same frame. */
11257 location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11258 stack_frame_id, bp_until);
11259
11260 sm = new_until_break_fsm (command_interp (), tp->global_num,
11261 std::move (location_breakpoint),
11262 std::move (caller_breakpoint));
11263 tp->thread_fsm = &sm->thread_fsm;
11264
11265 discard_cleanups (old_chain);
11266
11267 proceed (-1, GDB_SIGNAL_DEFAULT);
11268 }
11269
11270 /* This function attempts to parse an optional "if <cond>" clause
11271 from the arg string. If one is not found, it returns NULL.
11272
11273 Else, it returns a pointer to the condition string. (It does not
11274 attempt to evaluate the string against a particular block.) And,
11275 it updates arg to point to the first character following the parsed
11276 if clause in the arg string. */
11277
11278 const char *
11279 ep_parse_optional_if_clause (const char **arg)
11280 {
11281 const char *cond_string;
11282
11283 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
11284 return NULL;
11285
11286 /* Skip the "if" keyword. */
11287 (*arg) += 2;
11288
11289 /* Skip any extra leading whitespace, and record the start of the
11290 condition string. */
11291 *arg = skip_spaces (*arg);
11292 cond_string = *arg;
11293
11294 /* Assume that the condition occupies the remainder of the arg
11295 string. */
11296 (*arg) += strlen (cond_string);
11297
11298 return cond_string;
11299 }
11300
11301 /* Commands to deal with catching events, such as signals, exceptions,
11302 process start/exit, etc. */
11303
11304 typedef enum
11305 {
11306 catch_fork_temporary, catch_vfork_temporary,
11307 catch_fork_permanent, catch_vfork_permanent
11308 }
11309 catch_fork_kind;
11310
11311 static void
11312 catch_fork_command_1 (const char *arg, int from_tty,
11313 struct cmd_list_element *command)
11314 {
11315 struct gdbarch *gdbarch = get_current_arch ();
11316 const char *cond_string = NULL;
11317 catch_fork_kind fork_kind;
11318 int tempflag;
11319
11320 fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11321 tempflag = (fork_kind == catch_fork_temporary
11322 || fork_kind == catch_vfork_temporary);
11323
11324 if (!arg)
11325 arg = "";
11326 arg = skip_spaces (arg);
11327
11328 /* The allowed syntax is:
11329 catch [v]fork
11330 catch [v]fork if <cond>
11331
11332 First, check if there's an if clause. */
11333 cond_string = ep_parse_optional_if_clause (&arg);
11334
11335 if ((*arg != '\0') && !isspace (*arg))
11336 error (_("Junk at end of arguments."));
11337
11338 /* If this target supports it, create a fork or vfork catchpoint
11339 and enable reporting of such events. */
11340 switch (fork_kind)
11341 {
11342 case catch_fork_temporary:
11343 case catch_fork_permanent:
11344 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11345 &catch_fork_breakpoint_ops);
11346 break;
11347 case catch_vfork_temporary:
11348 case catch_vfork_permanent:
11349 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11350 &catch_vfork_breakpoint_ops);
11351 break;
11352 default:
11353 error (_("unsupported or unknown fork kind; cannot catch it"));
11354 break;
11355 }
11356 }
11357
11358 static void
11359 catch_exec_command_1 (const char *arg, int from_tty,
11360 struct cmd_list_element *command)
11361 {
11362 struct gdbarch *gdbarch = get_current_arch ();
11363 int tempflag;
11364 const char *cond_string = NULL;
11365
11366 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11367
11368 if (!arg)
11369 arg = "";
11370 arg = skip_spaces (arg);
11371
11372 /* The allowed syntax is:
11373 catch exec
11374 catch exec if <cond>
11375
11376 First, check if there's an if clause. */
11377 cond_string = ep_parse_optional_if_clause (&arg);
11378
11379 if ((*arg != '\0') && !isspace (*arg))
11380 error (_("Junk at end of arguments."));
11381
11382 std::unique_ptr<exec_catchpoint> c (new exec_catchpoint ());
11383 init_catchpoint (c.get (), gdbarch, tempflag, cond_string,
11384 &catch_exec_breakpoint_ops);
11385 c->exec_pathname = NULL;
11386
11387 install_breakpoint (0, std::move (c), 1);
11388 }
11389
11390 void
11391 init_ada_exception_breakpoint (struct breakpoint *b,
11392 struct gdbarch *gdbarch,
11393 struct symtab_and_line sal,
11394 const char *addr_string,
11395 const struct breakpoint_ops *ops,
11396 int tempflag,
11397 int enabled,
11398 int from_tty)
11399 {
11400 if (from_tty)
11401 {
11402 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11403 if (!loc_gdbarch)
11404 loc_gdbarch = gdbarch;
11405
11406 describe_other_breakpoints (loc_gdbarch,
11407 sal.pspace, sal.pc, sal.section, -1);
11408 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11409 version for exception catchpoints, because two catchpoints
11410 used for different exception names will use the same address.
11411 In this case, a "breakpoint ... also set at..." warning is
11412 unproductive. Besides, the warning phrasing is also a bit
11413 inappropriate, we should use the word catchpoint, and tell
11414 the user what type of catchpoint it is. The above is good
11415 enough for now, though. */
11416 }
11417
11418 init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
11419
11420 b->enable_state = enabled ? bp_enabled : bp_disabled;
11421 b->disposition = tempflag ? disp_del : disp_donttouch;
11422 b->location = string_to_event_location (&addr_string,
11423 language_def (language_ada));
11424 b->language = language_ada;
11425 }
11426
11427 static void
11428 catch_command (const char *arg, int from_tty)
11429 {
11430 error (_("Catch requires an event name."));
11431 }
11432
11433
11434 static void
11435 tcatch_command (const char *arg, int from_tty)
11436 {
11437 error (_("Catch requires an event name."));
11438 }
11439
11440 /* Compare two breakpoints and return a strcmp-like result. */
11441
11442 static int
11443 compare_breakpoints (const breakpoint *a, const breakpoint *b)
11444 {
11445 uintptr_t ua = (uintptr_t) a;
11446 uintptr_t ub = (uintptr_t) b;
11447
11448 if (a->number < b->number)
11449 return -1;
11450 else if (a->number > b->number)
11451 return 1;
11452
11453 /* Now sort by address, in case we see, e..g, two breakpoints with
11454 the number 0. */
11455 if (ua < ub)
11456 return -1;
11457 return ua > ub ? 1 : 0;
11458 }
11459
11460 /* Delete breakpoints by address or line. */
11461
11462 static void
11463 clear_command (const char *arg, int from_tty)
11464 {
11465 struct breakpoint *b;
11466 int default_match;
11467
11468 std::vector<symtab_and_line> decoded_sals;
11469 symtab_and_line last_sal;
11470 gdb::array_view<symtab_and_line> sals;
11471 if (arg)
11472 {
11473 decoded_sals
11474 = decode_line_with_current_source (arg,
11475 (DECODE_LINE_FUNFIRSTLINE
11476 | DECODE_LINE_LIST_MODE));
11477 default_match = 0;
11478 sals = decoded_sals;
11479 }
11480 else
11481 {
11482 /* Set sal's line, symtab, pc, and pspace to the values
11483 corresponding to the last call to print_frame_info. If the
11484 codepoint is not valid, this will set all the fields to 0. */
11485 last_sal = get_last_displayed_sal ();
11486 if (last_sal.symtab == 0)
11487 error (_("No source file specified."));
11488
11489 default_match = 1;
11490 sals = last_sal;
11491 }
11492
11493 /* We don't call resolve_sal_pc here. That's not as bad as it
11494 seems, because all existing breakpoints typically have both
11495 file/line and pc set. So, if clear is given file/line, we can
11496 match this to existing breakpoint without obtaining pc at all.
11497
11498 We only support clearing given the address explicitly
11499 present in breakpoint table. Say, we've set breakpoint
11500 at file:line. There were several PC values for that file:line,
11501 due to optimization, all in one block.
11502
11503 We've picked one PC value. If "clear" is issued with another
11504 PC corresponding to the same file:line, the breakpoint won't
11505 be cleared. We probably can still clear the breakpoint, but
11506 since the other PC value is never presented to user, user
11507 can only find it by guessing, and it does not seem important
11508 to support that. */
11509
11510 /* For each line spec given, delete bps which correspond to it. Do
11511 it in two passes, solely to preserve the current behavior that
11512 from_tty is forced true if we delete more than one
11513 breakpoint. */
11514
11515 std::vector<struct breakpoint *> found;
11516 for (const auto &sal : sals)
11517 {
11518 const char *sal_fullname;
11519
11520 /* If exact pc given, clear bpts at that pc.
11521 If line given (pc == 0), clear all bpts on specified line.
11522 If defaulting, clear all bpts on default line
11523 or at default pc.
11524
11525 defaulting sal.pc != 0 tests to do
11526
11527 0 1 pc
11528 1 1 pc _and_ line
11529 0 0 line
11530 1 0 <can't happen> */
11531
11532 sal_fullname = (sal.symtab == NULL
11533 ? NULL : symtab_to_fullname (sal.symtab));
11534
11535 /* Find all matching breakpoints and add them to 'found'. */
11536 ALL_BREAKPOINTS (b)
11537 {
11538 int match = 0;
11539 /* Are we going to delete b? */
11540 if (b->type != bp_none && !is_watchpoint (b))
11541 {
11542 struct bp_location *loc = b->loc;
11543 for (; loc; loc = loc->next)
11544 {
11545 /* If the user specified file:line, don't allow a PC
11546 match. This matches historical gdb behavior. */
11547 int pc_match = (!sal.explicit_line
11548 && sal.pc
11549 && (loc->pspace == sal.pspace)
11550 && (loc->address == sal.pc)
11551 && (!section_is_overlay (loc->section)
11552 || loc->section == sal.section));
11553 int line_match = 0;
11554
11555 if ((default_match || sal.explicit_line)
11556 && loc->symtab != NULL
11557 && sal_fullname != NULL
11558 && sal.pspace == loc->pspace
11559 && loc->line_number == sal.line
11560 && filename_cmp (symtab_to_fullname (loc->symtab),
11561 sal_fullname) == 0)
11562 line_match = 1;
11563
11564 if (pc_match || line_match)
11565 {
11566 match = 1;
11567 break;
11568 }
11569 }
11570 }
11571
11572 if (match)
11573 found.push_back (b);
11574 }
11575 }
11576
11577 /* Now go thru the 'found' chain and delete them. */
11578 if (found.empty ())
11579 {
11580 if (arg)
11581 error (_("No breakpoint at %s."), arg);
11582 else
11583 error (_("No breakpoint at this line."));
11584 }
11585
11586 /* Remove duplicates from the vec. */
11587 std::sort (found.begin (), found.end (),
11588 [] (const breakpoint *a, const breakpoint *b)
11589 {
11590 return compare_breakpoints (a, b) < 0;
11591 });
11592 found.erase (std::unique (found.begin (), found.end (),
11593 [] (const breakpoint *a, const breakpoint *b)
11594 {
11595 return compare_breakpoints (a, b) == 0;
11596 }),
11597 found.end ());
11598
11599 if (found.size () > 1)
11600 from_tty = 1; /* Always report if deleted more than one. */
11601 if (from_tty)
11602 {
11603 if (found.size () == 1)
11604 printf_unfiltered (_("Deleted breakpoint "));
11605 else
11606 printf_unfiltered (_("Deleted breakpoints "));
11607 }
11608
11609 for (breakpoint *iter : found)
11610 {
11611 if (from_tty)
11612 printf_unfiltered ("%d ", iter->number);
11613 delete_breakpoint (iter);
11614 }
11615 if (from_tty)
11616 putchar_unfiltered ('\n');
11617 }
11618
11619 /* Delete breakpoint in BS if they are `delete' breakpoints and
11620 all breakpoints that are marked for deletion, whether hit or not.
11621 This is called after any breakpoint is hit, or after errors. */
11622
11623 void
11624 breakpoint_auto_delete (bpstat bs)
11625 {
11626 struct breakpoint *b, *b_tmp;
11627
11628 for (; bs; bs = bs->next)
11629 if (bs->breakpoint_at
11630 && bs->breakpoint_at->disposition == disp_del
11631 && bs->stop)
11632 delete_breakpoint (bs->breakpoint_at);
11633
11634 ALL_BREAKPOINTS_SAFE (b, b_tmp)
11635 {
11636 if (b->disposition == disp_del_at_next_stop)
11637 delete_breakpoint (b);
11638 }
11639 }
11640
11641 /* A comparison function for bp_location AP and BP being interfaced to
11642 qsort. Sort elements primarily by their ADDRESS (no matter what
11643 does breakpoint_address_is_meaningful say for its OWNER),
11644 secondarily by ordering first permanent elements and
11645 terciarily just ensuring the array is sorted stable way despite
11646 qsort being an unstable algorithm. */
11647
11648 static int
11649 bp_locations_compare (const void *ap, const void *bp)
11650 {
11651 const struct bp_location *a = *(const struct bp_location **) ap;
11652 const struct bp_location *b = *(const struct bp_location **) bp;
11653
11654 if (a->address != b->address)
11655 return (a->address > b->address) - (a->address < b->address);
11656
11657 /* Sort locations at the same address by their pspace number, keeping
11658 locations of the same inferior (in a multi-inferior environment)
11659 grouped. */
11660
11661 if (a->pspace->num != b->pspace->num)
11662 return ((a->pspace->num > b->pspace->num)
11663 - (a->pspace->num < b->pspace->num));
11664
11665 /* Sort permanent breakpoints first. */
11666 if (a->permanent != b->permanent)
11667 return (a->permanent < b->permanent) - (a->permanent > b->permanent);
11668
11669 /* Make the internal GDB representation stable across GDB runs
11670 where A and B memory inside GDB can differ. Breakpoint locations of
11671 the same type at the same address can be sorted in arbitrary order. */
11672
11673 if (a->owner->number != b->owner->number)
11674 return ((a->owner->number > b->owner->number)
11675 - (a->owner->number < b->owner->number));
11676
11677 return (a > b) - (a < b);
11678 }
11679
11680 /* Set bp_locations_placed_address_before_address_max and
11681 bp_locations_shadow_len_after_address_max according to the current
11682 content of the bp_locations array. */
11683
11684 static void
11685 bp_locations_target_extensions_update (void)
11686 {
11687 struct bp_location *bl, **blp_tmp;
11688
11689 bp_locations_placed_address_before_address_max = 0;
11690 bp_locations_shadow_len_after_address_max = 0;
11691
11692 ALL_BP_LOCATIONS (bl, blp_tmp)
11693 {
11694 CORE_ADDR start, end, addr;
11695
11696 if (!bp_location_has_shadow (bl))
11697 continue;
11698
11699 start = bl->target_info.placed_address;
11700 end = start + bl->target_info.shadow_len;
11701
11702 gdb_assert (bl->address >= start);
11703 addr = bl->address - start;
11704 if (addr > bp_locations_placed_address_before_address_max)
11705 bp_locations_placed_address_before_address_max = addr;
11706
11707 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11708
11709 gdb_assert (bl->address < end);
11710 addr = end - bl->address;
11711 if (addr > bp_locations_shadow_len_after_address_max)
11712 bp_locations_shadow_len_after_address_max = addr;
11713 }
11714 }
11715
11716 /* Download tracepoint locations if they haven't been. */
11717
11718 static void
11719 download_tracepoint_locations (void)
11720 {
11721 struct breakpoint *b;
11722 enum tribool can_download_tracepoint = TRIBOOL_UNKNOWN;
11723
11724 scoped_restore_current_pspace_and_thread restore_pspace_thread;
11725
11726 ALL_TRACEPOINTS (b)
11727 {
11728 struct bp_location *bl;
11729 struct tracepoint *t;
11730 int bp_location_downloaded = 0;
11731
11732 if ((b->type == bp_fast_tracepoint
11733 ? !may_insert_fast_tracepoints
11734 : !may_insert_tracepoints))
11735 continue;
11736
11737 if (can_download_tracepoint == TRIBOOL_UNKNOWN)
11738 {
11739 if (target_can_download_tracepoint ())
11740 can_download_tracepoint = TRIBOOL_TRUE;
11741 else
11742 can_download_tracepoint = TRIBOOL_FALSE;
11743 }
11744
11745 if (can_download_tracepoint == TRIBOOL_FALSE)
11746 break;
11747
11748 for (bl = b->loc; bl; bl = bl->next)
11749 {
11750 /* In tracepoint, locations are _never_ duplicated, so
11751 should_be_inserted is equivalent to
11752 unduplicated_should_be_inserted. */
11753 if (!should_be_inserted (bl) || bl->inserted)
11754 continue;
11755
11756 switch_to_program_space_and_thread (bl->pspace);
11757
11758 target_download_tracepoint (bl);
11759
11760 bl->inserted = 1;
11761 bp_location_downloaded = 1;
11762 }
11763 t = (struct tracepoint *) b;
11764 t->number_on_target = b->number;
11765 if (bp_location_downloaded)
11766 observer_notify_breakpoint_modified (b);
11767 }
11768 }
11769
11770 /* Swap the insertion/duplication state between two locations. */
11771
11772 static void
11773 swap_insertion (struct bp_location *left, struct bp_location *right)
11774 {
11775 const int left_inserted = left->inserted;
11776 const int left_duplicate = left->duplicate;
11777 const int left_needs_update = left->needs_update;
11778 const struct bp_target_info left_target_info = left->target_info;
11779
11780 /* Locations of tracepoints can never be duplicated. */
11781 if (is_tracepoint (left->owner))
11782 gdb_assert (!left->duplicate);
11783 if (is_tracepoint (right->owner))
11784 gdb_assert (!right->duplicate);
11785
11786 left->inserted = right->inserted;
11787 left->duplicate = right->duplicate;
11788 left->needs_update = right->needs_update;
11789 left->target_info = right->target_info;
11790 right->inserted = left_inserted;
11791 right->duplicate = left_duplicate;
11792 right->needs_update = left_needs_update;
11793 right->target_info = left_target_info;
11794 }
11795
11796 /* Force the re-insertion of the locations at ADDRESS. This is called
11797 once a new/deleted/modified duplicate location is found and we are evaluating
11798 conditions on the target's side. Such conditions need to be updated on
11799 the target. */
11800
11801 static void
11802 force_breakpoint_reinsertion (struct bp_location *bl)
11803 {
11804 struct bp_location **locp = NULL, **loc2p;
11805 struct bp_location *loc;
11806 CORE_ADDR address = 0;
11807 int pspace_num;
11808
11809 address = bl->address;
11810 pspace_num = bl->pspace->num;
11811
11812 /* This is only meaningful if the target is
11813 evaluating conditions and if the user has
11814 opted for condition evaluation on the target's
11815 side. */
11816 if (gdb_evaluates_breakpoint_condition_p ()
11817 || !target_supports_evaluation_of_breakpoint_conditions ())
11818 return;
11819
11820 /* Flag all breakpoint locations with this address and
11821 the same program space as the location
11822 as "its condition has changed". We need to
11823 update the conditions on the target's side. */
11824 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
11825 {
11826 loc = *loc2p;
11827
11828 if (!is_breakpoint (loc->owner)
11829 || pspace_num != loc->pspace->num)
11830 continue;
11831
11832 /* Flag the location appropriately. We use a different state to
11833 let everyone know that we already updated the set of locations
11834 with addr bl->address and program space bl->pspace. This is so
11835 we don't have to keep calling these functions just to mark locations
11836 that have already been marked. */
11837 loc->condition_changed = condition_updated;
11838
11839 /* Free the agent expression bytecode as well. We will compute
11840 it later on. */
11841 loc->cond_bytecode.reset ();
11842 }
11843 }
11844 /* Called whether new breakpoints are created, or existing breakpoints
11845 deleted, to update the global location list and recompute which
11846 locations are duplicate of which.
11847
11848 The INSERT_MODE flag determines whether locations may not, may, or
11849 shall be inserted now. See 'enum ugll_insert_mode' for more
11850 info. */
11851
11852 static void
11853 update_global_location_list (enum ugll_insert_mode insert_mode)
11854 {
11855 struct breakpoint *b;
11856 struct bp_location **locp, *loc;
11857 /* Last breakpoint location address that was marked for update. */
11858 CORE_ADDR last_addr = 0;
11859 /* Last breakpoint location program space that was marked for update. */
11860 int last_pspace_num = -1;
11861
11862 /* Used in the duplicates detection below. When iterating over all
11863 bp_locations, points to the first bp_location of a given address.
11864 Breakpoints and watchpoints of different types are never
11865 duplicates of each other. Keep one pointer for each type of
11866 breakpoint/watchpoint, so we only need to loop over all locations
11867 once. */
11868 struct bp_location *bp_loc_first; /* breakpoint */
11869 struct bp_location *wp_loc_first; /* hardware watchpoint */
11870 struct bp_location *awp_loc_first; /* access watchpoint */
11871 struct bp_location *rwp_loc_first; /* read watchpoint */
11872
11873 /* Saved former bp_locations array which we compare against the newly
11874 built bp_locations from the current state of ALL_BREAKPOINTS. */
11875 struct bp_location **old_locp;
11876 unsigned old_locations_count;
11877 gdb::unique_xmalloc_ptr<struct bp_location *> old_locations (bp_locations);
11878
11879 old_locations_count = bp_locations_count;
11880 bp_locations = NULL;
11881 bp_locations_count = 0;
11882
11883 ALL_BREAKPOINTS (b)
11884 for (loc = b->loc; loc; loc = loc->next)
11885 bp_locations_count++;
11886
11887 bp_locations = XNEWVEC (struct bp_location *, bp_locations_count);
11888 locp = bp_locations;
11889 ALL_BREAKPOINTS (b)
11890 for (loc = b->loc; loc; loc = loc->next)
11891 *locp++ = loc;
11892 qsort (bp_locations, bp_locations_count, sizeof (*bp_locations),
11893 bp_locations_compare);
11894
11895 bp_locations_target_extensions_update ();
11896
11897 /* Identify bp_location instances that are no longer present in the
11898 new list, and therefore should be freed. Note that it's not
11899 necessary that those locations should be removed from inferior --
11900 if there's another location at the same address (previously
11901 marked as duplicate), we don't need to remove/insert the
11902 location.
11903
11904 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11905 and former bp_location array state respectively. */
11906
11907 locp = bp_locations;
11908 for (old_locp = old_locations.get ();
11909 old_locp < old_locations.get () + old_locations_count;
11910 old_locp++)
11911 {
11912 struct bp_location *old_loc = *old_locp;
11913 struct bp_location **loc2p;
11914
11915 /* Tells if 'old_loc' is found among the new locations. If
11916 not, we have to free it. */
11917 int found_object = 0;
11918 /* Tells if the location should remain inserted in the target. */
11919 int keep_in_target = 0;
11920 int removed = 0;
11921
11922 /* Skip LOCP entries which will definitely never be needed.
11923 Stop either at or being the one matching OLD_LOC. */
11924 while (locp < bp_locations + bp_locations_count
11925 && (*locp)->address < old_loc->address)
11926 locp++;
11927
11928 for (loc2p = locp;
11929 (loc2p < bp_locations + bp_locations_count
11930 && (*loc2p)->address == old_loc->address);
11931 loc2p++)
11932 {
11933 /* Check if this is a new/duplicated location or a duplicated
11934 location that had its condition modified. If so, we want to send
11935 its condition to the target if evaluation of conditions is taking
11936 place there. */
11937 if ((*loc2p)->condition_changed == condition_modified
11938 && (last_addr != old_loc->address
11939 || last_pspace_num != old_loc->pspace->num))
11940 {
11941 force_breakpoint_reinsertion (*loc2p);
11942 last_pspace_num = old_loc->pspace->num;
11943 }
11944
11945 if (*loc2p == old_loc)
11946 found_object = 1;
11947 }
11948
11949 /* We have already handled this address, update it so that we don't
11950 have to go through updates again. */
11951 last_addr = old_loc->address;
11952
11953 /* Target-side condition evaluation: Handle deleted locations. */
11954 if (!found_object)
11955 force_breakpoint_reinsertion (old_loc);
11956
11957 /* If this location is no longer present, and inserted, look if
11958 there's maybe a new location at the same address. If so,
11959 mark that one inserted, and don't remove this one. This is
11960 needed so that we don't have a time window where a breakpoint
11961 at certain location is not inserted. */
11962
11963 if (old_loc->inserted)
11964 {
11965 /* If the location is inserted now, we might have to remove
11966 it. */
11967
11968 if (found_object && should_be_inserted (old_loc))
11969 {
11970 /* The location is still present in the location list,
11971 and still should be inserted. Don't do anything. */
11972 keep_in_target = 1;
11973 }
11974 else
11975 {
11976 /* This location still exists, but it won't be kept in the
11977 target since it may have been disabled. We proceed to
11978 remove its target-side condition. */
11979
11980 /* The location is either no longer present, or got
11981 disabled. See if there's another location at the
11982 same address, in which case we don't need to remove
11983 this one from the target. */
11984
11985 /* OLD_LOC comes from existing struct breakpoint. */
11986 if (breakpoint_address_is_meaningful (old_loc->owner))
11987 {
11988 for (loc2p = locp;
11989 (loc2p < bp_locations + bp_locations_count
11990 && (*loc2p)->address == old_loc->address);
11991 loc2p++)
11992 {
11993 struct bp_location *loc2 = *loc2p;
11994
11995 if (breakpoint_locations_match (loc2, old_loc))
11996 {
11997 /* Read watchpoint locations are switched to
11998 access watchpoints, if the former are not
11999 supported, but the latter are. */
12000 if (is_hardware_watchpoint (old_loc->owner))
12001 {
12002 gdb_assert (is_hardware_watchpoint (loc2->owner));
12003 loc2->watchpoint_type = old_loc->watchpoint_type;
12004 }
12005
12006 /* loc2 is a duplicated location. We need to check
12007 if it should be inserted in case it will be
12008 unduplicated. */
12009 if (loc2 != old_loc
12010 && unduplicated_should_be_inserted (loc2))
12011 {
12012 swap_insertion (old_loc, loc2);
12013 keep_in_target = 1;
12014 break;
12015 }
12016 }
12017 }
12018 }
12019 }
12020
12021 if (!keep_in_target)
12022 {
12023 if (remove_breakpoint (old_loc))
12024 {
12025 /* This is just about all we can do. We could keep
12026 this location on the global list, and try to
12027 remove it next time, but there's no particular
12028 reason why we will succeed next time.
12029
12030 Note that at this point, old_loc->owner is still
12031 valid, as delete_breakpoint frees the breakpoint
12032 only after calling us. */
12033 printf_filtered (_("warning: Error removing "
12034 "breakpoint %d\n"),
12035 old_loc->owner->number);
12036 }
12037 removed = 1;
12038 }
12039 }
12040
12041 if (!found_object)
12042 {
12043 if (removed && target_is_non_stop_p ()
12044 && need_moribund_for_location_type (old_loc))
12045 {
12046 /* This location was removed from the target. In
12047 non-stop mode, a race condition is possible where
12048 we've removed a breakpoint, but stop events for that
12049 breakpoint are already queued and will arrive later.
12050 We apply an heuristic to be able to distinguish such
12051 SIGTRAPs from other random SIGTRAPs: we keep this
12052 breakpoint location for a bit, and will retire it
12053 after we see some number of events. The theory here
12054 is that reporting of events should, "on the average",
12055 be fair, so after a while we'll see events from all
12056 threads that have anything of interest, and no longer
12057 need to keep this breakpoint location around. We
12058 don't hold locations forever so to reduce chances of
12059 mistaking a non-breakpoint SIGTRAP for a breakpoint
12060 SIGTRAP.
12061
12062 The heuristic failing can be disastrous on
12063 decr_pc_after_break targets.
12064
12065 On decr_pc_after_break targets, like e.g., x86-linux,
12066 if we fail to recognize a late breakpoint SIGTRAP,
12067 because events_till_retirement has reached 0 too
12068 soon, we'll fail to do the PC adjustment, and report
12069 a random SIGTRAP to the user. When the user resumes
12070 the inferior, it will most likely immediately crash
12071 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12072 corrupted, because of being resumed e.g., in the
12073 middle of a multi-byte instruction, or skipped a
12074 one-byte instruction. This was actually seen happen
12075 on native x86-linux, and should be less rare on
12076 targets that do not support new thread events, like
12077 remote, due to the heuristic depending on
12078 thread_count.
12079
12080 Mistaking a random SIGTRAP for a breakpoint trap
12081 causes similar symptoms (PC adjustment applied when
12082 it shouldn't), but then again, playing with SIGTRAPs
12083 behind the debugger's back is asking for trouble.
12084
12085 Since hardware watchpoint traps are always
12086 distinguishable from other traps, so we don't need to
12087 apply keep hardware watchpoint moribund locations
12088 around. We simply always ignore hardware watchpoint
12089 traps we can no longer explain. */
12090
12091 old_loc->events_till_retirement = 3 * (thread_count () + 1);
12092 old_loc->owner = NULL;
12093
12094 VEC_safe_push (bp_location_p, moribund_locations, old_loc);
12095 }
12096 else
12097 {
12098 old_loc->owner = NULL;
12099 decref_bp_location (&old_loc);
12100 }
12101 }
12102 }
12103
12104 /* Rescan breakpoints at the same address and section, marking the
12105 first one as "first" and any others as "duplicates". This is so
12106 that the bpt instruction is only inserted once. If we have a
12107 permanent breakpoint at the same place as BPT, make that one the
12108 official one, and the rest as duplicates. Permanent breakpoints
12109 are sorted first for the same address.
12110
12111 Do the same for hardware watchpoints, but also considering the
12112 watchpoint's type (regular/access/read) and length. */
12113
12114 bp_loc_first = NULL;
12115 wp_loc_first = NULL;
12116 awp_loc_first = NULL;
12117 rwp_loc_first = NULL;
12118 ALL_BP_LOCATIONS (loc, locp)
12119 {
12120 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12121 non-NULL. */
12122 struct bp_location **loc_first_p;
12123 b = loc->owner;
12124
12125 if (!unduplicated_should_be_inserted (loc)
12126 || !breakpoint_address_is_meaningful (b)
12127 /* Don't detect duplicate for tracepoint locations because they are
12128 never duplicated. See the comments in field `duplicate' of
12129 `struct bp_location'. */
12130 || is_tracepoint (b))
12131 {
12132 /* Clear the condition modification flag. */
12133 loc->condition_changed = condition_unchanged;
12134 continue;
12135 }
12136
12137 if (b->type == bp_hardware_watchpoint)
12138 loc_first_p = &wp_loc_first;
12139 else if (b->type == bp_read_watchpoint)
12140 loc_first_p = &rwp_loc_first;
12141 else if (b->type == bp_access_watchpoint)
12142 loc_first_p = &awp_loc_first;
12143 else
12144 loc_first_p = &bp_loc_first;
12145
12146 if (*loc_first_p == NULL
12147 || (overlay_debugging && loc->section != (*loc_first_p)->section)
12148 || !breakpoint_locations_match (loc, *loc_first_p))
12149 {
12150 *loc_first_p = loc;
12151 loc->duplicate = 0;
12152
12153 if (is_breakpoint (loc->owner) && loc->condition_changed)
12154 {
12155 loc->needs_update = 1;
12156 /* Clear the condition modification flag. */
12157 loc->condition_changed = condition_unchanged;
12158 }
12159 continue;
12160 }
12161
12162
12163 /* This and the above ensure the invariant that the first location
12164 is not duplicated, and is the inserted one.
12165 All following are marked as duplicated, and are not inserted. */
12166 if (loc->inserted)
12167 swap_insertion (loc, *loc_first_p);
12168 loc->duplicate = 1;
12169
12170 /* Clear the condition modification flag. */
12171 loc->condition_changed = condition_unchanged;
12172 }
12173
12174 if (insert_mode == UGLL_INSERT || breakpoints_should_be_inserted_now ())
12175 {
12176 if (insert_mode != UGLL_DONT_INSERT)
12177 insert_breakpoint_locations ();
12178 else
12179 {
12180 /* Even though the caller told us to not insert new
12181 locations, we may still need to update conditions on the
12182 target's side of breakpoints that were already inserted
12183 if the target is evaluating breakpoint conditions. We
12184 only update conditions for locations that are marked
12185 "needs_update". */
12186 update_inserted_breakpoint_locations ();
12187 }
12188 }
12189
12190 if (insert_mode != UGLL_DONT_INSERT)
12191 download_tracepoint_locations ();
12192 }
12193
12194 void
12195 breakpoint_retire_moribund (void)
12196 {
12197 struct bp_location *loc;
12198 int ix;
12199
12200 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
12201 if (--(loc->events_till_retirement) == 0)
12202 {
12203 decref_bp_location (&loc);
12204 VEC_unordered_remove (bp_location_p, moribund_locations, ix);
12205 --ix;
12206 }
12207 }
12208
12209 static void
12210 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode)
12211 {
12212
12213 TRY
12214 {
12215 update_global_location_list (insert_mode);
12216 }
12217 CATCH (e, RETURN_MASK_ERROR)
12218 {
12219 }
12220 END_CATCH
12221 }
12222
12223 /* Clear BKP from a BPS. */
12224
12225 static void
12226 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12227 {
12228 bpstat bs;
12229
12230 for (bs = bps; bs; bs = bs->next)
12231 if (bs->breakpoint_at == bpt)
12232 {
12233 bs->breakpoint_at = NULL;
12234 bs->old_val = NULL;
12235 /* bs->commands will be freed later. */
12236 }
12237 }
12238
12239 /* Callback for iterate_over_threads. */
12240 static int
12241 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12242 {
12243 struct breakpoint *bpt = (struct breakpoint *) data;
12244
12245 bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12246 return 0;
12247 }
12248
12249 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12250 callbacks. */
12251
12252 static void
12253 say_where (struct breakpoint *b)
12254 {
12255 struct value_print_options opts;
12256
12257 get_user_print_options (&opts);
12258
12259 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12260 single string. */
12261 if (b->loc == NULL)
12262 {
12263 /* For pending locations, the output differs slightly based
12264 on b->extra_string. If this is non-NULL, it contains either
12265 a condition or dprintf arguments. */
12266 if (b->extra_string == NULL)
12267 {
12268 printf_filtered (_(" (%s) pending."),
12269 event_location_to_string (b->location.get ()));
12270 }
12271 else if (b->type == bp_dprintf)
12272 {
12273 printf_filtered (_(" (%s,%s) pending."),
12274 event_location_to_string (b->location.get ()),
12275 b->extra_string);
12276 }
12277 else
12278 {
12279 printf_filtered (_(" (%s %s) pending."),
12280 event_location_to_string (b->location.get ()),
12281 b->extra_string);
12282 }
12283 }
12284 else
12285 {
12286 if (opts.addressprint || b->loc->symtab == NULL)
12287 {
12288 printf_filtered (" at ");
12289 fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
12290 gdb_stdout);
12291 }
12292 if (b->loc->symtab != NULL)
12293 {
12294 /* If there is a single location, we can print the location
12295 more nicely. */
12296 if (b->loc->next == NULL)
12297 printf_filtered (": file %s, line %d.",
12298 symtab_to_filename_for_display (b->loc->symtab),
12299 b->loc->line_number);
12300 else
12301 /* This is not ideal, but each location may have a
12302 different file name, and this at least reflects the
12303 real situation somewhat. */
12304 printf_filtered (": %s.",
12305 event_location_to_string (b->location.get ()));
12306 }
12307
12308 if (b->loc->next)
12309 {
12310 struct bp_location *loc = b->loc;
12311 int n = 0;
12312 for (; loc; loc = loc->next)
12313 ++n;
12314 printf_filtered (" (%d locations)", n);
12315 }
12316 }
12317 }
12318
12319 /* Default bp_location_ops methods. */
12320
12321 static void
12322 bp_location_dtor (struct bp_location *self)
12323 {
12324 xfree (self->function_name);
12325 }
12326
12327 static const struct bp_location_ops bp_location_ops =
12328 {
12329 bp_location_dtor
12330 };
12331
12332 /* Destructor for the breakpoint base class. */
12333
12334 breakpoint::~breakpoint ()
12335 {
12336 xfree (this->cond_string);
12337 xfree (this->extra_string);
12338 xfree (this->filter);
12339 }
12340
12341 static struct bp_location *
12342 base_breakpoint_allocate_location (struct breakpoint *self)
12343 {
12344 return new bp_location (&bp_location_ops, self);
12345 }
12346
12347 static void
12348 base_breakpoint_re_set (struct breakpoint *b)
12349 {
12350 /* Nothing to re-set. */
12351 }
12352
12353 #define internal_error_pure_virtual_called() \
12354 gdb_assert_not_reached ("pure virtual function called")
12355
12356 static int
12357 base_breakpoint_insert_location (struct bp_location *bl)
12358 {
12359 internal_error_pure_virtual_called ();
12360 }
12361
12362 static int
12363 base_breakpoint_remove_location (struct bp_location *bl,
12364 enum remove_bp_reason reason)
12365 {
12366 internal_error_pure_virtual_called ();
12367 }
12368
12369 static int
12370 base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12371 const address_space *aspace,
12372 CORE_ADDR bp_addr,
12373 const struct target_waitstatus *ws)
12374 {
12375 internal_error_pure_virtual_called ();
12376 }
12377
12378 static void
12379 base_breakpoint_check_status (bpstat bs)
12380 {
12381 /* Always stop. */
12382 }
12383
12384 /* A "works_in_software_mode" breakpoint_ops method that just internal
12385 errors. */
12386
12387 static int
12388 base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12389 {
12390 internal_error_pure_virtual_called ();
12391 }
12392
12393 /* A "resources_needed" breakpoint_ops method that just internal
12394 errors. */
12395
12396 static int
12397 base_breakpoint_resources_needed (const struct bp_location *bl)
12398 {
12399 internal_error_pure_virtual_called ();
12400 }
12401
12402 static enum print_stop_action
12403 base_breakpoint_print_it (bpstat bs)
12404 {
12405 internal_error_pure_virtual_called ();
12406 }
12407
12408 static void
12409 base_breakpoint_print_one_detail (const struct breakpoint *self,
12410 struct ui_out *uiout)
12411 {
12412 /* nothing */
12413 }
12414
12415 static void
12416 base_breakpoint_print_mention (struct breakpoint *b)
12417 {
12418 internal_error_pure_virtual_called ();
12419 }
12420
12421 static void
12422 base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12423 {
12424 internal_error_pure_virtual_called ();
12425 }
12426
12427 static void
12428 base_breakpoint_create_sals_from_location
12429 (const struct event_location *location,
12430 struct linespec_result *canonical,
12431 enum bptype type_wanted)
12432 {
12433 internal_error_pure_virtual_called ();
12434 }
12435
12436 static void
12437 base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12438 struct linespec_result *c,
12439 gdb::unique_xmalloc_ptr<char> cond_string,
12440 gdb::unique_xmalloc_ptr<char> extra_string,
12441 enum bptype type_wanted,
12442 enum bpdisp disposition,
12443 int thread,
12444 int task, int ignore_count,
12445 const struct breakpoint_ops *o,
12446 int from_tty, int enabled,
12447 int internal, unsigned flags)
12448 {
12449 internal_error_pure_virtual_called ();
12450 }
12451
12452 static std::vector<symtab_and_line>
12453 base_breakpoint_decode_location (struct breakpoint *b,
12454 const struct event_location *location,
12455 struct program_space *search_pspace)
12456 {
12457 internal_error_pure_virtual_called ();
12458 }
12459
12460 /* The default 'explains_signal' method. */
12461
12462 static int
12463 base_breakpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
12464 {
12465 return 1;
12466 }
12467
12468 /* The default "after_condition_true" method. */
12469
12470 static void
12471 base_breakpoint_after_condition_true (struct bpstats *bs)
12472 {
12473 /* Nothing to do. */
12474 }
12475
12476 struct breakpoint_ops base_breakpoint_ops =
12477 {
12478 base_breakpoint_allocate_location,
12479 base_breakpoint_re_set,
12480 base_breakpoint_insert_location,
12481 base_breakpoint_remove_location,
12482 base_breakpoint_breakpoint_hit,
12483 base_breakpoint_check_status,
12484 base_breakpoint_resources_needed,
12485 base_breakpoint_works_in_software_mode,
12486 base_breakpoint_print_it,
12487 NULL,
12488 base_breakpoint_print_one_detail,
12489 base_breakpoint_print_mention,
12490 base_breakpoint_print_recreate,
12491 base_breakpoint_create_sals_from_location,
12492 base_breakpoint_create_breakpoints_sal,
12493 base_breakpoint_decode_location,
12494 base_breakpoint_explains_signal,
12495 base_breakpoint_after_condition_true,
12496 };
12497
12498 /* Default breakpoint_ops methods. */
12499
12500 static void
12501 bkpt_re_set (struct breakpoint *b)
12502 {
12503 /* FIXME: is this still reachable? */
12504 if (breakpoint_event_location_empty_p (b))
12505 {
12506 /* Anything without a location can't be re-set. */
12507 delete_breakpoint (b);
12508 return;
12509 }
12510
12511 breakpoint_re_set_default (b);
12512 }
12513
12514 static int
12515 bkpt_insert_location (struct bp_location *bl)
12516 {
12517 CORE_ADDR addr = bl->target_info.reqstd_address;
12518
12519 bl->target_info.kind = breakpoint_kind (bl, &addr);
12520 bl->target_info.placed_address = addr;
12521
12522 if (bl->loc_type == bp_loc_hardware_breakpoint)
12523 return target_insert_hw_breakpoint (bl->gdbarch, &bl->target_info);
12524 else
12525 return target_insert_breakpoint (bl->gdbarch, &bl->target_info);
12526 }
12527
12528 static int
12529 bkpt_remove_location (struct bp_location *bl, enum remove_bp_reason reason)
12530 {
12531 if (bl->loc_type == bp_loc_hardware_breakpoint)
12532 return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
12533 else
12534 return target_remove_breakpoint (bl->gdbarch, &bl->target_info, reason);
12535 }
12536
12537 static int
12538 bkpt_breakpoint_hit (const struct bp_location *bl,
12539 const address_space *aspace, CORE_ADDR bp_addr,
12540 const struct target_waitstatus *ws)
12541 {
12542 if (ws->kind != TARGET_WAITKIND_STOPPED
12543 || ws->value.sig != GDB_SIGNAL_TRAP)
12544 return 0;
12545
12546 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
12547 aspace, bp_addr))
12548 return 0;
12549
12550 if (overlay_debugging /* unmapped overlay section */
12551 && section_is_overlay (bl->section)
12552 && !section_is_mapped (bl->section))
12553 return 0;
12554
12555 return 1;
12556 }
12557
12558 static int
12559 dprintf_breakpoint_hit (const struct bp_location *bl,
12560 const address_space *aspace, CORE_ADDR bp_addr,
12561 const struct target_waitstatus *ws)
12562 {
12563 if (dprintf_style == dprintf_style_agent
12564 && target_can_run_breakpoint_commands ())
12565 {
12566 /* An agent-style dprintf never causes a stop. If we see a trap
12567 for this address it must be for a breakpoint that happens to
12568 be set at the same address. */
12569 return 0;
12570 }
12571
12572 return bkpt_breakpoint_hit (bl, aspace, bp_addr, ws);
12573 }
12574
12575 static int
12576 bkpt_resources_needed (const struct bp_location *bl)
12577 {
12578 gdb_assert (bl->owner->type == bp_hardware_breakpoint);
12579
12580 return 1;
12581 }
12582
12583 static enum print_stop_action
12584 bkpt_print_it (bpstat bs)
12585 {
12586 struct breakpoint *b;
12587 const struct bp_location *bl;
12588 int bp_temp;
12589 struct ui_out *uiout = current_uiout;
12590
12591 gdb_assert (bs->bp_location_at != NULL);
12592
12593 bl = bs->bp_location_at;
12594 b = bs->breakpoint_at;
12595
12596 bp_temp = b->disposition == disp_del;
12597 if (bl->address != bl->requested_address)
12598 breakpoint_adjustment_warning (bl->requested_address,
12599 bl->address,
12600 b->number, 1);
12601 annotate_breakpoint (b->number);
12602 maybe_print_thread_hit_breakpoint (uiout);
12603
12604 if (bp_temp)
12605 uiout->text ("Temporary breakpoint ");
12606 else
12607 uiout->text ("Breakpoint ");
12608 if (uiout->is_mi_like_p ())
12609 {
12610 uiout->field_string ("reason",
12611 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
12612 uiout->field_string ("disp", bpdisp_text (b->disposition));
12613 }
12614 uiout->field_int ("bkptno", b->number);
12615 uiout->text (", ");
12616
12617 return PRINT_SRC_AND_LOC;
12618 }
12619
12620 static void
12621 bkpt_print_mention (struct breakpoint *b)
12622 {
12623 if (current_uiout->is_mi_like_p ())
12624 return;
12625
12626 switch (b->type)
12627 {
12628 case bp_breakpoint:
12629 case bp_gnu_ifunc_resolver:
12630 if (b->disposition == disp_del)
12631 printf_filtered (_("Temporary breakpoint"));
12632 else
12633 printf_filtered (_("Breakpoint"));
12634 printf_filtered (_(" %d"), b->number);
12635 if (b->type == bp_gnu_ifunc_resolver)
12636 printf_filtered (_(" at gnu-indirect-function resolver"));
12637 break;
12638 case bp_hardware_breakpoint:
12639 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
12640 break;
12641 case bp_dprintf:
12642 printf_filtered (_("Dprintf %d"), b->number);
12643 break;
12644 }
12645
12646 say_where (b);
12647 }
12648
12649 static void
12650 bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
12651 {
12652 if (tp->type == bp_breakpoint && tp->disposition == disp_del)
12653 fprintf_unfiltered (fp, "tbreak");
12654 else if (tp->type == bp_breakpoint)
12655 fprintf_unfiltered (fp, "break");
12656 else if (tp->type == bp_hardware_breakpoint
12657 && tp->disposition == disp_del)
12658 fprintf_unfiltered (fp, "thbreak");
12659 else if (tp->type == bp_hardware_breakpoint)
12660 fprintf_unfiltered (fp, "hbreak");
12661 else
12662 internal_error (__FILE__, __LINE__,
12663 _("unhandled breakpoint type %d"), (int) tp->type);
12664
12665 fprintf_unfiltered (fp, " %s",
12666 event_location_to_string (tp->location.get ()));
12667
12668 /* Print out extra_string if this breakpoint is pending. It might
12669 contain, for example, conditions that were set by the user. */
12670 if (tp->loc == NULL && tp->extra_string != NULL)
12671 fprintf_unfiltered (fp, " %s", tp->extra_string);
12672
12673 print_recreate_thread (tp, fp);
12674 }
12675
12676 static void
12677 bkpt_create_sals_from_location (const struct event_location *location,
12678 struct linespec_result *canonical,
12679 enum bptype type_wanted)
12680 {
12681 create_sals_from_location_default (location, canonical, type_wanted);
12682 }
12683
12684 static void
12685 bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
12686 struct linespec_result *canonical,
12687 gdb::unique_xmalloc_ptr<char> cond_string,
12688 gdb::unique_xmalloc_ptr<char> extra_string,
12689 enum bptype type_wanted,
12690 enum bpdisp disposition,
12691 int thread,
12692 int task, int ignore_count,
12693 const struct breakpoint_ops *ops,
12694 int from_tty, int enabled,
12695 int internal, unsigned flags)
12696 {
12697 create_breakpoints_sal_default (gdbarch, canonical,
12698 std::move (cond_string),
12699 std::move (extra_string),
12700 type_wanted,
12701 disposition, thread, task,
12702 ignore_count, ops, from_tty,
12703 enabled, internal, flags);
12704 }
12705
12706 static std::vector<symtab_and_line>
12707 bkpt_decode_location (struct breakpoint *b,
12708 const struct event_location *location,
12709 struct program_space *search_pspace)
12710 {
12711 return decode_location_default (b, location, search_pspace);
12712 }
12713
12714 /* Virtual table for internal breakpoints. */
12715
12716 static void
12717 internal_bkpt_re_set (struct breakpoint *b)
12718 {
12719 switch (b->type)
12720 {
12721 /* Delete overlay event and longjmp master breakpoints; they
12722 will be reset later by breakpoint_re_set. */
12723 case bp_overlay_event:
12724 case bp_longjmp_master:
12725 case bp_std_terminate_master:
12726 case bp_exception_master:
12727 delete_breakpoint (b);
12728 break;
12729
12730 /* This breakpoint is special, it's set up when the inferior
12731 starts and we really don't want to touch it. */
12732 case bp_shlib_event:
12733
12734 /* Like bp_shlib_event, this breakpoint type is special. Once
12735 it is set up, we do not want to touch it. */
12736 case bp_thread_event:
12737 break;
12738 }
12739 }
12740
12741 static void
12742 internal_bkpt_check_status (bpstat bs)
12743 {
12744 if (bs->breakpoint_at->type == bp_shlib_event)
12745 {
12746 /* If requested, stop when the dynamic linker notifies GDB of
12747 events. This allows the user to get control and place
12748 breakpoints in initializer routines for dynamically loaded
12749 objects (among other things). */
12750 bs->stop = stop_on_solib_events;
12751 bs->print = stop_on_solib_events;
12752 }
12753 else
12754 bs->stop = 0;
12755 }
12756
12757 static enum print_stop_action
12758 internal_bkpt_print_it (bpstat bs)
12759 {
12760 struct breakpoint *b;
12761
12762 b = bs->breakpoint_at;
12763
12764 switch (b->type)
12765 {
12766 case bp_shlib_event:
12767 /* Did we stop because the user set the stop_on_solib_events
12768 variable? (If so, we report this as a generic, "Stopped due
12769 to shlib event" message.) */
12770 print_solib_event (0);
12771 break;
12772
12773 case bp_thread_event:
12774 /* Not sure how we will get here.
12775 GDB should not stop for these breakpoints. */
12776 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12777 break;
12778
12779 case bp_overlay_event:
12780 /* By analogy with the thread event, GDB should not stop for these. */
12781 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12782 break;
12783
12784 case bp_longjmp_master:
12785 /* These should never be enabled. */
12786 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12787 break;
12788
12789 case bp_std_terminate_master:
12790 /* These should never be enabled. */
12791 printf_filtered (_("std::terminate Master Breakpoint: "
12792 "gdb should not stop!\n"));
12793 break;
12794
12795 case bp_exception_master:
12796 /* These should never be enabled. */
12797 printf_filtered (_("Exception Master Breakpoint: "
12798 "gdb should not stop!\n"));
12799 break;
12800 }
12801
12802 return PRINT_NOTHING;
12803 }
12804
12805 static void
12806 internal_bkpt_print_mention (struct breakpoint *b)
12807 {
12808 /* Nothing to mention. These breakpoints are internal. */
12809 }
12810
12811 /* Virtual table for momentary breakpoints */
12812
12813 static void
12814 momentary_bkpt_re_set (struct breakpoint *b)
12815 {
12816 /* Keep temporary breakpoints, which can be encountered when we step
12817 over a dlopen call and solib_add is resetting the breakpoints.
12818 Otherwise these should have been blown away via the cleanup chain
12819 or by breakpoint_init_inferior when we rerun the executable. */
12820 }
12821
12822 static void
12823 momentary_bkpt_check_status (bpstat bs)
12824 {
12825 /* Nothing. The point of these breakpoints is causing a stop. */
12826 }
12827
12828 static enum print_stop_action
12829 momentary_bkpt_print_it (bpstat bs)
12830 {
12831 return PRINT_UNKNOWN;
12832 }
12833
12834 static void
12835 momentary_bkpt_print_mention (struct breakpoint *b)
12836 {
12837 /* Nothing to mention. These breakpoints are internal. */
12838 }
12839
12840 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12841
12842 It gets cleared already on the removal of the first one of such placed
12843 breakpoints. This is OK as they get all removed altogether. */
12844
12845 longjmp_breakpoint::~longjmp_breakpoint ()
12846 {
12847 thread_info *tp = find_thread_global_id (this->thread);
12848
12849 if (tp != NULL)
12850 tp->initiating_frame = null_frame_id;
12851 }
12852
12853 /* Specific methods for probe breakpoints. */
12854
12855 static int
12856 bkpt_probe_insert_location (struct bp_location *bl)
12857 {
12858 int v = bkpt_insert_location (bl);
12859
12860 if (v == 0)
12861 {
12862 /* The insertion was successful, now let's set the probe's semaphore
12863 if needed. */
12864 bl->probe.prob->set_semaphore (bl->probe.objfile, bl->gdbarch);
12865 }
12866
12867 return v;
12868 }
12869
12870 static int
12871 bkpt_probe_remove_location (struct bp_location *bl,
12872 enum remove_bp_reason reason)
12873 {
12874 /* Let's clear the semaphore before removing the location. */
12875 bl->probe.prob->clear_semaphore (bl->probe.objfile, bl->gdbarch);
12876
12877 return bkpt_remove_location (bl, reason);
12878 }
12879
12880 static void
12881 bkpt_probe_create_sals_from_location (const struct event_location *location,
12882 struct linespec_result *canonical,
12883 enum bptype type_wanted)
12884 {
12885 struct linespec_sals lsal;
12886
12887 lsal.sals = parse_probes (location, NULL, canonical);
12888 lsal.canonical
12889 = xstrdup (event_location_to_string (canonical->location.get ()));
12890 canonical->lsals.push_back (std::move (lsal));
12891 }
12892
12893 static std::vector<symtab_and_line>
12894 bkpt_probe_decode_location (struct breakpoint *b,
12895 const struct event_location *location,
12896 struct program_space *search_pspace)
12897 {
12898 std::vector<symtab_and_line> sals = parse_probes (location, search_pspace, NULL);
12899 if (sals.empty ())
12900 error (_("probe not found"));
12901 return sals;
12902 }
12903
12904 /* The breakpoint_ops structure to be used in tracepoints. */
12905
12906 static void
12907 tracepoint_re_set (struct breakpoint *b)
12908 {
12909 breakpoint_re_set_default (b);
12910 }
12911
12912 static int
12913 tracepoint_breakpoint_hit (const struct bp_location *bl,
12914 const address_space *aspace, CORE_ADDR bp_addr,
12915 const struct target_waitstatus *ws)
12916 {
12917 /* By definition, the inferior does not report stops at
12918 tracepoints. */
12919 return 0;
12920 }
12921
12922 static void
12923 tracepoint_print_one_detail (const struct breakpoint *self,
12924 struct ui_out *uiout)
12925 {
12926 struct tracepoint *tp = (struct tracepoint *) self;
12927 if (tp->static_trace_marker_id)
12928 {
12929 gdb_assert (self->type == bp_static_tracepoint);
12930
12931 uiout->text ("\tmarker id is ");
12932 uiout->field_string ("static-tracepoint-marker-string-id",
12933 tp->static_trace_marker_id);
12934 uiout->text ("\n");
12935 }
12936 }
12937
12938 static void
12939 tracepoint_print_mention (struct breakpoint *b)
12940 {
12941 if (current_uiout->is_mi_like_p ())
12942 return;
12943
12944 switch (b->type)
12945 {
12946 case bp_tracepoint:
12947 printf_filtered (_("Tracepoint"));
12948 printf_filtered (_(" %d"), b->number);
12949 break;
12950 case bp_fast_tracepoint:
12951 printf_filtered (_("Fast tracepoint"));
12952 printf_filtered (_(" %d"), b->number);
12953 break;
12954 case bp_static_tracepoint:
12955 printf_filtered (_("Static tracepoint"));
12956 printf_filtered (_(" %d"), b->number);
12957 break;
12958 default:
12959 internal_error (__FILE__, __LINE__,
12960 _("unhandled tracepoint type %d"), (int) b->type);
12961 }
12962
12963 say_where (b);
12964 }
12965
12966 static void
12967 tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
12968 {
12969 struct tracepoint *tp = (struct tracepoint *) self;
12970
12971 if (self->type == bp_fast_tracepoint)
12972 fprintf_unfiltered (fp, "ftrace");
12973 else if (self->type == bp_static_tracepoint)
12974 fprintf_unfiltered (fp, "strace");
12975 else if (self->type == bp_tracepoint)
12976 fprintf_unfiltered (fp, "trace");
12977 else
12978 internal_error (__FILE__, __LINE__,
12979 _("unhandled tracepoint type %d"), (int) self->type);
12980
12981 fprintf_unfiltered (fp, " %s",
12982 event_location_to_string (self->location.get ()));
12983 print_recreate_thread (self, fp);
12984
12985 if (tp->pass_count)
12986 fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
12987 }
12988
12989 static void
12990 tracepoint_create_sals_from_location (const struct event_location *location,
12991 struct linespec_result *canonical,
12992 enum bptype type_wanted)
12993 {
12994 create_sals_from_location_default (location, canonical, type_wanted);
12995 }
12996
12997 static void
12998 tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12999 struct linespec_result *canonical,
13000 gdb::unique_xmalloc_ptr<char> cond_string,
13001 gdb::unique_xmalloc_ptr<char> extra_string,
13002 enum bptype type_wanted,
13003 enum bpdisp disposition,
13004 int thread,
13005 int task, int ignore_count,
13006 const struct breakpoint_ops *ops,
13007 int from_tty, int enabled,
13008 int internal, unsigned flags)
13009 {
13010 create_breakpoints_sal_default (gdbarch, canonical,
13011 std::move (cond_string),
13012 std::move (extra_string),
13013 type_wanted,
13014 disposition, thread, task,
13015 ignore_count, ops, from_tty,
13016 enabled, internal, flags);
13017 }
13018
13019 static std::vector<symtab_and_line>
13020 tracepoint_decode_location (struct breakpoint *b,
13021 const struct event_location *location,
13022 struct program_space *search_pspace)
13023 {
13024 return decode_location_default (b, location, search_pspace);
13025 }
13026
13027 struct breakpoint_ops tracepoint_breakpoint_ops;
13028
13029 /* The breakpoint_ops structure to be use on tracepoints placed in a
13030 static probe. */
13031
13032 static void
13033 tracepoint_probe_create_sals_from_location
13034 (const struct event_location *location,
13035 struct linespec_result *canonical,
13036 enum bptype type_wanted)
13037 {
13038 /* We use the same method for breakpoint on probes. */
13039 bkpt_probe_create_sals_from_location (location, canonical, type_wanted);
13040 }
13041
13042 static std::vector<symtab_and_line>
13043 tracepoint_probe_decode_location (struct breakpoint *b,
13044 const struct event_location *location,
13045 struct program_space *search_pspace)
13046 {
13047 /* We use the same method for breakpoint on probes. */
13048 return bkpt_probe_decode_location (b, location, search_pspace);
13049 }
13050
13051 static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
13052
13053 /* Dprintf breakpoint_ops methods. */
13054
13055 static void
13056 dprintf_re_set (struct breakpoint *b)
13057 {
13058 breakpoint_re_set_default (b);
13059
13060 /* extra_string should never be non-NULL for dprintf. */
13061 gdb_assert (b->extra_string != NULL);
13062
13063 /* 1 - connect to target 1, that can run breakpoint commands.
13064 2 - create a dprintf, which resolves fine.
13065 3 - disconnect from target 1
13066 4 - connect to target 2, that can NOT run breakpoint commands.
13067
13068 After steps #3/#4, you'll want the dprintf command list to
13069 be updated, because target 1 and 2 may well return different
13070 answers for target_can_run_breakpoint_commands().
13071 Given absence of finer grained resetting, we get to do
13072 it all the time. */
13073 if (b->extra_string != NULL)
13074 update_dprintf_command_list (b);
13075 }
13076
13077 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13078
13079 static void
13080 dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp)
13081 {
13082 fprintf_unfiltered (fp, "dprintf %s,%s",
13083 event_location_to_string (tp->location.get ()),
13084 tp->extra_string);
13085 print_recreate_thread (tp, fp);
13086 }
13087
13088 /* Implement the "after_condition_true" breakpoint_ops method for
13089 dprintf.
13090
13091 dprintf's are implemented with regular commands in their command
13092 list, but we run the commands here instead of before presenting the
13093 stop to the user, as dprintf's don't actually cause a stop. This
13094 also makes it so that the commands of multiple dprintfs at the same
13095 address are all handled. */
13096
13097 static void
13098 dprintf_after_condition_true (struct bpstats *bs)
13099 {
13100 struct bpstats tmp_bs;
13101 struct bpstats *tmp_bs_p = &tmp_bs;
13102
13103 /* dprintf's never cause a stop. This wasn't set in the
13104 check_status hook instead because that would make the dprintf's
13105 condition not be evaluated. */
13106 bs->stop = 0;
13107
13108 /* Run the command list here. Take ownership of it instead of
13109 copying. We never want these commands to run later in
13110 bpstat_do_actions, if a breakpoint that causes a stop happens to
13111 be set at same address as this dprintf, or even if running the
13112 commands here throws. */
13113 tmp_bs.commands = bs->commands;
13114 bs->commands = NULL;
13115
13116 bpstat_do_actions_1 (&tmp_bs_p);
13117
13118 /* 'tmp_bs.commands' will usually be NULL by now, but
13119 bpstat_do_actions_1 may return early without processing the whole
13120 list. */
13121 }
13122
13123 /* The breakpoint_ops structure to be used on static tracepoints with
13124 markers (`-m'). */
13125
13126 static void
13127 strace_marker_create_sals_from_location (const struct event_location *location,
13128 struct linespec_result *canonical,
13129 enum bptype type_wanted)
13130 {
13131 struct linespec_sals lsal;
13132 const char *arg_start, *arg;
13133
13134 arg = arg_start = get_linespec_location (location)->spec_string;
13135 lsal.sals = decode_static_tracepoint_spec (&arg);
13136
13137 std::string str (arg_start, arg - arg_start);
13138 const char *ptr = str.c_str ();
13139 canonical->location
13140 = new_linespec_location (&ptr, symbol_name_match_type::FULL);
13141
13142 lsal.canonical
13143 = xstrdup (event_location_to_string (canonical->location.get ()));
13144 canonical->lsals.push_back (std::move (lsal));
13145 }
13146
13147 static void
13148 strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
13149 struct linespec_result *canonical,
13150 gdb::unique_xmalloc_ptr<char> cond_string,
13151 gdb::unique_xmalloc_ptr<char> extra_string,
13152 enum bptype type_wanted,
13153 enum bpdisp disposition,
13154 int thread,
13155 int task, int ignore_count,
13156 const struct breakpoint_ops *ops,
13157 int from_tty, int enabled,
13158 int internal, unsigned flags)
13159 {
13160 const linespec_sals &lsal = canonical->lsals[0];
13161
13162 /* If the user is creating a static tracepoint by marker id
13163 (strace -m MARKER_ID), then store the sals index, so that
13164 breakpoint_re_set can try to match up which of the newly
13165 found markers corresponds to this one, and, don't try to
13166 expand multiple locations for each sal, given than SALS
13167 already should contain all sals for MARKER_ID. */
13168
13169 for (size_t i = 0; i < lsal.sals.size (); i++)
13170 {
13171 event_location_up location
13172 = copy_event_location (canonical->location.get ());
13173
13174 std::unique_ptr<tracepoint> tp (new tracepoint ());
13175 init_breakpoint_sal (tp.get (), gdbarch, lsal.sals[i],
13176 std::move (location), NULL,
13177 std::move (cond_string),
13178 std::move (extra_string),
13179 type_wanted, disposition,
13180 thread, task, ignore_count, ops,
13181 from_tty, enabled, internal, flags,
13182 canonical->special_display);
13183 /* Given that its possible to have multiple markers with
13184 the same string id, if the user is creating a static
13185 tracepoint by marker id ("strace -m MARKER_ID"), then
13186 store the sals index, so that breakpoint_re_set can
13187 try to match up which of the newly found markers
13188 corresponds to this one */
13189 tp->static_trace_marker_id_idx = i;
13190
13191 install_breakpoint (internal, std::move (tp), 0);
13192 }
13193 }
13194
13195 static std::vector<symtab_and_line>
13196 strace_marker_decode_location (struct breakpoint *b,
13197 const struct event_location *location,
13198 struct program_space *search_pspace)
13199 {
13200 struct tracepoint *tp = (struct tracepoint *) b;
13201 const char *s = get_linespec_location (location)->spec_string;
13202
13203 std::vector<symtab_and_line> sals = decode_static_tracepoint_spec (&s);
13204 if (sals.size () > tp->static_trace_marker_id_idx)
13205 {
13206 sals[0] = sals[tp->static_trace_marker_id_idx];
13207 sals.resize (1);
13208 return sals;
13209 }
13210 else
13211 error (_("marker %s not found"), tp->static_trace_marker_id);
13212 }
13213
13214 static struct breakpoint_ops strace_marker_breakpoint_ops;
13215
13216 static int
13217 strace_marker_p (struct breakpoint *b)
13218 {
13219 return b->ops == &strace_marker_breakpoint_ops;
13220 }
13221
13222 /* Delete a breakpoint and clean up all traces of it in the data
13223 structures. */
13224
13225 void
13226 delete_breakpoint (struct breakpoint *bpt)
13227 {
13228 struct breakpoint *b;
13229
13230 gdb_assert (bpt != NULL);
13231
13232 /* Has this bp already been deleted? This can happen because
13233 multiple lists can hold pointers to bp's. bpstat lists are
13234 especial culprits.
13235
13236 One example of this happening is a watchpoint's scope bp. When
13237 the scope bp triggers, we notice that the watchpoint is out of
13238 scope, and delete it. We also delete its scope bp. But the
13239 scope bp is marked "auto-deleting", and is already on a bpstat.
13240 That bpstat is then checked for auto-deleting bp's, which are
13241 deleted.
13242
13243 A real solution to this problem might involve reference counts in
13244 bp's, and/or giving them pointers back to their referencing
13245 bpstat's, and teaching delete_breakpoint to only free a bp's
13246 storage when no more references were extent. A cheaper bandaid
13247 was chosen. */
13248 if (bpt->type == bp_none)
13249 return;
13250
13251 /* At least avoid this stale reference until the reference counting
13252 of breakpoints gets resolved. */
13253 if (bpt->related_breakpoint != bpt)
13254 {
13255 struct breakpoint *related;
13256 struct watchpoint *w;
13257
13258 if (bpt->type == bp_watchpoint_scope)
13259 w = (struct watchpoint *) bpt->related_breakpoint;
13260 else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
13261 w = (struct watchpoint *) bpt;
13262 else
13263 w = NULL;
13264 if (w != NULL)
13265 watchpoint_del_at_next_stop (w);
13266
13267 /* Unlink bpt from the bpt->related_breakpoint ring. */
13268 for (related = bpt; related->related_breakpoint != bpt;
13269 related = related->related_breakpoint);
13270 related->related_breakpoint = bpt->related_breakpoint;
13271 bpt->related_breakpoint = bpt;
13272 }
13273
13274 /* watch_command_1 creates a watchpoint but only sets its number if
13275 update_watchpoint succeeds in creating its bp_locations. If there's
13276 a problem in that process, we'll be asked to delete the half-created
13277 watchpoint. In that case, don't announce the deletion. */
13278 if (bpt->number)
13279 observer_notify_breakpoint_deleted (bpt);
13280
13281 if (breakpoint_chain == bpt)
13282 breakpoint_chain = bpt->next;
13283
13284 ALL_BREAKPOINTS (b)
13285 if (b->next == bpt)
13286 {
13287 b->next = bpt->next;
13288 break;
13289 }
13290
13291 /* Be sure no bpstat's are pointing at the breakpoint after it's
13292 been freed. */
13293 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13294 in all threads for now. Note that we cannot just remove bpstats
13295 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13296 commands are associated with the bpstat; if we remove it here,
13297 then the later call to bpstat_do_actions (&stop_bpstat); in
13298 event-top.c won't do anything, and temporary breakpoints with
13299 commands won't work. */
13300
13301 iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13302
13303 /* Now that breakpoint is removed from breakpoint list, update the
13304 global location list. This will remove locations that used to
13305 belong to this breakpoint. Do this before freeing the breakpoint
13306 itself, since remove_breakpoint looks at location's owner. It
13307 might be better design to have location completely
13308 self-contained, but it's not the case now. */
13309 update_global_location_list (UGLL_DONT_INSERT);
13310
13311 /* On the chance that someone will soon try again to delete this
13312 same bp, we mark it as deleted before freeing its storage. */
13313 bpt->type = bp_none;
13314 delete bpt;
13315 }
13316
13317 /* Iterator function to call a user-provided callback function once
13318 for each of B and its related breakpoints. */
13319
13320 static void
13321 iterate_over_related_breakpoints (struct breakpoint *b,
13322 gdb::function_view<void (breakpoint *)> function)
13323 {
13324 struct breakpoint *related;
13325
13326 related = b;
13327 do
13328 {
13329 struct breakpoint *next;
13330
13331 /* FUNCTION may delete RELATED. */
13332 next = related->related_breakpoint;
13333
13334 if (next == related)
13335 {
13336 /* RELATED is the last ring entry. */
13337 function (related);
13338
13339 /* FUNCTION may have deleted it, so we'd never reach back to
13340 B. There's nothing left to do anyway, so just break
13341 out. */
13342 break;
13343 }
13344 else
13345 function (related);
13346
13347 related = next;
13348 }
13349 while (related != b);
13350 }
13351
13352 static void
13353 delete_command (const char *arg, int from_tty)
13354 {
13355 struct breakpoint *b, *b_tmp;
13356
13357 dont_repeat ();
13358
13359 if (arg == 0)
13360 {
13361 int breaks_to_delete = 0;
13362
13363 /* Delete all breakpoints if no argument. Do not delete
13364 internal breakpoints, these have to be deleted with an
13365 explicit breakpoint number argument. */
13366 ALL_BREAKPOINTS (b)
13367 if (user_breakpoint_p (b))
13368 {
13369 breaks_to_delete = 1;
13370 break;
13371 }
13372
13373 /* Ask user only if there are some breakpoints to delete. */
13374 if (!from_tty
13375 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
13376 {
13377 ALL_BREAKPOINTS_SAFE (b, b_tmp)
13378 if (user_breakpoint_p (b))
13379 delete_breakpoint (b);
13380 }
13381 }
13382 else
13383 map_breakpoint_numbers
13384 (arg, [&] (breakpoint *b)
13385 {
13386 iterate_over_related_breakpoints (b, delete_breakpoint);
13387 });
13388 }
13389
13390 /* Return true if all locations of B bound to PSPACE are pending. If
13391 PSPACE is NULL, all locations of all program spaces are
13392 considered. */
13393
13394 static int
13395 all_locations_are_pending (struct breakpoint *b, struct program_space *pspace)
13396 {
13397 struct bp_location *loc;
13398
13399 for (loc = b->loc; loc != NULL; loc = loc->next)
13400 if ((pspace == NULL
13401 || loc->pspace == pspace)
13402 && !loc->shlib_disabled
13403 && !loc->pspace->executing_startup)
13404 return 0;
13405 return 1;
13406 }
13407
13408 /* Subroutine of update_breakpoint_locations to simplify it.
13409 Return non-zero if multiple fns in list LOC have the same name.
13410 Null names are ignored. */
13411
13412 static int
13413 ambiguous_names_p (struct bp_location *loc)
13414 {
13415 struct bp_location *l;
13416 htab_t htab = htab_create_alloc (13, htab_hash_string,
13417 (int (*) (const void *,
13418 const void *)) streq,
13419 NULL, xcalloc, xfree);
13420
13421 for (l = loc; l != NULL; l = l->next)
13422 {
13423 const char **slot;
13424 const char *name = l->function_name;
13425
13426 /* Allow for some names to be NULL, ignore them. */
13427 if (name == NULL)
13428 continue;
13429
13430 slot = (const char **) htab_find_slot (htab, (const void *) name,
13431 INSERT);
13432 /* NOTE: We can assume slot != NULL here because xcalloc never
13433 returns NULL. */
13434 if (*slot != NULL)
13435 {
13436 htab_delete (htab);
13437 return 1;
13438 }
13439 *slot = name;
13440 }
13441
13442 htab_delete (htab);
13443 return 0;
13444 }
13445
13446 /* When symbols change, it probably means the sources changed as well,
13447 and it might mean the static tracepoint markers are no longer at
13448 the same address or line numbers they used to be at last we
13449 checked. Losing your static tracepoints whenever you rebuild is
13450 undesirable. This function tries to resync/rematch gdb static
13451 tracepoints with the markers on the target, for static tracepoints
13452 that have not been set by marker id. Static tracepoint that have
13453 been set by marker id are reset by marker id in breakpoint_re_set.
13454 The heuristic is:
13455
13456 1) For a tracepoint set at a specific address, look for a marker at
13457 the old PC. If one is found there, assume to be the same marker.
13458 If the name / string id of the marker found is different from the
13459 previous known name, assume that means the user renamed the marker
13460 in the sources, and output a warning.
13461
13462 2) For a tracepoint set at a given line number, look for a marker
13463 at the new address of the old line number. If one is found there,
13464 assume to be the same marker. If the name / string id of the
13465 marker found is different from the previous known name, assume that
13466 means the user renamed the marker in the sources, and output a
13467 warning.
13468
13469 3) If a marker is no longer found at the same address or line, it
13470 may mean the marker no longer exists. But it may also just mean
13471 the code changed a bit. Maybe the user added a few lines of code
13472 that made the marker move up or down (in line number terms). Ask
13473 the target for info about the marker with the string id as we knew
13474 it. If found, update line number and address in the matching
13475 static tracepoint. This will get confused if there's more than one
13476 marker with the same ID (possible in UST, although unadvised
13477 precisely because it confuses tools). */
13478
13479 static struct symtab_and_line
13480 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
13481 {
13482 struct tracepoint *tp = (struct tracepoint *) b;
13483 struct static_tracepoint_marker marker;
13484 CORE_ADDR pc;
13485
13486 pc = sal.pc;
13487 if (sal.line)
13488 find_line_pc (sal.symtab, sal.line, &pc);
13489
13490 if (target_static_tracepoint_marker_at (pc, &marker))
13491 {
13492 if (strcmp (tp->static_trace_marker_id, marker.str_id) != 0)
13493 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13494 b->number,
13495 tp->static_trace_marker_id, marker.str_id);
13496
13497 xfree (tp->static_trace_marker_id);
13498 tp->static_trace_marker_id = xstrdup (marker.str_id);
13499 release_static_tracepoint_marker (&marker);
13500
13501 return sal;
13502 }
13503
13504 /* Old marker wasn't found on target at lineno. Try looking it up
13505 by string ID. */
13506 if (!sal.explicit_pc
13507 && sal.line != 0
13508 && sal.symtab != NULL
13509 && tp->static_trace_marker_id != NULL)
13510 {
13511 VEC(static_tracepoint_marker_p) *markers;
13512
13513 markers
13514 = target_static_tracepoint_markers_by_strid (tp->static_trace_marker_id);
13515
13516 if (!VEC_empty(static_tracepoint_marker_p, markers))
13517 {
13518 struct symbol *sym;
13519 struct static_tracepoint_marker *tpmarker;
13520 struct ui_out *uiout = current_uiout;
13521 struct explicit_location explicit_loc;
13522
13523 tpmarker = VEC_index (static_tracepoint_marker_p, markers, 0);
13524
13525 xfree (tp->static_trace_marker_id);
13526 tp->static_trace_marker_id = xstrdup (tpmarker->str_id);
13527
13528 warning (_("marker for static tracepoint %d (%s) not "
13529 "found at previous line number"),
13530 b->number, tp->static_trace_marker_id);
13531
13532 symtab_and_line sal2 = find_pc_line (tpmarker->address, 0);
13533 sym = find_pc_sect_function (tpmarker->address, NULL);
13534 uiout->text ("Now in ");
13535 if (sym)
13536 {
13537 uiout->field_string ("func", SYMBOL_PRINT_NAME (sym));
13538 uiout->text (" at ");
13539 }
13540 uiout->field_string ("file",
13541 symtab_to_filename_for_display (sal2.symtab));
13542 uiout->text (":");
13543
13544 if (uiout->is_mi_like_p ())
13545 {
13546 const char *fullname = symtab_to_fullname (sal2.symtab);
13547
13548 uiout->field_string ("fullname", fullname);
13549 }
13550
13551 uiout->field_int ("line", sal2.line);
13552 uiout->text ("\n");
13553
13554 b->loc->line_number = sal2.line;
13555 b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
13556
13557 b->location.reset (NULL);
13558 initialize_explicit_location (&explicit_loc);
13559 explicit_loc.source_filename
13560 = ASTRDUP (symtab_to_filename_for_display (sal2.symtab));
13561 explicit_loc.line_offset.offset = b->loc->line_number;
13562 explicit_loc.line_offset.sign = LINE_OFFSET_NONE;
13563 b->location = new_explicit_location (&explicit_loc);
13564
13565 /* Might be nice to check if function changed, and warn if
13566 so. */
13567
13568 release_static_tracepoint_marker (tpmarker);
13569 }
13570 }
13571 return sal;
13572 }
13573
13574 /* Returns 1 iff locations A and B are sufficiently same that
13575 we don't need to report breakpoint as changed. */
13576
13577 static int
13578 locations_are_equal (struct bp_location *a, struct bp_location *b)
13579 {
13580 while (a && b)
13581 {
13582 if (a->address != b->address)
13583 return 0;
13584
13585 if (a->shlib_disabled != b->shlib_disabled)
13586 return 0;
13587
13588 if (a->enabled != b->enabled)
13589 return 0;
13590
13591 a = a->next;
13592 b = b->next;
13593 }
13594
13595 if ((a == NULL) != (b == NULL))
13596 return 0;
13597
13598 return 1;
13599 }
13600
13601 /* Split all locations of B that are bound to PSPACE out of B's
13602 location list to a separate list and return that list's head. If
13603 PSPACE is NULL, hoist out all locations of B. */
13604
13605 static struct bp_location *
13606 hoist_existing_locations (struct breakpoint *b, struct program_space *pspace)
13607 {
13608 struct bp_location head;
13609 struct bp_location *i = b->loc;
13610 struct bp_location **i_link = &b->loc;
13611 struct bp_location *hoisted = &head;
13612
13613 if (pspace == NULL)
13614 {
13615 i = b->loc;
13616 b->loc = NULL;
13617 return i;
13618 }
13619
13620 head.next = NULL;
13621
13622 while (i != NULL)
13623 {
13624 if (i->pspace == pspace)
13625 {
13626 *i_link = i->next;
13627 i->next = NULL;
13628 hoisted->next = i;
13629 hoisted = i;
13630 }
13631 else
13632 i_link = &i->next;
13633 i = *i_link;
13634 }
13635
13636 return head.next;
13637 }
13638
13639 /* Create new breakpoint locations for B (a hardware or software
13640 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13641 zero, then B is a ranged breakpoint. Only recreates locations for
13642 FILTER_PSPACE. Locations of other program spaces are left
13643 untouched. */
13644
13645 void
13646 update_breakpoint_locations (struct breakpoint *b,
13647 struct program_space *filter_pspace,
13648 gdb::array_view<const symtab_and_line> sals,
13649 gdb::array_view<const symtab_and_line> sals_end)
13650 {
13651 struct bp_location *existing_locations;
13652
13653 if (!sals_end.empty () && (sals.size () != 1 || sals_end.size () != 1))
13654 {
13655 /* Ranged breakpoints have only one start location and one end
13656 location. */
13657 b->enable_state = bp_disabled;
13658 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13659 "multiple locations found\n"),
13660 b->number);
13661 return;
13662 }
13663
13664 /* If there's no new locations, and all existing locations are
13665 pending, don't do anything. This optimizes the common case where
13666 all locations are in the same shared library, that was unloaded.
13667 We'd like to retain the location, so that when the library is
13668 loaded again, we don't loose the enabled/disabled status of the
13669 individual locations. */
13670 if (all_locations_are_pending (b, filter_pspace) && sals.empty ())
13671 return;
13672
13673 existing_locations = hoist_existing_locations (b, filter_pspace);
13674
13675 for (const auto &sal : sals)
13676 {
13677 struct bp_location *new_loc;
13678
13679 switch_to_program_space_and_thread (sal.pspace);
13680
13681 new_loc = add_location_to_breakpoint (b, &sal);
13682
13683 /* Reparse conditions, they might contain references to the
13684 old symtab. */
13685 if (b->cond_string != NULL)
13686 {
13687 const char *s;
13688
13689 s = b->cond_string;
13690 TRY
13691 {
13692 new_loc->cond = parse_exp_1 (&s, sal.pc,
13693 block_for_pc (sal.pc),
13694 0);
13695 }
13696 CATCH (e, RETURN_MASK_ERROR)
13697 {
13698 warning (_("failed to reevaluate condition "
13699 "for breakpoint %d: %s"),
13700 b->number, e.message);
13701 new_loc->enabled = 0;
13702 }
13703 END_CATCH
13704 }
13705
13706 if (!sals_end.empty ())
13707 {
13708 CORE_ADDR end = find_breakpoint_range_end (sals_end[0]);
13709
13710 new_loc->length = end - sals[0].pc + 1;
13711 }
13712 }
13713
13714 /* If possible, carry over 'disable' status from existing
13715 breakpoints. */
13716 {
13717 struct bp_location *e = existing_locations;
13718 /* If there are multiple breakpoints with the same function name,
13719 e.g. for inline functions, comparing function names won't work.
13720 Instead compare pc addresses; this is just a heuristic as things
13721 may have moved, but in practice it gives the correct answer
13722 often enough until a better solution is found. */
13723 int have_ambiguous_names = ambiguous_names_p (b->loc);
13724
13725 for (; e; e = e->next)
13726 {
13727 if (!e->enabled && e->function_name)
13728 {
13729 struct bp_location *l = b->loc;
13730 if (have_ambiguous_names)
13731 {
13732 for (; l; l = l->next)
13733 if (breakpoint_locations_match (e, l))
13734 {
13735 l->enabled = 0;
13736 break;
13737 }
13738 }
13739 else
13740 {
13741 for (; l; l = l->next)
13742 if (l->function_name
13743 && strcmp (e->function_name, l->function_name) == 0)
13744 {
13745 l->enabled = 0;
13746 break;
13747 }
13748 }
13749 }
13750 }
13751 }
13752
13753 if (!locations_are_equal (existing_locations, b->loc))
13754 observer_notify_breakpoint_modified (b);
13755 }
13756
13757 /* Find the SaL locations corresponding to the given LOCATION.
13758 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13759
13760 static std::vector<symtab_and_line>
13761 location_to_sals (struct breakpoint *b, struct event_location *location,
13762 struct program_space *search_pspace, int *found)
13763 {
13764 struct gdb_exception exception = exception_none;
13765
13766 gdb_assert (b->ops != NULL);
13767
13768 std::vector<symtab_and_line> sals;
13769
13770 TRY
13771 {
13772 sals = b->ops->decode_location (b, location, search_pspace);
13773 }
13774 CATCH (e, RETURN_MASK_ERROR)
13775 {
13776 int not_found_and_ok = 0;
13777
13778 exception = e;
13779
13780 /* For pending breakpoints, it's expected that parsing will
13781 fail until the right shared library is loaded. User has
13782 already told to create pending breakpoints and don't need
13783 extra messages. If breakpoint is in bp_shlib_disabled
13784 state, then user already saw the message about that
13785 breakpoint being disabled, and don't want to see more
13786 errors. */
13787 if (e.error == NOT_FOUND_ERROR
13788 && (b->condition_not_parsed
13789 || (b->loc != NULL
13790 && search_pspace != NULL
13791 && b->loc->pspace != search_pspace)
13792 || (b->loc && b->loc->shlib_disabled)
13793 || (b->loc && b->loc->pspace->executing_startup)
13794 || b->enable_state == bp_disabled))
13795 not_found_and_ok = 1;
13796
13797 if (!not_found_and_ok)
13798 {
13799 /* We surely don't want to warn about the same breakpoint
13800 10 times. One solution, implemented here, is disable
13801 the breakpoint on error. Another solution would be to
13802 have separate 'warning emitted' flag. Since this
13803 happens only when a binary has changed, I don't know
13804 which approach is better. */
13805 b->enable_state = bp_disabled;
13806 throw_exception (e);
13807 }
13808 }
13809 END_CATCH
13810
13811 if (exception.reason == 0 || exception.error != NOT_FOUND_ERROR)
13812 {
13813 for (auto &sal : sals)
13814 resolve_sal_pc (&sal);
13815 if (b->condition_not_parsed && b->extra_string != NULL)
13816 {
13817 char *cond_string, *extra_string;
13818 int thread, task;
13819
13820 find_condition_and_thread (b->extra_string, sals[0].pc,
13821 &cond_string, &thread, &task,
13822 &extra_string);
13823 gdb_assert (b->cond_string == NULL);
13824 if (cond_string)
13825 b->cond_string = cond_string;
13826 b->thread = thread;
13827 b->task = task;
13828 if (extra_string)
13829 {
13830 xfree (b->extra_string);
13831 b->extra_string = extra_string;
13832 }
13833 b->condition_not_parsed = 0;
13834 }
13835
13836 if (b->type == bp_static_tracepoint && !strace_marker_p (b))
13837 sals[0] = update_static_tracepoint (b, sals[0]);
13838
13839 *found = 1;
13840 }
13841 else
13842 *found = 0;
13843
13844 return sals;
13845 }
13846
13847 /* The default re_set method, for typical hardware or software
13848 breakpoints. Reevaluate the breakpoint and recreate its
13849 locations. */
13850
13851 static void
13852 breakpoint_re_set_default (struct breakpoint *b)
13853 {
13854 struct program_space *filter_pspace = current_program_space;
13855 std::vector<symtab_and_line> expanded, expanded_end;
13856
13857 int found;
13858 std::vector<symtab_and_line> sals = location_to_sals (b, b->location.get (),
13859 filter_pspace, &found);
13860 if (found)
13861 expanded = std::move (sals);
13862
13863 if (b->location_range_end != NULL)
13864 {
13865 std::vector<symtab_and_line> sals_end
13866 = location_to_sals (b, b->location_range_end.get (),
13867 filter_pspace, &found);
13868 if (found)
13869 expanded_end = std::move (sals_end);
13870 }
13871
13872 update_breakpoint_locations (b, filter_pspace, expanded, expanded_end);
13873 }
13874
13875 /* Default method for creating SALs from an address string. It basically
13876 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
13877
13878 static void
13879 create_sals_from_location_default (const struct event_location *location,
13880 struct linespec_result *canonical,
13881 enum bptype type_wanted)
13882 {
13883 parse_breakpoint_sals (location, canonical);
13884 }
13885
13886 /* Call create_breakpoints_sal for the given arguments. This is the default
13887 function for the `create_breakpoints_sal' method of
13888 breakpoint_ops. */
13889
13890 static void
13891 create_breakpoints_sal_default (struct gdbarch *gdbarch,
13892 struct linespec_result *canonical,
13893 gdb::unique_xmalloc_ptr<char> cond_string,
13894 gdb::unique_xmalloc_ptr<char> extra_string,
13895 enum bptype type_wanted,
13896 enum bpdisp disposition,
13897 int thread,
13898 int task, int ignore_count,
13899 const struct breakpoint_ops *ops,
13900 int from_tty, int enabled,
13901 int internal, unsigned flags)
13902 {
13903 create_breakpoints_sal (gdbarch, canonical,
13904 std::move (cond_string),
13905 std::move (extra_string),
13906 type_wanted, disposition,
13907 thread, task, ignore_count, ops, from_tty,
13908 enabled, internal, flags);
13909 }
13910
13911 /* Decode the line represented by S by calling decode_line_full. This is the
13912 default function for the `decode_location' method of breakpoint_ops. */
13913
13914 static std::vector<symtab_and_line>
13915 decode_location_default (struct breakpoint *b,
13916 const struct event_location *location,
13917 struct program_space *search_pspace)
13918 {
13919 struct linespec_result canonical;
13920
13921 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, search_pspace,
13922 (struct symtab *) NULL, 0,
13923 &canonical, multiple_symbols_all,
13924 b->filter);
13925
13926 /* We should get 0 or 1 resulting SALs. */
13927 gdb_assert (canonical.lsals.size () < 2);
13928
13929 if (!canonical.lsals.empty ())
13930 {
13931 const linespec_sals &lsal = canonical.lsals[0];
13932 return std::move (lsal.sals);
13933 }
13934 return {};
13935 }
13936
13937 /* Reset a breakpoint. */
13938
13939 static void
13940 breakpoint_re_set_one (breakpoint *b)
13941 {
13942 input_radix = b->input_radix;
13943 set_language (b->language);
13944
13945 b->ops->re_set (b);
13946 }
13947
13948 /* Re-set breakpoint locations for the current program space.
13949 Locations bound to other program spaces are left untouched. */
13950
13951 void
13952 breakpoint_re_set (void)
13953 {
13954 struct breakpoint *b, *b_tmp;
13955
13956 {
13957 scoped_restore_current_language save_language;
13958 scoped_restore save_input_radix = make_scoped_restore (&input_radix);
13959 scoped_restore_current_pspace_and_thread restore_pspace_thread;
13960
13961 /* Note: we must not try to insert locations until after all
13962 breakpoints have been re-set. Otherwise, e.g., when re-setting
13963 breakpoint 1, we'd insert the locations of breakpoint 2, which
13964 hadn't been re-set yet, and thus may have stale locations. */
13965
13966 ALL_BREAKPOINTS_SAFE (b, b_tmp)
13967 {
13968 TRY
13969 {
13970 breakpoint_re_set_one (b);
13971 }
13972 CATCH (ex, RETURN_MASK_ALL)
13973 {
13974 exception_fprintf (gdb_stderr, ex,
13975 "Error in re-setting breakpoint %d: ",
13976 b->number);
13977 }
13978 END_CATCH
13979 }
13980
13981 jit_breakpoint_re_set ();
13982 }
13983
13984 create_overlay_event_breakpoint ();
13985 create_longjmp_master_breakpoint ();
13986 create_std_terminate_master_breakpoint ();
13987 create_exception_master_breakpoint ();
13988
13989 /* Now we can insert. */
13990 update_global_location_list (UGLL_MAY_INSERT);
13991 }
13992
13993 /* Reset the thread number of this breakpoint:
13994
13995 - If the breakpoint is for all threads, leave it as-is.
13996 - Else, reset it to the current thread for inferior_ptid. */
13997 void
13998 breakpoint_re_set_thread (struct breakpoint *b)
13999 {
14000 if (b->thread != -1)
14001 {
14002 if (in_thread_list (inferior_ptid))
14003 b->thread = ptid_to_global_thread_id (inferior_ptid);
14004
14005 /* We're being called after following a fork. The new fork is
14006 selected as current, and unless this was a vfork will have a
14007 different program space from the original thread. Reset that
14008 as well. */
14009 b->loc->pspace = current_program_space;
14010 }
14011 }
14012
14013 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14014 If from_tty is nonzero, it prints a message to that effect,
14015 which ends with a period (no newline). */
14016
14017 void
14018 set_ignore_count (int bptnum, int count, int from_tty)
14019 {
14020 struct breakpoint *b;
14021
14022 if (count < 0)
14023 count = 0;
14024
14025 ALL_BREAKPOINTS (b)
14026 if (b->number == bptnum)
14027 {
14028 if (is_tracepoint (b))
14029 {
14030 if (from_tty && count != 0)
14031 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14032 bptnum);
14033 return;
14034 }
14035
14036 b->ignore_count = count;
14037 if (from_tty)
14038 {
14039 if (count == 0)
14040 printf_filtered (_("Will stop next time "
14041 "breakpoint %d is reached."),
14042 bptnum);
14043 else if (count == 1)
14044 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14045 bptnum);
14046 else
14047 printf_filtered (_("Will ignore next %d "
14048 "crossings of breakpoint %d."),
14049 count, bptnum);
14050 }
14051 observer_notify_breakpoint_modified (b);
14052 return;
14053 }
14054
14055 error (_("No breakpoint number %d."), bptnum);
14056 }
14057
14058 /* Command to set ignore-count of breakpoint N to COUNT. */
14059
14060 static void
14061 ignore_command (const char *args, int from_tty)
14062 {
14063 const char *p = args;
14064 int num;
14065
14066 if (p == 0)
14067 error_no_arg (_("a breakpoint number"));
14068
14069 num = get_number (&p);
14070 if (num == 0)
14071 error (_("bad breakpoint number: '%s'"), args);
14072 if (*p == 0)
14073 error (_("Second argument (specified ignore-count) is missing."));
14074
14075 set_ignore_count (num,
14076 longest_to_int (value_as_long (parse_and_eval (p))),
14077 from_tty);
14078 if (from_tty)
14079 printf_filtered ("\n");
14080 }
14081
14082
14083 /* Call FUNCTION on each of the breakpoints with numbers in the range
14084 defined by BP_NUM_RANGE (an inclusive range). */
14085
14086 static void
14087 map_breakpoint_number_range (std::pair<int, int> bp_num_range,
14088 gdb::function_view<void (breakpoint *)> function)
14089 {
14090 if (bp_num_range.first == 0)
14091 {
14092 warning (_("bad breakpoint number at or near '%d'"),
14093 bp_num_range.first);
14094 }
14095 else
14096 {
14097 struct breakpoint *b, *tmp;
14098
14099 for (int i = bp_num_range.first; i <= bp_num_range.second; i++)
14100 {
14101 bool match = false;
14102
14103 ALL_BREAKPOINTS_SAFE (b, tmp)
14104 if (b->number == i)
14105 {
14106 match = true;
14107 function (b);
14108 break;
14109 }
14110 if (!match)
14111 printf_unfiltered (_("No breakpoint number %d.\n"), i);
14112 }
14113 }
14114 }
14115
14116 /* Call FUNCTION on each of the breakpoints whose numbers are given in
14117 ARGS. */
14118
14119 static void
14120 map_breakpoint_numbers (const char *args,
14121 gdb::function_view<void (breakpoint *)> function)
14122 {
14123 if (args == NULL || *args == '\0')
14124 error_no_arg (_("one or more breakpoint numbers"));
14125
14126 number_or_range_parser parser (args);
14127
14128 while (!parser.finished ())
14129 {
14130 int num = parser.get_number ();
14131 map_breakpoint_number_range (std::make_pair (num, num), function);
14132 }
14133 }
14134
14135 /* Return the breakpoint location structure corresponding to the
14136 BP_NUM and LOC_NUM values. */
14137
14138 static struct bp_location *
14139 find_location_by_number (int bp_num, int loc_num)
14140 {
14141 struct breakpoint *b;
14142
14143 ALL_BREAKPOINTS (b)
14144 if (b->number == bp_num)
14145 {
14146 break;
14147 }
14148
14149 if (!b || b->number != bp_num)
14150 error (_("Bad breakpoint number '%d'"), bp_num);
14151
14152 if (loc_num == 0)
14153 error (_("Bad breakpoint location number '%d'"), loc_num);
14154
14155 int n = 0;
14156 for (bp_location *loc = b->loc; loc != NULL; loc = loc->next)
14157 if (++n == loc_num)
14158 return loc;
14159
14160 error (_("Bad breakpoint location number '%d'"), loc_num);
14161 }
14162
14163 /* Modes of operation for extract_bp_num. */
14164 enum class extract_bp_kind
14165 {
14166 /* Extracting a breakpoint number. */
14167 bp,
14168
14169 /* Extracting a location number. */
14170 loc,
14171 };
14172
14173 /* Extract a breakpoint or location number (as determined by KIND)
14174 from the string starting at START. TRAILER is a character which
14175 can be found after the number. If you don't want a trailer, use
14176 '\0'. If END_OUT is not NULL, it is set to point after the parsed
14177 string. This always returns a positive integer. */
14178
14179 static int
14180 extract_bp_num (extract_bp_kind kind, const char *start,
14181 int trailer, const char **end_out = NULL)
14182 {
14183 const char *end = start;
14184 int num = get_number_trailer (&end, trailer);
14185 if (num < 0)
14186 error (kind == extract_bp_kind::bp
14187 ? _("Negative breakpoint number '%.*s'")
14188 : _("Negative breakpoint location number '%.*s'"),
14189 int (end - start), start);
14190 if (num == 0)
14191 error (kind == extract_bp_kind::bp
14192 ? _("Bad breakpoint number '%.*s'")
14193 : _("Bad breakpoint location number '%.*s'"),
14194 int (end - start), start);
14195
14196 if (end_out != NULL)
14197 *end_out = end;
14198 return num;
14199 }
14200
14201 /* Extract a breakpoint or location range (as determined by KIND) in
14202 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
14203 representing the (inclusive) range. The returned pair's elements
14204 are always positive integers. */
14205
14206 static std::pair<int, int>
14207 extract_bp_or_bp_range (extract_bp_kind kind,
14208 const std::string &arg,
14209 std::string::size_type arg_offset)
14210 {
14211 std::pair<int, int> range;
14212 const char *bp_loc = &arg[arg_offset];
14213 std::string::size_type dash = arg.find ('-', arg_offset);
14214 if (dash != std::string::npos)
14215 {
14216 /* bp_loc is a range (x-z). */
14217 if (arg.length () == dash + 1)
14218 error (kind == extract_bp_kind::bp
14219 ? _("Bad breakpoint number at or near: '%s'")
14220 : _("Bad breakpoint location number at or near: '%s'"),
14221 bp_loc);
14222
14223 const char *end;
14224 const char *start_first = bp_loc;
14225 const char *start_second = &arg[dash + 1];
14226 range.first = extract_bp_num (kind, start_first, '-');
14227 range.second = extract_bp_num (kind, start_second, '\0', &end);
14228
14229 if (range.first > range.second)
14230 error (kind == extract_bp_kind::bp
14231 ? _("Inverted breakpoint range at '%.*s'")
14232 : _("Inverted breakpoint location range at '%.*s'"),
14233 int (end - start_first), start_first);
14234 }
14235 else
14236 {
14237 /* bp_loc is a single value. */
14238 range.first = extract_bp_num (kind, bp_loc, '\0');
14239 range.second = range.first;
14240 }
14241 return range;
14242 }
14243
14244 /* Extract the breakpoint/location range specified by ARG. Returns
14245 the breakpoint range in BP_NUM_RANGE, and the location range in
14246 BP_LOC_RANGE.
14247
14248 ARG may be in any of the following forms:
14249
14250 x where 'x' is a breakpoint number.
14251 x-y where 'x' and 'y' specify a breakpoint numbers range.
14252 x.y where 'x' is a breakpoint number and 'y' a location number.
14253 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14254 location number range.
14255 */
14256
14257 static void
14258 extract_bp_number_and_location (const std::string &arg,
14259 std::pair<int, int> &bp_num_range,
14260 std::pair<int, int> &bp_loc_range)
14261 {
14262 std::string::size_type dot = arg.find ('.');
14263
14264 if (dot != std::string::npos)
14265 {
14266 /* Handle 'x.y' and 'x.y-z' cases. */
14267
14268 if (arg.length () == dot + 1 || dot == 0)
14269 error (_("Bad breakpoint number at or near: '%s'"), arg.c_str ());
14270
14271 bp_num_range.first
14272 = extract_bp_num (extract_bp_kind::bp, arg.c_str (), '.');
14273 bp_num_range.second = bp_num_range.first;
14274
14275 bp_loc_range = extract_bp_or_bp_range (extract_bp_kind::loc,
14276 arg, dot + 1);
14277 }
14278 else
14279 {
14280 /* Handle x and x-y cases. */
14281
14282 bp_num_range = extract_bp_or_bp_range (extract_bp_kind::bp, arg, 0);
14283 bp_loc_range.first = 0;
14284 bp_loc_range.second = 0;
14285 }
14286 }
14287
14288 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
14289 specifies whether to enable or disable. */
14290
14291 static void
14292 enable_disable_bp_num_loc (int bp_num, int loc_num, bool enable)
14293 {
14294 struct bp_location *loc = find_location_by_number (bp_num, loc_num);
14295 if (loc != NULL)
14296 {
14297 if (loc->enabled != enable)
14298 {
14299 loc->enabled = enable;
14300 mark_breakpoint_location_modified (loc);
14301 }
14302 if (target_supports_enable_disable_tracepoint ()
14303 && current_trace_status ()->running && loc->owner
14304 && is_tracepoint (loc->owner))
14305 target_disable_tracepoint (loc);
14306 }
14307 update_global_location_list (UGLL_DONT_INSERT);
14308 }
14309
14310 /* Enable or disable a range of breakpoint locations. BP_NUM is the
14311 number of the breakpoint, and BP_LOC_RANGE specifies the
14312 (inclusive) range of location numbers of that breakpoint to
14313 enable/disable. ENABLE specifies whether to enable or disable the
14314 location. */
14315
14316 static void
14317 enable_disable_breakpoint_location_range (int bp_num,
14318 std::pair<int, int> &bp_loc_range,
14319 bool enable)
14320 {
14321 for (int i = bp_loc_range.first; i <= bp_loc_range.second; i++)
14322 enable_disable_bp_num_loc (bp_num, i, enable);
14323 }
14324
14325 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14326 If from_tty is nonzero, it prints a message to that effect,
14327 which ends with a period (no newline). */
14328
14329 void
14330 disable_breakpoint (struct breakpoint *bpt)
14331 {
14332 /* Never disable a watchpoint scope breakpoint; we want to
14333 hit them when we leave scope so we can delete both the
14334 watchpoint and its scope breakpoint at that time. */
14335 if (bpt->type == bp_watchpoint_scope)
14336 return;
14337
14338 bpt->enable_state = bp_disabled;
14339
14340 /* Mark breakpoint locations modified. */
14341 mark_breakpoint_modified (bpt);
14342
14343 if (target_supports_enable_disable_tracepoint ()
14344 && current_trace_status ()->running && is_tracepoint (bpt))
14345 {
14346 struct bp_location *location;
14347
14348 for (location = bpt->loc; location; location = location->next)
14349 target_disable_tracepoint (location);
14350 }
14351
14352 update_global_location_list (UGLL_DONT_INSERT);
14353
14354 observer_notify_breakpoint_modified (bpt);
14355 }
14356
14357 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14358 specified in ARGS. ARGS may be in any of the formats handled by
14359 extract_bp_number_and_location. ENABLE specifies whether to enable
14360 or disable the breakpoints/locations. */
14361
14362 static void
14363 enable_disable_command (const char *args, int from_tty, bool enable)
14364 {
14365 if (args == 0)
14366 {
14367 struct breakpoint *bpt;
14368
14369 ALL_BREAKPOINTS (bpt)
14370 if (user_breakpoint_p (bpt))
14371 {
14372 if (enable)
14373 enable_breakpoint (bpt);
14374 else
14375 disable_breakpoint (bpt);
14376 }
14377 }
14378 else
14379 {
14380 std::string num = extract_arg (&args);
14381
14382 while (!num.empty ())
14383 {
14384 std::pair<int, int> bp_num_range, bp_loc_range;
14385
14386 extract_bp_number_and_location (num, bp_num_range, bp_loc_range);
14387
14388 if (bp_loc_range.first == bp_loc_range.second
14389 && bp_loc_range.first == 0)
14390 {
14391 /* Handle breakpoint ids with formats 'x' or 'x-z'. */
14392 map_breakpoint_number_range (bp_num_range,
14393 enable
14394 ? enable_breakpoint
14395 : disable_breakpoint);
14396 }
14397 else
14398 {
14399 /* Handle breakpoint ids with formats 'x.y' or
14400 'x.y-z'. */
14401 enable_disable_breakpoint_location_range
14402 (bp_num_range.first, bp_loc_range, enable);
14403 }
14404 num = extract_arg (&args);
14405 }
14406 }
14407 }
14408
14409 /* The disable command disables the specified breakpoints/locations
14410 (or all defined breakpoints) so they're no longer effective in
14411 stopping the inferior. ARGS may be in any of the forms defined in
14412 extract_bp_number_and_location. */
14413
14414 static void
14415 disable_command (const char *args, int from_tty)
14416 {
14417 enable_disable_command (args, from_tty, false);
14418 }
14419
14420 static void
14421 enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14422 int count)
14423 {
14424 int target_resources_ok;
14425
14426 if (bpt->type == bp_hardware_breakpoint)
14427 {
14428 int i;
14429 i = hw_breakpoint_used_count ();
14430 target_resources_ok =
14431 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
14432 i + 1, 0);
14433 if (target_resources_ok == 0)
14434 error (_("No hardware breakpoint support in the target."));
14435 else if (target_resources_ok < 0)
14436 error (_("Hardware breakpoints used exceeds limit."));
14437 }
14438
14439 if (is_watchpoint (bpt))
14440 {
14441 /* Initialize it just to avoid a GCC false warning. */
14442 enum enable_state orig_enable_state = bp_disabled;
14443
14444 TRY
14445 {
14446 struct watchpoint *w = (struct watchpoint *) bpt;
14447
14448 orig_enable_state = bpt->enable_state;
14449 bpt->enable_state = bp_enabled;
14450 update_watchpoint (w, 1 /* reparse */);
14451 }
14452 CATCH (e, RETURN_MASK_ALL)
14453 {
14454 bpt->enable_state = orig_enable_state;
14455 exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14456 bpt->number);
14457 return;
14458 }
14459 END_CATCH
14460 }
14461
14462 bpt->enable_state = bp_enabled;
14463
14464 /* Mark breakpoint locations modified. */
14465 mark_breakpoint_modified (bpt);
14466
14467 if (target_supports_enable_disable_tracepoint ()
14468 && current_trace_status ()->running && is_tracepoint (bpt))
14469 {
14470 struct bp_location *location;
14471
14472 for (location = bpt->loc; location; location = location->next)
14473 target_enable_tracepoint (location);
14474 }
14475
14476 bpt->disposition = disposition;
14477 bpt->enable_count = count;
14478 update_global_location_list (UGLL_MAY_INSERT);
14479
14480 observer_notify_breakpoint_modified (bpt);
14481 }
14482
14483
14484 void
14485 enable_breakpoint (struct breakpoint *bpt)
14486 {
14487 enable_breakpoint_disp (bpt, bpt->disposition, 0);
14488 }
14489
14490 /* The enable command enables the specified breakpoints/locations (or
14491 all defined breakpoints) so they once again become (or continue to
14492 be) effective in stopping the inferior. ARGS may be in any of the
14493 forms defined in extract_bp_number_and_location. */
14494
14495 static void
14496 enable_command (const char *args, int from_tty)
14497 {
14498 enable_disable_command (args, from_tty, true);
14499 }
14500
14501 static void
14502 enable_once_command (const char *args, int from_tty)
14503 {
14504 map_breakpoint_numbers
14505 (args, [&] (breakpoint *b)
14506 {
14507 iterate_over_related_breakpoints
14508 (b, [&] (breakpoint *bpt)
14509 {
14510 enable_breakpoint_disp (bpt, disp_disable, 1);
14511 });
14512 });
14513 }
14514
14515 static void
14516 enable_count_command (const char *args, int from_tty)
14517 {
14518 int count;
14519
14520 if (args == NULL)
14521 error_no_arg (_("hit count"));
14522
14523 count = get_number (&args);
14524
14525 map_breakpoint_numbers
14526 (args, [&] (breakpoint *b)
14527 {
14528 iterate_over_related_breakpoints
14529 (b, [&] (breakpoint *bpt)
14530 {
14531 enable_breakpoint_disp (bpt, disp_disable, count);
14532 });
14533 });
14534 }
14535
14536 static void
14537 enable_delete_command (const char *args, int from_tty)
14538 {
14539 map_breakpoint_numbers
14540 (args, [&] (breakpoint *b)
14541 {
14542 iterate_over_related_breakpoints
14543 (b, [&] (breakpoint *bpt)
14544 {
14545 enable_breakpoint_disp (bpt, disp_del, 1);
14546 });
14547 });
14548 }
14549
14550 static void
14551 set_breakpoint_cmd (const char *args, int from_tty)
14552 {
14553 }
14554
14555 static void
14556 show_breakpoint_cmd (const char *args, int from_tty)
14557 {
14558 }
14559
14560 /* Invalidate last known value of any hardware watchpoint if
14561 the memory which that value represents has been written to by
14562 GDB itself. */
14563
14564 static void
14565 invalidate_bp_value_on_memory_change (struct inferior *inferior,
14566 CORE_ADDR addr, ssize_t len,
14567 const bfd_byte *data)
14568 {
14569 struct breakpoint *bp;
14570
14571 ALL_BREAKPOINTS (bp)
14572 if (bp->enable_state == bp_enabled
14573 && bp->type == bp_hardware_watchpoint)
14574 {
14575 struct watchpoint *wp = (struct watchpoint *) bp;
14576
14577 if (wp->val_valid && wp->val)
14578 {
14579 struct bp_location *loc;
14580
14581 for (loc = bp->loc; loc != NULL; loc = loc->next)
14582 if (loc->loc_type == bp_loc_hardware_watchpoint
14583 && loc->address + loc->length > addr
14584 && addr + len > loc->address)
14585 {
14586 value_free (wp->val);
14587 wp->val = NULL;
14588 wp->val_valid = 0;
14589 }
14590 }
14591 }
14592 }
14593
14594 /* Create and insert a breakpoint for software single step. */
14595
14596 void
14597 insert_single_step_breakpoint (struct gdbarch *gdbarch,
14598 const address_space *aspace,
14599 CORE_ADDR next_pc)
14600 {
14601 struct thread_info *tp = inferior_thread ();
14602 struct symtab_and_line sal;
14603 CORE_ADDR pc = next_pc;
14604
14605 if (tp->control.single_step_breakpoints == NULL)
14606 {
14607 tp->control.single_step_breakpoints
14608 = new_single_step_breakpoint (tp->global_num, gdbarch);
14609 }
14610
14611 sal = find_pc_line (pc, 0);
14612 sal.pc = pc;
14613 sal.section = find_pc_overlay (pc);
14614 sal.explicit_pc = 1;
14615 add_location_to_breakpoint (tp->control.single_step_breakpoints, &sal);
14616
14617 update_global_location_list (UGLL_INSERT);
14618 }
14619
14620 /* Insert single step breakpoints according to the current state. */
14621
14622 int
14623 insert_single_step_breakpoints (struct gdbarch *gdbarch)
14624 {
14625 struct regcache *regcache = get_current_regcache ();
14626 std::vector<CORE_ADDR> next_pcs;
14627
14628 next_pcs = gdbarch_software_single_step (gdbarch, regcache);
14629
14630 if (!next_pcs.empty ())
14631 {
14632 struct frame_info *frame = get_current_frame ();
14633 const address_space *aspace = get_frame_address_space (frame);
14634
14635 for (CORE_ADDR pc : next_pcs)
14636 insert_single_step_breakpoint (gdbarch, aspace, pc);
14637
14638 return 1;
14639 }
14640 else
14641 return 0;
14642 }
14643
14644 /* See breakpoint.h. */
14645
14646 int
14647 breakpoint_has_location_inserted_here (struct breakpoint *bp,
14648 const address_space *aspace,
14649 CORE_ADDR pc)
14650 {
14651 struct bp_location *loc;
14652
14653 for (loc = bp->loc; loc != NULL; loc = loc->next)
14654 if (loc->inserted
14655 && breakpoint_location_address_match (loc, aspace, pc))
14656 return 1;
14657
14658 return 0;
14659 }
14660
14661 /* Check whether a software single-step breakpoint is inserted at
14662 PC. */
14663
14664 int
14665 single_step_breakpoint_inserted_here_p (const address_space *aspace,
14666 CORE_ADDR pc)
14667 {
14668 struct breakpoint *bpt;
14669
14670 ALL_BREAKPOINTS (bpt)
14671 {
14672 if (bpt->type == bp_single_step
14673 && breakpoint_has_location_inserted_here (bpt, aspace, pc))
14674 return 1;
14675 }
14676 return 0;
14677 }
14678
14679 /* Tracepoint-specific operations. */
14680
14681 /* Set tracepoint count to NUM. */
14682 static void
14683 set_tracepoint_count (int num)
14684 {
14685 tracepoint_count = num;
14686 set_internalvar_integer (lookup_internalvar ("tpnum"), num);
14687 }
14688
14689 static void
14690 trace_command (const char *arg, int from_tty)
14691 {
14692 struct breakpoint_ops *ops;
14693
14694 event_location_up location = string_to_event_location (&arg,
14695 current_language);
14696 if (location != NULL
14697 && event_location_type (location.get ()) == PROBE_LOCATION)
14698 ops = &tracepoint_probe_breakpoint_ops;
14699 else
14700 ops = &tracepoint_breakpoint_ops;
14701
14702 create_breakpoint (get_current_arch (),
14703 location.get (),
14704 NULL, 0, arg, 1 /* parse arg */,
14705 0 /* tempflag */,
14706 bp_tracepoint /* type_wanted */,
14707 0 /* Ignore count */,
14708 pending_break_support,
14709 ops,
14710 from_tty,
14711 1 /* enabled */,
14712 0 /* internal */, 0);
14713 }
14714
14715 static void
14716 ftrace_command (const char *arg, int from_tty)
14717 {
14718 event_location_up location = string_to_event_location (&arg,
14719 current_language);
14720 create_breakpoint (get_current_arch (),
14721 location.get (),
14722 NULL, 0, arg, 1 /* parse arg */,
14723 0 /* tempflag */,
14724 bp_fast_tracepoint /* type_wanted */,
14725 0 /* Ignore count */,
14726 pending_break_support,
14727 &tracepoint_breakpoint_ops,
14728 from_tty,
14729 1 /* enabled */,
14730 0 /* internal */, 0);
14731 }
14732
14733 /* strace command implementation. Creates a static tracepoint. */
14734
14735 static void
14736 strace_command (const char *arg, int from_tty)
14737 {
14738 struct breakpoint_ops *ops;
14739 event_location_up location;
14740
14741 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14742 or with a normal static tracepoint. */
14743 if (arg && startswith (arg, "-m") && isspace (arg[2]))
14744 {
14745 ops = &strace_marker_breakpoint_ops;
14746 location = new_linespec_location (&arg, symbol_name_match_type::FULL);
14747 }
14748 else
14749 {
14750 ops = &tracepoint_breakpoint_ops;
14751 location = string_to_event_location (&arg, current_language);
14752 }
14753
14754 create_breakpoint (get_current_arch (),
14755 location.get (),
14756 NULL, 0, arg, 1 /* parse arg */,
14757 0 /* tempflag */,
14758 bp_static_tracepoint /* type_wanted */,
14759 0 /* Ignore count */,
14760 pending_break_support,
14761 ops,
14762 from_tty,
14763 1 /* enabled */,
14764 0 /* internal */, 0);
14765 }
14766
14767 /* Set up a fake reader function that gets command lines from a linked
14768 list that was acquired during tracepoint uploading. */
14769
14770 static struct uploaded_tp *this_utp;
14771 static int next_cmd;
14772
14773 static char *
14774 read_uploaded_action (void)
14775 {
14776 char *rslt;
14777
14778 VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
14779
14780 next_cmd++;
14781
14782 return rslt;
14783 }
14784
14785 /* Given information about a tracepoint as recorded on a target (which
14786 can be either a live system or a trace file), attempt to create an
14787 equivalent GDB tracepoint. This is not a reliable process, since
14788 the target does not necessarily have all the information used when
14789 the tracepoint was originally defined. */
14790
14791 struct tracepoint *
14792 create_tracepoint_from_upload (struct uploaded_tp *utp)
14793 {
14794 const char *addr_str;
14795 char small_buf[100];
14796 struct tracepoint *tp;
14797
14798 if (utp->at_string)
14799 addr_str = utp->at_string;
14800 else
14801 {
14802 /* In the absence of a source location, fall back to raw
14803 address. Since there is no way to confirm that the address
14804 means the same thing as when the trace was started, warn the
14805 user. */
14806 warning (_("Uploaded tracepoint %d has no "
14807 "source location, using raw address"),
14808 utp->number);
14809 xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (utp->addr));
14810 addr_str = small_buf;
14811 }
14812
14813 /* There's not much we can do with a sequence of bytecodes. */
14814 if (utp->cond && !utp->cond_string)
14815 warning (_("Uploaded tracepoint %d condition "
14816 "has no source form, ignoring it"),
14817 utp->number);
14818
14819 event_location_up location = string_to_event_location (&addr_str,
14820 current_language);
14821 if (!create_breakpoint (get_current_arch (),
14822 location.get (),
14823 utp->cond_string, -1, addr_str,
14824 0 /* parse cond/thread */,
14825 0 /* tempflag */,
14826 utp->type /* type_wanted */,
14827 0 /* Ignore count */,
14828 pending_break_support,
14829 &tracepoint_breakpoint_ops,
14830 0 /* from_tty */,
14831 utp->enabled /* enabled */,
14832 0 /* internal */,
14833 CREATE_BREAKPOINT_FLAGS_INSERTED))
14834 return NULL;
14835
14836 /* Get the tracepoint we just created. */
14837 tp = get_tracepoint (tracepoint_count);
14838 gdb_assert (tp != NULL);
14839
14840 if (utp->pass > 0)
14841 {
14842 xsnprintf (small_buf, sizeof (small_buf), "%d %d", utp->pass,
14843 tp->number);
14844
14845 trace_pass_command (small_buf, 0);
14846 }
14847
14848 /* If we have uploaded versions of the original commands, set up a
14849 special-purpose "reader" function and call the usual command line
14850 reader, then pass the result to the breakpoint command-setting
14851 function. */
14852 if (!VEC_empty (char_ptr, utp->cmd_strings))
14853 {
14854 command_line_up cmd_list;
14855
14856 this_utp = utp;
14857 next_cmd = 0;
14858
14859 cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
14860
14861 breakpoint_set_commands (tp, std::move (cmd_list));
14862 }
14863 else if (!VEC_empty (char_ptr, utp->actions)
14864 || !VEC_empty (char_ptr, utp->step_actions))
14865 warning (_("Uploaded tracepoint %d actions "
14866 "have no source form, ignoring them"),
14867 utp->number);
14868
14869 /* Copy any status information that might be available. */
14870 tp->hit_count = utp->hit_count;
14871 tp->traceframe_usage = utp->traceframe_usage;
14872
14873 return tp;
14874 }
14875
14876 /* Print information on tracepoint number TPNUM_EXP, or all if
14877 omitted. */
14878
14879 static void
14880 info_tracepoints_command (const char *args, int from_tty)
14881 {
14882 struct ui_out *uiout = current_uiout;
14883 int num_printed;
14884
14885 num_printed = breakpoint_1 (args, 0, is_tracepoint);
14886
14887 if (num_printed == 0)
14888 {
14889 if (args == NULL || *args == '\0')
14890 uiout->message ("No tracepoints.\n");
14891 else
14892 uiout->message ("No tracepoint matching '%s'.\n", args);
14893 }
14894
14895 default_collect_info ();
14896 }
14897
14898 /* The 'enable trace' command enables tracepoints.
14899 Not supported by all targets. */
14900 static void
14901 enable_trace_command (const char *args, int from_tty)
14902 {
14903 enable_command (args, from_tty);
14904 }
14905
14906 /* The 'disable trace' command disables tracepoints.
14907 Not supported by all targets. */
14908 static void
14909 disable_trace_command (const char *args, int from_tty)
14910 {
14911 disable_command (args, from_tty);
14912 }
14913
14914 /* Remove a tracepoint (or all if no argument). */
14915 static void
14916 delete_trace_command (const char *arg, int from_tty)
14917 {
14918 struct breakpoint *b, *b_tmp;
14919
14920 dont_repeat ();
14921
14922 if (arg == 0)
14923 {
14924 int breaks_to_delete = 0;
14925
14926 /* Delete all breakpoints if no argument.
14927 Do not delete internal or call-dummy breakpoints, these
14928 have to be deleted with an explicit breakpoint number
14929 argument. */
14930 ALL_TRACEPOINTS (b)
14931 if (is_tracepoint (b) && user_breakpoint_p (b))
14932 {
14933 breaks_to_delete = 1;
14934 break;
14935 }
14936
14937 /* Ask user only if there are some breakpoints to delete. */
14938 if (!from_tty
14939 || (breaks_to_delete && query (_("Delete all tracepoints? "))))
14940 {
14941 ALL_BREAKPOINTS_SAFE (b, b_tmp)
14942 if (is_tracepoint (b) && user_breakpoint_p (b))
14943 delete_breakpoint (b);
14944 }
14945 }
14946 else
14947 map_breakpoint_numbers
14948 (arg, [&] (breakpoint *b)
14949 {
14950 iterate_over_related_breakpoints (b, delete_breakpoint);
14951 });
14952 }
14953
14954 /* Helper function for trace_pass_command. */
14955
14956 static void
14957 trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
14958 {
14959 tp->pass_count = count;
14960 observer_notify_breakpoint_modified (tp);
14961 if (from_tty)
14962 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14963 tp->number, count);
14964 }
14965
14966 /* Set passcount for tracepoint.
14967
14968 First command argument is passcount, second is tracepoint number.
14969 If tracepoint number omitted, apply to most recently defined.
14970 Also accepts special argument "all". */
14971
14972 static void
14973 trace_pass_command (const char *args, int from_tty)
14974 {
14975 struct tracepoint *t1;
14976 ULONGEST count;
14977
14978 if (args == 0 || *args == 0)
14979 error (_("passcount command requires an "
14980 "argument (count + optional TP num)"));
14981
14982 count = strtoulst (args, &args, 10); /* Count comes first, then TP num. */
14983
14984 args = skip_spaces (args);
14985 if (*args && strncasecmp (args, "all", 3) == 0)
14986 {
14987 struct breakpoint *b;
14988
14989 args += 3; /* Skip special argument "all". */
14990 if (*args)
14991 error (_("Junk at end of arguments."));
14992
14993 ALL_TRACEPOINTS (b)
14994 {
14995 t1 = (struct tracepoint *) b;
14996 trace_pass_set_count (t1, count, from_tty);
14997 }
14998 }
14999 else if (*args == '\0')
15000 {
15001 t1 = get_tracepoint_by_number (&args, NULL);
15002 if (t1)
15003 trace_pass_set_count (t1, count, from_tty);
15004 }
15005 else
15006 {
15007 number_or_range_parser parser (args);
15008 while (!parser.finished ())
15009 {
15010 t1 = get_tracepoint_by_number (&args, &parser);
15011 if (t1)
15012 trace_pass_set_count (t1, count, from_tty);
15013 }
15014 }
15015 }
15016
15017 struct tracepoint *
15018 get_tracepoint (int num)
15019 {
15020 struct breakpoint *t;
15021
15022 ALL_TRACEPOINTS (t)
15023 if (t->number == num)
15024 return (struct tracepoint *) t;
15025
15026 return NULL;
15027 }
15028
15029 /* Find the tracepoint with the given target-side number (which may be
15030 different from the tracepoint number after disconnecting and
15031 reconnecting). */
15032
15033 struct tracepoint *
15034 get_tracepoint_by_number_on_target (int num)
15035 {
15036 struct breakpoint *b;
15037
15038 ALL_TRACEPOINTS (b)
15039 {
15040 struct tracepoint *t = (struct tracepoint *) b;
15041
15042 if (t->number_on_target == num)
15043 return t;
15044 }
15045
15046 return NULL;
15047 }
15048
15049 /* Utility: parse a tracepoint number and look it up in the list.
15050 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15051 If the argument is missing, the most recent tracepoint
15052 (tracepoint_count) is returned. */
15053
15054 struct tracepoint *
15055 get_tracepoint_by_number (const char **arg,
15056 number_or_range_parser *parser)
15057 {
15058 struct breakpoint *t;
15059 int tpnum;
15060 const char *instring = arg == NULL ? NULL : *arg;
15061
15062 if (parser != NULL)
15063 {
15064 gdb_assert (!parser->finished ());
15065 tpnum = parser->get_number ();
15066 }
15067 else if (arg == NULL || *arg == NULL || ! **arg)
15068 tpnum = tracepoint_count;
15069 else
15070 tpnum = get_number (arg);
15071
15072 if (tpnum <= 0)
15073 {
15074 if (instring && *instring)
15075 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15076 instring);
15077 else
15078 printf_filtered (_("No previous tracepoint\n"));
15079 return NULL;
15080 }
15081
15082 ALL_TRACEPOINTS (t)
15083 if (t->number == tpnum)
15084 {
15085 return (struct tracepoint *) t;
15086 }
15087
15088 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
15089 return NULL;
15090 }
15091
15092 void
15093 print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
15094 {
15095 if (b->thread != -1)
15096 fprintf_unfiltered (fp, " thread %d", b->thread);
15097
15098 if (b->task != 0)
15099 fprintf_unfiltered (fp, " task %d", b->task);
15100
15101 fprintf_unfiltered (fp, "\n");
15102 }
15103
15104 /* Save information on user settable breakpoints (watchpoints, etc) to
15105 a new script file named FILENAME. If FILTER is non-NULL, call it
15106 on each breakpoint and only include the ones for which it returns
15107 non-zero. */
15108
15109 static void
15110 save_breakpoints (const char *filename, int from_tty,
15111 int (*filter) (const struct breakpoint *))
15112 {
15113 struct breakpoint *tp;
15114 int any = 0;
15115 int extra_trace_bits = 0;
15116
15117 if (filename == 0 || *filename == 0)
15118 error (_("Argument required (file name in which to save)"));
15119
15120 /* See if we have anything to save. */
15121 ALL_BREAKPOINTS (tp)
15122 {
15123 /* Skip internal and momentary breakpoints. */
15124 if (!user_breakpoint_p (tp))
15125 continue;
15126
15127 /* If we have a filter, only save the breakpoints it accepts. */
15128 if (filter && !filter (tp))
15129 continue;
15130
15131 any = 1;
15132
15133 if (is_tracepoint (tp))
15134 {
15135 extra_trace_bits = 1;
15136
15137 /* We can stop searching. */
15138 break;
15139 }
15140 }
15141
15142 if (!any)
15143 {
15144 warning (_("Nothing to save."));
15145 return;
15146 }
15147
15148 gdb::unique_xmalloc_ptr<char> expanded_filename (tilde_expand (filename));
15149
15150 stdio_file fp;
15151
15152 if (!fp.open (expanded_filename.get (), "w"))
15153 error (_("Unable to open file '%s' for saving (%s)"),
15154 expanded_filename.get (), safe_strerror (errno));
15155
15156 if (extra_trace_bits)
15157 save_trace_state_variables (&fp);
15158
15159 ALL_BREAKPOINTS (tp)
15160 {
15161 /* Skip internal and momentary breakpoints. */
15162 if (!user_breakpoint_p (tp))
15163 continue;
15164
15165 /* If we have a filter, only save the breakpoints it accepts. */
15166 if (filter && !filter (tp))
15167 continue;
15168
15169 tp->ops->print_recreate (tp, &fp);
15170
15171 /* Note, we can't rely on tp->number for anything, as we can't
15172 assume the recreated breakpoint numbers will match. Use $bpnum
15173 instead. */
15174
15175 if (tp->cond_string)
15176 fp.printf (" condition $bpnum %s\n", tp->cond_string);
15177
15178 if (tp->ignore_count)
15179 fp.printf (" ignore $bpnum %d\n", tp->ignore_count);
15180
15181 if (tp->type != bp_dprintf && tp->commands)
15182 {
15183 fp.puts (" commands\n");
15184
15185 current_uiout->redirect (&fp);
15186 TRY
15187 {
15188 print_command_lines (current_uiout, tp->commands.get (), 2);
15189 }
15190 CATCH (ex, RETURN_MASK_ALL)
15191 {
15192 current_uiout->redirect (NULL);
15193 throw_exception (ex);
15194 }
15195 END_CATCH
15196
15197 current_uiout->redirect (NULL);
15198 fp.puts (" end\n");
15199 }
15200
15201 if (tp->enable_state == bp_disabled)
15202 fp.puts ("disable $bpnum\n");
15203
15204 /* If this is a multi-location breakpoint, check if the locations
15205 should be individually disabled. Watchpoint locations are
15206 special, and not user visible. */
15207 if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15208 {
15209 struct bp_location *loc;
15210 int n = 1;
15211
15212 for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15213 if (!loc->enabled)
15214 fp.printf ("disable $bpnum.%d\n", n);
15215 }
15216 }
15217
15218 if (extra_trace_bits && *default_collect)
15219 fp.printf ("set default-collect %s\n", default_collect);
15220
15221 if (from_tty)
15222 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename.get ());
15223 }
15224
15225 /* The `save breakpoints' command. */
15226
15227 static void
15228 save_breakpoints_command (const char *args, int from_tty)
15229 {
15230 save_breakpoints (args, from_tty, NULL);
15231 }
15232
15233 /* The `save tracepoints' command. */
15234
15235 static void
15236 save_tracepoints_command (const char *args, int from_tty)
15237 {
15238 save_breakpoints (args, from_tty, is_tracepoint);
15239 }
15240
15241 /* Create a vector of all tracepoints. */
15242
15243 VEC(breakpoint_p) *
15244 all_tracepoints (void)
15245 {
15246 VEC(breakpoint_p) *tp_vec = 0;
15247 struct breakpoint *tp;
15248
15249 ALL_TRACEPOINTS (tp)
15250 {
15251 VEC_safe_push (breakpoint_p, tp_vec, tp);
15252 }
15253
15254 return tp_vec;
15255 }
15256
15257
15258 /* This help string is used to consolidate all the help string for specifying
15259 locations used by several commands. */
15260
15261 #define LOCATION_HELP_STRING \
15262 "Linespecs are colon-separated lists of location parameters, such as\n\
15263 source filename, function name, label name, and line number.\n\
15264 Example: To specify the start of a label named \"the_top\" in the\n\
15265 function \"fact\" in the file \"factorial.c\", use\n\
15266 \"factorial.c:fact:the_top\".\n\
15267 \n\
15268 Address locations begin with \"*\" and specify an exact address in the\n\
15269 program. Example: To specify the fourth byte past the start function\n\
15270 \"main\", use \"*main + 4\".\n\
15271 \n\
15272 Explicit locations are similar to linespecs but use an option/argument\n\
15273 syntax to specify location parameters.\n\
15274 Example: To specify the start of the label named \"the_top\" in the\n\
15275 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15276 -function fact -label the_top\".\n\
15277 \n\
15278 By default, a specified function is matched against the program's\n\
15279 functions in all scopes. For C++, this means in all namespaces and\n\
15280 classes. For Ada, this means in all packages. E.g., in C++,\n\
15281 \"func()\" matches \"A::func()\", \"A::B::func()\", etc. The\n\
15282 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15283 specified name as a complete fully-qualified name instead.\n"
15284
15285 /* This help string is used for the break, hbreak, tbreak and thbreak
15286 commands. It is defined as a macro to prevent duplication.
15287 COMMAND should be a string constant containing the name of the
15288 command. */
15289
15290 #define BREAK_ARGS_HELP(command) \
15291 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15292 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15293 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15294 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15295 `-probe-dtrace' (for a DTrace probe).\n\
15296 LOCATION may be a linespec, address, or explicit location as described\n\
15297 below.\n\
15298 \n\
15299 With no LOCATION, uses current execution address of the selected\n\
15300 stack frame. This is useful for breaking on return to a stack frame.\n\
15301 \n\
15302 THREADNUM is the number from \"info threads\".\n\
15303 CONDITION is a boolean expression.\n\
15304 \n" LOCATION_HELP_STRING "\n\
15305 Multiple breakpoints at one place are permitted, and useful if their\n\
15306 conditions are different.\n\
15307 \n\
15308 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15309
15310 /* List of subcommands for "catch". */
15311 static struct cmd_list_element *catch_cmdlist;
15312
15313 /* List of subcommands for "tcatch". */
15314 static struct cmd_list_element *tcatch_cmdlist;
15315
15316 void
15317 add_catch_command (const char *name, const char *docstring,
15318 cmd_const_sfunc_ftype *sfunc,
15319 completer_ftype *completer,
15320 void *user_data_catch,
15321 void *user_data_tcatch)
15322 {
15323 struct cmd_list_element *command;
15324
15325 command = add_cmd (name, class_breakpoint, docstring,
15326 &catch_cmdlist);
15327 set_cmd_sfunc (command, sfunc);
15328 set_cmd_context (command, user_data_catch);
15329 set_cmd_completer (command, completer);
15330
15331 command = add_cmd (name, class_breakpoint, docstring,
15332 &tcatch_cmdlist);
15333 set_cmd_sfunc (command, sfunc);
15334 set_cmd_context (command, user_data_tcatch);
15335 set_cmd_completer (command, completer);
15336 }
15337
15338 static void
15339 save_command (const char *arg, int from_tty)
15340 {
15341 printf_unfiltered (_("\"save\" must be followed by "
15342 "the name of a save subcommand.\n"));
15343 help_list (save_cmdlist, "save ", all_commands, gdb_stdout);
15344 }
15345
15346 struct breakpoint *
15347 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15348 void *data)
15349 {
15350 struct breakpoint *b, *b_tmp;
15351
15352 ALL_BREAKPOINTS_SAFE (b, b_tmp)
15353 {
15354 if ((*callback) (b, data))
15355 return b;
15356 }
15357
15358 return NULL;
15359 }
15360
15361 /* Zero if any of the breakpoint's locations could be a location where
15362 functions have been inlined, nonzero otherwise. */
15363
15364 static int
15365 is_non_inline_function (struct breakpoint *b)
15366 {
15367 /* The shared library event breakpoint is set on the address of a
15368 non-inline function. */
15369 if (b->type == bp_shlib_event)
15370 return 1;
15371
15372 return 0;
15373 }
15374
15375 /* Nonzero if the specified PC cannot be a location where functions
15376 have been inlined. */
15377
15378 int
15379 pc_at_non_inline_function (const address_space *aspace, CORE_ADDR pc,
15380 const struct target_waitstatus *ws)
15381 {
15382 struct breakpoint *b;
15383 struct bp_location *bl;
15384
15385 ALL_BREAKPOINTS (b)
15386 {
15387 if (!is_non_inline_function (b))
15388 continue;
15389
15390 for (bl = b->loc; bl != NULL; bl = bl->next)
15391 {
15392 if (!bl->shlib_disabled
15393 && bpstat_check_location (bl, aspace, pc, ws))
15394 return 1;
15395 }
15396 }
15397
15398 return 0;
15399 }
15400
15401 /* Remove any references to OBJFILE which is going to be freed. */
15402
15403 void
15404 breakpoint_free_objfile (struct objfile *objfile)
15405 {
15406 struct bp_location **locp, *loc;
15407
15408 ALL_BP_LOCATIONS (loc, locp)
15409 if (loc->symtab != NULL && SYMTAB_OBJFILE (loc->symtab) == objfile)
15410 loc->symtab = NULL;
15411 }
15412
15413 void
15414 initialize_breakpoint_ops (void)
15415 {
15416 static int initialized = 0;
15417
15418 struct breakpoint_ops *ops;
15419
15420 if (initialized)
15421 return;
15422 initialized = 1;
15423
15424 /* The breakpoint_ops structure to be inherit by all kinds of
15425 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15426 internal and momentary breakpoints, etc.). */
15427 ops = &bkpt_base_breakpoint_ops;
15428 *ops = base_breakpoint_ops;
15429 ops->re_set = bkpt_re_set;
15430 ops->insert_location = bkpt_insert_location;
15431 ops->remove_location = bkpt_remove_location;
15432 ops->breakpoint_hit = bkpt_breakpoint_hit;
15433 ops->create_sals_from_location = bkpt_create_sals_from_location;
15434 ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
15435 ops->decode_location = bkpt_decode_location;
15436
15437 /* The breakpoint_ops structure to be used in regular breakpoints. */
15438 ops = &bkpt_breakpoint_ops;
15439 *ops = bkpt_base_breakpoint_ops;
15440 ops->re_set = bkpt_re_set;
15441 ops->resources_needed = bkpt_resources_needed;
15442 ops->print_it = bkpt_print_it;
15443 ops->print_mention = bkpt_print_mention;
15444 ops->print_recreate = bkpt_print_recreate;
15445
15446 /* Ranged breakpoints. */
15447 ops = &ranged_breakpoint_ops;
15448 *ops = bkpt_breakpoint_ops;
15449 ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15450 ops->resources_needed = resources_needed_ranged_breakpoint;
15451 ops->print_it = print_it_ranged_breakpoint;
15452 ops->print_one = print_one_ranged_breakpoint;
15453 ops->print_one_detail = print_one_detail_ranged_breakpoint;
15454 ops->print_mention = print_mention_ranged_breakpoint;
15455 ops->print_recreate = print_recreate_ranged_breakpoint;
15456
15457 /* Internal breakpoints. */
15458 ops = &internal_breakpoint_ops;
15459 *ops = bkpt_base_breakpoint_ops;
15460 ops->re_set = internal_bkpt_re_set;
15461 ops->check_status = internal_bkpt_check_status;
15462 ops->print_it = internal_bkpt_print_it;
15463 ops->print_mention = internal_bkpt_print_mention;
15464
15465 /* Momentary breakpoints. */
15466 ops = &momentary_breakpoint_ops;
15467 *ops = bkpt_base_breakpoint_ops;
15468 ops->re_set = momentary_bkpt_re_set;
15469 ops->check_status = momentary_bkpt_check_status;
15470 ops->print_it = momentary_bkpt_print_it;
15471 ops->print_mention = momentary_bkpt_print_mention;
15472
15473 /* Probe breakpoints. */
15474 ops = &bkpt_probe_breakpoint_ops;
15475 *ops = bkpt_breakpoint_ops;
15476 ops->insert_location = bkpt_probe_insert_location;
15477 ops->remove_location = bkpt_probe_remove_location;
15478 ops->create_sals_from_location = bkpt_probe_create_sals_from_location;
15479 ops->decode_location = bkpt_probe_decode_location;
15480
15481 /* Watchpoints. */
15482 ops = &watchpoint_breakpoint_ops;
15483 *ops = base_breakpoint_ops;
15484 ops->re_set = re_set_watchpoint;
15485 ops->insert_location = insert_watchpoint;
15486 ops->remove_location = remove_watchpoint;
15487 ops->breakpoint_hit = breakpoint_hit_watchpoint;
15488 ops->check_status = check_status_watchpoint;
15489 ops->resources_needed = resources_needed_watchpoint;
15490 ops->works_in_software_mode = works_in_software_mode_watchpoint;
15491 ops->print_it = print_it_watchpoint;
15492 ops->print_mention = print_mention_watchpoint;
15493 ops->print_recreate = print_recreate_watchpoint;
15494 ops->explains_signal = explains_signal_watchpoint;
15495
15496 /* Masked watchpoints. */
15497 ops = &masked_watchpoint_breakpoint_ops;
15498 *ops = watchpoint_breakpoint_ops;
15499 ops->insert_location = insert_masked_watchpoint;
15500 ops->remove_location = remove_masked_watchpoint;
15501 ops->resources_needed = resources_needed_masked_watchpoint;
15502 ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15503 ops->print_it = print_it_masked_watchpoint;
15504 ops->print_one_detail = print_one_detail_masked_watchpoint;
15505 ops->print_mention = print_mention_masked_watchpoint;
15506 ops->print_recreate = print_recreate_masked_watchpoint;
15507
15508 /* Tracepoints. */
15509 ops = &tracepoint_breakpoint_ops;
15510 *ops = base_breakpoint_ops;
15511 ops->re_set = tracepoint_re_set;
15512 ops->breakpoint_hit = tracepoint_breakpoint_hit;
15513 ops->print_one_detail = tracepoint_print_one_detail;
15514 ops->print_mention = tracepoint_print_mention;
15515 ops->print_recreate = tracepoint_print_recreate;
15516 ops->create_sals_from_location = tracepoint_create_sals_from_location;
15517 ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
15518 ops->decode_location = tracepoint_decode_location;
15519
15520 /* Probe tracepoints. */
15521 ops = &tracepoint_probe_breakpoint_ops;
15522 *ops = tracepoint_breakpoint_ops;
15523 ops->create_sals_from_location = tracepoint_probe_create_sals_from_location;
15524 ops->decode_location = tracepoint_probe_decode_location;
15525
15526 /* Static tracepoints with marker (`-m'). */
15527 ops = &strace_marker_breakpoint_ops;
15528 *ops = tracepoint_breakpoint_ops;
15529 ops->create_sals_from_location = strace_marker_create_sals_from_location;
15530 ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
15531 ops->decode_location = strace_marker_decode_location;
15532
15533 /* Fork catchpoints. */
15534 ops = &catch_fork_breakpoint_ops;
15535 *ops = base_breakpoint_ops;
15536 ops->insert_location = insert_catch_fork;
15537 ops->remove_location = remove_catch_fork;
15538 ops->breakpoint_hit = breakpoint_hit_catch_fork;
15539 ops->print_it = print_it_catch_fork;
15540 ops->print_one = print_one_catch_fork;
15541 ops->print_mention = print_mention_catch_fork;
15542 ops->print_recreate = print_recreate_catch_fork;
15543
15544 /* Vfork catchpoints. */
15545 ops = &catch_vfork_breakpoint_ops;
15546 *ops = base_breakpoint_ops;
15547 ops->insert_location = insert_catch_vfork;
15548 ops->remove_location = remove_catch_vfork;
15549 ops->breakpoint_hit = breakpoint_hit_catch_vfork;
15550 ops->print_it = print_it_catch_vfork;
15551 ops->print_one = print_one_catch_vfork;
15552 ops->print_mention = print_mention_catch_vfork;
15553 ops->print_recreate = print_recreate_catch_vfork;
15554
15555 /* Exec catchpoints. */
15556 ops = &catch_exec_breakpoint_ops;
15557 *ops = base_breakpoint_ops;
15558 ops->insert_location = insert_catch_exec;
15559 ops->remove_location = remove_catch_exec;
15560 ops->breakpoint_hit = breakpoint_hit_catch_exec;
15561 ops->print_it = print_it_catch_exec;
15562 ops->print_one = print_one_catch_exec;
15563 ops->print_mention = print_mention_catch_exec;
15564 ops->print_recreate = print_recreate_catch_exec;
15565
15566 /* Solib-related catchpoints. */
15567 ops = &catch_solib_breakpoint_ops;
15568 *ops = base_breakpoint_ops;
15569 ops->insert_location = insert_catch_solib;
15570 ops->remove_location = remove_catch_solib;
15571 ops->breakpoint_hit = breakpoint_hit_catch_solib;
15572 ops->check_status = check_status_catch_solib;
15573 ops->print_it = print_it_catch_solib;
15574 ops->print_one = print_one_catch_solib;
15575 ops->print_mention = print_mention_catch_solib;
15576 ops->print_recreate = print_recreate_catch_solib;
15577
15578 ops = &dprintf_breakpoint_ops;
15579 *ops = bkpt_base_breakpoint_ops;
15580 ops->re_set = dprintf_re_set;
15581 ops->resources_needed = bkpt_resources_needed;
15582 ops->print_it = bkpt_print_it;
15583 ops->print_mention = bkpt_print_mention;
15584 ops->print_recreate = dprintf_print_recreate;
15585 ops->after_condition_true = dprintf_after_condition_true;
15586 ops->breakpoint_hit = dprintf_breakpoint_hit;
15587 }
15588
15589 /* Chain containing all defined "enable breakpoint" subcommands. */
15590
15591 static struct cmd_list_element *enablebreaklist = NULL;
15592
15593 void
15594 _initialize_breakpoint (void)
15595 {
15596 struct cmd_list_element *c;
15597
15598 initialize_breakpoint_ops ();
15599
15600 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
15601 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile);
15602 observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
15603
15604 breakpoint_objfile_key
15605 = register_objfile_data_with_cleanup (NULL, free_breakpoint_objfile_data);
15606
15607 breakpoint_chain = 0;
15608 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15609 before a breakpoint is set. */
15610 breakpoint_count = 0;
15611
15612 tracepoint_count = 0;
15613
15614 add_com ("ignore", class_breakpoint, ignore_command, _("\
15615 Set ignore-count of breakpoint number N to COUNT.\n\
15616 Usage is `ignore N COUNT'."));
15617
15618 add_com ("commands", class_breakpoint, commands_command, _("\
15619 Set commands to be executed when the given breakpoints are hit.\n\
15620 Give a space-separated breakpoint list as argument after \"commands\".\n\
15621 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15622 (e.g. `5-7').\n\
15623 With no argument, the targeted breakpoint is the last one set.\n\
15624 The commands themselves follow starting on the next line.\n\
15625 Type a line containing \"end\" to indicate the end of them.\n\
15626 Give \"silent\" as the first line to make the breakpoint silent;\n\
15627 then no output is printed when it is hit, except what the commands print."));
15628
15629 c = add_com ("condition", class_breakpoint, condition_command, _("\
15630 Specify breakpoint number N to break only if COND is true.\n\
15631 Usage is `condition N COND', where N is an integer and COND is an\n\
15632 expression to be evaluated whenever breakpoint N is reached."));
15633 set_cmd_completer (c, condition_completer);
15634
15635 c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
15636 Set a temporary breakpoint.\n\
15637 Like \"break\" except the breakpoint is only temporary,\n\
15638 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15639 by using \"enable delete\" on the breakpoint number.\n\
15640 \n"
15641 BREAK_ARGS_HELP ("tbreak")));
15642 set_cmd_completer (c, location_completer);
15643
15644 c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
15645 Set a hardware assisted breakpoint.\n\
15646 Like \"break\" except the breakpoint requires hardware support,\n\
15647 some target hardware may not have this support.\n\
15648 \n"
15649 BREAK_ARGS_HELP ("hbreak")));
15650 set_cmd_completer (c, location_completer);
15651
15652 c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
15653 Set a temporary hardware assisted breakpoint.\n\
15654 Like \"hbreak\" except the breakpoint is only temporary,\n\
15655 so it will be deleted when hit.\n\
15656 \n"
15657 BREAK_ARGS_HELP ("thbreak")));
15658 set_cmd_completer (c, location_completer);
15659
15660 add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
15661 Enable some breakpoints.\n\
15662 Give breakpoint numbers (separated by spaces) as arguments.\n\
15663 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15664 This is used to cancel the effect of the \"disable\" command.\n\
15665 With a subcommand you can enable temporarily."),
15666 &enablelist, "enable ", 1, &cmdlist);
15667
15668 add_com_alias ("en", "enable", class_breakpoint, 1);
15669
15670 add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
15671 Enable some breakpoints.\n\
15672 Give breakpoint numbers (separated by spaces) as arguments.\n\
15673 This is used to cancel the effect of the \"disable\" command.\n\
15674 May be abbreviated to simply \"enable\".\n"),
15675 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
15676
15677 add_cmd ("once", no_class, enable_once_command, _("\
15678 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15679 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15680 &enablebreaklist);
15681
15682 add_cmd ("delete", no_class, enable_delete_command, _("\
15683 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15684 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15685 &enablebreaklist);
15686
15687 add_cmd ("count", no_class, enable_count_command, _("\
15688 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15689 If a breakpoint is hit while enabled in this fashion,\n\
15690 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15691 &enablebreaklist);
15692
15693 add_cmd ("delete", no_class, enable_delete_command, _("\
15694 Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15695 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15696 &enablelist);
15697
15698 add_cmd ("once", no_class, enable_once_command, _("\
15699 Enable breakpoints for one hit. Give breakpoint numbers.\n\
15700 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15701 &enablelist);
15702
15703 add_cmd ("count", no_class, enable_count_command, _("\
15704 Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
15705 If a breakpoint is hit while enabled in this fashion,\n\
15706 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15707 &enablelist);
15708
15709 add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
15710 Disable some breakpoints.\n\
15711 Arguments are breakpoint numbers with spaces in between.\n\
15712 To disable all breakpoints, give no argument.\n\
15713 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15714 &disablelist, "disable ", 1, &cmdlist);
15715 add_com_alias ("dis", "disable", class_breakpoint, 1);
15716 add_com_alias ("disa", "disable", class_breakpoint, 1);
15717
15718 add_cmd ("breakpoints", class_alias, disable_command, _("\
15719 Disable some breakpoints.\n\
15720 Arguments are breakpoint numbers with spaces in between.\n\
15721 To disable all breakpoints, give no argument.\n\
15722 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15723 This command may be abbreviated \"disable\"."),
15724 &disablelist);
15725
15726 add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
15727 Delete some breakpoints or auto-display expressions.\n\
15728 Arguments are breakpoint numbers with spaces in between.\n\
15729 To delete all breakpoints, give no argument.\n\
15730 \n\
15731 Also a prefix command for deletion of other GDB objects.\n\
15732 The \"unset\" command is also an alias for \"delete\"."),
15733 &deletelist, "delete ", 1, &cmdlist);
15734 add_com_alias ("d", "delete", class_breakpoint, 1);
15735 add_com_alias ("del", "delete", class_breakpoint, 1);
15736
15737 add_cmd ("breakpoints", class_alias, delete_command, _("\
15738 Delete some breakpoints or auto-display expressions.\n\
15739 Arguments are breakpoint numbers with spaces in between.\n\
15740 To delete all breakpoints, give no argument.\n\
15741 This command may be abbreviated \"delete\"."),
15742 &deletelist);
15743
15744 add_com ("clear", class_breakpoint, clear_command, _("\
15745 Clear breakpoint at specified location.\n\
15746 Argument may be a linespec, explicit, or address location as described below.\n\
15747 \n\
15748 With no argument, clears all breakpoints in the line that the selected frame\n\
15749 is executing in.\n"
15750 "\n" LOCATION_HELP_STRING "\n\
15751 See also the \"delete\" command which clears breakpoints by number."));
15752 add_com_alias ("cl", "clear", class_breakpoint, 1);
15753
15754 c = add_com ("break", class_breakpoint, break_command, _("\
15755 Set breakpoint at specified location.\n"
15756 BREAK_ARGS_HELP ("break")));
15757 set_cmd_completer (c, location_completer);
15758
15759 add_com_alias ("b", "break", class_run, 1);
15760 add_com_alias ("br", "break", class_run, 1);
15761 add_com_alias ("bre", "break", class_run, 1);
15762 add_com_alias ("brea", "break", class_run, 1);
15763
15764 if (dbx_commands)
15765 {
15766 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
15767 Break in function/address or break at a line in the current file."),
15768 &stoplist, "stop ", 1, &cmdlist);
15769 add_cmd ("in", class_breakpoint, stopin_command,
15770 _("Break in function or address."), &stoplist);
15771 add_cmd ("at", class_breakpoint, stopat_command,
15772 _("Break at a line in the current file."), &stoplist);
15773 add_com ("status", class_info, info_breakpoints_command, _("\
15774 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15775 The \"Type\" column indicates one of:\n\
15776 \tbreakpoint - normal breakpoint\n\
15777 \twatchpoint - watchpoint\n\
15778 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15779 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15780 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15781 address and file/line number respectively.\n\
15782 \n\
15783 Convenience variable \"$_\" and default examine address for \"x\"\n\
15784 are set to the address of the last breakpoint listed unless the command\n\
15785 is prefixed with \"server \".\n\n\
15786 Convenience variable \"$bpnum\" contains the number of the last\n\
15787 breakpoint set."));
15788 }
15789
15790 add_info ("breakpoints", info_breakpoints_command, _("\
15791 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15792 The \"Type\" column indicates one of:\n\
15793 \tbreakpoint - normal breakpoint\n\
15794 \twatchpoint - watchpoint\n\
15795 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15796 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15797 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15798 address and file/line number respectively.\n\
15799 \n\
15800 Convenience variable \"$_\" and default examine address for \"x\"\n\
15801 are set to the address of the last breakpoint listed unless the command\n\
15802 is prefixed with \"server \".\n\n\
15803 Convenience variable \"$bpnum\" contains the number of the last\n\
15804 breakpoint set."));
15805
15806 add_info_alias ("b", "breakpoints", 1);
15807
15808 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
15809 Status of all breakpoints, or breakpoint number NUMBER.\n\
15810 The \"Type\" column indicates one of:\n\
15811 \tbreakpoint - normal breakpoint\n\
15812 \twatchpoint - watchpoint\n\
15813 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15814 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15815 \tuntil - internal breakpoint used by the \"until\" command\n\
15816 \tfinish - internal breakpoint used by the \"finish\" command\n\
15817 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15818 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15819 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15820 address and file/line number respectively.\n\
15821 \n\
15822 Convenience variable \"$_\" and default examine address for \"x\"\n\
15823 are set to the address of the last breakpoint listed unless the command\n\
15824 is prefixed with \"server \".\n\n\
15825 Convenience variable \"$bpnum\" contains the number of the last\n\
15826 breakpoint set."),
15827 &maintenanceinfolist);
15828
15829 add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
15830 Set catchpoints to catch events."),
15831 &catch_cmdlist, "catch ",
15832 0/*allow-unknown*/, &cmdlist);
15833
15834 add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
15835 Set temporary catchpoints to catch events."),
15836 &tcatch_cmdlist, "tcatch ",
15837 0/*allow-unknown*/, &cmdlist);
15838
15839 add_catch_command ("fork", _("Catch calls to fork."),
15840 catch_fork_command_1,
15841 NULL,
15842 (void *) (uintptr_t) catch_fork_permanent,
15843 (void *) (uintptr_t) catch_fork_temporary);
15844 add_catch_command ("vfork", _("Catch calls to vfork."),
15845 catch_fork_command_1,
15846 NULL,
15847 (void *) (uintptr_t) catch_vfork_permanent,
15848 (void *) (uintptr_t) catch_vfork_temporary);
15849 add_catch_command ("exec", _("Catch calls to exec."),
15850 catch_exec_command_1,
15851 NULL,
15852 CATCH_PERMANENT,
15853 CATCH_TEMPORARY);
15854 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15855 Usage: catch load [REGEX]\n\
15856 If REGEX is given, only stop for libraries matching the regular expression."),
15857 catch_load_command_1,
15858 NULL,
15859 CATCH_PERMANENT,
15860 CATCH_TEMPORARY);
15861 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15862 Usage: catch unload [REGEX]\n\
15863 If REGEX is given, only stop for libraries matching the regular expression."),
15864 catch_unload_command_1,
15865 NULL,
15866 CATCH_PERMANENT,
15867 CATCH_TEMPORARY);
15868
15869 c = add_com ("watch", class_breakpoint, watch_command, _("\
15870 Set a watchpoint for an expression.\n\
15871 Usage: watch [-l|-location] EXPRESSION\n\
15872 A watchpoint stops execution of your program whenever the value of\n\
15873 an expression changes.\n\
15874 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15875 the memory to which it refers."));
15876 set_cmd_completer (c, expression_completer);
15877
15878 c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
15879 Set a read watchpoint for an expression.\n\
15880 Usage: rwatch [-l|-location] EXPRESSION\n\
15881 A watchpoint stops execution of your program whenever the value of\n\
15882 an expression is read.\n\
15883 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15884 the memory to which it refers."));
15885 set_cmd_completer (c, expression_completer);
15886
15887 c = add_com ("awatch", class_breakpoint, awatch_command, _("\
15888 Set a watchpoint for an expression.\n\
15889 Usage: awatch [-l|-location] EXPRESSION\n\
15890 A watchpoint stops execution of your program whenever the value of\n\
15891 an expression is either read or written.\n\
15892 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15893 the memory to which it refers."));
15894 set_cmd_completer (c, expression_completer);
15895
15896 add_info ("watchpoints", info_watchpoints_command, _("\
15897 Status of specified watchpoints (all watchpoints if no argument)."));
15898
15899 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15900 respond to changes - contrary to the description. */
15901 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
15902 &can_use_hw_watchpoints, _("\
15903 Set debugger's willingness to use watchpoint hardware."), _("\
15904 Show debugger's willingness to use watchpoint hardware."), _("\
15905 If zero, gdb will not use hardware for new watchpoints, even if\n\
15906 such is available. (However, any hardware watchpoints that were\n\
15907 created before setting this to nonzero, will continue to use watchpoint\n\
15908 hardware.)"),
15909 NULL,
15910 show_can_use_hw_watchpoints,
15911 &setlist, &showlist);
15912
15913 can_use_hw_watchpoints = 1;
15914
15915 /* Tracepoint manipulation commands. */
15916
15917 c = add_com ("trace", class_breakpoint, trace_command, _("\
15918 Set a tracepoint at specified location.\n\
15919 \n"
15920 BREAK_ARGS_HELP ("trace") "\n\
15921 Do \"help tracepoints\" for info on other tracepoint commands."));
15922 set_cmd_completer (c, location_completer);
15923
15924 add_com_alias ("tp", "trace", class_alias, 0);
15925 add_com_alias ("tr", "trace", class_alias, 1);
15926 add_com_alias ("tra", "trace", class_alias, 1);
15927 add_com_alias ("trac", "trace", class_alias, 1);
15928
15929 c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
15930 Set a fast tracepoint at specified location.\n\
15931 \n"
15932 BREAK_ARGS_HELP ("ftrace") "\n\
15933 Do \"help tracepoints\" for info on other tracepoint commands."));
15934 set_cmd_completer (c, location_completer);
15935
15936 c = add_com ("strace", class_breakpoint, strace_command, _("\
15937 Set a static tracepoint at location or marker.\n\
15938 \n\
15939 strace [LOCATION] [if CONDITION]\n\
15940 LOCATION may be a linespec, explicit, or address location (described below) \n\
15941 or -m MARKER_ID.\n\n\
15942 If a marker id is specified, probe the marker with that name. With\n\
15943 no LOCATION, uses current execution address of the selected stack frame.\n\
15944 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15945 This collects arbitrary user data passed in the probe point call to the\n\
15946 tracing library. You can inspect it when analyzing the trace buffer,\n\
15947 by printing the $_sdata variable like any other convenience variable.\n\
15948 \n\
15949 CONDITION is a boolean expression.\n\
15950 \n" LOCATION_HELP_STRING "\n\
15951 Multiple tracepoints at one place are permitted, and useful if their\n\
15952 conditions are different.\n\
15953 \n\
15954 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15955 Do \"help tracepoints\" for info on other tracepoint commands."));
15956 set_cmd_completer (c, location_completer);
15957
15958 add_info ("tracepoints", info_tracepoints_command, _("\
15959 Status of specified tracepoints (all tracepoints if no argument).\n\
15960 Convenience variable \"$tpnum\" contains the number of the\n\
15961 last tracepoint set."));
15962
15963 add_info_alias ("tp", "tracepoints", 1);
15964
15965 add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
15966 Delete specified tracepoints.\n\
15967 Arguments are tracepoint numbers, separated by spaces.\n\
15968 No argument means delete all tracepoints."),
15969 &deletelist);
15970 add_alias_cmd ("tr", "tracepoints", class_trace, 1, &deletelist);
15971
15972 c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
15973 Disable specified tracepoints.\n\
15974 Arguments are tracepoint numbers, separated by spaces.\n\
15975 No argument means disable all tracepoints."),
15976 &disablelist);
15977 deprecate_cmd (c, "disable");
15978
15979 c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
15980 Enable specified tracepoints.\n\
15981 Arguments are tracepoint numbers, separated by spaces.\n\
15982 No argument means enable all tracepoints."),
15983 &enablelist);
15984 deprecate_cmd (c, "enable");
15985
15986 add_com ("passcount", class_trace, trace_pass_command, _("\
15987 Set the passcount for a tracepoint.\n\
15988 The trace will end when the tracepoint has been passed 'count' times.\n\
15989 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15990 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15991
15992 add_prefix_cmd ("save", class_breakpoint, save_command,
15993 _("Save breakpoint definitions as a script."),
15994 &save_cmdlist, "save ",
15995 0/*allow-unknown*/, &cmdlist);
15996
15997 c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
15998 Save current breakpoint definitions as a script.\n\
15999 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16000 catchpoints, tracepoints). Use the 'source' command in another debug\n\
16001 session to restore them."),
16002 &save_cmdlist);
16003 set_cmd_completer (c, filename_completer);
16004
16005 c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
16006 Save current tracepoint definitions as a script.\n\
16007 Use the 'source' command in another debug session to restore them."),
16008 &save_cmdlist);
16009 set_cmd_completer (c, filename_completer);
16010
16011 c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
16012 deprecate_cmd (c, "save tracepoints");
16013
16014 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
16015 Breakpoint specific settings\n\
16016 Configure various breakpoint-specific variables such as\n\
16017 pending breakpoint behavior"),
16018 &breakpoint_set_cmdlist, "set breakpoint ",
16019 0/*allow-unknown*/, &setlist);
16020 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
16021 Breakpoint specific settings\n\
16022 Configure various breakpoint-specific variables such as\n\
16023 pending breakpoint behavior"),
16024 &breakpoint_show_cmdlist, "show breakpoint ",
16025 0/*allow-unknown*/, &showlist);
16026
16027 add_setshow_auto_boolean_cmd ("pending", no_class,
16028 &pending_break_support, _("\
16029 Set debugger's behavior regarding pending breakpoints."), _("\
16030 Show debugger's behavior regarding pending breakpoints."), _("\
16031 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16032 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16033 an error. If auto, an unrecognized breakpoint location results in a\n\
16034 user-query to see if a pending breakpoint should be created."),
16035 NULL,
16036 show_pending_break_support,
16037 &breakpoint_set_cmdlist,
16038 &breakpoint_show_cmdlist);
16039
16040 pending_break_support = AUTO_BOOLEAN_AUTO;
16041
16042 add_setshow_boolean_cmd ("auto-hw", no_class,
16043 &automatic_hardware_breakpoints, _("\
16044 Set automatic usage of hardware breakpoints."), _("\
16045 Show automatic usage of hardware breakpoints."), _("\
16046 If set, the debugger will automatically use hardware breakpoints for\n\
16047 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16048 a warning will be emitted for such breakpoints."),
16049 NULL,
16050 show_automatic_hardware_breakpoints,
16051 &breakpoint_set_cmdlist,
16052 &breakpoint_show_cmdlist);
16053
16054 add_setshow_boolean_cmd ("always-inserted", class_support,
16055 &always_inserted_mode, _("\
16056 Set mode for inserting breakpoints."), _("\
16057 Show mode for inserting breakpoints."), _("\
16058 When this mode is on, breakpoints are inserted immediately as soon as\n\
16059 they're created, kept inserted even when execution stops, and removed\n\
16060 only when the user deletes them. When this mode is off (the default),\n\
16061 breakpoints are inserted only when execution continues, and removed\n\
16062 when execution stops."),
16063 NULL,
16064 &show_always_inserted_mode,
16065 &breakpoint_set_cmdlist,
16066 &breakpoint_show_cmdlist);
16067
16068 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
16069 condition_evaluation_enums,
16070 &condition_evaluation_mode_1, _("\
16071 Set mode of breakpoint condition evaluation."), _("\
16072 Show mode of breakpoint condition evaluation."), _("\
16073 When this is set to \"host\", breakpoint conditions will be\n\
16074 evaluated on the host's side by GDB. When it is set to \"target\",\n\
16075 breakpoint conditions will be downloaded to the target (if the target\n\
16076 supports such feature) and conditions will be evaluated on the target's side.\n\
16077 If this is set to \"auto\" (default), this will be automatically set to\n\
16078 \"target\" if it supports condition evaluation, otherwise it will\n\
16079 be set to \"gdb\""),
16080 &set_condition_evaluation_mode,
16081 &show_condition_evaluation_mode,
16082 &breakpoint_set_cmdlist,
16083 &breakpoint_show_cmdlist);
16084
16085 add_com ("break-range", class_breakpoint, break_range_command, _("\
16086 Set a breakpoint for an address range.\n\
16087 break-range START-LOCATION, END-LOCATION\n\
16088 where START-LOCATION and END-LOCATION can be one of the following:\n\
16089 LINENUM, for that line in the current file,\n\
16090 FILE:LINENUM, for that line in that file,\n\
16091 +OFFSET, for that number of lines after the current line\n\
16092 or the start of the range\n\
16093 FUNCTION, for the first line in that function,\n\
16094 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16095 *ADDRESS, for the instruction at that address.\n\
16096 \n\
16097 The breakpoint will stop execution of the inferior whenever it executes\n\
16098 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16099 range (including START-LOCATION and END-LOCATION)."));
16100
16101 c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
16102 Set a dynamic printf at specified location.\n\
16103 dprintf location,format string,arg1,arg2,...\n\
16104 location may be a linespec, explicit, or address location.\n"
16105 "\n" LOCATION_HELP_STRING));
16106 set_cmd_completer (c, location_completer);
16107
16108 add_setshow_enum_cmd ("dprintf-style", class_support,
16109 dprintf_style_enums, &dprintf_style, _("\
16110 Set the style of usage for dynamic printf."), _("\
16111 Show the style of usage for dynamic printf."), _("\
16112 This setting chooses how GDB will do a dynamic printf.\n\
16113 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16114 console, as with the \"printf\" command.\n\
16115 If the value is \"call\", the print is done by calling a function in your\n\
16116 program; by default printf(), but you can choose a different function or\n\
16117 output stream by setting dprintf-function and dprintf-channel."),
16118 update_dprintf_commands, NULL,
16119 &setlist, &showlist);
16120
16121 dprintf_function = xstrdup ("printf");
16122 add_setshow_string_cmd ("dprintf-function", class_support,
16123 &dprintf_function, _("\
16124 Set the function to use for dynamic printf"), _("\
16125 Show the function to use for dynamic printf"), NULL,
16126 update_dprintf_commands, NULL,
16127 &setlist, &showlist);
16128
16129 dprintf_channel = xstrdup ("");
16130 add_setshow_string_cmd ("dprintf-channel", class_support,
16131 &dprintf_channel, _("\
16132 Set the channel to use for dynamic printf"), _("\
16133 Show the channel to use for dynamic printf"), NULL,
16134 update_dprintf_commands, NULL,
16135 &setlist, &showlist);
16136
16137 add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
16138 &disconnected_dprintf, _("\
16139 Set whether dprintf continues after GDB disconnects."), _("\
16140 Show whether dprintf continues after GDB disconnects."), _("\
16141 Use this to let dprintf commands continue to hit and produce output\n\
16142 even if GDB disconnects or detaches from the target."),
16143 NULL,
16144 NULL,
16145 &setlist, &showlist);
16146
16147 add_com ("agent-printf", class_vars, agent_printf_command, _("\
16148 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16149 (target agent only) This is useful for formatted output in user-defined commands."));
16150
16151 automatic_hardware_breakpoints = 1;
16152
16153 observer_attach_about_to_proceed (breakpoint_about_to_proceed);
16154 observer_attach_thread_exit (remove_threaded_breakpoints);
16155 }
threads_are_executing
int threads_are_executing(void)
Definition: thread.c:1021
error_no_arg
void error_no_arg(const char *why)
Definition: cli-cmds.c:185
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
frame_id_p
int frame_id_p(struct frame_id l)
Definition: frame.c:646
breakpoint_in_range_p
int breakpoint_in_range_p(const address_space *aspace, CORE_ADDR addr, ULONGEST len)
Definition: breakpoint.c:4022
watchpoint_locations_match
static int watchpoint_locations_match(struct bp_location *loc1, struct bp_location *loc2)
Definition: breakpoint.c:6795
hardware_watchpoint_inserted_in_range
int hardware_watchpoint_inserted_in_range(const address_space *aspace, CORE_ADDR addr, ULONGEST len)
Definition: breakpoint.c:4156
gdbarch
Definition: gdbarch.c:127
catch_exec_breakpoint_ops
static struct breakpoint_ops catch_exec_breakpoint_ops
Definition: breakpoint.c:8402
frame_find_by_id
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:803
top.h
tracepoint_probe_breakpoint_ops
static struct breakpoint_ops tracepoint_probe_breakpoint_ops
Definition: breakpoint.c:13051
until_break_fsm_clean_up
static void until_break_fsm_clean_up(struct thread_fsm *self, struct thread_info *thread)
Definition: breakpoint.c:11144
remove_breakpoint
static int remove_breakpoint(struct bp_location *)
Definition: breakpoint.c:3831
objfile::flags
objfile_flags flags
Definition: objfiles.h:311
string
const char * string
Definition: signals.c:50
bpstat_what
Definition: breakpoint.h:1003
annotate_watchpoint
void annotate_watchpoint(int num)
Definition: annotate.c:94
set_cmd_context
void set_cmd_context(struct cmd_list_element *cmd, void *context)
Definition: cli-decode.c:142
command_line::body_count
int body_count
Definition: cli-script.h:67
mi-common.h
bpstats::~bpstats
~bpstats()
Definition: breakpoint.c:4200
bp_target_info::reqstd_address
CORE_ADDR reqstd_address
Definition: breakpoint.h:251
MEMORY_ERROR
Definition: common-exceptions.h:78
dprintf_breakpoint_hit
static int dprintf_breakpoint_hit(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.c:12559
probe
Definition: probe.h:112
thread_info::resumed
int resumed
Definition: gdbthread.h:280
bkpt_probe_breakpoint_ops
static struct breakpoint_ops bkpt_probe_breakpoint_ops
Definition: breakpoint.c:258
command_line
Definition: cli-script.h:51
breakpoint_objfile_data::overlay_msym
Definition: breakpoint.c:3146
target_remove_fork_catchpoint
#define target_remove_fork_catchpoint(pid)
Definition: target.h:1573
expression::elts
union exp_element elts[1]
Definition: expression.h:84
EXEC_ASYNC_VFORK
Definition: mi-common.h:45
get_last_displayed_sal
symtab_and_line get_last_displayed_sal()
Definition: stack.c:1019
hex_string
char * hex_string(LONGEST num)
Definition: print-utils.c:220
breakpoint_inserted_here_p
int breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4092
value_mark
struct value * value_mark(void)
Definition: value.c:1589
walk_bp_location_callback
void(* walk_bp_location_callback)(struct bp_location *, void *)
Definition: breakpoint.h:1252
bound_probe::prob
probe * prob
Definition: probe.h:253
target_waitstatus::related_pid
ptid_t related_pid
Definition: waitstatus.h:116
breakpoint::input_radix
int input_radix
Definition: breakpoint.h:746
extract_bp_kind::loc
PRINT_SRC_AND_LOC
Definition: breakpoint.h:505
breakpoint::loc
bp_location * loc
Definition: breakpoint.h:702
bp_location::cond_bytecode
agent_expr_up cond_bytecode
Definition: breakpoint.h:355
breakpoint_objfile_key
static const struct objfile_data * breakpoint_objfile_key
Definition: breakpoint.c:3172
release_static_tracepoint_marker
void release_static_tracepoint_marker(struct static_tracepoint_marker *marker)
Definition: tracepoint.c:3736
symtab_to_filename_for_display
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition: source.c:1168
bp_location_condition_evaluator
static const char * bp_location_condition_evaluator(struct bp_location *bl)
Definition: breakpoint.c:5865
probe::set_semaphore
virtual void set_semaphore(struct objfile *objfile, struct gdbarch *gdbarch)
Definition: probe.h:155
annotate_breakpoints_table
void annotate_breakpoints_table(void)
Definition: annotate.c:184
ftrace_command
static void ftrace_command(const char *arg, int from_tty)
Definition: breakpoint.c:14716
SYMTAB_COMPUNIT
#define SYMTAB_COMPUNIT(symtab)
Definition: symtab.h:1331
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
breakpoint_commands
struct command_line * breakpoint_commands(struct breakpoint *b)
Definition: breakpoint.c:303
watchpoint::hw_wp_mask
CORE_ADDR hw_wp_mask
Definition: breakpoint.h:845
init_raw_breakpoint_without_location
static void init_raw_breakpoint_without_location(struct breakpoint *b, struct gdbarch *gdbarch, enum bptype bptype, const struct breakpoint_ops *ops)
Definition: breakpoint.c:7146
demangle
int demangle
Definition: demangle.c:47
breakpoint_ops::print_recreate
void(* print_recreate)(struct breakpoint *, struct ui_file *fp)
Definition: breakpoint.h:593
command_line_is_silent
static int command_line_is_silent(struct command_line *cmd)
Definition: breakpoint.c:4397
show_can_use_hw_watchpoints
static void show_can_use_hw_watchpoints(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: breakpoint.c:330
create_jit_event_breakpoint
struct breakpoint * create_jit_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7500
range
static const char * range
Definition: language.c:114
base_breakpoint_explains_signal
static int base_breakpoint_explains_signal(struct breakpoint *b, enum gdb_signal sig)
Definition: breakpoint.c:12463
completer.h
number_of_program_spaces
int number_of_program_spaces(void)
Definition: progspace.c:353
bp_loc_hardware_watchpoint
Definition: breakpoint.h:300
breakpoint_here
breakpoint_here
Definition: breakpoint.h:1151
EXEC_ASYNC_FORK
Definition: mi-common.h:44
target_can_run_breakpoint_commands
#define target_can_run_breakpoint_commands()
Definition: target.h:1434
bkpt_create_breakpoints_sal
static void bkpt_create_breakpoints_sal(struct gdbarch *gdbarch, struct linespec_result *canonical, gdb::unique_xmalloc_ptr< char > cond_string, gdb::unique_xmalloc_ptr< char > extra_string, enum bptype type_wanted, enum bpdisp disposition, int thread, int task, int ignore_count, const struct breakpoint_ops *ops, int from_tty, int enabled, int internal, unsigned flags)
Definition: breakpoint.c:12685
observer_notify_breakpoint_created
void observer_notify_breakpoint_created(struct breakpoint *b)
handle_solib_event
void handle_solib_event(void)
Definition: solib.c:1286
find_thread_ptid
struct thread_info * find_thread_ptid(ptid_t ptid)
Definition: thread.c:514
set_condition_evaluation_mode
static void set_condition_evaluation_mode(const char *args, int from_tty, struct cmd_list_element *c)
Definition: breakpoint.c:713
breakpoint_here_p
enum breakpoint_here breakpoint_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:3989
bp_std_terminate_master
Definition: breakpoint.h:161
EX_EVENT_THROW
Definition: breakpoint.c:89
location_to_sals
static std::vector< symtab_and_line > location_to_sals(struct breakpoint *b, struct event_location *location, struct program_space *search_pspace, int *found)
Definition: breakpoint.c:13761
value_next
struct value * value_next(const struct value *value)
Definition: value.c:1089
show_breakpoint_cmd
static void show_breakpoint_cmd(const char *args, int from_tty)
Definition: breakpoint.c:14556
insert_single_step_breakpoints
int insert_single_step_breakpoints(struct gdbarch *gdbarch)
Definition: breakpoint.c:14623
allocate_bp_location
static struct bp_location * allocate_bp_location(struct breakpoint *bpt)
Definition: breakpoint.c:7086
base_breakpoint_re_set
static void base_breakpoint_re_set(struct breakpoint *b)
Definition: breakpoint.c:12348
set_ignore_count
void set_ignore_count(int bptnum, int count, int from_tty)
Definition: breakpoint.c:14018
target_remove_watchpoint
#define target_remove_watchpoint(addr, len, type, cond)
Definition: target.h:1943
insert_breakpoint_locations
static void insert_breakpoint_locations(void)
Definition: breakpoint.c:2937
catch_vfork_temporary
Definition: breakpoint.c:11306
observer_attach_thread_exit
struct observer * observer_attach_thread_exit(observer_thread_exit_ftype *f)
bp_finish
Definition: breakpoint.h:74
value_addr
struct value * value_addr(struct value *arg1)
Definition: valops.c:1462
breakpoint_address_match_range
static int breakpoint_address_match_range(const address_space *aspace1, CORE_ADDR addr1, int len1, const address_space *aspace2, CORE_ADDR addr2)
Definition: breakpoint.c:6852
solib_catchpoint::regex
char * regex
Definition: breakpoint.c:7992
enable_breakpoints_after_startup
void enable_breakpoints_after_startup(void)
Definition: breakpoint.c:8514
enable_overlay_breakpoints
void enable_overlay_breakpoints(void)
Definition: breakpoint.c:7420
free_bp_location
static void free_bp_location(struct bp_location *loc)
Definition: breakpoint.c:7092
enable_count_command
static void enable_count_command(const char *args, int from_tty)
Definition: breakpoint.c:14516
scoped_restore_current_language
Definition: language.h:664
putchar_unfiltered
int putchar_unfiltered(int c)
Definition: utils.c:1817
thread_control_state::stop_bpstat
bpstat stop_bpstat
Definition: gdbthread.h:139
dbx_commands
int dbx_commands
Definition: main.c:56
print_one_catch_vfork
static void print_one_catch_vfork(struct breakpoint *b, struct bp_location **last_loc)
Definition: breakpoint.c:7931
target_insert_mask_watchpoint
int target_insert_mask_watchpoint(CORE_ADDR addr, CORE_ADDR mask, enum target_hw_bp_type rw)
Definition: target.c:3513
remove_solib_event_breakpoints
void remove_solib_event_breakpoints(void)
Definition: breakpoint.c:7520
blockvector_for_pc_sect
const struct blockvector * blockvector_for_pc_sect(CORE_ADDR pc, struct obj_section *section, const struct block **pblock, struct compunit_symtab *cust)
Definition: block.c:184
current_ui
struct ui * current_ui
Definition: event-top.c:453
get_selected_frame
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1638
bp_locations_compare_addrs
static int bp_locations_compare_addrs(const void *ap, const void *bp)
Definition: breakpoint.c:792
base_breakpoint_create_breakpoints_sal
static void base_breakpoint_create_breakpoints_sal(struct gdbarch *gdbarch, struct linespec_result *c, gdb::unique_xmalloc_ptr< char > cond_string, gdb::unique_xmalloc_ptr< char > extra_string, enum bptype type_wanted, enum bpdisp disposition, int thread, int task, int ignore_count, const struct breakpoint_ops *o, int from_tty, int enabled, int internal, unsigned flags)
Definition: breakpoint.c:12437
bp_enabled
Definition: breakpoint.h:202
get_cmd_context
void * get_cmd_context(struct cmd_list_element *cmd)
Definition: cli-decode.c:148
breakpoint::language
enum language language
Definition: breakpoint.h:744
delete_longjmp_breakpoint_cleanup
void delete_longjmp_breakpoint_cleanup(void *arg)
Definition: infcmd.c:955
BP_TEMPFLAG
#define BP_TEMPFLAG
Definition: breakpoint.c:4852
watch_maybe_just_location
static void watch_maybe_just_location(const char *arg, int accessflag, int from_tty)
Definition: breakpoint.c:11018
bp_thread_event
Definition: breakpoint.h:143
WP_IGNORE
Definition: breakpoint.c:4849
observer_attach_free_objfile
struct observer * observer_attach_free_objfile(observer_free_objfile_ftype *f)
static_tracepoint_marker::str_id
char * str_id
Definition: tracepoint.h:221
print_one_catch_exec
static void print_one_catch_exec(struct breakpoint *b, struct bp_location **last_loc)
Definition: breakpoint.c:8360
uploaded_tp::pass
int pass
Definition: tracepoint.h:173
ui_out::field_core_addr
void field_core_addr(const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition: ui-out.c:513
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
breakpoint_condition_evaluation_mode
static const char * breakpoint_condition_evaluation_mode(void)
Definition: breakpoint.c:466
SYMBOL_PRINT_NAME
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:542
agent_expr_up
std::unique_ptr< agent_expr > agent_expr_up
Definition: ax.h:159
remove_threaded_breakpoints
static void remove_threaded_breakpoints(struct thread_info *tp, int silent)
Definition: breakpoint.c:3055
bp_location::length
int length
Definition: breakpoint.h:432
value_print
void value_print(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:1163
check_tracepoint_command
void check_tracepoint_command(char *line, void *closure)
Definition: breakpoint.c:1219
exp_element::opcode
enum exp_opcode opcode
Definition: expression.h:64
handle_jit_event
static void handle_jit_event(void)
Definition: breakpoint.c:5538
show_automatic_hardware_breakpoints
static void show_automatic_hardware_breakpoints(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: breakpoint.c:362
target_waitstatus
Definition: waitstatus.h:104
value_equal_contents
int value_equal_contents(struct value *arg1, struct value *arg2)
Definition: valarith.c:1549
bp_gnu_ifunc_resolver_return
Definition: breakpoint.h:193
bpstat_remove_bp_location
static void bpstat_remove_bp_location(bpstat bps, struct breakpoint *bpt)
Definition: breakpoint.c:12226
breakpoint_objfile_data::terminate_msym
Definition: breakpoint.c:3159
get_current_frame
struct frame_info * get_current_frame(void)
Definition: frame.c:1563
internal_bkpt_re_set
static void internal_bkpt_re_set(struct breakpoint *b)
Definition: breakpoint.c:12717
ui_out::field_string
void field_string(const char *fldname, const char *string)
Definition: ui-out.c:544
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
base_breakpoint_print_mention
static void base_breakpoint_print_mention(struct breakpoint *b)
Definition: breakpoint.c:12416
watch_triggered_no
Definition: breakpoint.h:652
bp_exception_master
Definition: breakpoint.h:164
this_utp
static struct uploaded_tp * this_utp
Definition: breakpoint.c:14770
ui_out_emit_type
Definition: ui-out.h:192
gdb::array_view::size
constexpr size_type size() const noexcept
Definition: array-view.h:169
disable_breakpoints_before_startup
void disable_breakpoints_before_startup(void)
Definition: breakpoint.c:8507
program_space::aspace
struct address_space * aspace
Definition: progspace.h:166
RETURN_MASK_ALL
Definition: common-exceptions.h:44
bp_breakpoint
Definition: breakpoint.h:70
bp_location::watchpoint_type
target_hw_bp_type watchpoint_type
Definition: breakpoint.h:435
tracepoint_probe_create_sals_from_location
static void tracepoint_probe_create_sals_from_location(const struct event_location *location, struct linespec_result *canonical, enum bptype type_wanted)
Definition: breakpoint.c:13034
insert_breakpoints
void insert_breakpoints(void)
Definition: breakpoint.c:2845
STOP_NONE
Definition: breakpoint.h:994
bkpt_decode_location
static std::vector< symtab_and_line > bkpt_decode_location(struct breakpoint *b, const struct event_location *location, struct program_space *search_pspace)
Definition: breakpoint.c:12707
breakpoint_1
static int breakpoint_1(const char *args, int allflag, int(*filter)(const struct breakpoint *))
Definition: breakpoint.c:6514
catch_vfork_breakpoint_ops
static struct breakpoint_ops catch_vfork_breakpoint_ops
Definition: breakpoint.c:7977
is_breakpoint
int is_breakpoint(const struct breakpoint *bpt)
Definition: breakpoint.c:1512
BREAK_ARGS_HELP
#define BREAK_ARGS_HELP(command)
Definition: breakpoint.c:15290
ptid_get_pid
int ptid_get_pid(const ptid_t &ptid)
Definition: ptid.c:47
breakpoint_ops::works_in_software_mode
int(* works_in_software_mode)(const struct breakpoint *)
Definition: breakpoint.h:564
save_command
static void save_command(const char *arg, int from_tty)
Definition: breakpoint.c:15339
uploaded_tp::number
int number
Definition: tracepoint.h:168
breakpoint_locations_match
static int breakpoint_locations_match(struct bp_location *loc1, struct bp_location *loc2)
Definition: breakpoint.c:6924
command.h
expression_up
gdb::unique_xmalloc_ptr< expression > expression_up
Definition: expression.h:87
get_thread_regcache
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:434
thread_fsm
Definition: thread-fsm.h:31
arm-linux.m
m
Definition: arm-linux.py:44
bpstat_clear
void bpstat_clear(bpstat *bsp)
Definition: breakpoint.c:4212
error_stream
void error_stream(const string_file &stream)
Definition: utils.c:255
print_one_breakpoint_location
static void print_one_breakpoint_location(struct breakpoint *b, struct bp_location *loc, int loc_number, struct bp_location **last_loc, int allflag)
Definition: breakpoint.c:6055
pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1824
xfree
void xfree(void *)
bpstat_clear_actions
void bpstat_clear_actions(void)
Definition: breakpoint.c:4349
thread_info::initiating_frame
struct frame_id initiating_frame
Definition: gdbthread.h:351
read_command_lines_1
command_line_up read_command_lines_1(char *(*read_next_line_func)(void), int parse_commands, void(*validator)(char *, void *), void *closure)
Definition: cli-script.c:1243
LOC_BLOCK
Definition: symtab.h:854
annotate_record
void annotate_record(void)
Definition: annotate.c:191
all_locations_are_pending
static int all_locations_are_pending(struct breakpoint *b, struct program_space *pspace)
Definition: breakpoint.c:13395
may_insert_fast_tracepoints
int may_insert_fast_tracepoints
ordinary_breakpoint_here
Definition: breakpoint.h:1154
create_solib_event_breakpoint
struct breakpoint * create_solib_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7560
works_in_software_mode_watchpoint
static int works_in_software_mode_watchpoint(const struct breakpoint *b)
Definition: breakpoint.c:10241
solist.h
no_class
Definition: command.h:41
enablelist
struct cmd_list_element * enablelist
Definition: cli-cmds.c:87
print_recreate_catch_fork
static void print_recreate_catch_fork(struct breakpoint *b, struct ui_file *fp)
Definition: breakpoint.c:7854
print_recreate_masked_watchpoint
static void print_recreate_masked_watchpoint(struct breakpoint *b, struct ui_file *fp)
Definition: breakpoint.c:10571
gnu_ifunc_resolver_stop
#define gnu_ifunc_resolver_stop
Definition: symtab.h:1738
base_breakpoint_remove_location
static int base_breakpoint_remove_location(struct bp_location *bl, enum remove_bp_reason reason)
Definition: breakpoint.c:12363
add_setshow_auto_boolean_cmd
void add_setshow_auto_boolean_cmd(const char *name, enum command_class theclass, enum auto_boolean *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:544
bpstat_print
enum print_stop_action bpstat_print(bpstat bs, int kind)
Definition: breakpoint.c:4686
breakpoint::pspace
program_space * pspace
Definition: breakpoint.h:727
bp_gnu_ifunc_resolver
Definition: breakpoint.h:187
condition_completer
static void condition_completer(struct cmd_list_element *cmd, completion_tracker &tracker, const char *text, const char *word)
Definition: breakpoint.c:912
class_support
Definition: command.h:42
section_is_overlay
int section_is_overlay(struct obj_section *section)
Definition: symfile.c:2978
create_fork_vfork_event_catchpoint
static void create_fork_vfork_event_catchpoint(struct gdbarch *gdbarch, int tempflag, const char *cond_string, const struct breakpoint_ops *ops)
Definition: breakpoint.c:8271
print_it_normal
Definition: breakpoint.h:1078
cmd_const_sfunc_ftype
void cmd_const_sfunc_ftype(const char *args, int from_tty, struct cmd_list_element *c)
Definition: command.h:177
disp_del
Definition: breakpoint.h:219
disp_del_at_next_stop
Definition: breakpoint.h:220
value_as_long
LONGEST value_as_long(struct value *val)
Definition: value.c:2749
momentary_bkpt_check_status
static void momentary_bkpt_check_status(bpstat bs)
Definition: breakpoint.c:12823
cmd_list_element
Definition: cli-decode.h:46
frame_unwind_caller_pc
CORE_ADDR frame_unwind_caller_pc(struct frame_info *this_frame)
Definition: frame.c:944
number_is_in_list
int number_is_in_list(const char *list, int number)
Definition: cli-utils.c:227
BPSTAT_WHAT_SINGLE
Definition: breakpoint.h:952
func
void(* func)(char *)
Definition: remote-fileio.c:1104
if
if(!(yy_init))
Definition: ada-lex.c:1075
until_break_fsm
Definition: breakpoint.c:11068
breakpoint_address_match
int breakpoint_address_match(const address_space *aspace1, CORE_ADDR addr1, const address_space *aspace2, CORE_ADDR addr2)
Definition: breakpoint.c:6838
base_breakpoint_print_recreate
static void base_breakpoint_print_recreate(struct breakpoint *b, struct ui_file *fp)
Definition: breakpoint.c:12422
breakpoint_address_is_meaningful
static int breakpoint_address_is_meaningful(struct breakpoint *bpt)
Definition: breakpoint.c:6784
gdb_regex.h
frame_unwind_caller_arch
struct gdbarch * frame_unwind_caller_arch(struct frame_info *next_frame)
Definition: frame.c:2725
CREATE_BREAKPOINT_FLAGS_INSERTED
Definition: breakpoint.h:1329
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
fork_catchpoint
Definition: breakpoint.c:7740
warning
void warning(const char *fmt,...)
Definition: errors.c:26
CATCH_TEMPORARY
#define CATCH_TEMPORARY
Definition: breakpoint.h:1283
ui_out::wrap_hint
void void wrap_hint(const char *identstring)
Definition: ui-out.c:597
tracepoint
Definition: breakpoint.h:874
deprecate_cmd
struct cmd_list_element * deprecate_cmd(struct cmd_list_element *cmd, const char *replacement)
Definition: cli-decode.c:292
regcache::regcache
regcache(gdbarch *gdbarch)
Definition: regcache.h:235
ui::async
int async
Definition: top.h:102
target_enable_tracepoint
#define target_enable_tracepoint(loc)
Definition: target.h:2140
compare_breakpoints
static int compare_breakpoints(const breakpoint *a, const breakpoint *b)
Definition: breakpoint.c:11443
agent_printf_command
static void agent_printf_command(const char *arg, int from_tty)
Definition: breakpoint.c:9729
create_breakpoint_sal
static void create_breakpoint_sal(struct gdbarch *gdbarch, gdb::array_view< const symtab_and_line > sals, event_location_up &&location, gdb::unique_xmalloc_ptr< char > filter, gdb::unique_xmalloc_ptr< char > cond_string, gdb::unique_xmalloc_ptr< char > extra_string, enum bptype type, enum bpdisp disposition, int thread, int task, int ignore_count, const struct breakpoint_ops *ops, int from_tty, int enabled, int internal, unsigned flags, int display_canonical)
Definition: breakpoint.c:8994
thread_fsm_ops
Definition: thread-fsm.h:50
next_cmd
static int next_cmd
Definition: breakpoint.c:14771
info_breakpoints_command
static void info_breakpoints_command(const char *args, int from_tty)
Definition: breakpoint.c:6676
query
int query(const char *ctlstr,...)
Definition: utils.c:1063
print_mention_catch_fork
static void print_mention_catch_fork(struct breakpoint *b)
Definition: breakpoint.c:7845
jit_breakpoint_re_set
void jit_breakpoint_re_set(void)
Definition: jit.c:1399
tbreak_command
void tbreak_command(const char *arg, int from_tty)
Definition: breakpoint.c:9602
bpstat_what::is_longjmp
int is_longjmp
Definition: breakpoint.h:1016
objfile::pspace
struct program_space * pspace
Definition: objfiles.h:315
value_bitsize
LONGEST value_bitsize(const struct value *value)
Definition: value.c:1128
bpdisp
bpdisp
Definition: breakpoint.h:217
bp_longjmp_resume
Definition: breakpoint.h:80
bp_longjmp_call_dummy
Definition: breakpoint.h:86
hbreak_command
static void hbreak_command(const char *arg, int from_tty)
Definition: breakpoint.c:9608
print_mention_watchpoint
static void print_mention_watchpoint(struct breakpoint *b)
Definition: breakpoint.c:10339
enablebreaklist
static struct cmd_list_element * enablebreaklist
Definition: breakpoint.c:15591
breakpoint_ops::print_it
enum print_stop_action(* print_it)(struct bpstats *bs)
Definition: breakpoint.h:568
BPSTAT_WHAT_STEP_RESUME
Definition: breakpoint.h:965
bp_step_resume
Definition: breakpoint.h:97
target_supports_enable_disable_tracepoint
#define target_supports_enable_disable_tracepoint()
Definition: target.h:1419
bp_location::enabled
bool enabled
Definition: breakpoint.h:385
breakpoint_auto_delete
void breakpoint_auto_delete(bpstat bs)
Definition: breakpoint.c:11624
ada-lang.h
deprecated_value_modifiable
int deprecated_value_modifiable(const struct value *value)
Definition: value.c:1580
show_always_inserted_mode
static void show_always_inserted_mode(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: breakpoint.c:381
bp_location_has_shadow
static int bp_location_has_shadow(struct bp_location *bl)
Definition: breakpoint.c:1298
find_pc_sect_function
struct symbol * find_pc_sect_function(CORE_ADDR pc, struct obj_section *section)
Definition: blockframe.c:136
catch_unload_command_1
static void catch_unload_command_1(const char *arg, int from_tty, struct cmd_list_element *command)
Definition: breakpoint.c:8229
set_language
enum language set_language(enum language lang)
Definition: language.c:379
new_linespec_location
event_location_up new_linespec_location(const char **linespec, symbol_name_match_type match_type)
Definition: location.c:88
breakpoint::commands
counted_command_line commands
Definition: breakpoint.h:719
EXEC_ASYNC_LOCATION_REACHED
Definition: mi-common.h:36
install_breakpoint
void install_breakpoint(int internal, std::unique_ptr< breakpoint > &&arg, int update_gll)
Definition: breakpoint.c:8256
ranged_breakpoint_ops
static struct breakpoint_ops ranged_breakpoint_ops
Definition: breakpoint.c:9878
pending_break_support
static enum auto_boolean pending_break_support
Definition: breakpoint.c:344
TRIBOOL_TRUE
Definition: common-types.h:61
extract_bp_or_bp_range
static std::pair< int, int > extract_bp_or_bp_range(extract_bp_kind kind, const std::string &arg, std::string::size_type arg_offset)
Definition: breakpoint.c:14207
plongest
char * plongest(LONGEST l)
Definition: print-utils.c:137
catch_cmdlist
static struct cmd_list_element * catch_cmdlist
Definition: breakpoint.c:15311
maintenanceinfolist
struct cmd_list_element * maintenanceinfolist
Definition: cli-cmds.c:139
bp_location::events_till_retirement
int events_till_retirement
Definition: breakpoint.h:476
lval_register
Definition: defs.h:385
invalid_thread_id_error
void ATTRIBUTE_NORETURN invalid_thread_id_error(const char *string)
Definition: tid-parse.c:29
interp
Definition: interps.h:41
ui_out::field_skip
void field_skip(const char *fldname)
Definition: ui-out.c:532
get_current_source_symtab_and_line
struct symtab_and_line get_current_source_symtab_and_line(void)
Definition: source.c:171
annotate_field
void annotate_field(int num)
Definition: annotate.c:177
momentary_bkpt_print_it
static enum print_stop_action momentary_bkpt_print_it(bpstat bs)
Definition: breakpoint.c:12829
breakpoint::display_canonical
bool display_canonical
Definition: breakpoint.h:708
bp_location::overlay_target_info
bp_target_info overlay_target_info
Definition: breakpoint.h:465
breakpoint_ops::resources_needed
int(* resources_needed)(const struct bp_location *)
Definition: breakpoint.h:559
print_mention_ranged_breakpoint
static void print_mention_ranged_breakpoint(struct breakpoint *b)
Definition: breakpoint.c:9848
extract_arg
std::string extract_arg(const char **arg)
Definition: cli-utils.c:259
internal_error_pure_virtual_called
#define internal_error_pure_virtual_called()
Definition: breakpoint.c:12353
print_recreate_catch_solib
static void print_recreate_catch_solib(struct breakpoint *b, struct ui_file *fp)
Definition: breakpoint.c:8158
add_info
struct cmd_list_element * add_info(const char *name, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:886
condition_evaluation_mode
static const char * condition_evaluation_mode
Definition: breakpoint.c:442
memattr.h
need_moribund_for_location_type
static int need_moribund_for_location_type(struct bp_location *loc)
Definition: breakpoint.c:5337
breakpoint_objfile_data
Definition: breakpoint.c:3143
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
breakpoint::number
int number
Definition: breakpoint.h:699
select_frame
void select_frame(struct frame_info *fi)
Definition: frame.c:1677
target_supports_stopped_by_sw_breakpoint
#define target_supports_stopped_by_sw_breakpoint()
Definition: target.h:1885
uploaded_tp::enabled
int enabled
Definition: tracepoint.h:171
bp_type
bp_type
Definition: mi-cmd-break.c:68
get_stack_frame_id
struct frame_id get_stack_frame_id(struct frame_info *next_frame)
Definition: frame.c:549
create_breakpoints_sal_default
static void create_breakpoints_sal_default(struct gdbarch *, struct linespec_result *, gdb::unique_xmalloc_ptr< char >, gdb::unique_xmalloc_ptr< char >, enum bptype, enum bpdisp, int, int, int, const struct breakpoint_ops *, int, int, int, unsigned)
Definition: breakpoint.c:13891
gdb_exception::error
enum errors error
Definition: common-exceptions.h:114
bpstats::next
bpstat next
Definition: breakpoint.h:1099
SYMBOL_CLASS
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:1155
automatic_hardware_breakpoints
static int automatic_hardware_breakpoints
Definition: breakpoint.c:360
save_breakpoints
static void save_breakpoints(const char *filename, int from_tty, int(*filter)(const struct breakpoint *))
Definition: breakpoint.c:15110
catch_fork_kind
catch_fork_kind
Definition: breakpoint.c:11304
memset
void * memset(T *s, int c, size_t n)=delete
show_thread_that_caused_stop
int show_thread_that_caused_stop(void)
Definition: thread.c:1586
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
valid_global_thread_id
int valid_global_thread_id(int global_id)
Definition: thread.c:593
null_frame_id
const struct frame_id null_frame_id
Definition: frame.c:575
inferior_thread
struct thread_info * inferior_thread(void)
Definition: thread.c:90
update_global_location_list_nothrow
static void update_global_location_list_nothrow(enum ugll_insert_mode)
Definition: breakpoint.c:12210
breakpoint::location_range_end
event_location_up location_range_end
Definition: breakpoint.h:739
ui_out::table_header
void table_header(int width, ui_align align, const std::string &col_name, const std::string &col_hdr)
Definition: ui-out.c:365
ax-gdb.h
breakpoint::silent
bool silent
Definition: breakpoint.h:706
language_def
const struct language_defn * language_def(enum language lang)
Definition: language.c:494
static_tracepoint_marker::gdbarch
struct gdbarch * gdbarch
Definition: tracepoint.h:217
bp_location::requested_address
CORE_ADDR requested_address
Definition: breakpoint.h:448
bp_location_ops
Definition: breakpoint.h:308
awatch_command_wrapper
void awatch_command_wrapper(const char *arg, int from_tty, int internal)
Definition: breakpoint.c:11052
print_one_catch_fork
static void print_one_catch_fork(struct breakpoint *b, struct bp_location **last_loc)
Definition: breakpoint.c:7815
deletelist
struct cmd_list_element * deletelist
Definition: cli-cmds.c:99
VEC_unordered_remove
#define VEC_unordered_remove(T, V, I)
Definition: vec.h:367
dprintf_re_set
static void dprintf_re_set(struct breakpoint *b)
Definition: breakpoint.c:13056
watchpoint::val
struct value * val
Definition: breakpoint.h:816
PRINT_UNKNOWN
Definition: breakpoint.h:501
inferior
Definition: inferior.h:310
add_setshow_enum_cmd
void add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:515
strace_command
static void strace_command(const char *arg, int from_tty)
Definition: breakpoint.c:14736
breakpoint_ops::print_mention
void(* print_mention)(struct breakpoint *)
Definition: breakpoint.h:590
AUTO_BOOLEAN_AUTO
Definition: defs.h:241
target_waitstatus::value
union target_waitstatus::@174 value
exception_none
const struct gdb_exception exception_none
Definition: common-exceptions.c:23
bpstat_check_breakpoint_conditions
static void bpstat_check_breakpoint_conditions(bpstat bs, ptid_t ptid)
Definition: breakpoint.c:5195
value_lazy
int value_lazy(const struct value *value)
Definition: value.c:1383
gdbarch_breakpoint_kind_from_pc
int gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr)
Definition: gdbarch.c:2861
copy_event_location
event_location_up copy_event_location(const struct event_location *src)
Definition: location.c:307
bp_location::pspace
program_space * pspace
Definition: breakpoint.h:421
decode_static_tracepoint_spec
static std::vector< symtab_and_line > decode_static_tracepoint_spec(const char **arg_p)
Definition: breakpoint.c:9284
value_free
void value_free(struct value *val)
Definition: value.c:1608
bp_watchpoint
Definition: breakpoint.h:75
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
block_linkage_function
struct symbol * block_linkage_function(const struct block *bl)
Definition: block.c:100
class_vars
Definition: command.h:41
catch_fork_permanent
Definition: breakpoint.c:11307
program_space::breakpoints_not_allowed
int breakpoints_not_allowed
Definition: progspace.h:180
bkpt_insert_location
static int bkpt_insert_location(struct bp_location *bl)
Definition: breakpoint.c:12515
target_insert_watchpoint
#define target_insert_watchpoint(addr, len, type, cond)
Definition: target.h:1939
add_to_breakpoint_chain
static breakpoint * add_to_breakpoint_chain(std::unique_ptr< breakpoint > &&b)
Definition: breakpoint.c:7122
frame_info
Definition: frame.c:85
target_insert_fork_catchpoint
#define target_insert_fork_catchpoint(pid)
Definition: target.h:1570
parse_exp_1
expression_up parse_exp_1(const char **, CORE_ADDR pc, const struct block *, int)
Definition: parse.c:1089
value_copy
struct value * value_copy(struct value *arg)
Definition: value.c:1757
dprintf_breakpoint_ops
struct breakpoint_ops dprintf_breakpoint_ops
Definition: breakpoint.c:261
overlay_events_enabled
static int overlay_events_enabled
Definition: breakpoint.c:486
innermost_block
const struct block * innermost_block
Definition: parse.c:71
print_mention_catch_solib
static void print_mention_catch_solib(struct breakpoint *b)
Definition: breakpoint.c:8149
explicit_location::line_offset
struct line_offset line_offset
Definition: location.h:102
enable_trace_command
static void enable_trace_command(const char *args, int from_tty)
Definition: breakpoint.c:14901
ambiguous_names_p
static int ambiguous_names_p(struct bp_location *loc)
Definition: breakpoint.c:13413
LINE_OFFSET_NONE
Definition: location.h:30
stop_command
static void stop_command(const char *arg, int from_tty)
Definition: breakpoint.c:9620
bp_locations_shadow_len_after_address_max
static CORE_ADDR bp_locations_shadow_len_after_address_max
Definition: breakpoint.c:557
make_scoped_restore_show_memory_breakpoints
scoped_restore_tmpl< int > make_scoped_restore_show_memory_breakpoints(int show)
Definition: target.c:1250
filename_completer
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:152
base_breakpoint_allocate_location
static struct bp_location * base_breakpoint_allocate_location(struct breakpoint *self)
Definition: breakpoint.c:12342
language_defn::la_language
enum language la_language
Definition: language.h:144
so_list
Definition: solist.h:38
validate_actionline
void validate_actionline(const char *line, struct breakpoint *b)
Definition: tracepoint.c:643
breakpoint_ops::allocate_location
struct bp_location *(* allocate_location)(struct breakpoint *)
Definition: breakpoint.h:523
watchpoint::cond_exp_valid_block
const struct block * cond_exp_valid_block
Definition: breakpoint.h:812
is_masked_watchpoint
static int is_masked_watchpoint(const struct breakpoint *b)
Definition: breakpoint.c:10604
create_thread_event_breakpoint
struct breakpoint * create_thread_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7475
set_breakpoint_cmd
static void set_breakpoint_cmd(const char *args, int from_tty)
Definition: breakpoint.c:14551
print_bp_stop_message
static enum print_stop_action print_bp_stop_message(bpstat bs)
Definition: breakpoint.c:4566
VEC_safe_push
#define VEC_safe_push(T, V, O)
Definition: vec.h:276
expression::nelts
int nelts
Definition: expression.h:83
symtab_and_line::section
struct obj_section * section
Definition: symtab.h:1753
cmdlist
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:79
linespec_location::spec_string
char * spec_string
Definition: location.h:77
breakpoint::ops
const breakpoint_ops * ops
Definition: breakpoint.h:689
set_next_address
void set_next_address(struct gdbarch *, CORE_ADDR)
Definition: printcmd.c:499
solib_catchpoint::~solib_catchpoint
~solib_catchpoint() override
Definition: breakpoint.c:7996
save_trace_state_variables
void save_trace_state_variables(struct ui_file *fp)
Definition: tracepoint.c:503
BPSTAT_WHAT_KEEP_CHECKING
Definition: breakpoint.h:945
bp_watchpoint_scope
Definition: breakpoint.h:115
longjmp_breakpoint::~longjmp_breakpoint
~longjmp_breakpoint() override
Definition: breakpoint.c:12845
probe::clear_semaphore
virtual void clear_semaphore(struct objfile *objfile, struct gdbarch *gdbarch)
Definition: probe.h:162
get_tracepoint
struct tracepoint * get_tracepoint(int num)
Definition: breakpoint.c:15018
OBJF_SHARED
Definition: objfile-flags.h:42
set_raw_breakpoint
struct breakpoint * set_raw_breakpoint(struct gdbarch *gdbarch, struct symtab_and_line, enum bptype, const struct breakpoint_ops *)
Definition: breakpoint.c:7280
set_breakpoint_number
static void set_breakpoint_number(int internal, struct breakpoint *b)
Definition: breakpoint.c:3108
lookup_internalvar
struct internalvar * lookup_internalvar(const char *name)
Definition: value.c:2212
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
cleanup
Definition: cleanups.c:38
TARGET_WAITKIND_EXECD
Definition: waitstatus.h:56
_
#define _(String)
Definition: gdb_locale.h:35
linespec_result::location
event_location_up location
Definition: linespec.h:76
print_breakpoint_location
static void print_breakpoint_location(struct breakpoint *b, struct bp_location *loc)
Definition: breakpoint.c:5883
value_contents_for_printing
const gdb_byte * value_contents_for_printing(struct value *value)
Definition: value.c:1250
set_longjmp_breakpoint
void set_longjmp_breakpoint(struct thread_info *tp, struct frame_id frame)
Definition: breakpoint.c:7295
ovly_auto
Definition: symfile.h:482
ui_file
Definition: ui-file.h:26
find_condition_and_thread
static void find_condition_and_thread(const char *tok, CORE_ADDR pc, char **cond_string, int *thread, int *task, char **rest)
Definition: breakpoint.c:9212
breakpoint_proceeded
static int breakpoint_proceeded
Definition: breakpoint.c:311
enable_disable_bp_num_loc
static void enable_disable_bp_num_loc(int bp_num, int loc_num, bool enable)
Definition: breakpoint.c:14292
uploaded_tp::traceframe_usage
ULONGEST traceframe_usage
Definition: tracepoint.h:197
read_uploaded_action
static char * read_uploaded_action(void)
Definition: breakpoint.c:14774
save_tracepoints_command
static void save_tracepoints_command(const char *args, int from_tty)
Definition: breakpoint.c:15236
output_thread_groups
static void output_thread_groups(struct ui_out *uiout, const char *field_name, const std::vector< int > &inf_nums, int mi_only)
Definition: breakpoint.c:6017
bpstat_causes_stop
int bpstat_causes_stop(bpstat bs)
Definition: breakpoint.c:5780
number_of_inferiors
int number_of_inferiors(void)
Definition: inferior.c:486
LINESPEC_LOCATION
Definition: location.h:57
hw_breakpoint_used_count
static int hw_breakpoint_used_count(void)
Definition: breakpoint.c:8405
bkpt_remove_location
static int bkpt_remove_location(struct bp_location *bl, enum remove_bp_reason reason)
Definition: breakpoint.c:12529
decref_bp_location
static void decref_bp_location(struct bp_location **loc)
Definition: breakpoint.c:7110
new_until_break_fsm
static struct until_break_fsm * new_until_break_fsm(struct interp *cmd_interp, int thread, breakpoint_up &&location_breakpoint, breakpoint_up &&caller_breakpoint)
Definition: breakpoint.c:11105
breakpoint_enabled
static int breakpoint_enabled(struct breakpoint *b)
Definition: breakpoint.c:601
ui_left
Definition: ui-out.h:44
defs.h
breakpoint::related_breakpoint
breakpoint * related_breakpoint
Definition: breakpoint.h:759
add_location_to_breakpoint
static struct bp_location * add_location_to_breakpoint(struct breakpoint *, const struct symtab_and_line *)
Definition: breakpoint.c:8650
char_ptr
char * char_ptr
Definition: gdb_vecs.h:25
target_remove_mask_watchpoint
int target_remove_mask_watchpoint(CORE_ADDR addr, CORE_ADDR mask, enum target_hw_bp_type rw)
Definition: target.c:3524
create_exception_master_breakpoint
static void create_exception_master_breakpoint(void)
Definition: breakpoint.c:3425
breakpoint_re_set_default
static void breakpoint_re_set_default(struct breakpoint *)
Definition: breakpoint.c:13852
gen_printf
agent_expr_up gen_printf(CORE_ADDR scope, struct gdbarch *gdbarch, CORE_ADDR function, LONGEST channel, const char *format, int fmtlen, int nargs, struct expression **exprs)
Definition: ax-gdb.c:2541
TARGET_WAITKIND_FORKED
Definition: waitstatus.h:48
program_breakpoint_here_p
int program_breakpoint_here_p(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:8715
build_target_command_list
static void build_target_command_list(struct bp_location *bl)
Definition: breakpoint.c:2305
bp_single_step
Definition: breakpoint.h:72
set_cmd_sfunc
void set_cmd_sfunc(struct cmd_list_element *cmd, cmd_const_sfunc_ftype *sfunc)
Definition: cli-decode.c:126
ALL_BREAKPOINTS_SAFE
#define ALL_BREAKPOINTS_SAFE(B, TMP)
Definition: breakpoint.c:497
breakpoint_hit_catch_solib
static int breakpoint_hit_catch_solib(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.c:8014
target_stopped_by_watchpoint
#define target_stopped_by_watchpoint()
Definition: target.h:1876
bp_longjmp
Definition: breakpoint.h:79
tracepoint_breakpoint_ops
struct breakpoint_ops tracepoint_breakpoint_ops
Definition: breakpoint.c:13027
DECODE_LINE_FUNFIRSTLINE
Definition: linespec.h:31
breakpoint_program_space_exit
void breakpoint_program_space_exit(struct program_space *pspace)
Definition: breakpoint.c:2802
bkpt_create_sals_from_location
static void bkpt_create_sals_from_location(const struct event_location *location, struct linespec_result *canonical, enum bptype type_wanted)
Definition: breakpoint.c:12677
momentary_breakpoint_from_master
static struct breakpoint * momentary_breakpoint_from_master(struct breakpoint *orig, enum bptype type, const struct breakpoint_ops *ops, int loc_enabled)
Definition: breakpoint.c:8575
print_it_noop
Definition: breakpoint.h:1081
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
stepping_past_instruction_at
int stepping_past_instruction_at(struct address_space *aspace, CORE_ADDR address)
Definition: infrun.c:1355
VALUE_LVAL
#define VALUE_LVAL(val)
Definition: value.h:414
enable_breakpoint
void enable_breakpoint(struct breakpoint *bpt)
Definition: breakpoint.c:14485
allocate_value
struct value * allocate_value(struct type *type)
Definition: value.c:1036
insert_catch_exec
static int insert_catch_exec(struct bp_location *bl)
Definition: breakpoint.c:8308
bp_location::section
obj_section * section
Definition: breakpoint.h:440
ui_out::text
void text(const char *string)
Definition: ui-out.c:581
arm-linux.inf
inf
Definition: arm-linux.py:13
delete_longjmp_breakpoint
void delete_longjmp_breakpoint(int thread)
Definition: breakpoint.c:7324
lookup_minimal_symbol_text
struct bound_minimal_symbol lookup_minimal_symbol_text(const char *name, struct objfile *objf)
Definition: minsyms.c:519
class_info
Definition: command.h:42
get_current_regcache
struct regcache * get_current_regcache(void)
Definition: regcache.c:446
moribund_breakpoint_here_p
int moribund_breakpoint_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4056
target_terminal::inferior
static void inferior()
Definition: target.c:450
target_stopped_data_address
#define target_stopped_data_address(target, addr_p)
Definition: target.h:1984
works_in_software_mode_masked_watchpoint
static int works_in_software_mode_masked_watchpoint(const struct breakpoint *b)
Definition: breakpoint.c:10460
insert_single_step_breakpoint
void insert_single_step_breakpoint(struct gdbarch *gdbarch, const address_space *aspace, CORE_ADDR next_pc)
Definition: breakpoint.c:14597
block_for_pc
const struct block * block_for_pc(CORE_ADDR pc)
Definition: block.c:282
is_addr_in_objfile
int is_addr_in_objfile(CORE_ADDR addr, const struct objfile *objfile)
Definition: objfiles.c:1494
_initialize_breakpoint
void _initialize_breakpoint(void)
Definition: breakpoint.c:15594
bp_location::function_name
char * function_name
Definition: breakpoint.h:459
breakpoint::gdbarch
struct gdbarch * gdbarch
Definition: breakpoint.h:742
bp_location::needs_update
bool needs_update
Definition: breakpoint.h:377
unpack_value_bitfield
void unpack_value_bitfield(struct value *dest_val, LONGEST bitpos, LONGEST bitsize, const gdb_byte *valaddr, LONGEST embedded_offset, const struct value *val)
Definition: value.c:3336
may_insert_tracepoints
int may_insert_tracepoints
until_break_fsm_async_reply_reason
static enum async_reply_reason until_break_fsm_async_reply_reason(struct thread_fsm *self)
Definition: breakpoint.c:11167
bpstat_stop_status
bpstat bpstat_stop_status(const address_space *aspace, CORE_ADDR bp_addr, ptid_t ptid, const struct target_waitstatus *ws)
Definition: breakpoint.c:5365
progspace-and-thread.h
linespec_result::pre_expanded
bool pre_expanded
Definition: linespec.h:72
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
watchpoint::exp_string
char * exp_string
Definition: breakpoint.h:799
longest_to_int
int longest_to_int(LONGEST)
Definition: valprint.c:1341
dummy_frame_discard
void dummy_frame_discard(struct frame_id dummy_id, ptid_t ptid)
Definition: dummy-frame.c:221
condition_updated
Definition: breakpoint.h:233
hw_write
Definition: break-common.h:24
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
new_type
static struct type * new_type(char *)
Definition: mdebugread.c:4852
breakpoint_set_task
void breakpoint_set_task(struct breakpoint *b, int task)
Definition: breakpoint.c:1209
bpstats::bpstats
bpstats()
Definition: breakpoint.c:4746
initialize_explicit_location
void initialize_explicit_location(struct explicit_location *explicit_loc)
Definition: location.c:78
bkpt_base_breakpoint_ops
static struct breakpoint_ops bkpt_base_breakpoint_ops
Definition: breakpoint.c:245
SYMBOL_OBJ_SECTION
#define SYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:471
arch-utils.h
program_space::num
int num
Definition: progspace.h:143
find_pc_overlay
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3173
info_watchpoints_command
static void info_watchpoints_command(const char *args, int from_tty)
Definition: breakpoint.c:6684
get_frame_address_space
const address_space * get_frame_address_space(struct frame_info *frame)
Definition: frame.c:2646
exp_element::symbol
struct symbol * symbol
Definition: expression.h:65
bp_locations_count
static unsigned bp_locations_count
Definition: breakpoint.c:541
is_longjmp_type
static bool is_longjmp_type(bptype type)
Definition: breakpoint.c:1047
XNEW
#define XNEW(T)
Definition: poison.h:109
tracepoint::step_count
long step_count
Definition: breakpoint.h:878
set_current_program_space
void set_current_program_space(struct program_space *pspace)
Definition: progspace.c:190
ovly_off
Definition: symfile.h:480
bp_loc_hardware_breakpoint
Definition: breakpoint.h:299
input_radix
unsigned input_radix
Definition: valprint.c:157
observer.h
symtab_to_fullname
const char * symtab_to_fullname(struct symtab *s)
Definition: source.c:1131
bpstat_should_step
int bpstat_should_step(void)
Definition: breakpoint.c:5769
stdio_file
Definition: ui-file.h:152
line_offset::sign
enum offset_relative_sign sign
Definition: location.h:48
target_insert_vfork_catchpoint
#define target_insert_vfork_catchpoint(pid)
Definition: target.h:1576
add_prefix_cmd
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:367
breakpoint_free_objfile
void breakpoint_free_objfile(struct objfile *objfile)
Definition: breakpoint.c:15404
base_breakpoint_print_one_detail
static void base_breakpoint_print_one_detail(const struct breakpoint *self, struct ui_out *uiout)
Definition: breakpoint.c:12409
current_trace_status
struct trace_status * current_trace_status(void)
Definition: tracepoint.c:189
ALL_INFERIORS
#define ALL_INFERIORS(I)
Definition: inferior.h:548
WP_VALUE_CHANGED
Definition: breakpoint.c:4843
symtab_and_line::explicit_line
bool explicit_line
Definition: symtab.h:1762
adjust_breakpoint_address
static CORE_ADDR adjust_breakpoint_address(struct gdbarch *gdbarch, CORE_ADDR bpaddr, enum bptype bptype)
make_scoped_restore
scoped_restore_tmpl< T > make_scoped_restore(T *var)
Definition: scoped_restore.h:105
breakpoint::hit_count
int hit_count
Definition: breakpoint.h:773
MSYMBOL_OBJ_SECTION
#define MSYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:700
GENERIC_ERROR
Definition: common-exceptions.h:54
bkpt_print_it
static enum print_stop_action bkpt_print_it(bpstat bs)
Definition: breakpoint.c:12584
value_offset
LONGEST value_offset(const struct value *value)
Definition: value.c:1106
uploaded_tp::at_string
char * at_string
Definition: tracepoint.h:185
parser-defs.h
flags
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1891
delete_trace_command
static void delete_trace_command(const char *arg, int from_tty)
Definition: breakpoint.c:14916
null_cleanup
void null_cleanup(void *arg)
Definition: cleanups.c:294
condition_evaluation_enums
static const char *const condition_evaluation_enums[]
Definition: breakpoint.c:430
breakpoint_re_set_one
static void breakpoint_re_set_one(breakpoint *b)
Definition: breakpoint.c:13940
evaluate_expression
struct value * evaluate_expression(struct expression *exp)
Definition: eval.c:144
breakpoint_location_address_range_overlap
static int breakpoint_location_address_range_overlap(struct bp_location *, const address_space *, CORE_ADDR, int)
Definition: breakpoint.c:6887
TRY
#define TRY
Definition: common-exceptions.h:246
bp_target_info::tcommands
std::vector< agent_expr * > tcommands
Definition: breakpoint.h:276
in_thread_list
int in_thread_list(ptid_t ptid)
Definition: thread.c:628
bp_target_info
Definition: breakpoint.h:238
thread_count
int thread_count(void)
Definition: thread.c:567
breakpoint_address_bits
static int breakpoint_address_bits(struct breakpoint *b)
Definition: breakpoint.c:6458
symtab.h
iterate_over_threads
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:551
bp_shlib_event
Definition: breakpoint.h:133
frame_id_eq
int frame_id_eq(struct frame_id l, struct frame_id r)
Definition: frame.c:674
bpstat_do_actions_1
static int bpstat_do_actions_1(bpstat *bsp)
Definition: breakpoint.c:4412
command_line::line
char * line
Definition: cli-script.h:54
breakpoint_hit_watchpoint
static int breakpoint_hit_watchpoint(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.c:10197
catch_fork_command_1
static void catch_fork_command_1(const char *arg, int from_tty, struct cmd_list_element *command)
Definition: breakpoint.c:11312
breakpoint_ops::insert_location
int(* insert_location)(struct bp_location *)
Definition: breakpoint.h:533
info_tracepoints_command
static void info_tracepoints_command(const char *args, int from_tty)
Definition: breakpoint.c:14880
breakpoint_objfile_data::exception_probes
std::vector< probe * > exception_probes
Definition: breakpoint.c:3169
RETURN_ERROR
Definition: common-exceptions.h:35
format.h
extract_bp_kind::bp
set_raw_breakpoint_without_location
static struct breakpoint * set_raw_breakpoint_without_location(struct gdbarch *, enum bptype, const struct breakpoint_ops *)
Definition: breakpoint.c:7165
lval_memory
Definition: defs.h:383
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
bpstat_what::call_dummy
enum stop_stack_kind call_dummy
Definition: breakpoint.h:1011
name
const char *const name
Definition: aarch64-tdep.c:76
REMOVE_BREAKPOINT
Definition: breakpoint.h:51
find_breakpoint_range_end
static CORE_ADDR find_breakpoint_range_end(struct symtab_and_line sal)
Definition: breakpoint.c:9886
remove_breakpoint_1
static int remove_breakpoint_1(struct bp_location *, enum remove_bp_reason)
Definition: breakpoint.c:3685
re_set_watchpoint
static void re_set_watchpoint(struct breakpoint *b)
Definition: breakpoint.c:10140
PRINT_NOTHING
Definition: breakpoint.h:513
exec_catchpoint::exec_pathname
char * exec_pathname
Definition: breakpoint.c:8297
internal_bkpt_print_it
static enum print_stop_action internal_bkpt_print_it(bpstat bs)
Definition: breakpoint.c:12758
shared_objfile_contains_address_p
int shared_objfile_contains_address_p(struct program_space *pspace, CORE_ADDR address)
Definition: objfiles.c:1514
wrap_indent_at_field
static char * wrap_indent_at_field(struct ui_out *uiout, const char *col_name)
Definition: breakpoint.c:5796
thread_control_state::in_infcall
int in_infcall
Definition: gdbthread.h:130
VEC_iterate
#define VEC_iterate(T, V, I, P)
Definition: vec.h:181
mem_ranges_overlap
int mem_ranges_overlap(CORE_ADDR start1, int len1, CORE_ADDR start2, int len2)
Definition: memrange.c:25
bound_probe::objfile
struct objfile * objfile
Definition: probe.h:256
get_tracepoint_by_number_on_target
struct tracepoint * get_tracepoint_by_number_on_target(int num)
Definition: breakpoint.c:15034
uploaded_tp::type
enum bptype type
Definition: tracepoint.h:169
target_remove_breakpoint
int target_remove_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt, enum remove_bp_reason reason)
Definition: target.c:2003
gdb_optional.h
get_frame_id
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:520
default_collect_info
static void default_collect_info(void)
Definition: breakpoint.c:6658
set_breakpoint_count
static void set_breakpoint_count(int num)
Definition: breakpoint.c:609
breakpoint_re_set
void breakpoint_re_set(void)
Definition: breakpoint.c:13952
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
disp_donttouch
Definition: breakpoint.h:223
get_sal_arch
struct gdbarch * get_sal_arch(struct symtab_and_line sal)
Definition: breakpoint.c:7227
update_inserted_breakpoint_locations
static void update_inserted_breakpoint_locations(void)
Definition: breakpoint.c:2881
block_innermost_frame
struct frame_info * block_innermost_frame(const struct block *block)
Definition: blockframe.c:331
LOC_CONST_BYTES
Definition: symtab.h:859
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
copy_command_lines
command_line_up copy_command_lines(struct command_line *cmds)
Definition: cli-script.c:1333
BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
Definition: breakpoint.h:962
breakpoint::disposition
bpdisp disposition
Definition: breakpoint.h:697
bp_hp_step_resume
Definition: breakpoint.h:101
print_it_masked_watchpoint
static enum print_stop_action print_it_masked_watchpoint(bpstat bs)
Definition: breakpoint.c:10469
print_it_done
Definition: breakpoint.h:1084
contained_in
int contained_in(const struct block *a, const struct block *b)
Definition: block.c:73
print_mention_catch_vfork
static void print_mention_catch_vfork(struct breakpoint *b)
Definition: breakpoint.c:7960
solib_contains_address_p
int solib_contains_address_p(const struct so_list *const solib, CORE_ADDR address)
Definition: solib.c:1148
watchpoint::watchpoint_thread
ptid_t watchpoint_thread
Definition: breakpoint.h:834
exception_event_kind
exception_event_kind
Definition: break-catch-throw.c:41
tcatch_cmdlist
static struct cmd_list_element * tcatch_cmdlist
Definition: breakpoint.c:15314
breakpoint::extra_string
char * extra_string
Definition: breakpoint.h:753
ignore_command
static void ignore_command(const char *args, int from_tty)
Definition: breakpoint.c:14061
unduplicated_should_be_inserted
static int unduplicated_should_be_inserted(struct bp_location *bl)
Definition: breakpoint.c:2081
value_print_options
Definition: valprint.h:25
tracepoint_re_set
static void tracepoint_re_set(struct breakpoint *b)
Definition: breakpoint.c:12907
thread_info::suspend
thread_suspend_state suspend
Definition: gdbthread.h:295
ALL_BP_LOCATIONS_AT_ADDR
#define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS)
Definition: breakpoint.c:517
inf_starting
Definition: breakpoint.h:1143
is_no_memory_software_watchpoint
static int is_no_memory_software_watchpoint(struct breakpoint *b)
Definition: breakpoint.c:1618
linespec_sals::sals
std::vector< symtab_and_line > sals
Definition: linespec.h:50
bp_location::probe
bound_probe probe
Definition: breakpoint.h:457
EXEC_ASYNC_SOLIB_EVENT
Definition: mi-common.h:43
remove_catch_vfork
static int remove_catch_vfork(struct bp_location *bl, enum remove_bp_reason reason)
Definition: breakpoint.c:7877
decode_location_default
static std::vector< symtab_and_line > decode_location_default(struct breakpoint *b, const struct event_location *location, struct program_space *search_pspace)
Definition: breakpoint.c:13915
create_overlay_event_breakpoint
static void create_overlay_event_breakpoint(void)
Definition: breakpoint.c:3213
DECODE_LINE_LIST_MODE
Definition: linespec.h:36
create_tracepoint_from_upload
struct tracepoint * create_tracepoint_from_upload(struct uploaded_tp *utp)
Definition: breakpoint.c:14792
breakpoint::type
bptype type
Definition: breakpoint.h:693
uploaded_tp::hit_count
int hit_count
Definition: tracepoint.h:194
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
DETACH_BREAKPOINT
Definition: breakpoint.h:54
validate_commands_for_breakpoint
static void validate_commands_for_breakpoint(struct breakpoint *b, struct command_line *commands)
Definition: breakpoint.c:1081
remove_catch_fork
static int remove_catch_fork(struct bp_location *bl, enum remove_bp_reason reason)
Definition: breakpoint.c:7761
current_target
struct target_ops current_target
bkpt_probe_create_sals_from_location
static void bkpt_probe_create_sals_from_location(const struct event_location *location, struct linespec_result *canonical, enum bptype type_wanted)
Definition: breakpoint.c:12881
detach_breakpoints
int detach_breakpoints(ptid_t ptid)
Definition: breakpoint.c:3645
language_defn::la_watch_location_expression
gdb::unique_xmalloc_ptr< char >(* la_watch_location_expression)(struct type *type, CORE_ADDR addr)
Definition: language.h:360
memory_error_message
std::string memory_error_message(enum target_xfer_status err, struct gdbarch *gdbarch, CORE_ADDR memaddr)
Definition: corefile.c:181
dprintf_style
static const char * dprintf_style
Definition: breakpoint.c:279
wrap_indent
static const char * wrap_indent
Definition: utils.c:1332
find_pc_line
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3288
target_watchpoint_addr_within_range
#define target_watchpoint_addr_within_range(target, addr, start, length)
Definition: target.h:1989
bpstat_run_callbacks
void bpstat_run_callbacks(bpstat bs_head)
Definition: breakpoint.c:5739
bpstats::bp_location_at
struct bp_location * bp_location_at
Definition: breakpoint.h:1116
uploaded_tp::cond_string
char * cond_string
Definition: tracepoint.h:188
find_thread_global_id
struct thread_info * find_thread_global_id(int global_id)
Definition: thread.c:488
objfile::objfile
objfile(bfd *, const char *, objfile_flags)
Definition: objfiles.c:373
tracepoint_print_recreate
static void tracepoint_print_recreate(struct breakpoint *self, struct ui_file *fp)
Definition: breakpoint.c:12967
get_tracepoint_by_number
struct tracepoint * get_tracepoint_by_number(const char **arg, number_or_range_parser *parser)
Definition: breakpoint.c:15055
dummy-frame.h
address_significant
CORE_ADDR address_significant(gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2730
dprintf_style_call
static const char dprintf_style_call[]
Definition: breakpoint.c:271
target_is_non_stop_p
int target_is_non_stop_p(void)
Definition: target.c:3917
extract_bp_kind
extract_bp_kind
Definition: breakpoint.c:14164
parse_breakpoint_sals
static void parse_breakpoint_sals(const struct event_location *location, struct linespec_result *canonical)
Definition: breakpoint.c:9081
WP_VALUE_NOT_CHANGED
Definition: breakpoint.c:4846
bp_locations_placed_address_before_address_max
static CORE_ADDR bp_locations_placed_address_before_address_max
Definition: breakpoint.c:549
check_status_catch_solib
static void check_status_catch_solib(struct bpstats *bs)
Definition: breakpoint.c:8049
language_ada
Definition: defs.h:219
map_breakpoint_numbers
static void map_breakpoint_numbers(const char *, gdb::function_view< void(breakpoint *)>)
Definition: breakpoint.c:14120
pending_breakpoint_p
int pending_breakpoint_p(struct breakpoint *b)
Definition: breakpoint.c:6501
check_fast_tracepoint_sals
static void check_fast_tracepoint_sals(struct gdbarch *gdbarch, gdb::array_view< const symtab_and_line > sals)
Definition: breakpoint.c:9177
print_one_ranged_breakpoint
static void print_one_ranged_breakpoint(struct breakpoint *b, struct bp_location **last_loc)
Definition: breakpoint.c:9799
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
solib_catchpoint::compiled
std::unique_ptr< compiled_regex > compiled
Definition: breakpoint.c:7993
iterate_over_breakpoints
struct breakpoint * iterate_over_breakpoints(int(*callback)(struct breakpoint *, void *), void *data)
Definition: breakpoint.c:15347
SYMTAB_OBJFILE
#define SYMTAB_OBJFILE(symtab)
Definition: symtab.h:1336
bpstat_check_watchpoint
static void bpstat_check_watchpoint(bpstat bs)
Definition: breakpoint.c:5023
tracepoint::static_trace_marker_id_idx
int static_trace_marker_id_idx
Definition: breakpoint.h:900
bp_loc_software_breakpoint
Definition: breakpoint.h:298
set_cmd_completer
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:160
extract_bp_number_and_location
static void extract_bp_number_and_location(const std::string &arg, std::pair< int, int > &bp_num_range, std::pair< int, int > &bp_loc_range)
Definition: breakpoint.c:14258
ugll_insert_mode
ugll_insert_mode
Definition: breakpoint.c:188
target_waitstatus::sig
enum gdb_signal sig
Definition: waitstatus.h:114
bpstats::print
char print
Definition: breakpoint.h:1131
class_trace
Definition: command.h:42
breakpoint_objfile_data::longjmp_probes
std::vector< probe * > longjmp_probes
Definition: breakpoint.c:3156
bound_minimal_symbol
Definition: minsyms.h:29
until_break_fsm_should_stop
static int until_break_fsm_should_stop(struct thread_fsm *self, struct thread_info *thread)
Definition: breakpoint.c:11125
scoped_restore_current_pspace_and_thread
Definition: progspace-and-thread.h:29
print_mention_catch_exec
static void print_mention_catch_exec(struct breakpoint *b)
Definition: breakpoint.c:8387
stopin_command
static void stopin_command(const char *arg, int from_tty)
Definition: breakpoint.c:9628
lookup_mem_region
struct mem_region * lookup_mem_region(CORE_ADDR addr)
Definition: memattr.c:163
stepping_past_nonsteppable_watchpoint
int stepping_past_nonsteppable_watchpoint(void)
Definition: infrun.c:1376
add_setshow_zinteger_cmd
void add_setshow_zinteger_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:748
explains_signal_watchpoint
static int explains_signal_watchpoint(struct breakpoint *b, enum gdb_signal sig)
Definition: breakpoint.c:10407
mem_region::attrib
mem_attrib attrib
Definition: memattr.h:125
ptid_t
Definition: ptid.h:35
gdbarch_convert_from_func_ptr_addr
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:3191
momentary_bkpt_print_mention
static void momentary_bkpt_print_mention(struct breakpoint *b)
Definition: breakpoint.c:12835
breakpoint_sals_to_pc
static void breakpoint_sals_to_pc(std::vector< symtab_and_line > &sals)
Definition: breakpoint.c:9163
is_watchpoint
int is_watchpoint(const struct breakpoint *bpt)
Definition: breakpoint.c:1533
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
base_breakpoint_create_sals_from_location
static void base_breakpoint_create_sals_from_location(const struct event_location *location, struct linespec_result *canonical, enum bptype type_wanted)
Definition: breakpoint.c:12429
watchpoint_value_print
static void watchpoint_value_print(struct value *val, struct ui_file *stream)
Definition: breakpoint.c:4516
breakpoint::cond_string
char * cond_string
Definition: breakpoint.h:749
bkpt_probe_remove_location
static int bkpt_probe_remove_location(struct bp_location *bl, enum remove_bp_reason reason)
Definition: breakpoint.c:12871
number_or_range_parser::finished
bool finished() const
Definition: cli-utils.h:78
commands_command
static void commands_command(const char *arg, int from_tty)
Definition: breakpoint.c:1278
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
exception_print
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
breakpoint_ops::breakpoint_hit
int(* breakpoint_hit)(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.h:547
add_com_alias
struct cmd_list_element * add_com_alias(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag)
Definition: cli-decode.c:912
cli-utils.h
expression
Definition: expression.h:78
fputs_filtered
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1811
clone_momentary_breakpoint
struct breakpoint * clone_momentary_breakpoint(struct breakpoint *orig)
Definition: breakpoint.c:8611
observer_attach_solib_unloaded
struct observer * observer_attach_solib_unloaded(observer_solib_unloaded_ftype *f)
frame.h
streq
int streq(const char *lhs, const char *rhs)
Definition: utils.c:2641
get_linespec_location
const linespec_location * get_linespec_location(const struct event_location *location)
Definition: location.c:112
set_breakpoint_location_function
static void set_breakpoint_location_function(struct bp_location *loc, int explicit_loc)
Definition: breakpoint.c:7180
expression.h
get_number_trailer
int get_number_trailer(const char **pp, int trailer)
Definition: cli-utils.c:29
print_one_catch_solib
static void print_one_catch_solib(struct breakpoint *b, struct bp_location **locs)
Definition: breakpoint.c:8109
watchpoint::exp_valid_block
const struct block * exp_valid_block
Definition: breakpoint.h:807
static_tracepoint_marker
Definition: tracepoint.h:215
thread_info::global_num
int global_num
Definition: gdbthread.h:253
bp_fast_tracepoint
Definition: breakpoint.h:169
prevent_dont_repeat
scoped_restore_tmpl< int > prevent_dont_repeat(void)
Definition: top.c:713
always_inserted_mode
static int always_inserted_mode
Definition: breakpoint.c:378
bp_dprintf
Definition: breakpoint.h:177
bp_target_info::shadow_contents
gdb_byte shadow_contents[BREAKPOINT_MAX]
Definition: breakpoint.h:261
build_target_condition_list
static void build_target_condition_list(struct bp_location *bl)
Definition: breakpoint.c:2131
get_frame_function
struct symbol * get_frame_function(struct frame_info *frame)
Definition: blockframe.c:118
base_breakpoint_print_it
static enum print_stop_action base_breakpoint_print_it(bpstat bs)
Definition: breakpoint.c:12403
watchpoint_del_at_next_stop
static void watchpoint_del_at_next_stop(struct watchpoint *w)
Definition: breakpoint.c:1561
mark_breakpoint_location_modified
static void mark_breakpoint_location_modified(struct bp_location *loc)
Definition: breakpoint.c:692
gdbarch_stack_frame_destroyed_p
int gdbarch_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:3357
VEC_length
#define VEC_length(T, V)
Definition: vec.h:140
gdbthread.h
current_uiout
#define current_uiout
Definition: ui-out.h:39
bp_overlay_event
Definition: breakpoint.h:151
breakpoint
Definition: breakpoint.h:684
valid_task_id
int valid_task_id(int)
Definition: ada-tasks.c:337
inferior.h
msym_not_found_p
static int msym_not_found_p(const struct minimal_symbol *msym)
Definition: breakpoint.c:3180
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
frame_id_artificial_p
int frame_id_artificial_p(struct frame_id l)
Definition: frame.c:665
dprintf_style_agent
static const char dprintf_style_agent[]
Definition: breakpoint.c:272
tracepoint_locations_match
static int tracepoint_locations_match(struct bp_location *loc1, struct bp_location *loc2)
Definition: breakpoint.c:6907
software_breakpoint_inserted_here_p
int software_breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4114
cli-script.h
invalidate_bp_value_on_memory_change
static void invalidate_bp_value_on_memory_change(struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data)
Definition: breakpoint.c:14565
bpstats::print_it
enum bp_print_how print_it
Definition: breakpoint.h:1138
get_objfile_arch
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:445
breakpoint_objfile_data::exception_msym
Definition: breakpoint.c:3162
linespec_sals
Definition: linespec.h:41
strace_marker_create_sals_from_location
static void strace_marker_create_sals_from_location(const struct event_location *location, struct linespec_result *canonical, enum bptype type_wanted)
Definition: breakpoint.c:13127
EXEC_ASYNC_WATCHPOINT_SCOPE
Definition: mi-common.h:37
CATCH_PERMANENT
#define CATCH_PERMANENT
Definition: breakpoint.h:1282
ptid_to_global_thread_id
int ptid_to_global_thread_id(ptid_t ptid)
Definition: thread.c:605
solib_name_from_address
char * solib_name_from_address(struct program_space *pspace, CORE_ADDR address)
Definition: solib.c:1172
update_breakpoint_locations
void update_breakpoint_locations(struct breakpoint *b, struct program_space *filter_pspace, gdb::array_view< const symtab_and_line > sals, gdb::array_view< const symtab_and_line > sals_end)
Definition: breakpoint.c:13646
print_it_catch_fork
static enum print_stop_action print_it_catch_fork(bpstat bs)
Definition: breakpoint.c:7787
gdbarch_has_global_breakpoints
int gdbarch_has_global_breakpoints(struct gdbarch *gdbarch)
Definition: gdbarch.c:4619
scoped_restore_base
Definition: scoped_restore.h:24
parse_probes
std::vector< symtab_and_line > parse_probes(const struct event_location *location, struct program_space *search_pspace, struct linespec_result *canonical)
Definition: probe.c:119
infrun.h
disable_breakpoint
void disable_breakpoint(struct breakpoint *bpt)
Definition: breakpoint.c:14330
hw_read
Definition: break-common.h:25
bp_call_disabled
Definition: breakpoint.h:204
print_recreate_ranged_breakpoint
static void print_recreate_ranged_breakpoint(struct breakpoint *b, struct ui_file *fp)
Definition: breakpoint.c:9868
tracepoint_print_one_detail
static void tracepoint_print_one_detail(const struct breakpoint *self, struct ui_out *uiout)
Definition: breakpoint.c:12923
find_inferior_pid
struct inferior * find_inferior_pid(int pid)
Definition: inferior.c:302
gdb_evaluates_breakpoint_condition_p
static int gdb_evaluates_breakpoint_condition_p(void)
Definition: breakpoint.c:475
type
Definition: gdbtypes.h:749
single_step_breakpoint_inserted_here_p
int single_step_breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:14665
target_supports_evaluation_of_breakpoint_conditions
#define target_supports_evaluation_of_breakpoint_conditions()
Definition: target.h:1428
iterate_over_bp_locations
void iterate_over_bp_locations(walk_bp_location_callback callback)
Definition: breakpoint.c:2866
so_list::so_name
char so_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:60
breakpoint_find_if
struct breakpoint * breakpoint_find_if(int(*func)(struct breakpoint *b, void *d), void *user_data)
class_alias
Definition: command.h:43
pending
Definition: buildsym.h:101
tracepoint_decode_location
static std::vector< symtab_and_line > tracepoint_decode_location(struct breakpoint *b, const struct event_location *location, struct program_space *search_pspace)
Definition: breakpoint.c:13020
insert_masked_watchpoint
static int insert_masked_watchpoint(struct bp_location *bl)
Definition: breakpoint.c:10425
language.h
default_collect
char * default_collect
tracepoint.h
add_setshow_string_cmd
void add_setshow_string_cmd(const char *name, enum command_class theclass, char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:613
tribool
tribool
Definition: common-types.h:61
base_breakpoint_decode_location
static std::vector< symtab_and_line > base_breakpoint_decode_location(struct breakpoint *b, const struct event_location *location, struct program_space *search_pspace)
Definition: breakpoint.c:12453
VEC_index
#define VEC_index(T, V, I)
Definition: vec.h:167
dprintf_channel
static char * dprintf_channel
Definition: breakpoint.c:296
target_disable_tracepoint
#define target_disable_tracepoint(loc)
Definition: target.h:2143
LOC_CONST
Definition: symtab.h:801
bp_call_dummy
Definition: breakpoint.h:119
symtab_and_line::objfile
struct objfile * objfile
Definition: symtab.h:1768
condition_evaluation_both
static const char condition_evaluation_both[]
Definition: breakpoint.c:424
print_one_detail_ranged_breakpoint
static void print_one_detail_ranged_breakpoint(const struct breakpoint *b, struct ui_out *uiout)
Definition: breakpoint.c:9824
ALL_BREAKPOINTS
#define ALL_BREAKPOINTS(B)
Definition: breakpoint.c:495
update_static_tracepoint
static struct symtab_and_line update_static_tracepoint(struct breakpoint *b, struct symtab_and_line sal)
Definition: breakpoint.c:13480
get_type_arch
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:234
EXT_LANG_NONE
Definition: extension.h:61
bp_location::next
bp_location * next
Definition: breakpoint.h:324
ALL_TRACEPOINTS
#define ALL_TRACEPOINTS(B)
Definition: breakpoint.c:527
enable
#define enable()
Definition: ser-go32.c:239
inf
Definition: gnu-nat.c:174
get_current_arch
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:798
EX_EVENT_CATCH
Definition: breakpoint.c:91
tracepoint::pass_count
int pass_count
Definition: breakpoint.h:882
NOT_FOUND_ERROR
Definition: common-exceptions.h:57
rwatch_command
static void rwatch_command(const char *arg, int from_tty)
Definition: breakpoint.c:11046
type
static const char * type
Definition: language.c:113
skip.h
thbreak_command
static void thbreak_command(const char *arg, int from_tty)
Definition: breakpoint.c:9614
ui_out::field_stream
void field_stream(const char *fldname, string_file &stream)
Definition: ui-out.c:520
command_control_type
command_control_type
Definition: cli-script.h:33
stopat_command
static void stopat_command(const char *arg, int from_tty)
Definition: breakpoint.c:9661
event_location
Definition: location.c:36
tracepoint::number_on_target
int number_on_target
Definition: breakpoint.h:885
get_breakpoint
struct breakpoint * get_breakpoint(int num)
Definition: breakpoint.c:652
solib.h
exception_fprintf
void exception_fprintf(struct ui_file *file, struct gdb_exception e, const char *prefix,...)
Definition: exceptions.c:119
iterate_over_related_breakpoints
static void iterate_over_related_breakpoints(struct breakpoint *b, gdb::function_view< void(breakpoint *)> function)
Definition: breakpoint.c:13321
breakpoint_kind
static int breakpoint_kind(struct bp_location *bl, CORE_ADDR *addr)
Definition: breakpoint.c:2415
target_static_tracepoint_markers_by_strid
#define target_static_tracepoint_markers_by_strid(marker_id)
Definition: target.h:2208
print_thread_id
const char * print_thread_id(struct thread_info *thr)
Definition: thread.c:1602
decode_line_full
void decode_line_full(const struct event_location *location, int flags, struct program_space *search_pspace, struct symtab *default_symtab, int default_line, struct linespec_result *canonical, const char *select_mode, const char *filter)
Definition: linespec.c:3270
target_download_tracepoint
#define target_download_tracepoint(t)
Definition: target.h:2131
startswith
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:107
watchpoint_breakpoint_ops
static struct breakpoint_ops watchpoint_breakpoint_ops
Definition: breakpoint.c:10419
EXEC_ASYNC_WATCHPOINT_TRIGGER
Definition: mi-common.h:32
linespec.h
BPSTAT_WHAT_HP_STEP_RESUME
Definition: breakpoint.h:986
thread_info::thread_fsm
struct thread_fsm * thread_fsm
Definition: gdbthread.h:337
new_explicit_location
event_location_up new_explicit_location(const struct explicit_location *explicit_loc)
Definition: location.c:178
bp_loc_is_permanent
static int bp_loc_is_permanent(struct bp_location *loc)
Definition: breakpoint.c:8748
ui_noalign
Definition: ui-out.h:47
explicit_location
Definition: location.h:85
nquery
int nquery(const char *ctlstr,...)
Definition: utils.c:1028
stoplist
struct cmd_list_element * stoplist
Definition: cli-cmds.c:95
bpstat_num
int bpstat_num(bpstat *bsp, int *num)
Definition: breakpoint.c:4327
catch_solib_breakpoint_ops
static struct breakpoint_ops catch_solib_breakpoint_ops
Definition: breakpoint.c:8170
disable_breakpoints_in_shlibs
void disable_breakpoints_in_shlibs(void)
Definition: breakpoint.c:7587
bp_exception
Definition: breakpoint.h:90
enable_delete_command
static void enable_delete_command(const char *args, int from_tty)
Definition: breakpoint.c:14537
momentary_breakpoint_ops
static struct breakpoint_ops momentary_breakpoint_ops
Definition: breakpoint.c:251
skip_to_space
const char * skip_to_space(const char *chp)
Definition: common-utils.c:361
event_location_up
std::unique_ptr< event_location, event_location_deleter > event_location_up
Definition: location.h:140
gdbarch_addr_bit
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1848
thread_info::ptid
ptid_t ptid
Definition: gdbthread.h:219
ada_get_task_number
int ada_get_task_number(ptid_t)
Definition: ada-tasks.c:295
breakpoint_ops::decode_location
std::vector< symtab_and_line >(* decode_location)(struct breakpoint *b, const struct event_location *location, struct program_space *search_pspace)
Definition: breakpoint.h:627
bp_jit_event
Definition: breakpoint.h:180
target_has_execution
#define target_has_execution
Definition: target.h:1756
EXEC_ASYNC_BREAKPOINT_HIT
Definition: mi-common.h:31
frame_id::stack_addr
CORE_ADDR stack_addr
Definition: frame.h:126
range
Definition: value.c:62
bp_target_info::conditions
std::vector< agent_expr * > conditions
Definition: breakpoint.h:272
create_breakpoints_sal
static void create_breakpoints_sal(struct gdbarch *gdbarch, struct linespec_result *canonical, gdb::unique_xmalloc_ptr< char > cond_string, gdb::unique_xmalloc_ptr< char > extra_string, enum bptype type, enum bpdisp disposition, int thread, int task, int ignore_count, const struct breakpoint_ops *ops, int from_tty, int enabled, int internal, unsigned flags)
Definition: breakpoint.c:9038
breakpoint_ops::explains_signal
int(* explains_signal)(struct breakpoint *, enum gdb_signal)
Definition: breakpoint.h:633
strtoulst
ULONGEST strtoulst(const char *num, const char **trailer, int base)
Definition: common-utils.c:266
event_location_to_string
const char * event_location_to_string(struct event_location *location)
Definition: location.c:397
cmd_list_element::sfunc
cmd_const_sfunc_ftype * sfunc
Definition: cli-decode.h:119
software_watchpoint_add_no_memory_location
static void software_watchpoint_add_no_memory_location(struct breakpoint *b, struct program_space *pspace)
Definition: breakpoint.c:1603
watchpoint::watchpoint_triggered
enum watchpoint_triggered watchpoint_triggered
Definition: breakpoint.h:838
xstrprintf
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
breakpoint_hit_catch_fork
static int breakpoint_hit_catch_fork(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.c:7770
target_exact_watchpoints
int target_exact_watchpoints
Definition: breakpoint.c:489
breakpoint.h
print_it_catch_exec
static enum print_stop_action print_it_catch_exec(bpstat bs)
Definition: breakpoint.c:8334
STOP_STD_TERMINATE
Definition: breakpoint.h:1000
probe::get_relocated_address
virtual CORE_ADDR get_relocated_address(struct objfile *objfile)=0
BP_HARDWAREFLAG
#define BP_HARDWAREFLAG
Definition: breakpoint.c:4853
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
section_is_mapped
int section_is_mapped(struct obj_section *osect)
Definition: symfile.c:3017
BPSTAT_WHAT_STOP_SILENT
Definition: breakpoint.h:974
value_bitpos
LONGEST value_bitpos(const struct value *value)
Definition: value.c:1117
bp_target_info::placed_address
CORE_ADDR placed_address
Definition: breakpoint.h:248
completer_ftype
void completer_ftype(struct cmd_list_element *, completion_tracker &tracker, const char *text, const char *word)
Definition: command.h:191
print_command_lines
void print_command_lines(struct ui_out *uiout, struct command_line *cmd, unsigned int depth)
Definition: cli-script.c:189
watch_triggered_yes
Definition: breakpoint.h:659
add_abbrev_prefix_cmd
struct cmd_list_element * add_abbrev_prefix_cmd(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:395
dprintf_style_gdb
static const char dprintf_style_gdb[]
Definition: breakpoint.c:270
get_last_displayed_line
int get_last_displayed_line(void)
Definition: stack.c:1009
frame_unwind_caller_id
struct frame_id frame_unwind_caller_id(struct frame_info *next_frame)
Definition: frame.c:555
extension_language_defn
Definition: extension-priv.h:53
value_print_options::addressprint
int addressprint
Definition: valprint.h:43
find_pc_partial_function_gnu_ifunc
int find_pc_partial_function_gnu_ifunc(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, int *is_gnu_ifunc_p)
Definition: blockframe.c:191
print_solib_event
static void print_solib_event(int is_catchpoint)
Definition: breakpoint.c:4605
line_offset::offset
int offset
Definition: location.h:47
symtab
Definition: symtab.h:1291
ui_file::puts
virtual void puts(const char *str)
Definition: ui-file.h:63
linespec_result::lsals
std::vector< linespec_sals > lsals
Definition: linespec.h:79
solib_catchpoint
Definition: breakpoint.c:7983
print_breakpoint
void print_breakpoint(breakpoint *b)
Definition: breakpoint.c:6483
while_stepping_control
Definition: cli-script.h:44
create_internal_breakpoint
static struct breakpoint * create_internal_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address, enum bptype type, const struct breakpoint_ops *ops)
Definition: breakpoint.c:3120
bp_location::duplicate
bool duplicate
Definition: breakpoint.h:403
catch_vfork_permanent
Definition: breakpoint.c:11307
breakpoint_chain
struct breakpoint * breakpoint_chain
Definition: breakpoint.c:533
bp_read_watchpoint
Definition: breakpoint.h:77
OBJF_USERLOADED
Definition: objfile-flags.h:53
watchpoint
Definition: breakpoint.h:793
print_it_catch_vfork
static enum print_stop_action print_it_catch_vfork(bpstat bs)
Definition: breakpoint.c:7903
bkpt_breakpoint_ops
struct breakpoint_ops bkpt_breakpoint_ops
Definition: breakpoint.c:255
so_list::pspace
struct program_space * pspace
Definition: solist.h:63
internal_bkpt_check_status
static void internal_bkpt_check_status(bpstat bs)
Definition: breakpoint.c:12742
bkpt_probe_insert_location
static int bkpt_probe_insert_location(struct bp_location *bl)
Definition: breakpoint.c:12856
symtab_and_line::symtab
struct symtab * symtab
Definition: symtab.h:1751
wp_check_result
wp_check_result
Definition: breakpoint.c:4837
skip_prologue_sal
void skip_prologue_sal(struct symtab_and_line *sal)
Definition: symtab.c:3671
is_hardware_watchpoint
static int is_hardware_watchpoint(const struct breakpoint *bpt)
Definition: breakpoint.c:1522
gdbarch_adjust_breakpoint_address
CORE_ADDR gdbarch_adjust_breakpoint_address(struct gdbarch *gdbarch, CORE_ADDR bpaddr)
Definition: gdbarch.c:2919
new_address_location
event_location_up new_address_location(CORE_ADDR addr, const char *addr_string, int addr_string_len)
Definition: location.c:121
interps.h
base_breakpoint_works_in_software_mode
static int base_breakpoint_works_in_software_mode(const struct breakpoint *b)
Definition: breakpoint.c:12388
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
bp_tracepoint
Definition: breakpoint.h:168
bpstat_what_main_action
bpstat_what_main_action
Definition: breakpoint.h:940
tracepoint_create_breakpoints_sal
static void tracepoint_create_breakpoints_sal(struct gdbarch *gdbarch, struct linespec_result *canonical, gdb::unique_xmalloc_ptr< char > cond_string, gdb::unique_xmalloc_ptr< char > extra_string, enum bptype type_wanted, enum bpdisp disposition, int thread, int task, int ignore_count, const struct breakpoint_ops *ops, int from_tty, int enabled, int internal, unsigned flags)
Definition: breakpoint.c:12998
breakpoint_ext_lang_cond_says_stop
int breakpoint_ext_lang_cond_says_stop(struct breakpoint *b)
Definition: extension.c:635
swap_insertion
static void swap_insertion(struct bp_location *left, struct bp_location *right)
Definition: breakpoint.c:11773
breakpoint_set_commands
void breakpoint_set_commands(struct breakpoint *b, command_line_up &&commands)
Definition: breakpoint.c:1169
check_no_tracepoint_commands
static void check_no_tracepoint_commands(struct command_line *commands)
Definition: breakpoint.c:1005
watchpoint::exp
expression_up exp
Definition: breakpoint.h:804
bptype
bptype
Definition: breakpoint.h:67
breakpoint_ops::check_status
void(* check_status)(struct bpstats *bs)
Definition: breakpoint.h:554
target_terminal::ours_for_output
static void ours_for_output()
Definition: target.c:501
breakpoint_up
std::unique_ptr< struct breakpoint, breakpoint_deleter > breakpoint_up
Definition: breakpoint.h:1236
bp_loc_type
bp_loc_type
Definition: breakpoint.h:296
async_reply_reason
async_reply_reason
Definition: mi-common.h:29
watch_command_1
static void watch_command_1(const char *arg, int accessflag, int from_tty, int just_location, int internal)
Definition: breakpoint.c:10613
extension.h
add_alias_cmd
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *old, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:306
can_use_hw_watchpoints
static int can_use_hw_watchpoints
Definition: breakpoint.c:327
observer_notify_breakpoint_deleted
void observer_notify_breakpoint_deleted(struct breakpoint *b)
ui_out::spaces
void void spaces(int numspaces)
Definition: ui-out.c:575
watch_command_wrapper
void watch_command_wrapper(const char *arg, int from_tty, int internal)
Definition: breakpoint.c:11009
awatch_command
static void awatch_command(const char *arg, int from_tty)
Definition: breakpoint.c:11058
TRIBOOL_UNKNOWN
Definition: common-types.h:61
watchpoint_exp_is_const
static int watchpoint_exp_is_const(const struct expression *exp)
Definition: breakpoint.c:10021
parse_cmd_to_aexpr
static agent_expr_up parse_cmd_to_aexpr(CORE_ADDR scope, char *cmd)
Definition: breakpoint.c:2227
print_one_breakpoint
static void print_one_breakpoint(struct breakpoint *b, struct bp_location **last_loc, int allflag)
Definition: breakpoint.c:6417
strace_marker_create_breakpoints_sal
static void strace_marker_create_breakpoints_sal(struct gdbarch *gdbarch, struct linespec_result *canonical, gdb::unique_xmalloc_ptr< char > cond_string, gdb::unique_xmalloc_ptr< char > extra_string, enum bptype type_wanted, enum bpdisp disposition, int thread, int task, int ignore_count, const struct breakpoint_ops *ops, int from_tty, int enabled, int internal, unsigned flags)
Definition: breakpoint.c:13148
SWITCH_THRU_ALL_UIS
#define SWITCH_THRU_ALL_UIS()
Definition: top.h:206
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
bkpt_print_recreate
static void bkpt_print_recreate(struct breakpoint *tp, struct ui_file *fp)
Definition: breakpoint.c:12650
block
Definition: block.h:60
PRINT_SRC_ONLY
Definition: breakpoint.h:509
update_dprintf_commands
static void update_dprintf_commands(const char *args, int from_tty, struct cmd_list_element *c)
Definition: breakpoint.c:8837
decode_line_1
std::vector< symtab_and_line > decode_line_1(const struct event_location *location, int flags, struct program_space *search_pspace, struct symtab *default_symtab, int default_line)
Definition: linespec.c:3346
VEC_empty
#define VEC_empty(T, V)
Definition: vec.h:148
value::next
struct value * next
Definition: value.c:316
get_last_displayed_symtab
struct symtab * get_last_displayed_symtab(void)
Definition: stack.c:999
translate_condition_evaluation_mode
static const char * translate_condition_evaluation_mode(const char *mode)
Definition: breakpoint.c:450
value
Definition: value.c:169
breakpoint_xfer_memory
void breakpoint_xfer_memory(gdb_byte *readbuf, gdb_byte *writebuf, const gdb_byte *writebuf_org, ULONGEST memaddr, LONGEST len)
Definition: breakpoint.c:1423
stop_on_solib_events
int stop_on_solib_events
Definition: infrun.c:356
annotate_breakpoints_headers
void annotate_breakpoints_headers(void)
Definition: annotate.c:170
resources_needed_masked_watchpoint
static int resources_needed_masked_watchpoint(const struct bp_location *bl)
Definition: breakpoint.c:10449
ep_parse_optional_if_clause
const char * ep_parse_optional_if_clause(const char **arg)
Definition: breakpoint.c:11279
disable_watchpoints_before_interactive_call_start
void disable_watchpoints_before_interactive_call_start(void)
Definition: breakpoint.c:8477
watchpoint::val_valid
int val_valid
Definition: breakpoint.h:819
find_line_pc
int find_line_pc(struct symtab *symtab, int line, CORE_ADDR *pc)
Definition: symtab.c:3456
event_location_type
event_location_type
Definition: location.h:54
bp_target_info::length
int length
Definition: breakpoint.h:255
ui_out
Definition: ui-out.h:77
mark_breakpoint_modified
static void mark_breakpoint_modified(struct breakpoint *b)
Definition: breakpoint.c:669
bp_location::address
CORE_ADDR address
Definition: breakpoint.h:427
blockvector
Definition: block.h:112
target_thread_name
const char * target_thread_name(struct thread_info *info)
Definition: target.c:2200
frame_info::aspace
const address_space * aspace
Definition: frame.c:102
parse_to_comma_and_eval
struct value * parse_to_comma_and_eval(const char **expp)
Definition: eval.c:131
disablelist
struct cmd_list_element * disablelist
Definition: cli-cmds.c:91
create_longjmp_master_breakpoint
static void create_longjmp_master_breakpoint(void)
Definition: breakpoint.c:3266
location_completer
void location_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *)
Definition: completer.c:828
print_recreate_thread
void print_recreate_thread(struct breakpoint *b, struct ui_file *fp)
Definition: breakpoint.c:15093
new_probe_location
event_location_up new_probe_location(const char *probe)
Definition: location.c:155
show_pending_break_support
static void show_pending_break_support(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: breakpoint.c:346
bp_location::permanent
bool permanent
Definition: breakpoint.h:395
create_std_terminate_master_breakpoint
static void create_std_terminate_master_breakpoint(void)
Definition: breakpoint.c:3370
bpstats::breakpoint_at
struct breakpoint * breakpoint_at
Definition: breakpoint.h:1122
bkpt_breakpoint_hit
static int bkpt_breakpoint_hit(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.c:12538
breakpoint_has_pc
static int breakpoint_has_pc(struct breakpoint *b, struct program_space *pspace, CORE_ADDR pc, struct obj_section *section)
Definition: breakpoint.c:6707
bpstat_copy
bpstat bpstat_copy(bpstat bs)
Definition: breakpoint.c:4251
bp_none
Definition: breakpoint.h:69
explicit_location::function_name
char * function_name
Definition: location.h:91
insert_watchpoint
static int insert_watchpoint(struct bp_location *bl)
Definition: breakpoint.c:10175
base_breakpoint_check_status
static void base_breakpoint_check_status(bpstat bs)
Definition: breakpoint.c:12379
objfile
Definition: objfiles.h:286
gdbarch_fast_tracepoint_valid_at
int gdbarch_fast_tracepoint_valid_at(struct gdbarch *gdbarch, CORE_ADDR addr, char **msg)
Definition: gdbarch.c:4653
symtab_and_line
Definition: symtab.h:1746
watchpoint::cond_exp
expression_up cond_exp
Definition: breakpoint.h:809
breakpoint_has_location_inserted_here
int breakpoint_has_location_inserted_here(struct breakpoint *bp, const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:14647
print_stop_action
print_stop_action
Definition: breakpoint.h:498
longjmp_breakpoint
Definition: breakpoint.c:1031
ui_file::printf
void printf(const char *,...) ATTRIBUTE_PRINTF(2
Definition: ui-file.c:37
condition_command
static void condition_command(const char *arg, int from_tty)
Definition: breakpoint.c:960
insert_catch_solib
static int insert_catch_solib(struct bp_location *ignore)
Definition: breakpoint.c:8002
save_breakpoints_command
static void save_breakpoints_command(const char *args, int from_tty)
Definition: breakpoint.c:15228
maintenance_info_breakpoints
static void maintenance_info_breakpoints(const char *args, int from_tty)
Definition: breakpoint.c:6699
longjmp_names
static const char *const longjmp_names[]
Definition: breakpoint.c:3136
breakpoint_adjustment_warning
static void breakpoint_adjustment_warning(CORE_ADDR, CORE_ADDR, int, int)
Definition: breakpoint.c:6950
jit.h
throw_exception
void throw_exception(struct gdb_exception exception)
Definition: common-exceptions.c:312
fixup_symbol_section
struct symbol * fixup_symbol_section(struct symbol *sym, struct objfile *objfile)
Definition: symtab.c:1718
breakpoint_ops::create_sals_from_location
void(* create_sals_from_location)(const struct event_location *location, struct linespec_result *canonical, enum bptype type_wanted)
Definition: breakpoint.h:601
command_line::next
struct command_line * next
Definition: cli-script.h:53
target_waitstatus::execd_pathname
char * execd_pathname
Definition: waitstatus.h:118
obj_section
Definition: objfiles.h:123
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
disable_command
static void disable_command(const char *args, int from_tty)
Definition: breakpoint.c:14415
parse_thread_id
struct thread_info * parse_thread_id(const char *tidstr, const char **end)
Definition: tid-parse.c:54
fetch_subexp_value
void fetch_subexp_value(struct expression *exp, int *pc, struct value **valp, struct value **resultp, struct value **val_chain, int preserve_errors)
Definition: eval.c:195
command_line::control_type
enum command_control_type control_type
Definition: cli-script.h:55
disable_trace_command
static void disable_trace_command(const char *args, int from_tty)
Definition: breakpoint.c:14909
find_line_pc_range
int find_line_pc_range(struct symtab_and_line sal, CORE_ADDR *startptr, CORE_ADDR *endptr)
Definition: symtab.c:3483
bpstat_remove_breakpoint_callback
static int bpstat_remove_breakpoint_callback(struct thread_info *th, void *data)
Definition: breakpoint.c:12241
breakpoint::next
breakpoint * next
Definition: breakpoint.h:691
locations_are_equal
static int locations_are_equal(struct bp_location *a, struct bp_location *b)
Definition: breakpoint.c:13578
hoist_existing_locations
static struct bp_location * hoist_existing_locations(struct breakpoint *b, struct program_space *pspace)
Definition: breakpoint.c:13606
static_tracepoint_marker::address
CORE_ADDR address
Definition: tracepoint.h:218
bp_location::refc
int refc
Definition: breakpoint.h:330
tracepoint_create_sals_from_location
static void tracepoint_create_sals_from_location(const struct event_location *location, struct linespec_result *canonical, enum bptype type_wanted)
Definition: breakpoint.c:12990
bp_hardware_breakpoint
Definition: breakpoint.h:71
set_tracepoint_count
static void set_tracepoint_count(int num)
Definition: breakpoint.c:14683
MSYMBOL_TYPE
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:680
linespec_sals::canonical
char * canonical
Definition: linespec.h:47
get_breakpoint_cond_ext_lang
const struct extension_language_defn * get_breakpoint_cond_ext_lang(struct breakpoint *b, enum extension_language skip_lang)
Definition: extension.c:614
help_list
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1071
hex_string_custom
char * hex_string_custom(LONGEST num, int width)
Definition: print-utils.c:231
XNEWVEC
#define XNEWVEC(T, N)
Definition: poison.h:145
tracepoint_breakpoint_hit
static int tracepoint_breakpoint_hit(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.c:12913
gdb::optional::emplace
T & emplace(Args &&... args)
Definition: gdb_optional.h:152
discard_cleanups
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:212
target_insert_breakpoint
int target_insert_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: target.c:1987
set_momentary_breakpoint
breakpoint_up set_momentary_breakpoint(struct gdbarch *gdbarch, struct symtab_and_line sal, struct frame_id frame_id, enum bptype type)
Definition: breakpoint.c:8545
linespec_result::special_display
bool special_display
Definition: linespec.h:66
current_language
const struct language_defn * current_language
Definition: language.c:81
null_ptid
ptid_t null_ptid
Definition: ptid.c:25
bp_catchpoint
Definition: breakpoint.h:166
last_displayed_sal_is_valid
int last_displayed_sal_is_valid(void)
Definition: stack.c:971
ui_out::query_table_field
bool query_table_field(int colno, int *width, int *alignment, const char **col_name)
Definition: ui-out.c:667
source.h
tracepoint::static_trace_marker_id
char * static_trace_marker_id
Definition: breakpoint.h:892
enable_state
enable_state
Definition: breakpoint.h:198
breakpoint::thread
int thread
Definition: breakpoint.h:763
overlay_unmapped_address
CORE_ADDR overlay_unmapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3107
lookup_minimal_symbol_by_pc
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:928
incref_bp_location
static void incref_bp_location(struct bp_location *loc)
Definition: breakpoint.c:7101
update_dprintf_command_list
static void update_dprintf_command_list(struct breakpoint *b)
Definition: breakpoint.c:8768
thread-fsm.h
bpstat_find_breakpoint
bpstat bpstat_find_breakpoint(bpstat bsp, struct breakpoint *breakpoint)
Definition: breakpoint.c:4278
print_recreate_catch_vfork
static void print_recreate_catch_vfork(struct breakpoint *b, struct ui_file *fp)
Definition: breakpoint.c:7969
ALL_PSPACES
#define ALL_PSPACES(pspace)
Definition: progspace.h:243
dprintf_function
static char * dprintf_function
Definition: breakpoint.c:286
ALL_NON_EXITED_THREADS
#define ALL_NON_EXITED_THREADS(T)
Definition: gdbthread.h:490
tracepoint_probe_decode_location
static std::vector< symtab_and_line > tracepoint_probe_decode_location(struct breakpoint *b, const struct event_location *location, struct program_space *search_pspace)
Definition: breakpoint.c:13043
ext_lang_capitalized_name
const char * ext_lang_capitalized_name(const struct extension_language_defn *extlang)
Definition: extension.c:235
operator_length
void operator_length(const struct expression *expr, int endpos, int *oplenp, int *argsp)
Definition: parse.c:827
insert_catch_vfork
static int insert_catch_vfork(struct bp_location *bl)
Definition: breakpoint.c:7868
target_can_download_tracepoint
#define target_can_download_tracepoint()
Definition: target.h:2134
lang_and_radix::radix
int radix
Definition: breakpoint.c:7494
base_breakpoint_resources_needed
static int base_breakpoint_resources_needed(const struct bp_location *bl)
Definition: breakpoint.c:12397
update_global_location_list
static void update_global_location_list(enum ugll_insert_mode)
Definition: breakpoint.c:11853
gdb::optional
Definition: gdb_optional.h:51
address_space
Definition: progspace.h:216
PROBE_LOCATION
Definition: location.h:66
thread_info::name
char * name
Definition: gdbthread.h:265
gdb::array_view::empty
constexpr bool empty() const noexcept
Definition: array-view.h:170
breakpoint_objfile_data::exception_searched
int exception_searched
Definition: breakpoint.c:3165
make_bpstat_clear_actions_cleanup
struct cleanup * make_bpstat_clear_actions_cleanup(void)
Definition: utils.c:3168
gdb::function_view
Definition: function-view.h:177
proceed
void proceed(CORE_ADDR addr, enum gdb_signal siggnal)
Definition: infrun.c:2977
gdb_stderr
#define gdb_stderr
Definition: utils.h:344
EXEC_ASYNC_EXEC
Definition: mi-common.h:48
breakpoint_event_location_empty_p
static int breakpoint_event_location_empty_p(const struct breakpoint *b)
Definition: breakpoint.c:3517
XCNEW
#define XCNEW(T)
Definition: poison.h:121
gdbcore.h
program_space::executing_startup
int executing_startup
Definition: progspace.h:176
remove_solib_event_breakpoints_at_next_stop
void remove_solib_event_breakpoints_at_next_stop(void)
Definition: breakpoint.c:7533
async_reason_lookup
const char * async_reason_lookup(enum async_reply_reason reason)
Definition: mi-common.c:49
UGLL_DONT_INSERT
Definition: breakpoint.c:205
tracepoint::traceframe_usage
ULONGEST traceframe_usage
Definition: breakpoint.h:889
catch_fork_temporary
Definition: breakpoint.c:11306
breakpoint::location
event_location_up location
Definition: breakpoint.h:730
say_where
static void say_where(struct breakpoint *b)
Definition: breakpoint.c:12253
commands_command_1
static void commands_command_1(const char *arg, int from_tty, struct command_line *control)
Definition: breakpoint.c:1227
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
SYMBOL_BLOCK_VALUE
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:467
set_longjmp_breakpoint_for_call_dummy
struct breakpoint * set_longjmp_breakpoint_for_call_dummy(void)
Definition: breakpoint.c:7355
bkpt_probe_decode_location
static std::vector< symtab_and_line > bkpt_probe_decode_location(struct breakpoint *b, const struct event_location *location, struct program_space *search_pspace)
Definition: breakpoint.c:12894
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
clear_proceed_status
void clear_proceed_status(int step)
Definition: infrun.c:2860
thread_info::control
thread_control_state control
Definition: gdbthread.h:291
bp_location::loc_type
bp_loc_type loc_type
Definition: breakpoint.h:333
bp_exception_resume
Definition: breakpoint.h:93
bp_location::inserted
bool inserted
Definition: breakpoint.h:388
breakpoint_ops::remove_location
int(* remove_location)(struct bp_location *, enum remove_bp_reason reason)
Definition: breakpoint.h:539
target_waitstatus::kind
enum target_waitkind kind
Definition: waitstatus.h:106
break_range_command
static void break_range_command(const char *arg, int from_tty)
Definition: breakpoint.c:9913
target_insert_exec_catchpoint
#define target_insert_exec_catchpoint(pid)
Definition: target.h:1602
add_catch_command
void add_catch_command(const char *name, const char *docstring, cmd_const_sfunc_ftype *sfunc, completer_ftype *completer, void *user_data_catch, void *user_data_tcatch)
Definition: breakpoint.c:15317
describe_other_breakpoints
static void describe_other_breakpoints(struct gdbarch *, struct program_space *, CORE_ADDR, struct obj_section *, int)
Definition: breakpoint.c:6728
ui_out::field_int
void field_int(const char *fldname, int value)
Definition: ui-out.c:486
bp_location::target_info
bp_target_info target_info
Definition: breakpoint.h:462
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
stdio_file::open
bool open(const char *name, const char *mode)
Definition: ui-file.c:171
bp_location::shlib_disabled
bool shlib_disabled
Definition: breakpoint.h:382
show_condition_evaluation_mode
static void show_condition_evaluation_mode(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: breakpoint.c:773
expression_completer
void expression_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1076
gdbarch_breakpoint_from_pc
const gdb_byte * gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition: gdbarch.c:2844
catch_command
static void catch_command(const char *arg, int from_tty)
Definition: breakpoint.c:11428
breakpoint_init_inferior
void breakpoint_init_inferior(enum inf_context context)
Definition: breakpoint.c:3872
create_sals_from_location_default
static void create_sals_from_location_default(const struct event_location *location, struct linespec_result *canonical, enum bptype type_wanted)
Definition: breakpoint.c:13879
bp_location::bp_location
bp_location()=default
target_region_ok_for_hw_watchpoint
#define target_region_ok_for_hw_watchpoint(addr, len)
Definition: target.h:1925
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
uploaded_tp::cond
char * cond
Definition: tracepoint.h:177
watchpoint::val_bitpos
int val_bitpos
Definition: breakpoint.h:823
class_breakpoint
Definition: command.h:42
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
MEM_RW
Definition: memattr.h:26
ui_out::table_body
void table_body()
Definition: ui-out.c:379
permanent_breakpoint_here
Definition: breakpoint.h:1155
linespec_result
Definition: linespec.h:56
simple_control
Definition: cli-script.h:35
safe_strerror
char * safe_strerror(int)
Definition: mingw-strerror.c:32
set_internalvar_integer
void set_internalvar_integer(struct internalvar *var, LONGEST l)
Definition: value.c:2442
trace_pass_set_count
static void trace_pass_set_count(struct tracepoint *tp, int count, int from_tty)
Definition: breakpoint.c:14957
until_break_command
void until_break_command(const char *arg, int from_tty, int anywhere)
Definition: breakpoint.c:11173
bp_longjmp_master
Definition: breakpoint.h:158
scoped_rbreak_breakpoints::~scoped_rbreak_breakpoints
~scoped_rbreak_breakpoints()
Definition: breakpoint.c:631
break_command_1
static void break_command_1(const char *arg, int flag, int from_tty)
Definition: breakpoint.c:9510
disable_breakpoints_in_freed_objfile
static void disable_breakpoints_in_freed_objfile(struct objfile *objfile)
Definition: breakpoint.c:7666
scoped_restore_current_program_space
Definition: progspace.h:277
remove_breakpoints
int remove_breakpoints(void)
Definition: breakpoint.c:3038
remove_masked_watchpoint
static int remove_masked_watchpoint(struct bp_location *bl, enum remove_bp_reason reason)
Definition: breakpoint.c:10437
create_breakpoint
int create_breakpoint(struct gdbarch *gdbarch, const struct event_location *location, const char *cond_string, int thread, const char *extra_string, int parse_extra, int tempflag, enum bptype type_wanted, int ignore_count, enum auto_boolean pending_break_support, const struct breakpoint_ops *ops, int from_tty, int enabled, int internal, unsigned flags)
Definition: breakpoint.c:9325
command_interp
struct interp * command_interp(void)
Definition: interps.c:321
decode_line_with_current_source
std::vector< symtab_and_line > decode_line_with_current_source(const char *string, int flags)
Definition: linespec.c:3371
symtab_and_line::pspace
struct program_space * pspace
Definition: symtab.h:1749
gnu_ifunc_resolve_name
#define gnu_ifunc_resolve_name
Definition: symtab.h:1737
hardware_breakpoint_inserted_here_p
int hardware_breakpoint_inserted_here_p(const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4136
watchpoint::exact
int exact
Definition: breakpoint.h:842
get_user_print_options
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:120
clear_breakpoint_hit_counts
void clear_breakpoint_hit_counts(void)
Definition: breakpoint.c:639
add_setshow_boolean_cmd
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
hw_watchpoint_use_count
static int hw_watchpoint_use_count(struct breakpoint *)
Definition: breakpoint.c:8429
pc_at_non_inline_function
int pc_at_non_inline_function(const address_space *aspace, CORE_ADDR pc, const struct target_waitstatus *ws)
Definition: breakpoint.c:15379
bp_location::related_address
CORE_ADDR related_address
Definition: breakpoint.h:453
bp_until
Definition: breakpoint.h:73
base_breakpoint_breakpoint_hit
static int base_breakpoint_breakpoint_hit(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.c:12370
WP_DELETED
Definition: breakpoint.c:4840
can_use_hardware_watchpoint
static int can_use_hardware_watchpoint(struct value *)
Definition: breakpoint.c:10928
create_solib_event_breakpoint_1
static struct breakpoint * create_solib_event_breakpoint_1(struct gdbarch *gdbarch, CORE_ADDR address, enum ugll_insert_mode insert_mode)
Definition: breakpoint.c:7548
obj_section::objfile
struct objfile * objfile
Definition: objfiles.h:129
resources_needed_watchpoint
static int resources_needed_watchpoint(const struct bp_location *bl)
Definition: breakpoint.c:10229
bptype_string
static const char * bptype_string(enum bptype type)
Definition: breakpoint.c:5959
extract_bp_num
static int extract_bp_num(extract_bp_kind kind, const char *start, int trailer, const char **end_out=NULL)
Definition: breakpoint.c:14180
breakpoint::~breakpoint
virtual ~breakpoint()
Definition: breakpoint.c:12334
bpstat_explains_signal
int bpstat_explains_signal(bpstat bsp, enum gdb_signal sig)
Definition: breakpoint.c:4294
target_insert_hw_breakpoint
#define target_insert_hw_breakpoint(gdbarch, bp_tgt)
Definition: target.h:1968
user_breakpoint_p
int user_breakpoint_p(struct breakpoint *b)
Definition: breakpoint.c:6493
add_solib_catchpoint
void add_solib_catchpoint(const char *arg, int is_load, int is_temp, int enabled)
Definition: breakpoint.c:8180
VEC_free
#define VEC_free(T, V)
Definition: vec.h:196
qsort
#define qsort
Definition: ada-exp.c:2694
disable_breakpoints_in_unloaded_shlib
static void disable_breakpoints_in_unloaded_shlib(struct so_list *solib)
Definition: breakpoint.c:7620
event_location_empty_p
int event_location_empty_p(const struct event_location *location)
Definition: location.c:951
set_std_terminate_breakpoint
void set_std_terminate_breakpoint(void)
Definition: breakpoint.c:7450
bpstat_check_location
static int bpstat_check_location(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.c:5007
completion_tracker::add_completion
void add_completion(gdb::unique_xmalloc_ptr< char > name, completion_match_for_lcd *match_for_lcd=NULL, const char *text=NULL, const char *word=NULL)
Definition: completer.c:1550
symtab_and_line::prob
probe * prob
Definition: symtab.h:1765
get_breakpoint_objfile_data
static struct breakpoint_objfile_data * get_breakpoint_objfile_data(struct objfile *objfile)
Definition: breakpoint.c:3189
bp_locations
static struct bp_location ** bp_locations
Definition: breakpoint.c:537
gdbarch_adjust_breakpoint_address_p
int gdbarch_adjust_breakpoint_address_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2912
mst_text
Definition: symtab.h:582
symtab_and_line::pc
CORE_ADDR pc
Definition: symtab.h:1759
probe.h
internal_bkpt_print_mention
static void internal_bkpt_print_mention(struct breakpoint *b)
Definition: breakpoint.c:12806
breakpoint::enable_count
int enable_count
Definition: breakpoint.h:715
disp_disable
Definition: breakpoint.h:222
ui_out::message
void message(const char *format,...) ATTRIBUTE_PRINTF(2
Definition: ui-out.c:587
VEC
VEC(bp_location_p)
Definition: breakpoint.c:562
condition_evaluation_auto
static const char condition_evaluation_auto[]
Definition: breakpoint.c:427
target.h
bp_disabled
Definition: breakpoint.h:200
breakpoint_ops::print_one_detail
void(* print_one_detail)(const struct breakpoint *, struct ui_out *)
Definition: breakpoint.h:586
base_breakpoint_ops
struct breakpoint_ops base_breakpoint_ops
Definition: breakpoint.c:12476
print_recreate_catch_exec
static void print_recreate_catch_exec(struct breakpoint *b, struct ui_file *fp)
Definition: breakpoint.c:8396
lang_and_radix::lang
enum language lang
Definition: breakpoint.c:7493
bp_target_info::kind
int kind
Definition: breakpoint.h:268
uploaded_tp::addr
ULONGEST addr
Definition: tracepoint.h:170
BPSTAT_WHAT_STOP_NOISY
Definition: breakpoint.h:977
EX_EVENT_RETHROW
Definition: breakpoint.c:90
break_command
void break_command(const char *arg, int from_tty)
Definition: breakpoint.c:9596
string_printf
std::string string_printf(const char *fmt,...)
Definition: common-utils.c:150
thread_control_state::single_step_breakpoints
struct breakpoint * single_step_breakpoints
Definition: gdbthread.h:65
complete_internalvar
void complete_internalvar(completion_tracker &tracker, const char *name)
Definition: value.c:2138
value_free_to_mark
void value_free_to_mark(const struct value *mark)
Definition: value.c:1641
base_breakpoint_after_condition_true
static void base_breakpoint_after_condition_true(struct bpstats *bs)
Definition: breakpoint.c:12471
value.h
force_breakpoint_reinsertion
static void force_breakpoint_reinsertion(struct bp_location *bl)
Definition: breakpoint.c:11802
target_can_accel_watchpoint_condition
#define target_can_accel_watchpoint_condition(addr, len, type, cond)
Definition: target.h:2002
number_or_range_parser
Definition: cli-utils.h:48
is_tracepoint_type
static bool is_tracepoint_type(bptype type)
Definition: breakpoint.c:1039
TARGET_WAITKIND_VFORKED
Definition: waitstatus.h:52
bp_target_info::persist
int persist
Definition: breakpoint.h:280
target_hw_bp_type
target_hw_bp_type
Definition: break-common.h:22
disable_overlay_breakpoints
void disable_overlay_breakpoints(void)
Definition: breakpoint.c:7434
print_it_watchpoint
static enum print_stop_action print_it_watchpoint(bpstat bs)
Definition: breakpoint.c:10248
gdbarch::data
void ** data
Definition: gdbarch.c:148
print_one_detail_masked_watchpoint
static void print_one_detail_masked_watchpoint(const struct breakpoint *b, struct ui_out *uiout)
Definition: breakpoint.c:10519
uploaded_tp
Definition: tracepoint.h:166
breakpoint_set_silent
void breakpoint_set_silent(struct breakpoint *b, int silent)
Definition: breakpoint.c:1183
insert_catch_fork
static int insert_catch_fork(struct bp_location *bl)
Definition: breakpoint.c:7752
rbreak_start_breakpoint_count
static int rbreak_start_breakpoint_count
Definition: breakpoint.c:618
bp_location::line_number
int line_number
Definition: breakpoint.h:483
save_cmdlist
struct cmd_list_element * save_cmdlist
watchpoint::~watchpoint
~watchpoint() override
Definition: breakpoint.c:10130
ptid_equal
int ptid_equal(const ptid_t &ptid1, const ptid_t &ptid2)
Definition: ptid.c:71
enable_disable_breakpoint_location_range
static void enable_disable_breakpoint_location_range(int bp_num, std::pair< int, int > &bp_loc_range, bool enable)
Definition: breakpoint.c:14317
trace_pass_command
static void trace_pass_command(const char *, int)
Definition: breakpoint.c:14973
target_ranged_break_num_registers
int target_ranged_break_num_registers(void)
Definition: target.c:3545
disconnected_dprintf
static int disconnected_dprintf
Definition: breakpoint.c:300
breakpoint_about_to_proceed
static void breakpoint_about_to_proceed(void)
Definition: breakpoint.c:4376
current_inferior
struct inferior * current_inferior(void)
Definition: inferior.c:58
watch_triggered_unknown
Definition: breakpoint.h:656
add_info_alias
struct cmd_list_element * add_info_alias(const char *name, const char *oldname, int abbrev_flag)
Definition: cli-decode.c:894
print_core_address
const char * print_core_address(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: utils.c:2766
bp_location::ops
const bp_location_ops * ops
Definition: breakpoint.h:327
is_exited
int is_exited(ptid_t ptid)
Definition: thread.c:969
map_breakpoint_number_range
static void map_breakpoint_number_range(std::pair< int, int > bp_num_range, gdb::function_view< void(breakpoint *)> function)
Definition: breakpoint.c:14087
memory_validate_breakpoint
int memory_validate_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: mem-break.c:102
breakpoint_objfile_data::longjmp_searched
int longjmp_searched
Definition: breakpoint.c:3152
breakpoints_should_be_inserted_now
int breakpoints_should_be_inserted_now(void)
Definition: breakpoint.c:391
auto_boolean
auto_boolean
Definition: defs.h:237
breakpoint_ops::after_condition_true
void(* after_condition_true)(struct bpstats *bs)
Definition: breakpoint.h:637
exec_catchpoint
Definition: breakpoint.c:8290
overlay_debugging
enum overlay_debugging_state overlay_debugging
Definition: symfile.c:2970
new_breakpoint_from_type
static std::unique_ptr< breakpoint > new_breakpoint_from_type(bptype type)
Definition: breakpoint.c:1062
catch_load_command_1
static void catch_load_command_1(const char *arg, int from_tty, struct cmd_list_element *command)
Definition: breakpoint.c:8222
bkpt_re_set
static void bkpt_re_set(struct breakpoint *b)
Definition: breakpoint.c:12501
current_program_space
struct program_space * current_program_space
Definition: progspace.c:35
bp_condition_evaluator
static const char * bp_condition_evaluator(struct breakpoint *b)
Definition: breakpoint.c:5829
gdbtypes.h
breakpoint_set_thread
void breakpoint_set_thread(struct breakpoint *b, int thread)
Definition: breakpoint.c:1196
extract_bitfield_from_watchpoint_value
static struct value * extract_bitfield_from_watchpoint_value(struct watchpoint *w, struct value *val)
Definition: breakpoint.c:1578
parse_and_eval
struct value * parse_and_eval(const char *exp)
Definition: eval.c:119
executing_breakpoint_commands
static int executing_breakpoint_commands
Definition: breakpoint.c:483
scoped_rbreak_breakpoints::scoped_rbreak_breakpoints
scoped_rbreak_breakpoints()
Definition: breakpoint.c:623
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
bp_locations_target_extensions_update
static void bp_locations_target_extensions_update(void)
Definition: breakpoint.c:11685
target_can_use_hardware_watchpoint
#define target_can_use_hardware_watchpoint(TYPE, CNT, OTHERTYPE)
Definition: target.h:1918
gdb_exception
Definition: common-exceptions.h:111
print_it_catch_solib
static enum print_stop_action print_it_catch_solib(bpstat bs)
Definition: breakpoint.c:8089
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
field_name
static PyObject * field_name(struct type *type, int field)
Definition: py-type.c:267
bp_loc_other
Definition: breakpoint.h:301
condition_evaluation_mode_1
static const char * condition_evaluation_mode_1
Definition: breakpoint.c:438
language
language
Definition: defs.h:203
release_value
void release_value(struct value *val)
Definition: value.c:1693
initialize_breakpoint_ops
void initialize_breakpoint_ops(void)
Definition: breakpoint.c:15414
savestring
char * savestring(const char *ptr, size_t len)
Definition: common-utils.c:226
target_remove_vfork_catchpoint
#define target_remove_vfork_catchpoint(pid)
Definition: target.h:1579
until_break_fsm::caller_breakpoint
struct breakpoint * caller_breakpoint
Definition: breakpoint.c:11081
gdb::array_view
Definition: array-view.h:69
breakpoint::condition_not_parsed
int condition_not_parsed
Definition: breakpoint.h:778
breakpoint::ignore_count
int ignore_count
Definition: breakpoint.h:711
regcache
Definition: regcache.h:232
bkpt_print_mention
static void bkpt_print_mention(struct breakpoint *b)
Definition: breakpoint.c:12621
strace_marker_breakpoint_ops
static struct breakpoint_ops strace_marker_breakpoint_ops
Definition: breakpoint.c:13214
annotate_breakpoints_table_end
void annotate_breakpoints_table_end(void)
Definition: annotate.c:198
class_run
Definition: command.h:41
symtab_and_line::symbol
struct symbol * symbol
Definition: symtab.h:1752
gdb_exception::message
const char * message
Definition: common-exceptions.h:115
target_remove_exec_catchpoint
#define target_remove_exec_catchpoint(pid)
Definition: target.h:1605
bp_location_inserted_here_p
static int bp_location_inserted_here_p(struct bp_location *bl, const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:4072
explicit_location::source_filename
char * source_filename
Definition: location.h:88
inf_context
inf_context
Definition: breakpoint.h:1141
bp_static_tracepoint
Definition: breakpoint.h:170
completion_tracker
Definition: completer.h:310
bpstats::commands
counted_command_line commands
Definition: breakpoint.h:1125
update_breakpoints_after_exec
void update_breakpoints_after_exec(void)
Definition: breakpoint.c:3523
catch_load_or_unload
static void catch_load_or_unload(const char *arg, int from_tty, int is_load, struct cmd_list_element *command)
Definition: breakpoint.c:8210
until_break_fsm::location_breakpoint
struct breakpoint * location_breakpoint
Definition: breakpoint.c:11077
bpstats::stop
char stop
Definition: breakpoint.h:1134
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
thread_is_stepping_over_breakpoint
int thread_is_stepping_over_breakpoint(int thread)
Definition: infrun.c:1367
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
watchpoints_triggered
int watchpoints_triggered(struct target_waitstatus *ws)
Definition: breakpoint.c:4762
print_address_symbolic
int print_address_symbolic(struct gdbarch *, CORE_ADDR, struct ui_file *, int, const char *)
Definition: printcmd.c:521
print_it_ranged_breakpoint
static enum print_stop_action print_it_ranged_breakpoint(bpstat bs)
Definition: breakpoint.c:9764
annotate_breakpoint
void annotate_breakpoint(int num)
Definition: annotate.c:80
one_breakpoint_xfer_memory
static void one_breakpoint_xfer_memory(gdb_byte *readbuf, gdb_byte *writebuf, const gdb_byte *writebuf_org, ULONGEST memaddr, LONGEST len, struct bp_target_info *target_info, struct gdbarch *gdbarch)
Definition: breakpoint.c:1319
find_probes_in_objfile
std::vector< probe * > find_probes_in_objfile(struct objfile *objfile, const char *provider, const char *name)
Definition: probe.c:220
TARGET_WAITKIND_LOADED
Definition: waitstatus.h:43
server_command
int server_command
Definition: top.c:145
tid-parse.h
enable_breakpoint_disp
static void enable_breakpoint_disp(struct breakpoint *, enum bpdisp, int count)
Definition: breakpoint.c:14421
debug_infrun
unsigned int debug_infrun
Definition: infrun.c:164
breakpoint_hit_ranged_breakpoint
static int breakpoint_hit_ranged_breakpoint(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.c:9738
symbol
Definition: symtab.h:1049
bpstat_do_actions
void bpstat_do_actions(void)
Definition: breakpoint.c:4494
stdio_file::puts
void puts(const char *) override
Definition: ui-file.c:237
all_commands
Definition: command.h:39
condition_evaluation_host
static const char condition_evaluation_host[]
Definition: breakpoint.c:428
value_as_address
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2762
NUM_LONGJMP_NAMES
#define NUM_LONGJMP_NAMES
Definition: breakpoint.c:3140
bp_location::gdbarch
struct gdbarch * gdbarch
Definition: breakpoint.h:413
catch_exec_command_1
static void catch_exec_command_1(const char *arg, int from_tty, struct cmd_list_element *command)
Definition: breakpoint.c:11359
get_first_locp_gte_addr
static struct bp_location ** get_first_locp_gte_addr(CORE_ADDR address)
Definition: breakpoint.c:809
compiled_regex
Definition: gdb_regex.h:35
bpstats
Definition: breakpoint.h:1087
bp_hardware_watchpoint
Definition: breakpoint.h:76
bp_location::cond
expression_up cond
Definition: breakpoint.h:350
BPSTAT_WHAT_SET_LONGJMP_RESUME
Definition: breakpoint.h:958
hw_access
Definition: break-common.h:26
gen_eval_for_expr
agent_expr_up gen_eval_for_expr(CORE_ADDR scope, struct expression *expr)
Definition: ax-gdb.c:2496
TRIBOOL_FALSE
Definition: common-types.h:61
gnu_ifunc_resolver_return_stop
#define gnu_ifunc_resolver_return_stop
Definition: symtab.h:1739
msym_not_found
static struct minimal_symbol msym_not_found
Definition: breakpoint.c:3175
bp_location::symtab
struct symtab * symtab
Definition: breakpoint.h:488
command_line_up
std::unique_ptr< command_line, command_lines_deleter > command_line_up
Definition: cli-script.h:88
mention
static void mention(struct breakpoint *)
Definition: breakpoint.c:8638
insert_bp_location
static int insert_bp_location(struct bp_location *bl, struct ui_file *tmp_error_stream, int *disabled_breaks, int *hw_breakpoint_error, int *hw_bp_error_explained_already)
Definition: breakpoint.c:2440
exec_catchpoint::~exec_catchpoint
~exec_catchpoint() override
Definition: breakpoint.c:8302
annotate_catchpoint
void annotate_catchpoint(int num)
Definition: annotate.c:87
enable_command
static void enable_command(const char *args, int from_tty)
Definition: breakpoint.c:14496
delete_std_terminate_breakpoint
void delete_std_terminate_breakpoint(void)
Definition: breakpoint.c:7465
strace_marker_decode_location
static std::vector< symtab_and_line > strace_marker_decode_location(struct breakpoint *b, const struct event_location *location, struct program_space *search_pspace)
Definition: breakpoint.c:13196
thread_fsm_ctor
void thread_fsm_ctor(struct thread_fsm *self, struct thread_fsm_ops *ops, struct interp *cmd_interp)
Definition: thread-fsm.c:25
set_momentary_breakpoint_at_pc
breakpoint_up set_momentary_breakpoint_at_pc(struct gdbarch *gdbarch, CORE_ADDR pc, enum bptype type)
Definition: breakpoint.c:8621
symtab_and_line::line
int line
Definition: symtab.h:1757
watchpoint::val_bitsize
int val_bitsize
Definition: breakpoint.h:824
breakpoint_ops
Definition: breakpoint.h:520
breakpoint_retire_moribund
void breakpoint_retire_moribund(void)
Definition: breakpoint.c:12195
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
minimal_symbol
Definition: symtab.h:623
enable_once_command
static void enable_once_command(const char *args, int from_tty)
Definition: breakpoint.c:14502
fork_catchpoint::forked_inferior_pid
ptid_t forked_inferior_pid
Definition: breakpoint.c:7745
remove_catch_exec
static int remove_catch_exec(struct bp_location *bl, enum remove_bp_reason reason)
Definition: breakpoint.c:8314
bound_minimal_symbol::objfile
struct objfile * objfile
Definition: minsyms.h:39
trace_command
static void trace_command(const char *arg, int from_tty)
Definition: breakpoint.c:14690
init_ada_exception_breakpoint
void init_ada_exception_breakpoint(struct breakpoint *b, struct gdbarch *gdbarch, struct symtab_and_line sal, const char *addr_string, const struct breakpoint_ops *ops, int tempflag, int enabled, int from_tty)
Definition: breakpoint.c:11391
new_single_step_breakpoint
static struct breakpoint * new_single_step_breakpoint(int thread, struct gdbarch *gdbarch)
Definition: breakpoint.c:8524
target_remove_hw_breakpoint
#define target_remove_hw_breakpoint(gdbarch, bp_tgt)
Definition: target.h:1972
cleanup::arg
void * arg
Definition: cleanups.c:43
bp_locations_compare
static int bp_locations_compare(const void *ap, const void *bp)
Definition: breakpoint.c:11649
dont_repeat
void dont_repeat(void)
Definition: top.c:695
watch_command
static void watch_command(const char *arg, int from_tty)
Definition: breakpoint.c:11034
probe::can_evaluate_arguments
virtual bool can_evaluate_arguments() const =0
class_maintenance
Definition: command.h:43
dprintf_after_condition_true
static void dprintf_after_condition_true(struct bpstats *bs)
Definition: breakpoint.c:13098
breakpoint_hit_catch_vfork
static int breakpoint_hit_catch_vfork(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.c:7886
remove_breakpoints_pid
int remove_breakpoints_pid(int pid)
Definition: breakpoint.c:3078
remove_jit_event_breakpoints
void remove_jit_event_breakpoints(void)
Definition: breakpoint.c:7509
find_location_by_number
static struct bp_location * find_location_by_number(int bp_num, int loc_num)
Definition: breakpoint.c:14139
bp_location::owner
breakpoint * owner
Definition: breakpoint.h:341
annotate.h
masked_watchpoint_breakpoint_ops
static struct breakpoint_ops masked_watchpoint_breakpoint_ops
Definition: breakpoint.c:10599
tracepoint_print_mention
static void tracepoint_print_mention(struct breakpoint *b)
Definition: breakpoint.c:12939
dprintf_style_enums
static const char *const dprintf_style_enums[]
Definition: breakpoint.c:273
until_break_fsm::thread_fsm
struct thread_fsm thread_fsm
Definition: breakpoint.c:11071
solib_catchpoint::is_load
unsigned char is_load
Definition: breakpoint.c:7988
enable_disable_command
static void enable_disable_command(const char *args, int from_tty, bool enable)
Definition: breakpoint.c:14363
bp_target_info::placed_address_space
struct address_space * placed_address_space
Definition: breakpoint.h:241
value_true
int value_true(struct value *val)
Definition: language.c:426
ALL_OBJFILES
#define ALL_OBJFILES(obj)
Definition: objfiles.h:582
QUIT
#define QUIT
Definition: defs.h:179
resolve_sal_pc
void resolve_sal_pc(struct symtab_and_line *sal)
Definition: breakpoint.c:9543
hw_watchpoint_used_count_others
static int hw_watchpoint_used_count_others(struct breakpoint *except, enum bptype type, int *other_type_used)
Definition: breakpoint.c:8453
EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
Definition: mi-common.h:34
bp_target_info::shadow_len
int shadow_len
Definition: breakpoint.h:264
catch_fork_breakpoint_ops
static struct breakpoint_ops catch_fork_breakpoint_ops
Definition: breakpoint.c:7862
no_breakpoint_here
Definition: breakpoint.h:1153
add_com
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:902
breakpoint::enable_state
enum enable_state enable_state
Definition: breakpoint.h:695
is_non_inline_function
static int is_non_inline_function(struct breakpoint *b)
Definition: breakpoint.c:15365
tcatch_command
static void tcatch_command(const char *arg, int from_tty)
Definition: breakpoint.c:11435
cmd_list_element::completer
completer_ftype * completer
Definition: cli-decode.h:164
switch_to_program_space_and_thread
void switch_to_program_space_and_thread(program_space *pspace)
Definition: progspace-and-thread.c:24
breakpoint_cond_eval
static bool breakpoint_cond_eval(expression *exp)
Definition: breakpoint.c:4720
bp_std_terminate
Definition: breakpoint.h:123
valprint.h
observer_attach_memory_changed
struct observer * observer_attach_memory_changed(observer_memory_changed_ftype *f)
symbol_name_match_type::FULL
value_address
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1529
is_catchpoint
int is_catchpoint(struct breakpoint *ep)
Definition: breakpoint.c:4192
breakpoint_objfile_data::longjmp_msym
struct bound_minimal_symbol longjmp_msym[NUM_LONGJMP_NAMES]
Definition: breakpoint.c:3149
UGLL_MAY_INSERT
Definition: breakpoint.c:209
enable_watchpoints_after_interactive_call_stop
void enable_watchpoints_after_interactive_call_stop(void)
Definition: breakpoint.c:8492
momentary_bkpt_re_set
static void momentary_bkpt_re_set(struct breakpoint *b)
Definition: breakpoint.c:12814
not_lval
Definition: defs.h:381
breakpoint_ops::create_breakpoints_sal
void(* create_breakpoints_sal)(struct gdbarch *, struct linespec_result *, gdb::unique_xmalloc_ptr< char >, gdb::unique_xmalloc_ptr< char >, enum bptype, enum bpdisp, int, int, int, const struct breakpoint_ops *, int, int, int, unsigned)
Definition: breakpoint.h:612
until_break_fsm::thread
int thread
Definition: breakpoint.c:11074
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
xcalloc
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:72
thread_suspend_state::waitstatus_pending_p
int waitstatus_pending_p
Definition: gdbthread.h:167
resources_needed_ranged_breakpoint
static int resources_needed_ranged_breakpoint(const struct bp_location *bl)
Definition: breakpoint.c:9755
stack.h
TARGET_WAITKIND_STOPPED
Definition: waitstatus.h:35
rwatch_command_wrapper
void rwatch_command_wrapper(const char *arg, int from_tty, int internal)
Definition: breakpoint.c:11040
remove_watchpoint
static int remove_watchpoint(struct bp_location *bl, enum remove_bp_reason reason)
Definition: breakpoint.c:10187
command_line::body_list
struct command_line ** body_list
Definition: cli-script.h:71
breakpoint_hit_catch_exec
static int breakpoint_hit_catch_exec(const struct bp_location *bl, const address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.c:8320
gdbarch_breakpoint_kind_from_current_state
int gdbarch_breakpoint_kind_from_current_state(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR *pcptr)
Definition: gdbarch.c:2895
ALL_BP_LOCATIONS
#define ALL_BP_LOCATIONS(B, BP_TMP)
Definition: breakpoint.c:506
LOCATION_HELP_STRING
#define LOCATION_HELP_STRING
Definition: breakpoint.c:15261
delete_longjmp_breakpoint_at_next_stop
void delete_longjmp_breakpoint_at_next_stop(int thread)
Definition: breakpoint.c:7337
gdbcmd.h
number_or_range_parser::get_number
int get_number()
Definition: cli-utils.c:151
is_scalar_type_recursive
int is_scalar_type_recursive(struct type *t)
Definition: gdbtypes.c:3075
delete_breakpoint
void delete_breakpoint(struct breakpoint *bpt)
Definition: breakpoint.c:13226
EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
Definition: mi-common.h:33
get_frame_program_space
struct program_space * get_frame_program_space(struct frame_info *frame)
Definition: frame.c:2629
base_breakpoint_insert_location
static int base_breakpoint_insert_location(struct bp_location *bl)
Definition: breakpoint.c:12357
format_pieces
Definition: format.h:61
breakpoint_ops::print_one
void(* print_one)(struct breakpoint *, struct bp_location **)
Definition: breakpoint.h:572
condition_evaluation_target
static const char condition_evaluation_target[]
Definition: breakpoint.c:429
breakpoint_re_set_thread
void breakpoint_re_set_thread(struct breakpoint *b)
Definition: breakpoint.c:13998
maybe_print_thread_hit_breakpoint
void maybe_print_thread_hit_breakpoint(struct ui_out *uiout)
Definition: breakpoint.c:4532
UGLL_INSERT
Definition: breakpoint.c:218
print_mention_masked_watchpoint
static void print_mention_masked_watchpoint(struct breakpoint *b)
Definition: breakpoint.c:10536
counted_command_line
std::shared_ptr< command_line > counted_command_line
Definition: breakpoint.h:667
dprintf_command
static void dprintf_command(const char *arg, int from_tty)
Definition: breakpoint.c:9698
should_be_inserted
static int should_be_inserted(struct bp_location *bl)
Definition: breakpoint.c:2005
delete_command
static void delete_command(const char *arg, int from_tty)
Definition: breakpoint.c:13353
STOP_STACK_DUMMY
Definition: breakpoint.h:997
is_tracepoint
int is_tracepoint(const struct breakpoint *b)
Definition: breakpoint.c:1053
ui_out_emit_table
Definition: ui-out.h:219
breakpoint::task
int task
Definition: breakpoint.h:767
target_supports_stopped_by_hw_breakpoint
#define target_supports_stopped_by_hw_breakpoint()
Definition: target.h:1891
multiple_symbols_all
const char multiple_symbols_all[]
Definition: symtab.c:238
string_to_event_location
event_location_up string_to_event_location(const char **stringp, const struct language_defn *language, symbol_name_match_type match_type)
Definition: location.c:917
remove_catch_solib
static int remove_catch_solib(struct bp_location *ignore, enum remove_bp_reason reason)
Definition: breakpoint.c:8008
thread_info
Definition: gdbthread.h:205
condition_modified
Definition: breakpoint.h:232
strace_marker_p
static int strace_marker_p(struct breakpoint *b)
Definition: breakpoint.c:13217
watchpoint::watchpoint_frame
struct frame_id watchpoint_frame
Definition: breakpoint.h:829
error
void error(const char *fmt,...)
Definition: errors.c:38
internal_breakpoint_number
static int internal_breakpoint_number
Definition: breakpoint.c:3099
jit_event_handler
void jit_event_handler(struct gdbarch *gdbarch)
Definition: jit.c:1426
dprintf_print_recreate
static void dprintf_print_recreate(struct breakpoint *tp, struct ui_file *fp)
Definition: breakpoint.c:13080
bp_access_watchpoint
Definition: breakpoint.h:78
internal_breakpoint_ops
static struct breakpoint_ops internal_breakpoint_ops
Definition: breakpoint.c:248
breakpoint_location_address_match
static int breakpoint_location_address_match(struct bp_location *bl, const struct address_space *aspace, CORE_ADDR addr)
get_number
int get_number(const char **pp)
Definition: cli-utils.c:110
breakpoint_ops::re_set
void(* re_set)(struct breakpoint *self)
Definition: breakpoint.h:528
watchpoint::exp_string_reparse
char * exp_string_reparse
Definition: breakpoint.h:801
target_static_tracepoint_marker_at
#define target_static_tracepoint_marker_at(addr, marker)
Definition: target.h:2204
create_and_insert_solib_event_breakpoint
struct breakpoint * create_and_insert_solib_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7568
remove_bp_reason
remove_bp_reason
Definition: breakpoint.h:47
gdbarch_software_single_step
std::vector< CORE_ADDR > gdbarch_software_single_step(struct gdbarch *gdbarch, struct regcache *regcache)
Definition: gdbarch.c:3248
set_breakpoint_condition
void set_breakpoint_condition(struct breakpoint *b, const char *exp, int from_tty)
Definition: breakpoint.c:838
check_for_argument
int check_for_argument(const char **str, const char *arg, int arg_len)
Definition: cli-utils.c:297
frame_id
Definition: frame.h:111
TARGET_XFER_E_IO
Definition: target.h:220
thread_fsm_set_finished
void thread_fsm_set_finished(struct thread_fsm *self)
Definition: thread-fsm.c:76
bp_location_dtor
static void bp_location_dtor(struct bp_location *self)
Definition: breakpoint.c:12322
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
bkpt_resources_needed
static int bkpt_resources_needed(const struct bp_location *bl)
Definition: breakpoint.c:12576
block.h
init_breakpoint_sal
static void init_breakpoint_sal(struct breakpoint *b, struct gdbarch *gdbarch, gdb::array_view< const symtab_and_line > sals, event_location_up &&location, gdb::unique_xmalloc_ptr< char > filter, gdb::unique_xmalloc_ptr< char > cond_string, gdb::unique_xmalloc_ptr< char > extra_string, enum bptype type, enum bpdisp disposition, int thread, int task, int ignore_count, const struct breakpoint_ops *ops, int from_tty, int enabled, int internal, unsigned flags, int display_canonical)
Definition: breakpoint.c:8855
LONGEST
long long LONGEST
Definition: common-types.h:52
symtab_and_line::explicit_pc
bool explicit_pc
Definition: symtab.h:1761
target_masked_watch_num_registers
int target_masked_watch_num_registers(CORE_ADDR addr, CORE_ADDR mask)
Definition: target.c:3535
execute_control_command
enum command_control_type execute_control_command(struct command_line *cmd)
Definition: cli-script.c:650
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
watchpoint_in_thread_scope
static int watchpoint_in_thread_scope(struct watchpoint *b)
Definition: breakpoint.c:1549
is_executing
int is_executing(ptid_t ptid)
Definition: thread.c:981
commands_from_control_command
enum command_control_type commands_from_control_command(const char *arg, struct command_line *cmd)
Definition: breakpoint.c:1289
update_watchpoint
static void update_watchpoint(struct watchpoint *b, int reparse)
Definition: breakpoint.c:1680
print_recreate_watchpoint
static void print_recreate_watchpoint(struct breakpoint *b, struct ui_file *fp)
Definition: breakpoint.c:10378
init_raw_breakpoint
static void init_raw_breakpoint(struct breakpoint *b, struct gdbarch *gdbarch, struct symtab_and_line sal, enum bptype bptype, const struct breakpoint_ops *ops)
Definition: breakpoint.c:7246
program_space
Definition: progspace.h:137
mst_file_text
Definition: symtab.h:600
ui_out::is_mi_like_p
bool is_mi_like_p()
Definition: ui-out.c:622
symfile.h
bp_location
Definition: breakpoint.h:315
watchpoint_check
static wp_check_result watchpoint_check(bpstat bs)
Definition: breakpoint.c:4859
AUTO_BOOLEAN_FALSE
Definition: defs.h:240
gdb_exception::reason
enum return_reason reason
Definition: common-exceptions.h:113
bpdisp_text
const char * bpdisp_text(enum bpdisp disp)
Definition: breakpoint.c:314
check_status_watchpoint
static void check_status_watchpoint(bpstat bs)
Definition: breakpoint.c:10218
ui_out::field_fmt
void field_fmt(const char *fldname, const char *format,...) ATTRIBUTE_PRINTF(3
Definition: ui-out.c:557
breakpoint::frame_id
struct frame_id frame_id
Definition: breakpoint.h:722
free_breakpoint_objfile_data
static void free_breakpoint_objfile_data(struct objfile *obj, void *data)
Definition: breakpoint.c:3204
download_tracepoint_locations
static void download_tracepoint_locations(void)
Definition: breakpoint.c:11719
ui-out.h
mem_region
Definition: memattr.h:83
gdb-demangle.h
lang_and_radix
Definition: breakpoint.c:7491
observer_notify_breakpoint_modified
void observer_notify_breakpoint_modified(struct breakpoint *b)
observer_attach_about_to_proceed
struct observer * observer_attach_about_to_proceed(observer_about_to_proceed_ftype *f)
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
parse_cond_to_aexpr
static agent_expr_up parse_cond_to_aexpr(CORE_ADDR scope, struct expression *cond)
Definition: breakpoint.c:2098
init_catchpoint
void init_catchpoint(struct breakpoint *b, struct gdbarch *gdbarch, int tempflag, const char *cond_string, const struct breakpoint_ops *ops)
Definition: breakpoint.c:8241
continuations.h
until_break_fsm_ops
static struct thread_fsm_ops until_break_fsm_ops
Definition: breakpoint.c:11093
breakpoint::filter
char * filter
Definition: breakpoint.h:735
check_longjmp_breakpoint_for_call_dummy
void check_longjmp_breakpoint_for_call_dummy(struct thread_info *tp)
Definition: breakpoint.c:7392
condition_unchanged
Definition: breakpoint.h:231
mem_attrib::mode
enum mem_access_mode mode
Definition: memattr.h:65
mark_breakpoints_out
void mark_breakpoints_out(void)
Definition: breakpoint.c:3850
clear_command
static void clear_command(const char *arg, int from_tty)
Definition: breakpoint.c:11463
gdbarch_get_longjmp_target_p
int gdbarch_get_longjmp_target_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2555
bpstats::old_val
struct value * old_val
Definition: breakpoint.h:1128
bpstat_what::main_action
enum bpstat_what_main_action main_action
Definition: breakpoint.h:1005
string_file
Definition: ui-file.h:106
parse_and_eval_long
LONGEST parse_and_eval_long(const char *exp)
Definition: eval.c:111
array-view.h