Automatic date update in version.in
[external/binutils.git] / gdb / breakpoint.c
1 /* Everything about breakpoints, for GDB.
2
3    Copyright (C) 1986-2019 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 "observable.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 "common/format.h"
69 #include "thread-fsm.h"
70 #include "tid-parse.h"
71 #include "cli/cli-style.h"
72
73 /* readline include files */
74 #include "readline/readline.h"
75 #include "readline/history.h"
76
77 /* readline defines this.  */
78 #undef savestring
79
80 #include "mi/mi-common.h"
81 #include "extension.h"
82 #include <algorithm>
83 #include "progspace-and-thread.h"
84 #include "common/array-view.h"
85 #include "common/gdb_optional.h"
86
87 /* Enums for exception-handling support.  */
88 enum exception_event_kind
89 {
90   EX_EVENT_THROW,
91   EX_EVENT_RETHROW,
92   EX_EVENT_CATCH
93 };
94
95 /* Prototypes for local functions.  */
96
97 static void map_breakpoint_numbers (const char *,
98                                     gdb::function_view<void (breakpoint *)>);
99
100 static void breakpoint_re_set_default (struct breakpoint *);
101
102 static void
103   create_sals_from_location_default (const struct event_location *location,
104                                      struct linespec_result *canonical,
105                                      enum bptype type_wanted);
106
107 static void create_breakpoints_sal_default (struct gdbarch *,
108                                             struct linespec_result *,
109                                             gdb::unique_xmalloc_ptr<char>,
110                                             gdb::unique_xmalloc_ptr<char>,
111                                             enum bptype,
112                                             enum bpdisp, int, int,
113                                             int,
114                                             const struct breakpoint_ops *,
115                                             int, int, int, unsigned);
116
117 static std::vector<symtab_and_line> decode_location_default
118   (struct breakpoint *b, const struct event_location *location,
119    struct program_space *search_pspace);
120
121 static int can_use_hardware_watchpoint
122     (const std::vector<value_ref_ptr> &vals);
123
124 static void mention (struct breakpoint *);
125
126 static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
127                                                                enum bptype,
128                                                                const struct breakpoint_ops *);
129 static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
130                                                        const struct symtab_and_line *);
131
132 /* This function is used in gdbtk sources and thus can not be made
133    static.  */
134 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
135                                        struct symtab_and_line,
136                                        enum bptype,
137                                        const struct breakpoint_ops *);
138
139 static struct breakpoint *
140   momentary_breakpoint_from_master (struct breakpoint *orig,
141                                     enum bptype type,
142                                     const struct breakpoint_ops *ops,
143                                     int loc_enabled);
144
145 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
146
147 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
148                                             CORE_ADDR bpaddr,
149                                             enum bptype bptype);
150
151 static void describe_other_breakpoints (struct gdbarch *,
152                                         struct program_space *, CORE_ADDR,
153                                         struct obj_section *, int);
154
155 static int watchpoint_locations_match (struct bp_location *loc1,
156                                        struct bp_location *loc2);
157
158 static int breakpoint_location_address_match (struct bp_location *bl,
159                                               const struct address_space *aspace,
160                                               CORE_ADDR addr);
161
162 static int breakpoint_location_address_range_overlap (struct bp_location *,
163                                                       const address_space *,
164                                                       CORE_ADDR, int);
165
166 static int remove_breakpoint (struct bp_location *);
167 static int remove_breakpoint_1 (struct bp_location *, enum remove_bp_reason);
168
169 static enum print_stop_action print_bp_stop_message (bpstat bs);
170
171 static int hw_breakpoint_used_count (void);
172
173 static int hw_watchpoint_use_count (struct breakpoint *);
174
175 static int hw_watchpoint_used_count_others (struct breakpoint *except,
176                                             enum bptype type,
177                                             int *other_type_used);
178
179 static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
180                                     int count);
181
182 static void free_bp_location (struct bp_location *loc);
183 static void incref_bp_location (struct bp_location *loc);
184 static void decref_bp_location (struct bp_location **loc);
185
186 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
187
188 /* update_global_location_list's modes of operation wrt to whether to
189    insert locations now.  */
190 enum ugll_insert_mode
191 {
192   /* Don't insert any breakpoint locations into the inferior, only
193      remove already-inserted locations that no longer should be
194      inserted.  Functions that delete a breakpoint or breakpoints
195      should specify this mode, so that deleting a breakpoint doesn't
196      have the side effect of inserting the locations of other
197      breakpoints that are marked not-inserted, but should_be_inserted
198      returns true on them.
199
200      This behavior is useful is situations close to tear-down -- e.g.,
201      after an exec, while the target still has execution, but
202      breakpoint shadows of the previous executable image should *NOT*
203      be restored to the new image; or before detaching, where the
204      target still has execution and wants to delete breakpoints from
205      GDB's lists, and all breakpoints had already been removed from
206      the inferior.  */
207   UGLL_DONT_INSERT,
208
209   /* May insert breakpoints iff breakpoints_should_be_inserted_now
210      claims breakpoints should be inserted now.  */
211   UGLL_MAY_INSERT,
212
213   /* Insert locations now, irrespective of
214      breakpoints_should_be_inserted_now.  E.g., say all threads are
215      stopped right now, and the user did "continue".  We need to
216      insert breakpoints _before_ resuming the target, but
217      UGLL_MAY_INSERT wouldn't insert them, because
218      breakpoints_should_be_inserted_now returns false at that point,
219      as no thread is running yet.  */
220   UGLL_INSERT
221 };
222
223 static void update_global_location_list (enum ugll_insert_mode);
224
225 static void update_global_location_list_nothrow (enum ugll_insert_mode);
226
227 static int is_hardware_watchpoint (const struct breakpoint *bpt);
228
229 static void insert_breakpoint_locations (void);
230
231 static void trace_pass_command (const char *, int);
232
233 static void set_tracepoint_count (int num);
234
235 static int is_masked_watchpoint (const struct breakpoint *b);
236
237 static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
238
239 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
240    otherwise.  */
241
242 static int strace_marker_p (struct breakpoint *b);
243
244 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
245    that are implemented on top of software or hardware breakpoints
246    (user breakpoints, internal and momentary breakpoints, etc.).  */
247 static struct breakpoint_ops bkpt_base_breakpoint_ops;
248
249 /* Internal breakpoints class type.  */
250 static struct breakpoint_ops internal_breakpoint_ops;
251
252 /* Momentary breakpoints class type.  */
253 static struct breakpoint_ops momentary_breakpoint_ops;
254
255 /* The breakpoint_ops structure to be used in regular user created
256    breakpoints.  */
257 struct breakpoint_ops bkpt_breakpoint_ops;
258
259 /* Breakpoints set on probes.  */
260 static struct breakpoint_ops bkpt_probe_breakpoint_ops;
261
262 /* Dynamic printf class type.  */
263 struct breakpoint_ops dprintf_breakpoint_ops;
264
265 /* The style in which to perform a dynamic printf.  This is a user
266    option because different output options have different tradeoffs;
267    if GDB does the printing, there is better error handling if there
268    is a problem with any of the arguments, but using an inferior
269    function lets you have special-purpose printers and sending of
270    output to the same place as compiled-in print functions.  */
271
272 static const char dprintf_style_gdb[] = "gdb";
273 static const char dprintf_style_call[] = "call";
274 static const char dprintf_style_agent[] = "agent";
275 static const char *const dprintf_style_enums[] = {
276   dprintf_style_gdb,
277   dprintf_style_call,
278   dprintf_style_agent,
279   NULL
280 };
281 static const char *dprintf_style = dprintf_style_gdb;
282
283 /* The function to use for dynamic printf if the preferred style is to
284    call into the inferior.  The value is simply a string that is
285    copied into the command, so it can be anything that GDB can
286    evaluate to a callable address, not necessarily a function name.  */
287
288 static char *dprintf_function;
289
290 /* The channel to use for dynamic printf if the preferred style is to
291    call into the inferior; if a nonempty string, it will be passed to
292    the call as the first argument, with the format string as the
293    second.  As with the dprintf function, this can be anything that
294    GDB knows how to evaluate, so in addition to common choices like
295    "stderr", this could be an app-specific expression like
296    "mystreams[curlogger]".  */
297
298 static char *dprintf_channel;
299
300 /* True if dprintf commands should continue to operate even if GDB
301    has disconnected.  */
302 static int disconnected_dprintf = 1;
303
304 struct command_line *
305 breakpoint_commands (struct breakpoint *b)
306 {
307   return b->commands ? b->commands.get () : NULL;
308 }
309
310 /* Flag indicating that a command has proceeded the inferior past the
311    current breakpoint.  */
312
313 static int breakpoint_proceeded;
314
315 const char *
316 bpdisp_text (enum bpdisp disp)
317 {
318   /* NOTE: the following values are a part of MI protocol and
319      represent values of 'disp' field returned when inferior stops at
320      a breakpoint.  */
321   static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
322
323   return bpdisps[(int) disp];
324 }
325
326 /* Prototypes for exported functions.  */
327 /* If FALSE, gdb will not use hardware support for watchpoints, even
328    if such is available.  */
329 static int can_use_hw_watchpoints;
330
331 static void
332 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
333                              struct cmd_list_element *c,
334                              const char *value)
335 {
336   fprintf_filtered (file,
337                     _("Debugger's willingness to use "
338                       "watchpoint hardware is %s.\n"),
339                     value);
340 }
341
342 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
343    If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
344    for unrecognized breakpoint locations.
345    If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized.  */
346 static enum auto_boolean pending_break_support;
347 static void
348 show_pending_break_support (struct ui_file *file, int from_tty,
349                             struct cmd_list_element *c,
350                             const char *value)
351 {
352   fprintf_filtered (file,
353                     _("Debugger's behavior regarding "
354                       "pending breakpoints is %s.\n"),
355                     value);
356 }
357
358 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
359    set with "break" but falling in read-only memory.
360    If 0, gdb will warn about such breakpoints, but won't automatically
361    use hardware breakpoints.  */
362 static int automatic_hardware_breakpoints;
363 static void
364 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
365                                      struct cmd_list_element *c,
366                                      const char *value)
367 {
368   fprintf_filtered (file,
369                     _("Automatic usage of hardware breakpoints is %s.\n"),
370                     value);
371 }
372
373 /* If on, GDB keeps breakpoints inserted even if the inferior is
374    stopped, and immediately inserts any new breakpoints as soon as
375    they're created.  If off (default), GDB keeps breakpoints off of
376    the target as long as possible.  That is, it delays inserting
377    breakpoints until the next resume, and removes them again when the
378    target fully stops.  This is a bit safer in case GDB crashes while
379    processing user input.  */
380 static int always_inserted_mode = 0;
381
382 static void
383 show_always_inserted_mode (struct ui_file *file, int from_tty,
384                      struct cmd_list_element *c, const char *value)
385 {
386   fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
387                     value);
388 }
389
390 /* See breakpoint.h.  */
391
392 int
393 breakpoints_should_be_inserted_now (void)
394 {
395   if (gdbarch_has_global_breakpoints (target_gdbarch ()))
396     {
397       /* If breakpoints are global, they should be inserted even if no
398          thread under gdb's control is running, or even if there are
399          no threads under GDB's control yet.  */
400       return 1;
401     }
402   else if (target_has_execution)
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       for (thread_info *tp : all_non_exited_threads ())
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 static std::vector<bp_location *> moribund_locations;
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 \f
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 \f
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.reset ();
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.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   gdb::observers::breakpoint_modified.notify (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       if (c->control_type == while_stepping_control)
1012         error (_("The 'while-stepping' command can "
1013                  "only be used for tracepoints"));
1014
1015       check_no_tracepoint_commands (c->body_list_0.get ());
1016       check_no_tracepoint_commands (c->body_list_1.get ());
1017
1018       /* Not that command parsing removes leading whitespace and comment
1019          lines and also empty lines.  So, we only need to check for
1020          command directly.  */
1021       if (strstr (c->line, "collect ") == c->line)
1022         error (_("The 'collect' command can only be used for tracepoints"));
1023
1024       if (strstr (c->line, "teval ") == c->line)
1025         error (_("The 'teval' command can only be used for tracepoints"));
1026     }
1027 }
1028
1029 struct longjmp_breakpoint : public breakpoint
1030 {
1031   ~longjmp_breakpoint () override;
1032 };
1033
1034 /* Encapsulate tests for different types of tracepoints.  */
1035
1036 static bool
1037 is_tracepoint_type (bptype type)
1038 {
1039   return (type == bp_tracepoint
1040           || type == bp_fast_tracepoint
1041           || type == bp_static_tracepoint);
1042 }
1043
1044 static bool
1045 is_longjmp_type (bptype type)
1046 {
1047   return type == bp_longjmp || type == bp_exception;
1048 }
1049
1050 int
1051 is_tracepoint (const struct breakpoint *b)
1052 {
1053   return is_tracepoint_type (b->type);
1054 }
1055
1056 /* Factory function to create an appropriate instance of breakpoint given
1057    TYPE.  */
1058
1059 static std::unique_ptr<breakpoint>
1060 new_breakpoint_from_type (bptype type)
1061 {
1062   breakpoint *b;
1063
1064   if (is_tracepoint_type (type))
1065     b = new tracepoint ();
1066   else if (is_longjmp_type (type))
1067     b = new longjmp_breakpoint ();
1068   else
1069     b = new breakpoint ();
1070
1071   return std::unique_ptr<breakpoint> (b);
1072 }
1073
1074 /* A helper function that validates that COMMANDS are valid for a
1075    breakpoint.  This function will throw an exception if a problem is
1076    found.  */
1077
1078 static void
1079 validate_commands_for_breakpoint (struct breakpoint *b,
1080                                   struct command_line *commands)
1081 {
1082   if (is_tracepoint (b))
1083     {
1084       struct tracepoint *t = (struct tracepoint *) b;
1085       struct command_line *c;
1086       struct command_line *while_stepping = 0;
1087
1088       /* Reset the while-stepping step count.  The previous commands
1089          might have included a while-stepping action, while the new
1090          ones might not.  */
1091       t->step_count = 0;
1092
1093       /* We need to verify that each top-level element of commands is
1094          valid for tracepoints, that there's at most one
1095          while-stepping element, and that the while-stepping's body
1096          has valid tracing commands excluding nested while-stepping.
1097          We also need to validate the tracepoint action line in the
1098          context of the tracepoint --- validate_actionline actually
1099          has side effects, like setting the tracepoint's
1100          while-stepping STEP_COUNT, in addition to checking if the
1101          collect/teval actions parse and make sense in the
1102          tracepoint's context.  */
1103       for (c = commands; c; c = c->next)
1104         {
1105           if (c->control_type == while_stepping_control)
1106             {
1107               if (b->type == bp_fast_tracepoint)
1108                 error (_("The 'while-stepping' command "
1109                          "cannot be used for fast tracepoint"));
1110               else if (b->type == bp_static_tracepoint)
1111                 error (_("The 'while-stepping' command "
1112                          "cannot be used for static tracepoint"));
1113
1114               if (while_stepping)
1115                 error (_("The 'while-stepping' command "
1116                          "can be used only once"));
1117               else
1118                 while_stepping = c;
1119             }
1120
1121           validate_actionline (c->line, b);
1122         }
1123       if (while_stepping)
1124         {
1125           struct command_line *c2;
1126
1127           gdb_assert (while_stepping->body_list_1 == nullptr);
1128           c2 = while_stepping->body_list_0.get ();
1129           for (; c2; c2 = c2->next)
1130             {
1131               if (c2->control_type == while_stepping_control)
1132                 error (_("The 'while-stepping' command cannot be nested"));
1133             }
1134         }
1135     }
1136   else
1137     {
1138       check_no_tracepoint_commands (commands);
1139     }
1140 }
1141
1142 /* Return a vector of all the static tracepoints set at ADDR.  The
1143    caller is responsible for releasing the vector.  */
1144
1145 std::vector<breakpoint *>
1146 static_tracepoints_here (CORE_ADDR addr)
1147 {
1148   struct breakpoint *b;
1149   std::vector<breakpoint *> found;
1150   struct bp_location *loc;
1151
1152   ALL_BREAKPOINTS (b)
1153     if (b->type == bp_static_tracepoint)
1154       {
1155         for (loc = b->loc; loc; loc = loc->next)
1156           if (loc->address == addr)
1157             found.push_back (b);
1158       }
1159
1160   return found;
1161 }
1162
1163 /* Set the command list of B to COMMANDS.  If breakpoint is tracepoint,
1164    validate that only allowed commands are included.  */
1165
1166 void
1167 breakpoint_set_commands (struct breakpoint *b, 
1168                          counted_command_line &&commands)
1169 {
1170   validate_commands_for_breakpoint (b, commands.get ());
1171
1172   b->commands = std::move (commands);
1173   gdb::observers::breakpoint_modified.notify (b);
1174 }
1175
1176 /* Set the internal `silent' flag on the breakpoint.  Note that this
1177    is not the same as the "silent" that may appear in the breakpoint's
1178    commands.  */
1179
1180 void
1181 breakpoint_set_silent (struct breakpoint *b, int silent)
1182 {
1183   int old_silent = b->silent;
1184
1185   b->silent = silent;
1186   if (old_silent != silent)
1187     gdb::observers::breakpoint_modified.notify (b);
1188 }
1189
1190 /* Set the thread for this breakpoint.  If THREAD is -1, make the
1191    breakpoint work for any thread.  */
1192
1193 void
1194 breakpoint_set_thread (struct breakpoint *b, int thread)
1195 {
1196   int old_thread = b->thread;
1197
1198   b->thread = thread;
1199   if (old_thread != thread)
1200     gdb::observers::breakpoint_modified.notify (b);
1201 }
1202
1203 /* Set the task for this breakpoint.  If TASK is 0, make the
1204    breakpoint work for any task.  */
1205
1206 void
1207 breakpoint_set_task (struct breakpoint *b, int task)
1208 {
1209   int old_task = b->task;
1210
1211   b->task = task;
1212   if (old_task != task)
1213     gdb::observers::breakpoint_modified.notify (b);
1214 }
1215
1216 static void
1217 commands_command_1 (const char *arg, int from_tty,
1218                     struct command_line *control)
1219 {
1220   counted_command_line cmd;
1221   /* cmd_read will be true once we have read cmd.  Note that cmd might still be
1222      NULL after the call to read_command_lines if the user provides an empty
1223      list of command by just typing "end".  */
1224   bool cmd_read = false;
1225
1226   std::string new_arg;
1227
1228   if (arg == NULL || !*arg)
1229     {
1230       if (breakpoint_count - prev_breakpoint_count > 1)
1231         new_arg = string_printf ("%d-%d", prev_breakpoint_count + 1,
1232                                  breakpoint_count);
1233       else if (breakpoint_count > 0)
1234         new_arg = string_printf ("%d", breakpoint_count);
1235       arg = new_arg.c_str ();
1236     }
1237
1238   map_breakpoint_numbers
1239     (arg, [&] (breakpoint *b)
1240      {
1241        if (!cmd_read)
1242          {
1243            gdb_assert (cmd == NULL);
1244            if (control != NULL)
1245              cmd = control->body_list_0;
1246            else
1247              {
1248                std::string str
1249                  = string_printf (_("Type commands for breakpoint(s) "
1250                                     "%s, one per line."),
1251                                   arg);
1252
1253                auto do_validate = [=] (const char *line)
1254                                   {
1255                                     validate_actionline (line, b);
1256                                   };
1257                gdb::function_view<void (const char *)> validator;
1258                if (is_tracepoint (b))
1259                  validator = do_validate;
1260
1261                cmd = read_command_lines (str.c_str (), from_tty, 1, validator);
1262              }
1263            cmd_read = true;
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            gdb::observers::breakpoint_modified.notify (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 \f
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           && (b->watchpoint_thread == null_ptid
1553               || (inferior_ptid == b->watchpoint_thread
1554                   && !inferior_thread ()->executing)));
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       b->val = NULL;
1744       b->val_valid = 0;
1745
1746       /* Note that unlike with breakpoints, the watchpoint's condition
1747          expression is stored in the breakpoint object, not in the
1748          locations (re)created below.  */
1749       if (b->cond_string != NULL)
1750         {
1751           b->cond_exp.reset ();
1752
1753           s = b->cond_string;
1754           b->cond_exp = parse_exp_1 (&s, 0, b->cond_exp_valid_block, 0);
1755         }
1756     }
1757
1758   /* If we failed to parse the expression, for example because
1759      it refers to a global variable in a not-yet-loaded shared library,
1760      don't try to insert watchpoint.  We don't automatically delete
1761      such watchpoint, though, since failure to parse expression
1762      is different from out-of-scope watchpoint.  */
1763   if (!target_has_execution)
1764     {
1765       /* Without execution, memory can't change.  No use to try and
1766          set watchpoint locations.  The watchpoint will be reset when
1767          the target gains execution, through breakpoint_re_set.  */
1768       if (!can_use_hw_watchpoints)
1769         {
1770           if (b->ops->works_in_software_mode (b))
1771             b->type = bp_watchpoint;
1772           else
1773             error (_("Can't set read/access watchpoint when "
1774                      "hardware watchpoints are disabled."));
1775         }
1776     }
1777   else if (within_current_scope && b->exp)
1778     {
1779       int pc = 0;
1780       std::vector<value_ref_ptr> val_chain;
1781       struct value *v, *result;
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             v = extract_bitfield_from_watchpoint_value (b, v);
1796           b->val = release_value (v);
1797           b->val_valid = 1;
1798         }
1799
1800       frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1801
1802       /* Look at each value on the value chain.  */
1803       gdb_assert (!val_chain.empty ());
1804       for (const value_ref_ptr &iter : val_chain)
1805         {
1806           v = iter.get ();
1807
1808           /* If it's a memory location, and GDB actually needed
1809              its contents to evaluate the expression, then we
1810              must watch it.  If the first value returned is
1811              still lazy, that means an error occurred reading it;
1812              watch it anyway in case it becomes readable.  */
1813           if (VALUE_LVAL (v) == lval_memory
1814               && (v == val_chain[0] || ! value_lazy (v)))
1815             {
1816               struct type *vtype = check_typedef (value_type (v));
1817
1818               /* We only watch structs and arrays if user asked
1819                  for it explicitly, never if they just happen to
1820                  appear in the middle of some value chain.  */
1821               if (v == result
1822                   || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1823                       && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1824                 {
1825                   CORE_ADDR addr;
1826                   enum target_hw_bp_type type;
1827                   struct bp_location *loc, **tmp;
1828                   int bitpos = 0, bitsize = 0;
1829
1830                   if (value_bitsize (v) != 0)
1831                     {
1832                       /* Extract the bit parameters out from the bitfield
1833                          sub-expression.  */
1834                       bitpos = value_bitpos (v);
1835                       bitsize = value_bitsize (v);
1836                     }
1837                   else if (v == result && b->val_bitsize != 0)
1838                     {
1839                      /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1840                         lvalue whose bit parameters are saved in the fields
1841                         VAL_BITPOS and VAL_BITSIZE.  */
1842                       bitpos = b->val_bitpos;
1843                       bitsize = b->val_bitsize;
1844                     }
1845
1846                   addr = value_address (v);
1847                   if (bitsize != 0)
1848                     {
1849                       /* Skip the bytes that don't contain the bitfield.  */
1850                       addr += bitpos / 8;
1851                     }
1852
1853                   type = hw_write;
1854                   if (b->type == bp_read_watchpoint)
1855                     type = hw_read;
1856                   else if (b->type == bp_access_watchpoint)
1857                     type = hw_access;
1858
1859                   loc = allocate_bp_location (b);
1860                   for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
1861                     ;
1862                   *tmp = loc;
1863                   loc->gdbarch = get_type_arch (value_type (v));
1864
1865                   loc->pspace = frame_pspace;
1866                   loc->address = address_significant (loc->gdbarch, addr);
1867
1868                   if (bitsize != 0)
1869                     {
1870                       /* Just cover the bytes that make up the bitfield.  */
1871                       loc->length = ((bitpos % 8) + bitsize + 7) / 8;
1872                     }
1873                   else
1874                     loc->length = TYPE_LENGTH (value_type (v));
1875
1876                   loc->watchpoint_type = type;
1877                 }
1878             }
1879         }
1880
1881       /* Change the type of breakpoint between hardware assisted or
1882          an ordinary watchpoint depending on the hardware support
1883          and free hardware slots.  REPARSE is set when the inferior
1884          is started.  */
1885       if (reparse)
1886         {
1887           int reg_cnt;
1888           enum bp_loc_type loc_type;
1889           struct bp_location *bl;
1890
1891           reg_cnt = can_use_hardware_watchpoint (val_chain);
1892
1893           if (reg_cnt)
1894             {
1895               int i, target_resources_ok, other_type_used;
1896               enum bptype type;
1897
1898               /* Use an exact watchpoint when there's only one memory region to be
1899                  watched, and only one debug register is needed to watch it.  */
1900               b->exact = target_exact_watchpoints && reg_cnt == 1;
1901
1902               /* We need to determine how many resources are already
1903                  used for all other hardware watchpoints plus this one
1904                  to see if we still have enough resources to also fit
1905                  this watchpoint in as well.  */
1906
1907               /* If this is a software watchpoint, we try to turn it
1908                  to a hardware one -- count resources as if B was of
1909                  hardware watchpoint type.  */
1910               type = b->type;
1911               if (type == bp_watchpoint)
1912                 type = bp_hardware_watchpoint;
1913
1914               /* This watchpoint may or may not have been placed on
1915                  the list yet at this point (it won't be in the list
1916                  if we're trying to create it for the first time,
1917                  through watch_command), so always account for it
1918                  manually.  */
1919
1920               /* Count resources used by all watchpoints except B.  */
1921               i = hw_watchpoint_used_count_others (b, type, &other_type_used);
1922
1923               /* Add in the resources needed for B.  */
1924               i += hw_watchpoint_use_count (b);
1925
1926               target_resources_ok
1927                 = target_can_use_hardware_watchpoint (type, i, other_type_used);
1928               if (target_resources_ok <= 0)
1929                 {
1930                   int sw_mode = b->ops->works_in_software_mode (b);
1931
1932                   if (target_resources_ok == 0 && !sw_mode)
1933                     error (_("Target does not support this type of "
1934                              "hardware watchpoint."));
1935                   else if (target_resources_ok < 0 && !sw_mode)
1936                     error (_("There are not enough available hardware "
1937                              "resources for this watchpoint."));
1938
1939                   /* Downgrade to software watchpoint.  */
1940                   b->type = bp_watchpoint;
1941                 }
1942               else
1943                 {
1944                   /* If this was a software watchpoint, we've just
1945                      found we have enough resources to turn it to a
1946                      hardware watchpoint.  Otherwise, this is a
1947                      nop.  */
1948                   b->type = type;
1949                 }
1950             }
1951           else if (!b->ops->works_in_software_mode (b))
1952             {
1953               if (!can_use_hw_watchpoints)
1954                 error (_("Can't set read/access watchpoint when "
1955                          "hardware watchpoints are disabled."));
1956               else
1957                 error (_("Expression cannot be implemented with "
1958                          "read/access watchpoint."));
1959             }
1960           else
1961             b->type = bp_watchpoint;
1962
1963           loc_type = (b->type == bp_watchpoint? bp_loc_other
1964                       : bp_loc_hardware_watchpoint);
1965           for (bl = b->loc; bl; bl = bl->next)
1966             bl->loc_type = loc_type;
1967         }
1968
1969       /* If a software watchpoint is not watching any memory, then the
1970          above left it without any location set up.  But,
1971          bpstat_stop_status requires a location to be able to report
1972          stops, so make sure there's at least a dummy one.  */
1973       if (b->type == bp_watchpoint && b->loc == NULL)
1974         software_watchpoint_add_no_memory_location (b, frame_pspace);
1975     }
1976   else if (!within_current_scope)
1977     {
1978       printf_filtered (_("\
1979 Watchpoint %d deleted because the program has left the block\n\
1980 in which its expression is valid.\n"),
1981                        b->number);
1982       watchpoint_del_at_next_stop (b);
1983     }
1984
1985   /* Restore the selected frame.  */
1986   if (frame_saved)
1987     select_frame (frame_find_by_id (saved_frame_id));
1988 }
1989
1990
1991 /* Returns 1 iff breakpoint location should be
1992    inserted in the inferior.  We don't differentiate the type of BL's owner
1993    (breakpoint vs. tracepoint), although insert_location in tracepoint's
1994    breakpoint_ops is not defined, because in insert_bp_location,
1995    tracepoint's insert_location will not be called.  */
1996 static int
1997 should_be_inserted (struct bp_location *bl)
1998 {
1999   if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
2000     return 0;
2001
2002   if (bl->owner->disposition == disp_del_at_next_stop)
2003     return 0;
2004
2005   if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
2006     return 0;
2007
2008   if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
2009     return 0;
2010
2011   /* This is set for example, when we're attached to the parent of a
2012      vfork, and have detached from the child.  The child is running
2013      free, and we expect it to do an exec or exit, at which point the
2014      OS makes the parent schedulable again (and the target reports
2015      that the vfork is done).  Until the child is done with the shared
2016      memory region, do not insert breakpoints in the parent, otherwise
2017      the child could still trip on the parent's breakpoints.  Since
2018      the parent is blocked anyway, it won't miss any breakpoint.  */
2019   if (bl->pspace->breakpoints_not_allowed)
2020     return 0;
2021
2022   /* Don't insert a breakpoint if we're trying to step past its
2023      location, except if the breakpoint is a single-step breakpoint,
2024      and the breakpoint's thread is the thread which is stepping past
2025      a breakpoint.  */
2026   if ((bl->loc_type == bp_loc_software_breakpoint
2027        || bl->loc_type == bp_loc_hardware_breakpoint)
2028       && stepping_past_instruction_at (bl->pspace->aspace,
2029                                        bl->address)
2030       /* The single-step breakpoint may be inserted at the location
2031          we're trying to step if the instruction branches to itself.
2032          However, the instruction won't be executed at all and it may
2033          break the semantics of the instruction, for example, the
2034          instruction is a conditional branch or updates some flags.
2035          We can't fix it unless GDB is able to emulate the instruction
2036          or switch to displaced stepping.  */
2037       && !(bl->owner->type == bp_single_step
2038            && thread_is_stepping_over_breakpoint (bl->owner->thread)))
2039     {
2040       if (debug_infrun)
2041         {
2042           fprintf_unfiltered (gdb_stdlog,
2043                               "infrun: skipping breakpoint: "
2044                               "stepping past insn at: %s\n",
2045                               paddress (bl->gdbarch, bl->address));
2046         }
2047       return 0;
2048     }
2049
2050   /* Don't insert watchpoints if we're trying to step past the
2051      instruction that triggered one.  */
2052   if ((bl->loc_type == bp_loc_hardware_watchpoint)
2053       && stepping_past_nonsteppable_watchpoint ())
2054     {
2055       if (debug_infrun)
2056         {
2057           fprintf_unfiltered (gdb_stdlog,
2058                               "infrun: stepping past non-steppable watchpoint. "
2059                               "skipping watchpoint at %s:%d\n",
2060                               paddress (bl->gdbarch, bl->address),
2061                               bl->length);
2062         }
2063       return 0;
2064     }
2065
2066   return 1;
2067 }
2068
2069 /* Same as should_be_inserted but does the check assuming
2070    that the location is not duplicated.  */
2071
2072 static int
2073 unduplicated_should_be_inserted (struct bp_location *bl)
2074 {
2075   int result;
2076   const int save_duplicate = bl->duplicate;
2077
2078   bl->duplicate = 0;
2079   result = should_be_inserted (bl);
2080   bl->duplicate = save_duplicate;
2081   return result;
2082 }
2083
2084 /* Parses a conditional described by an expression COND into an
2085    agent expression bytecode suitable for evaluation
2086    by the bytecode interpreter.  Return NULL if there was
2087    any error during parsing.  */
2088
2089 static agent_expr_up
2090 parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
2091 {
2092   if (cond == NULL)
2093     return NULL;
2094
2095   agent_expr_up aexpr;
2096
2097   /* We don't want to stop processing, so catch any errors
2098      that may show up.  */
2099   TRY
2100     {
2101       aexpr = gen_eval_for_expr (scope, cond);
2102     }
2103
2104   CATCH (ex, RETURN_MASK_ERROR)
2105     {
2106       /* If we got here, it means the condition could not be parsed to a valid
2107          bytecode expression and thus can't be evaluated on the target's side.
2108          It's no use iterating through the conditions.  */
2109     }
2110   END_CATCH
2111
2112   /* We have a valid agent expression.  */
2113   return aexpr;
2114 }
2115
2116 /* Based on location BL, create a list of breakpoint conditions to be
2117    passed on to the target.  If we have duplicated locations with different
2118    conditions, we will add such conditions to the list.  The idea is that the
2119    target will evaluate the list of conditions and will only notify GDB when
2120    one of them is true.  */
2121
2122 static void
2123 build_target_condition_list (struct bp_location *bl)
2124 {
2125   struct bp_location **locp = NULL, **loc2p;
2126   int null_condition_or_parse_error = 0;
2127   int modified = bl->needs_update;
2128   struct bp_location *loc;
2129
2130   /* Release conditions left over from a previous insert.  */
2131   bl->target_info.conditions.clear ();
2132
2133   /* This is only meaningful if the target is
2134      evaluating conditions and if the user has
2135      opted for condition evaluation on the target's
2136      side.  */
2137   if (gdb_evaluates_breakpoint_condition_p ()
2138       || !target_supports_evaluation_of_breakpoint_conditions ())
2139     return;
2140
2141   /* Do a first pass to check for locations with no assigned
2142      conditions or conditions that fail to parse to a valid agent expression
2143      bytecode.  If any of these happen, then it's no use to send conditions
2144      to the target since this location will always trigger and generate a
2145      response back to GDB.  */
2146   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2147     {
2148       loc = (*loc2p);
2149       if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2150         {
2151           if (modified)
2152             {
2153               /* Re-parse the conditions since something changed.  In that
2154                  case we already freed the condition bytecodes (see
2155                  force_breakpoint_reinsertion).  We just
2156                  need to parse the condition to bytecodes again.  */
2157               loc->cond_bytecode = parse_cond_to_aexpr (bl->address,
2158                                                         loc->cond.get ());
2159             }
2160
2161           /* If we have a NULL bytecode expression, it means something
2162              went wrong or we have a null condition expression.  */
2163           if (!loc->cond_bytecode)
2164             {
2165               null_condition_or_parse_error = 1;
2166               break;
2167             }
2168         }
2169     }
2170
2171   /* If any of these happened, it means we will have to evaluate the conditions
2172      for the location's address on gdb's side.  It is no use keeping bytecodes
2173      for all the other duplicate locations, thus we free all of them here.
2174
2175      This is so we have a finer control over which locations' conditions are
2176      being evaluated by GDB or the remote stub.  */
2177   if (null_condition_or_parse_error)
2178     {
2179       ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2180         {
2181           loc = (*loc2p);
2182           if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2183             {
2184               /* Only go as far as the first NULL bytecode is
2185                  located.  */
2186               if (!loc->cond_bytecode)
2187                 return;
2188
2189               loc->cond_bytecode.reset ();
2190             }
2191         }
2192     }
2193
2194   /* No NULL conditions or failed bytecode generation.  Build a condition list
2195      for this location's address.  */
2196   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2197     {
2198       loc = (*loc2p);
2199       if (loc->cond
2200           && is_breakpoint (loc->owner)
2201           && loc->pspace->num == bl->pspace->num
2202           && loc->owner->enable_state == bp_enabled
2203           && loc->enabled)
2204         {
2205           /* Add the condition to the vector.  This will be used later
2206              to send the conditions to the target.  */
2207           bl->target_info.conditions.push_back (loc->cond_bytecode.get ());
2208         }
2209     }
2210
2211   return;
2212 }
2213
2214 /* Parses a command described by string CMD into an agent expression
2215    bytecode suitable for evaluation by the bytecode interpreter.
2216    Return NULL if there was any error during parsing.  */
2217
2218 static agent_expr_up
2219 parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
2220 {
2221   const char *cmdrest;
2222   const char *format_start, *format_end;
2223   struct gdbarch *gdbarch = get_current_arch ();
2224
2225   if (cmd == NULL)
2226     return NULL;
2227
2228   cmdrest = cmd;
2229
2230   if (*cmdrest == ',')
2231     ++cmdrest;
2232   cmdrest = skip_spaces (cmdrest);
2233
2234   if (*cmdrest++ != '"')
2235     error (_("No format string following the location"));
2236
2237   format_start = cmdrest;
2238
2239   format_pieces fpieces (&cmdrest);
2240
2241   format_end = cmdrest;
2242
2243   if (*cmdrest++ != '"')
2244     error (_("Bad format string, non-terminated '\"'."));
2245   
2246   cmdrest = skip_spaces (cmdrest);
2247
2248   if (!(*cmdrest == ',' || *cmdrest == '\0'))
2249     error (_("Invalid argument syntax"));
2250
2251   if (*cmdrest == ',')
2252     cmdrest++;
2253   cmdrest = skip_spaces (cmdrest);
2254
2255   /* For each argument, make an expression.  */
2256
2257   std::vector<struct expression *> argvec;
2258   while (*cmdrest != '\0')
2259     {
2260       const char *cmd1;
2261
2262       cmd1 = cmdrest;
2263       expression_up expr = parse_exp_1 (&cmd1, scope, block_for_pc (scope), 1);
2264       argvec.push_back (expr.release ());
2265       cmdrest = cmd1;
2266       if (*cmdrest == ',')
2267         ++cmdrest;
2268     }
2269
2270   agent_expr_up aexpr;
2271
2272   /* We don't want to stop processing, so catch any errors
2273      that may show up.  */
2274   TRY
2275     {
2276       aexpr = gen_printf (scope, gdbarch, 0, 0,
2277                           format_start, format_end - format_start,
2278                           argvec.size (), argvec.data ());
2279     }
2280   CATCH (ex, RETURN_MASK_ERROR)
2281     {
2282       /* If we got here, it means the command could not be parsed to a valid
2283          bytecode expression and thus can't be evaluated on the target's side.
2284          It's no use iterating through the other commands.  */
2285     }
2286   END_CATCH
2287
2288   /* We have a valid agent expression, return it.  */
2289   return aexpr;
2290 }
2291
2292 /* Based on location BL, create a list of breakpoint commands to be
2293    passed on to the target.  If we have duplicated locations with
2294    different commands, we will add any such to the list.  */
2295
2296 static void
2297 build_target_command_list (struct bp_location *bl)
2298 {
2299   struct bp_location **locp = NULL, **loc2p;
2300   int null_command_or_parse_error = 0;
2301   int modified = bl->needs_update;
2302   struct bp_location *loc;
2303
2304   /* Clear commands left over from a previous insert.  */
2305   bl->target_info.tcommands.clear ();
2306
2307   if (!target_can_run_breakpoint_commands ())
2308     return;
2309
2310   /* For now, limit to agent-style dprintf breakpoints.  */
2311   if (dprintf_style != dprintf_style_agent)
2312     return;
2313
2314   /* For now, if we have any duplicate location that isn't a dprintf,
2315      don't install the target-side commands, as that would make the
2316      breakpoint not be reported to the core, and we'd lose
2317      control.  */
2318   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2319     {
2320       loc = (*loc2p);
2321       if (is_breakpoint (loc->owner)
2322           && loc->pspace->num == bl->pspace->num
2323           && loc->owner->type != bp_dprintf)
2324         return;
2325     }
2326
2327   /* Do a first pass to check for locations with no assigned
2328      conditions or conditions that fail to parse to a valid agent expression
2329      bytecode.  If any of these happen, then it's no use to send conditions
2330      to the target since this location will always trigger and generate a
2331      response back to GDB.  */
2332   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2333     {
2334       loc = (*loc2p);
2335       if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2336         {
2337           if (modified)
2338             {
2339               /* Re-parse the commands since something changed.  In that
2340                  case we already freed the command bytecodes (see
2341                  force_breakpoint_reinsertion).  We just
2342                  need to parse the command to bytecodes again.  */
2343               loc->cmd_bytecode
2344                 = parse_cmd_to_aexpr (bl->address,
2345                                       loc->owner->extra_string);
2346             }
2347
2348           /* If we have a NULL bytecode expression, it means something
2349              went wrong or we have a null command expression.  */
2350           if (!loc->cmd_bytecode)
2351             {
2352               null_command_or_parse_error = 1;
2353               break;
2354             }
2355         }
2356     }
2357
2358   /* If anything failed, then we're not doing target-side commands,
2359      and so clean up.  */
2360   if (null_command_or_parse_error)
2361     {
2362       ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2363         {
2364           loc = (*loc2p);
2365           if (is_breakpoint (loc->owner)
2366               && loc->pspace->num == bl->pspace->num)
2367             {
2368               /* Only go as far as the first NULL bytecode is
2369                  located.  */
2370               if (loc->cmd_bytecode == NULL)
2371                 return;
2372
2373               loc->cmd_bytecode.reset ();
2374             }
2375         }
2376     }
2377
2378   /* No NULL commands or failed bytecode generation.  Build a command list
2379      for this location's address.  */
2380   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2381     {
2382       loc = (*loc2p);
2383       if (loc->owner->extra_string
2384           && is_breakpoint (loc->owner)
2385           && loc->pspace->num == bl->pspace->num
2386           && loc->owner->enable_state == bp_enabled
2387           && loc->enabled)
2388         {
2389           /* Add the command to the vector.  This will be used later
2390              to send the commands to the target.  */
2391           bl->target_info.tcommands.push_back (loc->cmd_bytecode.get ());
2392         }
2393     }
2394
2395   bl->target_info.persist = 0;
2396   /* Maybe flag this location as persistent.  */
2397   if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2398     bl->target_info.persist = 1;
2399 }
2400
2401 /* Return the kind of breakpoint on address *ADDR.  Get the kind
2402    of breakpoint according to ADDR except single-step breakpoint.
2403    Get the kind of single-step breakpoint according to the current
2404    registers state.  */
2405
2406 static int
2407 breakpoint_kind (struct bp_location *bl, CORE_ADDR *addr)
2408 {
2409   if (bl->owner->type == bp_single_step)
2410     {
2411       struct thread_info *thr = find_thread_global_id (bl->owner->thread);
2412       struct regcache *regcache;
2413
2414       regcache = get_thread_regcache (thr);
2415
2416       return gdbarch_breakpoint_kind_from_current_state (bl->gdbarch,
2417                                                          regcache, addr);
2418     }
2419   else
2420     return gdbarch_breakpoint_kind_from_pc (bl->gdbarch, addr);
2421 }
2422
2423 /* Insert a low-level "breakpoint" of some type.  BL is the breakpoint
2424    location.  Any error messages are printed to TMP_ERROR_STREAM; and
2425    DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2426    Returns 0 for success, 1 if the bp_location type is not supported or
2427    -1 for failure.
2428
2429    NOTE drow/2003-09-09: This routine could be broken down to an
2430    object-style method for each breakpoint or catchpoint type.  */
2431 static int
2432 insert_bp_location (struct bp_location *bl,
2433                     struct ui_file *tmp_error_stream,
2434                     int *disabled_breaks,
2435                     int *hw_breakpoint_error,
2436                     int *hw_bp_error_explained_already)
2437 {
2438   gdb_exception bp_excpt = exception_none;
2439
2440   if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2441     return 0;
2442
2443   /* Note we don't initialize bl->target_info, as that wipes out
2444      the breakpoint location's shadow_contents if the breakpoint
2445      is still inserted at that location.  This in turn breaks
2446      target_read_memory which depends on these buffers when
2447      a memory read is requested at the breakpoint location:
2448      Once the target_info has been wiped, we fail to see that
2449      we have a breakpoint inserted at that address and thus
2450      read the breakpoint instead of returning the data saved in
2451      the breakpoint location's shadow contents.  */
2452   bl->target_info.reqstd_address = bl->address;
2453   bl->target_info.placed_address_space = bl->pspace->aspace;
2454   bl->target_info.length = bl->length;
2455
2456   /* When working with target-side conditions, we must pass all the conditions
2457      for the same breakpoint address down to the target since GDB will not
2458      insert those locations.  With a list of breakpoint conditions, the target
2459      can decide when to stop and notify GDB.  */
2460
2461   if (is_breakpoint (bl->owner))
2462     {
2463       build_target_condition_list (bl);
2464       build_target_command_list (bl);
2465       /* Reset the modification marker.  */
2466       bl->needs_update = 0;
2467     }
2468
2469   if (bl->loc_type == bp_loc_software_breakpoint
2470       || bl->loc_type == bp_loc_hardware_breakpoint)
2471     {
2472       if (bl->owner->type != bp_hardware_breakpoint)
2473         {
2474           /* If the explicitly specified breakpoint type
2475              is not hardware breakpoint, check the memory map to see
2476              if the breakpoint address is in read only memory or not.
2477
2478              Two important cases are:
2479              - location type is not hardware breakpoint, memory
2480              is readonly.  We change the type of the location to
2481              hardware breakpoint.
2482              - location type is hardware breakpoint, memory is
2483              read-write.  This means we've previously made the
2484              location hardware one, but then the memory map changed,
2485              so we undo.
2486              
2487              When breakpoints are removed, remove_breakpoints will use
2488              location types we've just set here, the only possible
2489              problem is that memory map has changed during running
2490              program, but it's not going to work anyway with current
2491              gdb.  */
2492           struct mem_region *mr 
2493             = lookup_mem_region (bl->target_info.reqstd_address);
2494           
2495           if (mr)
2496             {
2497               if (automatic_hardware_breakpoints)
2498                 {
2499                   enum bp_loc_type new_type;
2500                   
2501                   if (mr->attrib.mode != MEM_RW)
2502                     new_type = bp_loc_hardware_breakpoint;
2503                   else 
2504                     new_type = bp_loc_software_breakpoint;
2505                   
2506                   if (new_type != bl->loc_type)
2507                     {
2508                       static int said = 0;
2509
2510                       bl->loc_type = new_type;
2511                       if (!said)
2512                         {
2513                           fprintf_filtered (gdb_stdout,
2514                                             _("Note: automatically using "
2515                                               "hardware breakpoints for "
2516                                               "read-only addresses.\n"));
2517                           said = 1;
2518                         }
2519                     }
2520                 }
2521               else if (bl->loc_type == bp_loc_software_breakpoint
2522                        && mr->attrib.mode != MEM_RW)
2523                 {
2524                   fprintf_unfiltered (tmp_error_stream,
2525                                       _("Cannot insert breakpoint %d.\n"
2526                                         "Cannot set software breakpoint "
2527                                         "at read-only address %s\n"),
2528                                       bl->owner->number,
2529                                       paddress (bl->gdbarch, bl->address));
2530                   return 1;
2531                 }
2532             }
2533         }
2534         
2535       /* First check to see if we have to handle an overlay.  */
2536       if (overlay_debugging == ovly_off
2537           || bl->section == NULL
2538           || !(section_is_overlay (bl->section)))
2539         {
2540           /* No overlay handling: just set the breakpoint.  */
2541           TRY
2542             {
2543               int val;
2544
2545               val = bl->owner->ops->insert_location (bl);
2546               if (val)
2547                 bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2548             }
2549           CATCH (e, RETURN_MASK_ALL)
2550             {
2551               bp_excpt = e;
2552             }
2553           END_CATCH
2554         }
2555       else
2556         {
2557           /* This breakpoint is in an overlay section.
2558              Shall we set a breakpoint at the LMA?  */
2559           if (!overlay_events_enabled)
2560             {
2561               /* Yes -- overlay event support is not active, 
2562                  so we must try to set a breakpoint at the LMA.
2563                  This will not work for a hardware breakpoint.  */
2564               if (bl->loc_type == bp_loc_hardware_breakpoint)
2565                 warning (_("hardware breakpoint %d not supported in overlay!"),
2566                          bl->owner->number);
2567               else
2568                 {
2569                   CORE_ADDR addr = overlay_unmapped_address (bl->address,
2570                                                              bl->section);
2571                   /* Set a software (trap) breakpoint at the LMA.  */
2572                   bl->overlay_target_info = bl->target_info;
2573                   bl->overlay_target_info.reqstd_address = addr;
2574
2575                   /* No overlay handling: just set the breakpoint.  */
2576                   TRY
2577                     {
2578                       int val;
2579
2580                       bl->overlay_target_info.kind
2581                         = breakpoint_kind (bl, &addr);
2582                       bl->overlay_target_info.placed_address = addr;
2583                       val = target_insert_breakpoint (bl->gdbarch,
2584                                                       &bl->overlay_target_info);
2585                       if (val)
2586                         bp_excpt
2587                           = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2588                     }
2589                   CATCH (e, RETURN_MASK_ALL)
2590                     {
2591                       bp_excpt = e;
2592                     }
2593                   END_CATCH
2594
2595                   if (bp_excpt.reason != 0)
2596                     fprintf_unfiltered (tmp_error_stream,
2597                                         "Overlay breakpoint %d "
2598                                         "failed: in ROM?\n",
2599                                         bl->owner->number);
2600                 }
2601             }
2602           /* Shall we set a breakpoint at the VMA? */
2603           if (section_is_mapped (bl->section))
2604             {
2605               /* Yes.  This overlay section is mapped into memory.  */
2606               TRY
2607                 {
2608                   int val;
2609
2610                   val = bl->owner->ops->insert_location (bl);
2611                   if (val)
2612                     bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2613                 }
2614               CATCH (e, RETURN_MASK_ALL)
2615                 {
2616                   bp_excpt = e;
2617                 }
2618               END_CATCH
2619             }
2620           else
2621             {
2622               /* No.  This breakpoint will not be inserted.  
2623                  No error, but do not mark the bp as 'inserted'.  */
2624               return 0;
2625             }
2626         }
2627
2628       if (bp_excpt.reason != 0)
2629         {
2630           /* Can't set the breakpoint.  */
2631
2632           /* In some cases, we might not be able to insert a
2633              breakpoint in a shared library that has already been
2634              removed, but we have not yet processed the shlib unload
2635              event.  Unfortunately, some targets that implement
2636              breakpoint insertion themselves can't tell why the
2637              breakpoint insertion failed (e.g., the remote target
2638              doesn't define error codes), so we must treat generic
2639              errors as memory errors.  */
2640           if (bp_excpt.reason == RETURN_ERROR
2641               && (bp_excpt.error == GENERIC_ERROR
2642                   || bp_excpt.error == MEMORY_ERROR)
2643               && bl->loc_type == bp_loc_software_breakpoint
2644               && (solib_name_from_address (bl->pspace, bl->address)
2645                   || shared_objfile_contains_address_p (bl->pspace,
2646                                                         bl->address)))
2647             {
2648               /* See also: disable_breakpoints_in_shlibs.  */
2649               bl->shlib_disabled = 1;
2650               gdb::observers::breakpoint_modified.notify (bl->owner);
2651               if (!*disabled_breaks)
2652                 {
2653                   fprintf_unfiltered (tmp_error_stream, 
2654                                       "Cannot insert breakpoint %d.\n", 
2655                                       bl->owner->number);
2656                   fprintf_unfiltered (tmp_error_stream, 
2657                                       "Temporarily disabling shared "
2658                                       "library breakpoints:\n");
2659                 }
2660               *disabled_breaks = 1;
2661               fprintf_unfiltered (tmp_error_stream,
2662                                   "breakpoint #%d\n", bl->owner->number);
2663               return 0;
2664             }
2665           else
2666             {
2667               if (bl->loc_type == bp_loc_hardware_breakpoint)
2668                 {
2669                   *hw_breakpoint_error = 1;
2670                   *hw_bp_error_explained_already = bp_excpt.message != NULL;
2671                   fprintf_unfiltered (tmp_error_stream,
2672                                       "Cannot insert hardware breakpoint %d%s",
2673                                       bl->owner->number,
2674                                       bp_excpt.message ? ":" : ".\n");
2675                   if (bp_excpt.message != NULL)
2676                     fprintf_unfiltered (tmp_error_stream, "%s.\n",
2677                                         bp_excpt.message);
2678                 }
2679               else
2680                 {
2681                   if (bp_excpt.message == NULL)
2682                     {
2683                       std::string message
2684                         = memory_error_message (TARGET_XFER_E_IO,
2685                                                 bl->gdbarch, bl->address);
2686
2687                       fprintf_unfiltered (tmp_error_stream,
2688                                           "Cannot insert breakpoint %d.\n"
2689                                           "%s\n",
2690                                           bl->owner->number, message.c_str ());
2691                     }
2692                   else
2693                     {
2694                       fprintf_unfiltered (tmp_error_stream,
2695                                           "Cannot insert breakpoint %d: %s\n",
2696                                           bl->owner->number,
2697                                           bp_excpt.message);
2698                     }
2699                 }
2700               return 1;
2701
2702             }
2703         }
2704       else
2705         bl->inserted = 1;
2706
2707       return 0;
2708     }
2709
2710   else if (bl->loc_type == bp_loc_hardware_watchpoint
2711            /* NOTE drow/2003-09-08: This state only exists for removing
2712               watchpoints.  It's not clear that it's necessary...  */
2713            && bl->owner->disposition != disp_del_at_next_stop)
2714     {
2715       int val;
2716
2717       gdb_assert (bl->owner->ops != NULL
2718                   && bl->owner->ops->insert_location != NULL);
2719
2720       val = bl->owner->ops->insert_location (bl);
2721
2722       /* If trying to set a read-watchpoint, and it turns out it's not
2723          supported, try emulating one with an access watchpoint.  */
2724       if (val == 1 && bl->watchpoint_type == hw_read)
2725         {
2726           struct bp_location *loc, **loc_temp;
2727
2728           /* But don't try to insert it, if there's already another
2729              hw_access location that would be considered a duplicate
2730              of this one.  */
2731           ALL_BP_LOCATIONS (loc, loc_temp)
2732             if (loc != bl
2733                 && loc->watchpoint_type == hw_access
2734                 && watchpoint_locations_match (bl, loc))
2735               {
2736                 bl->duplicate = 1;
2737                 bl->inserted = 1;
2738                 bl->target_info = loc->target_info;
2739                 bl->watchpoint_type = hw_access;
2740                 val = 0;
2741                 break;
2742               }
2743
2744           if (val == 1)
2745             {
2746               bl->watchpoint_type = hw_access;
2747               val = bl->owner->ops->insert_location (bl);
2748
2749               if (val)
2750                 /* Back to the original value.  */
2751                 bl->watchpoint_type = hw_read;
2752             }
2753         }
2754
2755       bl->inserted = (val == 0);
2756     }
2757
2758   else if (bl->owner->type == bp_catchpoint)
2759     {
2760       int val;
2761
2762       gdb_assert (bl->owner->ops != NULL
2763                   && bl->owner->ops->insert_location != NULL);
2764
2765       val = bl->owner->ops->insert_location (bl);
2766       if (val)
2767         {
2768           bl->owner->enable_state = bp_disabled;
2769
2770           if (val == 1)
2771             warning (_("\
2772 Error inserting catchpoint %d: Your system does not support this type\n\
2773 of catchpoint."), bl->owner->number);
2774           else
2775             warning (_("Error inserting catchpoint %d."), bl->owner->number);
2776         }
2777
2778       bl->inserted = (val == 0);
2779
2780       /* We've already printed an error message if there was a problem
2781          inserting this catchpoint, and we've disabled the catchpoint,
2782          so just return success.  */
2783       return 0;
2784     }
2785
2786   return 0;
2787 }
2788
2789 /* This function is called when program space PSPACE is about to be
2790    deleted.  It takes care of updating breakpoints to not reference
2791    PSPACE anymore.  */
2792
2793 void
2794 breakpoint_program_space_exit (struct program_space *pspace)
2795 {
2796   struct breakpoint *b, *b_temp;
2797   struct bp_location *loc, **loc_temp;
2798
2799   /* Remove any breakpoint that was set through this program space.  */
2800   ALL_BREAKPOINTS_SAFE (b, b_temp)
2801     {
2802       if (b->pspace == pspace)
2803         delete_breakpoint (b);
2804     }
2805
2806   /* Breakpoints set through other program spaces could have locations
2807      bound to PSPACE as well.  Remove those.  */
2808   ALL_BP_LOCATIONS (loc, loc_temp)
2809     {
2810       struct bp_location *tmp;
2811
2812       if (loc->pspace == pspace)
2813         {
2814           /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
2815           if (loc->owner->loc == loc)
2816             loc->owner->loc = loc->next;
2817           else
2818             for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
2819               if (tmp->next == loc)
2820                 {
2821                   tmp->next = loc->next;
2822                   break;
2823                 }
2824         }
2825     }
2826
2827   /* Now update the global location list to permanently delete the
2828      removed locations above.  */
2829   update_global_location_list (UGLL_DONT_INSERT);
2830 }
2831
2832 /* Make sure all breakpoints are inserted in inferior.
2833    Throws exception on any error.
2834    A breakpoint that is already inserted won't be inserted
2835    again, so calling this function twice is safe.  */
2836 void
2837 insert_breakpoints (void)
2838 {
2839   struct breakpoint *bpt;
2840
2841   ALL_BREAKPOINTS (bpt)
2842     if (is_hardware_watchpoint (bpt))
2843       {
2844         struct watchpoint *w = (struct watchpoint *) bpt;
2845
2846         update_watchpoint (w, 0 /* don't reparse.  */);
2847       }
2848
2849   /* Updating watchpoints creates new locations, so update the global
2850      location list.  Explicitly tell ugll to insert locations and
2851      ignore breakpoints_always_inserted_mode.  */
2852   update_global_location_list (UGLL_INSERT);
2853 }
2854
2855 /* Invoke CALLBACK for each of bp_location.  */
2856
2857 void
2858 iterate_over_bp_locations (walk_bp_location_callback callback)
2859 {
2860   struct bp_location *loc, **loc_tmp;
2861
2862   ALL_BP_LOCATIONS (loc, loc_tmp)
2863     {
2864       callback (loc, NULL);
2865     }
2866 }
2867
2868 /* This is used when we need to synch breakpoint conditions between GDB and the
2869    target.  It is the case with deleting and disabling of breakpoints when using
2870    always-inserted mode.  */
2871
2872 static void
2873 update_inserted_breakpoint_locations (void)
2874 {
2875   struct bp_location *bl, **blp_tmp;
2876   int error_flag = 0;
2877   int val = 0;
2878   int disabled_breaks = 0;
2879   int hw_breakpoint_error = 0;
2880   int hw_bp_details_reported = 0;
2881
2882   string_file tmp_error_stream;
2883
2884   /* Explicitly mark the warning -- this will only be printed if
2885      there was an error.  */
2886   tmp_error_stream.puts ("Warning:\n");
2887
2888   scoped_restore_current_pspace_and_thread restore_pspace_thread;
2889
2890   ALL_BP_LOCATIONS (bl, blp_tmp)
2891     {
2892       /* We only want to update software breakpoints and hardware
2893          breakpoints.  */
2894       if (!is_breakpoint (bl->owner))
2895         continue;
2896
2897       /* We only want to update locations that are already inserted
2898          and need updating.  This is to avoid unwanted insertion during
2899          deletion of breakpoints.  */
2900       if (!bl->inserted || !bl->needs_update)
2901         continue;
2902
2903       switch_to_program_space_and_thread (bl->pspace);
2904
2905       /* For targets that support global breakpoints, there's no need
2906          to select an inferior to insert breakpoint to.  In fact, even
2907          if we aren't attached to any process yet, we should still
2908          insert breakpoints.  */
2909       if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2910           && inferior_ptid == null_ptid)
2911         continue;
2912
2913       val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
2914                                     &hw_breakpoint_error, &hw_bp_details_reported);
2915       if (val)
2916         error_flag = val;
2917     }
2918
2919   if (error_flag)
2920     {
2921       target_terminal::ours_for_output ();
2922       error_stream (tmp_error_stream);
2923     }
2924 }
2925
2926 /* Used when starting or continuing the program.  */
2927
2928 static void
2929 insert_breakpoint_locations (void)
2930 {
2931   struct breakpoint *bpt;
2932   struct bp_location *bl, **blp_tmp;
2933   int error_flag = 0;
2934   int val = 0;
2935   int disabled_breaks = 0;
2936   int hw_breakpoint_error = 0;
2937   int hw_bp_error_explained_already = 0;
2938
2939   string_file tmp_error_stream;
2940
2941   /* Explicitly mark the warning -- this will only be printed if
2942      there was an error.  */
2943   tmp_error_stream.puts ("Warning:\n");
2944
2945   scoped_restore_current_pspace_and_thread restore_pspace_thread;
2946
2947   ALL_BP_LOCATIONS (bl, blp_tmp)
2948     {
2949       if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2950         continue;
2951
2952       /* There is no point inserting thread-specific breakpoints if
2953          the thread no longer exists.  ALL_BP_LOCATIONS bp_location
2954          has BL->OWNER always non-NULL.  */
2955       if (bl->owner->thread != -1
2956           && !valid_global_thread_id (bl->owner->thread))
2957         continue;
2958
2959       switch_to_program_space_and_thread (bl->pspace);
2960
2961       /* For targets that support global breakpoints, there's no need
2962          to select an inferior to insert breakpoint to.  In fact, even
2963          if we aren't attached to any process yet, we should still
2964          insert breakpoints.  */
2965       if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2966           && inferior_ptid == null_ptid)
2967         continue;
2968
2969       val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
2970                                     &hw_breakpoint_error, &hw_bp_error_explained_already);
2971       if (val)
2972         error_flag = val;
2973     }
2974
2975   /* If we failed to insert all locations of a watchpoint, remove
2976      them, as half-inserted watchpoint is of limited use.  */
2977   ALL_BREAKPOINTS (bpt)  
2978     {
2979       int some_failed = 0;
2980       struct bp_location *loc;
2981
2982       if (!is_hardware_watchpoint (bpt))
2983         continue;
2984
2985       if (!breakpoint_enabled (bpt))
2986         continue;
2987
2988       if (bpt->disposition == disp_del_at_next_stop)
2989         continue;
2990       
2991       for (loc = bpt->loc; loc; loc = loc->next)
2992         if (!loc->inserted && should_be_inserted (loc))
2993           {
2994             some_failed = 1;
2995             break;
2996           }
2997       if (some_failed)
2998         {
2999           for (loc = bpt->loc; loc; loc = loc->next)
3000             if (loc->inserted)
3001               remove_breakpoint (loc);
3002
3003           hw_breakpoint_error = 1;
3004           tmp_error_stream.printf ("Could not insert "
3005                                    "hardware watchpoint %d.\n",
3006                                    bpt->number);
3007           error_flag = -1;
3008         }
3009     }
3010
3011   if (error_flag)
3012     {
3013       /* If a hardware breakpoint or watchpoint was inserted, add a
3014          message about possibly exhausted resources.  */
3015       if (hw_breakpoint_error && !hw_bp_error_explained_already)
3016         {
3017           tmp_error_stream.printf ("Could not insert hardware breakpoints:\n\
3018 You may have requested too many hardware breakpoints/watchpoints.\n");
3019         }
3020       target_terminal::ours_for_output ();
3021       error_stream (tmp_error_stream);
3022     }
3023 }
3024
3025 /* Used when the program stops.
3026    Returns zero if successful, or non-zero if there was a problem
3027    removing a breakpoint location.  */
3028
3029 int
3030 remove_breakpoints (void)
3031 {
3032   struct bp_location *bl, **blp_tmp;
3033   int val = 0;
3034
3035   ALL_BP_LOCATIONS (bl, blp_tmp)
3036   {
3037     if (bl->inserted && !is_tracepoint (bl->owner))
3038       val |= remove_breakpoint (bl);
3039   }
3040   return val;
3041 }
3042
3043 /* When a thread exits, remove breakpoints that are related to
3044    that thread.  */
3045
3046 static void
3047 remove_threaded_breakpoints (struct thread_info *tp, int silent)
3048 {
3049   struct breakpoint *b, *b_tmp;
3050
3051   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3052     {
3053       if (b->thread == tp->global_num && user_breakpoint_p (b))
3054         {
3055           b->disposition = disp_del_at_next_stop;
3056
3057           printf_filtered (_("\
3058 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3059                            b->number, print_thread_id (tp));
3060
3061           /* Hide it from the user.  */
3062           b->number = 0;
3063        }
3064     }
3065 }
3066
3067 /* Remove breakpoints of inferior INF.  */
3068
3069 int
3070 remove_breakpoints_inf (inferior *inf)
3071 {
3072   struct bp_location *bl, **blp_tmp;
3073   int val;
3074
3075   ALL_BP_LOCATIONS (bl, blp_tmp)
3076   {
3077     if (bl->pspace != inf->pspace)
3078       continue;
3079
3080     if (bl->inserted && !bl->target_info.persist)
3081       {
3082         val = remove_breakpoint (bl);
3083         if (val != 0)
3084           return val;
3085       }
3086   }
3087   return 0;
3088 }
3089
3090 static int internal_breakpoint_number = -1;
3091
3092 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3093    If INTERNAL is non-zero, the breakpoint number will be populated
3094    from internal_breakpoint_number and that variable decremented.
3095    Otherwise the breakpoint number will be populated from
3096    breakpoint_count and that value incremented.  Internal breakpoints
3097    do not set the internal var bpnum.  */
3098 static void
3099 set_breakpoint_number (int internal, struct breakpoint *b)
3100 {
3101   if (internal)
3102     b->number = internal_breakpoint_number--;
3103   else
3104     {
3105       set_breakpoint_count (breakpoint_count + 1);
3106       b->number = breakpoint_count;
3107     }
3108 }
3109
3110 static struct breakpoint *
3111 create_internal_breakpoint (struct gdbarch *gdbarch,
3112                             CORE_ADDR address, enum bptype type,
3113                             const struct breakpoint_ops *ops)
3114 {
3115   symtab_and_line sal;
3116   sal.pc = address;
3117   sal.section = find_pc_overlay (sal.pc);
3118   sal.pspace = current_program_space;
3119
3120   breakpoint *b = set_raw_breakpoint (gdbarch, sal, type, ops);
3121   b->number = internal_breakpoint_number--;
3122   b->disposition = disp_donttouch;
3123
3124   return b;
3125 }
3126
3127 static const char *const longjmp_names[] =
3128   {
3129     "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3130   };
3131 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3132
3133 /* Per-objfile data private to breakpoint.c.  */
3134 struct breakpoint_objfile_data
3135 {
3136   /* Minimal symbol for "_ovly_debug_event" (if any).  */
3137   struct bound_minimal_symbol overlay_msym {};
3138
3139   /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any).  */
3140   struct bound_minimal_symbol longjmp_msym[NUM_LONGJMP_NAMES] {};
3141
3142   /* True if we have looked for longjmp probes.  */
3143   int longjmp_searched = 0;
3144
3145   /* SystemTap probe points for longjmp (if any).  These are non-owning
3146      references.  */
3147   std::vector<probe *> longjmp_probes;
3148
3149   /* Minimal symbol for "std::terminate()" (if any).  */
3150   struct bound_minimal_symbol terminate_msym {};
3151
3152   /* Minimal symbol for "_Unwind_DebugHook" (if any).  */
3153   struct bound_minimal_symbol exception_msym {};
3154
3155   /* True if we have looked for exception probes.  */
3156   int exception_searched = 0;
3157
3158   /* SystemTap probe points for unwinding (if any).  These are non-owning
3159      references.  */
3160   std::vector<probe *> exception_probes;
3161 };
3162
3163 static const struct objfile_data *breakpoint_objfile_key;
3164
3165 /* Minimal symbol not found sentinel.  */
3166 static struct minimal_symbol msym_not_found;
3167
3168 /* Returns TRUE if MSYM point to the "not found" sentinel.  */
3169
3170 static int
3171 msym_not_found_p (const struct minimal_symbol *msym)
3172 {
3173   return msym == &msym_not_found;
3174 }
3175
3176 /* Return per-objfile data needed by breakpoint.c.
3177    Allocate the data if necessary.  */
3178
3179 static struct breakpoint_objfile_data *
3180 get_breakpoint_objfile_data (struct objfile *objfile)
3181 {
3182   struct breakpoint_objfile_data *bp_objfile_data;
3183
3184   bp_objfile_data = ((struct breakpoint_objfile_data *)
3185                      objfile_data (objfile, breakpoint_objfile_key));
3186   if (bp_objfile_data == NULL)
3187     {
3188       bp_objfile_data = new breakpoint_objfile_data ();
3189       set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
3190     }
3191   return bp_objfile_data;
3192 }
3193
3194 static void
3195 free_breakpoint_objfile_data (struct objfile *obj, void *data)
3196 {
3197   struct breakpoint_objfile_data *bp_objfile_data
3198     = (struct breakpoint_objfile_data *) data;
3199
3200   delete bp_objfile_data;
3201 }
3202
3203 static void
3204 create_overlay_event_breakpoint (void)
3205 {
3206   const char *const func_name = "_ovly_debug_event";
3207
3208   for (objfile *objfile : current_program_space->objfiles ())
3209     {
3210       struct breakpoint *b;
3211       struct breakpoint_objfile_data *bp_objfile_data;
3212       CORE_ADDR addr;
3213       struct explicit_location explicit_loc;
3214
3215       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3216
3217       if (msym_not_found_p (bp_objfile_data->overlay_msym.minsym))
3218         continue;
3219
3220       if (bp_objfile_data->overlay_msym.minsym == NULL)
3221         {
3222           struct bound_minimal_symbol m;
3223
3224           m = lookup_minimal_symbol_text (func_name, objfile);
3225           if (m.minsym == NULL)
3226             {
3227               /* Avoid future lookups in this objfile.  */
3228               bp_objfile_data->overlay_msym.minsym = &msym_not_found;
3229               continue;
3230             }
3231           bp_objfile_data->overlay_msym = m;
3232         }
3233
3234       addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
3235       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3236                                       bp_overlay_event,
3237                                       &internal_breakpoint_ops);
3238       initialize_explicit_location (&explicit_loc);
3239       explicit_loc.function_name = ASTRDUP (func_name);
3240       b->location = new_explicit_location (&explicit_loc);
3241
3242       if (overlay_debugging == ovly_auto)
3243         {
3244           b->enable_state = bp_enabled;
3245           overlay_events_enabled = 1;
3246         }
3247       else
3248        {
3249          b->enable_state = bp_disabled;
3250          overlay_events_enabled = 0;
3251        }
3252     }
3253 }
3254
3255 static void
3256 create_longjmp_master_breakpoint (void)
3257 {
3258   struct program_space *pspace;
3259
3260   scoped_restore_current_program_space restore_pspace;
3261
3262   ALL_PSPACES (pspace)
3263   {
3264     set_current_program_space (pspace);
3265
3266     for (objfile *objfile : current_program_space->objfiles ())
3267       {
3268         int i;
3269         struct gdbarch *gdbarch;
3270         struct breakpoint_objfile_data *bp_objfile_data;
3271
3272         gdbarch = get_objfile_arch (objfile);
3273
3274         bp_objfile_data = get_breakpoint_objfile_data (objfile);
3275
3276         if (!bp_objfile_data->longjmp_searched)
3277           {
3278             std::vector<probe *> ret
3279               = find_probes_in_objfile (objfile, "libc", "longjmp");
3280
3281             if (!ret.empty ())
3282               {
3283                 /* We are only interested in checking one element.  */
3284                 probe *p = ret[0];
3285
3286                 if (!p->can_evaluate_arguments ())
3287                   {
3288                     /* We cannot use the probe interface here, because it does
3289                        not know how to evaluate arguments.  */
3290                     ret.clear ();
3291                   }
3292               }
3293             bp_objfile_data->longjmp_probes = ret;
3294             bp_objfile_data->longjmp_searched = 1;
3295           }
3296
3297         if (!bp_objfile_data->longjmp_probes.empty ())
3298           {
3299             for (probe *p : bp_objfile_data->longjmp_probes)
3300               {
3301                 struct breakpoint *b;
3302
3303                 b = create_internal_breakpoint (gdbarch,
3304                                                 p->get_relocated_address (objfile),
3305                                                 bp_longjmp_master,
3306                                                 &internal_breakpoint_ops);
3307                 b->location = new_probe_location ("-probe-stap libc:longjmp");
3308                 b->enable_state = bp_disabled;
3309               }
3310
3311             continue;
3312           }
3313
3314         if (!gdbarch_get_longjmp_target_p (gdbarch))
3315           continue;
3316
3317         for (i = 0; i < NUM_LONGJMP_NAMES; i++)
3318           {
3319             struct breakpoint *b;
3320             const char *func_name;
3321             CORE_ADDR addr;
3322             struct explicit_location explicit_loc;
3323
3324             if (msym_not_found_p (bp_objfile_data->longjmp_msym[i].minsym))
3325               continue;
3326
3327             func_name = longjmp_names[i];
3328             if (bp_objfile_data->longjmp_msym[i].minsym == NULL)
3329               {
3330                 struct bound_minimal_symbol m;
3331
3332                 m = lookup_minimal_symbol_text (func_name, objfile);
3333                 if (m.minsym == NULL)
3334                   {
3335                     /* Prevent future lookups in this objfile.  */
3336                     bp_objfile_data->longjmp_msym[i].minsym = &msym_not_found;
3337                     continue;
3338                   }
3339                 bp_objfile_data->longjmp_msym[i] = m;
3340               }
3341
3342             addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
3343             b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3344                                             &internal_breakpoint_ops);
3345             initialize_explicit_location (&explicit_loc);
3346             explicit_loc.function_name = ASTRDUP (func_name);
3347             b->location = new_explicit_location (&explicit_loc);
3348             b->enable_state = bp_disabled;
3349           }
3350       }
3351   }
3352 }
3353
3354 /* Create a master std::terminate breakpoint.  */
3355 static void
3356 create_std_terminate_master_breakpoint (void)
3357 {
3358   struct program_space *pspace;
3359   const char *const func_name = "std::terminate()";
3360
3361   scoped_restore_current_program_space restore_pspace;
3362
3363   ALL_PSPACES (pspace)
3364   {
3365     CORE_ADDR addr;
3366
3367     set_current_program_space (pspace);
3368
3369     for (objfile *objfile : current_program_space->objfiles ())
3370       {
3371         struct breakpoint *b;
3372         struct breakpoint_objfile_data *bp_objfile_data;
3373         struct explicit_location explicit_loc;
3374
3375         bp_objfile_data = get_breakpoint_objfile_data (objfile);
3376
3377         if (msym_not_found_p (bp_objfile_data->terminate_msym.minsym))
3378           continue;
3379
3380         if (bp_objfile_data->terminate_msym.minsym == NULL)
3381           {
3382             struct bound_minimal_symbol m;
3383
3384             m = lookup_minimal_symbol (func_name, NULL, objfile);
3385             if (m.minsym == NULL || (MSYMBOL_TYPE (m.minsym) != mst_text
3386                                      && MSYMBOL_TYPE (m.minsym) != mst_file_text))
3387               {
3388                 /* Prevent future lookups in this objfile.  */
3389                 bp_objfile_data->terminate_msym.minsym = &msym_not_found;
3390                 continue;
3391               }
3392             bp_objfile_data->terminate_msym = m;
3393           }
3394
3395         addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
3396         b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3397                                         bp_std_terminate_master,
3398                                         &internal_breakpoint_ops);
3399         initialize_explicit_location (&explicit_loc);
3400         explicit_loc.function_name = ASTRDUP (func_name);
3401         b->location = new_explicit_location (&explicit_loc);
3402         b->enable_state = bp_disabled;
3403       }
3404   }
3405 }
3406
3407 /* Install a master breakpoint on the unwinder's debug hook.  */
3408
3409 static void
3410 create_exception_master_breakpoint (void)
3411 {
3412   const char *const func_name = "_Unwind_DebugHook";
3413
3414   for (objfile *objfile : current_program_space->objfiles ())
3415     {
3416       struct breakpoint *b;
3417       struct gdbarch *gdbarch;
3418       struct breakpoint_objfile_data *bp_objfile_data;
3419       CORE_ADDR addr;
3420       struct explicit_location explicit_loc;
3421
3422       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3423
3424       /* We prefer the SystemTap probe point if it exists.  */
3425       if (!bp_objfile_data->exception_searched)
3426         {
3427           std::vector<probe *> ret
3428             = find_probes_in_objfile (objfile, "libgcc", "unwind");
3429
3430           if (!ret.empty ())
3431             {
3432               /* We are only interested in checking one element.  */
3433               probe *p = ret[0];
3434
3435               if (!p->can_evaluate_arguments ())
3436                 {
3437                   /* We cannot use the probe interface here, because it does
3438                      not know how to evaluate arguments.  */
3439                   ret.clear ();
3440                 }
3441             }
3442           bp_objfile_data->exception_probes = ret;
3443           bp_objfile_data->exception_searched = 1;
3444         }
3445
3446       if (!bp_objfile_data->exception_probes.empty ())
3447         {
3448           gdbarch = get_objfile_arch (objfile);
3449
3450           for (probe *p : bp_objfile_data->exception_probes)
3451             {
3452               b = create_internal_breakpoint (gdbarch,
3453                                               p->get_relocated_address (objfile),
3454                                               bp_exception_master,
3455                                               &internal_breakpoint_ops);
3456               b->location = new_probe_location ("-probe-stap libgcc:unwind");
3457               b->enable_state = bp_disabled;
3458             }
3459
3460           continue;
3461         }
3462
3463       /* Otherwise, try the hook function.  */
3464
3465       if (msym_not_found_p (bp_objfile_data->exception_msym.minsym))
3466         continue;
3467
3468       gdbarch = get_objfile_arch (objfile);
3469
3470       if (bp_objfile_data->exception_msym.minsym == NULL)
3471         {
3472           struct bound_minimal_symbol debug_hook;
3473
3474           debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3475           if (debug_hook.minsym == NULL)
3476             {
3477               bp_objfile_data->exception_msym.minsym = &msym_not_found;
3478               continue;
3479             }
3480
3481           bp_objfile_data->exception_msym = debug_hook;
3482         }
3483
3484       addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
3485       addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3486                                                  current_top_target ());
3487       b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3488                                       &internal_breakpoint_ops);
3489       initialize_explicit_location (&explicit_loc);
3490       explicit_loc.function_name = ASTRDUP (func_name);
3491       b->location = new_explicit_location (&explicit_loc);
3492       b->enable_state = bp_disabled;
3493     }
3494 }
3495
3496 /* Does B have a location spec?  */
3497
3498 static int
3499 breakpoint_event_location_empty_p (const struct breakpoint *b)
3500 {
3501   return b->location != NULL && event_location_empty_p (b->location.get ());
3502 }
3503
3504 void
3505 update_breakpoints_after_exec (void)
3506 {
3507   struct breakpoint *b, *b_tmp;
3508   struct bp_location *bploc, **bplocp_tmp;
3509
3510   /* We're about to delete breakpoints from GDB's lists.  If the
3511      INSERTED flag is true, GDB will try to lift the breakpoints by
3512      writing the breakpoints' "shadow contents" back into memory.  The
3513      "shadow contents" are NOT valid after an exec, so GDB should not
3514      do that.  Instead, the target is responsible from marking
3515      breakpoints out as soon as it detects an exec.  We don't do that
3516      here instead, because there may be other attempts to delete
3517      breakpoints after detecting an exec and before reaching here.  */
3518   ALL_BP_LOCATIONS (bploc, bplocp_tmp)
3519     if (bploc->pspace == current_program_space)
3520       gdb_assert (!bploc->inserted);
3521
3522   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3523   {
3524     if (b->pspace != current_program_space)
3525       continue;
3526
3527     /* Solib breakpoints must be explicitly reset after an exec().  */
3528     if (b->type == bp_shlib_event)
3529       {
3530         delete_breakpoint (b);
3531         continue;
3532       }
3533
3534     /* JIT breakpoints must be explicitly reset after an exec().  */
3535     if (b->type == bp_jit_event)
3536       {
3537         delete_breakpoint (b);
3538         continue;
3539       }
3540
3541     /* Thread event breakpoints must be set anew after an exec(),
3542        as must overlay event and longjmp master breakpoints.  */
3543     if (b->type == bp_thread_event || b->type == bp_overlay_event
3544         || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3545         || b->type == bp_exception_master)
3546       {
3547         delete_breakpoint (b);
3548         continue;
3549       }
3550
3551     /* Step-resume breakpoints are meaningless after an exec().  */
3552     if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
3553       {
3554         delete_breakpoint (b);
3555         continue;
3556       }
3557
3558     /* Just like single-step breakpoints.  */
3559     if (b->type == bp_single_step)
3560       {
3561         delete_breakpoint (b);
3562         continue;
3563       }
3564
3565     /* Longjmp and longjmp-resume breakpoints are also meaningless
3566        after an exec.  */
3567     if (b->type == bp_longjmp || b->type == bp_longjmp_resume
3568         || b->type == bp_longjmp_call_dummy
3569         || b->type == bp_exception || b->type == bp_exception_resume)
3570       {
3571         delete_breakpoint (b);
3572         continue;
3573       }
3574
3575     if (b->type == bp_catchpoint)
3576       {
3577         /* For now, none of the bp_catchpoint breakpoints need to
3578            do anything at this point.  In the future, if some of
3579            the catchpoints need to something, we will need to add
3580            a new method, and call this method from here.  */
3581         continue;
3582       }
3583
3584     /* bp_finish is a special case.  The only way we ought to be able
3585        to see one of these when an exec() has happened, is if the user
3586        caught a vfork, and then said "finish".  Ordinarily a finish just
3587        carries them to the call-site of the current callee, by setting
3588        a temporary bp there and resuming.  But in this case, the finish
3589        will carry them entirely through the vfork & exec.
3590
3591        We don't want to allow a bp_finish to remain inserted now.  But
3592        we can't safely delete it, 'cause finish_command has a handle to
3593        the bp on a bpstat, and will later want to delete it.  There's a
3594        chance (and I've seen it happen) that if we delete the bp_finish
3595        here, that its storage will get reused by the time finish_command
3596        gets 'round to deleting the "use to be a bp_finish" breakpoint.
3597        We really must allow finish_command to delete a bp_finish.
3598
3599        In the absence of a general solution for the "how do we know
3600        it's safe to delete something others may have handles to?"
3601        problem, what we'll do here is just uninsert the bp_finish, and
3602        let finish_command delete it.
3603
3604        (We know the bp_finish is "doomed" in the sense that it's
3605        momentary, and will be deleted as soon as finish_command sees
3606        the inferior stopped.  So it doesn't matter that the bp's
3607        address is probably bogus in the new a.out, unlike e.g., the
3608        solib breakpoints.)  */
3609
3610     if (b->type == bp_finish)
3611       {
3612         continue;
3613       }
3614
3615     /* Without a symbolic address, we have little hope of the
3616        pre-exec() address meaning the same thing in the post-exec()
3617        a.out.  */
3618     if (breakpoint_event_location_empty_p (b))
3619       {
3620         delete_breakpoint (b);
3621         continue;
3622       }
3623   }
3624 }
3625
3626 int
3627 detach_breakpoints (ptid_t ptid)
3628 {
3629   struct bp_location *bl, **blp_tmp;
3630   int val = 0;
3631   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
3632   struct inferior *inf = current_inferior ();
3633
3634   if (ptid.pid () == inferior_ptid.pid ())
3635     error (_("Cannot detach breakpoints of inferior_ptid"));
3636
3637   /* Set inferior_ptid; remove_breakpoint_1 uses this global.  */
3638   inferior_ptid = ptid;
3639   ALL_BP_LOCATIONS (bl, blp_tmp)
3640   {
3641     if (bl->pspace != inf->pspace)
3642       continue;
3643
3644     /* This function must physically remove breakpoints locations
3645        from the specified ptid, without modifying the breakpoint
3646        package's state.  Locations of type bp_loc_other are only
3647        maintained at GDB side.  So, there is no need to remove
3648        these bp_loc_other locations.  Moreover, removing these
3649        would modify the breakpoint package's state.  */
3650     if (bl->loc_type == bp_loc_other)
3651       continue;
3652
3653     if (bl->inserted)
3654       val |= remove_breakpoint_1 (bl, DETACH_BREAKPOINT);
3655   }
3656
3657   return val;
3658 }
3659
3660 /* Remove the breakpoint location BL from the current address space.
3661    Note that this is used to detach breakpoints from a child fork.
3662    When we get here, the child isn't in the inferior list, and neither
3663    do we have objects to represent its address space --- we should
3664    *not* look at bl->pspace->aspace here.  */
3665
3666 static int
3667 remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason)
3668 {
3669   int val;
3670
3671   /* BL is never in moribund_locations by our callers.  */
3672   gdb_assert (bl->owner != NULL);
3673
3674   /* The type of none suggests that owner is actually deleted.
3675      This should not ever happen.  */
3676   gdb_assert (bl->owner->type != bp_none);
3677
3678   if (bl->loc_type == bp_loc_software_breakpoint
3679       || bl->loc_type == bp_loc_hardware_breakpoint)
3680     {
3681       /* "Normal" instruction breakpoint: either the standard
3682          trap-instruction bp (bp_breakpoint), or a
3683          bp_hardware_breakpoint.  */
3684
3685       /* First check to see if we have to handle an overlay.  */
3686       if (overlay_debugging == ovly_off
3687           || bl->section == NULL
3688           || !(section_is_overlay (bl->section)))
3689         {
3690           /* No overlay handling: just remove the breakpoint.  */
3691
3692           /* If we're trying to uninsert a memory breakpoint that we
3693              know is set in a dynamic object that is marked
3694              shlib_disabled, then either the dynamic object was
3695              removed with "remove-symbol-file" or with
3696              "nosharedlibrary".  In the former case, we don't know
3697              whether another dynamic object might have loaded over the
3698              breakpoint's address -- the user might well let us know
3699              about it next with add-symbol-file (the whole point of
3700              add-symbol-file is letting the user manually maintain a
3701              list of dynamically loaded objects).  If we have the
3702              breakpoint's shadow memory, that is, this is a software
3703              breakpoint managed by GDB, check whether the breakpoint
3704              is still inserted in memory, to avoid overwriting wrong
3705              code with stale saved shadow contents.  Note that HW
3706              breakpoints don't have shadow memory, as they're
3707              implemented using a mechanism that is not dependent on
3708              being able to modify the target's memory, and as such
3709              they should always be removed.  */
3710           if (bl->shlib_disabled
3711               && bl->target_info.shadow_len != 0
3712               && !memory_validate_breakpoint (bl->gdbarch, &bl->target_info))
3713             val = 0;
3714           else
3715             val = bl->owner->ops->remove_location (bl, reason);
3716         }
3717       else
3718         {
3719           /* This breakpoint is in an overlay section.
3720              Did we set a breakpoint at the LMA?  */
3721           if (!overlay_events_enabled)
3722               {
3723                 /* Yes -- overlay event support is not active, so we
3724                    should have set a breakpoint at the LMA.  Remove it.  
3725                 */
3726                 /* Ignore any failures: if the LMA is in ROM, we will
3727                    have already warned when we failed to insert it.  */
3728                 if (bl->loc_type == bp_loc_hardware_breakpoint)
3729                   target_remove_hw_breakpoint (bl->gdbarch,
3730                                                &bl->overlay_target_info);
3731                 else
3732                   target_remove_breakpoint (bl->gdbarch,
3733                                             &bl->overlay_target_info,
3734                                             reason);
3735               }
3736           /* Did we set a breakpoint at the VMA? 
3737              If so, we will have marked the breakpoint 'inserted'.  */
3738           if (bl->inserted)
3739             {
3740               /* Yes -- remove it.  Previously we did not bother to
3741                  remove the breakpoint if the section had been
3742                  unmapped, but let's not rely on that being safe.  We
3743                  don't know what the overlay manager might do.  */
3744
3745               /* However, we should remove *software* breakpoints only
3746                  if the section is still mapped, or else we overwrite
3747                  wrong code with the saved shadow contents.  */
3748               if (bl->loc_type == bp_loc_hardware_breakpoint
3749                   || section_is_mapped (bl->section))
3750                 val = bl->owner->ops->remove_location (bl, reason);
3751               else
3752                 val = 0;
3753             }
3754           else
3755             {
3756               /* No -- not inserted, so no need to remove.  No error.  */
3757               val = 0;
3758             }
3759         }
3760
3761       /* In some cases, we might not be able to remove a breakpoint in
3762          a shared library that has already been removed, but we have
3763          not yet processed the shlib unload event.  Similarly for an
3764          unloaded add-symbol-file object - the user might not yet have
3765          had the chance to remove-symbol-file it.  shlib_disabled will
3766          be set if the library/object has already been removed, but
3767          the breakpoint hasn't been uninserted yet, e.g., after
3768          "nosharedlibrary" or "remove-symbol-file" with breakpoints
3769          always-inserted mode.  */
3770       if (val
3771           && (bl->loc_type == bp_loc_software_breakpoint
3772               && (bl->shlib_disabled
3773                   || solib_name_from_address (bl->pspace, bl->address)
3774                   || shared_objfile_contains_address_p (bl->pspace,
3775                                                         bl->address))))
3776         val = 0;
3777
3778       if (val)
3779         return val;
3780       bl->inserted = (reason == DETACH_BREAKPOINT);
3781     }
3782   else if (bl->loc_type == bp_loc_hardware_watchpoint)
3783     {
3784       gdb_assert (bl->owner->ops != NULL
3785                   && bl->owner->ops->remove_location != NULL);
3786
3787       bl->inserted = (reason == DETACH_BREAKPOINT);
3788       bl->owner->ops->remove_location (bl, reason);
3789
3790       /* Failure to remove any of the hardware watchpoints comes here.  */
3791       if (reason == REMOVE_BREAKPOINT && bl->inserted)
3792         warning (_("Could not remove hardware watchpoint %d."),
3793                  bl->owner->number);
3794     }
3795   else if (bl->owner->type == bp_catchpoint
3796            && breakpoint_enabled (bl->owner)
3797            && !bl->duplicate)
3798     {
3799       gdb_assert (bl->owner->ops != NULL
3800                   && bl->owner->ops->remove_location != NULL);
3801
3802       val = bl->owner->ops->remove_location (bl, reason);
3803       if (val)
3804         return val;
3805
3806       bl->inserted = (reason == DETACH_BREAKPOINT);
3807     }
3808
3809   return 0;
3810 }
3811
3812 static int
3813 remove_breakpoint (struct bp_location *bl)
3814 {
3815   /* BL is never in moribund_locations by our callers.  */
3816   gdb_assert (bl->owner != NULL);
3817
3818   /* The type of none suggests that owner is actually deleted.
3819      This should not ever happen.  */
3820   gdb_assert (bl->owner->type != bp_none);
3821
3822   scoped_restore_current_pspace_and_thread restore_pspace_thread;
3823
3824   switch_to_program_space_and_thread (bl->pspace);
3825
3826   return remove_breakpoint_1 (bl, REMOVE_BREAKPOINT);
3827 }
3828
3829 /* Clear the "inserted" flag in all breakpoints.  */
3830
3831 void
3832 mark_breakpoints_out (void)
3833 {
3834   struct bp_location *bl, **blp_tmp;
3835
3836   ALL_BP_LOCATIONS (bl, blp_tmp)
3837     if (bl->pspace == current_program_space)
3838       bl->inserted = 0;
3839 }
3840
3841 /* Clear the "inserted" flag in all breakpoints and delete any
3842    breakpoints which should go away between runs of the program.
3843
3844    Plus other such housekeeping that has to be done for breakpoints
3845    between runs.
3846
3847    Note: this function gets called at the end of a run (by
3848    generic_mourn_inferior) and when a run begins (by
3849    init_wait_for_inferior).  */
3850
3851
3852
3853 void
3854 breakpoint_init_inferior (enum inf_context context)
3855 {
3856   struct breakpoint *b, *b_tmp;
3857   struct program_space *pspace = current_program_space;
3858
3859   /* If breakpoint locations are shared across processes, then there's
3860      nothing to do.  */
3861   if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3862     return;
3863
3864   mark_breakpoints_out ();
3865
3866   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3867   {
3868     if (b->loc && b->loc->pspace != pspace)
3869       continue;
3870
3871     switch (b->type)
3872       {
3873       case bp_call_dummy:
3874       case bp_longjmp_call_dummy:
3875
3876         /* If the call dummy breakpoint is at the entry point it will
3877            cause problems when the inferior is rerun, so we better get
3878            rid of it.  */
3879
3880       case bp_watchpoint_scope:
3881
3882         /* Also get rid of scope breakpoints.  */
3883
3884       case bp_shlib_event:
3885
3886         /* Also remove solib event breakpoints.  Their addresses may
3887            have changed since the last time we ran the program.
3888            Actually we may now be debugging against different target;
3889            and so the solib backend that installed this breakpoint may
3890            not be used in by the target.  E.g.,
3891
3892            (gdb) file prog-linux
3893            (gdb) run               # native linux target
3894            ...
3895            (gdb) kill
3896            (gdb) file prog-win.exe
3897            (gdb) tar rem :9999     # remote Windows gdbserver.
3898         */
3899
3900       case bp_step_resume:
3901
3902         /* Also remove step-resume breakpoints.  */
3903
3904       case bp_single_step:
3905
3906         /* Also remove single-step breakpoints.  */
3907
3908         delete_breakpoint (b);
3909         break;
3910
3911       case bp_watchpoint:
3912       case bp_hardware_watchpoint:
3913       case bp_read_watchpoint:
3914       case bp_access_watchpoint:
3915         {
3916           struct watchpoint *w = (struct watchpoint *) b;
3917
3918           /* Likewise for watchpoints on local expressions.  */
3919           if (w->exp_valid_block != NULL)
3920             delete_breakpoint (b);
3921           else
3922             {
3923               /* Get rid of existing locations, which are no longer
3924                  valid.  New ones will be created in
3925                  update_watchpoint, when the inferior is restarted.
3926                  The next update_global_location_list call will
3927                  garbage collect them.  */
3928               b->loc = NULL;
3929
3930               if (context == inf_starting)
3931                 {
3932                   /* Reset val field to force reread of starting value in
3933                      insert_breakpoints.  */
3934                   w->val.reset (nullptr);
3935                   w->val_valid = 0;
3936                 }
3937             }
3938         }
3939         break;
3940       default:
3941         break;
3942       }
3943   }
3944
3945   /* Get rid of the moribund locations.  */
3946   for (bp_location *bl : moribund_locations)
3947     decref_bp_location (&bl);
3948   moribund_locations.clear ();
3949 }
3950
3951 /* These functions concern about actual breakpoints inserted in the
3952    target --- to e.g. check if we need to do decr_pc adjustment or if
3953    we need to hop over the bkpt --- so we check for address space
3954    match, not program space.  */
3955
3956 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3957    exists at PC.  It returns ordinary_breakpoint_here if it's an
3958    ordinary breakpoint, or permanent_breakpoint_here if it's a
3959    permanent breakpoint.
3960    - When continuing from a location with an ordinary breakpoint, we
3961      actually single step once before calling insert_breakpoints.
3962    - When continuing from a location with a permanent breakpoint, we
3963      need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3964      the target, to advance the PC past the breakpoint.  */
3965
3966 enum breakpoint_here
3967 breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
3968 {
3969   struct bp_location *bl, **blp_tmp;
3970   int any_breakpoint_here = 0;
3971
3972   ALL_BP_LOCATIONS (bl, blp_tmp)
3973     {
3974       if (bl->loc_type != bp_loc_software_breakpoint
3975           && bl->loc_type != bp_loc_hardware_breakpoint)
3976         continue;
3977
3978       /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL.  */
3979       if ((breakpoint_enabled (bl->owner)
3980            || bl->permanent)
3981           && breakpoint_location_address_match (bl, aspace, pc))
3982         {
3983           if (overlay_debugging 
3984               && section_is_overlay (bl->section)
3985               && !section_is_mapped (bl->section))
3986             continue;           /* unmapped overlay -- can't be a match */
3987           else if (bl->permanent)
3988             return permanent_breakpoint_here;
3989           else
3990             any_breakpoint_here = 1;
3991         }
3992     }
3993
3994   return any_breakpoint_here ? ordinary_breakpoint_here : no_breakpoint_here;
3995 }
3996
3997 /* See breakpoint.h.  */
3998
3999 int
4000 breakpoint_in_range_p (const address_space *aspace,
4001                        CORE_ADDR addr, ULONGEST len)
4002 {
4003   struct bp_location *bl, **blp_tmp;
4004
4005   ALL_BP_LOCATIONS (bl, blp_tmp)
4006     {
4007       if (bl->loc_type != bp_loc_software_breakpoint
4008           && bl->loc_type != bp_loc_hardware_breakpoint)
4009         continue;
4010
4011       if ((breakpoint_enabled (bl->owner)
4012            || bl->permanent)
4013           && breakpoint_location_address_range_overlap (bl, aspace,
4014                                                         addr, len))
4015         {
4016           if (overlay_debugging
4017               && section_is_overlay (bl->section)
4018               && !section_is_mapped (bl->section))
4019             {
4020               /* Unmapped overlay -- can't be a match.  */
4021               continue;
4022             }
4023
4024           return 1;
4025         }
4026     }
4027
4028   return 0;
4029 }
4030
4031 /* Return true if there's a moribund breakpoint at PC.  */
4032
4033 int
4034 moribund_breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
4035 {
4036   for (bp_location *loc : moribund_locations)
4037     if (breakpoint_location_address_match (loc, aspace, pc))
4038       return 1;
4039
4040   return 0;
4041 }
4042
4043 /* Returns non-zero iff BL is inserted at PC, in address space
4044    ASPACE.  */
4045
4046 static int
4047 bp_location_inserted_here_p (struct bp_location *bl,
4048                              const address_space *aspace, CORE_ADDR pc)
4049 {
4050   if (bl->inserted
4051       && breakpoint_address_match (bl->pspace->aspace, bl->address,
4052                                    aspace, pc))
4053     {
4054       if (overlay_debugging
4055           && section_is_overlay (bl->section)
4056           && !section_is_mapped (bl->section))
4057         return 0;               /* unmapped overlay -- can't be a match */
4058       else
4059         return 1;
4060     }
4061   return 0;
4062 }
4063
4064 /* Returns non-zero iff there's a breakpoint inserted at PC.  */
4065
4066 int
4067 breakpoint_inserted_here_p (const address_space *aspace, CORE_ADDR pc)
4068 {
4069   struct bp_location **blp, **blp_tmp = NULL;
4070
4071   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4072     {
4073       struct bp_location *bl = *blp;
4074
4075       if (bl->loc_type != bp_loc_software_breakpoint
4076           && bl->loc_type != bp_loc_hardware_breakpoint)
4077         continue;
4078
4079       if (bp_location_inserted_here_p (bl, aspace, pc))
4080         return 1;
4081     }
4082   return 0;
4083 }
4084
4085 /* This function returns non-zero iff there is a software breakpoint
4086    inserted at PC.  */
4087
4088 int
4089 software_breakpoint_inserted_here_p (const address_space *aspace,
4090                                      CORE_ADDR pc)
4091 {
4092   struct bp_location **blp, **blp_tmp = NULL;
4093
4094   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4095     {
4096       struct bp_location *bl = *blp;
4097
4098       if (bl->loc_type != bp_loc_software_breakpoint)
4099         continue;
4100
4101       if (bp_location_inserted_here_p (bl, aspace, pc))
4102         return 1;
4103     }
4104
4105   return 0;
4106 }
4107
4108 /* See breakpoint.h.  */
4109
4110 int
4111 hardware_breakpoint_inserted_here_p (const address_space *aspace,
4112                                      CORE_ADDR pc)
4113 {
4114   struct bp_location **blp, **blp_tmp = NULL;
4115
4116   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4117     {
4118       struct bp_location *bl = *blp;
4119
4120       if (bl->loc_type != bp_loc_hardware_breakpoint)
4121         continue;
4122
4123       if (bp_location_inserted_here_p (bl, aspace, pc))
4124         return 1;
4125     }
4126
4127   return 0;
4128 }
4129
4130 int
4131 hardware_watchpoint_inserted_in_range (const address_space *aspace,
4132                                        CORE_ADDR addr, ULONGEST len)
4133 {
4134   struct breakpoint *bpt;
4135
4136   ALL_BREAKPOINTS (bpt)
4137     {
4138       struct bp_location *loc;
4139
4140       if (bpt->type != bp_hardware_watchpoint
4141           && bpt->type != bp_access_watchpoint)
4142         continue;
4143
4144       if (!breakpoint_enabled (bpt))
4145         continue;
4146
4147       for (loc = bpt->loc; loc; loc = loc->next)
4148         if (loc->pspace->aspace == aspace && loc->inserted)
4149           {
4150             CORE_ADDR l, h;
4151
4152             /* Check for intersection.  */
4153             l = std::max<CORE_ADDR> (loc->address, addr);
4154             h = std::min<CORE_ADDR> (loc->address + loc->length, addr + len);
4155             if (l < h)
4156               return 1;
4157           }
4158     }
4159   return 0;
4160 }
4161 \f
4162
4163 /* bpstat stuff.  External routines' interfaces are documented
4164    in breakpoint.h.  */
4165
4166 int
4167 is_catchpoint (struct breakpoint *ep)
4168 {
4169   return (ep->type == bp_catchpoint);
4170 }
4171
4172 /* Frees any storage that is part of a bpstat.  Does not walk the
4173    'next' chain.  */
4174
4175 bpstats::~bpstats ()
4176 {
4177   if (bp_location_at != NULL)
4178     decref_bp_location (&bp_location_at);
4179 }
4180
4181 /* Clear a bpstat so that it says we are not at any breakpoint.
4182    Also free any storage that is part of a bpstat.  */
4183
4184 void
4185 bpstat_clear (bpstat *bsp)
4186 {
4187   bpstat p;
4188   bpstat q;
4189
4190   if (bsp == 0)
4191     return;
4192   p = *bsp;
4193   while (p != NULL)
4194     {
4195       q = p->next;
4196       delete p;
4197       p = q;
4198     }
4199   *bsp = NULL;
4200 }
4201
4202 bpstats::bpstats (const bpstats &other)
4203   : next (NULL),
4204     bp_location_at (other.bp_location_at),
4205     breakpoint_at (other.breakpoint_at),
4206     commands (other.commands),
4207     print (other.print),
4208     stop (other.stop),
4209     print_it (other.print_it)
4210 {
4211   if (other.old_val != NULL)
4212     old_val = release_value (value_copy (other.old_val.get ()));
4213   incref_bp_location (bp_location_at);
4214 }
4215
4216 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
4217    is part of the bpstat is copied as well.  */
4218
4219 bpstat
4220 bpstat_copy (bpstat bs)
4221 {
4222   bpstat p = NULL;
4223   bpstat tmp;
4224   bpstat retval = NULL;
4225
4226   if (bs == NULL)
4227     return bs;
4228
4229   for (; bs != NULL; bs = bs->next)
4230     {
4231       tmp = new bpstats (*bs);
4232
4233       if (p == NULL)
4234         /* This is the first thing in the chain.  */
4235         retval = tmp;
4236       else
4237         p->next = tmp;
4238       p = tmp;
4239     }
4240   p->next = NULL;
4241   return retval;
4242 }
4243
4244 /* Find the bpstat associated with this breakpoint.  */
4245
4246 bpstat
4247 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
4248 {
4249   if (bsp == NULL)
4250     return NULL;
4251
4252   for (; bsp != NULL; bsp = bsp->next)
4253     {
4254       if (bsp->breakpoint_at == breakpoint)
4255         return bsp;
4256     }
4257   return NULL;
4258 }
4259
4260 /* See breakpoint.h.  */
4261
4262 int
4263 bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
4264 {
4265   for (; bsp != NULL; bsp = bsp->next)
4266     {
4267       if (bsp->breakpoint_at == NULL)
4268         {
4269           /* A moribund location can never explain a signal other than
4270              GDB_SIGNAL_TRAP.  */
4271           if (sig == GDB_SIGNAL_TRAP)
4272             return 1;
4273         }
4274       else
4275         {
4276           if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
4277                                                         sig))
4278             return 1;
4279         }
4280     }
4281
4282   return 0;
4283 }
4284
4285 /* Put in *NUM the breakpoint number of the first breakpoint we are
4286    stopped at.  *BSP upon return is a bpstat which points to the
4287    remaining breakpoints stopped at (but which is not guaranteed to be
4288    good for anything but further calls to bpstat_num).
4289
4290    Return 0 if passed a bpstat which does not indicate any breakpoints.
4291    Return -1 if stopped at a breakpoint that has been deleted since
4292    we set it.
4293    Return 1 otherwise.  */
4294
4295 int
4296 bpstat_num (bpstat *bsp, int *num)
4297 {
4298   struct breakpoint *b;
4299
4300   if ((*bsp) == NULL)
4301     return 0;                   /* No more breakpoint values */
4302
4303   /* We assume we'll never have several bpstats that correspond to a
4304      single breakpoint -- otherwise, this function might return the
4305      same number more than once and this will look ugly.  */
4306   b = (*bsp)->breakpoint_at;
4307   *bsp = (*bsp)->next;
4308   if (b == NULL)
4309     return -1;                  /* breakpoint that's been deleted since */
4310
4311   *num = b->number;             /* We have its number */
4312   return 1;
4313 }
4314
4315 /* See breakpoint.h.  */
4316
4317 void
4318 bpstat_clear_actions (void)
4319 {
4320   bpstat bs;
4321
4322   if (inferior_ptid == null_ptid)
4323     return;
4324
4325   thread_info *tp = inferior_thread ();
4326   for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
4327     {
4328       bs->commands = NULL;
4329       bs->old_val.reset (nullptr);
4330     }
4331 }
4332
4333 /* Called when a command is about to proceed the inferior.  */
4334
4335 static void
4336 breakpoint_about_to_proceed (void)
4337 {
4338   if (inferior_ptid != null_ptid)
4339     {
4340       struct thread_info *tp = inferior_thread ();
4341
4342       /* Allow inferior function calls in breakpoint commands to not
4343          interrupt the command list.  When the call finishes
4344          successfully, the inferior will be standing at the same
4345          breakpoint as if nothing happened.  */
4346       if (tp->control.in_infcall)
4347         return;
4348     }
4349
4350   breakpoint_proceeded = 1;
4351 }
4352
4353 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4354    or its equivalent.  */
4355
4356 static int
4357 command_line_is_silent (struct command_line *cmd)
4358 {
4359   return cmd && (strcmp ("silent", cmd->line) == 0);
4360 }
4361
4362 /* Execute all the commands associated with all the breakpoints at
4363    this location.  Any of these commands could cause the process to
4364    proceed beyond this point, etc.  We look out for such changes by
4365    checking the global "breakpoint_proceeded" after each command.
4366
4367    Returns true if a breakpoint command resumed the inferior.  In that
4368    case, it is the caller's responsibility to recall it again with the
4369    bpstat of the current thread.  */
4370
4371 static int
4372 bpstat_do_actions_1 (bpstat *bsp)
4373 {
4374   bpstat bs;
4375   int again = 0;
4376
4377   /* Avoid endless recursion if a `source' command is contained
4378      in bs->commands.  */
4379   if (executing_breakpoint_commands)
4380     return 0;
4381
4382   scoped_restore save_executing
4383     = make_scoped_restore (&executing_breakpoint_commands, 1);
4384
4385   scoped_restore preventer = prevent_dont_repeat ();
4386
4387   /* This pointer will iterate over the list of bpstat's.  */
4388   bs = *bsp;
4389
4390   breakpoint_proceeded = 0;
4391   for (; bs != NULL; bs = bs->next)
4392     {
4393       struct command_line *cmd = NULL;
4394
4395       /* Take ownership of the BSP's command tree, if it has one.
4396
4397          The command tree could legitimately contain commands like
4398          'step' and 'next', which call clear_proceed_status, which
4399          frees stop_bpstat's command tree.  To make sure this doesn't
4400          free the tree we're executing out from under us, we need to
4401          take ownership of the tree ourselves.  Since a given bpstat's
4402          commands are only executed once, we don't need to copy it; we
4403          can clear the pointer in the bpstat, and make sure we free
4404          the tree when we're done.  */
4405       counted_command_line ccmd = bs->commands;
4406       bs->commands = NULL;
4407       if (ccmd != NULL)
4408         cmd = ccmd.get ();
4409       if (command_line_is_silent (cmd))
4410         {
4411           /* The action has been already done by bpstat_stop_status.  */
4412           cmd = cmd->next;
4413         }
4414
4415       while (cmd != NULL)
4416         {
4417           execute_control_command (cmd);
4418
4419           if (breakpoint_proceeded)
4420             break;
4421           else
4422             cmd = cmd->next;
4423         }
4424
4425       if (breakpoint_proceeded)
4426         {
4427           if (current_ui->async)
4428             /* If we are in async mode, then the target might be still
4429                running, not stopped at any breakpoint, so nothing for
4430                us to do here -- just return to the event loop.  */
4431             ;
4432           else
4433             /* In sync mode, when execute_control_command returns
4434                we're already standing on the next breakpoint.
4435                Breakpoint commands for that stop were not run, since
4436                execute_command does not run breakpoint commands --
4437                only command_line_handler does, but that one is not
4438                involved in execution of breakpoint commands.  So, we
4439                can now execute breakpoint commands.  It should be
4440                noted that making execute_command do bpstat actions is
4441                not an option -- in this case we'll have recursive
4442                invocation of bpstat for each breakpoint with a
4443                command, and can easily blow up GDB stack.  Instead, we
4444                return true, which will trigger the caller to recall us
4445                with the new stop_bpstat.  */
4446             again = 1;
4447           break;
4448         }
4449     }
4450   return again;
4451 }
4452
4453 /* Helper for bpstat_do_actions.  Get the current thread, if there's
4454    one, is alive and has execution.  Return NULL otherwise.  */
4455
4456 static thread_info *
4457 get_bpstat_thread ()
4458 {
4459   if (inferior_ptid == null_ptid || !target_has_execution)
4460     return NULL;
4461
4462   thread_info *tp = inferior_thread ();
4463   if (tp->state == THREAD_EXITED || tp->executing)
4464     return NULL;
4465   return tp;
4466 }
4467
4468 void
4469 bpstat_do_actions (void)
4470 {
4471   auto cleanup_if_error = make_scope_exit (bpstat_clear_actions);
4472   thread_info *tp;
4473
4474   /* Do any commands attached to breakpoint we are stopped at.  */
4475   while ((tp = get_bpstat_thread ()) != NULL)
4476     {
4477       /* Since in sync mode, bpstat_do_actions may resume the
4478          inferior, and only return when it is stopped at the next
4479          breakpoint, we keep doing breakpoint actions until it returns
4480          false to indicate the inferior was not resumed.  */
4481       if (!bpstat_do_actions_1 (&tp->control.stop_bpstat))
4482         break;
4483     }
4484
4485   cleanup_if_error.release ();
4486 }
4487
4488 /* Print out the (old or new) value associated with a watchpoint.  */
4489
4490 static void
4491 watchpoint_value_print (struct value *val, struct ui_file *stream)
4492 {
4493   if (val == NULL)
4494     fprintf_unfiltered (stream, _("<unreadable>"));
4495   else
4496     {
4497       struct value_print_options opts;
4498       get_user_print_options (&opts);
4499       value_print (val, stream, &opts);
4500     }
4501 }
4502
4503 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4504    debugging multiple threads.  */
4505
4506 void
4507 maybe_print_thread_hit_breakpoint (struct ui_out *uiout)
4508 {
4509   if (uiout->is_mi_like_p ())
4510     return;
4511
4512   uiout->text ("\n");
4513
4514   if (show_thread_that_caused_stop ())
4515     {
4516       const char *name;
4517       struct thread_info *thr = inferior_thread ();
4518
4519       uiout->text ("Thread ");
4520       uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
4521
4522       name = thr->name != NULL ? thr->name : target_thread_name (thr);
4523       if (name != NULL)
4524         {
4525           uiout->text (" \"");
4526           uiout->field_fmt ("name", "%s", name);
4527           uiout->text ("\"");
4528         }
4529
4530       uiout->text (" hit ");
4531     }
4532 }
4533
4534 /* Generic routine for printing messages indicating why we
4535    stopped.  The behavior of this function depends on the value
4536    'print_it' in the bpstat structure.  Under some circumstances we
4537    may decide not to print anything here and delegate the task to
4538    normal_stop().  */
4539
4540 static enum print_stop_action
4541 print_bp_stop_message (bpstat bs)
4542 {
4543   switch (bs->print_it)
4544     {
4545     case print_it_noop:
4546       /* Nothing should be printed for this bpstat entry.  */
4547       return PRINT_UNKNOWN;
4548       break;
4549
4550     case print_it_done:
4551       /* We still want to print the frame, but we already printed the
4552          relevant messages.  */
4553       return PRINT_SRC_AND_LOC;
4554       break;
4555
4556     case print_it_normal:
4557       {
4558         struct breakpoint *b = bs->breakpoint_at;
4559
4560         /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4561            which has since been deleted.  */
4562         if (b == NULL)
4563           return PRINT_UNKNOWN;
4564
4565         /* Normal case.  Call the breakpoint's print_it method.  */
4566         return b->ops->print_it (bs);
4567       }
4568       break;
4569
4570     default:
4571       internal_error (__FILE__, __LINE__,
4572                       _("print_bp_stop_message: unrecognized enum value"));
4573       break;
4574     }
4575 }
4576
4577 /* A helper function that prints a shared library stopped event.  */
4578
4579 static void
4580 print_solib_event (int is_catchpoint)
4581 {
4582   bool any_deleted = !current_program_space->deleted_solibs.empty ();
4583   bool any_added = !current_program_space->added_solibs.empty ();
4584
4585   if (!is_catchpoint)
4586     {
4587       if (any_added || any_deleted)
4588         current_uiout->text (_("Stopped due to shared library event:\n"));
4589       else
4590         current_uiout->text (_("Stopped due to shared library event (no "
4591                                "libraries added or removed)\n"));
4592     }
4593
4594   if (current_uiout->is_mi_like_p ())
4595     current_uiout->field_string ("reason",
4596                                  async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
4597
4598   if (any_deleted)
4599     {
4600       current_uiout->text (_("  Inferior unloaded "));
4601       ui_out_emit_list list_emitter (current_uiout, "removed");
4602       for (int ix = 0; ix < current_program_space->deleted_solibs.size (); ix++)
4603         {
4604           const std::string &name = current_program_space->deleted_solibs[ix];
4605
4606           if (ix > 0)
4607             current_uiout->text ("    ");
4608           current_uiout->field_string ("library", name);
4609           current_uiout->text ("\n");
4610         }
4611     }
4612
4613   if (any_added)
4614     {
4615       current_uiout->text (_("  Inferior loaded "));
4616       ui_out_emit_list list_emitter (current_uiout, "added");
4617       bool first = true;
4618       for (so_list *iter : current_program_space->added_solibs)
4619         {
4620           if (!first)
4621             current_uiout->text ("    ");
4622           first = false;
4623           current_uiout->field_string ("library", iter->so_name);
4624           current_uiout->text ("\n");
4625         }
4626     }
4627 }
4628
4629 /* Print a message indicating what happened.  This is called from
4630    normal_stop().  The input to this routine is the head of the bpstat
4631    list - a list of the eventpoints that caused this stop.  KIND is
4632    the target_waitkind for the stopping event.  This
4633    routine calls the generic print routine for printing a message
4634    about reasons for stopping.  This will print (for example) the
4635    "Breakpoint n," part of the output.  The return value of this
4636    routine is one of:
4637
4638    PRINT_UNKNOWN: Means we printed nothing.
4639    PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4640    code to print the location.  An example is 
4641    "Breakpoint 1, " which should be followed by
4642    the location.
4643    PRINT_SRC_ONLY: Means we printed something, but there is no need
4644    to also print the location part of the message.
4645    An example is the catch/throw messages, which
4646    don't require a location appended to the end.
4647    PRINT_NOTHING: We have done some printing and we don't need any 
4648    further info to be printed.  */
4649
4650 enum print_stop_action
4651 bpstat_print (bpstat bs, int kind)
4652 {
4653   enum print_stop_action val;
4654
4655   /* Maybe another breakpoint in the chain caused us to stop.
4656      (Currently all watchpoints go on the bpstat whether hit or not.
4657      That probably could (should) be changed, provided care is taken
4658      with respect to bpstat_explains_signal).  */
4659   for (; bs; bs = bs->next)
4660     {
4661       val = print_bp_stop_message (bs);
4662       if (val == PRINT_SRC_ONLY 
4663           || val == PRINT_SRC_AND_LOC 
4664           || val == PRINT_NOTHING)
4665         return val;
4666     }
4667
4668   /* If we had hit a shared library event breakpoint,
4669      print_bp_stop_message would print out this message.  If we hit an
4670      OS-level shared library event, do the same thing.  */
4671   if (kind == TARGET_WAITKIND_LOADED)
4672     {
4673       print_solib_event (0);
4674       return PRINT_NOTHING;
4675     }
4676
4677   /* We reached the end of the chain, or we got a null BS to start
4678      with and nothing was printed.  */
4679   return PRINT_UNKNOWN;
4680 }
4681
4682 /* Evaluate the boolean expression EXP and return the result.  */
4683
4684 static bool
4685 breakpoint_cond_eval (expression *exp)
4686 {
4687   struct value *mark = value_mark ();
4688   bool res = value_true (evaluate_expression (exp));
4689
4690   value_free_to_mark (mark);
4691   return res;
4692 }
4693
4694 /* Allocate a new bpstat.  Link it to the FIFO list by BS_LINK_POINTER.  */
4695
4696 bpstats::bpstats (struct bp_location *bl, bpstat **bs_link_pointer)
4697   : next (NULL),
4698     bp_location_at (bl),
4699     breakpoint_at (bl->owner),
4700     commands (NULL),
4701     print (0),
4702     stop (0),
4703     print_it (print_it_normal)
4704 {
4705   incref_bp_location (bl);
4706   **bs_link_pointer = this;
4707   *bs_link_pointer = &next;
4708 }
4709
4710 bpstats::bpstats ()
4711   : next (NULL),
4712     bp_location_at (NULL),
4713     breakpoint_at (NULL),
4714     commands (NULL),
4715     print (0),
4716     stop (0),
4717     print_it (print_it_normal)
4718 {
4719 }
4720 \f
4721 /* The target has stopped with waitstatus WS.  Check if any hardware
4722    watchpoints have triggered, according to the target.  */
4723
4724 int
4725 watchpoints_triggered (struct target_waitstatus *ws)
4726 {
4727   bool stopped_by_watchpoint = target_stopped_by_watchpoint ();
4728   CORE_ADDR addr;
4729   struct breakpoint *b;
4730
4731   if (!stopped_by_watchpoint)
4732     {
4733       /* We were not stopped by a watchpoint.  Mark all watchpoints
4734          as not triggered.  */
4735       ALL_BREAKPOINTS (b)
4736         if (is_hardware_watchpoint (b))
4737           {
4738             struct watchpoint *w = (struct watchpoint *) b;
4739
4740             w->watchpoint_triggered = watch_triggered_no;
4741           }
4742
4743       return 0;
4744     }
4745
4746   if (!target_stopped_data_address (current_top_target (), &addr))
4747     {
4748       /* We were stopped by a watchpoint, but we don't know where.
4749          Mark all watchpoints as unknown.  */
4750       ALL_BREAKPOINTS (b)
4751         if (is_hardware_watchpoint (b))
4752           {
4753             struct watchpoint *w = (struct watchpoint *) b;
4754
4755             w->watchpoint_triggered = watch_triggered_unknown;
4756           }
4757
4758       return 1;
4759     }
4760
4761   /* The target could report the data address.  Mark watchpoints
4762      affected by this data address as triggered, and all others as not
4763      triggered.  */
4764
4765   ALL_BREAKPOINTS (b)
4766     if (is_hardware_watchpoint (b))
4767       {
4768         struct watchpoint *w = (struct watchpoint *) b;
4769         struct bp_location *loc;
4770
4771         w->watchpoint_triggered = watch_triggered_no;
4772         for (loc = b->loc; loc; loc = loc->next)
4773           {
4774             if (is_masked_watchpoint (b))
4775               {
4776                 CORE_ADDR newaddr = addr & w->hw_wp_mask;
4777                 CORE_ADDR start = loc->address & w->hw_wp_mask;
4778
4779                 if (newaddr == start)
4780                   {
4781                     w->watchpoint_triggered = watch_triggered_yes;
4782                     break;
4783                   }
4784               }
4785             /* Exact match not required.  Within range is sufficient.  */
4786             else if (target_watchpoint_addr_within_range (current_top_target (),
4787                                                          addr, loc->address,
4788                                                          loc->length))
4789               {
4790                 w->watchpoint_triggered = watch_triggered_yes;
4791                 break;
4792               }
4793           }
4794       }
4795
4796   return 1;
4797 }
4798
4799 /* Possible return values for watchpoint_check.  */
4800 enum wp_check_result
4801   {
4802     /* The watchpoint has been deleted.  */
4803     WP_DELETED = 1,
4804
4805     /* The value has changed.  */
4806     WP_VALUE_CHANGED = 2,
4807
4808     /* The value has not changed.  */
4809     WP_VALUE_NOT_CHANGED = 3,
4810
4811     /* Ignore this watchpoint, no matter if the value changed or not.  */
4812     WP_IGNORE = 4,
4813   };
4814
4815 #define BP_TEMPFLAG 1
4816 #define BP_HARDWAREFLAG 2
4817
4818 /* Evaluate watchpoint condition expression and check if its value
4819    changed.  */
4820
4821 static wp_check_result
4822 watchpoint_check (bpstat bs)
4823 {
4824   struct watchpoint *b;
4825   struct frame_info *fr;
4826   int within_current_scope;
4827
4828   /* BS is built from an existing struct breakpoint.  */
4829   gdb_assert (bs->breakpoint_at != NULL);
4830   b = (struct watchpoint *) bs->breakpoint_at;
4831
4832   /* If this is a local watchpoint, we only want to check if the
4833      watchpoint frame is in scope if the current thread is the thread
4834      that was used to create the watchpoint.  */
4835   if (!watchpoint_in_thread_scope (b))
4836     return WP_IGNORE;
4837
4838   if (b->exp_valid_block == NULL)
4839     within_current_scope = 1;
4840   else
4841     {
4842       struct frame_info *frame = get_current_frame ();
4843       struct gdbarch *frame_arch = get_frame_arch (frame);
4844       CORE_ADDR frame_pc = get_frame_pc (frame);
4845
4846       /* stack_frame_destroyed_p() returns a non-zero value if we're
4847          still in the function but the stack frame has already been
4848          invalidated.  Since we can't rely on the values of local
4849          variables after the stack has been destroyed, we are treating
4850          the watchpoint in that state as `not changed' without further
4851          checking.  Don't mark watchpoints as changed if the current
4852          frame is in an epilogue - even if they are in some other
4853          frame, our view of the stack is likely to be wrong and
4854          frame_find_by_id could error out.  */
4855       if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
4856         return WP_IGNORE;
4857
4858       fr = frame_find_by_id (b->watchpoint_frame);
4859       within_current_scope = (fr != NULL);
4860
4861       /* If we've gotten confused in the unwinder, we might have
4862          returned a frame that can't describe this variable.  */
4863       if (within_current_scope)
4864         {
4865           struct symbol *function;
4866
4867           function = get_frame_function (fr);
4868           if (function == NULL
4869               || !contained_in (b->exp_valid_block,
4870                                 SYMBOL_BLOCK_VALUE (function)))
4871             within_current_scope = 0;
4872         }
4873
4874       if (within_current_scope)
4875         /* If we end up stopping, the current frame will get selected
4876            in normal_stop.  So this call to select_frame won't affect
4877            the user.  */
4878         select_frame (fr);
4879     }
4880
4881   if (within_current_scope)
4882     {
4883       /* We use value_{,free_to_}mark because it could be a *long*
4884          time before we return to the command level and call
4885          free_all_values.  We can't call free_all_values because we
4886          might be in the middle of evaluating a function call.  */
4887
4888       int pc = 0;
4889       struct value *mark;
4890       struct value *new_val;
4891
4892       if (is_masked_watchpoint (b))
4893         /* Since we don't know the exact trigger address (from
4894            stopped_data_address), just tell the user we've triggered
4895            a mask watchpoint.  */
4896         return WP_VALUE_CHANGED;
4897
4898       mark = value_mark ();
4899       fetch_subexp_value (b->exp.get (), &pc, &new_val, NULL, NULL, 0);
4900
4901       if (b->val_bitsize != 0)
4902         new_val = extract_bitfield_from_watchpoint_value (b, new_val);
4903
4904       /* We use value_equal_contents instead of value_equal because
4905          the latter coerces an array to a pointer, thus comparing just
4906          the address of the array instead of its contents.  This is
4907          not what we want.  */
4908       if ((b->val != NULL) != (new_val != NULL)
4909           || (b->val != NULL && !value_equal_contents (b->val.get (),
4910                                                        new_val)))
4911         {
4912           bs->old_val = b->val;
4913           b->val = release_value (new_val);
4914           b->val_valid = 1;
4915           if (new_val != NULL)
4916             value_free_to_mark (mark);
4917           return WP_VALUE_CHANGED;
4918         }
4919       else
4920         {
4921           /* Nothing changed.  */
4922           value_free_to_mark (mark);
4923           return WP_VALUE_NOT_CHANGED;
4924         }
4925     }
4926   else
4927     {
4928       /* This seems like the only logical thing to do because
4929          if we temporarily ignored the watchpoint, then when
4930          we reenter the block in which it is valid it contains
4931          garbage (in the case of a function, it may have two
4932          garbage values, one before and one after the prologue).
4933          So we can't even detect the first assignment to it and
4934          watch after that (since the garbage may or may not equal
4935          the first value assigned).  */
4936       /* We print all the stop information in
4937          breakpoint_ops->print_it, but in this case, by the time we
4938          call breakpoint_ops->print_it this bp will be deleted
4939          already.  So we have no choice but print the information
4940          here.  */
4941
4942       SWITCH_THRU_ALL_UIS ()
4943         {
4944           struct ui_out *uiout = current_uiout;
4945
4946           if (uiout->is_mi_like_p ())
4947             uiout->field_string
4948               ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
4949           uiout->text ("\nWatchpoint ");
4950           uiout->field_int ("wpnum", b->number);
4951           uiout->text (" deleted because the program has left the block in\n"
4952                        "which its expression is valid.\n");
4953         }
4954
4955       /* Make sure the watchpoint's commands aren't executed.  */
4956       b->commands = NULL;
4957       watchpoint_del_at_next_stop (b);
4958
4959       return WP_DELETED;
4960     }
4961 }
4962
4963 /* Return true if it looks like target has stopped due to hitting
4964    breakpoint location BL.  This function does not check if we should
4965    stop, only if BL explains the stop.  */
4966
4967 static int
4968 bpstat_check_location (const struct bp_location *bl,
4969                        const address_space *aspace, CORE_ADDR bp_addr,
4970                        const struct target_waitstatus *ws)
4971 {
4972   struct breakpoint *b = bl->owner;
4973
4974   /* BL is from an existing breakpoint.  */
4975   gdb_assert (b != NULL);
4976
4977   return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
4978 }
4979
4980 /* Determine if the watched values have actually changed, and we
4981    should stop.  If not, set BS->stop to 0.  */
4982
4983 static void
4984 bpstat_check_watchpoint (bpstat bs)
4985 {
4986   const struct bp_location *bl;
4987   struct watchpoint *b;
4988
4989   /* BS is built for existing struct breakpoint.  */
4990   bl = bs->bp_location_at;
4991   gdb_assert (bl != NULL);
4992   b = (struct watchpoint *) bs->breakpoint_at;
4993   gdb_assert (b != NULL);
4994
4995     {
4996       int must_check_value = 0;
4997       
4998       if (b->type == bp_watchpoint)
4999         /* For a software watchpoint, we must always check the
5000            watched value.  */
5001         must_check_value = 1;
5002       else if (b->watchpoint_triggered == watch_triggered_yes)
5003         /* We have a hardware watchpoint (read, write, or access)
5004            and the target earlier reported an address watched by
5005            this watchpoint.  */
5006         must_check_value = 1;
5007       else if (b->watchpoint_triggered == watch_triggered_unknown
5008                && b->type == bp_hardware_watchpoint)
5009         /* We were stopped by a hardware watchpoint, but the target could
5010            not report the data address.  We must check the watchpoint's
5011            value.  Access and read watchpoints are out of luck; without
5012            a data address, we can't figure it out.  */
5013         must_check_value = 1;
5014
5015       if (must_check_value)
5016         {
5017           wp_check_result e;
5018
5019           TRY
5020             {
5021               e = watchpoint_check (bs);
5022             }
5023           CATCH (ex, RETURN_MASK_ALL)
5024             {
5025               exception_fprintf (gdb_stderr, ex,
5026                                  "Error evaluating expression "
5027                                  "for watchpoint %d\n",
5028                                  b->number);
5029
5030               SWITCH_THRU_ALL_UIS ()
5031                 {
5032                   printf_filtered (_("Watchpoint %d deleted.\n"),
5033                                    b->number);
5034                 }
5035               watchpoint_del_at_next_stop (b);
5036               e = WP_DELETED;
5037             }
5038           END_CATCH
5039
5040           switch (e)
5041             {
5042             case WP_DELETED:
5043               /* We've already printed what needs to be printed.  */
5044               bs->print_it = print_it_done;
5045               /* Stop.  */
5046               break;
5047             case WP_IGNORE:
5048               bs->print_it = print_it_noop;
5049               bs->stop = 0;
5050               break;
5051             case WP_VALUE_CHANGED:
5052               if (b->type == bp_read_watchpoint)
5053                 {
5054                   /* There are two cases to consider here:
5055
5056                      1. We're watching the triggered memory for reads.
5057                      In that case, trust the target, and always report
5058                      the watchpoint hit to the user.  Even though
5059                      reads don't cause value changes, the value may
5060                      have changed since the last time it was read, and
5061                      since we're not trapping writes, we will not see
5062                      those, and as such we should ignore our notion of
5063                      old value.
5064
5065                      2. We're watching the triggered memory for both
5066                      reads and writes.  There are two ways this may
5067                      happen:
5068
5069                      2.1. This is a target that can't break on data
5070                      reads only, but can break on accesses (reads or
5071                      writes), such as e.g., x86.  We detect this case
5072                      at the time we try to insert read watchpoints.
5073
5074                      2.2. Otherwise, the target supports read
5075                      watchpoints, but, the user set an access or write
5076                      watchpoint watching the same memory as this read
5077                      watchpoint.
5078
5079                      If we're watching memory writes as well as reads,
5080                      ignore watchpoint hits when we find that the
5081                      value hasn't changed, as reads don't cause
5082                      changes.  This still gives false positives when
5083                      the program writes the same value to memory as
5084                      what there was already in memory (we will confuse
5085                      it for a read), but it's much better than
5086                      nothing.  */
5087
5088                   int other_write_watchpoint = 0;
5089
5090                   if (bl->watchpoint_type == hw_read)
5091                     {
5092                       struct breakpoint *other_b;
5093
5094                       ALL_BREAKPOINTS (other_b)
5095                         if (other_b->type == bp_hardware_watchpoint
5096                             || other_b->type == bp_access_watchpoint)
5097                           {
5098                             struct watchpoint *other_w =
5099                               (struct watchpoint *) other_b;
5100
5101                             if (other_w->watchpoint_triggered
5102                                 == watch_triggered_yes)
5103                               {
5104                                 other_write_watchpoint = 1;
5105                                 break;
5106                               }
5107                           }
5108                     }
5109
5110                   if (other_write_watchpoint
5111                       || bl->watchpoint_type == hw_access)
5112                     {
5113                       /* We're watching the same memory for writes,
5114                          and the value changed since the last time we
5115                          updated it, so this trap must be for a write.
5116                          Ignore it.  */
5117                       bs->print_it = print_it_noop;
5118                       bs->stop = 0;
5119                     }
5120                 }
5121               break;
5122             case WP_VALUE_NOT_CHANGED:
5123               if (b->type == bp_hardware_watchpoint
5124                   || b->type == bp_watchpoint)
5125                 {
5126                   /* Don't stop: write watchpoints shouldn't fire if
5127                      the value hasn't changed.  */
5128                   bs->print_it = print_it_noop;
5129                   bs->stop = 0;
5130                 }
5131               /* Stop.  */
5132               break;
5133             default:
5134               /* Can't happen.  */
5135               break;
5136             }
5137         }
5138       else      /* must_check_value == 0 */
5139         {
5140           /* This is a case where some watchpoint(s) triggered, but
5141              not at the address of this watchpoint, or else no
5142              watchpoint triggered after all.  So don't print
5143              anything for this watchpoint.  */
5144           bs->print_it = print_it_noop;
5145           bs->stop = 0;
5146         }
5147     }
5148 }
5149
5150 /* For breakpoints that are currently marked as telling gdb to stop,
5151    check conditions (condition proper, frame, thread and ignore count)
5152    of breakpoint referred to by BS.  If we should not stop for this
5153    breakpoint, set BS->stop to 0.  */
5154
5155 static void
5156 bpstat_check_breakpoint_conditions (bpstat bs, thread_info *thread)
5157 {
5158   const struct bp_location *bl;
5159   struct breakpoint *b;
5160   /* Assume stop.  */
5161   bool condition_result = true;
5162   struct expression *cond;
5163
5164   gdb_assert (bs->stop);
5165
5166   /* BS is built for existing struct breakpoint.  */
5167   bl = bs->bp_location_at;
5168   gdb_assert (bl != NULL);
5169   b = bs->breakpoint_at;
5170   gdb_assert (b != NULL);
5171
5172   /* Even if the target evaluated the condition on its end and notified GDB, we
5173      need to do so again since GDB does not know if we stopped due to a
5174      breakpoint or a single step breakpoint.  */
5175
5176   if (frame_id_p (b->frame_id)
5177       && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
5178     {
5179       bs->stop = 0;
5180       return;
5181     }
5182
5183   /* If this is a thread/task-specific breakpoint, don't waste cpu
5184      evaluating the condition if this isn't the specified
5185      thread/task.  */
5186   if ((b->thread != -1 && b->thread != thread->global_num)
5187       || (b->task != 0 && b->task != ada_get_task_number (thread)))
5188     {
5189       bs->stop = 0;
5190       return;
5191     }
5192
5193   /* Evaluate extension language breakpoints that have a "stop" method
5194      implemented.  */
5195   bs->stop = breakpoint_ext_lang_cond_says_stop (b);
5196
5197   if (is_watchpoint (b))
5198     {
5199       struct watchpoint *w = (struct watchpoint *) b;
5200
5201       cond = w->cond_exp.get ();
5202     }
5203   else
5204     cond = bl->cond.get ();
5205
5206   if (cond && b->disposition != disp_del_at_next_stop)
5207     {
5208       int within_current_scope = 1;
5209       struct watchpoint * w;
5210
5211       /* We use value_mark and value_free_to_mark because it could
5212          be a long time before we return to the command level and
5213          call free_all_values.  We can't call free_all_values
5214          because we might be in the middle of evaluating a
5215          function call.  */
5216       struct value *mark = value_mark ();
5217
5218       if (is_watchpoint (b))
5219         w = (struct watchpoint *) b;
5220       else
5221         w = NULL;
5222
5223       /* Need to select the frame, with all that implies so that
5224          the conditions will have the right context.  Because we
5225          use the frame, we will not see an inlined function's
5226          variables when we arrive at a breakpoint at the start
5227          of the inlined function; the current frame will be the
5228          call site.  */
5229       if (w == NULL || w->cond_exp_valid_block == NULL)
5230         select_frame (get_current_frame ());
5231       else
5232         {
5233           struct frame_info *frame;
5234
5235           /* For local watchpoint expressions, which particular
5236              instance of a local is being watched matters, so we
5237              keep track of the frame to evaluate the expression
5238              in.  To evaluate the condition however, it doesn't
5239              really matter which instantiation of the function
5240              where the condition makes sense triggers the
5241              watchpoint.  This allows an expression like "watch
5242              global if q > 10" set in `func', catch writes to
5243              global on all threads that call `func', or catch
5244              writes on all recursive calls of `func' by a single
5245              thread.  We simply always evaluate the condition in
5246              the innermost frame that's executing where it makes
5247              sense to evaluate the condition.  It seems
5248              intuitive.  */
5249           frame = block_innermost_frame (w->cond_exp_valid_block);
5250           if (frame != NULL)
5251             select_frame (frame);
5252           else
5253             within_current_scope = 0;
5254         }
5255       if (within_current_scope)
5256         {
5257           TRY
5258             {
5259               condition_result = breakpoint_cond_eval (cond);
5260             }
5261           CATCH (ex, RETURN_MASK_ALL)
5262             {
5263               exception_fprintf (gdb_stderr, ex,
5264                                  "Error in testing breakpoint condition:\n");
5265             }
5266           END_CATCH
5267         }
5268       else
5269         {
5270           warning (_("Watchpoint condition cannot be tested "
5271                      "in the current scope"));
5272           /* If we failed to set the right context for this
5273              watchpoint, unconditionally report it.  */
5274         }
5275       /* FIXME-someday, should give breakpoint #.  */
5276       value_free_to_mark (mark);
5277     }
5278
5279   if (cond && !condition_result)
5280     {
5281       bs->stop = 0;
5282     }
5283   else if (b->ignore_count > 0)
5284     {
5285       b->ignore_count--;
5286       bs->stop = 0;
5287       /* Increase the hit count even though we don't stop.  */
5288       ++(b->hit_count);
5289       gdb::observers::breakpoint_modified.notify (b);
5290     }   
5291 }
5292
5293 /* Returns true if we need to track moribund locations of LOC's type
5294    on the current target.  */
5295
5296 static int
5297 need_moribund_for_location_type (struct bp_location *loc)
5298 {
5299   return ((loc->loc_type == bp_loc_software_breakpoint
5300            && !target_supports_stopped_by_sw_breakpoint ())
5301           || (loc->loc_type == bp_loc_hardware_breakpoint
5302               && !target_supports_stopped_by_hw_breakpoint ()));
5303 }
5304
5305 /* See breakpoint.h.  */
5306
5307 bpstat
5308 build_bpstat_chain (const address_space *aspace, CORE_ADDR bp_addr,
5309                     const struct target_waitstatus *ws)
5310 {
5311   struct breakpoint *b;
5312   bpstat bs_head = NULL, *bs_link = &bs_head;
5313
5314   ALL_BREAKPOINTS (b)
5315     {
5316       if (!breakpoint_enabled (b))
5317         continue;
5318
5319       for (bp_location *bl = b->loc; bl != NULL; bl = bl->next)
5320         {
5321           /* For hardware watchpoints, we look only at the first
5322              location.  The watchpoint_check function will work on the
5323              entire expression, not the individual locations.  For
5324              read watchpoints, the watchpoints_triggered function has
5325              checked all locations already.  */
5326           if (b->type == bp_hardware_watchpoint && bl != b->loc)
5327             break;
5328
5329           if (!bl->enabled || bl->shlib_disabled)
5330             continue;
5331
5332           if (!bpstat_check_location (bl, aspace, bp_addr, ws))
5333             continue;
5334
5335           /* Come here if it's a watchpoint, or if the break address
5336              matches.  */
5337
5338           bpstat bs = new bpstats (bl, &bs_link);       /* Alloc a bpstat to
5339                                                            explain stop.  */
5340
5341           /* Assume we stop.  Should we find a watchpoint that is not
5342              actually triggered, or if the condition of the breakpoint
5343              evaluates as false, we'll reset 'stop' to 0.  */
5344           bs->stop = 1;
5345           bs->print = 1;
5346
5347           /* If this is a scope breakpoint, mark the associated
5348              watchpoint as triggered so that we will handle the
5349              out-of-scope event.  We'll get to the watchpoint next
5350              iteration.  */
5351           if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
5352             {
5353               struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5354
5355               w->watchpoint_triggered = watch_triggered_yes;
5356             }
5357         }
5358     }
5359
5360   /* Check if a moribund breakpoint explains the stop.  */
5361   if (!target_supports_stopped_by_sw_breakpoint ()
5362       || !target_supports_stopped_by_hw_breakpoint ())
5363     {
5364       for (bp_location *loc : moribund_locations)
5365         {
5366           if (breakpoint_location_address_match (loc, aspace, bp_addr)
5367               && need_moribund_for_location_type (loc))
5368             {
5369               bpstat bs = new bpstats (loc, &bs_link);
5370               /* For hits of moribund locations, we should just proceed.  */
5371               bs->stop = 0;
5372               bs->print = 0;
5373               bs->print_it = print_it_noop;
5374             }
5375         }
5376     }
5377
5378   return bs_head;
5379 }
5380
5381 /* See breakpoint.h.  */
5382
5383 bpstat
5384 bpstat_stop_status (const address_space *aspace,
5385                     CORE_ADDR bp_addr, thread_info *thread,
5386                     const struct target_waitstatus *ws,
5387                     bpstat stop_chain)
5388 {
5389   struct breakpoint *b = NULL;
5390   /* First item of allocated bpstat's.  */
5391   bpstat bs_head = stop_chain;
5392   bpstat bs;
5393   int need_remove_insert;
5394   int removed_any;
5395
5396   /* First, build the bpstat chain with locations that explain a
5397      target stop, while being careful to not set the target running,
5398      as that may invalidate locations (in particular watchpoint
5399      locations are recreated).  Resuming will happen here with
5400      breakpoint conditions or watchpoint expressions that include
5401      inferior function calls.  */
5402   if (bs_head == NULL)
5403     bs_head = build_bpstat_chain (aspace, bp_addr, ws);
5404
5405   /* A bit of special processing for shlib breakpoints.  We need to
5406      process solib loading here, so that the lists of loaded and
5407      unloaded libraries are correct before we handle "catch load" and
5408      "catch unload".  */
5409   for (bs = bs_head; bs != NULL; bs = bs->next)
5410     {
5411       if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
5412         {
5413           handle_solib_event ();
5414           break;
5415         }
5416     }
5417
5418   /* Now go through the locations that caused the target to stop, and
5419      check whether we're interested in reporting this stop to higher
5420      layers, or whether we should resume the target transparently.  */
5421
5422   removed_any = 0;
5423
5424   for (bs = bs_head; bs != NULL; bs = bs->next)
5425     {
5426       if (!bs->stop)
5427         continue;
5428
5429       b = bs->breakpoint_at;
5430       b->ops->check_status (bs);
5431       if (bs->stop)
5432         {
5433           bpstat_check_breakpoint_conditions (bs, thread);
5434
5435           if (bs->stop)
5436             {
5437               ++(b->hit_count);
5438               gdb::observers::breakpoint_modified.notify (b);
5439
5440               /* We will stop here.  */
5441               if (b->disposition == disp_disable)
5442                 {
5443                   --(b->enable_count);
5444                   if (b->enable_count <= 0)
5445                     b->enable_state = bp_disabled;
5446                   removed_any = 1;
5447                 }
5448               if (b->silent)
5449                 bs->print = 0;
5450               bs->commands = b->commands;
5451               if (command_line_is_silent (bs->commands
5452                                           ? bs->commands.get () : NULL))
5453                 bs->print = 0;
5454
5455               b->ops->after_condition_true (bs);
5456             }
5457
5458         }
5459
5460       /* Print nothing for this entry if we don't stop or don't
5461          print.  */
5462       if (!bs->stop || !bs->print)
5463         bs->print_it = print_it_noop;
5464     }
5465
5466   /* If we aren't stopping, the value of some hardware watchpoint may
5467      not have changed, but the intermediate memory locations we are
5468      watching may have.  Don't bother if we're stopping; this will get
5469      done later.  */
5470   need_remove_insert = 0;
5471   if (! bpstat_causes_stop (bs_head))
5472     for (bs = bs_head; bs != NULL; bs = bs->next)
5473       if (!bs->stop
5474           && bs->breakpoint_at
5475           && is_hardware_watchpoint (bs->breakpoint_at))
5476         {
5477           struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5478
5479           update_watchpoint (w, 0 /* don't reparse.  */);
5480           need_remove_insert = 1;
5481         }
5482
5483   if (need_remove_insert)
5484     update_global_location_list (UGLL_MAY_INSERT);
5485   else if (removed_any)
5486     update_global_location_list (UGLL_DONT_INSERT);
5487
5488   return bs_head;
5489 }
5490
5491 static void
5492 handle_jit_event (void)
5493 {
5494   struct frame_info *frame;
5495   struct gdbarch *gdbarch;
5496
5497   if (debug_infrun)
5498     fprintf_unfiltered (gdb_stdlog, "handling bp_jit_event\n");
5499
5500   /* Switch terminal for any messages produced by
5501      breakpoint_re_set.  */
5502   target_terminal::ours_for_output ();
5503
5504   frame = get_current_frame ();
5505   gdbarch = get_frame_arch (frame);
5506
5507   jit_event_handler (gdbarch);
5508
5509   target_terminal::inferior ();
5510 }
5511
5512 /* Prepare WHAT final decision for infrun.  */
5513
5514 /* Decide what infrun needs to do with this bpstat.  */
5515
5516 struct bpstat_what
5517 bpstat_what (bpstat bs_head)
5518 {
5519   struct bpstat_what retval;
5520   bpstat bs;
5521
5522   retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
5523   retval.call_dummy = STOP_NONE;
5524   retval.is_longjmp = 0;
5525
5526   for (bs = bs_head; bs != NULL; bs = bs->next)
5527     {
5528       /* Extract this BS's action.  After processing each BS, we check
5529          if its action overrides all we've seem so far.  */
5530       enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5531       enum bptype bptype;
5532
5533       if (bs->breakpoint_at == NULL)
5534         {
5535           /* I suspect this can happen if it was a momentary
5536              breakpoint which has since been deleted.  */
5537           bptype = bp_none;
5538         }
5539       else
5540         bptype = bs->breakpoint_at->type;
5541
5542       switch (bptype)
5543         {
5544         case bp_none:
5545           break;
5546         case bp_breakpoint:
5547         case bp_hardware_breakpoint:
5548         case bp_single_step:
5549         case bp_until:
5550         case bp_finish:
5551         case bp_shlib_event:
5552           if (bs->stop)
5553             {
5554               if (bs->print)
5555                 this_action = BPSTAT_WHAT_STOP_NOISY;
5556               else
5557                 this_action = BPSTAT_WHAT_STOP_SILENT;
5558             }
5559           else
5560             this_action = BPSTAT_WHAT_SINGLE;
5561           break;
5562         case bp_watchpoint:
5563         case bp_hardware_watchpoint:
5564         case bp_read_watchpoint:
5565         case bp_access_watchpoint:
5566           if (bs->stop)
5567             {
5568               if (bs->print)
5569                 this_action = BPSTAT_WHAT_STOP_NOISY;
5570               else
5571                 this_action = BPSTAT_WHAT_STOP_SILENT;
5572             }
5573           else
5574             {
5575               /* There was a watchpoint, but we're not stopping.
5576                  This requires no further action.  */
5577             }
5578           break;
5579         case bp_longjmp:
5580         case bp_longjmp_call_dummy:
5581         case bp_exception:
5582           if (bs->stop)
5583             {
5584               this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5585               retval.is_longjmp = bptype != bp_exception;
5586             }
5587           else
5588             this_action = BPSTAT_WHAT_SINGLE;
5589           break;
5590         case bp_longjmp_resume:
5591         case bp_exception_resume:
5592           if (bs->stop)
5593             {
5594               this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5595               retval.is_longjmp = bptype == bp_longjmp_resume;
5596             }
5597           else
5598             this_action = BPSTAT_WHAT_SINGLE;
5599           break;
5600         case bp_step_resume:
5601           if (bs->stop)
5602             this_action = BPSTAT_WHAT_STEP_RESUME;
5603           else
5604             {
5605               /* It is for the wrong frame.  */
5606               this_action = BPSTAT_WHAT_SINGLE;
5607             }
5608           break;
5609         case bp_hp_step_resume:
5610           if (bs->stop)
5611             this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5612           else
5613             {
5614               /* It is for the wrong frame.  */
5615               this_action = BPSTAT_WHAT_SINGLE;
5616             }
5617           break;
5618         case bp_watchpoint_scope:
5619         case bp_thread_event:
5620         case bp_overlay_event:
5621         case bp_longjmp_master:
5622         case bp_std_terminate_master:
5623         case bp_exception_master:
5624           this_action = BPSTAT_WHAT_SINGLE;
5625           break;
5626         case bp_catchpoint:
5627           if (bs->stop)
5628             {
5629               if (bs->print)
5630                 this_action = BPSTAT_WHAT_STOP_NOISY;
5631               else
5632                 this_action = BPSTAT_WHAT_STOP_SILENT;
5633             }
5634           else
5635             {
5636               /* There was a catchpoint, but we're not stopping.
5637                  This requires no further action.  */
5638             }
5639           break;
5640         case bp_jit_event:
5641           this_action = BPSTAT_WHAT_SINGLE;
5642           break;
5643         case bp_call_dummy:
5644           /* Make sure the action is stop (silent or noisy),
5645              so infrun.c pops the dummy frame.  */
5646           retval.call_dummy = STOP_STACK_DUMMY;
5647           this_action = BPSTAT_WHAT_STOP_SILENT;
5648           break;
5649         case bp_std_terminate:
5650           /* Make sure the action is stop (silent or noisy),
5651              so infrun.c pops the dummy frame.  */
5652           retval.call_dummy = STOP_STD_TERMINATE;
5653           this_action = BPSTAT_WHAT_STOP_SILENT;
5654           break;
5655         case bp_tracepoint:
5656         case bp_fast_tracepoint:
5657         case bp_static_tracepoint:
5658           /* Tracepoint hits should not be reported back to GDB, and
5659              if one got through somehow, it should have been filtered
5660              out already.  */
5661           internal_error (__FILE__, __LINE__,
5662                           _("bpstat_what: tracepoint encountered"));
5663           break;
5664         case bp_gnu_ifunc_resolver:
5665           /* Step over it (and insert bp_gnu_ifunc_resolver_return).  */
5666           this_action = BPSTAT_WHAT_SINGLE;
5667           break;
5668         case bp_gnu_ifunc_resolver_return:
5669           /* The breakpoint will be removed, execution will restart from the
5670              PC of the former breakpoint.  */
5671           this_action = BPSTAT_WHAT_KEEP_CHECKING;
5672           break;
5673
5674         case bp_dprintf:
5675           if (bs->stop)
5676             this_action = BPSTAT_WHAT_STOP_SILENT;
5677           else
5678             this_action = BPSTAT_WHAT_SINGLE;
5679           break;
5680
5681         default:
5682           internal_error (__FILE__, __LINE__,
5683                           _("bpstat_what: unhandled bptype %d"), (int) bptype);
5684         }
5685
5686       retval.main_action = std::max (retval.main_action, this_action);
5687     }
5688
5689   return retval;
5690 }
5691
5692 void
5693 bpstat_run_callbacks (bpstat bs_head)
5694 {
5695   bpstat bs;
5696
5697   for (bs = bs_head; bs != NULL; bs = bs->next)
5698     {
5699       struct breakpoint *b = bs->breakpoint_at;
5700
5701       if (b == NULL)
5702         continue;
5703       switch (b->type)
5704         {
5705         case bp_jit_event:
5706           handle_jit_event ();
5707           break;
5708         case bp_gnu_ifunc_resolver:
5709           gnu_ifunc_resolver_stop (b);
5710           break;
5711         case bp_gnu_ifunc_resolver_return:
5712           gnu_ifunc_resolver_return_stop (b);
5713           break;
5714         }
5715     }
5716 }
5717
5718 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5719    without hardware support).  This isn't related to a specific bpstat,
5720    just to things like whether watchpoints are set.  */
5721
5722 int
5723 bpstat_should_step (void)
5724 {
5725   struct breakpoint *b;
5726
5727   ALL_BREAKPOINTS (b)
5728     if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
5729       return 1;
5730   return 0;
5731 }
5732
5733 int
5734 bpstat_causes_stop (bpstat bs)
5735 {
5736   for (; bs != NULL; bs = bs->next)
5737     if (bs->stop)
5738       return 1;
5739
5740   return 0;
5741 }
5742
5743 \f
5744
5745 /* Compute a string of spaces suitable to indent the next line
5746    so it starts at the position corresponding to the table column
5747    named COL_NAME in the currently active table of UIOUT.  */
5748
5749 static char *
5750 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
5751 {
5752   static char wrap_indent[80];
5753   int i, total_width, width, align;
5754   const char *text;
5755
5756   total_width = 0;
5757   for (i = 1; uiout->query_table_field (i, &width, &align, &text); i++)
5758     {
5759       if (strcmp (text, col_name) == 0)
5760         {
5761           gdb_assert (total_width < sizeof wrap_indent);
5762           memset (wrap_indent, ' ', total_width);
5763           wrap_indent[total_width] = 0;
5764
5765           return wrap_indent;
5766         }
5767
5768       total_width += width + 1;
5769     }
5770
5771   return NULL;
5772 }
5773
5774 /* Determine if the locations of this breakpoint will have their conditions
5775    evaluated by the target, host or a mix of both.  Returns the following:
5776
5777     "host": Host evals condition.
5778     "host or target": Host or Target evals condition.
5779     "target": Target evals condition.
5780 */
5781
5782 static const char *
5783 bp_condition_evaluator (struct breakpoint *b)
5784 {
5785   struct bp_location *bl;
5786   char host_evals = 0;
5787   char target_evals = 0;
5788
5789   if (!b)
5790     return NULL;
5791
5792   if (!is_breakpoint (b))
5793     return NULL;
5794
5795   if (gdb_evaluates_breakpoint_condition_p ()
5796       || !target_supports_evaluation_of_breakpoint_conditions ())
5797     return condition_evaluation_host;
5798
5799   for (bl = b->loc; bl; bl = bl->next)
5800     {
5801       if (bl->cond_bytecode)
5802         target_evals++;
5803       else
5804         host_evals++;
5805     }
5806
5807   if (host_evals && target_evals)
5808     return condition_evaluation_both;
5809   else if (target_evals)
5810     return condition_evaluation_target;
5811   else
5812     return condition_evaluation_host;
5813 }
5814
5815 /* Determine the breakpoint location's condition evaluator.  This is
5816    similar to bp_condition_evaluator, but for locations.  */
5817
5818 static const char *
5819 bp_location_condition_evaluator (struct bp_location *bl)
5820 {
5821   if (bl && !is_breakpoint (bl->owner))
5822     return NULL;
5823
5824   if (gdb_evaluates_breakpoint_condition_p ()
5825       || !target_supports_evaluation_of_breakpoint_conditions ())
5826     return condition_evaluation_host;
5827
5828   if (bl && bl->cond_bytecode)
5829     return condition_evaluation_target;
5830   else
5831     return condition_evaluation_host;
5832 }
5833
5834 /* Print the LOC location out of the list of B->LOC locations.  */
5835
5836 static void
5837 print_breakpoint_location (struct breakpoint *b,
5838                            struct bp_location *loc)
5839 {
5840   struct ui_out *uiout = current_uiout;
5841
5842   scoped_restore_current_program_space restore_pspace;
5843
5844   if (loc != NULL && loc->shlib_disabled)
5845     loc = NULL;
5846
5847   if (loc != NULL)
5848     set_current_program_space (loc->pspace);
5849
5850   if (b->display_canonical)
5851     uiout->field_string ("what", event_location_to_string (b->location.get ()));
5852   else if (loc && loc->symtab)
5853     {
5854       const struct symbol *sym = loc->symbol;
5855
5856       if (sym)
5857         {
5858           uiout->text ("in ");
5859           uiout->field_string ("func", SYMBOL_PRINT_NAME (sym),
5860                                ui_out_style_kind::FUNCTION);
5861           uiout->text (" ");
5862           uiout->wrap_hint (wrap_indent_at_field (uiout, "what"));
5863           uiout->text ("at ");
5864         }
5865       uiout->field_string ("file",
5866                            symtab_to_filename_for_display (loc->symtab),
5867                            ui_out_style_kind::FILE);
5868       uiout->text (":");
5869
5870       if (uiout->is_mi_like_p ())
5871         uiout->field_string ("fullname", symtab_to_fullname (loc->symtab));
5872       
5873       uiout->field_int ("line", loc->line_number);
5874     }
5875   else if (loc)
5876     {
5877       string_file stb;
5878
5879       print_address_symbolic (loc->gdbarch, loc->address, &stb,
5880                               demangle, "");
5881       uiout->field_stream ("at", stb);
5882     }
5883   else
5884     {
5885       uiout->field_string ("pending",
5886                            event_location_to_string (b->location.get ()));
5887       /* If extra_string is available, it could be holding a condition
5888          or dprintf arguments.  In either case, make sure it is printed,
5889          too, but only for non-MI streams.  */
5890       if (!uiout->is_mi_like_p () && b->extra_string != NULL)
5891         {
5892           if (b->type == bp_dprintf)
5893             uiout->text (",");
5894           else
5895             uiout->text (" ");
5896           uiout->text (b->extra_string);
5897         }
5898     }
5899
5900   if (loc && is_breakpoint (b)
5901       && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5902       && bp_condition_evaluator (b) == condition_evaluation_both)
5903     {
5904       uiout->text (" (");
5905       uiout->field_string ("evaluated-by",
5906                            bp_location_condition_evaluator (loc));
5907       uiout->text (")");
5908     }
5909 }
5910
5911 static const char *
5912 bptype_string (enum bptype type)
5913 {
5914   struct ep_type_description
5915     {
5916       enum bptype type;
5917       const char *description;
5918     };
5919   static struct ep_type_description bptypes[] =
5920   {
5921     {bp_none, "?deleted?"},
5922     {bp_breakpoint, "breakpoint"},
5923     {bp_hardware_breakpoint, "hw breakpoint"},
5924     {bp_single_step, "sw single-step"},
5925     {bp_until, "until"},
5926     {bp_finish, "finish"},
5927     {bp_watchpoint, "watchpoint"},
5928     {bp_hardware_watchpoint, "hw watchpoint"},
5929     {bp_read_watchpoint, "read watchpoint"},
5930     {bp_access_watchpoint, "acc watchpoint"},
5931     {bp_longjmp, "longjmp"},
5932     {bp_longjmp_resume, "longjmp resume"},
5933     {bp_longjmp_call_dummy, "longjmp for call dummy"},
5934     {bp_exception, "exception"},
5935     {bp_exception_resume, "exception resume"},
5936     {bp_step_resume, "step resume"},
5937     {bp_hp_step_resume, "high-priority step resume"},
5938     {bp_watchpoint_scope, "watchpoint scope"},
5939     {bp_call_dummy, "call dummy"},
5940     {bp_std_terminate, "std::terminate"},
5941     {bp_shlib_event, "shlib events"},
5942     {bp_thread_event, "thread events"},
5943     {bp_overlay_event, "overlay events"},
5944     {bp_longjmp_master, "longjmp master"},
5945     {bp_std_terminate_master, "std::terminate master"},
5946     {bp_exception_master, "exception master"},
5947     {bp_catchpoint, "catchpoint"},
5948     {bp_tracepoint, "tracepoint"},
5949     {bp_fast_tracepoint, "fast tracepoint"},
5950     {bp_static_tracepoint, "static tracepoint"},
5951     {bp_dprintf, "dprintf"},
5952     {bp_jit_event, "jit events"},
5953     {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
5954     {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
5955   };
5956
5957   if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
5958       || ((int) type != bptypes[(int) type].type))
5959     internal_error (__FILE__, __LINE__,
5960                     _("bptypes table does not describe type #%d."),
5961                     (int) type);
5962
5963   return bptypes[(int) type].description;
5964 }
5965
5966 /* For MI, output a field named 'thread-groups' with a list as the value.
5967    For CLI, prefix the list with the string 'inf'. */
5968
5969 static void
5970 output_thread_groups (struct ui_out *uiout,
5971                       const char *field_name,
5972                       const std::vector<int> &inf_nums,
5973                       int mi_only)
5974 {
5975   int is_mi = uiout->is_mi_like_p ();
5976
5977   /* For backward compatibility, don't display inferiors in CLI unless
5978      there are several.  Always display them for MI. */
5979   if (!is_mi && mi_only)
5980     return;
5981
5982   ui_out_emit_list list_emitter (uiout, field_name);
5983
5984   for (size_t i = 0; i < inf_nums.size (); i++)
5985     {
5986       if (is_mi)
5987         {
5988           char mi_group[10];
5989
5990           xsnprintf (mi_group, sizeof (mi_group), "i%d", inf_nums[i]);
5991           uiout->field_string (NULL, mi_group);
5992         }
5993       else
5994         {
5995           if (i == 0)
5996             uiout->text (" inf ");
5997           else
5998             uiout->text (", ");
5999         
6000           uiout->text (plongest (inf_nums[i]));
6001         }
6002     }
6003 }
6004
6005 /* Print B to gdb_stdout.  */
6006
6007 static void
6008 print_one_breakpoint_location (struct breakpoint *b,
6009                                struct bp_location *loc,
6010                                int loc_number,
6011                                struct bp_location **last_loc,
6012                                int allflag)
6013 {
6014   struct command_line *l;
6015   static char bpenables[] = "nynny";
6016
6017   struct ui_out *uiout = current_uiout;
6018   int header_of_multiple = 0;
6019   int part_of_multiple = (loc != NULL);
6020   struct value_print_options opts;
6021
6022   get_user_print_options (&opts);
6023
6024   gdb_assert (!loc || loc_number != 0);
6025   /* See comment in print_one_breakpoint concerning treatment of
6026      breakpoints with single disabled location.  */
6027   if (loc == NULL 
6028       && (b->loc != NULL 
6029           && (b->loc->next != NULL || !b->loc->enabled)))
6030     header_of_multiple = 1;
6031   if (loc == NULL)
6032     loc = b->loc;
6033
6034   annotate_record ();
6035
6036   /* 1 */
6037   annotate_field (0);
6038   if (part_of_multiple)
6039     uiout->field_fmt ("number", "%d.%d", b->number, loc_number);
6040   else
6041     uiout->field_int ("number", b->number);
6042
6043   /* 2 */
6044   annotate_field (1);
6045   if (part_of_multiple)
6046     uiout->field_skip ("type");
6047   else
6048     uiout->field_string ("type", bptype_string (b->type));
6049
6050   /* 3 */
6051   annotate_field (2);
6052   if (part_of_multiple)
6053     uiout->field_skip ("disp");
6054   else
6055     uiout->field_string ("disp", bpdisp_text (b->disposition));
6056
6057   /* 4 */
6058   annotate_field (3);
6059   if (part_of_multiple)
6060     uiout->field_string ("enabled", loc->enabled ? "y" : "n");
6061   else
6062     uiout->field_fmt ("enabled", "%c", bpenables[(int) b->enable_state]);
6063
6064   /* 5 and 6 */
6065   if (b->ops != NULL && b->ops->print_one != NULL)
6066     {
6067       /* Although the print_one can possibly print all locations,
6068          calling it here is not likely to get any nice result.  So,
6069          make sure there's just one location.  */
6070       gdb_assert (b->loc == NULL || b->loc->next == NULL);
6071       b->ops->print_one (b, last_loc);
6072     }
6073   else
6074     switch (b->type)
6075       {
6076       case bp_none:
6077         internal_error (__FILE__, __LINE__,
6078                         _("print_one_breakpoint: bp_none encountered\n"));
6079         break;
6080
6081       case bp_watchpoint:
6082       case bp_hardware_watchpoint:
6083       case bp_read_watchpoint:
6084       case bp_access_watchpoint:
6085         {
6086           struct watchpoint *w = (struct watchpoint *) b;
6087
6088           /* Field 4, the address, is omitted (which makes the columns
6089              not line up too nicely with the headers, but the effect
6090              is relatively readable).  */
6091           if (opts.addressprint)
6092             uiout->field_skip ("addr");
6093           annotate_field (5);
6094           uiout->field_string ("what", w->exp_string);
6095         }
6096         break;
6097
6098       case bp_breakpoint:
6099       case bp_hardware_breakpoint:
6100       case bp_single_step:
6101       case bp_until:
6102       case bp_finish:
6103       case bp_longjmp:
6104       case bp_longjmp_resume:
6105       case bp_longjmp_call_dummy:
6106       case bp_exception:
6107       case bp_exception_resume:
6108       case bp_step_resume:
6109       case bp_hp_step_resume:
6110       case bp_watchpoint_scope:
6111       case bp_call_dummy:
6112       case bp_std_terminate:
6113       case bp_shlib_event:
6114       case bp_thread_event:
6115       case bp_overlay_event:
6116       case bp_longjmp_master:
6117       case bp_std_terminate_master:
6118       case bp_exception_master:
6119       case bp_tracepoint:
6120       case bp_fast_tracepoint:
6121       case bp_static_tracepoint:
6122       case bp_dprintf:
6123       case bp_jit_event:
6124       case bp_gnu_ifunc_resolver:
6125       case bp_gnu_ifunc_resolver_return:
6126         if (opts.addressprint)
6127           {
6128             annotate_field (4);
6129             if (header_of_multiple)
6130               uiout->field_string ("addr", "<MULTIPLE>");
6131             else if (b->loc == NULL || loc->shlib_disabled)
6132               uiout->field_string ("addr", "<PENDING>");
6133             else
6134               uiout->field_core_addr ("addr",
6135                                       loc->gdbarch, loc->address);
6136           }
6137         annotate_field (5);
6138         if (!header_of_multiple)
6139           print_breakpoint_location (b, loc);
6140         if (b->loc)
6141           *last_loc = b->loc;
6142         break;
6143       }
6144
6145
6146   if (loc != NULL && !header_of_multiple)
6147     {
6148       std::vector<int> inf_nums;
6149       int mi_only = 1;
6150
6151       for (inferior *inf : all_inferiors ())
6152         {
6153           if (inf->pspace == loc->pspace)
6154             inf_nums.push_back (inf->num);
6155         }
6156
6157         /* For backward compatibility, don't display inferiors in CLI unless
6158            there are several.  Always display for MI. */
6159         if (allflag
6160             || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6161                 && (number_of_program_spaces () > 1
6162                     || number_of_inferiors () > 1)
6163                 /* LOC is for existing B, it cannot be in
6164                    moribund_locations and thus having NULL OWNER.  */
6165                 && loc->owner->type != bp_catchpoint))
6166         mi_only = 0;
6167       output_thread_groups (uiout, "thread-groups", inf_nums, mi_only);
6168     }
6169
6170   if (!part_of_multiple)
6171     {
6172       if (b->thread != -1)
6173         {
6174           /* FIXME: This seems to be redundant and lost here; see the
6175              "stop only in" line a little further down.  */
6176           uiout->text (" thread ");
6177           uiout->field_int ("thread", b->thread);
6178         }
6179       else if (b->task != 0)
6180         {
6181           uiout->text (" task ");
6182           uiout->field_int ("task", b->task);
6183         }
6184     }
6185
6186   uiout->text ("\n");
6187
6188   if (!part_of_multiple)
6189     b->ops->print_one_detail (b, uiout);
6190
6191   if (part_of_multiple && frame_id_p (b->frame_id))
6192     {
6193       annotate_field (6);
6194       uiout->text ("\tstop only in stack frame at ");
6195       /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6196          the frame ID.  */
6197       uiout->field_core_addr ("frame",
6198                               b->gdbarch, b->frame_id.stack_addr);
6199       uiout->text ("\n");
6200     }
6201   
6202   if (!part_of_multiple && b->cond_string)
6203     {
6204       annotate_field (7);
6205       if (is_tracepoint (b))
6206         uiout->text ("\ttrace only if ");
6207       else
6208         uiout->text ("\tstop only if ");
6209       uiout->field_string ("cond", b->cond_string);
6210
6211       /* Print whether the target is doing the breakpoint's condition
6212          evaluation.  If GDB is doing the evaluation, don't print anything.  */
6213       if (is_breakpoint (b)
6214           && breakpoint_condition_evaluation_mode ()
6215           == condition_evaluation_target)
6216         {
6217           uiout->text (" (");
6218           uiout->field_string ("evaluated-by",
6219                                bp_condition_evaluator (b));
6220           uiout->text (" evals)");
6221         }
6222       uiout->text ("\n");
6223     }
6224
6225   if (!part_of_multiple && b->thread != -1)
6226     {
6227       /* FIXME should make an annotation for this.  */
6228       uiout->text ("\tstop only in thread ");
6229       if (uiout->is_mi_like_p ())
6230         uiout->field_int ("thread", b->thread);
6231       else
6232         {
6233           struct thread_info *thr = find_thread_global_id (b->thread);
6234
6235           uiout->field_string ("thread", print_thread_id (thr));
6236         }
6237       uiout->text ("\n");
6238     }
6239   
6240   if (!part_of_multiple)
6241     {
6242       if (b->hit_count)
6243         {
6244           /* FIXME should make an annotation for this.  */
6245           if (is_catchpoint (b))
6246             uiout->text ("\tcatchpoint");
6247           else if (is_tracepoint (b))
6248             uiout->text ("\ttracepoint");
6249           else
6250             uiout->text ("\tbreakpoint");
6251           uiout->text (" already hit ");
6252           uiout->field_int ("times", b->hit_count);
6253           if (b->hit_count == 1)
6254             uiout->text (" time\n");
6255           else
6256             uiout->text (" times\n");
6257         }
6258       else
6259         {
6260           /* Output the count also if it is zero, but only if this is mi.  */
6261           if (uiout->is_mi_like_p ())
6262             uiout->field_int ("times", b->hit_count);
6263         }
6264     }
6265
6266   if (!part_of_multiple && b->ignore_count)
6267     {
6268       annotate_field (8);
6269       uiout->text ("\tignore next ");
6270       uiout->field_int ("ignore", b->ignore_count);
6271       uiout->text (" hits\n");
6272     }
6273
6274   /* Note that an enable count of 1 corresponds to "enable once"
6275      behavior, which is reported by the combination of enablement and
6276      disposition, so we don't need to mention it here.  */
6277   if (!part_of_multiple && b->enable_count > 1)
6278     {
6279       annotate_field (8);
6280       uiout->text ("\tdisable after ");
6281       /* Tweak the wording to clarify that ignore and enable counts
6282          are distinct, and have additive effect.  */
6283       if (b->ignore_count)
6284         uiout->text ("additional ");
6285       else
6286         uiout->text ("next ");
6287       uiout->field_int ("enable", b->enable_count);
6288       uiout->text (" hits\n");
6289     }
6290
6291   if (!part_of_multiple && is_tracepoint (b))
6292     {
6293       struct tracepoint *tp = (struct tracepoint *) b;
6294
6295       if (tp->traceframe_usage)
6296         {
6297           uiout->text ("\ttrace buffer usage ");
6298           uiout->field_int ("traceframe-usage", tp->traceframe_usage);
6299           uiout->text (" bytes\n");
6300         }
6301     }
6302
6303   l = b->commands ? b->commands.get () : NULL;
6304   if (!part_of_multiple && l)
6305     {
6306       annotate_field (9);
6307       ui_out_emit_tuple tuple_emitter (uiout, "script");
6308       print_command_lines (uiout, l, 4);
6309     }
6310
6311   if (is_tracepoint (b))
6312     {
6313       struct tracepoint *t = (struct tracepoint *) b;
6314
6315       if (!part_of_multiple && t->pass_count)
6316         {
6317           annotate_field (10);
6318           uiout->text ("\tpass count ");
6319           uiout->field_int ("pass", t->pass_count);
6320           uiout->text (" \n");
6321         }
6322
6323       /* Don't display it when tracepoint or tracepoint location is
6324          pending.   */
6325       if (!header_of_multiple && loc != NULL && !loc->shlib_disabled)
6326         {
6327           annotate_field (11);
6328
6329           if (uiout->is_mi_like_p ())
6330             uiout->field_string ("installed",
6331                                  loc->inserted ? "y" : "n");
6332           else
6333             {
6334               if (loc->inserted)
6335                 uiout->text ("\t");
6336               else
6337                 uiout->text ("\tnot ");
6338               uiout->text ("installed on target\n");
6339             }
6340         }
6341     }
6342
6343   if (uiout->is_mi_like_p () && !part_of_multiple)
6344     {
6345       if (is_watchpoint (b))
6346         {
6347           struct watchpoint *w = (struct watchpoint *) b;
6348
6349           uiout->field_string ("original-location", w->exp_string);
6350         }
6351       else if (b->location != NULL
6352                && event_location_to_string (b->location.get ()) != NULL)
6353         uiout->field_string ("original-location",
6354                              event_location_to_string (b->location.get ()));
6355     }
6356 }
6357
6358 static void
6359 print_one_breakpoint (struct breakpoint *b,
6360                       struct bp_location **last_loc, 
6361                       int allflag)
6362 {
6363   struct ui_out *uiout = current_uiout;
6364
6365   {
6366     ui_out_emit_tuple tuple_emitter (uiout, "bkpt");
6367
6368     print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
6369   }
6370
6371   /* If this breakpoint has custom print function,
6372      it's already printed.  Otherwise, print individual
6373      locations, if any.  */
6374   if (b->ops == NULL || b->ops->print_one == NULL)
6375     {
6376       /* If breakpoint has a single location that is disabled, we
6377          print it as if it had several locations, since otherwise it's
6378          hard to represent "breakpoint enabled, location disabled"
6379          situation.
6380
6381          Note that while hardware watchpoints have several locations
6382          internally, that's not a property exposed to user.  */
6383       if (b->loc 
6384           && !is_hardware_watchpoint (b)
6385           && (b->loc->next || !b->loc->enabled))
6386         {
6387           struct bp_location *loc;
6388           int n = 1;
6389
6390           for (loc = b->loc; loc; loc = loc->next, ++n)
6391             {
6392               ui_out_emit_tuple tuple_emitter (uiout, NULL);
6393               print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6394             }
6395         }
6396     }
6397 }
6398
6399 static int
6400 breakpoint_address_bits (struct breakpoint *b)
6401 {
6402   int print_address_bits = 0;
6403   struct bp_location *loc;
6404
6405   /* Software watchpoints that aren't watching memory don't have an
6406      address to print.  */
6407   if (is_no_memory_software_watchpoint (b))
6408     return 0;
6409
6410   for (loc = b->loc; loc; loc = loc->next)
6411     {
6412       int addr_bit;
6413
6414       addr_bit = gdbarch_addr_bit (loc->gdbarch);
6415       if (addr_bit > print_address_bits)
6416         print_address_bits = addr_bit;
6417     }
6418
6419   return print_address_bits;
6420 }
6421
6422 /* See breakpoint.h.  */
6423
6424 void
6425 print_breakpoint (breakpoint *b)
6426 {
6427   struct bp_location *dummy_loc = NULL;
6428   print_one_breakpoint (b, &dummy_loc, 0);
6429 }
6430
6431 /* Return true if this breakpoint was set by the user, false if it is
6432    internal or momentary.  */
6433
6434 int
6435 user_breakpoint_p (struct breakpoint *b)
6436 {
6437   return b->number > 0;
6438 }
6439
6440 /* See breakpoint.h.  */
6441
6442 int
6443 pending_breakpoint_p (struct breakpoint *b)
6444 {
6445   return b->loc == NULL;
6446 }
6447
6448 /* Print information on user settable breakpoint (watchpoint, etc)
6449    number BNUM.  If BNUM is -1 print all user-settable breakpoints.
6450    If ALLFLAG is non-zero, include non-user-settable breakpoints.  If
6451    FILTER is non-NULL, call it on each breakpoint and only include the
6452    ones for which it returns non-zero.  Return the total number of
6453    breakpoints listed.  */
6454
6455 static int
6456 breakpoint_1 (const char *args, int allflag, 
6457               int (*filter) (const struct breakpoint *))
6458 {
6459   struct breakpoint *b;
6460   struct bp_location *last_loc = NULL;
6461   int nr_printable_breakpoints;
6462   struct value_print_options opts;
6463   int print_address_bits = 0;
6464   int print_type_col_width = 14;
6465   struct ui_out *uiout = current_uiout;
6466
6467   get_user_print_options (&opts);
6468
6469   /* Compute the number of rows in the table, as well as the size
6470      required for address fields.  */
6471   nr_printable_breakpoints = 0;
6472   ALL_BREAKPOINTS (b)
6473     {
6474       /* If we have a filter, only list the breakpoints it accepts.  */
6475       if (filter && !filter (b))
6476         continue;
6477
6478       /* If we have an "args" string, it is a list of breakpoints to 
6479          accept.  Skip the others.  */
6480       if (args != NULL && *args != '\0')
6481         {
6482           if (allflag && parse_and_eval_long (args) != b->number)
6483             continue;
6484           if (!allflag && !number_is_in_list (args, b->number))
6485             continue;
6486         }
6487
6488       if (allflag || user_breakpoint_p (b))
6489         {
6490           int addr_bit, type_len;
6491
6492           addr_bit = breakpoint_address_bits (b);
6493           if (addr_bit > print_address_bits)
6494             print_address_bits = addr_bit;
6495
6496           type_len = strlen (bptype_string (b->type));
6497           if (type_len > print_type_col_width)
6498             print_type_col_width = type_len;
6499
6500           nr_printable_breakpoints++;
6501         }
6502     }
6503
6504   {
6505     ui_out_emit_table table_emitter (uiout,
6506                                      opts.addressprint ? 6 : 5,
6507                                      nr_printable_breakpoints,
6508                                      "BreakpointTable");
6509
6510     if (nr_printable_breakpoints > 0)
6511       annotate_breakpoints_headers ();
6512     if (nr_printable_breakpoints > 0)
6513       annotate_field (0);
6514     uiout->table_header (7, ui_left, "number", "Num"); /* 1 */
6515     if (nr_printable_breakpoints > 0)
6516       annotate_field (1);
6517     uiout->table_header (print_type_col_width, ui_left, "type", "Type"); /* 2 */
6518     if (nr_printable_breakpoints > 0)
6519       annotate_field (2);
6520     uiout->table_header (4, ui_left, "disp", "Disp"); /* 3 */
6521     if (nr_printable_breakpoints > 0)
6522       annotate_field (3);
6523     uiout->table_header (3, ui_left, "enabled", "Enb"); /* 4 */
6524     if (opts.addressprint)
6525       {
6526         if (nr_printable_breakpoints > 0)
6527           annotate_field (4);
6528         if (print_address_bits <= 32)
6529           uiout->table_header (10, ui_left, "addr", "Address"); /* 5 */
6530         else
6531           uiout->table_header (18, ui_left, "addr", "Address"); /* 5 */
6532       }
6533     if (nr_printable_breakpoints > 0)
6534       annotate_field (5);
6535     uiout->table_header (40, ui_noalign, "what", "What"); /* 6 */
6536     uiout->table_body ();
6537     if (nr_printable_breakpoints > 0)
6538       annotate_breakpoints_table ();
6539
6540     ALL_BREAKPOINTS (b)
6541       {
6542         QUIT;
6543         /* If we have a filter, only list the breakpoints it accepts.  */
6544         if (filter && !filter (b))
6545           continue;
6546
6547         /* If we have an "args" string, it is a list of breakpoints to 
6548            accept.  Skip the others.  */
6549
6550         if (args != NULL && *args != '\0')
6551           {
6552             if (allflag)        /* maintenance info breakpoint */
6553               {
6554                 if (parse_and_eval_long (args) != b->number)
6555                   continue;
6556               }
6557             else                /* all others */
6558               {
6559                 if (!number_is_in_list (args, b->number))
6560                   continue;
6561               }
6562           }
6563         /* We only print out user settable breakpoints unless the
6564            allflag is set.  */
6565         if (allflag || user_breakpoint_p (b))
6566           print_one_breakpoint (b, &last_loc, allflag);
6567       }
6568   }
6569
6570   if (nr_printable_breakpoints == 0)
6571     {
6572       /* If there's a filter, let the caller decide how to report
6573          empty list.  */
6574       if (!filter)
6575         {
6576           if (args == NULL || *args == '\0')
6577             uiout->message ("No breakpoints or watchpoints.\n");
6578           else
6579             uiout->message ("No breakpoint or watchpoint matching '%s'.\n",
6580                             args);
6581         }
6582     }
6583   else
6584     {
6585       if (last_loc && !server_command)
6586         set_next_address (last_loc->gdbarch, last_loc->address);
6587     }
6588
6589   /* FIXME?  Should this be moved up so that it is only called when
6590      there have been breakpoints? */
6591   annotate_breakpoints_table_end ();
6592
6593   return nr_printable_breakpoints;
6594 }
6595
6596 /* Display the value of default-collect in a way that is generally
6597    compatible with the breakpoint list.  */
6598
6599 static void
6600 default_collect_info (void)
6601 {
6602   struct ui_out *uiout = current_uiout;
6603
6604   /* If it has no value (which is frequently the case), say nothing; a
6605      message like "No default-collect." gets in user's face when it's
6606      not wanted.  */
6607   if (!*default_collect)
6608     return;
6609
6610   /* The following phrase lines up nicely with per-tracepoint collect
6611      actions.  */
6612   uiout->text ("default collect ");
6613   uiout->field_string ("default-collect", default_collect);
6614   uiout->text (" \n");
6615 }
6616   
6617 static void
6618 info_breakpoints_command (const char *args, int from_tty)
6619 {
6620   breakpoint_1 (args, 0, NULL);
6621
6622   default_collect_info ();
6623 }
6624
6625 static void
6626 info_watchpoints_command (const char *args, int from_tty)
6627 {
6628   int num_printed = breakpoint_1 (args, 0, is_watchpoint);
6629   struct ui_out *uiout = current_uiout;
6630
6631   if (num_printed == 0)
6632     {
6633       if (args == NULL || *args == '\0')
6634         uiout->message ("No watchpoints.\n");
6635       else
6636         uiout->message ("No watchpoint matching '%s'.\n", args);
6637     }
6638 }
6639
6640 static void
6641 maintenance_info_breakpoints (const char *args, int from_tty)
6642 {
6643   breakpoint_1 (args, 1, NULL);
6644
6645   default_collect_info ();
6646 }
6647
6648 static int
6649 breakpoint_has_pc (struct breakpoint *b,
6650                    struct program_space *pspace,
6651                    CORE_ADDR pc, struct obj_section *section)
6652 {
6653   struct bp_location *bl = b->loc;
6654
6655   for (; bl; bl = bl->next)
6656     {
6657       if (bl->pspace == pspace
6658           && bl->address == pc
6659           && (!overlay_debugging || bl->section == section))
6660         return 1;         
6661     }
6662   return 0;
6663 }
6664
6665 /* Print a message describing any user-breakpoints set at PC.  This
6666    concerns with logical breakpoints, so we match program spaces, not
6667    address spaces.  */
6668
6669 static void
6670 describe_other_breakpoints (struct gdbarch *gdbarch,
6671                             struct program_space *pspace, CORE_ADDR pc,
6672                             struct obj_section *section, int thread)
6673 {
6674   int others = 0;
6675   struct breakpoint *b;
6676
6677   ALL_BREAKPOINTS (b)
6678     others += (user_breakpoint_p (b)
6679                && breakpoint_has_pc (b, pspace, pc, section));
6680   if (others > 0)
6681     {
6682       if (others == 1)
6683         printf_filtered (_("Note: breakpoint "));
6684       else /* if (others == ???) */
6685         printf_filtered (_("Note: breakpoints "));
6686       ALL_BREAKPOINTS (b)
6687         if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
6688           {
6689             others--;
6690             printf_filtered ("%d", b->number);
6691             if (b->thread == -1 && thread != -1)
6692               printf_filtered (" (all threads)");
6693             else if (b->thread != -1)
6694               printf_filtered (" (thread %d)", b->thread);
6695             printf_filtered ("%s%s ",
6696                              ((b->enable_state == bp_disabled
6697                                || b->enable_state == bp_call_disabled)
6698                               ? " (disabled)"
6699                               : ""),
6700                              (others > 1) ? "," 
6701                              : ((others == 1) ? " and" : ""));
6702           }
6703       printf_filtered (_("also set at pc "));
6704       fputs_styled (paddress (gdbarch, pc), address_style.style (), gdb_stdout);
6705       printf_filtered (".\n");
6706     }
6707 }
6708 \f
6709
6710 /* Return true iff it is meaningful to use the address member of
6711    BPT locations.  For some breakpoint types, the locations' address members
6712    are irrelevant and it makes no sense to attempt to compare them to other
6713    addresses (or use them for any other purpose either).
6714
6715    More specifically, each of the following breakpoint types will
6716    always have a zero valued location address and we don't want to mark
6717    breakpoints of any of these types to be a duplicate of an actual
6718    breakpoint location at address zero:
6719
6720       bp_watchpoint
6721       bp_catchpoint
6722
6723 */
6724
6725 static int
6726 breakpoint_address_is_meaningful (struct breakpoint *bpt)
6727 {
6728   enum bptype type = bpt->type;
6729
6730   return (type != bp_watchpoint && type != bp_catchpoint);
6731 }
6732
6733 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6734    true if LOC1 and LOC2 represent the same watchpoint location.  */
6735
6736 static int
6737 watchpoint_locations_match (struct bp_location *loc1, 
6738                             struct bp_location *loc2)
6739 {
6740   struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
6741   struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
6742
6743   /* Both of them must exist.  */
6744   gdb_assert (w1 != NULL);
6745   gdb_assert (w2 != NULL);
6746
6747   /* If the target can evaluate the condition expression in hardware,
6748      then we we need to insert both watchpoints even if they are at
6749      the same place.  Otherwise the watchpoint will only trigger when
6750      the condition of whichever watchpoint was inserted evaluates to
6751      true, not giving a chance for GDB to check the condition of the
6752      other watchpoint.  */
6753   if ((w1->cond_exp
6754        && target_can_accel_watchpoint_condition (loc1->address, 
6755                                                  loc1->length,
6756                                                  loc1->watchpoint_type,
6757                                                  w1->cond_exp.get ()))
6758       || (w2->cond_exp
6759           && target_can_accel_watchpoint_condition (loc2->address, 
6760                                                     loc2->length,
6761                                                     loc2->watchpoint_type,
6762                                                     w2->cond_exp.get ())))
6763     return 0;
6764
6765   /* Note that this checks the owner's type, not the location's.  In
6766      case the target does not support read watchpoints, but does
6767      support access watchpoints, we'll have bp_read_watchpoint
6768      watchpoints with hw_access locations.  Those should be considered
6769      duplicates of hw_read locations.  The hw_read locations will
6770      become hw_access locations later.  */
6771   return (loc1->owner->type == loc2->owner->type
6772           && loc1->pspace->aspace == loc2->pspace->aspace
6773           && loc1->address == loc2->address
6774           && loc1->length == loc2->length);
6775 }
6776
6777 /* See breakpoint.h.  */
6778
6779 int
6780 breakpoint_address_match (const address_space *aspace1, CORE_ADDR addr1,
6781                           const address_space *aspace2, CORE_ADDR addr2)
6782 {
6783   return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6784            || aspace1 == aspace2)
6785           && addr1 == addr2);
6786 }
6787
6788 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6789    {ASPACE1,ADDR1,LEN1}.  In most targets, this can only be true if ASPACE1
6790    matches ASPACE2.  On targets that have global breakpoints, the address
6791    space doesn't really matter.  */
6792
6793 static int
6794 breakpoint_address_match_range (const address_space *aspace1,
6795                                 CORE_ADDR addr1,
6796                                 int len1, const address_space *aspace2,
6797                                 CORE_ADDR addr2)
6798 {
6799   return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6800            || aspace1 == aspace2)
6801           && addr2 >= addr1 && addr2 < addr1 + len1);
6802 }
6803
6804 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL.  BL may be
6805    a ranged breakpoint.  In most targets, a match happens only if ASPACE
6806    matches the breakpoint's address space.  On targets that have global
6807    breakpoints, the address space doesn't really matter.  */
6808
6809 static int
6810 breakpoint_location_address_match (struct bp_location *bl,
6811                                    const address_space *aspace,
6812                                    CORE_ADDR addr)
6813 {
6814   return (breakpoint_address_match (bl->pspace->aspace, bl->address,
6815                                     aspace, addr)
6816           || (bl->length
6817               && breakpoint_address_match_range (bl->pspace->aspace,
6818                                                  bl->address, bl->length,
6819                                                  aspace, addr)));
6820 }
6821
6822 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6823    breakpoint BL.  BL may be a ranged breakpoint.  In most targets, a
6824    match happens only if ASPACE matches the breakpoint's address
6825    space.  On targets that have global breakpoints, the address space
6826    doesn't really matter.  */
6827
6828 static int
6829 breakpoint_location_address_range_overlap (struct bp_location *bl,
6830                                            const address_space *aspace,
6831                                            CORE_ADDR addr, int len)
6832 {
6833   if (gdbarch_has_global_breakpoints (target_gdbarch ())
6834       || bl->pspace->aspace == aspace)
6835     {
6836       int bl_len = bl->length != 0 ? bl->length : 1;
6837
6838       if (mem_ranges_overlap (addr, len, bl->address, bl_len))
6839         return 1;
6840     }
6841   return 0;
6842 }
6843
6844 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6845    Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6846    true, otherwise returns false.  */
6847
6848 static int
6849 tracepoint_locations_match (struct bp_location *loc1,
6850                             struct bp_location *loc2)
6851 {
6852   if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
6853     /* Since tracepoint locations are never duplicated with others', tracepoint
6854        locations at the same address of different tracepoints are regarded as
6855        different locations.  */
6856     return (loc1->address == loc2->address && loc1->owner == loc2->owner);
6857   else
6858     return 0;
6859 }
6860
6861 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6862    (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6863    represent the same location.  */
6864
6865 static int
6866 breakpoint_locations_match (struct bp_location *loc1, 
6867                             struct bp_location *loc2)
6868 {
6869   int hw_point1, hw_point2;
6870
6871   /* Both of them must not be in moribund_locations.  */
6872   gdb_assert (loc1->owner != NULL);
6873   gdb_assert (loc2->owner != NULL);
6874
6875   hw_point1 = is_hardware_watchpoint (loc1->owner);
6876   hw_point2 = is_hardware_watchpoint (loc2->owner);
6877
6878   if (hw_point1 != hw_point2)
6879     return 0;
6880   else if (hw_point1)
6881     return watchpoint_locations_match (loc1, loc2);
6882   else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
6883     return tracepoint_locations_match (loc1, loc2);
6884   else
6885     /* We compare bp_location.length in order to cover ranged breakpoints.  */
6886     return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
6887                                      loc2->pspace->aspace, loc2->address)
6888             && loc1->length == loc2->length);
6889 }
6890
6891 static void
6892 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
6893                                int bnum, int have_bnum)
6894 {
6895   /* The longest string possibly returned by hex_string_custom
6896      is 50 chars.  These must be at least that big for safety.  */
6897   char astr1[64];
6898   char astr2[64];
6899
6900   strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
6901   strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
6902   if (have_bnum)
6903     warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6904              bnum, astr1, astr2);
6905   else
6906     warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
6907 }
6908
6909 /* Adjust a breakpoint's address to account for architectural
6910    constraints on breakpoint placement.  Return the adjusted address.
6911    Note: Very few targets require this kind of adjustment.  For most
6912    targets, this function is simply the identity function.  */
6913
6914 static CORE_ADDR
6915 adjust_breakpoint_address (struct gdbarch *gdbarch,
6916                            CORE_ADDR bpaddr, enum bptype bptype)
6917 {
6918   if (bptype == bp_watchpoint
6919       || bptype == bp_hardware_watchpoint
6920       || bptype == bp_read_watchpoint
6921       || bptype == bp_access_watchpoint
6922       || bptype == bp_catchpoint)
6923     {
6924       /* Watchpoints and the various bp_catch_* eventpoints should not
6925          have their addresses modified.  */
6926       return bpaddr;
6927     }
6928   else if (bptype == bp_single_step)
6929     {
6930       /* Single-step breakpoints should not have their addresses
6931          modified.  If there's any architectural constrain that
6932          applies to this address, then it should have already been
6933          taken into account when the breakpoint was created in the
6934          first place.  If we didn't do this, stepping through e.g.,
6935          Thumb-2 IT blocks would break.  */
6936       return bpaddr;
6937     }
6938   else
6939     {
6940       CORE_ADDR adjusted_bpaddr = bpaddr;
6941
6942       if (gdbarch_adjust_breakpoint_address_p (gdbarch))
6943         {
6944           /* Some targets have architectural constraints on the placement
6945              of breakpoint instructions.  Obtain the adjusted address.  */
6946           adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
6947         }
6948
6949       adjusted_bpaddr = address_significant (gdbarch, adjusted_bpaddr);
6950
6951       /* An adjusted breakpoint address can significantly alter
6952          a user's expectations.  Print a warning if an adjustment
6953          is required.  */
6954       if (adjusted_bpaddr != bpaddr)
6955         breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
6956
6957       return adjusted_bpaddr;
6958     }
6959 }
6960
6961 bp_location::bp_location (breakpoint *owner)
6962 {
6963   bp_location *loc = this;
6964
6965   loc->owner = owner;
6966   loc->cond_bytecode = NULL;
6967   loc->shlib_disabled = 0;
6968   loc->enabled = 1;
6969
6970   switch (owner->type)
6971     {
6972     case bp_breakpoint:
6973     case bp_single_step:
6974     case bp_until:
6975     case bp_finish:
6976     case bp_longjmp:
6977     case bp_longjmp_resume:
6978     case bp_longjmp_call_dummy:
6979     case bp_exception:
6980     case bp_exception_resume:
6981     case bp_step_resume:
6982     case bp_hp_step_resume:
6983     case bp_watchpoint_scope:
6984     case bp_call_dummy:
6985     case bp_std_terminate:
6986     case bp_shlib_event:
6987     case bp_thread_event:
6988     case bp_overlay_event:
6989     case bp_jit_event:
6990     case bp_longjmp_master:
6991     case bp_std_terminate_master:
6992     case bp_exception_master:
6993     case bp_gnu_ifunc_resolver:
6994     case bp_gnu_ifunc_resolver_return:
6995     case bp_dprintf:
6996       loc->loc_type = bp_loc_software_breakpoint;
6997       mark_breakpoint_location_modified (loc);
6998       break;
6999     case bp_hardware_breakpoint:
7000       loc->loc_type = bp_loc_hardware_breakpoint;
7001       mark_breakpoint_location_modified (loc);
7002       break;
7003     case bp_hardware_watchpoint:
7004     case bp_read_watchpoint:
7005     case bp_access_watchpoint:
7006       loc->loc_type = bp_loc_hardware_watchpoint;
7007       break;
7008     case bp_watchpoint:
7009     case bp_catchpoint:
7010     case bp_tracepoint:
7011     case bp_fast_tracepoint:
7012     case bp_static_tracepoint:
7013       loc->loc_type = bp_loc_other;
7014       break;
7015     default:
7016       internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
7017     }
7018
7019   loc->refc = 1;
7020 }
7021
7022 /* Allocate a struct bp_location.  */
7023
7024 static struct bp_location *
7025 allocate_bp_location (struct breakpoint *bpt)
7026 {
7027   return bpt->ops->allocate_location (bpt);
7028 }
7029
7030 static void
7031 free_bp_location (struct bp_location *loc)
7032 {
7033   delete loc;
7034 }
7035
7036 /* Increment reference count.  */
7037
7038 static void
7039 incref_bp_location (struct bp_location *bl)
7040 {
7041   ++bl->refc;
7042 }
7043
7044 /* Decrement reference count.  If the reference count reaches 0,
7045    destroy the bp_location.  Sets *BLP to NULL.  */
7046
7047 static void
7048 decref_bp_location (struct bp_location **blp)
7049 {
7050   gdb_assert ((*blp)->refc > 0);
7051
7052   if (--(*blp)->refc == 0)
7053     free_bp_location (*blp);
7054   *blp = NULL;
7055 }
7056
7057 /* Add breakpoint B at the end of the global breakpoint chain.  */
7058
7059 static breakpoint *
7060 add_to_breakpoint_chain (std::unique_ptr<breakpoint> &&b)
7061 {
7062   struct breakpoint *b1;
7063   struct breakpoint *result = b.get ();
7064
7065   /* Add this breakpoint to the end of the chain so that a list of
7066      breakpoints will come out in order of increasing numbers.  */
7067
7068   b1 = breakpoint_chain;
7069   if (b1 == 0)
7070     breakpoint_chain = b.release ();
7071   else
7072     {
7073       while (b1->next)
7074         b1 = b1->next;
7075       b1->next = b.release ();
7076     }
7077
7078   return result;
7079 }
7080
7081 /* Initializes breakpoint B with type BPTYPE and no locations yet.  */
7082
7083 static void
7084 init_raw_breakpoint_without_location (struct breakpoint *b,
7085                                       struct gdbarch *gdbarch,
7086                                       enum bptype bptype,
7087                                       const struct breakpoint_ops *ops)
7088 {
7089   gdb_assert (ops != NULL);
7090
7091   b->ops = ops;
7092   b->type = bptype;
7093   b->gdbarch = gdbarch;
7094   b->language = current_language->la_language;
7095   b->input_radix = input_radix;
7096   b->related_breakpoint = b;
7097 }
7098
7099 /* Helper to set_raw_breakpoint below.  Creates a breakpoint
7100    that has type BPTYPE and has no locations as yet.  */
7101
7102 static struct breakpoint *
7103 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
7104                                      enum bptype bptype,
7105                                      const struct breakpoint_ops *ops)
7106 {
7107   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7108
7109   init_raw_breakpoint_without_location (b.get (), gdbarch, bptype, ops);
7110   return add_to_breakpoint_chain (std::move (b));
7111 }
7112
7113 /* Initialize loc->function_name.  EXPLICIT_LOC says no indirect function
7114    resolutions should be made as the user specified the location explicitly
7115    enough.  */
7116
7117 static void
7118 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
7119 {
7120   gdb_assert (loc->owner != NULL);
7121
7122   if (loc->owner->type == bp_breakpoint
7123       || loc->owner->type == bp_hardware_breakpoint
7124       || is_tracepoint (loc->owner))
7125     {
7126       const char *function_name;
7127
7128       if (loc->msymbol != NULL
7129           && (MSYMBOL_TYPE (loc->msymbol) == mst_text_gnu_ifunc
7130               || MSYMBOL_TYPE (loc->msymbol) == mst_data_gnu_ifunc)
7131           && !explicit_loc)
7132         {
7133           struct breakpoint *b = loc->owner;
7134
7135           function_name = MSYMBOL_LINKAGE_NAME (loc->msymbol);
7136
7137           if (b->type == bp_breakpoint && b->loc == loc
7138               && loc->next == NULL && b->related_breakpoint == b)
7139             {
7140               /* Create only the whole new breakpoint of this type but do not
7141                  mess more complicated breakpoints with multiple locations.  */
7142               b->type = bp_gnu_ifunc_resolver;
7143               /* Remember the resolver's address for use by the return
7144                  breakpoint.  */
7145               loc->related_address = loc->address;
7146             }
7147         }
7148       else
7149         find_pc_partial_function (loc->address, &function_name, NULL, NULL);
7150
7151       if (function_name)
7152         loc->function_name = xstrdup (function_name);
7153     }
7154 }
7155
7156 /* Attempt to determine architecture of location identified by SAL.  */
7157 struct gdbarch *
7158 get_sal_arch (struct symtab_and_line sal)
7159 {
7160   if (sal.section)
7161     return get_objfile_arch (sal.section->objfile);
7162   if (sal.symtab)
7163     return get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
7164
7165   return NULL;
7166 }
7167
7168 /* Low level routine for partially initializing a breakpoint of type
7169    BPTYPE.  The newly created breakpoint's address, section, source
7170    file name, and line number are provided by SAL.
7171
7172    It is expected that the caller will complete the initialization of
7173    the newly created breakpoint struct as well as output any status
7174    information regarding the creation of a new breakpoint.  */
7175
7176 static void
7177 init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
7178                      struct symtab_and_line sal, enum bptype bptype,
7179                      const struct breakpoint_ops *ops)
7180 {
7181   init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
7182
7183   add_location_to_breakpoint (b, &sal);
7184
7185   if (bptype != bp_catchpoint)
7186     gdb_assert (sal.pspace != NULL);
7187
7188   /* Store the program space that was used to set the breakpoint,
7189      except for ordinary breakpoints, which are independent of the
7190      program space.  */
7191   if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
7192     b->pspace = sal.pspace;
7193 }
7194
7195 /* set_raw_breakpoint is a low level routine for allocating and
7196    partially initializing a breakpoint of type BPTYPE.  The newly
7197    created breakpoint's address, section, source file name, and line
7198    number are provided by SAL.  The newly created and partially
7199    initialized breakpoint is added to the breakpoint chain and
7200    is also returned as the value of this function.
7201
7202    It is expected that the caller will complete the initialization of
7203    the newly created breakpoint struct as well as output any status
7204    information regarding the creation of a new breakpoint.  In
7205    particular, set_raw_breakpoint does NOT set the breakpoint
7206    number!  Care should be taken to not allow an error to occur
7207    prior to completing the initialization of the breakpoint.  If this
7208    should happen, a bogus breakpoint will be left on the chain.  */
7209
7210 struct breakpoint *
7211 set_raw_breakpoint (struct gdbarch *gdbarch,
7212                     struct symtab_and_line sal, enum bptype bptype,
7213                     const struct breakpoint_ops *ops)
7214 {
7215   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7216
7217   init_raw_breakpoint (b.get (), gdbarch, sal, bptype, ops);
7218   return add_to_breakpoint_chain (std::move (b));
7219 }
7220
7221 /* Call this routine when stepping and nexting to enable a breakpoint
7222    if we do a longjmp() or 'throw' in TP.  FRAME is the frame which
7223    initiated the operation.  */
7224
7225 void
7226 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
7227 {
7228   struct breakpoint *b, *b_tmp;
7229   int thread = tp->global_num;
7230
7231   /* To avoid having to rescan all objfile symbols at every step,
7232      we maintain a list of continually-inserted but always disabled
7233      longjmp "master" breakpoints.  Here, we simply create momentary
7234      clones of those and enable them for the requested thread.  */
7235   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7236     if (b->pspace == current_program_space
7237         && (b->type == bp_longjmp_master
7238             || b->type == bp_exception_master))
7239       {
7240         enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7241         struct breakpoint *clone;
7242
7243         /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7244            after their removal.  */
7245         clone = momentary_breakpoint_from_master (b, type,
7246                                                   &momentary_breakpoint_ops, 1);
7247         clone->thread = thread;
7248       }
7249
7250   tp->initiating_frame = frame;
7251 }
7252
7253 /* Delete all longjmp breakpoints from THREAD.  */
7254 void
7255 delete_longjmp_breakpoint (int thread)
7256 {
7257   struct breakpoint *b, *b_tmp;
7258
7259   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7260     if (b->type == bp_longjmp || b->type == bp_exception)
7261       {
7262         if (b->thread == thread)
7263           delete_breakpoint (b);
7264       }
7265 }
7266
7267 void
7268 delete_longjmp_breakpoint_at_next_stop (int thread)
7269 {
7270   struct breakpoint *b, *b_tmp;
7271
7272   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7273     if (b->type == bp_longjmp || b->type == bp_exception)
7274       {
7275         if (b->thread == thread)
7276           b->disposition = disp_del_at_next_stop;
7277       }
7278 }
7279
7280 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7281    INFERIOR_PTID thread.  Chain them all by RELATED_BREAKPOINT and return
7282    pointer to any of them.  Return NULL if this system cannot place longjmp
7283    breakpoints.  */
7284
7285 struct breakpoint *
7286 set_longjmp_breakpoint_for_call_dummy (void)
7287 {
7288   struct breakpoint *b, *retval = NULL;
7289
7290   ALL_BREAKPOINTS (b)
7291     if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7292       {
7293         struct breakpoint *new_b;
7294
7295         new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
7296                                                   &momentary_breakpoint_ops,
7297                                                   1);
7298         new_b->thread = inferior_thread ()->global_num;
7299
7300         /* Link NEW_B into the chain of RETVAL breakpoints.  */
7301
7302         gdb_assert (new_b->related_breakpoint == new_b);
7303         if (retval == NULL)
7304           retval = new_b;
7305         new_b->related_breakpoint = retval;
7306         while (retval->related_breakpoint != new_b->related_breakpoint)
7307           retval = retval->related_breakpoint;
7308         retval->related_breakpoint = new_b;
7309       }
7310
7311   return retval;
7312 }
7313
7314 /* Verify all existing dummy frames and their associated breakpoints for
7315    TP.  Remove those which can no longer be found in the current frame
7316    stack.
7317
7318    You should call this function only at places where it is safe to currently
7319    unwind the whole stack.  Failed stack unwind would discard live dummy
7320    frames.  */
7321
7322 void
7323 check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp)
7324 {
7325   struct breakpoint *b, *b_tmp;
7326
7327   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7328     if (b->type == bp_longjmp_call_dummy && b->thread == tp->global_num)
7329       {
7330         struct breakpoint *dummy_b = b->related_breakpoint;
7331
7332         while (dummy_b != b && dummy_b->type != bp_call_dummy)
7333           dummy_b = dummy_b->related_breakpoint;
7334         if (dummy_b->type != bp_call_dummy
7335             || frame_find_by_id (dummy_b->frame_id) != NULL)
7336           continue;
7337         
7338         dummy_frame_discard (dummy_b->frame_id, tp);
7339
7340         while (b->related_breakpoint != b)
7341           {
7342             if (b_tmp == b->related_breakpoint)
7343               b_tmp = b->related_breakpoint->next;
7344             delete_breakpoint (b->related_breakpoint);
7345           }
7346         delete_breakpoint (b);
7347       }
7348 }
7349
7350 void
7351 enable_overlay_breakpoints (void)
7352 {
7353   struct breakpoint *b;
7354
7355   ALL_BREAKPOINTS (b)
7356     if (b->type == bp_overlay_event)
7357     {
7358       b->enable_state = bp_enabled;
7359       update_global_location_list (UGLL_MAY_INSERT);
7360       overlay_events_enabled = 1;
7361     }
7362 }
7363
7364 void
7365 disable_overlay_breakpoints (void)
7366 {
7367   struct breakpoint *b;
7368
7369   ALL_BREAKPOINTS (b)
7370     if (b->type == bp_overlay_event)
7371     {
7372       b->enable_state = bp_disabled;
7373       update_global_location_list (UGLL_DONT_INSERT);
7374       overlay_events_enabled = 0;
7375     }
7376 }
7377
7378 /* Set an active std::terminate breakpoint for each std::terminate
7379    master breakpoint.  */
7380 void
7381 set_std_terminate_breakpoint (void)
7382 {
7383   struct breakpoint *b, *b_tmp;
7384
7385   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7386     if (b->pspace == current_program_space
7387         && b->type == bp_std_terminate_master)
7388       {
7389         momentary_breakpoint_from_master (b, bp_std_terminate,
7390                                           &momentary_breakpoint_ops, 1);
7391       }
7392 }
7393
7394 /* Delete all the std::terminate breakpoints.  */
7395 void
7396 delete_std_terminate_breakpoint (void)
7397 {
7398   struct breakpoint *b, *b_tmp;
7399
7400   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7401     if (b->type == bp_std_terminate)
7402       delete_breakpoint (b);
7403 }
7404
7405 struct breakpoint *
7406 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7407 {
7408   struct breakpoint *b;
7409
7410   b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7411                                   &internal_breakpoint_ops);
7412
7413   b->enable_state = bp_enabled;
7414   /* location has to be used or breakpoint_re_set will delete me.  */
7415   b->location = new_address_location (b->loc->address, NULL, 0);
7416
7417   update_global_location_list_nothrow (UGLL_MAY_INSERT);
7418
7419   return b;
7420 }
7421
7422 struct lang_and_radix
7423   {
7424     enum language lang;
7425     int radix;
7426   };
7427
7428 /* Create a breakpoint for JIT code registration and unregistration.  */
7429
7430 struct breakpoint *
7431 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7432 {
7433   return create_internal_breakpoint (gdbarch, address, bp_jit_event,
7434                                      &internal_breakpoint_ops);
7435 }
7436
7437 /* Remove JIT code registration and unregistration breakpoint(s).  */
7438
7439 void
7440 remove_jit_event_breakpoints (void)
7441 {
7442   struct breakpoint *b, *b_tmp;
7443
7444   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7445     if (b->type == bp_jit_event
7446         && b->loc->pspace == current_program_space)
7447       delete_breakpoint (b);
7448 }
7449
7450 void
7451 remove_solib_event_breakpoints (void)
7452 {
7453   struct breakpoint *b, *b_tmp;
7454
7455   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7456     if (b->type == bp_shlib_event
7457         && b->loc->pspace == current_program_space)
7458       delete_breakpoint (b);
7459 }
7460
7461 /* See breakpoint.h.  */
7462
7463 void
7464 remove_solib_event_breakpoints_at_next_stop (void)
7465 {
7466   struct breakpoint *b, *b_tmp;
7467
7468   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7469     if (b->type == bp_shlib_event
7470         && b->loc->pspace == current_program_space)
7471       b->disposition = disp_del_at_next_stop;
7472 }
7473
7474 /* Helper for create_solib_event_breakpoint /
7475    create_and_insert_solib_event_breakpoint.  Allows specifying which
7476    INSERT_MODE to pass through to update_global_location_list.  */
7477
7478 static struct breakpoint *
7479 create_solib_event_breakpoint_1 (struct gdbarch *gdbarch, CORE_ADDR address,
7480                                  enum ugll_insert_mode insert_mode)
7481 {
7482   struct breakpoint *b;
7483
7484   b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7485                                   &internal_breakpoint_ops);
7486   update_global_location_list_nothrow (insert_mode);
7487   return b;
7488 }
7489
7490 struct breakpoint *
7491 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7492 {
7493   return create_solib_event_breakpoint_1 (gdbarch, address, UGLL_MAY_INSERT);
7494 }
7495
7496 /* See breakpoint.h.  */
7497
7498 struct breakpoint *
7499 create_and_insert_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7500 {
7501   struct breakpoint *b;
7502
7503   /* Explicitly tell update_global_location_list to insert
7504      locations.  */
7505   b = create_solib_event_breakpoint_1 (gdbarch, address, UGLL_INSERT);
7506   if (!b->loc->inserted)
7507     {
7508       delete_breakpoint (b);
7509       return NULL;
7510     }
7511   return b;
7512 }
7513
7514 /* Disable any breakpoints that are on code in shared libraries.  Only
7515    apply to enabled breakpoints, disabled ones can just stay disabled.  */
7516
7517 void
7518 disable_breakpoints_in_shlibs (void)
7519 {
7520   struct bp_location *loc, **locp_tmp;
7521
7522   ALL_BP_LOCATIONS (loc, locp_tmp)
7523   {
7524     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7525     struct breakpoint *b = loc->owner;
7526
7527     /* We apply the check to all breakpoints, including disabled for
7528        those with loc->duplicate set.  This is so that when breakpoint
7529        becomes enabled, or the duplicate is removed, gdb will try to
7530        insert all breakpoints.  If we don't set shlib_disabled here,
7531        we'll try to insert those breakpoints and fail.  */
7532     if (((b->type == bp_breakpoint)
7533          || (b->type == bp_jit_event)
7534          || (b->type == bp_hardware_breakpoint)
7535          || (is_tracepoint (b)))
7536         && loc->pspace == current_program_space
7537         && !loc->shlib_disabled
7538         && solib_name_from_address (loc->pspace, loc->address)
7539         )
7540       {
7541         loc->shlib_disabled = 1;
7542       }
7543   }
7544 }
7545
7546 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7547    notification of unloaded_shlib.  Only apply to enabled breakpoints,
7548    disabled ones can just stay disabled.  */
7549
7550 static void
7551 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7552 {
7553   struct bp_location *loc, **locp_tmp;
7554   int disabled_shlib_breaks = 0;
7555
7556   ALL_BP_LOCATIONS (loc, locp_tmp)
7557   {
7558     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7559     struct breakpoint *b = loc->owner;
7560
7561     if (solib->pspace == loc->pspace
7562         && !loc->shlib_disabled
7563         && (((b->type == bp_breakpoint
7564               || b->type == bp_jit_event
7565               || b->type == bp_hardware_breakpoint)
7566              && (loc->loc_type == bp_loc_hardware_breakpoint
7567                  || loc->loc_type == bp_loc_software_breakpoint))
7568             || is_tracepoint (b))
7569         && solib_contains_address_p (solib, loc->address))
7570       {
7571         loc->shlib_disabled = 1;
7572         /* At this point, we cannot rely on remove_breakpoint
7573            succeeding so we must mark the breakpoint as not inserted
7574            to prevent future errors occurring in remove_breakpoints.  */
7575         loc->inserted = 0;
7576
7577         /* This may cause duplicate notifications for the same breakpoint.  */
7578         gdb::observers::breakpoint_modified.notify (b);
7579
7580         if (!disabled_shlib_breaks)
7581           {
7582             target_terminal::ours_for_output ();
7583             warning (_("Temporarily disabling breakpoints "
7584                        "for unloaded shared library \"%s\""),
7585                      solib->so_name);
7586           }
7587         disabled_shlib_breaks = 1;
7588       }
7589   }
7590 }
7591
7592 /* Disable any breakpoints and tracepoints in OBJFILE upon
7593    notification of free_objfile.  Only apply to enabled breakpoints,
7594    disabled ones can just stay disabled.  */
7595
7596 static void
7597 disable_breakpoints_in_freed_objfile (struct objfile *objfile)
7598 {
7599   struct breakpoint *b;
7600
7601   if (objfile == NULL)
7602     return;
7603
7604   /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7605      managed by the user with add-symbol-file/remove-symbol-file.
7606      Similarly to how breakpoints in shared libraries are handled in
7607      response to "nosharedlibrary", mark breakpoints in such modules
7608      shlib_disabled so they end up uninserted on the next global
7609      location list update.  Shared libraries not loaded by the user
7610      aren't handled here -- they're already handled in
7611      disable_breakpoints_in_unloaded_shlib, called by solib.c's
7612      solib_unloaded observer.  We skip objfiles that are not
7613      OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7614      main objfile).  */
7615   if ((objfile->flags & OBJF_SHARED) == 0
7616       || (objfile->flags & OBJF_USERLOADED) == 0)
7617     return;
7618
7619   ALL_BREAKPOINTS (b)
7620     {
7621       struct bp_location *loc;
7622       int bp_modified = 0;
7623
7624       if (!is_breakpoint (b) && !is_tracepoint (b))
7625         continue;
7626
7627       for (loc = b->loc; loc != NULL; loc = loc->next)
7628         {
7629           CORE_ADDR loc_addr = loc->address;
7630
7631           if (loc->loc_type != bp_loc_hardware_breakpoint
7632               && loc->loc_type != bp_loc_software_breakpoint)
7633             continue;
7634
7635           if (loc->shlib_disabled != 0)
7636             continue;
7637
7638           if (objfile->pspace != loc->pspace)
7639             continue;
7640
7641           if (loc->loc_type != bp_loc_hardware_breakpoint
7642               && loc->loc_type != bp_loc_software_breakpoint)
7643             continue;
7644
7645           if (is_addr_in_objfile (loc_addr, objfile))
7646             {
7647               loc->shlib_disabled = 1;
7648               /* At this point, we don't know whether the object was
7649                  unmapped from the inferior or not, so leave the
7650                  inserted flag alone.  We'll handle failure to
7651                  uninsert quietly, in case the object was indeed
7652                  unmapped.  */
7653
7654               mark_breakpoint_location_modified (loc);
7655
7656               bp_modified = 1;
7657             }
7658         }
7659
7660       if (bp_modified)
7661         gdb::observers::breakpoint_modified.notify (b);
7662     }
7663 }
7664
7665 /* FORK & VFORK catchpoints.  */
7666
7667 /* An instance of this type is used to represent a fork or vfork
7668    catchpoint.  A breakpoint is really of this type iff its ops pointer points
7669    to CATCH_FORK_BREAKPOINT_OPS.  */
7670
7671 struct fork_catchpoint : public breakpoint
7672 {
7673   /* Process id of a child process whose forking triggered this
7674      catchpoint.  This field is only valid immediately after this
7675      catchpoint has triggered.  */
7676   ptid_t forked_inferior_pid;
7677 };
7678
7679 /* Implement the "insert" breakpoint_ops method for fork
7680    catchpoints.  */
7681
7682 static int
7683 insert_catch_fork (struct bp_location *bl)
7684 {
7685   return target_insert_fork_catchpoint (inferior_ptid.pid ());
7686 }
7687
7688 /* Implement the "remove" breakpoint_ops method for fork
7689    catchpoints.  */
7690
7691 static int
7692 remove_catch_fork (struct bp_location *bl, enum remove_bp_reason reason)
7693 {
7694   return target_remove_fork_catchpoint (inferior_ptid.pid ());
7695 }
7696
7697 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7698    catchpoints.  */
7699
7700 static int
7701 breakpoint_hit_catch_fork (const struct bp_location *bl,
7702                            const address_space *aspace, CORE_ADDR bp_addr,
7703                            const struct target_waitstatus *ws)
7704 {
7705   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7706
7707   if (ws->kind != TARGET_WAITKIND_FORKED)
7708     return 0;
7709
7710   c->forked_inferior_pid = ws->value.related_pid;
7711   return 1;
7712 }
7713
7714 /* Implement the "print_it" breakpoint_ops method for fork
7715    catchpoints.  */
7716
7717 static enum print_stop_action
7718 print_it_catch_fork (bpstat bs)
7719 {
7720   struct ui_out *uiout = current_uiout;
7721   struct breakpoint *b = bs->breakpoint_at;
7722   struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
7723
7724   annotate_catchpoint (b->number);
7725   maybe_print_thread_hit_breakpoint (uiout);
7726   if (b->disposition == disp_del)
7727     uiout->text ("Temporary catchpoint ");
7728   else
7729     uiout->text ("Catchpoint ");
7730   if (uiout->is_mi_like_p ())
7731     {
7732       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK));
7733       uiout->field_string ("disp", bpdisp_text (b->disposition));
7734     }
7735   uiout->field_int ("bkptno", b->number);
7736   uiout->text (" (forked process ");
7737   uiout->field_int ("newpid", c->forked_inferior_pid.pid ());
7738   uiout->text ("), ");
7739   return PRINT_SRC_AND_LOC;
7740 }
7741
7742 /* Implement the "print_one" breakpoint_ops method for fork
7743    catchpoints.  */
7744
7745 static void
7746 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
7747 {
7748   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7749   struct value_print_options opts;
7750   struct ui_out *uiout = current_uiout;
7751
7752   get_user_print_options (&opts);
7753
7754   /* Field 4, the address, is omitted (which makes the columns not
7755      line up too nicely with the headers, but the effect is relatively
7756      readable).  */
7757   if (opts.addressprint)
7758     uiout->field_skip ("addr");
7759   annotate_field (5);
7760   uiout->text ("fork");
7761   if (c->forked_inferior_pid != null_ptid)
7762     {
7763       uiout->text (", process ");
7764       uiout->field_int ("what", c->forked_inferior_pid.pid ());
7765       uiout->spaces (1);
7766     }
7767
7768   if (uiout->is_mi_like_p ())
7769     uiout->field_string ("catch-type", "fork");
7770 }
7771
7772 /* Implement the "print_mention" breakpoint_ops method for fork
7773    catchpoints.  */
7774
7775 static void
7776 print_mention_catch_fork (struct breakpoint *b)
7777 {
7778   printf_filtered (_("Catchpoint %d (fork)"), b->number);
7779 }
7780
7781 /* Implement the "print_recreate" breakpoint_ops method for fork
7782    catchpoints.  */
7783
7784 static void
7785 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
7786 {
7787   fprintf_unfiltered (fp, "catch fork");
7788   print_recreate_thread (b, fp);
7789 }
7790
7791 /* The breakpoint_ops structure to be used in fork catchpoints.  */
7792
7793 static struct breakpoint_ops catch_fork_breakpoint_ops;
7794
7795 /* Implement the "insert" breakpoint_ops method for vfork
7796    catchpoints.  */
7797
7798 static int
7799 insert_catch_vfork (struct bp_location *bl)
7800 {
7801   return target_insert_vfork_catchpoint (inferior_ptid.pid ());
7802 }
7803
7804 /* Implement the "remove" breakpoint_ops method for vfork
7805    catchpoints.  */
7806
7807 static int
7808 remove_catch_vfork (struct bp_location *bl, enum remove_bp_reason reason)
7809 {
7810   return target_remove_vfork_catchpoint (inferior_ptid.pid ());
7811 }
7812
7813 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7814    catchpoints.  */
7815
7816 static int
7817 breakpoint_hit_catch_vfork (const struct bp_location *bl,
7818                             const address_space *aspace, CORE_ADDR bp_addr,
7819                             const struct target_waitstatus *ws)
7820 {
7821   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7822
7823   if (ws->kind != TARGET_WAITKIND_VFORKED)
7824     return 0;
7825
7826   c->forked_inferior_pid = ws->value.related_pid;
7827   return 1;
7828 }
7829
7830 /* Implement the "print_it" breakpoint_ops method for vfork
7831    catchpoints.  */
7832
7833 static enum print_stop_action
7834 print_it_catch_vfork (bpstat bs)
7835 {
7836   struct ui_out *uiout = current_uiout;
7837   struct breakpoint *b = bs->breakpoint_at;
7838   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7839
7840   annotate_catchpoint (b->number);
7841   maybe_print_thread_hit_breakpoint (uiout);
7842   if (b->disposition == disp_del)
7843     uiout->text ("Temporary catchpoint ");
7844   else
7845     uiout->text ("Catchpoint ");
7846   if (uiout->is_mi_like_p ())
7847     {
7848       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK));
7849       uiout->field_string ("disp", bpdisp_text (b->disposition));
7850     }
7851   uiout->field_int ("bkptno", b->number);
7852   uiout->text (" (vforked process ");
7853   uiout->field_int ("newpid", c->forked_inferior_pid.pid ());
7854   uiout->text ("), ");
7855   return PRINT_SRC_AND_LOC;
7856 }
7857
7858 /* Implement the "print_one" breakpoint_ops method for vfork
7859    catchpoints.  */
7860
7861 static void
7862 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
7863 {
7864   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7865   struct value_print_options opts;
7866   struct ui_out *uiout = current_uiout;
7867
7868   get_user_print_options (&opts);
7869   /* Field 4, the address, is omitted (which makes the columns not
7870      line up too nicely with the headers, but the effect is relatively
7871      readable).  */
7872   if (opts.addressprint)
7873     uiout->field_skip ("addr");
7874   annotate_field (5);
7875   uiout->text ("vfork");
7876   if (c->forked_inferior_pid != null_ptid)
7877     {
7878       uiout->text (", process ");
7879       uiout->field_int ("what", c->forked_inferior_pid.pid ());
7880       uiout->spaces (1);
7881     }
7882
7883   if (uiout->is_mi_like_p ())
7884     uiout->field_string ("catch-type", "vfork");
7885 }
7886
7887 /* Implement the "print_mention" breakpoint_ops method for vfork
7888    catchpoints.  */
7889
7890 static void
7891 print_mention_catch_vfork (struct breakpoint *b)
7892 {
7893   printf_filtered (_("Catchpoint %d (vfork)"), b->number);
7894 }
7895
7896 /* Implement the "print_recreate" breakpoint_ops method for vfork
7897    catchpoints.  */
7898
7899 static void
7900 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
7901 {
7902   fprintf_unfiltered (fp, "catch vfork");
7903   print_recreate_thread (b, fp);
7904 }
7905
7906 /* The breakpoint_ops structure to be used in vfork catchpoints.  */
7907
7908 static struct breakpoint_ops catch_vfork_breakpoint_ops;
7909
7910 /* An instance of this type is used to represent an solib catchpoint.
7911    A breakpoint is really of this type iff its ops pointer points to
7912    CATCH_SOLIB_BREAKPOINT_OPS.  */
7913
7914 struct solib_catchpoint : public breakpoint
7915 {
7916   ~solib_catchpoint () override;
7917
7918   /* True for "catch load", false for "catch unload".  */
7919   unsigned char is_load;
7920
7921   /* Regular expression to match, if any.  COMPILED is only valid when
7922      REGEX is non-NULL.  */
7923   char *regex;
7924   std::unique_ptr<compiled_regex> compiled;
7925 };
7926
7927 solib_catchpoint::~solib_catchpoint ()
7928 {
7929   xfree (this->regex);
7930 }
7931
7932 static int
7933 insert_catch_solib (struct bp_location *ignore)
7934 {
7935   return 0;
7936 }
7937
7938 static int
7939 remove_catch_solib (struct bp_location *ignore, enum remove_bp_reason reason)
7940 {
7941   return 0;
7942 }
7943
7944 static int
7945 breakpoint_hit_catch_solib (const struct bp_location *bl,
7946                             const address_space *aspace,
7947                             CORE_ADDR bp_addr,
7948                             const struct target_waitstatus *ws)
7949 {
7950   struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
7951   struct breakpoint *other;
7952
7953   if (ws->kind == TARGET_WAITKIND_LOADED)
7954     return 1;
7955
7956   ALL_BREAKPOINTS (other)
7957   {
7958     struct bp_location *other_bl;
7959
7960     if (other == bl->owner)
7961       continue;
7962
7963     if (other->type != bp_shlib_event)
7964       continue;
7965
7966     if (self->pspace != NULL && other->pspace != self->pspace)
7967       continue;
7968
7969     for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
7970       {
7971         if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
7972           return 1;
7973       }
7974   }
7975
7976   return 0;
7977 }
7978
7979 static void
7980 check_status_catch_solib (struct bpstats *bs)
7981 {
7982   struct solib_catchpoint *self
7983     = (struct solib_catchpoint *) bs->breakpoint_at;
7984
7985   if (self->is_load)
7986     {
7987       for (so_list *iter : current_program_space->added_solibs)
7988         {
7989           if (!self->regex
7990               || self->compiled->exec (iter->so_name, 0, NULL, 0) == 0)
7991             return;
7992         }
7993     }
7994   else
7995     {
7996       for (const std::string &iter : current_program_space->deleted_solibs)
7997         {
7998           if (!self->regex
7999               || self->compiled->exec (iter.c_str (), 0, NULL, 0) == 0)
8000             return;
8001         }
8002     }
8003
8004   bs->stop = 0;
8005   bs->print_it = print_it_noop;
8006 }
8007
8008 static enum print_stop_action
8009 print_it_catch_solib (bpstat bs)
8010 {
8011   struct breakpoint *b = bs->breakpoint_at;
8012   struct ui_out *uiout = current_uiout;
8013
8014   annotate_catchpoint (b->number);
8015   maybe_print_thread_hit_breakpoint (uiout);
8016   if (b->disposition == disp_del)
8017     uiout->text ("Temporary catchpoint ");
8018   else
8019     uiout->text ("Catchpoint ");
8020   uiout->field_int ("bkptno", b->number);
8021   uiout->text ("\n");
8022   if (uiout->is_mi_like_p ())
8023     uiout->field_string ("disp", bpdisp_text (b->disposition));
8024   print_solib_event (1);
8025   return PRINT_SRC_AND_LOC;
8026 }
8027
8028 static void
8029 print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
8030 {
8031   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8032   struct value_print_options opts;
8033   struct ui_out *uiout = current_uiout;
8034
8035   get_user_print_options (&opts);
8036   /* Field 4, the address, is omitted (which makes the columns not
8037      line up too nicely with the headers, but the effect is relatively
8038      readable).  */
8039   if (opts.addressprint)
8040     {
8041       annotate_field (4);
8042       uiout->field_skip ("addr");
8043     }
8044
8045   std::string msg;
8046   annotate_field (5);
8047   if (self->is_load)
8048     {
8049       if (self->regex)
8050         msg = string_printf (_("load of library matching %s"), self->regex);
8051       else
8052         msg = _("load of library");
8053     }
8054   else
8055     {
8056       if (self->regex)
8057         msg = string_printf (_("unload of library matching %s"), self->regex);
8058       else
8059         msg = _("unload of library");
8060     }
8061   uiout->field_string ("what", msg);
8062
8063   if (uiout->is_mi_like_p ())
8064     uiout->field_string ("catch-type", self->is_load ? "load" : "unload");
8065 }
8066
8067 static void
8068 print_mention_catch_solib (struct breakpoint *b)
8069 {
8070   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8071
8072   printf_filtered (_("Catchpoint %d (%s)"), b->number,
8073                    self->is_load ? "load" : "unload");
8074 }
8075
8076 static void
8077 print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
8078 {
8079   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8080
8081   fprintf_unfiltered (fp, "%s %s",
8082                       b->disposition == disp_del ? "tcatch" : "catch",
8083                       self->is_load ? "load" : "unload");
8084   if (self->regex)
8085     fprintf_unfiltered (fp, " %s", self->regex);
8086   fprintf_unfiltered (fp, "\n");
8087 }
8088
8089 static struct breakpoint_ops catch_solib_breakpoint_ops;
8090
8091 /* Shared helper function (MI and CLI) for creating and installing
8092    a shared object event catchpoint.  If IS_LOAD is non-zero then
8093    the events to be caught are load events, otherwise they are
8094    unload events.  If IS_TEMP is non-zero the catchpoint is a
8095    temporary one.  If ENABLED is non-zero the catchpoint is
8096    created in an enabled state.  */
8097
8098 void
8099 add_solib_catchpoint (const char *arg, int is_load, int is_temp, int enabled)
8100 {
8101   struct gdbarch *gdbarch = get_current_arch ();
8102
8103   if (!arg)
8104     arg = "";
8105   arg = skip_spaces (arg);
8106
8107   std::unique_ptr<solib_catchpoint> c (new solib_catchpoint ());
8108
8109   if (*arg != '\0')
8110     {
8111       c->compiled.reset (new compiled_regex (arg, REG_NOSUB,
8112                                              _("Invalid regexp")));
8113       c->regex = xstrdup (arg);
8114     }
8115
8116   c->is_load = is_load;
8117   init_catchpoint (c.get (), gdbarch, is_temp, NULL,
8118                    &catch_solib_breakpoint_ops);
8119
8120   c->enable_state = enabled ? bp_enabled : bp_disabled;
8121
8122   install_breakpoint (0, std::move (c), 1);
8123 }
8124
8125 /* A helper function that does all the work for "catch load" and
8126    "catch unload".  */
8127
8128 static void
8129 catch_load_or_unload (const char *arg, int from_tty, int is_load,
8130                       struct cmd_list_element *command)
8131 {
8132   int tempflag;
8133   const int enabled = 1;
8134
8135   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8136
8137   add_solib_catchpoint (arg, is_load, tempflag, enabled);
8138 }
8139
8140 static void
8141 catch_load_command_1 (const char *arg, int from_tty,
8142                       struct cmd_list_element *command)
8143 {
8144   catch_load_or_unload (arg, from_tty, 1, command);
8145 }
8146
8147 static void
8148 catch_unload_command_1 (const char *arg, int from_tty,
8149                         struct cmd_list_element *command)
8150 {
8151   catch_load_or_unload (arg, from_tty, 0, command);
8152 }
8153
8154 /* Initialize a new breakpoint of the bp_catchpoint kind.  If TEMPFLAG
8155    is non-zero, then make the breakpoint temporary.  If COND_STRING is
8156    not NULL, then store it in the breakpoint.  OPS, if not NULL, is
8157    the breakpoint_ops structure associated to the catchpoint.  */
8158
8159 void
8160 init_catchpoint (struct breakpoint *b,
8161                  struct gdbarch *gdbarch, int tempflag,
8162                  const char *cond_string,
8163                  const struct breakpoint_ops *ops)
8164 {
8165   symtab_and_line sal;
8166   sal.pspace = current_program_space;
8167
8168   init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
8169
8170   b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
8171   b->disposition = tempflag ? disp_del : disp_donttouch;
8172 }
8173
8174 void
8175 install_breakpoint (int internal, std::unique_ptr<breakpoint> &&arg, int update_gll)
8176 {
8177   breakpoint *b = add_to_breakpoint_chain (std::move (arg));
8178   set_breakpoint_number (internal, b);
8179   if (is_tracepoint (b))
8180     set_tracepoint_count (breakpoint_count);
8181   if (!internal)
8182     mention (b);
8183   gdb::observers::breakpoint_created.notify (b);
8184
8185   if (update_gll)
8186     update_global_location_list (UGLL_MAY_INSERT);
8187 }
8188
8189 static void
8190 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
8191                                     int tempflag, const char *cond_string,
8192                                     const struct breakpoint_ops *ops)
8193 {
8194   std::unique_ptr<fork_catchpoint> c (new fork_catchpoint ());
8195
8196   init_catchpoint (c.get (), gdbarch, tempflag, cond_string, ops);
8197
8198   c->forked_inferior_pid = null_ptid;
8199
8200   install_breakpoint (0, std::move (c), 1);
8201 }
8202
8203 /* Exec catchpoints.  */
8204
8205 /* An instance of this type is used to represent an exec catchpoint.
8206    A breakpoint is really of this type iff its ops pointer points to
8207    CATCH_EXEC_BREAKPOINT_OPS.  */
8208
8209 struct exec_catchpoint : public breakpoint
8210 {
8211   ~exec_catchpoint () override;
8212
8213   /* Filename of a program whose exec triggered this catchpoint.
8214      This field is only valid immediately after this catchpoint has
8215      triggered.  */
8216   char *exec_pathname;
8217 };
8218
8219 /* Exec catchpoint destructor.  */
8220
8221 exec_catchpoint::~exec_catchpoint ()
8222 {
8223   xfree (this->exec_pathname);
8224 }
8225
8226 static int
8227 insert_catch_exec (struct bp_location *bl)
8228 {
8229   return target_insert_exec_catchpoint (inferior_ptid.pid ());
8230 }
8231
8232 static int
8233 remove_catch_exec (struct bp_location *bl, enum remove_bp_reason reason)
8234 {
8235   return target_remove_exec_catchpoint (inferior_ptid.pid ());
8236 }
8237
8238 static int
8239 breakpoint_hit_catch_exec (const struct bp_location *bl,
8240                            const address_space *aspace, CORE_ADDR bp_addr,
8241                            const struct target_waitstatus *ws)
8242 {
8243   struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8244
8245   if (ws->kind != TARGET_WAITKIND_EXECD)
8246     return 0;
8247
8248   c->exec_pathname = xstrdup (ws->value.execd_pathname);
8249   return 1;
8250 }
8251
8252 static enum print_stop_action
8253 print_it_catch_exec (bpstat bs)
8254 {
8255   struct ui_out *uiout = current_uiout;
8256   struct breakpoint *b = bs->breakpoint_at;
8257   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8258
8259   annotate_catchpoint (b->number);
8260   maybe_print_thread_hit_breakpoint (uiout);
8261   if (b->disposition == disp_del)
8262     uiout->text ("Temporary catchpoint ");
8263   else
8264     uiout->text ("Catchpoint ");
8265   if (uiout->is_mi_like_p ())
8266     {
8267       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC));
8268       uiout->field_string ("disp", bpdisp_text (b->disposition));
8269     }
8270   uiout->field_int ("bkptno", b->number);
8271   uiout->text (" (exec'd ");
8272   uiout->field_string ("new-exec", c->exec_pathname);
8273   uiout->text ("), ");
8274
8275   return PRINT_SRC_AND_LOC;
8276 }
8277
8278 static void
8279 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
8280 {
8281   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8282   struct value_print_options opts;
8283   struct ui_out *uiout = current_uiout;
8284
8285   get_user_print_options (&opts);
8286
8287   /* Field 4, the address, is omitted (which makes the columns
8288      not line up too nicely with the headers, but the effect
8289      is relatively readable).  */
8290   if (opts.addressprint)
8291     uiout->field_skip ("addr");
8292   annotate_field (5);
8293   uiout->text ("exec");
8294   if (c->exec_pathname != NULL)
8295     {
8296       uiout->text (", program \"");
8297       uiout->field_string ("what", c->exec_pathname);
8298       uiout->text ("\" ");
8299     }
8300
8301   if (uiout->is_mi_like_p ())
8302     uiout->field_string ("catch-type", "exec");
8303 }
8304
8305 static void
8306 print_mention_catch_exec (struct breakpoint *b)
8307 {
8308   printf_filtered (_("Catchpoint %d (exec)"), b->number);
8309 }
8310
8311 /* Implement the "print_recreate" breakpoint_ops method for exec
8312    catchpoints.  */
8313
8314 static void
8315 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8316 {
8317   fprintf_unfiltered (fp, "catch exec");
8318   print_recreate_thread (b, fp);
8319 }
8320
8321 static struct breakpoint_ops catch_exec_breakpoint_ops;
8322
8323 static int
8324 hw_breakpoint_used_count (void)
8325 {
8326   int i = 0;
8327   struct breakpoint *b;
8328   struct bp_location *bl;
8329
8330   ALL_BREAKPOINTS (b)
8331   {
8332     if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
8333       for (bl = b->loc; bl; bl = bl->next)
8334         {
8335           /* Special types of hardware breakpoints may use more than
8336              one register.  */
8337           i += b->ops->resources_needed (bl);
8338         }
8339   }
8340
8341   return i;
8342 }
8343
8344 /* Returns the resources B would use if it were a hardware
8345    watchpoint.  */
8346
8347 static int
8348 hw_watchpoint_use_count (struct breakpoint *b)
8349 {
8350   int i = 0;
8351   struct bp_location *bl;
8352
8353   if (!breakpoint_enabled (b))
8354     return 0;
8355
8356   for (bl = b->loc; bl; bl = bl->next)
8357     {
8358       /* Special types of hardware watchpoints may use more than
8359          one register.  */
8360       i += b->ops->resources_needed (bl);
8361     }
8362
8363   return i;
8364 }
8365
8366 /* Returns the sum the used resources of all hardware watchpoints of
8367    type TYPE in the breakpoints list.  Also returns in OTHER_TYPE_USED
8368    the sum of the used resources of all hardware watchpoints of other
8369    types _not_ TYPE.  */
8370
8371 static int
8372 hw_watchpoint_used_count_others (struct breakpoint *except,
8373                                  enum bptype type, int *other_type_used)
8374 {
8375   int i = 0;
8376   struct breakpoint *b;
8377
8378   *other_type_used = 0;
8379   ALL_BREAKPOINTS (b)
8380     {
8381       if (b == except)
8382         continue;
8383       if (!breakpoint_enabled (b))
8384         continue;
8385
8386       if (b->type == type)
8387         i += hw_watchpoint_use_count (b);
8388       else if (is_hardware_watchpoint (b))
8389         *other_type_used = 1;
8390     }
8391
8392   return i;
8393 }
8394
8395 void
8396 disable_watchpoints_before_interactive_call_start (void)
8397 {
8398   struct breakpoint *b;
8399
8400   ALL_BREAKPOINTS (b)
8401   {
8402     if (is_watchpoint (b) && breakpoint_enabled (b))
8403       {
8404         b->enable_state = bp_call_disabled;
8405         update_global_location_list (UGLL_DONT_INSERT);
8406       }
8407   }
8408 }
8409
8410 void
8411 enable_watchpoints_after_interactive_call_stop (void)
8412 {
8413   struct breakpoint *b;
8414
8415   ALL_BREAKPOINTS (b)
8416   {
8417     if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
8418       {
8419         b->enable_state = bp_enabled;
8420         update_global_location_list (UGLL_MAY_INSERT);
8421       }
8422   }
8423 }
8424
8425 void
8426 disable_breakpoints_before_startup (void)
8427 {
8428   current_program_space->executing_startup = 1;
8429   update_global_location_list (UGLL_DONT_INSERT);
8430 }
8431
8432 void
8433 enable_breakpoints_after_startup (void)
8434 {
8435   current_program_space->executing_startup = 0;
8436   breakpoint_re_set ();
8437 }
8438
8439 /* Create a new single-step breakpoint for thread THREAD, with no
8440    locations.  */
8441
8442 static struct breakpoint *
8443 new_single_step_breakpoint (int thread, struct gdbarch *gdbarch)
8444 {
8445   std::unique_ptr<breakpoint> b (new breakpoint ());
8446
8447   init_raw_breakpoint_without_location (b.get (), gdbarch, bp_single_step,
8448                                         &momentary_breakpoint_ops);
8449
8450   b->disposition = disp_donttouch;
8451   b->frame_id = null_frame_id;
8452
8453   b->thread = thread;
8454   gdb_assert (b->thread != 0);
8455
8456   return add_to_breakpoint_chain (std::move (b));
8457 }
8458
8459 /* Set a momentary breakpoint of type TYPE at address specified by
8460    SAL.  If FRAME_ID is valid, the breakpoint is restricted to that
8461    frame.  */
8462
8463 breakpoint_up
8464 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8465                           struct frame_id frame_id, enum bptype type)
8466 {
8467   struct breakpoint *b;
8468
8469   /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8470      tail-called one.  */
8471   gdb_assert (!frame_id_artificial_p (frame_id));
8472
8473   b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
8474   b->enable_state = bp_enabled;
8475   b->disposition = disp_donttouch;
8476   b->frame_id = frame_id;
8477
8478   b->thread = inferior_thread ()->global_num;
8479
8480   update_global_location_list_nothrow (UGLL_MAY_INSERT);
8481
8482   return breakpoint_up (b);
8483 }
8484
8485 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8486    The new breakpoint will have type TYPE, use OPS as its
8487    breakpoint_ops, and will set enabled to LOC_ENABLED.  */
8488
8489 static struct breakpoint *
8490 momentary_breakpoint_from_master (struct breakpoint *orig,
8491                                   enum bptype type,
8492                                   const struct breakpoint_ops *ops,
8493                                   int loc_enabled)
8494 {
8495   struct breakpoint *copy;
8496
8497   copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
8498   copy->loc = allocate_bp_location (copy);
8499   set_breakpoint_location_function (copy->loc, 1);
8500
8501   copy->loc->gdbarch = orig->loc->gdbarch;
8502   copy->loc->requested_address = orig->loc->requested_address;
8503   copy->loc->address = orig->loc->address;
8504   copy->loc->section = orig->loc->section;
8505   copy->loc->pspace = orig->loc->pspace;
8506   copy->loc->probe = orig->loc->probe;
8507   copy->loc->line_number = orig->loc->line_number;
8508   copy->loc->symtab = orig->loc->symtab;
8509   copy->loc->enabled = loc_enabled;
8510   copy->frame_id = orig->frame_id;
8511   copy->thread = orig->thread;
8512   copy->pspace = orig->pspace;
8513
8514   copy->enable_state = bp_enabled;
8515   copy->disposition = disp_donttouch;
8516   copy->number = internal_breakpoint_number--;
8517
8518   update_global_location_list_nothrow (UGLL_DONT_INSERT);
8519   return copy;
8520 }
8521
8522 /* Make a deep copy of momentary breakpoint ORIG.  Returns NULL if
8523    ORIG is NULL.  */
8524
8525 struct breakpoint *
8526 clone_momentary_breakpoint (struct breakpoint *orig)
8527 {
8528   /* If there's nothing to clone, then return nothing.  */
8529   if (orig == NULL)
8530     return NULL;
8531
8532   return momentary_breakpoint_from_master (orig, orig->type, orig->ops, 0);
8533 }
8534
8535 breakpoint_up
8536 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8537                                 enum bptype type)
8538 {
8539   struct symtab_and_line sal;
8540
8541   sal = find_pc_line (pc, 0);
8542   sal.pc = pc;
8543   sal.section = find_pc_overlay (pc);
8544   sal.explicit_pc = 1;
8545
8546   return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
8547 }
8548 \f
8549
8550 /* Tell the user we have just set a breakpoint B.  */
8551
8552 static void
8553 mention (struct breakpoint *b)
8554 {
8555   b->ops->print_mention (b);
8556   current_uiout->text ("\n");
8557 }
8558 \f
8559
8560 static int bp_loc_is_permanent (struct bp_location *loc);
8561
8562 static struct bp_location *
8563 add_location_to_breakpoint (struct breakpoint *b,
8564                             const struct symtab_and_line *sal)
8565 {
8566   struct bp_location *loc, **tmp;
8567   CORE_ADDR adjusted_address;
8568   struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
8569
8570   if (loc_gdbarch == NULL)
8571     loc_gdbarch = b->gdbarch;
8572
8573   /* Adjust the breakpoint's address prior to allocating a location.
8574      Once we call allocate_bp_location(), that mostly uninitialized
8575      location will be placed on the location chain.  Adjustment of the
8576      breakpoint may cause target_read_memory() to be called and we do
8577      not want its scan of the location chain to find a breakpoint and
8578      location that's only been partially initialized.  */
8579   adjusted_address = adjust_breakpoint_address (loc_gdbarch,
8580                                                 sal->pc, b->type);
8581
8582   /* Sort the locations by their ADDRESS.  */
8583   loc = allocate_bp_location (b);
8584   for (tmp = &(b->loc); *tmp != NULL && (*tmp)->address <= adjusted_address;
8585        tmp = &((*tmp)->next))
8586     ;
8587   loc->next = *tmp;
8588   *tmp = loc;
8589
8590   loc->requested_address = sal->pc;
8591   loc->address = adjusted_address;
8592   loc->pspace = sal->pspace;
8593   loc->probe.prob = sal->prob;
8594   loc->probe.objfile = sal->objfile;
8595   gdb_assert (loc->pspace != NULL);
8596   loc->section = sal->section;
8597   loc->gdbarch = loc_gdbarch;
8598   loc->line_number = sal->line;
8599   loc->symtab = sal->symtab;
8600   loc->symbol = sal->symbol;
8601   loc->msymbol = sal->msymbol;
8602   loc->objfile = sal->objfile;
8603
8604   set_breakpoint_location_function (loc,
8605                                     sal->explicit_pc || sal->explicit_line);
8606
8607   /* While by definition, permanent breakpoints are already present in the
8608      code, we don't mark the location as inserted.  Normally one would expect
8609      that GDB could rely on that breakpoint instruction to stop the program,
8610      thus removing the need to insert its own breakpoint, except that executing
8611      the breakpoint instruction can kill the target instead of reporting a
8612      SIGTRAP.  E.g., on SPARC, when interrupts are disabled, executing the
8613      instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8614      with "Trap 0x02 while interrupts disabled, Error state".  Letting the
8615      breakpoint be inserted normally results in QEMU knowing about the GDB
8616      breakpoint, and thus trap before the breakpoint instruction is executed.
8617      (If GDB later needs to continue execution past the permanent breakpoint,
8618      it manually increments the PC, thus avoiding executing the breakpoint
8619      instruction.)  */
8620   if (bp_loc_is_permanent (loc))
8621     loc->permanent = 1;
8622
8623   return loc;
8624 }
8625 \f
8626
8627 /* See breakpoint.h.  */
8628
8629 int
8630 program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address)
8631 {
8632   int len;
8633   CORE_ADDR addr;
8634   const gdb_byte *bpoint;
8635   gdb_byte *target_mem;
8636
8637   addr = address;
8638   bpoint = gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
8639
8640   /* Software breakpoints unsupported?  */
8641   if (bpoint == NULL)
8642     return 0;
8643
8644   target_mem = (gdb_byte *) alloca (len);
8645
8646   /* Enable the automatic memory restoration from breakpoints while
8647      we read the memory.  Otherwise we could say about our temporary
8648      breakpoints they are permanent.  */
8649   scoped_restore restore_memory
8650     = make_scoped_restore_show_memory_breakpoints (0);
8651
8652   if (target_read_memory (address, target_mem, len) == 0
8653       && memcmp (target_mem, bpoint, len) == 0)
8654     return 1;
8655
8656   return 0;
8657 }
8658
8659 /* Return 1 if LOC is pointing to a permanent breakpoint,
8660    return 0 otherwise.  */
8661
8662 static int
8663 bp_loc_is_permanent (struct bp_location *loc)
8664 {
8665   gdb_assert (loc != NULL);
8666
8667   /* If we have a catchpoint or a watchpoint, just return 0.  We should not
8668      attempt to read from the addresses the locations of these breakpoint types
8669      point to.  program_breakpoint_here_p, below, will attempt to read
8670      memory.  */
8671   if (!breakpoint_address_is_meaningful (loc->owner))
8672     return 0;
8673
8674   scoped_restore_current_pspace_and_thread restore_pspace_thread;
8675   switch_to_program_space_and_thread (loc->pspace);
8676   return program_breakpoint_here_p (loc->gdbarch, loc->address);
8677 }
8678
8679 /* Build a command list for the dprintf corresponding to the current
8680    settings of the dprintf style options.  */
8681
8682 static void
8683 update_dprintf_command_list (struct breakpoint *b)
8684 {
8685   char *dprintf_args = b->extra_string;
8686   char *printf_line = NULL;
8687
8688   if (!dprintf_args)
8689     return;
8690
8691   dprintf_args = skip_spaces (dprintf_args);
8692
8693   /* Allow a comma, as it may have terminated a location, but don't
8694      insist on it.  */
8695   if (*dprintf_args == ',')
8696     ++dprintf_args;
8697   dprintf_args = skip_spaces (dprintf_args);
8698
8699   if (*dprintf_args != '"')
8700     error (_("Bad format string, missing '\"'."));
8701
8702   if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
8703     printf_line = xstrprintf ("printf %s", dprintf_args);
8704   else if (strcmp (dprintf_style, dprintf_style_call) == 0)
8705     {
8706       if (!dprintf_function)
8707         error (_("No function supplied for dprintf call"));
8708
8709       if (dprintf_channel && strlen (dprintf_channel) > 0)
8710         printf_line = xstrprintf ("call (void) %s (%s,%s)",
8711                                   dprintf_function,
8712                                   dprintf_channel,
8713                                   dprintf_args);
8714       else
8715         printf_line = xstrprintf ("call (void) %s (%s)",
8716                                   dprintf_function,
8717                                   dprintf_args);
8718     }
8719   else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
8720     {
8721       if (target_can_run_breakpoint_commands ())
8722         printf_line = xstrprintf ("agent-printf %s", dprintf_args);
8723       else
8724         {
8725           warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8726           printf_line = xstrprintf ("printf %s", dprintf_args);
8727         }
8728     }
8729   else
8730     internal_error (__FILE__, __LINE__,
8731                     _("Invalid dprintf style."));
8732
8733   gdb_assert (printf_line != NULL);
8734
8735   /* Manufacture a printf sequence.  */
8736   struct command_line *printf_cmd_line
8737     = new struct command_line (simple_control, printf_line);
8738   breakpoint_set_commands (b, counted_command_line (printf_cmd_line,
8739                                                     command_lines_deleter ()));
8740 }
8741
8742 /* Update all dprintf commands, making their command lists reflect
8743    current style settings.  */
8744
8745 static void
8746 update_dprintf_commands (const char *args, int from_tty,
8747                          struct cmd_list_element *c)
8748 {
8749   struct breakpoint *b;
8750
8751   ALL_BREAKPOINTS (b)
8752     {
8753       if (b->type == bp_dprintf)
8754         update_dprintf_command_list (b);
8755     }
8756 }
8757
8758 /* Create a breakpoint with SAL as location.  Use LOCATION
8759    as a description of the location, and COND_STRING
8760    as condition expression.  If LOCATION is NULL then create an
8761    "address location" from the address in the SAL.  */
8762
8763 static void
8764 init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
8765                      gdb::array_view<const symtab_and_line> sals,
8766                      event_location_up &&location,
8767                      gdb::unique_xmalloc_ptr<char> filter,
8768                      gdb::unique_xmalloc_ptr<char> cond_string,
8769                      gdb::unique_xmalloc_ptr<char> extra_string,
8770                      enum bptype type, enum bpdisp disposition,
8771                      int thread, int task, int ignore_count,
8772                      const struct breakpoint_ops *ops, int from_tty,
8773                      int enabled, int internal, unsigned flags,
8774                      int display_canonical)
8775 {
8776   int i;
8777
8778   if (type == bp_hardware_breakpoint)
8779     {
8780       int target_resources_ok;
8781
8782       i = hw_breakpoint_used_count ();
8783       target_resources_ok =
8784         target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
8785                                             i + 1, 0);
8786       if (target_resources_ok == 0)
8787         error (_("No hardware breakpoint support in the target."));
8788       else if (target_resources_ok < 0)
8789         error (_("Hardware breakpoints used exceeds limit."));
8790     }
8791
8792   gdb_assert (!sals.empty ());
8793
8794   for (const auto &sal : sals)
8795     {
8796       struct bp_location *loc;
8797
8798       if (from_tty)
8799         {
8800           struct gdbarch *loc_gdbarch = get_sal_arch (sal);
8801           if (!loc_gdbarch)
8802             loc_gdbarch = gdbarch;
8803
8804           describe_other_breakpoints (loc_gdbarch,
8805                                       sal.pspace, sal.pc, sal.section, thread);
8806         }
8807
8808       if (&sal == &sals[0])
8809         {
8810           init_raw_breakpoint (b, gdbarch, sal, type, ops);
8811           b->thread = thread;
8812           b->task = task;
8813
8814           b->cond_string = cond_string.release ();
8815           b->extra_string = extra_string.release ();
8816           b->ignore_count = ignore_count;
8817           b->enable_state = enabled ? bp_enabled : bp_disabled;
8818           b->disposition = disposition;
8819
8820           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8821             b->loc->inserted = 1;
8822
8823           if (type == bp_static_tracepoint)
8824             {
8825               struct tracepoint *t = (struct tracepoint *) b;
8826               struct static_tracepoint_marker marker;
8827
8828               if (strace_marker_p (b))
8829                 {
8830                   /* We already know the marker exists, otherwise, we
8831                      wouldn't see a sal for it.  */
8832                   const char *p
8833                     = &event_location_to_string (b->location.get ())[3];
8834                   const char *endp;
8835
8836                   p = skip_spaces (p);
8837
8838                   endp = skip_to_space (p);
8839
8840                   t->static_trace_marker_id.assign (p, endp - p);
8841
8842                   printf_filtered (_("Probed static tracepoint "
8843                                      "marker \"%s\"\n"),
8844                                    t->static_trace_marker_id.c_str ());
8845                 }
8846               else if (target_static_tracepoint_marker_at (sal.pc, &marker))
8847                 {
8848                   t->static_trace_marker_id = std::move (marker.str_id);
8849
8850                   printf_filtered (_("Probed static tracepoint "
8851                                      "marker \"%s\"\n"),
8852                                    t->static_trace_marker_id.c_str ());
8853                 }
8854               else
8855                 warning (_("Couldn't determine the static "
8856                            "tracepoint marker to probe"));
8857             }
8858
8859           loc = b->loc;
8860         }
8861       else
8862         {
8863           loc = add_location_to_breakpoint (b, &sal);
8864           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8865             loc->inserted = 1;
8866         }
8867
8868       if (b->cond_string)
8869         {
8870           const char *arg = b->cond_string;
8871
8872           loc->cond = parse_exp_1 (&arg, loc->address,
8873                                    block_for_pc (loc->address), 0);
8874           if (*arg)
8875               error (_("Garbage '%s' follows condition"), arg);
8876         }
8877
8878       /* Dynamic printf requires and uses additional arguments on the
8879          command line, otherwise it's an error.  */
8880       if (type == bp_dprintf)
8881         {
8882           if (b->extra_string)
8883             update_dprintf_command_list (b);
8884           else
8885             error (_("Format string required"));
8886         }
8887       else if (b->extra_string)
8888         error (_("Garbage '%s' at end of command"), b->extra_string);
8889     }
8890
8891   b->display_canonical = display_canonical;
8892   if (location != NULL)
8893     b->location = std::move (location);
8894   else
8895     b->location = new_address_location (b->loc->address, NULL, 0);
8896   b->filter = filter.release ();
8897 }
8898
8899 static void
8900 create_breakpoint_sal (struct gdbarch *gdbarch,
8901                        gdb::array_view<const symtab_and_line> sals,
8902                        event_location_up &&location,
8903                        gdb::unique_xmalloc_ptr<char> filter,
8904                        gdb::unique_xmalloc_ptr<char> cond_string,
8905                        gdb::unique_xmalloc_ptr<char> extra_string,
8906                        enum bptype type, enum bpdisp disposition,
8907                        int thread, int task, int ignore_count,
8908                        const struct breakpoint_ops *ops, int from_tty,
8909                        int enabled, int internal, unsigned flags,
8910                        int display_canonical)
8911 {
8912   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (type);
8913
8914   init_breakpoint_sal (b.get (), gdbarch,
8915                        sals, std::move (location),
8916                        std::move (filter),
8917                        std::move (cond_string),
8918                        std::move (extra_string),
8919                        type, disposition,
8920                        thread, task, ignore_count,
8921                        ops, from_tty,
8922                        enabled, internal, flags,
8923                        display_canonical);
8924
8925   install_breakpoint (internal, std::move (b), 0);
8926 }
8927
8928 /* Add SALS.nelts breakpoints to the breakpoint table.  For each
8929    SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
8930    value.  COND_STRING, if not NULL, specified the condition to be
8931    used for all breakpoints.  Essentially the only case where
8932    SALS.nelts is not 1 is when we set a breakpoint on an overloaded
8933    function.  In that case, it's still not possible to specify
8934    separate conditions for different overloaded functions, so
8935    we take just a single condition string.
8936    
8937    NOTE: If the function succeeds, the caller is expected to cleanup
8938    the arrays ADDR_STRING, COND_STRING, and SALS (but not the
8939    array contents).  If the function fails (error() is called), the
8940    caller is expected to cleanups both the ADDR_STRING, COND_STRING,
8941    COND and SALS arrays and each of those arrays contents.  */
8942
8943 static void
8944 create_breakpoints_sal (struct gdbarch *gdbarch,
8945                         struct linespec_result *canonical,
8946                         gdb::unique_xmalloc_ptr<char> cond_string,
8947                         gdb::unique_xmalloc_ptr<char> extra_string,
8948                         enum bptype type, enum bpdisp disposition,
8949                         int thread, int task, int ignore_count,
8950                         const struct breakpoint_ops *ops, int from_tty,
8951                         int enabled, int internal, unsigned flags)
8952 {
8953   if (canonical->pre_expanded)
8954     gdb_assert (canonical->lsals.size () == 1);
8955
8956   for (const auto &lsal : canonical->lsals)
8957     {
8958       /* Note that 'location' can be NULL in the case of a plain
8959          'break', without arguments.  */
8960       event_location_up location
8961         = (canonical->location != NULL
8962            ? copy_event_location (canonical->location.get ()) : NULL);
8963       gdb::unique_xmalloc_ptr<char> filter_string
8964         (lsal.canonical != NULL ? xstrdup (lsal.canonical) : NULL);
8965
8966       create_breakpoint_sal (gdbarch, lsal.sals,
8967                              std::move (location),
8968                              std::move (filter_string),
8969                              std::move (cond_string),
8970                              std::move (extra_string),
8971                              type, disposition,
8972                              thread, task, ignore_count, ops,
8973                              from_tty, enabled, internal, flags,
8974                              canonical->special_display);
8975     }
8976 }
8977
8978 /* Parse LOCATION which is assumed to be a SAL specification possibly
8979    followed by conditionals.  On return, SALS contains an array of SAL
8980    addresses found.  LOCATION points to the end of the SAL (for
8981    linespec locations).
8982
8983    The array and the line spec strings are allocated on the heap, it is
8984    the caller's responsibility to free them.  */
8985
8986 static void
8987 parse_breakpoint_sals (const struct event_location *location,
8988                        struct linespec_result *canonical)
8989 {
8990   struct symtab_and_line cursal;
8991
8992   if (event_location_type (location) == LINESPEC_LOCATION)
8993     {
8994       const char *spec = get_linespec_location (location)->spec_string;
8995
8996       if (spec == NULL)
8997         {
8998           /* The last displayed codepoint, if it's valid, is our default
8999              breakpoint address.  */
9000           if (last_displayed_sal_is_valid ())
9001             {
9002               /* Set sal's pspace, pc, symtab, and line to the values
9003                  corresponding to the last call to print_frame_info.
9004                  Be sure to reinitialize LINE with NOTCURRENT == 0
9005                  as the breakpoint line number is inappropriate otherwise.
9006                  find_pc_line would adjust PC, re-set it back.  */
9007               symtab_and_line sal = get_last_displayed_sal ();
9008               CORE_ADDR pc = sal.pc;
9009
9010               sal = find_pc_line (pc, 0);
9011
9012               /* "break" without arguments is equivalent to "break *PC"
9013                  where PC is the last displayed codepoint's address.  So
9014                  make sure to set sal.explicit_pc to prevent GDB from
9015                  trying to expand the list of sals to include all other
9016                  instances with the same symtab and line.  */
9017               sal.pc = pc;
9018               sal.explicit_pc = 1;
9019
9020               struct linespec_sals lsal;
9021               lsal.sals = {sal};
9022               lsal.canonical = NULL;
9023
9024               canonical->lsals.push_back (std::move (lsal));
9025               return;
9026             }
9027           else
9028             error (_("No default breakpoint address now."));
9029         }
9030     }
9031
9032   /* Force almost all breakpoints to be in terms of the
9033      current_source_symtab (which is decode_line_1's default).
9034      This should produce the results we want almost all of the
9035      time while leaving default_breakpoint_* alone.
9036
9037      ObjC: However, don't match an Objective-C method name which
9038      may have a '+' or '-' succeeded by a '['.  */
9039   cursal = get_current_source_symtab_and_line ();
9040   if (last_displayed_sal_is_valid ())
9041     {
9042       const char *spec = NULL;
9043
9044       if (event_location_type (location) == LINESPEC_LOCATION)
9045         spec = get_linespec_location (location)->spec_string;
9046
9047       if (!cursal.symtab
9048           || (spec != NULL
9049               && strchr ("+-", spec[0]) != NULL
9050               && spec[1] != '['))
9051         {
9052           decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9053                             get_last_displayed_symtab (),
9054                             get_last_displayed_line (),
9055                             canonical, NULL, NULL);
9056           return;
9057         }
9058     }
9059
9060   decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9061                     cursal.symtab, cursal.line, canonical, NULL, NULL);
9062 }
9063
9064
9065 /* Convert each SAL into a real PC.  Verify that the PC can be
9066    inserted as a breakpoint.  If it can't throw an error.  */
9067
9068 static void
9069 breakpoint_sals_to_pc (std::vector<symtab_and_line> &sals)
9070 {    
9071   for (auto &sal : sals)
9072     resolve_sal_pc (&sal);
9073 }
9074
9075 /* Fast tracepoints may have restrictions on valid locations.  For
9076    instance, a fast tracepoint using a jump instead of a trap will
9077    likely have to overwrite more bytes than a trap would, and so can
9078    only be placed where the instruction is longer than the jump, or a
9079    multi-instruction sequence does not have a jump into the middle of
9080    it, etc.  */
9081
9082 static void
9083 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9084                             gdb::array_view<const symtab_and_line> sals)
9085 {
9086   for (const auto &sal : sals)
9087     {
9088       struct gdbarch *sarch;
9089
9090       sarch = get_sal_arch (sal);
9091       /* We fall back to GDBARCH if there is no architecture
9092          associated with SAL.  */
9093       if (sarch == NULL)
9094         sarch = gdbarch;
9095       std::string msg;
9096       if (!gdbarch_fast_tracepoint_valid_at (sarch, sal.pc, &msg))
9097         error (_("May not have a fast tracepoint at %s%s"),
9098                paddress (sarch, sal.pc), msg.c_str ());
9099     }
9100 }
9101
9102 /* Given TOK, a string specification of condition and thread, as
9103    accepted by the 'break' command, extract the condition
9104    string and thread number and set *COND_STRING and *THREAD.
9105    PC identifies the context at which the condition should be parsed.
9106    If no condition is found, *COND_STRING is set to NULL.
9107    If no thread is found, *THREAD is set to -1.  */
9108
9109 static void
9110 find_condition_and_thread (const char *tok, CORE_ADDR pc,
9111                            char **cond_string, int *thread, int *task,
9112                            char **rest)
9113 {
9114   *cond_string = NULL;
9115   *thread = -1;
9116   *task = 0;
9117   *rest = NULL;
9118
9119   while (tok && *tok)
9120     {
9121       const char *end_tok;
9122       int toklen;
9123       const char *cond_start = NULL;
9124       const char *cond_end = NULL;
9125
9126       tok = skip_spaces (tok);
9127
9128       if ((*tok == '"' || *tok == ',') && rest)
9129         {
9130           *rest = savestring (tok, strlen (tok));
9131           return;
9132         }
9133
9134       end_tok = skip_to_space (tok);
9135
9136       toklen = end_tok - tok;
9137
9138       if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9139         {
9140           tok = cond_start = end_tok + 1;
9141           parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
9142           cond_end = tok;
9143           *cond_string = savestring (cond_start, cond_end - cond_start);
9144         }
9145       else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9146         {
9147           const char *tmptok;
9148           struct thread_info *thr;
9149
9150           tok = end_tok + 1;
9151           thr = parse_thread_id (tok, &tmptok);
9152           if (tok == tmptok)
9153             error (_("Junk after thread keyword."));
9154           *thread = thr->global_num;
9155           tok = tmptok;
9156         }
9157       else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9158         {
9159           char *tmptok;
9160
9161           tok = end_tok + 1;
9162           *task = strtol (tok, &tmptok, 0);
9163           if (tok == tmptok)
9164             error (_("Junk after task keyword."));
9165           if (!valid_task_id (*task))
9166             error (_("Unknown task %d."), *task);
9167           tok = tmptok;
9168         }
9169       else if (rest)
9170         {
9171           *rest = savestring (tok, strlen (tok));
9172           return;
9173         }
9174       else
9175         error (_("Junk at end of arguments."));
9176     }
9177 }
9178
9179 /* Decode a static tracepoint marker spec.  */
9180
9181 static std::vector<symtab_and_line>
9182 decode_static_tracepoint_spec (const char **arg_p)
9183 {
9184   const char *p = &(*arg_p)[3];
9185   const char *endp;
9186
9187   p = skip_spaces (p);
9188
9189   endp = skip_to_space (p);
9190
9191   std::string marker_str (p, endp - p);
9192
9193   std::vector<static_tracepoint_marker> markers
9194     = target_static_tracepoint_markers_by_strid (marker_str.c_str ());
9195   if (markers.empty ())
9196     error (_("No known static tracepoint marker named %s"),
9197            marker_str.c_str ());
9198
9199   std::vector<symtab_and_line> sals;
9200   sals.reserve (markers.size ());
9201
9202   for (const static_tracepoint_marker &marker : markers)
9203     {
9204       symtab_and_line sal = find_pc_line (marker.address, 0);
9205       sal.pc = marker.address;
9206       sals.push_back (sal);
9207    }
9208
9209   *arg_p = endp;
9210   return sals;
9211 }
9212
9213 /* See breakpoint.h.  */
9214
9215 int
9216 create_breakpoint (struct gdbarch *gdbarch,
9217                    const struct event_location *location,
9218                    const char *cond_string,
9219                    int thread, const char *extra_string,
9220                    int parse_extra,
9221                    int tempflag, enum bptype type_wanted,
9222                    int ignore_count,
9223                    enum auto_boolean pending_break_support,
9224                    const struct breakpoint_ops *ops,
9225                    int from_tty, int enabled, int internal,
9226                    unsigned flags)
9227 {
9228   struct linespec_result canonical;
9229   int pending = 0;
9230   int task = 0;
9231   int prev_bkpt_count = breakpoint_count;
9232
9233   gdb_assert (ops != NULL);
9234
9235   /* If extra_string isn't useful, set it to NULL.  */
9236   if (extra_string != NULL && *extra_string == '\0')
9237     extra_string = NULL;
9238
9239   TRY
9240     {
9241       ops->create_sals_from_location (location, &canonical, type_wanted);
9242     }
9243   CATCH (e, RETURN_MASK_ERROR)
9244     {
9245       /* If caller is interested in rc value from parse, set
9246          value.  */
9247       if (e.error == NOT_FOUND_ERROR)
9248         {
9249           /* If pending breakpoint support is turned off, throw
9250              error.  */
9251
9252           if (pending_break_support == AUTO_BOOLEAN_FALSE)
9253             throw_exception (e);
9254
9255           exception_print (gdb_stderr, e);
9256
9257           /* If pending breakpoint support is auto query and the user
9258              selects no, then simply return the error code.  */
9259           if (pending_break_support == AUTO_BOOLEAN_AUTO
9260               && !nquery (_("Make %s pending on future shared library load? "),
9261                           bptype_string (type_wanted)))
9262             return 0;
9263
9264           /* At this point, either the user was queried about setting
9265              a pending breakpoint and selected yes, or pending
9266              breakpoint behavior is on and thus a pending breakpoint
9267              is defaulted on behalf of the user.  */
9268           pending = 1;
9269         }
9270       else
9271         throw_exception (e);
9272     }
9273   END_CATCH
9274
9275   if (!pending && canonical.lsals.empty ())
9276     return 0;
9277
9278   /* Resolve all line numbers to PC's and verify that the addresses
9279      are ok for the target.  */
9280   if (!pending)
9281     {
9282       for (auto &lsal : canonical.lsals)
9283         breakpoint_sals_to_pc (lsal.sals);
9284     }
9285
9286   /* Fast tracepoints may have additional restrictions on location.  */
9287   if (!pending && type_wanted == bp_fast_tracepoint)
9288     {
9289       for (const auto &lsal : canonical.lsals)
9290         check_fast_tracepoint_sals (gdbarch, lsal.sals);
9291     }
9292
9293   /* Verify that condition can be parsed, before setting any
9294      breakpoints.  Allocate a separate condition expression for each
9295      breakpoint.  */
9296   if (!pending)
9297     {
9298       gdb::unique_xmalloc_ptr<char> cond_string_copy;
9299       gdb::unique_xmalloc_ptr<char> extra_string_copy;
9300
9301       if (parse_extra)
9302         {
9303           char *rest;
9304           char *cond;
9305
9306           const linespec_sals &lsal = canonical.lsals[0];
9307
9308           /* Here we only parse 'arg' to separate condition
9309              from thread number, so parsing in context of first
9310              sal is OK.  When setting the breakpoint we'll
9311              re-parse it in context of each sal.  */
9312
9313           find_condition_and_thread (extra_string, lsal.sals[0].pc,
9314                                      &cond, &thread, &task, &rest);
9315           cond_string_copy.reset (cond);
9316           extra_string_copy.reset (rest);
9317         }
9318       else
9319         {
9320           if (type_wanted != bp_dprintf
9321               && extra_string != NULL && *extra_string != '\0')
9322                 error (_("Garbage '%s' at end of location"), extra_string);
9323
9324           /* Create a private copy of condition string.  */
9325           if (cond_string)
9326             cond_string_copy.reset (xstrdup (cond_string));
9327           /* Create a private copy of any extra string.  */
9328           if (extra_string)
9329             extra_string_copy.reset (xstrdup (extra_string));
9330         }
9331
9332       ops->create_breakpoints_sal (gdbarch, &canonical,
9333                                    std::move (cond_string_copy),
9334                                    std::move (extra_string_copy),
9335                                    type_wanted,
9336                                    tempflag ? disp_del : disp_donttouch,
9337                                    thread, task, ignore_count, ops,
9338                                    from_tty, enabled, internal, flags);
9339     }
9340   else
9341     {
9342       std::unique_ptr <breakpoint> b = new_breakpoint_from_type (type_wanted);
9343
9344       init_raw_breakpoint_without_location (b.get (), gdbarch, type_wanted, ops);
9345       b->location = copy_event_location (location);
9346
9347       if (parse_extra)
9348         b->cond_string = NULL;
9349       else
9350         {
9351           /* Create a private copy of condition string.  */
9352           b->cond_string = cond_string != NULL ? xstrdup (cond_string) : NULL;
9353           b->thread = thread;
9354         }
9355
9356       /* Create a private copy of any extra string.  */
9357       b->extra_string = extra_string != NULL ? xstrdup (extra_string) : NULL;
9358       b->ignore_count = ignore_count;
9359       b->disposition = tempflag ? disp_del : disp_donttouch;
9360       b->condition_not_parsed = 1;
9361       b->enable_state = enabled ? bp_enabled : bp_disabled;
9362       if ((type_wanted != bp_breakpoint
9363            && type_wanted != bp_hardware_breakpoint) || thread != -1)
9364         b->pspace = current_program_space;
9365
9366       install_breakpoint (internal, std::move (b), 0);
9367     }
9368   
9369   if (canonical.lsals.size () > 1)
9370     {
9371       warning (_("Multiple breakpoints were set.\nUse the "
9372                  "\"delete\" command to delete unwanted breakpoints."));
9373       prev_breakpoint_count = prev_bkpt_count;
9374     }
9375
9376   update_global_location_list (UGLL_MAY_INSERT);
9377
9378   return 1;
9379 }
9380
9381 /* Set a breakpoint.
9382    ARG is a string describing breakpoint address,
9383    condition, and thread.
9384    FLAG specifies if a breakpoint is hardware on,
9385    and if breakpoint is temporary, using BP_HARDWARE_FLAG
9386    and BP_TEMPFLAG.  */
9387
9388 static void
9389 break_command_1 (const char *arg, int flag, int from_tty)
9390 {
9391   int tempflag = flag & BP_TEMPFLAG;
9392   enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9393                              ? bp_hardware_breakpoint
9394                              : bp_breakpoint);
9395   struct breakpoint_ops *ops;
9396
9397   event_location_up location = string_to_event_location (&arg, current_language);
9398
9399   /* Matching breakpoints on probes.  */
9400   if (location != NULL
9401       && event_location_type (location.get ()) == PROBE_LOCATION)
9402     ops = &bkpt_probe_breakpoint_ops;
9403   else
9404     ops = &bkpt_breakpoint_ops;
9405
9406   create_breakpoint (get_current_arch (),
9407                      location.get (),
9408                      NULL, 0, arg, 1 /* parse arg */,
9409                      tempflag, type_wanted,
9410                      0 /* Ignore count */,
9411                      pending_break_support,
9412                      ops,
9413                      from_tty,
9414                      1 /* enabled */,
9415                      0 /* internal */,
9416                      0);
9417 }
9418
9419 /* Helper function for break_command_1 and disassemble_command.  */
9420
9421 void
9422 resolve_sal_pc (struct symtab_and_line *sal)
9423 {
9424   CORE_ADDR pc;
9425
9426   if (sal->pc == 0 && sal->symtab != NULL)
9427     {
9428       if (!find_line_pc (sal->symtab, sal->line, &pc))
9429         error (_("No line %d in file \"%s\"."),
9430                sal->line, symtab_to_filename_for_display (sal->symtab));
9431       sal->pc = pc;
9432
9433       /* If this SAL corresponds to a breakpoint inserted using a line
9434          number, then skip the function prologue if necessary.  */
9435       if (sal->explicit_line)
9436         skip_prologue_sal (sal);
9437     }
9438
9439   if (sal->section == 0 && sal->symtab != NULL)
9440     {
9441       const struct blockvector *bv;
9442       const struct block *b;
9443       struct symbol *sym;
9444
9445       bv = blockvector_for_pc_sect (sal->pc, 0, &b,
9446                                     SYMTAB_COMPUNIT (sal->symtab));
9447       if (bv != NULL)
9448         {
9449           sym = block_linkage_function (b);
9450           if (sym != NULL)
9451             {
9452               fixup_symbol_section (sym, SYMTAB_OBJFILE (sal->symtab));
9453               sal->section = SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal->symtab),
9454                                                  sym);
9455             }
9456           else
9457             {
9458               /* It really is worthwhile to have the section, so we'll
9459                  just have to look harder. This case can be executed
9460                  if we have line numbers but no functions (as can
9461                  happen in assembly source).  */
9462
9463               scoped_restore_current_pspace_and_thread restore_pspace_thread;
9464               switch_to_program_space_and_thread (sal->pspace);
9465
9466               bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (sal->pc);
9467               if (msym.minsym)
9468                 sal->section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
9469             }
9470         }
9471     }
9472 }
9473
9474 void
9475 break_command (const char *arg, int from_tty)
9476 {
9477   break_command_1 (arg, 0, from_tty);
9478 }
9479
9480 void
9481 tbreak_command (const char *arg, int from_tty)
9482 {
9483   break_command_1 (arg, BP_TEMPFLAG, from_tty);
9484 }
9485
9486 static void
9487 hbreak_command (const char *arg, int from_tty)
9488 {
9489   break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
9490 }
9491
9492 static void
9493 thbreak_command (const char *arg, int from_tty)
9494 {
9495   break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
9496 }
9497
9498 static void
9499 stop_command (const char *arg, int from_tty)
9500 {
9501   printf_filtered (_("Specify the type of breakpoint to set.\n\
9502 Usage: stop in <function | address>\n\
9503        stop at <line>\n"));
9504 }
9505
9506 static void
9507 stopin_command (const char *arg, int from_tty)
9508 {
9509   int badInput = 0;
9510
9511   if (arg == (char *) NULL)
9512     badInput = 1;
9513   else if (*arg != '*')
9514     {
9515       const char *argptr = arg;
9516       int hasColon = 0;
9517
9518       /* Look for a ':'.  If this is a line number specification, then
9519          say it is bad, otherwise, it should be an address or
9520          function/method name.  */
9521       while (*argptr && !hasColon)
9522         {
9523           hasColon = (*argptr == ':');
9524           argptr++;
9525         }
9526
9527       if (hasColon)
9528         badInput = (*argptr != ':');    /* Not a class::method */
9529       else
9530         badInput = isdigit (*arg);      /* a simple line number */
9531     }
9532
9533   if (badInput)
9534     printf_filtered (_("Usage: stop in <function | address>\n"));
9535   else
9536     break_command_1 (arg, 0, from_tty);
9537 }
9538
9539 static void
9540 stopat_command (const char *arg, int from_tty)
9541 {
9542   int badInput = 0;
9543
9544   if (arg == (char *) NULL || *arg == '*')      /* no line number */
9545     badInput = 1;
9546   else
9547     {
9548       const char *argptr = arg;
9549       int hasColon = 0;
9550
9551       /* Look for a ':'.  If there is a '::' then get out, otherwise
9552          it is probably a line number.  */
9553       while (*argptr && !hasColon)
9554         {
9555           hasColon = (*argptr == ':');
9556           argptr++;
9557         }
9558
9559       if (hasColon)
9560         badInput = (*argptr == ':');    /* we have class::method */
9561       else
9562         badInput = !isdigit (*arg);     /* not a line number */
9563     }
9564
9565   if (badInput)
9566     printf_filtered (_("Usage: stop at LINE\n"));
9567   else
9568     break_command_1 (arg, 0, from_tty);
9569 }
9570
9571 /* The dynamic printf command is mostly like a regular breakpoint, but
9572    with a prewired command list consisting of a single output command,
9573    built from extra arguments supplied on the dprintf command
9574    line.  */
9575
9576 static void
9577 dprintf_command (const char *arg, int from_tty)
9578 {
9579   event_location_up location = string_to_event_location (&arg, current_language);
9580
9581   /* If non-NULL, ARG should have been advanced past the location;
9582      the next character must be ','.  */
9583   if (arg != NULL)
9584     {
9585       if (arg[0] != ',' || arg[1] == '\0')
9586         error (_("Format string required"));
9587       else
9588         {
9589           /* Skip the comma.  */
9590           ++arg;
9591         }
9592     }
9593
9594   create_breakpoint (get_current_arch (),
9595                      location.get (),
9596                      NULL, 0, arg, 1 /* parse arg */,
9597                      0, bp_dprintf,
9598                      0 /* Ignore count */,
9599                      pending_break_support,
9600                      &dprintf_breakpoint_ops,
9601                      from_tty,
9602                      1 /* enabled */,
9603                      0 /* internal */,
9604                      0);
9605 }
9606
9607 static void
9608 agent_printf_command (const char *arg, int from_tty)
9609 {
9610   error (_("May only run agent-printf on the target"));
9611 }
9612
9613 /* Implement the "breakpoint_hit" breakpoint_ops method for
9614    ranged breakpoints.  */
9615
9616 static int
9617 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
9618                                   const address_space *aspace,
9619                                   CORE_ADDR bp_addr,
9620                                   const struct target_waitstatus *ws)
9621 {
9622   if (ws->kind != TARGET_WAITKIND_STOPPED
9623       || ws->value.sig != GDB_SIGNAL_TRAP)
9624     return 0;
9625
9626   return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
9627                                          bl->length, aspace, bp_addr);
9628 }
9629
9630 /* Implement the "resources_needed" breakpoint_ops method for
9631    ranged breakpoints.  */
9632
9633 static int
9634 resources_needed_ranged_breakpoint (const struct bp_location *bl)
9635 {
9636   return target_ranged_break_num_registers ();
9637 }
9638
9639 /* Implement the "print_it" breakpoint_ops method for
9640    ranged breakpoints.  */
9641
9642 static enum print_stop_action
9643 print_it_ranged_breakpoint (bpstat bs)
9644 {
9645   struct breakpoint *b = bs->breakpoint_at;
9646   struct bp_location *bl = b->loc;
9647   struct ui_out *uiout = current_uiout;
9648
9649   gdb_assert (b->type == bp_hardware_breakpoint);
9650
9651   /* Ranged breakpoints have only one location.  */
9652   gdb_assert (bl && bl->next == NULL);
9653
9654   annotate_breakpoint (b->number);
9655
9656   maybe_print_thread_hit_breakpoint (uiout);
9657
9658   if (b->disposition == disp_del)
9659     uiout->text ("Temporary ranged breakpoint ");
9660   else
9661     uiout->text ("Ranged breakpoint ");
9662   if (uiout->is_mi_like_p ())
9663     {
9664       uiout->field_string ("reason",
9665                       async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9666       uiout->field_string ("disp", bpdisp_text (b->disposition));
9667     }
9668   uiout->field_int ("bkptno", b->number);
9669   uiout->text (", ");
9670
9671   return PRINT_SRC_AND_LOC;
9672 }
9673
9674 /* Implement the "print_one" breakpoint_ops method for
9675    ranged breakpoints.  */
9676
9677 static void
9678 print_one_ranged_breakpoint (struct breakpoint *b,
9679                              struct bp_location **last_loc)
9680 {
9681   struct bp_location *bl = b->loc;
9682   struct value_print_options opts;
9683   struct ui_out *uiout = current_uiout;
9684
9685   /* Ranged breakpoints have only one location.  */
9686   gdb_assert (bl && bl->next == NULL);
9687
9688   get_user_print_options (&opts);
9689
9690   if (opts.addressprint)
9691     /* We don't print the address range here, it will be printed later
9692        by print_one_detail_ranged_breakpoint.  */
9693     uiout->field_skip ("addr");
9694   annotate_field (5);
9695   print_breakpoint_location (b, bl);
9696   *last_loc = bl;
9697 }
9698
9699 /* Implement the "print_one_detail" breakpoint_ops method for
9700    ranged breakpoints.  */
9701
9702 static void
9703 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
9704                                     struct ui_out *uiout)
9705 {
9706   CORE_ADDR address_start, address_end;
9707   struct bp_location *bl = b->loc;
9708   string_file stb;
9709
9710   gdb_assert (bl);
9711
9712   address_start = bl->address;
9713   address_end = address_start + bl->length - 1;
9714
9715   uiout->text ("\taddress range: ");
9716   stb.printf ("[%s, %s]",
9717               print_core_address (bl->gdbarch, address_start),
9718               print_core_address (bl->gdbarch, address_end));
9719   uiout->field_stream ("addr", stb);
9720   uiout->text ("\n");
9721 }
9722
9723 /* Implement the "print_mention" breakpoint_ops method for
9724    ranged breakpoints.  */
9725
9726 static void
9727 print_mention_ranged_breakpoint (struct breakpoint *b)
9728 {
9729   struct bp_location *bl = b->loc;
9730   struct ui_out *uiout = current_uiout;
9731
9732   gdb_assert (bl);
9733   gdb_assert (b->type == bp_hardware_breakpoint);
9734
9735   uiout->message (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9736                   b->number, paddress (bl->gdbarch, bl->address),
9737                   paddress (bl->gdbarch, bl->address + bl->length - 1));
9738 }
9739
9740 /* Implement the "print_recreate" breakpoint_ops method for
9741    ranged breakpoints.  */
9742
9743 static void
9744 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
9745 {
9746   fprintf_unfiltered (fp, "break-range %s, %s",
9747                       event_location_to_string (b->location.get ()),
9748                       event_location_to_string (b->location_range_end.get ()));
9749   print_recreate_thread (b, fp);
9750 }
9751
9752 /* The breakpoint_ops structure to be used in ranged breakpoints.  */
9753
9754 static struct breakpoint_ops ranged_breakpoint_ops;
9755
9756 /* Find the address where the end of the breakpoint range should be
9757    placed, given the SAL of the end of the range.  This is so that if
9758    the user provides a line number, the end of the range is set to the
9759    last instruction of the given line.  */
9760
9761 static CORE_ADDR
9762 find_breakpoint_range_end (struct symtab_and_line sal)
9763 {
9764   CORE_ADDR end;
9765
9766   /* If the user provided a PC value, use it.  Otherwise,
9767      find the address of the end of the given location.  */
9768   if (sal.explicit_pc)
9769     end = sal.pc;
9770   else
9771     {
9772       int ret;
9773       CORE_ADDR start;
9774
9775       ret = find_line_pc_range (sal, &start, &end);
9776       if (!ret)
9777         error (_("Could not find location of the end of the range."));
9778
9779       /* find_line_pc_range returns the start of the next line.  */
9780       end--;
9781     }
9782
9783   return end;
9784 }
9785
9786 /* Implement the "break-range" CLI command.  */
9787
9788 static void
9789 break_range_command (const char *arg, int from_tty)
9790 {
9791   const char *arg_start;
9792   struct linespec_result canonical_start, canonical_end;
9793   int bp_count, can_use_bp, length;
9794   CORE_ADDR end;
9795   struct breakpoint *b;
9796
9797   /* We don't support software ranged breakpoints.  */
9798   if (target_ranged_break_num_registers () < 0)
9799     error (_("This target does not support hardware ranged breakpoints."));
9800
9801   bp_count = hw_breakpoint_used_count ();
9802   bp_count += target_ranged_break_num_registers ();
9803   can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
9804                                                    bp_count, 0);
9805   if (can_use_bp < 0)
9806     error (_("Hardware breakpoints used exceeds limit."));
9807
9808   arg = skip_spaces (arg);
9809   if (arg == NULL || arg[0] == '\0')
9810     error(_("No address range specified."));
9811
9812   arg_start = arg;
9813   event_location_up start_location = string_to_event_location (&arg,
9814                                                                current_language);
9815   parse_breakpoint_sals (start_location.get (), &canonical_start);
9816
9817   if (arg[0] != ',')
9818     error (_("Too few arguments."));
9819   else if (canonical_start.lsals.empty ())
9820     error (_("Could not find location of the beginning of the range."));
9821
9822   const linespec_sals &lsal_start = canonical_start.lsals[0];
9823
9824   if (canonical_start.lsals.size () > 1
9825       || lsal_start.sals.size () != 1)
9826     error (_("Cannot create a ranged breakpoint with multiple locations."));
9827
9828   const symtab_and_line &sal_start = lsal_start.sals[0];
9829   std::string addr_string_start (arg_start, arg - arg_start);
9830
9831   arg++;        /* Skip the comma.  */
9832   arg = skip_spaces (arg);
9833
9834   /* Parse the end location.  */
9835
9836   arg_start = arg;
9837
9838   /* We call decode_line_full directly here instead of using
9839      parse_breakpoint_sals because we need to specify the start location's
9840      symtab and line as the default symtab and line for the end of the
9841      range.  This makes it possible to have ranges like "foo.c:27, +14",
9842      where +14 means 14 lines from the start location.  */
9843   event_location_up end_location = string_to_event_location (&arg,
9844                                                              current_language);
9845   decode_line_full (end_location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
9846                     sal_start.symtab, sal_start.line,
9847                     &canonical_end, NULL, NULL);
9848
9849   if (canonical_end.lsals.empty ())
9850     error (_("Could not find location of the end of the range."));
9851
9852   const linespec_sals &lsal_end = canonical_end.lsals[0];
9853   if (canonical_end.lsals.size () > 1
9854       || lsal_end.sals.size () != 1)
9855     error (_("Cannot create a ranged breakpoint with multiple locations."));
9856
9857   const symtab_and_line &sal_end = lsal_end.sals[0];
9858
9859   end = find_breakpoint_range_end (sal_end);
9860   if (sal_start.pc > end)
9861     error (_("Invalid address range, end precedes start."));
9862
9863   length = end - sal_start.pc + 1;
9864   if (length < 0)
9865     /* Length overflowed.  */
9866     error (_("Address range too large."));
9867   else if (length == 1)
9868     {
9869       /* This range is simple enough to be handled by
9870          the `hbreak' command.  */
9871       hbreak_command (&addr_string_start[0], 1);
9872
9873       return;
9874     }
9875
9876   /* Now set up the breakpoint.  */
9877   b = set_raw_breakpoint (get_current_arch (), sal_start,
9878                           bp_hardware_breakpoint, &ranged_breakpoint_ops);
9879   set_breakpoint_count (breakpoint_count + 1);
9880   b->number = breakpoint_count;
9881   b->disposition = disp_donttouch;
9882   b->location = std::move (start_location);
9883   b->location_range_end = std::move (end_location);
9884   b->loc->length = length;
9885
9886   mention (b);
9887   gdb::observers::breakpoint_created.notify (b);
9888   update_global_location_list (UGLL_MAY_INSERT);
9889 }
9890
9891 /*  Return non-zero if EXP is verified as constant.  Returned zero
9892     means EXP is variable.  Also the constant detection may fail for
9893     some constant expressions and in such case still falsely return
9894     zero.  */
9895
9896 static int
9897 watchpoint_exp_is_const (const struct expression *exp)
9898 {
9899   int i = exp->nelts;
9900
9901   while (i > 0)
9902     {
9903       int oplenp, argsp;
9904
9905       /* We are only interested in the descriptor of each element.  */
9906       operator_length (exp, i, &oplenp, &argsp);
9907       i -= oplenp;
9908
9909       switch (exp->elts[i].opcode)
9910         {
9911         case BINOP_ADD:
9912         case BINOP_SUB:
9913         case BINOP_MUL:
9914         case BINOP_DIV:
9915         case BINOP_REM:
9916         case BINOP_MOD:
9917         case BINOP_LSH:
9918         case BINOP_RSH:
9919         case BINOP_LOGICAL_AND:
9920         case BINOP_LOGICAL_OR:
9921         case BINOP_BITWISE_AND:
9922         case BINOP_BITWISE_IOR:
9923         case BINOP_BITWISE_XOR:
9924         case BINOP_EQUAL:
9925         case BINOP_NOTEQUAL:
9926         case BINOP_LESS:
9927         case BINOP_GTR:
9928         case BINOP_LEQ:
9929         case BINOP_GEQ:
9930         case BINOP_REPEAT:
9931         case BINOP_COMMA:
9932         case BINOP_EXP:
9933         case BINOP_MIN:
9934         case BINOP_MAX:
9935         case BINOP_INTDIV:
9936         case BINOP_CONCAT:
9937         case TERNOP_COND:
9938         case TERNOP_SLICE:
9939
9940         case OP_LONG:
9941         case OP_FLOAT:
9942         case OP_LAST:
9943         case OP_COMPLEX:
9944         case OP_STRING:
9945         case OP_ARRAY:
9946         case OP_TYPE:
9947         case OP_TYPEOF:
9948         case OP_DECLTYPE:
9949         case OP_TYPEID:
9950         case OP_NAME:
9951         case OP_OBJC_NSSTRING:
9952
9953         case UNOP_NEG:
9954         case UNOP_LOGICAL_NOT:
9955         case UNOP_COMPLEMENT:
9956         case UNOP_ADDR:
9957         case UNOP_HIGH:
9958         case UNOP_CAST:
9959
9960         case UNOP_CAST_TYPE:
9961         case UNOP_REINTERPRET_CAST:
9962         case UNOP_DYNAMIC_CAST:
9963           /* Unary, binary and ternary operators: We have to check
9964              their operands.  If they are constant, then so is the
9965              result of that operation.  For instance, if A and B are
9966              determined to be constants, then so is "A + B".
9967
9968              UNOP_IND is one exception to the rule above, because the
9969              value of *ADDR is not necessarily a constant, even when
9970              ADDR is.  */
9971           break;
9972
9973         case OP_VAR_VALUE:
9974           /* Check whether the associated symbol is a constant.
9975
9976              We use SYMBOL_CLASS rather than TYPE_CONST because it's
9977              possible that a buggy compiler could mark a variable as
9978              constant even when it is not, and TYPE_CONST would return
9979              true in this case, while SYMBOL_CLASS wouldn't.
9980
9981              We also have to check for function symbols because they
9982              are always constant.  */
9983           {
9984             struct symbol *s = exp->elts[i + 2].symbol;
9985
9986             if (SYMBOL_CLASS (s) != LOC_BLOCK
9987                 && SYMBOL_CLASS (s) != LOC_CONST
9988                 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
9989               return 0;
9990             break;
9991           }
9992
9993         /* The default action is to return 0 because we are using
9994            the optimistic approach here: If we don't know something,
9995            then it is not a constant.  */
9996         default:
9997           return 0;
9998         }
9999     }
10000
10001   return 1;
10002 }
10003
10004 /* Watchpoint destructor.  */
10005
10006 watchpoint::~watchpoint ()
10007 {
10008   xfree (this->exp_string);
10009   xfree (this->exp_string_reparse);
10010 }
10011
10012 /* Implement the "re_set" breakpoint_ops method for watchpoints.  */
10013
10014 static void
10015 re_set_watchpoint (struct breakpoint *b)
10016 {
10017   struct watchpoint *w = (struct watchpoint *) b;
10018
10019   /* Watchpoint can be either on expression using entirely global
10020      variables, or it can be on local variables.
10021
10022      Watchpoints of the first kind are never auto-deleted, and even
10023      persist across program restarts.  Since they can use variables
10024      from shared libraries, we need to reparse expression as libraries
10025      are loaded and unloaded.
10026
10027      Watchpoints on local variables can also change meaning as result
10028      of solib event.  For example, if a watchpoint uses both a local
10029      and a global variables in expression, it's a local watchpoint,
10030      but unloading of a shared library will make the expression
10031      invalid.  This is not a very common use case, but we still
10032      re-evaluate expression, to avoid surprises to the user.
10033
10034      Note that for local watchpoints, we re-evaluate it only if
10035      watchpoints frame id is still valid.  If it's not, it means the
10036      watchpoint is out of scope and will be deleted soon.  In fact,
10037      I'm not sure we'll ever be called in this case.
10038
10039      If a local watchpoint's frame id is still valid, then
10040      w->exp_valid_block is likewise valid, and we can safely use it.
10041
10042      Don't do anything about disabled watchpoints, since they will be
10043      reevaluated again when enabled.  */
10044   update_watchpoint (w, 1 /* reparse */);
10045 }
10046
10047 /* Implement the "insert" breakpoint_ops method for hardware watchpoints.  */
10048
10049 static int
10050 insert_watchpoint (struct bp_location *bl)
10051 {
10052   struct watchpoint *w = (struct watchpoint *) bl->owner;
10053   int length = w->exact ? 1 : bl->length;
10054
10055   return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
10056                                    w->cond_exp.get ());
10057 }
10058
10059 /* Implement the "remove" breakpoint_ops method for hardware watchpoints.  */
10060
10061 static int
10062 remove_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10063 {
10064   struct watchpoint *w = (struct watchpoint *) bl->owner;
10065   int length = w->exact ? 1 : bl->length;
10066
10067   return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
10068                                    w->cond_exp.get ());
10069 }
10070
10071 static int
10072 breakpoint_hit_watchpoint (const struct bp_location *bl,
10073                            const address_space *aspace, CORE_ADDR bp_addr,
10074                            const struct target_waitstatus *ws)
10075 {
10076   struct breakpoint *b = bl->owner;
10077   struct watchpoint *w = (struct watchpoint *) b;
10078
10079   /* Continuable hardware watchpoints are treated as non-existent if the
10080      reason we stopped wasn't a hardware watchpoint (we didn't stop on
10081      some data address).  Otherwise gdb won't stop on a break instruction
10082      in the code (not from a breakpoint) when a hardware watchpoint has
10083      been defined.  Also skip watchpoints which we know did not trigger
10084      (did not match the data address).  */
10085   if (is_hardware_watchpoint (b)
10086       && w->watchpoint_triggered == watch_triggered_no)
10087     return 0;
10088
10089   return 1;
10090 }
10091
10092 static void
10093 check_status_watchpoint (bpstat bs)
10094 {
10095   gdb_assert (is_watchpoint (bs->breakpoint_at));
10096
10097   bpstat_check_watchpoint (bs);
10098 }
10099
10100 /* Implement the "resources_needed" breakpoint_ops method for
10101    hardware watchpoints.  */
10102
10103 static int
10104 resources_needed_watchpoint (const struct bp_location *bl)
10105 {
10106   struct watchpoint *w = (struct watchpoint *) bl->owner;
10107   int length = w->exact? 1 : bl->length;
10108
10109   return target_region_ok_for_hw_watchpoint (bl->address, length);
10110 }
10111
10112 /* Implement the "works_in_software_mode" breakpoint_ops method for
10113    hardware watchpoints.  */
10114
10115 static int
10116 works_in_software_mode_watchpoint (const struct breakpoint *b)
10117 {
10118   /* Read and access watchpoints only work with hardware support.  */
10119   return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
10120 }
10121
10122 static enum print_stop_action
10123 print_it_watchpoint (bpstat bs)
10124 {
10125   struct breakpoint *b;
10126   enum print_stop_action result;
10127   struct watchpoint *w;
10128   struct ui_out *uiout = current_uiout;
10129
10130   gdb_assert (bs->bp_location_at != NULL);
10131
10132   b = bs->breakpoint_at;
10133   w = (struct watchpoint *) b;
10134
10135   annotate_watchpoint (b->number);
10136   maybe_print_thread_hit_breakpoint (uiout);
10137
10138   string_file stb;
10139
10140   gdb::optional<ui_out_emit_tuple> tuple_emitter;
10141   switch (b->type)
10142     {
10143     case bp_watchpoint:
10144     case bp_hardware_watchpoint:
10145       if (uiout->is_mi_like_p ())
10146         uiout->field_string
10147           ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10148       mention (b);
10149       tuple_emitter.emplace (uiout, "value");
10150       uiout->text ("\nOld value = ");
10151       watchpoint_value_print (bs->old_val.get (), &stb);
10152       uiout->field_stream ("old", stb);
10153       uiout->text ("\nNew value = ");
10154       watchpoint_value_print (w->val.get (), &stb);
10155       uiout->field_stream ("new", stb);
10156       uiout->text ("\n");
10157       /* More than one watchpoint may have been triggered.  */
10158       result = PRINT_UNKNOWN;
10159       break;
10160
10161     case bp_read_watchpoint:
10162       if (uiout->is_mi_like_p ())
10163         uiout->field_string
10164           ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10165       mention (b);
10166       tuple_emitter.emplace (uiout, "value");
10167       uiout->text ("\nValue = ");
10168       watchpoint_value_print (w->val.get (), &stb);
10169       uiout->field_stream ("value", stb);
10170       uiout->text ("\n");
10171       result = PRINT_UNKNOWN;
10172       break;
10173
10174     case bp_access_watchpoint:
10175       if (bs->old_val != NULL)
10176         {
10177           if (uiout->is_mi_like_p ())
10178             uiout->field_string
10179               ("reason",
10180                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10181           mention (b);
10182           tuple_emitter.emplace (uiout, "value");
10183           uiout->text ("\nOld value = ");
10184           watchpoint_value_print (bs->old_val.get (), &stb);
10185           uiout->field_stream ("old", stb);
10186           uiout->text ("\nNew value = ");
10187         }
10188       else
10189         {
10190           mention (b);
10191           if (uiout->is_mi_like_p ())
10192             uiout->field_string
10193               ("reason",
10194                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10195           tuple_emitter.emplace (uiout, "value");
10196           uiout->text ("\nValue = ");
10197         }
10198       watchpoint_value_print (w->val.get (), &stb);
10199       uiout->field_stream ("new", stb);
10200       uiout->text ("\n");
10201       result = PRINT_UNKNOWN;
10202       break;
10203     default:
10204       result = PRINT_UNKNOWN;
10205     }
10206
10207   return result;
10208 }
10209
10210 /* Implement the "print_mention" breakpoint_ops method for hardware
10211    watchpoints.  */
10212
10213 static void
10214 print_mention_watchpoint (struct breakpoint *b)
10215 {
10216   struct watchpoint *w = (struct watchpoint *) b;
10217   struct ui_out *uiout = current_uiout;
10218   const char *tuple_name;
10219
10220   switch (b->type)
10221     {
10222     case bp_watchpoint:
10223       uiout->text ("Watchpoint ");
10224       tuple_name = "wpt";
10225       break;
10226     case bp_hardware_watchpoint:
10227       uiout->text ("Hardware watchpoint ");
10228       tuple_name = "wpt";
10229       break;
10230     case bp_read_watchpoint:
10231       uiout->text ("Hardware read watchpoint ");
10232       tuple_name = "hw-rwpt";
10233       break;
10234     case bp_access_watchpoint:
10235       uiout->text ("Hardware access (read/write) watchpoint ");
10236       tuple_name = "hw-awpt";
10237       break;
10238     default:
10239       internal_error (__FILE__, __LINE__,
10240                       _("Invalid hardware watchpoint type."));
10241     }
10242
10243   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10244   uiout->field_int ("number", b->number);
10245   uiout->text (": ");
10246   uiout->field_string ("exp", w->exp_string);
10247 }
10248
10249 /* Implement the "print_recreate" breakpoint_ops method for
10250    watchpoints.  */
10251
10252 static void
10253 print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10254 {
10255   struct watchpoint *w = (struct watchpoint *) b;
10256
10257   switch (b->type)
10258     {
10259     case bp_watchpoint:
10260     case bp_hardware_watchpoint:
10261       fprintf_unfiltered (fp, "watch");
10262       break;
10263     case bp_read_watchpoint:
10264       fprintf_unfiltered (fp, "rwatch");
10265       break;
10266     case bp_access_watchpoint:
10267       fprintf_unfiltered (fp, "awatch");
10268       break;
10269     default:
10270       internal_error (__FILE__, __LINE__,
10271                       _("Invalid watchpoint type."));
10272     }
10273
10274   fprintf_unfiltered (fp, " %s", w->exp_string);
10275   print_recreate_thread (b, fp);
10276 }
10277
10278 /* Implement the "explains_signal" breakpoint_ops method for
10279    watchpoints.  */
10280
10281 static int
10282 explains_signal_watchpoint (struct breakpoint *b, enum gdb_signal sig)
10283 {
10284   /* A software watchpoint cannot cause a signal other than
10285      GDB_SIGNAL_TRAP.  */
10286   if (b->type == bp_watchpoint && sig != GDB_SIGNAL_TRAP)
10287     return 0;
10288
10289   return 1;
10290 }
10291
10292 /* The breakpoint_ops structure to be used in hardware watchpoints.  */
10293
10294 static struct breakpoint_ops watchpoint_breakpoint_ops;
10295
10296 /* Implement the "insert" breakpoint_ops method for
10297    masked hardware watchpoints.  */
10298
10299 static int
10300 insert_masked_watchpoint (struct bp_location *bl)
10301 {
10302   struct watchpoint *w = (struct watchpoint *) bl->owner;
10303
10304   return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
10305                                         bl->watchpoint_type);
10306 }
10307
10308 /* Implement the "remove" breakpoint_ops method for
10309    masked hardware watchpoints.  */
10310
10311 static int
10312 remove_masked_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10313 {
10314   struct watchpoint *w = (struct watchpoint *) bl->owner;
10315
10316   return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
10317                                         bl->watchpoint_type);
10318 }
10319
10320 /* Implement the "resources_needed" breakpoint_ops method for
10321    masked hardware watchpoints.  */
10322
10323 static int
10324 resources_needed_masked_watchpoint (const struct bp_location *bl)
10325 {
10326   struct watchpoint *w = (struct watchpoint *) bl->owner;
10327
10328   return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
10329 }
10330
10331 /* Implement the "works_in_software_mode" breakpoint_ops method for
10332    masked hardware watchpoints.  */
10333
10334 static int
10335 works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10336 {
10337   return 0;
10338 }
10339
10340 /* Implement the "print_it" breakpoint_ops method for
10341    masked hardware watchpoints.  */
10342
10343 static enum print_stop_action
10344 print_it_masked_watchpoint (bpstat bs)
10345 {
10346   struct breakpoint *b = bs->breakpoint_at;
10347   struct ui_out *uiout = current_uiout;
10348
10349   /* Masked watchpoints have only one location.  */
10350   gdb_assert (b->loc && b->loc->next == NULL);
10351
10352   annotate_watchpoint (b->number);
10353   maybe_print_thread_hit_breakpoint (uiout);
10354
10355   switch (b->type)
10356     {
10357     case bp_hardware_watchpoint:
10358       if (uiout->is_mi_like_p ())
10359         uiout->field_string
10360           ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10361       break;
10362
10363     case bp_read_watchpoint:
10364       if (uiout->is_mi_like_p ())
10365         uiout->field_string
10366           ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10367       break;
10368
10369     case bp_access_watchpoint:
10370       if (uiout->is_mi_like_p ())
10371         uiout->field_string
10372           ("reason",
10373            async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10374       break;
10375     default:
10376       internal_error (__FILE__, __LINE__,
10377                       _("Invalid hardware watchpoint type."));
10378     }
10379
10380   mention (b);
10381   uiout->text (_("\n\
10382 Check the underlying instruction at PC for the memory\n\
10383 address and value which triggered this watchpoint.\n"));
10384   uiout->text ("\n");
10385
10386   /* More than one watchpoint may have been triggered.  */
10387   return PRINT_UNKNOWN;
10388 }
10389
10390 /* Implement the "print_one_detail" breakpoint_ops method for
10391    masked hardware watchpoints.  */
10392
10393 static void
10394 print_one_detail_masked_watchpoint (const struct breakpoint *b,
10395                                     struct ui_out *uiout)
10396 {
10397   struct watchpoint *w = (struct watchpoint *) b;
10398
10399   /* Masked watchpoints have only one location.  */
10400   gdb_assert (b->loc && b->loc->next == NULL);
10401
10402   uiout->text ("\tmask ");
10403   uiout->field_core_addr ("mask", b->loc->gdbarch, w->hw_wp_mask);
10404   uiout->text ("\n");
10405 }
10406
10407 /* Implement the "print_mention" breakpoint_ops method for
10408    masked hardware watchpoints.  */
10409
10410 static void
10411 print_mention_masked_watchpoint (struct breakpoint *b)
10412 {
10413   struct watchpoint *w = (struct watchpoint *) b;
10414   struct ui_out *uiout = current_uiout;
10415   const char *tuple_name;
10416
10417   switch (b->type)
10418     {
10419     case bp_hardware_watchpoint:
10420       uiout->text ("Masked hardware watchpoint ");
10421       tuple_name = "wpt";
10422       break;
10423     case bp_read_watchpoint:
10424       uiout->text ("Masked hardware read watchpoint ");
10425       tuple_name = "hw-rwpt";
10426       break;
10427     case bp_access_watchpoint:
10428       uiout->text ("Masked hardware access (read/write) watchpoint ");
10429       tuple_name = "hw-awpt";
10430       break;
10431     default:
10432       internal_error (__FILE__, __LINE__,
10433                       _("Invalid hardware watchpoint type."));
10434     }
10435
10436   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10437   uiout->field_int ("number", b->number);
10438   uiout->text (": ");
10439   uiout->field_string ("exp", w->exp_string);
10440 }
10441
10442 /* Implement the "print_recreate" breakpoint_ops method for
10443    masked hardware watchpoints.  */
10444
10445 static void
10446 print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
10447 {
10448   struct watchpoint *w = (struct watchpoint *) b;
10449   char tmp[40];
10450
10451   switch (b->type)
10452     {
10453     case bp_hardware_watchpoint:
10454       fprintf_unfiltered (fp, "watch");
10455       break;
10456     case bp_read_watchpoint:
10457       fprintf_unfiltered (fp, "rwatch");
10458       break;
10459     case bp_access_watchpoint:
10460       fprintf_unfiltered (fp, "awatch");
10461       break;
10462     default:
10463       internal_error (__FILE__, __LINE__,
10464                       _("Invalid hardware watchpoint type."));
10465     }
10466
10467   sprintf_vma (tmp, w->hw_wp_mask);
10468   fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
10469   print_recreate_thread (b, fp);
10470 }
10471
10472 /* The breakpoint_ops structure to be used in masked hardware watchpoints.  */
10473
10474 static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
10475
10476 /* Tell whether the given watchpoint is a masked hardware watchpoint.  */
10477
10478 static int
10479 is_masked_watchpoint (const struct breakpoint *b)
10480 {
10481   return b->ops == &masked_watchpoint_breakpoint_ops;
10482 }
10483
10484 /* accessflag:  hw_write:  watch write, 
10485                 hw_read:   watch read, 
10486                 hw_access: watch access (read or write) */
10487 static void
10488 watch_command_1 (const char *arg, int accessflag, int from_tty,
10489                  int just_location, int internal)
10490 {
10491   struct breakpoint *scope_breakpoint = NULL;
10492   const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
10493   struct value *result;
10494   int saved_bitpos = 0, saved_bitsize = 0;
10495   const char *exp_start = NULL;
10496   const char *exp_end = NULL;
10497   const char *tok, *end_tok;
10498   int toklen = -1;
10499   const char *cond_start = NULL;
10500   const char *cond_end = NULL;
10501   enum bptype bp_type;
10502   int thread = -1;
10503   int pc = 0;
10504   /* Flag to indicate whether we are going to use masks for
10505      the hardware watchpoint.  */
10506   int use_mask = 0;
10507   CORE_ADDR mask = 0;
10508
10509   /* Make sure that we actually have parameters to parse.  */
10510   if (arg != NULL && arg[0] != '\0')
10511     {
10512       const char *value_start;
10513
10514       exp_end = arg + strlen (arg);
10515
10516       /* Look for "parameter value" pairs at the end
10517          of the arguments string.  */
10518       for (tok = exp_end - 1; tok > arg; tok--)
10519         {
10520           /* Skip whitespace at the end of the argument list.  */
10521           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10522             tok--;
10523
10524           /* Find the beginning of the last token.
10525              This is the value of the parameter.  */
10526           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10527             tok--;
10528           value_start = tok + 1;
10529
10530           /* Skip whitespace.  */
10531           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10532             tok--;
10533
10534           end_tok = tok;
10535
10536           /* Find the beginning of the second to last token.
10537              This is the parameter itself.  */
10538           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10539             tok--;
10540           tok++;
10541           toklen = end_tok - tok + 1;
10542
10543           if (toklen == 6 && startswith (tok, "thread"))
10544             {
10545               struct thread_info *thr;
10546               /* At this point we've found a "thread" token, which means
10547                  the user is trying to set a watchpoint that triggers
10548                  only in a specific thread.  */
10549               const char *endp;
10550
10551               if (thread != -1)
10552                 error(_("You can specify only one thread."));
10553
10554               /* Extract the thread ID from the next token.  */
10555               thr = parse_thread_id (value_start, &endp);
10556
10557               /* Check if the user provided a valid thread ID.  */
10558               if (*endp != ' ' && *endp != '\t' && *endp != '\0')
10559                 invalid_thread_id_error (value_start);
10560
10561               thread = thr->global_num;
10562             }
10563           else if (toklen == 4 && startswith (tok, "mask"))
10564             {
10565               /* We've found a "mask" token, which means the user wants to
10566                  create a hardware watchpoint that is going to have the mask
10567                  facility.  */
10568               struct value *mask_value, *mark;
10569
10570               if (use_mask)
10571                 error(_("You can specify only one mask."));
10572
10573               use_mask = just_location = 1;
10574
10575               mark = value_mark ();
10576               mask_value = parse_to_comma_and_eval (&value_start);
10577               mask = value_as_address (mask_value);
10578               value_free_to_mark (mark);
10579             }
10580           else
10581             /* We didn't recognize what we found.  We should stop here.  */
10582             break;
10583
10584           /* Truncate the string and get rid of the "parameter value" pair before
10585              the arguments string is parsed by the parse_exp_1 function.  */
10586           exp_end = tok;
10587         }
10588     }
10589   else
10590     exp_end = arg;
10591
10592   /* Parse the rest of the arguments.  From here on out, everything
10593      is in terms of a newly allocated string instead of the original
10594      ARG.  */
10595   innermost_block.reset ();
10596   std::string expression (arg, exp_end - arg);
10597   exp_start = arg = expression.c_str ();
10598   expression_up exp = parse_exp_1 (&arg, 0, 0, 0);
10599   exp_end = arg;
10600   /* Remove trailing whitespace from the expression before saving it.
10601      This makes the eventual display of the expression string a bit
10602      prettier.  */
10603   while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
10604     --exp_end;
10605
10606   /* Checking if the expression is not constant.  */
10607   if (watchpoint_exp_is_const (exp.get ()))
10608     {
10609       int len;
10610
10611       len = exp_end - exp_start;
10612       while (len > 0 && isspace (exp_start[len - 1]))
10613         len--;
10614       error (_("Cannot watch constant value `%.*s'."), len, exp_start);
10615     }
10616
10617   exp_valid_block = innermost_block.block ();
10618   struct value *mark = value_mark ();
10619   struct value *val_as_value = nullptr;
10620   fetch_subexp_value (exp.get (), &pc, &val_as_value, &result, NULL,
10621                       just_location);
10622
10623   if (val_as_value != NULL && just_location)
10624     {
10625       saved_bitpos = value_bitpos (val_as_value);
10626       saved_bitsize = value_bitsize (val_as_value);
10627     }
10628
10629   value_ref_ptr val;
10630   if (just_location)
10631     {
10632       int ret;
10633
10634       exp_valid_block = NULL;
10635       val = release_value (value_addr (result));
10636       value_free_to_mark (mark);
10637
10638       if (use_mask)
10639         {
10640           ret = target_masked_watch_num_registers (value_as_address (val.get ()),
10641                                                    mask);
10642           if (ret == -1)
10643             error (_("This target does not support masked watchpoints."));
10644           else if (ret == -2)
10645             error (_("Invalid mask or memory region."));
10646         }
10647     }
10648   else if (val_as_value != NULL)
10649     val = release_value (val_as_value);
10650
10651   tok = skip_spaces (arg);
10652   end_tok = skip_to_space (tok);
10653
10654   toklen = end_tok - tok;
10655   if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
10656     {
10657       innermost_block.reset ();
10658       tok = cond_start = end_tok + 1;
10659       parse_exp_1 (&tok, 0, 0, 0);
10660
10661       /* The watchpoint expression may not be local, but the condition
10662          may still be.  E.g.: `watch global if local > 0'.  */
10663       cond_exp_valid_block = innermost_block.block ();
10664
10665       cond_end = tok;
10666     }
10667   if (*tok)
10668     error (_("Junk at end of command."));
10669
10670   frame_info *wp_frame = block_innermost_frame (exp_valid_block);
10671
10672   /* Save this because create_internal_breakpoint below invalidates
10673      'wp_frame'.  */
10674   frame_id watchpoint_frame = get_frame_id (wp_frame);
10675
10676   /* If the expression is "local", then set up a "watchpoint scope"
10677      breakpoint at the point where we've left the scope of the watchpoint
10678      expression.  Create the scope breakpoint before the watchpoint, so
10679      that we will encounter it first in bpstat_stop_status.  */
10680   if (exp_valid_block != NULL && wp_frame != NULL)
10681     {
10682       frame_id caller_frame_id = frame_unwind_caller_id (wp_frame);
10683
10684       if (frame_id_p (caller_frame_id))
10685         {
10686           gdbarch *caller_arch = frame_unwind_caller_arch (wp_frame);
10687           CORE_ADDR caller_pc = frame_unwind_caller_pc (wp_frame);
10688
10689           scope_breakpoint
10690             = create_internal_breakpoint (caller_arch, caller_pc,
10691                                           bp_watchpoint_scope,
10692                                           &momentary_breakpoint_ops);
10693
10694           /* create_internal_breakpoint could invalidate WP_FRAME.  */
10695           wp_frame = NULL;
10696
10697           scope_breakpoint->enable_state = bp_enabled;
10698
10699           /* Automatically delete the breakpoint when it hits.  */
10700           scope_breakpoint->disposition = disp_del;
10701
10702           /* Only break in the proper frame (help with recursion).  */
10703           scope_breakpoint->frame_id = caller_frame_id;
10704
10705           /* Set the address at which we will stop.  */
10706           scope_breakpoint->loc->gdbarch = caller_arch;
10707           scope_breakpoint->loc->requested_address = caller_pc;
10708           scope_breakpoint->loc->address
10709             = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
10710                                          scope_breakpoint->loc->requested_address,
10711                                          scope_breakpoint->type);
10712         }
10713     }
10714
10715   /* Now set up the breakpoint.  We create all watchpoints as hardware
10716      watchpoints here even if hardware watchpoints are turned off, a call
10717      to update_watchpoint later in this function will cause the type to
10718      drop back to bp_watchpoint (software watchpoint) if required.  */
10719
10720   if (accessflag == hw_read)
10721     bp_type = bp_read_watchpoint;
10722   else if (accessflag == hw_access)
10723     bp_type = bp_access_watchpoint;
10724   else
10725     bp_type = bp_hardware_watchpoint;
10726
10727   std::unique_ptr<watchpoint> w (new watchpoint ());
10728
10729   if (use_mask)
10730     init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10731                                           &masked_watchpoint_breakpoint_ops);
10732   else
10733     init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10734                                           &watchpoint_breakpoint_ops);
10735   w->thread = thread;
10736   w->disposition = disp_donttouch;
10737   w->pspace = current_program_space;
10738   w->exp = std::move (exp);
10739   w->exp_valid_block = exp_valid_block;
10740   w->cond_exp_valid_block = cond_exp_valid_block;
10741   if (just_location)
10742     {
10743       struct type *t = value_type (val.get ());
10744       CORE_ADDR addr = value_as_address (val.get ());
10745
10746       w->exp_string_reparse
10747         = current_language->la_watch_location_expression (t, addr).release ();
10748
10749       w->exp_string = xstrprintf ("-location %.*s",
10750                                   (int) (exp_end - exp_start), exp_start);
10751     }
10752   else
10753     w->exp_string = savestring (exp_start, exp_end - exp_start);
10754
10755   if (use_mask)
10756     {
10757       w->hw_wp_mask = mask;
10758     }
10759   else
10760     {
10761       w->val = val;
10762       w->val_bitpos = saved_bitpos;
10763       w->val_bitsize = saved_bitsize;
10764       w->val_valid = 1;
10765     }
10766
10767   if (cond_start)
10768     w->cond_string = savestring (cond_start, cond_end - cond_start);
10769   else
10770     w->cond_string = 0;
10771
10772   if (frame_id_p (watchpoint_frame))
10773     {
10774       w->watchpoint_frame = watchpoint_frame;
10775       w->watchpoint_thread = inferior_ptid;
10776     }
10777   else
10778     {
10779       w->watchpoint_frame = null_frame_id;
10780       w->watchpoint_thread = null_ptid;
10781     }
10782
10783   if (scope_breakpoint != NULL)
10784     {
10785       /* The scope breakpoint is related to the watchpoint.  We will
10786          need to act on them together.  */
10787       w->related_breakpoint = scope_breakpoint;
10788       scope_breakpoint->related_breakpoint = w.get ();
10789     }
10790
10791   if (!just_location)
10792     value_free_to_mark (mark);
10793
10794   /* Finally update the new watchpoint.  This creates the locations
10795      that should be inserted.  */
10796   update_watchpoint (w.get (), 1);
10797
10798   install_breakpoint (internal, std::move (w), 1);
10799 }
10800
10801 /* Return count of debug registers needed to watch the given expression.
10802    If the watchpoint cannot be handled in hardware return zero.  */
10803
10804 static int
10805 can_use_hardware_watchpoint (const std::vector<value_ref_ptr> &vals)
10806 {
10807   int found_memory_cnt = 0;
10808
10809   /* Did the user specifically forbid us to use hardware watchpoints? */
10810   if (!can_use_hw_watchpoints)
10811     return 0;
10812
10813   gdb_assert (!vals.empty ());
10814   struct value *head = vals[0].get ();
10815
10816   /* Make sure that the value of the expression depends only upon
10817      memory contents, and values computed from them within GDB.  If we
10818      find any register references or function calls, we can't use a
10819      hardware watchpoint.
10820
10821      The idea here is that evaluating an expression generates a series
10822      of values, one holding the value of every subexpression.  (The
10823      expression a*b+c has five subexpressions: a, b, a*b, c, and
10824      a*b+c.)  GDB's values hold almost enough information to establish
10825      the criteria given above --- they identify memory lvalues,
10826      register lvalues, computed values, etcetera.  So we can evaluate
10827      the expression, and then scan the chain of values that leaves
10828      behind to decide whether we can detect any possible change to the
10829      expression's final value using only hardware watchpoints.
10830
10831      However, I don't think that the values returned by inferior
10832      function calls are special in any way.  So this function may not
10833      notice that an expression involving an inferior function call
10834      can't be watched with hardware watchpoints.  FIXME.  */
10835   for (const value_ref_ptr &iter : vals)
10836     {
10837       struct value *v = iter.get ();
10838
10839       if (VALUE_LVAL (v) == lval_memory)
10840         {
10841           if (v != head && value_lazy (v))
10842             /* A lazy memory lvalue in the chain is one that GDB never
10843                needed to fetch; we either just used its address (e.g.,
10844                `a' in `a.b') or we never needed it at all (e.g., `a'
10845                in `a,b').  This doesn't apply to HEAD; if that is
10846                lazy then it was not readable, but watch it anyway.  */
10847             ;
10848           else
10849             {
10850               /* Ahh, memory we actually used!  Check if we can cover
10851                  it with hardware watchpoints.  */
10852               struct type *vtype = check_typedef (value_type (v));
10853
10854               /* We only watch structs and arrays if user asked for it
10855                  explicitly, never if they just happen to appear in a
10856                  middle of some value chain.  */
10857               if (v == head
10858                   || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
10859                       && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
10860                 {
10861                   CORE_ADDR vaddr = value_address (v);
10862                   int len;
10863                   int num_regs;
10864
10865                   len = (target_exact_watchpoints
10866                          && is_scalar_type_recursive (vtype))?
10867                     1 : TYPE_LENGTH (value_type (v));
10868
10869                   num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
10870                   if (!num_regs)
10871                     return 0;
10872                   else
10873                     found_memory_cnt += num_regs;
10874                 }
10875             }
10876         }
10877       else if (VALUE_LVAL (v) != not_lval
10878                && deprecated_value_modifiable (v) == 0)
10879         return 0;       /* These are values from the history (e.g., $1).  */
10880       else if (VALUE_LVAL (v) == lval_register)
10881         return 0;       /* Cannot watch a register with a HW watchpoint.  */
10882     }
10883
10884   /* The expression itself looks suitable for using a hardware
10885      watchpoint, but give the target machine a chance to reject it.  */
10886   return found_memory_cnt;
10887 }
10888
10889 void
10890 watch_command_wrapper (const char *arg, int from_tty, int internal)
10891 {
10892   watch_command_1 (arg, hw_write, from_tty, 0, internal);
10893 }
10894
10895 /* A helper function that looks for the "-location" argument and then
10896    calls watch_command_1.  */
10897
10898 static void
10899 watch_maybe_just_location (const char *arg, int accessflag, int from_tty)
10900 {
10901   int just_location = 0;
10902
10903   if (arg
10904       && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
10905           || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
10906     {
10907       arg = skip_spaces (arg);
10908       just_location = 1;
10909     }
10910
10911   watch_command_1 (arg, accessflag, from_tty, just_location, 0);
10912 }
10913
10914 static void
10915 watch_command (const char *arg, int from_tty)
10916 {
10917   watch_maybe_just_location (arg, hw_write, from_tty);
10918 }
10919
10920 void
10921 rwatch_command_wrapper (const char *arg, int from_tty, int internal)
10922 {
10923   watch_command_1 (arg, hw_read, from_tty, 0, internal);
10924 }
10925
10926 static void
10927 rwatch_command (const char *arg, int from_tty)
10928 {
10929   watch_maybe_just_location (arg, hw_read, from_tty);
10930 }
10931
10932 void
10933 awatch_command_wrapper (const char *arg, int from_tty, int internal)
10934 {
10935   watch_command_1 (arg, hw_access, from_tty, 0, internal);
10936 }
10937
10938 static void
10939 awatch_command (const char *arg, int from_tty)
10940 {
10941   watch_maybe_just_location (arg, hw_access, from_tty);
10942 }
10943 \f
10944
10945 /* Data for the FSM that manages the until(location)/advance commands
10946    in infcmd.c.  Here because it uses the mechanisms of
10947    breakpoints.  */
10948
10949 struct until_break_fsm : public thread_fsm
10950 {
10951   /* The thread that was current when the command was executed.  */
10952   int thread;
10953
10954   /* The breakpoint set at the destination location.  */
10955   breakpoint_up location_breakpoint;
10956
10957   /* Breakpoint set at the return address in the caller frame.  May be
10958      NULL.  */
10959   breakpoint_up caller_breakpoint;
10960
10961   until_break_fsm (struct interp *cmd_interp, int thread,
10962                    breakpoint_up &&location_breakpoint,
10963                    breakpoint_up &&caller_breakpoint)
10964     : thread_fsm (cmd_interp),
10965       thread (thread),
10966       location_breakpoint (std::move (location_breakpoint)),
10967       caller_breakpoint (std::move (caller_breakpoint))
10968   {
10969   }
10970
10971   void clean_up (struct thread_info *thread) override;
10972   bool should_stop (struct thread_info *thread) override;
10973   enum async_reply_reason do_async_reply_reason () override;
10974 };
10975
10976 /* Implementation of the 'should_stop' FSM method for the
10977    until(location)/advance commands.  */
10978
10979 bool
10980 until_break_fsm::should_stop (struct thread_info *tp)
10981 {
10982   if (bpstat_find_breakpoint (tp->control.stop_bpstat,
10983                               location_breakpoint.get ()) != NULL
10984       || (caller_breakpoint != NULL
10985           && bpstat_find_breakpoint (tp->control.stop_bpstat,
10986                                      caller_breakpoint.get ()) != NULL))
10987     set_finished ();
10988
10989   return true;
10990 }
10991
10992 /* Implementation of the 'clean_up' FSM method for the
10993    until(location)/advance commands.  */
10994
10995 void
10996 until_break_fsm::clean_up (struct thread_info *)
10997 {
10998   /* Clean up our temporary breakpoints.  */
10999   location_breakpoint.reset ();
11000   caller_breakpoint.reset ();
11001   delete_longjmp_breakpoint (thread);
11002 }
11003
11004 /* Implementation of the 'async_reply_reason' FSM method for the
11005    until(location)/advance commands.  */
11006
11007 enum async_reply_reason
11008 until_break_fsm::do_async_reply_reason ()
11009 {
11010   return EXEC_ASYNC_LOCATION_REACHED;
11011 }
11012
11013 void
11014 until_break_command (const char *arg, int from_tty, int anywhere)
11015 {
11016   struct frame_info *frame;
11017   struct gdbarch *frame_gdbarch;
11018   struct frame_id stack_frame_id;
11019   struct frame_id caller_frame_id;
11020   int thread;
11021   struct thread_info *tp;
11022
11023   clear_proceed_status (0);
11024
11025   /* Set a breakpoint where the user wants it and at return from
11026      this function.  */
11027
11028   event_location_up location = string_to_event_location (&arg, current_language);
11029
11030   std::vector<symtab_and_line> sals
11031     = (last_displayed_sal_is_valid ()
11032        ? decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
11033                         get_last_displayed_symtab (),
11034                         get_last_displayed_line ())
11035        : decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
11036                         NULL, (struct symtab *) NULL, 0));
11037
11038   if (sals.size () != 1)
11039     error (_("Couldn't get information on specified line."));
11040
11041   symtab_and_line &sal = sals[0];
11042
11043   if (*arg)
11044     error (_("Junk at end of arguments."));
11045
11046   resolve_sal_pc (&sal);
11047
11048   tp = inferior_thread ();
11049   thread = tp->global_num;
11050
11051   /* Note linespec handling above invalidates the frame chain.
11052      Installing a breakpoint also invalidates the frame chain (as it
11053      may need to switch threads), so do any frame handling before
11054      that.  */
11055
11056   frame = get_selected_frame (NULL);
11057   frame_gdbarch = get_frame_arch (frame);
11058   stack_frame_id = get_stack_frame_id (frame);
11059   caller_frame_id = frame_unwind_caller_id (frame);
11060
11061   /* Keep within the current frame, or in frames called by the current
11062      one.  */
11063
11064   breakpoint_up caller_breakpoint;
11065
11066   gdb::optional<delete_longjmp_breakpoint_cleanup> lj_deleter;
11067
11068   if (frame_id_p (caller_frame_id))
11069     {
11070       struct symtab_and_line sal2;
11071       struct gdbarch *caller_gdbarch;
11072
11073       sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11074       sal2.pc = frame_unwind_caller_pc (frame);
11075       caller_gdbarch = frame_unwind_caller_arch (frame);
11076       caller_breakpoint = set_momentary_breakpoint (caller_gdbarch,
11077                                                     sal2,
11078                                                     caller_frame_id,
11079                                                     bp_until);
11080
11081       set_longjmp_breakpoint (tp, caller_frame_id);
11082       lj_deleter.emplace (thread);
11083     }
11084
11085   /* set_momentary_breakpoint could invalidate FRAME.  */
11086   frame = NULL;
11087
11088   breakpoint_up location_breakpoint;
11089   if (anywhere)
11090     /* If the user told us to continue until a specified location,
11091        we don't specify a frame at which we need to stop.  */
11092     location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11093                                                     null_frame_id, bp_until);
11094   else
11095     /* Otherwise, specify the selected frame, because we want to stop
11096        only at the very same frame.  */
11097     location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11098                                                     stack_frame_id, bp_until);
11099
11100   tp->thread_fsm = new until_break_fsm (command_interp (), tp->global_num,
11101                                         std::move (location_breakpoint),
11102                                         std::move (caller_breakpoint));
11103
11104   if (lj_deleter)
11105     lj_deleter->release ();
11106
11107   proceed (-1, GDB_SIGNAL_DEFAULT);
11108 }
11109
11110 /* This function attempts to parse an optional "if <cond>" clause
11111    from the arg string.  If one is not found, it returns NULL.
11112
11113    Else, it returns a pointer to the condition string.  (It does not
11114    attempt to evaluate the string against a particular block.)  And,
11115    it updates arg to point to the first character following the parsed
11116    if clause in the arg string.  */
11117
11118 const char *
11119 ep_parse_optional_if_clause (const char **arg)
11120 {
11121   const char *cond_string;
11122
11123   if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
11124     return NULL;
11125
11126   /* Skip the "if" keyword.  */
11127   (*arg) += 2;
11128
11129   /* Skip any extra leading whitespace, and record the start of the
11130      condition string.  */
11131   *arg = skip_spaces (*arg);
11132   cond_string = *arg;
11133
11134   /* Assume that the condition occupies the remainder of the arg
11135      string.  */
11136   (*arg) += strlen (cond_string);
11137
11138   return cond_string;
11139 }
11140
11141 /* Commands to deal with catching events, such as signals, exceptions,
11142    process start/exit, etc.  */
11143
11144 typedef enum
11145 {
11146   catch_fork_temporary, catch_vfork_temporary,
11147   catch_fork_permanent, catch_vfork_permanent
11148 }
11149 catch_fork_kind;
11150
11151 static void
11152 catch_fork_command_1 (const char *arg, int from_tty,
11153                       struct cmd_list_element *command)
11154 {
11155   struct gdbarch *gdbarch = get_current_arch ();
11156   const char *cond_string = NULL;
11157   catch_fork_kind fork_kind;
11158   int tempflag;
11159
11160   fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11161   tempflag = (fork_kind == catch_fork_temporary
11162               || fork_kind == catch_vfork_temporary);
11163
11164   if (!arg)
11165     arg = "";
11166   arg = skip_spaces (arg);
11167
11168   /* The allowed syntax is:
11169      catch [v]fork
11170      catch [v]fork if <cond>
11171
11172      First, check if there's an if clause.  */
11173   cond_string = ep_parse_optional_if_clause (&arg);
11174
11175   if ((*arg != '\0') && !isspace (*arg))
11176     error (_("Junk at end of arguments."));
11177
11178   /* If this target supports it, create a fork or vfork catchpoint
11179      and enable reporting of such events.  */
11180   switch (fork_kind)
11181     {
11182     case catch_fork_temporary:
11183     case catch_fork_permanent:
11184       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11185                                           &catch_fork_breakpoint_ops);
11186       break;
11187     case catch_vfork_temporary:
11188     case catch_vfork_permanent:
11189       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11190                                           &catch_vfork_breakpoint_ops);
11191       break;
11192     default:
11193       error (_("unsupported or unknown fork kind; cannot catch it"));
11194       break;
11195     }
11196 }
11197
11198 static void
11199 catch_exec_command_1 (const char *arg, int from_tty,
11200                       struct cmd_list_element *command)
11201 {
11202   struct gdbarch *gdbarch = get_current_arch ();
11203   int tempflag;
11204   const char *cond_string = NULL;
11205
11206   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11207
11208   if (!arg)
11209     arg = "";
11210   arg = skip_spaces (arg);
11211
11212   /* The allowed syntax is:
11213      catch exec
11214      catch exec if <cond>
11215
11216      First, check if there's an if clause.  */
11217   cond_string = ep_parse_optional_if_clause (&arg);
11218
11219   if ((*arg != '\0') && !isspace (*arg))
11220     error (_("Junk at end of arguments."));
11221
11222   std::unique_ptr<exec_catchpoint> c (new exec_catchpoint ());
11223   init_catchpoint (c.get (), gdbarch, tempflag, cond_string,
11224                    &catch_exec_breakpoint_ops);
11225   c->exec_pathname = NULL;
11226
11227   install_breakpoint (0, std::move (c), 1);
11228 }
11229
11230 void
11231 init_ada_exception_breakpoint (struct breakpoint *b,
11232                                struct gdbarch *gdbarch,
11233                                struct symtab_and_line sal,
11234                                const char *addr_string,
11235                                const struct breakpoint_ops *ops,
11236                                int tempflag,
11237                                int enabled,
11238                                int from_tty)
11239 {
11240   if (from_tty)
11241     {
11242       struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11243       if (!loc_gdbarch)
11244         loc_gdbarch = gdbarch;
11245
11246       describe_other_breakpoints (loc_gdbarch,
11247                                   sal.pspace, sal.pc, sal.section, -1);
11248       /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11249          version for exception catchpoints, because two catchpoints
11250          used for different exception names will use the same address.
11251          In this case, a "breakpoint ... also set at..." warning is
11252          unproductive.  Besides, the warning phrasing is also a bit
11253          inappropriate, we should use the word catchpoint, and tell
11254          the user what type of catchpoint it is.  The above is good
11255          enough for now, though.  */
11256     }
11257
11258   init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
11259
11260   b->enable_state = enabled ? bp_enabled : bp_disabled;
11261   b->disposition = tempflag ? disp_del : disp_donttouch;
11262   b->location = string_to_event_location (&addr_string,
11263                                           language_def (language_ada));
11264   b->language = language_ada;
11265 }
11266
11267 static void
11268 catch_command (const char *arg, int from_tty)
11269 {
11270   error (_("Catch requires an event name."));
11271 }
11272 \f
11273
11274 static void
11275 tcatch_command (const char *arg, int from_tty)
11276 {
11277   error (_("Catch requires an event name."));
11278 }
11279
11280 /* Compare two breakpoints and return a strcmp-like result.  */
11281
11282 static int
11283 compare_breakpoints (const breakpoint *a, const breakpoint *b)
11284 {
11285   uintptr_t ua = (uintptr_t) a;
11286   uintptr_t ub = (uintptr_t) b;
11287
11288   if (a->number < b->number)
11289     return -1;
11290   else if (a->number > b->number)
11291     return 1;
11292
11293   /* Now sort by address, in case we see, e..g, two breakpoints with
11294      the number 0.  */
11295   if (ua < ub)
11296     return -1;
11297   return ua > ub ? 1 : 0;
11298 }
11299
11300 /* Delete breakpoints by address or line.  */
11301
11302 static void
11303 clear_command (const char *arg, int from_tty)
11304 {
11305   struct breakpoint *b;
11306   int default_match;
11307
11308   std::vector<symtab_and_line> decoded_sals;
11309   symtab_and_line last_sal;
11310   gdb::array_view<symtab_and_line> sals;
11311   if (arg)
11312     {
11313       decoded_sals
11314         = decode_line_with_current_source (arg,
11315                                            (DECODE_LINE_FUNFIRSTLINE
11316                                             | DECODE_LINE_LIST_MODE));
11317       default_match = 0;
11318       sals = decoded_sals;
11319     }
11320   else
11321     {
11322       /* Set sal's line, symtab, pc, and pspace to the values
11323          corresponding to the last call to print_frame_info.  If the
11324          codepoint is not valid, this will set all the fields to 0.  */
11325       last_sal = get_last_displayed_sal ();
11326       if (last_sal.symtab == 0)
11327         error (_("No source file specified."));
11328
11329       default_match = 1;
11330       sals = last_sal;
11331     }
11332
11333   /* We don't call resolve_sal_pc here.  That's not as bad as it
11334      seems, because all existing breakpoints typically have both
11335      file/line and pc set.  So, if clear is given file/line, we can
11336      match this to existing breakpoint without obtaining pc at all.
11337
11338      We only support clearing given the address explicitly 
11339      present in breakpoint table.  Say, we've set breakpoint 
11340      at file:line.  There were several PC values for that file:line,
11341      due to optimization, all in one block.
11342
11343      We've picked one PC value.  If "clear" is issued with another
11344      PC corresponding to the same file:line, the breakpoint won't
11345      be cleared.  We probably can still clear the breakpoint, but 
11346      since the other PC value is never presented to user, user
11347      can only find it by guessing, and it does not seem important
11348      to support that.  */
11349
11350   /* For each line spec given, delete bps which correspond to it.  Do
11351      it in two passes, solely to preserve the current behavior that
11352      from_tty is forced true if we delete more than one
11353      breakpoint.  */
11354
11355   std::vector<struct breakpoint *> found;
11356   for (const auto &sal : sals)
11357     {
11358       const char *sal_fullname;
11359
11360       /* If exact pc given, clear bpts at that pc.
11361          If line given (pc == 0), clear all bpts on specified line.
11362          If defaulting, clear all bpts on default line
11363          or at default pc.
11364
11365          defaulting    sal.pc != 0    tests to do
11366
11367          0              1             pc
11368          1              1             pc _and_ line
11369          0              0             line
11370          1              0             <can't happen> */
11371
11372       sal_fullname = (sal.symtab == NULL
11373                       ? NULL : symtab_to_fullname (sal.symtab));
11374
11375       /* Find all matching breakpoints and add them to 'found'.  */
11376       ALL_BREAKPOINTS (b)
11377         {
11378           int match = 0;
11379           /* Are we going to delete b?  */
11380           if (b->type != bp_none && !is_watchpoint (b))
11381             {
11382               struct bp_location *loc = b->loc;
11383               for (; loc; loc = loc->next)
11384                 {
11385                   /* If the user specified file:line, don't allow a PC
11386                      match.  This matches historical gdb behavior.  */
11387                   int pc_match = (!sal.explicit_line
11388                                   && sal.pc
11389                                   && (loc->pspace == sal.pspace)
11390                                   && (loc->address == sal.pc)
11391                                   && (!section_is_overlay (loc->section)
11392                                       || loc->section == sal.section));
11393                   int line_match = 0;
11394
11395                   if ((default_match || sal.explicit_line)
11396                       && loc->symtab != NULL
11397                       && sal_fullname != NULL
11398                       && sal.pspace == loc->pspace
11399                       && loc->line_number == sal.line
11400                       && filename_cmp (symtab_to_fullname (loc->symtab),
11401                                        sal_fullname) == 0)
11402                     line_match = 1;
11403
11404                   if (pc_match || line_match)
11405                     {
11406                       match = 1;
11407                       break;
11408                     }
11409                 }
11410             }
11411
11412           if (match)
11413             found.push_back (b);
11414         }
11415     }
11416
11417   /* Now go thru the 'found' chain and delete them.  */
11418   if (found.empty ())
11419     {
11420       if (arg)
11421         error (_("No breakpoint at %s."), arg);
11422       else
11423         error (_("No breakpoint at this line."));
11424     }
11425
11426   /* Remove duplicates from the vec.  */
11427   std::sort (found.begin (), found.end (),
11428              [] (const breakpoint *bp_a, const breakpoint *bp_b)
11429              {
11430                return compare_breakpoints (bp_a, bp_b) < 0;
11431              });
11432   found.erase (std::unique (found.begin (), found.end (),
11433                             [] (const breakpoint *bp_a, const breakpoint *bp_b)
11434                             {
11435                               return compare_breakpoints (bp_a, bp_b) == 0;
11436                             }),
11437                found.end ());
11438
11439   if (found.size () > 1)
11440     from_tty = 1;       /* Always report if deleted more than one.  */
11441   if (from_tty)
11442     {
11443       if (found.size () == 1)
11444         printf_unfiltered (_("Deleted breakpoint "));
11445       else
11446         printf_unfiltered (_("Deleted breakpoints "));
11447     }
11448
11449   for (breakpoint *iter : found)
11450     {
11451       if (from_tty)
11452         printf_unfiltered ("%d ", iter->number);
11453       delete_breakpoint (iter);
11454     }
11455   if (from_tty)
11456     putchar_unfiltered ('\n');
11457 }
11458 \f
11459 /* Delete breakpoint in BS if they are `delete' breakpoints and
11460    all breakpoints that are marked for deletion, whether hit or not.
11461    This is called after any breakpoint is hit, or after errors.  */
11462
11463 void
11464 breakpoint_auto_delete (bpstat bs)
11465 {
11466   struct breakpoint *b, *b_tmp;
11467
11468   for (; bs; bs = bs->next)
11469     if (bs->breakpoint_at
11470         && bs->breakpoint_at->disposition == disp_del
11471         && bs->stop)
11472       delete_breakpoint (bs->breakpoint_at);
11473
11474   ALL_BREAKPOINTS_SAFE (b, b_tmp)
11475   {
11476     if (b->disposition == disp_del_at_next_stop)
11477       delete_breakpoint (b);
11478   }
11479 }
11480
11481 /* A comparison function for bp_location AP and BP being interfaced to
11482    qsort.  Sort elements primarily by their ADDRESS (no matter what
11483    does breakpoint_address_is_meaningful say for its OWNER),
11484    secondarily by ordering first permanent elements and
11485    terciarily just ensuring the array is sorted stable way despite
11486    qsort being an unstable algorithm.  */
11487
11488 static int
11489 bp_locations_compare (const void *ap, const void *bp)
11490 {
11491   const struct bp_location *a = *(const struct bp_location **) ap;
11492   const struct bp_location *b = *(const struct bp_location **) bp;
11493
11494   if (a->address != b->address)
11495     return (a->address > b->address) - (a->address < b->address);
11496
11497   /* Sort locations at the same address by their pspace number, keeping
11498      locations of the same inferior (in a multi-inferior environment)
11499      grouped.  */
11500
11501   if (a->pspace->num != b->pspace->num)
11502     return ((a->pspace->num > b->pspace->num)
11503             - (a->pspace->num < b->pspace->num));
11504
11505   /* Sort permanent breakpoints first.  */
11506   if (a->permanent != b->permanent)
11507     return (a->permanent < b->permanent) - (a->permanent > b->permanent);
11508
11509   /* Make the internal GDB representation stable across GDB runs
11510      where A and B memory inside GDB can differ.  Breakpoint locations of
11511      the same type at the same address can be sorted in arbitrary order.  */
11512
11513   if (a->owner->number != b->owner->number)
11514     return ((a->owner->number > b->owner->number)
11515             - (a->owner->number < b->owner->number));
11516
11517   return (a > b) - (a < b);
11518 }
11519
11520 /* Set bp_locations_placed_address_before_address_max and
11521    bp_locations_shadow_len_after_address_max according to the current
11522    content of the bp_locations array.  */
11523
11524 static void
11525 bp_locations_target_extensions_update (void)
11526 {
11527   struct bp_location *bl, **blp_tmp;
11528
11529   bp_locations_placed_address_before_address_max = 0;
11530   bp_locations_shadow_len_after_address_max = 0;
11531
11532   ALL_BP_LOCATIONS (bl, blp_tmp)
11533     {
11534       CORE_ADDR start, end, addr;
11535
11536       if (!bp_location_has_shadow (bl))
11537         continue;
11538
11539       start = bl->target_info.placed_address;
11540       end = start + bl->target_info.shadow_len;
11541
11542       gdb_assert (bl->address >= start);
11543       addr = bl->address - start;
11544       if (addr > bp_locations_placed_address_before_address_max)
11545         bp_locations_placed_address_before_address_max = addr;
11546
11547       /* Zero SHADOW_LEN would not pass bp_location_has_shadow.  */
11548
11549       gdb_assert (bl->address < end);
11550       addr = end - bl->address;
11551       if (addr > bp_locations_shadow_len_after_address_max)
11552         bp_locations_shadow_len_after_address_max = addr;
11553     }
11554 }
11555
11556 /* Download tracepoint locations if they haven't been.  */
11557
11558 static void
11559 download_tracepoint_locations (void)
11560 {
11561   struct breakpoint *b;
11562   enum tribool can_download_tracepoint = TRIBOOL_UNKNOWN;
11563
11564   scoped_restore_current_pspace_and_thread restore_pspace_thread;
11565
11566   ALL_TRACEPOINTS (b)
11567     {
11568       struct bp_location *bl;
11569       struct tracepoint *t;
11570       int bp_location_downloaded = 0;
11571
11572       if ((b->type == bp_fast_tracepoint
11573            ? !may_insert_fast_tracepoints
11574            : !may_insert_tracepoints))
11575         continue;
11576
11577       if (can_download_tracepoint == TRIBOOL_UNKNOWN)
11578         {
11579           if (target_can_download_tracepoint ())
11580             can_download_tracepoint = TRIBOOL_TRUE;
11581           else
11582             can_download_tracepoint = TRIBOOL_FALSE;
11583         }
11584
11585       if (can_download_tracepoint == TRIBOOL_FALSE)
11586         break;
11587
11588       for (bl = b->loc; bl; bl = bl->next)
11589         {
11590           /* In tracepoint, locations are _never_ duplicated, so
11591              should_be_inserted is equivalent to
11592              unduplicated_should_be_inserted.  */
11593           if (!should_be_inserted (bl) || bl->inserted)
11594             continue;
11595
11596           switch_to_program_space_and_thread (bl->pspace);
11597
11598           target_download_tracepoint (bl);
11599
11600           bl->inserted = 1;
11601           bp_location_downloaded = 1;
11602         }
11603       t = (struct tracepoint *) b;
11604       t->number_on_target = b->number;
11605       if (bp_location_downloaded)
11606         gdb::observers::breakpoint_modified.notify (b);
11607     }
11608 }
11609
11610 /* Swap the insertion/duplication state between two locations.  */
11611
11612 static void
11613 swap_insertion (struct bp_location *left, struct bp_location *right)
11614 {
11615   const int left_inserted = left->inserted;
11616   const int left_duplicate = left->duplicate;
11617   const int left_needs_update = left->needs_update;
11618   const struct bp_target_info left_target_info = left->target_info;
11619
11620   /* Locations of tracepoints can never be duplicated.  */
11621   if (is_tracepoint (left->owner))
11622     gdb_assert (!left->duplicate);
11623   if (is_tracepoint (right->owner))
11624     gdb_assert (!right->duplicate);
11625
11626   left->inserted = right->inserted;
11627   left->duplicate = right->duplicate;
11628   left->needs_update = right->needs_update;
11629   left->target_info = right->target_info;
11630   right->inserted = left_inserted;
11631   right->duplicate = left_duplicate;
11632   right->needs_update = left_needs_update;
11633   right->target_info = left_target_info;
11634 }
11635
11636 /* Force the re-insertion of the locations at ADDRESS.  This is called
11637    once a new/deleted/modified duplicate location is found and we are evaluating
11638    conditions on the target's side.  Such conditions need to be updated on
11639    the target.  */
11640
11641 static void
11642 force_breakpoint_reinsertion (struct bp_location *bl)
11643 {
11644   struct bp_location **locp = NULL, **loc2p;
11645   struct bp_location *loc;
11646   CORE_ADDR address = 0;
11647   int pspace_num;
11648
11649   address = bl->address;
11650   pspace_num = bl->pspace->num;
11651
11652   /* This is only meaningful if the target is
11653      evaluating conditions and if the user has
11654      opted for condition evaluation on the target's
11655      side.  */
11656   if (gdb_evaluates_breakpoint_condition_p ()
11657       || !target_supports_evaluation_of_breakpoint_conditions ())
11658     return;
11659
11660   /* Flag all breakpoint locations with this address and
11661      the same program space as the location
11662      as "its condition has changed".  We need to
11663      update the conditions on the target's side.  */
11664   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
11665     {
11666       loc = *loc2p;
11667
11668       if (!is_breakpoint (loc->owner)
11669           || pspace_num != loc->pspace->num)
11670         continue;
11671
11672       /* Flag the location appropriately.  We use a different state to
11673          let everyone know that we already updated the set of locations
11674          with addr bl->address and program space bl->pspace.  This is so
11675          we don't have to keep calling these functions just to mark locations
11676          that have already been marked.  */
11677       loc->condition_changed = condition_updated;
11678
11679       /* Free the agent expression bytecode as well.  We will compute
11680          it later on.  */
11681       loc->cond_bytecode.reset ();
11682     }
11683 }
11684 /* Called whether new breakpoints are created, or existing breakpoints
11685    deleted, to update the global location list and recompute which
11686    locations are duplicate of which.
11687
11688    The INSERT_MODE flag determines whether locations may not, may, or
11689    shall be inserted now.  See 'enum ugll_insert_mode' for more
11690    info.  */
11691
11692 static void
11693 update_global_location_list (enum ugll_insert_mode insert_mode)
11694 {
11695   struct breakpoint *b;
11696   struct bp_location **locp, *loc;
11697   /* Last breakpoint location address that was marked for update.  */
11698   CORE_ADDR last_addr = 0;
11699   /* Last breakpoint location program space that was marked for update.  */
11700   int last_pspace_num = -1;
11701
11702   /* Used in the duplicates detection below.  When iterating over all
11703      bp_locations, points to the first bp_location of a given address.
11704      Breakpoints and watchpoints of different types are never
11705      duplicates of each other.  Keep one pointer for each type of
11706      breakpoint/watchpoint, so we only need to loop over all locations
11707      once.  */
11708   struct bp_location *bp_loc_first;  /* breakpoint */
11709   struct bp_location *wp_loc_first;  /* hardware watchpoint */
11710   struct bp_location *awp_loc_first; /* access watchpoint */
11711   struct bp_location *rwp_loc_first; /* read watchpoint */
11712
11713   /* Saved former bp_locations array which we compare against the newly
11714      built bp_locations from the current state of ALL_BREAKPOINTS.  */
11715   struct bp_location **old_locp;
11716   unsigned old_locations_count;
11717   gdb::unique_xmalloc_ptr<struct bp_location *> old_locations (bp_locations);
11718
11719   old_locations_count = bp_locations_count;
11720   bp_locations = NULL;
11721   bp_locations_count = 0;
11722
11723   ALL_BREAKPOINTS (b)
11724     for (loc = b->loc; loc; loc = loc->next)
11725       bp_locations_count++;
11726
11727   bp_locations = XNEWVEC (struct bp_location *, bp_locations_count);
11728   locp = bp_locations;
11729   ALL_BREAKPOINTS (b)
11730     for (loc = b->loc; loc; loc = loc->next)
11731       *locp++ = loc;
11732   qsort (bp_locations, bp_locations_count, sizeof (*bp_locations),
11733          bp_locations_compare);
11734
11735   bp_locations_target_extensions_update ();
11736
11737   /* Identify bp_location instances that are no longer present in the
11738      new list, and therefore should be freed.  Note that it's not
11739      necessary that those locations should be removed from inferior --
11740      if there's another location at the same address (previously
11741      marked as duplicate), we don't need to remove/insert the
11742      location.
11743      
11744      LOCP is kept in sync with OLD_LOCP, each pointing to the current
11745      and former bp_location array state respectively.  */
11746
11747   locp = bp_locations;
11748   for (old_locp = old_locations.get ();
11749        old_locp < old_locations.get () + old_locations_count;
11750        old_locp++)
11751     {
11752       struct bp_location *old_loc = *old_locp;
11753       struct bp_location **loc2p;
11754
11755       /* Tells if 'old_loc' is found among the new locations.  If
11756          not, we have to free it.  */
11757       int found_object = 0;
11758       /* Tells if the location should remain inserted in the target.  */
11759       int keep_in_target = 0;
11760       int removed = 0;
11761
11762       /* Skip LOCP entries which will definitely never be needed.
11763          Stop either at or being the one matching OLD_LOC.  */
11764       while (locp < bp_locations + bp_locations_count
11765              && (*locp)->address < old_loc->address)
11766         locp++;
11767
11768       for (loc2p = locp;
11769            (loc2p < bp_locations + bp_locations_count
11770             && (*loc2p)->address == old_loc->address);
11771            loc2p++)
11772         {
11773           /* Check if this is a new/duplicated location or a duplicated
11774              location that had its condition modified.  If so, we want to send
11775              its condition to the target if evaluation of conditions is taking
11776              place there.  */
11777           if ((*loc2p)->condition_changed == condition_modified
11778               && (last_addr != old_loc->address
11779                   || last_pspace_num != old_loc->pspace->num))
11780             {
11781               force_breakpoint_reinsertion (*loc2p);
11782               last_pspace_num = old_loc->pspace->num;
11783             }
11784
11785           if (*loc2p == old_loc)
11786             found_object = 1;
11787         }
11788
11789       /* We have already handled this address, update it so that we don't
11790          have to go through updates again.  */
11791       last_addr = old_loc->address;
11792
11793       /* Target-side condition evaluation: Handle deleted locations.  */
11794       if (!found_object)
11795         force_breakpoint_reinsertion (old_loc);
11796
11797       /* If this location is no longer present, and inserted, look if
11798          there's maybe a new location at the same address.  If so,
11799          mark that one inserted, and don't remove this one.  This is
11800          needed so that we don't have a time window where a breakpoint
11801          at certain location is not inserted.  */
11802
11803       if (old_loc->inserted)
11804         {
11805           /* If the location is inserted now, we might have to remove
11806              it.  */
11807
11808           if (found_object && should_be_inserted (old_loc))
11809             {
11810               /* The location is still present in the location list,
11811                  and still should be inserted.  Don't do anything.  */
11812               keep_in_target = 1;
11813             }
11814           else
11815             {
11816               /* This location still exists, but it won't be kept in the
11817                  target since it may have been disabled.  We proceed to
11818                  remove its target-side condition.  */
11819
11820               /* The location is either no longer present, or got
11821                  disabled.  See if there's another location at the
11822                  same address, in which case we don't need to remove
11823                  this one from the target.  */
11824
11825               /* OLD_LOC comes from existing struct breakpoint.  */
11826               if (breakpoint_address_is_meaningful (old_loc->owner))
11827                 {
11828                   for (loc2p = locp;
11829                        (loc2p < bp_locations + bp_locations_count
11830                         && (*loc2p)->address == old_loc->address);
11831                        loc2p++)
11832                     {
11833                       struct bp_location *loc2 = *loc2p;
11834
11835                       if (breakpoint_locations_match (loc2, old_loc))
11836                         {
11837                           /* Read watchpoint locations are switched to
11838                              access watchpoints, if the former are not
11839                              supported, but the latter are.  */
11840                           if (is_hardware_watchpoint (old_loc->owner))
11841                             {
11842                               gdb_assert (is_hardware_watchpoint (loc2->owner));
11843                               loc2->watchpoint_type = old_loc->watchpoint_type;
11844                             }
11845
11846                           /* loc2 is a duplicated location. We need to check
11847                              if it should be inserted in case it will be
11848                              unduplicated.  */
11849                           if (loc2 != old_loc
11850                               && unduplicated_should_be_inserted (loc2))
11851                             {
11852                               swap_insertion (old_loc, loc2);
11853                               keep_in_target = 1;
11854                               break;
11855                             }
11856                         }
11857                     }
11858                 }
11859             }
11860
11861           if (!keep_in_target)
11862             {
11863               if (remove_breakpoint (old_loc))
11864                 {
11865                   /* This is just about all we can do.  We could keep
11866                      this location on the global list, and try to
11867                      remove it next time, but there's no particular
11868                      reason why we will succeed next time.
11869                      
11870                      Note that at this point, old_loc->owner is still
11871                      valid, as delete_breakpoint frees the breakpoint
11872                      only after calling us.  */
11873                   printf_filtered (_("warning: Error removing "
11874                                      "breakpoint %d\n"), 
11875                                    old_loc->owner->number);
11876                 }
11877               removed = 1;
11878             }
11879         }
11880
11881       if (!found_object)
11882         {
11883           if (removed && target_is_non_stop_p ()
11884               && need_moribund_for_location_type (old_loc))
11885             {
11886               /* This location was removed from the target.  In
11887                  non-stop mode, a race condition is possible where
11888                  we've removed a breakpoint, but stop events for that
11889                  breakpoint are already queued and will arrive later.
11890                  We apply an heuristic to be able to distinguish such
11891                  SIGTRAPs from other random SIGTRAPs: we keep this
11892                  breakpoint location for a bit, and will retire it
11893                  after we see some number of events.  The theory here
11894                  is that reporting of events should, "on the average",
11895                  be fair, so after a while we'll see events from all
11896                  threads that have anything of interest, and no longer
11897                  need to keep this breakpoint location around.  We
11898                  don't hold locations forever so to reduce chances of
11899                  mistaking a non-breakpoint SIGTRAP for a breakpoint
11900                  SIGTRAP.
11901
11902                  The heuristic failing can be disastrous on
11903                  decr_pc_after_break targets.
11904
11905                  On decr_pc_after_break targets, like e.g., x86-linux,
11906                  if we fail to recognize a late breakpoint SIGTRAP,
11907                  because events_till_retirement has reached 0 too
11908                  soon, we'll fail to do the PC adjustment, and report
11909                  a random SIGTRAP to the user.  When the user resumes
11910                  the inferior, it will most likely immediately crash
11911                  with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
11912                  corrupted, because of being resumed e.g., in the
11913                  middle of a multi-byte instruction, or skipped a
11914                  one-byte instruction.  This was actually seen happen
11915                  on native x86-linux, and should be less rare on
11916                  targets that do not support new thread events, like
11917                  remote, due to the heuristic depending on
11918                  thread_count.
11919
11920                  Mistaking a random SIGTRAP for a breakpoint trap
11921                  causes similar symptoms (PC adjustment applied when
11922                  it shouldn't), but then again, playing with SIGTRAPs
11923                  behind the debugger's back is asking for trouble.
11924
11925                  Since hardware watchpoint traps are always
11926                  distinguishable from other traps, so we don't need to
11927                  apply keep hardware watchpoint moribund locations
11928                  around.  We simply always ignore hardware watchpoint
11929                  traps we can no longer explain.  */
11930
11931               old_loc->events_till_retirement = 3 * (thread_count () + 1);
11932               old_loc->owner = NULL;
11933
11934               moribund_locations.push_back (old_loc);
11935             }
11936           else
11937             {
11938               old_loc->owner = NULL;
11939               decref_bp_location (&old_loc);
11940             }
11941         }
11942     }
11943
11944   /* Rescan breakpoints at the same address and section, marking the
11945      first one as "first" and any others as "duplicates".  This is so
11946      that the bpt instruction is only inserted once.  If we have a
11947      permanent breakpoint at the same place as BPT, make that one the
11948      official one, and the rest as duplicates.  Permanent breakpoints
11949      are sorted first for the same address.
11950
11951      Do the same for hardware watchpoints, but also considering the
11952      watchpoint's type (regular/access/read) and length.  */
11953
11954   bp_loc_first = NULL;
11955   wp_loc_first = NULL;
11956   awp_loc_first = NULL;
11957   rwp_loc_first = NULL;
11958   ALL_BP_LOCATIONS (loc, locp)
11959     {
11960       /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
11961          non-NULL.  */
11962       struct bp_location **loc_first_p;
11963       b = loc->owner;
11964
11965       if (!unduplicated_should_be_inserted (loc)
11966           || !breakpoint_address_is_meaningful (b)
11967           /* Don't detect duplicate for tracepoint locations because they are
11968            never duplicated.  See the comments in field `duplicate' of
11969            `struct bp_location'.  */
11970           || is_tracepoint (b))
11971         {
11972           /* Clear the condition modification flag.  */
11973           loc->condition_changed = condition_unchanged;
11974           continue;
11975         }
11976
11977       if (b->type == bp_hardware_watchpoint)
11978         loc_first_p = &wp_loc_first;
11979       else if (b->type == bp_read_watchpoint)
11980         loc_first_p = &rwp_loc_first;
11981       else if (b->type == bp_access_watchpoint)
11982         loc_first_p = &awp_loc_first;
11983       else
11984         loc_first_p = &bp_loc_first;
11985
11986       if (*loc_first_p == NULL
11987           || (overlay_debugging && loc->section != (*loc_first_p)->section)
11988           || !breakpoint_locations_match (loc, *loc_first_p))
11989         {
11990           *loc_first_p = loc;
11991           loc->duplicate = 0;
11992
11993           if (is_breakpoint (loc->owner) && loc->condition_changed)
11994             {
11995               loc->needs_update = 1;
11996               /* Clear the condition modification flag.  */
11997               loc->condition_changed = condition_unchanged;
11998             }
11999           continue;
12000         }
12001
12002
12003       /* This and the above ensure the invariant that the first location
12004          is not duplicated, and is the inserted one.
12005          All following are marked as duplicated, and are not inserted.  */
12006       if (loc->inserted)
12007         swap_insertion (loc, *loc_first_p);
12008       loc->duplicate = 1;
12009
12010       /* Clear the condition modification flag.  */
12011       loc->condition_changed = condition_unchanged;
12012     }
12013
12014   if (insert_mode == UGLL_INSERT || breakpoints_should_be_inserted_now ())
12015     {
12016       if (insert_mode != UGLL_DONT_INSERT)
12017         insert_breakpoint_locations ();
12018       else
12019         {
12020           /* Even though the caller told us to not insert new
12021              locations, we may still need to update conditions on the
12022              target's side of breakpoints that were already inserted
12023              if the target is evaluating breakpoint conditions.  We
12024              only update conditions for locations that are marked
12025              "needs_update".  */
12026           update_inserted_breakpoint_locations ();
12027         }
12028     }
12029
12030   if (insert_mode != UGLL_DONT_INSERT)
12031     download_tracepoint_locations ();
12032 }
12033
12034 void
12035 breakpoint_retire_moribund (void)
12036 {
12037   for (int ix = 0; ix < moribund_locations.size (); ++ix)
12038     {
12039       struct bp_location *loc = moribund_locations[ix];
12040       if (--(loc->events_till_retirement) == 0)
12041         {
12042           decref_bp_location (&loc);
12043           unordered_remove (moribund_locations, ix);
12044           --ix;
12045         }
12046     }
12047 }
12048
12049 static void
12050 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode)
12051 {
12052
12053   TRY
12054     {
12055       update_global_location_list (insert_mode);
12056     }
12057   CATCH (e, RETURN_MASK_ERROR)
12058     {
12059     }
12060   END_CATCH
12061 }
12062
12063 /* Clear BKP from a BPS.  */
12064
12065 static void
12066 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12067 {
12068   bpstat bs;
12069
12070   for (bs = bps; bs; bs = bs->next)
12071     if (bs->breakpoint_at == bpt)
12072       {
12073         bs->breakpoint_at = NULL;
12074         bs->old_val = NULL;
12075         /* bs->commands will be freed later.  */
12076       }
12077 }
12078
12079 /* Callback for iterate_over_threads.  */
12080 static int
12081 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12082 {
12083   struct breakpoint *bpt = (struct breakpoint *) data;
12084
12085   bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12086   return 0;
12087 }
12088
12089 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12090    callbacks.  */
12091
12092 static void
12093 say_where (struct breakpoint *b)
12094 {
12095   struct value_print_options opts;
12096
12097   get_user_print_options (&opts);
12098
12099   /* i18n: cagney/2005-02-11: Below needs to be merged into a
12100      single string.  */
12101   if (b->loc == NULL)
12102     {
12103       /* For pending locations, the output differs slightly based
12104          on b->extra_string.  If this is non-NULL, it contains either
12105          a condition or dprintf arguments.  */
12106       if (b->extra_string == NULL)
12107         {
12108           printf_filtered (_(" (%s) pending."),
12109                            event_location_to_string (b->location.get ()));
12110         }
12111       else if (b->type == bp_dprintf)
12112         {
12113           printf_filtered (_(" (%s,%s) pending."),
12114                            event_location_to_string (b->location.get ()),
12115                            b->extra_string);
12116         }
12117       else
12118         {
12119           printf_filtered (_(" (%s %s) pending."),
12120                            event_location_to_string (b->location.get ()),
12121                            b->extra_string);
12122         }
12123     }
12124   else
12125     {
12126       if (opts.addressprint || b->loc->symtab == NULL)
12127         {
12128           printf_filtered (" at ");
12129           fputs_styled (paddress (b->loc->gdbarch, b->loc->address),
12130                         address_style.style (),
12131                         gdb_stdout);
12132         }
12133       if (b->loc->symtab != NULL)
12134         {
12135           /* If there is a single location, we can print the location
12136              more nicely.  */
12137           if (b->loc->next == NULL)
12138             {
12139               puts_filtered (": file ");
12140               fputs_styled (symtab_to_filename_for_display (b->loc->symtab),
12141                             file_name_style.style (),
12142                             gdb_stdout);
12143               printf_filtered (", line %d.",
12144                                b->loc->line_number);
12145             }
12146           else
12147             /* This is not ideal, but each location may have a
12148                different file name, and this at least reflects the
12149                real situation somewhat.  */
12150             printf_filtered (": %s.",
12151                              event_location_to_string (b->location.get ()));
12152         }
12153
12154       if (b->loc->next)
12155         {
12156           struct bp_location *loc = b->loc;
12157           int n = 0;
12158           for (; loc; loc = loc->next)
12159             ++n;
12160           printf_filtered (" (%d locations)", n);
12161         }
12162     }
12163 }
12164
12165 bp_location::~bp_location ()
12166 {
12167   xfree (function_name);
12168 }
12169
12170 /* Destructor for the breakpoint base class.  */
12171
12172 breakpoint::~breakpoint ()
12173 {
12174   xfree (this->cond_string);
12175   xfree (this->extra_string);
12176   xfree (this->filter);
12177 }
12178
12179 static struct bp_location *
12180 base_breakpoint_allocate_location (struct breakpoint *self)
12181 {
12182   return new bp_location (self);
12183 }
12184
12185 static void
12186 base_breakpoint_re_set (struct breakpoint *b)
12187 {
12188   /* Nothing to re-set. */
12189 }
12190
12191 #define internal_error_pure_virtual_called() \
12192   gdb_assert_not_reached ("pure virtual function called")
12193
12194 static int
12195 base_breakpoint_insert_location (struct bp_location *bl)
12196 {
12197   internal_error_pure_virtual_called ();
12198 }
12199
12200 static int
12201 base_breakpoint_remove_location (struct bp_location *bl,
12202                                  enum remove_bp_reason reason)
12203 {
12204   internal_error_pure_virtual_called ();
12205 }
12206
12207 static int
12208 base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12209                                 const address_space *aspace,
12210                                 CORE_ADDR bp_addr,
12211                                 const struct target_waitstatus *ws)
12212 {
12213   internal_error_pure_virtual_called ();
12214 }
12215
12216 static void
12217 base_breakpoint_check_status (bpstat bs)
12218 {
12219   /* Always stop.   */
12220 }
12221
12222 /* A "works_in_software_mode" breakpoint_ops method that just internal
12223    errors.  */
12224
12225 static int
12226 base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12227 {
12228   internal_error_pure_virtual_called ();
12229 }
12230
12231 /* A "resources_needed" breakpoint_ops method that just internal
12232    errors.  */
12233
12234 static int
12235 base_breakpoint_resources_needed (const struct bp_location *bl)
12236 {
12237   internal_error_pure_virtual_called ();
12238 }
12239
12240 static enum print_stop_action
12241 base_breakpoint_print_it (bpstat bs)
12242 {
12243   internal_error_pure_virtual_called ();
12244 }
12245
12246 static void
12247 base_breakpoint_print_one_detail (const struct breakpoint *self,
12248                                   struct ui_out *uiout)
12249 {
12250   /* nothing */
12251 }
12252
12253 static void
12254 base_breakpoint_print_mention (struct breakpoint *b)
12255 {
12256   internal_error_pure_virtual_called ();
12257 }
12258
12259 static void
12260 base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12261 {
12262   internal_error_pure_virtual_called ();
12263 }
12264
12265 static void
12266 base_breakpoint_create_sals_from_location
12267   (const struct event_location *location,
12268    struct linespec_result *canonical,
12269    enum bptype type_wanted)
12270 {
12271   internal_error_pure_virtual_called ();
12272 }
12273
12274 static void
12275 base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12276                                         struct linespec_result *c,
12277                                         gdb::unique_xmalloc_ptr<char> cond_string,
12278                                         gdb::unique_xmalloc_ptr<char> extra_string,
12279                                         enum bptype type_wanted,
12280                                         enum bpdisp disposition,
12281                                         int thread,
12282                                         int task, int ignore_count,
12283                                         const struct breakpoint_ops *o,
12284                                         int from_tty, int enabled,
12285                                         int internal, unsigned flags)
12286 {
12287   internal_error_pure_virtual_called ();
12288 }
12289
12290 static std::vector<symtab_and_line>
12291 base_breakpoint_decode_location (struct breakpoint *b,
12292                                  const struct event_location *location,
12293                                  struct program_space *search_pspace)
12294 {
12295   internal_error_pure_virtual_called ();
12296 }
12297
12298 /* The default 'explains_signal' method.  */
12299
12300 static int
12301 base_breakpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
12302 {
12303   return 1;
12304 }
12305
12306 /* The default "after_condition_true" method.  */
12307
12308 static void
12309 base_breakpoint_after_condition_true (struct bpstats *bs)
12310 {
12311   /* Nothing to do.   */
12312 }
12313
12314 struct breakpoint_ops base_breakpoint_ops =
12315 {
12316   base_breakpoint_allocate_location,
12317   base_breakpoint_re_set,
12318   base_breakpoint_insert_location,
12319   base_breakpoint_remove_location,
12320   base_breakpoint_breakpoint_hit,
12321   base_breakpoint_check_status,
12322   base_breakpoint_resources_needed,
12323   base_breakpoint_works_in_software_mode,
12324   base_breakpoint_print_it,
12325   NULL,
12326   base_breakpoint_print_one_detail,
12327   base_breakpoint_print_mention,
12328   base_breakpoint_print_recreate,
12329   base_breakpoint_create_sals_from_location,
12330   base_breakpoint_create_breakpoints_sal,
12331   base_breakpoint_decode_location,
12332   base_breakpoint_explains_signal,
12333   base_breakpoint_after_condition_true,
12334 };
12335
12336 /* Default breakpoint_ops methods.  */
12337
12338 static void
12339 bkpt_re_set (struct breakpoint *b)
12340 {
12341   /* FIXME: is this still reachable?  */
12342   if (breakpoint_event_location_empty_p (b))
12343     {
12344       /* Anything without a location can't be re-set.  */
12345       delete_breakpoint (b);
12346       return;
12347     }
12348
12349   breakpoint_re_set_default (b);
12350 }
12351
12352 static int
12353 bkpt_insert_location (struct bp_location *bl)
12354 {
12355   CORE_ADDR addr = bl->target_info.reqstd_address;
12356
12357   bl->target_info.kind = breakpoint_kind (bl, &addr);
12358   bl->target_info.placed_address = addr;
12359
12360   if (bl->loc_type == bp_loc_hardware_breakpoint)
12361     return target_insert_hw_breakpoint (bl->gdbarch, &bl->target_info);
12362   else
12363     return target_insert_breakpoint (bl->gdbarch, &bl->target_info);
12364 }
12365
12366 static int
12367 bkpt_remove_location (struct bp_location *bl, enum remove_bp_reason reason)
12368 {
12369   if (bl->loc_type == bp_loc_hardware_breakpoint)
12370     return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
12371   else
12372     return target_remove_breakpoint (bl->gdbarch, &bl->target_info, reason);
12373 }
12374
12375 static int
12376 bkpt_breakpoint_hit (const struct bp_location *bl,
12377                      const address_space *aspace, CORE_ADDR bp_addr,
12378                      const struct target_waitstatus *ws)
12379 {
12380   if (ws->kind != TARGET_WAITKIND_STOPPED
12381       || ws->value.sig != GDB_SIGNAL_TRAP)
12382     return 0;
12383
12384   if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
12385                                  aspace, bp_addr))
12386     return 0;
12387
12388   if (overlay_debugging         /* unmapped overlay section */
12389       && section_is_overlay (bl->section)
12390       && !section_is_mapped (bl->section))
12391     return 0;
12392
12393   return 1;
12394 }
12395
12396 static int
12397 dprintf_breakpoint_hit (const struct bp_location *bl,
12398                         const address_space *aspace, CORE_ADDR bp_addr,
12399                         const struct target_waitstatus *ws)
12400 {
12401   if (dprintf_style == dprintf_style_agent
12402       && target_can_run_breakpoint_commands ())
12403     {
12404       /* An agent-style dprintf never causes a stop.  If we see a trap
12405          for this address it must be for a breakpoint that happens to
12406          be set at the same address.  */
12407       return 0;
12408     }
12409
12410   return bkpt_breakpoint_hit (bl, aspace, bp_addr, ws);
12411 }
12412
12413 static int
12414 bkpt_resources_needed (const struct bp_location *bl)
12415 {
12416   gdb_assert (bl->owner->type == bp_hardware_breakpoint);
12417
12418   return 1;
12419 }
12420
12421 static enum print_stop_action
12422 bkpt_print_it (bpstat bs)
12423 {
12424   struct breakpoint *b;
12425   const struct bp_location *bl;
12426   int bp_temp;
12427   struct ui_out *uiout = current_uiout;
12428
12429   gdb_assert (bs->bp_location_at != NULL);
12430
12431   bl = bs->bp_location_at;
12432   b = bs->breakpoint_at;
12433
12434   bp_temp = b->disposition == disp_del;
12435   if (bl->address != bl->requested_address)
12436     breakpoint_adjustment_warning (bl->requested_address,
12437                                    bl->address,
12438                                    b->number, 1);
12439   annotate_breakpoint (b->number);
12440   maybe_print_thread_hit_breakpoint (uiout);
12441
12442   if (bp_temp)
12443     uiout->text ("Temporary breakpoint ");
12444   else
12445     uiout->text ("Breakpoint ");
12446   if (uiout->is_mi_like_p ())
12447     {
12448       uiout->field_string ("reason",
12449                            async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
12450       uiout->field_string ("disp", bpdisp_text (b->disposition));
12451     }
12452   uiout->field_int ("bkptno", b->number);
12453   uiout->text (", ");
12454
12455   return PRINT_SRC_AND_LOC;
12456 }
12457
12458 static void
12459 bkpt_print_mention (struct breakpoint *b)
12460 {
12461   if (current_uiout->is_mi_like_p ())
12462     return;
12463
12464   switch (b->type)
12465     {
12466     case bp_breakpoint:
12467     case bp_gnu_ifunc_resolver:
12468       if (b->disposition == disp_del)
12469         printf_filtered (_("Temporary breakpoint"));
12470       else
12471         printf_filtered (_("Breakpoint"));
12472       printf_filtered (_(" %d"), b->number);
12473       if (b->type == bp_gnu_ifunc_resolver)
12474         printf_filtered (_(" at gnu-indirect-function resolver"));
12475       break;
12476     case bp_hardware_breakpoint:
12477       printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
12478       break;
12479     case bp_dprintf:
12480       printf_filtered (_("Dprintf %d"), b->number);
12481       break;
12482     }
12483
12484   say_where (b);
12485 }
12486
12487 static void
12488 bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
12489 {
12490   if (tp->type == bp_breakpoint && tp->disposition == disp_del)
12491     fprintf_unfiltered (fp, "tbreak");
12492   else if (tp->type == bp_breakpoint)
12493     fprintf_unfiltered (fp, "break");
12494   else if (tp->type == bp_hardware_breakpoint
12495            && tp->disposition == disp_del)
12496     fprintf_unfiltered (fp, "thbreak");
12497   else if (tp->type == bp_hardware_breakpoint)
12498     fprintf_unfiltered (fp, "hbreak");
12499   else
12500     internal_error (__FILE__, __LINE__,
12501                     _("unhandled breakpoint type %d"), (int) tp->type);
12502
12503   fprintf_unfiltered (fp, " %s",
12504                       event_location_to_string (tp->location.get ()));
12505
12506   /* Print out extra_string if this breakpoint is pending.  It might
12507      contain, for example, conditions that were set by the user.  */
12508   if (tp->loc == NULL && tp->extra_string != NULL)
12509     fprintf_unfiltered (fp, " %s", tp->extra_string);
12510
12511   print_recreate_thread (tp, fp);
12512 }
12513
12514 static void
12515 bkpt_create_sals_from_location (const struct event_location *location,
12516                                 struct linespec_result *canonical,
12517                                 enum bptype type_wanted)
12518 {
12519   create_sals_from_location_default (location, canonical, type_wanted);
12520 }
12521
12522 static void
12523 bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
12524                              struct linespec_result *canonical,
12525                              gdb::unique_xmalloc_ptr<char> cond_string,
12526                              gdb::unique_xmalloc_ptr<char> extra_string,
12527                              enum bptype type_wanted,
12528                              enum bpdisp disposition,
12529                              int thread,
12530                              int task, int ignore_count,
12531                              const struct breakpoint_ops *ops,
12532                              int from_tty, int enabled,
12533                              int internal, unsigned flags)
12534 {
12535   create_breakpoints_sal_default (gdbarch, canonical,
12536                                   std::move (cond_string),
12537                                   std::move (extra_string),
12538                                   type_wanted,
12539                                   disposition, thread, task,
12540                                   ignore_count, ops, from_tty,
12541                                   enabled, internal, flags);
12542 }
12543
12544 static std::vector<symtab_and_line>
12545 bkpt_decode_location (struct breakpoint *b,
12546                       const struct event_location *location,
12547                       struct program_space *search_pspace)
12548 {
12549   return decode_location_default (b, location, search_pspace);
12550 }
12551
12552 /* Virtual table for internal breakpoints.  */
12553
12554 static void
12555 internal_bkpt_re_set (struct breakpoint *b)
12556 {
12557   switch (b->type)
12558     {
12559       /* Delete overlay event and longjmp master breakpoints; they
12560          will be reset later by breakpoint_re_set.  */
12561     case bp_overlay_event:
12562     case bp_longjmp_master:
12563     case bp_std_terminate_master:
12564     case bp_exception_master:
12565       delete_breakpoint (b);
12566       break;
12567
12568       /* This breakpoint is special, it's set up when the inferior
12569          starts and we really don't want to touch it.  */
12570     case bp_shlib_event:
12571
12572       /* Like bp_shlib_event, this breakpoint type is special.  Once
12573          it is set up, we do not want to touch it.  */
12574     case bp_thread_event:
12575       break;
12576     }
12577 }
12578
12579 static void
12580 internal_bkpt_check_status (bpstat bs)
12581 {
12582   if (bs->breakpoint_at->type == bp_shlib_event)
12583     {
12584       /* If requested, stop when the dynamic linker notifies GDB of
12585          events.  This allows the user to get control and place
12586          breakpoints in initializer routines for dynamically loaded
12587          objects (among other things).  */
12588       bs->stop = stop_on_solib_events;
12589       bs->print = stop_on_solib_events;
12590     }
12591   else
12592     bs->stop = 0;
12593 }
12594
12595 static enum print_stop_action
12596 internal_bkpt_print_it (bpstat bs)
12597 {
12598   struct breakpoint *b;
12599
12600   b = bs->breakpoint_at;
12601
12602   switch (b->type)
12603     {
12604     case bp_shlib_event:
12605       /* Did we stop because the user set the stop_on_solib_events
12606          variable?  (If so, we report this as a generic, "Stopped due
12607          to shlib event" message.) */
12608       print_solib_event (0);
12609       break;
12610
12611     case bp_thread_event:
12612       /* Not sure how we will get here.
12613          GDB should not stop for these breakpoints.  */
12614       printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12615       break;
12616
12617     case bp_overlay_event:
12618       /* By analogy with the thread event, GDB should not stop for these.  */
12619       printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12620       break;
12621
12622     case bp_longjmp_master:
12623       /* These should never be enabled.  */
12624       printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12625       break;
12626
12627     case bp_std_terminate_master:
12628       /* These should never be enabled.  */
12629       printf_filtered (_("std::terminate Master Breakpoint: "
12630                          "gdb should not stop!\n"));
12631       break;
12632
12633     case bp_exception_master:
12634       /* These should never be enabled.  */
12635       printf_filtered (_("Exception Master Breakpoint: "
12636                          "gdb should not stop!\n"));
12637       break;
12638     }
12639
12640   return PRINT_NOTHING;
12641 }
12642
12643 static void
12644 internal_bkpt_print_mention (struct breakpoint *b)
12645 {
12646   /* Nothing to mention.  These breakpoints are internal.  */
12647 }
12648
12649 /* Virtual table for momentary breakpoints  */
12650
12651 static void
12652 momentary_bkpt_re_set (struct breakpoint *b)
12653 {
12654   /* Keep temporary breakpoints, which can be encountered when we step
12655      over a dlopen call and solib_add is resetting the breakpoints.
12656      Otherwise these should have been blown away via the cleanup chain
12657      or by breakpoint_init_inferior when we rerun the executable.  */
12658 }
12659
12660 static void
12661 momentary_bkpt_check_status (bpstat bs)
12662 {
12663   /* Nothing.  The point of these breakpoints is causing a stop.  */
12664 }
12665
12666 static enum print_stop_action
12667 momentary_bkpt_print_it (bpstat bs)
12668 {
12669   return PRINT_UNKNOWN;
12670 }
12671
12672 static void
12673 momentary_bkpt_print_mention (struct breakpoint *b)
12674 {
12675   /* Nothing to mention.  These breakpoints are internal.  */
12676 }
12677
12678 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12679
12680    It gets cleared already on the removal of the first one of such placed
12681    breakpoints.  This is OK as they get all removed altogether.  */
12682
12683 longjmp_breakpoint::~longjmp_breakpoint ()
12684 {
12685   thread_info *tp = find_thread_global_id (this->thread);
12686
12687   if (tp != NULL)
12688     tp->initiating_frame = null_frame_id;
12689 }
12690
12691 /* Specific methods for probe breakpoints.  */
12692
12693 static int
12694 bkpt_probe_insert_location (struct bp_location *bl)
12695 {
12696   int v = bkpt_insert_location (bl);
12697
12698   if (v == 0)
12699     {
12700       /* The insertion was successful, now let's set the probe's semaphore
12701          if needed.  */
12702       bl->probe.prob->set_semaphore (bl->probe.objfile, bl->gdbarch);
12703     }
12704
12705   return v;
12706 }
12707
12708 static int
12709 bkpt_probe_remove_location (struct bp_location *bl,
12710                             enum remove_bp_reason reason)
12711 {
12712   /* Let's clear the semaphore before removing the location.  */
12713   bl->probe.prob->clear_semaphore (bl->probe.objfile, bl->gdbarch);
12714
12715   return bkpt_remove_location (bl, reason);
12716 }
12717
12718 static void
12719 bkpt_probe_create_sals_from_location (const struct event_location *location,
12720                                       struct linespec_result *canonical,
12721                                       enum bptype type_wanted)
12722 {
12723   struct linespec_sals lsal;
12724
12725   lsal.sals = parse_probes (location, NULL, canonical);
12726   lsal.canonical
12727     = xstrdup (event_location_to_string (canonical->location.get ()));
12728   canonical->lsals.push_back (std::move (lsal));
12729 }
12730
12731 static std::vector<symtab_and_line>
12732 bkpt_probe_decode_location (struct breakpoint *b,
12733                             const struct event_location *location,
12734                             struct program_space *search_pspace)
12735 {
12736   std::vector<symtab_and_line> sals = parse_probes (location, search_pspace, NULL);
12737   if (sals.empty ())
12738     error (_("probe not found"));
12739   return sals;
12740 }
12741
12742 /* The breakpoint_ops structure to be used in tracepoints.  */
12743
12744 static void
12745 tracepoint_re_set (struct breakpoint *b)
12746 {
12747   breakpoint_re_set_default (b);
12748 }
12749
12750 static int
12751 tracepoint_breakpoint_hit (const struct bp_location *bl,
12752                            const address_space *aspace, CORE_ADDR bp_addr,
12753                            const struct target_waitstatus *ws)
12754 {
12755   /* By definition, the inferior does not report stops at
12756      tracepoints.  */
12757   return 0;
12758 }
12759
12760 static void
12761 tracepoint_print_one_detail (const struct breakpoint *self,
12762                              struct ui_out *uiout)
12763 {
12764   struct tracepoint *tp = (struct tracepoint *) self;
12765   if (!tp->static_trace_marker_id.empty ())
12766     {
12767       gdb_assert (self->type == bp_static_tracepoint);
12768
12769       uiout->text ("\tmarker id is ");
12770       uiout->field_string ("static-tracepoint-marker-string-id",
12771                            tp->static_trace_marker_id);
12772       uiout->text ("\n");
12773     }
12774 }
12775
12776 static void
12777 tracepoint_print_mention (struct breakpoint *b)
12778 {
12779   if (current_uiout->is_mi_like_p ())
12780     return;
12781
12782   switch (b->type)
12783     {
12784     case bp_tracepoint:
12785       printf_filtered (_("Tracepoint"));
12786       printf_filtered (_(" %d"), b->number);
12787       break;
12788     case bp_fast_tracepoint:
12789       printf_filtered (_("Fast tracepoint"));
12790       printf_filtered (_(" %d"), b->number);
12791       break;
12792     case bp_static_tracepoint:
12793       printf_filtered (_("Static tracepoint"));
12794       printf_filtered (_(" %d"), b->number);
12795       break;
12796     default:
12797       internal_error (__FILE__, __LINE__,
12798                       _("unhandled tracepoint type %d"), (int) b->type);
12799     }
12800
12801   say_where (b);
12802 }
12803
12804 static void
12805 tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
12806 {
12807   struct tracepoint *tp = (struct tracepoint *) self;
12808
12809   if (self->type == bp_fast_tracepoint)
12810     fprintf_unfiltered (fp, "ftrace");
12811   else if (self->type == bp_static_tracepoint)
12812     fprintf_unfiltered (fp, "strace");
12813   else if (self->type == bp_tracepoint)
12814     fprintf_unfiltered (fp, "trace");
12815   else
12816     internal_error (__FILE__, __LINE__,
12817                     _("unhandled tracepoint type %d"), (int) self->type);
12818
12819   fprintf_unfiltered (fp, " %s",
12820                       event_location_to_string (self->location.get ()));
12821   print_recreate_thread (self, fp);
12822
12823   if (tp->pass_count)
12824     fprintf_unfiltered (fp, "  passcount %d\n", tp->pass_count);
12825 }
12826
12827 static void
12828 tracepoint_create_sals_from_location (const struct event_location *location,
12829                                       struct linespec_result *canonical,
12830                                       enum bptype type_wanted)
12831 {
12832   create_sals_from_location_default (location, canonical, type_wanted);
12833 }
12834
12835 static void
12836 tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12837                                    struct linespec_result *canonical,
12838                                    gdb::unique_xmalloc_ptr<char> cond_string,
12839                                    gdb::unique_xmalloc_ptr<char> extra_string,
12840                                    enum bptype type_wanted,
12841                                    enum bpdisp disposition,
12842                                    int thread,
12843                                    int task, int ignore_count,
12844                                    const struct breakpoint_ops *ops,
12845                                    int from_tty, int enabled,
12846                                    int internal, unsigned flags)
12847 {
12848   create_breakpoints_sal_default (gdbarch, canonical,
12849                                   std::move (cond_string),
12850                                   std::move (extra_string),
12851                                   type_wanted,
12852                                   disposition, thread, task,
12853                                   ignore_count, ops, from_tty,
12854                                   enabled, internal, flags);
12855 }
12856
12857 static std::vector<symtab_and_line>
12858 tracepoint_decode_location (struct breakpoint *b,
12859                             const struct event_location *location,
12860                             struct program_space *search_pspace)
12861 {
12862   return decode_location_default (b, location, search_pspace);
12863 }
12864
12865 struct breakpoint_ops tracepoint_breakpoint_ops;
12866
12867 /* The breakpoint_ops structure to be use on tracepoints placed in a
12868    static probe.  */
12869
12870 static void
12871 tracepoint_probe_create_sals_from_location
12872   (const struct event_location *location,
12873    struct linespec_result *canonical,
12874    enum bptype type_wanted)
12875 {
12876   /* We use the same method for breakpoint on probes.  */
12877   bkpt_probe_create_sals_from_location (location, canonical, type_wanted);
12878 }
12879
12880 static std::vector<symtab_and_line>
12881 tracepoint_probe_decode_location (struct breakpoint *b,
12882                                   const struct event_location *location,
12883                                   struct program_space *search_pspace)
12884 {
12885   /* We use the same method for breakpoint on probes.  */
12886   return bkpt_probe_decode_location (b, location, search_pspace);
12887 }
12888
12889 static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
12890
12891 /* Dprintf breakpoint_ops methods.  */
12892
12893 static void
12894 dprintf_re_set (struct breakpoint *b)
12895 {
12896   breakpoint_re_set_default (b);
12897
12898   /* extra_string should never be non-NULL for dprintf.  */
12899   gdb_assert (b->extra_string != NULL);
12900
12901   /* 1 - connect to target 1, that can run breakpoint commands.
12902      2 - create a dprintf, which resolves fine.
12903      3 - disconnect from target 1
12904      4 - connect to target 2, that can NOT run breakpoint commands.
12905
12906      After steps #3/#4, you'll want the dprintf command list to
12907      be updated, because target 1 and 2 may well return different
12908      answers for target_can_run_breakpoint_commands().
12909      Given absence of finer grained resetting, we get to do
12910      it all the time.  */
12911   if (b->extra_string != NULL)
12912     update_dprintf_command_list (b);
12913 }
12914
12915 /* Implement the "print_recreate" breakpoint_ops method for dprintf.  */
12916
12917 static void
12918 dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp)
12919 {
12920   fprintf_unfiltered (fp, "dprintf %s,%s",
12921                       event_location_to_string (tp->location.get ()),
12922                       tp->extra_string);
12923   print_recreate_thread (tp, fp);
12924 }
12925
12926 /* Implement the "after_condition_true" breakpoint_ops method for
12927    dprintf.
12928
12929    dprintf's are implemented with regular commands in their command
12930    list, but we run the commands here instead of before presenting the
12931    stop to the user, as dprintf's don't actually cause a stop.  This
12932    also makes it so that the commands of multiple dprintfs at the same
12933    address are all handled.  */
12934
12935 static void
12936 dprintf_after_condition_true (struct bpstats *bs)
12937 {
12938   struct bpstats tmp_bs;
12939   struct bpstats *tmp_bs_p = &tmp_bs;
12940
12941   /* dprintf's never cause a stop.  This wasn't set in the
12942      check_status hook instead because that would make the dprintf's
12943      condition not be evaluated.  */
12944   bs->stop = 0;
12945
12946   /* Run the command list here.  Take ownership of it instead of
12947      copying.  We never want these commands to run later in
12948      bpstat_do_actions, if a breakpoint that causes a stop happens to
12949      be set at same address as this dprintf, or even if running the
12950      commands here throws.  */
12951   tmp_bs.commands = bs->commands;
12952   bs->commands = NULL;
12953
12954   bpstat_do_actions_1 (&tmp_bs_p);
12955
12956   /* 'tmp_bs.commands' will usually be NULL by now, but
12957      bpstat_do_actions_1 may return early without processing the whole
12958      list.  */
12959 }
12960
12961 /* The breakpoint_ops structure to be used on static tracepoints with
12962    markers (`-m').  */
12963
12964 static void
12965 strace_marker_create_sals_from_location (const struct event_location *location,
12966                                          struct linespec_result *canonical,
12967                                          enum bptype type_wanted)
12968 {
12969   struct linespec_sals lsal;
12970   const char *arg_start, *arg;
12971
12972   arg = arg_start = get_linespec_location (location)->spec_string;
12973   lsal.sals = decode_static_tracepoint_spec (&arg);
12974
12975   std::string str (arg_start, arg - arg_start);
12976   const char *ptr = str.c_str ();
12977   canonical->location
12978     = new_linespec_location (&ptr, symbol_name_match_type::FULL);
12979
12980   lsal.canonical
12981     = xstrdup (event_location_to_string (canonical->location.get ()));
12982   canonical->lsals.push_back (std::move (lsal));
12983 }
12984
12985 static void
12986 strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
12987                                       struct linespec_result *canonical,
12988                                       gdb::unique_xmalloc_ptr<char> cond_string,
12989                                       gdb::unique_xmalloc_ptr<char> extra_string,
12990                                       enum bptype type_wanted,
12991                                       enum bpdisp disposition,
12992                                       int thread,
12993                                       int task, int ignore_count,
12994                                       const struct breakpoint_ops *ops,
12995                                       int from_tty, int enabled,
12996                                       int internal, unsigned flags)
12997 {
12998   const linespec_sals &lsal = canonical->lsals[0];
12999
13000   /* If the user is creating a static tracepoint by marker id
13001      (strace -m MARKER_ID), then store the sals index, so that
13002      breakpoint_re_set can try to match up which of the newly
13003      found markers corresponds to this one, and, don't try to
13004      expand multiple locations for each sal, given than SALS
13005      already should contain all sals for MARKER_ID.  */
13006
13007   for (size_t i = 0; i < lsal.sals.size (); i++)
13008     {
13009       event_location_up location
13010         = copy_event_location (canonical->location.get ());
13011
13012       std::unique_ptr<tracepoint> tp (new tracepoint ());
13013       init_breakpoint_sal (tp.get (), gdbarch, lsal.sals[i],
13014                            std::move (location), NULL,
13015                            std::move (cond_string),
13016                            std::move (extra_string),
13017                            type_wanted, disposition,
13018                            thread, task, ignore_count, ops,
13019                            from_tty, enabled, internal, flags,
13020                            canonical->special_display);
13021       /* Given that its possible to have multiple markers with
13022          the same string id, if the user is creating a static
13023          tracepoint by marker id ("strace -m MARKER_ID"), then
13024          store the sals index, so that breakpoint_re_set can
13025          try to match up which of the newly found markers
13026          corresponds to this one  */
13027       tp->static_trace_marker_id_idx = i;
13028
13029       install_breakpoint (internal, std::move (tp), 0);
13030     }
13031 }
13032
13033 static std::vector<symtab_and_line>
13034 strace_marker_decode_location (struct breakpoint *b,
13035                                const struct event_location *location,
13036                                struct program_space *search_pspace)
13037 {
13038   struct tracepoint *tp = (struct tracepoint *) b;
13039   const char *s = get_linespec_location (location)->spec_string;
13040
13041   std::vector<symtab_and_line> sals = decode_static_tracepoint_spec (&s);
13042   if (sals.size () > tp->static_trace_marker_id_idx)
13043     {
13044       sals[0] = sals[tp->static_trace_marker_id_idx];
13045       sals.resize (1);
13046       return sals;
13047     }
13048   else
13049     error (_("marker %s not found"), tp->static_trace_marker_id.c_str ());
13050 }
13051
13052 static struct breakpoint_ops strace_marker_breakpoint_ops;
13053
13054 static int
13055 strace_marker_p (struct breakpoint *b)
13056 {
13057   return b->ops == &strace_marker_breakpoint_ops;
13058 }
13059
13060 /* Delete a breakpoint and clean up all traces of it in the data
13061    structures.  */
13062
13063 void
13064 delete_breakpoint (struct breakpoint *bpt)
13065 {
13066   struct breakpoint *b;
13067
13068   gdb_assert (bpt != NULL);
13069
13070   /* Has this bp already been deleted?  This can happen because
13071      multiple lists can hold pointers to bp's.  bpstat lists are
13072      especial culprits.
13073
13074      One example of this happening is a watchpoint's scope bp.  When
13075      the scope bp triggers, we notice that the watchpoint is out of
13076      scope, and delete it.  We also delete its scope bp.  But the
13077      scope bp is marked "auto-deleting", and is already on a bpstat.
13078      That bpstat is then checked for auto-deleting bp's, which are
13079      deleted.
13080
13081      A real solution to this problem might involve reference counts in
13082      bp's, and/or giving them pointers back to their referencing
13083      bpstat's, and teaching delete_breakpoint to only free a bp's
13084      storage when no more references were extent.  A cheaper bandaid
13085      was chosen.  */
13086   if (bpt->type == bp_none)
13087     return;
13088
13089   /* At least avoid this stale reference until the reference counting
13090      of breakpoints gets resolved.  */
13091   if (bpt->related_breakpoint != bpt)
13092     {
13093       struct breakpoint *related;
13094       struct watchpoint *w;
13095
13096       if (bpt->type == bp_watchpoint_scope)
13097         w = (struct watchpoint *) bpt->related_breakpoint;
13098       else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
13099         w = (struct watchpoint *) bpt;
13100       else
13101         w = NULL;
13102       if (w != NULL)
13103         watchpoint_del_at_next_stop (w);
13104
13105       /* Unlink bpt from the bpt->related_breakpoint ring.  */
13106       for (related = bpt; related->related_breakpoint != bpt;
13107            related = related->related_breakpoint);
13108       related->related_breakpoint = bpt->related_breakpoint;
13109       bpt->related_breakpoint = bpt;
13110     }
13111
13112   /* watch_command_1 creates a watchpoint but only sets its number if
13113      update_watchpoint succeeds in creating its bp_locations.  If there's
13114      a problem in that process, we'll be asked to delete the half-created
13115      watchpoint.  In that case, don't announce the deletion.  */
13116   if (bpt->number)
13117     gdb::observers::breakpoint_deleted.notify (bpt);
13118
13119   if (breakpoint_chain == bpt)
13120     breakpoint_chain = bpt->next;
13121
13122   ALL_BREAKPOINTS (b)
13123     if (b->next == bpt)
13124     {
13125       b->next = bpt->next;
13126       break;
13127     }
13128
13129   /* Be sure no bpstat's are pointing at the breakpoint after it's
13130      been freed.  */
13131   /* FIXME, how can we find all bpstat's?  We just check stop_bpstat
13132      in all threads for now.  Note that we cannot just remove bpstats
13133      pointing at bpt from the stop_bpstat list entirely, as breakpoint
13134      commands are associated with the bpstat; if we remove it here,
13135      then the later call to bpstat_do_actions (&stop_bpstat); in
13136      event-top.c won't do anything, and temporary breakpoints with
13137      commands won't work.  */
13138
13139   iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13140
13141   /* Now that breakpoint is removed from breakpoint list, update the
13142      global location list.  This will remove locations that used to
13143      belong to this breakpoint.  Do this before freeing the breakpoint
13144      itself, since remove_breakpoint looks at location's owner.  It
13145      might be better design to have location completely
13146      self-contained, but it's not the case now.  */
13147   update_global_location_list (UGLL_DONT_INSERT);
13148
13149   /* On the chance that someone will soon try again to delete this
13150      same bp, we mark it as deleted before freeing its storage.  */
13151   bpt->type = bp_none;
13152   delete bpt;
13153 }
13154
13155 /* Iterator function to call a user-provided callback function once
13156    for each of B and its related breakpoints.  */
13157
13158 static void
13159 iterate_over_related_breakpoints (struct breakpoint *b,
13160                                   gdb::function_view<void (breakpoint *)> function)
13161 {
13162   struct breakpoint *related;
13163
13164   related = b;
13165   do
13166     {
13167       struct breakpoint *next;
13168
13169       /* FUNCTION may delete RELATED.  */
13170       next = related->related_breakpoint;
13171
13172       if (next == related)
13173         {
13174           /* RELATED is the last ring entry.  */
13175           function (related);
13176
13177           /* FUNCTION may have deleted it, so we'd never reach back to
13178              B.  There's nothing left to do anyway, so just break
13179              out.  */
13180           break;
13181         }
13182       else
13183         function (related);
13184
13185       related = next;
13186     }
13187   while (related != b);
13188 }
13189
13190 static void
13191 delete_command (const char *arg, int from_tty)
13192 {
13193   struct breakpoint *b, *b_tmp;
13194
13195   dont_repeat ();
13196
13197   if (arg == 0)
13198     {
13199       int breaks_to_delete = 0;
13200
13201       /* Delete all breakpoints if no argument.  Do not delete
13202          internal breakpoints, these have to be deleted with an
13203          explicit breakpoint number argument.  */
13204       ALL_BREAKPOINTS (b)
13205         if (user_breakpoint_p (b))
13206           {
13207             breaks_to_delete = 1;
13208             break;
13209           }
13210
13211       /* Ask user only if there are some breakpoints to delete.  */
13212       if (!from_tty
13213           || (breaks_to_delete && query (_("Delete all breakpoints? "))))
13214         {
13215           ALL_BREAKPOINTS_SAFE (b, b_tmp)
13216             if (user_breakpoint_p (b))
13217               delete_breakpoint (b);
13218         }
13219     }
13220   else
13221     map_breakpoint_numbers
13222       (arg, [&] (breakpoint *br)
13223        {
13224          iterate_over_related_breakpoints (br, delete_breakpoint);
13225        });
13226 }
13227
13228 /* Return true if all locations of B bound to PSPACE are pending.  If
13229    PSPACE is NULL, all locations of all program spaces are
13230    considered.  */
13231
13232 static int
13233 all_locations_are_pending (struct breakpoint *b, struct program_space *pspace)
13234 {
13235   struct bp_location *loc;
13236
13237   for (loc = b->loc; loc != NULL; loc = loc->next)
13238     if ((pspace == NULL
13239          || loc->pspace == pspace)
13240         && !loc->shlib_disabled
13241         && !loc->pspace->executing_startup)
13242       return 0;
13243   return 1;
13244 }
13245
13246 /* Subroutine of update_breakpoint_locations to simplify it.
13247    Return non-zero if multiple fns in list LOC have the same name.
13248    Null names are ignored.  */
13249
13250 static int
13251 ambiguous_names_p (struct bp_location *loc)
13252 {
13253   struct bp_location *l;
13254   htab_t htab = htab_create_alloc (13, htab_hash_string, streq_hash, NULL,
13255                                    xcalloc, xfree);
13256
13257   for (l = loc; l != NULL; l = l->next)
13258     {
13259       const char **slot;
13260       const char *name = l->function_name;
13261
13262       /* Allow for some names to be NULL, ignore them.  */
13263       if (name == NULL)
13264         continue;
13265
13266       slot = (const char **) htab_find_slot (htab, (const void *) name,
13267                                              INSERT);
13268       /* NOTE: We can assume slot != NULL here because xcalloc never
13269          returns NULL.  */
13270       if (*slot != NULL)
13271         {
13272           htab_delete (htab);
13273           return 1;
13274         }
13275       *slot = name;
13276     }
13277
13278   htab_delete (htab);
13279   return 0;
13280 }
13281
13282 /* When symbols change, it probably means the sources changed as well,
13283    and it might mean the static tracepoint markers are no longer at
13284    the same address or line numbers they used to be at last we
13285    checked.  Losing your static tracepoints whenever you rebuild is
13286    undesirable.  This function tries to resync/rematch gdb static
13287    tracepoints with the markers on the target, for static tracepoints
13288    that have not been set by marker id.  Static tracepoint that have
13289    been set by marker id are reset by marker id in breakpoint_re_set.
13290    The heuristic is:
13291
13292    1) For a tracepoint set at a specific address, look for a marker at
13293    the old PC.  If one is found there, assume to be the same marker.
13294    If the name / string id of the marker found is different from the
13295    previous known name, assume that means the user renamed the marker
13296    in the sources, and output a warning.
13297
13298    2) For a tracepoint set at a given line number, look for a marker
13299    at the new address of the old line number.  If one is found there,
13300    assume to be the same marker.  If the name / string id of the
13301    marker found is different from the previous known name, assume that
13302    means the user renamed the marker in the sources, and output a
13303    warning.
13304
13305    3) If a marker is no longer found at the same address or line, it
13306    may mean the marker no longer exists.  But it may also just mean
13307    the code changed a bit.  Maybe the user added a few lines of code
13308    that made the marker move up or down (in line number terms).  Ask
13309    the target for info about the marker with the string id as we knew
13310    it.  If found, update line number and address in the matching
13311    static tracepoint.  This will get confused if there's more than one
13312    marker with the same ID (possible in UST, although unadvised
13313    precisely because it confuses tools).  */
13314
13315 static struct symtab_and_line
13316 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
13317 {
13318   struct tracepoint *tp = (struct tracepoint *) b;
13319   struct static_tracepoint_marker marker;
13320   CORE_ADDR pc;
13321
13322   pc = sal.pc;
13323   if (sal.line)
13324     find_line_pc (sal.symtab, sal.line, &pc);
13325
13326   if (target_static_tracepoint_marker_at (pc, &marker))
13327     {
13328       if (tp->static_trace_marker_id != marker.str_id)
13329         warning (_("static tracepoint %d changed probed marker from %s to %s"),
13330                  b->number, tp->static_trace_marker_id.c_str (),
13331                  marker.str_id.c_str ());
13332
13333       tp->static_trace_marker_id = std::move (marker.str_id);
13334
13335       return sal;
13336     }
13337
13338   /* Old marker wasn't found on target at lineno.  Try looking it up
13339      by string ID.  */
13340   if (!sal.explicit_pc
13341       && sal.line != 0
13342       && sal.symtab != NULL
13343       && !tp->static_trace_marker_id.empty ())
13344     {
13345       std::vector<static_tracepoint_marker> markers
13346         = target_static_tracepoint_markers_by_strid
13347             (tp->static_trace_marker_id.c_str ());
13348
13349       if (!markers.empty ())
13350         {
13351           struct symbol *sym;
13352           struct static_tracepoint_marker *tpmarker;
13353           struct ui_out *uiout = current_uiout;
13354           struct explicit_location explicit_loc;
13355
13356           tpmarker = &markers[0];
13357
13358           tp->static_trace_marker_id = std::move (tpmarker->str_id);
13359
13360           warning (_("marker for static tracepoint %d (%s) not "
13361                      "found at previous line number"),
13362                    b->number, tp->static_trace_marker_id.c_str ());
13363
13364           symtab_and_line sal2 = find_pc_line (tpmarker->address, 0);
13365           sym = find_pc_sect_function (tpmarker->address, NULL);
13366           uiout->text ("Now in ");
13367           if (sym)
13368             {
13369               uiout->field_string ("func", SYMBOL_PRINT_NAME (sym),
13370                                    ui_out_style_kind::FUNCTION);
13371               uiout->text (" at ");
13372             }
13373           uiout->field_string ("file",
13374                                symtab_to_filename_for_display (sal2.symtab),
13375                                ui_out_style_kind::FILE);
13376           uiout->text (":");
13377
13378           if (uiout->is_mi_like_p ())
13379             {
13380               const char *fullname = symtab_to_fullname (sal2.symtab);
13381
13382               uiout->field_string ("fullname", fullname);
13383             }
13384
13385           uiout->field_int ("line", sal2.line);
13386           uiout->text ("\n");
13387
13388           b->loc->line_number = sal2.line;
13389           b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
13390
13391           b->location.reset (NULL);
13392           initialize_explicit_location (&explicit_loc);
13393           explicit_loc.source_filename
13394             = ASTRDUP (symtab_to_filename_for_display (sal2.symtab));
13395           explicit_loc.line_offset.offset = b->loc->line_number;
13396           explicit_loc.line_offset.sign = LINE_OFFSET_NONE;
13397           b->location = new_explicit_location (&explicit_loc);
13398
13399           /* Might be nice to check if function changed, and warn if
13400              so.  */
13401         }
13402     }
13403   return sal;
13404 }
13405
13406 /* Returns 1 iff locations A and B are sufficiently same that
13407    we don't need to report breakpoint as changed.  */
13408
13409 static int
13410 locations_are_equal (struct bp_location *a, struct bp_location *b)
13411 {
13412   while (a && b)
13413     {
13414       if (a->address != b->address)
13415         return 0;
13416
13417       if (a->shlib_disabled != b->shlib_disabled)
13418         return 0;
13419
13420       if (a->enabled != b->enabled)
13421         return 0;
13422
13423       a = a->next;
13424       b = b->next;
13425     }
13426
13427   if ((a == NULL) != (b == NULL))
13428     return 0;
13429
13430   return 1;
13431 }
13432
13433 /* Split all locations of B that are bound to PSPACE out of B's
13434    location list to a separate list and return that list's head.  If
13435    PSPACE is NULL, hoist out all locations of B.  */
13436
13437 static struct bp_location *
13438 hoist_existing_locations (struct breakpoint *b, struct program_space *pspace)
13439 {
13440   struct bp_location head;
13441   struct bp_location *i = b->loc;
13442   struct bp_location **i_link = &b->loc;
13443   struct bp_location *hoisted = &head;
13444
13445   if (pspace == NULL)
13446     {
13447       i = b->loc;
13448       b->loc = NULL;
13449       return i;
13450     }
13451
13452   head.next = NULL;
13453
13454   while (i != NULL)
13455     {
13456       if (i->pspace == pspace)
13457         {
13458           *i_link = i->next;
13459           i->next = NULL;
13460           hoisted->next = i;
13461           hoisted = i;
13462         }
13463       else
13464         i_link = &i->next;
13465       i = *i_link;
13466     }
13467
13468   return head.next;
13469 }
13470
13471 /* Create new breakpoint locations for B (a hardware or software
13472    breakpoint) based on SALS and SALS_END.  If SALS_END.NELTS is not
13473    zero, then B is a ranged breakpoint.  Only recreates locations for
13474    FILTER_PSPACE.  Locations of other program spaces are left
13475    untouched.  */
13476
13477 void
13478 update_breakpoint_locations (struct breakpoint *b,
13479                              struct program_space *filter_pspace,
13480                              gdb::array_view<const symtab_and_line> sals,
13481                              gdb::array_view<const symtab_and_line> sals_end)
13482 {
13483   struct bp_location *existing_locations;
13484
13485   if (!sals_end.empty () && (sals.size () != 1 || sals_end.size () != 1))
13486     {
13487       /* Ranged breakpoints have only one start location and one end
13488          location.  */
13489       b->enable_state = bp_disabled;
13490       printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13491                            "multiple locations found\n"),
13492                          b->number);
13493       return;
13494     }
13495
13496   /* If there's no new locations, and all existing locations are
13497      pending, don't do anything.  This optimizes the common case where
13498      all locations are in the same shared library, that was unloaded.
13499      We'd like to retain the location, so that when the library is
13500      loaded again, we don't loose the enabled/disabled status of the
13501      individual locations.  */
13502   if (all_locations_are_pending (b, filter_pspace) && sals.empty ())
13503     return;
13504
13505   existing_locations = hoist_existing_locations (b, filter_pspace);
13506
13507   for (const auto &sal : sals)
13508     {
13509       struct bp_location *new_loc;
13510
13511       switch_to_program_space_and_thread (sal.pspace);
13512
13513       new_loc = add_location_to_breakpoint (b, &sal);
13514
13515       /* Reparse conditions, they might contain references to the
13516          old symtab.  */
13517       if (b->cond_string != NULL)
13518         {
13519           const char *s;
13520
13521           s = b->cond_string;
13522           TRY
13523             {
13524               new_loc->cond = parse_exp_1 (&s, sal.pc,
13525                                            block_for_pc (sal.pc),
13526                                            0);
13527             }
13528           CATCH (e, RETURN_MASK_ERROR)
13529             {
13530               warning (_("failed to reevaluate condition "
13531                          "for breakpoint %d: %s"), 
13532                        b->number, e.message);
13533               new_loc->enabled = 0;
13534             }
13535           END_CATCH
13536         }
13537
13538       if (!sals_end.empty ())
13539         {
13540           CORE_ADDR end = find_breakpoint_range_end (sals_end[0]);
13541
13542           new_loc->length = end - sals[0].pc + 1;
13543         }
13544     }
13545
13546   /* If possible, carry over 'disable' status from existing
13547      breakpoints.  */
13548   {
13549     struct bp_location *e = existing_locations;
13550     /* If there are multiple breakpoints with the same function name,
13551        e.g. for inline functions, comparing function names won't work.
13552        Instead compare pc addresses; this is just a heuristic as things
13553        may have moved, but in practice it gives the correct answer
13554        often enough until a better solution is found.  */
13555     int have_ambiguous_names = ambiguous_names_p (b->loc);
13556
13557     for (; e; e = e->next)
13558       {
13559         if (!e->enabled && e->function_name)
13560           {
13561             struct bp_location *l = b->loc;
13562             if (have_ambiguous_names)
13563               {
13564                 for (; l; l = l->next)
13565                   if (breakpoint_locations_match (e, l))
13566                     {
13567                       l->enabled = 0;
13568                       break;
13569                     }
13570               }
13571             else
13572               {
13573                 for (; l; l = l->next)
13574                   if (l->function_name
13575                       && strcmp (e->function_name, l->function_name) == 0)
13576                     {
13577                       l->enabled = 0;
13578                       break;
13579                     }
13580               }
13581           }
13582       }
13583   }
13584
13585   if (!locations_are_equal (existing_locations, b->loc))
13586     gdb::observers::breakpoint_modified.notify (b);
13587 }
13588
13589 /* Find the SaL locations corresponding to the given LOCATION.
13590    On return, FOUND will be 1 if any SaL was found, zero otherwise.  */
13591
13592 static std::vector<symtab_and_line>
13593 location_to_sals (struct breakpoint *b, struct event_location *location,
13594                   struct program_space *search_pspace, int *found)
13595 {
13596   struct gdb_exception exception = exception_none;
13597
13598   gdb_assert (b->ops != NULL);
13599
13600   std::vector<symtab_and_line> sals;
13601
13602   TRY
13603     {
13604       sals = b->ops->decode_location (b, location, search_pspace);
13605     }
13606   CATCH (e, RETURN_MASK_ERROR)
13607     {
13608       int not_found_and_ok = 0;
13609
13610       exception = e;
13611
13612       /* For pending breakpoints, it's expected that parsing will
13613          fail until the right shared library is loaded.  User has
13614          already told to create pending breakpoints and don't need
13615          extra messages.  If breakpoint is in bp_shlib_disabled
13616          state, then user already saw the message about that
13617          breakpoint being disabled, and don't want to see more
13618          errors.  */
13619       if (e.error == NOT_FOUND_ERROR
13620           && (b->condition_not_parsed
13621               || (b->loc != NULL
13622                   && search_pspace != NULL
13623                   && b->loc->pspace != search_pspace)
13624               || (b->loc && b->loc->shlib_disabled)
13625               || (b->loc && b->loc->pspace->executing_startup)
13626               || b->enable_state == bp_disabled))
13627         not_found_and_ok = 1;
13628
13629       if (!not_found_and_ok)
13630         {
13631           /* We surely don't want to warn about the same breakpoint
13632              10 times.  One solution, implemented here, is disable
13633              the breakpoint on error.  Another solution would be to
13634              have separate 'warning emitted' flag.  Since this
13635              happens only when a binary has changed, I don't know
13636              which approach is better.  */
13637           b->enable_state = bp_disabled;
13638           throw_exception (e);
13639         }
13640     }
13641   END_CATCH
13642
13643   if (exception.reason == 0 || exception.error != NOT_FOUND_ERROR)
13644     {
13645       for (auto &sal : sals)
13646         resolve_sal_pc (&sal);
13647       if (b->condition_not_parsed && b->extra_string != NULL)
13648         {
13649           char *cond_string, *extra_string;
13650           int thread, task;
13651
13652           find_condition_and_thread (b->extra_string, sals[0].pc,
13653                                      &cond_string, &thread, &task,
13654                                      &extra_string);
13655           gdb_assert (b->cond_string == NULL);
13656           if (cond_string)
13657             b->cond_string = cond_string;
13658           b->thread = thread;
13659           b->task = task;
13660           if (extra_string)
13661             {
13662               xfree (b->extra_string);
13663               b->extra_string = extra_string;
13664             }
13665           b->condition_not_parsed = 0;
13666         }
13667
13668       if (b->type == bp_static_tracepoint && !strace_marker_p (b))
13669         sals[0] = update_static_tracepoint (b, sals[0]);
13670
13671       *found = 1;
13672     }
13673   else
13674     *found = 0;
13675
13676   return sals;
13677 }
13678
13679 /* The default re_set method, for typical hardware or software
13680    breakpoints.  Reevaluate the breakpoint and recreate its
13681    locations.  */
13682
13683 static void
13684 breakpoint_re_set_default (struct breakpoint *b)
13685 {
13686   struct program_space *filter_pspace = current_program_space;
13687   std::vector<symtab_and_line> expanded, expanded_end;
13688
13689   int found;
13690   std::vector<symtab_and_line> sals = location_to_sals (b, b->location.get (),
13691                                                         filter_pspace, &found);
13692   if (found)
13693     expanded = std::move (sals);
13694
13695   if (b->location_range_end != NULL)
13696     {
13697       std::vector<symtab_and_line> sals_end
13698         = location_to_sals (b, b->location_range_end.get (),
13699                             filter_pspace, &found);
13700       if (found)
13701         expanded_end = std::move (sals_end);
13702     }
13703
13704   update_breakpoint_locations (b, filter_pspace, expanded, expanded_end);
13705 }
13706
13707 /* Default method for creating SALs from an address string.  It basically
13708    calls parse_breakpoint_sals.  Return 1 for success, zero for failure.  */
13709
13710 static void
13711 create_sals_from_location_default (const struct event_location *location,
13712                                    struct linespec_result *canonical,
13713                                    enum bptype type_wanted)
13714 {
13715   parse_breakpoint_sals (location, canonical);
13716 }
13717
13718 /* Call create_breakpoints_sal for the given arguments.  This is the default
13719    function for the `create_breakpoints_sal' method of
13720    breakpoint_ops.  */
13721
13722 static void
13723 create_breakpoints_sal_default (struct gdbarch *gdbarch,
13724                                 struct linespec_result *canonical,
13725                                 gdb::unique_xmalloc_ptr<char> cond_string,
13726                                 gdb::unique_xmalloc_ptr<char> extra_string,
13727                                 enum bptype type_wanted,
13728                                 enum bpdisp disposition,
13729                                 int thread,
13730                                 int task, int ignore_count,
13731                                 const struct breakpoint_ops *ops,
13732                                 int from_tty, int enabled,
13733                                 int internal, unsigned flags)
13734 {
13735   create_breakpoints_sal (gdbarch, canonical,
13736                           std::move (cond_string),
13737                           std::move (extra_string),
13738                           type_wanted, disposition,
13739                           thread, task, ignore_count, ops, from_tty,
13740                           enabled, internal, flags);
13741 }
13742
13743 /* Decode the line represented by S by calling decode_line_full.  This is the
13744    default function for the `decode_location' method of breakpoint_ops.  */
13745
13746 static std::vector<symtab_and_line>
13747 decode_location_default (struct breakpoint *b,
13748                          const struct event_location *location,
13749                          struct program_space *search_pspace)
13750 {
13751   struct linespec_result canonical;
13752
13753   decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, search_pspace,
13754                     (struct symtab *) NULL, 0,
13755                     &canonical, multiple_symbols_all,
13756                     b->filter);
13757
13758   /* We should get 0 or 1 resulting SALs.  */
13759   gdb_assert (canonical.lsals.size () < 2);
13760
13761   if (!canonical.lsals.empty ())
13762     {
13763       const linespec_sals &lsal = canonical.lsals[0];
13764       return std::move (lsal.sals);
13765     }
13766   return {};
13767 }
13768
13769 /* Reset a breakpoint.  */
13770
13771 static void
13772 breakpoint_re_set_one (breakpoint *b)
13773 {
13774   input_radix = b->input_radix;
13775   set_language (b->language);
13776
13777   b->ops->re_set (b);
13778 }
13779
13780 /* Re-set breakpoint locations for the current program space.
13781    Locations bound to other program spaces are left untouched.  */
13782
13783 void
13784 breakpoint_re_set (void)
13785 {
13786   struct breakpoint *b, *b_tmp;
13787
13788   {
13789     scoped_restore_current_language save_language;
13790     scoped_restore save_input_radix = make_scoped_restore (&input_radix);
13791     scoped_restore_current_pspace_and_thread restore_pspace_thread;
13792
13793     /* breakpoint_re_set_one sets the current_language to the language
13794        of the breakpoint it is resetting (see prepare_re_set_context)
13795        before re-evaluating the breakpoint's location.  This change can
13796        unfortunately get undone by accident if the language_mode is set
13797        to auto, and we either switch frames, or more likely in this context,
13798        we select the current frame.
13799
13800        We prevent this by temporarily turning the language_mode to
13801        language_mode_manual.  We restore it once all breakpoints
13802        have been reset.  */
13803     scoped_restore save_language_mode = make_scoped_restore (&language_mode);
13804     language_mode = language_mode_manual;
13805
13806     /* Note: we must not try to insert locations until after all
13807        breakpoints have been re-set.  Otherwise, e.g., when re-setting
13808        breakpoint 1, we'd insert the locations of breakpoint 2, which
13809        hadn't been re-set yet, and thus may have stale locations.  */
13810
13811     ALL_BREAKPOINTS_SAFE (b, b_tmp)
13812       {
13813         TRY
13814           {
13815             breakpoint_re_set_one (b);
13816           }
13817         CATCH (ex, RETURN_MASK_ALL)
13818           {
13819             exception_fprintf (gdb_stderr, ex,
13820                                "Error in re-setting breakpoint %d: ",
13821                                b->number);
13822           }
13823         END_CATCH
13824       }
13825
13826     jit_breakpoint_re_set ();
13827   }
13828
13829   create_overlay_event_breakpoint ();
13830   create_longjmp_master_breakpoint ();
13831   create_std_terminate_master_breakpoint ();
13832   create_exception_master_breakpoint ();
13833
13834   /* Now we can insert.  */
13835   update_global_location_list (UGLL_MAY_INSERT);
13836 }
13837 \f
13838 /* Reset the thread number of this breakpoint:
13839
13840    - If the breakpoint is for all threads, leave it as-is.
13841    - Else, reset it to the current thread for inferior_ptid.  */
13842 void
13843 breakpoint_re_set_thread (struct breakpoint *b)
13844 {
13845   if (b->thread != -1)
13846     {
13847       b->thread = inferior_thread ()->global_num;
13848
13849       /* We're being called after following a fork.  The new fork is
13850          selected as current, and unless this was a vfork will have a
13851          different program space from the original thread.  Reset that
13852          as well.  */
13853       b->loc->pspace = current_program_space;
13854     }
13855 }
13856
13857 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13858    If from_tty is nonzero, it prints a message to that effect,
13859    which ends with a period (no newline).  */
13860
13861 void
13862 set_ignore_count (int bptnum, int count, int from_tty)
13863 {
13864   struct breakpoint *b;
13865
13866   if (count < 0)
13867     count = 0;
13868
13869   ALL_BREAKPOINTS (b)
13870     if (b->number == bptnum)
13871     {
13872       if (is_tracepoint (b))
13873         {
13874           if (from_tty && count != 0)
13875             printf_filtered (_("Ignore count ignored for tracepoint %d."),
13876                              bptnum);
13877           return;
13878         }
13879       
13880       b->ignore_count = count;
13881       if (from_tty)
13882         {
13883           if (count == 0)
13884             printf_filtered (_("Will stop next time "
13885                                "breakpoint %d is reached."),
13886                              bptnum);
13887           else if (count == 1)
13888             printf_filtered (_("Will ignore next crossing of breakpoint %d."),
13889                              bptnum);
13890           else
13891             printf_filtered (_("Will ignore next %d "
13892                                "crossings of breakpoint %d."),
13893                              count, bptnum);
13894         }
13895       gdb::observers::breakpoint_modified.notify (b);
13896       return;
13897     }
13898
13899   error (_("No breakpoint number %d."), bptnum);
13900 }
13901
13902 /* Command to set ignore-count of breakpoint N to COUNT.  */
13903
13904 static void
13905 ignore_command (const char *args, int from_tty)
13906 {
13907   const char *p = args;
13908   int num;
13909
13910   if (p == 0)
13911     error_no_arg (_("a breakpoint number"));
13912
13913   num = get_number (&p);
13914   if (num == 0)
13915     error (_("bad breakpoint number: '%s'"), args);
13916   if (*p == 0)
13917     error (_("Second argument (specified ignore-count) is missing."));
13918
13919   set_ignore_count (num,
13920                     longest_to_int (value_as_long (parse_and_eval (p))),
13921                     from_tty);
13922   if (from_tty)
13923     printf_filtered ("\n");
13924 }
13925 \f
13926
13927 /* Call FUNCTION on each of the breakpoints with numbers in the range
13928    defined by BP_NUM_RANGE (an inclusive range).  */
13929
13930 static void
13931 map_breakpoint_number_range (std::pair<int, int> bp_num_range,
13932                              gdb::function_view<void (breakpoint *)> function)
13933 {
13934   if (bp_num_range.first == 0)
13935     {
13936       warning (_("bad breakpoint number at or near '%d'"),
13937                bp_num_range.first);
13938     }
13939   else
13940     {
13941       struct breakpoint *b, *tmp;
13942
13943       for (int i = bp_num_range.first; i <= bp_num_range.second; i++)
13944         {
13945           bool match = false;
13946
13947           ALL_BREAKPOINTS_SAFE (b, tmp)
13948             if (b->number == i)
13949               {
13950                 match = true;
13951                 function (b);
13952                 break;
13953               }
13954           if (!match)
13955             printf_unfiltered (_("No breakpoint number %d.\n"), i);
13956         }
13957     }
13958 }
13959
13960 /* Call FUNCTION on each of the breakpoints whose numbers are given in
13961    ARGS.  */
13962
13963 static void
13964 map_breakpoint_numbers (const char *args,
13965                         gdb::function_view<void (breakpoint *)> function)
13966 {
13967   if (args == NULL || *args == '\0')
13968     error_no_arg (_("one or more breakpoint numbers"));
13969
13970   number_or_range_parser parser (args);
13971
13972   while (!parser.finished ())
13973     {
13974       int num = parser.get_number ();
13975       map_breakpoint_number_range (std::make_pair (num, num), function);
13976     }
13977 }
13978
13979 /* Return the breakpoint location structure corresponding to the
13980    BP_NUM and LOC_NUM values.  */
13981
13982 static struct bp_location *
13983 find_location_by_number (int bp_num, int loc_num)
13984 {
13985   struct breakpoint *b;
13986
13987   ALL_BREAKPOINTS (b)
13988     if (b->number == bp_num)
13989       {
13990         break;
13991       }
13992
13993   if (!b || b->number != bp_num)
13994     error (_("Bad breakpoint number '%d'"), bp_num);
13995   
13996   if (loc_num == 0)
13997     error (_("Bad breakpoint location number '%d'"), loc_num);
13998
13999   int n = 0;
14000   for (bp_location *loc = b->loc; loc != NULL; loc = loc->next)
14001     if (++n == loc_num)
14002       return loc;
14003
14004   error (_("Bad breakpoint location number '%d'"), loc_num);
14005 }
14006
14007 /* Modes of operation for extract_bp_num.  */
14008 enum class extract_bp_kind
14009 {
14010   /* Extracting a breakpoint number.  */
14011   bp,
14012
14013   /* Extracting a location number.  */
14014   loc,
14015 };
14016
14017 /* Extract a breakpoint or location number (as determined by KIND)
14018    from the string starting at START.  TRAILER is a character which
14019    can be found after the number.  If you don't want a trailer, use
14020    '\0'.  If END_OUT is not NULL, it is set to point after the parsed
14021    string.  This always returns a positive integer.  */
14022
14023 static int
14024 extract_bp_num (extract_bp_kind kind, const char *start,
14025                 int trailer, const char **end_out = NULL)
14026 {
14027   const char *end = start;
14028   int num = get_number_trailer (&end, trailer);
14029   if (num < 0)
14030     error (kind == extract_bp_kind::bp
14031            ? _("Negative breakpoint number '%.*s'")
14032            : _("Negative breakpoint location number '%.*s'"),
14033            int (end - start), start);
14034   if (num == 0)
14035     error (kind == extract_bp_kind::bp
14036            ? _("Bad breakpoint number '%.*s'")
14037            : _("Bad breakpoint location number '%.*s'"),
14038            int (end - start), start);
14039
14040   if (end_out != NULL)
14041     *end_out = end;
14042   return num;
14043 }
14044
14045 /* Extract a breakpoint or location range (as determined by KIND) in
14046    the form NUM1-NUM2 stored at &ARG[arg_offset].  Returns a std::pair
14047    representing the (inclusive) range.  The returned pair's elements
14048    are always positive integers.  */
14049
14050 static std::pair<int, int>
14051 extract_bp_or_bp_range (extract_bp_kind kind,
14052                         const std::string &arg,
14053                         std::string::size_type arg_offset)
14054 {
14055   std::pair<int, int> range;
14056   const char *bp_loc = &arg[arg_offset];
14057   std::string::size_type dash = arg.find ('-', arg_offset);
14058   if (dash != std::string::npos)
14059     {
14060       /* bp_loc is a range (x-z).  */
14061       if (arg.length () == dash + 1)
14062         error (kind == extract_bp_kind::bp
14063                ? _("Bad breakpoint number at or near: '%s'")
14064                : _("Bad breakpoint location number at or near: '%s'"),
14065                bp_loc);
14066
14067       const char *end;
14068       const char *start_first = bp_loc;
14069       const char *start_second = &arg[dash + 1];
14070       range.first = extract_bp_num (kind, start_first, '-');
14071       range.second = extract_bp_num (kind, start_second, '\0', &end);
14072
14073       if (range.first > range.second)
14074         error (kind == extract_bp_kind::bp
14075                ? _("Inverted breakpoint range at '%.*s'")
14076                : _("Inverted breakpoint location range at '%.*s'"),
14077                int (end - start_first), start_first);
14078     }
14079   else
14080     {
14081       /* bp_loc is a single value.  */
14082       range.first = extract_bp_num (kind, bp_loc, '\0');
14083       range.second = range.first;
14084     }
14085   return range;
14086 }
14087
14088 /* Extract the breakpoint/location range specified by ARG.  Returns
14089    the breakpoint range in BP_NUM_RANGE, and the location range in
14090    BP_LOC_RANGE.
14091
14092    ARG may be in any of the following forms:
14093
14094    x     where 'x' is a breakpoint number.
14095    x-y   where 'x' and 'y' specify a breakpoint numbers range.
14096    x.y   where 'x' is a breakpoint number and 'y' a location number.
14097    x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14098          location number range.
14099 */
14100
14101 static void
14102 extract_bp_number_and_location (const std::string &arg,
14103                                 std::pair<int, int> &bp_num_range,
14104                                 std::pair<int, int> &bp_loc_range)
14105 {
14106   std::string::size_type dot = arg.find ('.');
14107
14108   if (dot != std::string::npos)
14109     {
14110       /* Handle 'x.y' and 'x.y-z' cases.  */
14111
14112       if (arg.length () == dot + 1 || dot == 0)
14113         error (_("Bad breakpoint number at or near: '%s'"), arg.c_str ());
14114
14115       bp_num_range.first
14116         = extract_bp_num (extract_bp_kind::bp, arg.c_str (), '.');
14117       bp_num_range.second = bp_num_range.first;
14118
14119       bp_loc_range = extract_bp_or_bp_range (extract_bp_kind::loc,
14120                                              arg, dot + 1);
14121     }
14122   else
14123     {
14124       /* Handle x and x-y cases.  */
14125
14126       bp_num_range = extract_bp_or_bp_range (extract_bp_kind::bp, arg, 0);
14127       bp_loc_range.first = 0;
14128       bp_loc_range.second = 0;
14129     }
14130 }
14131
14132 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM.  ENABLE
14133    specifies whether to enable or disable.  */
14134
14135 static void
14136 enable_disable_bp_num_loc (int bp_num, int loc_num, bool enable)
14137 {
14138   struct bp_location *loc = find_location_by_number (bp_num, loc_num);
14139   if (loc != NULL)
14140     {
14141       if (loc->enabled != enable)
14142         {
14143           loc->enabled = enable;
14144           mark_breakpoint_location_modified (loc);
14145         }
14146       if (target_supports_enable_disable_tracepoint ()
14147           && current_trace_status ()->running && loc->owner
14148           && is_tracepoint (loc->owner))
14149         target_disable_tracepoint (loc);
14150     }
14151   update_global_location_list (UGLL_DONT_INSERT);
14152
14153   gdb::observers::breakpoint_modified.notify (loc->owner);
14154 }
14155
14156 /* Enable or disable a range of breakpoint locations.  BP_NUM is the
14157    number of the breakpoint, and BP_LOC_RANGE specifies the
14158    (inclusive) range of location numbers of that breakpoint to
14159    enable/disable.  ENABLE specifies whether to enable or disable the
14160    location.  */
14161
14162 static void
14163 enable_disable_breakpoint_location_range (int bp_num,
14164                                           std::pair<int, int> &bp_loc_range,
14165                                           bool enable)
14166 {
14167   for (int i = bp_loc_range.first; i <= bp_loc_range.second; i++)
14168     enable_disable_bp_num_loc (bp_num, i, enable);
14169 }
14170
14171 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14172    If from_tty is nonzero, it prints a message to that effect,
14173    which ends with a period (no newline).  */
14174
14175 void
14176 disable_breakpoint (struct breakpoint *bpt)
14177 {
14178   /* Never disable a watchpoint scope breakpoint; we want to
14179      hit them when we leave scope so we can delete both the
14180      watchpoint and its scope breakpoint at that time.  */
14181   if (bpt->type == bp_watchpoint_scope)
14182     return;
14183
14184   bpt->enable_state = bp_disabled;
14185
14186   /* Mark breakpoint locations modified.  */
14187   mark_breakpoint_modified (bpt);
14188
14189   if (target_supports_enable_disable_tracepoint ()
14190       && current_trace_status ()->running && is_tracepoint (bpt))
14191     {
14192       struct bp_location *location;
14193      
14194       for (location = bpt->loc; location; location = location->next)
14195         target_disable_tracepoint (location);
14196     }
14197
14198   update_global_location_list (UGLL_DONT_INSERT);
14199
14200   gdb::observers::breakpoint_modified.notify (bpt);
14201 }
14202
14203 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14204    specified in ARGS.  ARGS may be in any of the formats handled by
14205    extract_bp_number_and_location.  ENABLE specifies whether to enable
14206    or disable the breakpoints/locations.  */
14207
14208 static void
14209 enable_disable_command (const char *args, int from_tty, bool enable)
14210 {
14211   if (args == 0)
14212     {
14213       struct breakpoint *bpt;
14214
14215       ALL_BREAKPOINTS (bpt)
14216         if (user_breakpoint_p (bpt))
14217           {
14218             if (enable)
14219               enable_breakpoint (bpt);
14220             else
14221               disable_breakpoint (bpt);
14222           }
14223     }
14224   else
14225     {
14226       std::string num = extract_arg (&args);
14227
14228       while (!num.empty ())
14229         {
14230           std::pair<int, int> bp_num_range, bp_loc_range;
14231
14232           extract_bp_number_and_location (num, bp_num_range, bp_loc_range);
14233
14234           if (bp_loc_range.first == bp_loc_range.second
14235               && bp_loc_range.first == 0)
14236             {
14237               /* Handle breakpoint ids with formats 'x' or 'x-z'.  */
14238               map_breakpoint_number_range (bp_num_range,
14239                                            enable
14240                                            ? enable_breakpoint
14241                                            : disable_breakpoint);
14242             }
14243           else
14244             {
14245               /* Handle breakpoint ids with formats 'x.y' or
14246                  'x.y-z'.  */
14247               enable_disable_breakpoint_location_range
14248                 (bp_num_range.first, bp_loc_range, enable);
14249             }
14250           num = extract_arg (&args);
14251         }
14252     }
14253 }
14254
14255 /* The disable command disables the specified breakpoints/locations
14256    (or all defined breakpoints) so they're no longer effective in
14257    stopping the inferior.  ARGS may be in any of the forms defined in
14258    extract_bp_number_and_location.  */
14259
14260 static void
14261 disable_command (const char *args, int from_tty)
14262 {
14263   enable_disable_command (args, from_tty, false);
14264 }
14265
14266 static void
14267 enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14268                         int count)
14269 {
14270   int target_resources_ok;
14271
14272   if (bpt->type == bp_hardware_breakpoint)
14273     {
14274       int i;
14275       i = hw_breakpoint_used_count ();
14276       target_resources_ok = 
14277         target_can_use_hardware_watchpoint (bp_hardware_breakpoint, 
14278                                             i + 1, 0);
14279       if (target_resources_ok == 0)
14280         error (_("No hardware breakpoint support in the target."));
14281       else if (target_resources_ok < 0)
14282         error (_("Hardware breakpoints used exceeds limit."));
14283     }
14284
14285   if (is_watchpoint (bpt))
14286     {
14287       /* Initialize it just to avoid a GCC false warning.  */
14288       enum enable_state orig_enable_state = bp_disabled;
14289
14290       TRY
14291         {
14292           struct watchpoint *w = (struct watchpoint *) bpt;
14293
14294           orig_enable_state = bpt->enable_state;
14295           bpt->enable_state = bp_enabled;
14296           update_watchpoint (w, 1 /* reparse */);
14297         }
14298       CATCH (e, RETURN_MASK_ALL)
14299         {
14300           bpt->enable_state = orig_enable_state;
14301           exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14302                              bpt->number);
14303           return;
14304         }
14305       END_CATCH
14306     }
14307
14308   bpt->enable_state = bp_enabled;
14309
14310   /* Mark breakpoint locations modified.  */
14311   mark_breakpoint_modified (bpt);
14312
14313   if (target_supports_enable_disable_tracepoint ()
14314       && current_trace_status ()->running && is_tracepoint (bpt))
14315     {
14316       struct bp_location *location;
14317
14318       for (location = bpt->loc; location; location = location->next)
14319         target_enable_tracepoint (location);
14320     }
14321
14322   bpt->disposition = disposition;
14323   bpt->enable_count = count;
14324   update_global_location_list (UGLL_MAY_INSERT);
14325
14326   gdb::observers::breakpoint_modified.notify (bpt);
14327 }
14328
14329
14330 void
14331 enable_breakpoint (struct breakpoint *bpt)
14332 {
14333   enable_breakpoint_disp (bpt, bpt->disposition, 0);
14334 }
14335
14336 /* The enable command enables the specified breakpoints/locations (or
14337    all defined breakpoints) so they once again become (or continue to
14338    be) effective in stopping the inferior.  ARGS may be in any of the
14339    forms defined in extract_bp_number_and_location.  */
14340
14341 static void
14342 enable_command (const char *args, int from_tty)
14343 {
14344   enable_disable_command (args, from_tty, true);
14345 }
14346
14347 static void
14348 enable_once_command (const char *args, int from_tty)
14349 {
14350   map_breakpoint_numbers
14351     (args, [&] (breakpoint *b)
14352      {
14353        iterate_over_related_breakpoints
14354          (b, [&] (breakpoint *bpt)
14355           {
14356             enable_breakpoint_disp (bpt, disp_disable, 1);
14357           });
14358      });
14359 }
14360
14361 static void
14362 enable_count_command (const char *args, int from_tty)
14363 {
14364   int count;
14365
14366   if (args == NULL)
14367     error_no_arg (_("hit count"));
14368
14369   count = get_number (&args);
14370
14371   map_breakpoint_numbers
14372     (args, [&] (breakpoint *b)
14373      {
14374        iterate_over_related_breakpoints
14375          (b, [&] (breakpoint *bpt)
14376           {
14377             enable_breakpoint_disp (bpt, disp_disable, count);
14378           });
14379      });
14380 }
14381
14382 static void
14383 enable_delete_command (const char *args, int from_tty)
14384 {
14385   map_breakpoint_numbers
14386     (args, [&] (breakpoint *b)
14387      {
14388        iterate_over_related_breakpoints
14389          (b, [&] (breakpoint *bpt)
14390           {
14391             enable_breakpoint_disp (bpt, disp_del, 1);
14392           });
14393      });
14394 }
14395 \f
14396 static void
14397 set_breakpoint_cmd (const char *args, int from_tty)
14398 {
14399 }
14400
14401 static void
14402 show_breakpoint_cmd (const char *args, int from_tty)
14403 {
14404 }
14405
14406 /* Invalidate last known value of any hardware watchpoint if
14407    the memory which that value represents has been written to by
14408    GDB itself.  */
14409
14410 static void
14411 invalidate_bp_value_on_memory_change (struct inferior *inferior,
14412                                       CORE_ADDR addr, ssize_t len,
14413                                       const bfd_byte *data)
14414 {
14415   struct breakpoint *bp;
14416
14417   ALL_BREAKPOINTS (bp)
14418     if (bp->enable_state == bp_enabled
14419         && bp->type == bp_hardware_watchpoint)
14420       {
14421         struct watchpoint *wp = (struct watchpoint *) bp;
14422
14423         if (wp->val_valid && wp->val != nullptr)
14424           {
14425             struct bp_location *loc;
14426
14427             for (loc = bp->loc; loc != NULL; loc = loc->next)
14428               if (loc->loc_type == bp_loc_hardware_watchpoint
14429                   && loc->address + loc->length > addr
14430                   && addr + len > loc->address)
14431                 {
14432                   wp->val = NULL;
14433                   wp->val_valid = 0;
14434                 }
14435           }
14436       }
14437 }
14438
14439 /* Create and insert a breakpoint for software single step.  */
14440
14441 void
14442 insert_single_step_breakpoint (struct gdbarch *gdbarch,
14443                                const address_space *aspace,
14444                                CORE_ADDR next_pc)
14445 {
14446   struct thread_info *tp = inferior_thread ();
14447   struct symtab_and_line sal;
14448   CORE_ADDR pc = next_pc;
14449
14450   if (tp->control.single_step_breakpoints == NULL)
14451     {
14452       tp->control.single_step_breakpoints
14453         = new_single_step_breakpoint (tp->global_num, gdbarch);
14454     }
14455
14456   sal = find_pc_line (pc, 0);
14457   sal.pc = pc;
14458   sal.section = find_pc_overlay (pc);
14459   sal.explicit_pc = 1;
14460   add_location_to_breakpoint (tp->control.single_step_breakpoints, &sal);
14461
14462   update_global_location_list (UGLL_INSERT);
14463 }
14464
14465 /* Insert single step breakpoints according to the current state.  */
14466
14467 int
14468 insert_single_step_breakpoints (struct gdbarch *gdbarch)
14469 {
14470   struct regcache *regcache = get_current_regcache ();
14471   std::vector<CORE_ADDR> next_pcs;
14472
14473   next_pcs = gdbarch_software_single_step (gdbarch, regcache);
14474
14475   if (!next_pcs.empty ())
14476     {
14477       struct frame_info *frame = get_current_frame ();
14478       const address_space *aspace = get_frame_address_space (frame);
14479
14480       for (CORE_ADDR pc : next_pcs)
14481         insert_single_step_breakpoint (gdbarch, aspace, pc);
14482
14483       return 1;
14484     }
14485   else
14486     return 0;
14487 }
14488
14489 /* See breakpoint.h.  */
14490
14491 int
14492 breakpoint_has_location_inserted_here (struct breakpoint *bp,
14493                                        const address_space *aspace,
14494                                        CORE_ADDR pc)
14495 {
14496   struct bp_location *loc;
14497
14498   for (loc = bp->loc; loc != NULL; loc = loc->next)
14499     if (loc->inserted
14500         && breakpoint_location_address_match (loc, aspace, pc))
14501       return 1;
14502
14503   return 0;
14504 }
14505
14506 /* Check whether a software single-step breakpoint is inserted at
14507    PC.  */
14508
14509 int
14510 single_step_breakpoint_inserted_here_p (const address_space *aspace,
14511                                         CORE_ADDR pc)
14512 {
14513   struct breakpoint *bpt;
14514
14515   ALL_BREAKPOINTS (bpt)
14516     {
14517       if (bpt->type == bp_single_step
14518           && breakpoint_has_location_inserted_here (bpt, aspace, pc))
14519         return 1;
14520     }
14521   return 0;
14522 }
14523
14524 /* Tracepoint-specific operations.  */
14525
14526 /* Set tracepoint count to NUM.  */
14527 static void
14528 set_tracepoint_count (int num)
14529 {
14530   tracepoint_count = num;
14531   set_internalvar_integer (lookup_internalvar ("tpnum"), num);
14532 }
14533
14534 static void
14535 trace_command (const char *arg, int from_tty)
14536 {
14537   struct breakpoint_ops *ops;
14538
14539   event_location_up location = string_to_event_location (&arg,
14540                                                          current_language);
14541   if (location != NULL
14542       && event_location_type (location.get ()) == PROBE_LOCATION)
14543     ops = &tracepoint_probe_breakpoint_ops;
14544   else
14545     ops = &tracepoint_breakpoint_ops;
14546
14547   create_breakpoint (get_current_arch (),
14548                      location.get (),
14549                      NULL, 0, arg, 1 /* parse arg */,
14550                      0 /* tempflag */,
14551                      bp_tracepoint /* type_wanted */,
14552                      0 /* Ignore count */,
14553                      pending_break_support,
14554                      ops,
14555                      from_tty,
14556                      1 /* enabled */,
14557                      0 /* internal */, 0);
14558 }
14559
14560 static void
14561 ftrace_command (const char *arg, int from_tty)
14562 {
14563   event_location_up location = string_to_event_location (&arg,
14564                                                          current_language);
14565   create_breakpoint (get_current_arch (),
14566                      location.get (),
14567                      NULL, 0, arg, 1 /* parse arg */,
14568                      0 /* tempflag */,
14569                      bp_fast_tracepoint /* type_wanted */,
14570                      0 /* Ignore count */,
14571                      pending_break_support,
14572                      &tracepoint_breakpoint_ops,
14573                      from_tty,
14574                      1 /* enabled */,
14575                      0 /* internal */, 0);
14576 }
14577
14578 /* strace command implementation.  Creates a static tracepoint.  */
14579
14580 static void
14581 strace_command (const char *arg, int from_tty)
14582 {
14583   struct breakpoint_ops *ops;
14584   event_location_up location;
14585
14586   /* Decide if we are dealing with a static tracepoint marker (`-m'),
14587      or with a normal static tracepoint.  */
14588   if (arg && startswith (arg, "-m") && isspace (arg[2]))
14589     {
14590       ops = &strace_marker_breakpoint_ops;
14591       location = new_linespec_location (&arg, symbol_name_match_type::FULL);
14592     }
14593   else
14594     {
14595       ops = &tracepoint_breakpoint_ops;
14596       location = string_to_event_location (&arg, current_language);
14597     }
14598
14599   create_breakpoint (get_current_arch (),
14600                      location.get (),
14601                      NULL, 0, arg, 1 /* parse arg */,
14602                      0 /* tempflag */,
14603                      bp_static_tracepoint /* type_wanted */,
14604                      0 /* Ignore count */,
14605                      pending_break_support,
14606                      ops,
14607                      from_tty,
14608                      1 /* enabled */,
14609                      0 /* internal */, 0);
14610 }
14611
14612 /* Set up a fake reader function that gets command lines from a linked
14613    list that was acquired during tracepoint uploading.  */
14614
14615 static struct uploaded_tp *this_utp;
14616 static int next_cmd;
14617
14618 static char *
14619 read_uploaded_action (void)
14620 {
14621   char *rslt = nullptr;
14622
14623   if (next_cmd < this_utp->cmd_strings.size ())
14624     {
14625       rslt = this_utp->cmd_strings[next_cmd].get ();
14626       next_cmd++;
14627     }
14628
14629   return rslt;
14630 }
14631
14632 /* Given information about a tracepoint as recorded on a target (which
14633    can be either a live system or a trace file), attempt to create an
14634    equivalent GDB tracepoint.  This is not a reliable process, since
14635    the target does not necessarily have all the information used when
14636    the tracepoint was originally defined.  */
14637   
14638 struct tracepoint *
14639 create_tracepoint_from_upload (struct uploaded_tp *utp)
14640 {
14641   const char *addr_str;
14642   char small_buf[100];
14643   struct tracepoint *tp;
14644
14645   if (utp->at_string)
14646     addr_str = utp->at_string.get ();
14647   else
14648     {
14649       /* In the absence of a source location, fall back to raw
14650          address.  Since there is no way to confirm that the address
14651          means the same thing as when the trace was started, warn the
14652          user.  */
14653       warning (_("Uploaded tracepoint %d has no "
14654                  "source location, using raw address"),
14655                utp->number);
14656       xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (utp->addr));
14657       addr_str = small_buf;
14658     }
14659
14660   /* There's not much we can do with a sequence of bytecodes.  */
14661   if (utp->cond && !utp->cond_string)
14662     warning (_("Uploaded tracepoint %d condition "
14663                "has no source form, ignoring it"),
14664              utp->number);
14665
14666   event_location_up location = string_to_event_location (&addr_str,
14667                                                          current_language);
14668   if (!create_breakpoint (get_current_arch (),
14669                           location.get (),
14670                           utp->cond_string.get (), -1, addr_str,
14671                           0 /* parse cond/thread */,
14672                           0 /* tempflag */,
14673                           utp->type /* type_wanted */,
14674                           0 /* Ignore count */,
14675                           pending_break_support,
14676                           &tracepoint_breakpoint_ops,
14677                           0 /* from_tty */,
14678                           utp->enabled /* enabled */,
14679                           0 /* internal */,
14680                           CREATE_BREAKPOINT_FLAGS_INSERTED))
14681     return NULL;
14682
14683   /* Get the tracepoint we just created.  */
14684   tp = get_tracepoint (tracepoint_count);
14685   gdb_assert (tp != NULL);
14686
14687   if (utp->pass > 0)
14688     {
14689       xsnprintf (small_buf, sizeof (small_buf), "%d %d", utp->pass,
14690                  tp->number);
14691
14692       trace_pass_command (small_buf, 0);
14693     }
14694
14695   /* If we have uploaded versions of the original commands, set up a
14696      special-purpose "reader" function and call the usual command line
14697      reader, then pass the result to the breakpoint command-setting
14698      function.  */
14699   if (!utp->cmd_strings.empty ())
14700     {
14701       counted_command_line cmd_list;
14702
14703       this_utp = utp;
14704       next_cmd = 0;
14705
14706       cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL);
14707
14708       breakpoint_set_commands (tp, std::move (cmd_list));
14709     }
14710   else if (!utp->actions.empty ()
14711            || !utp->step_actions.empty ())
14712     warning (_("Uploaded tracepoint %d actions "
14713                "have no source form, ignoring them"),
14714              utp->number);
14715
14716   /* Copy any status information that might be available.  */
14717   tp->hit_count = utp->hit_count;
14718   tp->traceframe_usage = utp->traceframe_usage;
14719
14720   return tp;
14721 }
14722   
14723 /* Print information on tracepoint number TPNUM_EXP, or all if
14724    omitted.  */
14725
14726 static void
14727 info_tracepoints_command (const char *args, int from_tty)
14728 {
14729   struct ui_out *uiout = current_uiout;
14730   int num_printed;
14731
14732   num_printed = breakpoint_1 (args, 0, is_tracepoint);
14733
14734   if (num_printed == 0)
14735     {
14736       if (args == NULL || *args == '\0')
14737         uiout->message ("No tracepoints.\n");
14738       else
14739         uiout->message ("No tracepoint matching '%s'.\n", args);
14740     }
14741
14742   default_collect_info ();
14743 }
14744
14745 /* The 'enable trace' command enables tracepoints.
14746    Not supported by all targets.  */
14747 static void
14748 enable_trace_command (const char *args, int from_tty)
14749 {
14750   enable_command (args, from_tty);
14751 }
14752
14753 /* The 'disable trace' command disables tracepoints.
14754    Not supported by all targets.  */
14755 static void
14756 disable_trace_command (const char *args, int from_tty)
14757 {
14758   disable_command (args, from_tty);
14759 }
14760
14761 /* Remove a tracepoint (or all if no argument).  */
14762 static void
14763 delete_trace_command (const char *arg, int from_tty)
14764 {
14765   struct breakpoint *b, *b_tmp;
14766
14767   dont_repeat ();
14768
14769   if (arg == 0)
14770     {
14771       int breaks_to_delete = 0;
14772
14773       /* Delete all breakpoints if no argument.
14774          Do not delete internal or call-dummy breakpoints, these
14775          have to be deleted with an explicit breakpoint number 
14776          argument.  */
14777       ALL_TRACEPOINTS (b)
14778         if (is_tracepoint (b) && user_breakpoint_p (b))
14779           {
14780             breaks_to_delete = 1;
14781             break;
14782           }
14783
14784       /* Ask user only if there are some breakpoints to delete.  */
14785       if (!from_tty
14786           || (breaks_to_delete && query (_("Delete all tracepoints? "))))
14787         {
14788           ALL_BREAKPOINTS_SAFE (b, b_tmp)
14789             if (is_tracepoint (b) && user_breakpoint_p (b))
14790               delete_breakpoint (b);
14791         }
14792     }
14793   else
14794     map_breakpoint_numbers
14795       (arg, [&] (breakpoint *br)
14796        {
14797          iterate_over_related_breakpoints (br, delete_breakpoint);
14798        });
14799 }
14800
14801 /* Helper function for trace_pass_command.  */
14802
14803 static void
14804 trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
14805 {
14806   tp->pass_count = count;
14807   gdb::observers::breakpoint_modified.notify (tp);
14808   if (from_tty)
14809     printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14810                      tp->number, count);
14811 }
14812
14813 /* Set passcount for tracepoint.
14814
14815    First command argument is passcount, second is tracepoint number.
14816    If tracepoint number omitted, apply to most recently defined.
14817    Also accepts special argument "all".  */
14818
14819 static void
14820 trace_pass_command (const char *args, int from_tty)
14821 {
14822   struct tracepoint *t1;
14823   ULONGEST count;
14824
14825   if (args == 0 || *args == 0)
14826     error (_("passcount command requires an "
14827              "argument (count + optional TP num)"));
14828
14829   count = strtoulst (args, &args, 10);  /* Count comes first, then TP num.  */
14830
14831   args = skip_spaces (args);
14832   if (*args && strncasecmp (args, "all", 3) == 0)
14833     {
14834       struct breakpoint *b;
14835
14836       args += 3;                        /* Skip special argument "all".  */
14837       if (*args)
14838         error (_("Junk at end of arguments."));
14839
14840       ALL_TRACEPOINTS (b)
14841       {
14842         t1 = (struct tracepoint *) b;
14843         trace_pass_set_count (t1, count, from_tty);
14844       }
14845     }
14846   else if (*args == '\0')
14847     {
14848       t1 = get_tracepoint_by_number (&args, NULL);
14849       if (t1)
14850         trace_pass_set_count (t1, count, from_tty);
14851     }
14852   else
14853     {
14854       number_or_range_parser parser (args);
14855       while (!parser.finished ())
14856         {
14857           t1 = get_tracepoint_by_number (&args, &parser);
14858           if (t1)
14859             trace_pass_set_count (t1, count, from_tty);
14860         }
14861     }
14862 }
14863
14864 struct tracepoint *
14865 get_tracepoint (int num)
14866 {
14867   struct breakpoint *t;
14868
14869   ALL_TRACEPOINTS (t)
14870     if (t->number == num)
14871       return (struct tracepoint *) t;
14872
14873   return NULL;
14874 }
14875
14876 /* Find the tracepoint with the given target-side number (which may be
14877    different from the tracepoint number after disconnecting and
14878    reconnecting).  */
14879
14880 struct tracepoint *
14881 get_tracepoint_by_number_on_target (int num)
14882 {
14883   struct breakpoint *b;
14884
14885   ALL_TRACEPOINTS (b)
14886     {
14887       struct tracepoint *t = (struct tracepoint *) b;
14888
14889       if (t->number_on_target == num)
14890         return t;
14891     }
14892
14893   return NULL;
14894 }
14895
14896 /* Utility: parse a tracepoint number and look it up in the list.
14897    If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
14898    If the argument is missing, the most recent tracepoint
14899    (tracepoint_count) is returned.  */
14900
14901 struct tracepoint *
14902 get_tracepoint_by_number (const char **arg,
14903                           number_or_range_parser *parser)
14904 {
14905   struct breakpoint *t;
14906   int tpnum;
14907   const char *instring = arg == NULL ? NULL : *arg;
14908
14909   if (parser != NULL)
14910     {
14911       gdb_assert (!parser->finished ());
14912       tpnum = parser->get_number ();
14913     }
14914   else if (arg == NULL || *arg == NULL || ! **arg)
14915     tpnum = tracepoint_count;
14916   else
14917     tpnum = get_number (arg);
14918
14919   if (tpnum <= 0)
14920     {
14921       if (instring && *instring)
14922         printf_filtered (_("bad tracepoint number at or near '%s'\n"), 
14923                          instring);
14924       else
14925         printf_filtered (_("No previous tracepoint\n"));
14926       return NULL;
14927     }
14928
14929   ALL_TRACEPOINTS (t)
14930     if (t->number == tpnum)
14931     {
14932       return (struct tracepoint *) t;
14933     }
14934
14935   printf_unfiltered ("No tracepoint number %d.\n", tpnum);
14936   return NULL;
14937 }
14938
14939 void
14940 print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
14941 {
14942   if (b->thread != -1)
14943     fprintf_unfiltered (fp, " thread %d", b->thread);
14944
14945   if (b->task != 0)
14946     fprintf_unfiltered (fp, " task %d", b->task);
14947
14948   fprintf_unfiltered (fp, "\n");
14949 }
14950
14951 /* Save information on user settable breakpoints (watchpoints, etc) to
14952    a new script file named FILENAME.  If FILTER is non-NULL, call it
14953    on each breakpoint and only include the ones for which it returns
14954    non-zero.  */
14955
14956 static void
14957 save_breakpoints (const char *filename, int from_tty,
14958                   int (*filter) (const struct breakpoint *))
14959 {
14960   struct breakpoint *tp;
14961   int any = 0;
14962   int extra_trace_bits = 0;
14963
14964   if (filename == 0 || *filename == 0)
14965     error (_("Argument required (file name in which to save)"));
14966
14967   /* See if we have anything to save.  */
14968   ALL_BREAKPOINTS (tp)
14969   {
14970     /* Skip internal and momentary breakpoints.  */
14971     if (!user_breakpoint_p (tp))
14972       continue;
14973
14974     /* If we have a filter, only save the breakpoints it accepts.  */
14975     if (filter && !filter (tp))
14976       continue;
14977
14978     any = 1;
14979
14980     if (is_tracepoint (tp))
14981       {
14982         extra_trace_bits = 1;
14983
14984         /* We can stop searching.  */
14985         break;
14986       }
14987   }
14988
14989   if (!any)
14990     {
14991       warning (_("Nothing to save."));
14992       return;
14993     }
14994
14995   gdb::unique_xmalloc_ptr<char> expanded_filename (tilde_expand (filename));
14996
14997   stdio_file fp;
14998
14999   if (!fp.open (expanded_filename.get (), "w"))
15000     error (_("Unable to open file '%s' for saving (%s)"),
15001            expanded_filename.get (), safe_strerror (errno));
15002
15003   if (extra_trace_bits)
15004     save_trace_state_variables (&fp);
15005
15006   ALL_BREAKPOINTS (tp)
15007   {
15008     /* Skip internal and momentary breakpoints.  */
15009     if (!user_breakpoint_p (tp))
15010       continue;
15011
15012     /* If we have a filter, only save the breakpoints it accepts.  */
15013     if (filter && !filter (tp))
15014       continue;
15015
15016     tp->ops->print_recreate (tp, &fp);
15017
15018     /* Note, we can't rely on tp->number for anything, as we can't
15019        assume the recreated breakpoint numbers will match.  Use $bpnum
15020        instead.  */
15021
15022     if (tp->cond_string)
15023       fp.printf ("  condition $bpnum %s\n", tp->cond_string);
15024
15025     if (tp->ignore_count)
15026       fp.printf ("  ignore $bpnum %d\n", tp->ignore_count);
15027
15028     if (tp->type != bp_dprintf && tp->commands)
15029       {
15030         fp.puts ("  commands\n");
15031         
15032         current_uiout->redirect (&fp);
15033         TRY
15034           {
15035             print_command_lines (current_uiout, tp->commands.get (), 2);
15036           }
15037         CATCH (ex, RETURN_MASK_ALL)
15038           {
15039           current_uiout->redirect (NULL);
15040             throw_exception (ex);
15041           }
15042         END_CATCH
15043
15044         current_uiout->redirect (NULL);
15045         fp.puts ("  end\n");
15046       }
15047
15048     if (tp->enable_state == bp_disabled)
15049       fp.puts ("disable $bpnum\n");
15050
15051     /* If this is a multi-location breakpoint, check if the locations
15052        should be individually disabled.  Watchpoint locations are
15053        special, and not user visible.  */
15054     if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15055       {
15056         struct bp_location *loc;
15057         int n = 1;
15058
15059         for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15060           if (!loc->enabled)
15061             fp.printf ("disable $bpnum.%d\n", n);
15062       }
15063   }
15064
15065   if (extra_trace_bits && *default_collect)
15066     fp.printf ("set default-collect %s\n", default_collect);
15067
15068   if (from_tty)
15069     printf_filtered (_("Saved to file '%s'.\n"), expanded_filename.get ());
15070 }
15071
15072 /* The `save breakpoints' command.  */
15073
15074 static void
15075 save_breakpoints_command (const char *args, int from_tty)
15076 {
15077   save_breakpoints (args, from_tty, NULL);
15078 }
15079
15080 /* The `save tracepoints' command.  */
15081
15082 static void
15083 save_tracepoints_command (const char *args, int from_tty)
15084 {
15085   save_breakpoints (args, from_tty, is_tracepoint);
15086 }
15087
15088 /* Create a vector of all tracepoints.  */
15089
15090 std::vector<breakpoint *>
15091 all_tracepoints (void)
15092 {
15093   std::vector<breakpoint *> tp_vec;
15094   struct breakpoint *tp;
15095
15096   ALL_TRACEPOINTS (tp)
15097   {
15098     tp_vec.push_back (tp);
15099   }
15100
15101   return tp_vec;
15102 }
15103
15104 \f
15105 /* This help string is used to consolidate all the help string for specifying
15106    locations used by several commands.  */
15107
15108 #define LOCATION_HELP_STRING \
15109 "Linespecs are colon-separated lists of location parameters, such as\n\
15110 source filename, function name, label name, and line number.\n\
15111 Example: To specify the start of a label named \"the_top\" in the\n\
15112 function \"fact\" in the file \"factorial.c\", use\n\
15113 \"factorial.c:fact:the_top\".\n\
15114 \n\
15115 Address locations begin with \"*\" and specify an exact address in the\n\
15116 program.  Example: To specify the fourth byte past the start function\n\
15117 \"main\", use \"*main + 4\".\n\
15118 \n\
15119 Explicit locations are similar to linespecs but use an option/argument\n\
15120 syntax to specify location parameters.\n\
15121 Example: To specify the start of the label named \"the_top\" in the\n\
15122 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15123 -function fact -label the_top\".\n\
15124 \n\
15125 By default, a specified function is matched against the program's\n\
15126 functions in all scopes.  For C++, this means in all namespaces and\n\
15127 classes.  For Ada, this means in all packages.  E.g., in C++,\n\
15128 \"func()\" matches \"A::func()\", \"A::B::func()\", etc.  The\n\
15129 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15130 specified name as a complete fully-qualified name instead.\n"
15131
15132 /* This help string is used for the break, hbreak, tbreak and thbreak
15133    commands.  It is defined as a macro to prevent duplication.
15134    COMMAND should be a string constant containing the name of the
15135    command.  */
15136
15137 #define BREAK_ARGS_HELP(command) \
15138 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15139 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15140 probe point.  Accepted values are `-probe' (for a generic, automatically\n\
15141 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15142 `-probe-dtrace' (for a DTrace probe).\n\
15143 LOCATION may be a linespec, address, or explicit location as described\n\
15144 below.\n\
15145 \n\
15146 With no LOCATION, uses current execution address of the selected\n\
15147 stack frame.  This is useful for breaking on return to a stack frame.\n\
15148 \n\
15149 THREADNUM is the number from \"info threads\".\n\
15150 CONDITION is a boolean expression.\n\
15151 \n" LOCATION_HELP_STRING "\n\
15152 Multiple breakpoints at one place are permitted, and useful if their\n\
15153 conditions are different.\n\
15154 \n\
15155 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15156
15157 /* List of subcommands for "catch".  */
15158 static struct cmd_list_element *catch_cmdlist;
15159
15160 /* List of subcommands for "tcatch".  */
15161 static struct cmd_list_element *tcatch_cmdlist;
15162
15163 void
15164 add_catch_command (const char *name, const char *docstring,
15165                    cmd_const_sfunc_ftype *sfunc,
15166                    completer_ftype *completer,
15167                    void *user_data_catch,
15168                    void *user_data_tcatch)
15169 {
15170   struct cmd_list_element *command;
15171
15172   command = add_cmd (name, class_breakpoint, docstring,
15173                      &catch_cmdlist);
15174   set_cmd_sfunc (command, sfunc);
15175   set_cmd_context (command, user_data_catch);
15176   set_cmd_completer (command, completer);
15177
15178   command = add_cmd (name, class_breakpoint, docstring,
15179                      &tcatch_cmdlist);
15180   set_cmd_sfunc (command, sfunc);
15181   set_cmd_context (command, user_data_tcatch);
15182   set_cmd_completer (command, completer);
15183 }
15184
15185 static void
15186 save_command (const char *arg, int from_tty)
15187 {
15188   printf_unfiltered (_("\"save\" must be followed by "
15189                        "the name of a save subcommand.\n"));
15190   help_list (save_cmdlist, "save ", all_commands, gdb_stdout);
15191 }
15192
15193 struct breakpoint *
15194 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15195                           void *data)
15196 {
15197   struct breakpoint *b, *b_tmp;
15198
15199   ALL_BREAKPOINTS_SAFE (b, b_tmp)
15200     {
15201       if ((*callback) (b, data))
15202         return b;
15203     }
15204
15205   return NULL;
15206 }
15207
15208 /* Zero if any of the breakpoint's locations could be a location where
15209    functions have been inlined, nonzero otherwise.  */
15210
15211 static int
15212 is_non_inline_function (struct breakpoint *b)
15213 {
15214   /* The shared library event breakpoint is set on the address of a
15215      non-inline function.  */
15216   if (b->type == bp_shlib_event)
15217     return 1;
15218
15219   return 0;
15220 }
15221
15222 /* Nonzero if the specified PC cannot be a location where functions
15223    have been inlined.  */
15224
15225 int
15226 pc_at_non_inline_function (const address_space *aspace, CORE_ADDR pc,
15227                            const struct target_waitstatus *ws)
15228 {
15229   struct breakpoint *b;
15230   struct bp_location *bl;
15231
15232   ALL_BREAKPOINTS (b)
15233     {
15234       if (!is_non_inline_function (b))
15235         continue;
15236
15237       for (bl = b->loc; bl != NULL; bl = bl->next)
15238         {
15239           if (!bl->shlib_disabled
15240               && bpstat_check_location (bl, aspace, pc, ws))
15241             return 1;
15242         }
15243     }
15244
15245   return 0;
15246 }
15247
15248 /* Remove any references to OBJFILE which is going to be freed.  */
15249
15250 void
15251 breakpoint_free_objfile (struct objfile *objfile)
15252 {
15253   struct bp_location **locp, *loc;
15254
15255   ALL_BP_LOCATIONS (loc, locp)
15256     if (loc->symtab != NULL && SYMTAB_OBJFILE (loc->symtab) == objfile)
15257       loc->symtab = NULL;
15258 }
15259
15260 void
15261 initialize_breakpoint_ops (void)
15262 {
15263   static int initialized = 0;
15264
15265   struct breakpoint_ops *ops;
15266
15267   if (initialized)
15268     return;
15269   initialized = 1;
15270
15271   /* The breakpoint_ops structure to be inherit by all kinds of
15272      breakpoints (real breakpoints, i.e., user "break" breakpoints,
15273      internal and momentary breakpoints, etc.).  */
15274   ops = &bkpt_base_breakpoint_ops;
15275   *ops = base_breakpoint_ops;
15276   ops->re_set = bkpt_re_set;
15277   ops->insert_location = bkpt_insert_location;
15278   ops->remove_location = bkpt_remove_location;
15279   ops->breakpoint_hit = bkpt_breakpoint_hit;
15280   ops->create_sals_from_location = bkpt_create_sals_from_location;
15281   ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
15282   ops->decode_location = bkpt_decode_location;
15283
15284   /* The breakpoint_ops structure to be used in regular breakpoints.  */
15285   ops = &bkpt_breakpoint_ops;
15286   *ops = bkpt_base_breakpoint_ops;
15287   ops->re_set = bkpt_re_set;
15288   ops->resources_needed = bkpt_resources_needed;
15289   ops->print_it = bkpt_print_it;
15290   ops->print_mention = bkpt_print_mention;
15291   ops->print_recreate = bkpt_print_recreate;
15292
15293   /* Ranged breakpoints.  */
15294   ops = &ranged_breakpoint_ops;
15295   *ops = bkpt_breakpoint_ops;
15296   ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15297   ops->resources_needed = resources_needed_ranged_breakpoint;
15298   ops->print_it = print_it_ranged_breakpoint;
15299   ops->print_one = print_one_ranged_breakpoint;
15300   ops->print_one_detail = print_one_detail_ranged_breakpoint;
15301   ops->print_mention = print_mention_ranged_breakpoint;
15302   ops->print_recreate = print_recreate_ranged_breakpoint;
15303
15304   /* Internal breakpoints.  */
15305   ops = &internal_breakpoint_ops;
15306   *ops = bkpt_base_breakpoint_ops;
15307   ops->re_set = internal_bkpt_re_set;
15308   ops->check_status = internal_bkpt_check_status;
15309   ops->print_it = internal_bkpt_print_it;
15310   ops->print_mention = internal_bkpt_print_mention;
15311
15312   /* Momentary breakpoints.  */
15313   ops = &momentary_breakpoint_ops;
15314   *ops = bkpt_base_breakpoint_ops;
15315   ops->re_set = momentary_bkpt_re_set;
15316   ops->check_status = momentary_bkpt_check_status;
15317   ops->print_it = momentary_bkpt_print_it;
15318   ops->print_mention = momentary_bkpt_print_mention;
15319
15320   /* Probe breakpoints.  */
15321   ops = &bkpt_probe_breakpoint_ops;
15322   *ops = bkpt_breakpoint_ops;
15323   ops->insert_location = bkpt_probe_insert_location;
15324   ops->remove_location = bkpt_probe_remove_location;
15325   ops->create_sals_from_location = bkpt_probe_create_sals_from_location;
15326   ops->decode_location = bkpt_probe_decode_location;
15327
15328   /* Watchpoints.  */
15329   ops = &watchpoint_breakpoint_ops;
15330   *ops = base_breakpoint_ops;
15331   ops->re_set = re_set_watchpoint;
15332   ops->insert_location = insert_watchpoint;
15333   ops->remove_location = remove_watchpoint;
15334   ops->breakpoint_hit = breakpoint_hit_watchpoint;
15335   ops->check_status = check_status_watchpoint;
15336   ops->resources_needed = resources_needed_watchpoint;
15337   ops->works_in_software_mode = works_in_software_mode_watchpoint;
15338   ops->print_it = print_it_watchpoint;
15339   ops->print_mention = print_mention_watchpoint;
15340   ops->print_recreate = print_recreate_watchpoint;
15341   ops->explains_signal = explains_signal_watchpoint;
15342
15343   /* Masked watchpoints.  */
15344   ops = &masked_watchpoint_breakpoint_ops;
15345   *ops = watchpoint_breakpoint_ops;
15346   ops->insert_location = insert_masked_watchpoint;
15347   ops->remove_location = remove_masked_watchpoint;
15348   ops->resources_needed = resources_needed_masked_watchpoint;
15349   ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15350   ops->print_it = print_it_masked_watchpoint;
15351   ops->print_one_detail = print_one_detail_masked_watchpoint;
15352   ops->print_mention = print_mention_masked_watchpoint;
15353   ops->print_recreate = print_recreate_masked_watchpoint;
15354
15355   /* Tracepoints.  */
15356   ops = &tracepoint_breakpoint_ops;
15357   *ops = base_breakpoint_ops;
15358   ops->re_set = tracepoint_re_set;
15359   ops->breakpoint_hit = tracepoint_breakpoint_hit;
15360   ops->print_one_detail = tracepoint_print_one_detail;
15361   ops->print_mention = tracepoint_print_mention;
15362   ops->print_recreate = tracepoint_print_recreate;
15363   ops->create_sals_from_location = tracepoint_create_sals_from_location;
15364   ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
15365   ops->decode_location = tracepoint_decode_location;
15366
15367   /* Probe tracepoints.  */
15368   ops = &tracepoint_probe_breakpoint_ops;
15369   *ops = tracepoint_breakpoint_ops;
15370   ops->create_sals_from_location = tracepoint_probe_create_sals_from_location;
15371   ops->decode_location = tracepoint_probe_decode_location;
15372
15373   /* Static tracepoints with marker (`-m').  */
15374   ops = &strace_marker_breakpoint_ops;
15375   *ops = tracepoint_breakpoint_ops;
15376   ops->create_sals_from_location = strace_marker_create_sals_from_location;
15377   ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
15378   ops->decode_location = strace_marker_decode_location;
15379
15380   /* Fork catchpoints.  */
15381   ops = &catch_fork_breakpoint_ops;
15382   *ops = base_breakpoint_ops;
15383   ops->insert_location = insert_catch_fork;
15384   ops->remove_location = remove_catch_fork;
15385   ops->breakpoint_hit = breakpoint_hit_catch_fork;
15386   ops->print_it = print_it_catch_fork;
15387   ops->print_one = print_one_catch_fork;
15388   ops->print_mention = print_mention_catch_fork;
15389   ops->print_recreate = print_recreate_catch_fork;
15390
15391   /* Vfork catchpoints.  */
15392   ops = &catch_vfork_breakpoint_ops;
15393   *ops = base_breakpoint_ops;
15394   ops->insert_location = insert_catch_vfork;
15395   ops->remove_location = remove_catch_vfork;
15396   ops->breakpoint_hit = breakpoint_hit_catch_vfork;
15397   ops->print_it = print_it_catch_vfork;
15398   ops->print_one = print_one_catch_vfork;
15399   ops->print_mention = print_mention_catch_vfork;
15400   ops->print_recreate = print_recreate_catch_vfork;
15401
15402   /* Exec catchpoints.  */
15403   ops = &catch_exec_breakpoint_ops;
15404   *ops = base_breakpoint_ops;
15405   ops->insert_location = insert_catch_exec;
15406   ops->remove_location = remove_catch_exec;
15407   ops->breakpoint_hit = breakpoint_hit_catch_exec;
15408   ops->print_it = print_it_catch_exec;
15409   ops->print_one = print_one_catch_exec;
15410   ops->print_mention = print_mention_catch_exec;
15411   ops->print_recreate = print_recreate_catch_exec;
15412
15413   /* Solib-related catchpoints.  */
15414   ops = &catch_solib_breakpoint_ops;
15415   *ops = base_breakpoint_ops;
15416   ops->insert_location = insert_catch_solib;
15417   ops->remove_location = remove_catch_solib;
15418   ops->breakpoint_hit = breakpoint_hit_catch_solib;
15419   ops->check_status = check_status_catch_solib;
15420   ops->print_it = print_it_catch_solib;
15421   ops->print_one = print_one_catch_solib;
15422   ops->print_mention = print_mention_catch_solib;
15423   ops->print_recreate = print_recreate_catch_solib;
15424
15425   ops = &dprintf_breakpoint_ops;
15426   *ops = bkpt_base_breakpoint_ops;
15427   ops->re_set = dprintf_re_set;
15428   ops->resources_needed = bkpt_resources_needed;
15429   ops->print_it = bkpt_print_it;
15430   ops->print_mention = bkpt_print_mention;
15431   ops->print_recreate = dprintf_print_recreate;
15432   ops->after_condition_true = dprintf_after_condition_true;
15433   ops->breakpoint_hit = dprintf_breakpoint_hit;
15434 }
15435
15436 /* Chain containing all defined "enable breakpoint" subcommands.  */
15437
15438 static struct cmd_list_element *enablebreaklist = NULL;
15439
15440 /* See breakpoint.h.  */
15441
15442 cmd_list_element *commands_cmd_element = nullptr;
15443
15444 void
15445 _initialize_breakpoint (void)
15446 {
15447   struct cmd_list_element *c;
15448
15449   initialize_breakpoint_ops ();
15450
15451   gdb::observers::solib_unloaded.attach (disable_breakpoints_in_unloaded_shlib);
15452   gdb::observers::free_objfile.attach (disable_breakpoints_in_freed_objfile);
15453   gdb::observers::memory_changed.attach (invalidate_bp_value_on_memory_change);
15454
15455   breakpoint_objfile_key
15456     = register_objfile_data_with_cleanup (NULL, free_breakpoint_objfile_data);
15457
15458   breakpoint_chain = 0;
15459   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
15460      before a breakpoint is set.  */
15461   breakpoint_count = 0;
15462
15463   tracepoint_count = 0;
15464
15465   add_com ("ignore", class_breakpoint, ignore_command, _("\
15466 Set ignore-count of breakpoint number N to COUNT.\n\
15467 Usage is `ignore N COUNT'."));
15468
15469   commands_cmd_element = add_com ("commands", class_breakpoint,
15470                                   commands_command, _("\
15471 Set commands to be executed when the given breakpoints are hit.\n\
15472 Give a space-separated breakpoint list as argument after \"commands\".\n\
15473 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15474 (e.g. `5-7').\n\
15475 With no argument, the targeted breakpoint is the last one set.\n\
15476 The commands themselves follow starting on the next line.\n\
15477 Type a line containing \"end\" to indicate the end of them.\n\
15478 Give \"silent\" as the first line to make the breakpoint silent;\n\
15479 then no output is printed when it is hit, except what the commands print."));
15480
15481   c = add_com ("condition", class_breakpoint, condition_command, _("\
15482 Specify breakpoint number N to break only if COND is true.\n\
15483 Usage is `condition N COND', where N is an integer and COND is an\n\
15484 expression to be evaluated whenever breakpoint N is reached."));
15485   set_cmd_completer (c, condition_completer);
15486
15487   c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
15488 Set a temporary breakpoint.\n\
15489 Like \"break\" except the breakpoint is only temporary,\n\
15490 so it will be deleted when hit.  Equivalent to \"break\" followed\n\
15491 by using \"enable delete\" on the breakpoint number.\n\
15492 \n"
15493 BREAK_ARGS_HELP ("tbreak")));
15494   set_cmd_completer (c, location_completer);
15495
15496   c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
15497 Set a hardware assisted breakpoint.\n\
15498 Like \"break\" except the breakpoint requires hardware support,\n\
15499 some target hardware may not have this support.\n\
15500 \n"
15501 BREAK_ARGS_HELP ("hbreak")));
15502   set_cmd_completer (c, location_completer);
15503
15504   c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
15505 Set a temporary hardware assisted breakpoint.\n\
15506 Like \"hbreak\" except the breakpoint is only temporary,\n\
15507 so it will be deleted when hit.\n\
15508 \n"
15509 BREAK_ARGS_HELP ("thbreak")));
15510   set_cmd_completer (c, location_completer);
15511
15512   add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
15513 Enable some breakpoints.\n\
15514 Give breakpoint numbers (separated by spaces) as arguments.\n\
15515 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15516 This is used to cancel the effect of the \"disable\" command.\n\
15517 With a subcommand you can enable temporarily."),
15518                   &enablelist, "enable ", 1, &cmdlist);
15519
15520   add_com_alias ("en", "enable", class_breakpoint, 1);
15521
15522   add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
15523 Enable some breakpoints.\n\
15524 Give breakpoint numbers (separated by spaces) as arguments.\n\
15525 This is used to cancel the effect of the \"disable\" command.\n\
15526 May be abbreviated to simply \"enable\".\n"),
15527                    &enablebreaklist, "enable breakpoints ", 1, &enablelist);
15528
15529   add_cmd ("once", no_class, enable_once_command, _("\
15530 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
15531 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15532            &enablebreaklist);
15533
15534   add_cmd ("delete", no_class, enable_delete_command, _("\
15535 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
15536 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15537            &enablebreaklist);
15538
15539   add_cmd ("count", no_class, enable_count_command, _("\
15540 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
15541 If a breakpoint is hit while enabled in this fashion,\n\
15542 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15543            &enablebreaklist);
15544
15545   add_cmd ("delete", no_class, enable_delete_command, _("\
15546 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
15547 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15548            &enablelist);
15549
15550   add_cmd ("once", no_class, enable_once_command, _("\
15551 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
15552 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15553            &enablelist);
15554
15555   add_cmd ("count", no_class, enable_count_command, _("\
15556 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
15557 If a breakpoint is hit while enabled in this fashion,\n\
15558 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15559            &enablelist);
15560
15561   add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
15562 Disable some breakpoints.\n\
15563 Arguments are breakpoint numbers with spaces in between.\n\
15564 To disable all breakpoints, give no argument.\n\
15565 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15566                   &disablelist, "disable ", 1, &cmdlist);
15567   add_com_alias ("dis", "disable", class_breakpoint, 1);
15568   add_com_alias ("disa", "disable", class_breakpoint, 1);
15569
15570   add_cmd ("breakpoints", class_alias, disable_command, _("\
15571 Disable some breakpoints.\n\
15572 Arguments are breakpoint numbers with spaces in between.\n\
15573 To disable all breakpoints, give no argument.\n\
15574 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15575 This command may be abbreviated \"disable\"."),
15576            &disablelist);
15577
15578   add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
15579 Delete some breakpoints or auto-display expressions.\n\
15580 Arguments are breakpoint numbers with spaces in between.\n\
15581 To delete all breakpoints, give no argument.\n\
15582 \n\
15583 Also a prefix command for deletion of other GDB objects.\n\
15584 The \"unset\" command is also an alias for \"delete\"."),
15585                   &deletelist, "delete ", 1, &cmdlist);
15586   add_com_alias ("d", "delete", class_breakpoint, 1);
15587   add_com_alias ("del", "delete", class_breakpoint, 1);
15588
15589   add_cmd ("breakpoints", class_alias, delete_command, _("\
15590 Delete some breakpoints or auto-display expressions.\n\
15591 Arguments are breakpoint numbers with spaces in between.\n\
15592 To delete all breakpoints, give no argument.\n\
15593 This command may be abbreviated \"delete\"."),
15594            &deletelist);
15595
15596   add_com ("clear", class_breakpoint, clear_command, _("\
15597 Clear breakpoint at specified location.\n\
15598 Argument may be a linespec, explicit, or address location as described below.\n\
15599 \n\
15600 With no argument, clears all breakpoints in the line that the selected frame\n\
15601 is executing in.\n"
15602 "\n" LOCATION_HELP_STRING "\n\
15603 See also the \"delete\" command which clears breakpoints by number."));
15604   add_com_alias ("cl", "clear", class_breakpoint, 1);
15605
15606   c = add_com ("break", class_breakpoint, break_command, _("\
15607 Set breakpoint at specified location.\n"
15608 BREAK_ARGS_HELP ("break")));
15609   set_cmd_completer (c, location_completer);
15610
15611   add_com_alias ("b", "break", class_run, 1);
15612   add_com_alias ("br", "break", class_run, 1);
15613   add_com_alias ("bre", "break", class_run, 1);
15614   add_com_alias ("brea", "break", class_run, 1);
15615
15616   if (dbx_commands)
15617     {
15618       add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
15619 Break in function/address or break at a line in the current file."),
15620                              &stoplist, "stop ", 1, &cmdlist);
15621       add_cmd ("in", class_breakpoint, stopin_command,
15622                _("Break in function or address."), &stoplist);
15623       add_cmd ("at", class_breakpoint, stopat_command,
15624                _("Break at a line in the current file."), &stoplist);
15625       add_com ("status", class_info, info_breakpoints_command, _("\
15626 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15627 The \"Type\" column indicates one of:\n\
15628 \tbreakpoint     - normal breakpoint\n\
15629 \twatchpoint     - watchpoint\n\
15630 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15631 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15632 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15633 address and file/line number respectively.\n\
15634 \n\
15635 Convenience variable \"$_\" and default examine address for \"x\"\n\
15636 are set to the address of the last breakpoint listed unless the command\n\
15637 is prefixed with \"server \".\n\n\
15638 Convenience variable \"$bpnum\" contains the number of the last\n\
15639 breakpoint set."));
15640     }
15641
15642   add_info ("breakpoints", info_breakpoints_command, _("\
15643 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15644 The \"Type\" column indicates one of:\n\
15645 \tbreakpoint     - normal breakpoint\n\
15646 \twatchpoint     - watchpoint\n\
15647 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15648 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15649 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15650 address and file/line number respectively.\n\
15651 \n\
15652 Convenience variable \"$_\" and default examine address for \"x\"\n\
15653 are set to the address of the last breakpoint listed unless the command\n\
15654 is prefixed with \"server \".\n\n\
15655 Convenience variable \"$bpnum\" contains the number of the last\n\
15656 breakpoint set."));
15657
15658   add_info_alias ("b", "breakpoints", 1);
15659
15660   add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
15661 Status of all breakpoints, or breakpoint number NUMBER.\n\
15662 The \"Type\" column indicates one of:\n\
15663 \tbreakpoint     - normal breakpoint\n\
15664 \twatchpoint     - watchpoint\n\
15665 \tlongjmp        - internal breakpoint used to step through longjmp()\n\
15666 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15667 \tuntil          - internal breakpoint used by the \"until\" command\n\
15668 \tfinish         - internal breakpoint used by the \"finish\" command\n\
15669 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15670 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15671 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15672 address and file/line number respectively.\n\
15673 \n\
15674 Convenience variable \"$_\" and default examine address for \"x\"\n\
15675 are set to the address of the last breakpoint listed unless the command\n\
15676 is prefixed with \"server \".\n\n\
15677 Convenience variable \"$bpnum\" contains the number of the last\n\
15678 breakpoint set."),
15679            &maintenanceinfolist);
15680
15681   add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
15682 Set catchpoints to catch events."),
15683                   &catch_cmdlist, "catch ",
15684                   0/*allow-unknown*/, &cmdlist);
15685
15686   add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
15687 Set temporary catchpoints to catch events."),
15688                   &tcatch_cmdlist, "tcatch ",
15689                   0/*allow-unknown*/, &cmdlist);
15690
15691   add_catch_command ("fork", _("Catch calls to fork."),
15692                      catch_fork_command_1,
15693                      NULL,
15694                      (void *) (uintptr_t) catch_fork_permanent,
15695                      (void *) (uintptr_t) catch_fork_temporary);
15696   add_catch_command ("vfork", _("Catch calls to vfork."),
15697                      catch_fork_command_1,
15698                      NULL,
15699                      (void *) (uintptr_t) catch_vfork_permanent,
15700                      (void *) (uintptr_t) catch_vfork_temporary);
15701   add_catch_command ("exec", _("Catch calls to exec."),
15702                      catch_exec_command_1,
15703                      NULL,
15704                      CATCH_PERMANENT,
15705                      CATCH_TEMPORARY);
15706   add_catch_command ("load", _("Catch loads of shared libraries.\n\
15707 Usage: catch load [REGEX]\n\
15708 If REGEX is given, only stop for libraries matching the regular expression."),
15709                      catch_load_command_1,
15710                      NULL,
15711                      CATCH_PERMANENT,
15712                      CATCH_TEMPORARY);
15713   add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15714 Usage: catch unload [REGEX]\n\
15715 If REGEX is given, only stop for libraries matching the regular expression."),
15716                      catch_unload_command_1,
15717                      NULL,
15718                      CATCH_PERMANENT,
15719                      CATCH_TEMPORARY);
15720
15721   c = add_com ("watch", class_breakpoint, watch_command, _("\
15722 Set a watchpoint for an expression.\n\
15723 Usage: watch [-l|-location] EXPRESSION\n\
15724 A watchpoint stops execution of your program whenever the value of\n\
15725 an expression changes.\n\
15726 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15727 the memory to which it refers."));
15728   set_cmd_completer (c, expression_completer);
15729
15730   c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
15731 Set a read watchpoint for an expression.\n\
15732 Usage: rwatch [-l|-location] EXPRESSION\n\
15733 A watchpoint stops execution of your program whenever the value of\n\
15734 an expression is read.\n\
15735 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15736 the memory to which it refers."));
15737   set_cmd_completer (c, expression_completer);
15738
15739   c = add_com ("awatch", class_breakpoint, awatch_command, _("\
15740 Set a watchpoint for an expression.\n\
15741 Usage: awatch [-l|-location] EXPRESSION\n\
15742 A watchpoint stops execution of your program whenever the value of\n\
15743 an expression is either read or written.\n\
15744 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15745 the memory to which it refers."));
15746   set_cmd_completer (c, expression_completer);
15747
15748   add_info ("watchpoints", info_watchpoints_command, _("\
15749 Status of specified watchpoints (all watchpoints if no argument)."));
15750
15751   /* XXX: cagney/2005-02-23: This should be a boolean, and should
15752      respond to changes - contrary to the description.  */
15753   add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
15754                             &can_use_hw_watchpoints, _("\
15755 Set debugger's willingness to use watchpoint hardware."), _("\
15756 Show debugger's willingness to use watchpoint hardware."), _("\
15757 If zero, gdb will not use hardware for new watchpoints, even if\n\
15758 such is available.  (However, any hardware watchpoints that were\n\
15759 created before setting this to nonzero, will continue to use watchpoint\n\
15760 hardware.)"),
15761                             NULL,
15762                             show_can_use_hw_watchpoints,
15763                             &setlist, &showlist);
15764
15765   can_use_hw_watchpoints = 1;
15766
15767   /* Tracepoint manipulation commands.  */
15768
15769   c = add_com ("trace", class_breakpoint, trace_command, _("\
15770 Set a tracepoint at specified location.\n\
15771 \n"
15772 BREAK_ARGS_HELP ("trace") "\n\
15773 Do \"help tracepoints\" for info on other tracepoint commands."));
15774   set_cmd_completer (c, location_completer);
15775
15776   add_com_alias ("tp", "trace", class_alias, 0);
15777   add_com_alias ("tr", "trace", class_alias, 1);
15778   add_com_alias ("tra", "trace", class_alias, 1);
15779   add_com_alias ("trac", "trace", class_alias, 1);
15780
15781   c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
15782 Set a fast tracepoint at specified location.\n\
15783 \n"
15784 BREAK_ARGS_HELP ("ftrace") "\n\
15785 Do \"help tracepoints\" for info on other tracepoint commands."));
15786   set_cmd_completer (c, location_completer);
15787
15788   c = add_com ("strace", class_breakpoint, strace_command, _("\
15789 Set a static tracepoint at location or marker.\n\
15790 \n\
15791 strace [LOCATION] [if CONDITION]\n\
15792 LOCATION may be a linespec, explicit, or address location (described below) \n\
15793 or -m MARKER_ID.\n\n\
15794 If a marker id is specified, probe the marker with that name.  With\n\
15795 no LOCATION, uses current execution address of the selected stack frame.\n\
15796 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15797 This collects arbitrary user data passed in the probe point call to the\n\
15798 tracing library.  You can inspect it when analyzing the trace buffer,\n\
15799 by printing the $_sdata variable like any other convenience variable.\n\
15800 \n\
15801 CONDITION is a boolean expression.\n\
15802 \n" LOCATION_HELP_STRING "\n\
15803 Multiple tracepoints at one place are permitted, and useful if their\n\
15804 conditions are different.\n\
15805 \n\
15806 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15807 Do \"help tracepoints\" for info on other tracepoint commands."));
15808   set_cmd_completer (c, location_completer);
15809
15810   add_info ("tracepoints", info_tracepoints_command, _("\
15811 Status of specified tracepoints (all tracepoints if no argument).\n\
15812 Convenience variable \"$tpnum\" contains the number of the\n\
15813 last tracepoint set."));
15814
15815   add_info_alias ("tp", "tracepoints", 1);
15816
15817   add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
15818 Delete specified tracepoints.\n\
15819 Arguments are tracepoint numbers, separated by spaces.\n\
15820 No argument means delete all tracepoints."),
15821            &deletelist);
15822   add_alias_cmd ("tr", "tracepoints", class_trace, 1, &deletelist);
15823
15824   c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
15825 Disable specified tracepoints.\n\
15826 Arguments are tracepoint numbers, separated by spaces.\n\
15827 No argument means disable all tracepoints."),
15828            &disablelist);
15829   deprecate_cmd (c, "disable");
15830
15831   c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
15832 Enable specified tracepoints.\n\
15833 Arguments are tracepoint numbers, separated by spaces.\n\
15834 No argument means enable all tracepoints."),
15835            &enablelist);
15836   deprecate_cmd (c, "enable");
15837
15838   add_com ("passcount", class_trace, trace_pass_command, _("\
15839 Set the passcount for a tracepoint.\n\
15840 The trace will end when the tracepoint has been passed 'count' times.\n\
15841 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15842 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15843
15844   add_prefix_cmd ("save", class_breakpoint, save_command,
15845                   _("Save breakpoint definitions as a script."),
15846                   &save_cmdlist, "save ",
15847                   0/*allow-unknown*/, &cmdlist);
15848
15849   c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
15850 Save current breakpoint definitions as a script.\n\
15851 This includes all types of breakpoints (breakpoints, watchpoints,\n\
15852 catchpoints, tracepoints).  Use the 'source' command in another debug\n\
15853 session to restore them."),
15854                &save_cmdlist);
15855   set_cmd_completer (c, filename_completer);
15856
15857   c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
15858 Save current tracepoint definitions as a script.\n\
15859 Use the 'source' command in another debug session to restore them."),
15860                &save_cmdlist);
15861   set_cmd_completer (c, filename_completer);
15862
15863   c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
15864   deprecate_cmd (c, "save tracepoints");
15865
15866   add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
15867 Breakpoint specific settings\n\
15868 Configure various breakpoint-specific variables such as\n\
15869 pending breakpoint behavior"),
15870                   &breakpoint_set_cmdlist, "set breakpoint ",
15871                   0/*allow-unknown*/, &setlist);
15872   add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
15873 Breakpoint specific settings\n\
15874 Configure various breakpoint-specific variables such as\n\
15875 pending breakpoint behavior"),
15876                   &breakpoint_show_cmdlist, "show breakpoint ",
15877                   0/*allow-unknown*/, &showlist);
15878
15879   add_setshow_auto_boolean_cmd ("pending", no_class,
15880                                 &pending_break_support, _("\
15881 Set debugger's behavior regarding pending breakpoints."), _("\
15882 Show debugger's behavior regarding pending breakpoints."), _("\
15883 If on, an unrecognized breakpoint location will cause gdb to create a\n\
15884 pending breakpoint.  If off, an unrecognized breakpoint location results in\n\
15885 an error.  If auto, an unrecognized breakpoint location results in a\n\
15886 user-query to see if a pending breakpoint should be created."),
15887                                 NULL,
15888                                 show_pending_break_support,
15889                                 &breakpoint_set_cmdlist,
15890                                 &breakpoint_show_cmdlist);
15891
15892   pending_break_support = AUTO_BOOLEAN_AUTO;
15893
15894   add_setshow_boolean_cmd ("auto-hw", no_class,
15895                            &automatic_hardware_breakpoints, _("\
15896 Set automatic usage of hardware breakpoints."), _("\
15897 Show automatic usage of hardware breakpoints."), _("\
15898 If set, the debugger will automatically use hardware breakpoints for\n\
15899 breakpoints set with \"break\" but falling in read-only memory.  If not set,\n\
15900 a warning will be emitted for such breakpoints."),
15901                            NULL,
15902                            show_automatic_hardware_breakpoints,
15903                            &breakpoint_set_cmdlist,
15904                            &breakpoint_show_cmdlist);
15905
15906   add_setshow_boolean_cmd ("always-inserted", class_support,
15907                            &always_inserted_mode, _("\
15908 Set mode for inserting breakpoints."), _("\
15909 Show mode for inserting breakpoints."), _("\
15910 When this mode is on, breakpoints are inserted immediately as soon as\n\
15911 they're created, kept inserted even when execution stops, and removed\n\
15912 only when the user deletes them.  When this mode is off (the default),\n\
15913 breakpoints are inserted only when execution continues, and removed\n\
15914 when execution stops."),
15915                                 NULL,
15916                                 &show_always_inserted_mode,
15917                                 &breakpoint_set_cmdlist,
15918                                 &breakpoint_show_cmdlist);
15919
15920   add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
15921                         condition_evaluation_enums,
15922                         &condition_evaluation_mode_1, _("\
15923 Set mode of breakpoint condition evaluation."), _("\
15924 Show mode of breakpoint condition evaluation."), _("\
15925 When this is set to \"host\", breakpoint conditions will be\n\
15926 evaluated on the host's side by GDB.  When it is set to \"target\",\n\
15927 breakpoint conditions will be downloaded to the target (if the target\n\
15928 supports such feature) and conditions will be evaluated on the target's side.\n\
15929 If this is set to \"auto\" (default), this will be automatically set to\n\
15930 \"target\" if it supports condition evaluation, otherwise it will\n\
15931 be set to \"gdb\""),
15932                            &set_condition_evaluation_mode,
15933                            &show_condition_evaluation_mode,
15934                            &breakpoint_set_cmdlist,
15935                            &breakpoint_show_cmdlist);
15936
15937   add_com ("break-range", class_breakpoint, break_range_command, _("\
15938 Set a breakpoint for an address range.\n\
15939 break-range START-LOCATION, END-LOCATION\n\
15940 where START-LOCATION and END-LOCATION can be one of the following:\n\
15941   LINENUM, for that line in the current file,\n\
15942   FILE:LINENUM, for that line in that file,\n\
15943   +OFFSET, for that number of lines after the current line\n\
15944            or the start of the range\n\
15945   FUNCTION, for the first line in that function,\n\
15946   FILE:FUNCTION, to distinguish among like-named static functions.\n\
15947   *ADDRESS, for the instruction at that address.\n\
15948 \n\
15949 The breakpoint will stop execution of the inferior whenever it executes\n\
15950 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
15951 range (including START-LOCATION and END-LOCATION)."));
15952
15953   c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
15954 Set a dynamic printf at specified location.\n\
15955 dprintf location,format string,arg1,arg2,...\n\
15956 location may be a linespec, explicit, or address location.\n"
15957 "\n" LOCATION_HELP_STRING));
15958   set_cmd_completer (c, location_completer);
15959
15960   add_setshow_enum_cmd ("dprintf-style", class_support,
15961                         dprintf_style_enums, &dprintf_style, _("\
15962 Set the style of usage for dynamic printf."), _("\
15963 Show the style of usage for dynamic printf."), _("\
15964 This setting chooses how GDB will do a dynamic printf.\n\
15965 If the value is \"gdb\", then the printing is done by GDB to its own\n\
15966 console, as with the \"printf\" command.\n\
15967 If the value is \"call\", the print is done by calling a function in your\n\
15968 program; by default printf(), but you can choose a different function or\n\
15969 output stream by setting dprintf-function and dprintf-channel."),
15970                         update_dprintf_commands, NULL,
15971                         &setlist, &showlist);
15972
15973   dprintf_function = xstrdup ("printf");
15974   add_setshow_string_cmd ("dprintf-function", class_support,
15975                           &dprintf_function, _("\
15976 Set the function to use for dynamic printf"), _("\
15977 Show the function to use for dynamic printf"), NULL,
15978                           update_dprintf_commands, NULL,
15979                           &setlist, &showlist);
15980
15981   dprintf_channel = xstrdup ("");
15982   add_setshow_string_cmd ("dprintf-channel", class_support,
15983                           &dprintf_channel, _("\
15984 Set the channel to use for dynamic printf"), _("\
15985 Show the channel to use for dynamic printf"), NULL,
15986                           update_dprintf_commands, NULL,
15987                           &setlist, &showlist);
15988
15989   add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
15990                            &disconnected_dprintf, _("\
15991 Set whether dprintf continues after GDB disconnects."), _("\
15992 Show whether dprintf continues after GDB disconnects."), _("\
15993 Use this to let dprintf commands continue to hit and produce output\n\
15994 even if GDB disconnects or detaches from the target."),
15995                            NULL,
15996                            NULL,
15997                            &setlist, &showlist);
15998
15999   add_com ("agent-printf", class_vars, agent_printf_command, _("\
16000 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16001 (target agent only) This is useful for formatted output in user-defined commands."));
16002
16003   automatic_hardware_breakpoints = 1;
16004
16005   gdb::observers::about_to_proceed.attach (breakpoint_about_to_proceed);
16006   gdb::observers::thread_exit.attach (remove_threaded_breakpoints);
16007 }