Convert breakpoint.c to type-safe registry API
[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 #include "mi/mi-main.h"
73
74 /* readline include files */
75 #include "readline/readline.h"
76 #include "readline/history.h"
77
78 /* readline defines this.  */
79 #undef savestring
80
81 #include "mi/mi-common.h"
82 #include "extension.h"
83 #include <algorithm>
84 #include "progspace-and-thread.h"
85 #include "common/array-view.h"
86 #include "common/gdb_optional.h"
87
88 /* Enums for exception-handling support.  */
89 enum exception_event_kind
90 {
91   EX_EVENT_THROW,
92   EX_EVENT_RETHROW,
93   EX_EVENT_CATCH
94 };
95
96 /* Prototypes for local functions.  */
97
98 static void map_breakpoint_numbers (const char *,
99                                     gdb::function_view<void (breakpoint *)>);
100
101 static void breakpoint_re_set_default (struct breakpoint *);
102
103 static void
104   create_sals_from_location_default (const struct event_location *location,
105                                      struct linespec_result *canonical,
106                                      enum bptype type_wanted);
107
108 static void create_breakpoints_sal_default (struct gdbarch *,
109                                             struct linespec_result *,
110                                             gdb::unique_xmalloc_ptr<char>,
111                                             gdb::unique_xmalloc_ptr<char>,
112                                             enum bptype,
113                                             enum bpdisp, int, int,
114                                             int,
115                                             const struct breakpoint_ops *,
116                                             int, int, int, unsigned);
117
118 static std::vector<symtab_and_line> decode_location_default
119   (struct breakpoint *b, const struct event_location *location,
120    struct program_space *search_pspace);
121
122 static int can_use_hardware_watchpoint
123     (const std::vector<value_ref_ptr> &vals);
124
125 static void mention (struct breakpoint *);
126
127 static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
128                                                                enum bptype,
129                                                                const struct breakpoint_ops *);
130 static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
131                                                        const struct symtab_and_line *);
132
133 /* This function is used in gdbtk sources and thus can not be made
134    static.  */
135 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
136                                        struct symtab_and_line,
137                                        enum bptype,
138                                        const struct breakpoint_ops *);
139
140 static struct breakpoint *
141   momentary_breakpoint_from_master (struct breakpoint *orig,
142                                     enum bptype type,
143                                     const struct breakpoint_ops *ops,
144                                     int loc_enabled);
145
146 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
147
148 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
149                                             CORE_ADDR bpaddr,
150                                             enum bptype bptype);
151
152 static void describe_other_breakpoints (struct gdbarch *,
153                                         struct program_space *, CORE_ADDR,
154                                         struct obj_section *, int);
155
156 static int watchpoint_locations_match (struct bp_location *loc1,
157                                        struct bp_location *loc2);
158
159 static int breakpoint_location_address_match (struct bp_location *bl,
160                                               const struct address_space *aspace,
161                                               CORE_ADDR addr);
162
163 static int breakpoint_location_address_range_overlap (struct bp_location *,
164                                                       const address_space *,
165                                                       CORE_ADDR, int);
166
167 static int remove_breakpoint (struct bp_location *);
168 static int remove_breakpoint_1 (struct bp_location *, enum remove_bp_reason);
169
170 static enum print_stop_action print_bp_stop_message (bpstat bs);
171
172 static int hw_breakpoint_used_count (void);
173
174 static int hw_watchpoint_use_count (struct breakpoint *);
175
176 static int hw_watchpoint_used_count_others (struct breakpoint *except,
177                                             enum bptype type,
178                                             int *other_type_used);
179
180 static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
181                                     int count);
182
183 static void free_bp_location (struct bp_location *loc);
184 static void incref_bp_location (struct bp_location *loc);
185 static void decref_bp_location (struct bp_location **loc);
186
187 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
188
189 /* update_global_location_list's modes of operation wrt to whether to
190    insert locations now.  */
191 enum ugll_insert_mode
192 {
193   /* Don't insert any breakpoint locations into the inferior, only
194      remove already-inserted locations that no longer should be
195      inserted.  Functions that delete a breakpoint or breakpoints
196      should specify this mode, so that deleting a breakpoint doesn't
197      have the side effect of inserting the locations of other
198      breakpoints that are marked not-inserted, but should_be_inserted
199      returns true on them.
200
201      This behavior is useful is situations close to tear-down -- e.g.,
202      after an exec, while the target still has execution, but
203      breakpoint shadows of the previous executable image should *NOT*
204      be restored to the new image; or before detaching, where the
205      target still has execution and wants to delete breakpoints from
206      GDB's lists, and all breakpoints had already been removed from
207      the inferior.  */
208   UGLL_DONT_INSERT,
209
210   /* May insert breakpoints iff breakpoints_should_be_inserted_now
211      claims breakpoints should be inserted now.  */
212   UGLL_MAY_INSERT,
213
214   /* Insert locations now, irrespective of
215      breakpoints_should_be_inserted_now.  E.g., say all threads are
216      stopped right now, and the user did "continue".  We need to
217      insert breakpoints _before_ resuming the target, but
218      UGLL_MAY_INSERT wouldn't insert them, because
219      breakpoints_should_be_inserted_now returns false at that point,
220      as no thread is running yet.  */
221   UGLL_INSERT
222 };
223
224 static void update_global_location_list (enum ugll_insert_mode);
225
226 static void update_global_location_list_nothrow (enum ugll_insert_mode);
227
228 static int is_hardware_watchpoint (const struct breakpoint *bpt);
229
230 static void insert_breakpoint_locations (void);
231
232 static void trace_pass_command (const char *, int);
233
234 static void set_tracepoint_count (int num);
235
236 static int is_masked_watchpoint (const struct breakpoint *b);
237
238 static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
239
240 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
241    otherwise.  */
242
243 static int strace_marker_p (struct breakpoint *b);
244
245 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
246    that are implemented on top of software or hardware breakpoints
247    (user breakpoints, internal and momentary breakpoints, etc.).  */
248 static struct breakpoint_ops bkpt_base_breakpoint_ops;
249
250 /* Internal breakpoints class type.  */
251 static struct breakpoint_ops internal_breakpoint_ops;
252
253 /* Momentary breakpoints class type.  */
254 static struct breakpoint_ops momentary_breakpoint_ops;
255
256 /* The breakpoint_ops structure to be used in regular user created
257    breakpoints.  */
258 struct breakpoint_ops bkpt_breakpoint_ops;
259
260 /* Breakpoints set on probes.  */
261 static struct breakpoint_ops bkpt_probe_breakpoint_ops;
262
263 /* Dynamic printf class type.  */
264 struct breakpoint_ops dprintf_breakpoint_ops;
265
266 /* The style in which to perform a dynamic printf.  This is a user
267    option because different output options have different tradeoffs;
268    if GDB does the printing, there is better error handling if there
269    is a problem with any of the arguments, but using an inferior
270    function lets you have special-purpose printers and sending of
271    output to the same place as compiled-in print functions.  */
272
273 static const char dprintf_style_gdb[] = "gdb";
274 static const char dprintf_style_call[] = "call";
275 static const char dprintf_style_agent[] = "agent";
276 static const char *const dprintf_style_enums[] = {
277   dprintf_style_gdb,
278   dprintf_style_call,
279   dprintf_style_agent,
280   NULL
281 };
282 static const char *dprintf_style = dprintf_style_gdb;
283
284 /* The function to use for dynamic printf if the preferred style is to
285    call into the inferior.  The value is simply a string that is
286    copied into the command, so it can be anything that GDB can
287    evaluate to a callable address, not necessarily a function name.  */
288
289 static char *dprintf_function;
290
291 /* The channel to use for dynamic printf if the preferred style is to
292    call into the inferior; if a nonempty string, it will be passed to
293    the call as the first argument, with the format string as the
294    second.  As with the dprintf function, this can be anything that
295    GDB knows how to evaluate, so in addition to common choices like
296    "stderr", this could be an app-specific expression like
297    "mystreams[curlogger]".  */
298
299 static char *dprintf_channel;
300
301 /* True if dprintf commands should continue to operate even if GDB
302    has disconnected.  */
303 static int disconnected_dprintf = 1;
304
305 struct command_line *
306 breakpoint_commands (struct breakpoint *b)
307 {
308   return b->commands ? b->commands.get () : NULL;
309 }
310
311 /* Flag indicating that a command has proceeded the inferior past the
312    current breakpoint.  */
313
314 static int breakpoint_proceeded;
315
316 const char *
317 bpdisp_text (enum bpdisp disp)
318 {
319   /* NOTE: the following values are a part of MI protocol and
320      represent values of 'disp' field returned when inferior stops at
321      a breakpoint.  */
322   static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
323
324   return bpdisps[(int) disp];
325 }
326
327 /* Prototypes for exported functions.  */
328 /* If FALSE, gdb will not use hardware support for watchpoints, even
329    if such is available.  */
330 static int can_use_hw_watchpoints;
331
332 static void
333 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
334                              struct cmd_list_element *c,
335                              const char *value)
336 {
337   fprintf_filtered (file,
338                     _("Debugger's willingness to use "
339                       "watchpoint hardware is %s.\n"),
340                     value);
341 }
342
343 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
344    If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
345    for unrecognized breakpoint locations.
346    If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized.  */
347 static enum auto_boolean pending_break_support;
348 static void
349 show_pending_break_support (struct ui_file *file, int from_tty,
350                             struct cmd_list_element *c,
351                             const char *value)
352 {
353   fprintf_filtered (file,
354                     _("Debugger's behavior regarding "
355                       "pending breakpoints is %s.\n"),
356                     value);
357 }
358
359 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
360    set with "break" but falling in read-only memory.
361    If 0, gdb will warn about such breakpoints, but won't automatically
362    use hardware breakpoints.  */
363 static int automatic_hardware_breakpoints;
364 static void
365 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
366                                      struct cmd_list_element *c,
367                                      const char *value)
368 {
369   fprintf_filtered (file,
370                     _("Automatic usage of hardware breakpoints is %s.\n"),
371                     value);
372 }
373
374 /* If on, GDB keeps breakpoints inserted even if the inferior is
375    stopped, and immediately inserts any new breakpoints as soon as
376    they're created.  If off (default), GDB keeps breakpoints off of
377    the target as long as possible.  That is, it delays inserting
378    breakpoints until the next resume, and removes them again when the
379    target fully stops.  This is a bit safer in case GDB crashes while
380    processing user input.  */
381 static int always_inserted_mode = 0;
382
383 static void
384 show_always_inserted_mode (struct ui_file *file, int from_tty,
385                      struct cmd_list_element *c, const char *value)
386 {
387   fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
388                     value);
389 }
390
391 /* See breakpoint.h.  */
392
393 int
394 breakpoints_should_be_inserted_now (void)
395 {
396   if (gdbarch_has_global_breakpoints (target_gdbarch ()))
397     {
398       /* If breakpoints are global, they should be inserted even if no
399          thread under gdb's control is running, or even if there are
400          no threads under GDB's control yet.  */
401       return 1;
402     }
403   else if (target_has_execution)
404     {
405       if (always_inserted_mode)
406         {
407           /* The user wants breakpoints inserted even if all threads
408              are stopped.  */
409           return 1;
410         }
411
412       if (threads_are_executing ())
413         return 1;
414
415       /* Don't remove breakpoints yet if, even though all threads are
416          stopped, we still have events to process.  */
417       for (thread_info *tp : all_non_exited_threads ())
418         if (tp->resumed
419             && tp->suspend.waitstatus_pending_p)
420           return 1;
421     }
422   return 0;
423 }
424
425 static const char condition_evaluation_both[] = "host or target";
426
427 /* Modes for breakpoint condition evaluation.  */
428 static const char condition_evaluation_auto[] = "auto";
429 static const char condition_evaluation_host[] = "host";
430 static const char condition_evaluation_target[] = "target";
431 static const char *const condition_evaluation_enums[] = {
432   condition_evaluation_auto,
433   condition_evaluation_host,
434   condition_evaluation_target,
435   NULL
436 };
437
438 /* Global that holds the current mode for breakpoint condition evaluation.  */
439 static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
440
441 /* Global that we use to display information to the user (gets its value from
442    condition_evaluation_mode_1.  */
443 static const char *condition_evaluation_mode = condition_evaluation_auto;
444
445 /* Translate a condition evaluation mode MODE into either "host"
446    or "target".  This is used mostly to translate from "auto" to the
447    real setting that is being used.  It returns the translated
448    evaluation mode.  */
449
450 static const char *
451 translate_condition_evaluation_mode (const char *mode)
452 {
453   if (mode == condition_evaluation_auto)
454     {
455       if (target_supports_evaluation_of_breakpoint_conditions ())
456         return condition_evaluation_target;
457       else
458         return condition_evaluation_host;
459     }
460   else
461     return mode;
462 }
463
464 /* Discovers what condition_evaluation_auto translates to.  */
465
466 static const char *
467 breakpoint_condition_evaluation_mode (void)
468 {
469   return translate_condition_evaluation_mode (condition_evaluation_mode);
470 }
471
472 /* Return true if GDB should evaluate breakpoint conditions or false
473    otherwise.  */
474
475 static int
476 gdb_evaluates_breakpoint_condition_p (void)
477 {
478   const char *mode = breakpoint_condition_evaluation_mode ();
479
480   return (mode == condition_evaluation_host);
481 }
482
483 /* Are we executing breakpoint commands?  */
484 static int executing_breakpoint_commands;
485
486 /* Are overlay event breakpoints enabled? */
487 static int overlay_events_enabled;
488
489 /* See description in breakpoint.h. */
490 int target_exact_watchpoints = 0;
491
492 /* Walk the following statement or block through all breakpoints.
493    ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
494    current breakpoint.  */
495
496 #define ALL_BREAKPOINTS(B)  for (B = breakpoint_chain; B; B = B->next)
497
498 #define ALL_BREAKPOINTS_SAFE(B,TMP)     \
499         for (B = breakpoint_chain;      \
500              B ? (TMP=B->next, 1): 0;   \
501              B = TMP)
502
503 /* Similar iterator for the low-level breakpoints.  SAFE variant is
504    not provided so update_global_location_list must not be called
505    while executing the block of ALL_BP_LOCATIONS.  */
506
507 #define ALL_BP_LOCATIONS(B,BP_TMP)                                      \
508         for (BP_TMP = bp_locations;                                     \
509              BP_TMP < bp_locations + bp_locations_count && (B = *BP_TMP);\
510              BP_TMP++)
511
512 /* Iterates through locations with address ADDRESS for the currently selected
513    program space.  BP_LOCP_TMP points to each object.  BP_LOCP_START points
514    to where the loop should start from.
515    If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
516    appropriate location to start with.  */
517
518 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS)   \
519         for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
520              BP_LOCP_TMP = BP_LOCP_START;                               \
521              BP_LOCP_START                                              \
522              && (BP_LOCP_TMP < bp_locations + bp_locations_count        \
523              && (*BP_LOCP_TMP)->address == ADDRESS);                    \
524              BP_LOCP_TMP++)
525
526 /* Iterator for tracepoints only.  */
527
528 #define ALL_TRACEPOINTS(B)  \
529   for (B = breakpoint_chain; B; B = B->next)  \
530     if (is_tracepoint (B))
531
532 /* Chains of all breakpoints defined.  */
533
534 struct breakpoint *breakpoint_chain;
535
536 /* Array is sorted by bp_locations_compare - primarily by the ADDRESS.  */
537
538 static struct bp_location **bp_locations;
539
540 /* Number of elements of BP_LOCATIONS.  */
541
542 static unsigned bp_locations_count;
543
544 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
545    ADDRESS for the current elements of BP_LOCATIONS which get a valid
546    result from bp_location_has_shadow.  You can use it for roughly
547    limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
548    an address you need to read.  */
549
550 static CORE_ADDR bp_locations_placed_address_before_address_max;
551
552 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
553    + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
554    BP_LOCATIONS which get a valid result from bp_location_has_shadow.
555    You can use it for roughly limiting the subrange of BP_LOCATIONS to
556    scan for shadow bytes for an address you need to read.  */
557
558 static CORE_ADDR bp_locations_shadow_len_after_address_max;
559
560 /* The locations that no longer correspond to any breakpoint, unlinked
561    from the bp_locations array, but for which a hit may still be
562    reported by a target.  */
563 static std::vector<bp_location *> moribund_locations;
564
565 /* Number of last breakpoint made.  */
566
567 static int breakpoint_count;
568
569 /* The value of `breakpoint_count' before the last command that
570    created breakpoints.  If the last (break-like) command created more
571    than one breakpoint, then the difference between BREAKPOINT_COUNT
572    and PREV_BREAKPOINT_COUNT is more than one.  */
573 static int prev_breakpoint_count;
574
575 /* Number of last tracepoint made.  */
576
577 static int tracepoint_count;
578
579 static struct cmd_list_element *breakpoint_set_cmdlist;
580 static struct cmd_list_element *breakpoint_show_cmdlist;
581 struct cmd_list_element *save_cmdlist;
582
583 /* See declaration at breakpoint.h.  */
584
585 struct breakpoint *
586 breakpoint_find_if (int (*func) (struct breakpoint *b, void *d),
587                     void *user_data)
588 {
589   struct breakpoint *b = NULL;
590
591   ALL_BREAKPOINTS (b)
592     {
593       if (func (b, user_data) != 0)
594         break;
595     }
596
597   return b;
598 }
599
600 /* Return whether a breakpoint is an active enabled breakpoint.  */
601 static int
602 breakpoint_enabled (struct breakpoint *b)
603 {
604   return (b->enable_state == bp_enabled);
605 }
606
607 /* Set breakpoint count to NUM.  */
608
609 static void
610 set_breakpoint_count (int num)
611 {
612   prev_breakpoint_count = breakpoint_count;
613   breakpoint_count = num;
614   set_internalvar_integer (lookup_internalvar ("bpnum"), num);
615 }
616
617 /* Used by `start_rbreak_breakpoints' below, to record the current
618    breakpoint count before "rbreak" creates any breakpoint.  */
619 static int rbreak_start_breakpoint_count;
620
621 /* Called at the start an "rbreak" command to record the first
622    breakpoint made.  */
623
624 scoped_rbreak_breakpoints::scoped_rbreak_breakpoints ()
625 {
626   rbreak_start_breakpoint_count = breakpoint_count;
627 }
628
629 /* Called at the end of an "rbreak" command to record the last
630    breakpoint made.  */
631
632 scoped_rbreak_breakpoints::~scoped_rbreak_breakpoints ()
633 {
634   prev_breakpoint_count = rbreak_start_breakpoint_count;
635 }
636
637 /* Used in run_command to zero the hit count when a new run starts.  */
638
639 void
640 clear_breakpoint_hit_counts (void)
641 {
642   struct breakpoint *b;
643
644   ALL_BREAKPOINTS (b)
645     b->hit_count = 0;
646 }
647
648 \f
649 /* Return the breakpoint with the specified number, or NULL
650    if the number does not refer to an existing breakpoint.  */
651
652 struct breakpoint *
653 get_breakpoint (int num)
654 {
655   struct breakpoint *b;
656
657   ALL_BREAKPOINTS (b)
658     if (b->number == num)
659       return b;
660   
661   return NULL;
662 }
663
664 \f
665
666 /* Mark locations as "conditions have changed" in case the target supports
667    evaluating conditions on its side.  */
668
669 static void
670 mark_breakpoint_modified (struct breakpoint *b)
671 {
672   struct bp_location *loc;
673
674   /* This is only meaningful if the target is
675      evaluating conditions and if the user has
676      opted for condition evaluation on the target's
677      side.  */
678   if (gdb_evaluates_breakpoint_condition_p ()
679       || !target_supports_evaluation_of_breakpoint_conditions ())
680     return;
681
682   if (!is_breakpoint (b))
683     return;
684
685   for (loc = b->loc; loc; loc = loc->next)
686     loc->condition_changed = condition_modified;
687 }
688
689 /* Mark location as "conditions have changed" in case the target supports
690    evaluating conditions on its side.  */
691
692 static void
693 mark_breakpoint_location_modified (struct bp_location *loc)
694 {
695   /* This is only meaningful if the target is
696      evaluating conditions and if the user has
697      opted for condition evaluation on the target's
698      side.  */
699   if (gdb_evaluates_breakpoint_condition_p ()
700       || !target_supports_evaluation_of_breakpoint_conditions ())
701
702     return;
703
704   if (!is_breakpoint (loc->owner))
705     return;
706
707   loc->condition_changed = condition_modified;
708 }
709
710 /* Sets the condition-evaluation mode using the static global
711    condition_evaluation_mode.  */
712
713 static void
714 set_condition_evaluation_mode (const char *args, int from_tty,
715                                struct cmd_list_element *c)
716 {
717   const char *old_mode, *new_mode;
718
719   if ((condition_evaluation_mode_1 == condition_evaluation_target)
720       && !target_supports_evaluation_of_breakpoint_conditions ())
721     {
722       condition_evaluation_mode_1 = condition_evaluation_mode;
723       warning (_("Target does not support breakpoint condition evaluation.\n"
724                  "Using host evaluation mode instead."));
725       return;
726     }
727
728   new_mode = translate_condition_evaluation_mode (condition_evaluation_mode_1);
729   old_mode = translate_condition_evaluation_mode (condition_evaluation_mode);
730
731   /* Flip the switch.  Flip it even if OLD_MODE == NEW_MODE as one of the
732      settings was "auto".  */
733   condition_evaluation_mode = condition_evaluation_mode_1;
734
735   /* Only update the mode if the user picked a different one.  */
736   if (new_mode != old_mode)
737     {
738       struct bp_location *loc, **loc_tmp;
739       /* If the user switched to a different evaluation mode, we
740          need to synch the changes with the target as follows:
741
742          "host" -> "target": Send all (valid) conditions to the target.
743          "target" -> "host": Remove all the conditions from the target.
744       */
745
746       if (new_mode == condition_evaluation_target)
747         {
748           /* Mark everything modified and synch conditions with the
749              target.  */
750           ALL_BP_LOCATIONS (loc, loc_tmp)
751             mark_breakpoint_location_modified (loc);
752         }
753       else
754         {
755           /* Manually mark non-duplicate locations to synch conditions
756              with the target.  We do this to remove all the conditions the
757              target knows about.  */
758           ALL_BP_LOCATIONS (loc, loc_tmp)
759             if (is_breakpoint (loc->owner) && loc->inserted)
760               loc->needs_update = 1;
761         }
762
763       /* Do the update.  */
764       update_global_location_list (UGLL_MAY_INSERT);
765     }
766
767   return;
768 }
769
770 /* Shows the current mode of breakpoint condition evaluation.  Explicitly shows
771    what "auto" is translating to.  */
772
773 static void
774 show_condition_evaluation_mode (struct ui_file *file, int from_tty,
775                                 struct cmd_list_element *c, const char *value)
776 {
777   if (condition_evaluation_mode == condition_evaluation_auto)
778     fprintf_filtered (file,
779                       _("Breakpoint condition evaluation "
780                         "mode is %s (currently %s).\n"),
781                       value,
782                       breakpoint_condition_evaluation_mode ());
783   else
784     fprintf_filtered (file, _("Breakpoint condition evaluation mode is %s.\n"),
785                       value);
786 }
787
788 /* A comparison function for bp_location AP and BP that is used by
789    bsearch.  This comparison function only cares about addresses, unlike
790    the more general bp_locations_compare function.  */
791
792 static int
793 bp_locations_compare_addrs (const void *ap, const void *bp)
794 {
795   const struct bp_location *a = *(const struct bp_location **) ap;
796   const struct bp_location *b = *(const struct bp_location **) bp;
797
798   if (a->address == b->address)
799     return 0;
800   else
801     return ((a->address > b->address) - (a->address < b->address));
802 }
803
804 /* Helper function to skip all bp_locations with addresses
805    less than ADDRESS.  It returns the first bp_location that
806    is greater than or equal to ADDRESS.  If none is found, just
807    return NULL.  */
808
809 static struct bp_location **
810 get_first_locp_gte_addr (CORE_ADDR address)
811 {
812   struct bp_location dummy_loc;
813   struct bp_location *dummy_locp = &dummy_loc;
814   struct bp_location **locp_found = NULL;
815
816   /* Initialize the dummy location's address field.  */
817   dummy_loc.address = address;
818
819   /* Find a close match to the first location at ADDRESS.  */
820   locp_found = ((struct bp_location **)
821                 bsearch (&dummy_locp, bp_locations, bp_locations_count,
822                          sizeof (struct bp_location **),
823                          bp_locations_compare_addrs));
824
825   /* Nothing was found, nothing left to do.  */
826   if (locp_found == NULL)
827     return NULL;
828
829   /* We may have found a location that is at ADDRESS but is not the first in the
830      location's list.  Go backwards (if possible) and locate the first one.  */
831   while ((locp_found - 1) >= bp_locations
832          && (*(locp_found - 1))->address == address)
833     locp_found--;
834
835   return locp_found;
836 }
837
838 void
839 set_breakpoint_condition (struct breakpoint *b, const char *exp,
840                           int from_tty)
841 {
842   xfree (b->cond_string);
843   b->cond_string = NULL;
844
845   if (is_watchpoint (b))
846     {
847       struct watchpoint *w = (struct watchpoint *) b;
848
849       w->cond_exp.reset ();
850     }
851   else
852     {
853       struct bp_location *loc;
854
855       for (loc = b->loc; loc; loc = loc->next)
856         {
857           loc->cond.reset ();
858
859           /* No need to free the condition agent expression
860              bytecode (if we have one).  We will handle this
861              when we go through update_global_location_list.  */
862         }
863     }
864
865   if (*exp == 0)
866     {
867       if (from_tty)
868         printf_filtered (_("Breakpoint %d now unconditional.\n"), b->number);
869     }
870   else
871     {
872       const char *arg = exp;
873
874       /* I don't know if it matters whether this is the string the user
875          typed in or the decompiled expression.  */
876       b->cond_string = xstrdup (arg);
877       b->condition_not_parsed = 0;
878
879       if (is_watchpoint (b))
880         {
881           struct watchpoint *w = (struct watchpoint *) b;
882
883           innermost_block_tracker tracker;
884           arg = exp;
885           w->cond_exp = parse_exp_1 (&arg, 0, 0, 0, &tracker);
886           if (*arg)
887             error (_("Junk at end of expression"));
888           w->cond_exp_valid_block = tracker.block ();
889         }
890       else
891         {
892           struct bp_location *loc;
893
894           for (loc = b->loc; loc; loc = loc->next)
895             {
896               arg = exp;
897               loc->cond =
898                 parse_exp_1 (&arg, loc->address,
899                              block_for_pc (loc->address), 0);
900               if (*arg)
901                 error (_("Junk at end of expression"));
902             }
903         }
904     }
905   mark_breakpoint_modified (b);
906
907   gdb::observers::breakpoint_modified.notify (b);
908 }
909
910 /* Completion for the "condition" command.  */
911
912 static void
913 condition_completer (struct cmd_list_element *cmd,
914                      completion_tracker &tracker,
915                      const char *text, const char *word)
916 {
917   const char *space;
918
919   text = skip_spaces (text);
920   space = skip_to_space (text);
921   if (*space == '\0')
922     {
923       int len;
924       struct breakpoint *b;
925
926       if (text[0] == '$')
927         {
928           /* We don't support completion of history indices.  */
929           if (!isdigit (text[1]))
930             complete_internalvar (tracker, &text[1]);
931           return;
932         }
933
934       /* We're completing the breakpoint number.  */
935       len = strlen (text);
936
937       ALL_BREAKPOINTS (b)
938         {
939           char number[50];
940
941           xsnprintf (number, sizeof (number), "%d", b->number);
942
943           if (strncmp (number, text, len) == 0)
944             {
945               gdb::unique_xmalloc_ptr<char> copy (xstrdup (number));
946               tracker.add_completion (std::move (copy));
947             }
948         }
949
950       return;
951     }
952
953   /* We're completing the expression part.  */
954   text = skip_spaces (space);
955   expression_completer (cmd, tracker, text, word);
956 }
957
958 /* condition N EXP -- set break condition of breakpoint N to EXP.  */
959
960 static void
961 condition_command (const char *arg, int from_tty)
962 {
963   struct breakpoint *b;
964   const char *p;
965   int bnum;
966
967   if (arg == 0)
968     error_no_arg (_("breakpoint number"));
969
970   p = arg;
971   bnum = get_number (&p);
972   if (bnum == 0)
973     error (_("Bad breakpoint argument: '%s'"), arg);
974
975   ALL_BREAKPOINTS (b)
976     if (b->number == bnum)
977       {
978         /* Check if this breakpoint has a "stop" method implemented in an
979            extension language.  This method and conditions entered into GDB
980            from the CLI are mutually exclusive.  */
981         const struct extension_language_defn *extlang
982           = get_breakpoint_cond_ext_lang (b, EXT_LANG_NONE);
983
984         if (extlang != NULL)
985           {
986             error (_("Only one stop condition allowed.  There is currently"
987                      " a %s stop condition defined for this breakpoint."),
988                    ext_lang_capitalized_name (extlang));
989           }
990         set_breakpoint_condition (b, p, from_tty);
991
992         if (is_breakpoint (b))
993           update_global_location_list (UGLL_MAY_INSERT);
994
995         return;
996       }
997
998   error (_("No breakpoint number %d."), bnum);
999 }
1000
1001 /* Check that COMMAND do not contain commands that are suitable
1002    only for tracepoints and not suitable for ordinary breakpoints.
1003    Throw if any such commands is found.  */
1004
1005 static void
1006 check_no_tracepoint_commands (struct command_line *commands)
1007 {
1008   struct command_line *c;
1009
1010   for (c = commands; c; c = c->next)
1011     {
1012       if (c->control_type == while_stepping_control)
1013         error (_("The 'while-stepping' command can "
1014                  "only be used for tracepoints"));
1015
1016       check_no_tracepoint_commands (c->body_list_0.get ());
1017       check_no_tracepoint_commands (c->body_list_1.get ());
1018
1019       /* Not that command parsing removes leading whitespace and comment
1020          lines and also empty lines.  So, we only need to check for
1021          command directly.  */
1022       if (strstr (c->line, "collect ") == c->line)
1023         error (_("The 'collect' command can only be used for tracepoints"));
1024
1025       if (strstr (c->line, "teval ") == c->line)
1026         error (_("The 'teval' command can only be used for tracepoints"));
1027     }
1028 }
1029
1030 struct longjmp_breakpoint : public breakpoint
1031 {
1032   ~longjmp_breakpoint () override;
1033 };
1034
1035 /* Encapsulate tests for different types of tracepoints.  */
1036
1037 static bool
1038 is_tracepoint_type (bptype type)
1039 {
1040   return (type == bp_tracepoint
1041           || type == bp_fast_tracepoint
1042           || type == bp_static_tracepoint);
1043 }
1044
1045 static bool
1046 is_longjmp_type (bptype type)
1047 {
1048   return type == bp_longjmp || type == bp_exception;
1049 }
1050
1051 int
1052 is_tracepoint (const struct breakpoint *b)
1053 {
1054   return is_tracepoint_type (b->type);
1055 }
1056
1057 /* Factory function to create an appropriate instance of breakpoint given
1058    TYPE.  */
1059
1060 static std::unique_ptr<breakpoint>
1061 new_breakpoint_from_type (bptype type)
1062 {
1063   breakpoint *b;
1064
1065   if (is_tracepoint_type (type))
1066     b = new tracepoint ();
1067   else if (is_longjmp_type (type))
1068     b = new longjmp_breakpoint ();
1069   else
1070     b = new breakpoint ();
1071
1072   return std::unique_ptr<breakpoint> (b);
1073 }
1074
1075 /* A helper function that validates that COMMANDS are valid for a
1076    breakpoint.  This function will throw an exception if a problem is
1077    found.  */
1078
1079 static void
1080 validate_commands_for_breakpoint (struct breakpoint *b,
1081                                   struct command_line *commands)
1082 {
1083   if (is_tracepoint (b))
1084     {
1085       struct tracepoint *t = (struct tracepoint *) b;
1086       struct command_line *c;
1087       struct command_line *while_stepping = 0;
1088
1089       /* Reset the while-stepping step count.  The previous commands
1090          might have included a while-stepping action, while the new
1091          ones might not.  */
1092       t->step_count = 0;
1093
1094       /* We need to verify that each top-level element of commands is
1095          valid for tracepoints, that there's at most one
1096          while-stepping element, and that the while-stepping's body
1097          has valid tracing commands excluding nested while-stepping.
1098          We also need to validate the tracepoint action line in the
1099          context of the tracepoint --- validate_actionline actually
1100          has side effects, like setting the tracepoint's
1101          while-stepping STEP_COUNT, in addition to checking if the
1102          collect/teval actions parse and make sense in the
1103          tracepoint's context.  */
1104       for (c = commands; c; c = c->next)
1105         {
1106           if (c->control_type == while_stepping_control)
1107             {
1108               if (b->type == bp_fast_tracepoint)
1109                 error (_("The 'while-stepping' command "
1110                          "cannot be used for fast tracepoint"));
1111               else if (b->type == bp_static_tracepoint)
1112                 error (_("The 'while-stepping' command "
1113                          "cannot be used for static tracepoint"));
1114
1115               if (while_stepping)
1116                 error (_("The 'while-stepping' command "
1117                          "can be used only once"));
1118               else
1119                 while_stepping = c;
1120             }
1121
1122           validate_actionline (c->line, b);
1123         }
1124       if (while_stepping)
1125         {
1126           struct command_line *c2;
1127
1128           gdb_assert (while_stepping->body_list_1 == nullptr);
1129           c2 = while_stepping->body_list_0.get ();
1130           for (; c2; c2 = c2->next)
1131             {
1132               if (c2->control_type == while_stepping_control)
1133                 error (_("The 'while-stepping' command cannot be nested"));
1134             }
1135         }
1136     }
1137   else
1138     {
1139       check_no_tracepoint_commands (commands);
1140     }
1141 }
1142
1143 /* Return a vector of all the static tracepoints set at ADDR.  The
1144    caller is responsible for releasing the vector.  */
1145
1146 std::vector<breakpoint *>
1147 static_tracepoints_here (CORE_ADDR addr)
1148 {
1149   struct breakpoint *b;
1150   std::vector<breakpoint *> found;
1151   struct bp_location *loc;
1152
1153   ALL_BREAKPOINTS (b)
1154     if (b->type == bp_static_tracepoint)
1155       {
1156         for (loc = b->loc; loc; loc = loc->next)
1157           if (loc->address == addr)
1158             found.push_back (b);
1159       }
1160
1161   return found;
1162 }
1163
1164 /* Set the command list of B to COMMANDS.  If breakpoint is tracepoint,
1165    validate that only allowed commands are included.  */
1166
1167 void
1168 breakpoint_set_commands (struct breakpoint *b, 
1169                          counted_command_line &&commands)
1170 {
1171   validate_commands_for_breakpoint (b, commands.get ());
1172
1173   b->commands = std::move (commands);
1174   gdb::observers::breakpoint_modified.notify (b);
1175 }
1176
1177 /* Set the internal `silent' flag on the breakpoint.  Note that this
1178    is not the same as the "silent" that may appear in the breakpoint's
1179    commands.  */
1180
1181 void
1182 breakpoint_set_silent (struct breakpoint *b, int silent)
1183 {
1184   int old_silent = b->silent;
1185
1186   b->silent = silent;
1187   if (old_silent != silent)
1188     gdb::observers::breakpoint_modified.notify (b);
1189 }
1190
1191 /* Set the thread for this breakpoint.  If THREAD is -1, make the
1192    breakpoint work for any thread.  */
1193
1194 void
1195 breakpoint_set_thread (struct breakpoint *b, int thread)
1196 {
1197   int old_thread = b->thread;
1198
1199   b->thread = thread;
1200   if (old_thread != thread)
1201     gdb::observers::breakpoint_modified.notify (b);
1202 }
1203
1204 /* Set the task for this breakpoint.  If TASK is 0, make the
1205    breakpoint work for any task.  */
1206
1207 void
1208 breakpoint_set_task (struct breakpoint *b, int task)
1209 {
1210   int old_task = b->task;
1211
1212   b->task = task;
1213   if (old_task != task)
1214     gdb::observers::breakpoint_modified.notify (b);
1215 }
1216
1217 static void
1218 commands_command_1 (const char *arg, int from_tty,
1219                     struct command_line *control)
1220 {
1221   counted_command_line cmd;
1222   /* cmd_read will be true once we have read cmd.  Note that cmd might still be
1223      NULL after the call to read_command_lines if the user provides an empty
1224      list of command by just typing "end".  */
1225   bool cmd_read = false;
1226
1227   std::string new_arg;
1228
1229   if (arg == NULL || !*arg)
1230     {
1231       if (breakpoint_count - prev_breakpoint_count > 1)
1232         new_arg = string_printf ("%d-%d", prev_breakpoint_count + 1,
1233                                  breakpoint_count);
1234       else if (breakpoint_count > 0)
1235         new_arg = string_printf ("%d", breakpoint_count);
1236       arg = new_arg.c_str ();
1237     }
1238
1239   map_breakpoint_numbers
1240     (arg, [&] (breakpoint *b)
1241      {
1242        if (!cmd_read)
1243          {
1244            gdb_assert (cmd == NULL);
1245            if (control != NULL)
1246              cmd = control->body_list_0;
1247            else
1248              {
1249                std::string str
1250                  = string_printf (_("Type commands for breakpoint(s) "
1251                                     "%s, one per line."),
1252                                   arg);
1253
1254                auto do_validate = [=] (const char *line)
1255                                   {
1256                                     validate_actionline (line, b);
1257                                   };
1258                gdb::function_view<void (const char *)> validator;
1259                if (is_tracepoint (b))
1260                  validator = do_validate;
1261
1262                cmd = read_command_lines (str.c_str (), from_tty, 1, validator);
1263              }
1264            cmd_read = true;
1265          }
1266
1267        /* If a breakpoint was on the list more than once, we don't need to
1268           do anything.  */
1269        if (b->commands != cmd)
1270          {
1271            validate_commands_for_breakpoint (b, cmd.get ());
1272            b->commands = cmd;
1273            gdb::observers::breakpoint_modified.notify (b);
1274          }
1275      });
1276 }
1277
1278 static void
1279 commands_command (const char *arg, int from_tty)
1280 {
1281   commands_command_1 (arg, from_tty, NULL);
1282 }
1283
1284 /* Like commands_command, but instead of reading the commands from
1285    input stream, takes them from an already parsed command structure.
1286
1287    This is used by cli-script.c to DTRT with breakpoint commands
1288    that are part of if and while bodies.  */
1289 enum command_control_type
1290 commands_from_control_command (const char *arg, struct command_line *cmd)
1291 {
1292   commands_command_1 (arg, 0, cmd);
1293   return simple_control;
1294 }
1295
1296 /* Return non-zero if BL->TARGET_INFO contains valid information.  */
1297
1298 static int
1299 bp_location_has_shadow (struct bp_location *bl)
1300 {
1301   if (bl->loc_type != bp_loc_software_breakpoint)
1302     return 0;
1303   if (!bl->inserted)
1304     return 0;
1305   if (bl->target_info.shadow_len == 0)
1306     /* BL isn't valid, or doesn't shadow memory.  */
1307     return 0;
1308   return 1;
1309 }
1310
1311 /* Update BUF, which is LEN bytes read from the target address
1312    MEMADDR, by replacing a memory breakpoint with its shadowed
1313    contents.
1314
1315    If READBUF is not NULL, this buffer must not overlap with the of
1316    the breakpoint location's shadow_contents buffer.  Otherwise, a
1317    failed assertion internal error will be raised.  */
1318
1319 static void
1320 one_breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1321                             const gdb_byte *writebuf_org,
1322                             ULONGEST memaddr, LONGEST len,
1323                             struct bp_target_info *target_info,
1324                             struct gdbarch *gdbarch)
1325 {
1326   /* Now do full processing of the found relevant range of elements.  */
1327   CORE_ADDR bp_addr = 0;
1328   int bp_size = 0;
1329   int bptoffset = 0;
1330
1331   if (!breakpoint_address_match (target_info->placed_address_space, 0,
1332                                  current_program_space->aspace, 0))
1333     {
1334       /* The breakpoint is inserted in a different address space.  */
1335       return;
1336     }
1337
1338   /* Addresses and length of the part of the breakpoint that
1339      we need to copy.  */
1340   bp_addr = target_info->placed_address;
1341   bp_size = target_info->shadow_len;
1342
1343   if (bp_addr + bp_size <= memaddr)
1344     {
1345       /* The breakpoint is entirely before the chunk of memory we are
1346          reading.  */
1347       return;
1348     }
1349
1350   if (bp_addr >= memaddr + len)
1351     {
1352       /* The breakpoint is entirely after the chunk of memory we are
1353          reading.  */
1354       return;
1355     }
1356
1357   /* Offset within shadow_contents.  */
1358   if (bp_addr < memaddr)
1359     {
1360       /* Only copy the second part of the breakpoint.  */
1361       bp_size -= memaddr - bp_addr;
1362       bptoffset = memaddr - bp_addr;
1363       bp_addr = memaddr;
1364     }
1365
1366   if (bp_addr + bp_size > memaddr + len)
1367     {
1368       /* Only copy the first part of the breakpoint.  */
1369       bp_size -= (bp_addr + bp_size) - (memaddr + len);
1370     }
1371
1372   if (readbuf != NULL)
1373     {
1374       /* Verify that the readbuf buffer does not overlap with the
1375          shadow_contents buffer.  */
1376       gdb_assert (target_info->shadow_contents >= readbuf + len
1377                   || readbuf >= (target_info->shadow_contents
1378                                  + target_info->shadow_len));
1379
1380       /* Update the read buffer with this inserted breakpoint's
1381          shadow.  */
1382       memcpy (readbuf + bp_addr - memaddr,
1383               target_info->shadow_contents + bptoffset, bp_size);
1384     }
1385   else
1386     {
1387       const unsigned char *bp;
1388       CORE_ADDR addr = target_info->reqstd_address;
1389       int placed_size;
1390
1391       /* Update the shadow with what we want to write to memory.  */
1392       memcpy (target_info->shadow_contents + bptoffset,
1393               writebuf_org + bp_addr - memaddr, bp_size);
1394
1395       /* Determine appropriate breakpoint contents and size for this
1396          address.  */
1397       bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &placed_size);
1398
1399       /* Update the final write buffer with this inserted
1400          breakpoint's INSN.  */
1401       memcpy (writebuf + bp_addr - memaddr, bp + bptoffset, bp_size);
1402     }
1403 }
1404
1405 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1406    by replacing any memory breakpoints with their shadowed contents.
1407
1408    If READBUF is not NULL, this buffer must not overlap with any of
1409    the breakpoint location's shadow_contents buffers.  Otherwise,
1410    a failed assertion internal error will be raised.
1411
1412    The range of shadowed area by each bp_location is:
1413      bl->address - bp_locations_placed_address_before_address_max
1414      up to bl->address + bp_locations_shadow_len_after_address_max
1415    The range we were requested to resolve shadows for is:
1416      memaddr ... memaddr + len
1417    Thus the safe cutoff boundaries for performance optimization are
1418      memaddr + len <= (bl->address
1419                        - bp_locations_placed_address_before_address_max)
1420    and:
1421      bl->address + bp_locations_shadow_len_after_address_max <= memaddr  */
1422
1423 void
1424 breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1425                         const gdb_byte *writebuf_org,
1426                         ULONGEST memaddr, LONGEST len)
1427 {
1428   /* Left boundary, right boundary and median element of our binary
1429      search.  */
1430   unsigned bc_l, bc_r, bc;
1431
1432   /* Find BC_L which is a leftmost element which may affect BUF
1433      content.  It is safe to report lower value but a failure to
1434      report higher one.  */
1435
1436   bc_l = 0;
1437   bc_r = bp_locations_count;
1438   while (bc_l + 1 < bc_r)
1439     {
1440       struct bp_location *bl;
1441
1442       bc = (bc_l + bc_r) / 2;
1443       bl = bp_locations[bc];
1444
1445       /* Check first BL->ADDRESS will not overflow due to the added
1446          constant.  Then advance the left boundary only if we are sure
1447          the BC element can in no way affect the BUF content (MEMADDR
1448          to MEMADDR + LEN range).
1449
1450          Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1451          offset so that we cannot miss a breakpoint with its shadow
1452          range tail still reaching MEMADDR.  */
1453
1454       if ((bl->address + bp_locations_shadow_len_after_address_max
1455            >= bl->address)
1456           && (bl->address + bp_locations_shadow_len_after_address_max
1457               <= memaddr))
1458         bc_l = bc;
1459       else
1460         bc_r = bc;
1461     }
1462
1463   /* Due to the binary search above, we need to make sure we pick the
1464      first location that's at BC_L's address.  E.g., if there are
1465      multiple locations at the same address, BC_L may end up pointing
1466      at a duplicate location, and miss the "master"/"inserted"
1467      location.  Say, given locations L1, L2 and L3 at addresses A and
1468      B:
1469
1470       L1@A, L2@A, L3@B, ...
1471
1472      BC_L could end up pointing at location L2, while the "master"
1473      location could be L1.  Since the `loc->inserted' flag is only set
1474      on "master" locations, we'd forget to restore the shadow of L1
1475      and L2.  */
1476   while (bc_l > 0
1477          && bp_locations[bc_l]->address == bp_locations[bc_l - 1]->address)
1478     bc_l--;
1479
1480   /* Now do full processing of the found relevant range of elements.  */
1481
1482   for (bc = bc_l; bc < bp_locations_count; bc++)
1483   {
1484     struct bp_location *bl = bp_locations[bc];
1485
1486     /* bp_location array has BL->OWNER always non-NULL.  */
1487     if (bl->owner->type == bp_none)
1488       warning (_("reading through apparently deleted breakpoint #%d?"),
1489                bl->owner->number);
1490
1491     /* Performance optimization: any further element can no longer affect BUF
1492        content.  */
1493
1494     if (bl->address >= bp_locations_placed_address_before_address_max
1495         && memaddr + len <= (bl->address
1496                              - bp_locations_placed_address_before_address_max))
1497       break;
1498
1499     if (!bp_location_has_shadow (bl))
1500       continue;
1501
1502     one_breakpoint_xfer_memory (readbuf, writebuf, writebuf_org,
1503                                 memaddr, len, &bl->target_info, bl->gdbarch);
1504   }
1505 }
1506
1507 \f
1508
1509 /* Return true if BPT is either a software breakpoint or a hardware
1510    breakpoint.  */
1511
1512 int
1513 is_breakpoint (const struct breakpoint *bpt)
1514 {
1515   return (bpt->type == bp_breakpoint
1516           || bpt->type == bp_hardware_breakpoint
1517           || bpt->type == bp_dprintf);
1518 }
1519
1520 /* Return true if BPT is of any hardware watchpoint kind.  */
1521
1522 static int
1523 is_hardware_watchpoint (const struct breakpoint *bpt)
1524 {
1525   return (bpt->type == bp_hardware_watchpoint
1526           || bpt->type == bp_read_watchpoint
1527           || bpt->type == bp_access_watchpoint);
1528 }
1529
1530 /* Return true if BPT is of any watchpoint kind, hardware or
1531    software.  */
1532
1533 int
1534 is_watchpoint (const struct breakpoint *bpt)
1535 {
1536   return (is_hardware_watchpoint (bpt)
1537           || bpt->type == bp_watchpoint);
1538 }
1539
1540 /* Returns true if the current thread and its running state are safe
1541    to evaluate or update watchpoint B.  Watchpoints on local
1542    expressions need to be evaluated in the context of the thread that
1543    was current when the watchpoint was created, and, that thread needs
1544    to be stopped to be able to select the correct frame context.
1545    Watchpoints on global expressions can be evaluated on any thread,
1546    and in any state.  It is presently left to the target allowing
1547    memory accesses when threads are running.  */
1548
1549 static int
1550 watchpoint_in_thread_scope (struct watchpoint *b)
1551 {
1552   return (b->pspace == current_program_space
1553           && (b->watchpoint_thread == null_ptid
1554               || (inferior_ptid == b->watchpoint_thread
1555                   && !inferior_thread ()->executing)));
1556 }
1557
1558 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1559    associated bp_watchpoint_scope breakpoint.  */
1560
1561 static void
1562 watchpoint_del_at_next_stop (struct watchpoint *w)
1563 {
1564   if (w->related_breakpoint != w)
1565     {
1566       gdb_assert (w->related_breakpoint->type == bp_watchpoint_scope);
1567       gdb_assert (w->related_breakpoint->related_breakpoint == w);
1568       w->related_breakpoint->disposition = disp_del_at_next_stop;
1569       w->related_breakpoint->related_breakpoint = w->related_breakpoint;
1570       w->related_breakpoint = w;
1571     }
1572   w->disposition = disp_del_at_next_stop;
1573 }
1574
1575 /* Extract a bitfield value from value VAL using the bit parameters contained in
1576    watchpoint W.  */
1577
1578 static struct value *
1579 extract_bitfield_from_watchpoint_value (struct watchpoint *w, struct value *val)
1580 {
1581   struct value *bit_val;
1582
1583   if (val == NULL)
1584     return NULL;
1585
1586   bit_val = allocate_value (value_type (val));
1587
1588   unpack_value_bitfield (bit_val,
1589                          w->val_bitpos,
1590                          w->val_bitsize,
1591                          value_contents_for_printing (val),
1592                          value_offset (val),
1593                          val);
1594
1595   return bit_val;
1596 }
1597
1598 /* Allocate a dummy location and add it to B, which must be a software
1599    watchpoint.  This is required because even if a software watchpoint
1600    is not watching any memory, bpstat_stop_status requires a location
1601    to be able to report stops.  */
1602
1603 static void
1604 software_watchpoint_add_no_memory_location (struct breakpoint *b,
1605                                             struct program_space *pspace)
1606 {
1607   gdb_assert (b->type == bp_watchpoint && b->loc == NULL);
1608
1609   b->loc = allocate_bp_location (b);
1610   b->loc->pspace = pspace;
1611   b->loc->address = -1;
1612   b->loc->length = -1;
1613 }
1614
1615 /* Returns true if B is a software watchpoint that is not watching any
1616    memory (e.g., "watch $pc").  */
1617
1618 static int
1619 is_no_memory_software_watchpoint (struct breakpoint *b)
1620 {
1621   return (b->type == bp_watchpoint
1622           && b->loc != NULL
1623           && b->loc->next == NULL
1624           && b->loc->address == -1
1625           && b->loc->length == -1);
1626 }
1627
1628 /* Assuming that B is a watchpoint:
1629    - Reparse watchpoint expression, if REPARSE is non-zero
1630    - Evaluate expression and store the result in B->val
1631    - Evaluate the condition if there is one, and store the result
1632      in b->loc->cond.
1633    - Update the list of values that must be watched in B->loc.
1634
1635    If the watchpoint disposition is disp_del_at_next_stop, then do
1636    nothing.  If this is local watchpoint that is out of scope, delete
1637    it.
1638
1639    Even with `set breakpoint always-inserted on' the watchpoints are
1640    removed + inserted on each stop here.  Normal breakpoints must
1641    never be removed because they might be missed by a running thread
1642    when debugging in non-stop mode.  On the other hand, hardware
1643    watchpoints (is_hardware_watchpoint; processed here) are specific
1644    to each LWP since they are stored in each LWP's hardware debug
1645    registers.  Therefore, such LWP must be stopped first in order to
1646    be able to modify its hardware watchpoints.
1647
1648    Hardware watchpoints must be reset exactly once after being
1649    presented to the user.  It cannot be done sooner, because it would
1650    reset the data used to present the watchpoint hit to the user.  And
1651    it must not be done later because it could display the same single
1652    watchpoint hit during multiple GDB stops.  Note that the latter is
1653    relevant only to the hardware watchpoint types bp_read_watchpoint
1654    and bp_access_watchpoint.  False hit by bp_hardware_watchpoint is
1655    not user-visible - its hit is suppressed if the memory content has
1656    not changed.
1657
1658    The following constraints influence the location where we can reset
1659    hardware watchpoints:
1660
1661    * target_stopped_by_watchpoint and target_stopped_data_address are
1662      called several times when GDB stops.
1663
1664    [linux] 
1665    * Multiple hardware watchpoints can be hit at the same time,
1666      causing GDB to stop.  GDB only presents one hardware watchpoint
1667      hit at a time as the reason for stopping, and all the other hits
1668      are presented later, one after the other, each time the user
1669      requests the execution to be resumed.  Execution is not resumed
1670      for the threads still having pending hit event stored in
1671      LWP_INFO->STATUS.  While the watchpoint is already removed from
1672      the inferior on the first stop the thread hit event is kept being
1673      reported from its cached value by linux_nat_stopped_data_address
1674      until the real thread resume happens after the watchpoint gets
1675      presented and thus its LWP_INFO->STATUS gets reset.
1676
1677    Therefore the hardware watchpoint hit can get safely reset on the
1678    watchpoint removal from inferior.  */
1679
1680 static void
1681 update_watchpoint (struct watchpoint *b, int reparse)
1682 {
1683   int within_current_scope;
1684   struct frame_id saved_frame_id;
1685   int frame_saved;
1686
1687   /* If this is a local watchpoint, we only want to check if the
1688      watchpoint frame is in scope if the current thread is the thread
1689      that was used to create the watchpoint.  */
1690   if (!watchpoint_in_thread_scope (b))
1691     return;
1692
1693   if (b->disposition == disp_del_at_next_stop)
1694     return;
1695  
1696   frame_saved = 0;
1697
1698   /* Determine if the watchpoint is within scope.  */
1699   if (b->exp_valid_block == NULL)
1700     within_current_scope = 1;
1701   else
1702     {
1703       struct frame_info *fi = get_current_frame ();
1704       struct gdbarch *frame_arch = get_frame_arch (fi);
1705       CORE_ADDR frame_pc = get_frame_pc (fi);
1706
1707       /* If we're at a point where the stack has been destroyed
1708          (e.g. in a function epilogue), unwinding may not work
1709          properly. Do not attempt to recreate locations at this
1710          point.  See similar comments in watchpoint_check.  */
1711       if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
1712         return;
1713
1714       /* Save the current frame's ID so we can restore it after
1715          evaluating the watchpoint expression on its own frame.  */
1716       /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1717          took a frame parameter, so that we didn't have to change the
1718          selected frame.  */
1719       frame_saved = 1;
1720       saved_frame_id = get_frame_id (get_selected_frame (NULL));
1721
1722       fi = frame_find_by_id (b->watchpoint_frame);
1723       within_current_scope = (fi != NULL);
1724       if (within_current_scope)
1725         select_frame (fi);
1726     }
1727
1728   /* We don't free locations.  They are stored in the bp_location array
1729      and update_global_location_list will eventually delete them and
1730      remove breakpoints if needed.  */
1731   b->loc = NULL;
1732
1733   if (within_current_scope && reparse)
1734     {
1735       const char *s;
1736
1737       b->exp.reset ();
1738       s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1739       b->exp = parse_exp_1 (&s, 0, b->exp_valid_block, 0);
1740       /* If the meaning of expression itself changed, the old value is
1741          no longer relevant.  We don't want to report a watchpoint hit
1742          to the user when the old value and the new value may actually
1743          be completely different objects.  */
1744       b->val = NULL;
1745       b->val_valid = 0;
1746
1747       /* Note that unlike with breakpoints, the watchpoint's condition
1748          expression is stored in the breakpoint object, not in the
1749          locations (re)created below.  */
1750       if (b->cond_string != NULL)
1751         {
1752           b->cond_exp.reset ();
1753
1754           s = b->cond_string;
1755           b->cond_exp = parse_exp_1 (&s, 0, b->cond_exp_valid_block, 0);
1756         }
1757     }
1758
1759   /* If we failed to parse the expression, for example because
1760      it refers to a global variable in a not-yet-loaded shared library,
1761      don't try to insert watchpoint.  We don't automatically delete
1762      such watchpoint, though, since failure to parse expression
1763      is different from out-of-scope watchpoint.  */
1764   if (!target_has_execution)
1765     {
1766       /* Without execution, memory can't change.  No use to try and
1767          set watchpoint locations.  The watchpoint will be reset when
1768          the target gains execution, through breakpoint_re_set.  */
1769       if (!can_use_hw_watchpoints)
1770         {
1771           if (b->ops->works_in_software_mode (b))
1772             b->type = bp_watchpoint;
1773           else
1774             error (_("Can't set read/access watchpoint when "
1775                      "hardware watchpoints are disabled."));
1776         }
1777     }
1778   else if (within_current_scope && b->exp)
1779     {
1780       int pc = 0;
1781       std::vector<value_ref_ptr> val_chain;
1782       struct value *v, *result;
1783       struct program_space *frame_pspace;
1784
1785       fetch_subexp_value (b->exp.get (), &pc, &v, &result, &val_chain, 0);
1786
1787       /* Avoid setting b->val if it's already set.  The meaning of
1788          b->val is 'the last value' user saw, and we should update
1789          it only if we reported that last value to user.  As it
1790          happens, the code that reports it updates b->val directly.
1791          We don't keep track of the memory value for masked
1792          watchpoints.  */
1793       if (!b->val_valid && !is_masked_watchpoint (b))
1794         {
1795           if (b->val_bitsize != 0)
1796             v = extract_bitfield_from_watchpoint_value (b, v);
1797           b->val = release_value (v);
1798           b->val_valid = 1;
1799         }
1800
1801       frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1802
1803       /* Look at each value on the value chain.  */
1804       gdb_assert (!val_chain.empty ());
1805       for (const value_ref_ptr &iter : val_chain)
1806         {
1807           v = iter.get ();
1808
1809           /* If it's a memory location, and GDB actually needed
1810              its contents to evaluate the expression, then we
1811              must watch it.  If the first value returned is
1812              still lazy, that means an error occurred reading it;
1813              watch it anyway in case it becomes readable.  */
1814           if (VALUE_LVAL (v) == lval_memory
1815               && (v == val_chain[0] || ! value_lazy (v)))
1816             {
1817               struct type *vtype = check_typedef (value_type (v));
1818
1819               /* We only watch structs and arrays if user asked
1820                  for it explicitly, never if they just happen to
1821                  appear in the middle of some value chain.  */
1822               if (v == result
1823                   || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1824                       && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1825                 {
1826                   CORE_ADDR addr;
1827                   enum target_hw_bp_type type;
1828                   struct bp_location *loc, **tmp;
1829                   int bitpos = 0, bitsize = 0;
1830
1831                   if (value_bitsize (v) != 0)
1832                     {
1833                       /* Extract the bit parameters out from the bitfield
1834                          sub-expression.  */
1835                       bitpos = value_bitpos (v);
1836                       bitsize = value_bitsize (v);
1837                     }
1838                   else if (v == result && b->val_bitsize != 0)
1839                     {
1840                      /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1841                         lvalue whose bit parameters are saved in the fields
1842                         VAL_BITPOS and VAL_BITSIZE.  */
1843                       bitpos = b->val_bitpos;
1844                       bitsize = b->val_bitsize;
1845                     }
1846
1847                   addr = value_address (v);
1848                   if (bitsize != 0)
1849                     {
1850                       /* Skip the bytes that don't contain the bitfield.  */
1851                       addr += bitpos / 8;
1852                     }
1853
1854                   type = hw_write;
1855                   if (b->type == bp_read_watchpoint)
1856                     type = hw_read;
1857                   else if (b->type == bp_access_watchpoint)
1858                     type = hw_access;
1859
1860                   loc = allocate_bp_location (b);
1861                   for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
1862                     ;
1863                   *tmp = loc;
1864                   loc->gdbarch = get_type_arch (value_type (v));
1865
1866                   loc->pspace = frame_pspace;
1867                   loc->address = address_significant (loc->gdbarch, addr);
1868
1869                   if (bitsize != 0)
1870                     {
1871                       /* Just cover the bytes that make up the bitfield.  */
1872                       loc->length = ((bitpos % 8) + bitsize + 7) / 8;
1873                     }
1874                   else
1875                     loc->length = TYPE_LENGTH (value_type (v));
1876
1877                   loc->watchpoint_type = type;
1878                 }
1879             }
1880         }
1881
1882       /* Change the type of breakpoint between hardware assisted or
1883          an ordinary watchpoint depending on the hardware support
1884          and free hardware slots.  REPARSE is set when the inferior
1885          is started.  */
1886       if (reparse)
1887         {
1888           int reg_cnt;
1889           enum bp_loc_type loc_type;
1890           struct bp_location *bl;
1891
1892           reg_cnt = can_use_hardware_watchpoint (val_chain);
1893
1894           if (reg_cnt)
1895             {
1896               int i, target_resources_ok, other_type_used;
1897               enum bptype type;
1898
1899               /* Use an exact watchpoint when there's only one memory region to be
1900                  watched, and only one debug register is needed to watch it.  */
1901               b->exact = target_exact_watchpoints && reg_cnt == 1;
1902
1903               /* We need to determine how many resources are already
1904                  used for all other hardware watchpoints plus this one
1905                  to see if we still have enough resources to also fit
1906                  this watchpoint in as well.  */
1907
1908               /* If this is a software watchpoint, we try to turn it
1909                  to a hardware one -- count resources as if B was of
1910                  hardware watchpoint type.  */
1911               type = b->type;
1912               if (type == bp_watchpoint)
1913                 type = bp_hardware_watchpoint;
1914
1915               /* This watchpoint may or may not have been placed on
1916                  the list yet at this point (it won't be in the list
1917                  if we're trying to create it for the first time,
1918                  through watch_command), so always account for it
1919                  manually.  */
1920
1921               /* Count resources used by all watchpoints except B.  */
1922               i = hw_watchpoint_used_count_others (b, type, &other_type_used);
1923
1924               /* Add in the resources needed for B.  */
1925               i += hw_watchpoint_use_count (b);
1926
1927               target_resources_ok
1928                 = target_can_use_hardware_watchpoint (type, i, other_type_used);
1929               if (target_resources_ok <= 0)
1930                 {
1931                   int sw_mode = b->ops->works_in_software_mode (b);
1932
1933                   if (target_resources_ok == 0 && !sw_mode)
1934                     error (_("Target does not support this type of "
1935                              "hardware watchpoint."));
1936                   else if (target_resources_ok < 0 && !sw_mode)
1937                     error (_("There are not enough available hardware "
1938                              "resources for this watchpoint."));
1939
1940                   /* Downgrade to software watchpoint.  */
1941                   b->type = bp_watchpoint;
1942                 }
1943               else
1944                 {
1945                   /* If this was a software watchpoint, we've just
1946                      found we have enough resources to turn it to a
1947                      hardware watchpoint.  Otherwise, this is a
1948                      nop.  */
1949                   b->type = type;
1950                 }
1951             }
1952           else if (!b->ops->works_in_software_mode (b))
1953             {
1954               if (!can_use_hw_watchpoints)
1955                 error (_("Can't set read/access watchpoint when "
1956                          "hardware watchpoints are disabled."));
1957               else
1958                 error (_("Expression cannot be implemented with "
1959                          "read/access watchpoint."));
1960             }
1961           else
1962             b->type = bp_watchpoint;
1963
1964           loc_type = (b->type == bp_watchpoint? bp_loc_other
1965                       : bp_loc_hardware_watchpoint);
1966           for (bl = b->loc; bl; bl = bl->next)
1967             bl->loc_type = loc_type;
1968         }
1969
1970       /* If a software watchpoint is not watching any memory, then the
1971          above left it without any location set up.  But,
1972          bpstat_stop_status requires a location to be able to report
1973          stops, so make sure there's at least a dummy one.  */
1974       if (b->type == bp_watchpoint && b->loc == NULL)
1975         software_watchpoint_add_no_memory_location (b, frame_pspace);
1976     }
1977   else if (!within_current_scope)
1978     {
1979       printf_filtered (_("\
1980 Watchpoint %d deleted because the program has left the block\n\
1981 in which its expression is valid.\n"),
1982                        b->number);
1983       watchpoint_del_at_next_stop (b);
1984     }
1985
1986   /* Restore the selected frame.  */
1987   if (frame_saved)
1988     select_frame (frame_find_by_id (saved_frame_id));
1989 }
1990
1991
1992 /* Returns 1 iff breakpoint location should be
1993    inserted in the inferior.  We don't differentiate the type of BL's owner
1994    (breakpoint vs. tracepoint), although insert_location in tracepoint's
1995    breakpoint_ops is not defined, because in insert_bp_location,
1996    tracepoint's insert_location will not be called.  */
1997 static int
1998 should_be_inserted (struct bp_location *bl)
1999 {
2000   if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
2001     return 0;
2002
2003   if (bl->owner->disposition == disp_del_at_next_stop)
2004     return 0;
2005
2006   if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
2007     return 0;
2008
2009   if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
2010     return 0;
2011
2012   /* This is set for example, when we're attached to the parent of a
2013      vfork, and have detached from the child.  The child is running
2014      free, and we expect it to do an exec or exit, at which point the
2015      OS makes the parent schedulable again (and the target reports
2016      that the vfork is done).  Until the child is done with the shared
2017      memory region, do not insert breakpoints in the parent, otherwise
2018      the child could still trip on the parent's breakpoints.  Since
2019      the parent is blocked anyway, it won't miss any breakpoint.  */
2020   if (bl->pspace->breakpoints_not_allowed)
2021     return 0;
2022
2023   /* Don't insert a breakpoint if we're trying to step past its
2024      location, except if the breakpoint is a single-step breakpoint,
2025      and the breakpoint's thread is the thread which is stepping past
2026      a breakpoint.  */
2027   if ((bl->loc_type == bp_loc_software_breakpoint
2028        || bl->loc_type == bp_loc_hardware_breakpoint)
2029       && stepping_past_instruction_at (bl->pspace->aspace,
2030                                        bl->address)
2031       /* The single-step breakpoint may be inserted at the location
2032          we're trying to step if the instruction branches to itself.
2033          However, the instruction won't be executed at all and it may
2034          break the semantics of the instruction, for example, the
2035          instruction is a conditional branch or updates some flags.
2036          We can't fix it unless GDB is able to emulate the instruction
2037          or switch to displaced stepping.  */
2038       && !(bl->owner->type == bp_single_step
2039            && thread_is_stepping_over_breakpoint (bl->owner->thread)))
2040     {
2041       if (debug_infrun)
2042         {
2043           fprintf_unfiltered (gdb_stdlog,
2044                               "infrun: skipping breakpoint: "
2045                               "stepping past insn at: %s\n",
2046                               paddress (bl->gdbarch, bl->address));
2047         }
2048       return 0;
2049     }
2050
2051   /* Don't insert watchpoints if we're trying to step past the
2052      instruction that triggered one.  */
2053   if ((bl->loc_type == bp_loc_hardware_watchpoint)
2054       && stepping_past_nonsteppable_watchpoint ())
2055     {
2056       if (debug_infrun)
2057         {
2058           fprintf_unfiltered (gdb_stdlog,
2059                               "infrun: stepping past non-steppable watchpoint. "
2060                               "skipping watchpoint at %s:%d\n",
2061                               paddress (bl->gdbarch, bl->address),
2062                               bl->length);
2063         }
2064       return 0;
2065     }
2066
2067   return 1;
2068 }
2069
2070 /* Same as should_be_inserted but does the check assuming
2071    that the location is not duplicated.  */
2072
2073 static int
2074 unduplicated_should_be_inserted (struct bp_location *bl)
2075 {
2076   int result;
2077   const int save_duplicate = bl->duplicate;
2078
2079   bl->duplicate = 0;
2080   result = should_be_inserted (bl);
2081   bl->duplicate = save_duplicate;
2082   return result;
2083 }
2084
2085 /* Parses a conditional described by an expression COND into an
2086    agent expression bytecode suitable for evaluation
2087    by the bytecode interpreter.  Return NULL if there was
2088    any error during parsing.  */
2089
2090 static agent_expr_up
2091 parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
2092 {
2093   if (cond == NULL)
2094     return NULL;
2095
2096   agent_expr_up aexpr;
2097
2098   /* We don't want to stop processing, so catch any errors
2099      that may show up.  */
2100   try
2101     {
2102       aexpr = gen_eval_for_expr (scope, cond);
2103     }
2104
2105   catch (const gdb_exception_error &ex)
2106     {
2107       /* If we got here, it means the condition could not be parsed to a valid
2108          bytecode expression and thus can't be evaluated on the target's side.
2109          It's no use iterating through the conditions.  */
2110     }
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 (const gdb_exception_error &ex)
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
2287   /* We have a valid agent expression, return it.  */
2288   return aexpr;
2289 }
2290
2291 /* Based on location BL, create a list of breakpoint commands to be
2292    passed on to the target.  If we have duplicated locations with
2293    different commands, we will add any such to the list.  */
2294
2295 static void
2296 build_target_command_list (struct bp_location *bl)
2297 {
2298   struct bp_location **locp = NULL, **loc2p;
2299   int null_command_or_parse_error = 0;
2300   int modified = bl->needs_update;
2301   struct bp_location *loc;
2302
2303   /* Clear commands left over from a previous insert.  */
2304   bl->target_info.tcommands.clear ();
2305
2306   if (!target_can_run_breakpoint_commands ())
2307     return;
2308
2309   /* For now, limit to agent-style dprintf breakpoints.  */
2310   if (dprintf_style != dprintf_style_agent)
2311     return;
2312
2313   /* For now, if we have any duplicate location that isn't a dprintf,
2314      don't install the target-side commands, as that would make the
2315      breakpoint not be reported to the core, and we'd lose
2316      control.  */
2317   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2318     {
2319       loc = (*loc2p);
2320       if (is_breakpoint (loc->owner)
2321           && loc->pspace->num == bl->pspace->num
2322           && loc->owner->type != bp_dprintf)
2323         return;
2324     }
2325
2326   /* Do a first pass to check for locations with no assigned
2327      conditions or conditions that fail to parse to a valid agent expression
2328      bytecode.  If any of these happen, then it's no use to send conditions
2329      to the target since this location will always trigger and generate a
2330      response back to GDB.  */
2331   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2332     {
2333       loc = (*loc2p);
2334       if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2335         {
2336           if (modified)
2337             {
2338               /* Re-parse the commands since something changed.  In that
2339                  case we already freed the command bytecodes (see
2340                  force_breakpoint_reinsertion).  We just
2341                  need to parse the command to bytecodes again.  */
2342               loc->cmd_bytecode
2343                 = parse_cmd_to_aexpr (bl->address,
2344                                       loc->owner->extra_string);
2345             }
2346
2347           /* If we have a NULL bytecode expression, it means something
2348              went wrong or we have a null command expression.  */
2349           if (!loc->cmd_bytecode)
2350             {
2351               null_command_or_parse_error = 1;
2352               break;
2353             }
2354         }
2355     }
2356
2357   /* If anything failed, then we're not doing target-side commands,
2358      and so clean up.  */
2359   if (null_command_or_parse_error)
2360     {
2361       ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2362         {
2363           loc = (*loc2p);
2364           if (is_breakpoint (loc->owner)
2365               && loc->pspace->num == bl->pspace->num)
2366             {
2367               /* Only go as far as the first NULL bytecode is
2368                  located.  */
2369               if (loc->cmd_bytecode == NULL)
2370                 return;
2371
2372               loc->cmd_bytecode.reset ();
2373             }
2374         }
2375     }
2376
2377   /* No NULL commands or failed bytecode generation.  Build a command list
2378      for this location's address.  */
2379   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2380     {
2381       loc = (*loc2p);
2382       if (loc->owner->extra_string
2383           && is_breakpoint (loc->owner)
2384           && loc->pspace->num == bl->pspace->num
2385           && loc->owner->enable_state == bp_enabled
2386           && loc->enabled)
2387         {
2388           /* Add the command to the vector.  This will be used later
2389              to send the commands to the target.  */
2390           bl->target_info.tcommands.push_back (loc->cmd_bytecode.get ());
2391         }
2392     }
2393
2394   bl->target_info.persist = 0;
2395   /* Maybe flag this location as persistent.  */
2396   if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2397     bl->target_info.persist = 1;
2398 }
2399
2400 /* Return the kind of breakpoint on address *ADDR.  Get the kind
2401    of breakpoint according to ADDR except single-step breakpoint.
2402    Get the kind of single-step breakpoint according to the current
2403    registers state.  */
2404
2405 static int
2406 breakpoint_kind (struct bp_location *bl, CORE_ADDR *addr)
2407 {
2408   if (bl->owner->type == bp_single_step)
2409     {
2410       struct thread_info *thr = find_thread_global_id (bl->owner->thread);
2411       struct regcache *regcache;
2412
2413       regcache = get_thread_regcache (thr);
2414
2415       return gdbarch_breakpoint_kind_from_current_state (bl->gdbarch,
2416                                                          regcache, addr);
2417     }
2418   else
2419     return gdbarch_breakpoint_kind_from_pc (bl->gdbarch, addr);
2420 }
2421
2422 /* Insert a low-level "breakpoint" of some type.  BL is the breakpoint
2423    location.  Any error messages are printed to TMP_ERROR_STREAM; and
2424    DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2425    Returns 0 for success, 1 if the bp_location type is not supported or
2426    -1 for failure.
2427
2428    NOTE drow/2003-09-09: This routine could be broken down to an
2429    object-style method for each breakpoint or catchpoint type.  */
2430 static int
2431 insert_bp_location (struct bp_location *bl,
2432                     struct ui_file *tmp_error_stream,
2433                     int *disabled_breaks,
2434                     int *hw_breakpoint_error,
2435                     int *hw_bp_error_explained_already)
2436 {
2437   gdb_exception bp_excpt;
2438
2439   if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2440     return 0;
2441
2442   /* Note we don't initialize bl->target_info, as that wipes out
2443      the breakpoint location's shadow_contents if the breakpoint
2444      is still inserted at that location.  This in turn breaks
2445      target_read_memory which depends on these buffers when
2446      a memory read is requested at the breakpoint location:
2447      Once the target_info has been wiped, we fail to see that
2448      we have a breakpoint inserted at that address and thus
2449      read the breakpoint instead of returning the data saved in
2450      the breakpoint location's shadow contents.  */
2451   bl->target_info.reqstd_address = bl->address;
2452   bl->target_info.placed_address_space = bl->pspace->aspace;
2453   bl->target_info.length = bl->length;
2454
2455   /* When working with target-side conditions, we must pass all the conditions
2456      for the same breakpoint address down to the target since GDB will not
2457      insert those locations.  With a list of breakpoint conditions, the target
2458      can decide when to stop and notify GDB.  */
2459
2460   if (is_breakpoint (bl->owner))
2461     {
2462       build_target_condition_list (bl);
2463       build_target_command_list (bl);
2464       /* Reset the modification marker.  */
2465       bl->needs_update = 0;
2466     }
2467
2468   if (bl->loc_type == bp_loc_software_breakpoint
2469       || bl->loc_type == bp_loc_hardware_breakpoint)
2470     {
2471       if (bl->owner->type != bp_hardware_breakpoint)
2472         {
2473           /* If the explicitly specified breakpoint type
2474              is not hardware breakpoint, check the memory map to see
2475              if the breakpoint address is in read only memory or not.
2476
2477              Two important cases are:
2478              - location type is not hardware breakpoint, memory
2479              is readonly.  We change the type of the location to
2480              hardware breakpoint.
2481              - location type is hardware breakpoint, memory is
2482              read-write.  This means we've previously made the
2483              location hardware one, but then the memory map changed,
2484              so we undo.
2485              
2486              When breakpoints are removed, remove_breakpoints will use
2487              location types we've just set here, the only possible
2488              problem is that memory map has changed during running
2489              program, but it's not going to work anyway with current
2490              gdb.  */
2491           struct mem_region *mr 
2492             = lookup_mem_region (bl->target_info.reqstd_address);
2493           
2494           if (mr)
2495             {
2496               if (automatic_hardware_breakpoints)
2497                 {
2498                   enum bp_loc_type new_type;
2499                   
2500                   if (mr->attrib.mode != MEM_RW)
2501                     new_type = bp_loc_hardware_breakpoint;
2502                   else 
2503                     new_type = bp_loc_software_breakpoint;
2504                   
2505                   if (new_type != bl->loc_type)
2506                     {
2507                       static int said = 0;
2508
2509                       bl->loc_type = new_type;
2510                       if (!said)
2511                         {
2512                           fprintf_filtered (gdb_stdout,
2513                                             _("Note: automatically using "
2514                                               "hardware breakpoints for "
2515                                               "read-only addresses.\n"));
2516                           said = 1;
2517                         }
2518                     }
2519                 }
2520               else if (bl->loc_type == bp_loc_software_breakpoint
2521                        && mr->attrib.mode != MEM_RW)
2522                 {
2523                   fprintf_unfiltered (tmp_error_stream,
2524                                       _("Cannot insert breakpoint %d.\n"
2525                                         "Cannot set software breakpoint "
2526                                         "at read-only address %s\n"),
2527                                       bl->owner->number,
2528                                       paddress (bl->gdbarch, bl->address));
2529                   return 1;
2530                 }
2531             }
2532         }
2533         
2534       /* First check to see if we have to handle an overlay.  */
2535       if (overlay_debugging == ovly_off
2536           || bl->section == NULL
2537           || !(section_is_overlay (bl->section)))
2538         {
2539           /* No overlay handling: just set the breakpoint.  */
2540           try
2541             {
2542               int val;
2543
2544               val = bl->owner->ops->insert_location (bl);
2545               if (val)
2546                 bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2547             }
2548           catch (gdb_exception &e)
2549             {
2550               bp_excpt = std::move (e);
2551             }
2552         }
2553       else
2554         {
2555           /* This breakpoint is in an overlay section.
2556              Shall we set a breakpoint at the LMA?  */
2557           if (!overlay_events_enabled)
2558             {
2559               /* Yes -- overlay event support is not active, 
2560                  so we must try to set a breakpoint at the LMA.
2561                  This will not work for a hardware breakpoint.  */
2562               if (bl->loc_type == bp_loc_hardware_breakpoint)
2563                 warning (_("hardware breakpoint %d not supported in overlay!"),
2564                          bl->owner->number);
2565               else
2566                 {
2567                   CORE_ADDR addr = overlay_unmapped_address (bl->address,
2568                                                              bl->section);
2569                   /* Set a software (trap) breakpoint at the LMA.  */
2570                   bl->overlay_target_info = bl->target_info;
2571                   bl->overlay_target_info.reqstd_address = addr;
2572
2573                   /* No overlay handling: just set the breakpoint.  */
2574                   try
2575                     {
2576                       int val;
2577
2578                       bl->overlay_target_info.kind
2579                         = breakpoint_kind (bl, &addr);
2580                       bl->overlay_target_info.placed_address = addr;
2581                       val = target_insert_breakpoint (bl->gdbarch,
2582                                                       &bl->overlay_target_info);
2583                       if (val)
2584                         bp_excpt
2585                           = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2586                     }
2587                   catch (gdb_exception &e)
2588                     {
2589                       bp_excpt = std::move (e);
2590                     }
2591
2592                   if (bp_excpt.reason != 0)
2593                     fprintf_unfiltered (tmp_error_stream,
2594                                         "Overlay breakpoint %d "
2595                                         "failed: in ROM?\n",
2596                                         bl->owner->number);
2597                 }
2598             }
2599           /* Shall we set a breakpoint at the VMA? */
2600           if (section_is_mapped (bl->section))
2601             {
2602               /* Yes.  This overlay section is mapped into memory.  */
2603               try
2604                 {
2605                   int val;
2606
2607                   val = bl->owner->ops->insert_location (bl);
2608                   if (val)
2609                     bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2610                 }
2611               catch (gdb_exception &e)
2612                 {
2613                   bp_excpt = std::move (e);
2614                 }
2615             }
2616           else
2617             {
2618               /* No.  This breakpoint will not be inserted.  
2619                  No error, but do not mark the bp as 'inserted'.  */
2620               return 0;
2621             }
2622         }
2623
2624       if (bp_excpt.reason != 0)
2625         {
2626           /* Can't set the breakpoint.  */
2627
2628           /* In some cases, we might not be able to insert a
2629              breakpoint in a shared library that has already been
2630              removed, but we have not yet processed the shlib unload
2631              event.  Unfortunately, some targets that implement
2632              breakpoint insertion themselves can't tell why the
2633              breakpoint insertion failed (e.g., the remote target
2634              doesn't define error codes), so we must treat generic
2635              errors as memory errors.  */
2636           if (bp_excpt.reason == RETURN_ERROR
2637               && (bp_excpt.error == GENERIC_ERROR
2638                   || bp_excpt.error == MEMORY_ERROR)
2639               && bl->loc_type == bp_loc_software_breakpoint
2640               && (solib_name_from_address (bl->pspace, bl->address)
2641                   || shared_objfile_contains_address_p (bl->pspace,
2642                                                         bl->address)))
2643             {
2644               /* See also: disable_breakpoints_in_shlibs.  */
2645               bl->shlib_disabled = 1;
2646               gdb::observers::breakpoint_modified.notify (bl->owner);
2647               if (!*disabled_breaks)
2648                 {
2649                   fprintf_unfiltered (tmp_error_stream, 
2650                                       "Cannot insert breakpoint %d.\n", 
2651                                       bl->owner->number);
2652                   fprintf_unfiltered (tmp_error_stream, 
2653                                       "Temporarily disabling shared "
2654                                       "library breakpoints:\n");
2655                 }
2656               *disabled_breaks = 1;
2657               fprintf_unfiltered (tmp_error_stream,
2658                                   "breakpoint #%d\n", bl->owner->number);
2659               return 0;
2660             }
2661           else
2662             {
2663               if (bl->loc_type == bp_loc_hardware_breakpoint)
2664                 {
2665                   *hw_breakpoint_error = 1;
2666                   *hw_bp_error_explained_already = bp_excpt.message != NULL;
2667                   fprintf_unfiltered (tmp_error_stream,
2668                                       "Cannot insert hardware breakpoint %d%s",
2669                                       bl->owner->number,
2670                                       bp_excpt.message ? ":" : ".\n");
2671                   if (bp_excpt.message != NULL)
2672                     fprintf_unfiltered (tmp_error_stream, "%s.\n",
2673                                         bp_excpt.what ());
2674                 }
2675               else
2676                 {
2677                   if (bp_excpt.message == NULL)
2678                     {
2679                       std::string message
2680                         = memory_error_message (TARGET_XFER_E_IO,
2681                                                 bl->gdbarch, bl->address);
2682
2683                       fprintf_unfiltered (tmp_error_stream,
2684                                           "Cannot insert breakpoint %d.\n"
2685                                           "%s\n",
2686                                           bl->owner->number, message.c_str ());
2687                     }
2688                   else
2689                     {
2690                       fprintf_unfiltered (tmp_error_stream,
2691                                           "Cannot insert breakpoint %d: %s\n",
2692                                           bl->owner->number,
2693                                           bp_excpt.what ());
2694                     }
2695                 }
2696               return 1;
2697
2698             }
2699         }
2700       else
2701         bl->inserted = 1;
2702
2703       return 0;
2704     }
2705
2706   else if (bl->loc_type == bp_loc_hardware_watchpoint
2707            /* NOTE drow/2003-09-08: This state only exists for removing
2708               watchpoints.  It's not clear that it's necessary...  */
2709            && bl->owner->disposition != disp_del_at_next_stop)
2710     {
2711       int val;
2712
2713       gdb_assert (bl->owner->ops != NULL
2714                   && bl->owner->ops->insert_location != NULL);
2715
2716       val = bl->owner->ops->insert_location (bl);
2717
2718       /* If trying to set a read-watchpoint, and it turns out it's not
2719          supported, try emulating one with an access watchpoint.  */
2720       if (val == 1 && bl->watchpoint_type == hw_read)
2721         {
2722           struct bp_location *loc, **loc_temp;
2723
2724           /* But don't try to insert it, if there's already another
2725              hw_access location that would be considered a duplicate
2726              of this one.  */
2727           ALL_BP_LOCATIONS (loc, loc_temp)
2728             if (loc != bl
2729                 && loc->watchpoint_type == hw_access
2730                 && watchpoint_locations_match (bl, loc))
2731               {
2732                 bl->duplicate = 1;
2733                 bl->inserted = 1;
2734                 bl->target_info = loc->target_info;
2735                 bl->watchpoint_type = hw_access;
2736                 val = 0;
2737                 break;
2738               }
2739
2740           if (val == 1)
2741             {
2742               bl->watchpoint_type = hw_access;
2743               val = bl->owner->ops->insert_location (bl);
2744
2745               if (val)
2746                 /* Back to the original value.  */
2747                 bl->watchpoint_type = hw_read;
2748             }
2749         }
2750
2751       bl->inserted = (val == 0);
2752     }
2753
2754   else if (bl->owner->type == bp_catchpoint)
2755     {
2756       int val;
2757
2758       gdb_assert (bl->owner->ops != NULL
2759                   && bl->owner->ops->insert_location != NULL);
2760
2761       val = bl->owner->ops->insert_location (bl);
2762       if (val)
2763         {
2764           bl->owner->enable_state = bp_disabled;
2765
2766           if (val == 1)
2767             warning (_("\
2768 Error inserting catchpoint %d: Your system does not support this type\n\
2769 of catchpoint."), bl->owner->number);
2770           else
2771             warning (_("Error inserting catchpoint %d."), bl->owner->number);
2772         }
2773
2774       bl->inserted = (val == 0);
2775
2776       /* We've already printed an error message if there was a problem
2777          inserting this catchpoint, and we've disabled the catchpoint,
2778          so just return success.  */
2779       return 0;
2780     }
2781
2782   return 0;
2783 }
2784
2785 /* This function is called when program space PSPACE is about to be
2786    deleted.  It takes care of updating breakpoints to not reference
2787    PSPACE anymore.  */
2788
2789 void
2790 breakpoint_program_space_exit (struct program_space *pspace)
2791 {
2792   struct breakpoint *b, *b_temp;
2793   struct bp_location *loc, **loc_temp;
2794
2795   /* Remove any breakpoint that was set through this program space.  */
2796   ALL_BREAKPOINTS_SAFE (b, b_temp)
2797     {
2798       if (b->pspace == pspace)
2799         delete_breakpoint (b);
2800     }
2801
2802   /* Breakpoints set through other program spaces could have locations
2803      bound to PSPACE as well.  Remove those.  */
2804   ALL_BP_LOCATIONS (loc, loc_temp)
2805     {
2806       struct bp_location *tmp;
2807
2808       if (loc->pspace == pspace)
2809         {
2810           /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
2811           if (loc->owner->loc == loc)
2812             loc->owner->loc = loc->next;
2813           else
2814             for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
2815               if (tmp->next == loc)
2816                 {
2817                   tmp->next = loc->next;
2818                   break;
2819                 }
2820         }
2821     }
2822
2823   /* Now update the global location list to permanently delete the
2824      removed locations above.  */
2825   update_global_location_list (UGLL_DONT_INSERT);
2826 }
2827
2828 /* Make sure all breakpoints are inserted in inferior.
2829    Throws exception on any error.
2830    A breakpoint that is already inserted won't be inserted
2831    again, so calling this function twice is safe.  */
2832 void
2833 insert_breakpoints (void)
2834 {
2835   struct breakpoint *bpt;
2836
2837   ALL_BREAKPOINTS (bpt)
2838     if (is_hardware_watchpoint (bpt))
2839       {
2840         struct watchpoint *w = (struct watchpoint *) bpt;
2841
2842         update_watchpoint (w, 0 /* don't reparse.  */);
2843       }
2844
2845   /* Updating watchpoints creates new locations, so update the global
2846      location list.  Explicitly tell ugll to insert locations and
2847      ignore breakpoints_always_inserted_mode.  */
2848   update_global_location_list (UGLL_INSERT);
2849 }
2850
2851 /* Invoke CALLBACK for each of bp_location.  */
2852
2853 void
2854 iterate_over_bp_locations (walk_bp_location_callback callback)
2855 {
2856   struct bp_location *loc, **loc_tmp;
2857
2858   ALL_BP_LOCATIONS (loc, loc_tmp)
2859     {
2860       callback (loc, NULL);
2861     }
2862 }
2863
2864 /* This is used when we need to synch breakpoint conditions between GDB and the
2865    target.  It is the case with deleting and disabling of breakpoints when using
2866    always-inserted mode.  */
2867
2868 static void
2869 update_inserted_breakpoint_locations (void)
2870 {
2871   struct bp_location *bl, **blp_tmp;
2872   int error_flag = 0;
2873   int val = 0;
2874   int disabled_breaks = 0;
2875   int hw_breakpoint_error = 0;
2876   int hw_bp_details_reported = 0;
2877
2878   string_file tmp_error_stream;
2879
2880   /* Explicitly mark the warning -- this will only be printed if
2881      there was an error.  */
2882   tmp_error_stream.puts ("Warning:\n");
2883
2884   scoped_restore_current_pspace_and_thread restore_pspace_thread;
2885
2886   ALL_BP_LOCATIONS (bl, blp_tmp)
2887     {
2888       /* We only want to update software breakpoints and hardware
2889          breakpoints.  */
2890       if (!is_breakpoint (bl->owner))
2891         continue;
2892
2893       /* We only want to update locations that are already inserted
2894          and need updating.  This is to avoid unwanted insertion during
2895          deletion of breakpoints.  */
2896       if (!bl->inserted || !bl->needs_update)
2897         continue;
2898
2899       switch_to_program_space_and_thread (bl->pspace);
2900
2901       /* For targets that support global breakpoints, there's no need
2902          to select an inferior to insert breakpoint to.  In fact, even
2903          if we aren't attached to any process yet, we should still
2904          insert breakpoints.  */
2905       if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2906           && inferior_ptid == null_ptid)
2907         continue;
2908
2909       val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
2910                                     &hw_breakpoint_error, &hw_bp_details_reported);
2911       if (val)
2912         error_flag = val;
2913     }
2914
2915   if (error_flag)
2916     {
2917       target_terminal::ours_for_output ();
2918       error_stream (tmp_error_stream);
2919     }
2920 }
2921
2922 /* Used when starting or continuing the program.  */
2923
2924 static void
2925 insert_breakpoint_locations (void)
2926 {
2927   struct breakpoint *bpt;
2928   struct bp_location *bl, **blp_tmp;
2929   int error_flag = 0;
2930   int val = 0;
2931   int disabled_breaks = 0;
2932   int hw_breakpoint_error = 0;
2933   int hw_bp_error_explained_already = 0;
2934
2935   string_file tmp_error_stream;
2936
2937   /* Explicitly mark the warning -- this will only be printed if
2938      there was an error.  */
2939   tmp_error_stream.puts ("Warning:\n");
2940
2941   scoped_restore_current_pspace_and_thread restore_pspace_thread;
2942
2943   ALL_BP_LOCATIONS (bl, blp_tmp)
2944     {
2945       if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2946         continue;
2947
2948       /* There is no point inserting thread-specific breakpoints if
2949          the thread no longer exists.  ALL_BP_LOCATIONS bp_location
2950          has BL->OWNER always non-NULL.  */
2951       if (bl->owner->thread != -1
2952           && !valid_global_thread_id (bl->owner->thread))
2953         continue;
2954
2955       switch_to_program_space_and_thread (bl->pspace);
2956
2957       /* For targets that support global breakpoints, there's no need
2958          to select an inferior to insert breakpoint to.  In fact, even
2959          if we aren't attached to any process yet, we should still
2960          insert breakpoints.  */
2961       if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2962           && inferior_ptid == null_ptid)
2963         continue;
2964
2965       val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
2966                                     &hw_breakpoint_error, &hw_bp_error_explained_already);
2967       if (val)
2968         error_flag = val;
2969     }
2970
2971   /* If we failed to insert all locations of a watchpoint, remove
2972      them, as half-inserted watchpoint is of limited use.  */
2973   ALL_BREAKPOINTS (bpt)  
2974     {
2975       int some_failed = 0;
2976       struct bp_location *loc;
2977
2978       if (!is_hardware_watchpoint (bpt))
2979         continue;
2980
2981       if (!breakpoint_enabled (bpt))
2982         continue;
2983
2984       if (bpt->disposition == disp_del_at_next_stop)
2985         continue;
2986       
2987       for (loc = bpt->loc; loc; loc = loc->next)
2988         if (!loc->inserted && should_be_inserted (loc))
2989           {
2990             some_failed = 1;
2991             break;
2992           }
2993       if (some_failed)
2994         {
2995           for (loc = bpt->loc; loc; loc = loc->next)
2996             if (loc->inserted)
2997               remove_breakpoint (loc);
2998
2999           hw_breakpoint_error = 1;
3000           tmp_error_stream.printf ("Could not insert "
3001                                    "hardware watchpoint %d.\n",
3002                                    bpt->number);
3003           error_flag = -1;
3004         }
3005     }
3006
3007   if (error_flag)
3008     {
3009       /* If a hardware breakpoint or watchpoint was inserted, add a
3010          message about possibly exhausted resources.  */
3011       if (hw_breakpoint_error && !hw_bp_error_explained_already)
3012         {
3013           tmp_error_stream.printf ("Could not insert hardware breakpoints:\n\
3014 You may have requested too many hardware breakpoints/watchpoints.\n");
3015         }
3016       target_terminal::ours_for_output ();
3017       error_stream (tmp_error_stream);
3018     }
3019 }
3020
3021 /* Used when the program stops.
3022    Returns zero if successful, or non-zero if there was a problem
3023    removing a breakpoint location.  */
3024
3025 int
3026 remove_breakpoints (void)
3027 {
3028   struct bp_location *bl, **blp_tmp;
3029   int val = 0;
3030
3031   ALL_BP_LOCATIONS (bl, blp_tmp)
3032   {
3033     if (bl->inserted && !is_tracepoint (bl->owner))
3034       val |= remove_breakpoint (bl);
3035   }
3036   return val;
3037 }
3038
3039 /* When a thread exits, remove breakpoints that are related to
3040    that thread.  */
3041
3042 static void
3043 remove_threaded_breakpoints (struct thread_info *tp, int silent)
3044 {
3045   struct breakpoint *b, *b_tmp;
3046
3047   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3048     {
3049       if (b->thread == tp->global_num && user_breakpoint_p (b))
3050         {
3051           b->disposition = disp_del_at_next_stop;
3052
3053           printf_filtered (_("\
3054 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3055                            b->number, print_thread_id (tp));
3056
3057           /* Hide it from the user.  */
3058           b->number = 0;
3059        }
3060     }
3061 }
3062
3063 /* Remove breakpoints of inferior INF.  */
3064
3065 int
3066 remove_breakpoints_inf (inferior *inf)
3067 {
3068   struct bp_location *bl, **blp_tmp;
3069   int val;
3070
3071   ALL_BP_LOCATIONS (bl, blp_tmp)
3072   {
3073     if (bl->pspace != inf->pspace)
3074       continue;
3075
3076     if (bl->inserted && !bl->target_info.persist)
3077       {
3078         val = remove_breakpoint (bl);
3079         if (val != 0)
3080           return val;
3081       }
3082   }
3083   return 0;
3084 }
3085
3086 static int internal_breakpoint_number = -1;
3087
3088 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3089    If INTERNAL is non-zero, the breakpoint number will be populated
3090    from internal_breakpoint_number and that variable decremented.
3091    Otherwise the breakpoint number will be populated from
3092    breakpoint_count and that value incremented.  Internal breakpoints
3093    do not set the internal var bpnum.  */
3094 static void
3095 set_breakpoint_number (int internal, struct breakpoint *b)
3096 {
3097   if (internal)
3098     b->number = internal_breakpoint_number--;
3099   else
3100     {
3101       set_breakpoint_count (breakpoint_count + 1);
3102       b->number = breakpoint_count;
3103     }
3104 }
3105
3106 static struct breakpoint *
3107 create_internal_breakpoint (struct gdbarch *gdbarch,
3108                             CORE_ADDR address, enum bptype type,
3109                             const struct breakpoint_ops *ops)
3110 {
3111   symtab_and_line sal;
3112   sal.pc = address;
3113   sal.section = find_pc_overlay (sal.pc);
3114   sal.pspace = current_program_space;
3115
3116   breakpoint *b = set_raw_breakpoint (gdbarch, sal, type, ops);
3117   b->number = internal_breakpoint_number--;
3118   b->disposition = disp_donttouch;
3119
3120   return b;
3121 }
3122
3123 static const char *const longjmp_names[] =
3124   {
3125     "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3126   };
3127 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3128
3129 /* Per-objfile data private to breakpoint.c.  */
3130 struct breakpoint_objfile_data
3131 {
3132   /* Minimal symbol for "_ovly_debug_event" (if any).  */
3133   struct bound_minimal_symbol overlay_msym {};
3134
3135   /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any).  */
3136   struct bound_minimal_symbol longjmp_msym[NUM_LONGJMP_NAMES] {};
3137
3138   /* True if we have looked for longjmp probes.  */
3139   int longjmp_searched = 0;
3140
3141   /* SystemTap probe points for longjmp (if any).  These are non-owning
3142      references.  */
3143   std::vector<probe *> longjmp_probes;
3144
3145   /* Minimal symbol for "std::terminate()" (if any).  */
3146   struct bound_minimal_symbol terminate_msym {};
3147
3148   /* Minimal symbol for "_Unwind_DebugHook" (if any).  */
3149   struct bound_minimal_symbol exception_msym {};
3150
3151   /* True if we have looked for exception probes.  */
3152   int exception_searched = 0;
3153
3154   /* SystemTap probe points for unwinding (if any).  These are non-owning
3155      references.  */
3156   std::vector<probe *> exception_probes;
3157 };
3158
3159 static const struct objfile_key<breakpoint_objfile_data>
3160   breakpoint_objfile_key;
3161
3162 /* Minimal symbol not found sentinel.  */
3163 static struct minimal_symbol msym_not_found;
3164
3165 /* Returns TRUE if MSYM point to the "not found" sentinel.  */
3166
3167 static int
3168 msym_not_found_p (const struct minimal_symbol *msym)
3169 {
3170   return msym == &msym_not_found;
3171 }
3172
3173 /* Return per-objfile data needed by breakpoint.c.
3174    Allocate the data if necessary.  */
3175
3176 static struct breakpoint_objfile_data *
3177 get_breakpoint_objfile_data (struct objfile *objfile)
3178 {
3179   struct breakpoint_objfile_data *bp_objfile_data;
3180
3181   bp_objfile_data = breakpoint_objfile_key.get (objfile);
3182   if (bp_objfile_data == NULL)
3183     bp_objfile_data = breakpoint_objfile_key.emplace (objfile);
3184   return bp_objfile_data;
3185 }
3186
3187 static void
3188 create_overlay_event_breakpoint (void)
3189 {
3190   const char *const func_name = "_ovly_debug_event";
3191
3192   for (objfile *objfile : current_program_space->objfiles ())
3193     {
3194       struct breakpoint *b;
3195       struct breakpoint_objfile_data *bp_objfile_data;
3196       CORE_ADDR addr;
3197       struct explicit_location explicit_loc;
3198
3199       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3200
3201       if (msym_not_found_p (bp_objfile_data->overlay_msym.minsym))
3202         continue;
3203
3204       if (bp_objfile_data->overlay_msym.minsym == NULL)
3205         {
3206           struct bound_minimal_symbol m;
3207
3208           m = lookup_minimal_symbol_text (func_name, objfile);
3209           if (m.minsym == NULL)
3210             {
3211               /* Avoid future lookups in this objfile.  */
3212               bp_objfile_data->overlay_msym.minsym = &msym_not_found;
3213               continue;
3214             }
3215           bp_objfile_data->overlay_msym = m;
3216         }
3217
3218       addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
3219       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3220                                       bp_overlay_event,
3221                                       &internal_breakpoint_ops);
3222       initialize_explicit_location (&explicit_loc);
3223       explicit_loc.function_name = ASTRDUP (func_name);
3224       b->location = new_explicit_location (&explicit_loc);
3225
3226       if (overlay_debugging == ovly_auto)
3227         {
3228           b->enable_state = bp_enabled;
3229           overlay_events_enabled = 1;
3230         }
3231       else
3232        {
3233          b->enable_state = bp_disabled;
3234          overlay_events_enabled = 0;
3235        }
3236     }
3237 }
3238
3239 static void
3240 create_longjmp_master_breakpoint (void)
3241 {
3242   struct program_space *pspace;
3243
3244   scoped_restore_current_program_space restore_pspace;
3245
3246   ALL_PSPACES (pspace)
3247   {
3248     set_current_program_space (pspace);
3249
3250     for (objfile *objfile : current_program_space->objfiles ())
3251       {
3252         int i;
3253         struct gdbarch *gdbarch;
3254         struct breakpoint_objfile_data *bp_objfile_data;
3255
3256         gdbarch = get_objfile_arch (objfile);
3257
3258         bp_objfile_data = get_breakpoint_objfile_data (objfile);
3259
3260         if (!bp_objfile_data->longjmp_searched)
3261           {
3262             std::vector<probe *> ret
3263               = find_probes_in_objfile (objfile, "libc", "longjmp");
3264
3265             if (!ret.empty ())
3266               {
3267                 /* We are only interested in checking one element.  */
3268                 probe *p = ret[0];
3269
3270                 if (!p->can_evaluate_arguments ())
3271                   {
3272                     /* We cannot use the probe interface here, because it does
3273                        not know how to evaluate arguments.  */
3274                     ret.clear ();
3275                   }
3276               }
3277             bp_objfile_data->longjmp_probes = ret;
3278             bp_objfile_data->longjmp_searched = 1;
3279           }
3280
3281         if (!bp_objfile_data->longjmp_probes.empty ())
3282           {
3283             for (probe *p : bp_objfile_data->longjmp_probes)
3284               {
3285                 struct breakpoint *b;
3286
3287                 b = create_internal_breakpoint (gdbarch,
3288                                                 p->get_relocated_address (objfile),
3289                                                 bp_longjmp_master,
3290                                                 &internal_breakpoint_ops);
3291                 b->location = new_probe_location ("-probe-stap libc:longjmp");
3292                 b->enable_state = bp_disabled;
3293               }
3294
3295             continue;
3296           }
3297
3298         if (!gdbarch_get_longjmp_target_p (gdbarch))
3299           continue;
3300
3301         for (i = 0; i < NUM_LONGJMP_NAMES; i++)
3302           {
3303             struct breakpoint *b;
3304             const char *func_name;
3305             CORE_ADDR addr;
3306             struct explicit_location explicit_loc;
3307
3308             if (msym_not_found_p (bp_objfile_data->longjmp_msym[i].minsym))
3309               continue;
3310
3311             func_name = longjmp_names[i];
3312             if (bp_objfile_data->longjmp_msym[i].minsym == NULL)
3313               {
3314                 struct bound_minimal_symbol m;
3315
3316                 m = lookup_minimal_symbol_text (func_name, objfile);
3317                 if (m.minsym == NULL)
3318                   {
3319                     /* Prevent future lookups in this objfile.  */
3320                     bp_objfile_data->longjmp_msym[i].minsym = &msym_not_found;
3321                     continue;
3322                   }
3323                 bp_objfile_data->longjmp_msym[i] = m;
3324               }
3325
3326             addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
3327             b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3328                                             &internal_breakpoint_ops);
3329             initialize_explicit_location (&explicit_loc);
3330             explicit_loc.function_name = ASTRDUP (func_name);
3331             b->location = new_explicit_location (&explicit_loc);
3332             b->enable_state = bp_disabled;
3333           }
3334       }
3335   }
3336 }
3337
3338 /* Create a master std::terminate breakpoint.  */
3339 static void
3340 create_std_terminate_master_breakpoint (void)
3341 {
3342   struct program_space *pspace;
3343   const char *const func_name = "std::terminate()";
3344
3345   scoped_restore_current_program_space restore_pspace;
3346
3347   ALL_PSPACES (pspace)
3348   {
3349     CORE_ADDR addr;
3350
3351     set_current_program_space (pspace);
3352
3353     for (objfile *objfile : current_program_space->objfiles ())
3354       {
3355         struct breakpoint *b;
3356         struct breakpoint_objfile_data *bp_objfile_data;
3357         struct explicit_location explicit_loc;
3358
3359         bp_objfile_data = get_breakpoint_objfile_data (objfile);
3360
3361         if (msym_not_found_p (bp_objfile_data->terminate_msym.minsym))
3362           continue;
3363
3364         if (bp_objfile_data->terminate_msym.minsym == NULL)
3365           {
3366             struct bound_minimal_symbol m;
3367
3368             m = lookup_minimal_symbol (func_name, NULL, objfile);
3369             if (m.minsym == NULL || (MSYMBOL_TYPE (m.minsym) != mst_text
3370                                      && MSYMBOL_TYPE (m.minsym) != mst_file_text))
3371               {
3372                 /* Prevent future lookups in this objfile.  */
3373                 bp_objfile_data->terminate_msym.minsym = &msym_not_found;
3374                 continue;
3375               }
3376             bp_objfile_data->terminate_msym = m;
3377           }
3378
3379         addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
3380         b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3381                                         bp_std_terminate_master,
3382                                         &internal_breakpoint_ops);
3383         initialize_explicit_location (&explicit_loc);
3384         explicit_loc.function_name = ASTRDUP (func_name);
3385         b->location = new_explicit_location (&explicit_loc);
3386         b->enable_state = bp_disabled;
3387       }
3388   }
3389 }
3390
3391 /* Install a master breakpoint on the unwinder's debug hook.  */
3392
3393 static void
3394 create_exception_master_breakpoint (void)
3395 {
3396   const char *const func_name = "_Unwind_DebugHook";
3397
3398   for (objfile *objfile : current_program_space->objfiles ())
3399     {
3400       struct breakpoint *b;
3401       struct gdbarch *gdbarch;
3402       struct breakpoint_objfile_data *bp_objfile_data;
3403       CORE_ADDR addr;
3404       struct explicit_location explicit_loc;
3405
3406       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3407
3408       /* We prefer the SystemTap probe point if it exists.  */
3409       if (!bp_objfile_data->exception_searched)
3410         {
3411           std::vector<probe *> ret
3412             = find_probes_in_objfile (objfile, "libgcc", "unwind");
3413
3414           if (!ret.empty ())
3415             {
3416               /* We are only interested in checking one element.  */
3417               probe *p = ret[0];
3418
3419               if (!p->can_evaluate_arguments ())
3420                 {
3421                   /* We cannot use the probe interface here, because it does
3422                      not know how to evaluate arguments.  */
3423                   ret.clear ();
3424                 }
3425             }
3426           bp_objfile_data->exception_probes = ret;
3427           bp_objfile_data->exception_searched = 1;
3428         }
3429
3430       if (!bp_objfile_data->exception_probes.empty ())
3431         {
3432           gdbarch = get_objfile_arch (objfile);
3433
3434           for (probe *p : bp_objfile_data->exception_probes)
3435             {
3436               b = create_internal_breakpoint (gdbarch,
3437                                               p->get_relocated_address (objfile),
3438                                               bp_exception_master,
3439                                               &internal_breakpoint_ops);
3440               b->location = new_probe_location ("-probe-stap libgcc:unwind");
3441               b->enable_state = bp_disabled;
3442             }
3443
3444           continue;
3445         }
3446
3447       /* Otherwise, try the hook function.  */
3448
3449       if (msym_not_found_p (bp_objfile_data->exception_msym.minsym))
3450         continue;
3451
3452       gdbarch = get_objfile_arch (objfile);
3453
3454       if (bp_objfile_data->exception_msym.minsym == NULL)
3455         {
3456           struct bound_minimal_symbol debug_hook;
3457
3458           debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3459           if (debug_hook.minsym == NULL)
3460             {
3461               bp_objfile_data->exception_msym.minsym = &msym_not_found;
3462               continue;
3463             }
3464
3465           bp_objfile_data->exception_msym = debug_hook;
3466         }
3467
3468       addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
3469       addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3470                                                  current_top_target ());
3471       b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3472                                       &internal_breakpoint_ops);
3473       initialize_explicit_location (&explicit_loc);
3474       explicit_loc.function_name = ASTRDUP (func_name);
3475       b->location = new_explicit_location (&explicit_loc);
3476       b->enable_state = bp_disabled;
3477     }
3478 }
3479
3480 /* Does B have a location spec?  */
3481
3482 static int
3483 breakpoint_event_location_empty_p (const struct breakpoint *b)
3484 {
3485   return b->location != NULL && event_location_empty_p (b->location.get ());
3486 }
3487
3488 void
3489 update_breakpoints_after_exec (void)
3490 {
3491   struct breakpoint *b, *b_tmp;
3492   struct bp_location *bploc, **bplocp_tmp;
3493
3494   /* We're about to delete breakpoints from GDB's lists.  If the
3495      INSERTED flag is true, GDB will try to lift the breakpoints by
3496      writing the breakpoints' "shadow contents" back into memory.  The
3497      "shadow contents" are NOT valid after an exec, so GDB should not
3498      do that.  Instead, the target is responsible from marking
3499      breakpoints out as soon as it detects an exec.  We don't do that
3500      here instead, because there may be other attempts to delete
3501      breakpoints after detecting an exec and before reaching here.  */
3502   ALL_BP_LOCATIONS (bploc, bplocp_tmp)
3503     if (bploc->pspace == current_program_space)
3504       gdb_assert (!bploc->inserted);
3505
3506   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3507   {
3508     if (b->pspace != current_program_space)
3509       continue;
3510
3511     /* Solib breakpoints must be explicitly reset after an exec().  */
3512     if (b->type == bp_shlib_event)
3513       {
3514         delete_breakpoint (b);
3515         continue;
3516       }
3517
3518     /* JIT breakpoints must be explicitly reset after an exec().  */
3519     if (b->type == bp_jit_event)
3520       {
3521         delete_breakpoint (b);
3522         continue;
3523       }
3524
3525     /* Thread event breakpoints must be set anew after an exec(),
3526        as must overlay event and longjmp master breakpoints.  */
3527     if (b->type == bp_thread_event || b->type == bp_overlay_event
3528         || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3529         || b->type == bp_exception_master)
3530       {
3531         delete_breakpoint (b);
3532         continue;
3533       }
3534
3535     /* Step-resume breakpoints are meaningless after an exec().  */
3536     if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
3537       {
3538         delete_breakpoint (b);
3539         continue;
3540       }
3541
3542     /* Just like single-step breakpoints.  */
3543     if (b->type == bp_single_step)
3544       {
3545         delete_breakpoint (b);
3546         continue;
3547       }
3548
3549     /* Longjmp and longjmp-resume breakpoints are also meaningless
3550        after an exec.  */
3551     if (b->type == bp_longjmp || b->type == bp_longjmp_resume
3552         || b->type == bp_longjmp_call_dummy
3553         || b->type == bp_exception || b->type == bp_exception_resume)
3554       {
3555         delete_breakpoint (b);
3556         continue;
3557       }
3558
3559     if (b->type == bp_catchpoint)
3560       {
3561         /* For now, none of the bp_catchpoint breakpoints need to
3562            do anything at this point.  In the future, if some of
3563            the catchpoints need to something, we will need to add
3564            a new method, and call this method from here.  */
3565         continue;
3566       }
3567
3568     /* bp_finish is a special case.  The only way we ought to be able
3569        to see one of these when an exec() has happened, is if the user
3570        caught a vfork, and then said "finish".  Ordinarily a finish just
3571        carries them to the call-site of the current callee, by setting
3572        a temporary bp there and resuming.  But in this case, the finish
3573        will carry them entirely through the vfork & exec.
3574
3575        We don't want to allow a bp_finish to remain inserted now.  But
3576        we can't safely delete it, 'cause finish_command has a handle to
3577        the bp on a bpstat, and will later want to delete it.  There's a
3578        chance (and I've seen it happen) that if we delete the bp_finish
3579        here, that its storage will get reused by the time finish_command
3580        gets 'round to deleting the "use to be a bp_finish" breakpoint.
3581        We really must allow finish_command to delete a bp_finish.
3582
3583        In the absence of a general solution for the "how do we know
3584        it's safe to delete something others may have handles to?"
3585        problem, what we'll do here is just uninsert the bp_finish, and
3586        let finish_command delete it.
3587
3588        (We know the bp_finish is "doomed" in the sense that it's
3589        momentary, and will be deleted as soon as finish_command sees
3590        the inferior stopped.  So it doesn't matter that the bp's
3591        address is probably bogus in the new a.out, unlike e.g., the
3592        solib breakpoints.)  */
3593
3594     if (b->type == bp_finish)
3595       {
3596         continue;
3597       }
3598
3599     /* Without a symbolic address, we have little hope of the
3600        pre-exec() address meaning the same thing in the post-exec()
3601        a.out.  */
3602     if (breakpoint_event_location_empty_p (b))
3603       {
3604         delete_breakpoint (b);
3605         continue;
3606       }
3607   }
3608 }
3609
3610 int
3611 detach_breakpoints (ptid_t ptid)
3612 {
3613   struct bp_location *bl, **blp_tmp;
3614   int val = 0;
3615   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
3616   struct inferior *inf = current_inferior ();
3617
3618   if (ptid.pid () == inferior_ptid.pid ())
3619     error (_("Cannot detach breakpoints of inferior_ptid"));
3620
3621   /* Set inferior_ptid; remove_breakpoint_1 uses this global.  */
3622   inferior_ptid = ptid;
3623   ALL_BP_LOCATIONS (bl, blp_tmp)
3624   {
3625     if (bl->pspace != inf->pspace)
3626       continue;
3627
3628     /* This function must physically remove breakpoints locations
3629        from the specified ptid, without modifying the breakpoint
3630        package's state.  Locations of type bp_loc_other are only
3631        maintained at GDB side.  So, there is no need to remove
3632        these bp_loc_other locations.  Moreover, removing these
3633        would modify the breakpoint package's state.  */
3634     if (bl->loc_type == bp_loc_other)
3635       continue;
3636
3637     if (bl->inserted)
3638       val |= remove_breakpoint_1 (bl, DETACH_BREAKPOINT);
3639   }
3640
3641   return val;
3642 }
3643
3644 /* Remove the breakpoint location BL from the current address space.
3645    Note that this is used to detach breakpoints from a child fork.
3646    When we get here, the child isn't in the inferior list, and neither
3647    do we have objects to represent its address space --- we should
3648    *not* look at bl->pspace->aspace here.  */
3649
3650 static int
3651 remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason)
3652 {
3653   int val;
3654
3655   /* BL is never in moribund_locations by our callers.  */
3656   gdb_assert (bl->owner != NULL);
3657
3658   /* The type of none suggests that owner is actually deleted.
3659      This should not ever happen.  */
3660   gdb_assert (bl->owner->type != bp_none);
3661
3662   if (bl->loc_type == bp_loc_software_breakpoint
3663       || bl->loc_type == bp_loc_hardware_breakpoint)
3664     {
3665       /* "Normal" instruction breakpoint: either the standard
3666          trap-instruction bp (bp_breakpoint), or a
3667          bp_hardware_breakpoint.  */
3668
3669       /* First check to see if we have to handle an overlay.  */
3670       if (overlay_debugging == ovly_off
3671           || bl->section == NULL
3672           || !(section_is_overlay (bl->section)))
3673         {
3674           /* No overlay handling: just remove the breakpoint.  */
3675
3676           /* If we're trying to uninsert a memory breakpoint that we
3677              know is set in a dynamic object that is marked
3678              shlib_disabled, then either the dynamic object was
3679              removed with "remove-symbol-file" or with
3680              "nosharedlibrary".  In the former case, we don't know
3681              whether another dynamic object might have loaded over the
3682              breakpoint's address -- the user might well let us know
3683              about it next with add-symbol-file (the whole point of
3684              add-symbol-file is letting the user manually maintain a
3685              list of dynamically loaded objects).  If we have the
3686              breakpoint's shadow memory, that is, this is a software
3687              breakpoint managed by GDB, check whether the breakpoint
3688              is still inserted in memory, to avoid overwriting wrong
3689              code with stale saved shadow contents.  Note that HW
3690              breakpoints don't have shadow memory, as they're
3691              implemented using a mechanism that is not dependent on
3692              being able to modify the target's memory, and as such
3693              they should always be removed.  */
3694           if (bl->shlib_disabled
3695               && bl->target_info.shadow_len != 0
3696               && !memory_validate_breakpoint (bl->gdbarch, &bl->target_info))
3697             val = 0;
3698           else
3699             val = bl->owner->ops->remove_location (bl, reason);
3700         }
3701       else
3702         {
3703           /* This breakpoint is in an overlay section.
3704              Did we set a breakpoint at the LMA?  */
3705           if (!overlay_events_enabled)
3706               {
3707                 /* Yes -- overlay event support is not active, so we
3708                    should have set a breakpoint at the LMA.  Remove it.  
3709                 */
3710                 /* Ignore any failures: if the LMA is in ROM, we will
3711                    have already warned when we failed to insert it.  */
3712                 if (bl->loc_type == bp_loc_hardware_breakpoint)
3713                   target_remove_hw_breakpoint (bl->gdbarch,
3714                                                &bl->overlay_target_info);
3715                 else
3716                   target_remove_breakpoint (bl->gdbarch,
3717                                             &bl->overlay_target_info,
3718                                             reason);
3719               }
3720           /* Did we set a breakpoint at the VMA? 
3721              If so, we will have marked the breakpoint 'inserted'.  */
3722           if (bl->inserted)
3723             {
3724               /* Yes -- remove it.  Previously we did not bother to
3725                  remove the breakpoint if the section had been
3726                  unmapped, but let's not rely on that being safe.  We
3727                  don't know what the overlay manager might do.  */
3728
3729               /* However, we should remove *software* breakpoints only
3730                  if the section is still mapped, or else we overwrite
3731                  wrong code with the saved shadow contents.  */
3732               if (bl->loc_type == bp_loc_hardware_breakpoint
3733                   || section_is_mapped (bl->section))
3734                 val = bl->owner->ops->remove_location (bl, reason);
3735               else
3736                 val = 0;
3737             }
3738           else
3739             {
3740               /* No -- not inserted, so no need to remove.  No error.  */
3741               val = 0;
3742             }
3743         }
3744
3745       /* In some cases, we might not be able to remove a breakpoint in
3746          a shared library that has already been removed, but we have
3747          not yet processed the shlib unload event.  Similarly for an
3748          unloaded add-symbol-file object - the user might not yet have
3749          had the chance to remove-symbol-file it.  shlib_disabled will
3750          be set if the library/object has already been removed, but
3751          the breakpoint hasn't been uninserted yet, e.g., after
3752          "nosharedlibrary" or "remove-symbol-file" with breakpoints
3753          always-inserted mode.  */
3754       if (val
3755           && (bl->loc_type == bp_loc_software_breakpoint
3756               && (bl->shlib_disabled
3757                   || solib_name_from_address (bl->pspace, bl->address)
3758                   || shared_objfile_contains_address_p (bl->pspace,
3759                                                         bl->address))))
3760         val = 0;
3761
3762       if (val)
3763         return val;
3764       bl->inserted = (reason == DETACH_BREAKPOINT);
3765     }
3766   else if (bl->loc_type == bp_loc_hardware_watchpoint)
3767     {
3768       gdb_assert (bl->owner->ops != NULL
3769                   && bl->owner->ops->remove_location != NULL);
3770
3771       bl->inserted = (reason == DETACH_BREAKPOINT);
3772       bl->owner->ops->remove_location (bl, reason);
3773
3774       /* Failure to remove any of the hardware watchpoints comes here.  */
3775       if (reason == REMOVE_BREAKPOINT && bl->inserted)
3776         warning (_("Could not remove hardware watchpoint %d."),
3777                  bl->owner->number);
3778     }
3779   else if (bl->owner->type == bp_catchpoint
3780            && breakpoint_enabled (bl->owner)
3781            && !bl->duplicate)
3782     {
3783       gdb_assert (bl->owner->ops != NULL
3784                   && bl->owner->ops->remove_location != NULL);
3785
3786       val = bl->owner->ops->remove_location (bl, reason);
3787       if (val)
3788         return val;
3789
3790       bl->inserted = (reason == DETACH_BREAKPOINT);
3791     }
3792
3793   return 0;
3794 }
3795
3796 static int
3797 remove_breakpoint (struct bp_location *bl)
3798 {
3799   /* BL is never in moribund_locations by our callers.  */
3800   gdb_assert (bl->owner != NULL);
3801
3802   /* The type of none suggests that owner is actually deleted.
3803      This should not ever happen.  */
3804   gdb_assert (bl->owner->type != bp_none);
3805
3806   scoped_restore_current_pspace_and_thread restore_pspace_thread;
3807
3808   switch_to_program_space_and_thread (bl->pspace);
3809
3810   return remove_breakpoint_1 (bl, REMOVE_BREAKPOINT);
3811 }
3812
3813 /* Clear the "inserted" flag in all breakpoints.  */
3814
3815 void
3816 mark_breakpoints_out (void)
3817 {
3818   struct bp_location *bl, **blp_tmp;
3819
3820   ALL_BP_LOCATIONS (bl, blp_tmp)
3821     if (bl->pspace == current_program_space)
3822       bl->inserted = 0;
3823 }
3824
3825 /* Clear the "inserted" flag in all breakpoints and delete any
3826    breakpoints which should go away between runs of the program.
3827
3828    Plus other such housekeeping that has to be done for breakpoints
3829    between runs.
3830
3831    Note: this function gets called at the end of a run (by
3832    generic_mourn_inferior) and when a run begins (by
3833    init_wait_for_inferior).  */
3834
3835
3836
3837 void
3838 breakpoint_init_inferior (enum inf_context context)
3839 {
3840   struct breakpoint *b, *b_tmp;
3841   struct program_space *pspace = current_program_space;
3842
3843   /* If breakpoint locations are shared across processes, then there's
3844      nothing to do.  */
3845   if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3846     return;
3847
3848   mark_breakpoints_out ();
3849
3850   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3851   {
3852     if (b->loc && b->loc->pspace != pspace)
3853       continue;
3854
3855     switch (b->type)
3856       {
3857       case bp_call_dummy:
3858       case bp_longjmp_call_dummy:
3859
3860         /* If the call dummy breakpoint is at the entry point it will
3861            cause problems when the inferior is rerun, so we better get
3862            rid of it.  */
3863
3864       case bp_watchpoint_scope:
3865
3866         /* Also get rid of scope breakpoints.  */
3867
3868       case bp_shlib_event:
3869
3870         /* Also remove solib event breakpoints.  Their addresses may
3871            have changed since the last time we ran the program.
3872            Actually we may now be debugging against different target;
3873            and so the solib backend that installed this breakpoint may
3874            not be used in by the target.  E.g.,
3875
3876            (gdb) file prog-linux
3877            (gdb) run               # native linux target
3878            ...
3879            (gdb) kill
3880            (gdb) file prog-win.exe
3881            (gdb) tar rem :9999     # remote Windows gdbserver.
3882         */
3883
3884       case bp_step_resume:
3885
3886         /* Also remove step-resume breakpoints.  */
3887
3888       case bp_single_step:
3889
3890         /* Also remove single-step breakpoints.  */
3891
3892         delete_breakpoint (b);
3893         break;
3894
3895       case bp_watchpoint:
3896       case bp_hardware_watchpoint:
3897       case bp_read_watchpoint:
3898       case bp_access_watchpoint:
3899         {
3900           struct watchpoint *w = (struct watchpoint *) b;
3901
3902           /* Likewise for watchpoints on local expressions.  */
3903           if (w->exp_valid_block != NULL)
3904             delete_breakpoint (b);
3905           else
3906             {
3907               /* Get rid of existing locations, which are no longer
3908                  valid.  New ones will be created in
3909                  update_watchpoint, when the inferior is restarted.
3910                  The next update_global_location_list call will
3911                  garbage collect them.  */
3912               b->loc = NULL;
3913
3914               if (context == inf_starting)
3915                 {
3916                   /* Reset val field to force reread of starting value in
3917                      insert_breakpoints.  */
3918                   w->val.reset (nullptr);
3919                   w->val_valid = 0;
3920                 }
3921             }
3922         }
3923         break;
3924       default:
3925         break;
3926       }
3927   }
3928
3929   /* Get rid of the moribund locations.  */
3930   for (bp_location *bl : moribund_locations)
3931     decref_bp_location (&bl);
3932   moribund_locations.clear ();
3933 }
3934
3935 /* These functions concern about actual breakpoints inserted in the
3936    target --- to e.g. check if we need to do decr_pc adjustment or if
3937    we need to hop over the bkpt --- so we check for address space
3938    match, not program space.  */
3939
3940 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3941    exists at PC.  It returns ordinary_breakpoint_here if it's an
3942    ordinary breakpoint, or permanent_breakpoint_here if it's a
3943    permanent breakpoint.
3944    - When continuing from a location with an ordinary breakpoint, we
3945      actually single step once before calling insert_breakpoints.
3946    - When continuing from a location with a permanent breakpoint, we
3947      need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3948      the target, to advance the PC past the breakpoint.  */
3949
3950 enum breakpoint_here
3951 breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
3952 {
3953   struct bp_location *bl, **blp_tmp;
3954   int any_breakpoint_here = 0;
3955
3956   ALL_BP_LOCATIONS (bl, blp_tmp)
3957     {
3958       if (bl->loc_type != bp_loc_software_breakpoint
3959           && bl->loc_type != bp_loc_hardware_breakpoint)
3960         continue;
3961
3962       /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL.  */
3963       if ((breakpoint_enabled (bl->owner)
3964            || bl->permanent)
3965           && breakpoint_location_address_match (bl, aspace, pc))
3966         {
3967           if (overlay_debugging 
3968               && section_is_overlay (bl->section)
3969               && !section_is_mapped (bl->section))
3970             continue;           /* unmapped overlay -- can't be a match */
3971           else if (bl->permanent)
3972             return permanent_breakpoint_here;
3973           else
3974             any_breakpoint_here = 1;
3975         }
3976     }
3977
3978   return any_breakpoint_here ? ordinary_breakpoint_here : no_breakpoint_here;
3979 }
3980
3981 /* See breakpoint.h.  */
3982
3983 int
3984 breakpoint_in_range_p (const address_space *aspace,
3985                        CORE_ADDR addr, ULONGEST len)
3986 {
3987   struct bp_location *bl, **blp_tmp;
3988
3989   ALL_BP_LOCATIONS (bl, blp_tmp)
3990     {
3991       if (bl->loc_type != bp_loc_software_breakpoint
3992           && bl->loc_type != bp_loc_hardware_breakpoint)
3993         continue;
3994
3995       if ((breakpoint_enabled (bl->owner)
3996            || bl->permanent)
3997           && breakpoint_location_address_range_overlap (bl, aspace,
3998                                                         addr, len))
3999         {
4000           if (overlay_debugging
4001               && section_is_overlay (bl->section)
4002               && !section_is_mapped (bl->section))
4003             {
4004               /* Unmapped overlay -- can't be a match.  */
4005               continue;
4006             }
4007
4008           return 1;
4009         }
4010     }
4011
4012   return 0;
4013 }
4014
4015 /* Return true if there's a moribund breakpoint at PC.  */
4016
4017 int
4018 moribund_breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
4019 {
4020   for (bp_location *loc : moribund_locations)
4021     if (breakpoint_location_address_match (loc, aspace, pc))
4022       return 1;
4023
4024   return 0;
4025 }
4026
4027 /* Returns non-zero iff BL is inserted at PC, in address space
4028    ASPACE.  */
4029
4030 static int
4031 bp_location_inserted_here_p (struct bp_location *bl,
4032                              const address_space *aspace, CORE_ADDR pc)
4033 {
4034   if (bl->inserted
4035       && breakpoint_address_match (bl->pspace->aspace, bl->address,
4036                                    aspace, pc))
4037     {
4038       if (overlay_debugging
4039           && section_is_overlay (bl->section)
4040           && !section_is_mapped (bl->section))
4041         return 0;               /* unmapped overlay -- can't be a match */
4042       else
4043         return 1;
4044     }
4045   return 0;
4046 }
4047
4048 /* Returns non-zero iff there's a breakpoint inserted at PC.  */
4049
4050 int
4051 breakpoint_inserted_here_p (const address_space *aspace, CORE_ADDR pc)
4052 {
4053   struct bp_location **blp, **blp_tmp = NULL;
4054
4055   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4056     {
4057       struct bp_location *bl = *blp;
4058
4059       if (bl->loc_type != bp_loc_software_breakpoint
4060           && bl->loc_type != bp_loc_hardware_breakpoint)
4061         continue;
4062
4063       if (bp_location_inserted_here_p (bl, aspace, pc))
4064         return 1;
4065     }
4066   return 0;
4067 }
4068
4069 /* This function returns non-zero iff there is a software breakpoint
4070    inserted at PC.  */
4071
4072 int
4073 software_breakpoint_inserted_here_p (const address_space *aspace,
4074                                      CORE_ADDR pc)
4075 {
4076   struct bp_location **blp, **blp_tmp = NULL;
4077
4078   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4079     {
4080       struct bp_location *bl = *blp;
4081
4082       if (bl->loc_type != bp_loc_software_breakpoint)
4083         continue;
4084
4085       if (bp_location_inserted_here_p (bl, aspace, pc))
4086         return 1;
4087     }
4088
4089   return 0;
4090 }
4091
4092 /* See breakpoint.h.  */
4093
4094 int
4095 hardware_breakpoint_inserted_here_p (const address_space *aspace,
4096                                      CORE_ADDR pc)
4097 {
4098   struct bp_location **blp, **blp_tmp = NULL;
4099
4100   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4101     {
4102       struct bp_location *bl = *blp;
4103
4104       if (bl->loc_type != bp_loc_hardware_breakpoint)
4105         continue;
4106
4107       if (bp_location_inserted_here_p (bl, aspace, pc))
4108         return 1;
4109     }
4110
4111   return 0;
4112 }
4113
4114 int
4115 hardware_watchpoint_inserted_in_range (const address_space *aspace,
4116                                        CORE_ADDR addr, ULONGEST len)
4117 {
4118   struct breakpoint *bpt;
4119
4120   ALL_BREAKPOINTS (bpt)
4121     {
4122       struct bp_location *loc;
4123
4124       if (bpt->type != bp_hardware_watchpoint
4125           && bpt->type != bp_access_watchpoint)
4126         continue;
4127
4128       if (!breakpoint_enabled (bpt))
4129         continue;
4130
4131       for (loc = bpt->loc; loc; loc = loc->next)
4132         if (loc->pspace->aspace == aspace && loc->inserted)
4133           {
4134             CORE_ADDR l, h;
4135
4136             /* Check for intersection.  */
4137             l = std::max<CORE_ADDR> (loc->address, addr);
4138             h = std::min<CORE_ADDR> (loc->address + loc->length, addr + len);
4139             if (l < h)
4140               return 1;
4141           }
4142     }
4143   return 0;
4144 }
4145 \f
4146
4147 /* bpstat stuff.  External routines' interfaces are documented
4148    in breakpoint.h.  */
4149
4150 int
4151 is_catchpoint (struct breakpoint *ep)
4152 {
4153   return (ep->type == bp_catchpoint);
4154 }
4155
4156 /* Frees any storage that is part of a bpstat.  Does not walk the
4157    'next' chain.  */
4158
4159 bpstats::~bpstats ()
4160 {
4161   if (bp_location_at != NULL)
4162     decref_bp_location (&bp_location_at);
4163 }
4164
4165 /* Clear a bpstat so that it says we are not at any breakpoint.
4166    Also free any storage that is part of a bpstat.  */
4167
4168 void
4169 bpstat_clear (bpstat *bsp)
4170 {
4171   bpstat p;
4172   bpstat q;
4173
4174   if (bsp == 0)
4175     return;
4176   p = *bsp;
4177   while (p != NULL)
4178     {
4179       q = p->next;
4180       delete p;
4181       p = q;
4182     }
4183   *bsp = NULL;
4184 }
4185
4186 bpstats::bpstats (const bpstats &other)
4187   : next (NULL),
4188     bp_location_at (other.bp_location_at),
4189     breakpoint_at (other.breakpoint_at),
4190     commands (other.commands),
4191     print (other.print),
4192     stop (other.stop),
4193     print_it (other.print_it)
4194 {
4195   if (other.old_val != NULL)
4196     old_val = release_value (value_copy (other.old_val.get ()));
4197   incref_bp_location (bp_location_at);
4198 }
4199
4200 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
4201    is part of the bpstat is copied as well.  */
4202
4203 bpstat
4204 bpstat_copy (bpstat bs)
4205 {
4206   bpstat p = NULL;
4207   bpstat tmp;
4208   bpstat retval = NULL;
4209
4210   if (bs == NULL)
4211     return bs;
4212
4213   for (; bs != NULL; bs = bs->next)
4214     {
4215       tmp = new bpstats (*bs);
4216
4217       if (p == NULL)
4218         /* This is the first thing in the chain.  */
4219         retval = tmp;
4220       else
4221         p->next = tmp;
4222       p = tmp;
4223     }
4224   p->next = NULL;
4225   return retval;
4226 }
4227
4228 /* Find the bpstat associated with this breakpoint.  */
4229
4230 bpstat
4231 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
4232 {
4233   if (bsp == NULL)
4234     return NULL;
4235
4236   for (; bsp != NULL; bsp = bsp->next)
4237     {
4238       if (bsp->breakpoint_at == breakpoint)
4239         return bsp;
4240     }
4241   return NULL;
4242 }
4243
4244 /* See breakpoint.h.  */
4245
4246 int
4247 bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
4248 {
4249   for (; bsp != NULL; bsp = bsp->next)
4250     {
4251       if (bsp->breakpoint_at == NULL)
4252         {
4253           /* A moribund location can never explain a signal other than
4254              GDB_SIGNAL_TRAP.  */
4255           if (sig == GDB_SIGNAL_TRAP)
4256             return 1;
4257         }
4258       else
4259         {
4260           if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
4261                                                         sig))
4262             return 1;
4263         }
4264     }
4265
4266   return 0;
4267 }
4268
4269 /* Put in *NUM the breakpoint number of the first breakpoint we are
4270    stopped at.  *BSP upon return is a bpstat which points to the
4271    remaining breakpoints stopped at (but which is not guaranteed to be
4272    good for anything but further calls to bpstat_num).
4273
4274    Return 0 if passed a bpstat which does not indicate any breakpoints.
4275    Return -1 if stopped at a breakpoint that has been deleted since
4276    we set it.
4277    Return 1 otherwise.  */
4278
4279 int
4280 bpstat_num (bpstat *bsp, int *num)
4281 {
4282   struct breakpoint *b;
4283
4284   if ((*bsp) == NULL)
4285     return 0;                   /* No more breakpoint values */
4286
4287   /* We assume we'll never have several bpstats that correspond to a
4288      single breakpoint -- otherwise, this function might return the
4289      same number more than once and this will look ugly.  */
4290   b = (*bsp)->breakpoint_at;
4291   *bsp = (*bsp)->next;
4292   if (b == NULL)
4293     return -1;                  /* breakpoint that's been deleted since */
4294
4295   *num = b->number;             /* We have its number */
4296   return 1;
4297 }
4298
4299 /* See breakpoint.h.  */
4300
4301 void
4302 bpstat_clear_actions (void)
4303 {
4304   bpstat bs;
4305
4306   if (inferior_ptid == null_ptid)
4307     return;
4308
4309   thread_info *tp = inferior_thread ();
4310   for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
4311     {
4312       bs->commands = NULL;
4313       bs->old_val.reset (nullptr);
4314     }
4315 }
4316
4317 /* Called when a command is about to proceed the inferior.  */
4318
4319 static void
4320 breakpoint_about_to_proceed (void)
4321 {
4322   if (inferior_ptid != null_ptid)
4323     {
4324       struct thread_info *tp = inferior_thread ();
4325
4326       /* Allow inferior function calls in breakpoint commands to not
4327          interrupt the command list.  When the call finishes
4328          successfully, the inferior will be standing at the same
4329          breakpoint as if nothing happened.  */
4330       if (tp->control.in_infcall)
4331         return;
4332     }
4333
4334   breakpoint_proceeded = 1;
4335 }
4336
4337 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4338    or its equivalent.  */
4339
4340 static int
4341 command_line_is_silent (struct command_line *cmd)
4342 {
4343   return cmd && (strcmp ("silent", cmd->line) == 0);
4344 }
4345
4346 /* Execute all the commands associated with all the breakpoints at
4347    this location.  Any of these commands could cause the process to
4348    proceed beyond this point, etc.  We look out for such changes by
4349    checking the global "breakpoint_proceeded" after each command.
4350
4351    Returns true if a breakpoint command resumed the inferior.  In that
4352    case, it is the caller's responsibility to recall it again with the
4353    bpstat of the current thread.  */
4354
4355 static int
4356 bpstat_do_actions_1 (bpstat *bsp)
4357 {
4358   bpstat bs;
4359   int again = 0;
4360
4361   /* Avoid endless recursion if a `source' command is contained
4362      in bs->commands.  */
4363   if (executing_breakpoint_commands)
4364     return 0;
4365
4366   scoped_restore save_executing
4367     = make_scoped_restore (&executing_breakpoint_commands, 1);
4368
4369   scoped_restore preventer = prevent_dont_repeat ();
4370
4371   /* This pointer will iterate over the list of bpstat's.  */
4372   bs = *bsp;
4373
4374   breakpoint_proceeded = 0;
4375   for (; bs != NULL; bs = bs->next)
4376     {
4377       struct command_line *cmd = NULL;
4378
4379       /* Take ownership of the BSP's command tree, if it has one.
4380
4381          The command tree could legitimately contain commands like
4382          'step' and 'next', which call clear_proceed_status, which
4383          frees stop_bpstat's command tree.  To make sure this doesn't
4384          free the tree we're executing out from under us, we need to
4385          take ownership of the tree ourselves.  Since a given bpstat's
4386          commands are only executed once, we don't need to copy it; we
4387          can clear the pointer in the bpstat, and make sure we free
4388          the tree when we're done.  */
4389       counted_command_line ccmd = bs->commands;
4390       bs->commands = NULL;
4391       if (ccmd != NULL)
4392         cmd = ccmd.get ();
4393       if (command_line_is_silent (cmd))
4394         {
4395           /* The action has been already done by bpstat_stop_status.  */
4396           cmd = cmd->next;
4397         }
4398
4399       while (cmd != NULL)
4400         {
4401           execute_control_command (cmd);
4402
4403           if (breakpoint_proceeded)
4404             break;
4405           else
4406             cmd = cmd->next;
4407         }
4408
4409       if (breakpoint_proceeded)
4410         {
4411           if (current_ui->async)
4412             /* If we are in async mode, then the target might be still
4413                running, not stopped at any breakpoint, so nothing for
4414                us to do here -- just return to the event loop.  */
4415             ;
4416           else
4417             /* In sync mode, when execute_control_command returns
4418                we're already standing on the next breakpoint.
4419                Breakpoint commands for that stop were not run, since
4420                execute_command does not run breakpoint commands --
4421                only command_line_handler does, but that one is not
4422                involved in execution of breakpoint commands.  So, we
4423                can now execute breakpoint commands.  It should be
4424                noted that making execute_command do bpstat actions is
4425                not an option -- in this case we'll have recursive
4426                invocation of bpstat for each breakpoint with a
4427                command, and can easily blow up GDB stack.  Instead, we
4428                return true, which will trigger the caller to recall us
4429                with the new stop_bpstat.  */
4430             again = 1;
4431           break;
4432         }
4433     }
4434   return again;
4435 }
4436
4437 /* Helper for bpstat_do_actions.  Get the current thread, if there's
4438    one, is alive and has execution.  Return NULL otherwise.  */
4439
4440 static thread_info *
4441 get_bpstat_thread ()
4442 {
4443   if (inferior_ptid == null_ptid || !target_has_execution)
4444     return NULL;
4445
4446   thread_info *tp = inferior_thread ();
4447   if (tp->state == THREAD_EXITED || tp->executing)
4448     return NULL;
4449   return tp;
4450 }
4451
4452 void
4453 bpstat_do_actions (void)
4454 {
4455   auto cleanup_if_error = make_scope_exit (bpstat_clear_actions);
4456   thread_info *tp;
4457
4458   /* Do any commands attached to breakpoint we are stopped at.  */
4459   while ((tp = get_bpstat_thread ()) != NULL)
4460     {
4461       /* Since in sync mode, bpstat_do_actions may resume the
4462          inferior, and only return when it is stopped at the next
4463          breakpoint, we keep doing breakpoint actions until it returns
4464          false to indicate the inferior was not resumed.  */
4465       if (!bpstat_do_actions_1 (&tp->control.stop_bpstat))
4466         break;
4467     }
4468
4469   cleanup_if_error.release ();
4470 }
4471
4472 /* Print out the (old or new) value associated with a watchpoint.  */
4473
4474 static void
4475 watchpoint_value_print (struct value *val, struct ui_file *stream)
4476 {
4477   if (val == NULL)
4478     fprintf_unfiltered (stream, _("<unreadable>"));
4479   else
4480     {
4481       struct value_print_options opts;
4482       get_user_print_options (&opts);
4483       value_print (val, stream, &opts);
4484     }
4485 }
4486
4487 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4488    debugging multiple threads.  */
4489
4490 void
4491 maybe_print_thread_hit_breakpoint (struct ui_out *uiout)
4492 {
4493   if (uiout->is_mi_like_p ())
4494     return;
4495
4496   uiout->text ("\n");
4497
4498   if (show_thread_that_caused_stop ())
4499     {
4500       const char *name;
4501       struct thread_info *thr = inferior_thread ();
4502
4503       uiout->text ("Thread ");
4504       uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
4505
4506       name = thr->name != NULL ? thr->name : target_thread_name (thr);
4507       if (name != NULL)
4508         {
4509           uiout->text (" \"");
4510           uiout->field_fmt ("name", "%s", name);
4511           uiout->text ("\"");
4512         }
4513
4514       uiout->text (" hit ");
4515     }
4516 }
4517
4518 /* Generic routine for printing messages indicating why we
4519    stopped.  The behavior of this function depends on the value
4520    'print_it' in the bpstat structure.  Under some circumstances we
4521    may decide not to print anything here and delegate the task to
4522    normal_stop().  */
4523
4524 static enum print_stop_action
4525 print_bp_stop_message (bpstat bs)
4526 {
4527   switch (bs->print_it)
4528     {
4529     case print_it_noop:
4530       /* Nothing should be printed for this bpstat entry.  */
4531       return PRINT_UNKNOWN;
4532       break;
4533
4534     case print_it_done:
4535       /* We still want to print the frame, but we already printed the
4536          relevant messages.  */
4537       return PRINT_SRC_AND_LOC;
4538       break;
4539
4540     case print_it_normal:
4541       {
4542         struct breakpoint *b = bs->breakpoint_at;
4543
4544         /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4545            which has since been deleted.  */
4546         if (b == NULL)
4547           return PRINT_UNKNOWN;
4548
4549         /* Normal case.  Call the breakpoint's print_it method.  */
4550         return b->ops->print_it (bs);
4551       }
4552       break;
4553
4554     default:
4555       internal_error (__FILE__, __LINE__,
4556                       _("print_bp_stop_message: unrecognized enum value"));
4557       break;
4558     }
4559 }
4560
4561 /* A helper function that prints a shared library stopped event.  */
4562
4563 static void
4564 print_solib_event (int is_catchpoint)
4565 {
4566   bool any_deleted = !current_program_space->deleted_solibs.empty ();
4567   bool any_added = !current_program_space->added_solibs.empty ();
4568
4569   if (!is_catchpoint)
4570     {
4571       if (any_added || any_deleted)
4572         current_uiout->text (_("Stopped due to shared library event:\n"));
4573       else
4574         current_uiout->text (_("Stopped due to shared library event (no "
4575                                "libraries added or removed)\n"));
4576     }
4577
4578   if (current_uiout->is_mi_like_p ())
4579     current_uiout->field_string ("reason",
4580                                  async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
4581
4582   if (any_deleted)
4583     {
4584       current_uiout->text (_("  Inferior unloaded "));
4585       ui_out_emit_list list_emitter (current_uiout, "removed");
4586       for (int ix = 0; ix < current_program_space->deleted_solibs.size (); ix++)
4587         {
4588           const std::string &name = current_program_space->deleted_solibs[ix];
4589
4590           if (ix > 0)
4591             current_uiout->text ("    ");
4592           current_uiout->field_string ("library", name);
4593           current_uiout->text ("\n");
4594         }
4595     }
4596
4597   if (any_added)
4598     {
4599       current_uiout->text (_("  Inferior loaded "));
4600       ui_out_emit_list list_emitter (current_uiout, "added");
4601       bool first = true;
4602       for (so_list *iter : current_program_space->added_solibs)
4603         {
4604           if (!first)
4605             current_uiout->text ("    ");
4606           first = false;
4607           current_uiout->field_string ("library", iter->so_name);
4608           current_uiout->text ("\n");
4609         }
4610     }
4611 }
4612
4613 /* Print a message indicating what happened.  This is called from
4614    normal_stop().  The input to this routine is the head of the bpstat
4615    list - a list of the eventpoints that caused this stop.  KIND is
4616    the target_waitkind for the stopping event.  This
4617    routine calls the generic print routine for printing a message
4618    about reasons for stopping.  This will print (for example) the
4619    "Breakpoint n," part of the output.  The return value of this
4620    routine is one of:
4621
4622    PRINT_UNKNOWN: Means we printed nothing.
4623    PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4624    code to print the location.  An example is 
4625    "Breakpoint 1, " which should be followed by
4626    the location.
4627    PRINT_SRC_ONLY: Means we printed something, but there is no need
4628    to also print the location part of the message.
4629    An example is the catch/throw messages, which
4630    don't require a location appended to the end.
4631    PRINT_NOTHING: We have done some printing and we don't need any 
4632    further info to be printed.  */
4633
4634 enum print_stop_action
4635 bpstat_print (bpstat bs, int kind)
4636 {
4637   enum print_stop_action val;
4638
4639   /* Maybe another breakpoint in the chain caused us to stop.
4640      (Currently all watchpoints go on the bpstat whether hit or not.
4641      That probably could (should) be changed, provided care is taken
4642      with respect to bpstat_explains_signal).  */
4643   for (; bs; bs = bs->next)
4644     {
4645       val = print_bp_stop_message (bs);
4646       if (val == PRINT_SRC_ONLY 
4647           || val == PRINT_SRC_AND_LOC 
4648           || val == PRINT_NOTHING)
4649         return val;
4650     }
4651
4652   /* If we had hit a shared library event breakpoint,
4653      print_bp_stop_message would print out this message.  If we hit an
4654      OS-level shared library event, do the same thing.  */
4655   if (kind == TARGET_WAITKIND_LOADED)
4656     {
4657       print_solib_event (0);
4658       return PRINT_NOTHING;
4659     }
4660
4661   /* We reached the end of the chain, or we got a null BS to start
4662      with and nothing was printed.  */
4663   return PRINT_UNKNOWN;
4664 }
4665
4666 /* Evaluate the boolean expression EXP and return the result.  */
4667
4668 static bool
4669 breakpoint_cond_eval (expression *exp)
4670 {
4671   struct value *mark = value_mark ();
4672   bool res = value_true (evaluate_expression (exp));
4673
4674   value_free_to_mark (mark);
4675   return res;
4676 }
4677
4678 /* Allocate a new bpstat.  Link it to the FIFO list by BS_LINK_POINTER.  */
4679
4680 bpstats::bpstats (struct bp_location *bl, bpstat **bs_link_pointer)
4681   : next (NULL),
4682     bp_location_at (bl),
4683     breakpoint_at (bl->owner),
4684     commands (NULL),
4685     print (0),
4686     stop (0),
4687     print_it (print_it_normal)
4688 {
4689   incref_bp_location (bl);
4690   **bs_link_pointer = this;
4691   *bs_link_pointer = &next;
4692 }
4693
4694 bpstats::bpstats ()
4695   : next (NULL),
4696     bp_location_at (NULL),
4697     breakpoint_at (NULL),
4698     commands (NULL),
4699     print (0),
4700     stop (0),
4701     print_it (print_it_normal)
4702 {
4703 }
4704 \f
4705 /* The target has stopped with waitstatus WS.  Check if any hardware
4706    watchpoints have triggered, according to the target.  */
4707
4708 int
4709 watchpoints_triggered (struct target_waitstatus *ws)
4710 {
4711   bool stopped_by_watchpoint = target_stopped_by_watchpoint ();
4712   CORE_ADDR addr;
4713   struct breakpoint *b;
4714
4715   if (!stopped_by_watchpoint)
4716     {
4717       /* We were not stopped by a watchpoint.  Mark all watchpoints
4718          as not triggered.  */
4719       ALL_BREAKPOINTS (b)
4720         if (is_hardware_watchpoint (b))
4721           {
4722             struct watchpoint *w = (struct watchpoint *) b;
4723
4724             w->watchpoint_triggered = watch_triggered_no;
4725           }
4726
4727       return 0;
4728     }
4729
4730   if (!target_stopped_data_address (current_top_target (), &addr))
4731     {
4732       /* We were stopped by a watchpoint, but we don't know where.
4733          Mark all watchpoints as unknown.  */
4734       ALL_BREAKPOINTS (b)
4735         if (is_hardware_watchpoint (b))
4736           {
4737             struct watchpoint *w = (struct watchpoint *) b;
4738
4739             w->watchpoint_triggered = watch_triggered_unknown;
4740           }
4741
4742       return 1;
4743     }
4744
4745   /* The target could report the data address.  Mark watchpoints
4746      affected by this data address as triggered, and all others as not
4747      triggered.  */
4748
4749   ALL_BREAKPOINTS (b)
4750     if (is_hardware_watchpoint (b))
4751       {
4752         struct watchpoint *w = (struct watchpoint *) b;
4753         struct bp_location *loc;
4754
4755         w->watchpoint_triggered = watch_triggered_no;
4756         for (loc = b->loc; loc; loc = loc->next)
4757           {
4758             if (is_masked_watchpoint (b))
4759               {
4760                 CORE_ADDR newaddr = addr & w->hw_wp_mask;
4761                 CORE_ADDR start = loc->address & w->hw_wp_mask;
4762
4763                 if (newaddr == start)
4764                   {
4765                     w->watchpoint_triggered = watch_triggered_yes;
4766                     break;
4767                   }
4768               }
4769             /* Exact match not required.  Within range is sufficient.  */
4770             else if (target_watchpoint_addr_within_range (current_top_target (),
4771                                                          addr, loc->address,
4772                                                          loc->length))
4773               {
4774                 w->watchpoint_triggered = watch_triggered_yes;
4775                 break;
4776               }
4777           }
4778       }
4779
4780   return 1;
4781 }
4782
4783 /* Possible return values for watchpoint_check.  */
4784 enum wp_check_result
4785   {
4786     /* The watchpoint has been deleted.  */
4787     WP_DELETED = 1,
4788
4789     /* The value has changed.  */
4790     WP_VALUE_CHANGED = 2,
4791
4792     /* The value has not changed.  */
4793     WP_VALUE_NOT_CHANGED = 3,
4794
4795     /* Ignore this watchpoint, no matter if the value changed or not.  */
4796     WP_IGNORE = 4,
4797   };
4798
4799 #define BP_TEMPFLAG 1
4800 #define BP_HARDWAREFLAG 2
4801
4802 /* Evaluate watchpoint condition expression and check if its value
4803    changed.  */
4804
4805 static wp_check_result
4806 watchpoint_check (bpstat bs)
4807 {
4808   struct watchpoint *b;
4809   struct frame_info *fr;
4810   int within_current_scope;
4811
4812   /* BS is built from an existing struct breakpoint.  */
4813   gdb_assert (bs->breakpoint_at != NULL);
4814   b = (struct watchpoint *) bs->breakpoint_at;
4815
4816   /* If this is a local watchpoint, we only want to check if the
4817      watchpoint frame is in scope if the current thread is the thread
4818      that was used to create the watchpoint.  */
4819   if (!watchpoint_in_thread_scope (b))
4820     return WP_IGNORE;
4821
4822   if (b->exp_valid_block == NULL)
4823     within_current_scope = 1;
4824   else
4825     {
4826       struct frame_info *frame = get_current_frame ();
4827       struct gdbarch *frame_arch = get_frame_arch (frame);
4828       CORE_ADDR frame_pc = get_frame_pc (frame);
4829
4830       /* stack_frame_destroyed_p() returns a non-zero value if we're
4831          still in the function but the stack frame has already been
4832          invalidated.  Since we can't rely on the values of local
4833          variables after the stack has been destroyed, we are treating
4834          the watchpoint in that state as `not changed' without further
4835          checking.  Don't mark watchpoints as changed if the current
4836          frame is in an epilogue - even if they are in some other
4837          frame, our view of the stack is likely to be wrong and
4838          frame_find_by_id could error out.  */
4839       if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
4840         return WP_IGNORE;
4841
4842       fr = frame_find_by_id (b->watchpoint_frame);
4843       within_current_scope = (fr != NULL);
4844
4845       /* If we've gotten confused in the unwinder, we might have
4846          returned a frame that can't describe this variable.  */
4847       if (within_current_scope)
4848         {
4849           struct symbol *function;
4850
4851           function = get_frame_function (fr);
4852           if (function == NULL
4853               || !contained_in (b->exp_valid_block,
4854                                 SYMBOL_BLOCK_VALUE (function)))
4855             within_current_scope = 0;
4856         }
4857
4858       if (within_current_scope)
4859         /* If we end up stopping, the current frame will get selected
4860            in normal_stop.  So this call to select_frame won't affect
4861            the user.  */
4862         select_frame (fr);
4863     }
4864
4865   if (within_current_scope)
4866     {
4867       /* We use value_{,free_to_}mark because it could be a *long*
4868          time before we return to the command level and call
4869          free_all_values.  We can't call free_all_values because we
4870          might be in the middle of evaluating a function call.  */
4871
4872       int pc = 0;
4873       struct value *mark;
4874       struct value *new_val;
4875
4876       if (is_masked_watchpoint (b))
4877         /* Since we don't know the exact trigger address (from
4878            stopped_data_address), just tell the user we've triggered
4879            a mask watchpoint.  */
4880         return WP_VALUE_CHANGED;
4881
4882       mark = value_mark ();
4883       fetch_subexp_value (b->exp.get (), &pc, &new_val, NULL, NULL, 0);
4884
4885       if (b->val_bitsize != 0)
4886         new_val = extract_bitfield_from_watchpoint_value (b, new_val);
4887
4888       /* We use value_equal_contents instead of value_equal because
4889          the latter coerces an array to a pointer, thus comparing just
4890          the address of the array instead of its contents.  This is
4891          not what we want.  */
4892       if ((b->val != NULL) != (new_val != NULL)
4893           || (b->val != NULL && !value_equal_contents (b->val.get (),
4894                                                        new_val)))
4895         {
4896           bs->old_val = b->val;
4897           b->val = release_value (new_val);
4898           b->val_valid = 1;
4899           if (new_val != NULL)
4900             value_free_to_mark (mark);
4901           return WP_VALUE_CHANGED;
4902         }
4903       else
4904         {
4905           /* Nothing changed.  */
4906           value_free_to_mark (mark);
4907           return WP_VALUE_NOT_CHANGED;
4908         }
4909     }
4910   else
4911     {
4912       /* This seems like the only logical thing to do because
4913          if we temporarily ignored the watchpoint, then when
4914          we reenter the block in which it is valid it contains
4915          garbage (in the case of a function, it may have two
4916          garbage values, one before and one after the prologue).
4917          So we can't even detect the first assignment to it and
4918          watch after that (since the garbage may or may not equal
4919          the first value assigned).  */
4920       /* We print all the stop information in
4921          breakpoint_ops->print_it, but in this case, by the time we
4922          call breakpoint_ops->print_it this bp will be deleted
4923          already.  So we have no choice but print the information
4924          here.  */
4925
4926       SWITCH_THRU_ALL_UIS ()
4927         {
4928           struct ui_out *uiout = current_uiout;
4929
4930           if (uiout->is_mi_like_p ())
4931             uiout->field_string
4932               ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
4933           uiout->text ("\nWatchpoint ");
4934           uiout->field_int ("wpnum", b->number);
4935           uiout->text (" deleted because the program has left the block in\n"
4936                        "which its expression is valid.\n");
4937         }
4938
4939       /* Make sure the watchpoint's commands aren't executed.  */
4940       b->commands = NULL;
4941       watchpoint_del_at_next_stop (b);
4942
4943       return WP_DELETED;
4944     }
4945 }
4946
4947 /* Return true if it looks like target has stopped due to hitting
4948    breakpoint location BL.  This function does not check if we should
4949    stop, only if BL explains the stop.  */
4950
4951 static int
4952 bpstat_check_location (const struct bp_location *bl,
4953                        const address_space *aspace, CORE_ADDR bp_addr,
4954                        const struct target_waitstatus *ws)
4955 {
4956   struct breakpoint *b = bl->owner;
4957
4958   /* BL is from an existing breakpoint.  */
4959   gdb_assert (b != NULL);
4960
4961   return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
4962 }
4963
4964 /* Determine if the watched values have actually changed, and we
4965    should stop.  If not, set BS->stop to 0.  */
4966
4967 static void
4968 bpstat_check_watchpoint (bpstat bs)
4969 {
4970   const struct bp_location *bl;
4971   struct watchpoint *b;
4972
4973   /* BS is built for existing struct breakpoint.  */
4974   bl = bs->bp_location_at;
4975   gdb_assert (bl != NULL);
4976   b = (struct watchpoint *) bs->breakpoint_at;
4977   gdb_assert (b != NULL);
4978
4979     {
4980       int must_check_value = 0;
4981       
4982       if (b->type == bp_watchpoint)
4983         /* For a software watchpoint, we must always check the
4984            watched value.  */
4985         must_check_value = 1;
4986       else if (b->watchpoint_triggered == watch_triggered_yes)
4987         /* We have a hardware watchpoint (read, write, or access)
4988            and the target earlier reported an address watched by
4989            this watchpoint.  */
4990         must_check_value = 1;
4991       else if (b->watchpoint_triggered == watch_triggered_unknown
4992                && b->type == bp_hardware_watchpoint)
4993         /* We were stopped by a hardware watchpoint, but the target could
4994            not report the data address.  We must check the watchpoint's
4995            value.  Access and read watchpoints are out of luck; without
4996            a data address, we can't figure it out.  */
4997         must_check_value = 1;
4998
4999       if (must_check_value)
5000         {
5001           wp_check_result e;
5002
5003           try
5004             {
5005               e = watchpoint_check (bs);
5006             }
5007           catch (const gdb_exception &ex)
5008             {
5009               exception_fprintf (gdb_stderr, ex,
5010                                  "Error evaluating expression "
5011                                  "for watchpoint %d\n",
5012                                  b->number);
5013
5014               SWITCH_THRU_ALL_UIS ()
5015                 {
5016                   printf_filtered (_("Watchpoint %d deleted.\n"),
5017                                    b->number);
5018                 }
5019               watchpoint_del_at_next_stop (b);
5020               e = WP_DELETED;
5021             }
5022
5023           switch (e)
5024             {
5025             case WP_DELETED:
5026               /* We've already printed what needs to be printed.  */
5027               bs->print_it = print_it_done;
5028               /* Stop.  */
5029               break;
5030             case WP_IGNORE:
5031               bs->print_it = print_it_noop;
5032               bs->stop = 0;
5033               break;
5034             case WP_VALUE_CHANGED:
5035               if (b->type == bp_read_watchpoint)
5036                 {
5037                   /* There are two cases to consider here:
5038
5039                      1. We're watching the triggered memory for reads.
5040                      In that case, trust the target, and always report
5041                      the watchpoint hit to the user.  Even though
5042                      reads don't cause value changes, the value may
5043                      have changed since the last time it was read, and
5044                      since we're not trapping writes, we will not see
5045                      those, and as such we should ignore our notion of
5046                      old value.
5047
5048                      2. We're watching the triggered memory for both
5049                      reads and writes.  There are two ways this may
5050                      happen:
5051
5052                      2.1. This is a target that can't break on data
5053                      reads only, but can break on accesses (reads or
5054                      writes), such as e.g., x86.  We detect this case
5055                      at the time we try to insert read watchpoints.
5056
5057                      2.2. Otherwise, the target supports read
5058                      watchpoints, but, the user set an access or write
5059                      watchpoint watching the same memory as this read
5060                      watchpoint.
5061
5062                      If we're watching memory writes as well as reads,
5063                      ignore watchpoint hits when we find that the
5064                      value hasn't changed, as reads don't cause
5065                      changes.  This still gives false positives when
5066                      the program writes the same value to memory as
5067                      what there was already in memory (we will confuse
5068                      it for a read), but it's much better than
5069                      nothing.  */
5070
5071                   int other_write_watchpoint = 0;
5072
5073                   if (bl->watchpoint_type == hw_read)
5074                     {
5075                       struct breakpoint *other_b;
5076
5077                       ALL_BREAKPOINTS (other_b)
5078                         if (other_b->type == bp_hardware_watchpoint
5079                             || other_b->type == bp_access_watchpoint)
5080                           {
5081                             struct watchpoint *other_w =
5082                               (struct watchpoint *) other_b;
5083
5084                             if (other_w->watchpoint_triggered
5085                                 == watch_triggered_yes)
5086                               {
5087                                 other_write_watchpoint = 1;
5088                                 break;
5089                               }
5090                           }
5091                     }
5092
5093                   if (other_write_watchpoint
5094                       || bl->watchpoint_type == hw_access)
5095                     {
5096                       /* We're watching the same memory for writes,
5097                          and the value changed since the last time we
5098                          updated it, so this trap must be for a write.
5099                          Ignore it.  */
5100                       bs->print_it = print_it_noop;
5101                       bs->stop = 0;
5102                     }
5103                 }
5104               break;
5105             case WP_VALUE_NOT_CHANGED:
5106               if (b->type == bp_hardware_watchpoint
5107                   || b->type == bp_watchpoint)
5108                 {
5109                   /* Don't stop: write watchpoints shouldn't fire if
5110                      the value hasn't changed.  */
5111                   bs->print_it = print_it_noop;
5112                   bs->stop = 0;
5113                 }
5114               /* Stop.  */
5115               break;
5116             default:
5117               /* Can't happen.  */
5118               break;
5119             }
5120         }
5121       else      /* must_check_value == 0 */
5122         {
5123           /* This is a case where some watchpoint(s) triggered, but
5124              not at the address of this watchpoint, or else no
5125              watchpoint triggered after all.  So don't print
5126              anything for this watchpoint.  */
5127           bs->print_it = print_it_noop;
5128           bs->stop = 0;
5129         }
5130     }
5131 }
5132
5133 /* For breakpoints that are currently marked as telling gdb to stop,
5134    check conditions (condition proper, frame, thread and ignore count)
5135    of breakpoint referred to by BS.  If we should not stop for this
5136    breakpoint, set BS->stop to 0.  */
5137
5138 static void
5139 bpstat_check_breakpoint_conditions (bpstat bs, thread_info *thread)
5140 {
5141   const struct bp_location *bl;
5142   struct breakpoint *b;
5143   /* Assume stop.  */
5144   bool condition_result = true;
5145   struct expression *cond;
5146
5147   gdb_assert (bs->stop);
5148
5149   /* BS is built for existing struct breakpoint.  */
5150   bl = bs->bp_location_at;
5151   gdb_assert (bl != NULL);
5152   b = bs->breakpoint_at;
5153   gdb_assert (b != NULL);
5154
5155   /* Even if the target evaluated the condition on its end and notified GDB, we
5156      need to do so again since GDB does not know if we stopped due to a
5157      breakpoint or a single step breakpoint.  */
5158
5159   if (frame_id_p (b->frame_id)
5160       && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
5161     {
5162       bs->stop = 0;
5163       return;
5164     }
5165
5166   /* If this is a thread/task-specific breakpoint, don't waste cpu
5167      evaluating the condition if this isn't the specified
5168      thread/task.  */
5169   if ((b->thread != -1 && b->thread != thread->global_num)
5170       || (b->task != 0 && b->task != ada_get_task_number (thread)))
5171     {
5172       bs->stop = 0;
5173       return;
5174     }
5175
5176   /* Evaluate extension language breakpoints that have a "stop" method
5177      implemented.  */
5178   bs->stop = breakpoint_ext_lang_cond_says_stop (b);
5179
5180   if (is_watchpoint (b))
5181     {
5182       struct watchpoint *w = (struct watchpoint *) b;
5183
5184       cond = w->cond_exp.get ();
5185     }
5186   else
5187     cond = bl->cond.get ();
5188
5189   if (cond && b->disposition != disp_del_at_next_stop)
5190     {
5191       int within_current_scope = 1;
5192       struct watchpoint * w;
5193
5194       /* We use value_mark and value_free_to_mark because it could
5195          be a long time before we return to the command level and
5196          call free_all_values.  We can't call free_all_values
5197          because we might be in the middle of evaluating a
5198          function call.  */
5199       struct value *mark = value_mark ();
5200
5201       if (is_watchpoint (b))
5202         w = (struct watchpoint *) b;
5203       else
5204         w = NULL;
5205
5206       /* Need to select the frame, with all that implies so that
5207          the conditions will have the right context.  Because we
5208          use the frame, we will not see an inlined function's
5209          variables when we arrive at a breakpoint at the start
5210          of the inlined function; the current frame will be the
5211          call site.  */
5212       if (w == NULL || w->cond_exp_valid_block == NULL)
5213         select_frame (get_current_frame ());
5214       else
5215         {
5216           struct frame_info *frame;
5217
5218           /* For local watchpoint expressions, which particular
5219              instance of a local is being watched matters, so we
5220              keep track of the frame to evaluate the expression
5221              in.  To evaluate the condition however, it doesn't
5222              really matter which instantiation of the function
5223              where the condition makes sense triggers the
5224              watchpoint.  This allows an expression like "watch
5225              global if q > 10" set in `func', catch writes to
5226              global on all threads that call `func', or catch
5227              writes on all recursive calls of `func' by a single
5228              thread.  We simply always evaluate the condition in
5229              the innermost frame that's executing where it makes
5230              sense to evaluate the condition.  It seems
5231              intuitive.  */
5232           frame = block_innermost_frame (w->cond_exp_valid_block);
5233           if (frame != NULL)
5234             select_frame (frame);
5235           else
5236             within_current_scope = 0;
5237         }
5238       if (within_current_scope)
5239         {
5240           try
5241             {
5242               condition_result = breakpoint_cond_eval (cond);
5243             }
5244           catch (const gdb_exception &ex)
5245             {
5246               exception_fprintf (gdb_stderr, ex,
5247                                  "Error in testing breakpoint condition:\n");
5248             }
5249         }
5250       else
5251         {
5252           warning (_("Watchpoint condition cannot be tested "
5253                      "in the current scope"));
5254           /* If we failed to set the right context for this
5255              watchpoint, unconditionally report it.  */
5256         }
5257       /* FIXME-someday, should give breakpoint #.  */
5258       value_free_to_mark (mark);
5259     }
5260
5261   if (cond && !condition_result)
5262     {
5263       bs->stop = 0;
5264     }
5265   else if (b->ignore_count > 0)
5266     {
5267       b->ignore_count--;
5268       bs->stop = 0;
5269       /* Increase the hit count even though we don't stop.  */
5270       ++(b->hit_count);
5271       gdb::observers::breakpoint_modified.notify (b);
5272     }   
5273 }
5274
5275 /* Returns true if we need to track moribund locations of LOC's type
5276    on the current target.  */
5277
5278 static int
5279 need_moribund_for_location_type (struct bp_location *loc)
5280 {
5281   return ((loc->loc_type == bp_loc_software_breakpoint
5282            && !target_supports_stopped_by_sw_breakpoint ())
5283           || (loc->loc_type == bp_loc_hardware_breakpoint
5284               && !target_supports_stopped_by_hw_breakpoint ()));
5285 }
5286
5287 /* See breakpoint.h.  */
5288
5289 bpstat
5290 build_bpstat_chain (const address_space *aspace, CORE_ADDR bp_addr,
5291                     const struct target_waitstatus *ws)
5292 {
5293   struct breakpoint *b;
5294   bpstat bs_head = NULL, *bs_link = &bs_head;
5295
5296   ALL_BREAKPOINTS (b)
5297     {
5298       if (!breakpoint_enabled (b))
5299         continue;
5300
5301       for (bp_location *bl = b->loc; bl != NULL; bl = bl->next)
5302         {
5303           /* For hardware watchpoints, we look only at the first
5304              location.  The watchpoint_check function will work on the
5305              entire expression, not the individual locations.  For
5306              read watchpoints, the watchpoints_triggered function has
5307              checked all locations already.  */
5308           if (b->type == bp_hardware_watchpoint && bl != b->loc)
5309             break;
5310
5311           if (!bl->enabled || bl->shlib_disabled)
5312             continue;
5313
5314           if (!bpstat_check_location (bl, aspace, bp_addr, ws))
5315             continue;
5316
5317           /* Come here if it's a watchpoint, or if the break address
5318              matches.  */
5319
5320           bpstat bs = new bpstats (bl, &bs_link);       /* Alloc a bpstat to
5321                                                            explain stop.  */
5322
5323           /* Assume we stop.  Should we find a watchpoint that is not
5324              actually triggered, or if the condition of the breakpoint
5325              evaluates as false, we'll reset 'stop' to 0.  */
5326           bs->stop = 1;
5327           bs->print = 1;
5328
5329           /* If this is a scope breakpoint, mark the associated
5330              watchpoint as triggered so that we will handle the
5331              out-of-scope event.  We'll get to the watchpoint next
5332              iteration.  */
5333           if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
5334             {
5335               struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5336
5337               w->watchpoint_triggered = watch_triggered_yes;
5338             }
5339         }
5340     }
5341
5342   /* Check if a moribund breakpoint explains the stop.  */
5343   if (!target_supports_stopped_by_sw_breakpoint ()
5344       || !target_supports_stopped_by_hw_breakpoint ())
5345     {
5346       for (bp_location *loc : moribund_locations)
5347         {
5348           if (breakpoint_location_address_match (loc, aspace, bp_addr)
5349               && need_moribund_for_location_type (loc))
5350             {
5351               bpstat bs = new bpstats (loc, &bs_link);
5352               /* For hits of moribund locations, we should just proceed.  */
5353               bs->stop = 0;
5354               bs->print = 0;
5355               bs->print_it = print_it_noop;
5356             }
5357         }
5358     }
5359
5360   return bs_head;
5361 }
5362
5363 /* See breakpoint.h.  */
5364
5365 bpstat
5366 bpstat_stop_status (const address_space *aspace,
5367                     CORE_ADDR bp_addr, thread_info *thread,
5368                     const struct target_waitstatus *ws,
5369                     bpstat stop_chain)
5370 {
5371   struct breakpoint *b = NULL;
5372   /* First item of allocated bpstat's.  */
5373   bpstat bs_head = stop_chain;
5374   bpstat bs;
5375   int need_remove_insert;
5376   int removed_any;
5377
5378   /* First, build the bpstat chain with locations that explain a
5379      target stop, while being careful to not set the target running,
5380      as that may invalidate locations (in particular watchpoint
5381      locations are recreated).  Resuming will happen here with
5382      breakpoint conditions or watchpoint expressions that include
5383      inferior function calls.  */
5384   if (bs_head == NULL)
5385     bs_head = build_bpstat_chain (aspace, bp_addr, ws);
5386
5387   /* A bit of special processing for shlib breakpoints.  We need to
5388      process solib loading here, so that the lists of loaded and
5389      unloaded libraries are correct before we handle "catch load" and
5390      "catch unload".  */
5391   for (bs = bs_head; bs != NULL; bs = bs->next)
5392     {
5393       if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
5394         {
5395           handle_solib_event ();
5396           break;
5397         }
5398     }
5399
5400   /* Now go through the locations that caused the target to stop, and
5401      check whether we're interested in reporting this stop to higher
5402      layers, or whether we should resume the target transparently.  */
5403
5404   removed_any = 0;
5405
5406   for (bs = bs_head; bs != NULL; bs = bs->next)
5407     {
5408       if (!bs->stop)
5409         continue;
5410
5411       b = bs->breakpoint_at;
5412       b->ops->check_status (bs);
5413       if (bs->stop)
5414         {
5415           bpstat_check_breakpoint_conditions (bs, thread);
5416
5417           if (bs->stop)
5418             {
5419               ++(b->hit_count);
5420               gdb::observers::breakpoint_modified.notify (b);
5421
5422               /* We will stop here.  */
5423               if (b->disposition == disp_disable)
5424                 {
5425                   --(b->enable_count);
5426                   if (b->enable_count <= 0)
5427                     b->enable_state = bp_disabled;
5428                   removed_any = 1;
5429                 }
5430               if (b->silent)
5431                 bs->print = 0;
5432               bs->commands = b->commands;
5433               if (command_line_is_silent (bs->commands
5434                                           ? bs->commands.get () : NULL))
5435                 bs->print = 0;
5436
5437               b->ops->after_condition_true (bs);
5438             }
5439
5440         }
5441
5442       /* Print nothing for this entry if we don't stop or don't
5443          print.  */
5444       if (!bs->stop || !bs->print)
5445         bs->print_it = print_it_noop;
5446     }
5447
5448   /* If we aren't stopping, the value of some hardware watchpoint may
5449      not have changed, but the intermediate memory locations we are
5450      watching may have.  Don't bother if we're stopping; this will get
5451      done later.  */
5452   need_remove_insert = 0;
5453   if (! bpstat_causes_stop (bs_head))
5454     for (bs = bs_head; bs != NULL; bs = bs->next)
5455       if (!bs->stop
5456           && bs->breakpoint_at
5457           && is_hardware_watchpoint (bs->breakpoint_at))
5458         {
5459           struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5460
5461           update_watchpoint (w, 0 /* don't reparse.  */);
5462           need_remove_insert = 1;
5463         }
5464
5465   if (need_remove_insert)
5466     update_global_location_list (UGLL_MAY_INSERT);
5467   else if (removed_any)
5468     update_global_location_list (UGLL_DONT_INSERT);
5469
5470   return bs_head;
5471 }
5472
5473 static void
5474 handle_jit_event (void)
5475 {
5476   struct frame_info *frame;
5477   struct gdbarch *gdbarch;
5478
5479   if (debug_infrun)
5480     fprintf_unfiltered (gdb_stdlog, "handling bp_jit_event\n");
5481
5482   /* Switch terminal for any messages produced by
5483      breakpoint_re_set.  */
5484   target_terminal::ours_for_output ();
5485
5486   frame = get_current_frame ();
5487   gdbarch = get_frame_arch (frame);
5488
5489   jit_event_handler (gdbarch);
5490
5491   target_terminal::inferior ();
5492 }
5493
5494 /* Prepare WHAT final decision for infrun.  */
5495
5496 /* Decide what infrun needs to do with this bpstat.  */
5497
5498 struct bpstat_what
5499 bpstat_what (bpstat bs_head)
5500 {
5501   struct bpstat_what retval;
5502   bpstat bs;
5503
5504   retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
5505   retval.call_dummy = STOP_NONE;
5506   retval.is_longjmp = 0;
5507
5508   for (bs = bs_head; bs != NULL; bs = bs->next)
5509     {
5510       /* Extract this BS's action.  After processing each BS, we check
5511          if its action overrides all we've seem so far.  */
5512       enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5513       enum bptype bptype;
5514
5515       if (bs->breakpoint_at == NULL)
5516         {
5517           /* I suspect this can happen if it was a momentary
5518              breakpoint which has since been deleted.  */
5519           bptype = bp_none;
5520         }
5521       else
5522         bptype = bs->breakpoint_at->type;
5523
5524       switch (bptype)
5525         {
5526         case bp_none:
5527           break;
5528         case bp_breakpoint:
5529         case bp_hardware_breakpoint:
5530         case bp_single_step:
5531         case bp_until:
5532         case bp_finish:
5533         case bp_shlib_event:
5534           if (bs->stop)
5535             {
5536               if (bs->print)
5537                 this_action = BPSTAT_WHAT_STOP_NOISY;
5538               else
5539                 this_action = BPSTAT_WHAT_STOP_SILENT;
5540             }
5541           else
5542             this_action = BPSTAT_WHAT_SINGLE;
5543           break;
5544         case bp_watchpoint:
5545         case bp_hardware_watchpoint:
5546         case bp_read_watchpoint:
5547         case bp_access_watchpoint:
5548           if (bs->stop)
5549             {
5550               if (bs->print)
5551                 this_action = BPSTAT_WHAT_STOP_NOISY;
5552               else
5553                 this_action = BPSTAT_WHAT_STOP_SILENT;
5554             }
5555           else
5556             {
5557               /* There was a watchpoint, but we're not stopping.
5558                  This requires no further action.  */
5559             }
5560           break;
5561         case bp_longjmp:
5562         case bp_longjmp_call_dummy:
5563         case bp_exception:
5564           if (bs->stop)
5565             {
5566               this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5567               retval.is_longjmp = bptype != bp_exception;
5568             }
5569           else
5570             this_action = BPSTAT_WHAT_SINGLE;
5571           break;
5572         case bp_longjmp_resume:
5573         case bp_exception_resume:
5574           if (bs->stop)
5575             {
5576               this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5577               retval.is_longjmp = bptype == bp_longjmp_resume;
5578             }
5579           else
5580             this_action = BPSTAT_WHAT_SINGLE;
5581           break;
5582         case bp_step_resume:
5583           if (bs->stop)
5584             this_action = BPSTAT_WHAT_STEP_RESUME;
5585           else
5586             {
5587               /* It is for the wrong frame.  */
5588               this_action = BPSTAT_WHAT_SINGLE;
5589             }
5590           break;
5591         case bp_hp_step_resume:
5592           if (bs->stop)
5593             this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5594           else
5595             {
5596               /* It is for the wrong frame.  */
5597               this_action = BPSTAT_WHAT_SINGLE;
5598             }
5599           break;
5600         case bp_watchpoint_scope:
5601         case bp_thread_event:
5602         case bp_overlay_event:
5603         case bp_longjmp_master:
5604         case bp_std_terminate_master:
5605         case bp_exception_master:
5606           this_action = BPSTAT_WHAT_SINGLE;
5607           break;
5608         case bp_catchpoint:
5609           if (bs->stop)
5610             {
5611               if (bs->print)
5612                 this_action = BPSTAT_WHAT_STOP_NOISY;
5613               else
5614                 this_action = BPSTAT_WHAT_STOP_SILENT;
5615             }
5616           else
5617             {
5618               /* There was a catchpoint, but we're not stopping.
5619                  This requires no further action.  */
5620             }
5621           break;
5622         case bp_jit_event:
5623           this_action = BPSTAT_WHAT_SINGLE;
5624           break;
5625         case bp_call_dummy:
5626           /* Make sure the action is stop (silent or noisy),
5627              so infrun.c pops the dummy frame.  */
5628           retval.call_dummy = STOP_STACK_DUMMY;
5629           this_action = BPSTAT_WHAT_STOP_SILENT;
5630           break;
5631         case bp_std_terminate:
5632           /* Make sure the action is stop (silent or noisy),
5633              so infrun.c pops the dummy frame.  */
5634           retval.call_dummy = STOP_STD_TERMINATE;
5635           this_action = BPSTAT_WHAT_STOP_SILENT;
5636           break;
5637         case bp_tracepoint:
5638         case bp_fast_tracepoint:
5639         case bp_static_tracepoint:
5640           /* Tracepoint hits should not be reported back to GDB, and
5641              if one got through somehow, it should have been filtered
5642              out already.  */
5643           internal_error (__FILE__, __LINE__,
5644                           _("bpstat_what: tracepoint encountered"));
5645           break;
5646         case bp_gnu_ifunc_resolver:
5647           /* Step over it (and insert bp_gnu_ifunc_resolver_return).  */
5648           this_action = BPSTAT_WHAT_SINGLE;
5649           break;
5650         case bp_gnu_ifunc_resolver_return:
5651           /* The breakpoint will be removed, execution will restart from the
5652              PC of the former breakpoint.  */
5653           this_action = BPSTAT_WHAT_KEEP_CHECKING;
5654           break;
5655
5656         case bp_dprintf:
5657           if (bs->stop)
5658             this_action = BPSTAT_WHAT_STOP_SILENT;
5659           else
5660             this_action = BPSTAT_WHAT_SINGLE;
5661           break;
5662
5663         default:
5664           internal_error (__FILE__, __LINE__,
5665                           _("bpstat_what: unhandled bptype %d"), (int) bptype);
5666         }
5667
5668       retval.main_action = std::max (retval.main_action, this_action);
5669     }
5670
5671   return retval;
5672 }
5673
5674 void
5675 bpstat_run_callbacks (bpstat bs_head)
5676 {
5677   bpstat bs;
5678
5679   for (bs = bs_head; bs != NULL; bs = bs->next)
5680     {
5681       struct breakpoint *b = bs->breakpoint_at;
5682
5683       if (b == NULL)
5684         continue;
5685       switch (b->type)
5686         {
5687         case bp_jit_event:
5688           handle_jit_event ();
5689           break;
5690         case bp_gnu_ifunc_resolver:
5691           gnu_ifunc_resolver_stop (b);
5692           break;
5693         case bp_gnu_ifunc_resolver_return:
5694           gnu_ifunc_resolver_return_stop (b);
5695           break;
5696         }
5697     }
5698 }
5699
5700 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5701    without hardware support).  This isn't related to a specific bpstat,
5702    just to things like whether watchpoints are set.  */
5703
5704 int
5705 bpstat_should_step (void)
5706 {
5707   struct breakpoint *b;
5708
5709   ALL_BREAKPOINTS (b)
5710     if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
5711       return 1;
5712   return 0;
5713 }
5714
5715 int
5716 bpstat_causes_stop (bpstat bs)
5717 {
5718   for (; bs != NULL; bs = bs->next)
5719     if (bs->stop)
5720       return 1;
5721
5722   return 0;
5723 }
5724
5725 \f
5726
5727 /* Compute a string of spaces suitable to indent the next line
5728    so it starts at the position corresponding to the table column
5729    named COL_NAME in the currently active table of UIOUT.  */
5730
5731 static char *
5732 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
5733 {
5734   static char wrap_indent[80];
5735   int i, total_width, width, align;
5736   const char *text;
5737
5738   total_width = 0;
5739   for (i = 1; uiout->query_table_field (i, &width, &align, &text); i++)
5740     {
5741       if (strcmp (text, col_name) == 0)
5742         {
5743           gdb_assert (total_width < sizeof wrap_indent);
5744           memset (wrap_indent, ' ', total_width);
5745           wrap_indent[total_width] = 0;
5746
5747           return wrap_indent;
5748         }
5749
5750       total_width += width + 1;
5751     }
5752
5753   return NULL;
5754 }
5755
5756 /* Determine if the locations of this breakpoint will have their conditions
5757    evaluated by the target, host or a mix of both.  Returns the following:
5758
5759     "host": Host evals condition.
5760     "host or target": Host or Target evals condition.
5761     "target": Target evals condition.
5762 */
5763
5764 static const char *
5765 bp_condition_evaluator (struct breakpoint *b)
5766 {
5767   struct bp_location *bl;
5768   char host_evals = 0;
5769   char target_evals = 0;
5770
5771   if (!b)
5772     return NULL;
5773
5774   if (!is_breakpoint (b))
5775     return NULL;
5776
5777   if (gdb_evaluates_breakpoint_condition_p ()
5778       || !target_supports_evaluation_of_breakpoint_conditions ())
5779     return condition_evaluation_host;
5780
5781   for (bl = b->loc; bl; bl = bl->next)
5782     {
5783       if (bl->cond_bytecode)
5784         target_evals++;
5785       else
5786         host_evals++;
5787     }
5788
5789   if (host_evals && target_evals)
5790     return condition_evaluation_both;
5791   else if (target_evals)
5792     return condition_evaluation_target;
5793   else
5794     return condition_evaluation_host;
5795 }
5796
5797 /* Determine the breakpoint location's condition evaluator.  This is
5798    similar to bp_condition_evaluator, but for locations.  */
5799
5800 static const char *
5801 bp_location_condition_evaluator (struct bp_location *bl)
5802 {
5803   if (bl && !is_breakpoint (bl->owner))
5804     return NULL;
5805
5806   if (gdb_evaluates_breakpoint_condition_p ()
5807       || !target_supports_evaluation_of_breakpoint_conditions ())
5808     return condition_evaluation_host;
5809
5810   if (bl && bl->cond_bytecode)
5811     return condition_evaluation_target;
5812   else
5813     return condition_evaluation_host;
5814 }
5815
5816 /* Print the LOC location out of the list of B->LOC locations.  */
5817
5818 static void
5819 print_breakpoint_location (struct breakpoint *b,
5820                            struct bp_location *loc)
5821 {
5822   struct ui_out *uiout = current_uiout;
5823
5824   scoped_restore_current_program_space restore_pspace;
5825
5826   if (loc != NULL && loc->shlib_disabled)
5827     loc = NULL;
5828
5829   if (loc != NULL)
5830     set_current_program_space (loc->pspace);
5831
5832   if (b->display_canonical)
5833     uiout->field_string ("what", event_location_to_string (b->location.get ()));
5834   else if (loc && loc->symtab)
5835     {
5836       const struct symbol *sym = loc->symbol;
5837
5838       if (sym)
5839         {
5840           uiout->text ("in ");
5841           uiout->field_string ("func", SYMBOL_PRINT_NAME (sym),
5842                                ui_out_style_kind::FUNCTION);
5843           uiout->text (" ");
5844           uiout->wrap_hint (wrap_indent_at_field (uiout, "what"));
5845           uiout->text ("at ");
5846         }
5847       uiout->field_string ("file",
5848                            symtab_to_filename_for_display (loc->symtab),
5849                            ui_out_style_kind::FILE);
5850       uiout->text (":");
5851
5852       if (uiout->is_mi_like_p ())
5853         uiout->field_string ("fullname", symtab_to_fullname (loc->symtab));
5854       
5855       uiout->field_int ("line", loc->line_number);
5856     }
5857   else if (loc)
5858     {
5859       string_file stb;
5860
5861       print_address_symbolic (loc->gdbarch, loc->address, &stb,
5862                               demangle, "");
5863       uiout->field_stream ("at", stb);
5864     }
5865   else
5866     {
5867       uiout->field_string ("pending",
5868                            event_location_to_string (b->location.get ()));
5869       /* If extra_string is available, it could be holding a condition
5870          or dprintf arguments.  In either case, make sure it is printed,
5871          too, but only for non-MI streams.  */
5872       if (!uiout->is_mi_like_p () && b->extra_string != NULL)
5873         {
5874           if (b->type == bp_dprintf)
5875             uiout->text (",");
5876           else
5877             uiout->text (" ");
5878           uiout->text (b->extra_string);
5879         }
5880     }
5881
5882   if (loc && is_breakpoint (b)
5883       && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5884       && bp_condition_evaluator (b) == condition_evaluation_both)
5885     {
5886       uiout->text (" (");
5887       uiout->field_string ("evaluated-by",
5888                            bp_location_condition_evaluator (loc));
5889       uiout->text (")");
5890     }
5891 }
5892
5893 static const char *
5894 bptype_string (enum bptype type)
5895 {
5896   struct ep_type_description
5897     {
5898       enum bptype type;
5899       const char *description;
5900     };
5901   static struct ep_type_description bptypes[] =
5902   {
5903     {bp_none, "?deleted?"},
5904     {bp_breakpoint, "breakpoint"},
5905     {bp_hardware_breakpoint, "hw breakpoint"},
5906     {bp_single_step, "sw single-step"},
5907     {bp_until, "until"},
5908     {bp_finish, "finish"},
5909     {bp_watchpoint, "watchpoint"},
5910     {bp_hardware_watchpoint, "hw watchpoint"},
5911     {bp_read_watchpoint, "read watchpoint"},
5912     {bp_access_watchpoint, "acc watchpoint"},
5913     {bp_longjmp, "longjmp"},
5914     {bp_longjmp_resume, "longjmp resume"},
5915     {bp_longjmp_call_dummy, "longjmp for call dummy"},
5916     {bp_exception, "exception"},
5917     {bp_exception_resume, "exception resume"},
5918     {bp_step_resume, "step resume"},
5919     {bp_hp_step_resume, "high-priority step resume"},
5920     {bp_watchpoint_scope, "watchpoint scope"},
5921     {bp_call_dummy, "call dummy"},
5922     {bp_std_terminate, "std::terminate"},
5923     {bp_shlib_event, "shlib events"},
5924     {bp_thread_event, "thread events"},
5925     {bp_overlay_event, "overlay events"},
5926     {bp_longjmp_master, "longjmp master"},
5927     {bp_std_terminate_master, "std::terminate master"},
5928     {bp_exception_master, "exception master"},
5929     {bp_catchpoint, "catchpoint"},
5930     {bp_tracepoint, "tracepoint"},
5931     {bp_fast_tracepoint, "fast tracepoint"},
5932     {bp_static_tracepoint, "static tracepoint"},
5933     {bp_dprintf, "dprintf"},
5934     {bp_jit_event, "jit events"},
5935     {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
5936     {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
5937   };
5938
5939   if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
5940       || ((int) type != bptypes[(int) type].type))
5941     internal_error (__FILE__, __LINE__,
5942                     _("bptypes table does not describe type #%d."),
5943                     (int) type);
5944
5945   return bptypes[(int) type].description;
5946 }
5947
5948 /* For MI, output a field named 'thread-groups' with a list as the value.
5949    For CLI, prefix the list with the string 'inf'. */
5950
5951 static void
5952 output_thread_groups (struct ui_out *uiout,
5953                       const char *field_name,
5954                       const std::vector<int> &inf_nums,
5955                       int mi_only)
5956 {
5957   int is_mi = uiout->is_mi_like_p ();
5958
5959   /* For backward compatibility, don't display inferiors in CLI unless
5960      there are several.  Always display them for MI. */
5961   if (!is_mi && mi_only)
5962     return;
5963
5964   ui_out_emit_list list_emitter (uiout, field_name);
5965
5966   for (size_t i = 0; i < inf_nums.size (); i++)
5967     {
5968       if (is_mi)
5969         {
5970           char mi_group[10];
5971
5972           xsnprintf (mi_group, sizeof (mi_group), "i%d", inf_nums[i]);
5973           uiout->field_string (NULL, mi_group);
5974         }
5975       else
5976         {
5977           if (i == 0)
5978             uiout->text (" inf ");
5979           else
5980             uiout->text (", ");
5981         
5982           uiout->text (plongest (inf_nums[i]));
5983         }
5984     }
5985 }
5986
5987 /* Print B to gdb_stdout.  */
5988
5989 static void
5990 print_one_breakpoint_location (struct breakpoint *b,
5991                                struct bp_location *loc,
5992                                int loc_number,
5993                                struct bp_location **last_loc,
5994                                int allflag)
5995 {
5996   struct command_line *l;
5997   static char bpenables[] = "nynny";
5998
5999   struct ui_out *uiout = current_uiout;
6000   int header_of_multiple = 0;
6001   int part_of_multiple = (loc != NULL);
6002   struct value_print_options opts;
6003
6004   get_user_print_options (&opts);
6005
6006   gdb_assert (!loc || loc_number != 0);
6007   /* See comment in print_one_breakpoint concerning treatment of
6008      breakpoints with single disabled location.  */
6009   if (loc == NULL 
6010       && (b->loc != NULL 
6011           && (b->loc->next != NULL || !b->loc->enabled)))
6012     header_of_multiple = 1;
6013   if (loc == NULL)
6014     loc = b->loc;
6015
6016   annotate_record ();
6017
6018   /* 1 */
6019   annotate_field (0);
6020   if (part_of_multiple)
6021     uiout->field_fmt ("number", "%d.%d", b->number, loc_number);
6022   else
6023     uiout->field_int ("number", b->number);
6024
6025   /* 2 */
6026   annotate_field (1);
6027   if (part_of_multiple)
6028     uiout->field_skip ("type");
6029   else
6030     uiout->field_string ("type", bptype_string (b->type));
6031
6032   /* 3 */
6033   annotate_field (2);
6034   if (part_of_multiple)
6035     uiout->field_skip ("disp");
6036   else
6037     uiout->field_string ("disp", bpdisp_text (b->disposition));
6038
6039   /* 4 */
6040   annotate_field (3);
6041   if (part_of_multiple)
6042     uiout->field_string ("enabled", loc->enabled ? "y" : "n");
6043   else
6044     uiout->field_fmt ("enabled", "%c", bpenables[(int) b->enable_state]);
6045
6046   /* 5 and 6 */
6047   if (b->ops != NULL && b->ops->print_one != NULL)
6048     {
6049       /* Although the print_one can possibly print all locations,
6050          calling it here is not likely to get any nice result.  So,
6051          make sure there's just one location.  */
6052       gdb_assert (b->loc == NULL || b->loc->next == NULL);
6053       b->ops->print_one (b, last_loc);
6054     }
6055   else
6056     switch (b->type)
6057       {
6058       case bp_none:
6059         internal_error (__FILE__, __LINE__,
6060                         _("print_one_breakpoint: bp_none encountered\n"));
6061         break;
6062
6063       case bp_watchpoint:
6064       case bp_hardware_watchpoint:
6065       case bp_read_watchpoint:
6066       case bp_access_watchpoint:
6067         {
6068           struct watchpoint *w = (struct watchpoint *) b;
6069
6070           /* Field 4, the address, is omitted (which makes the columns
6071              not line up too nicely with the headers, but the effect
6072              is relatively readable).  */
6073           if (opts.addressprint)
6074             uiout->field_skip ("addr");
6075           annotate_field (5);
6076           uiout->field_string ("what", w->exp_string);
6077         }
6078         break;
6079
6080       case bp_breakpoint:
6081       case bp_hardware_breakpoint:
6082       case bp_single_step:
6083       case bp_until:
6084       case bp_finish:
6085       case bp_longjmp:
6086       case bp_longjmp_resume:
6087       case bp_longjmp_call_dummy:
6088       case bp_exception:
6089       case bp_exception_resume:
6090       case bp_step_resume:
6091       case bp_hp_step_resume:
6092       case bp_watchpoint_scope:
6093       case bp_call_dummy:
6094       case bp_std_terminate:
6095       case bp_shlib_event:
6096       case bp_thread_event:
6097       case bp_overlay_event:
6098       case bp_longjmp_master:
6099       case bp_std_terminate_master:
6100       case bp_exception_master:
6101       case bp_tracepoint:
6102       case bp_fast_tracepoint:
6103       case bp_static_tracepoint:
6104       case bp_dprintf:
6105       case bp_jit_event:
6106       case bp_gnu_ifunc_resolver:
6107       case bp_gnu_ifunc_resolver_return:
6108         if (opts.addressprint)
6109           {
6110             annotate_field (4);
6111             if (header_of_multiple)
6112               uiout->field_string ("addr", "<MULTIPLE>");
6113             else if (b->loc == NULL || loc->shlib_disabled)
6114               uiout->field_string ("addr", "<PENDING>");
6115             else
6116               uiout->field_core_addr ("addr",
6117                                       loc->gdbarch, loc->address);
6118           }
6119         annotate_field (5);
6120         if (!header_of_multiple)
6121           print_breakpoint_location (b, loc);
6122         if (b->loc)
6123           *last_loc = b->loc;
6124         break;
6125       }
6126
6127
6128   if (loc != NULL && !header_of_multiple)
6129     {
6130       std::vector<int> inf_nums;
6131       int mi_only = 1;
6132
6133       for (inferior *inf : all_inferiors ())
6134         {
6135           if (inf->pspace == loc->pspace)
6136             inf_nums.push_back (inf->num);
6137         }
6138
6139         /* For backward compatibility, don't display inferiors in CLI unless
6140            there are several.  Always display for MI. */
6141         if (allflag
6142             || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6143                 && (number_of_program_spaces () > 1
6144                     || number_of_inferiors () > 1)
6145                 /* LOC is for existing B, it cannot be in
6146                    moribund_locations and thus having NULL OWNER.  */
6147                 && loc->owner->type != bp_catchpoint))
6148         mi_only = 0;
6149       output_thread_groups (uiout, "thread-groups", inf_nums, mi_only);
6150     }
6151
6152   if (!part_of_multiple)
6153     {
6154       if (b->thread != -1)
6155         {
6156           /* FIXME: This seems to be redundant and lost here; see the
6157              "stop only in" line a little further down.  */
6158           uiout->text (" thread ");
6159           uiout->field_int ("thread", b->thread);
6160         }
6161       else if (b->task != 0)
6162         {
6163           uiout->text (" task ");
6164           uiout->field_int ("task", b->task);
6165         }
6166     }
6167
6168   uiout->text ("\n");
6169
6170   if (!part_of_multiple)
6171     b->ops->print_one_detail (b, uiout);
6172
6173   if (part_of_multiple && frame_id_p (b->frame_id))
6174     {
6175       annotate_field (6);
6176       uiout->text ("\tstop only in stack frame at ");
6177       /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6178          the frame ID.  */
6179       uiout->field_core_addr ("frame",
6180                               b->gdbarch, b->frame_id.stack_addr);
6181       uiout->text ("\n");
6182     }
6183   
6184   if (!part_of_multiple && b->cond_string)
6185     {
6186       annotate_field (7);
6187       if (is_tracepoint (b))
6188         uiout->text ("\ttrace only if ");
6189       else
6190         uiout->text ("\tstop only if ");
6191       uiout->field_string ("cond", b->cond_string);
6192
6193       /* Print whether the target is doing the breakpoint's condition
6194          evaluation.  If GDB is doing the evaluation, don't print anything.  */
6195       if (is_breakpoint (b)
6196           && breakpoint_condition_evaluation_mode ()
6197           == condition_evaluation_target)
6198         {
6199           uiout->text (" (");
6200           uiout->field_string ("evaluated-by",
6201                                bp_condition_evaluator (b));
6202           uiout->text (" evals)");
6203         }
6204       uiout->text ("\n");
6205     }
6206
6207   if (!part_of_multiple && b->thread != -1)
6208     {
6209       /* FIXME should make an annotation for this.  */
6210       uiout->text ("\tstop only in thread ");
6211       if (uiout->is_mi_like_p ())
6212         uiout->field_int ("thread", b->thread);
6213       else
6214         {
6215           struct thread_info *thr = find_thread_global_id (b->thread);
6216
6217           uiout->field_string ("thread", print_thread_id (thr));
6218         }
6219       uiout->text ("\n");
6220     }
6221   
6222   if (!part_of_multiple)
6223     {
6224       if (b->hit_count)
6225         {
6226           /* FIXME should make an annotation for this.  */
6227           if (is_catchpoint (b))
6228             uiout->text ("\tcatchpoint");
6229           else if (is_tracepoint (b))
6230             uiout->text ("\ttracepoint");
6231           else
6232             uiout->text ("\tbreakpoint");
6233           uiout->text (" already hit ");
6234           uiout->field_int ("times", b->hit_count);
6235           if (b->hit_count == 1)
6236             uiout->text (" time\n");
6237           else
6238             uiout->text (" times\n");
6239         }
6240       else
6241         {
6242           /* Output the count also if it is zero, but only if this is mi.  */
6243           if (uiout->is_mi_like_p ())
6244             uiout->field_int ("times", b->hit_count);
6245         }
6246     }
6247
6248   if (!part_of_multiple && b->ignore_count)
6249     {
6250       annotate_field (8);
6251       uiout->text ("\tignore next ");
6252       uiout->field_int ("ignore", b->ignore_count);
6253       uiout->text (" hits\n");
6254     }
6255
6256   /* Note that an enable count of 1 corresponds to "enable once"
6257      behavior, which is reported by the combination of enablement and
6258      disposition, so we don't need to mention it here.  */
6259   if (!part_of_multiple && b->enable_count > 1)
6260     {
6261       annotate_field (8);
6262       uiout->text ("\tdisable after ");
6263       /* Tweak the wording to clarify that ignore and enable counts
6264          are distinct, and have additive effect.  */
6265       if (b->ignore_count)
6266         uiout->text ("additional ");
6267       else
6268         uiout->text ("next ");
6269       uiout->field_int ("enable", b->enable_count);
6270       uiout->text (" hits\n");
6271     }
6272
6273   if (!part_of_multiple && is_tracepoint (b))
6274     {
6275       struct tracepoint *tp = (struct tracepoint *) b;
6276
6277       if (tp->traceframe_usage)
6278         {
6279           uiout->text ("\ttrace buffer usage ");
6280           uiout->field_int ("traceframe-usage", tp->traceframe_usage);
6281           uiout->text (" bytes\n");
6282         }
6283     }
6284
6285   l = b->commands ? b->commands.get () : NULL;
6286   if (!part_of_multiple && l)
6287     {
6288       annotate_field (9);
6289       ui_out_emit_tuple tuple_emitter (uiout, "script");
6290       print_command_lines (uiout, l, 4);
6291     }
6292
6293   if (is_tracepoint (b))
6294     {
6295       struct tracepoint *t = (struct tracepoint *) b;
6296
6297       if (!part_of_multiple && t->pass_count)
6298         {
6299           annotate_field (10);
6300           uiout->text ("\tpass count ");
6301           uiout->field_int ("pass", t->pass_count);
6302           uiout->text (" \n");
6303         }
6304
6305       /* Don't display it when tracepoint or tracepoint location is
6306          pending.   */
6307       if (!header_of_multiple && loc != NULL && !loc->shlib_disabled)
6308         {
6309           annotate_field (11);
6310
6311           if (uiout->is_mi_like_p ())
6312             uiout->field_string ("installed",
6313                                  loc->inserted ? "y" : "n");
6314           else
6315             {
6316               if (loc->inserted)
6317                 uiout->text ("\t");
6318               else
6319                 uiout->text ("\tnot ");
6320               uiout->text ("installed on target\n");
6321             }
6322         }
6323     }
6324
6325   if (uiout->is_mi_like_p () && !part_of_multiple)
6326     {
6327       if (is_watchpoint (b))
6328         {
6329           struct watchpoint *w = (struct watchpoint *) b;
6330
6331           uiout->field_string ("original-location", w->exp_string);
6332         }
6333       else if (b->location != NULL
6334                && event_location_to_string (b->location.get ()) != NULL)
6335         uiout->field_string ("original-location",
6336                              event_location_to_string (b->location.get ()));
6337     }
6338 }
6339
6340 static void
6341 print_one_breakpoint (struct breakpoint *b,
6342                       struct bp_location **last_loc, 
6343                       int allflag)
6344 {
6345   struct ui_out *uiout = current_uiout;
6346   bool use_fixed_output = mi_multi_location_breakpoint_output_fixed (uiout);
6347
6348   gdb::optional<ui_out_emit_tuple> bkpt_tuple_emitter (gdb::in_place, uiout, "bkpt");
6349   print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
6350
6351   /* The mi2 broken format: the main breakpoint tuple ends here, the locations
6352      are outside.  */
6353   if (!use_fixed_output)
6354     bkpt_tuple_emitter.reset ();
6355
6356   /* If this breakpoint has custom print function,
6357      it's already printed.  Otherwise, print individual
6358      locations, if any.  */
6359   if (b->ops == NULL || b->ops->print_one == NULL)
6360     {
6361       /* If breakpoint has a single location that is disabled, we
6362          print it as if it had several locations, since otherwise it's
6363          hard to represent "breakpoint enabled, location disabled"
6364          situation.
6365
6366          Note that while hardware watchpoints have several locations
6367          internally, that's not a property exposed to user.  */
6368       if (b->loc 
6369           && !is_hardware_watchpoint (b)
6370           && (b->loc->next || !b->loc->enabled))
6371         {
6372           gdb::optional<ui_out_emit_list> locations_list;
6373
6374           /* For MI version <= 2, keep the behavior where GDB outputs an invalid
6375              MI record.  For later versions, place breakpoint locations in a
6376              list.  */
6377           if (uiout->is_mi_like_p () && use_fixed_output)
6378             locations_list.emplace (uiout, "locations");
6379
6380           int n = 1;
6381           for (bp_location *loc = b->loc; loc != NULL; loc = loc->next, ++n)
6382             {
6383               ui_out_emit_tuple loc_tuple_emitter (uiout, NULL);
6384               print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6385             }
6386         }
6387     }
6388 }
6389
6390 static int
6391 breakpoint_address_bits (struct breakpoint *b)
6392 {
6393   int print_address_bits = 0;
6394   struct bp_location *loc;
6395
6396   /* Software watchpoints that aren't watching memory don't have an
6397      address to print.  */
6398   if (is_no_memory_software_watchpoint (b))
6399     return 0;
6400
6401   for (loc = b->loc; loc; loc = loc->next)
6402     {
6403       int addr_bit;
6404
6405       addr_bit = gdbarch_addr_bit (loc->gdbarch);
6406       if (addr_bit > print_address_bits)
6407         print_address_bits = addr_bit;
6408     }
6409
6410   return print_address_bits;
6411 }
6412
6413 /* See breakpoint.h.  */
6414
6415 void
6416 print_breakpoint (breakpoint *b)
6417 {
6418   struct bp_location *dummy_loc = NULL;
6419   print_one_breakpoint (b, &dummy_loc, 0);
6420 }
6421
6422 /* Return true if this breakpoint was set by the user, false if it is
6423    internal or momentary.  */
6424
6425 int
6426 user_breakpoint_p (struct breakpoint *b)
6427 {
6428   return b->number > 0;
6429 }
6430
6431 /* See breakpoint.h.  */
6432
6433 int
6434 pending_breakpoint_p (struct breakpoint *b)
6435 {
6436   return b->loc == NULL;
6437 }
6438
6439 /* Print information on user settable breakpoint (watchpoint, etc)
6440    number BNUM.  If BNUM is -1 print all user-settable breakpoints.
6441    If ALLFLAG is non-zero, include non-user-settable breakpoints.  If
6442    FILTER is non-NULL, call it on each breakpoint and only include the
6443    ones for which it returns non-zero.  Return the total number of
6444    breakpoints listed.  */
6445
6446 static int
6447 breakpoint_1 (const char *args, int allflag, 
6448               int (*filter) (const struct breakpoint *))
6449 {
6450   struct breakpoint *b;
6451   struct bp_location *last_loc = NULL;
6452   int nr_printable_breakpoints;
6453   struct value_print_options opts;
6454   int print_address_bits = 0;
6455   int print_type_col_width = 14;
6456   struct ui_out *uiout = current_uiout;
6457
6458   get_user_print_options (&opts);
6459
6460   /* Compute the number of rows in the table, as well as the size
6461      required for address fields.  */
6462   nr_printable_breakpoints = 0;
6463   ALL_BREAKPOINTS (b)
6464     {
6465       /* If we have a filter, only list the breakpoints it accepts.  */
6466       if (filter && !filter (b))
6467         continue;
6468
6469       /* If we have an "args" string, it is a list of breakpoints to 
6470          accept.  Skip the others.  */
6471       if (args != NULL && *args != '\0')
6472         {
6473           if (allflag && parse_and_eval_long (args) != b->number)
6474             continue;
6475           if (!allflag && !number_is_in_list (args, b->number))
6476             continue;
6477         }
6478
6479       if (allflag || user_breakpoint_p (b))
6480         {
6481           int addr_bit, type_len;
6482
6483           addr_bit = breakpoint_address_bits (b);
6484           if (addr_bit > print_address_bits)
6485             print_address_bits = addr_bit;
6486
6487           type_len = strlen (bptype_string (b->type));
6488           if (type_len > print_type_col_width)
6489             print_type_col_width = type_len;
6490
6491           nr_printable_breakpoints++;
6492         }
6493     }
6494
6495   {
6496     ui_out_emit_table table_emitter (uiout,
6497                                      opts.addressprint ? 6 : 5,
6498                                      nr_printable_breakpoints,
6499                                      "BreakpointTable");
6500
6501     if (nr_printable_breakpoints > 0)
6502       annotate_breakpoints_headers ();
6503     if (nr_printable_breakpoints > 0)
6504       annotate_field (0);
6505     uiout->table_header (7, ui_left, "number", "Num"); /* 1 */
6506     if (nr_printable_breakpoints > 0)
6507       annotate_field (1);
6508     uiout->table_header (print_type_col_width, ui_left, "type", "Type"); /* 2 */
6509     if (nr_printable_breakpoints > 0)
6510       annotate_field (2);
6511     uiout->table_header (4, ui_left, "disp", "Disp"); /* 3 */
6512     if (nr_printable_breakpoints > 0)
6513       annotate_field (3);
6514     uiout->table_header (3, ui_left, "enabled", "Enb"); /* 4 */
6515     if (opts.addressprint)
6516       {
6517         if (nr_printable_breakpoints > 0)
6518           annotate_field (4);
6519         if (print_address_bits <= 32)
6520           uiout->table_header (10, ui_left, "addr", "Address"); /* 5 */
6521         else
6522           uiout->table_header (18, ui_left, "addr", "Address"); /* 5 */
6523       }
6524     if (nr_printable_breakpoints > 0)
6525       annotate_field (5);
6526     uiout->table_header (40, ui_noalign, "what", "What"); /* 6 */
6527     uiout->table_body ();
6528     if (nr_printable_breakpoints > 0)
6529       annotate_breakpoints_table ();
6530
6531     ALL_BREAKPOINTS (b)
6532       {
6533         QUIT;
6534         /* If we have a filter, only list the breakpoints it accepts.  */
6535         if (filter && !filter (b))
6536           continue;
6537
6538         /* If we have an "args" string, it is a list of breakpoints to 
6539            accept.  Skip the others.  */
6540
6541         if (args != NULL && *args != '\0')
6542           {
6543             if (allflag)        /* maintenance info breakpoint */
6544               {
6545                 if (parse_and_eval_long (args) != b->number)
6546                   continue;
6547               }
6548             else                /* all others */
6549               {
6550                 if (!number_is_in_list (args, b->number))
6551                   continue;
6552               }
6553           }
6554         /* We only print out user settable breakpoints unless the
6555            allflag is set.  */
6556         if (allflag || user_breakpoint_p (b))
6557           print_one_breakpoint (b, &last_loc, allflag);
6558       }
6559   }
6560
6561   if (nr_printable_breakpoints == 0)
6562     {
6563       /* If there's a filter, let the caller decide how to report
6564          empty list.  */
6565       if (!filter)
6566         {
6567           if (args == NULL || *args == '\0')
6568             uiout->message ("No breakpoints or watchpoints.\n");
6569           else
6570             uiout->message ("No breakpoint or watchpoint matching '%s'.\n",
6571                             args);
6572         }
6573     }
6574   else
6575     {
6576       if (last_loc && !server_command)
6577         set_next_address (last_loc->gdbarch, last_loc->address);
6578     }
6579
6580   /* FIXME?  Should this be moved up so that it is only called when
6581      there have been breakpoints? */
6582   annotate_breakpoints_table_end ();
6583
6584   return nr_printable_breakpoints;
6585 }
6586
6587 /* Display the value of default-collect in a way that is generally
6588    compatible with the breakpoint list.  */
6589
6590 static void
6591 default_collect_info (void)
6592 {
6593   struct ui_out *uiout = current_uiout;
6594
6595   /* If it has no value (which is frequently the case), say nothing; a
6596      message like "No default-collect." gets in user's face when it's
6597      not wanted.  */
6598   if (!*default_collect)
6599     return;
6600
6601   /* The following phrase lines up nicely with per-tracepoint collect
6602      actions.  */
6603   uiout->text ("default collect ");
6604   uiout->field_string ("default-collect", default_collect);
6605   uiout->text (" \n");
6606 }
6607   
6608 static void
6609 info_breakpoints_command (const char *args, int from_tty)
6610 {
6611   breakpoint_1 (args, 0, NULL);
6612
6613   default_collect_info ();
6614 }
6615
6616 static void
6617 info_watchpoints_command (const char *args, int from_tty)
6618 {
6619   int num_printed = breakpoint_1 (args, 0, is_watchpoint);
6620   struct ui_out *uiout = current_uiout;
6621
6622   if (num_printed == 0)
6623     {
6624       if (args == NULL || *args == '\0')
6625         uiout->message ("No watchpoints.\n");
6626       else
6627         uiout->message ("No watchpoint matching '%s'.\n", args);
6628     }
6629 }
6630
6631 static void
6632 maintenance_info_breakpoints (const char *args, int from_tty)
6633 {
6634   breakpoint_1 (args, 1, NULL);
6635
6636   default_collect_info ();
6637 }
6638
6639 static int
6640 breakpoint_has_pc (struct breakpoint *b,
6641                    struct program_space *pspace,
6642                    CORE_ADDR pc, struct obj_section *section)
6643 {
6644   struct bp_location *bl = b->loc;
6645
6646   for (; bl; bl = bl->next)
6647     {
6648       if (bl->pspace == pspace
6649           && bl->address == pc
6650           && (!overlay_debugging || bl->section == section))
6651         return 1;         
6652     }
6653   return 0;
6654 }
6655
6656 /* Print a message describing any user-breakpoints set at PC.  This
6657    concerns with logical breakpoints, so we match program spaces, not
6658    address spaces.  */
6659
6660 static void
6661 describe_other_breakpoints (struct gdbarch *gdbarch,
6662                             struct program_space *pspace, CORE_ADDR pc,
6663                             struct obj_section *section, int thread)
6664 {
6665   int others = 0;
6666   struct breakpoint *b;
6667
6668   ALL_BREAKPOINTS (b)
6669     others += (user_breakpoint_p (b)
6670                && breakpoint_has_pc (b, pspace, pc, section));
6671   if (others > 0)
6672     {
6673       if (others == 1)
6674         printf_filtered (_("Note: breakpoint "));
6675       else /* if (others == ???) */
6676         printf_filtered (_("Note: breakpoints "));
6677       ALL_BREAKPOINTS (b)
6678         if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
6679           {
6680             others--;
6681             printf_filtered ("%d", b->number);
6682             if (b->thread == -1 && thread != -1)
6683               printf_filtered (" (all threads)");
6684             else if (b->thread != -1)
6685               printf_filtered (" (thread %d)", b->thread);
6686             printf_filtered ("%s%s ",
6687                              ((b->enable_state == bp_disabled
6688                                || b->enable_state == bp_call_disabled)
6689                               ? " (disabled)"
6690                               : ""),
6691                              (others > 1) ? "," 
6692                              : ((others == 1) ? " and" : ""));
6693           }
6694       printf_filtered (_("also set at pc "));
6695       fputs_styled (paddress (gdbarch, pc), address_style.style (), gdb_stdout);
6696       printf_filtered (".\n");
6697     }
6698 }
6699 \f
6700
6701 /* Return true iff it is meaningful to use the address member of
6702    BPT locations.  For some breakpoint types, the locations' address members
6703    are irrelevant and it makes no sense to attempt to compare them to other
6704    addresses (or use them for any other purpose either).
6705
6706    More specifically, each of the following breakpoint types will
6707    always have a zero valued location address and we don't want to mark
6708    breakpoints of any of these types to be a duplicate of an actual
6709    breakpoint location at address zero:
6710
6711       bp_watchpoint
6712       bp_catchpoint
6713
6714 */
6715
6716 static int
6717 breakpoint_address_is_meaningful (struct breakpoint *bpt)
6718 {
6719   enum bptype type = bpt->type;
6720
6721   return (type != bp_watchpoint && type != bp_catchpoint);
6722 }
6723
6724 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6725    true if LOC1 and LOC2 represent the same watchpoint location.  */
6726
6727 static int
6728 watchpoint_locations_match (struct bp_location *loc1, 
6729                             struct bp_location *loc2)
6730 {
6731   struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
6732   struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
6733
6734   /* Both of them must exist.  */
6735   gdb_assert (w1 != NULL);
6736   gdb_assert (w2 != NULL);
6737
6738   /* If the target can evaluate the condition expression in hardware,
6739      then we we need to insert both watchpoints even if they are at
6740      the same place.  Otherwise the watchpoint will only trigger when
6741      the condition of whichever watchpoint was inserted evaluates to
6742      true, not giving a chance for GDB to check the condition of the
6743      other watchpoint.  */
6744   if ((w1->cond_exp
6745        && target_can_accel_watchpoint_condition (loc1->address, 
6746                                                  loc1->length,
6747                                                  loc1->watchpoint_type,
6748                                                  w1->cond_exp.get ()))
6749       || (w2->cond_exp
6750           && target_can_accel_watchpoint_condition (loc2->address, 
6751                                                     loc2->length,
6752                                                     loc2->watchpoint_type,
6753                                                     w2->cond_exp.get ())))
6754     return 0;
6755
6756   /* Note that this checks the owner's type, not the location's.  In
6757      case the target does not support read watchpoints, but does
6758      support access watchpoints, we'll have bp_read_watchpoint
6759      watchpoints with hw_access locations.  Those should be considered
6760      duplicates of hw_read locations.  The hw_read locations will
6761      become hw_access locations later.  */
6762   return (loc1->owner->type == loc2->owner->type
6763           && loc1->pspace->aspace == loc2->pspace->aspace
6764           && loc1->address == loc2->address
6765           && loc1->length == loc2->length);
6766 }
6767
6768 /* See breakpoint.h.  */
6769
6770 int
6771 breakpoint_address_match (const address_space *aspace1, CORE_ADDR addr1,
6772                           const address_space *aspace2, CORE_ADDR addr2)
6773 {
6774   return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6775            || aspace1 == aspace2)
6776           && addr1 == addr2);
6777 }
6778
6779 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6780    {ASPACE1,ADDR1,LEN1}.  In most targets, this can only be true if ASPACE1
6781    matches ASPACE2.  On targets that have global breakpoints, the address
6782    space doesn't really matter.  */
6783
6784 static int
6785 breakpoint_address_match_range (const address_space *aspace1,
6786                                 CORE_ADDR addr1,
6787                                 int len1, const address_space *aspace2,
6788                                 CORE_ADDR addr2)
6789 {
6790   return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6791            || aspace1 == aspace2)
6792           && addr2 >= addr1 && addr2 < addr1 + len1);
6793 }
6794
6795 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL.  BL may be
6796    a ranged breakpoint.  In most targets, a match happens only if ASPACE
6797    matches the breakpoint's address space.  On targets that have global
6798    breakpoints, the address space doesn't really matter.  */
6799
6800 static int
6801 breakpoint_location_address_match (struct bp_location *bl,
6802                                    const address_space *aspace,
6803                                    CORE_ADDR addr)
6804 {
6805   return (breakpoint_address_match (bl->pspace->aspace, bl->address,
6806                                     aspace, addr)
6807           || (bl->length
6808               && breakpoint_address_match_range (bl->pspace->aspace,
6809                                                  bl->address, bl->length,
6810                                                  aspace, addr)));
6811 }
6812
6813 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6814    breakpoint BL.  BL may be a ranged breakpoint.  In most targets, a
6815    match happens only if ASPACE matches the breakpoint's address
6816    space.  On targets that have global breakpoints, the address space
6817    doesn't really matter.  */
6818
6819 static int
6820 breakpoint_location_address_range_overlap (struct bp_location *bl,
6821                                            const address_space *aspace,
6822                                            CORE_ADDR addr, int len)
6823 {
6824   if (gdbarch_has_global_breakpoints (target_gdbarch ())
6825       || bl->pspace->aspace == aspace)
6826     {
6827       int bl_len = bl->length != 0 ? bl->length : 1;
6828
6829       if (mem_ranges_overlap (addr, len, bl->address, bl_len))
6830         return 1;
6831     }
6832   return 0;
6833 }
6834
6835 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6836    Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6837    true, otherwise returns false.  */
6838
6839 static int
6840 tracepoint_locations_match (struct bp_location *loc1,
6841                             struct bp_location *loc2)
6842 {
6843   if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
6844     /* Since tracepoint locations are never duplicated with others', tracepoint
6845        locations at the same address of different tracepoints are regarded as
6846        different locations.  */
6847     return (loc1->address == loc2->address && loc1->owner == loc2->owner);
6848   else
6849     return 0;
6850 }
6851
6852 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6853    (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6854    represent the same location.  */
6855
6856 static int
6857 breakpoint_locations_match (struct bp_location *loc1, 
6858                             struct bp_location *loc2)
6859 {
6860   int hw_point1, hw_point2;
6861
6862   /* Both of them must not be in moribund_locations.  */
6863   gdb_assert (loc1->owner != NULL);
6864   gdb_assert (loc2->owner != NULL);
6865
6866   hw_point1 = is_hardware_watchpoint (loc1->owner);
6867   hw_point2 = is_hardware_watchpoint (loc2->owner);
6868
6869   if (hw_point1 != hw_point2)
6870     return 0;
6871   else if (hw_point1)
6872     return watchpoint_locations_match (loc1, loc2);
6873   else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
6874     return tracepoint_locations_match (loc1, loc2);
6875   else
6876     /* We compare bp_location.length in order to cover ranged breakpoints.  */
6877     return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
6878                                      loc2->pspace->aspace, loc2->address)
6879             && loc1->length == loc2->length);
6880 }
6881
6882 static void
6883 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
6884                                int bnum, int have_bnum)
6885 {
6886   /* The longest string possibly returned by hex_string_custom
6887      is 50 chars.  These must be at least that big for safety.  */
6888   char astr1[64];
6889   char astr2[64];
6890
6891   strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
6892   strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
6893   if (have_bnum)
6894     warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6895              bnum, astr1, astr2);
6896   else
6897     warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
6898 }
6899
6900 /* Adjust a breakpoint's address to account for architectural
6901    constraints on breakpoint placement.  Return the adjusted address.
6902    Note: Very few targets require this kind of adjustment.  For most
6903    targets, this function is simply the identity function.  */
6904
6905 static CORE_ADDR
6906 adjust_breakpoint_address (struct gdbarch *gdbarch,
6907                            CORE_ADDR bpaddr, enum bptype bptype)
6908 {
6909   if (bptype == bp_watchpoint
6910       || bptype == bp_hardware_watchpoint
6911       || bptype == bp_read_watchpoint
6912       || bptype == bp_access_watchpoint
6913       || bptype == bp_catchpoint)
6914     {
6915       /* Watchpoints and the various bp_catch_* eventpoints should not
6916          have their addresses modified.  */
6917       return bpaddr;
6918     }
6919   else if (bptype == bp_single_step)
6920     {
6921       /* Single-step breakpoints should not have their addresses
6922          modified.  If there's any architectural constrain that
6923          applies to this address, then it should have already been
6924          taken into account when the breakpoint was created in the
6925          first place.  If we didn't do this, stepping through e.g.,
6926          Thumb-2 IT blocks would break.  */
6927       return bpaddr;
6928     }
6929   else
6930     {
6931       CORE_ADDR adjusted_bpaddr = bpaddr;
6932
6933       if (gdbarch_adjust_breakpoint_address_p (gdbarch))
6934         {
6935           /* Some targets have architectural constraints on the placement
6936              of breakpoint instructions.  Obtain the adjusted address.  */
6937           adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
6938         }
6939
6940       adjusted_bpaddr = address_significant (gdbarch, adjusted_bpaddr);
6941
6942       /* An adjusted breakpoint address can significantly alter
6943          a user's expectations.  Print a warning if an adjustment
6944          is required.  */
6945       if (adjusted_bpaddr != bpaddr)
6946         breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
6947
6948       return adjusted_bpaddr;
6949     }
6950 }
6951
6952 bp_location::bp_location (breakpoint *owner)
6953 {
6954   bp_location *loc = this;
6955
6956   loc->owner = owner;
6957   loc->cond_bytecode = NULL;
6958   loc->shlib_disabled = 0;
6959   loc->enabled = 1;
6960
6961   switch (owner->type)
6962     {
6963     case bp_breakpoint:
6964     case bp_single_step:
6965     case bp_until:
6966     case bp_finish:
6967     case bp_longjmp:
6968     case bp_longjmp_resume:
6969     case bp_longjmp_call_dummy:
6970     case bp_exception:
6971     case bp_exception_resume:
6972     case bp_step_resume:
6973     case bp_hp_step_resume:
6974     case bp_watchpoint_scope:
6975     case bp_call_dummy:
6976     case bp_std_terminate:
6977     case bp_shlib_event:
6978     case bp_thread_event:
6979     case bp_overlay_event:
6980     case bp_jit_event:
6981     case bp_longjmp_master:
6982     case bp_std_terminate_master:
6983     case bp_exception_master:
6984     case bp_gnu_ifunc_resolver:
6985     case bp_gnu_ifunc_resolver_return:
6986     case bp_dprintf:
6987       loc->loc_type = bp_loc_software_breakpoint;
6988       mark_breakpoint_location_modified (loc);
6989       break;
6990     case bp_hardware_breakpoint:
6991       loc->loc_type = bp_loc_hardware_breakpoint;
6992       mark_breakpoint_location_modified (loc);
6993       break;
6994     case bp_hardware_watchpoint:
6995     case bp_read_watchpoint:
6996     case bp_access_watchpoint:
6997       loc->loc_type = bp_loc_hardware_watchpoint;
6998       break;
6999     case bp_watchpoint:
7000     case bp_catchpoint:
7001     case bp_tracepoint:
7002     case bp_fast_tracepoint:
7003     case bp_static_tracepoint:
7004       loc->loc_type = bp_loc_other;
7005       break;
7006     default:
7007       internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
7008     }
7009
7010   loc->refc = 1;
7011 }
7012
7013 /* Allocate a struct bp_location.  */
7014
7015 static struct bp_location *
7016 allocate_bp_location (struct breakpoint *bpt)
7017 {
7018   return bpt->ops->allocate_location (bpt);
7019 }
7020
7021 static void
7022 free_bp_location (struct bp_location *loc)
7023 {
7024   delete loc;
7025 }
7026
7027 /* Increment reference count.  */
7028
7029 static void
7030 incref_bp_location (struct bp_location *bl)
7031 {
7032   ++bl->refc;
7033 }
7034
7035 /* Decrement reference count.  If the reference count reaches 0,
7036    destroy the bp_location.  Sets *BLP to NULL.  */
7037
7038 static void
7039 decref_bp_location (struct bp_location **blp)
7040 {
7041   gdb_assert ((*blp)->refc > 0);
7042
7043   if (--(*blp)->refc == 0)
7044     free_bp_location (*blp);
7045   *blp = NULL;
7046 }
7047
7048 /* Add breakpoint B at the end of the global breakpoint chain.  */
7049
7050 static breakpoint *
7051 add_to_breakpoint_chain (std::unique_ptr<breakpoint> &&b)
7052 {
7053   struct breakpoint *b1;
7054   struct breakpoint *result = b.get ();
7055
7056   /* Add this breakpoint to the end of the chain so that a list of
7057      breakpoints will come out in order of increasing numbers.  */
7058
7059   b1 = breakpoint_chain;
7060   if (b1 == 0)
7061     breakpoint_chain = b.release ();
7062   else
7063     {
7064       while (b1->next)
7065         b1 = b1->next;
7066       b1->next = b.release ();
7067     }
7068
7069   return result;
7070 }
7071
7072 /* Initializes breakpoint B with type BPTYPE and no locations yet.  */
7073
7074 static void
7075 init_raw_breakpoint_without_location (struct breakpoint *b,
7076                                       struct gdbarch *gdbarch,
7077                                       enum bptype bptype,
7078                                       const struct breakpoint_ops *ops)
7079 {
7080   gdb_assert (ops != NULL);
7081
7082   b->ops = ops;
7083   b->type = bptype;
7084   b->gdbarch = gdbarch;
7085   b->language = current_language->la_language;
7086   b->input_radix = input_radix;
7087   b->related_breakpoint = b;
7088 }
7089
7090 /* Helper to set_raw_breakpoint below.  Creates a breakpoint
7091    that has type BPTYPE and has no locations as yet.  */
7092
7093 static struct breakpoint *
7094 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
7095                                      enum bptype bptype,
7096                                      const struct breakpoint_ops *ops)
7097 {
7098   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7099
7100   init_raw_breakpoint_without_location (b.get (), gdbarch, bptype, ops);
7101   return add_to_breakpoint_chain (std::move (b));
7102 }
7103
7104 /* Initialize loc->function_name.  EXPLICIT_LOC says no indirect function
7105    resolutions should be made as the user specified the location explicitly
7106    enough.  */
7107
7108 static void
7109 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
7110 {
7111   gdb_assert (loc->owner != NULL);
7112
7113   if (loc->owner->type == bp_breakpoint
7114       || loc->owner->type == bp_hardware_breakpoint
7115       || is_tracepoint (loc->owner))
7116     {
7117       const char *function_name;
7118
7119       if (loc->msymbol != NULL
7120           && (MSYMBOL_TYPE (loc->msymbol) == mst_text_gnu_ifunc
7121               || MSYMBOL_TYPE (loc->msymbol) == mst_data_gnu_ifunc)
7122           && !explicit_loc)
7123         {
7124           struct breakpoint *b = loc->owner;
7125
7126           function_name = MSYMBOL_LINKAGE_NAME (loc->msymbol);
7127
7128           if (b->type == bp_breakpoint && b->loc == loc
7129               && loc->next == NULL && b->related_breakpoint == b)
7130             {
7131               /* Create only the whole new breakpoint of this type but do not
7132                  mess more complicated breakpoints with multiple locations.  */
7133               b->type = bp_gnu_ifunc_resolver;
7134               /* Remember the resolver's address for use by the return
7135                  breakpoint.  */
7136               loc->related_address = loc->address;
7137             }
7138         }
7139       else
7140         find_pc_partial_function (loc->address, &function_name, NULL, NULL);
7141
7142       if (function_name)
7143         loc->function_name = xstrdup (function_name);
7144     }
7145 }
7146
7147 /* Attempt to determine architecture of location identified by SAL.  */
7148 struct gdbarch *
7149 get_sal_arch (struct symtab_and_line sal)
7150 {
7151   if (sal.section)
7152     return get_objfile_arch (sal.section->objfile);
7153   if (sal.symtab)
7154     return get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
7155
7156   return NULL;
7157 }
7158
7159 /* Low level routine for partially initializing a breakpoint of type
7160    BPTYPE.  The newly created breakpoint's address, section, source
7161    file name, and line number are provided by SAL.
7162
7163    It is expected that the caller will complete the initialization of
7164    the newly created breakpoint struct as well as output any status
7165    information regarding the creation of a new breakpoint.  */
7166
7167 static void
7168 init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
7169                      struct symtab_and_line sal, enum bptype bptype,
7170                      const struct breakpoint_ops *ops)
7171 {
7172   init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
7173
7174   add_location_to_breakpoint (b, &sal);
7175
7176   if (bptype != bp_catchpoint)
7177     gdb_assert (sal.pspace != NULL);
7178
7179   /* Store the program space that was used to set the breakpoint,
7180      except for ordinary breakpoints, which are independent of the
7181      program space.  */
7182   if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
7183     b->pspace = sal.pspace;
7184 }
7185
7186 /* set_raw_breakpoint is a low level routine for allocating and
7187    partially initializing a breakpoint of type BPTYPE.  The newly
7188    created breakpoint's address, section, source file name, and line
7189    number are provided by SAL.  The newly created and partially
7190    initialized breakpoint is added to the breakpoint chain and
7191    is also returned as the value of this function.
7192
7193    It is expected that the caller will complete the initialization of
7194    the newly created breakpoint struct as well as output any status
7195    information regarding the creation of a new breakpoint.  In
7196    particular, set_raw_breakpoint does NOT set the breakpoint
7197    number!  Care should be taken to not allow an error to occur
7198    prior to completing the initialization of the breakpoint.  If this
7199    should happen, a bogus breakpoint will be left on the chain.  */
7200
7201 struct breakpoint *
7202 set_raw_breakpoint (struct gdbarch *gdbarch,
7203                     struct symtab_and_line sal, enum bptype bptype,
7204                     const struct breakpoint_ops *ops)
7205 {
7206   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7207
7208   init_raw_breakpoint (b.get (), gdbarch, sal, bptype, ops);
7209   return add_to_breakpoint_chain (std::move (b));
7210 }
7211
7212 /* Call this routine when stepping and nexting to enable a breakpoint
7213    if we do a longjmp() or 'throw' in TP.  FRAME is the frame which
7214    initiated the operation.  */
7215
7216 void
7217 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
7218 {
7219   struct breakpoint *b, *b_tmp;
7220   int thread = tp->global_num;
7221
7222   /* To avoid having to rescan all objfile symbols at every step,
7223      we maintain a list of continually-inserted but always disabled
7224      longjmp "master" breakpoints.  Here, we simply create momentary
7225      clones of those and enable them for the requested thread.  */
7226   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7227     if (b->pspace == current_program_space
7228         && (b->type == bp_longjmp_master
7229             || b->type == bp_exception_master))
7230       {
7231         enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7232         struct breakpoint *clone;
7233
7234         /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7235            after their removal.  */
7236         clone = momentary_breakpoint_from_master (b, type,
7237                                                   &momentary_breakpoint_ops, 1);
7238         clone->thread = thread;
7239       }
7240
7241   tp->initiating_frame = frame;
7242 }
7243
7244 /* Delete all longjmp breakpoints from THREAD.  */
7245 void
7246 delete_longjmp_breakpoint (int thread)
7247 {
7248   struct breakpoint *b, *b_tmp;
7249
7250   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7251     if (b->type == bp_longjmp || b->type == bp_exception)
7252       {
7253         if (b->thread == thread)
7254           delete_breakpoint (b);
7255       }
7256 }
7257
7258 void
7259 delete_longjmp_breakpoint_at_next_stop (int thread)
7260 {
7261   struct breakpoint *b, *b_tmp;
7262
7263   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7264     if (b->type == bp_longjmp || b->type == bp_exception)
7265       {
7266         if (b->thread == thread)
7267           b->disposition = disp_del_at_next_stop;
7268       }
7269 }
7270
7271 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7272    INFERIOR_PTID thread.  Chain them all by RELATED_BREAKPOINT and return
7273    pointer to any of them.  Return NULL if this system cannot place longjmp
7274    breakpoints.  */
7275
7276 struct breakpoint *
7277 set_longjmp_breakpoint_for_call_dummy (void)
7278 {
7279   struct breakpoint *b, *retval = NULL;
7280
7281   ALL_BREAKPOINTS (b)
7282     if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7283       {
7284         struct breakpoint *new_b;
7285
7286         new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
7287                                                   &momentary_breakpoint_ops,
7288                                                   1);
7289         new_b->thread = inferior_thread ()->global_num;
7290
7291         /* Link NEW_B into the chain of RETVAL breakpoints.  */
7292
7293         gdb_assert (new_b->related_breakpoint == new_b);
7294         if (retval == NULL)
7295           retval = new_b;
7296         new_b->related_breakpoint = retval;
7297         while (retval->related_breakpoint != new_b->related_breakpoint)
7298           retval = retval->related_breakpoint;
7299         retval->related_breakpoint = new_b;
7300       }
7301
7302   return retval;
7303 }
7304
7305 /* Verify all existing dummy frames and their associated breakpoints for
7306    TP.  Remove those which can no longer be found in the current frame
7307    stack.
7308
7309    You should call this function only at places where it is safe to currently
7310    unwind the whole stack.  Failed stack unwind would discard live dummy
7311    frames.  */
7312
7313 void
7314 check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp)
7315 {
7316   struct breakpoint *b, *b_tmp;
7317
7318   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7319     if (b->type == bp_longjmp_call_dummy && b->thread == tp->global_num)
7320       {
7321         struct breakpoint *dummy_b = b->related_breakpoint;
7322
7323         while (dummy_b != b && dummy_b->type != bp_call_dummy)
7324           dummy_b = dummy_b->related_breakpoint;
7325         if (dummy_b->type != bp_call_dummy
7326             || frame_find_by_id (dummy_b->frame_id) != NULL)
7327           continue;
7328         
7329         dummy_frame_discard (dummy_b->frame_id, tp);
7330
7331         while (b->related_breakpoint != b)
7332           {
7333             if (b_tmp == b->related_breakpoint)
7334               b_tmp = b->related_breakpoint->next;
7335             delete_breakpoint (b->related_breakpoint);
7336           }
7337         delete_breakpoint (b);
7338       }
7339 }
7340
7341 void
7342 enable_overlay_breakpoints (void)
7343 {
7344   struct breakpoint *b;
7345
7346   ALL_BREAKPOINTS (b)
7347     if (b->type == bp_overlay_event)
7348     {
7349       b->enable_state = bp_enabled;
7350       update_global_location_list (UGLL_MAY_INSERT);
7351       overlay_events_enabled = 1;
7352     }
7353 }
7354
7355 void
7356 disable_overlay_breakpoints (void)
7357 {
7358   struct breakpoint *b;
7359
7360   ALL_BREAKPOINTS (b)
7361     if (b->type == bp_overlay_event)
7362     {
7363       b->enable_state = bp_disabled;
7364       update_global_location_list (UGLL_DONT_INSERT);
7365       overlay_events_enabled = 0;
7366     }
7367 }
7368
7369 /* Set an active std::terminate breakpoint for each std::terminate
7370    master breakpoint.  */
7371 void
7372 set_std_terminate_breakpoint (void)
7373 {
7374   struct breakpoint *b, *b_tmp;
7375
7376   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7377     if (b->pspace == current_program_space
7378         && b->type == bp_std_terminate_master)
7379       {
7380         momentary_breakpoint_from_master (b, bp_std_terminate,
7381                                           &momentary_breakpoint_ops, 1);
7382       }
7383 }
7384
7385 /* Delete all the std::terminate breakpoints.  */
7386 void
7387 delete_std_terminate_breakpoint (void)
7388 {
7389   struct breakpoint *b, *b_tmp;
7390
7391   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7392     if (b->type == bp_std_terminate)
7393       delete_breakpoint (b);
7394 }
7395
7396 struct breakpoint *
7397 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7398 {
7399   struct breakpoint *b;
7400
7401   b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7402                                   &internal_breakpoint_ops);
7403
7404   b->enable_state = bp_enabled;
7405   /* location has to be used or breakpoint_re_set will delete me.  */
7406   b->location = new_address_location (b->loc->address, NULL, 0);
7407
7408   update_global_location_list_nothrow (UGLL_MAY_INSERT);
7409
7410   return b;
7411 }
7412
7413 struct lang_and_radix
7414   {
7415     enum language lang;
7416     int radix;
7417   };
7418
7419 /* Create a breakpoint for JIT code registration and unregistration.  */
7420
7421 struct breakpoint *
7422 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7423 {
7424   return create_internal_breakpoint (gdbarch, address, bp_jit_event,
7425                                      &internal_breakpoint_ops);
7426 }
7427
7428 /* Remove JIT code registration and unregistration breakpoint(s).  */
7429
7430 void
7431 remove_jit_event_breakpoints (void)
7432 {
7433   struct breakpoint *b, *b_tmp;
7434
7435   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7436     if (b->type == bp_jit_event
7437         && b->loc->pspace == current_program_space)
7438       delete_breakpoint (b);
7439 }
7440
7441 void
7442 remove_solib_event_breakpoints (void)
7443 {
7444   struct breakpoint *b, *b_tmp;
7445
7446   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7447     if (b->type == bp_shlib_event
7448         && b->loc->pspace == current_program_space)
7449       delete_breakpoint (b);
7450 }
7451
7452 /* See breakpoint.h.  */
7453
7454 void
7455 remove_solib_event_breakpoints_at_next_stop (void)
7456 {
7457   struct breakpoint *b, *b_tmp;
7458
7459   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7460     if (b->type == bp_shlib_event
7461         && b->loc->pspace == current_program_space)
7462       b->disposition = disp_del_at_next_stop;
7463 }
7464
7465 /* Helper for create_solib_event_breakpoint /
7466    create_and_insert_solib_event_breakpoint.  Allows specifying which
7467    INSERT_MODE to pass through to update_global_location_list.  */
7468
7469 static struct breakpoint *
7470 create_solib_event_breakpoint_1 (struct gdbarch *gdbarch, CORE_ADDR address,
7471                                  enum ugll_insert_mode insert_mode)
7472 {
7473   struct breakpoint *b;
7474
7475   b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7476                                   &internal_breakpoint_ops);
7477   update_global_location_list_nothrow (insert_mode);
7478   return b;
7479 }
7480
7481 struct breakpoint *
7482 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7483 {
7484   return create_solib_event_breakpoint_1 (gdbarch, address, UGLL_MAY_INSERT);
7485 }
7486
7487 /* See breakpoint.h.  */
7488
7489 struct breakpoint *
7490 create_and_insert_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7491 {
7492   struct breakpoint *b;
7493
7494   /* Explicitly tell update_global_location_list to insert
7495      locations.  */
7496   b = create_solib_event_breakpoint_1 (gdbarch, address, UGLL_INSERT);
7497   if (!b->loc->inserted)
7498     {
7499       delete_breakpoint (b);
7500       return NULL;
7501     }
7502   return b;
7503 }
7504
7505 /* Disable any breakpoints that are on code in shared libraries.  Only
7506    apply to enabled breakpoints, disabled ones can just stay disabled.  */
7507
7508 void
7509 disable_breakpoints_in_shlibs (void)
7510 {
7511   struct bp_location *loc, **locp_tmp;
7512
7513   ALL_BP_LOCATIONS (loc, locp_tmp)
7514   {
7515     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7516     struct breakpoint *b = loc->owner;
7517
7518     /* We apply the check to all breakpoints, including disabled for
7519        those with loc->duplicate set.  This is so that when breakpoint
7520        becomes enabled, or the duplicate is removed, gdb will try to
7521        insert all breakpoints.  If we don't set shlib_disabled here,
7522        we'll try to insert those breakpoints and fail.  */
7523     if (((b->type == bp_breakpoint)
7524          || (b->type == bp_jit_event)
7525          || (b->type == bp_hardware_breakpoint)
7526          || (is_tracepoint (b)))
7527         && loc->pspace == current_program_space
7528         && !loc->shlib_disabled
7529         && solib_name_from_address (loc->pspace, loc->address)
7530         )
7531       {
7532         loc->shlib_disabled = 1;
7533       }
7534   }
7535 }
7536
7537 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7538    notification of unloaded_shlib.  Only apply to enabled breakpoints,
7539    disabled ones can just stay disabled.  */
7540
7541 static void
7542 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7543 {
7544   struct bp_location *loc, **locp_tmp;
7545   int disabled_shlib_breaks = 0;
7546
7547   ALL_BP_LOCATIONS (loc, locp_tmp)
7548   {
7549     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7550     struct breakpoint *b = loc->owner;
7551
7552     if (solib->pspace == loc->pspace
7553         && !loc->shlib_disabled
7554         && (((b->type == bp_breakpoint
7555               || b->type == bp_jit_event
7556               || b->type == bp_hardware_breakpoint)
7557              && (loc->loc_type == bp_loc_hardware_breakpoint
7558                  || loc->loc_type == bp_loc_software_breakpoint))
7559             || is_tracepoint (b))
7560         && solib_contains_address_p (solib, loc->address))
7561       {
7562         loc->shlib_disabled = 1;
7563         /* At this point, we cannot rely on remove_breakpoint
7564            succeeding so we must mark the breakpoint as not inserted
7565            to prevent future errors occurring in remove_breakpoints.  */
7566         loc->inserted = 0;
7567
7568         /* This may cause duplicate notifications for the same breakpoint.  */
7569         gdb::observers::breakpoint_modified.notify (b);
7570
7571         if (!disabled_shlib_breaks)
7572           {
7573             target_terminal::ours_for_output ();
7574             warning (_("Temporarily disabling breakpoints "
7575                        "for unloaded shared library \"%s\""),
7576                      solib->so_name);
7577           }
7578         disabled_shlib_breaks = 1;
7579       }
7580   }
7581 }
7582
7583 /* Disable any breakpoints and tracepoints in OBJFILE upon
7584    notification of free_objfile.  Only apply to enabled breakpoints,
7585    disabled ones can just stay disabled.  */
7586
7587 static void
7588 disable_breakpoints_in_freed_objfile (struct objfile *objfile)
7589 {
7590   struct breakpoint *b;
7591
7592   if (objfile == NULL)
7593     return;
7594
7595   /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7596      managed by the user with add-symbol-file/remove-symbol-file.
7597      Similarly to how breakpoints in shared libraries are handled in
7598      response to "nosharedlibrary", mark breakpoints in such modules
7599      shlib_disabled so they end up uninserted on the next global
7600      location list update.  Shared libraries not loaded by the user
7601      aren't handled here -- they're already handled in
7602      disable_breakpoints_in_unloaded_shlib, called by solib.c's
7603      solib_unloaded observer.  We skip objfiles that are not
7604      OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7605      main objfile).  */
7606   if ((objfile->flags & OBJF_SHARED) == 0
7607       || (objfile->flags & OBJF_USERLOADED) == 0)
7608     return;
7609
7610   ALL_BREAKPOINTS (b)
7611     {
7612       struct bp_location *loc;
7613       int bp_modified = 0;
7614
7615       if (!is_breakpoint (b) && !is_tracepoint (b))
7616         continue;
7617
7618       for (loc = b->loc; loc != NULL; loc = loc->next)
7619         {
7620           CORE_ADDR loc_addr = loc->address;
7621
7622           if (loc->loc_type != bp_loc_hardware_breakpoint
7623               && loc->loc_type != bp_loc_software_breakpoint)
7624             continue;
7625
7626           if (loc->shlib_disabled != 0)
7627             continue;
7628
7629           if (objfile->pspace != loc->pspace)
7630             continue;
7631
7632           if (loc->loc_type != bp_loc_hardware_breakpoint
7633               && loc->loc_type != bp_loc_software_breakpoint)
7634             continue;
7635
7636           if (is_addr_in_objfile (loc_addr, objfile))
7637             {
7638               loc->shlib_disabled = 1;
7639               /* At this point, we don't know whether the object was
7640                  unmapped from the inferior or not, so leave the
7641                  inserted flag alone.  We'll handle failure to
7642                  uninsert quietly, in case the object was indeed
7643                  unmapped.  */
7644
7645               mark_breakpoint_location_modified (loc);
7646
7647               bp_modified = 1;
7648             }
7649         }
7650
7651       if (bp_modified)
7652         gdb::observers::breakpoint_modified.notify (b);
7653     }
7654 }
7655
7656 /* FORK & VFORK catchpoints.  */
7657
7658 /* An instance of this type is used to represent a fork or vfork
7659    catchpoint.  A breakpoint is really of this type iff its ops pointer points
7660    to CATCH_FORK_BREAKPOINT_OPS.  */
7661
7662 struct fork_catchpoint : public breakpoint
7663 {
7664   /* Process id of a child process whose forking triggered this
7665      catchpoint.  This field is only valid immediately after this
7666      catchpoint has triggered.  */
7667   ptid_t forked_inferior_pid;
7668 };
7669
7670 /* Implement the "insert" breakpoint_ops method for fork
7671    catchpoints.  */
7672
7673 static int
7674 insert_catch_fork (struct bp_location *bl)
7675 {
7676   return target_insert_fork_catchpoint (inferior_ptid.pid ());
7677 }
7678
7679 /* Implement the "remove" breakpoint_ops method for fork
7680    catchpoints.  */
7681
7682 static int
7683 remove_catch_fork (struct bp_location *bl, enum remove_bp_reason reason)
7684 {
7685   return target_remove_fork_catchpoint (inferior_ptid.pid ());
7686 }
7687
7688 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7689    catchpoints.  */
7690
7691 static int
7692 breakpoint_hit_catch_fork (const struct bp_location *bl,
7693                            const address_space *aspace, CORE_ADDR bp_addr,
7694                            const struct target_waitstatus *ws)
7695 {
7696   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7697
7698   if (ws->kind != TARGET_WAITKIND_FORKED)
7699     return 0;
7700
7701   c->forked_inferior_pid = ws->value.related_pid;
7702   return 1;
7703 }
7704
7705 /* Implement the "print_it" breakpoint_ops method for fork
7706    catchpoints.  */
7707
7708 static enum print_stop_action
7709 print_it_catch_fork (bpstat bs)
7710 {
7711   struct ui_out *uiout = current_uiout;
7712   struct breakpoint *b = bs->breakpoint_at;
7713   struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
7714
7715   annotate_catchpoint (b->number);
7716   maybe_print_thread_hit_breakpoint (uiout);
7717   if (b->disposition == disp_del)
7718     uiout->text ("Temporary catchpoint ");
7719   else
7720     uiout->text ("Catchpoint ");
7721   if (uiout->is_mi_like_p ())
7722     {
7723       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK));
7724       uiout->field_string ("disp", bpdisp_text (b->disposition));
7725     }
7726   uiout->field_int ("bkptno", b->number);
7727   uiout->text (" (forked process ");
7728   uiout->field_int ("newpid", c->forked_inferior_pid.pid ());
7729   uiout->text ("), ");
7730   return PRINT_SRC_AND_LOC;
7731 }
7732
7733 /* Implement the "print_one" breakpoint_ops method for fork
7734    catchpoints.  */
7735
7736 static void
7737 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
7738 {
7739   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7740   struct value_print_options opts;
7741   struct ui_out *uiout = current_uiout;
7742
7743   get_user_print_options (&opts);
7744
7745   /* Field 4, the address, is omitted (which makes the columns not
7746      line up too nicely with the headers, but the effect is relatively
7747      readable).  */
7748   if (opts.addressprint)
7749     uiout->field_skip ("addr");
7750   annotate_field (5);
7751   uiout->text ("fork");
7752   if (c->forked_inferior_pid != null_ptid)
7753     {
7754       uiout->text (", process ");
7755       uiout->field_int ("what", c->forked_inferior_pid.pid ());
7756       uiout->spaces (1);
7757     }
7758
7759   if (uiout->is_mi_like_p ())
7760     uiout->field_string ("catch-type", "fork");
7761 }
7762
7763 /* Implement the "print_mention" breakpoint_ops method for fork
7764    catchpoints.  */
7765
7766 static void
7767 print_mention_catch_fork (struct breakpoint *b)
7768 {
7769   printf_filtered (_("Catchpoint %d (fork)"), b->number);
7770 }
7771
7772 /* Implement the "print_recreate" breakpoint_ops method for fork
7773    catchpoints.  */
7774
7775 static void
7776 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
7777 {
7778   fprintf_unfiltered (fp, "catch fork");
7779   print_recreate_thread (b, fp);
7780 }
7781
7782 /* The breakpoint_ops structure to be used in fork catchpoints.  */
7783
7784 static struct breakpoint_ops catch_fork_breakpoint_ops;
7785
7786 /* Implement the "insert" breakpoint_ops method for vfork
7787    catchpoints.  */
7788
7789 static int
7790 insert_catch_vfork (struct bp_location *bl)
7791 {
7792   return target_insert_vfork_catchpoint (inferior_ptid.pid ());
7793 }
7794
7795 /* Implement the "remove" breakpoint_ops method for vfork
7796    catchpoints.  */
7797
7798 static int
7799 remove_catch_vfork (struct bp_location *bl, enum remove_bp_reason reason)
7800 {
7801   return target_remove_vfork_catchpoint (inferior_ptid.pid ());
7802 }
7803
7804 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7805    catchpoints.  */
7806
7807 static int
7808 breakpoint_hit_catch_vfork (const struct bp_location *bl,
7809                             const address_space *aspace, CORE_ADDR bp_addr,
7810                             const struct target_waitstatus *ws)
7811 {
7812   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7813
7814   if (ws->kind != TARGET_WAITKIND_VFORKED)
7815     return 0;
7816
7817   c->forked_inferior_pid = ws->value.related_pid;
7818   return 1;
7819 }
7820
7821 /* Implement the "print_it" breakpoint_ops method for vfork
7822    catchpoints.  */
7823
7824 static enum print_stop_action
7825 print_it_catch_vfork (bpstat bs)
7826 {
7827   struct ui_out *uiout = current_uiout;
7828   struct breakpoint *b = bs->breakpoint_at;
7829   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7830
7831   annotate_catchpoint (b->number);
7832   maybe_print_thread_hit_breakpoint (uiout);
7833   if (b->disposition == disp_del)
7834     uiout->text ("Temporary catchpoint ");
7835   else
7836     uiout->text ("Catchpoint ");
7837   if (uiout->is_mi_like_p ())
7838     {
7839       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK));
7840       uiout->field_string ("disp", bpdisp_text (b->disposition));
7841     }
7842   uiout->field_int ("bkptno", b->number);
7843   uiout->text (" (vforked process ");
7844   uiout->field_int ("newpid", c->forked_inferior_pid.pid ());
7845   uiout->text ("), ");
7846   return PRINT_SRC_AND_LOC;
7847 }
7848
7849 /* Implement the "print_one" breakpoint_ops method for vfork
7850    catchpoints.  */
7851
7852 static void
7853 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
7854 {
7855   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7856   struct value_print_options opts;
7857   struct ui_out *uiout = current_uiout;
7858
7859   get_user_print_options (&opts);
7860   /* Field 4, the address, is omitted (which makes the columns not
7861      line up too nicely with the headers, but the effect is relatively
7862      readable).  */
7863   if (opts.addressprint)
7864     uiout->field_skip ("addr");
7865   annotate_field (5);
7866   uiout->text ("vfork");
7867   if (c->forked_inferior_pid != null_ptid)
7868     {
7869       uiout->text (", process ");
7870       uiout->field_int ("what", c->forked_inferior_pid.pid ());
7871       uiout->spaces (1);
7872     }
7873
7874   if (uiout->is_mi_like_p ())
7875     uiout->field_string ("catch-type", "vfork");
7876 }
7877
7878 /* Implement the "print_mention" breakpoint_ops method for vfork
7879    catchpoints.  */
7880
7881 static void
7882 print_mention_catch_vfork (struct breakpoint *b)
7883 {
7884   printf_filtered (_("Catchpoint %d (vfork)"), b->number);
7885 }
7886
7887 /* Implement the "print_recreate" breakpoint_ops method for vfork
7888    catchpoints.  */
7889
7890 static void
7891 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
7892 {
7893   fprintf_unfiltered (fp, "catch vfork");
7894   print_recreate_thread (b, fp);
7895 }
7896
7897 /* The breakpoint_ops structure to be used in vfork catchpoints.  */
7898
7899 static struct breakpoint_ops catch_vfork_breakpoint_ops;
7900
7901 /* An instance of this type is used to represent an solib catchpoint.
7902    A breakpoint is really of this type iff its ops pointer points to
7903    CATCH_SOLIB_BREAKPOINT_OPS.  */
7904
7905 struct solib_catchpoint : public breakpoint
7906 {
7907   ~solib_catchpoint () override;
7908
7909   /* True for "catch load", false for "catch unload".  */
7910   unsigned char is_load;
7911
7912   /* Regular expression to match, if any.  COMPILED is only valid when
7913      REGEX is non-NULL.  */
7914   char *regex;
7915   std::unique_ptr<compiled_regex> compiled;
7916 };
7917
7918 solib_catchpoint::~solib_catchpoint ()
7919 {
7920   xfree (this->regex);
7921 }
7922
7923 static int
7924 insert_catch_solib (struct bp_location *ignore)
7925 {
7926   return 0;
7927 }
7928
7929 static int
7930 remove_catch_solib (struct bp_location *ignore, enum remove_bp_reason reason)
7931 {
7932   return 0;
7933 }
7934
7935 static int
7936 breakpoint_hit_catch_solib (const struct bp_location *bl,
7937                             const address_space *aspace,
7938                             CORE_ADDR bp_addr,
7939                             const struct target_waitstatus *ws)
7940 {
7941   struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
7942   struct breakpoint *other;
7943
7944   if (ws->kind == TARGET_WAITKIND_LOADED)
7945     return 1;
7946
7947   ALL_BREAKPOINTS (other)
7948   {
7949     struct bp_location *other_bl;
7950
7951     if (other == bl->owner)
7952       continue;
7953
7954     if (other->type != bp_shlib_event)
7955       continue;
7956
7957     if (self->pspace != NULL && other->pspace != self->pspace)
7958       continue;
7959
7960     for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
7961       {
7962         if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
7963           return 1;
7964       }
7965   }
7966
7967   return 0;
7968 }
7969
7970 static void
7971 check_status_catch_solib (struct bpstats *bs)
7972 {
7973   struct solib_catchpoint *self
7974     = (struct solib_catchpoint *) bs->breakpoint_at;
7975
7976   if (self->is_load)
7977     {
7978       for (so_list *iter : current_program_space->added_solibs)
7979         {
7980           if (!self->regex
7981               || self->compiled->exec (iter->so_name, 0, NULL, 0) == 0)
7982             return;
7983         }
7984     }
7985   else
7986     {
7987       for (const std::string &iter : current_program_space->deleted_solibs)
7988         {
7989           if (!self->regex
7990               || self->compiled->exec (iter.c_str (), 0, NULL, 0) == 0)
7991             return;
7992         }
7993     }
7994
7995   bs->stop = 0;
7996   bs->print_it = print_it_noop;
7997 }
7998
7999 static enum print_stop_action
8000 print_it_catch_solib (bpstat bs)
8001 {
8002   struct breakpoint *b = bs->breakpoint_at;
8003   struct ui_out *uiout = current_uiout;
8004
8005   annotate_catchpoint (b->number);
8006   maybe_print_thread_hit_breakpoint (uiout);
8007   if (b->disposition == disp_del)
8008     uiout->text ("Temporary catchpoint ");
8009   else
8010     uiout->text ("Catchpoint ");
8011   uiout->field_int ("bkptno", b->number);
8012   uiout->text ("\n");
8013   if (uiout->is_mi_like_p ())
8014     uiout->field_string ("disp", bpdisp_text (b->disposition));
8015   print_solib_event (1);
8016   return PRINT_SRC_AND_LOC;
8017 }
8018
8019 static void
8020 print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
8021 {
8022   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8023   struct value_print_options opts;
8024   struct ui_out *uiout = current_uiout;
8025
8026   get_user_print_options (&opts);
8027   /* Field 4, the address, is omitted (which makes the columns not
8028      line up too nicely with the headers, but the effect is relatively
8029      readable).  */
8030   if (opts.addressprint)
8031     {
8032       annotate_field (4);
8033       uiout->field_skip ("addr");
8034     }
8035
8036   std::string msg;
8037   annotate_field (5);
8038   if (self->is_load)
8039     {
8040       if (self->regex)
8041         msg = string_printf (_("load of library matching %s"), self->regex);
8042       else
8043         msg = _("load of library");
8044     }
8045   else
8046     {
8047       if (self->regex)
8048         msg = string_printf (_("unload of library matching %s"), self->regex);
8049       else
8050         msg = _("unload of library");
8051     }
8052   uiout->field_string ("what", msg);
8053
8054   if (uiout->is_mi_like_p ())
8055     uiout->field_string ("catch-type", self->is_load ? "load" : "unload");
8056 }
8057
8058 static void
8059 print_mention_catch_solib (struct breakpoint *b)
8060 {
8061   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8062
8063   printf_filtered (_("Catchpoint %d (%s)"), b->number,
8064                    self->is_load ? "load" : "unload");
8065 }
8066
8067 static void
8068 print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
8069 {
8070   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8071
8072   fprintf_unfiltered (fp, "%s %s",
8073                       b->disposition == disp_del ? "tcatch" : "catch",
8074                       self->is_load ? "load" : "unload");
8075   if (self->regex)
8076     fprintf_unfiltered (fp, " %s", self->regex);
8077   fprintf_unfiltered (fp, "\n");
8078 }
8079
8080 static struct breakpoint_ops catch_solib_breakpoint_ops;
8081
8082 /* Shared helper function (MI and CLI) for creating and installing
8083    a shared object event catchpoint.  If IS_LOAD is non-zero then
8084    the events to be caught are load events, otherwise they are
8085    unload events.  If IS_TEMP is non-zero the catchpoint is a
8086    temporary one.  If ENABLED is non-zero the catchpoint is
8087    created in an enabled state.  */
8088
8089 void
8090 add_solib_catchpoint (const char *arg, int is_load, int is_temp, int enabled)
8091 {
8092   struct gdbarch *gdbarch = get_current_arch ();
8093
8094   if (!arg)
8095     arg = "";
8096   arg = skip_spaces (arg);
8097
8098   std::unique_ptr<solib_catchpoint> c (new solib_catchpoint ());
8099
8100   if (*arg != '\0')
8101     {
8102       c->compiled.reset (new compiled_regex (arg, REG_NOSUB,
8103                                              _("Invalid regexp")));
8104       c->regex = xstrdup (arg);
8105     }
8106
8107   c->is_load = is_load;
8108   init_catchpoint (c.get (), gdbarch, is_temp, NULL,
8109                    &catch_solib_breakpoint_ops);
8110
8111   c->enable_state = enabled ? bp_enabled : bp_disabled;
8112
8113   install_breakpoint (0, std::move (c), 1);
8114 }
8115
8116 /* A helper function that does all the work for "catch load" and
8117    "catch unload".  */
8118
8119 static void
8120 catch_load_or_unload (const char *arg, int from_tty, int is_load,
8121                       struct cmd_list_element *command)
8122 {
8123   int tempflag;
8124   const int enabled = 1;
8125
8126   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8127
8128   add_solib_catchpoint (arg, is_load, tempflag, enabled);
8129 }
8130
8131 static void
8132 catch_load_command_1 (const char *arg, int from_tty,
8133                       struct cmd_list_element *command)
8134 {
8135   catch_load_or_unload (arg, from_tty, 1, command);
8136 }
8137
8138 static void
8139 catch_unload_command_1 (const char *arg, int from_tty,
8140                         struct cmd_list_element *command)
8141 {
8142   catch_load_or_unload (arg, from_tty, 0, command);
8143 }
8144
8145 /* Initialize a new breakpoint of the bp_catchpoint kind.  If TEMPFLAG
8146    is non-zero, then make the breakpoint temporary.  If COND_STRING is
8147    not NULL, then store it in the breakpoint.  OPS, if not NULL, is
8148    the breakpoint_ops structure associated to the catchpoint.  */
8149
8150 void
8151 init_catchpoint (struct breakpoint *b,
8152                  struct gdbarch *gdbarch, int tempflag,
8153                  const char *cond_string,
8154                  const struct breakpoint_ops *ops)
8155 {
8156   symtab_and_line sal;
8157   sal.pspace = current_program_space;
8158
8159   init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
8160
8161   b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
8162   b->disposition = tempflag ? disp_del : disp_donttouch;
8163 }
8164
8165 void
8166 install_breakpoint (int internal, std::unique_ptr<breakpoint> &&arg, int update_gll)
8167 {
8168   breakpoint *b = add_to_breakpoint_chain (std::move (arg));
8169   set_breakpoint_number (internal, b);
8170   if (is_tracepoint (b))
8171     set_tracepoint_count (breakpoint_count);
8172   if (!internal)
8173     mention (b);
8174   gdb::observers::breakpoint_created.notify (b);
8175
8176   if (update_gll)
8177     update_global_location_list (UGLL_MAY_INSERT);
8178 }
8179
8180 static void
8181 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
8182                                     int tempflag, const char *cond_string,
8183                                     const struct breakpoint_ops *ops)
8184 {
8185   std::unique_ptr<fork_catchpoint> c (new fork_catchpoint ());
8186
8187   init_catchpoint (c.get (), gdbarch, tempflag, cond_string, ops);
8188
8189   c->forked_inferior_pid = null_ptid;
8190
8191   install_breakpoint (0, std::move (c), 1);
8192 }
8193
8194 /* Exec catchpoints.  */
8195
8196 /* An instance of this type is used to represent an exec catchpoint.
8197    A breakpoint is really of this type iff its ops pointer points to
8198    CATCH_EXEC_BREAKPOINT_OPS.  */
8199
8200 struct exec_catchpoint : public breakpoint
8201 {
8202   ~exec_catchpoint () override;
8203
8204   /* Filename of a program whose exec triggered this catchpoint.
8205      This field is only valid immediately after this catchpoint has
8206      triggered.  */
8207   char *exec_pathname;
8208 };
8209
8210 /* Exec catchpoint destructor.  */
8211
8212 exec_catchpoint::~exec_catchpoint ()
8213 {
8214   xfree (this->exec_pathname);
8215 }
8216
8217 static int
8218 insert_catch_exec (struct bp_location *bl)
8219 {
8220   return target_insert_exec_catchpoint (inferior_ptid.pid ());
8221 }
8222
8223 static int
8224 remove_catch_exec (struct bp_location *bl, enum remove_bp_reason reason)
8225 {
8226   return target_remove_exec_catchpoint (inferior_ptid.pid ());
8227 }
8228
8229 static int
8230 breakpoint_hit_catch_exec (const struct bp_location *bl,
8231                            const address_space *aspace, CORE_ADDR bp_addr,
8232                            const struct target_waitstatus *ws)
8233 {
8234   struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8235
8236   if (ws->kind != TARGET_WAITKIND_EXECD)
8237     return 0;
8238
8239   c->exec_pathname = xstrdup (ws->value.execd_pathname);
8240   return 1;
8241 }
8242
8243 static enum print_stop_action
8244 print_it_catch_exec (bpstat bs)
8245 {
8246   struct ui_out *uiout = current_uiout;
8247   struct breakpoint *b = bs->breakpoint_at;
8248   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8249
8250   annotate_catchpoint (b->number);
8251   maybe_print_thread_hit_breakpoint (uiout);
8252   if (b->disposition == disp_del)
8253     uiout->text ("Temporary catchpoint ");
8254   else
8255     uiout->text ("Catchpoint ");
8256   if (uiout->is_mi_like_p ())
8257     {
8258       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC));
8259       uiout->field_string ("disp", bpdisp_text (b->disposition));
8260     }
8261   uiout->field_int ("bkptno", b->number);
8262   uiout->text (" (exec'd ");
8263   uiout->field_string ("new-exec", c->exec_pathname);
8264   uiout->text ("), ");
8265
8266   return PRINT_SRC_AND_LOC;
8267 }
8268
8269 static void
8270 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
8271 {
8272   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8273   struct value_print_options opts;
8274   struct ui_out *uiout = current_uiout;
8275
8276   get_user_print_options (&opts);
8277
8278   /* Field 4, the address, is omitted (which makes the columns
8279      not line up too nicely with the headers, but the effect
8280      is relatively readable).  */
8281   if (opts.addressprint)
8282     uiout->field_skip ("addr");
8283   annotate_field (5);
8284   uiout->text ("exec");
8285   if (c->exec_pathname != NULL)
8286     {
8287       uiout->text (", program \"");
8288       uiout->field_string ("what", c->exec_pathname);
8289       uiout->text ("\" ");
8290     }
8291
8292   if (uiout->is_mi_like_p ())
8293     uiout->field_string ("catch-type", "exec");
8294 }
8295
8296 static void
8297 print_mention_catch_exec (struct breakpoint *b)
8298 {
8299   printf_filtered (_("Catchpoint %d (exec)"), b->number);
8300 }
8301
8302 /* Implement the "print_recreate" breakpoint_ops method for exec
8303    catchpoints.  */
8304
8305 static void
8306 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8307 {
8308   fprintf_unfiltered (fp, "catch exec");
8309   print_recreate_thread (b, fp);
8310 }
8311
8312 static struct breakpoint_ops catch_exec_breakpoint_ops;
8313
8314 static int
8315 hw_breakpoint_used_count (void)
8316 {
8317   int i = 0;
8318   struct breakpoint *b;
8319   struct bp_location *bl;
8320
8321   ALL_BREAKPOINTS (b)
8322   {
8323     if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
8324       for (bl = b->loc; bl; bl = bl->next)
8325         {
8326           /* Special types of hardware breakpoints may use more than
8327              one register.  */
8328           i += b->ops->resources_needed (bl);
8329         }
8330   }
8331
8332   return i;
8333 }
8334
8335 /* Returns the resources B would use if it were a hardware
8336    watchpoint.  */
8337
8338 static int
8339 hw_watchpoint_use_count (struct breakpoint *b)
8340 {
8341   int i = 0;
8342   struct bp_location *bl;
8343
8344   if (!breakpoint_enabled (b))
8345     return 0;
8346
8347   for (bl = b->loc; bl; bl = bl->next)
8348     {
8349       /* Special types of hardware watchpoints may use more than
8350          one register.  */
8351       i += b->ops->resources_needed (bl);
8352     }
8353
8354   return i;
8355 }
8356
8357 /* Returns the sum the used resources of all hardware watchpoints of
8358    type TYPE in the breakpoints list.  Also returns in OTHER_TYPE_USED
8359    the sum of the used resources of all hardware watchpoints of other
8360    types _not_ TYPE.  */
8361
8362 static int
8363 hw_watchpoint_used_count_others (struct breakpoint *except,
8364                                  enum bptype type, int *other_type_used)
8365 {
8366   int i = 0;
8367   struct breakpoint *b;
8368
8369   *other_type_used = 0;
8370   ALL_BREAKPOINTS (b)
8371     {
8372       if (b == except)
8373         continue;
8374       if (!breakpoint_enabled (b))
8375         continue;
8376
8377       if (b->type == type)
8378         i += hw_watchpoint_use_count (b);
8379       else if (is_hardware_watchpoint (b))
8380         *other_type_used = 1;
8381     }
8382
8383   return i;
8384 }
8385
8386 void
8387 disable_watchpoints_before_interactive_call_start (void)
8388 {
8389   struct breakpoint *b;
8390
8391   ALL_BREAKPOINTS (b)
8392   {
8393     if (is_watchpoint (b) && breakpoint_enabled (b))
8394       {
8395         b->enable_state = bp_call_disabled;
8396         update_global_location_list (UGLL_DONT_INSERT);
8397       }
8398   }
8399 }
8400
8401 void
8402 enable_watchpoints_after_interactive_call_stop (void)
8403 {
8404   struct breakpoint *b;
8405
8406   ALL_BREAKPOINTS (b)
8407   {
8408     if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
8409       {
8410         b->enable_state = bp_enabled;
8411         update_global_location_list (UGLL_MAY_INSERT);
8412       }
8413   }
8414 }
8415
8416 void
8417 disable_breakpoints_before_startup (void)
8418 {
8419   current_program_space->executing_startup = 1;
8420   update_global_location_list (UGLL_DONT_INSERT);
8421 }
8422
8423 void
8424 enable_breakpoints_after_startup (void)
8425 {
8426   current_program_space->executing_startup = 0;
8427   breakpoint_re_set ();
8428 }
8429
8430 /* Create a new single-step breakpoint for thread THREAD, with no
8431    locations.  */
8432
8433 static struct breakpoint *
8434 new_single_step_breakpoint (int thread, struct gdbarch *gdbarch)
8435 {
8436   std::unique_ptr<breakpoint> b (new breakpoint ());
8437
8438   init_raw_breakpoint_without_location (b.get (), gdbarch, bp_single_step,
8439                                         &momentary_breakpoint_ops);
8440
8441   b->disposition = disp_donttouch;
8442   b->frame_id = null_frame_id;
8443
8444   b->thread = thread;
8445   gdb_assert (b->thread != 0);
8446
8447   return add_to_breakpoint_chain (std::move (b));
8448 }
8449
8450 /* Set a momentary breakpoint of type TYPE at address specified by
8451    SAL.  If FRAME_ID is valid, the breakpoint is restricted to that
8452    frame.  */
8453
8454 breakpoint_up
8455 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8456                           struct frame_id frame_id, enum bptype type)
8457 {
8458   struct breakpoint *b;
8459
8460   /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8461      tail-called one.  */
8462   gdb_assert (!frame_id_artificial_p (frame_id));
8463
8464   b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
8465   b->enable_state = bp_enabled;
8466   b->disposition = disp_donttouch;
8467   b->frame_id = frame_id;
8468
8469   b->thread = inferior_thread ()->global_num;
8470
8471   update_global_location_list_nothrow (UGLL_MAY_INSERT);
8472
8473   return breakpoint_up (b);
8474 }
8475
8476 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8477    The new breakpoint will have type TYPE, use OPS as its
8478    breakpoint_ops, and will set enabled to LOC_ENABLED.  */
8479
8480 static struct breakpoint *
8481 momentary_breakpoint_from_master (struct breakpoint *orig,
8482                                   enum bptype type,
8483                                   const struct breakpoint_ops *ops,
8484                                   int loc_enabled)
8485 {
8486   struct breakpoint *copy;
8487
8488   copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
8489   copy->loc = allocate_bp_location (copy);
8490   set_breakpoint_location_function (copy->loc, 1);
8491
8492   copy->loc->gdbarch = orig->loc->gdbarch;
8493   copy->loc->requested_address = orig->loc->requested_address;
8494   copy->loc->address = orig->loc->address;
8495   copy->loc->section = orig->loc->section;
8496   copy->loc->pspace = orig->loc->pspace;
8497   copy->loc->probe = orig->loc->probe;
8498   copy->loc->line_number = orig->loc->line_number;
8499   copy->loc->symtab = orig->loc->symtab;
8500   copy->loc->enabled = loc_enabled;
8501   copy->frame_id = orig->frame_id;
8502   copy->thread = orig->thread;
8503   copy->pspace = orig->pspace;
8504
8505   copy->enable_state = bp_enabled;
8506   copy->disposition = disp_donttouch;
8507   copy->number = internal_breakpoint_number--;
8508
8509   update_global_location_list_nothrow (UGLL_DONT_INSERT);
8510   return copy;
8511 }
8512
8513 /* Make a deep copy of momentary breakpoint ORIG.  Returns NULL if
8514    ORIG is NULL.  */
8515
8516 struct breakpoint *
8517 clone_momentary_breakpoint (struct breakpoint *orig)
8518 {
8519   /* If there's nothing to clone, then return nothing.  */
8520   if (orig == NULL)
8521     return NULL;
8522
8523   return momentary_breakpoint_from_master (orig, orig->type, orig->ops, 0);
8524 }
8525
8526 breakpoint_up
8527 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8528                                 enum bptype type)
8529 {
8530   struct symtab_and_line sal;
8531
8532   sal = find_pc_line (pc, 0);
8533   sal.pc = pc;
8534   sal.section = find_pc_overlay (pc);
8535   sal.explicit_pc = 1;
8536
8537   return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
8538 }
8539 \f
8540
8541 /* Tell the user we have just set a breakpoint B.  */
8542
8543 static void
8544 mention (struct breakpoint *b)
8545 {
8546   b->ops->print_mention (b);
8547   current_uiout->text ("\n");
8548 }
8549 \f
8550
8551 static int bp_loc_is_permanent (struct bp_location *loc);
8552
8553 static struct bp_location *
8554 add_location_to_breakpoint (struct breakpoint *b,
8555                             const struct symtab_and_line *sal)
8556 {
8557   struct bp_location *loc, **tmp;
8558   CORE_ADDR adjusted_address;
8559   struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
8560
8561   if (loc_gdbarch == NULL)
8562     loc_gdbarch = b->gdbarch;
8563
8564   /* Adjust the breakpoint's address prior to allocating a location.
8565      Once we call allocate_bp_location(), that mostly uninitialized
8566      location will be placed on the location chain.  Adjustment of the
8567      breakpoint may cause target_read_memory() to be called and we do
8568      not want its scan of the location chain to find a breakpoint and
8569      location that's only been partially initialized.  */
8570   adjusted_address = adjust_breakpoint_address (loc_gdbarch,
8571                                                 sal->pc, b->type);
8572
8573   /* Sort the locations by their ADDRESS.  */
8574   loc = allocate_bp_location (b);
8575   for (tmp = &(b->loc); *tmp != NULL && (*tmp)->address <= adjusted_address;
8576        tmp = &((*tmp)->next))
8577     ;
8578   loc->next = *tmp;
8579   *tmp = loc;
8580
8581   loc->requested_address = sal->pc;
8582   loc->address = adjusted_address;
8583   loc->pspace = sal->pspace;
8584   loc->probe.prob = sal->prob;
8585   loc->probe.objfile = sal->objfile;
8586   gdb_assert (loc->pspace != NULL);
8587   loc->section = sal->section;
8588   loc->gdbarch = loc_gdbarch;
8589   loc->line_number = sal->line;
8590   loc->symtab = sal->symtab;
8591   loc->symbol = sal->symbol;
8592   loc->msymbol = sal->msymbol;
8593   loc->objfile = sal->objfile;
8594
8595   set_breakpoint_location_function (loc,
8596                                     sal->explicit_pc || sal->explicit_line);
8597
8598   /* While by definition, permanent breakpoints are already present in the
8599      code, we don't mark the location as inserted.  Normally one would expect
8600      that GDB could rely on that breakpoint instruction to stop the program,
8601      thus removing the need to insert its own breakpoint, except that executing
8602      the breakpoint instruction can kill the target instead of reporting a
8603      SIGTRAP.  E.g., on SPARC, when interrupts are disabled, executing the
8604      instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8605      with "Trap 0x02 while interrupts disabled, Error state".  Letting the
8606      breakpoint be inserted normally results in QEMU knowing about the GDB
8607      breakpoint, and thus trap before the breakpoint instruction is executed.
8608      (If GDB later needs to continue execution past the permanent breakpoint,
8609      it manually increments the PC, thus avoiding executing the breakpoint
8610      instruction.)  */
8611   if (bp_loc_is_permanent (loc))
8612     loc->permanent = 1;
8613
8614   return loc;
8615 }
8616 \f
8617
8618 /* See breakpoint.h.  */
8619
8620 int
8621 program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address)
8622 {
8623   int len;
8624   CORE_ADDR addr;
8625   const gdb_byte *bpoint;
8626   gdb_byte *target_mem;
8627
8628   addr = address;
8629   bpoint = gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
8630
8631   /* Software breakpoints unsupported?  */
8632   if (bpoint == NULL)
8633     return 0;
8634
8635   target_mem = (gdb_byte *) alloca (len);
8636
8637   /* Enable the automatic memory restoration from breakpoints while
8638      we read the memory.  Otherwise we could say about our temporary
8639      breakpoints they are permanent.  */
8640   scoped_restore restore_memory
8641     = make_scoped_restore_show_memory_breakpoints (0);
8642
8643   if (target_read_memory (address, target_mem, len) == 0
8644       && memcmp (target_mem, bpoint, len) == 0)
8645     return 1;
8646
8647   return 0;
8648 }
8649
8650 /* Return 1 if LOC is pointing to a permanent breakpoint,
8651    return 0 otherwise.  */
8652
8653 static int
8654 bp_loc_is_permanent (struct bp_location *loc)
8655 {
8656   gdb_assert (loc != NULL);
8657
8658   /* If we have a catchpoint or a watchpoint, just return 0.  We should not
8659      attempt to read from the addresses the locations of these breakpoint types
8660      point to.  program_breakpoint_here_p, below, will attempt to read
8661      memory.  */
8662   if (!breakpoint_address_is_meaningful (loc->owner))
8663     return 0;
8664
8665   scoped_restore_current_pspace_and_thread restore_pspace_thread;
8666   switch_to_program_space_and_thread (loc->pspace);
8667   return program_breakpoint_here_p (loc->gdbarch, loc->address);
8668 }
8669
8670 /* Build a command list for the dprintf corresponding to the current
8671    settings of the dprintf style options.  */
8672
8673 static void
8674 update_dprintf_command_list (struct breakpoint *b)
8675 {
8676   char *dprintf_args = b->extra_string;
8677   char *printf_line = NULL;
8678
8679   if (!dprintf_args)
8680     return;
8681
8682   dprintf_args = skip_spaces (dprintf_args);
8683
8684   /* Allow a comma, as it may have terminated a location, but don't
8685      insist on it.  */
8686   if (*dprintf_args == ',')
8687     ++dprintf_args;
8688   dprintf_args = skip_spaces (dprintf_args);
8689
8690   if (*dprintf_args != '"')
8691     error (_("Bad format string, missing '\"'."));
8692
8693   if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
8694     printf_line = xstrprintf ("printf %s", dprintf_args);
8695   else if (strcmp (dprintf_style, dprintf_style_call) == 0)
8696     {
8697       if (!dprintf_function)
8698         error (_("No function supplied for dprintf call"));
8699
8700       if (dprintf_channel && strlen (dprintf_channel) > 0)
8701         printf_line = xstrprintf ("call (void) %s (%s,%s)",
8702                                   dprintf_function,
8703                                   dprintf_channel,
8704                                   dprintf_args);
8705       else
8706         printf_line = xstrprintf ("call (void) %s (%s)",
8707                                   dprintf_function,
8708                                   dprintf_args);
8709     }
8710   else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
8711     {
8712       if (target_can_run_breakpoint_commands ())
8713         printf_line = xstrprintf ("agent-printf %s", dprintf_args);
8714       else
8715         {
8716           warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8717           printf_line = xstrprintf ("printf %s", dprintf_args);
8718         }
8719     }
8720   else
8721     internal_error (__FILE__, __LINE__,
8722                     _("Invalid dprintf style."));
8723
8724   gdb_assert (printf_line != NULL);
8725
8726   /* Manufacture a printf sequence.  */
8727   struct command_line *printf_cmd_line
8728     = new struct command_line (simple_control, printf_line);
8729   breakpoint_set_commands (b, counted_command_line (printf_cmd_line,
8730                                                     command_lines_deleter ()));
8731 }
8732
8733 /* Update all dprintf commands, making their command lists reflect
8734    current style settings.  */
8735
8736 static void
8737 update_dprintf_commands (const char *args, int from_tty,
8738                          struct cmd_list_element *c)
8739 {
8740   struct breakpoint *b;
8741
8742   ALL_BREAKPOINTS (b)
8743     {
8744       if (b->type == bp_dprintf)
8745         update_dprintf_command_list (b);
8746     }
8747 }
8748
8749 /* Create a breakpoint with SAL as location.  Use LOCATION
8750    as a description of the location, and COND_STRING
8751    as condition expression.  If LOCATION is NULL then create an
8752    "address location" from the address in the SAL.  */
8753
8754 static void
8755 init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
8756                      gdb::array_view<const symtab_and_line> sals,
8757                      event_location_up &&location,
8758                      gdb::unique_xmalloc_ptr<char> filter,
8759                      gdb::unique_xmalloc_ptr<char> cond_string,
8760                      gdb::unique_xmalloc_ptr<char> extra_string,
8761                      enum bptype type, enum bpdisp disposition,
8762                      int thread, int task, int ignore_count,
8763                      const struct breakpoint_ops *ops, int from_tty,
8764                      int enabled, int internal, unsigned flags,
8765                      int display_canonical)
8766 {
8767   int i;
8768
8769   if (type == bp_hardware_breakpoint)
8770     {
8771       int target_resources_ok;
8772
8773       i = hw_breakpoint_used_count ();
8774       target_resources_ok =
8775         target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
8776                                             i + 1, 0);
8777       if (target_resources_ok == 0)
8778         error (_("No hardware breakpoint support in the target."));
8779       else if (target_resources_ok < 0)
8780         error (_("Hardware breakpoints used exceeds limit."));
8781     }
8782
8783   gdb_assert (!sals.empty ());
8784
8785   for (const auto &sal : sals)
8786     {
8787       struct bp_location *loc;
8788
8789       if (from_tty)
8790         {
8791           struct gdbarch *loc_gdbarch = get_sal_arch (sal);
8792           if (!loc_gdbarch)
8793             loc_gdbarch = gdbarch;
8794
8795           describe_other_breakpoints (loc_gdbarch,
8796                                       sal.pspace, sal.pc, sal.section, thread);
8797         }
8798
8799       if (&sal == &sals[0])
8800         {
8801           init_raw_breakpoint (b, gdbarch, sal, type, ops);
8802           b->thread = thread;
8803           b->task = task;
8804
8805           b->cond_string = cond_string.release ();
8806           b->extra_string = extra_string.release ();
8807           b->ignore_count = ignore_count;
8808           b->enable_state = enabled ? bp_enabled : bp_disabled;
8809           b->disposition = disposition;
8810
8811           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8812             b->loc->inserted = 1;
8813
8814           if (type == bp_static_tracepoint)
8815             {
8816               struct tracepoint *t = (struct tracepoint *) b;
8817               struct static_tracepoint_marker marker;
8818
8819               if (strace_marker_p (b))
8820                 {
8821                   /* We already know the marker exists, otherwise, we
8822                      wouldn't see a sal for it.  */
8823                   const char *p
8824                     = &event_location_to_string (b->location.get ())[3];
8825                   const char *endp;
8826
8827                   p = skip_spaces (p);
8828
8829                   endp = skip_to_space (p);
8830
8831                   t->static_trace_marker_id.assign (p, endp - p);
8832
8833                   printf_filtered (_("Probed static tracepoint "
8834                                      "marker \"%s\"\n"),
8835                                    t->static_trace_marker_id.c_str ());
8836                 }
8837               else if (target_static_tracepoint_marker_at (sal.pc, &marker))
8838                 {
8839                   t->static_trace_marker_id = std::move (marker.str_id);
8840
8841                   printf_filtered (_("Probed static tracepoint "
8842                                      "marker \"%s\"\n"),
8843                                    t->static_trace_marker_id.c_str ());
8844                 }
8845               else
8846                 warning (_("Couldn't determine the static "
8847                            "tracepoint marker to probe"));
8848             }
8849
8850           loc = b->loc;
8851         }
8852       else
8853         {
8854           loc = add_location_to_breakpoint (b, &sal);
8855           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8856             loc->inserted = 1;
8857         }
8858
8859       if (b->cond_string)
8860         {
8861           const char *arg = b->cond_string;
8862
8863           loc->cond = parse_exp_1 (&arg, loc->address,
8864                                    block_for_pc (loc->address), 0);
8865           if (*arg)
8866               error (_("Garbage '%s' follows condition"), arg);
8867         }
8868
8869       /* Dynamic printf requires and uses additional arguments on the
8870          command line, otherwise it's an error.  */
8871       if (type == bp_dprintf)
8872         {
8873           if (b->extra_string)
8874             update_dprintf_command_list (b);
8875           else
8876             error (_("Format string required"));
8877         }
8878       else if (b->extra_string)
8879         error (_("Garbage '%s' at end of command"), b->extra_string);
8880     }
8881
8882   b->display_canonical = display_canonical;
8883   if (location != NULL)
8884     b->location = std::move (location);
8885   else
8886     b->location = new_address_location (b->loc->address, NULL, 0);
8887   b->filter = filter.release ();
8888 }
8889
8890 static void
8891 create_breakpoint_sal (struct gdbarch *gdbarch,
8892                        gdb::array_view<const symtab_and_line> sals,
8893                        event_location_up &&location,
8894                        gdb::unique_xmalloc_ptr<char> filter,
8895                        gdb::unique_xmalloc_ptr<char> cond_string,
8896                        gdb::unique_xmalloc_ptr<char> extra_string,
8897                        enum bptype type, enum bpdisp disposition,
8898                        int thread, int task, int ignore_count,
8899                        const struct breakpoint_ops *ops, int from_tty,
8900                        int enabled, int internal, unsigned flags,
8901                        int display_canonical)
8902 {
8903   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (type);
8904
8905   init_breakpoint_sal (b.get (), gdbarch,
8906                        sals, std::move (location),
8907                        std::move (filter),
8908                        std::move (cond_string),
8909                        std::move (extra_string),
8910                        type, disposition,
8911                        thread, task, ignore_count,
8912                        ops, from_tty,
8913                        enabled, internal, flags,
8914                        display_canonical);
8915
8916   install_breakpoint (internal, std::move (b), 0);
8917 }
8918
8919 /* Add SALS.nelts breakpoints to the breakpoint table.  For each
8920    SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
8921    value.  COND_STRING, if not NULL, specified the condition to be
8922    used for all breakpoints.  Essentially the only case where
8923    SALS.nelts is not 1 is when we set a breakpoint on an overloaded
8924    function.  In that case, it's still not possible to specify
8925    separate conditions for different overloaded functions, so
8926    we take just a single condition string.
8927    
8928    NOTE: If the function succeeds, the caller is expected to cleanup
8929    the arrays ADDR_STRING, COND_STRING, and SALS (but not the
8930    array contents).  If the function fails (error() is called), the
8931    caller is expected to cleanups both the ADDR_STRING, COND_STRING,
8932    COND and SALS arrays and each of those arrays contents.  */
8933
8934 static void
8935 create_breakpoints_sal (struct gdbarch *gdbarch,
8936                         struct linespec_result *canonical,
8937                         gdb::unique_xmalloc_ptr<char> cond_string,
8938                         gdb::unique_xmalloc_ptr<char> extra_string,
8939                         enum bptype type, enum bpdisp disposition,
8940                         int thread, int task, int ignore_count,
8941                         const struct breakpoint_ops *ops, int from_tty,
8942                         int enabled, int internal, unsigned flags)
8943 {
8944   if (canonical->pre_expanded)
8945     gdb_assert (canonical->lsals.size () == 1);
8946
8947   for (const auto &lsal : canonical->lsals)
8948     {
8949       /* Note that 'location' can be NULL in the case of a plain
8950          'break', without arguments.  */
8951       event_location_up location
8952         = (canonical->location != NULL
8953            ? copy_event_location (canonical->location.get ()) : NULL);
8954       gdb::unique_xmalloc_ptr<char> filter_string
8955         (lsal.canonical != NULL ? xstrdup (lsal.canonical) : NULL);
8956
8957       create_breakpoint_sal (gdbarch, lsal.sals,
8958                              std::move (location),
8959                              std::move (filter_string),
8960                              std::move (cond_string),
8961                              std::move (extra_string),
8962                              type, disposition,
8963                              thread, task, ignore_count, ops,
8964                              from_tty, enabled, internal, flags,
8965                              canonical->special_display);
8966     }
8967 }
8968
8969 /* Parse LOCATION which is assumed to be a SAL specification possibly
8970    followed by conditionals.  On return, SALS contains an array of SAL
8971    addresses found.  LOCATION points to the end of the SAL (for
8972    linespec locations).
8973
8974    The array and the line spec strings are allocated on the heap, it is
8975    the caller's responsibility to free them.  */
8976
8977 static void
8978 parse_breakpoint_sals (const struct event_location *location,
8979                        struct linespec_result *canonical)
8980 {
8981   struct symtab_and_line cursal;
8982
8983   if (event_location_type (location) == LINESPEC_LOCATION)
8984     {
8985       const char *spec = get_linespec_location (location)->spec_string;
8986
8987       if (spec == NULL)
8988         {
8989           /* The last displayed codepoint, if it's valid, is our default
8990              breakpoint address.  */
8991           if (last_displayed_sal_is_valid ())
8992             {
8993               /* Set sal's pspace, pc, symtab, and line to the values
8994                  corresponding to the last call to print_frame_info.
8995                  Be sure to reinitialize LINE with NOTCURRENT == 0
8996                  as the breakpoint line number is inappropriate otherwise.
8997                  find_pc_line would adjust PC, re-set it back.  */
8998               symtab_and_line sal = get_last_displayed_sal ();
8999               CORE_ADDR pc = sal.pc;
9000
9001               sal = find_pc_line (pc, 0);
9002
9003               /* "break" without arguments is equivalent to "break *PC"
9004                  where PC is the last displayed codepoint's address.  So
9005                  make sure to set sal.explicit_pc to prevent GDB from
9006                  trying to expand the list of sals to include all other
9007                  instances with the same symtab and line.  */
9008               sal.pc = pc;
9009               sal.explicit_pc = 1;
9010
9011               struct linespec_sals lsal;
9012               lsal.sals = {sal};
9013               lsal.canonical = NULL;
9014
9015               canonical->lsals.push_back (std::move (lsal));
9016               return;
9017             }
9018           else
9019             error (_("No default breakpoint address now."));
9020         }
9021     }
9022
9023   /* Force almost all breakpoints to be in terms of the
9024      current_source_symtab (which is decode_line_1's default).
9025      This should produce the results we want almost all of the
9026      time while leaving default_breakpoint_* alone.
9027
9028      ObjC: However, don't match an Objective-C method name which
9029      may have a '+' or '-' succeeded by a '['.  */
9030   cursal = get_current_source_symtab_and_line ();
9031   if (last_displayed_sal_is_valid ())
9032     {
9033       const char *spec = NULL;
9034
9035       if (event_location_type (location) == LINESPEC_LOCATION)
9036         spec = get_linespec_location (location)->spec_string;
9037
9038       if (!cursal.symtab
9039           || (spec != NULL
9040               && strchr ("+-", spec[0]) != NULL
9041               && spec[1] != '['))
9042         {
9043           decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9044                             get_last_displayed_symtab (),
9045                             get_last_displayed_line (),
9046                             canonical, NULL, NULL);
9047           return;
9048         }
9049     }
9050
9051   decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9052                     cursal.symtab, cursal.line, canonical, NULL, NULL);
9053 }
9054
9055
9056 /* Convert each SAL into a real PC.  Verify that the PC can be
9057    inserted as a breakpoint.  If it can't throw an error.  */
9058
9059 static void
9060 breakpoint_sals_to_pc (std::vector<symtab_and_line> &sals)
9061 {    
9062   for (auto &sal : sals)
9063     resolve_sal_pc (&sal);
9064 }
9065
9066 /* Fast tracepoints may have restrictions on valid locations.  For
9067    instance, a fast tracepoint using a jump instead of a trap will
9068    likely have to overwrite more bytes than a trap would, and so can
9069    only be placed where the instruction is longer than the jump, or a
9070    multi-instruction sequence does not have a jump into the middle of
9071    it, etc.  */
9072
9073 static void
9074 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9075                             gdb::array_view<const symtab_and_line> sals)
9076 {
9077   for (const auto &sal : sals)
9078     {
9079       struct gdbarch *sarch;
9080
9081       sarch = get_sal_arch (sal);
9082       /* We fall back to GDBARCH if there is no architecture
9083          associated with SAL.  */
9084       if (sarch == NULL)
9085         sarch = gdbarch;
9086       std::string msg;
9087       if (!gdbarch_fast_tracepoint_valid_at (sarch, sal.pc, &msg))
9088         error (_("May not have a fast tracepoint at %s%s"),
9089                paddress (sarch, sal.pc), msg.c_str ());
9090     }
9091 }
9092
9093 /* Given TOK, a string specification of condition and thread, as
9094    accepted by the 'break' command, extract the condition
9095    string and thread number and set *COND_STRING and *THREAD.
9096    PC identifies the context at which the condition should be parsed.
9097    If no condition is found, *COND_STRING is set to NULL.
9098    If no thread is found, *THREAD is set to -1.  */
9099
9100 static void
9101 find_condition_and_thread (const char *tok, CORE_ADDR pc,
9102                            char **cond_string, int *thread, int *task,
9103                            char **rest)
9104 {
9105   *cond_string = NULL;
9106   *thread = -1;
9107   *task = 0;
9108   *rest = NULL;
9109
9110   while (tok && *tok)
9111     {
9112       const char *end_tok;
9113       int toklen;
9114       const char *cond_start = NULL;
9115       const char *cond_end = NULL;
9116
9117       tok = skip_spaces (tok);
9118
9119       if ((*tok == '"' || *tok == ',') && rest)
9120         {
9121           *rest = savestring (tok, strlen (tok));
9122           return;
9123         }
9124
9125       end_tok = skip_to_space (tok);
9126
9127       toklen = end_tok - tok;
9128
9129       if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9130         {
9131           tok = cond_start = end_tok + 1;
9132           parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
9133           cond_end = tok;
9134           *cond_string = savestring (cond_start, cond_end - cond_start);
9135         }
9136       else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9137         {
9138           const char *tmptok;
9139           struct thread_info *thr;
9140
9141           tok = end_tok + 1;
9142           thr = parse_thread_id (tok, &tmptok);
9143           if (tok == tmptok)
9144             error (_("Junk after thread keyword."));
9145           *thread = thr->global_num;
9146           tok = tmptok;
9147         }
9148       else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9149         {
9150           char *tmptok;
9151
9152           tok = end_tok + 1;
9153           *task = strtol (tok, &tmptok, 0);
9154           if (tok == tmptok)
9155             error (_("Junk after task keyword."));
9156           if (!valid_task_id (*task))
9157             error (_("Unknown task %d."), *task);
9158           tok = tmptok;
9159         }
9160       else if (rest)
9161         {
9162           *rest = savestring (tok, strlen (tok));
9163           return;
9164         }
9165       else
9166         error (_("Junk at end of arguments."));
9167     }
9168 }
9169
9170 /* Decode a static tracepoint marker spec.  */
9171
9172 static std::vector<symtab_and_line>
9173 decode_static_tracepoint_spec (const char **arg_p)
9174 {
9175   const char *p = &(*arg_p)[3];
9176   const char *endp;
9177
9178   p = skip_spaces (p);
9179
9180   endp = skip_to_space (p);
9181
9182   std::string marker_str (p, endp - p);
9183
9184   std::vector<static_tracepoint_marker> markers
9185     = target_static_tracepoint_markers_by_strid (marker_str.c_str ());
9186   if (markers.empty ())
9187     error (_("No known static tracepoint marker named %s"),
9188            marker_str.c_str ());
9189
9190   std::vector<symtab_and_line> sals;
9191   sals.reserve (markers.size ());
9192
9193   for (const static_tracepoint_marker &marker : markers)
9194     {
9195       symtab_and_line sal = find_pc_line (marker.address, 0);
9196       sal.pc = marker.address;
9197       sals.push_back (sal);
9198    }
9199
9200   *arg_p = endp;
9201   return sals;
9202 }
9203
9204 /* See breakpoint.h.  */
9205
9206 int
9207 create_breakpoint (struct gdbarch *gdbarch,
9208                    const struct event_location *location,
9209                    const char *cond_string,
9210                    int thread, const char *extra_string,
9211                    int parse_extra,
9212                    int tempflag, enum bptype type_wanted,
9213                    int ignore_count,
9214                    enum auto_boolean pending_break_support,
9215                    const struct breakpoint_ops *ops,
9216                    int from_tty, int enabled, int internal,
9217                    unsigned flags)
9218 {
9219   struct linespec_result canonical;
9220   int pending = 0;
9221   int task = 0;
9222   int prev_bkpt_count = breakpoint_count;
9223
9224   gdb_assert (ops != NULL);
9225
9226   /* If extra_string isn't useful, set it to NULL.  */
9227   if (extra_string != NULL && *extra_string == '\0')
9228     extra_string = NULL;
9229
9230   try
9231     {
9232       ops->create_sals_from_location (location, &canonical, type_wanted);
9233     }
9234   catch (const gdb_exception_error &e)
9235     {
9236       /* If caller is interested in rc value from parse, set
9237          value.  */
9238       if (e.error == NOT_FOUND_ERROR)
9239         {
9240           /* If pending breakpoint support is turned off, throw
9241              error.  */
9242
9243           if (pending_break_support == AUTO_BOOLEAN_FALSE)
9244             throw;
9245
9246           exception_print (gdb_stderr, e);
9247
9248           /* If pending breakpoint support is auto query and the user
9249              selects no, then simply return the error code.  */
9250           if (pending_break_support == AUTO_BOOLEAN_AUTO
9251               && !nquery (_("Make %s pending on future shared library load? "),
9252                           bptype_string (type_wanted)))
9253             return 0;
9254
9255           /* At this point, either the user was queried about setting
9256              a pending breakpoint and selected yes, or pending
9257              breakpoint behavior is on and thus a pending breakpoint
9258              is defaulted on behalf of the user.  */
9259           pending = 1;
9260         }
9261       else
9262         throw;
9263     }
9264
9265   if (!pending && canonical.lsals.empty ())
9266     return 0;
9267
9268   /* Resolve all line numbers to PC's and verify that the addresses
9269      are ok for the target.  */
9270   if (!pending)
9271     {
9272       for (auto &lsal : canonical.lsals)
9273         breakpoint_sals_to_pc (lsal.sals);
9274     }
9275
9276   /* Fast tracepoints may have additional restrictions on location.  */
9277   if (!pending && type_wanted == bp_fast_tracepoint)
9278     {
9279       for (const auto &lsal : canonical.lsals)
9280         check_fast_tracepoint_sals (gdbarch, lsal.sals);
9281     }
9282
9283   /* Verify that condition can be parsed, before setting any
9284      breakpoints.  Allocate a separate condition expression for each
9285      breakpoint.  */
9286   if (!pending)
9287     {
9288       gdb::unique_xmalloc_ptr<char> cond_string_copy;
9289       gdb::unique_xmalloc_ptr<char> extra_string_copy;
9290
9291       if (parse_extra)
9292         {
9293           char *rest;
9294           char *cond;
9295
9296           const linespec_sals &lsal = canonical.lsals[0];
9297
9298           /* Here we only parse 'arg' to separate condition
9299              from thread number, so parsing in context of first
9300              sal is OK.  When setting the breakpoint we'll
9301              re-parse it in context of each sal.  */
9302
9303           find_condition_and_thread (extra_string, lsal.sals[0].pc,
9304                                      &cond, &thread, &task, &rest);
9305           cond_string_copy.reset (cond);
9306           extra_string_copy.reset (rest);
9307         }
9308       else
9309         {
9310           if (type_wanted != bp_dprintf
9311               && extra_string != NULL && *extra_string != '\0')
9312                 error (_("Garbage '%s' at end of location"), extra_string);
9313
9314           /* Create a private copy of condition string.  */
9315           if (cond_string)
9316             cond_string_copy.reset (xstrdup (cond_string));
9317           /* Create a private copy of any extra string.  */
9318           if (extra_string)
9319             extra_string_copy.reset (xstrdup (extra_string));
9320         }
9321
9322       ops->create_breakpoints_sal (gdbarch, &canonical,
9323                                    std::move (cond_string_copy),
9324                                    std::move (extra_string_copy),
9325                                    type_wanted,
9326                                    tempflag ? disp_del : disp_donttouch,
9327                                    thread, task, ignore_count, ops,
9328                                    from_tty, enabled, internal, flags);
9329     }
9330   else
9331     {
9332       std::unique_ptr <breakpoint> b = new_breakpoint_from_type (type_wanted);
9333
9334       init_raw_breakpoint_without_location (b.get (), gdbarch, type_wanted, ops);
9335       b->location = copy_event_location (location);
9336
9337       if (parse_extra)
9338         b->cond_string = NULL;
9339       else
9340         {
9341           /* Create a private copy of condition string.  */
9342           b->cond_string = cond_string != NULL ? xstrdup (cond_string) : NULL;
9343           b->thread = thread;
9344         }
9345
9346       /* Create a private copy of any extra string.  */
9347       b->extra_string = extra_string != NULL ? xstrdup (extra_string) : NULL;
9348       b->ignore_count = ignore_count;
9349       b->disposition = tempflag ? disp_del : disp_donttouch;
9350       b->condition_not_parsed = 1;
9351       b->enable_state = enabled ? bp_enabled : bp_disabled;
9352       if ((type_wanted != bp_breakpoint
9353            && type_wanted != bp_hardware_breakpoint) || thread != -1)
9354         b->pspace = current_program_space;
9355
9356       install_breakpoint (internal, std::move (b), 0);
9357     }
9358   
9359   if (canonical.lsals.size () > 1)
9360     {
9361       warning (_("Multiple breakpoints were set.\nUse the "
9362                  "\"delete\" command to delete unwanted breakpoints."));
9363       prev_breakpoint_count = prev_bkpt_count;
9364     }
9365
9366   update_global_location_list (UGLL_MAY_INSERT);
9367
9368   return 1;
9369 }
9370
9371 /* Set a breakpoint.
9372    ARG is a string describing breakpoint address,
9373    condition, and thread.
9374    FLAG specifies if a breakpoint is hardware on,
9375    and if breakpoint is temporary, using BP_HARDWARE_FLAG
9376    and BP_TEMPFLAG.  */
9377
9378 static void
9379 break_command_1 (const char *arg, int flag, int from_tty)
9380 {
9381   int tempflag = flag & BP_TEMPFLAG;
9382   enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9383                              ? bp_hardware_breakpoint
9384                              : bp_breakpoint);
9385   struct breakpoint_ops *ops;
9386
9387   event_location_up location = string_to_event_location (&arg, current_language);
9388
9389   /* Matching breakpoints on probes.  */
9390   if (location != NULL
9391       && event_location_type (location.get ()) == PROBE_LOCATION)
9392     ops = &bkpt_probe_breakpoint_ops;
9393   else
9394     ops = &bkpt_breakpoint_ops;
9395
9396   create_breakpoint (get_current_arch (),
9397                      location.get (),
9398                      NULL, 0, arg, 1 /* parse arg */,
9399                      tempflag, type_wanted,
9400                      0 /* Ignore count */,
9401                      pending_break_support,
9402                      ops,
9403                      from_tty,
9404                      1 /* enabled */,
9405                      0 /* internal */,
9406                      0);
9407 }
9408
9409 /* Helper function for break_command_1 and disassemble_command.  */
9410
9411 void
9412 resolve_sal_pc (struct symtab_and_line *sal)
9413 {
9414   CORE_ADDR pc;
9415
9416   if (sal->pc == 0 && sal->symtab != NULL)
9417     {
9418       if (!find_line_pc (sal->symtab, sal->line, &pc))
9419         error (_("No line %d in file \"%s\"."),
9420                sal->line, symtab_to_filename_for_display (sal->symtab));
9421       sal->pc = pc;
9422
9423       /* If this SAL corresponds to a breakpoint inserted using a line
9424          number, then skip the function prologue if necessary.  */
9425       if (sal->explicit_line)
9426         skip_prologue_sal (sal);
9427     }
9428
9429   if (sal->section == 0 && sal->symtab != NULL)
9430     {
9431       const struct blockvector *bv;
9432       const struct block *b;
9433       struct symbol *sym;
9434
9435       bv = blockvector_for_pc_sect (sal->pc, 0, &b,
9436                                     SYMTAB_COMPUNIT (sal->symtab));
9437       if (bv != NULL)
9438         {
9439           sym = block_linkage_function (b);
9440           if (sym != NULL)
9441             {
9442               fixup_symbol_section (sym, SYMTAB_OBJFILE (sal->symtab));
9443               sal->section = SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal->symtab),
9444                                                  sym);
9445             }
9446           else
9447             {
9448               /* It really is worthwhile to have the section, so we'll
9449                  just have to look harder. This case can be executed
9450                  if we have line numbers but no functions (as can
9451                  happen in assembly source).  */
9452
9453               scoped_restore_current_pspace_and_thread restore_pspace_thread;
9454               switch_to_program_space_and_thread (sal->pspace);
9455
9456               bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (sal->pc);
9457               if (msym.minsym)
9458                 sal->section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
9459             }
9460         }
9461     }
9462 }
9463
9464 void
9465 break_command (const char *arg, int from_tty)
9466 {
9467   break_command_1 (arg, 0, from_tty);
9468 }
9469
9470 void
9471 tbreak_command (const char *arg, int from_tty)
9472 {
9473   break_command_1 (arg, BP_TEMPFLAG, from_tty);
9474 }
9475
9476 static void
9477 hbreak_command (const char *arg, int from_tty)
9478 {
9479   break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
9480 }
9481
9482 static void
9483 thbreak_command (const char *arg, int from_tty)
9484 {
9485   break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
9486 }
9487
9488 static void
9489 stop_command (const char *arg, int from_tty)
9490 {
9491   printf_filtered (_("Specify the type of breakpoint to set.\n\
9492 Usage: stop in <function | address>\n\
9493        stop at <line>\n"));
9494 }
9495
9496 static void
9497 stopin_command (const char *arg, int from_tty)
9498 {
9499   int badInput = 0;
9500
9501   if (arg == (char *) NULL)
9502     badInput = 1;
9503   else if (*arg != '*')
9504     {
9505       const char *argptr = arg;
9506       int hasColon = 0;
9507
9508       /* Look for a ':'.  If this is a line number specification, then
9509          say it is bad, otherwise, it should be an address or
9510          function/method name.  */
9511       while (*argptr && !hasColon)
9512         {
9513           hasColon = (*argptr == ':');
9514           argptr++;
9515         }
9516
9517       if (hasColon)
9518         badInput = (*argptr != ':');    /* Not a class::method */
9519       else
9520         badInput = isdigit (*arg);      /* a simple line number */
9521     }
9522
9523   if (badInput)
9524     printf_filtered (_("Usage: stop in <function | address>\n"));
9525   else
9526     break_command_1 (arg, 0, from_tty);
9527 }
9528
9529 static void
9530 stopat_command (const char *arg, int from_tty)
9531 {
9532   int badInput = 0;
9533
9534   if (arg == (char *) NULL || *arg == '*')      /* no line number */
9535     badInput = 1;
9536   else
9537     {
9538       const char *argptr = arg;
9539       int hasColon = 0;
9540
9541       /* Look for a ':'.  If there is a '::' then get out, otherwise
9542          it is probably a line number.  */
9543       while (*argptr && !hasColon)
9544         {
9545           hasColon = (*argptr == ':');
9546           argptr++;
9547         }
9548
9549       if (hasColon)
9550         badInput = (*argptr == ':');    /* we have class::method */
9551       else
9552         badInput = !isdigit (*arg);     /* not a line number */
9553     }
9554
9555   if (badInput)
9556     printf_filtered (_("Usage: stop at LINE\n"));
9557   else
9558     break_command_1 (arg, 0, from_tty);
9559 }
9560
9561 /* The dynamic printf command is mostly like a regular breakpoint, but
9562    with a prewired command list consisting of a single output command,
9563    built from extra arguments supplied on the dprintf command
9564    line.  */
9565
9566 static void
9567 dprintf_command (const char *arg, int from_tty)
9568 {
9569   event_location_up location = string_to_event_location (&arg, current_language);
9570
9571   /* If non-NULL, ARG should have been advanced past the location;
9572      the next character must be ','.  */
9573   if (arg != NULL)
9574     {
9575       if (arg[0] != ',' || arg[1] == '\0')
9576         error (_("Format string required"));
9577       else
9578         {
9579           /* Skip the comma.  */
9580           ++arg;
9581         }
9582     }
9583
9584   create_breakpoint (get_current_arch (),
9585                      location.get (),
9586                      NULL, 0, arg, 1 /* parse arg */,
9587                      0, bp_dprintf,
9588                      0 /* Ignore count */,
9589                      pending_break_support,
9590                      &dprintf_breakpoint_ops,
9591                      from_tty,
9592                      1 /* enabled */,
9593                      0 /* internal */,
9594                      0);
9595 }
9596
9597 static void
9598 agent_printf_command (const char *arg, int from_tty)
9599 {
9600   error (_("May only run agent-printf on the target"));
9601 }
9602
9603 /* Implement the "breakpoint_hit" breakpoint_ops method for
9604    ranged breakpoints.  */
9605
9606 static int
9607 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
9608                                   const address_space *aspace,
9609                                   CORE_ADDR bp_addr,
9610                                   const struct target_waitstatus *ws)
9611 {
9612   if (ws->kind != TARGET_WAITKIND_STOPPED
9613       || ws->value.sig != GDB_SIGNAL_TRAP)
9614     return 0;
9615
9616   return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
9617                                          bl->length, aspace, bp_addr);
9618 }
9619
9620 /* Implement the "resources_needed" breakpoint_ops method for
9621    ranged breakpoints.  */
9622
9623 static int
9624 resources_needed_ranged_breakpoint (const struct bp_location *bl)
9625 {
9626   return target_ranged_break_num_registers ();
9627 }
9628
9629 /* Implement the "print_it" breakpoint_ops method for
9630    ranged breakpoints.  */
9631
9632 static enum print_stop_action
9633 print_it_ranged_breakpoint (bpstat bs)
9634 {
9635   struct breakpoint *b = bs->breakpoint_at;
9636   struct bp_location *bl = b->loc;
9637   struct ui_out *uiout = current_uiout;
9638
9639   gdb_assert (b->type == bp_hardware_breakpoint);
9640
9641   /* Ranged breakpoints have only one location.  */
9642   gdb_assert (bl && bl->next == NULL);
9643
9644   annotate_breakpoint (b->number);
9645
9646   maybe_print_thread_hit_breakpoint (uiout);
9647
9648   if (b->disposition == disp_del)
9649     uiout->text ("Temporary ranged breakpoint ");
9650   else
9651     uiout->text ("Ranged breakpoint ");
9652   if (uiout->is_mi_like_p ())
9653     {
9654       uiout->field_string ("reason",
9655                       async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9656       uiout->field_string ("disp", bpdisp_text (b->disposition));
9657     }
9658   uiout->field_int ("bkptno", b->number);
9659   uiout->text (", ");
9660
9661   return PRINT_SRC_AND_LOC;
9662 }
9663
9664 /* Implement the "print_one" breakpoint_ops method for
9665    ranged breakpoints.  */
9666
9667 static void
9668 print_one_ranged_breakpoint (struct breakpoint *b,
9669                              struct bp_location **last_loc)
9670 {
9671   struct bp_location *bl = b->loc;
9672   struct value_print_options opts;
9673   struct ui_out *uiout = current_uiout;
9674
9675   /* Ranged breakpoints have only one location.  */
9676   gdb_assert (bl && bl->next == NULL);
9677
9678   get_user_print_options (&opts);
9679
9680   if (opts.addressprint)
9681     /* We don't print the address range here, it will be printed later
9682        by print_one_detail_ranged_breakpoint.  */
9683     uiout->field_skip ("addr");
9684   annotate_field (5);
9685   print_breakpoint_location (b, bl);
9686   *last_loc = bl;
9687 }
9688
9689 /* Implement the "print_one_detail" breakpoint_ops method for
9690    ranged breakpoints.  */
9691
9692 static void
9693 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
9694                                     struct ui_out *uiout)
9695 {
9696   CORE_ADDR address_start, address_end;
9697   struct bp_location *bl = b->loc;
9698   string_file stb;
9699
9700   gdb_assert (bl);
9701
9702   address_start = bl->address;
9703   address_end = address_start + bl->length - 1;
9704
9705   uiout->text ("\taddress range: ");
9706   stb.printf ("[%s, %s]",
9707               print_core_address (bl->gdbarch, address_start),
9708               print_core_address (bl->gdbarch, address_end));
9709   uiout->field_stream ("addr", stb);
9710   uiout->text ("\n");
9711 }
9712
9713 /* Implement the "print_mention" breakpoint_ops method for
9714    ranged breakpoints.  */
9715
9716 static void
9717 print_mention_ranged_breakpoint (struct breakpoint *b)
9718 {
9719   struct bp_location *bl = b->loc;
9720   struct ui_out *uiout = current_uiout;
9721
9722   gdb_assert (bl);
9723   gdb_assert (b->type == bp_hardware_breakpoint);
9724
9725   uiout->message (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9726                   b->number, paddress (bl->gdbarch, bl->address),
9727                   paddress (bl->gdbarch, bl->address + bl->length - 1));
9728 }
9729
9730 /* Implement the "print_recreate" breakpoint_ops method for
9731    ranged breakpoints.  */
9732
9733 static void
9734 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
9735 {
9736   fprintf_unfiltered (fp, "break-range %s, %s",
9737                       event_location_to_string (b->location.get ()),
9738                       event_location_to_string (b->location_range_end.get ()));
9739   print_recreate_thread (b, fp);
9740 }
9741
9742 /* The breakpoint_ops structure to be used in ranged breakpoints.  */
9743
9744 static struct breakpoint_ops ranged_breakpoint_ops;
9745
9746 /* Find the address where the end of the breakpoint range should be
9747    placed, given the SAL of the end of the range.  This is so that if
9748    the user provides a line number, the end of the range is set to the
9749    last instruction of the given line.  */
9750
9751 static CORE_ADDR
9752 find_breakpoint_range_end (struct symtab_and_line sal)
9753 {
9754   CORE_ADDR end;
9755
9756   /* If the user provided a PC value, use it.  Otherwise,
9757      find the address of the end of the given location.  */
9758   if (sal.explicit_pc)
9759     end = sal.pc;
9760   else
9761     {
9762       int ret;
9763       CORE_ADDR start;
9764
9765       ret = find_line_pc_range (sal, &start, &end);
9766       if (!ret)
9767         error (_("Could not find location of the end of the range."));
9768
9769       /* find_line_pc_range returns the start of the next line.  */
9770       end--;
9771     }
9772
9773   return end;
9774 }
9775
9776 /* Implement the "break-range" CLI command.  */
9777
9778 static void
9779 break_range_command (const char *arg, int from_tty)
9780 {
9781   const char *arg_start;
9782   struct linespec_result canonical_start, canonical_end;
9783   int bp_count, can_use_bp, length;
9784   CORE_ADDR end;
9785   struct breakpoint *b;
9786
9787   /* We don't support software ranged breakpoints.  */
9788   if (target_ranged_break_num_registers () < 0)
9789     error (_("This target does not support hardware ranged breakpoints."));
9790
9791   bp_count = hw_breakpoint_used_count ();
9792   bp_count += target_ranged_break_num_registers ();
9793   can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
9794                                                    bp_count, 0);
9795   if (can_use_bp < 0)
9796     error (_("Hardware breakpoints used exceeds limit."));
9797
9798   arg = skip_spaces (arg);
9799   if (arg == NULL || arg[0] == '\0')
9800     error(_("No address range specified."));
9801
9802   arg_start = arg;
9803   event_location_up start_location = string_to_event_location (&arg,
9804                                                                current_language);
9805   parse_breakpoint_sals (start_location.get (), &canonical_start);
9806
9807   if (arg[0] != ',')
9808     error (_("Too few arguments."));
9809   else if (canonical_start.lsals.empty ())
9810     error (_("Could not find location of the beginning of the range."));
9811
9812   const linespec_sals &lsal_start = canonical_start.lsals[0];
9813
9814   if (canonical_start.lsals.size () > 1
9815       || lsal_start.sals.size () != 1)
9816     error (_("Cannot create a ranged breakpoint with multiple locations."));
9817
9818   const symtab_and_line &sal_start = lsal_start.sals[0];
9819   std::string addr_string_start (arg_start, arg - arg_start);
9820
9821   arg++;        /* Skip the comma.  */
9822   arg = skip_spaces (arg);
9823
9824   /* Parse the end location.  */
9825
9826   arg_start = arg;
9827
9828   /* We call decode_line_full directly here instead of using
9829      parse_breakpoint_sals because we need to specify the start location's
9830      symtab and line as the default symtab and line for the end of the
9831      range.  This makes it possible to have ranges like "foo.c:27, +14",
9832      where +14 means 14 lines from the start location.  */
9833   event_location_up end_location = string_to_event_location (&arg,
9834                                                              current_language);
9835   decode_line_full (end_location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
9836                     sal_start.symtab, sal_start.line,
9837                     &canonical_end, NULL, NULL);
9838
9839   if (canonical_end.lsals.empty ())
9840     error (_("Could not find location of the end of the range."));
9841
9842   const linespec_sals &lsal_end = canonical_end.lsals[0];
9843   if (canonical_end.lsals.size () > 1
9844       || lsal_end.sals.size () != 1)
9845     error (_("Cannot create a ranged breakpoint with multiple locations."));
9846
9847   const symtab_and_line &sal_end = lsal_end.sals[0];
9848
9849   end = find_breakpoint_range_end (sal_end);
9850   if (sal_start.pc > end)
9851     error (_("Invalid address range, end precedes start."));
9852
9853   length = end - sal_start.pc + 1;
9854   if (length < 0)
9855     /* Length overflowed.  */
9856     error (_("Address range too large."));
9857   else if (length == 1)
9858     {
9859       /* This range is simple enough to be handled by
9860          the `hbreak' command.  */
9861       hbreak_command (&addr_string_start[0], 1);
9862
9863       return;
9864     }
9865
9866   /* Now set up the breakpoint.  */
9867   b = set_raw_breakpoint (get_current_arch (), sal_start,
9868                           bp_hardware_breakpoint, &ranged_breakpoint_ops);
9869   set_breakpoint_count (breakpoint_count + 1);
9870   b->number = breakpoint_count;
9871   b->disposition = disp_donttouch;
9872   b->location = std::move (start_location);
9873   b->location_range_end = std::move (end_location);
9874   b->loc->length = length;
9875
9876   mention (b);
9877   gdb::observers::breakpoint_created.notify (b);
9878   update_global_location_list (UGLL_MAY_INSERT);
9879 }
9880
9881 /*  Return non-zero if EXP is verified as constant.  Returned zero
9882     means EXP is variable.  Also the constant detection may fail for
9883     some constant expressions and in such case still falsely return
9884     zero.  */
9885
9886 static int
9887 watchpoint_exp_is_const (const struct expression *exp)
9888 {
9889   int i = exp->nelts;
9890
9891   while (i > 0)
9892     {
9893       int oplenp, argsp;
9894
9895       /* We are only interested in the descriptor of each element.  */
9896       operator_length (exp, i, &oplenp, &argsp);
9897       i -= oplenp;
9898
9899       switch (exp->elts[i].opcode)
9900         {
9901         case BINOP_ADD:
9902         case BINOP_SUB:
9903         case BINOP_MUL:
9904         case BINOP_DIV:
9905         case BINOP_REM:
9906         case BINOP_MOD:
9907         case BINOP_LSH:
9908         case BINOP_RSH:
9909         case BINOP_LOGICAL_AND:
9910         case BINOP_LOGICAL_OR:
9911         case BINOP_BITWISE_AND:
9912         case BINOP_BITWISE_IOR:
9913         case BINOP_BITWISE_XOR:
9914         case BINOP_EQUAL:
9915         case BINOP_NOTEQUAL:
9916         case BINOP_LESS:
9917         case BINOP_GTR:
9918         case BINOP_LEQ:
9919         case BINOP_GEQ:
9920         case BINOP_REPEAT:
9921         case BINOP_COMMA:
9922         case BINOP_EXP:
9923         case BINOP_MIN:
9924         case BINOP_MAX:
9925         case BINOP_INTDIV:
9926         case BINOP_CONCAT:
9927         case TERNOP_COND:
9928         case TERNOP_SLICE:
9929
9930         case OP_LONG:
9931         case OP_FLOAT:
9932         case OP_LAST:
9933         case OP_COMPLEX:
9934         case OP_STRING:
9935         case OP_ARRAY:
9936         case OP_TYPE:
9937         case OP_TYPEOF:
9938         case OP_DECLTYPE:
9939         case OP_TYPEID:
9940         case OP_NAME:
9941         case OP_OBJC_NSSTRING:
9942
9943         case UNOP_NEG:
9944         case UNOP_LOGICAL_NOT:
9945         case UNOP_COMPLEMENT:
9946         case UNOP_ADDR:
9947         case UNOP_HIGH:
9948         case UNOP_CAST:
9949
9950         case UNOP_CAST_TYPE:
9951         case UNOP_REINTERPRET_CAST:
9952         case UNOP_DYNAMIC_CAST:
9953           /* Unary, binary and ternary operators: We have to check
9954              their operands.  If they are constant, then so is the
9955              result of that operation.  For instance, if A and B are
9956              determined to be constants, then so is "A + B".
9957
9958              UNOP_IND is one exception to the rule above, because the
9959              value of *ADDR is not necessarily a constant, even when
9960              ADDR is.  */
9961           break;
9962
9963         case OP_VAR_VALUE:
9964           /* Check whether the associated symbol is a constant.
9965
9966              We use SYMBOL_CLASS rather than TYPE_CONST because it's
9967              possible that a buggy compiler could mark a variable as
9968              constant even when it is not, and TYPE_CONST would return
9969              true in this case, while SYMBOL_CLASS wouldn't.
9970
9971              We also have to check for function symbols because they
9972              are always constant.  */
9973           {
9974             struct symbol *s = exp->elts[i + 2].symbol;
9975
9976             if (SYMBOL_CLASS (s) != LOC_BLOCK
9977                 && SYMBOL_CLASS (s) != LOC_CONST
9978                 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
9979               return 0;
9980             break;
9981           }
9982
9983         /* The default action is to return 0 because we are using
9984            the optimistic approach here: If we don't know something,
9985            then it is not a constant.  */
9986         default:
9987           return 0;
9988         }
9989     }
9990
9991   return 1;
9992 }
9993
9994 /* Watchpoint destructor.  */
9995
9996 watchpoint::~watchpoint ()
9997 {
9998   xfree (this->exp_string);
9999   xfree (this->exp_string_reparse);
10000 }
10001
10002 /* Implement the "re_set" breakpoint_ops method for watchpoints.  */
10003
10004 static void
10005 re_set_watchpoint (struct breakpoint *b)
10006 {
10007   struct watchpoint *w = (struct watchpoint *) b;
10008
10009   /* Watchpoint can be either on expression using entirely global
10010      variables, or it can be on local variables.
10011
10012      Watchpoints of the first kind are never auto-deleted, and even
10013      persist across program restarts.  Since they can use variables
10014      from shared libraries, we need to reparse expression as libraries
10015      are loaded and unloaded.
10016
10017      Watchpoints on local variables can also change meaning as result
10018      of solib event.  For example, if a watchpoint uses both a local
10019      and a global variables in expression, it's a local watchpoint,
10020      but unloading of a shared library will make the expression
10021      invalid.  This is not a very common use case, but we still
10022      re-evaluate expression, to avoid surprises to the user.
10023
10024      Note that for local watchpoints, we re-evaluate it only if
10025      watchpoints frame id is still valid.  If it's not, it means the
10026      watchpoint is out of scope and will be deleted soon.  In fact,
10027      I'm not sure we'll ever be called in this case.
10028
10029      If a local watchpoint's frame id is still valid, then
10030      w->exp_valid_block is likewise valid, and we can safely use it.
10031
10032      Don't do anything about disabled watchpoints, since they will be
10033      reevaluated again when enabled.  */
10034   update_watchpoint (w, 1 /* reparse */);
10035 }
10036
10037 /* Implement the "insert" breakpoint_ops method for hardware watchpoints.  */
10038
10039 static int
10040 insert_watchpoint (struct bp_location *bl)
10041 {
10042   struct watchpoint *w = (struct watchpoint *) bl->owner;
10043   int length = w->exact ? 1 : bl->length;
10044
10045   return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
10046                                    w->cond_exp.get ());
10047 }
10048
10049 /* Implement the "remove" breakpoint_ops method for hardware watchpoints.  */
10050
10051 static int
10052 remove_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10053 {
10054   struct watchpoint *w = (struct watchpoint *) bl->owner;
10055   int length = w->exact ? 1 : bl->length;
10056
10057   return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
10058                                    w->cond_exp.get ());
10059 }
10060
10061 static int
10062 breakpoint_hit_watchpoint (const struct bp_location *bl,
10063                            const address_space *aspace, CORE_ADDR bp_addr,
10064                            const struct target_waitstatus *ws)
10065 {
10066   struct breakpoint *b = bl->owner;
10067   struct watchpoint *w = (struct watchpoint *) b;
10068
10069   /* Continuable hardware watchpoints are treated as non-existent if the
10070      reason we stopped wasn't a hardware watchpoint (we didn't stop on
10071      some data address).  Otherwise gdb won't stop on a break instruction
10072      in the code (not from a breakpoint) when a hardware watchpoint has
10073      been defined.  Also skip watchpoints which we know did not trigger
10074      (did not match the data address).  */
10075   if (is_hardware_watchpoint (b)
10076       && w->watchpoint_triggered == watch_triggered_no)
10077     return 0;
10078
10079   return 1;
10080 }
10081
10082 static void
10083 check_status_watchpoint (bpstat bs)
10084 {
10085   gdb_assert (is_watchpoint (bs->breakpoint_at));
10086
10087   bpstat_check_watchpoint (bs);
10088 }
10089
10090 /* Implement the "resources_needed" breakpoint_ops method for
10091    hardware watchpoints.  */
10092
10093 static int
10094 resources_needed_watchpoint (const struct bp_location *bl)
10095 {
10096   struct watchpoint *w = (struct watchpoint *) bl->owner;
10097   int length = w->exact? 1 : bl->length;
10098
10099   return target_region_ok_for_hw_watchpoint (bl->address, length);
10100 }
10101
10102 /* Implement the "works_in_software_mode" breakpoint_ops method for
10103    hardware watchpoints.  */
10104
10105 static int
10106 works_in_software_mode_watchpoint (const struct breakpoint *b)
10107 {
10108   /* Read and access watchpoints only work with hardware support.  */
10109   return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
10110 }
10111
10112 static enum print_stop_action
10113 print_it_watchpoint (bpstat bs)
10114 {
10115   struct breakpoint *b;
10116   enum print_stop_action result;
10117   struct watchpoint *w;
10118   struct ui_out *uiout = current_uiout;
10119
10120   gdb_assert (bs->bp_location_at != NULL);
10121
10122   b = bs->breakpoint_at;
10123   w = (struct watchpoint *) b;
10124
10125   annotate_watchpoint (b->number);
10126   maybe_print_thread_hit_breakpoint (uiout);
10127
10128   string_file stb;
10129
10130   gdb::optional<ui_out_emit_tuple> tuple_emitter;
10131   switch (b->type)
10132     {
10133     case bp_watchpoint:
10134     case bp_hardware_watchpoint:
10135       if (uiout->is_mi_like_p ())
10136         uiout->field_string
10137           ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10138       mention (b);
10139       tuple_emitter.emplace (uiout, "value");
10140       uiout->text ("\nOld value = ");
10141       watchpoint_value_print (bs->old_val.get (), &stb);
10142       uiout->field_stream ("old", stb);
10143       uiout->text ("\nNew value = ");
10144       watchpoint_value_print (w->val.get (), &stb);
10145       uiout->field_stream ("new", stb);
10146       uiout->text ("\n");
10147       /* More than one watchpoint may have been triggered.  */
10148       result = PRINT_UNKNOWN;
10149       break;
10150
10151     case bp_read_watchpoint:
10152       if (uiout->is_mi_like_p ())
10153         uiout->field_string
10154           ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10155       mention (b);
10156       tuple_emitter.emplace (uiout, "value");
10157       uiout->text ("\nValue = ");
10158       watchpoint_value_print (w->val.get (), &stb);
10159       uiout->field_stream ("value", stb);
10160       uiout->text ("\n");
10161       result = PRINT_UNKNOWN;
10162       break;
10163
10164     case bp_access_watchpoint:
10165       if (bs->old_val != NULL)
10166         {
10167           if (uiout->is_mi_like_p ())
10168             uiout->field_string
10169               ("reason",
10170                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10171           mention (b);
10172           tuple_emitter.emplace (uiout, "value");
10173           uiout->text ("\nOld value = ");
10174           watchpoint_value_print (bs->old_val.get (), &stb);
10175           uiout->field_stream ("old", stb);
10176           uiout->text ("\nNew value = ");
10177         }
10178       else
10179         {
10180           mention (b);
10181           if (uiout->is_mi_like_p ())
10182             uiout->field_string
10183               ("reason",
10184                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10185           tuple_emitter.emplace (uiout, "value");
10186           uiout->text ("\nValue = ");
10187         }
10188       watchpoint_value_print (w->val.get (), &stb);
10189       uiout->field_stream ("new", stb);
10190       uiout->text ("\n");
10191       result = PRINT_UNKNOWN;
10192       break;
10193     default:
10194       result = PRINT_UNKNOWN;
10195     }
10196
10197   return result;
10198 }
10199
10200 /* Implement the "print_mention" breakpoint_ops method for hardware
10201    watchpoints.  */
10202
10203 static void
10204 print_mention_watchpoint (struct breakpoint *b)
10205 {
10206   struct watchpoint *w = (struct watchpoint *) b;
10207   struct ui_out *uiout = current_uiout;
10208   const char *tuple_name;
10209
10210   switch (b->type)
10211     {
10212     case bp_watchpoint:
10213       uiout->text ("Watchpoint ");
10214       tuple_name = "wpt";
10215       break;
10216     case bp_hardware_watchpoint:
10217       uiout->text ("Hardware watchpoint ");
10218       tuple_name = "wpt";
10219       break;
10220     case bp_read_watchpoint:
10221       uiout->text ("Hardware read watchpoint ");
10222       tuple_name = "hw-rwpt";
10223       break;
10224     case bp_access_watchpoint:
10225       uiout->text ("Hardware access (read/write) watchpoint ");
10226       tuple_name = "hw-awpt";
10227       break;
10228     default:
10229       internal_error (__FILE__, __LINE__,
10230                       _("Invalid hardware watchpoint type."));
10231     }
10232
10233   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10234   uiout->field_int ("number", b->number);
10235   uiout->text (": ");
10236   uiout->field_string ("exp", w->exp_string);
10237 }
10238
10239 /* Implement the "print_recreate" breakpoint_ops method for
10240    watchpoints.  */
10241
10242 static void
10243 print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10244 {
10245   struct watchpoint *w = (struct watchpoint *) b;
10246
10247   switch (b->type)
10248     {
10249     case bp_watchpoint:
10250     case bp_hardware_watchpoint:
10251       fprintf_unfiltered (fp, "watch");
10252       break;
10253     case bp_read_watchpoint:
10254       fprintf_unfiltered (fp, "rwatch");
10255       break;
10256     case bp_access_watchpoint:
10257       fprintf_unfiltered (fp, "awatch");
10258       break;
10259     default:
10260       internal_error (__FILE__, __LINE__,
10261                       _("Invalid watchpoint type."));
10262     }
10263
10264   fprintf_unfiltered (fp, " %s", w->exp_string);
10265   print_recreate_thread (b, fp);
10266 }
10267
10268 /* Implement the "explains_signal" breakpoint_ops method for
10269    watchpoints.  */
10270
10271 static int
10272 explains_signal_watchpoint (struct breakpoint *b, enum gdb_signal sig)
10273 {
10274   /* A software watchpoint cannot cause a signal other than
10275      GDB_SIGNAL_TRAP.  */
10276   if (b->type == bp_watchpoint && sig != GDB_SIGNAL_TRAP)
10277     return 0;
10278
10279   return 1;
10280 }
10281
10282 /* The breakpoint_ops structure to be used in hardware watchpoints.  */
10283
10284 static struct breakpoint_ops watchpoint_breakpoint_ops;
10285
10286 /* Implement the "insert" breakpoint_ops method for
10287    masked hardware watchpoints.  */
10288
10289 static int
10290 insert_masked_watchpoint (struct bp_location *bl)
10291 {
10292   struct watchpoint *w = (struct watchpoint *) bl->owner;
10293
10294   return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
10295                                         bl->watchpoint_type);
10296 }
10297
10298 /* Implement the "remove" breakpoint_ops method for
10299    masked hardware watchpoints.  */
10300
10301 static int
10302 remove_masked_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10303 {
10304   struct watchpoint *w = (struct watchpoint *) bl->owner;
10305
10306   return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
10307                                         bl->watchpoint_type);
10308 }
10309
10310 /* Implement the "resources_needed" breakpoint_ops method for
10311    masked hardware watchpoints.  */
10312
10313 static int
10314 resources_needed_masked_watchpoint (const struct bp_location *bl)
10315 {
10316   struct watchpoint *w = (struct watchpoint *) bl->owner;
10317
10318   return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
10319 }
10320
10321 /* Implement the "works_in_software_mode" breakpoint_ops method for
10322    masked hardware watchpoints.  */
10323
10324 static int
10325 works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10326 {
10327   return 0;
10328 }
10329
10330 /* Implement the "print_it" breakpoint_ops method for
10331    masked hardware watchpoints.  */
10332
10333 static enum print_stop_action
10334 print_it_masked_watchpoint (bpstat bs)
10335 {
10336   struct breakpoint *b = bs->breakpoint_at;
10337   struct ui_out *uiout = current_uiout;
10338
10339   /* Masked watchpoints have only one location.  */
10340   gdb_assert (b->loc && b->loc->next == NULL);
10341
10342   annotate_watchpoint (b->number);
10343   maybe_print_thread_hit_breakpoint (uiout);
10344
10345   switch (b->type)
10346     {
10347     case bp_hardware_watchpoint:
10348       if (uiout->is_mi_like_p ())
10349         uiout->field_string
10350           ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10351       break;
10352
10353     case bp_read_watchpoint:
10354       if (uiout->is_mi_like_p ())
10355         uiout->field_string
10356           ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10357       break;
10358
10359     case bp_access_watchpoint:
10360       if (uiout->is_mi_like_p ())
10361         uiout->field_string
10362           ("reason",
10363            async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10364       break;
10365     default:
10366       internal_error (__FILE__, __LINE__,
10367                       _("Invalid hardware watchpoint type."));
10368     }
10369
10370   mention (b);
10371   uiout->text (_("\n\
10372 Check the underlying instruction at PC for the memory\n\
10373 address and value which triggered this watchpoint.\n"));
10374   uiout->text ("\n");
10375
10376   /* More than one watchpoint may have been triggered.  */
10377   return PRINT_UNKNOWN;
10378 }
10379
10380 /* Implement the "print_one_detail" breakpoint_ops method for
10381    masked hardware watchpoints.  */
10382
10383 static void
10384 print_one_detail_masked_watchpoint (const struct breakpoint *b,
10385                                     struct ui_out *uiout)
10386 {
10387   struct watchpoint *w = (struct watchpoint *) b;
10388
10389   /* Masked watchpoints have only one location.  */
10390   gdb_assert (b->loc && b->loc->next == NULL);
10391
10392   uiout->text ("\tmask ");
10393   uiout->field_core_addr ("mask", b->loc->gdbarch, w->hw_wp_mask);
10394   uiout->text ("\n");
10395 }
10396
10397 /* Implement the "print_mention" breakpoint_ops method for
10398    masked hardware watchpoints.  */
10399
10400 static void
10401 print_mention_masked_watchpoint (struct breakpoint *b)
10402 {
10403   struct watchpoint *w = (struct watchpoint *) b;
10404   struct ui_out *uiout = current_uiout;
10405   const char *tuple_name;
10406
10407   switch (b->type)
10408     {
10409     case bp_hardware_watchpoint:
10410       uiout->text ("Masked hardware watchpoint ");
10411       tuple_name = "wpt";
10412       break;
10413     case bp_read_watchpoint:
10414       uiout->text ("Masked hardware read watchpoint ");
10415       tuple_name = "hw-rwpt";
10416       break;
10417     case bp_access_watchpoint:
10418       uiout->text ("Masked hardware access (read/write) watchpoint ");
10419       tuple_name = "hw-awpt";
10420       break;
10421     default:
10422       internal_error (__FILE__, __LINE__,
10423                       _("Invalid hardware watchpoint type."));
10424     }
10425
10426   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10427   uiout->field_int ("number", b->number);
10428   uiout->text (": ");
10429   uiout->field_string ("exp", w->exp_string);
10430 }
10431
10432 /* Implement the "print_recreate" breakpoint_ops method for
10433    masked hardware watchpoints.  */
10434
10435 static void
10436 print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
10437 {
10438   struct watchpoint *w = (struct watchpoint *) b;
10439   char tmp[40];
10440
10441   switch (b->type)
10442     {
10443     case bp_hardware_watchpoint:
10444       fprintf_unfiltered (fp, "watch");
10445       break;
10446     case bp_read_watchpoint:
10447       fprintf_unfiltered (fp, "rwatch");
10448       break;
10449     case bp_access_watchpoint:
10450       fprintf_unfiltered (fp, "awatch");
10451       break;
10452     default:
10453       internal_error (__FILE__, __LINE__,
10454                       _("Invalid hardware watchpoint type."));
10455     }
10456
10457   sprintf_vma (tmp, w->hw_wp_mask);
10458   fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
10459   print_recreate_thread (b, fp);
10460 }
10461
10462 /* The breakpoint_ops structure to be used in masked hardware watchpoints.  */
10463
10464 static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
10465
10466 /* Tell whether the given watchpoint is a masked hardware watchpoint.  */
10467
10468 static int
10469 is_masked_watchpoint (const struct breakpoint *b)
10470 {
10471   return b->ops == &masked_watchpoint_breakpoint_ops;
10472 }
10473
10474 /* accessflag:  hw_write:  watch write, 
10475                 hw_read:   watch read, 
10476                 hw_access: watch access (read or write) */
10477 static void
10478 watch_command_1 (const char *arg, int accessflag, int from_tty,
10479                  int just_location, int internal)
10480 {
10481   struct breakpoint *scope_breakpoint = NULL;
10482   const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
10483   struct value *result;
10484   int saved_bitpos = 0, saved_bitsize = 0;
10485   const char *exp_start = NULL;
10486   const char *exp_end = NULL;
10487   const char *tok, *end_tok;
10488   int toklen = -1;
10489   const char *cond_start = NULL;
10490   const char *cond_end = NULL;
10491   enum bptype bp_type;
10492   int thread = -1;
10493   int pc = 0;
10494   /* Flag to indicate whether we are going to use masks for
10495      the hardware watchpoint.  */
10496   int use_mask = 0;
10497   CORE_ADDR mask = 0;
10498
10499   /* Make sure that we actually have parameters to parse.  */
10500   if (arg != NULL && arg[0] != '\0')
10501     {
10502       const char *value_start;
10503
10504       exp_end = arg + strlen (arg);
10505
10506       /* Look for "parameter value" pairs at the end
10507          of the arguments string.  */
10508       for (tok = exp_end - 1; tok > arg; tok--)
10509         {
10510           /* Skip whitespace at the end of the argument list.  */
10511           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10512             tok--;
10513
10514           /* Find the beginning of the last token.
10515              This is the value of the parameter.  */
10516           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10517             tok--;
10518           value_start = tok + 1;
10519
10520           /* Skip whitespace.  */
10521           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10522             tok--;
10523
10524           end_tok = tok;
10525
10526           /* Find the beginning of the second to last token.
10527              This is the parameter itself.  */
10528           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10529             tok--;
10530           tok++;
10531           toklen = end_tok - tok + 1;
10532
10533           if (toklen == 6 && startswith (tok, "thread"))
10534             {
10535               struct thread_info *thr;
10536               /* At this point we've found a "thread" token, which means
10537                  the user is trying to set a watchpoint that triggers
10538                  only in a specific thread.  */
10539               const char *endp;
10540
10541               if (thread != -1)
10542                 error(_("You can specify only one thread."));
10543
10544               /* Extract the thread ID from the next token.  */
10545               thr = parse_thread_id (value_start, &endp);
10546
10547               /* Check if the user provided a valid thread ID.  */
10548               if (*endp != ' ' && *endp != '\t' && *endp != '\0')
10549                 invalid_thread_id_error (value_start);
10550
10551               thread = thr->global_num;
10552             }
10553           else if (toklen == 4 && startswith (tok, "mask"))
10554             {
10555               /* We've found a "mask" token, which means the user wants to
10556                  create a hardware watchpoint that is going to have the mask
10557                  facility.  */
10558               struct value *mask_value, *mark;
10559
10560               if (use_mask)
10561                 error(_("You can specify only one mask."));
10562
10563               use_mask = just_location = 1;
10564
10565               mark = value_mark ();
10566               mask_value = parse_to_comma_and_eval (&value_start);
10567               mask = value_as_address (mask_value);
10568               value_free_to_mark (mark);
10569             }
10570           else
10571             /* We didn't recognize what we found.  We should stop here.  */
10572             break;
10573
10574           /* Truncate the string and get rid of the "parameter value" pair before
10575              the arguments string is parsed by the parse_exp_1 function.  */
10576           exp_end = tok;
10577         }
10578     }
10579   else
10580     exp_end = arg;
10581
10582   /* Parse the rest of the arguments.  From here on out, everything
10583      is in terms of a newly allocated string instead of the original
10584      ARG.  */
10585   std::string expression (arg, exp_end - arg);
10586   exp_start = arg = expression.c_str ();
10587   innermost_block_tracker tracker;
10588   expression_up exp = parse_exp_1 (&arg, 0, 0, 0, &tracker);
10589   exp_end = arg;
10590   /* Remove trailing whitespace from the expression before saving it.
10591      This makes the eventual display of the expression string a bit
10592      prettier.  */
10593   while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
10594     --exp_end;
10595
10596   /* Checking if the expression is not constant.  */
10597   if (watchpoint_exp_is_const (exp.get ()))
10598     {
10599       int len;
10600
10601       len = exp_end - exp_start;
10602       while (len > 0 && isspace (exp_start[len - 1]))
10603         len--;
10604       error (_("Cannot watch constant value `%.*s'."), len, exp_start);
10605     }
10606
10607   exp_valid_block = tracker.block ();
10608   struct value *mark = value_mark ();
10609   struct value *val_as_value = nullptr;
10610   fetch_subexp_value (exp.get (), &pc, &val_as_value, &result, NULL,
10611                       just_location);
10612
10613   if (val_as_value != NULL && just_location)
10614     {
10615       saved_bitpos = value_bitpos (val_as_value);
10616       saved_bitsize = value_bitsize (val_as_value);
10617     }
10618
10619   value_ref_ptr val;
10620   if (just_location)
10621     {
10622       int ret;
10623
10624       exp_valid_block = NULL;
10625       val = release_value (value_addr (result));
10626       value_free_to_mark (mark);
10627
10628       if (use_mask)
10629         {
10630           ret = target_masked_watch_num_registers (value_as_address (val.get ()),
10631                                                    mask);
10632           if (ret == -1)
10633             error (_("This target does not support masked watchpoints."));
10634           else if (ret == -2)
10635             error (_("Invalid mask or memory region."));
10636         }
10637     }
10638   else if (val_as_value != NULL)
10639     val = release_value (val_as_value);
10640
10641   tok = skip_spaces (arg);
10642   end_tok = skip_to_space (tok);
10643
10644   toklen = end_tok - tok;
10645   if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
10646     {
10647       tok = cond_start = end_tok + 1;
10648       innermost_block_tracker if_tracker;
10649       parse_exp_1 (&tok, 0, 0, 0, &if_tracker);
10650
10651       /* The watchpoint expression may not be local, but the condition
10652          may still be.  E.g.: `watch global if local > 0'.  */
10653       cond_exp_valid_block = if_tracker.block ();
10654
10655       cond_end = tok;
10656     }
10657   if (*tok)
10658     error (_("Junk at end of command."));
10659
10660   frame_info *wp_frame = block_innermost_frame (exp_valid_block);
10661
10662   /* Save this because create_internal_breakpoint below invalidates
10663      'wp_frame'.  */
10664   frame_id watchpoint_frame = get_frame_id (wp_frame);
10665
10666   /* If the expression is "local", then set up a "watchpoint scope"
10667      breakpoint at the point where we've left the scope of the watchpoint
10668      expression.  Create the scope breakpoint before the watchpoint, so
10669      that we will encounter it first in bpstat_stop_status.  */
10670   if (exp_valid_block != NULL && wp_frame != NULL)
10671     {
10672       frame_id caller_frame_id = frame_unwind_caller_id (wp_frame);
10673
10674       if (frame_id_p (caller_frame_id))
10675         {
10676           gdbarch *caller_arch = frame_unwind_caller_arch (wp_frame);
10677           CORE_ADDR caller_pc = frame_unwind_caller_pc (wp_frame);
10678
10679           scope_breakpoint
10680             = create_internal_breakpoint (caller_arch, caller_pc,
10681                                           bp_watchpoint_scope,
10682                                           &momentary_breakpoint_ops);
10683
10684           /* create_internal_breakpoint could invalidate WP_FRAME.  */
10685           wp_frame = NULL;
10686
10687           scope_breakpoint->enable_state = bp_enabled;
10688
10689           /* Automatically delete the breakpoint when it hits.  */
10690           scope_breakpoint->disposition = disp_del;
10691
10692           /* Only break in the proper frame (help with recursion).  */
10693           scope_breakpoint->frame_id = caller_frame_id;
10694
10695           /* Set the address at which we will stop.  */
10696           scope_breakpoint->loc->gdbarch = caller_arch;
10697           scope_breakpoint->loc->requested_address = caller_pc;
10698           scope_breakpoint->loc->address
10699             = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
10700                                          scope_breakpoint->loc->requested_address,
10701                                          scope_breakpoint->type);
10702         }
10703     }
10704
10705   /* Now set up the breakpoint.  We create all watchpoints as hardware
10706      watchpoints here even if hardware watchpoints are turned off, a call
10707      to update_watchpoint later in this function will cause the type to
10708      drop back to bp_watchpoint (software watchpoint) if required.  */
10709
10710   if (accessflag == hw_read)
10711     bp_type = bp_read_watchpoint;
10712   else if (accessflag == hw_access)
10713     bp_type = bp_access_watchpoint;
10714   else
10715     bp_type = bp_hardware_watchpoint;
10716
10717   std::unique_ptr<watchpoint> w (new watchpoint ());
10718
10719   if (use_mask)
10720     init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10721                                           &masked_watchpoint_breakpoint_ops);
10722   else
10723     init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10724                                           &watchpoint_breakpoint_ops);
10725   w->thread = thread;
10726   w->disposition = disp_donttouch;
10727   w->pspace = current_program_space;
10728   w->exp = std::move (exp);
10729   w->exp_valid_block = exp_valid_block;
10730   w->cond_exp_valid_block = cond_exp_valid_block;
10731   if (just_location)
10732     {
10733       struct type *t = value_type (val.get ());
10734       CORE_ADDR addr = value_as_address (val.get ());
10735
10736       w->exp_string_reparse
10737         = current_language->la_watch_location_expression (t, addr).release ();
10738
10739       w->exp_string = xstrprintf ("-location %.*s",
10740                                   (int) (exp_end - exp_start), exp_start);
10741     }
10742   else
10743     w->exp_string = savestring (exp_start, exp_end - exp_start);
10744
10745   if (use_mask)
10746     {
10747       w->hw_wp_mask = mask;
10748     }
10749   else
10750     {
10751       w->val = val;
10752       w->val_bitpos = saved_bitpos;
10753       w->val_bitsize = saved_bitsize;
10754       w->val_valid = 1;
10755     }
10756
10757   if (cond_start)
10758     w->cond_string = savestring (cond_start, cond_end - cond_start);
10759   else
10760     w->cond_string = 0;
10761
10762   if (frame_id_p (watchpoint_frame))
10763     {
10764       w->watchpoint_frame = watchpoint_frame;
10765       w->watchpoint_thread = inferior_ptid;
10766     }
10767   else
10768     {
10769       w->watchpoint_frame = null_frame_id;
10770       w->watchpoint_thread = null_ptid;
10771     }
10772
10773   if (scope_breakpoint != NULL)
10774     {
10775       /* The scope breakpoint is related to the watchpoint.  We will
10776          need to act on them together.  */
10777       w->related_breakpoint = scope_breakpoint;
10778       scope_breakpoint->related_breakpoint = w.get ();
10779     }
10780
10781   if (!just_location)
10782     value_free_to_mark (mark);
10783
10784   /* Finally update the new watchpoint.  This creates the locations
10785      that should be inserted.  */
10786   update_watchpoint (w.get (), 1);
10787
10788   install_breakpoint (internal, std::move (w), 1);
10789 }
10790
10791 /* Return count of debug registers needed to watch the given expression.
10792    If the watchpoint cannot be handled in hardware return zero.  */
10793
10794 static int
10795 can_use_hardware_watchpoint (const std::vector<value_ref_ptr> &vals)
10796 {
10797   int found_memory_cnt = 0;
10798
10799   /* Did the user specifically forbid us to use hardware watchpoints? */
10800   if (!can_use_hw_watchpoints)
10801     return 0;
10802
10803   gdb_assert (!vals.empty ());
10804   struct value *head = vals[0].get ();
10805
10806   /* Make sure that the value of the expression depends only upon
10807      memory contents, and values computed from them within GDB.  If we
10808      find any register references or function calls, we can't use a
10809      hardware watchpoint.
10810
10811      The idea here is that evaluating an expression generates a series
10812      of values, one holding the value of every subexpression.  (The
10813      expression a*b+c has five subexpressions: a, b, a*b, c, and
10814      a*b+c.)  GDB's values hold almost enough information to establish
10815      the criteria given above --- they identify memory lvalues,
10816      register lvalues, computed values, etcetera.  So we can evaluate
10817      the expression, and then scan the chain of values that leaves
10818      behind to decide whether we can detect any possible change to the
10819      expression's final value using only hardware watchpoints.
10820
10821      However, I don't think that the values returned by inferior
10822      function calls are special in any way.  So this function may not
10823      notice that an expression involving an inferior function call
10824      can't be watched with hardware watchpoints.  FIXME.  */
10825   for (const value_ref_ptr &iter : vals)
10826     {
10827       struct value *v = iter.get ();
10828
10829       if (VALUE_LVAL (v) == lval_memory)
10830         {
10831           if (v != head && value_lazy (v))
10832             /* A lazy memory lvalue in the chain is one that GDB never
10833                needed to fetch; we either just used its address (e.g.,
10834                `a' in `a.b') or we never needed it at all (e.g., `a'
10835                in `a,b').  This doesn't apply to HEAD; if that is
10836                lazy then it was not readable, but watch it anyway.  */
10837             ;
10838           else
10839             {
10840               /* Ahh, memory we actually used!  Check if we can cover
10841                  it with hardware watchpoints.  */
10842               struct type *vtype = check_typedef (value_type (v));
10843
10844               /* We only watch structs and arrays if user asked for it
10845                  explicitly, never if they just happen to appear in a
10846                  middle of some value chain.  */
10847               if (v == head
10848                   || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
10849                       && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
10850                 {
10851                   CORE_ADDR vaddr = value_address (v);
10852                   int len;
10853                   int num_regs;
10854
10855                   len = (target_exact_watchpoints
10856                          && is_scalar_type_recursive (vtype))?
10857                     1 : TYPE_LENGTH (value_type (v));
10858
10859                   num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
10860                   if (!num_regs)
10861                     return 0;
10862                   else
10863                     found_memory_cnt += num_regs;
10864                 }
10865             }
10866         }
10867       else if (VALUE_LVAL (v) != not_lval
10868                && deprecated_value_modifiable (v) == 0)
10869         return 0;       /* These are values from the history (e.g., $1).  */
10870       else if (VALUE_LVAL (v) == lval_register)
10871         return 0;       /* Cannot watch a register with a HW watchpoint.  */
10872     }
10873
10874   /* The expression itself looks suitable for using a hardware
10875      watchpoint, but give the target machine a chance to reject it.  */
10876   return found_memory_cnt;
10877 }
10878
10879 void
10880 watch_command_wrapper (const char *arg, int from_tty, int internal)
10881 {
10882   watch_command_1 (arg, hw_write, from_tty, 0, internal);
10883 }
10884
10885 /* A helper function that looks for the "-location" argument and then
10886    calls watch_command_1.  */
10887
10888 static void
10889 watch_maybe_just_location (const char *arg, int accessflag, int from_tty)
10890 {
10891   int just_location = 0;
10892
10893   if (arg
10894       && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
10895           || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
10896     {
10897       arg = skip_spaces (arg);
10898       just_location = 1;
10899     }
10900
10901   watch_command_1 (arg, accessflag, from_tty, just_location, 0);
10902 }
10903
10904 static void
10905 watch_command (const char *arg, int from_tty)
10906 {
10907   watch_maybe_just_location (arg, hw_write, from_tty);
10908 }
10909
10910 void
10911 rwatch_command_wrapper (const char *arg, int from_tty, int internal)
10912 {
10913   watch_command_1 (arg, hw_read, from_tty, 0, internal);
10914 }
10915
10916 static void
10917 rwatch_command (const char *arg, int from_tty)
10918 {
10919   watch_maybe_just_location (arg, hw_read, from_tty);
10920 }
10921
10922 void
10923 awatch_command_wrapper (const char *arg, int from_tty, int internal)
10924 {
10925   watch_command_1 (arg, hw_access, from_tty, 0, internal);
10926 }
10927
10928 static void
10929 awatch_command (const char *arg, int from_tty)
10930 {
10931   watch_maybe_just_location (arg, hw_access, from_tty);
10932 }
10933 \f
10934
10935 /* Data for the FSM that manages the until(location)/advance commands
10936    in infcmd.c.  Here because it uses the mechanisms of
10937    breakpoints.  */
10938
10939 struct until_break_fsm : public thread_fsm
10940 {
10941   /* The thread that was current when the command was executed.  */
10942   int thread;
10943
10944   /* The breakpoint set at the destination location.  */
10945   breakpoint_up location_breakpoint;
10946
10947   /* Breakpoint set at the return address in the caller frame.  May be
10948      NULL.  */
10949   breakpoint_up caller_breakpoint;
10950
10951   until_break_fsm (struct interp *cmd_interp, int thread,
10952                    breakpoint_up &&location_breakpoint,
10953                    breakpoint_up &&caller_breakpoint)
10954     : thread_fsm (cmd_interp),
10955       thread (thread),
10956       location_breakpoint (std::move (location_breakpoint)),
10957       caller_breakpoint (std::move (caller_breakpoint))
10958   {
10959   }
10960
10961   void clean_up (struct thread_info *thread) override;
10962   bool should_stop (struct thread_info *thread) override;
10963   enum async_reply_reason do_async_reply_reason () override;
10964 };
10965
10966 /* Implementation of the 'should_stop' FSM method for the
10967    until(location)/advance commands.  */
10968
10969 bool
10970 until_break_fsm::should_stop (struct thread_info *tp)
10971 {
10972   if (bpstat_find_breakpoint (tp->control.stop_bpstat,
10973                               location_breakpoint.get ()) != NULL
10974       || (caller_breakpoint != NULL
10975           && bpstat_find_breakpoint (tp->control.stop_bpstat,
10976                                      caller_breakpoint.get ()) != NULL))
10977     set_finished ();
10978
10979   return true;
10980 }
10981
10982 /* Implementation of the 'clean_up' FSM method for the
10983    until(location)/advance commands.  */
10984
10985 void
10986 until_break_fsm::clean_up (struct thread_info *)
10987 {
10988   /* Clean up our temporary breakpoints.  */
10989   location_breakpoint.reset ();
10990   caller_breakpoint.reset ();
10991   delete_longjmp_breakpoint (thread);
10992 }
10993
10994 /* Implementation of the 'async_reply_reason' FSM method for the
10995    until(location)/advance commands.  */
10996
10997 enum async_reply_reason
10998 until_break_fsm::do_async_reply_reason ()
10999 {
11000   return EXEC_ASYNC_LOCATION_REACHED;
11001 }
11002
11003 void
11004 until_break_command (const char *arg, int from_tty, int anywhere)
11005 {
11006   struct frame_info *frame;
11007   struct gdbarch *frame_gdbarch;
11008   struct frame_id stack_frame_id;
11009   struct frame_id caller_frame_id;
11010   int thread;
11011   struct thread_info *tp;
11012
11013   clear_proceed_status (0);
11014
11015   /* Set a breakpoint where the user wants it and at return from
11016      this function.  */
11017
11018   event_location_up location = string_to_event_location (&arg, current_language);
11019
11020   std::vector<symtab_and_line> sals
11021     = (last_displayed_sal_is_valid ()
11022        ? decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
11023                         get_last_displayed_symtab (),
11024                         get_last_displayed_line ())
11025        : decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
11026                         NULL, (struct symtab *) NULL, 0));
11027
11028   if (sals.size () != 1)
11029     error (_("Couldn't get information on specified line."));
11030
11031   symtab_and_line &sal = sals[0];
11032
11033   if (*arg)
11034     error (_("Junk at end of arguments."));
11035
11036   resolve_sal_pc (&sal);
11037
11038   tp = inferior_thread ();
11039   thread = tp->global_num;
11040
11041   /* Note linespec handling above invalidates the frame chain.
11042      Installing a breakpoint also invalidates the frame chain (as it
11043      may need to switch threads), so do any frame handling before
11044      that.  */
11045
11046   frame = get_selected_frame (NULL);
11047   frame_gdbarch = get_frame_arch (frame);
11048   stack_frame_id = get_stack_frame_id (frame);
11049   caller_frame_id = frame_unwind_caller_id (frame);
11050
11051   /* Keep within the current frame, or in frames called by the current
11052      one.  */
11053
11054   breakpoint_up caller_breakpoint;
11055
11056   gdb::optional<delete_longjmp_breakpoint_cleanup> lj_deleter;
11057
11058   if (frame_id_p (caller_frame_id))
11059     {
11060       struct symtab_and_line sal2;
11061       struct gdbarch *caller_gdbarch;
11062
11063       sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11064       sal2.pc = frame_unwind_caller_pc (frame);
11065       caller_gdbarch = frame_unwind_caller_arch (frame);
11066       caller_breakpoint = set_momentary_breakpoint (caller_gdbarch,
11067                                                     sal2,
11068                                                     caller_frame_id,
11069                                                     bp_until);
11070
11071       set_longjmp_breakpoint (tp, caller_frame_id);
11072       lj_deleter.emplace (thread);
11073     }
11074
11075   /* set_momentary_breakpoint could invalidate FRAME.  */
11076   frame = NULL;
11077
11078   breakpoint_up location_breakpoint;
11079   if (anywhere)
11080     /* If the user told us to continue until a specified location,
11081        we don't specify a frame at which we need to stop.  */
11082     location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11083                                                     null_frame_id, bp_until);
11084   else
11085     /* Otherwise, specify the selected frame, because we want to stop
11086        only at the very same frame.  */
11087     location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11088                                                     stack_frame_id, bp_until);
11089
11090   tp->thread_fsm = new until_break_fsm (command_interp (), tp->global_num,
11091                                         std::move (location_breakpoint),
11092                                         std::move (caller_breakpoint));
11093
11094   if (lj_deleter)
11095     lj_deleter->release ();
11096
11097   proceed (-1, GDB_SIGNAL_DEFAULT);
11098 }
11099
11100 /* This function attempts to parse an optional "if <cond>" clause
11101    from the arg string.  If one is not found, it returns NULL.
11102
11103    Else, it returns a pointer to the condition string.  (It does not
11104    attempt to evaluate the string against a particular block.)  And,
11105    it updates arg to point to the first character following the parsed
11106    if clause in the arg string.  */
11107
11108 const char *
11109 ep_parse_optional_if_clause (const char **arg)
11110 {
11111   const char *cond_string;
11112
11113   if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
11114     return NULL;
11115
11116   /* Skip the "if" keyword.  */
11117   (*arg) += 2;
11118
11119   /* Skip any extra leading whitespace, and record the start of the
11120      condition string.  */
11121   *arg = skip_spaces (*arg);
11122   cond_string = *arg;
11123
11124   /* Assume that the condition occupies the remainder of the arg
11125      string.  */
11126   (*arg) += strlen (cond_string);
11127
11128   return cond_string;
11129 }
11130
11131 /* Commands to deal with catching events, such as signals, exceptions,
11132    process start/exit, etc.  */
11133
11134 typedef enum
11135 {
11136   catch_fork_temporary, catch_vfork_temporary,
11137   catch_fork_permanent, catch_vfork_permanent
11138 }
11139 catch_fork_kind;
11140
11141 static void
11142 catch_fork_command_1 (const char *arg, int from_tty,
11143                       struct cmd_list_element *command)
11144 {
11145   struct gdbarch *gdbarch = get_current_arch ();
11146   const char *cond_string = NULL;
11147   catch_fork_kind fork_kind;
11148   int tempflag;
11149
11150   fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11151   tempflag = (fork_kind == catch_fork_temporary
11152               || fork_kind == catch_vfork_temporary);
11153
11154   if (!arg)
11155     arg = "";
11156   arg = skip_spaces (arg);
11157
11158   /* The allowed syntax is:
11159      catch [v]fork
11160      catch [v]fork if <cond>
11161
11162      First, check if there's an if clause.  */
11163   cond_string = ep_parse_optional_if_clause (&arg);
11164
11165   if ((*arg != '\0') && !isspace (*arg))
11166     error (_("Junk at end of arguments."));
11167
11168   /* If this target supports it, create a fork or vfork catchpoint
11169      and enable reporting of such events.  */
11170   switch (fork_kind)
11171     {
11172     case catch_fork_temporary:
11173     case catch_fork_permanent:
11174       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11175                                           &catch_fork_breakpoint_ops);
11176       break;
11177     case catch_vfork_temporary:
11178     case catch_vfork_permanent:
11179       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11180                                           &catch_vfork_breakpoint_ops);
11181       break;
11182     default:
11183       error (_("unsupported or unknown fork kind; cannot catch it"));
11184       break;
11185     }
11186 }
11187
11188 static void
11189 catch_exec_command_1 (const char *arg, int from_tty,
11190                       struct cmd_list_element *command)
11191 {
11192   struct gdbarch *gdbarch = get_current_arch ();
11193   int tempflag;
11194   const char *cond_string = NULL;
11195
11196   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11197
11198   if (!arg)
11199     arg = "";
11200   arg = skip_spaces (arg);
11201
11202   /* The allowed syntax is:
11203      catch exec
11204      catch exec if <cond>
11205
11206      First, check if there's an if clause.  */
11207   cond_string = ep_parse_optional_if_clause (&arg);
11208
11209   if ((*arg != '\0') && !isspace (*arg))
11210     error (_("Junk at end of arguments."));
11211
11212   std::unique_ptr<exec_catchpoint> c (new exec_catchpoint ());
11213   init_catchpoint (c.get (), gdbarch, tempflag, cond_string,
11214                    &catch_exec_breakpoint_ops);
11215   c->exec_pathname = NULL;
11216
11217   install_breakpoint (0, std::move (c), 1);
11218 }
11219
11220 void
11221 init_ada_exception_breakpoint (struct breakpoint *b,
11222                                struct gdbarch *gdbarch,
11223                                struct symtab_and_line sal,
11224                                const char *addr_string,
11225                                const struct breakpoint_ops *ops,
11226                                int tempflag,
11227                                int enabled,
11228                                int from_tty)
11229 {
11230   if (from_tty)
11231     {
11232       struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11233       if (!loc_gdbarch)
11234         loc_gdbarch = gdbarch;
11235
11236       describe_other_breakpoints (loc_gdbarch,
11237                                   sal.pspace, sal.pc, sal.section, -1);
11238       /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11239          version for exception catchpoints, because two catchpoints
11240          used for different exception names will use the same address.
11241          In this case, a "breakpoint ... also set at..." warning is
11242          unproductive.  Besides, the warning phrasing is also a bit
11243          inappropriate, we should use the word catchpoint, and tell
11244          the user what type of catchpoint it is.  The above is good
11245          enough for now, though.  */
11246     }
11247
11248   init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
11249
11250   b->enable_state = enabled ? bp_enabled : bp_disabled;
11251   b->disposition = tempflag ? disp_del : disp_donttouch;
11252   b->location = string_to_event_location (&addr_string,
11253                                           language_def (language_ada));
11254   b->language = language_ada;
11255 }
11256
11257 static void
11258 catch_command (const char *arg, int from_tty)
11259 {
11260   error (_("Catch requires an event name."));
11261 }
11262 \f
11263
11264 static void
11265 tcatch_command (const char *arg, int from_tty)
11266 {
11267   error (_("Catch requires an event name."));
11268 }
11269
11270 /* Compare two breakpoints and return a strcmp-like result.  */
11271
11272 static int
11273 compare_breakpoints (const breakpoint *a, const breakpoint *b)
11274 {
11275   uintptr_t ua = (uintptr_t) a;
11276   uintptr_t ub = (uintptr_t) b;
11277
11278   if (a->number < b->number)
11279     return -1;
11280   else if (a->number > b->number)
11281     return 1;
11282
11283   /* Now sort by address, in case we see, e..g, two breakpoints with
11284      the number 0.  */
11285   if (ua < ub)
11286     return -1;
11287   return ua > ub ? 1 : 0;
11288 }
11289
11290 /* Delete breakpoints by address or line.  */
11291
11292 static void
11293 clear_command (const char *arg, int from_tty)
11294 {
11295   struct breakpoint *b;
11296   int default_match;
11297
11298   std::vector<symtab_and_line> decoded_sals;
11299   symtab_and_line last_sal;
11300   gdb::array_view<symtab_and_line> sals;
11301   if (arg)
11302     {
11303       decoded_sals
11304         = decode_line_with_current_source (arg,
11305                                            (DECODE_LINE_FUNFIRSTLINE
11306                                             | DECODE_LINE_LIST_MODE));
11307       default_match = 0;
11308       sals = decoded_sals;
11309     }
11310   else
11311     {
11312       /* Set sal's line, symtab, pc, and pspace to the values
11313          corresponding to the last call to print_frame_info.  If the
11314          codepoint is not valid, this will set all the fields to 0.  */
11315       last_sal = get_last_displayed_sal ();
11316       if (last_sal.symtab == 0)
11317         error (_("No source file specified."));
11318
11319       default_match = 1;
11320       sals = last_sal;
11321     }
11322
11323   /* We don't call resolve_sal_pc here.  That's not as bad as it
11324      seems, because all existing breakpoints typically have both
11325      file/line and pc set.  So, if clear is given file/line, we can
11326      match this to existing breakpoint without obtaining pc at all.
11327
11328      We only support clearing given the address explicitly 
11329      present in breakpoint table.  Say, we've set breakpoint 
11330      at file:line.  There were several PC values for that file:line,
11331      due to optimization, all in one block.
11332
11333      We've picked one PC value.  If "clear" is issued with another
11334      PC corresponding to the same file:line, the breakpoint won't
11335      be cleared.  We probably can still clear the breakpoint, but 
11336      since the other PC value is never presented to user, user
11337      can only find it by guessing, and it does not seem important
11338      to support that.  */
11339
11340   /* For each line spec given, delete bps which correspond to it.  Do
11341      it in two passes, solely to preserve the current behavior that
11342      from_tty is forced true if we delete more than one
11343      breakpoint.  */
11344
11345   std::vector<struct breakpoint *> found;
11346   for (const auto &sal : sals)
11347     {
11348       const char *sal_fullname;
11349
11350       /* If exact pc given, clear bpts at that pc.
11351          If line given (pc == 0), clear all bpts on specified line.
11352          If defaulting, clear all bpts on default line
11353          or at default pc.
11354
11355          defaulting    sal.pc != 0    tests to do
11356
11357          0              1             pc
11358          1              1             pc _and_ line
11359          0              0             line
11360          1              0             <can't happen> */
11361
11362       sal_fullname = (sal.symtab == NULL
11363                       ? NULL : symtab_to_fullname (sal.symtab));
11364
11365       /* Find all matching breakpoints and add them to 'found'.  */
11366       ALL_BREAKPOINTS (b)
11367         {
11368           int match = 0;
11369           /* Are we going to delete b?  */
11370           if (b->type != bp_none && !is_watchpoint (b))
11371             {
11372               struct bp_location *loc = b->loc;
11373               for (; loc; loc = loc->next)
11374                 {
11375                   /* If the user specified file:line, don't allow a PC
11376                      match.  This matches historical gdb behavior.  */
11377                   int pc_match = (!sal.explicit_line
11378                                   && sal.pc
11379                                   && (loc->pspace == sal.pspace)
11380                                   && (loc->address == sal.pc)
11381                                   && (!section_is_overlay (loc->section)
11382                                       || loc->section == sal.section));
11383                   int line_match = 0;
11384
11385                   if ((default_match || sal.explicit_line)
11386                       && loc->symtab != NULL
11387                       && sal_fullname != NULL
11388                       && sal.pspace == loc->pspace
11389                       && loc->line_number == sal.line
11390                       && filename_cmp (symtab_to_fullname (loc->symtab),
11391                                        sal_fullname) == 0)
11392                     line_match = 1;
11393
11394                   if (pc_match || line_match)
11395                     {
11396                       match = 1;
11397                       break;
11398                     }
11399                 }
11400             }
11401
11402           if (match)
11403             found.push_back (b);
11404         }
11405     }
11406
11407   /* Now go thru the 'found' chain and delete them.  */
11408   if (found.empty ())
11409     {
11410       if (arg)
11411         error (_("No breakpoint at %s."), arg);
11412       else
11413         error (_("No breakpoint at this line."));
11414     }
11415
11416   /* Remove duplicates from the vec.  */
11417   std::sort (found.begin (), found.end (),
11418              [] (const breakpoint *bp_a, const breakpoint *bp_b)
11419              {
11420                return compare_breakpoints (bp_a, bp_b) < 0;
11421              });
11422   found.erase (std::unique (found.begin (), found.end (),
11423                             [] (const breakpoint *bp_a, const breakpoint *bp_b)
11424                             {
11425                               return compare_breakpoints (bp_a, bp_b) == 0;
11426                             }),
11427                found.end ());
11428
11429   if (found.size () > 1)
11430     from_tty = 1;       /* Always report if deleted more than one.  */
11431   if (from_tty)
11432     {
11433       if (found.size () == 1)
11434         printf_unfiltered (_("Deleted breakpoint "));
11435       else
11436         printf_unfiltered (_("Deleted breakpoints "));
11437     }
11438
11439   for (breakpoint *iter : found)
11440     {
11441       if (from_tty)
11442         printf_unfiltered ("%d ", iter->number);
11443       delete_breakpoint (iter);
11444     }
11445   if (from_tty)
11446     putchar_unfiltered ('\n');
11447 }
11448 \f
11449 /* Delete breakpoint in BS if they are `delete' breakpoints and
11450    all breakpoints that are marked for deletion, whether hit or not.
11451    This is called after any breakpoint is hit, or after errors.  */
11452
11453 void
11454 breakpoint_auto_delete (bpstat bs)
11455 {
11456   struct breakpoint *b, *b_tmp;
11457
11458   for (; bs; bs = bs->next)
11459     if (bs->breakpoint_at
11460         && bs->breakpoint_at->disposition == disp_del
11461         && bs->stop)
11462       delete_breakpoint (bs->breakpoint_at);
11463
11464   ALL_BREAKPOINTS_SAFE (b, b_tmp)
11465   {
11466     if (b->disposition == disp_del_at_next_stop)
11467       delete_breakpoint (b);
11468   }
11469 }
11470
11471 /* A comparison function for bp_location AP and BP being interfaced to
11472    qsort.  Sort elements primarily by their ADDRESS (no matter what
11473    does breakpoint_address_is_meaningful say for its OWNER),
11474    secondarily by ordering first permanent elements and
11475    terciarily just ensuring the array is sorted stable way despite
11476    qsort being an unstable algorithm.  */
11477
11478 static int
11479 bp_locations_compare (const void *ap, const void *bp)
11480 {
11481   const struct bp_location *a = *(const struct bp_location **) ap;
11482   const struct bp_location *b = *(const struct bp_location **) bp;
11483
11484   if (a->address != b->address)
11485     return (a->address > b->address) - (a->address < b->address);
11486
11487   /* Sort locations at the same address by their pspace number, keeping
11488      locations of the same inferior (in a multi-inferior environment)
11489      grouped.  */
11490
11491   if (a->pspace->num != b->pspace->num)
11492     return ((a->pspace->num > b->pspace->num)
11493             - (a->pspace->num < b->pspace->num));
11494
11495   /* Sort permanent breakpoints first.  */
11496   if (a->permanent != b->permanent)
11497     return (a->permanent < b->permanent) - (a->permanent > b->permanent);
11498
11499   /* Make the internal GDB representation stable across GDB runs
11500      where A and B memory inside GDB can differ.  Breakpoint locations of
11501      the same type at the same address can be sorted in arbitrary order.  */
11502
11503   if (a->owner->number != b->owner->number)
11504     return ((a->owner->number > b->owner->number)
11505             - (a->owner->number < b->owner->number));
11506
11507   return (a > b) - (a < b);
11508 }
11509
11510 /* Set bp_locations_placed_address_before_address_max and
11511    bp_locations_shadow_len_after_address_max according to the current
11512    content of the bp_locations array.  */
11513
11514 static void
11515 bp_locations_target_extensions_update (void)
11516 {
11517   struct bp_location *bl, **blp_tmp;
11518
11519   bp_locations_placed_address_before_address_max = 0;
11520   bp_locations_shadow_len_after_address_max = 0;
11521
11522   ALL_BP_LOCATIONS (bl, blp_tmp)
11523     {
11524       CORE_ADDR start, end, addr;
11525
11526       if (!bp_location_has_shadow (bl))
11527         continue;
11528
11529       start = bl->target_info.placed_address;
11530       end = start + bl->target_info.shadow_len;
11531
11532       gdb_assert (bl->address >= start);
11533       addr = bl->address - start;
11534       if (addr > bp_locations_placed_address_before_address_max)
11535         bp_locations_placed_address_before_address_max = addr;
11536
11537       /* Zero SHADOW_LEN would not pass bp_location_has_shadow.  */
11538
11539       gdb_assert (bl->address < end);
11540       addr = end - bl->address;
11541       if (addr > bp_locations_shadow_len_after_address_max)
11542         bp_locations_shadow_len_after_address_max = addr;
11543     }
11544 }
11545
11546 /* Download tracepoint locations if they haven't been.  */
11547
11548 static void
11549 download_tracepoint_locations (void)
11550 {
11551   struct breakpoint *b;
11552   enum tribool can_download_tracepoint = TRIBOOL_UNKNOWN;
11553
11554   scoped_restore_current_pspace_and_thread restore_pspace_thread;
11555
11556   ALL_TRACEPOINTS (b)
11557     {
11558       struct bp_location *bl;
11559       struct tracepoint *t;
11560       int bp_location_downloaded = 0;
11561
11562       if ((b->type == bp_fast_tracepoint
11563            ? !may_insert_fast_tracepoints
11564            : !may_insert_tracepoints))
11565         continue;
11566
11567       if (can_download_tracepoint == TRIBOOL_UNKNOWN)
11568         {
11569           if (target_can_download_tracepoint ())
11570             can_download_tracepoint = TRIBOOL_TRUE;
11571           else
11572             can_download_tracepoint = TRIBOOL_FALSE;
11573         }
11574
11575       if (can_download_tracepoint == TRIBOOL_FALSE)
11576         break;
11577
11578       for (bl = b->loc; bl; bl = bl->next)
11579         {
11580           /* In tracepoint, locations are _never_ duplicated, so
11581              should_be_inserted is equivalent to
11582              unduplicated_should_be_inserted.  */
11583           if (!should_be_inserted (bl) || bl->inserted)
11584             continue;
11585
11586           switch_to_program_space_and_thread (bl->pspace);
11587
11588           target_download_tracepoint (bl);
11589
11590           bl->inserted = 1;
11591           bp_location_downloaded = 1;
11592         }
11593       t = (struct tracepoint *) b;
11594       t->number_on_target = b->number;
11595       if (bp_location_downloaded)
11596         gdb::observers::breakpoint_modified.notify (b);
11597     }
11598 }
11599
11600 /* Swap the insertion/duplication state between two locations.  */
11601
11602 static void
11603 swap_insertion (struct bp_location *left, struct bp_location *right)
11604 {
11605   const int left_inserted = left->inserted;
11606   const int left_duplicate = left->duplicate;
11607   const int left_needs_update = left->needs_update;
11608   const struct bp_target_info left_target_info = left->target_info;
11609
11610   /* Locations of tracepoints can never be duplicated.  */
11611   if (is_tracepoint (left->owner))
11612     gdb_assert (!left->duplicate);
11613   if (is_tracepoint (right->owner))
11614     gdb_assert (!right->duplicate);
11615
11616   left->inserted = right->inserted;
11617   left->duplicate = right->duplicate;
11618   left->needs_update = right->needs_update;
11619   left->target_info = right->target_info;
11620   right->inserted = left_inserted;
11621   right->duplicate = left_duplicate;
11622   right->needs_update = left_needs_update;
11623   right->target_info = left_target_info;
11624 }
11625
11626 /* Force the re-insertion of the locations at ADDRESS.  This is called
11627    once a new/deleted/modified duplicate location is found and we are evaluating
11628    conditions on the target's side.  Such conditions need to be updated on
11629    the target.  */
11630
11631 static void
11632 force_breakpoint_reinsertion (struct bp_location *bl)
11633 {
11634   struct bp_location **locp = NULL, **loc2p;
11635   struct bp_location *loc;
11636   CORE_ADDR address = 0;
11637   int pspace_num;
11638
11639   address = bl->address;
11640   pspace_num = bl->pspace->num;
11641
11642   /* This is only meaningful if the target is
11643      evaluating conditions and if the user has
11644      opted for condition evaluation on the target's
11645      side.  */
11646   if (gdb_evaluates_breakpoint_condition_p ()
11647       || !target_supports_evaluation_of_breakpoint_conditions ())
11648     return;
11649
11650   /* Flag all breakpoint locations with this address and
11651      the same program space as the location
11652      as "its condition has changed".  We need to
11653      update the conditions on the target's side.  */
11654   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
11655     {
11656       loc = *loc2p;
11657
11658       if (!is_breakpoint (loc->owner)
11659           || pspace_num != loc->pspace->num)
11660         continue;
11661
11662       /* Flag the location appropriately.  We use a different state to
11663          let everyone know that we already updated the set of locations
11664          with addr bl->address and program space bl->pspace.  This is so
11665          we don't have to keep calling these functions just to mark locations
11666          that have already been marked.  */
11667       loc->condition_changed = condition_updated;
11668
11669       /* Free the agent expression bytecode as well.  We will compute
11670          it later on.  */
11671       loc->cond_bytecode.reset ();
11672     }
11673 }
11674 /* Called whether new breakpoints are created, or existing breakpoints
11675    deleted, to update the global location list and recompute which
11676    locations are duplicate of which.
11677
11678    The INSERT_MODE flag determines whether locations may not, may, or
11679    shall be inserted now.  See 'enum ugll_insert_mode' for more
11680    info.  */
11681
11682 static void
11683 update_global_location_list (enum ugll_insert_mode insert_mode)
11684 {
11685   struct breakpoint *b;
11686   struct bp_location **locp, *loc;
11687   /* Last breakpoint location address that was marked for update.  */
11688   CORE_ADDR last_addr = 0;
11689   /* Last breakpoint location program space that was marked for update.  */
11690   int last_pspace_num = -1;
11691
11692   /* Used in the duplicates detection below.  When iterating over all
11693      bp_locations, points to the first bp_location of a given address.
11694      Breakpoints and watchpoints of different types are never
11695      duplicates of each other.  Keep one pointer for each type of
11696      breakpoint/watchpoint, so we only need to loop over all locations
11697      once.  */
11698   struct bp_location *bp_loc_first;  /* breakpoint */
11699   struct bp_location *wp_loc_first;  /* hardware watchpoint */
11700   struct bp_location *awp_loc_first; /* access watchpoint */
11701   struct bp_location *rwp_loc_first; /* read watchpoint */
11702
11703   /* Saved former bp_locations array which we compare against the newly
11704      built bp_locations from the current state of ALL_BREAKPOINTS.  */
11705   struct bp_location **old_locp;
11706   unsigned old_locations_count;
11707   gdb::unique_xmalloc_ptr<struct bp_location *> old_locations (bp_locations);
11708
11709   old_locations_count = bp_locations_count;
11710   bp_locations = NULL;
11711   bp_locations_count = 0;
11712
11713   ALL_BREAKPOINTS (b)
11714     for (loc = b->loc; loc; loc = loc->next)
11715       bp_locations_count++;
11716
11717   bp_locations = XNEWVEC (struct bp_location *, bp_locations_count);
11718   locp = bp_locations;
11719   ALL_BREAKPOINTS (b)
11720     for (loc = b->loc; loc; loc = loc->next)
11721       *locp++ = loc;
11722   qsort (bp_locations, bp_locations_count, sizeof (*bp_locations),
11723          bp_locations_compare);
11724
11725   bp_locations_target_extensions_update ();
11726
11727   /* Identify bp_location instances that are no longer present in the
11728      new list, and therefore should be freed.  Note that it's not
11729      necessary that those locations should be removed from inferior --
11730      if there's another location at the same address (previously
11731      marked as duplicate), we don't need to remove/insert the
11732      location.
11733      
11734      LOCP is kept in sync with OLD_LOCP, each pointing to the current
11735      and former bp_location array state respectively.  */
11736
11737   locp = bp_locations;
11738   for (old_locp = old_locations.get ();
11739        old_locp < old_locations.get () + old_locations_count;
11740        old_locp++)
11741     {
11742       struct bp_location *old_loc = *old_locp;
11743       struct bp_location **loc2p;
11744
11745       /* Tells if 'old_loc' is found among the new locations.  If
11746          not, we have to free it.  */
11747       int found_object = 0;
11748       /* Tells if the location should remain inserted in the target.  */
11749       int keep_in_target = 0;
11750       int removed = 0;
11751
11752       /* Skip LOCP entries which will definitely never be needed.
11753          Stop either at or being the one matching OLD_LOC.  */
11754       while (locp < bp_locations + bp_locations_count
11755              && (*locp)->address < old_loc->address)
11756         locp++;
11757
11758       for (loc2p = locp;
11759            (loc2p < bp_locations + bp_locations_count
11760             && (*loc2p)->address == old_loc->address);
11761            loc2p++)
11762         {
11763           /* Check if this is a new/duplicated location or a duplicated
11764              location that had its condition modified.  If so, we want to send
11765              its condition to the target if evaluation of conditions is taking
11766              place there.  */
11767           if ((*loc2p)->condition_changed == condition_modified
11768               && (last_addr != old_loc->address
11769                   || last_pspace_num != old_loc->pspace->num))
11770             {
11771               force_breakpoint_reinsertion (*loc2p);
11772               last_pspace_num = old_loc->pspace->num;
11773             }
11774
11775           if (*loc2p == old_loc)
11776             found_object = 1;
11777         }
11778
11779       /* We have already handled this address, update it so that we don't
11780          have to go through updates again.  */
11781       last_addr = old_loc->address;
11782
11783       /* Target-side condition evaluation: Handle deleted locations.  */
11784       if (!found_object)
11785         force_breakpoint_reinsertion (old_loc);
11786
11787       /* If this location is no longer present, and inserted, look if
11788          there's maybe a new location at the same address.  If so,
11789          mark that one inserted, and don't remove this one.  This is
11790          needed so that we don't have a time window where a breakpoint
11791          at certain location is not inserted.  */
11792
11793       if (old_loc->inserted)
11794         {
11795           /* If the location is inserted now, we might have to remove
11796              it.  */
11797
11798           if (found_object && should_be_inserted (old_loc))
11799             {
11800               /* The location is still present in the location list,
11801                  and still should be inserted.  Don't do anything.  */
11802               keep_in_target = 1;
11803             }
11804           else
11805             {
11806               /* This location still exists, but it won't be kept in the
11807                  target since it may have been disabled.  We proceed to
11808                  remove its target-side condition.  */
11809
11810               /* The location is either no longer present, or got
11811                  disabled.  See if there's another location at the
11812                  same address, in which case we don't need to remove
11813                  this one from the target.  */
11814
11815               /* OLD_LOC comes from existing struct breakpoint.  */
11816               if (breakpoint_address_is_meaningful (old_loc->owner))
11817                 {
11818                   for (loc2p = locp;
11819                        (loc2p < bp_locations + bp_locations_count
11820                         && (*loc2p)->address == old_loc->address);
11821                        loc2p++)
11822                     {
11823                       struct bp_location *loc2 = *loc2p;
11824
11825                       if (breakpoint_locations_match (loc2, old_loc))
11826                         {
11827                           /* Read watchpoint locations are switched to
11828                              access watchpoints, if the former are not
11829                              supported, but the latter are.  */
11830                           if (is_hardware_watchpoint (old_loc->owner))
11831                             {
11832                               gdb_assert (is_hardware_watchpoint (loc2->owner));
11833                               loc2->watchpoint_type = old_loc->watchpoint_type;
11834                             }
11835
11836                           /* loc2 is a duplicated location. We need to check
11837                              if it should be inserted in case it will be
11838                              unduplicated.  */
11839                           if (loc2 != old_loc
11840                               && unduplicated_should_be_inserted (loc2))
11841                             {
11842                               swap_insertion (old_loc, loc2);
11843                               keep_in_target = 1;
11844                               break;
11845                             }
11846                         }
11847                     }
11848                 }
11849             }
11850
11851           if (!keep_in_target)
11852             {
11853               if (remove_breakpoint (old_loc))
11854                 {
11855                   /* This is just about all we can do.  We could keep
11856                      this location on the global list, and try to
11857                      remove it next time, but there's no particular
11858                      reason why we will succeed next time.
11859                      
11860                      Note that at this point, old_loc->owner is still
11861                      valid, as delete_breakpoint frees the breakpoint
11862                      only after calling us.  */
11863                   printf_filtered (_("warning: Error removing "
11864                                      "breakpoint %d\n"), 
11865                                    old_loc->owner->number);
11866                 }
11867               removed = 1;
11868             }
11869         }
11870
11871       if (!found_object)
11872         {
11873           if (removed && target_is_non_stop_p ()
11874               && need_moribund_for_location_type (old_loc))
11875             {
11876               /* This location was removed from the target.  In
11877                  non-stop mode, a race condition is possible where
11878                  we've removed a breakpoint, but stop events for that
11879                  breakpoint are already queued and will arrive later.
11880                  We apply an heuristic to be able to distinguish such
11881                  SIGTRAPs from other random SIGTRAPs: we keep this
11882                  breakpoint location for a bit, and will retire it
11883                  after we see some number of events.  The theory here
11884                  is that reporting of events should, "on the average",
11885                  be fair, so after a while we'll see events from all
11886                  threads that have anything of interest, and no longer
11887                  need to keep this breakpoint location around.  We
11888                  don't hold locations forever so to reduce chances of
11889                  mistaking a non-breakpoint SIGTRAP for a breakpoint
11890                  SIGTRAP.
11891
11892                  The heuristic failing can be disastrous on
11893                  decr_pc_after_break targets.
11894
11895                  On decr_pc_after_break targets, like e.g., x86-linux,
11896                  if we fail to recognize a late breakpoint SIGTRAP,
11897                  because events_till_retirement has reached 0 too
11898                  soon, we'll fail to do the PC adjustment, and report
11899                  a random SIGTRAP to the user.  When the user resumes
11900                  the inferior, it will most likely immediately crash
11901                  with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
11902                  corrupted, because of being resumed e.g., in the
11903                  middle of a multi-byte instruction, or skipped a
11904                  one-byte instruction.  This was actually seen happen
11905                  on native x86-linux, and should be less rare on
11906                  targets that do not support new thread events, like
11907                  remote, due to the heuristic depending on
11908                  thread_count.
11909
11910                  Mistaking a random SIGTRAP for a breakpoint trap
11911                  causes similar symptoms (PC adjustment applied when
11912                  it shouldn't), but then again, playing with SIGTRAPs
11913                  behind the debugger's back is asking for trouble.
11914
11915                  Since hardware watchpoint traps are always
11916                  distinguishable from other traps, so we don't need to
11917                  apply keep hardware watchpoint moribund locations
11918                  around.  We simply always ignore hardware watchpoint
11919                  traps we can no longer explain.  */
11920
11921               old_loc->events_till_retirement = 3 * (thread_count () + 1);
11922               old_loc->owner = NULL;
11923
11924               moribund_locations.push_back (old_loc);
11925             }
11926           else
11927             {
11928               old_loc->owner = NULL;
11929               decref_bp_location (&old_loc);
11930             }
11931         }
11932     }
11933
11934   /* Rescan breakpoints at the same address and section, marking the
11935      first one as "first" and any others as "duplicates".  This is so
11936      that the bpt instruction is only inserted once.  If we have a
11937      permanent breakpoint at the same place as BPT, make that one the
11938      official one, and the rest as duplicates.  Permanent breakpoints
11939      are sorted first for the same address.
11940
11941      Do the same for hardware watchpoints, but also considering the
11942      watchpoint's type (regular/access/read) and length.  */
11943
11944   bp_loc_first = NULL;
11945   wp_loc_first = NULL;
11946   awp_loc_first = NULL;
11947   rwp_loc_first = NULL;
11948   ALL_BP_LOCATIONS (loc, locp)
11949     {
11950       /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
11951          non-NULL.  */
11952       struct bp_location **loc_first_p;
11953       b = loc->owner;
11954
11955       if (!unduplicated_should_be_inserted (loc)
11956           || !breakpoint_address_is_meaningful (b)
11957           /* Don't detect duplicate for tracepoint locations because they are
11958            never duplicated.  See the comments in field `duplicate' of
11959            `struct bp_location'.  */
11960           || is_tracepoint (b))
11961         {
11962           /* Clear the condition modification flag.  */
11963           loc->condition_changed = condition_unchanged;
11964           continue;
11965         }
11966
11967       if (b->type == bp_hardware_watchpoint)
11968         loc_first_p = &wp_loc_first;
11969       else if (b->type == bp_read_watchpoint)
11970         loc_first_p = &rwp_loc_first;
11971       else if (b->type == bp_access_watchpoint)
11972         loc_first_p = &awp_loc_first;
11973       else
11974         loc_first_p = &bp_loc_first;
11975
11976       if (*loc_first_p == NULL
11977           || (overlay_debugging && loc->section != (*loc_first_p)->section)
11978           || !breakpoint_locations_match (loc, *loc_first_p))
11979         {
11980           *loc_first_p = loc;
11981           loc->duplicate = 0;
11982
11983           if (is_breakpoint (loc->owner) && loc->condition_changed)
11984             {
11985               loc->needs_update = 1;
11986               /* Clear the condition modification flag.  */
11987               loc->condition_changed = condition_unchanged;
11988             }
11989           continue;
11990         }
11991
11992
11993       /* This and the above ensure the invariant that the first location
11994          is not duplicated, and is the inserted one.
11995          All following are marked as duplicated, and are not inserted.  */
11996       if (loc->inserted)
11997         swap_insertion (loc, *loc_first_p);
11998       loc->duplicate = 1;
11999
12000       /* Clear the condition modification flag.  */
12001       loc->condition_changed = condition_unchanged;
12002     }
12003
12004   if (insert_mode == UGLL_INSERT || breakpoints_should_be_inserted_now ())
12005     {
12006       if (insert_mode != UGLL_DONT_INSERT)
12007         insert_breakpoint_locations ();
12008       else
12009         {
12010           /* Even though the caller told us to not insert new
12011              locations, we may still need to update conditions on the
12012              target's side of breakpoints that were already inserted
12013              if the target is evaluating breakpoint conditions.  We
12014              only update conditions for locations that are marked
12015              "needs_update".  */
12016           update_inserted_breakpoint_locations ();
12017         }
12018     }
12019
12020   if (insert_mode != UGLL_DONT_INSERT)
12021     download_tracepoint_locations ();
12022 }
12023
12024 void
12025 breakpoint_retire_moribund (void)
12026 {
12027   for (int ix = 0; ix < moribund_locations.size (); ++ix)
12028     {
12029       struct bp_location *loc = moribund_locations[ix];
12030       if (--(loc->events_till_retirement) == 0)
12031         {
12032           decref_bp_location (&loc);
12033           unordered_remove (moribund_locations, ix);
12034           --ix;
12035         }
12036     }
12037 }
12038
12039 static void
12040 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode)
12041 {
12042
12043   try
12044     {
12045       update_global_location_list (insert_mode);
12046     }
12047   catch (const gdb_exception_error &e)
12048     {
12049     }
12050 }
12051
12052 /* Clear BKP from a BPS.  */
12053
12054 static void
12055 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12056 {
12057   bpstat bs;
12058
12059   for (bs = bps; bs; bs = bs->next)
12060     if (bs->breakpoint_at == bpt)
12061       {
12062         bs->breakpoint_at = NULL;
12063         bs->old_val = NULL;
12064         /* bs->commands will be freed later.  */
12065       }
12066 }
12067
12068 /* Callback for iterate_over_threads.  */
12069 static int
12070 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12071 {
12072   struct breakpoint *bpt = (struct breakpoint *) data;
12073
12074   bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12075   return 0;
12076 }
12077
12078 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12079    callbacks.  */
12080
12081 static void
12082 say_where (struct breakpoint *b)
12083 {
12084   struct value_print_options opts;
12085
12086   get_user_print_options (&opts);
12087
12088   /* i18n: cagney/2005-02-11: Below needs to be merged into a
12089      single string.  */
12090   if (b->loc == NULL)
12091     {
12092       /* For pending locations, the output differs slightly based
12093          on b->extra_string.  If this is non-NULL, it contains either
12094          a condition or dprintf arguments.  */
12095       if (b->extra_string == NULL)
12096         {
12097           printf_filtered (_(" (%s) pending."),
12098                            event_location_to_string (b->location.get ()));
12099         }
12100       else if (b->type == bp_dprintf)
12101         {
12102           printf_filtered (_(" (%s,%s) pending."),
12103                            event_location_to_string (b->location.get ()),
12104                            b->extra_string);
12105         }
12106       else
12107         {
12108           printf_filtered (_(" (%s %s) pending."),
12109                            event_location_to_string (b->location.get ()),
12110                            b->extra_string);
12111         }
12112     }
12113   else
12114     {
12115       if (opts.addressprint || b->loc->symtab == NULL)
12116         {
12117           printf_filtered (" at ");
12118           fputs_styled (paddress (b->loc->gdbarch, b->loc->address),
12119                         address_style.style (),
12120                         gdb_stdout);
12121         }
12122       if (b->loc->symtab != NULL)
12123         {
12124           /* If there is a single location, we can print the location
12125              more nicely.  */
12126           if (b->loc->next == NULL)
12127             {
12128               puts_filtered (": file ");
12129               fputs_styled (symtab_to_filename_for_display (b->loc->symtab),
12130                             file_name_style.style (),
12131                             gdb_stdout);
12132               printf_filtered (", line %d.",
12133                                b->loc->line_number);
12134             }
12135           else
12136             /* This is not ideal, but each location may have a
12137                different file name, and this at least reflects the
12138                real situation somewhat.  */
12139             printf_filtered (": %s.",
12140                              event_location_to_string (b->location.get ()));
12141         }
12142
12143       if (b->loc->next)
12144         {
12145           struct bp_location *loc = b->loc;
12146           int n = 0;
12147           for (; loc; loc = loc->next)
12148             ++n;
12149           printf_filtered (" (%d locations)", n);
12150         }
12151     }
12152 }
12153
12154 bp_location::~bp_location ()
12155 {
12156   xfree (function_name);
12157 }
12158
12159 /* Destructor for the breakpoint base class.  */
12160
12161 breakpoint::~breakpoint ()
12162 {
12163   xfree (this->cond_string);
12164   xfree (this->extra_string);
12165   xfree (this->filter);
12166 }
12167
12168 static struct bp_location *
12169 base_breakpoint_allocate_location (struct breakpoint *self)
12170 {
12171   return new bp_location (self);
12172 }
12173
12174 static void
12175 base_breakpoint_re_set (struct breakpoint *b)
12176 {
12177   /* Nothing to re-set. */
12178 }
12179
12180 #define internal_error_pure_virtual_called() \
12181   gdb_assert_not_reached ("pure virtual function called")
12182
12183 static int
12184 base_breakpoint_insert_location (struct bp_location *bl)
12185 {
12186   internal_error_pure_virtual_called ();
12187 }
12188
12189 static int
12190 base_breakpoint_remove_location (struct bp_location *bl,
12191                                  enum remove_bp_reason reason)
12192 {
12193   internal_error_pure_virtual_called ();
12194 }
12195
12196 static int
12197 base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12198                                 const address_space *aspace,
12199                                 CORE_ADDR bp_addr,
12200                                 const struct target_waitstatus *ws)
12201 {
12202   internal_error_pure_virtual_called ();
12203 }
12204
12205 static void
12206 base_breakpoint_check_status (bpstat bs)
12207 {
12208   /* Always stop.   */
12209 }
12210
12211 /* A "works_in_software_mode" breakpoint_ops method that just internal
12212    errors.  */
12213
12214 static int
12215 base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12216 {
12217   internal_error_pure_virtual_called ();
12218 }
12219
12220 /* A "resources_needed" breakpoint_ops method that just internal
12221    errors.  */
12222
12223 static int
12224 base_breakpoint_resources_needed (const struct bp_location *bl)
12225 {
12226   internal_error_pure_virtual_called ();
12227 }
12228
12229 static enum print_stop_action
12230 base_breakpoint_print_it (bpstat bs)
12231 {
12232   internal_error_pure_virtual_called ();
12233 }
12234
12235 static void
12236 base_breakpoint_print_one_detail (const struct breakpoint *self,
12237                                   struct ui_out *uiout)
12238 {
12239   /* nothing */
12240 }
12241
12242 static void
12243 base_breakpoint_print_mention (struct breakpoint *b)
12244 {
12245   internal_error_pure_virtual_called ();
12246 }
12247
12248 static void
12249 base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12250 {
12251   internal_error_pure_virtual_called ();
12252 }
12253
12254 static void
12255 base_breakpoint_create_sals_from_location
12256   (const struct event_location *location,
12257    struct linespec_result *canonical,
12258    enum bptype type_wanted)
12259 {
12260   internal_error_pure_virtual_called ();
12261 }
12262
12263 static void
12264 base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12265                                         struct linespec_result *c,
12266                                         gdb::unique_xmalloc_ptr<char> cond_string,
12267                                         gdb::unique_xmalloc_ptr<char> extra_string,
12268                                         enum bptype type_wanted,
12269                                         enum bpdisp disposition,
12270                                         int thread,
12271                                         int task, int ignore_count,
12272                                         const struct breakpoint_ops *o,
12273                                         int from_tty, int enabled,
12274                                         int internal, unsigned flags)
12275 {
12276   internal_error_pure_virtual_called ();
12277 }
12278
12279 static std::vector<symtab_and_line>
12280 base_breakpoint_decode_location (struct breakpoint *b,
12281                                  const struct event_location *location,
12282                                  struct program_space *search_pspace)
12283 {
12284   internal_error_pure_virtual_called ();
12285 }
12286
12287 /* The default 'explains_signal' method.  */
12288
12289 static int
12290 base_breakpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
12291 {
12292   return 1;
12293 }
12294
12295 /* The default "after_condition_true" method.  */
12296
12297 static void
12298 base_breakpoint_after_condition_true (struct bpstats *bs)
12299 {
12300   /* Nothing to do.   */
12301 }
12302
12303 struct breakpoint_ops base_breakpoint_ops =
12304 {
12305   base_breakpoint_allocate_location,
12306   base_breakpoint_re_set,
12307   base_breakpoint_insert_location,
12308   base_breakpoint_remove_location,
12309   base_breakpoint_breakpoint_hit,
12310   base_breakpoint_check_status,
12311   base_breakpoint_resources_needed,
12312   base_breakpoint_works_in_software_mode,
12313   base_breakpoint_print_it,
12314   NULL,
12315   base_breakpoint_print_one_detail,
12316   base_breakpoint_print_mention,
12317   base_breakpoint_print_recreate,
12318   base_breakpoint_create_sals_from_location,
12319   base_breakpoint_create_breakpoints_sal,
12320   base_breakpoint_decode_location,
12321   base_breakpoint_explains_signal,
12322   base_breakpoint_after_condition_true,
12323 };
12324
12325 /* Default breakpoint_ops methods.  */
12326
12327 static void
12328 bkpt_re_set (struct breakpoint *b)
12329 {
12330   /* FIXME: is this still reachable?  */
12331   if (breakpoint_event_location_empty_p (b))
12332     {
12333       /* Anything without a location can't be re-set.  */
12334       delete_breakpoint (b);
12335       return;
12336     }
12337
12338   breakpoint_re_set_default (b);
12339 }
12340
12341 static int
12342 bkpt_insert_location (struct bp_location *bl)
12343 {
12344   CORE_ADDR addr = bl->target_info.reqstd_address;
12345
12346   bl->target_info.kind = breakpoint_kind (bl, &addr);
12347   bl->target_info.placed_address = addr;
12348
12349   if (bl->loc_type == bp_loc_hardware_breakpoint)
12350     return target_insert_hw_breakpoint (bl->gdbarch, &bl->target_info);
12351   else
12352     return target_insert_breakpoint (bl->gdbarch, &bl->target_info);
12353 }
12354
12355 static int
12356 bkpt_remove_location (struct bp_location *bl, enum remove_bp_reason reason)
12357 {
12358   if (bl->loc_type == bp_loc_hardware_breakpoint)
12359     return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
12360   else
12361     return target_remove_breakpoint (bl->gdbarch, &bl->target_info, reason);
12362 }
12363
12364 static int
12365 bkpt_breakpoint_hit (const struct bp_location *bl,
12366                      const address_space *aspace, CORE_ADDR bp_addr,
12367                      const struct target_waitstatus *ws)
12368 {
12369   if (ws->kind != TARGET_WAITKIND_STOPPED
12370       || ws->value.sig != GDB_SIGNAL_TRAP)
12371     return 0;
12372
12373   if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
12374                                  aspace, bp_addr))
12375     return 0;
12376
12377   if (overlay_debugging         /* unmapped overlay section */
12378       && section_is_overlay (bl->section)
12379       && !section_is_mapped (bl->section))
12380     return 0;
12381
12382   return 1;
12383 }
12384
12385 static int
12386 dprintf_breakpoint_hit (const struct bp_location *bl,
12387                         const address_space *aspace, CORE_ADDR bp_addr,
12388                         const struct target_waitstatus *ws)
12389 {
12390   if (dprintf_style == dprintf_style_agent
12391       && target_can_run_breakpoint_commands ())
12392     {
12393       /* An agent-style dprintf never causes a stop.  If we see a trap
12394          for this address it must be for a breakpoint that happens to
12395          be set at the same address.  */
12396       return 0;
12397     }
12398
12399   return bkpt_breakpoint_hit (bl, aspace, bp_addr, ws);
12400 }
12401
12402 static int
12403 bkpt_resources_needed (const struct bp_location *bl)
12404 {
12405   gdb_assert (bl->owner->type == bp_hardware_breakpoint);
12406
12407   return 1;
12408 }
12409
12410 static enum print_stop_action
12411 bkpt_print_it (bpstat bs)
12412 {
12413   struct breakpoint *b;
12414   const struct bp_location *bl;
12415   int bp_temp;
12416   struct ui_out *uiout = current_uiout;
12417
12418   gdb_assert (bs->bp_location_at != NULL);
12419
12420   bl = bs->bp_location_at;
12421   b = bs->breakpoint_at;
12422
12423   bp_temp = b->disposition == disp_del;
12424   if (bl->address != bl->requested_address)
12425     breakpoint_adjustment_warning (bl->requested_address,
12426                                    bl->address,
12427                                    b->number, 1);
12428   annotate_breakpoint (b->number);
12429   maybe_print_thread_hit_breakpoint (uiout);
12430
12431   if (bp_temp)
12432     uiout->text ("Temporary breakpoint ");
12433   else
12434     uiout->text ("Breakpoint ");
12435   if (uiout->is_mi_like_p ())
12436     {
12437       uiout->field_string ("reason",
12438                            async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
12439       uiout->field_string ("disp", bpdisp_text (b->disposition));
12440     }
12441   uiout->field_int ("bkptno", b->number);
12442   uiout->text (", ");
12443
12444   return PRINT_SRC_AND_LOC;
12445 }
12446
12447 static void
12448 bkpt_print_mention (struct breakpoint *b)
12449 {
12450   if (current_uiout->is_mi_like_p ())
12451     return;
12452
12453   switch (b->type)
12454     {
12455     case bp_breakpoint:
12456     case bp_gnu_ifunc_resolver:
12457       if (b->disposition == disp_del)
12458         printf_filtered (_("Temporary breakpoint"));
12459       else
12460         printf_filtered (_("Breakpoint"));
12461       printf_filtered (_(" %d"), b->number);
12462       if (b->type == bp_gnu_ifunc_resolver)
12463         printf_filtered (_(" at gnu-indirect-function resolver"));
12464       break;
12465     case bp_hardware_breakpoint:
12466       printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
12467       break;
12468     case bp_dprintf:
12469       printf_filtered (_("Dprintf %d"), b->number);
12470       break;
12471     }
12472
12473   say_where (b);
12474 }
12475
12476 static void
12477 bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
12478 {
12479   if (tp->type == bp_breakpoint && tp->disposition == disp_del)
12480     fprintf_unfiltered (fp, "tbreak");
12481   else if (tp->type == bp_breakpoint)
12482     fprintf_unfiltered (fp, "break");
12483   else if (tp->type == bp_hardware_breakpoint
12484            && tp->disposition == disp_del)
12485     fprintf_unfiltered (fp, "thbreak");
12486   else if (tp->type == bp_hardware_breakpoint)
12487     fprintf_unfiltered (fp, "hbreak");
12488   else
12489     internal_error (__FILE__, __LINE__,
12490                     _("unhandled breakpoint type %d"), (int) tp->type);
12491
12492   fprintf_unfiltered (fp, " %s",
12493                       event_location_to_string (tp->location.get ()));
12494
12495   /* Print out extra_string if this breakpoint is pending.  It might
12496      contain, for example, conditions that were set by the user.  */
12497   if (tp->loc == NULL && tp->extra_string != NULL)
12498     fprintf_unfiltered (fp, " %s", tp->extra_string);
12499
12500   print_recreate_thread (tp, fp);
12501 }
12502
12503 static void
12504 bkpt_create_sals_from_location (const struct event_location *location,
12505                                 struct linespec_result *canonical,
12506                                 enum bptype type_wanted)
12507 {
12508   create_sals_from_location_default (location, canonical, type_wanted);
12509 }
12510
12511 static void
12512 bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
12513                              struct linespec_result *canonical,
12514                              gdb::unique_xmalloc_ptr<char> cond_string,
12515                              gdb::unique_xmalloc_ptr<char> extra_string,
12516                              enum bptype type_wanted,
12517                              enum bpdisp disposition,
12518                              int thread,
12519                              int task, int ignore_count,
12520                              const struct breakpoint_ops *ops,
12521                              int from_tty, int enabled,
12522                              int internal, unsigned flags)
12523 {
12524   create_breakpoints_sal_default (gdbarch, canonical,
12525                                   std::move (cond_string),
12526                                   std::move (extra_string),
12527                                   type_wanted,
12528                                   disposition, thread, task,
12529                                   ignore_count, ops, from_tty,
12530                                   enabled, internal, flags);
12531 }
12532
12533 static std::vector<symtab_and_line>
12534 bkpt_decode_location (struct breakpoint *b,
12535                       const struct event_location *location,
12536                       struct program_space *search_pspace)
12537 {
12538   return decode_location_default (b, location, search_pspace);
12539 }
12540
12541 /* Virtual table for internal breakpoints.  */
12542
12543 static void
12544 internal_bkpt_re_set (struct breakpoint *b)
12545 {
12546   switch (b->type)
12547     {
12548       /* Delete overlay event and longjmp master breakpoints; they
12549          will be reset later by breakpoint_re_set.  */
12550     case bp_overlay_event:
12551     case bp_longjmp_master:
12552     case bp_std_terminate_master:
12553     case bp_exception_master:
12554       delete_breakpoint (b);
12555       break;
12556
12557       /* This breakpoint is special, it's set up when the inferior
12558          starts and we really don't want to touch it.  */
12559     case bp_shlib_event:
12560
12561       /* Like bp_shlib_event, this breakpoint type is special.  Once
12562          it is set up, we do not want to touch it.  */
12563     case bp_thread_event:
12564       break;
12565     }
12566 }
12567
12568 static void
12569 internal_bkpt_check_status (bpstat bs)
12570 {
12571   if (bs->breakpoint_at->type == bp_shlib_event)
12572     {
12573       /* If requested, stop when the dynamic linker notifies GDB of
12574          events.  This allows the user to get control and place
12575          breakpoints in initializer routines for dynamically loaded
12576          objects (among other things).  */
12577       bs->stop = stop_on_solib_events;
12578       bs->print = stop_on_solib_events;
12579     }
12580   else
12581     bs->stop = 0;
12582 }
12583
12584 static enum print_stop_action
12585 internal_bkpt_print_it (bpstat bs)
12586 {
12587   struct breakpoint *b;
12588
12589   b = bs->breakpoint_at;
12590
12591   switch (b->type)
12592     {
12593     case bp_shlib_event:
12594       /* Did we stop because the user set the stop_on_solib_events
12595          variable?  (If so, we report this as a generic, "Stopped due
12596          to shlib event" message.) */
12597       print_solib_event (0);
12598       break;
12599
12600     case bp_thread_event:
12601       /* Not sure how we will get here.
12602          GDB should not stop for these breakpoints.  */
12603       printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12604       break;
12605
12606     case bp_overlay_event:
12607       /* By analogy with the thread event, GDB should not stop for these.  */
12608       printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12609       break;
12610
12611     case bp_longjmp_master:
12612       /* These should never be enabled.  */
12613       printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12614       break;
12615
12616     case bp_std_terminate_master:
12617       /* These should never be enabled.  */
12618       printf_filtered (_("std::terminate Master Breakpoint: "
12619                          "gdb should not stop!\n"));
12620       break;
12621
12622     case bp_exception_master:
12623       /* These should never be enabled.  */
12624       printf_filtered (_("Exception Master Breakpoint: "
12625                          "gdb should not stop!\n"));
12626       break;
12627     }
12628
12629   return PRINT_NOTHING;
12630 }
12631
12632 static void
12633 internal_bkpt_print_mention (struct breakpoint *b)
12634 {
12635   /* Nothing to mention.  These breakpoints are internal.  */
12636 }
12637
12638 /* Virtual table for momentary breakpoints  */
12639
12640 static void
12641 momentary_bkpt_re_set (struct breakpoint *b)
12642 {
12643   /* Keep temporary breakpoints, which can be encountered when we step
12644      over a dlopen call and solib_add is resetting the breakpoints.
12645      Otherwise these should have been blown away via the cleanup chain
12646      or by breakpoint_init_inferior when we rerun the executable.  */
12647 }
12648
12649 static void
12650 momentary_bkpt_check_status (bpstat bs)
12651 {
12652   /* Nothing.  The point of these breakpoints is causing a stop.  */
12653 }
12654
12655 static enum print_stop_action
12656 momentary_bkpt_print_it (bpstat bs)
12657 {
12658   return PRINT_UNKNOWN;
12659 }
12660
12661 static void
12662 momentary_bkpt_print_mention (struct breakpoint *b)
12663 {
12664   /* Nothing to mention.  These breakpoints are internal.  */
12665 }
12666
12667 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12668
12669    It gets cleared already on the removal of the first one of such placed
12670    breakpoints.  This is OK as they get all removed altogether.  */
12671
12672 longjmp_breakpoint::~longjmp_breakpoint ()
12673 {
12674   thread_info *tp = find_thread_global_id (this->thread);
12675
12676   if (tp != NULL)
12677     tp->initiating_frame = null_frame_id;
12678 }
12679
12680 /* Specific methods for probe breakpoints.  */
12681
12682 static int
12683 bkpt_probe_insert_location (struct bp_location *bl)
12684 {
12685   int v = bkpt_insert_location (bl);
12686
12687   if (v == 0)
12688     {
12689       /* The insertion was successful, now let's set the probe's semaphore
12690          if needed.  */
12691       bl->probe.prob->set_semaphore (bl->probe.objfile, bl->gdbarch);
12692     }
12693
12694   return v;
12695 }
12696
12697 static int
12698 bkpt_probe_remove_location (struct bp_location *bl,
12699                             enum remove_bp_reason reason)
12700 {
12701   /* Let's clear the semaphore before removing the location.  */
12702   bl->probe.prob->clear_semaphore (bl->probe.objfile, bl->gdbarch);
12703
12704   return bkpt_remove_location (bl, reason);
12705 }
12706
12707 static void
12708 bkpt_probe_create_sals_from_location (const struct event_location *location,
12709                                       struct linespec_result *canonical,
12710                                       enum bptype type_wanted)
12711 {
12712   struct linespec_sals lsal;
12713
12714   lsal.sals = parse_probes (location, NULL, canonical);
12715   lsal.canonical
12716     = xstrdup (event_location_to_string (canonical->location.get ()));
12717   canonical->lsals.push_back (std::move (lsal));
12718 }
12719
12720 static std::vector<symtab_and_line>
12721 bkpt_probe_decode_location (struct breakpoint *b,
12722                             const struct event_location *location,
12723                             struct program_space *search_pspace)
12724 {
12725   std::vector<symtab_and_line> sals = parse_probes (location, search_pspace, NULL);
12726   if (sals.empty ())
12727     error (_("probe not found"));
12728   return sals;
12729 }
12730
12731 /* The breakpoint_ops structure to be used in tracepoints.  */
12732
12733 static void
12734 tracepoint_re_set (struct breakpoint *b)
12735 {
12736   breakpoint_re_set_default (b);
12737 }
12738
12739 static int
12740 tracepoint_breakpoint_hit (const struct bp_location *bl,
12741                            const address_space *aspace, CORE_ADDR bp_addr,
12742                            const struct target_waitstatus *ws)
12743 {
12744   /* By definition, the inferior does not report stops at
12745      tracepoints.  */
12746   return 0;
12747 }
12748
12749 static void
12750 tracepoint_print_one_detail (const struct breakpoint *self,
12751                              struct ui_out *uiout)
12752 {
12753   struct tracepoint *tp = (struct tracepoint *) self;
12754   if (!tp->static_trace_marker_id.empty ())
12755     {
12756       gdb_assert (self->type == bp_static_tracepoint);
12757
12758       uiout->text ("\tmarker id is ");
12759       uiout->field_string ("static-tracepoint-marker-string-id",
12760                            tp->static_trace_marker_id);
12761       uiout->text ("\n");
12762     }
12763 }
12764
12765 static void
12766 tracepoint_print_mention (struct breakpoint *b)
12767 {
12768   if (current_uiout->is_mi_like_p ())
12769     return;
12770
12771   switch (b->type)
12772     {
12773     case bp_tracepoint:
12774       printf_filtered (_("Tracepoint"));
12775       printf_filtered (_(" %d"), b->number);
12776       break;
12777     case bp_fast_tracepoint:
12778       printf_filtered (_("Fast tracepoint"));
12779       printf_filtered (_(" %d"), b->number);
12780       break;
12781     case bp_static_tracepoint:
12782       printf_filtered (_("Static tracepoint"));
12783       printf_filtered (_(" %d"), b->number);
12784       break;
12785     default:
12786       internal_error (__FILE__, __LINE__,
12787                       _("unhandled tracepoint type %d"), (int) b->type);
12788     }
12789
12790   say_where (b);
12791 }
12792
12793 static void
12794 tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
12795 {
12796   struct tracepoint *tp = (struct tracepoint *) self;
12797
12798   if (self->type == bp_fast_tracepoint)
12799     fprintf_unfiltered (fp, "ftrace");
12800   else if (self->type == bp_static_tracepoint)
12801     fprintf_unfiltered (fp, "strace");
12802   else if (self->type == bp_tracepoint)
12803     fprintf_unfiltered (fp, "trace");
12804   else
12805     internal_error (__FILE__, __LINE__,
12806                     _("unhandled tracepoint type %d"), (int) self->type);
12807
12808   fprintf_unfiltered (fp, " %s",
12809                       event_location_to_string (self->location.get ()));
12810   print_recreate_thread (self, fp);
12811
12812   if (tp->pass_count)
12813     fprintf_unfiltered (fp, "  passcount %d\n", tp->pass_count);
12814 }
12815
12816 static void
12817 tracepoint_create_sals_from_location (const struct event_location *location,
12818                                       struct linespec_result *canonical,
12819                                       enum bptype type_wanted)
12820 {
12821   create_sals_from_location_default (location, canonical, type_wanted);
12822 }
12823
12824 static void
12825 tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12826                                    struct linespec_result *canonical,
12827                                    gdb::unique_xmalloc_ptr<char> cond_string,
12828                                    gdb::unique_xmalloc_ptr<char> extra_string,
12829                                    enum bptype type_wanted,
12830                                    enum bpdisp disposition,
12831                                    int thread,
12832                                    int task, int ignore_count,
12833                                    const struct breakpoint_ops *ops,
12834                                    int from_tty, int enabled,
12835                                    int internal, unsigned flags)
12836 {
12837   create_breakpoints_sal_default (gdbarch, canonical,
12838                                   std::move (cond_string),
12839                                   std::move (extra_string),
12840                                   type_wanted,
12841                                   disposition, thread, task,
12842                                   ignore_count, ops, from_tty,
12843                                   enabled, internal, flags);
12844 }
12845
12846 static std::vector<symtab_and_line>
12847 tracepoint_decode_location (struct breakpoint *b,
12848                             const struct event_location *location,
12849                             struct program_space *search_pspace)
12850 {
12851   return decode_location_default (b, location, search_pspace);
12852 }
12853
12854 struct breakpoint_ops tracepoint_breakpoint_ops;
12855
12856 /* The breakpoint_ops structure to be use on tracepoints placed in a
12857    static probe.  */
12858
12859 static void
12860 tracepoint_probe_create_sals_from_location
12861   (const struct event_location *location,
12862    struct linespec_result *canonical,
12863    enum bptype type_wanted)
12864 {
12865   /* We use the same method for breakpoint on probes.  */
12866   bkpt_probe_create_sals_from_location (location, canonical, type_wanted);
12867 }
12868
12869 static std::vector<symtab_and_line>
12870 tracepoint_probe_decode_location (struct breakpoint *b,
12871                                   const struct event_location *location,
12872                                   struct program_space *search_pspace)
12873 {
12874   /* We use the same method for breakpoint on probes.  */
12875   return bkpt_probe_decode_location (b, location, search_pspace);
12876 }
12877
12878 static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
12879
12880 /* Dprintf breakpoint_ops methods.  */
12881
12882 static void
12883 dprintf_re_set (struct breakpoint *b)
12884 {
12885   breakpoint_re_set_default (b);
12886
12887   /* extra_string should never be non-NULL for dprintf.  */
12888   gdb_assert (b->extra_string != NULL);
12889
12890   /* 1 - connect to target 1, that can run breakpoint commands.
12891      2 - create a dprintf, which resolves fine.
12892      3 - disconnect from target 1
12893      4 - connect to target 2, that can NOT run breakpoint commands.
12894
12895      After steps #3/#4, you'll want the dprintf command list to
12896      be updated, because target 1 and 2 may well return different
12897      answers for target_can_run_breakpoint_commands().
12898      Given absence of finer grained resetting, we get to do
12899      it all the time.  */
12900   if (b->extra_string != NULL)
12901     update_dprintf_command_list (b);
12902 }
12903
12904 /* Implement the "print_recreate" breakpoint_ops method for dprintf.  */
12905
12906 static void
12907 dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp)
12908 {
12909   fprintf_unfiltered (fp, "dprintf %s,%s",
12910                       event_location_to_string (tp->location.get ()),
12911                       tp->extra_string);
12912   print_recreate_thread (tp, fp);
12913 }
12914
12915 /* Implement the "after_condition_true" breakpoint_ops method for
12916    dprintf.
12917
12918    dprintf's are implemented with regular commands in their command
12919    list, but we run the commands here instead of before presenting the
12920    stop to the user, as dprintf's don't actually cause a stop.  This
12921    also makes it so that the commands of multiple dprintfs at the same
12922    address are all handled.  */
12923
12924 static void
12925 dprintf_after_condition_true (struct bpstats *bs)
12926 {
12927   struct bpstats tmp_bs;
12928   struct bpstats *tmp_bs_p = &tmp_bs;
12929
12930   /* dprintf's never cause a stop.  This wasn't set in the
12931      check_status hook instead because that would make the dprintf's
12932      condition not be evaluated.  */
12933   bs->stop = 0;
12934
12935   /* Run the command list here.  Take ownership of it instead of
12936      copying.  We never want these commands to run later in
12937      bpstat_do_actions, if a breakpoint that causes a stop happens to
12938      be set at same address as this dprintf, or even if running the
12939      commands here throws.  */
12940   tmp_bs.commands = bs->commands;
12941   bs->commands = NULL;
12942
12943   bpstat_do_actions_1 (&tmp_bs_p);
12944
12945   /* 'tmp_bs.commands' will usually be NULL by now, but
12946      bpstat_do_actions_1 may return early without processing the whole
12947      list.  */
12948 }
12949
12950 /* The breakpoint_ops structure to be used on static tracepoints with
12951    markers (`-m').  */
12952
12953 static void
12954 strace_marker_create_sals_from_location (const struct event_location *location,
12955                                          struct linespec_result *canonical,
12956                                          enum bptype type_wanted)
12957 {
12958   struct linespec_sals lsal;
12959   const char *arg_start, *arg;
12960
12961   arg = arg_start = get_linespec_location (location)->spec_string;
12962   lsal.sals = decode_static_tracepoint_spec (&arg);
12963
12964   std::string str (arg_start, arg - arg_start);
12965   const char *ptr = str.c_str ();
12966   canonical->location
12967     = new_linespec_location (&ptr, symbol_name_match_type::FULL);
12968
12969   lsal.canonical
12970     = xstrdup (event_location_to_string (canonical->location.get ()));
12971   canonical->lsals.push_back (std::move (lsal));
12972 }
12973
12974 static void
12975 strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
12976                                       struct linespec_result *canonical,
12977                                       gdb::unique_xmalloc_ptr<char> cond_string,
12978                                       gdb::unique_xmalloc_ptr<char> extra_string,
12979                                       enum bptype type_wanted,
12980                                       enum bpdisp disposition,
12981                                       int thread,
12982                                       int task, int ignore_count,
12983                                       const struct breakpoint_ops *ops,
12984                                       int from_tty, int enabled,
12985                                       int internal, unsigned flags)
12986 {
12987   const linespec_sals &lsal = canonical->lsals[0];
12988
12989   /* If the user is creating a static tracepoint by marker id
12990      (strace -m MARKER_ID), then store the sals index, so that
12991      breakpoint_re_set can try to match up which of the newly
12992      found markers corresponds to this one, and, don't try to
12993      expand multiple locations for each sal, given than SALS
12994      already should contain all sals for MARKER_ID.  */
12995
12996   for (size_t i = 0; i < lsal.sals.size (); i++)
12997     {
12998       event_location_up location
12999         = copy_event_location (canonical->location.get ());
13000
13001       std::unique_ptr<tracepoint> tp (new tracepoint ());
13002       init_breakpoint_sal (tp.get (), gdbarch, lsal.sals[i],
13003                            std::move (location), NULL,
13004                            std::move (cond_string),
13005                            std::move (extra_string),
13006                            type_wanted, disposition,
13007                            thread, task, ignore_count, ops,
13008                            from_tty, enabled, internal, flags,
13009                            canonical->special_display);
13010       /* Given that its possible to have multiple markers with
13011          the same string id, if the user is creating a static
13012          tracepoint by marker id ("strace -m MARKER_ID"), then
13013          store the sals index, so that breakpoint_re_set can
13014          try to match up which of the newly found markers
13015          corresponds to this one  */
13016       tp->static_trace_marker_id_idx = i;
13017
13018       install_breakpoint (internal, std::move (tp), 0);
13019     }
13020 }
13021
13022 static std::vector<symtab_and_line>
13023 strace_marker_decode_location (struct breakpoint *b,
13024                                const struct event_location *location,
13025                                struct program_space *search_pspace)
13026 {
13027   struct tracepoint *tp = (struct tracepoint *) b;
13028   const char *s = get_linespec_location (location)->spec_string;
13029
13030   std::vector<symtab_and_line> sals = decode_static_tracepoint_spec (&s);
13031   if (sals.size () > tp->static_trace_marker_id_idx)
13032     {
13033       sals[0] = sals[tp->static_trace_marker_id_idx];
13034       sals.resize (1);
13035       return sals;
13036     }
13037   else
13038     error (_("marker %s not found"), tp->static_trace_marker_id.c_str ());
13039 }
13040
13041 static struct breakpoint_ops strace_marker_breakpoint_ops;
13042
13043 static int
13044 strace_marker_p (struct breakpoint *b)
13045 {
13046   return b->ops == &strace_marker_breakpoint_ops;
13047 }
13048
13049 /* Delete a breakpoint and clean up all traces of it in the data
13050    structures.  */
13051
13052 void
13053 delete_breakpoint (struct breakpoint *bpt)
13054 {
13055   struct breakpoint *b;
13056
13057   gdb_assert (bpt != NULL);
13058
13059   /* Has this bp already been deleted?  This can happen because
13060      multiple lists can hold pointers to bp's.  bpstat lists are
13061      especial culprits.
13062
13063      One example of this happening is a watchpoint's scope bp.  When
13064      the scope bp triggers, we notice that the watchpoint is out of
13065      scope, and delete it.  We also delete its scope bp.  But the
13066      scope bp is marked "auto-deleting", and is already on a bpstat.
13067      That bpstat is then checked for auto-deleting bp's, which are
13068      deleted.
13069
13070      A real solution to this problem might involve reference counts in
13071      bp's, and/or giving them pointers back to their referencing
13072      bpstat's, and teaching delete_breakpoint to only free a bp's
13073      storage when no more references were extent.  A cheaper bandaid
13074      was chosen.  */
13075   if (bpt->type == bp_none)
13076     return;
13077
13078   /* At least avoid this stale reference until the reference counting
13079      of breakpoints gets resolved.  */
13080   if (bpt->related_breakpoint != bpt)
13081     {
13082       struct breakpoint *related;
13083       struct watchpoint *w;
13084
13085       if (bpt->type == bp_watchpoint_scope)
13086         w = (struct watchpoint *) bpt->related_breakpoint;
13087       else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
13088         w = (struct watchpoint *) bpt;
13089       else
13090         w = NULL;
13091       if (w != NULL)
13092         watchpoint_del_at_next_stop (w);
13093
13094       /* Unlink bpt from the bpt->related_breakpoint ring.  */
13095       for (related = bpt; related->related_breakpoint != bpt;
13096            related = related->related_breakpoint);
13097       related->related_breakpoint = bpt->related_breakpoint;
13098       bpt->related_breakpoint = bpt;
13099     }
13100
13101   /* watch_command_1 creates a watchpoint but only sets its number if
13102      update_watchpoint succeeds in creating its bp_locations.  If there's
13103      a problem in that process, we'll be asked to delete the half-created
13104      watchpoint.  In that case, don't announce the deletion.  */
13105   if (bpt->number)
13106     gdb::observers::breakpoint_deleted.notify (bpt);
13107
13108   if (breakpoint_chain == bpt)
13109     breakpoint_chain = bpt->next;
13110
13111   ALL_BREAKPOINTS (b)
13112     if (b->next == bpt)
13113     {
13114       b->next = bpt->next;
13115       break;
13116     }
13117
13118   /* Be sure no bpstat's are pointing at the breakpoint after it's
13119      been freed.  */
13120   /* FIXME, how can we find all bpstat's?  We just check stop_bpstat
13121      in all threads for now.  Note that we cannot just remove bpstats
13122      pointing at bpt from the stop_bpstat list entirely, as breakpoint
13123      commands are associated with the bpstat; if we remove it here,
13124      then the later call to bpstat_do_actions (&stop_bpstat); in
13125      event-top.c won't do anything, and temporary breakpoints with
13126      commands won't work.  */
13127
13128   iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13129
13130   /* Now that breakpoint is removed from breakpoint list, update the
13131      global location list.  This will remove locations that used to
13132      belong to this breakpoint.  Do this before freeing the breakpoint
13133      itself, since remove_breakpoint looks at location's owner.  It
13134      might be better design to have location completely
13135      self-contained, but it's not the case now.  */
13136   update_global_location_list (UGLL_DONT_INSERT);
13137
13138   /* On the chance that someone will soon try again to delete this
13139      same bp, we mark it as deleted before freeing its storage.  */
13140   bpt->type = bp_none;
13141   delete bpt;
13142 }
13143
13144 /* Iterator function to call a user-provided callback function once
13145    for each of B and its related breakpoints.  */
13146
13147 static void
13148 iterate_over_related_breakpoints (struct breakpoint *b,
13149                                   gdb::function_view<void (breakpoint *)> function)
13150 {
13151   struct breakpoint *related;
13152
13153   related = b;
13154   do
13155     {
13156       struct breakpoint *next;
13157
13158       /* FUNCTION may delete RELATED.  */
13159       next = related->related_breakpoint;
13160
13161       if (next == related)
13162         {
13163           /* RELATED is the last ring entry.  */
13164           function (related);
13165
13166           /* FUNCTION may have deleted it, so we'd never reach back to
13167              B.  There's nothing left to do anyway, so just break
13168              out.  */
13169           break;
13170         }
13171       else
13172         function (related);
13173
13174       related = next;
13175     }
13176   while (related != b);
13177 }
13178
13179 static void
13180 delete_command (const char *arg, int from_tty)
13181 {
13182   struct breakpoint *b, *b_tmp;
13183
13184   dont_repeat ();
13185
13186   if (arg == 0)
13187     {
13188       int breaks_to_delete = 0;
13189
13190       /* Delete all breakpoints if no argument.  Do not delete
13191          internal breakpoints, these have to be deleted with an
13192          explicit breakpoint number argument.  */
13193       ALL_BREAKPOINTS (b)
13194         if (user_breakpoint_p (b))
13195           {
13196             breaks_to_delete = 1;
13197             break;
13198           }
13199
13200       /* Ask user only if there are some breakpoints to delete.  */
13201       if (!from_tty
13202           || (breaks_to_delete && query (_("Delete all breakpoints? "))))
13203         {
13204           ALL_BREAKPOINTS_SAFE (b, b_tmp)
13205             if (user_breakpoint_p (b))
13206               delete_breakpoint (b);
13207         }
13208     }
13209   else
13210     map_breakpoint_numbers
13211       (arg, [&] (breakpoint *br)
13212        {
13213          iterate_over_related_breakpoints (br, delete_breakpoint);
13214        });
13215 }
13216
13217 /* Return true if all locations of B bound to PSPACE are pending.  If
13218    PSPACE is NULL, all locations of all program spaces are
13219    considered.  */
13220
13221 static int
13222 all_locations_are_pending (struct breakpoint *b, struct program_space *pspace)
13223 {
13224   struct bp_location *loc;
13225
13226   for (loc = b->loc; loc != NULL; loc = loc->next)
13227     if ((pspace == NULL
13228          || loc->pspace == pspace)
13229         && !loc->shlib_disabled
13230         && !loc->pspace->executing_startup)
13231       return 0;
13232   return 1;
13233 }
13234
13235 /* Subroutine of update_breakpoint_locations to simplify it.
13236    Return non-zero if multiple fns in list LOC have the same name.
13237    Null names are ignored.  */
13238
13239 static int
13240 ambiguous_names_p (struct bp_location *loc)
13241 {
13242   struct bp_location *l;
13243   htab_t htab = htab_create_alloc (13, htab_hash_string, streq_hash, NULL,
13244                                    xcalloc, xfree);
13245
13246   for (l = loc; l != NULL; l = l->next)
13247     {
13248       const char **slot;
13249       const char *name = l->function_name;
13250
13251       /* Allow for some names to be NULL, ignore them.  */
13252       if (name == NULL)
13253         continue;
13254
13255       slot = (const char **) htab_find_slot (htab, (const void *) name,
13256                                              INSERT);
13257       /* NOTE: We can assume slot != NULL here because xcalloc never
13258          returns NULL.  */
13259       if (*slot != NULL)
13260         {
13261           htab_delete (htab);
13262           return 1;
13263         }
13264       *slot = name;
13265     }
13266
13267   htab_delete (htab);
13268   return 0;
13269 }
13270
13271 /* When symbols change, it probably means the sources changed as well,
13272    and it might mean the static tracepoint markers are no longer at
13273    the same address or line numbers they used to be at last we
13274    checked.  Losing your static tracepoints whenever you rebuild is
13275    undesirable.  This function tries to resync/rematch gdb static
13276    tracepoints with the markers on the target, for static tracepoints
13277    that have not been set by marker id.  Static tracepoint that have
13278    been set by marker id are reset by marker id in breakpoint_re_set.
13279    The heuristic is:
13280
13281    1) For a tracepoint set at a specific address, look for a marker at
13282    the old PC.  If one is found there, assume to be the same marker.
13283    If the name / string id of the marker found is different from the
13284    previous known name, assume that means the user renamed the marker
13285    in the sources, and output a warning.
13286
13287    2) For a tracepoint set at a given line number, look for a marker
13288    at the new address of the old line number.  If one is found there,
13289    assume to be the same marker.  If the name / string id of the
13290    marker found is different from the previous known name, assume that
13291    means the user renamed the marker in the sources, and output a
13292    warning.
13293
13294    3) If a marker is no longer found at the same address or line, it
13295    may mean the marker no longer exists.  But it may also just mean
13296    the code changed a bit.  Maybe the user added a few lines of code
13297    that made the marker move up or down (in line number terms).  Ask
13298    the target for info about the marker with the string id as we knew
13299    it.  If found, update line number and address in the matching
13300    static tracepoint.  This will get confused if there's more than one
13301    marker with the same ID (possible in UST, although unadvised
13302    precisely because it confuses tools).  */
13303
13304 static struct symtab_and_line
13305 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
13306 {
13307   struct tracepoint *tp = (struct tracepoint *) b;
13308   struct static_tracepoint_marker marker;
13309   CORE_ADDR pc;
13310
13311   pc = sal.pc;
13312   if (sal.line)
13313     find_line_pc (sal.symtab, sal.line, &pc);
13314
13315   if (target_static_tracepoint_marker_at (pc, &marker))
13316     {
13317       if (tp->static_trace_marker_id != marker.str_id)
13318         warning (_("static tracepoint %d changed probed marker from %s to %s"),
13319                  b->number, tp->static_trace_marker_id.c_str (),
13320                  marker.str_id.c_str ());
13321
13322       tp->static_trace_marker_id = std::move (marker.str_id);
13323
13324       return sal;
13325     }
13326
13327   /* Old marker wasn't found on target at lineno.  Try looking it up
13328      by string ID.  */
13329   if (!sal.explicit_pc
13330       && sal.line != 0
13331       && sal.symtab != NULL
13332       && !tp->static_trace_marker_id.empty ())
13333     {
13334       std::vector<static_tracepoint_marker> markers
13335         = target_static_tracepoint_markers_by_strid
13336             (tp->static_trace_marker_id.c_str ());
13337
13338       if (!markers.empty ())
13339         {
13340           struct symbol *sym;
13341           struct static_tracepoint_marker *tpmarker;
13342           struct ui_out *uiout = current_uiout;
13343           struct explicit_location explicit_loc;
13344
13345           tpmarker = &markers[0];
13346
13347           tp->static_trace_marker_id = std::move (tpmarker->str_id);
13348
13349           warning (_("marker for static tracepoint %d (%s) not "
13350                      "found at previous line number"),
13351                    b->number, tp->static_trace_marker_id.c_str ());
13352
13353           symtab_and_line sal2 = find_pc_line (tpmarker->address, 0);
13354           sym = find_pc_sect_function (tpmarker->address, NULL);
13355           uiout->text ("Now in ");
13356           if (sym)
13357             {
13358               uiout->field_string ("func", SYMBOL_PRINT_NAME (sym),
13359                                    ui_out_style_kind::FUNCTION);
13360               uiout->text (" at ");
13361             }
13362           uiout->field_string ("file",
13363                                symtab_to_filename_for_display (sal2.symtab),
13364                                ui_out_style_kind::FILE);
13365           uiout->text (":");
13366
13367           if (uiout->is_mi_like_p ())
13368             {
13369               const char *fullname = symtab_to_fullname (sal2.symtab);
13370
13371               uiout->field_string ("fullname", fullname);
13372             }
13373
13374           uiout->field_int ("line", sal2.line);
13375           uiout->text ("\n");
13376
13377           b->loc->line_number = sal2.line;
13378           b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
13379
13380           b->location.reset (NULL);
13381           initialize_explicit_location (&explicit_loc);
13382           explicit_loc.source_filename
13383             = ASTRDUP (symtab_to_filename_for_display (sal2.symtab));
13384           explicit_loc.line_offset.offset = b->loc->line_number;
13385           explicit_loc.line_offset.sign = LINE_OFFSET_NONE;
13386           b->location = new_explicit_location (&explicit_loc);
13387
13388           /* Might be nice to check if function changed, and warn if
13389              so.  */
13390         }
13391     }
13392   return sal;
13393 }
13394
13395 /* Returns 1 iff locations A and B are sufficiently same that
13396    we don't need to report breakpoint as changed.  */
13397
13398 static int
13399 locations_are_equal (struct bp_location *a, struct bp_location *b)
13400 {
13401   while (a && b)
13402     {
13403       if (a->address != b->address)
13404         return 0;
13405
13406       if (a->shlib_disabled != b->shlib_disabled)
13407         return 0;
13408
13409       if (a->enabled != b->enabled)
13410         return 0;
13411
13412       a = a->next;
13413       b = b->next;
13414     }
13415
13416   if ((a == NULL) != (b == NULL))
13417     return 0;
13418
13419   return 1;
13420 }
13421
13422 /* Split all locations of B that are bound to PSPACE out of B's
13423    location list to a separate list and return that list's head.  If
13424    PSPACE is NULL, hoist out all locations of B.  */
13425
13426 static struct bp_location *
13427 hoist_existing_locations (struct breakpoint *b, struct program_space *pspace)
13428 {
13429   struct bp_location head;
13430   struct bp_location *i = b->loc;
13431   struct bp_location **i_link = &b->loc;
13432   struct bp_location *hoisted = &head;
13433
13434   if (pspace == NULL)
13435     {
13436       i = b->loc;
13437       b->loc = NULL;
13438       return i;
13439     }
13440
13441   head.next = NULL;
13442
13443   while (i != NULL)
13444     {
13445       if (i->pspace == pspace)
13446         {
13447           *i_link = i->next;
13448           i->next = NULL;
13449           hoisted->next = i;
13450           hoisted = i;
13451         }
13452       else
13453         i_link = &i->next;
13454       i = *i_link;
13455     }
13456
13457   return head.next;
13458 }
13459
13460 /* Create new breakpoint locations for B (a hardware or software
13461    breakpoint) based on SALS and SALS_END.  If SALS_END.NELTS is not
13462    zero, then B is a ranged breakpoint.  Only recreates locations for
13463    FILTER_PSPACE.  Locations of other program spaces are left
13464    untouched.  */
13465
13466 void
13467 update_breakpoint_locations (struct breakpoint *b,
13468                              struct program_space *filter_pspace,
13469                              gdb::array_view<const symtab_and_line> sals,
13470                              gdb::array_view<const symtab_and_line> sals_end)
13471 {
13472   struct bp_location *existing_locations;
13473
13474   if (!sals_end.empty () && (sals.size () != 1 || sals_end.size () != 1))
13475     {
13476       /* Ranged breakpoints have only one start location and one end
13477          location.  */
13478       b->enable_state = bp_disabled;
13479       printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13480                            "multiple locations found\n"),
13481                          b->number);
13482       return;
13483     }
13484
13485   /* If there's no new locations, and all existing locations are
13486      pending, don't do anything.  This optimizes the common case where
13487      all locations are in the same shared library, that was unloaded.
13488      We'd like to retain the location, so that when the library is
13489      loaded again, we don't loose the enabled/disabled status of the
13490      individual locations.  */
13491   if (all_locations_are_pending (b, filter_pspace) && sals.empty ())
13492     return;
13493
13494   existing_locations = hoist_existing_locations (b, filter_pspace);
13495
13496   for (const auto &sal : sals)
13497     {
13498       struct bp_location *new_loc;
13499
13500       switch_to_program_space_and_thread (sal.pspace);
13501
13502       new_loc = add_location_to_breakpoint (b, &sal);
13503
13504       /* Reparse conditions, they might contain references to the
13505          old symtab.  */
13506       if (b->cond_string != NULL)
13507         {
13508           const char *s;
13509
13510           s = b->cond_string;
13511           try
13512             {
13513               new_loc->cond = parse_exp_1 (&s, sal.pc,
13514                                            block_for_pc (sal.pc),
13515                                            0);
13516             }
13517           catch (const gdb_exception_error &e)
13518             {
13519               warning (_("failed to reevaluate condition "
13520                          "for breakpoint %d: %s"), 
13521                        b->number, e.what ());
13522               new_loc->enabled = 0;
13523             }
13524         }
13525
13526       if (!sals_end.empty ())
13527         {
13528           CORE_ADDR end = find_breakpoint_range_end (sals_end[0]);
13529
13530           new_loc->length = end - sals[0].pc + 1;
13531         }
13532     }
13533
13534   /* If possible, carry over 'disable' status from existing
13535      breakpoints.  */
13536   {
13537     struct bp_location *e = existing_locations;
13538     /* If there are multiple breakpoints with the same function name,
13539        e.g. for inline functions, comparing function names won't work.
13540        Instead compare pc addresses; this is just a heuristic as things
13541        may have moved, but in practice it gives the correct answer
13542        often enough until a better solution is found.  */
13543     int have_ambiguous_names = ambiguous_names_p (b->loc);
13544
13545     for (; e; e = e->next)
13546       {
13547         if (!e->enabled && e->function_name)
13548           {
13549             struct bp_location *l = b->loc;
13550             if (have_ambiguous_names)
13551               {
13552                 for (; l; l = l->next)
13553                   if (breakpoint_locations_match (e, l))
13554                     {
13555                       l->enabled = 0;
13556                       break;
13557                     }
13558               }
13559             else
13560               {
13561                 for (; l; l = l->next)
13562                   if (l->function_name
13563                       && strcmp (e->function_name, l->function_name) == 0)
13564                     {
13565                       l->enabled = 0;
13566                       break;
13567                     }
13568               }
13569           }
13570       }
13571   }
13572
13573   if (!locations_are_equal (existing_locations, b->loc))
13574     gdb::observers::breakpoint_modified.notify (b);
13575 }
13576
13577 /* Find the SaL locations corresponding to the given LOCATION.
13578    On return, FOUND will be 1 if any SaL was found, zero otherwise.  */
13579
13580 static std::vector<symtab_and_line>
13581 location_to_sals (struct breakpoint *b, struct event_location *location,
13582                   struct program_space *search_pspace, int *found)
13583 {
13584   struct gdb_exception exception;
13585
13586   gdb_assert (b->ops != NULL);
13587
13588   std::vector<symtab_and_line> sals;
13589
13590   try
13591     {
13592       sals = b->ops->decode_location (b, location, search_pspace);
13593     }
13594   catch (gdb_exception_error &e)
13595     {
13596       int not_found_and_ok = 0;
13597
13598       /* For pending breakpoints, it's expected that parsing will
13599          fail until the right shared library is loaded.  User has
13600          already told to create pending breakpoints and don't need
13601          extra messages.  If breakpoint is in bp_shlib_disabled
13602          state, then user already saw the message about that
13603          breakpoint being disabled, and don't want to see more
13604          errors.  */
13605       if (e.error == NOT_FOUND_ERROR
13606           && (b->condition_not_parsed
13607               || (b->loc != NULL
13608                   && search_pspace != NULL
13609                   && b->loc->pspace != search_pspace)
13610               || (b->loc && b->loc->shlib_disabled)
13611               || (b->loc && b->loc->pspace->executing_startup)
13612               || b->enable_state == bp_disabled))
13613         not_found_and_ok = 1;
13614
13615       if (!not_found_and_ok)
13616         {
13617           /* We surely don't want to warn about the same breakpoint
13618              10 times.  One solution, implemented here, is disable
13619              the breakpoint on error.  Another solution would be to
13620              have separate 'warning emitted' flag.  Since this
13621              happens only when a binary has changed, I don't know
13622              which approach is better.  */
13623           b->enable_state = bp_disabled;
13624           throw;
13625         }
13626
13627       exception = std::move (e);
13628     }
13629
13630   if (exception.reason == 0 || exception.error != NOT_FOUND_ERROR)
13631     {
13632       for (auto &sal : sals)
13633         resolve_sal_pc (&sal);
13634       if (b->condition_not_parsed && b->extra_string != NULL)
13635         {
13636           char *cond_string, *extra_string;
13637           int thread, task;
13638
13639           find_condition_and_thread (b->extra_string, sals[0].pc,
13640                                      &cond_string, &thread, &task,
13641                                      &extra_string);
13642           gdb_assert (b->cond_string == NULL);
13643           if (cond_string)
13644             b->cond_string = cond_string;
13645           b->thread = thread;
13646           b->task = task;
13647           if (extra_string)
13648             {
13649               xfree (b->extra_string);
13650               b->extra_string = extra_string;
13651             }
13652           b->condition_not_parsed = 0;
13653         }
13654
13655       if (b->type == bp_static_tracepoint && !strace_marker_p (b))
13656         sals[0] = update_static_tracepoint (b, sals[0]);
13657
13658       *found = 1;
13659     }
13660   else
13661     *found = 0;
13662
13663   return sals;
13664 }
13665
13666 /* The default re_set method, for typical hardware or software
13667    breakpoints.  Reevaluate the breakpoint and recreate its
13668    locations.  */
13669
13670 static void
13671 breakpoint_re_set_default (struct breakpoint *b)
13672 {
13673   struct program_space *filter_pspace = current_program_space;
13674   std::vector<symtab_and_line> expanded, expanded_end;
13675
13676   int found;
13677   std::vector<symtab_and_line> sals = location_to_sals (b, b->location.get (),
13678                                                         filter_pspace, &found);
13679   if (found)
13680     expanded = std::move (sals);
13681
13682   if (b->location_range_end != NULL)
13683     {
13684       std::vector<symtab_and_line> sals_end
13685         = location_to_sals (b, b->location_range_end.get (),
13686                             filter_pspace, &found);
13687       if (found)
13688         expanded_end = std::move (sals_end);
13689     }
13690
13691   update_breakpoint_locations (b, filter_pspace, expanded, expanded_end);
13692 }
13693
13694 /* Default method for creating SALs from an address string.  It basically
13695    calls parse_breakpoint_sals.  Return 1 for success, zero for failure.  */
13696
13697 static void
13698 create_sals_from_location_default (const struct event_location *location,
13699                                    struct linespec_result *canonical,
13700                                    enum bptype type_wanted)
13701 {
13702   parse_breakpoint_sals (location, canonical);
13703 }
13704
13705 /* Call create_breakpoints_sal for the given arguments.  This is the default
13706    function for the `create_breakpoints_sal' method of
13707    breakpoint_ops.  */
13708
13709 static void
13710 create_breakpoints_sal_default (struct gdbarch *gdbarch,
13711                                 struct linespec_result *canonical,
13712                                 gdb::unique_xmalloc_ptr<char> cond_string,
13713                                 gdb::unique_xmalloc_ptr<char> extra_string,
13714                                 enum bptype type_wanted,
13715                                 enum bpdisp disposition,
13716                                 int thread,
13717                                 int task, int ignore_count,
13718                                 const struct breakpoint_ops *ops,
13719                                 int from_tty, int enabled,
13720                                 int internal, unsigned flags)
13721 {
13722   create_breakpoints_sal (gdbarch, canonical,
13723                           std::move (cond_string),
13724                           std::move (extra_string),
13725                           type_wanted, disposition,
13726                           thread, task, ignore_count, ops, from_tty,
13727                           enabled, internal, flags);
13728 }
13729
13730 /* Decode the line represented by S by calling decode_line_full.  This is the
13731    default function for the `decode_location' method of breakpoint_ops.  */
13732
13733 static std::vector<symtab_and_line>
13734 decode_location_default (struct breakpoint *b,
13735                          const struct event_location *location,
13736                          struct program_space *search_pspace)
13737 {
13738   struct linespec_result canonical;
13739
13740   decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, search_pspace,
13741                     (struct symtab *) NULL, 0,
13742                     &canonical, multiple_symbols_all,
13743                     b->filter);
13744
13745   /* We should get 0 or 1 resulting SALs.  */
13746   gdb_assert (canonical.lsals.size () < 2);
13747
13748   if (!canonical.lsals.empty ())
13749     {
13750       const linespec_sals &lsal = canonical.lsals[0];
13751       return std::move (lsal.sals);
13752     }
13753   return {};
13754 }
13755
13756 /* Reset a breakpoint.  */
13757
13758 static void
13759 breakpoint_re_set_one (breakpoint *b)
13760 {
13761   input_radix = b->input_radix;
13762   set_language (b->language);
13763
13764   b->ops->re_set (b);
13765 }
13766
13767 /* Re-set breakpoint locations for the current program space.
13768    Locations bound to other program spaces are left untouched.  */
13769
13770 void
13771 breakpoint_re_set (void)
13772 {
13773   struct breakpoint *b, *b_tmp;
13774
13775   {
13776     scoped_restore_current_language save_language;
13777     scoped_restore save_input_radix = make_scoped_restore (&input_radix);
13778     scoped_restore_current_pspace_and_thread restore_pspace_thread;
13779
13780     /* breakpoint_re_set_one sets the current_language to the language
13781        of the breakpoint it is resetting (see prepare_re_set_context)
13782        before re-evaluating the breakpoint's location.  This change can
13783        unfortunately get undone by accident if the language_mode is set
13784        to auto, and we either switch frames, or more likely in this context,
13785        we select the current frame.
13786
13787        We prevent this by temporarily turning the language_mode to
13788        language_mode_manual.  We restore it once all breakpoints
13789        have been reset.  */
13790     scoped_restore save_language_mode = make_scoped_restore (&language_mode);
13791     language_mode = language_mode_manual;
13792
13793     /* Note: we must not try to insert locations until after all
13794        breakpoints have been re-set.  Otherwise, e.g., when re-setting
13795        breakpoint 1, we'd insert the locations of breakpoint 2, which
13796        hadn't been re-set yet, and thus may have stale locations.  */
13797
13798     ALL_BREAKPOINTS_SAFE (b, b_tmp)
13799       {
13800         try
13801           {
13802             breakpoint_re_set_one (b);
13803           }
13804         catch (const gdb_exception &ex)
13805           {
13806             exception_fprintf (gdb_stderr, ex,
13807                                "Error in re-setting breakpoint %d: ",
13808                                b->number);
13809           }
13810       }
13811
13812     jit_breakpoint_re_set ();
13813   }
13814
13815   create_overlay_event_breakpoint ();
13816   create_longjmp_master_breakpoint ();
13817   create_std_terminate_master_breakpoint ();
13818   create_exception_master_breakpoint ();
13819
13820   /* Now we can insert.  */
13821   update_global_location_list (UGLL_MAY_INSERT);
13822 }
13823 \f
13824 /* Reset the thread number of this breakpoint:
13825
13826    - If the breakpoint is for all threads, leave it as-is.
13827    - Else, reset it to the current thread for inferior_ptid.  */
13828 void
13829 breakpoint_re_set_thread (struct breakpoint *b)
13830 {
13831   if (b->thread != -1)
13832     {
13833       b->thread = inferior_thread ()->global_num;
13834
13835       /* We're being called after following a fork.  The new fork is
13836          selected as current, and unless this was a vfork will have a
13837          different program space from the original thread.  Reset that
13838          as well.  */
13839       b->loc->pspace = current_program_space;
13840     }
13841 }
13842
13843 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13844    If from_tty is nonzero, it prints a message to that effect,
13845    which ends with a period (no newline).  */
13846
13847 void
13848 set_ignore_count (int bptnum, int count, int from_tty)
13849 {
13850   struct breakpoint *b;
13851
13852   if (count < 0)
13853     count = 0;
13854
13855   ALL_BREAKPOINTS (b)
13856     if (b->number == bptnum)
13857     {
13858       if (is_tracepoint (b))
13859         {
13860           if (from_tty && count != 0)
13861             printf_filtered (_("Ignore count ignored for tracepoint %d."),
13862                              bptnum);
13863           return;
13864         }
13865       
13866       b->ignore_count = count;
13867       if (from_tty)
13868         {
13869           if (count == 0)
13870             printf_filtered (_("Will stop next time "
13871                                "breakpoint %d is reached."),
13872                              bptnum);
13873           else if (count == 1)
13874             printf_filtered (_("Will ignore next crossing of breakpoint %d."),
13875                              bptnum);
13876           else
13877             printf_filtered (_("Will ignore next %d "
13878                                "crossings of breakpoint %d."),
13879                              count, bptnum);
13880         }
13881       gdb::observers::breakpoint_modified.notify (b);
13882       return;
13883     }
13884
13885   error (_("No breakpoint number %d."), bptnum);
13886 }
13887
13888 /* Command to set ignore-count of breakpoint N to COUNT.  */
13889
13890 static void
13891 ignore_command (const char *args, int from_tty)
13892 {
13893   const char *p = args;
13894   int num;
13895
13896   if (p == 0)
13897     error_no_arg (_("a breakpoint number"));
13898
13899   num = get_number (&p);
13900   if (num == 0)
13901     error (_("bad breakpoint number: '%s'"), args);
13902   if (*p == 0)
13903     error (_("Second argument (specified ignore-count) is missing."));
13904
13905   set_ignore_count (num,
13906                     longest_to_int (value_as_long (parse_and_eval (p))),
13907                     from_tty);
13908   if (from_tty)
13909     printf_filtered ("\n");
13910 }
13911 \f
13912
13913 /* Call FUNCTION on each of the breakpoints with numbers in the range
13914    defined by BP_NUM_RANGE (an inclusive range).  */
13915
13916 static void
13917 map_breakpoint_number_range (std::pair<int, int> bp_num_range,
13918                              gdb::function_view<void (breakpoint *)> function)
13919 {
13920   if (bp_num_range.first == 0)
13921     {
13922       warning (_("bad breakpoint number at or near '%d'"),
13923                bp_num_range.first);
13924     }
13925   else
13926     {
13927       struct breakpoint *b, *tmp;
13928
13929       for (int i = bp_num_range.first; i <= bp_num_range.second; i++)
13930         {
13931           bool match = false;
13932
13933           ALL_BREAKPOINTS_SAFE (b, tmp)
13934             if (b->number == i)
13935               {
13936                 match = true;
13937                 function (b);
13938                 break;
13939               }
13940           if (!match)
13941             printf_unfiltered (_("No breakpoint number %d.\n"), i);
13942         }
13943     }
13944 }
13945
13946 /* Call FUNCTION on each of the breakpoints whose numbers are given in
13947    ARGS.  */
13948
13949 static void
13950 map_breakpoint_numbers (const char *args,
13951                         gdb::function_view<void (breakpoint *)> function)
13952 {
13953   if (args == NULL || *args == '\0')
13954     error_no_arg (_("one or more breakpoint numbers"));
13955
13956   number_or_range_parser parser (args);
13957
13958   while (!parser.finished ())
13959     {
13960       int num = parser.get_number ();
13961       map_breakpoint_number_range (std::make_pair (num, num), function);
13962     }
13963 }
13964
13965 /* Return the breakpoint location structure corresponding to the
13966    BP_NUM and LOC_NUM values.  */
13967
13968 static struct bp_location *
13969 find_location_by_number (int bp_num, int loc_num)
13970 {
13971   struct breakpoint *b;
13972
13973   ALL_BREAKPOINTS (b)
13974     if (b->number == bp_num)
13975       {
13976         break;
13977       }
13978
13979   if (!b || b->number != bp_num)
13980     error (_("Bad breakpoint number '%d'"), bp_num);
13981   
13982   if (loc_num == 0)
13983     error (_("Bad breakpoint location number '%d'"), loc_num);
13984
13985   int n = 0;
13986   for (bp_location *loc = b->loc; loc != NULL; loc = loc->next)
13987     if (++n == loc_num)
13988       return loc;
13989
13990   error (_("Bad breakpoint location number '%d'"), loc_num);
13991 }
13992
13993 /* Modes of operation for extract_bp_num.  */
13994 enum class extract_bp_kind
13995 {
13996   /* Extracting a breakpoint number.  */
13997   bp,
13998
13999   /* Extracting a location number.  */
14000   loc,
14001 };
14002
14003 /* Extract a breakpoint or location number (as determined by KIND)
14004    from the string starting at START.  TRAILER is a character which
14005    can be found after the number.  If you don't want a trailer, use
14006    '\0'.  If END_OUT is not NULL, it is set to point after the parsed
14007    string.  This always returns a positive integer.  */
14008
14009 static int
14010 extract_bp_num (extract_bp_kind kind, const char *start,
14011                 int trailer, const char **end_out = NULL)
14012 {
14013   const char *end = start;
14014   int num = get_number_trailer (&end, trailer);
14015   if (num < 0)
14016     error (kind == extract_bp_kind::bp
14017            ? _("Negative breakpoint number '%.*s'")
14018            : _("Negative breakpoint location number '%.*s'"),
14019            int (end - start), start);
14020   if (num == 0)
14021     error (kind == extract_bp_kind::bp
14022            ? _("Bad breakpoint number '%.*s'")
14023            : _("Bad breakpoint location number '%.*s'"),
14024            int (end - start), start);
14025
14026   if (end_out != NULL)
14027     *end_out = end;
14028   return num;
14029 }
14030
14031 /* Extract a breakpoint or location range (as determined by KIND) in
14032    the form NUM1-NUM2 stored at &ARG[arg_offset].  Returns a std::pair
14033    representing the (inclusive) range.  The returned pair's elements
14034    are always positive integers.  */
14035
14036 static std::pair<int, int>
14037 extract_bp_or_bp_range (extract_bp_kind kind,
14038                         const std::string &arg,
14039                         std::string::size_type arg_offset)
14040 {
14041   std::pair<int, int> range;
14042   const char *bp_loc = &arg[arg_offset];
14043   std::string::size_type dash = arg.find ('-', arg_offset);
14044   if (dash != std::string::npos)
14045     {
14046       /* bp_loc is a range (x-z).  */
14047       if (arg.length () == dash + 1)
14048         error (kind == extract_bp_kind::bp
14049                ? _("Bad breakpoint number at or near: '%s'")
14050                : _("Bad breakpoint location number at or near: '%s'"),
14051                bp_loc);
14052
14053       const char *end;
14054       const char *start_first = bp_loc;
14055       const char *start_second = &arg[dash + 1];
14056       range.first = extract_bp_num (kind, start_first, '-');
14057       range.second = extract_bp_num (kind, start_second, '\0', &end);
14058
14059       if (range.first > range.second)
14060         error (kind == extract_bp_kind::bp
14061                ? _("Inverted breakpoint range at '%.*s'")
14062                : _("Inverted breakpoint location range at '%.*s'"),
14063                int (end - start_first), start_first);
14064     }
14065   else
14066     {
14067       /* bp_loc is a single value.  */
14068       range.first = extract_bp_num (kind, bp_loc, '\0');
14069       range.second = range.first;
14070     }
14071   return range;
14072 }
14073
14074 /* Extract the breakpoint/location range specified by ARG.  Returns
14075    the breakpoint range in BP_NUM_RANGE, and the location range in
14076    BP_LOC_RANGE.
14077
14078    ARG may be in any of the following forms:
14079
14080    x     where 'x' is a breakpoint number.
14081    x-y   where 'x' and 'y' specify a breakpoint numbers range.
14082    x.y   where 'x' is a breakpoint number and 'y' a location number.
14083    x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14084          location number range.
14085 */
14086
14087 static void
14088 extract_bp_number_and_location (const std::string &arg,
14089                                 std::pair<int, int> &bp_num_range,
14090                                 std::pair<int, int> &bp_loc_range)
14091 {
14092   std::string::size_type dot = arg.find ('.');
14093
14094   if (dot != std::string::npos)
14095     {
14096       /* Handle 'x.y' and 'x.y-z' cases.  */
14097
14098       if (arg.length () == dot + 1 || dot == 0)
14099         error (_("Bad breakpoint number at or near: '%s'"), arg.c_str ());
14100
14101       bp_num_range.first
14102         = extract_bp_num (extract_bp_kind::bp, arg.c_str (), '.');
14103       bp_num_range.second = bp_num_range.first;
14104
14105       bp_loc_range = extract_bp_or_bp_range (extract_bp_kind::loc,
14106                                              arg, dot + 1);
14107     }
14108   else
14109     {
14110       /* Handle x and x-y cases.  */
14111
14112       bp_num_range = extract_bp_or_bp_range (extract_bp_kind::bp, arg, 0);
14113       bp_loc_range.first = 0;
14114       bp_loc_range.second = 0;
14115     }
14116 }
14117
14118 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM.  ENABLE
14119    specifies whether to enable or disable.  */
14120
14121 static void
14122 enable_disable_bp_num_loc (int bp_num, int loc_num, bool enable)
14123 {
14124   struct bp_location *loc = find_location_by_number (bp_num, loc_num);
14125   if (loc != NULL)
14126     {
14127       if (loc->enabled != enable)
14128         {
14129           loc->enabled = enable;
14130           mark_breakpoint_location_modified (loc);
14131         }
14132       if (target_supports_enable_disable_tracepoint ()
14133           && current_trace_status ()->running && loc->owner
14134           && is_tracepoint (loc->owner))
14135         target_disable_tracepoint (loc);
14136     }
14137   update_global_location_list (UGLL_DONT_INSERT);
14138
14139   gdb::observers::breakpoint_modified.notify (loc->owner);
14140 }
14141
14142 /* Enable or disable a range of breakpoint locations.  BP_NUM is the
14143    number of the breakpoint, and BP_LOC_RANGE specifies the
14144    (inclusive) range of location numbers of that breakpoint to
14145    enable/disable.  ENABLE specifies whether to enable or disable the
14146    location.  */
14147
14148 static void
14149 enable_disable_breakpoint_location_range (int bp_num,
14150                                           std::pair<int, int> &bp_loc_range,
14151                                           bool enable)
14152 {
14153   for (int i = bp_loc_range.first; i <= bp_loc_range.second; i++)
14154     enable_disable_bp_num_loc (bp_num, i, enable);
14155 }
14156
14157 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14158    If from_tty is nonzero, it prints a message to that effect,
14159    which ends with a period (no newline).  */
14160
14161 void
14162 disable_breakpoint (struct breakpoint *bpt)
14163 {
14164   /* Never disable a watchpoint scope breakpoint; we want to
14165      hit them when we leave scope so we can delete both the
14166      watchpoint and its scope breakpoint at that time.  */
14167   if (bpt->type == bp_watchpoint_scope)
14168     return;
14169
14170   bpt->enable_state = bp_disabled;
14171
14172   /* Mark breakpoint locations modified.  */
14173   mark_breakpoint_modified (bpt);
14174
14175   if (target_supports_enable_disable_tracepoint ()
14176       && current_trace_status ()->running && is_tracepoint (bpt))
14177     {
14178       struct bp_location *location;
14179      
14180       for (location = bpt->loc; location; location = location->next)
14181         target_disable_tracepoint (location);
14182     }
14183
14184   update_global_location_list (UGLL_DONT_INSERT);
14185
14186   gdb::observers::breakpoint_modified.notify (bpt);
14187 }
14188
14189 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14190    specified in ARGS.  ARGS may be in any of the formats handled by
14191    extract_bp_number_and_location.  ENABLE specifies whether to enable
14192    or disable the breakpoints/locations.  */
14193
14194 static void
14195 enable_disable_command (const char *args, int from_tty, bool enable)
14196 {
14197   if (args == 0)
14198     {
14199       struct breakpoint *bpt;
14200
14201       ALL_BREAKPOINTS (bpt)
14202         if (user_breakpoint_p (bpt))
14203           {
14204             if (enable)
14205               enable_breakpoint (bpt);
14206             else
14207               disable_breakpoint (bpt);
14208           }
14209     }
14210   else
14211     {
14212       std::string num = extract_arg (&args);
14213
14214       while (!num.empty ())
14215         {
14216           std::pair<int, int> bp_num_range, bp_loc_range;
14217
14218           extract_bp_number_and_location (num, bp_num_range, bp_loc_range);
14219
14220           if (bp_loc_range.first == bp_loc_range.second
14221               && bp_loc_range.first == 0)
14222             {
14223               /* Handle breakpoint ids with formats 'x' or 'x-z'.  */
14224               map_breakpoint_number_range (bp_num_range,
14225                                            enable
14226                                            ? enable_breakpoint
14227                                            : disable_breakpoint);
14228             }
14229           else
14230             {
14231               /* Handle breakpoint ids with formats 'x.y' or
14232                  'x.y-z'.  */
14233               enable_disable_breakpoint_location_range
14234                 (bp_num_range.first, bp_loc_range, enable);
14235             }
14236           num = extract_arg (&args);
14237         }
14238     }
14239 }
14240
14241 /* The disable command disables the specified breakpoints/locations
14242    (or all defined breakpoints) so they're no longer effective in
14243    stopping the inferior.  ARGS may be in any of the forms defined in
14244    extract_bp_number_and_location.  */
14245
14246 static void
14247 disable_command (const char *args, int from_tty)
14248 {
14249   enable_disable_command (args, from_tty, false);
14250 }
14251
14252 static void
14253 enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14254                         int count)
14255 {
14256   int target_resources_ok;
14257
14258   if (bpt->type == bp_hardware_breakpoint)
14259     {
14260       int i;
14261       i = hw_breakpoint_used_count ();
14262       target_resources_ok = 
14263         target_can_use_hardware_watchpoint (bp_hardware_breakpoint, 
14264                                             i + 1, 0);
14265       if (target_resources_ok == 0)
14266         error (_("No hardware breakpoint support in the target."));
14267       else if (target_resources_ok < 0)
14268         error (_("Hardware breakpoints used exceeds limit."));
14269     }
14270
14271   if (is_watchpoint (bpt))
14272     {
14273       /* Initialize it just to avoid a GCC false warning.  */
14274       enum enable_state orig_enable_state = bp_disabled;
14275
14276       try
14277         {
14278           struct watchpoint *w = (struct watchpoint *) bpt;
14279
14280           orig_enable_state = bpt->enable_state;
14281           bpt->enable_state = bp_enabled;
14282           update_watchpoint (w, 1 /* reparse */);
14283         }
14284       catch (const gdb_exception &e)
14285         {
14286           bpt->enable_state = orig_enable_state;
14287           exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14288                              bpt->number);
14289           return;
14290         }
14291     }
14292
14293   bpt->enable_state = bp_enabled;
14294
14295   /* Mark breakpoint locations modified.  */
14296   mark_breakpoint_modified (bpt);
14297
14298   if (target_supports_enable_disable_tracepoint ()
14299       && current_trace_status ()->running && is_tracepoint (bpt))
14300     {
14301       struct bp_location *location;
14302
14303       for (location = bpt->loc; location; location = location->next)
14304         target_enable_tracepoint (location);
14305     }
14306
14307   bpt->disposition = disposition;
14308   bpt->enable_count = count;
14309   update_global_location_list (UGLL_MAY_INSERT);
14310
14311   gdb::observers::breakpoint_modified.notify (bpt);
14312 }
14313
14314
14315 void
14316 enable_breakpoint (struct breakpoint *bpt)
14317 {
14318   enable_breakpoint_disp (bpt, bpt->disposition, 0);
14319 }
14320
14321 /* The enable command enables the specified breakpoints/locations (or
14322    all defined breakpoints) so they once again become (or continue to
14323    be) effective in stopping the inferior.  ARGS may be in any of the
14324    forms defined in extract_bp_number_and_location.  */
14325
14326 static void
14327 enable_command (const char *args, int from_tty)
14328 {
14329   enable_disable_command (args, from_tty, true);
14330 }
14331
14332 static void
14333 enable_once_command (const char *args, int from_tty)
14334 {
14335   map_breakpoint_numbers
14336     (args, [&] (breakpoint *b)
14337      {
14338        iterate_over_related_breakpoints
14339          (b, [&] (breakpoint *bpt)
14340           {
14341             enable_breakpoint_disp (bpt, disp_disable, 1);
14342           });
14343      });
14344 }
14345
14346 static void
14347 enable_count_command (const char *args, int from_tty)
14348 {
14349   int count;
14350
14351   if (args == NULL)
14352     error_no_arg (_("hit count"));
14353
14354   count = get_number (&args);
14355
14356   map_breakpoint_numbers
14357     (args, [&] (breakpoint *b)
14358      {
14359        iterate_over_related_breakpoints
14360          (b, [&] (breakpoint *bpt)
14361           {
14362             enable_breakpoint_disp (bpt, disp_disable, count);
14363           });
14364      });
14365 }
14366
14367 static void
14368 enable_delete_command (const char *args, int from_tty)
14369 {
14370   map_breakpoint_numbers
14371     (args, [&] (breakpoint *b)
14372      {
14373        iterate_over_related_breakpoints
14374          (b, [&] (breakpoint *bpt)
14375           {
14376             enable_breakpoint_disp (bpt, disp_del, 1);
14377           });
14378      });
14379 }
14380 \f
14381 static void
14382 set_breakpoint_cmd (const char *args, int from_tty)
14383 {
14384 }
14385
14386 static void
14387 show_breakpoint_cmd (const char *args, int from_tty)
14388 {
14389 }
14390
14391 /* Invalidate last known value of any hardware watchpoint if
14392    the memory which that value represents has been written to by
14393    GDB itself.  */
14394
14395 static void
14396 invalidate_bp_value_on_memory_change (struct inferior *inferior,
14397                                       CORE_ADDR addr, ssize_t len,
14398                                       const bfd_byte *data)
14399 {
14400   struct breakpoint *bp;
14401
14402   ALL_BREAKPOINTS (bp)
14403     if (bp->enable_state == bp_enabled
14404         && bp->type == bp_hardware_watchpoint)
14405       {
14406         struct watchpoint *wp = (struct watchpoint *) bp;
14407
14408         if (wp->val_valid && wp->val != nullptr)
14409           {
14410             struct bp_location *loc;
14411
14412             for (loc = bp->loc; loc != NULL; loc = loc->next)
14413               if (loc->loc_type == bp_loc_hardware_watchpoint
14414                   && loc->address + loc->length > addr
14415                   && addr + len > loc->address)
14416                 {
14417                   wp->val = NULL;
14418                   wp->val_valid = 0;
14419                 }
14420           }
14421       }
14422 }
14423
14424 /* Create and insert a breakpoint for software single step.  */
14425
14426 void
14427 insert_single_step_breakpoint (struct gdbarch *gdbarch,
14428                                const address_space *aspace,
14429                                CORE_ADDR next_pc)
14430 {
14431   struct thread_info *tp = inferior_thread ();
14432   struct symtab_and_line sal;
14433   CORE_ADDR pc = next_pc;
14434
14435   if (tp->control.single_step_breakpoints == NULL)
14436     {
14437       tp->control.single_step_breakpoints
14438         = new_single_step_breakpoint (tp->global_num, gdbarch);
14439     }
14440
14441   sal = find_pc_line (pc, 0);
14442   sal.pc = pc;
14443   sal.section = find_pc_overlay (pc);
14444   sal.explicit_pc = 1;
14445   add_location_to_breakpoint (tp->control.single_step_breakpoints, &sal);
14446
14447   update_global_location_list (UGLL_INSERT);
14448 }
14449
14450 /* Insert single step breakpoints according to the current state.  */
14451
14452 int
14453 insert_single_step_breakpoints (struct gdbarch *gdbarch)
14454 {
14455   struct regcache *regcache = get_current_regcache ();
14456   std::vector<CORE_ADDR> next_pcs;
14457
14458   next_pcs = gdbarch_software_single_step (gdbarch, regcache);
14459
14460   if (!next_pcs.empty ())
14461     {
14462       struct frame_info *frame = get_current_frame ();
14463       const address_space *aspace = get_frame_address_space (frame);
14464
14465       for (CORE_ADDR pc : next_pcs)
14466         insert_single_step_breakpoint (gdbarch, aspace, pc);
14467
14468       return 1;
14469     }
14470   else
14471     return 0;
14472 }
14473
14474 /* See breakpoint.h.  */
14475
14476 int
14477 breakpoint_has_location_inserted_here (struct breakpoint *bp,
14478                                        const address_space *aspace,
14479                                        CORE_ADDR pc)
14480 {
14481   struct bp_location *loc;
14482
14483   for (loc = bp->loc; loc != NULL; loc = loc->next)
14484     if (loc->inserted
14485         && breakpoint_location_address_match (loc, aspace, pc))
14486       return 1;
14487
14488   return 0;
14489 }
14490
14491 /* Check whether a software single-step breakpoint is inserted at
14492    PC.  */
14493
14494 int
14495 single_step_breakpoint_inserted_here_p (const address_space *aspace,
14496                                         CORE_ADDR pc)
14497 {
14498   struct breakpoint *bpt;
14499
14500   ALL_BREAKPOINTS (bpt)
14501     {
14502       if (bpt->type == bp_single_step
14503           && breakpoint_has_location_inserted_here (bpt, aspace, pc))
14504         return 1;
14505     }
14506   return 0;
14507 }
14508
14509 /* Tracepoint-specific operations.  */
14510
14511 /* Set tracepoint count to NUM.  */
14512 static void
14513 set_tracepoint_count (int num)
14514 {
14515   tracepoint_count = num;
14516   set_internalvar_integer (lookup_internalvar ("tpnum"), num);
14517 }
14518
14519 static void
14520 trace_command (const char *arg, int from_tty)
14521 {
14522   struct breakpoint_ops *ops;
14523
14524   event_location_up location = string_to_event_location (&arg,
14525                                                          current_language);
14526   if (location != NULL
14527       && event_location_type (location.get ()) == PROBE_LOCATION)
14528     ops = &tracepoint_probe_breakpoint_ops;
14529   else
14530     ops = &tracepoint_breakpoint_ops;
14531
14532   create_breakpoint (get_current_arch (),
14533                      location.get (),
14534                      NULL, 0, arg, 1 /* parse arg */,
14535                      0 /* tempflag */,
14536                      bp_tracepoint /* type_wanted */,
14537                      0 /* Ignore count */,
14538                      pending_break_support,
14539                      ops,
14540                      from_tty,
14541                      1 /* enabled */,
14542                      0 /* internal */, 0);
14543 }
14544
14545 static void
14546 ftrace_command (const char *arg, int from_tty)
14547 {
14548   event_location_up location = string_to_event_location (&arg,
14549                                                          current_language);
14550   create_breakpoint (get_current_arch (),
14551                      location.get (),
14552                      NULL, 0, arg, 1 /* parse arg */,
14553                      0 /* tempflag */,
14554                      bp_fast_tracepoint /* type_wanted */,
14555                      0 /* Ignore count */,
14556                      pending_break_support,
14557                      &tracepoint_breakpoint_ops,
14558                      from_tty,
14559                      1 /* enabled */,
14560                      0 /* internal */, 0);
14561 }
14562
14563 /* strace command implementation.  Creates a static tracepoint.  */
14564
14565 static void
14566 strace_command (const char *arg, int from_tty)
14567 {
14568   struct breakpoint_ops *ops;
14569   event_location_up location;
14570
14571   /* Decide if we are dealing with a static tracepoint marker (`-m'),
14572      or with a normal static tracepoint.  */
14573   if (arg && startswith (arg, "-m") && isspace (arg[2]))
14574     {
14575       ops = &strace_marker_breakpoint_ops;
14576       location = new_linespec_location (&arg, symbol_name_match_type::FULL);
14577     }
14578   else
14579     {
14580       ops = &tracepoint_breakpoint_ops;
14581       location = string_to_event_location (&arg, current_language);
14582     }
14583
14584   create_breakpoint (get_current_arch (),
14585                      location.get (),
14586                      NULL, 0, arg, 1 /* parse arg */,
14587                      0 /* tempflag */,
14588                      bp_static_tracepoint /* type_wanted */,
14589                      0 /* Ignore count */,
14590                      pending_break_support,
14591                      ops,
14592                      from_tty,
14593                      1 /* enabled */,
14594                      0 /* internal */, 0);
14595 }
14596
14597 /* Set up a fake reader function that gets command lines from a linked
14598    list that was acquired during tracepoint uploading.  */
14599
14600 static struct uploaded_tp *this_utp;
14601 static int next_cmd;
14602
14603 static char *
14604 read_uploaded_action (void)
14605 {
14606   char *rslt = nullptr;
14607
14608   if (next_cmd < this_utp->cmd_strings.size ())
14609     {
14610       rslt = this_utp->cmd_strings[next_cmd].get ();
14611       next_cmd++;
14612     }
14613
14614   return rslt;
14615 }
14616
14617 /* Given information about a tracepoint as recorded on a target (which
14618    can be either a live system or a trace file), attempt to create an
14619    equivalent GDB tracepoint.  This is not a reliable process, since
14620    the target does not necessarily have all the information used when
14621    the tracepoint was originally defined.  */
14622   
14623 struct tracepoint *
14624 create_tracepoint_from_upload (struct uploaded_tp *utp)
14625 {
14626   const char *addr_str;
14627   char small_buf[100];
14628   struct tracepoint *tp;
14629
14630   if (utp->at_string)
14631     addr_str = utp->at_string.get ();
14632   else
14633     {
14634       /* In the absence of a source location, fall back to raw
14635          address.  Since there is no way to confirm that the address
14636          means the same thing as when the trace was started, warn the
14637          user.  */
14638       warning (_("Uploaded tracepoint %d has no "
14639                  "source location, using raw address"),
14640                utp->number);
14641       xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (utp->addr));
14642       addr_str = small_buf;
14643     }
14644
14645   /* There's not much we can do with a sequence of bytecodes.  */
14646   if (utp->cond && !utp->cond_string)
14647     warning (_("Uploaded tracepoint %d condition "
14648                "has no source form, ignoring it"),
14649              utp->number);
14650
14651   event_location_up location = string_to_event_location (&addr_str,
14652                                                          current_language);
14653   if (!create_breakpoint (get_current_arch (),
14654                           location.get (),
14655                           utp->cond_string.get (), -1, addr_str,
14656                           0 /* parse cond/thread */,
14657                           0 /* tempflag */,
14658                           utp->type /* type_wanted */,
14659                           0 /* Ignore count */,
14660                           pending_break_support,
14661                           &tracepoint_breakpoint_ops,
14662                           0 /* from_tty */,
14663                           utp->enabled /* enabled */,
14664                           0 /* internal */,
14665                           CREATE_BREAKPOINT_FLAGS_INSERTED))
14666     return NULL;
14667
14668   /* Get the tracepoint we just created.  */
14669   tp = get_tracepoint (tracepoint_count);
14670   gdb_assert (tp != NULL);
14671
14672   if (utp->pass > 0)
14673     {
14674       xsnprintf (small_buf, sizeof (small_buf), "%d %d", utp->pass,
14675                  tp->number);
14676
14677       trace_pass_command (small_buf, 0);
14678     }
14679
14680   /* If we have uploaded versions of the original commands, set up a
14681      special-purpose "reader" function and call the usual command line
14682      reader, then pass the result to the breakpoint command-setting
14683      function.  */
14684   if (!utp->cmd_strings.empty ())
14685     {
14686       counted_command_line cmd_list;
14687
14688       this_utp = utp;
14689       next_cmd = 0;
14690
14691       cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL);
14692
14693       breakpoint_set_commands (tp, std::move (cmd_list));
14694     }
14695   else if (!utp->actions.empty ()
14696            || !utp->step_actions.empty ())
14697     warning (_("Uploaded tracepoint %d actions "
14698                "have no source form, ignoring them"),
14699              utp->number);
14700
14701   /* Copy any status information that might be available.  */
14702   tp->hit_count = utp->hit_count;
14703   tp->traceframe_usage = utp->traceframe_usage;
14704
14705   return tp;
14706 }
14707   
14708 /* Print information on tracepoint number TPNUM_EXP, or all if
14709    omitted.  */
14710
14711 static void
14712 info_tracepoints_command (const char *args, int from_tty)
14713 {
14714   struct ui_out *uiout = current_uiout;
14715   int num_printed;
14716
14717   num_printed = breakpoint_1 (args, 0, is_tracepoint);
14718
14719   if (num_printed == 0)
14720     {
14721       if (args == NULL || *args == '\0')
14722         uiout->message ("No tracepoints.\n");
14723       else
14724         uiout->message ("No tracepoint matching '%s'.\n", args);
14725     }
14726
14727   default_collect_info ();
14728 }
14729
14730 /* The 'enable trace' command enables tracepoints.
14731    Not supported by all targets.  */
14732 static void
14733 enable_trace_command (const char *args, int from_tty)
14734 {
14735   enable_command (args, from_tty);
14736 }
14737
14738 /* The 'disable trace' command disables tracepoints.
14739    Not supported by all targets.  */
14740 static void
14741 disable_trace_command (const char *args, int from_tty)
14742 {
14743   disable_command (args, from_tty);
14744 }
14745
14746 /* Remove a tracepoint (or all if no argument).  */
14747 static void
14748 delete_trace_command (const char *arg, int from_tty)
14749 {
14750   struct breakpoint *b, *b_tmp;
14751
14752   dont_repeat ();
14753
14754   if (arg == 0)
14755     {
14756       int breaks_to_delete = 0;
14757
14758       /* Delete all breakpoints if no argument.
14759          Do not delete internal or call-dummy breakpoints, these
14760          have to be deleted with an explicit breakpoint number 
14761          argument.  */
14762       ALL_TRACEPOINTS (b)
14763         if (is_tracepoint (b) && user_breakpoint_p (b))
14764           {
14765             breaks_to_delete = 1;
14766             break;
14767           }
14768
14769       /* Ask user only if there are some breakpoints to delete.  */
14770       if (!from_tty
14771           || (breaks_to_delete && query (_("Delete all tracepoints? "))))
14772         {
14773           ALL_BREAKPOINTS_SAFE (b, b_tmp)
14774             if (is_tracepoint (b) && user_breakpoint_p (b))
14775               delete_breakpoint (b);
14776         }
14777     }
14778   else
14779     map_breakpoint_numbers
14780       (arg, [&] (breakpoint *br)
14781        {
14782          iterate_over_related_breakpoints (br, delete_breakpoint);
14783        });
14784 }
14785
14786 /* Helper function for trace_pass_command.  */
14787
14788 static void
14789 trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
14790 {
14791   tp->pass_count = count;
14792   gdb::observers::breakpoint_modified.notify (tp);
14793   if (from_tty)
14794     printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14795                      tp->number, count);
14796 }
14797
14798 /* Set passcount for tracepoint.
14799
14800    First command argument is passcount, second is tracepoint number.
14801    If tracepoint number omitted, apply to most recently defined.
14802    Also accepts special argument "all".  */
14803
14804 static void
14805 trace_pass_command (const char *args, int from_tty)
14806 {
14807   struct tracepoint *t1;
14808   ULONGEST count;
14809
14810   if (args == 0 || *args == 0)
14811     error (_("passcount command requires an "
14812              "argument (count + optional TP num)"));
14813
14814   count = strtoulst (args, &args, 10);  /* Count comes first, then TP num.  */
14815
14816   args = skip_spaces (args);
14817   if (*args && strncasecmp (args, "all", 3) == 0)
14818     {
14819       struct breakpoint *b;
14820
14821       args += 3;                        /* Skip special argument "all".  */
14822       if (*args)
14823         error (_("Junk at end of arguments."));
14824
14825       ALL_TRACEPOINTS (b)
14826       {
14827         t1 = (struct tracepoint *) b;
14828         trace_pass_set_count (t1, count, from_tty);
14829       }
14830     }
14831   else if (*args == '\0')
14832     {
14833       t1 = get_tracepoint_by_number (&args, NULL);
14834       if (t1)
14835         trace_pass_set_count (t1, count, from_tty);
14836     }
14837   else
14838     {
14839       number_or_range_parser parser (args);
14840       while (!parser.finished ())
14841         {
14842           t1 = get_tracepoint_by_number (&args, &parser);
14843           if (t1)
14844             trace_pass_set_count (t1, count, from_tty);
14845         }
14846     }
14847 }
14848
14849 struct tracepoint *
14850 get_tracepoint (int num)
14851 {
14852   struct breakpoint *t;
14853
14854   ALL_TRACEPOINTS (t)
14855     if (t->number == num)
14856       return (struct tracepoint *) t;
14857
14858   return NULL;
14859 }
14860
14861 /* Find the tracepoint with the given target-side number (which may be
14862    different from the tracepoint number after disconnecting and
14863    reconnecting).  */
14864
14865 struct tracepoint *
14866 get_tracepoint_by_number_on_target (int num)
14867 {
14868   struct breakpoint *b;
14869
14870   ALL_TRACEPOINTS (b)
14871     {
14872       struct tracepoint *t = (struct tracepoint *) b;
14873
14874       if (t->number_on_target == num)
14875         return t;
14876     }
14877
14878   return NULL;
14879 }
14880
14881 /* Utility: parse a tracepoint number and look it up in the list.
14882    If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
14883    If the argument is missing, the most recent tracepoint
14884    (tracepoint_count) is returned.  */
14885
14886 struct tracepoint *
14887 get_tracepoint_by_number (const char **arg,
14888                           number_or_range_parser *parser)
14889 {
14890   struct breakpoint *t;
14891   int tpnum;
14892   const char *instring = arg == NULL ? NULL : *arg;
14893
14894   if (parser != NULL)
14895     {
14896       gdb_assert (!parser->finished ());
14897       tpnum = parser->get_number ();
14898     }
14899   else if (arg == NULL || *arg == NULL || ! **arg)
14900     tpnum = tracepoint_count;
14901   else
14902     tpnum = get_number (arg);
14903
14904   if (tpnum <= 0)
14905     {
14906       if (instring && *instring)
14907         printf_filtered (_("bad tracepoint number at or near '%s'\n"), 
14908                          instring);
14909       else
14910         printf_filtered (_("No previous tracepoint\n"));
14911       return NULL;
14912     }
14913
14914   ALL_TRACEPOINTS (t)
14915     if (t->number == tpnum)
14916     {
14917       return (struct tracepoint *) t;
14918     }
14919
14920   printf_unfiltered ("No tracepoint number %d.\n", tpnum);
14921   return NULL;
14922 }
14923
14924 void
14925 print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
14926 {
14927   if (b->thread != -1)
14928     fprintf_unfiltered (fp, " thread %d", b->thread);
14929
14930   if (b->task != 0)
14931     fprintf_unfiltered (fp, " task %d", b->task);
14932
14933   fprintf_unfiltered (fp, "\n");
14934 }
14935
14936 /* Save information on user settable breakpoints (watchpoints, etc) to
14937    a new script file named FILENAME.  If FILTER is non-NULL, call it
14938    on each breakpoint and only include the ones for which it returns
14939    non-zero.  */
14940
14941 static void
14942 save_breakpoints (const char *filename, int from_tty,
14943                   int (*filter) (const struct breakpoint *))
14944 {
14945   struct breakpoint *tp;
14946   int any = 0;
14947   int extra_trace_bits = 0;
14948
14949   if (filename == 0 || *filename == 0)
14950     error (_("Argument required (file name in which to save)"));
14951
14952   /* See if we have anything to save.  */
14953   ALL_BREAKPOINTS (tp)
14954   {
14955     /* Skip internal and momentary breakpoints.  */
14956     if (!user_breakpoint_p (tp))
14957       continue;
14958
14959     /* If we have a filter, only save the breakpoints it accepts.  */
14960     if (filter && !filter (tp))
14961       continue;
14962
14963     any = 1;
14964
14965     if (is_tracepoint (tp))
14966       {
14967         extra_trace_bits = 1;
14968
14969         /* We can stop searching.  */
14970         break;
14971       }
14972   }
14973
14974   if (!any)
14975     {
14976       warning (_("Nothing to save."));
14977       return;
14978     }
14979
14980   gdb::unique_xmalloc_ptr<char> expanded_filename (tilde_expand (filename));
14981
14982   stdio_file fp;
14983
14984   if (!fp.open (expanded_filename.get (), "w"))
14985     error (_("Unable to open file '%s' for saving (%s)"),
14986            expanded_filename.get (), safe_strerror (errno));
14987
14988   if (extra_trace_bits)
14989     save_trace_state_variables (&fp);
14990
14991   ALL_BREAKPOINTS (tp)
14992   {
14993     /* Skip internal and momentary breakpoints.  */
14994     if (!user_breakpoint_p (tp))
14995       continue;
14996
14997     /* If we have a filter, only save the breakpoints it accepts.  */
14998     if (filter && !filter (tp))
14999       continue;
15000
15001     tp->ops->print_recreate (tp, &fp);
15002
15003     /* Note, we can't rely on tp->number for anything, as we can't
15004        assume the recreated breakpoint numbers will match.  Use $bpnum
15005        instead.  */
15006
15007     if (tp->cond_string)
15008       fp.printf ("  condition $bpnum %s\n", tp->cond_string);
15009
15010     if (tp->ignore_count)
15011       fp.printf ("  ignore $bpnum %d\n", tp->ignore_count);
15012
15013     if (tp->type != bp_dprintf && tp->commands)
15014       {
15015         fp.puts ("  commands\n");
15016         
15017         current_uiout->redirect (&fp);
15018         try
15019           {
15020             print_command_lines (current_uiout, tp->commands.get (), 2);
15021           }
15022         catch (const gdb_exception &ex)
15023           {
15024           current_uiout->redirect (NULL);
15025             throw;
15026           }
15027
15028         current_uiout->redirect (NULL);
15029         fp.puts ("  end\n");
15030       }
15031
15032     if (tp->enable_state == bp_disabled)
15033       fp.puts ("disable $bpnum\n");
15034
15035     /* If this is a multi-location breakpoint, check if the locations
15036        should be individually disabled.  Watchpoint locations are
15037        special, and not user visible.  */
15038     if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15039       {
15040         struct bp_location *loc;
15041         int n = 1;
15042
15043         for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15044           if (!loc->enabled)
15045             fp.printf ("disable $bpnum.%d\n", n);
15046       }
15047   }
15048
15049   if (extra_trace_bits && *default_collect)
15050     fp.printf ("set default-collect %s\n", default_collect);
15051
15052   if (from_tty)
15053     printf_filtered (_("Saved to file '%s'.\n"), expanded_filename.get ());
15054 }
15055
15056 /* The `save breakpoints' command.  */
15057
15058 static void
15059 save_breakpoints_command (const char *args, int from_tty)
15060 {
15061   save_breakpoints (args, from_tty, NULL);
15062 }
15063
15064 /* The `save tracepoints' command.  */
15065
15066 static void
15067 save_tracepoints_command (const char *args, int from_tty)
15068 {
15069   save_breakpoints (args, from_tty, is_tracepoint);
15070 }
15071
15072 /* Create a vector of all tracepoints.  */
15073
15074 std::vector<breakpoint *>
15075 all_tracepoints (void)
15076 {
15077   std::vector<breakpoint *> tp_vec;
15078   struct breakpoint *tp;
15079
15080   ALL_TRACEPOINTS (tp)
15081   {
15082     tp_vec.push_back (tp);
15083   }
15084
15085   return tp_vec;
15086 }
15087
15088 \f
15089 /* This help string is used to consolidate all the help string for specifying
15090    locations used by several commands.  */
15091
15092 #define LOCATION_HELP_STRING \
15093 "Linespecs are colon-separated lists of location parameters, such as\n\
15094 source filename, function name, label name, and line number.\n\
15095 Example: To specify the start of a label named \"the_top\" in the\n\
15096 function \"fact\" in the file \"factorial.c\", use\n\
15097 \"factorial.c:fact:the_top\".\n\
15098 \n\
15099 Address locations begin with \"*\" and specify an exact address in the\n\
15100 program.  Example: To specify the fourth byte past the start function\n\
15101 \"main\", use \"*main + 4\".\n\
15102 \n\
15103 Explicit locations are similar to linespecs but use an option/argument\n\
15104 syntax to specify location parameters.\n\
15105 Example: To specify the start of the label named \"the_top\" in the\n\
15106 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15107 -function fact -label the_top\".\n\
15108 \n\
15109 By default, a specified function is matched against the program's\n\
15110 functions in all scopes.  For C++, this means in all namespaces and\n\
15111 classes.  For Ada, this means in all packages.  E.g., in C++,\n\
15112 \"func()\" matches \"A::func()\", \"A::B::func()\", etc.  The\n\
15113 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15114 specified name as a complete fully-qualified name instead.\n"
15115
15116 /* This help string is used for the break, hbreak, tbreak and thbreak
15117    commands.  It is defined as a macro to prevent duplication.
15118    COMMAND should be a string constant containing the name of the
15119    command.  */
15120
15121 #define BREAK_ARGS_HELP(command) \
15122 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15123 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15124 probe point.  Accepted values are `-probe' (for a generic, automatically\n\
15125 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15126 `-probe-dtrace' (for a DTrace probe).\n\
15127 LOCATION may be a linespec, address, or explicit location as described\n\
15128 below.\n\
15129 \n\
15130 With no LOCATION, uses current execution address of the selected\n\
15131 stack frame.  This is useful for breaking on return to a stack frame.\n\
15132 \n\
15133 THREADNUM is the number from \"info threads\".\n\
15134 CONDITION is a boolean expression.\n\
15135 \n" LOCATION_HELP_STRING "\n\
15136 Multiple breakpoints at one place are permitted, and useful if their\n\
15137 conditions are different.\n\
15138 \n\
15139 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15140
15141 /* List of subcommands for "catch".  */
15142 static struct cmd_list_element *catch_cmdlist;
15143
15144 /* List of subcommands for "tcatch".  */
15145 static struct cmd_list_element *tcatch_cmdlist;
15146
15147 void
15148 add_catch_command (const char *name, const char *docstring,
15149                    cmd_const_sfunc_ftype *sfunc,
15150                    completer_ftype *completer,
15151                    void *user_data_catch,
15152                    void *user_data_tcatch)
15153 {
15154   struct cmd_list_element *command;
15155
15156   command = add_cmd (name, class_breakpoint, docstring,
15157                      &catch_cmdlist);
15158   set_cmd_sfunc (command, sfunc);
15159   set_cmd_context (command, user_data_catch);
15160   set_cmd_completer (command, completer);
15161
15162   command = add_cmd (name, class_breakpoint, docstring,
15163                      &tcatch_cmdlist);
15164   set_cmd_sfunc (command, sfunc);
15165   set_cmd_context (command, user_data_tcatch);
15166   set_cmd_completer (command, completer);
15167 }
15168
15169 static void
15170 save_command (const char *arg, int from_tty)
15171 {
15172   printf_unfiltered (_("\"save\" must be followed by "
15173                        "the name of a save subcommand.\n"));
15174   help_list (save_cmdlist, "save ", all_commands, gdb_stdout);
15175 }
15176
15177 struct breakpoint *
15178 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15179                           void *data)
15180 {
15181   struct breakpoint *b, *b_tmp;
15182
15183   ALL_BREAKPOINTS_SAFE (b, b_tmp)
15184     {
15185       if ((*callback) (b, data))
15186         return b;
15187     }
15188
15189   return NULL;
15190 }
15191
15192 /* Zero if any of the breakpoint's locations could be a location where
15193    functions have been inlined, nonzero otherwise.  */
15194
15195 static int
15196 is_non_inline_function (struct breakpoint *b)
15197 {
15198   /* The shared library event breakpoint is set on the address of a
15199      non-inline function.  */
15200   if (b->type == bp_shlib_event)
15201     return 1;
15202
15203   return 0;
15204 }
15205
15206 /* Nonzero if the specified PC cannot be a location where functions
15207    have been inlined.  */
15208
15209 int
15210 pc_at_non_inline_function (const address_space *aspace, CORE_ADDR pc,
15211                            const struct target_waitstatus *ws)
15212 {
15213   struct breakpoint *b;
15214   struct bp_location *bl;
15215
15216   ALL_BREAKPOINTS (b)
15217     {
15218       if (!is_non_inline_function (b))
15219         continue;
15220
15221       for (bl = b->loc; bl != NULL; bl = bl->next)
15222         {
15223           if (!bl->shlib_disabled
15224               && bpstat_check_location (bl, aspace, pc, ws))
15225             return 1;
15226         }
15227     }
15228
15229   return 0;
15230 }
15231
15232 /* Remove any references to OBJFILE which is going to be freed.  */
15233
15234 void
15235 breakpoint_free_objfile (struct objfile *objfile)
15236 {
15237   struct bp_location **locp, *loc;
15238
15239   ALL_BP_LOCATIONS (loc, locp)
15240     if (loc->symtab != NULL && SYMTAB_OBJFILE (loc->symtab) == objfile)
15241       loc->symtab = NULL;
15242 }
15243
15244 void
15245 initialize_breakpoint_ops (void)
15246 {
15247   static int initialized = 0;
15248
15249   struct breakpoint_ops *ops;
15250
15251   if (initialized)
15252     return;
15253   initialized = 1;
15254
15255   /* The breakpoint_ops structure to be inherit by all kinds of
15256      breakpoints (real breakpoints, i.e., user "break" breakpoints,
15257      internal and momentary breakpoints, etc.).  */
15258   ops = &bkpt_base_breakpoint_ops;
15259   *ops = base_breakpoint_ops;
15260   ops->re_set = bkpt_re_set;
15261   ops->insert_location = bkpt_insert_location;
15262   ops->remove_location = bkpt_remove_location;
15263   ops->breakpoint_hit = bkpt_breakpoint_hit;
15264   ops->create_sals_from_location = bkpt_create_sals_from_location;
15265   ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
15266   ops->decode_location = bkpt_decode_location;
15267
15268   /* The breakpoint_ops structure to be used in regular breakpoints.  */
15269   ops = &bkpt_breakpoint_ops;
15270   *ops = bkpt_base_breakpoint_ops;
15271   ops->re_set = bkpt_re_set;
15272   ops->resources_needed = bkpt_resources_needed;
15273   ops->print_it = bkpt_print_it;
15274   ops->print_mention = bkpt_print_mention;
15275   ops->print_recreate = bkpt_print_recreate;
15276
15277   /* Ranged breakpoints.  */
15278   ops = &ranged_breakpoint_ops;
15279   *ops = bkpt_breakpoint_ops;
15280   ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15281   ops->resources_needed = resources_needed_ranged_breakpoint;
15282   ops->print_it = print_it_ranged_breakpoint;
15283   ops->print_one = print_one_ranged_breakpoint;
15284   ops->print_one_detail = print_one_detail_ranged_breakpoint;
15285   ops->print_mention = print_mention_ranged_breakpoint;
15286   ops->print_recreate = print_recreate_ranged_breakpoint;
15287
15288   /* Internal breakpoints.  */
15289   ops = &internal_breakpoint_ops;
15290   *ops = bkpt_base_breakpoint_ops;
15291   ops->re_set = internal_bkpt_re_set;
15292   ops->check_status = internal_bkpt_check_status;
15293   ops->print_it = internal_bkpt_print_it;
15294   ops->print_mention = internal_bkpt_print_mention;
15295
15296   /* Momentary breakpoints.  */
15297   ops = &momentary_breakpoint_ops;
15298   *ops = bkpt_base_breakpoint_ops;
15299   ops->re_set = momentary_bkpt_re_set;
15300   ops->check_status = momentary_bkpt_check_status;
15301   ops->print_it = momentary_bkpt_print_it;
15302   ops->print_mention = momentary_bkpt_print_mention;
15303
15304   /* Probe breakpoints.  */
15305   ops = &bkpt_probe_breakpoint_ops;
15306   *ops = bkpt_breakpoint_ops;
15307   ops->insert_location = bkpt_probe_insert_location;
15308   ops->remove_location = bkpt_probe_remove_location;
15309   ops->create_sals_from_location = bkpt_probe_create_sals_from_location;
15310   ops->decode_location = bkpt_probe_decode_location;
15311
15312   /* Watchpoints.  */
15313   ops = &watchpoint_breakpoint_ops;
15314   *ops = base_breakpoint_ops;
15315   ops->re_set = re_set_watchpoint;
15316   ops->insert_location = insert_watchpoint;
15317   ops->remove_location = remove_watchpoint;
15318   ops->breakpoint_hit = breakpoint_hit_watchpoint;
15319   ops->check_status = check_status_watchpoint;
15320   ops->resources_needed = resources_needed_watchpoint;
15321   ops->works_in_software_mode = works_in_software_mode_watchpoint;
15322   ops->print_it = print_it_watchpoint;
15323   ops->print_mention = print_mention_watchpoint;
15324   ops->print_recreate = print_recreate_watchpoint;
15325   ops->explains_signal = explains_signal_watchpoint;
15326
15327   /* Masked watchpoints.  */
15328   ops = &masked_watchpoint_breakpoint_ops;
15329   *ops = watchpoint_breakpoint_ops;
15330   ops->insert_location = insert_masked_watchpoint;
15331   ops->remove_location = remove_masked_watchpoint;
15332   ops->resources_needed = resources_needed_masked_watchpoint;
15333   ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15334   ops->print_it = print_it_masked_watchpoint;
15335   ops->print_one_detail = print_one_detail_masked_watchpoint;
15336   ops->print_mention = print_mention_masked_watchpoint;
15337   ops->print_recreate = print_recreate_masked_watchpoint;
15338
15339   /* Tracepoints.  */
15340   ops = &tracepoint_breakpoint_ops;
15341   *ops = base_breakpoint_ops;
15342   ops->re_set = tracepoint_re_set;
15343   ops->breakpoint_hit = tracepoint_breakpoint_hit;
15344   ops->print_one_detail = tracepoint_print_one_detail;
15345   ops->print_mention = tracepoint_print_mention;
15346   ops->print_recreate = tracepoint_print_recreate;
15347   ops->create_sals_from_location = tracepoint_create_sals_from_location;
15348   ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
15349   ops->decode_location = tracepoint_decode_location;
15350
15351   /* Probe tracepoints.  */
15352   ops = &tracepoint_probe_breakpoint_ops;
15353   *ops = tracepoint_breakpoint_ops;
15354   ops->create_sals_from_location = tracepoint_probe_create_sals_from_location;
15355   ops->decode_location = tracepoint_probe_decode_location;
15356
15357   /* Static tracepoints with marker (`-m').  */
15358   ops = &strace_marker_breakpoint_ops;
15359   *ops = tracepoint_breakpoint_ops;
15360   ops->create_sals_from_location = strace_marker_create_sals_from_location;
15361   ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
15362   ops->decode_location = strace_marker_decode_location;
15363
15364   /* Fork catchpoints.  */
15365   ops = &catch_fork_breakpoint_ops;
15366   *ops = base_breakpoint_ops;
15367   ops->insert_location = insert_catch_fork;
15368   ops->remove_location = remove_catch_fork;
15369   ops->breakpoint_hit = breakpoint_hit_catch_fork;
15370   ops->print_it = print_it_catch_fork;
15371   ops->print_one = print_one_catch_fork;
15372   ops->print_mention = print_mention_catch_fork;
15373   ops->print_recreate = print_recreate_catch_fork;
15374
15375   /* Vfork catchpoints.  */
15376   ops = &catch_vfork_breakpoint_ops;
15377   *ops = base_breakpoint_ops;
15378   ops->insert_location = insert_catch_vfork;
15379   ops->remove_location = remove_catch_vfork;
15380   ops->breakpoint_hit = breakpoint_hit_catch_vfork;
15381   ops->print_it = print_it_catch_vfork;
15382   ops->print_one = print_one_catch_vfork;
15383   ops->print_mention = print_mention_catch_vfork;
15384   ops->print_recreate = print_recreate_catch_vfork;
15385
15386   /* Exec catchpoints.  */
15387   ops = &catch_exec_breakpoint_ops;
15388   *ops = base_breakpoint_ops;
15389   ops->insert_location = insert_catch_exec;
15390   ops->remove_location = remove_catch_exec;
15391   ops->breakpoint_hit = breakpoint_hit_catch_exec;
15392   ops->print_it = print_it_catch_exec;
15393   ops->print_one = print_one_catch_exec;
15394   ops->print_mention = print_mention_catch_exec;
15395   ops->print_recreate = print_recreate_catch_exec;
15396
15397   /* Solib-related catchpoints.  */
15398   ops = &catch_solib_breakpoint_ops;
15399   *ops = base_breakpoint_ops;
15400   ops->insert_location = insert_catch_solib;
15401   ops->remove_location = remove_catch_solib;
15402   ops->breakpoint_hit = breakpoint_hit_catch_solib;
15403   ops->check_status = check_status_catch_solib;
15404   ops->print_it = print_it_catch_solib;
15405   ops->print_one = print_one_catch_solib;
15406   ops->print_mention = print_mention_catch_solib;
15407   ops->print_recreate = print_recreate_catch_solib;
15408
15409   ops = &dprintf_breakpoint_ops;
15410   *ops = bkpt_base_breakpoint_ops;
15411   ops->re_set = dprintf_re_set;
15412   ops->resources_needed = bkpt_resources_needed;
15413   ops->print_it = bkpt_print_it;
15414   ops->print_mention = bkpt_print_mention;
15415   ops->print_recreate = dprintf_print_recreate;
15416   ops->after_condition_true = dprintf_after_condition_true;
15417   ops->breakpoint_hit = dprintf_breakpoint_hit;
15418 }
15419
15420 /* Chain containing all defined "enable breakpoint" subcommands.  */
15421
15422 static struct cmd_list_element *enablebreaklist = NULL;
15423
15424 /* See breakpoint.h.  */
15425
15426 cmd_list_element *commands_cmd_element = nullptr;
15427
15428 void
15429 _initialize_breakpoint (void)
15430 {
15431   struct cmd_list_element *c;
15432
15433   initialize_breakpoint_ops ();
15434
15435   gdb::observers::solib_unloaded.attach (disable_breakpoints_in_unloaded_shlib);
15436   gdb::observers::free_objfile.attach (disable_breakpoints_in_freed_objfile);
15437   gdb::observers::memory_changed.attach (invalidate_bp_value_on_memory_change);
15438
15439   breakpoint_chain = 0;
15440   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
15441      before a breakpoint is set.  */
15442   breakpoint_count = 0;
15443
15444   tracepoint_count = 0;
15445
15446   add_com ("ignore", class_breakpoint, ignore_command, _("\
15447 Set ignore-count of breakpoint number N to COUNT.\n\
15448 Usage is `ignore N COUNT'."));
15449
15450   commands_cmd_element = add_com ("commands", class_breakpoint,
15451                                   commands_command, _("\
15452 Set commands to be executed when the given breakpoints are hit.\n\
15453 Give a space-separated breakpoint list as argument after \"commands\".\n\
15454 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15455 (e.g. `5-7').\n\
15456 With no argument, the targeted breakpoint is the last one set.\n\
15457 The commands themselves follow starting on the next line.\n\
15458 Type a line containing \"end\" to indicate the end of them.\n\
15459 Give \"silent\" as the first line to make the breakpoint silent;\n\
15460 then no output is printed when it is hit, except what the commands print."));
15461
15462   c = add_com ("condition", class_breakpoint, condition_command, _("\
15463 Specify breakpoint number N to break only if COND is true.\n\
15464 Usage is `condition N COND', where N is an integer and COND is an\n\
15465 expression to be evaluated whenever breakpoint N is reached."));
15466   set_cmd_completer (c, condition_completer);
15467
15468   c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
15469 Set a temporary breakpoint.\n\
15470 Like \"break\" except the breakpoint is only temporary,\n\
15471 so it will be deleted when hit.  Equivalent to \"break\" followed\n\
15472 by using \"enable delete\" on the breakpoint number.\n\
15473 \n"
15474 BREAK_ARGS_HELP ("tbreak")));
15475   set_cmd_completer (c, location_completer);
15476
15477   c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
15478 Set a hardware assisted breakpoint.\n\
15479 Like \"break\" except the breakpoint requires hardware support,\n\
15480 some target hardware may not have this support.\n\
15481 \n"
15482 BREAK_ARGS_HELP ("hbreak")));
15483   set_cmd_completer (c, location_completer);
15484
15485   c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
15486 Set a temporary hardware assisted breakpoint.\n\
15487 Like \"hbreak\" except the breakpoint is only temporary,\n\
15488 so it will be deleted when hit.\n\
15489 \n"
15490 BREAK_ARGS_HELP ("thbreak")));
15491   set_cmd_completer (c, location_completer);
15492
15493   add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
15494 Enable some breakpoints.\n\
15495 Give breakpoint numbers (separated by spaces) as arguments.\n\
15496 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15497 This is used to cancel the effect of the \"disable\" command.\n\
15498 With a subcommand you can enable temporarily."),
15499                   &enablelist, "enable ", 1, &cmdlist);
15500
15501   add_com_alias ("en", "enable", class_breakpoint, 1);
15502
15503   add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
15504 Enable some breakpoints.\n\
15505 Give breakpoint numbers (separated by spaces) as arguments.\n\
15506 This is used to cancel the effect of the \"disable\" command.\n\
15507 May be abbreviated to simply \"enable\".\n"),
15508                    &enablebreaklist, "enable breakpoints ", 1, &enablelist);
15509
15510   add_cmd ("once", no_class, enable_once_command, _("\
15511 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
15512 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15513            &enablebreaklist);
15514
15515   add_cmd ("delete", no_class, enable_delete_command, _("\
15516 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
15517 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15518            &enablebreaklist);
15519
15520   add_cmd ("count", no_class, enable_count_command, _("\
15521 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
15522 If a breakpoint is hit while enabled in this fashion,\n\
15523 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15524            &enablebreaklist);
15525
15526   add_cmd ("delete", no_class, enable_delete_command, _("\
15527 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
15528 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15529            &enablelist);
15530
15531   add_cmd ("once", no_class, enable_once_command, _("\
15532 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
15533 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15534            &enablelist);
15535
15536   add_cmd ("count", no_class, enable_count_command, _("\
15537 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
15538 If a breakpoint is hit while enabled in this fashion,\n\
15539 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15540            &enablelist);
15541
15542   add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
15543 Disable some breakpoints.\n\
15544 Arguments are breakpoint numbers with spaces in between.\n\
15545 To disable all breakpoints, give no argument.\n\
15546 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15547                   &disablelist, "disable ", 1, &cmdlist);
15548   add_com_alias ("dis", "disable", class_breakpoint, 1);
15549   add_com_alias ("disa", "disable", class_breakpoint, 1);
15550
15551   add_cmd ("breakpoints", class_alias, disable_command, _("\
15552 Disable some breakpoints.\n\
15553 Arguments are breakpoint numbers with spaces in between.\n\
15554 To disable all breakpoints, give no argument.\n\
15555 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15556 This command may be abbreviated \"disable\"."),
15557            &disablelist);
15558
15559   add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
15560 Delete some breakpoints or auto-display expressions.\n\
15561 Arguments are breakpoint numbers with spaces in between.\n\
15562 To delete all breakpoints, give no argument.\n\
15563 \n\
15564 Also a prefix command for deletion of other GDB objects.\n\
15565 The \"unset\" command is also an alias for \"delete\"."),
15566                   &deletelist, "delete ", 1, &cmdlist);
15567   add_com_alias ("d", "delete", class_breakpoint, 1);
15568   add_com_alias ("del", "delete", class_breakpoint, 1);
15569
15570   add_cmd ("breakpoints", class_alias, delete_command, _("\
15571 Delete some breakpoints or auto-display expressions.\n\
15572 Arguments are breakpoint numbers with spaces in between.\n\
15573 To delete all breakpoints, give no argument.\n\
15574 This command may be abbreviated \"delete\"."),
15575            &deletelist);
15576
15577   add_com ("clear", class_breakpoint, clear_command, _("\
15578 Clear breakpoint at specified location.\n\
15579 Argument may be a linespec, explicit, or address location as described below.\n\
15580 \n\
15581 With no argument, clears all breakpoints in the line that the selected frame\n\
15582 is executing in.\n"
15583 "\n" LOCATION_HELP_STRING "\n\
15584 See also the \"delete\" command which clears breakpoints by number."));
15585   add_com_alias ("cl", "clear", class_breakpoint, 1);
15586
15587   c = add_com ("break", class_breakpoint, break_command, _("\
15588 Set breakpoint at specified location.\n"
15589 BREAK_ARGS_HELP ("break")));
15590   set_cmd_completer (c, location_completer);
15591
15592   add_com_alias ("b", "break", class_run, 1);
15593   add_com_alias ("br", "break", class_run, 1);
15594   add_com_alias ("bre", "break", class_run, 1);
15595   add_com_alias ("brea", "break", class_run, 1);
15596
15597   if (dbx_commands)
15598     {
15599       add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
15600 Break in function/address or break at a line in the current file."),
15601                              &stoplist, "stop ", 1, &cmdlist);
15602       add_cmd ("in", class_breakpoint, stopin_command,
15603                _("Break in function or address."), &stoplist);
15604       add_cmd ("at", class_breakpoint, stopat_command,
15605                _("Break at a line in the current file."), &stoplist);
15606       add_com ("status", class_info, info_breakpoints_command, _("\
15607 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15608 The \"Type\" column indicates one of:\n\
15609 \tbreakpoint     - normal breakpoint\n\
15610 \twatchpoint     - watchpoint\n\
15611 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15612 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15613 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15614 address and file/line number respectively.\n\
15615 \n\
15616 Convenience variable \"$_\" and default examine address for \"x\"\n\
15617 are set to the address of the last breakpoint listed unless the command\n\
15618 is prefixed with \"server \".\n\n\
15619 Convenience variable \"$bpnum\" contains the number of the last\n\
15620 breakpoint set."));
15621     }
15622
15623   add_info ("breakpoints", info_breakpoints_command, _("\
15624 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15625 The \"Type\" column indicates one of:\n\
15626 \tbreakpoint     - normal breakpoint\n\
15627 \twatchpoint     - watchpoint\n\
15628 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15629 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15630 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15631 address and file/line number respectively.\n\
15632 \n\
15633 Convenience variable \"$_\" and default examine address for \"x\"\n\
15634 are set to the address of the last breakpoint listed unless the command\n\
15635 is prefixed with \"server \".\n\n\
15636 Convenience variable \"$bpnum\" contains the number of the last\n\
15637 breakpoint set."));
15638
15639   add_info_alias ("b", "breakpoints", 1);
15640
15641   add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
15642 Status of all breakpoints, or breakpoint number NUMBER.\n\
15643 The \"Type\" column indicates one of:\n\
15644 \tbreakpoint     - normal breakpoint\n\
15645 \twatchpoint     - watchpoint\n\
15646 \tlongjmp        - internal breakpoint used to step through longjmp()\n\
15647 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15648 \tuntil          - internal breakpoint used by the \"until\" command\n\
15649 \tfinish         - internal breakpoint used by the \"finish\" command\n\
15650 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15651 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15652 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15653 address and file/line number respectively.\n\
15654 \n\
15655 Convenience variable \"$_\" and default examine address for \"x\"\n\
15656 are set to the address of the last breakpoint listed unless the command\n\
15657 is prefixed with \"server \".\n\n\
15658 Convenience variable \"$bpnum\" contains the number of the last\n\
15659 breakpoint set."),
15660            &maintenanceinfolist);
15661
15662   add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
15663 Set catchpoints to catch events."),
15664                   &catch_cmdlist, "catch ",
15665                   0/*allow-unknown*/, &cmdlist);
15666
15667   add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
15668 Set temporary catchpoints to catch events."),
15669                   &tcatch_cmdlist, "tcatch ",
15670                   0/*allow-unknown*/, &cmdlist);
15671
15672   add_catch_command ("fork", _("Catch calls to fork."),
15673                      catch_fork_command_1,
15674                      NULL,
15675                      (void *) (uintptr_t) catch_fork_permanent,
15676                      (void *) (uintptr_t) catch_fork_temporary);
15677   add_catch_command ("vfork", _("Catch calls to vfork."),
15678                      catch_fork_command_1,
15679                      NULL,
15680                      (void *) (uintptr_t) catch_vfork_permanent,
15681                      (void *) (uintptr_t) catch_vfork_temporary);
15682   add_catch_command ("exec", _("Catch calls to exec."),
15683                      catch_exec_command_1,
15684                      NULL,
15685                      CATCH_PERMANENT,
15686                      CATCH_TEMPORARY);
15687   add_catch_command ("load", _("Catch loads of shared libraries.\n\
15688 Usage: catch load [REGEX]\n\
15689 If REGEX is given, only stop for libraries matching the regular expression."),
15690                      catch_load_command_1,
15691                      NULL,
15692                      CATCH_PERMANENT,
15693                      CATCH_TEMPORARY);
15694   add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15695 Usage: catch unload [REGEX]\n\
15696 If REGEX is given, only stop for libraries matching the regular expression."),
15697                      catch_unload_command_1,
15698                      NULL,
15699                      CATCH_PERMANENT,
15700                      CATCH_TEMPORARY);
15701
15702   c = add_com ("watch", class_breakpoint, watch_command, _("\
15703 Set a watchpoint for an expression.\n\
15704 Usage: watch [-l|-location] EXPRESSION\n\
15705 A watchpoint stops execution of your program whenever the value of\n\
15706 an expression changes.\n\
15707 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15708 the memory to which it refers."));
15709   set_cmd_completer (c, expression_completer);
15710
15711   c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
15712 Set a read watchpoint for an expression.\n\
15713 Usage: rwatch [-l|-location] EXPRESSION\n\
15714 A watchpoint stops execution of your program whenever the value of\n\
15715 an expression is read.\n\
15716 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15717 the memory to which it refers."));
15718   set_cmd_completer (c, expression_completer);
15719
15720   c = add_com ("awatch", class_breakpoint, awatch_command, _("\
15721 Set a watchpoint for an expression.\n\
15722 Usage: awatch [-l|-location] EXPRESSION\n\
15723 A watchpoint stops execution of your program whenever the value of\n\
15724 an expression is either read or written.\n\
15725 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15726 the memory to which it refers."));
15727   set_cmd_completer (c, expression_completer);
15728
15729   add_info ("watchpoints", info_watchpoints_command, _("\
15730 Status of specified watchpoints (all watchpoints if no argument)."));
15731
15732   /* XXX: cagney/2005-02-23: This should be a boolean, and should
15733      respond to changes - contrary to the description.  */
15734   add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
15735                             &can_use_hw_watchpoints, _("\
15736 Set debugger's willingness to use watchpoint hardware."), _("\
15737 Show debugger's willingness to use watchpoint hardware."), _("\
15738 If zero, gdb will not use hardware for new watchpoints, even if\n\
15739 such is available.  (However, any hardware watchpoints that were\n\
15740 created before setting this to nonzero, will continue to use watchpoint\n\
15741 hardware.)"),
15742                             NULL,
15743                             show_can_use_hw_watchpoints,
15744                             &setlist, &showlist);
15745
15746   can_use_hw_watchpoints = 1;
15747
15748   /* Tracepoint manipulation commands.  */
15749
15750   c = add_com ("trace", class_breakpoint, trace_command, _("\
15751 Set a tracepoint at specified location.\n\
15752 \n"
15753 BREAK_ARGS_HELP ("trace") "\n\
15754 Do \"help tracepoints\" for info on other tracepoint commands."));
15755   set_cmd_completer (c, location_completer);
15756
15757   add_com_alias ("tp", "trace", class_alias, 0);
15758   add_com_alias ("tr", "trace", class_alias, 1);
15759   add_com_alias ("tra", "trace", class_alias, 1);
15760   add_com_alias ("trac", "trace", class_alias, 1);
15761
15762   c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
15763 Set a fast tracepoint at specified location.\n\
15764 \n"
15765 BREAK_ARGS_HELP ("ftrace") "\n\
15766 Do \"help tracepoints\" for info on other tracepoint commands."));
15767   set_cmd_completer (c, location_completer);
15768
15769   c = add_com ("strace", class_breakpoint, strace_command, _("\
15770 Set a static tracepoint at location or marker.\n\
15771 \n\
15772 strace [LOCATION] [if CONDITION]\n\
15773 LOCATION may be a linespec, explicit, or address location (described below) \n\
15774 or -m MARKER_ID.\n\n\
15775 If a marker id is specified, probe the marker with that name.  With\n\
15776 no LOCATION, uses current execution address of the selected stack frame.\n\
15777 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15778 This collects arbitrary user data passed in the probe point call to the\n\
15779 tracing library.  You can inspect it when analyzing the trace buffer,\n\
15780 by printing the $_sdata variable like any other convenience variable.\n\
15781 \n\
15782 CONDITION is a boolean expression.\n\
15783 \n" LOCATION_HELP_STRING "\n\
15784 Multiple tracepoints at one place are permitted, and useful if their\n\
15785 conditions are different.\n\
15786 \n\
15787 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15788 Do \"help tracepoints\" for info on other tracepoint commands."));
15789   set_cmd_completer (c, location_completer);
15790
15791   add_info ("tracepoints", info_tracepoints_command, _("\
15792 Status of specified tracepoints (all tracepoints if no argument).\n\
15793 Convenience variable \"$tpnum\" contains the number of the\n\
15794 last tracepoint set."));
15795
15796   add_info_alias ("tp", "tracepoints", 1);
15797
15798   add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
15799 Delete specified tracepoints.\n\
15800 Arguments are tracepoint numbers, separated by spaces.\n\
15801 No argument means delete all tracepoints."),
15802            &deletelist);
15803   add_alias_cmd ("tr", "tracepoints", class_trace, 1, &deletelist);
15804
15805   c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
15806 Disable specified tracepoints.\n\
15807 Arguments are tracepoint numbers, separated by spaces.\n\
15808 No argument means disable all tracepoints."),
15809            &disablelist);
15810   deprecate_cmd (c, "disable");
15811
15812   c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
15813 Enable specified tracepoints.\n\
15814 Arguments are tracepoint numbers, separated by spaces.\n\
15815 No argument means enable all tracepoints."),
15816            &enablelist);
15817   deprecate_cmd (c, "enable");
15818
15819   add_com ("passcount", class_trace, trace_pass_command, _("\
15820 Set the passcount for a tracepoint.\n\
15821 The trace will end when the tracepoint has been passed 'count' times.\n\
15822 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15823 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15824
15825   add_prefix_cmd ("save", class_breakpoint, save_command,
15826                   _("Save breakpoint definitions as a script."),
15827                   &save_cmdlist, "save ",
15828                   0/*allow-unknown*/, &cmdlist);
15829
15830   c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
15831 Save current breakpoint definitions as a script.\n\
15832 This includes all types of breakpoints (breakpoints, watchpoints,\n\
15833 catchpoints, tracepoints).  Use the 'source' command in another debug\n\
15834 session to restore them."),
15835                &save_cmdlist);
15836   set_cmd_completer (c, filename_completer);
15837
15838   c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
15839 Save current tracepoint definitions as a script.\n\
15840 Use the 'source' command in another debug session to restore them."),
15841                &save_cmdlist);
15842   set_cmd_completer (c, filename_completer);
15843
15844   c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
15845   deprecate_cmd (c, "save tracepoints");
15846
15847   add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
15848 Breakpoint specific settings\n\
15849 Configure various breakpoint-specific variables such as\n\
15850 pending breakpoint behavior"),
15851                   &breakpoint_set_cmdlist, "set breakpoint ",
15852                   0/*allow-unknown*/, &setlist);
15853   add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
15854 Breakpoint specific settings\n\
15855 Configure various breakpoint-specific variables such as\n\
15856 pending breakpoint behavior"),
15857                   &breakpoint_show_cmdlist, "show breakpoint ",
15858                   0/*allow-unknown*/, &showlist);
15859
15860   add_setshow_auto_boolean_cmd ("pending", no_class,
15861                                 &pending_break_support, _("\
15862 Set debugger's behavior regarding pending breakpoints."), _("\
15863 Show debugger's behavior regarding pending breakpoints."), _("\
15864 If on, an unrecognized breakpoint location will cause gdb to create a\n\
15865 pending breakpoint.  If off, an unrecognized breakpoint location results in\n\
15866 an error.  If auto, an unrecognized breakpoint location results in a\n\
15867 user-query to see if a pending breakpoint should be created."),
15868                                 NULL,
15869                                 show_pending_break_support,
15870                                 &breakpoint_set_cmdlist,
15871                                 &breakpoint_show_cmdlist);
15872
15873   pending_break_support = AUTO_BOOLEAN_AUTO;
15874
15875   add_setshow_boolean_cmd ("auto-hw", no_class,
15876                            &automatic_hardware_breakpoints, _("\
15877 Set automatic usage of hardware breakpoints."), _("\
15878 Show automatic usage of hardware breakpoints."), _("\
15879 If set, the debugger will automatically use hardware breakpoints for\n\
15880 breakpoints set with \"break\" but falling in read-only memory.  If not set,\n\
15881 a warning will be emitted for such breakpoints."),
15882                            NULL,
15883                            show_automatic_hardware_breakpoints,
15884                            &breakpoint_set_cmdlist,
15885                            &breakpoint_show_cmdlist);
15886
15887   add_setshow_boolean_cmd ("always-inserted", class_support,
15888                            &always_inserted_mode, _("\
15889 Set mode for inserting breakpoints."), _("\
15890 Show mode for inserting breakpoints."), _("\
15891 When this mode is on, breakpoints are inserted immediately as soon as\n\
15892 they're created, kept inserted even when execution stops, and removed\n\
15893 only when the user deletes them.  When this mode is off (the default),\n\
15894 breakpoints are inserted only when execution continues, and removed\n\
15895 when execution stops."),
15896                                 NULL,
15897                                 &show_always_inserted_mode,
15898                                 &breakpoint_set_cmdlist,
15899                                 &breakpoint_show_cmdlist);
15900
15901   add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
15902                         condition_evaluation_enums,
15903                         &condition_evaluation_mode_1, _("\
15904 Set mode of breakpoint condition evaluation."), _("\
15905 Show mode of breakpoint condition evaluation."), _("\
15906 When this is set to \"host\", breakpoint conditions will be\n\
15907 evaluated on the host's side by GDB.  When it is set to \"target\",\n\
15908 breakpoint conditions will be downloaded to the target (if the target\n\
15909 supports such feature) and conditions will be evaluated on the target's side.\n\
15910 If this is set to \"auto\" (default), this will be automatically set to\n\
15911 \"target\" if it supports condition evaluation, otherwise it will\n\
15912 be set to \"gdb\""),
15913                            &set_condition_evaluation_mode,
15914                            &show_condition_evaluation_mode,
15915                            &breakpoint_set_cmdlist,
15916                            &breakpoint_show_cmdlist);
15917
15918   add_com ("break-range", class_breakpoint, break_range_command, _("\
15919 Set a breakpoint for an address range.\n\
15920 break-range START-LOCATION, END-LOCATION\n\
15921 where START-LOCATION and END-LOCATION can be one of the following:\n\
15922   LINENUM, for that line in the current file,\n\
15923   FILE:LINENUM, for that line in that file,\n\
15924   +OFFSET, for that number of lines after the current line\n\
15925            or the start of the range\n\
15926   FUNCTION, for the first line in that function,\n\
15927   FILE:FUNCTION, to distinguish among like-named static functions.\n\
15928   *ADDRESS, for the instruction at that address.\n\
15929 \n\
15930 The breakpoint will stop execution of the inferior whenever it executes\n\
15931 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
15932 range (including START-LOCATION and END-LOCATION)."));
15933
15934   c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
15935 Set a dynamic printf at specified location.\n\
15936 dprintf location,format string,arg1,arg2,...\n\
15937 location may be a linespec, explicit, or address location.\n"
15938 "\n" LOCATION_HELP_STRING));
15939   set_cmd_completer (c, location_completer);
15940
15941   add_setshow_enum_cmd ("dprintf-style", class_support,
15942                         dprintf_style_enums, &dprintf_style, _("\
15943 Set the style of usage for dynamic printf."), _("\
15944 Show the style of usage for dynamic printf."), _("\
15945 This setting chooses how GDB will do a dynamic printf.\n\
15946 If the value is \"gdb\", then the printing is done by GDB to its own\n\
15947 console, as with the \"printf\" command.\n\
15948 If the value is \"call\", the print is done by calling a function in your\n\
15949 program; by default printf(), but you can choose a different function or\n\
15950 output stream by setting dprintf-function and dprintf-channel."),
15951                         update_dprintf_commands, NULL,
15952                         &setlist, &showlist);
15953
15954   dprintf_function = xstrdup ("printf");
15955   add_setshow_string_cmd ("dprintf-function", class_support,
15956                           &dprintf_function, _("\
15957 Set the function to use for dynamic printf"), _("\
15958 Show the function to use for dynamic printf"), NULL,
15959                           update_dprintf_commands, NULL,
15960                           &setlist, &showlist);
15961
15962   dprintf_channel = xstrdup ("");
15963   add_setshow_string_cmd ("dprintf-channel", class_support,
15964                           &dprintf_channel, _("\
15965 Set the channel to use for dynamic printf"), _("\
15966 Show the channel to use for dynamic printf"), NULL,
15967                           update_dprintf_commands, NULL,
15968                           &setlist, &showlist);
15969
15970   add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
15971                            &disconnected_dprintf, _("\
15972 Set whether dprintf continues after GDB disconnects."), _("\
15973 Show whether dprintf continues after GDB disconnects."), _("\
15974 Use this to let dprintf commands continue to hit and produce output\n\
15975 even if GDB disconnects or detaches from the target."),
15976                            NULL,
15977                            NULL,
15978                            &setlist, &showlist);
15979
15980   add_com ("agent-printf", class_vars, agent_printf_command, _("\
15981 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
15982 (target agent only) This is useful for formatted output in user-defined commands."));
15983
15984   automatic_hardware_breakpoints = 1;
15985
15986   gdb::observers::about_to_proceed.attach (breakpoint_about_to_proceed);
15987   gdb::observers::thread_exit.attach (remove_threaded_breakpoints);
15988 }