python: Make gdb.execute("show commands") work (PR 23669)
[external/binutils.git] / gdb / breakpoint.c
1 /* Everything about breakpoints, for GDB.
2
3    Copyright (C) 1986-2018 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include <ctype.h>
23 #include "hashtab.h"
24 #include "symtab.h"
25 #include "frame.h"
26 #include "breakpoint.h"
27 #include "tracepoint.h"
28 #include "gdbtypes.h"
29 #include "expression.h"
30 #include "gdbcore.h"
31 #include "gdbcmd.h"
32 #include "value.h"
33 #include "command.h"
34 #include "inferior.h"
35 #include "infrun.h"
36 #include "gdbthread.h"
37 #include "target.h"
38 #include "language.h"
39 #include "gdb-demangle.h"
40 #include "filenames.h"
41 #include "annotate.h"
42 #include "symfile.h"
43 #include "objfiles.h"
44 #include "source.h"
45 #include "linespec.h"
46 #include "completer.h"
47 #include "ui-out.h"
48 #include "cli/cli-script.h"
49 #include "block.h"
50 #include "solib.h"
51 #include "solist.h"
52 #include "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 "format.h"
69 #include "thread-fsm.h"
70 #include "tid-parse.h"
71
72 /* readline include files */
73 #include "readline/readline.h"
74 #include "readline/history.h"
75
76 /* readline defines this.  */
77 #undef savestring
78
79 #include "mi/mi-common.h"
80 #include "extension.h"
81 #include <algorithm>
82 #include "progspace-and-thread.h"
83 #include "common/array-view.h"
84 #include "common/gdb_optional.h"
85
86 /* Enums for exception-handling support.  */
87 enum exception_event_kind
88 {
89   EX_EVENT_THROW,
90   EX_EVENT_RETHROW,
91   EX_EVENT_CATCH
92 };
93
94 /* Prototypes for local functions.  */
95
96 static void map_breakpoint_numbers (const char *,
97                                     gdb::function_view<void (breakpoint *)>);
98
99 static void breakpoint_re_set_default (struct breakpoint *);
100
101 static void
102   create_sals_from_location_default (const struct event_location *location,
103                                      struct linespec_result *canonical,
104                                      enum bptype type_wanted);
105
106 static void create_breakpoints_sal_default (struct gdbarch *,
107                                             struct linespec_result *,
108                                             gdb::unique_xmalloc_ptr<char>,
109                                             gdb::unique_xmalloc_ptr<char>,
110                                             enum bptype,
111                                             enum bpdisp, int, int,
112                                             int,
113                                             const struct breakpoint_ops *,
114                                             int, int, int, unsigned);
115
116 static std::vector<symtab_and_line> decode_location_default
117   (struct breakpoint *b, const struct event_location *location,
118    struct program_space *search_pspace);
119
120 static int can_use_hardware_watchpoint
121     (const std::vector<value_ref_ptr> &vals);
122
123 static void mention (struct breakpoint *);
124
125 static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
126                                                                enum bptype,
127                                                                const struct breakpoint_ops *);
128 static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
129                                                        const struct symtab_and_line *);
130
131 /* This function is used in gdbtk sources and thus can not be made
132    static.  */
133 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
134                                        struct symtab_and_line,
135                                        enum bptype,
136                                        const struct breakpoint_ops *);
137
138 static struct breakpoint *
139   momentary_breakpoint_from_master (struct breakpoint *orig,
140                                     enum bptype type,
141                                     const struct breakpoint_ops *ops,
142                                     int loc_enabled);
143
144 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
145
146 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
147                                             CORE_ADDR bpaddr,
148                                             enum bptype bptype);
149
150 static void describe_other_breakpoints (struct gdbarch *,
151                                         struct program_space *, CORE_ADDR,
152                                         struct obj_section *, int);
153
154 static int watchpoint_locations_match (struct bp_location *loc1,
155                                        struct bp_location *loc2);
156
157 static int breakpoint_location_address_match (struct bp_location *bl,
158                                               const struct address_space *aspace,
159                                               CORE_ADDR addr);
160
161 static int breakpoint_location_address_range_overlap (struct bp_location *,
162                                                       const address_space *,
163                                                       CORE_ADDR, int);
164
165 static int remove_breakpoint (struct bp_location *);
166 static int remove_breakpoint_1 (struct bp_location *, enum remove_bp_reason);
167
168 static enum print_stop_action print_bp_stop_message (bpstat bs);
169
170 static int hw_breakpoint_used_count (void);
171
172 static int hw_watchpoint_use_count (struct breakpoint *);
173
174 static int hw_watchpoint_used_count_others (struct breakpoint *except,
175                                             enum bptype type,
176                                             int *other_type_used);
177
178 static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
179                                     int count);
180
181 static void free_bp_location (struct bp_location *loc);
182 static void incref_bp_location (struct bp_location *loc);
183 static void decref_bp_location (struct bp_location **loc);
184
185 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
186
187 /* update_global_location_list's modes of operation wrt to whether to
188    insert locations now.  */
189 enum ugll_insert_mode
190 {
191   /* Don't insert any breakpoint locations into the inferior, only
192      remove already-inserted locations that no longer should be
193      inserted.  Functions that delete a breakpoint or breakpoints
194      should specify this mode, so that deleting a breakpoint doesn't
195      have the side effect of inserting the locations of other
196      breakpoints that are marked not-inserted, but should_be_inserted
197      returns true on them.
198
199      This behavior is useful is situations close to tear-down -- e.g.,
200      after an exec, while the target still has execution, but
201      breakpoint shadows of the previous executable image should *NOT*
202      be restored to the new image; or before detaching, where the
203      target still has execution and wants to delete breakpoints from
204      GDB's lists, and all breakpoints had already been removed from
205      the inferior.  */
206   UGLL_DONT_INSERT,
207
208   /* May insert breakpoints iff breakpoints_should_be_inserted_now
209      claims breakpoints should be inserted now.  */
210   UGLL_MAY_INSERT,
211
212   /* Insert locations now, irrespective of
213      breakpoints_should_be_inserted_now.  E.g., say all threads are
214      stopped right now, and the user did "continue".  We need to
215      insert breakpoints _before_ resuming the target, but
216      UGLL_MAY_INSERT wouldn't insert them, because
217      breakpoints_should_be_inserted_now returns false at that point,
218      as no thread is running yet.  */
219   UGLL_INSERT
220 };
221
222 static void update_global_location_list (enum ugll_insert_mode);
223
224 static void update_global_location_list_nothrow (enum ugll_insert_mode);
225
226 static int is_hardware_watchpoint (const struct breakpoint *bpt);
227
228 static void insert_breakpoint_locations (void);
229
230 static void trace_pass_command (const char *, int);
231
232 static void set_tracepoint_count (int num);
233
234 static int is_masked_watchpoint (const struct breakpoint *b);
235
236 static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
237
238 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
239    otherwise.  */
240
241 static int strace_marker_p (struct breakpoint *b);
242
243 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
244    that are implemented on top of software or hardware breakpoints
245    (user breakpoints, internal and momentary breakpoints, etc.).  */
246 static struct breakpoint_ops bkpt_base_breakpoint_ops;
247
248 /* Internal breakpoints class type.  */
249 static struct breakpoint_ops internal_breakpoint_ops;
250
251 /* Momentary breakpoints class type.  */
252 static struct breakpoint_ops momentary_breakpoint_ops;
253
254 /* The breakpoint_ops structure to be used in regular user created
255    breakpoints.  */
256 struct breakpoint_ops bkpt_breakpoint_ops;
257
258 /* Breakpoints set on probes.  */
259 static struct breakpoint_ops bkpt_probe_breakpoint_ops;
260
261 /* Dynamic printf class type.  */
262 struct breakpoint_ops dprintf_breakpoint_ops;
263
264 /* The style in which to perform a dynamic printf.  This is a user
265    option because different output options have different tradeoffs;
266    if GDB does the printing, there is better error handling if there
267    is a problem with any of the arguments, but using an inferior
268    function lets you have special-purpose printers and sending of
269    output to the same place as compiled-in print functions.  */
270
271 static const char dprintf_style_gdb[] = "gdb";
272 static const char dprintf_style_call[] = "call";
273 static const char dprintf_style_agent[] = "agent";
274 static const char *const dprintf_style_enums[] = {
275   dprintf_style_gdb,
276   dprintf_style_call,
277   dprintf_style_agent,
278   NULL
279 };
280 static const char *dprintf_style = dprintf_style_gdb;
281
282 /* The function to use for dynamic printf if the preferred style is to
283    call into the inferior.  The value is simply a string that is
284    copied into the command, so it can be anything that GDB can
285    evaluate to a callable address, not necessarily a function name.  */
286
287 static char *dprintf_function;
288
289 /* The channel to use for dynamic printf if the preferred style is to
290    call into the inferior; if a nonempty string, it will be passed to
291    the call as the first argument, with the format string as the
292    second.  As with the dprintf function, this can be anything that
293    GDB knows how to evaluate, so in addition to common choices like
294    "stderr", this could be an app-specific expression like
295    "mystreams[curlogger]".  */
296
297 static char *dprintf_channel;
298
299 /* True if dprintf commands should continue to operate even if GDB
300    has disconnected.  */
301 static int disconnected_dprintf = 1;
302
303 struct command_line *
304 breakpoint_commands (struct breakpoint *b)
305 {
306   return b->commands ? b->commands.get () : NULL;
307 }
308
309 /* Flag indicating that a command has proceeded the inferior past the
310    current breakpoint.  */
311
312 static int breakpoint_proceeded;
313
314 const char *
315 bpdisp_text (enum bpdisp disp)
316 {
317   /* NOTE: the following values are a part of MI protocol and
318      represent values of 'disp' field returned when inferior stops at
319      a breakpoint.  */
320   static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
321
322   return bpdisps[(int) disp];
323 }
324
325 /* Prototypes for exported functions.  */
326 /* If FALSE, gdb will not use hardware support for watchpoints, even
327    if such is available.  */
328 static int can_use_hw_watchpoints;
329
330 static void
331 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
332                              struct cmd_list_element *c,
333                              const char *value)
334 {
335   fprintf_filtered (file,
336                     _("Debugger's willingness to use "
337                       "watchpoint hardware is %s.\n"),
338                     value);
339 }
340
341 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
342    If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
343    for unrecognized breakpoint locations.
344    If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized.  */
345 static enum auto_boolean pending_break_support;
346 static void
347 show_pending_break_support (struct ui_file *file, int from_tty,
348                             struct cmd_list_element *c,
349                             const char *value)
350 {
351   fprintf_filtered (file,
352                     _("Debugger's behavior regarding "
353                       "pending breakpoints is %s.\n"),
354                     value);
355 }
356
357 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
358    set with "break" but falling in read-only memory.
359    If 0, gdb will warn about such breakpoints, but won't automatically
360    use hardware breakpoints.  */
361 static int automatic_hardware_breakpoints;
362 static void
363 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
364                                      struct cmd_list_element *c,
365                                      const char *value)
366 {
367   fprintf_filtered (file,
368                     _("Automatic usage of hardware breakpoints is %s.\n"),
369                     value);
370 }
371
372 /* If on, GDB keeps breakpoints inserted even if the inferior is
373    stopped, and immediately inserts any new breakpoints as soon as
374    they're created.  If off (default), GDB keeps breakpoints off of
375    the target as long as possible.  That is, it delays inserting
376    breakpoints until the next resume, and removes them again when the
377    target fully stops.  This is a bit safer in case GDB crashes while
378    processing user input.  */
379 static int always_inserted_mode = 0;
380
381 static void
382 show_always_inserted_mode (struct ui_file *file, int from_tty,
383                      struct cmd_list_element *c, const char *value)
384 {
385   fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
386                     value);
387 }
388
389 /* See breakpoint.h.  */
390
391 int
392 breakpoints_should_be_inserted_now (void)
393 {
394   if (gdbarch_has_global_breakpoints (target_gdbarch ()))
395     {
396       /* If breakpoints are global, they should be inserted even if no
397          thread under gdb's control is running, or even if there are
398          no threads under GDB's control yet.  */
399       return 1;
400     }
401   else if (target_has_execution)
402     {
403       struct thread_info *tp;
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       ALL_NON_EXITED_THREADS (tp)
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.reset ();
884           arg = exp;
885           w->cond_exp = parse_exp_1 (&arg, 0, 0, 0);
886           if (*arg)
887             error (_("Junk at end of expression"));
888           w->cond_exp_valid_block = innermost_block.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 (ex, RETURN_MASK_ERROR)
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   END_CATCH
2112
2113   /* We have a valid agent expression.  */
2114   return aexpr;
2115 }
2116
2117 /* Based on location BL, create a list of breakpoint conditions to be
2118    passed on to the target.  If we have duplicated locations with different
2119    conditions, we will add such conditions to the list.  The idea is that the
2120    target will evaluate the list of conditions and will only notify GDB when
2121    one of them is true.  */
2122
2123 static void
2124 build_target_condition_list (struct bp_location *bl)
2125 {
2126   struct bp_location **locp = NULL, **loc2p;
2127   int null_condition_or_parse_error = 0;
2128   int modified = bl->needs_update;
2129   struct bp_location *loc;
2130
2131   /* Release conditions left over from a previous insert.  */
2132   bl->target_info.conditions.clear ();
2133
2134   /* This is only meaningful if the target is
2135      evaluating conditions and if the user has
2136      opted for condition evaluation on the target's
2137      side.  */
2138   if (gdb_evaluates_breakpoint_condition_p ()
2139       || !target_supports_evaluation_of_breakpoint_conditions ())
2140     return;
2141
2142   /* Do a first pass to check for locations with no assigned
2143      conditions or conditions that fail to parse to a valid agent expression
2144      bytecode.  If any of these happen, then it's no use to send conditions
2145      to the target since this location will always trigger and generate a
2146      response back to GDB.  */
2147   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2148     {
2149       loc = (*loc2p);
2150       if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2151         {
2152           if (modified)
2153             {
2154               /* Re-parse the conditions since something changed.  In that
2155                  case we already freed the condition bytecodes (see
2156                  force_breakpoint_reinsertion).  We just
2157                  need to parse the condition to bytecodes again.  */
2158               loc->cond_bytecode = parse_cond_to_aexpr (bl->address,
2159                                                         loc->cond.get ());
2160             }
2161
2162           /* If we have a NULL bytecode expression, it means something
2163              went wrong or we have a null condition expression.  */
2164           if (!loc->cond_bytecode)
2165             {
2166               null_condition_or_parse_error = 1;
2167               break;
2168             }
2169         }
2170     }
2171
2172   /* If any of these happened, it means we will have to evaluate the conditions
2173      for the location's address on gdb's side.  It is no use keeping bytecodes
2174      for all the other duplicate locations, thus we free all of them here.
2175
2176      This is so we have a finer control over which locations' conditions are
2177      being evaluated by GDB or the remote stub.  */
2178   if (null_condition_or_parse_error)
2179     {
2180       ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2181         {
2182           loc = (*loc2p);
2183           if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2184             {
2185               /* Only go as far as the first NULL bytecode is
2186                  located.  */
2187               if (!loc->cond_bytecode)
2188                 return;
2189
2190               loc->cond_bytecode.reset ();
2191             }
2192         }
2193     }
2194
2195   /* No NULL conditions or failed bytecode generation.  Build a condition list
2196      for this location's address.  */
2197   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2198     {
2199       loc = (*loc2p);
2200       if (loc->cond
2201           && is_breakpoint (loc->owner)
2202           && loc->pspace->num == bl->pspace->num
2203           && loc->owner->enable_state == bp_enabled
2204           && loc->enabled)
2205         {
2206           /* Add the condition to the vector.  This will be used later
2207              to send the conditions to the target.  */
2208           bl->target_info.conditions.push_back (loc->cond_bytecode.get ());
2209         }
2210     }
2211
2212   return;
2213 }
2214
2215 /* Parses a command described by string CMD into an agent expression
2216    bytecode suitable for evaluation by the bytecode interpreter.
2217    Return NULL if there was any error during parsing.  */
2218
2219 static agent_expr_up
2220 parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
2221 {
2222   const char *cmdrest;
2223   const char *format_start, *format_end;
2224   struct gdbarch *gdbarch = get_current_arch ();
2225
2226   if (cmd == NULL)
2227     return NULL;
2228
2229   cmdrest = cmd;
2230
2231   if (*cmdrest == ',')
2232     ++cmdrest;
2233   cmdrest = skip_spaces (cmdrest);
2234
2235   if (*cmdrest++ != '"')
2236     error (_("No format string following the location"));
2237
2238   format_start = cmdrest;
2239
2240   format_pieces fpieces (&cmdrest);
2241
2242   format_end = cmdrest;
2243
2244   if (*cmdrest++ != '"')
2245     error (_("Bad format string, non-terminated '\"'."));
2246   
2247   cmdrest = skip_spaces (cmdrest);
2248
2249   if (!(*cmdrest == ',' || *cmdrest == '\0'))
2250     error (_("Invalid argument syntax"));
2251
2252   if (*cmdrest == ',')
2253     cmdrest++;
2254   cmdrest = skip_spaces (cmdrest);
2255
2256   /* For each argument, make an expression.  */
2257
2258   std::vector<struct expression *> argvec;
2259   while (*cmdrest != '\0')
2260     {
2261       const char *cmd1;
2262
2263       cmd1 = cmdrest;
2264       expression_up expr = parse_exp_1 (&cmd1, scope, block_for_pc (scope), 1);
2265       argvec.push_back (expr.release ());
2266       cmdrest = cmd1;
2267       if (*cmdrest == ',')
2268         ++cmdrest;
2269     }
2270
2271   agent_expr_up aexpr;
2272
2273   /* We don't want to stop processing, so catch any errors
2274      that may show up.  */
2275   TRY
2276     {
2277       aexpr = gen_printf (scope, gdbarch, 0, 0,
2278                           format_start, format_end - format_start,
2279                           argvec.size (), argvec.data ());
2280     }
2281   CATCH (ex, RETURN_MASK_ERROR)
2282     {
2283       /* If we got here, it means the command could not be parsed to a valid
2284          bytecode expression and thus can't be evaluated on the target's side.
2285          It's no use iterating through the other commands.  */
2286     }
2287   END_CATCH
2288
2289   /* We have a valid agent expression, return it.  */
2290   return aexpr;
2291 }
2292
2293 /* Based on location BL, create a list of breakpoint commands to be
2294    passed on to the target.  If we have duplicated locations with
2295    different commands, we will add any such to the list.  */
2296
2297 static void
2298 build_target_command_list (struct bp_location *bl)
2299 {
2300   struct bp_location **locp = NULL, **loc2p;
2301   int null_command_or_parse_error = 0;
2302   int modified = bl->needs_update;
2303   struct bp_location *loc;
2304
2305   /* Clear commands left over from a previous insert.  */
2306   bl->target_info.tcommands.clear ();
2307
2308   if (!target_can_run_breakpoint_commands ())
2309     return;
2310
2311   /* For now, limit to agent-style dprintf breakpoints.  */
2312   if (dprintf_style != dprintf_style_agent)
2313     return;
2314
2315   /* For now, if we have any duplicate location that isn't a dprintf,
2316      don't install the target-side commands, as that would make the
2317      breakpoint not be reported to the core, and we'd lose
2318      control.  */
2319   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2320     {
2321       loc = (*loc2p);
2322       if (is_breakpoint (loc->owner)
2323           && loc->pspace->num == bl->pspace->num
2324           && loc->owner->type != bp_dprintf)
2325         return;
2326     }
2327
2328   /* Do a first pass to check for locations with no assigned
2329      conditions or conditions that fail to parse to a valid agent expression
2330      bytecode.  If any of these happen, then it's no use to send conditions
2331      to the target since this location will always trigger and generate a
2332      response back to GDB.  */
2333   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2334     {
2335       loc = (*loc2p);
2336       if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2337         {
2338           if (modified)
2339             {
2340               /* Re-parse the commands since something changed.  In that
2341                  case we already freed the command bytecodes (see
2342                  force_breakpoint_reinsertion).  We just
2343                  need to parse the command to bytecodes again.  */
2344               loc->cmd_bytecode
2345                 = parse_cmd_to_aexpr (bl->address,
2346                                       loc->owner->extra_string);
2347             }
2348
2349           /* If we have a NULL bytecode expression, it means something
2350              went wrong or we have a null command expression.  */
2351           if (!loc->cmd_bytecode)
2352             {
2353               null_command_or_parse_error = 1;
2354               break;
2355             }
2356         }
2357     }
2358
2359   /* If anything failed, then we're not doing target-side commands,
2360      and so clean up.  */
2361   if (null_command_or_parse_error)
2362     {
2363       ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2364         {
2365           loc = (*loc2p);
2366           if (is_breakpoint (loc->owner)
2367               && loc->pspace->num == bl->pspace->num)
2368             {
2369               /* Only go as far as the first NULL bytecode is
2370                  located.  */
2371               if (loc->cmd_bytecode == NULL)
2372                 return;
2373
2374               loc->cmd_bytecode.reset ();
2375             }
2376         }
2377     }
2378
2379   /* No NULL commands or failed bytecode generation.  Build a command list
2380      for this location's address.  */
2381   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2382     {
2383       loc = (*loc2p);
2384       if (loc->owner->extra_string
2385           && is_breakpoint (loc->owner)
2386           && loc->pspace->num == bl->pspace->num
2387           && loc->owner->enable_state == bp_enabled
2388           && loc->enabled)
2389         {
2390           /* Add the command to the vector.  This will be used later
2391              to send the commands to the target.  */
2392           bl->target_info.tcommands.push_back (loc->cmd_bytecode.get ());
2393         }
2394     }
2395
2396   bl->target_info.persist = 0;
2397   /* Maybe flag this location as persistent.  */
2398   if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2399     bl->target_info.persist = 1;
2400 }
2401
2402 /* Return the kind of breakpoint on address *ADDR.  Get the kind
2403    of breakpoint according to ADDR except single-step breakpoint.
2404    Get the kind of single-step breakpoint according to the current
2405    registers state.  */
2406
2407 static int
2408 breakpoint_kind (struct bp_location *bl, CORE_ADDR *addr)
2409 {
2410   if (bl->owner->type == bp_single_step)
2411     {
2412       struct thread_info *thr = find_thread_global_id (bl->owner->thread);
2413       struct regcache *regcache;
2414
2415       regcache = get_thread_regcache (thr);
2416
2417       return gdbarch_breakpoint_kind_from_current_state (bl->gdbarch,
2418                                                          regcache, addr);
2419     }
2420   else
2421     return gdbarch_breakpoint_kind_from_pc (bl->gdbarch, addr);
2422 }
2423
2424 /* Insert a low-level "breakpoint" of some type.  BL is the breakpoint
2425    location.  Any error messages are printed to TMP_ERROR_STREAM; and
2426    DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2427    Returns 0 for success, 1 if the bp_location type is not supported or
2428    -1 for failure.
2429
2430    NOTE drow/2003-09-09: This routine could be broken down to an
2431    object-style method for each breakpoint or catchpoint type.  */
2432 static int
2433 insert_bp_location (struct bp_location *bl,
2434                     struct ui_file *tmp_error_stream,
2435                     int *disabled_breaks,
2436                     int *hw_breakpoint_error,
2437                     int *hw_bp_error_explained_already)
2438 {
2439   gdb_exception bp_excpt = exception_none;
2440
2441   if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2442     return 0;
2443
2444   /* Note we don't initialize bl->target_info, as that wipes out
2445      the breakpoint location's shadow_contents if the breakpoint
2446      is still inserted at that location.  This in turn breaks
2447      target_read_memory which depends on these buffers when
2448      a memory read is requested at the breakpoint location:
2449      Once the target_info has been wiped, we fail to see that
2450      we have a breakpoint inserted at that address and thus
2451      read the breakpoint instead of returning the data saved in
2452      the breakpoint location's shadow contents.  */
2453   bl->target_info.reqstd_address = bl->address;
2454   bl->target_info.placed_address_space = bl->pspace->aspace;
2455   bl->target_info.length = bl->length;
2456
2457   /* When working with target-side conditions, we must pass all the conditions
2458      for the same breakpoint address down to the target since GDB will not
2459      insert those locations.  With a list of breakpoint conditions, the target
2460      can decide when to stop and notify GDB.  */
2461
2462   if (is_breakpoint (bl->owner))
2463     {
2464       build_target_condition_list (bl);
2465       build_target_command_list (bl);
2466       /* Reset the modification marker.  */
2467       bl->needs_update = 0;
2468     }
2469
2470   if (bl->loc_type == bp_loc_software_breakpoint
2471       || bl->loc_type == bp_loc_hardware_breakpoint)
2472     {
2473       if (bl->owner->type != bp_hardware_breakpoint)
2474         {
2475           /* If the explicitly specified breakpoint type
2476              is not hardware breakpoint, check the memory map to see
2477              if the breakpoint address is in read only memory or not.
2478
2479              Two important cases are:
2480              - location type is not hardware breakpoint, memory
2481              is readonly.  We change the type of the location to
2482              hardware breakpoint.
2483              - location type is hardware breakpoint, memory is
2484              read-write.  This means we've previously made the
2485              location hardware one, but then the memory map changed,
2486              so we undo.
2487              
2488              When breakpoints are removed, remove_breakpoints will use
2489              location types we've just set here, the only possible
2490              problem is that memory map has changed during running
2491              program, but it's not going to work anyway with current
2492              gdb.  */
2493           struct mem_region *mr 
2494             = lookup_mem_region (bl->target_info.reqstd_address);
2495           
2496           if (mr)
2497             {
2498               if (automatic_hardware_breakpoints)
2499                 {
2500                   enum bp_loc_type new_type;
2501                   
2502                   if (mr->attrib.mode != MEM_RW)
2503                     new_type = bp_loc_hardware_breakpoint;
2504                   else 
2505                     new_type = bp_loc_software_breakpoint;
2506                   
2507                   if (new_type != bl->loc_type)
2508                     {
2509                       static int said = 0;
2510
2511                       bl->loc_type = new_type;
2512                       if (!said)
2513                         {
2514                           fprintf_filtered (gdb_stdout,
2515                                             _("Note: automatically using "
2516                                               "hardware breakpoints for "
2517                                               "read-only addresses.\n"));
2518                           said = 1;
2519                         }
2520                     }
2521                 }
2522               else if (bl->loc_type == bp_loc_software_breakpoint
2523                        && mr->attrib.mode != MEM_RW)
2524                 {
2525                   fprintf_unfiltered (tmp_error_stream,
2526                                       _("Cannot insert breakpoint %d.\n"
2527                                         "Cannot set software breakpoint "
2528                                         "at read-only address %s\n"),
2529                                       bl->owner->number,
2530                                       paddress (bl->gdbarch, bl->address));
2531                   return 1;
2532                 }
2533             }
2534         }
2535         
2536       /* First check to see if we have to handle an overlay.  */
2537       if (overlay_debugging == ovly_off
2538           || bl->section == NULL
2539           || !(section_is_overlay (bl->section)))
2540         {
2541           /* No overlay handling: just set the breakpoint.  */
2542           TRY
2543             {
2544               int val;
2545
2546               val = bl->owner->ops->insert_location (bl);
2547               if (val)
2548                 bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2549             }
2550           CATCH (e, RETURN_MASK_ALL)
2551             {
2552               bp_excpt = e;
2553             }
2554           END_CATCH
2555         }
2556       else
2557         {
2558           /* This breakpoint is in an overlay section.
2559              Shall we set a breakpoint at the LMA?  */
2560           if (!overlay_events_enabled)
2561             {
2562               /* Yes -- overlay event support is not active, 
2563                  so we must try to set a breakpoint at the LMA.
2564                  This will not work for a hardware breakpoint.  */
2565               if (bl->loc_type == bp_loc_hardware_breakpoint)
2566                 warning (_("hardware breakpoint %d not supported in overlay!"),
2567                          bl->owner->number);
2568               else
2569                 {
2570                   CORE_ADDR addr = overlay_unmapped_address (bl->address,
2571                                                              bl->section);
2572                   /* Set a software (trap) breakpoint at the LMA.  */
2573                   bl->overlay_target_info = bl->target_info;
2574                   bl->overlay_target_info.reqstd_address = addr;
2575
2576                   /* No overlay handling: just set the breakpoint.  */
2577                   TRY
2578                     {
2579                       int val;
2580
2581                       bl->overlay_target_info.kind
2582                         = breakpoint_kind (bl, &addr);
2583                       bl->overlay_target_info.placed_address = addr;
2584                       val = target_insert_breakpoint (bl->gdbarch,
2585                                                       &bl->overlay_target_info);
2586                       if (val)
2587                         bp_excpt
2588                           = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2589                     }
2590                   CATCH (e, RETURN_MASK_ALL)
2591                     {
2592                       bp_excpt = e;
2593                     }
2594                   END_CATCH
2595
2596                   if (bp_excpt.reason != 0)
2597                     fprintf_unfiltered (tmp_error_stream,
2598                                         "Overlay breakpoint %d "
2599                                         "failed: in ROM?\n",
2600                                         bl->owner->number);
2601                 }
2602             }
2603           /* Shall we set a breakpoint at the VMA? */
2604           if (section_is_mapped (bl->section))
2605             {
2606               /* Yes.  This overlay section is mapped into memory.  */
2607               TRY
2608                 {
2609                   int val;
2610
2611                   val = bl->owner->ops->insert_location (bl);
2612                   if (val)
2613                     bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2614                 }
2615               CATCH (e, RETURN_MASK_ALL)
2616                 {
2617                   bp_excpt = e;
2618                 }
2619               END_CATCH
2620             }
2621           else
2622             {
2623               /* No.  This breakpoint will not be inserted.  
2624                  No error, but do not mark the bp as 'inserted'.  */
2625               return 0;
2626             }
2627         }
2628
2629       if (bp_excpt.reason != 0)
2630         {
2631           /* Can't set the breakpoint.  */
2632
2633           /* In some cases, we might not be able to insert a
2634              breakpoint in a shared library that has already been
2635              removed, but we have not yet processed the shlib unload
2636              event.  Unfortunately, some targets that implement
2637              breakpoint insertion themselves can't tell why the
2638              breakpoint insertion failed (e.g., the remote target
2639              doesn't define error codes), so we must treat generic
2640              errors as memory errors.  */
2641           if (bp_excpt.reason == RETURN_ERROR
2642               && (bp_excpt.error == GENERIC_ERROR
2643                   || bp_excpt.error == MEMORY_ERROR)
2644               && bl->loc_type == bp_loc_software_breakpoint
2645               && (solib_name_from_address (bl->pspace, bl->address)
2646                   || shared_objfile_contains_address_p (bl->pspace,
2647                                                         bl->address)))
2648             {
2649               /* See also: disable_breakpoints_in_shlibs.  */
2650               bl->shlib_disabled = 1;
2651               gdb::observers::breakpoint_modified.notify (bl->owner);
2652               if (!*disabled_breaks)
2653                 {
2654                   fprintf_unfiltered (tmp_error_stream, 
2655                                       "Cannot insert breakpoint %d.\n", 
2656                                       bl->owner->number);
2657                   fprintf_unfiltered (tmp_error_stream, 
2658                                       "Temporarily disabling shared "
2659                                       "library breakpoints:\n");
2660                 }
2661               *disabled_breaks = 1;
2662               fprintf_unfiltered (tmp_error_stream,
2663                                   "breakpoint #%d\n", bl->owner->number);
2664               return 0;
2665             }
2666           else
2667             {
2668               if (bl->loc_type == bp_loc_hardware_breakpoint)
2669                 {
2670                   *hw_breakpoint_error = 1;
2671                   *hw_bp_error_explained_already = bp_excpt.message != NULL;
2672                   fprintf_unfiltered (tmp_error_stream,
2673                                       "Cannot insert hardware breakpoint %d%s",
2674                                       bl->owner->number,
2675                                       bp_excpt.message ? ":" : ".\n");
2676                   if (bp_excpt.message != NULL)
2677                     fprintf_unfiltered (tmp_error_stream, "%s.\n",
2678                                         bp_excpt.message);
2679                 }
2680               else
2681                 {
2682                   if (bp_excpt.message == NULL)
2683                     {
2684                       std::string message
2685                         = memory_error_message (TARGET_XFER_E_IO,
2686                                                 bl->gdbarch, bl->address);
2687
2688                       fprintf_unfiltered (tmp_error_stream,
2689                                           "Cannot insert breakpoint %d.\n"
2690                                           "%s\n",
2691                                           bl->owner->number, message.c_str ());
2692                     }
2693                   else
2694                     {
2695                       fprintf_unfiltered (tmp_error_stream,
2696                                           "Cannot insert breakpoint %d: %s\n",
2697                                           bl->owner->number,
2698                                           bp_excpt.message);
2699                     }
2700                 }
2701               return 1;
2702
2703             }
2704         }
2705       else
2706         bl->inserted = 1;
2707
2708       return 0;
2709     }
2710
2711   else if (bl->loc_type == bp_loc_hardware_watchpoint
2712            /* NOTE drow/2003-09-08: This state only exists for removing
2713               watchpoints.  It's not clear that it's necessary...  */
2714            && bl->owner->disposition != disp_del_at_next_stop)
2715     {
2716       int val;
2717
2718       gdb_assert (bl->owner->ops != NULL
2719                   && bl->owner->ops->insert_location != NULL);
2720
2721       val = bl->owner->ops->insert_location (bl);
2722
2723       /* If trying to set a read-watchpoint, and it turns out it's not
2724          supported, try emulating one with an access watchpoint.  */
2725       if (val == 1 && bl->watchpoint_type == hw_read)
2726         {
2727           struct bp_location *loc, **loc_temp;
2728
2729           /* But don't try to insert it, if there's already another
2730              hw_access location that would be considered a duplicate
2731              of this one.  */
2732           ALL_BP_LOCATIONS (loc, loc_temp)
2733             if (loc != bl
2734                 && loc->watchpoint_type == hw_access
2735                 && watchpoint_locations_match (bl, loc))
2736               {
2737                 bl->duplicate = 1;
2738                 bl->inserted = 1;
2739                 bl->target_info = loc->target_info;
2740                 bl->watchpoint_type = hw_access;
2741                 val = 0;
2742                 break;
2743               }
2744
2745           if (val == 1)
2746             {
2747               bl->watchpoint_type = hw_access;
2748               val = bl->owner->ops->insert_location (bl);
2749
2750               if (val)
2751                 /* Back to the original value.  */
2752                 bl->watchpoint_type = hw_read;
2753             }
2754         }
2755
2756       bl->inserted = (val == 0);
2757     }
2758
2759   else if (bl->owner->type == bp_catchpoint)
2760     {
2761       int val;
2762
2763       gdb_assert (bl->owner->ops != NULL
2764                   && bl->owner->ops->insert_location != NULL);
2765
2766       val = bl->owner->ops->insert_location (bl);
2767       if (val)
2768         {
2769           bl->owner->enable_state = bp_disabled;
2770
2771           if (val == 1)
2772             warning (_("\
2773 Error inserting catchpoint %d: Your system does not support this type\n\
2774 of catchpoint."), bl->owner->number);
2775           else
2776             warning (_("Error inserting catchpoint %d."), bl->owner->number);
2777         }
2778
2779       bl->inserted = (val == 0);
2780
2781       /* We've already printed an error message if there was a problem
2782          inserting this catchpoint, and we've disabled the catchpoint,
2783          so just return success.  */
2784       return 0;
2785     }
2786
2787   return 0;
2788 }
2789
2790 /* This function is called when program space PSPACE is about to be
2791    deleted.  It takes care of updating breakpoints to not reference
2792    PSPACE anymore.  */
2793
2794 void
2795 breakpoint_program_space_exit (struct program_space *pspace)
2796 {
2797   struct breakpoint *b, *b_temp;
2798   struct bp_location *loc, **loc_temp;
2799
2800   /* Remove any breakpoint that was set through this program space.  */
2801   ALL_BREAKPOINTS_SAFE (b, b_temp)
2802     {
2803       if (b->pspace == pspace)
2804         delete_breakpoint (b);
2805     }
2806
2807   /* Breakpoints set through other program spaces could have locations
2808      bound to PSPACE as well.  Remove those.  */
2809   ALL_BP_LOCATIONS (loc, loc_temp)
2810     {
2811       struct bp_location *tmp;
2812
2813       if (loc->pspace == pspace)
2814         {
2815           /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
2816           if (loc->owner->loc == loc)
2817             loc->owner->loc = loc->next;
2818           else
2819             for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
2820               if (tmp->next == loc)
2821                 {
2822                   tmp->next = loc->next;
2823                   break;
2824                 }
2825         }
2826     }
2827
2828   /* Now update the global location list to permanently delete the
2829      removed locations above.  */
2830   update_global_location_list (UGLL_DONT_INSERT);
2831 }
2832
2833 /* Make sure all breakpoints are inserted in inferior.
2834    Throws exception on any error.
2835    A breakpoint that is already inserted won't be inserted
2836    again, so calling this function twice is safe.  */
2837 void
2838 insert_breakpoints (void)
2839 {
2840   struct breakpoint *bpt;
2841
2842   ALL_BREAKPOINTS (bpt)
2843     if (is_hardware_watchpoint (bpt))
2844       {
2845         struct watchpoint *w = (struct watchpoint *) bpt;
2846
2847         update_watchpoint (w, 0 /* don't reparse.  */);
2848       }
2849
2850   /* Updating watchpoints creates new locations, so update the global
2851      location list.  Explicitly tell ugll to insert locations and
2852      ignore breakpoints_always_inserted_mode.  */
2853   update_global_location_list (UGLL_INSERT);
2854 }
2855
2856 /* Invoke CALLBACK for each of bp_location.  */
2857
2858 void
2859 iterate_over_bp_locations (walk_bp_location_callback callback)
2860 {
2861   struct bp_location *loc, **loc_tmp;
2862
2863   ALL_BP_LOCATIONS (loc, loc_tmp)
2864     {
2865       callback (loc, NULL);
2866     }
2867 }
2868
2869 /* This is used when we need to synch breakpoint conditions between GDB and the
2870    target.  It is the case with deleting and disabling of breakpoints when using
2871    always-inserted mode.  */
2872
2873 static void
2874 update_inserted_breakpoint_locations (void)
2875 {
2876   struct bp_location *bl, **blp_tmp;
2877   int error_flag = 0;
2878   int val = 0;
2879   int disabled_breaks = 0;
2880   int hw_breakpoint_error = 0;
2881   int hw_bp_details_reported = 0;
2882
2883   string_file tmp_error_stream;
2884
2885   /* Explicitly mark the warning -- this will only be printed if
2886      there was an error.  */
2887   tmp_error_stream.puts ("Warning:\n");
2888
2889   scoped_restore_current_pspace_and_thread restore_pspace_thread;
2890
2891   ALL_BP_LOCATIONS (bl, blp_tmp)
2892     {
2893       /* We only want to update software breakpoints and hardware
2894          breakpoints.  */
2895       if (!is_breakpoint (bl->owner))
2896         continue;
2897
2898       /* We only want to update locations that are already inserted
2899          and need updating.  This is to avoid unwanted insertion during
2900          deletion of breakpoints.  */
2901       if (!bl->inserted || (bl->inserted && !bl->needs_update))
2902         continue;
2903
2904       switch_to_program_space_and_thread (bl->pspace);
2905
2906       /* For targets that support global breakpoints, there's no need
2907          to select an inferior to insert breakpoint to.  In fact, even
2908          if we aren't attached to any process yet, we should still
2909          insert breakpoints.  */
2910       if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2911           && inferior_ptid == null_ptid)
2912         continue;
2913
2914       val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
2915                                     &hw_breakpoint_error, &hw_bp_details_reported);
2916       if (val)
2917         error_flag = val;
2918     }
2919
2920   if (error_flag)
2921     {
2922       target_terminal::ours_for_output ();
2923       error_stream (tmp_error_stream);
2924     }
2925 }
2926
2927 /* Used when starting or continuing the program.  */
2928
2929 static void
2930 insert_breakpoint_locations (void)
2931 {
2932   struct breakpoint *bpt;
2933   struct bp_location *bl, **blp_tmp;
2934   int error_flag = 0;
2935   int val = 0;
2936   int disabled_breaks = 0;
2937   int hw_breakpoint_error = 0;
2938   int hw_bp_error_explained_already = 0;
2939
2940   string_file tmp_error_stream;
2941
2942   /* Explicitly mark the warning -- this will only be printed if
2943      there was an error.  */
2944   tmp_error_stream.puts ("Warning:\n");
2945
2946   scoped_restore_current_pspace_and_thread restore_pspace_thread;
2947
2948   ALL_BP_LOCATIONS (bl, blp_tmp)
2949     {
2950       if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2951         continue;
2952
2953       /* There is no point inserting thread-specific breakpoints if
2954          the thread no longer exists.  ALL_BP_LOCATIONS bp_location
2955          has BL->OWNER always non-NULL.  */
2956       if (bl->owner->thread != -1
2957           && !valid_global_thread_id (bl->owner->thread))
2958         continue;
2959
2960       switch_to_program_space_and_thread (bl->pspace);
2961
2962       /* For targets that support global breakpoints, there's no need
2963          to select an inferior to insert breakpoint to.  In fact, even
2964          if we aren't attached to any process yet, we should still
2965          insert breakpoints.  */
2966       if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2967           && inferior_ptid == null_ptid)
2968         continue;
2969
2970       val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
2971                                     &hw_breakpoint_error, &hw_bp_error_explained_already);
2972       if (val)
2973         error_flag = val;
2974     }
2975
2976   /* If we failed to insert all locations of a watchpoint, remove
2977      them, as half-inserted watchpoint is of limited use.  */
2978   ALL_BREAKPOINTS (bpt)  
2979     {
2980       int some_failed = 0;
2981       struct bp_location *loc;
2982
2983       if (!is_hardware_watchpoint (bpt))
2984         continue;
2985
2986       if (!breakpoint_enabled (bpt))
2987         continue;
2988
2989       if (bpt->disposition == disp_del_at_next_stop)
2990         continue;
2991       
2992       for (loc = bpt->loc; loc; loc = loc->next)
2993         if (!loc->inserted && should_be_inserted (loc))
2994           {
2995             some_failed = 1;
2996             break;
2997           }
2998       if (some_failed)
2999         {
3000           for (loc = bpt->loc; loc; loc = loc->next)
3001             if (loc->inserted)
3002               remove_breakpoint (loc);
3003
3004           hw_breakpoint_error = 1;
3005           tmp_error_stream.printf ("Could not insert "
3006                                    "hardware watchpoint %d.\n",
3007                                    bpt->number);
3008           error_flag = -1;
3009         }
3010     }
3011
3012   if (error_flag)
3013     {
3014       /* If a hardware breakpoint or watchpoint was inserted, add a
3015          message about possibly exhausted resources.  */
3016       if (hw_breakpoint_error && !hw_bp_error_explained_already)
3017         {
3018           tmp_error_stream.printf ("Could not insert hardware breakpoints:\n\
3019 You may have requested too many hardware breakpoints/watchpoints.\n");
3020         }
3021       target_terminal::ours_for_output ();
3022       error_stream (tmp_error_stream);
3023     }
3024 }
3025
3026 /* Used when the program stops.
3027    Returns zero if successful, or non-zero if there was a problem
3028    removing a breakpoint location.  */
3029
3030 int
3031 remove_breakpoints (void)
3032 {
3033   struct bp_location *bl, **blp_tmp;
3034   int val = 0;
3035
3036   ALL_BP_LOCATIONS (bl, blp_tmp)
3037   {
3038     if (bl->inserted && !is_tracepoint (bl->owner))
3039       val |= remove_breakpoint (bl);
3040   }
3041   return val;
3042 }
3043
3044 /* When a thread exits, remove breakpoints that are related to
3045    that thread.  */
3046
3047 static void
3048 remove_threaded_breakpoints (struct thread_info *tp, int silent)
3049 {
3050   struct breakpoint *b, *b_tmp;
3051
3052   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3053     {
3054       if (b->thread == tp->global_num && user_breakpoint_p (b))
3055         {
3056           b->disposition = disp_del_at_next_stop;
3057
3058           printf_filtered (_("\
3059 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3060                            b->number, print_thread_id (tp));
3061
3062           /* Hide it from the user.  */
3063           b->number = 0;
3064        }
3065     }
3066 }
3067
3068 /* Remove breakpoints of inferior INF.  */
3069
3070 int
3071 remove_breakpoints_inf (inferior *inf)
3072 {
3073   struct bp_location *bl, **blp_tmp;
3074   int val;
3075
3076   ALL_BP_LOCATIONS (bl, blp_tmp)
3077   {
3078     if (bl->pspace != inf->pspace)
3079       continue;
3080
3081     if (bl->inserted && !bl->target_info.persist)
3082       {
3083         val = remove_breakpoint (bl);
3084         if (val != 0)
3085           return val;
3086       }
3087   }
3088   return 0;
3089 }
3090
3091 static int internal_breakpoint_number = -1;
3092
3093 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3094    If INTERNAL is non-zero, the breakpoint number will be populated
3095    from internal_breakpoint_number and that variable decremented.
3096    Otherwise the breakpoint number will be populated from
3097    breakpoint_count and that value incremented.  Internal breakpoints
3098    do not set the internal var bpnum.  */
3099 static void
3100 set_breakpoint_number (int internal, struct breakpoint *b)
3101 {
3102   if (internal)
3103     b->number = internal_breakpoint_number--;
3104   else
3105     {
3106       set_breakpoint_count (breakpoint_count + 1);
3107       b->number = breakpoint_count;
3108     }
3109 }
3110
3111 static struct breakpoint *
3112 create_internal_breakpoint (struct gdbarch *gdbarch,
3113                             CORE_ADDR address, enum bptype type,
3114                             const struct breakpoint_ops *ops)
3115 {
3116   symtab_and_line sal;
3117   sal.pc = address;
3118   sal.section = find_pc_overlay (sal.pc);
3119   sal.pspace = current_program_space;
3120
3121   breakpoint *b = set_raw_breakpoint (gdbarch, sal, type, ops);
3122   b->number = internal_breakpoint_number--;
3123   b->disposition = disp_donttouch;
3124
3125   return b;
3126 }
3127
3128 static const char *const longjmp_names[] =
3129   {
3130     "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3131   };
3132 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3133
3134 /* Per-objfile data private to breakpoint.c.  */
3135 struct breakpoint_objfile_data
3136 {
3137   /* Minimal symbol for "_ovly_debug_event" (if any).  */
3138   struct bound_minimal_symbol overlay_msym {};
3139
3140   /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any).  */
3141   struct bound_minimal_symbol longjmp_msym[NUM_LONGJMP_NAMES] {};
3142
3143   /* True if we have looked for longjmp probes.  */
3144   int longjmp_searched = 0;
3145
3146   /* SystemTap probe points for longjmp (if any).  These are non-owning
3147      references.  */
3148   std::vector<probe *> longjmp_probes;
3149
3150   /* Minimal symbol for "std::terminate()" (if any).  */
3151   struct bound_minimal_symbol terminate_msym {};
3152
3153   /* Minimal symbol for "_Unwind_DebugHook" (if any).  */
3154   struct bound_minimal_symbol exception_msym {};
3155
3156   /* True if we have looked for exception probes.  */
3157   int exception_searched = 0;
3158
3159   /* SystemTap probe points for unwinding (if any).  These are non-owning
3160      references.  */
3161   std::vector<probe *> exception_probes;
3162 };
3163
3164 static const struct objfile_data *breakpoint_objfile_key;
3165
3166 /* Minimal symbol not found sentinel.  */
3167 static struct minimal_symbol msym_not_found;
3168
3169 /* Returns TRUE if MSYM point to the "not found" sentinel.  */
3170
3171 static int
3172 msym_not_found_p (const struct minimal_symbol *msym)
3173 {
3174   return msym == &msym_not_found;
3175 }
3176
3177 /* Return per-objfile data needed by breakpoint.c.
3178    Allocate the data if necessary.  */
3179
3180 static struct breakpoint_objfile_data *
3181 get_breakpoint_objfile_data (struct objfile *objfile)
3182 {
3183   struct breakpoint_objfile_data *bp_objfile_data;
3184
3185   bp_objfile_data = ((struct breakpoint_objfile_data *)
3186                      objfile_data (objfile, breakpoint_objfile_key));
3187   if (bp_objfile_data == NULL)
3188     {
3189       bp_objfile_data = new breakpoint_objfile_data ();
3190       set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
3191     }
3192   return bp_objfile_data;
3193 }
3194
3195 static void
3196 free_breakpoint_objfile_data (struct objfile *obj, void *data)
3197 {
3198   struct breakpoint_objfile_data *bp_objfile_data
3199     = (struct breakpoint_objfile_data *) data;
3200
3201   delete bp_objfile_data;
3202 }
3203
3204 static void
3205 create_overlay_event_breakpoint (void)
3206 {
3207   struct objfile *objfile;
3208   const char *const func_name = "_ovly_debug_event";
3209
3210   ALL_OBJFILES (objfile)
3211     {
3212       struct breakpoint *b;
3213       struct breakpoint_objfile_data *bp_objfile_data;
3214       CORE_ADDR addr;
3215       struct explicit_location explicit_loc;
3216
3217       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3218
3219       if (msym_not_found_p (bp_objfile_data->overlay_msym.minsym))
3220         continue;
3221
3222       if (bp_objfile_data->overlay_msym.minsym == NULL)
3223         {
3224           struct bound_minimal_symbol m;
3225
3226           m = lookup_minimal_symbol_text (func_name, objfile);
3227           if (m.minsym == NULL)
3228             {
3229               /* Avoid future lookups in this objfile.  */
3230               bp_objfile_data->overlay_msym.minsym = &msym_not_found;
3231               continue;
3232             }
3233           bp_objfile_data->overlay_msym = m;
3234         }
3235
3236       addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
3237       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3238                                       bp_overlay_event,
3239                                       &internal_breakpoint_ops);
3240       initialize_explicit_location (&explicit_loc);
3241       explicit_loc.function_name = ASTRDUP (func_name);
3242       b->location = new_explicit_location (&explicit_loc);
3243
3244       if (overlay_debugging == ovly_auto)
3245         {
3246           b->enable_state = bp_enabled;
3247           overlay_events_enabled = 1;
3248         }
3249       else
3250        {
3251          b->enable_state = bp_disabled;
3252          overlay_events_enabled = 0;
3253        }
3254     }
3255 }
3256
3257 static void
3258 create_longjmp_master_breakpoint (void)
3259 {
3260   struct program_space *pspace;
3261
3262   scoped_restore_current_program_space restore_pspace;
3263
3264   ALL_PSPACES (pspace)
3265   {
3266     struct objfile *objfile;
3267
3268     set_current_program_space (pspace);
3269
3270     ALL_OBJFILES (objfile)
3271     {
3272       int i;
3273       struct gdbarch *gdbarch;
3274       struct breakpoint_objfile_data *bp_objfile_data;
3275
3276       gdbarch = get_objfile_arch (objfile);
3277
3278       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3279
3280       if (!bp_objfile_data->longjmp_searched)
3281         {
3282           std::vector<probe *> ret
3283             = find_probes_in_objfile (objfile, "libc", "longjmp");
3284
3285           if (!ret.empty ())
3286             {
3287               /* We are only interested in checking one element.  */
3288               probe *p = ret[0];
3289
3290               if (!p->can_evaluate_arguments ())
3291                 {
3292                   /* We cannot use the probe interface here, because it does
3293                      not know how to evaluate arguments.  */
3294                   ret.clear ();
3295                 }
3296             }
3297           bp_objfile_data->longjmp_probes = ret;
3298           bp_objfile_data->longjmp_searched = 1;
3299         }
3300
3301       if (!bp_objfile_data->longjmp_probes.empty ())
3302         {
3303           struct gdbarch *gdbarch = get_objfile_arch (objfile);
3304
3305           for (probe *p : bp_objfile_data->longjmp_probes)
3306             {
3307               struct breakpoint *b;
3308
3309               b = create_internal_breakpoint (gdbarch,
3310                                               p->get_relocated_address (objfile),
3311                                               bp_longjmp_master,
3312                                               &internal_breakpoint_ops);
3313               b->location = new_probe_location ("-probe-stap libc:longjmp");
3314               b->enable_state = bp_disabled;
3315             }
3316
3317           continue;
3318         }
3319
3320       if (!gdbarch_get_longjmp_target_p (gdbarch))
3321         continue;
3322
3323       for (i = 0; i < NUM_LONGJMP_NAMES; i++)
3324         {
3325           struct breakpoint *b;
3326           const char *func_name;
3327           CORE_ADDR addr;
3328           struct explicit_location explicit_loc;
3329
3330           if (msym_not_found_p (bp_objfile_data->longjmp_msym[i].minsym))
3331             continue;
3332
3333           func_name = longjmp_names[i];
3334           if (bp_objfile_data->longjmp_msym[i].minsym == NULL)
3335             {
3336               struct bound_minimal_symbol m;
3337
3338               m = lookup_minimal_symbol_text (func_name, objfile);
3339               if (m.minsym == NULL)
3340                 {
3341                   /* Prevent future lookups in this objfile.  */
3342                   bp_objfile_data->longjmp_msym[i].minsym = &msym_not_found;
3343                   continue;
3344                 }
3345               bp_objfile_data->longjmp_msym[i] = m;
3346             }
3347
3348           addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
3349           b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3350                                           &internal_breakpoint_ops);
3351           initialize_explicit_location (&explicit_loc);
3352           explicit_loc.function_name = ASTRDUP (func_name);
3353           b->location = new_explicit_location (&explicit_loc);
3354           b->enable_state = bp_disabled;
3355         }
3356     }
3357   }
3358 }
3359
3360 /* Create a master std::terminate breakpoint.  */
3361 static void
3362 create_std_terminate_master_breakpoint (void)
3363 {
3364   struct program_space *pspace;
3365   const char *const func_name = "std::terminate()";
3366
3367   scoped_restore_current_program_space restore_pspace;
3368
3369   ALL_PSPACES (pspace)
3370   {
3371     struct objfile *objfile;
3372     CORE_ADDR addr;
3373
3374     set_current_program_space (pspace);
3375
3376     ALL_OBJFILES (objfile)
3377     {
3378       struct breakpoint *b;
3379       struct breakpoint_objfile_data *bp_objfile_data;
3380       struct explicit_location explicit_loc;
3381
3382       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3383
3384       if (msym_not_found_p (bp_objfile_data->terminate_msym.minsym))
3385         continue;
3386
3387       if (bp_objfile_data->terminate_msym.minsym == NULL)
3388         {
3389           struct bound_minimal_symbol m;
3390
3391           m = lookup_minimal_symbol (func_name, NULL, objfile);
3392           if (m.minsym == NULL || (MSYMBOL_TYPE (m.minsym) != mst_text
3393                                    && MSYMBOL_TYPE (m.minsym) != mst_file_text))
3394             {
3395               /* Prevent future lookups in this objfile.  */
3396               bp_objfile_data->terminate_msym.minsym = &msym_not_found;
3397               continue;
3398             }
3399           bp_objfile_data->terminate_msym = m;
3400         }
3401
3402       addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
3403       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3404                                       bp_std_terminate_master,
3405                                       &internal_breakpoint_ops);
3406       initialize_explicit_location (&explicit_loc);
3407       explicit_loc.function_name = ASTRDUP (func_name);
3408       b->location = new_explicit_location (&explicit_loc);
3409       b->enable_state = bp_disabled;
3410     }
3411   }
3412 }
3413
3414 /* Install a master breakpoint on the unwinder's debug hook.  */
3415
3416 static void
3417 create_exception_master_breakpoint (void)
3418 {
3419   struct objfile *objfile;
3420   const char *const func_name = "_Unwind_DebugHook";
3421
3422   ALL_OBJFILES (objfile)
3423     {
3424       struct breakpoint *b;
3425       struct gdbarch *gdbarch;
3426       struct breakpoint_objfile_data *bp_objfile_data;
3427       CORE_ADDR addr;
3428       struct explicit_location explicit_loc;
3429
3430       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3431
3432       /* We prefer the SystemTap probe point if it exists.  */
3433       if (!bp_objfile_data->exception_searched)
3434         {
3435           std::vector<probe *> ret
3436             = find_probes_in_objfile (objfile, "libgcc", "unwind");
3437
3438           if (!ret.empty ())
3439             {
3440               /* We are only interested in checking one element.  */
3441               probe *p = ret[0];
3442
3443               if (!p->can_evaluate_arguments ())
3444                 {
3445                   /* We cannot use the probe interface here, because it does
3446                      not know how to evaluate arguments.  */
3447                   ret.clear ();
3448                 }
3449             }
3450           bp_objfile_data->exception_probes = ret;
3451           bp_objfile_data->exception_searched = 1;
3452         }
3453
3454       if (!bp_objfile_data->exception_probes.empty ())
3455         {
3456           struct gdbarch *gdbarch = get_objfile_arch (objfile);
3457
3458           for (probe *p : bp_objfile_data->exception_probes)
3459             {
3460               struct breakpoint *b;
3461
3462               b = create_internal_breakpoint (gdbarch,
3463                                               p->get_relocated_address (objfile),
3464                                               bp_exception_master,
3465                                               &internal_breakpoint_ops);
3466               b->location = new_probe_location ("-probe-stap libgcc:unwind");
3467               b->enable_state = bp_disabled;
3468             }
3469
3470           continue;
3471         }
3472
3473       /* Otherwise, try the hook function.  */
3474
3475       if (msym_not_found_p (bp_objfile_data->exception_msym.minsym))
3476         continue;
3477
3478       gdbarch = get_objfile_arch (objfile);
3479
3480       if (bp_objfile_data->exception_msym.minsym == NULL)
3481         {
3482           struct bound_minimal_symbol debug_hook;
3483
3484           debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3485           if (debug_hook.minsym == NULL)
3486             {
3487               bp_objfile_data->exception_msym.minsym = &msym_not_found;
3488               continue;
3489             }
3490
3491           bp_objfile_data->exception_msym = debug_hook;
3492         }
3493
3494       addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
3495       addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3496                                                  current_top_target ());
3497       b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3498                                       &internal_breakpoint_ops);
3499       initialize_explicit_location (&explicit_loc);
3500       explicit_loc.function_name = ASTRDUP (func_name);
3501       b->location = new_explicit_location (&explicit_loc);
3502       b->enable_state = bp_disabled;
3503     }
3504 }
3505
3506 /* Does B have a location spec?  */
3507
3508 static int
3509 breakpoint_event_location_empty_p (const struct breakpoint *b)
3510 {
3511   return b->location != NULL && event_location_empty_p (b->location.get ());
3512 }
3513
3514 void
3515 update_breakpoints_after_exec (void)
3516 {
3517   struct breakpoint *b, *b_tmp;
3518   struct bp_location *bploc, **bplocp_tmp;
3519
3520   /* We're about to delete breakpoints from GDB's lists.  If the
3521      INSERTED flag is true, GDB will try to lift the breakpoints by
3522      writing the breakpoints' "shadow contents" back into memory.  The
3523      "shadow contents" are NOT valid after an exec, so GDB should not
3524      do that.  Instead, the target is responsible from marking
3525      breakpoints out as soon as it detects an exec.  We don't do that
3526      here instead, because there may be other attempts to delete
3527      breakpoints after detecting an exec and before reaching here.  */
3528   ALL_BP_LOCATIONS (bploc, bplocp_tmp)
3529     if (bploc->pspace == current_program_space)
3530       gdb_assert (!bploc->inserted);
3531
3532   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3533   {
3534     if (b->pspace != current_program_space)
3535       continue;
3536
3537     /* Solib breakpoints must be explicitly reset after an exec().  */
3538     if (b->type == bp_shlib_event)
3539       {
3540         delete_breakpoint (b);
3541         continue;
3542       }
3543
3544     /* JIT breakpoints must be explicitly reset after an exec().  */
3545     if (b->type == bp_jit_event)
3546       {
3547         delete_breakpoint (b);
3548         continue;
3549       }
3550
3551     /* Thread event breakpoints must be set anew after an exec(),
3552        as must overlay event and longjmp master breakpoints.  */
3553     if (b->type == bp_thread_event || b->type == bp_overlay_event
3554         || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3555         || b->type == bp_exception_master)
3556       {
3557         delete_breakpoint (b);
3558         continue;
3559       }
3560
3561     /* Step-resume breakpoints are meaningless after an exec().  */
3562     if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
3563       {
3564         delete_breakpoint (b);
3565         continue;
3566       }
3567
3568     /* Just like single-step breakpoints.  */
3569     if (b->type == bp_single_step)
3570       {
3571         delete_breakpoint (b);
3572         continue;
3573       }
3574
3575     /* Longjmp and longjmp-resume breakpoints are also meaningless
3576        after an exec.  */
3577     if (b->type == bp_longjmp || b->type == bp_longjmp_resume
3578         || b->type == bp_longjmp_call_dummy
3579         || b->type == bp_exception || b->type == bp_exception_resume)
3580       {
3581         delete_breakpoint (b);
3582         continue;
3583       }
3584
3585     if (b->type == bp_catchpoint)
3586       {
3587         /* For now, none of the bp_catchpoint breakpoints need to
3588            do anything at this point.  In the future, if some of
3589            the catchpoints need to something, we will need to add
3590            a new method, and call this method from here.  */
3591         continue;
3592       }
3593
3594     /* bp_finish is a special case.  The only way we ought to be able
3595        to see one of these when an exec() has happened, is if the user
3596        caught a vfork, and then said "finish".  Ordinarily a finish just
3597        carries them to the call-site of the current callee, by setting
3598        a temporary bp there and resuming.  But in this case, the finish
3599        will carry them entirely through the vfork & exec.
3600
3601        We don't want to allow a bp_finish to remain inserted now.  But
3602        we can't safely delete it, 'cause finish_command has a handle to
3603        the bp on a bpstat, and will later want to delete it.  There's a
3604        chance (and I've seen it happen) that if we delete the bp_finish
3605        here, that its storage will get reused by the time finish_command
3606        gets 'round to deleting the "use to be a bp_finish" breakpoint.
3607        We really must allow finish_command to delete a bp_finish.
3608
3609        In the absence of a general solution for the "how do we know
3610        it's safe to delete something others may have handles to?"
3611        problem, what we'll do here is just uninsert the bp_finish, and
3612        let finish_command delete it.
3613
3614        (We know the bp_finish is "doomed" in the sense that it's
3615        momentary, and will be deleted as soon as finish_command sees
3616        the inferior stopped.  So it doesn't matter that the bp's
3617        address is probably bogus in the new a.out, unlike e.g., the
3618        solib breakpoints.)  */
3619
3620     if (b->type == bp_finish)
3621       {
3622         continue;
3623       }
3624
3625     /* Without a symbolic address, we have little hope of the
3626        pre-exec() address meaning the same thing in the post-exec()
3627        a.out.  */
3628     if (breakpoint_event_location_empty_p (b))
3629       {
3630         delete_breakpoint (b);
3631         continue;
3632       }
3633   }
3634 }
3635
3636 int
3637 detach_breakpoints (ptid_t ptid)
3638 {
3639   struct bp_location *bl, **blp_tmp;
3640   int val = 0;
3641   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
3642   struct inferior *inf = current_inferior ();
3643
3644   if (ptid.pid () == inferior_ptid.pid ())
3645     error (_("Cannot detach breakpoints of inferior_ptid"));
3646
3647   /* Set inferior_ptid; remove_breakpoint_1 uses this global.  */
3648   inferior_ptid = ptid;
3649   ALL_BP_LOCATIONS (bl, blp_tmp)
3650   {
3651     if (bl->pspace != inf->pspace)
3652       continue;
3653
3654     /* This function must physically remove breakpoints locations
3655        from the specified ptid, without modifying the breakpoint
3656        package's state.  Locations of type bp_loc_other are only
3657        maintained at GDB side.  So, there is no need to remove
3658        these bp_loc_other locations.  Moreover, removing these
3659        would modify the breakpoint package's state.  */
3660     if (bl->loc_type == bp_loc_other)
3661       continue;
3662
3663     if (bl->inserted)
3664       val |= remove_breakpoint_1 (bl, DETACH_BREAKPOINT);
3665   }
3666
3667   return val;
3668 }
3669
3670 /* Remove the breakpoint location BL from the current address space.
3671    Note that this is used to detach breakpoints from a child fork.
3672    When we get here, the child isn't in the inferior list, and neither
3673    do we have objects to represent its address space --- we should
3674    *not* look at bl->pspace->aspace here.  */
3675
3676 static int
3677 remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason)
3678 {
3679   int val;
3680
3681   /* BL is never in moribund_locations by our callers.  */
3682   gdb_assert (bl->owner != NULL);
3683
3684   /* The type of none suggests that owner is actually deleted.
3685      This should not ever happen.  */
3686   gdb_assert (bl->owner->type != bp_none);
3687
3688   if (bl->loc_type == bp_loc_software_breakpoint
3689       || bl->loc_type == bp_loc_hardware_breakpoint)
3690     {
3691       /* "Normal" instruction breakpoint: either the standard
3692          trap-instruction bp (bp_breakpoint), or a
3693          bp_hardware_breakpoint.  */
3694
3695       /* First check to see if we have to handle an overlay.  */
3696       if (overlay_debugging == ovly_off
3697           || bl->section == NULL
3698           || !(section_is_overlay (bl->section)))
3699         {
3700           /* No overlay handling: just remove the breakpoint.  */
3701
3702           /* If we're trying to uninsert a memory breakpoint that we
3703              know is set in a dynamic object that is marked
3704              shlib_disabled, then either the dynamic object was
3705              removed with "remove-symbol-file" or with
3706              "nosharedlibrary".  In the former case, we don't know
3707              whether another dynamic object might have loaded over the
3708              breakpoint's address -- the user might well let us know
3709              about it next with add-symbol-file (the whole point of
3710              add-symbol-file is letting the user manually maintain a
3711              list of dynamically loaded objects).  If we have the
3712              breakpoint's shadow memory, that is, this is a software
3713              breakpoint managed by GDB, check whether the breakpoint
3714              is still inserted in memory, to avoid overwriting wrong
3715              code with stale saved shadow contents.  Note that HW
3716              breakpoints don't have shadow memory, as they're
3717              implemented using a mechanism that is not dependent on
3718              being able to modify the target's memory, and as such
3719              they should always be removed.  */
3720           if (bl->shlib_disabled
3721               && bl->target_info.shadow_len != 0
3722               && !memory_validate_breakpoint (bl->gdbarch, &bl->target_info))
3723             val = 0;
3724           else
3725             val = bl->owner->ops->remove_location (bl, reason);
3726         }
3727       else
3728         {
3729           /* This breakpoint is in an overlay section.
3730              Did we set a breakpoint at the LMA?  */
3731           if (!overlay_events_enabled)
3732               {
3733                 /* Yes -- overlay event support is not active, so we
3734                    should have set a breakpoint at the LMA.  Remove it.  
3735                 */
3736                 /* Ignore any failures: if the LMA is in ROM, we will
3737                    have already warned when we failed to insert it.  */
3738                 if (bl->loc_type == bp_loc_hardware_breakpoint)
3739                   target_remove_hw_breakpoint (bl->gdbarch,
3740                                                &bl->overlay_target_info);
3741                 else
3742                   target_remove_breakpoint (bl->gdbarch,
3743                                             &bl->overlay_target_info,
3744                                             reason);
3745               }
3746           /* Did we set a breakpoint at the VMA? 
3747              If so, we will have marked the breakpoint 'inserted'.  */
3748           if (bl->inserted)
3749             {
3750               /* Yes -- remove it.  Previously we did not bother to
3751                  remove the breakpoint if the section had been
3752                  unmapped, but let's not rely on that being safe.  We
3753                  don't know what the overlay manager might do.  */
3754
3755               /* However, we should remove *software* breakpoints only
3756                  if the section is still mapped, or else we overwrite
3757                  wrong code with the saved shadow contents.  */
3758               if (bl->loc_type == bp_loc_hardware_breakpoint
3759                   || section_is_mapped (bl->section))
3760                 val = bl->owner->ops->remove_location (bl, reason);
3761               else
3762                 val = 0;
3763             }
3764           else
3765             {
3766               /* No -- not inserted, so no need to remove.  No error.  */
3767               val = 0;
3768             }
3769         }
3770
3771       /* In some cases, we might not be able to remove a breakpoint in
3772          a shared library that has already been removed, but we have
3773          not yet processed the shlib unload event.  Similarly for an
3774          unloaded add-symbol-file object - the user might not yet have
3775          had the chance to remove-symbol-file it.  shlib_disabled will
3776          be set if the library/object has already been removed, but
3777          the breakpoint hasn't been uninserted yet, e.g., after
3778          "nosharedlibrary" or "remove-symbol-file" with breakpoints
3779          always-inserted mode.  */
3780       if (val
3781           && (bl->loc_type == bp_loc_software_breakpoint
3782               && (bl->shlib_disabled
3783                   || solib_name_from_address (bl->pspace, bl->address)
3784                   || shared_objfile_contains_address_p (bl->pspace,
3785                                                         bl->address))))
3786         val = 0;
3787
3788       if (val)
3789         return val;
3790       bl->inserted = (reason == DETACH_BREAKPOINT);
3791     }
3792   else if (bl->loc_type == bp_loc_hardware_watchpoint)
3793     {
3794       gdb_assert (bl->owner->ops != NULL
3795                   && bl->owner->ops->remove_location != NULL);
3796
3797       bl->inserted = (reason == DETACH_BREAKPOINT);
3798       bl->owner->ops->remove_location (bl, reason);
3799
3800       /* Failure to remove any of the hardware watchpoints comes here.  */
3801       if (reason == REMOVE_BREAKPOINT && bl->inserted)
3802         warning (_("Could not remove hardware watchpoint %d."),
3803                  bl->owner->number);
3804     }
3805   else if (bl->owner->type == bp_catchpoint
3806            && breakpoint_enabled (bl->owner)
3807            && !bl->duplicate)
3808     {
3809       gdb_assert (bl->owner->ops != NULL
3810                   && bl->owner->ops->remove_location != NULL);
3811
3812       val = bl->owner->ops->remove_location (bl, reason);
3813       if (val)
3814         return val;
3815
3816       bl->inserted = (reason == DETACH_BREAKPOINT);
3817     }
3818
3819   return 0;
3820 }
3821
3822 static int
3823 remove_breakpoint (struct bp_location *bl)
3824 {
3825   /* BL is never in moribund_locations by our callers.  */
3826   gdb_assert (bl->owner != NULL);
3827
3828   /* The type of none suggests that owner is actually deleted.
3829      This should not ever happen.  */
3830   gdb_assert (bl->owner->type != bp_none);
3831
3832   scoped_restore_current_pspace_and_thread restore_pspace_thread;
3833
3834   switch_to_program_space_and_thread (bl->pspace);
3835
3836   return remove_breakpoint_1 (bl, REMOVE_BREAKPOINT);
3837 }
3838
3839 /* Clear the "inserted" flag in all breakpoints.  */
3840
3841 void
3842 mark_breakpoints_out (void)
3843 {
3844   struct bp_location *bl, **blp_tmp;
3845
3846   ALL_BP_LOCATIONS (bl, blp_tmp)
3847     if (bl->pspace == current_program_space)
3848       bl->inserted = 0;
3849 }
3850
3851 /* Clear the "inserted" flag in all breakpoints and delete any
3852    breakpoints which should go away between runs of the program.
3853
3854    Plus other such housekeeping that has to be done for breakpoints
3855    between runs.
3856
3857    Note: this function gets called at the end of a run (by
3858    generic_mourn_inferior) and when a run begins (by
3859    init_wait_for_inferior).  */
3860
3861
3862
3863 void
3864 breakpoint_init_inferior (enum inf_context context)
3865 {
3866   struct breakpoint *b, *b_tmp;
3867   struct program_space *pspace = current_program_space;
3868
3869   /* If breakpoint locations are shared across processes, then there's
3870      nothing to do.  */
3871   if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3872     return;
3873
3874   mark_breakpoints_out ();
3875
3876   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3877   {
3878     if (b->loc && b->loc->pspace != pspace)
3879       continue;
3880
3881     switch (b->type)
3882       {
3883       case bp_call_dummy:
3884       case bp_longjmp_call_dummy:
3885
3886         /* If the call dummy breakpoint is at the entry point it will
3887            cause problems when the inferior is rerun, so we better get
3888            rid of it.  */
3889
3890       case bp_watchpoint_scope:
3891
3892         /* Also get rid of scope breakpoints.  */
3893
3894       case bp_shlib_event:
3895
3896         /* Also remove solib event breakpoints.  Their addresses may
3897            have changed since the last time we ran the program.
3898            Actually we may now be debugging against different target;
3899            and so the solib backend that installed this breakpoint may
3900            not be used in by the target.  E.g.,
3901
3902            (gdb) file prog-linux
3903            (gdb) run               # native linux target
3904            ...
3905            (gdb) kill
3906            (gdb) file prog-win.exe
3907            (gdb) tar rem :9999     # remote Windows gdbserver.
3908         */
3909
3910       case bp_step_resume:
3911
3912         /* Also remove step-resume breakpoints.  */
3913
3914       case bp_single_step:
3915
3916         /* Also remove single-step breakpoints.  */
3917
3918         delete_breakpoint (b);
3919         break;
3920
3921       case bp_watchpoint:
3922       case bp_hardware_watchpoint:
3923       case bp_read_watchpoint:
3924       case bp_access_watchpoint:
3925         {
3926           struct watchpoint *w = (struct watchpoint *) b;
3927
3928           /* Likewise for watchpoints on local expressions.  */
3929           if (w->exp_valid_block != NULL)
3930             delete_breakpoint (b);
3931           else
3932             {
3933               /* Get rid of existing locations, which are no longer
3934                  valid.  New ones will be created in
3935                  update_watchpoint, when the inferior is restarted.
3936                  The next update_global_location_list call will
3937                  garbage collect them.  */
3938               b->loc = NULL;
3939
3940               if (context == inf_starting)
3941                 {
3942                   /* Reset val field to force reread of starting value in
3943                      insert_breakpoints.  */
3944                   w->val.reset (nullptr);
3945                   w->val_valid = 0;
3946                 }
3947             }
3948         }
3949         break;
3950       default:
3951         break;
3952       }
3953   }
3954
3955   /* Get rid of the moribund locations.  */
3956   for (bp_location *bl : moribund_locations)
3957     decref_bp_location (&bl);
3958   moribund_locations.clear ();
3959 }
3960
3961 /* These functions concern about actual breakpoints inserted in the
3962    target --- to e.g. check if we need to do decr_pc adjustment or if
3963    we need to hop over the bkpt --- so we check for address space
3964    match, not program space.  */
3965
3966 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3967    exists at PC.  It returns ordinary_breakpoint_here if it's an
3968    ordinary breakpoint, or permanent_breakpoint_here if it's a
3969    permanent breakpoint.
3970    - When continuing from a location with an ordinary breakpoint, we
3971      actually single step once before calling insert_breakpoints.
3972    - When continuing from a location with a permanent breakpoint, we
3973      need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3974      the target, to advance the PC past the breakpoint.  */
3975
3976 enum breakpoint_here
3977 breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
3978 {
3979   struct bp_location *bl, **blp_tmp;
3980   int any_breakpoint_here = 0;
3981
3982   ALL_BP_LOCATIONS (bl, blp_tmp)
3983     {
3984       if (bl->loc_type != bp_loc_software_breakpoint
3985           && bl->loc_type != bp_loc_hardware_breakpoint)
3986         continue;
3987
3988       /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL.  */
3989       if ((breakpoint_enabled (bl->owner)
3990            || bl->permanent)
3991           && breakpoint_location_address_match (bl, aspace, pc))
3992         {
3993           if (overlay_debugging 
3994               && section_is_overlay (bl->section)
3995               && !section_is_mapped (bl->section))
3996             continue;           /* unmapped overlay -- can't be a match */
3997           else if (bl->permanent)
3998             return permanent_breakpoint_here;
3999           else
4000             any_breakpoint_here = 1;
4001         }
4002     }
4003
4004   return any_breakpoint_here ? ordinary_breakpoint_here : no_breakpoint_here;
4005 }
4006
4007 /* See breakpoint.h.  */
4008
4009 int
4010 breakpoint_in_range_p (const address_space *aspace,
4011                        CORE_ADDR addr, ULONGEST len)
4012 {
4013   struct bp_location *bl, **blp_tmp;
4014
4015   ALL_BP_LOCATIONS (bl, blp_tmp)
4016     {
4017       if (bl->loc_type != bp_loc_software_breakpoint
4018           && bl->loc_type != bp_loc_hardware_breakpoint)
4019         continue;
4020
4021       if ((breakpoint_enabled (bl->owner)
4022            || bl->permanent)
4023           && breakpoint_location_address_range_overlap (bl, aspace,
4024                                                         addr, len))
4025         {
4026           if (overlay_debugging
4027               && section_is_overlay (bl->section)
4028               && !section_is_mapped (bl->section))
4029             {
4030               /* Unmapped overlay -- can't be a match.  */
4031               continue;
4032             }
4033
4034           return 1;
4035         }
4036     }
4037
4038   return 0;
4039 }
4040
4041 /* Return true if there's a moribund breakpoint at PC.  */
4042
4043 int
4044 moribund_breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
4045 {
4046   for (bp_location *loc : moribund_locations)
4047     if (breakpoint_location_address_match (loc, aspace, pc))
4048       return 1;
4049
4050   return 0;
4051 }
4052
4053 /* Returns non-zero iff BL is inserted at PC, in address space
4054    ASPACE.  */
4055
4056 static int
4057 bp_location_inserted_here_p (struct bp_location *bl,
4058                              const address_space *aspace, CORE_ADDR pc)
4059 {
4060   if (bl->inserted
4061       && breakpoint_address_match (bl->pspace->aspace, bl->address,
4062                                    aspace, pc))
4063     {
4064       if (overlay_debugging
4065           && section_is_overlay (bl->section)
4066           && !section_is_mapped (bl->section))
4067         return 0;               /* unmapped overlay -- can't be a match */
4068       else
4069         return 1;
4070     }
4071   return 0;
4072 }
4073
4074 /* Returns non-zero iff there's a breakpoint inserted at PC.  */
4075
4076 int
4077 breakpoint_inserted_here_p (const address_space *aspace, CORE_ADDR pc)
4078 {
4079   struct bp_location **blp, **blp_tmp = NULL;
4080
4081   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4082     {
4083       struct bp_location *bl = *blp;
4084
4085       if (bl->loc_type != bp_loc_software_breakpoint
4086           && bl->loc_type != bp_loc_hardware_breakpoint)
4087         continue;
4088
4089       if (bp_location_inserted_here_p (bl, aspace, pc))
4090         return 1;
4091     }
4092   return 0;
4093 }
4094
4095 /* This function returns non-zero iff there is a software breakpoint
4096    inserted at PC.  */
4097
4098 int
4099 software_breakpoint_inserted_here_p (const address_space *aspace,
4100                                      CORE_ADDR pc)
4101 {
4102   struct bp_location **blp, **blp_tmp = NULL;
4103
4104   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4105     {
4106       struct bp_location *bl = *blp;
4107
4108       if (bl->loc_type != bp_loc_software_breakpoint)
4109         continue;
4110
4111       if (bp_location_inserted_here_p (bl, aspace, pc))
4112         return 1;
4113     }
4114
4115   return 0;
4116 }
4117
4118 /* See breakpoint.h.  */
4119
4120 int
4121 hardware_breakpoint_inserted_here_p (const address_space *aspace,
4122                                      CORE_ADDR pc)
4123 {
4124   struct bp_location **blp, **blp_tmp = NULL;
4125
4126   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4127     {
4128       struct bp_location *bl = *blp;
4129
4130       if (bl->loc_type != bp_loc_hardware_breakpoint)
4131         continue;
4132
4133       if (bp_location_inserted_here_p (bl, aspace, pc))
4134         return 1;
4135     }
4136
4137   return 0;
4138 }
4139
4140 int
4141 hardware_watchpoint_inserted_in_range (const address_space *aspace,
4142                                        CORE_ADDR addr, ULONGEST len)
4143 {
4144   struct breakpoint *bpt;
4145
4146   ALL_BREAKPOINTS (bpt)
4147     {
4148       struct bp_location *loc;
4149
4150       if (bpt->type != bp_hardware_watchpoint
4151           && bpt->type != bp_access_watchpoint)
4152         continue;
4153
4154       if (!breakpoint_enabled (bpt))
4155         continue;
4156
4157       for (loc = bpt->loc; loc; loc = loc->next)
4158         if (loc->pspace->aspace == aspace && loc->inserted)
4159           {
4160             CORE_ADDR l, h;
4161
4162             /* Check for intersection.  */
4163             l = std::max<CORE_ADDR> (loc->address, addr);
4164             h = std::min<CORE_ADDR> (loc->address + loc->length, addr + len);
4165             if (l < h)
4166               return 1;
4167           }
4168     }
4169   return 0;
4170 }
4171 \f
4172
4173 /* bpstat stuff.  External routines' interfaces are documented
4174    in breakpoint.h.  */
4175
4176 int
4177 is_catchpoint (struct breakpoint *ep)
4178 {
4179   return (ep->type == bp_catchpoint);
4180 }
4181
4182 /* Frees any storage that is part of a bpstat.  Does not walk the
4183    'next' chain.  */
4184
4185 bpstats::~bpstats ()
4186 {
4187   if (bp_location_at != NULL)
4188     decref_bp_location (&bp_location_at);
4189 }
4190
4191 /* Clear a bpstat so that it says we are not at any breakpoint.
4192    Also free any storage that is part of a bpstat.  */
4193
4194 void
4195 bpstat_clear (bpstat *bsp)
4196 {
4197   bpstat p;
4198   bpstat q;
4199
4200   if (bsp == 0)
4201     return;
4202   p = *bsp;
4203   while (p != NULL)
4204     {
4205       q = p->next;
4206       delete p;
4207       p = q;
4208     }
4209   *bsp = NULL;
4210 }
4211
4212 bpstats::bpstats (const bpstats &other)
4213   : next (NULL),
4214     bp_location_at (other.bp_location_at),
4215     breakpoint_at (other.breakpoint_at),
4216     commands (other.commands),
4217     print (other.print),
4218     stop (other.stop),
4219     print_it (other.print_it)
4220 {
4221   if (other.old_val != NULL)
4222     old_val = release_value (value_copy (other.old_val.get ()));
4223   incref_bp_location (bp_location_at);
4224 }
4225
4226 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
4227    is part of the bpstat is copied as well.  */
4228
4229 bpstat
4230 bpstat_copy (bpstat bs)
4231 {
4232   bpstat p = NULL;
4233   bpstat tmp;
4234   bpstat retval = NULL;
4235
4236   if (bs == NULL)
4237     return bs;
4238
4239   for (; bs != NULL; bs = bs->next)
4240     {
4241       tmp = new bpstats (*bs);
4242
4243       if (p == NULL)
4244         /* This is the first thing in the chain.  */
4245         retval = tmp;
4246       else
4247         p->next = tmp;
4248       p = tmp;
4249     }
4250   p->next = NULL;
4251   return retval;
4252 }
4253
4254 /* Find the bpstat associated with this breakpoint.  */
4255
4256 bpstat
4257 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
4258 {
4259   if (bsp == NULL)
4260     return NULL;
4261
4262   for (; bsp != NULL; bsp = bsp->next)
4263     {
4264       if (bsp->breakpoint_at == breakpoint)
4265         return bsp;
4266     }
4267   return NULL;
4268 }
4269
4270 /* See breakpoint.h.  */
4271
4272 int
4273 bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
4274 {
4275   for (; bsp != NULL; bsp = bsp->next)
4276     {
4277       if (bsp->breakpoint_at == NULL)
4278         {
4279           /* A moribund location can never explain a signal other than
4280              GDB_SIGNAL_TRAP.  */
4281           if (sig == GDB_SIGNAL_TRAP)
4282             return 1;
4283         }
4284       else
4285         {
4286           if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
4287                                                         sig))
4288             return 1;
4289         }
4290     }
4291
4292   return 0;
4293 }
4294
4295 /* Put in *NUM the breakpoint number of the first breakpoint we are
4296    stopped at.  *BSP upon return is a bpstat which points to the
4297    remaining breakpoints stopped at (but which is not guaranteed to be
4298    good for anything but further calls to bpstat_num).
4299
4300    Return 0 if passed a bpstat which does not indicate any breakpoints.
4301    Return -1 if stopped at a breakpoint that has been deleted since
4302    we set it.
4303    Return 1 otherwise.  */
4304
4305 int
4306 bpstat_num (bpstat *bsp, int *num)
4307 {
4308   struct breakpoint *b;
4309
4310   if ((*bsp) == NULL)
4311     return 0;                   /* No more breakpoint values */
4312
4313   /* We assume we'll never have several bpstats that correspond to a
4314      single breakpoint -- otherwise, this function might return the
4315      same number more than once and this will look ugly.  */
4316   b = (*bsp)->breakpoint_at;
4317   *bsp = (*bsp)->next;
4318   if (b == NULL)
4319     return -1;                  /* breakpoint that's been deleted since */
4320
4321   *num = b->number;             /* We have its number */
4322   return 1;
4323 }
4324
4325 /* See breakpoint.h.  */
4326
4327 void
4328 bpstat_clear_actions (void)
4329 {
4330   bpstat bs;
4331
4332   if (inferior_ptid == null_ptid)
4333     return;
4334
4335   thread_info *tp = inferior_thread ();
4336   for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
4337     {
4338       bs->commands = NULL;
4339       bs->old_val.reset (nullptr);
4340     }
4341 }
4342
4343 /* Called when a command is about to proceed the inferior.  */
4344
4345 static void
4346 breakpoint_about_to_proceed (void)
4347 {
4348   if (inferior_ptid != null_ptid)
4349     {
4350       struct thread_info *tp = inferior_thread ();
4351
4352       /* Allow inferior function calls in breakpoint commands to not
4353          interrupt the command list.  When the call finishes
4354          successfully, the inferior will be standing at the same
4355          breakpoint as if nothing happened.  */
4356       if (tp->control.in_infcall)
4357         return;
4358     }
4359
4360   breakpoint_proceeded = 1;
4361 }
4362
4363 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4364    or its equivalent.  */
4365
4366 static int
4367 command_line_is_silent (struct command_line *cmd)
4368 {
4369   return cmd && (strcmp ("silent", cmd->line) == 0);
4370 }
4371
4372 /* Execute all the commands associated with all the breakpoints at
4373    this location.  Any of these commands could cause the process to
4374    proceed beyond this point, etc.  We look out for such changes by
4375    checking the global "breakpoint_proceeded" after each command.
4376
4377    Returns true if a breakpoint command resumed the inferior.  In that
4378    case, it is the caller's responsibility to recall it again with the
4379    bpstat of the current thread.  */
4380
4381 static int
4382 bpstat_do_actions_1 (bpstat *bsp)
4383 {
4384   bpstat bs;
4385   int again = 0;
4386
4387   /* Avoid endless recursion if a `source' command is contained
4388      in bs->commands.  */
4389   if (executing_breakpoint_commands)
4390     return 0;
4391
4392   scoped_restore save_executing
4393     = make_scoped_restore (&executing_breakpoint_commands, 1);
4394
4395   scoped_restore preventer = prevent_dont_repeat ();
4396
4397   /* This pointer will iterate over the list of bpstat's.  */
4398   bs = *bsp;
4399
4400   breakpoint_proceeded = 0;
4401   for (; bs != NULL; bs = bs->next)
4402     {
4403       struct command_line *cmd = NULL;
4404
4405       /* Take ownership of the BSP's command tree, if it has one.
4406
4407          The command tree could legitimately contain commands like
4408          'step' and 'next', which call clear_proceed_status, which
4409          frees stop_bpstat's command tree.  To make sure this doesn't
4410          free the tree we're executing out from under us, we need to
4411          take ownership of the tree ourselves.  Since a given bpstat's
4412          commands are only executed once, we don't need to copy it; we
4413          can clear the pointer in the bpstat, and make sure we free
4414          the tree when we're done.  */
4415       counted_command_line ccmd = bs->commands;
4416       bs->commands = NULL;
4417       if (ccmd != NULL)
4418         cmd = ccmd.get ();
4419       if (command_line_is_silent (cmd))
4420         {
4421           /* The action has been already done by bpstat_stop_status.  */
4422           cmd = cmd->next;
4423         }
4424
4425       while (cmd != NULL)
4426         {
4427           execute_control_command (cmd);
4428
4429           if (breakpoint_proceeded)
4430             break;
4431           else
4432             cmd = cmd->next;
4433         }
4434
4435       if (breakpoint_proceeded)
4436         {
4437           if (current_ui->async)
4438             /* If we are in async mode, then the target might be still
4439                running, not stopped at any breakpoint, so nothing for
4440                us to do here -- just return to the event loop.  */
4441             ;
4442           else
4443             /* In sync mode, when execute_control_command returns
4444                we're already standing on the next breakpoint.
4445                Breakpoint commands for that stop were not run, since
4446                execute_command does not run breakpoint commands --
4447                only command_line_handler does, but that one is not
4448                involved in execution of breakpoint commands.  So, we
4449                can now execute breakpoint commands.  It should be
4450                noted that making execute_command do bpstat actions is
4451                not an option -- in this case we'll have recursive
4452                invocation of bpstat for each breakpoint with a
4453                command, and can easily blow up GDB stack.  Instead, we
4454                return true, which will trigger the caller to recall us
4455                with the new stop_bpstat.  */
4456             again = 1;
4457           break;
4458         }
4459     }
4460   return again;
4461 }
4462
4463 /* Helper for bpstat_do_actions.  Get the current thread, if there's
4464    one, is alive and has execution.  Return NULL otherwise.  */
4465
4466 static thread_info *
4467 get_bpstat_thread ()
4468 {
4469   if (inferior_ptid == null_ptid || !target_has_execution)
4470     return NULL;
4471
4472   thread_info *tp = inferior_thread ();
4473   if (tp->state == THREAD_EXITED || tp->executing)
4474     return NULL;
4475   return tp;
4476 }
4477
4478 void
4479 bpstat_do_actions (void)
4480 {
4481   struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
4482   thread_info *tp;
4483
4484   /* Do any commands attached to breakpoint we are stopped at.  */
4485   while ((tp = get_bpstat_thread ()) != NULL)
4486     {
4487       /* Since in sync mode, bpstat_do_actions may resume the
4488          inferior, and only return when it is stopped at the next
4489          breakpoint, we keep doing breakpoint actions until it returns
4490          false to indicate the inferior was not resumed.  */
4491       if (!bpstat_do_actions_1 (&tp->control.stop_bpstat))
4492         break;
4493     }
4494
4495   discard_cleanups (cleanup_if_error);
4496 }
4497
4498 /* Print out the (old or new) value associated with a watchpoint.  */
4499
4500 static void
4501 watchpoint_value_print (struct value *val, struct ui_file *stream)
4502 {
4503   if (val == NULL)
4504     fprintf_unfiltered (stream, _("<unreadable>"));
4505   else
4506     {
4507       struct value_print_options opts;
4508       get_user_print_options (&opts);
4509       value_print (val, stream, &opts);
4510     }
4511 }
4512
4513 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4514    debugging multiple threads.  */
4515
4516 void
4517 maybe_print_thread_hit_breakpoint (struct ui_out *uiout)
4518 {
4519   if (uiout->is_mi_like_p ())
4520     return;
4521
4522   uiout->text ("\n");
4523
4524   if (show_thread_that_caused_stop ())
4525     {
4526       const char *name;
4527       struct thread_info *thr = inferior_thread ();
4528
4529       uiout->text ("Thread ");
4530       uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
4531
4532       name = thr->name != NULL ? thr->name : target_thread_name (thr);
4533       if (name != NULL)
4534         {
4535           uiout->text (" \"");
4536           uiout->field_fmt ("name", "%s", name);
4537           uiout->text ("\"");
4538         }
4539
4540       uiout->text (" hit ");
4541     }
4542 }
4543
4544 /* Generic routine for printing messages indicating why we
4545    stopped.  The behavior of this function depends on the value
4546    'print_it' in the bpstat structure.  Under some circumstances we
4547    may decide not to print anything here and delegate the task to
4548    normal_stop().  */
4549
4550 static enum print_stop_action
4551 print_bp_stop_message (bpstat bs)
4552 {
4553   switch (bs->print_it)
4554     {
4555     case print_it_noop:
4556       /* Nothing should be printed for this bpstat entry.  */
4557       return PRINT_UNKNOWN;
4558       break;
4559
4560     case print_it_done:
4561       /* We still want to print the frame, but we already printed the
4562          relevant messages.  */
4563       return PRINT_SRC_AND_LOC;
4564       break;
4565
4566     case print_it_normal:
4567       {
4568         struct breakpoint *b = bs->breakpoint_at;
4569
4570         /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4571            which has since been deleted.  */
4572         if (b == NULL)
4573           return PRINT_UNKNOWN;
4574
4575         /* Normal case.  Call the breakpoint's print_it method.  */
4576         return b->ops->print_it (bs);
4577       }
4578       break;
4579
4580     default:
4581       internal_error (__FILE__, __LINE__,
4582                       _("print_bp_stop_message: unrecognized enum value"));
4583       break;
4584     }
4585 }
4586
4587 /* A helper function that prints a shared library stopped event.  */
4588
4589 static void
4590 print_solib_event (int is_catchpoint)
4591 {
4592   bool any_deleted = !current_program_space->deleted_solibs.empty ();
4593   bool any_added = !current_program_space->added_solibs.empty ();
4594
4595   if (!is_catchpoint)
4596     {
4597       if (any_added || any_deleted)
4598         current_uiout->text (_("Stopped due to shared library event:\n"));
4599       else
4600         current_uiout->text (_("Stopped due to shared library event (no "
4601                                "libraries added or removed)\n"));
4602     }
4603
4604   if (current_uiout->is_mi_like_p ())
4605     current_uiout->field_string ("reason",
4606                                  async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
4607
4608   if (any_deleted)
4609     {
4610       current_uiout->text (_("  Inferior unloaded "));
4611       ui_out_emit_list list_emitter (current_uiout, "removed");
4612       for (int ix = 0; ix < current_program_space->deleted_solibs.size (); ix++)
4613         {
4614           const std::string &name = current_program_space->deleted_solibs[ix];
4615
4616           if (ix > 0)
4617             current_uiout->text ("    ");
4618           current_uiout->field_string ("library", name);
4619           current_uiout->text ("\n");
4620         }
4621     }
4622
4623   if (any_added)
4624     {
4625       current_uiout->text (_("  Inferior loaded "));
4626       ui_out_emit_list list_emitter (current_uiout, "added");
4627       bool first = true;
4628       for (so_list *iter : current_program_space->added_solibs)
4629         {
4630           if (!first)
4631             current_uiout->text ("    ");
4632           first = false;
4633           current_uiout->field_string ("library", iter->so_name);
4634           current_uiout->text ("\n");
4635         }
4636     }
4637 }
4638
4639 /* Print a message indicating what happened.  This is called from
4640    normal_stop().  The input to this routine is the head of the bpstat
4641    list - a list of the eventpoints that caused this stop.  KIND is
4642    the target_waitkind for the stopping event.  This
4643    routine calls the generic print routine for printing a message
4644    about reasons for stopping.  This will print (for example) the
4645    "Breakpoint n," part of the output.  The return value of this
4646    routine is one of:
4647
4648    PRINT_UNKNOWN: Means we printed nothing.
4649    PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4650    code to print the location.  An example is 
4651    "Breakpoint 1, " which should be followed by
4652    the location.
4653    PRINT_SRC_ONLY: Means we printed something, but there is no need
4654    to also print the location part of the message.
4655    An example is the catch/throw messages, which
4656    don't require a location appended to the end.
4657    PRINT_NOTHING: We have done some printing and we don't need any 
4658    further info to be printed.  */
4659
4660 enum print_stop_action
4661 bpstat_print (bpstat bs, int kind)
4662 {
4663   enum print_stop_action val;
4664
4665   /* Maybe another breakpoint in the chain caused us to stop.
4666      (Currently all watchpoints go on the bpstat whether hit or not.
4667      That probably could (should) be changed, provided care is taken
4668      with respect to bpstat_explains_signal).  */
4669   for (; bs; bs = bs->next)
4670     {
4671       val = print_bp_stop_message (bs);
4672       if (val == PRINT_SRC_ONLY 
4673           || val == PRINT_SRC_AND_LOC 
4674           || val == PRINT_NOTHING)
4675         return val;
4676     }
4677
4678   /* If we had hit a shared library event breakpoint,
4679      print_bp_stop_message would print out this message.  If we hit an
4680      OS-level shared library event, do the same thing.  */
4681   if (kind == TARGET_WAITKIND_LOADED)
4682     {
4683       print_solib_event (0);
4684       return PRINT_NOTHING;
4685     }
4686
4687   /* We reached the end of the chain, or we got a null BS to start
4688      with and nothing was printed.  */
4689   return PRINT_UNKNOWN;
4690 }
4691
4692 /* Evaluate the boolean expression EXP and return the result.  */
4693
4694 static bool
4695 breakpoint_cond_eval (expression *exp)
4696 {
4697   struct value *mark = value_mark ();
4698   bool res = value_true (evaluate_expression (exp));
4699
4700   value_free_to_mark (mark);
4701   return res;
4702 }
4703
4704 /* Allocate a new bpstat.  Link it to the FIFO list by BS_LINK_POINTER.  */
4705
4706 bpstats::bpstats (struct bp_location *bl, bpstat **bs_link_pointer)
4707   : next (NULL),
4708     bp_location_at (bl),
4709     breakpoint_at (bl->owner),
4710     commands (NULL),
4711     print (0),
4712     stop (0),
4713     print_it (print_it_normal)
4714 {
4715   incref_bp_location (bl);
4716   **bs_link_pointer = this;
4717   *bs_link_pointer = &next;
4718 }
4719
4720 bpstats::bpstats ()
4721   : next (NULL),
4722     bp_location_at (NULL),
4723     breakpoint_at (NULL),
4724     commands (NULL),
4725     print (0),
4726     stop (0),
4727     print_it (print_it_normal)
4728 {
4729 }
4730 \f
4731 /* The target has stopped with waitstatus WS.  Check if any hardware
4732    watchpoints have triggered, according to the target.  */
4733
4734 int
4735 watchpoints_triggered (struct target_waitstatus *ws)
4736 {
4737   bool stopped_by_watchpoint = target_stopped_by_watchpoint ();
4738   CORE_ADDR addr;
4739   struct breakpoint *b;
4740
4741   if (!stopped_by_watchpoint)
4742     {
4743       /* We were not stopped by a watchpoint.  Mark all watchpoints
4744          as not triggered.  */
4745       ALL_BREAKPOINTS (b)
4746         if (is_hardware_watchpoint (b))
4747           {
4748             struct watchpoint *w = (struct watchpoint *) b;
4749
4750             w->watchpoint_triggered = watch_triggered_no;
4751           }
4752
4753       return 0;
4754     }
4755
4756   if (!target_stopped_data_address (current_top_target (), &addr))
4757     {
4758       /* We were stopped by a watchpoint, but we don't know where.
4759          Mark all watchpoints as unknown.  */
4760       ALL_BREAKPOINTS (b)
4761         if (is_hardware_watchpoint (b))
4762           {
4763             struct watchpoint *w = (struct watchpoint *) b;
4764
4765             w->watchpoint_triggered = watch_triggered_unknown;
4766           }
4767
4768       return 1;
4769     }
4770
4771   /* The target could report the data address.  Mark watchpoints
4772      affected by this data address as triggered, and all others as not
4773      triggered.  */
4774
4775   ALL_BREAKPOINTS (b)
4776     if (is_hardware_watchpoint (b))
4777       {
4778         struct watchpoint *w = (struct watchpoint *) b;
4779         struct bp_location *loc;
4780
4781         w->watchpoint_triggered = watch_triggered_no;
4782         for (loc = b->loc; loc; loc = loc->next)
4783           {
4784             if (is_masked_watchpoint (b))
4785               {
4786                 CORE_ADDR newaddr = addr & w->hw_wp_mask;
4787                 CORE_ADDR start = loc->address & w->hw_wp_mask;
4788
4789                 if (newaddr == start)
4790                   {
4791                     w->watchpoint_triggered = watch_triggered_yes;
4792                     break;
4793                   }
4794               }
4795             /* Exact match not required.  Within range is sufficient.  */
4796             else if (target_watchpoint_addr_within_range (current_top_target (),
4797                                                          addr, loc->address,
4798                                                          loc->length))
4799               {
4800                 w->watchpoint_triggered = watch_triggered_yes;
4801                 break;
4802               }
4803           }
4804       }
4805
4806   return 1;
4807 }
4808
4809 /* Possible return values for watchpoint_check.  */
4810 enum wp_check_result
4811   {
4812     /* The watchpoint has been deleted.  */
4813     WP_DELETED = 1,
4814
4815     /* The value has changed.  */
4816     WP_VALUE_CHANGED = 2,
4817
4818     /* The value has not changed.  */
4819     WP_VALUE_NOT_CHANGED = 3,
4820
4821     /* Ignore this watchpoint, no matter if the value changed or not.  */
4822     WP_IGNORE = 4,
4823   };
4824
4825 #define BP_TEMPFLAG 1
4826 #define BP_HARDWAREFLAG 2
4827
4828 /* Evaluate watchpoint condition expression and check if its value
4829    changed.  */
4830
4831 static wp_check_result
4832 watchpoint_check (bpstat bs)
4833 {
4834   struct watchpoint *b;
4835   struct frame_info *fr;
4836   int within_current_scope;
4837
4838   /* BS is built from an existing struct breakpoint.  */
4839   gdb_assert (bs->breakpoint_at != NULL);
4840   b = (struct watchpoint *) bs->breakpoint_at;
4841
4842   /* If this is a local watchpoint, we only want to check if the
4843      watchpoint frame is in scope if the current thread is the thread
4844      that was used to create the watchpoint.  */
4845   if (!watchpoint_in_thread_scope (b))
4846     return WP_IGNORE;
4847
4848   if (b->exp_valid_block == NULL)
4849     within_current_scope = 1;
4850   else
4851     {
4852       struct frame_info *frame = get_current_frame ();
4853       struct gdbarch *frame_arch = get_frame_arch (frame);
4854       CORE_ADDR frame_pc = get_frame_pc (frame);
4855
4856       /* stack_frame_destroyed_p() returns a non-zero value if we're
4857          still in the function but the stack frame has already been
4858          invalidated.  Since we can't rely on the values of local
4859          variables after the stack has been destroyed, we are treating
4860          the watchpoint in that state as `not changed' without further
4861          checking.  Don't mark watchpoints as changed if the current
4862          frame is in an epilogue - even if they are in some other
4863          frame, our view of the stack is likely to be wrong and
4864          frame_find_by_id could error out.  */
4865       if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
4866         return WP_IGNORE;
4867
4868       fr = frame_find_by_id (b->watchpoint_frame);
4869       within_current_scope = (fr != NULL);
4870
4871       /* If we've gotten confused in the unwinder, we might have
4872          returned a frame that can't describe this variable.  */
4873       if (within_current_scope)
4874         {
4875           struct symbol *function;
4876
4877           function = get_frame_function (fr);
4878           if (function == NULL
4879               || !contained_in (b->exp_valid_block,
4880                                 SYMBOL_BLOCK_VALUE (function)))
4881             within_current_scope = 0;
4882         }
4883
4884       if (within_current_scope)
4885         /* If we end up stopping, the current frame will get selected
4886            in normal_stop.  So this call to select_frame won't affect
4887            the user.  */
4888         select_frame (fr);
4889     }
4890
4891   if (within_current_scope)
4892     {
4893       /* We use value_{,free_to_}mark because it could be a *long*
4894          time before we return to the command level and call
4895          free_all_values.  We can't call free_all_values because we
4896          might be in the middle of evaluating a function call.  */
4897
4898       int pc = 0;
4899       struct value *mark;
4900       struct value *new_val;
4901
4902       if (is_masked_watchpoint (b))
4903         /* Since we don't know the exact trigger address (from
4904            stopped_data_address), just tell the user we've triggered
4905            a mask watchpoint.  */
4906         return WP_VALUE_CHANGED;
4907
4908       mark = value_mark ();
4909       fetch_subexp_value (b->exp.get (), &pc, &new_val, NULL, NULL, 0);
4910
4911       if (b->val_bitsize != 0)
4912         new_val = extract_bitfield_from_watchpoint_value (b, new_val);
4913
4914       /* We use value_equal_contents instead of value_equal because
4915          the latter coerces an array to a pointer, thus comparing just
4916          the address of the array instead of its contents.  This is
4917          not what we want.  */
4918       if ((b->val != NULL) != (new_val != NULL)
4919           || (b->val != NULL && !value_equal_contents (b->val.get (),
4920                                                        new_val)))
4921         {
4922           bs->old_val = b->val;
4923           b->val = release_value (new_val);
4924           b->val_valid = 1;
4925           if (new_val != NULL)
4926             value_free_to_mark (mark);
4927           return WP_VALUE_CHANGED;
4928         }
4929       else
4930         {
4931           /* Nothing changed.  */
4932           value_free_to_mark (mark);
4933           return WP_VALUE_NOT_CHANGED;
4934         }
4935     }
4936   else
4937     {
4938       /* This seems like the only logical thing to do because
4939          if we temporarily ignored the watchpoint, then when
4940          we reenter the block in which it is valid it contains
4941          garbage (in the case of a function, it may have two
4942          garbage values, one before and one after the prologue).
4943          So we can't even detect the first assignment to it and
4944          watch after that (since the garbage may or may not equal
4945          the first value assigned).  */
4946       /* We print all the stop information in
4947          breakpoint_ops->print_it, but in this case, by the time we
4948          call breakpoint_ops->print_it this bp will be deleted
4949          already.  So we have no choice but print the information
4950          here.  */
4951
4952       SWITCH_THRU_ALL_UIS ()
4953         {
4954           struct ui_out *uiout = current_uiout;
4955
4956           if (uiout->is_mi_like_p ())
4957             uiout->field_string
4958               ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
4959           uiout->text ("\nWatchpoint ");
4960           uiout->field_int ("wpnum", b->number);
4961           uiout->text (" deleted because the program has left the block in\n"
4962                        "which its expression is valid.\n");
4963         }
4964
4965       /* Make sure the watchpoint's commands aren't executed.  */
4966       b->commands = NULL;
4967       watchpoint_del_at_next_stop (b);
4968
4969       return WP_DELETED;
4970     }
4971 }
4972
4973 /* Return true if it looks like target has stopped due to hitting
4974    breakpoint location BL.  This function does not check if we should
4975    stop, only if BL explains the stop.  */
4976
4977 static int
4978 bpstat_check_location (const struct bp_location *bl,
4979                        const address_space *aspace, CORE_ADDR bp_addr,
4980                        const struct target_waitstatus *ws)
4981 {
4982   struct breakpoint *b = bl->owner;
4983
4984   /* BL is from an existing breakpoint.  */
4985   gdb_assert (b != NULL);
4986
4987   return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
4988 }
4989
4990 /* Determine if the watched values have actually changed, and we
4991    should stop.  If not, set BS->stop to 0.  */
4992
4993 static void
4994 bpstat_check_watchpoint (bpstat bs)
4995 {
4996   const struct bp_location *bl;
4997   struct watchpoint *b;
4998
4999   /* BS is built for existing struct breakpoint.  */
5000   bl = bs->bp_location_at;
5001   gdb_assert (bl != NULL);
5002   b = (struct watchpoint *) bs->breakpoint_at;
5003   gdb_assert (b != NULL);
5004
5005     {
5006       int must_check_value = 0;
5007       
5008       if (b->type == bp_watchpoint)
5009         /* For a software watchpoint, we must always check the
5010            watched value.  */
5011         must_check_value = 1;
5012       else if (b->watchpoint_triggered == watch_triggered_yes)
5013         /* We have a hardware watchpoint (read, write, or access)
5014            and the target earlier reported an address watched by
5015            this watchpoint.  */
5016         must_check_value = 1;
5017       else if (b->watchpoint_triggered == watch_triggered_unknown
5018                && b->type == bp_hardware_watchpoint)
5019         /* We were stopped by a hardware watchpoint, but the target could
5020            not report the data address.  We must check the watchpoint's
5021            value.  Access and read watchpoints are out of luck; without
5022            a data address, we can't figure it out.  */
5023         must_check_value = 1;
5024
5025       if (must_check_value)
5026         {
5027           wp_check_result e;
5028
5029           TRY
5030             {
5031               e = watchpoint_check (bs);
5032             }
5033           CATCH (ex, RETURN_MASK_ALL)
5034             {
5035               exception_fprintf (gdb_stderr, ex,
5036                                  "Error evaluating expression "
5037                                  "for watchpoint %d\n",
5038                                  b->number);
5039
5040               SWITCH_THRU_ALL_UIS ()
5041                 {
5042                   printf_filtered (_("Watchpoint %d deleted.\n"),
5043                                    b->number);
5044                 }
5045               watchpoint_del_at_next_stop (b);
5046               e = WP_DELETED;
5047             }
5048           END_CATCH
5049
5050           switch (e)
5051             {
5052             case WP_DELETED:
5053               /* We've already printed what needs to be printed.  */
5054               bs->print_it = print_it_done;
5055               /* Stop.  */
5056               break;
5057             case WP_IGNORE:
5058               bs->print_it = print_it_noop;
5059               bs->stop = 0;
5060               break;
5061             case WP_VALUE_CHANGED:
5062               if (b->type == bp_read_watchpoint)
5063                 {
5064                   /* There are two cases to consider here:
5065
5066                      1. We're watching the triggered memory for reads.
5067                      In that case, trust the target, and always report
5068                      the watchpoint hit to the user.  Even though
5069                      reads don't cause value changes, the value may
5070                      have changed since the last time it was read, and
5071                      since we're not trapping writes, we will not see
5072                      those, and as such we should ignore our notion of
5073                      old value.
5074
5075                      2. We're watching the triggered memory for both
5076                      reads and writes.  There are two ways this may
5077                      happen:
5078
5079                      2.1. This is a target that can't break on data
5080                      reads only, but can break on accesses (reads or
5081                      writes), such as e.g., x86.  We detect this case
5082                      at the time we try to insert read watchpoints.
5083
5084                      2.2. Otherwise, the target supports read
5085                      watchpoints, but, the user set an access or write
5086                      watchpoint watching the same memory as this read
5087                      watchpoint.
5088
5089                      If we're watching memory writes as well as reads,
5090                      ignore watchpoint hits when we find that the
5091                      value hasn't changed, as reads don't cause
5092                      changes.  This still gives false positives when
5093                      the program writes the same value to memory as
5094                      what there was already in memory (we will confuse
5095                      it for a read), but it's much better than
5096                      nothing.  */
5097
5098                   int other_write_watchpoint = 0;
5099
5100                   if (bl->watchpoint_type == hw_read)
5101                     {
5102                       struct breakpoint *other_b;
5103
5104                       ALL_BREAKPOINTS (other_b)
5105                         if (other_b->type == bp_hardware_watchpoint
5106                             || other_b->type == bp_access_watchpoint)
5107                           {
5108                             struct watchpoint *other_w =
5109                               (struct watchpoint *) other_b;
5110
5111                             if (other_w->watchpoint_triggered
5112                                 == watch_triggered_yes)
5113                               {
5114                                 other_write_watchpoint = 1;
5115                                 break;
5116                               }
5117                           }
5118                     }
5119
5120                   if (other_write_watchpoint
5121                       || bl->watchpoint_type == hw_access)
5122                     {
5123                       /* We're watching the same memory for writes,
5124                          and the value changed since the last time we
5125                          updated it, so this trap must be for a write.
5126                          Ignore it.  */
5127                       bs->print_it = print_it_noop;
5128                       bs->stop = 0;
5129                     }
5130                 }
5131               break;
5132             case WP_VALUE_NOT_CHANGED:
5133               if (b->type == bp_hardware_watchpoint
5134                   || b->type == bp_watchpoint)
5135                 {
5136                   /* Don't stop: write watchpoints shouldn't fire if
5137                      the value hasn't changed.  */
5138                   bs->print_it = print_it_noop;
5139                   bs->stop = 0;
5140                 }
5141               /* Stop.  */
5142               break;
5143             default:
5144               /* Can't happen.  */
5145               break;
5146             }
5147         }
5148       else      /* must_check_value == 0 */
5149         {
5150           /* This is a case where some watchpoint(s) triggered, but
5151              not at the address of this watchpoint, or else no
5152              watchpoint triggered after all.  So don't print
5153              anything for this watchpoint.  */
5154           bs->print_it = print_it_noop;
5155           bs->stop = 0;
5156         }
5157     }
5158 }
5159
5160 /* For breakpoints that are currently marked as telling gdb to stop,
5161    check conditions (condition proper, frame, thread and ignore count)
5162    of breakpoint referred to by BS.  If we should not stop for this
5163    breakpoint, set BS->stop to 0.  */
5164
5165 static void
5166 bpstat_check_breakpoint_conditions (bpstat bs, thread_info *thread)
5167 {
5168   const struct bp_location *bl;
5169   struct breakpoint *b;
5170   /* Assume stop.  */
5171   bool condition_result = true;
5172   struct expression *cond;
5173
5174   gdb_assert (bs->stop);
5175
5176   /* BS is built for existing struct breakpoint.  */
5177   bl = bs->bp_location_at;
5178   gdb_assert (bl != NULL);
5179   b = bs->breakpoint_at;
5180   gdb_assert (b != NULL);
5181
5182   /* Even if the target evaluated the condition on its end and notified GDB, we
5183      need to do so again since GDB does not know if we stopped due to a
5184      breakpoint or a single step breakpoint.  */
5185
5186   if (frame_id_p (b->frame_id)
5187       && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
5188     {
5189       bs->stop = 0;
5190       return;
5191     }
5192
5193   /* If this is a thread/task-specific breakpoint, don't waste cpu
5194      evaluating the condition if this isn't the specified
5195      thread/task.  */
5196   if ((b->thread != -1 && b->thread != thread->global_num)
5197       || (b->task != 0 && b->task != ada_get_task_number (thread)))
5198     {
5199       bs->stop = 0;
5200       return;
5201     }
5202
5203   /* Evaluate extension language breakpoints that have a "stop" method
5204      implemented.  */
5205   bs->stop = breakpoint_ext_lang_cond_says_stop (b);
5206
5207   if (is_watchpoint (b))
5208     {
5209       struct watchpoint *w = (struct watchpoint *) b;
5210
5211       cond = w->cond_exp.get ();
5212     }
5213   else
5214     cond = bl->cond.get ();
5215
5216   if (cond && b->disposition != disp_del_at_next_stop)
5217     {
5218       int within_current_scope = 1;
5219       struct watchpoint * w;
5220
5221       /* We use value_mark and value_free_to_mark because it could
5222          be a long time before we return to the command level and
5223          call free_all_values.  We can't call free_all_values
5224          because we might be in the middle of evaluating a
5225          function call.  */
5226       struct value *mark = value_mark ();
5227
5228       if (is_watchpoint (b))
5229         w = (struct watchpoint *) b;
5230       else
5231         w = NULL;
5232
5233       /* Need to select the frame, with all that implies so that
5234          the conditions will have the right context.  Because we
5235          use the frame, we will not see an inlined function's
5236          variables when we arrive at a breakpoint at the start
5237          of the inlined function; the current frame will be the
5238          call site.  */
5239       if (w == NULL || w->cond_exp_valid_block == NULL)
5240         select_frame (get_current_frame ());
5241       else
5242         {
5243           struct frame_info *frame;
5244
5245           /* For local watchpoint expressions, which particular
5246              instance of a local is being watched matters, so we
5247              keep track of the frame to evaluate the expression
5248              in.  To evaluate the condition however, it doesn't
5249              really matter which instantiation of the function
5250              where the condition makes sense triggers the
5251              watchpoint.  This allows an expression like "watch
5252              global if q > 10" set in `func', catch writes to
5253              global on all threads that call `func', or catch
5254              writes on all recursive calls of `func' by a single
5255              thread.  We simply always evaluate the condition in
5256              the innermost frame that's executing where it makes
5257              sense to evaluate the condition.  It seems
5258              intuitive.  */
5259           frame = block_innermost_frame (w->cond_exp_valid_block);
5260           if (frame != NULL)
5261             select_frame (frame);
5262           else
5263             within_current_scope = 0;
5264         }
5265       if (within_current_scope)
5266         {
5267           TRY
5268             {
5269               condition_result = breakpoint_cond_eval (cond);
5270             }
5271           CATCH (ex, RETURN_MASK_ALL)
5272             {
5273               exception_fprintf (gdb_stderr, ex,
5274                                  "Error in testing breakpoint condition:\n");
5275             }
5276           END_CATCH
5277         }
5278       else
5279         {
5280           warning (_("Watchpoint condition cannot be tested "
5281                      "in the current scope"));
5282           /* If we failed to set the right context for this
5283              watchpoint, unconditionally report it.  */
5284         }
5285       /* FIXME-someday, should give breakpoint #.  */
5286       value_free_to_mark (mark);
5287     }
5288
5289   if (cond && !condition_result)
5290     {
5291       bs->stop = 0;
5292     }
5293   else if (b->ignore_count > 0)
5294     {
5295       b->ignore_count--;
5296       bs->stop = 0;
5297       /* Increase the hit count even though we don't stop.  */
5298       ++(b->hit_count);
5299       gdb::observers::breakpoint_modified.notify (b);
5300     }   
5301 }
5302
5303 /* Returns true if we need to track moribund locations of LOC's type
5304    on the current target.  */
5305
5306 static int
5307 need_moribund_for_location_type (struct bp_location *loc)
5308 {
5309   return ((loc->loc_type == bp_loc_software_breakpoint
5310            && !target_supports_stopped_by_sw_breakpoint ())
5311           || (loc->loc_type == bp_loc_hardware_breakpoint
5312               && !target_supports_stopped_by_hw_breakpoint ()));
5313 }
5314
5315 /* See breakpoint.h.  */
5316
5317 bpstat
5318 build_bpstat_chain (const address_space *aspace, CORE_ADDR bp_addr,
5319                     const struct target_waitstatus *ws)
5320 {
5321   struct breakpoint *b;
5322   bpstat bs_head = NULL, *bs_link = &bs_head;
5323
5324   ALL_BREAKPOINTS (b)
5325     {
5326       if (!breakpoint_enabled (b))
5327         continue;
5328
5329       for (bp_location *bl = b->loc; bl != NULL; bl = bl->next)
5330         {
5331           /* For hardware watchpoints, we look only at the first
5332              location.  The watchpoint_check function will work on the
5333              entire expression, not the individual locations.  For
5334              read watchpoints, the watchpoints_triggered function has
5335              checked all locations already.  */
5336           if (b->type == bp_hardware_watchpoint && bl != b->loc)
5337             break;
5338
5339           if (!bl->enabled || bl->shlib_disabled)
5340             continue;
5341
5342           if (!bpstat_check_location (bl, aspace, bp_addr, ws))
5343             continue;
5344
5345           /* Come here if it's a watchpoint, or if the break address
5346              matches.  */
5347
5348           bpstat bs = new bpstats (bl, &bs_link);       /* Alloc a bpstat to
5349                                                            explain stop.  */
5350
5351           /* Assume we stop.  Should we find a watchpoint that is not
5352              actually triggered, or if the condition of the breakpoint
5353              evaluates as false, we'll reset 'stop' to 0.  */
5354           bs->stop = 1;
5355           bs->print = 1;
5356
5357           /* If this is a scope breakpoint, mark the associated
5358              watchpoint as triggered so that we will handle the
5359              out-of-scope event.  We'll get to the watchpoint next
5360              iteration.  */
5361           if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
5362             {
5363               struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5364
5365               w->watchpoint_triggered = watch_triggered_yes;
5366             }
5367         }
5368     }
5369
5370   /* Check if a moribund breakpoint explains the stop.  */
5371   if (!target_supports_stopped_by_sw_breakpoint ()
5372       || !target_supports_stopped_by_hw_breakpoint ())
5373     {
5374       for (bp_location *loc : moribund_locations)
5375         {
5376           if (breakpoint_location_address_match (loc, aspace, bp_addr)
5377               && need_moribund_for_location_type (loc))
5378             {
5379               bpstat bs = new bpstats (loc, &bs_link);
5380               /* For hits of moribund locations, we should just proceed.  */
5381               bs->stop = 0;
5382               bs->print = 0;
5383               bs->print_it = print_it_noop;
5384             }
5385         }
5386     }
5387
5388   return bs_head;
5389 }
5390
5391 /* See breakpoint.h.  */
5392
5393 bpstat
5394 bpstat_stop_status (const address_space *aspace,
5395                     CORE_ADDR bp_addr, thread_info *thread,
5396                     const struct target_waitstatus *ws,
5397                     bpstat stop_chain)
5398 {
5399   struct breakpoint *b = NULL;
5400   /* First item of allocated bpstat's.  */
5401   bpstat bs_head = stop_chain;
5402   bpstat bs;
5403   int need_remove_insert;
5404   int removed_any;
5405
5406   /* First, build the bpstat chain with locations that explain a
5407      target stop, while being careful to not set the target running,
5408      as that may invalidate locations (in particular watchpoint
5409      locations are recreated).  Resuming will happen here with
5410      breakpoint conditions or watchpoint expressions that include
5411      inferior function calls.  */
5412   if (bs_head == NULL)
5413     bs_head = build_bpstat_chain (aspace, bp_addr, ws);
5414
5415   /* A bit of special processing for shlib breakpoints.  We need to
5416      process solib loading here, so that the lists of loaded and
5417      unloaded libraries are correct before we handle "catch load" and
5418      "catch unload".  */
5419   for (bs = bs_head; bs != NULL; bs = bs->next)
5420     {
5421       if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
5422         {
5423           handle_solib_event ();
5424           break;
5425         }
5426     }
5427
5428   /* Now go through the locations that caused the target to stop, and
5429      check whether we're interested in reporting this stop to higher
5430      layers, or whether we should resume the target transparently.  */
5431
5432   removed_any = 0;
5433
5434   for (bs = bs_head; bs != NULL; bs = bs->next)
5435     {
5436       if (!bs->stop)
5437         continue;
5438
5439       b = bs->breakpoint_at;
5440       b->ops->check_status (bs);
5441       if (bs->stop)
5442         {
5443           bpstat_check_breakpoint_conditions (bs, thread);
5444
5445           if (bs->stop)
5446             {
5447               ++(b->hit_count);
5448               gdb::observers::breakpoint_modified.notify (b);
5449
5450               /* We will stop here.  */
5451               if (b->disposition == disp_disable)
5452                 {
5453                   --(b->enable_count);
5454                   if (b->enable_count <= 0)
5455                     b->enable_state = bp_disabled;
5456                   removed_any = 1;
5457                 }
5458               if (b->silent)
5459                 bs->print = 0;
5460               bs->commands = b->commands;
5461               if (command_line_is_silent (bs->commands
5462                                           ? bs->commands.get () : NULL))
5463                 bs->print = 0;
5464
5465               b->ops->after_condition_true (bs);
5466             }
5467
5468         }
5469
5470       /* Print nothing for this entry if we don't stop or don't
5471          print.  */
5472       if (!bs->stop || !bs->print)
5473         bs->print_it = print_it_noop;
5474     }
5475
5476   /* If we aren't stopping, the value of some hardware watchpoint may
5477      not have changed, but the intermediate memory locations we are
5478      watching may have.  Don't bother if we're stopping; this will get
5479      done later.  */
5480   need_remove_insert = 0;
5481   if (! bpstat_causes_stop (bs_head))
5482     for (bs = bs_head; bs != NULL; bs = bs->next)
5483       if (!bs->stop
5484           && bs->breakpoint_at
5485           && is_hardware_watchpoint (bs->breakpoint_at))
5486         {
5487           struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5488
5489           update_watchpoint (w, 0 /* don't reparse.  */);
5490           need_remove_insert = 1;
5491         }
5492
5493   if (need_remove_insert)
5494     update_global_location_list (UGLL_MAY_INSERT);
5495   else if (removed_any)
5496     update_global_location_list (UGLL_DONT_INSERT);
5497
5498   return bs_head;
5499 }
5500
5501 static void
5502 handle_jit_event (void)
5503 {
5504   struct frame_info *frame;
5505   struct gdbarch *gdbarch;
5506
5507   if (debug_infrun)
5508     fprintf_unfiltered (gdb_stdlog, "handling bp_jit_event\n");
5509
5510   /* Switch terminal for any messages produced by
5511      breakpoint_re_set.  */
5512   target_terminal::ours_for_output ();
5513
5514   frame = get_current_frame ();
5515   gdbarch = get_frame_arch (frame);
5516
5517   jit_event_handler (gdbarch);
5518
5519   target_terminal::inferior ();
5520 }
5521
5522 /* Prepare WHAT final decision for infrun.  */
5523
5524 /* Decide what infrun needs to do with this bpstat.  */
5525
5526 struct bpstat_what
5527 bpstat_what (bpstat bs_head)
5528 {
5529   struct bpstat_what retval;
5530   bpstat bs;
5531
5532   retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
5533   retval.call_dummy = STOP_NONE;
5534   retval.is_longjmp = 0;
5535
5536   for (bs = bs_head; bs != NULL; bs = bs->next)
5537     {
5538       /* Extract this BS's action.  After processing each BS, we check
5539          if its action overrides all we've seem so far.  */
5540       enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5541       enum bptype bptype;
5542
5543       if (bs->breakpoint_at == NULL)
5544         {
5545           /* I suspect this can happen if it was a momentary
5546              breakpoint which has since been deleted.  */
5547           bptype = bp_none;
5548         }
5549       else
5550         bptype = bs->breakpoint_at->type;
5551
5552       switch (bptype)
5553         {
5554         case bp_none:
5555           break;
5556         case bp_breakpoint:
5557         case bp_hardware_breakpoint:
5558         case bp_single_step:
5559         case bp_until:
5560         case bp_finish:
5561         case bp_shlib_event:
5562           if (bs->stop)
5563             {
5564               if (bs->print)
5565                 this_action = BPSTAT_WHAT_STOP_NOISY;
5566               else
5567                 this_action = BPSTAT_WHAT_STOP_SILENT;
5568             }
5569           else
5570             this_action = BPSTAT_WHAT_SINGLE;
5571           break;
5572         case bp_watchpoint:
5573         case bp_hardware_watchpoint:
5574         case bp_read_watchpoint:
5575         case bp_access_watchpoint:
5576           if (bs->stop)
5577             {
5578               if (bs->print)
5579                 this_action = BPSTAT_WHAT_STOP_NOISY;
5580               else
5581                 this_action = BPSTAT_WHAT_STOP_SILENT;
5582             }
5583           else
5584             {
5585               /* There was a watchpoint, but we're not stopping.
5586                  This requires no further action.  */
5587             }
5588           break;
5589         case bp_longjmp:
5590         case bp_longjmp_call_dummy:
5591         case bp_exception:
5592           if (bs->stop)
5593             {
5594               this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5595               retval.is_longjmp = bptype != bp_exception;
5596             }
5597           else
5598             this_action = BPSTAT_WHAT_SINGLE;
5599           break;
5600         case bp_longjmp_resume:
5601         case bp_exception_resume:
5602           if (bs->stop)
5603             {
5604               this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5605               retval.is_longjmp = bptype == bp_longjmp_resume;
5606             }
5607           else
5608             this_action = BPSTAT_WHAT_SINGLE;
5609           break;
5610         case bp_step_resume:
5611           if (bs->stop)
5612             this_action = BPSTAT_WHAT_STEP_RESUME;
5613           else
5614             {
5615               /* It is for the wrong frame.  */
5616               this_action = BPSTAT_WHAT_SINGLE;
5617             }
5618           break;
5619         case bp_hp_step_resume:
5620           if (bs->stop)
5621             this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5622           else
5623             {
5624               /* It is for the wrong frame.  */
5625               this_action = BPSTAT_WHAT_SINGLE;
5626             }
5627           break;
5628         case bp_watchpoint_scope:
5629         case bp_thread_event:
5630         case bp_overlay_event:
5631         case bp_longjmp_master:
5632         case bp_std_terminate_master:
5633         case bp_exception_master:
5634           this_action = BPSTAT_WHAT_SINGLE;
5635           break;
5636         case bp_catchpoint:
5637           if (bs->stop)
5638             {
5639               if (bs->print)
5640                 this_action = BPSTAT_WHAT_STOP_NOISY;
5641               else
5642                 this_action = BPSTAT_WHAT_STOP_SILENT;
5643             }
5644           else
5645             {
5646               /* There was a catchpoint, but we're not stopping.
5647                  This requires no further action.  */
5648             }
5649           break;
5650         case bp_jit_event:
5651           this_action = BPSTAT_WHAT_SINGLE;
5652           break;
5653         case bp_call_dummy:
5654           /* Make sure the action is stop (silent or noisy),
5655              so infrun.c pops the dummy frame.  */
5656           retval.call_dummy = STOP_STACK_DUMMY;
5657           this_action = BPSTAT_WHAT_STOP_SILENT;
5658           break;
5659         case bp_std_terminate:
5660           /* Make sure the action is stop (silent or noisy),
5661              so infrun.c pops the dummy frame.  */
5662           retval.call_dummy = STOP_STD_TERMINATE;
5663           this_action = BPSTAT_WHAT_STOP_SILENT;
5664           break;
5665         case bp_tracepoint:
5666         case bp_fast_tracepoint:
5667         case bp_static_tracepoint:
5668           /* Tracepoint hits should not be reported back to GDB, and
5669              if one got through somehow, it should have been filtered
5670              out already.  */
5671           internal_error (__FILE__, __LINE__,
5672                           _("bpstat_what: tracepoint encountered"));
5673           break;
5674         case bp_gnu_ifunc_resolver:
5675           /* Step over it (and insert bp_gnu_ifunc_resolver_return).  */
5676           this_action = BPSTAT_WHAT_SINGLE;
5677           break;
5678         case bp_gnu_ifunc_resolver_return:
5679           /* The breakpoint will be removed, execution will restart from the
5680              PC of the former breakpoint.  */
5681           this_action = BPSTAT_WHAT_KEEP_CHECKING;
5682           break;
5683
5684         case bp_dprintf:
5685           if (bs->stop)
5686             this_action = BPSTAT_WHAT_STOP_SILENT;
5687           else
5688             this_action = BPSTAT_WHAT_SINGLE;
5689           break;
5690
5691         default:
5692           internal_error (__FILE__, __LINE__,
5693                           _("bpstat_what: unhandled bptype %d"), (int) bptype);
5694         }
5695
5696       retval.main_action = std::max (retval.main_action, this_action);
5697     }
5698
5699   return retval;
5700 }
5701
5702 void
5703 bpstat_run_callbacks (bpstat bs_head)
5704 {
5705   bpstat bs;
5706
5707   for (bs = bs_head; bs != NULL; bs = bs->next)
5708     {
5709       struct breakpoint *b = bs->breakpoint_at;
5710
5711       if (b == NULL)
5712         continue;
5713       switch (b->type)
5714         {
5715         case bp_jit_event:
5716           handle_jit_event ();
5717           break;
5718         case bp_gnu_ifunc_resolver:
5719           gnu_ifunc_resolver_stop (b);
5720           break;
5721         case bp_gnu_ifunc_resolver_return:
5722           gnu_ifunc_resolver_return_stop (b);
5723           break;
5724         }
5725     }
5726 }
5727
5728 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5729    without hardware support).  This isn't related to a specific bpstat,
5730    just to things like whether watchpoints are set.  */
5731
5732 int
5733 bpstat_should_step (void)
5734 {
5735   struct breakpoint *b;
5736
5737   ALL_BREAKPOINTS (b)
5738     if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
5739       return 1;
5740   return 0;
5741 }
5742
5743 int
5744 bpstat_causes_stop (bpstat bs)
5745 {
5746   for (; bs != NULL; bs = bs->next)
5747     if (bs->stop)
5748       return 1;
5749
5750   return 0;
5751 }
5752
5753 \f
5754
5755 /* Compute a string of spaces suitable to indent the next line
5756    so it starts at the position corresponding to the table column
5757    named COL_NAME in the currently active table of UIOUT.  */
5758
5759 static char *
5760 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
5761 {
5762   static char wrap_indent[80];
5763   int i, total_width, width, align;
5764   const char *text;
5765
5766   total_width = 0;
5767   for (i = 1; uiout->query_table_field (i, &width, &align, &text); i++)
5768     {
5769       if (strcmp (text, col_name) == 0)
5770         {
5771           gdb_assert (total_width < sizeof wrap_indent);
5772           memset (wrap_indent, ' ', total_width);
5773           wrap_indent[total_width] = 0;
5774
5775           return wrap_indent;
5776         }
5777
5778       total_width += width + 1;
5779     }
5780
5781   return NULL;
5782 }
5783
5784 /* Determine if the locations of this breakpoint will have their conditions
5785    evaluated by the target, host or a mix of both.  Returns the following:
5786
5787     "host": Host evals condition.
5788     "host or target": Host or Target evals condition.
5789     "target": Target evals condition.
5790 */
5791
5792 static const char *
5793 bp_condition_evaluator (struct breakpoint *b)
5794 {
5795   struct bp_location *bl;
5796   char host_evals = 0;
5797   char target_evals = 0;
5798
5799   if (!b)
5800     return NULL;
5801
5802   if (!is_breakpoint (b))
5803     return NULL;
5804
5805   if (gdb_evaluates_breakpoint_condition_p ()
5806       || !target_supports_evaluation_of_breakpoint_conditions ())
5807     return condition_evaluation_host;
5808
5809   for (bl = b->loc; bl; bl = bl->next)
5810     {
5811       if (bl->cond_bytecode)
5812         target_evals++;
5813       else
5814         host_evals++;
5815     }
5816
5817   if (host_evals && target_evals)
5818     return condition_evaluation_both;
5819   else if (target_evals)
5820     return condition_evaluation_target;
5821   else
5822     return condition_evaluation_host;
5823 }
5824
5825 /* Determine the breakpoint location's condition evaluator.  This is
5826    similar to bp_condition_evaluator, but for locations.  */
5827
5828 static const char *
5829 bp_location_condition_evaluator (struct bp_location *bl)
5830 {
5831   if (bl && !is_breakpoint (bl->owner))
5832     return NULL;
5833
5834   if (gdb_evaluates_breakpoint_condition_p ()
5835       || !target_supports_evaluation_of_breakpoint_conditions ())
5836     return condition_evaluation_host;
5837
5838   if (bl && bl->cond_bytecode)
5839     return condition_evaluation_target;
5840   else
5841     return condition_evaluation_host;
5842 }
5843
5844 /* Print the LOC location out of the list of B->LOC locations.  */
5845
5846 static void
5847 print_breakpoint_location (struct breakpoint *b,
5848                            struct bp_location *loc)
5849 {
5850   struct ui_out *uiout = current_uiout;
5851
5852   scoped_restore_current_program_space restore_pspace;
5853
5854   if (loc != NULL && loc->shlib_disabled)
5855     loc = NULL;
5856
5857   if (loc != NULL)
5858     set_current_program_space (loc->pspace);
5859
5860   if (b->display_canonical)
5861     uiout->field_string ("what", event_location_to_string (b->location.get ()));
5862   else if (loc && loc->symtab)
5863     {
5864       const struct symbol *sym = loc->symbol;
5865
5866       if (sym)
5867         {
5868           uiout->text ("in ");
5869           uiout->field_string ("func", SYMBOL_PRINT_NAME (sym));
5870           uiout->text (" ");
5871           uiout->wrap_hint (wrap_indent_at_field (uiout, "what"));
5872           uiout->text ("at ");
5873         }
5874       uiout->field_string ("file",
5875                            symtab_to_filename_for_display (loc->symtab));
5876       uiout->text (":");
5877
5878       if (uiout->is_mi_like_p ())
5879         uiout->field_string ("fullname", symtab_to_fullname (loc->symtab));
5880       
5881       uiout->field_int ("line", loc->line_number);
5882     }
5883   else if (loc)
5884     {
5885       string_file stb;
5886
5887       print_address_symbolic (loc->gdbarch, loc->address, &stb,
5888                               demangle, "");
5889       uiout->field_stream ("at", stb);
5890     }
5891   else
5892     {
5893       uiout->field_string ("pending",
5894                            event_location_to_string (b->location.get ()));
5895       /* If extra_string is available, it could be holding a condition
5896          or dprintf arguments.  In either case, make sure it is printed,
5897          too, but only for non-MI streams.  */
5898       if (!uiout->is_mi_like_p () && b->extra_string != NULL)
5899         {
5900           if (b->type == bp_dprintf)
5901             uiout->text (",");
5902           else
5903             uiout->text (" ");
5904           uiout->text (b->extra_string);
5905         }
5906     }
5907
5908   if (loc && is_breakpoint (b)
5909       && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5910       && bp_condition_evaluator (b) == condition_evaluation_both)
5911     {
5912       uiout->text (" (");
5913       uiout->field_string ("evaluated-by",
5914                            bp_location_condition_evaluator (loc));
5915       uiout->text (")");
5916     }
5917 }
5918
5919 static const char *
5920 bptype_string (enum bptype type)
5921 {
5922   struct ep_type_description
5923     {
5924       enum bptype type;
5925       const char *description;
5926     };
5927   static struct ep_type_description bptypes[] =
5928   {
5929     {bp_none, "?deleted?"},
5930     {bp_breakpoint, "breakpoint"},
5931     {bp_hardware_breakpoint, "hw breakpoint"},
5932     {bp_single_step, "sw single-step"},
5933     {bp_until, "until"},
5934     {bp_finish, "finish"},
5935     {bp_watchpoint, "watchpoint"},
5936     {bp_hardware_watchpoint, "hw watchpoint"},
5937     {bp_read_watchpoint, "read watchpoint"},
5938     {bp_access_watchpoint, "acc watchpoint"},
5939     {bp_longjmp, "longjmp"},
5940     {bp_longjmp_resume, "longjmp resume"},
5941     {bp_longjmp_call_dummy, "longjmp for call dummy"},
5942     {bp_exception, "exception"},
5943     {bp_exception_resume, "exception resume"},
5944     {bp_step_resume, "step resume"},
5945     {bp_hp_step_resume, "high-priority step resume"},
5946     {bp_watchpoint_scope, "watchpoint scope"},
5947     {bp_call_dummy, "call dummy"},
5948     {bp_std_terminate, "std::terminate"},
5949     {bp_shlib_event, "shlib events"},
5950     {bp_thread_event, "thread events"},
5951     {bp_overlay_event, "overlay events"},
5952     {bp_longjmp_master, "longjmp master"},
5953     {bp_std_terminate_master, "std::terminate master"},
5954     {bp_exception_master, "exception master"},
5955     {bp_catchpoint, "catchpoint"},
5956     {bp_tracepoint, "tracepoint"},
5957     {bp_fast_tracepoint, "fast tracepoint"},
5958     {bp_static_tracepoint, "static tracepoint"},
5959     {bp_dprintf, "dprintf"},
5960     {bp_jit_event, "jit events"},
5961     {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
5962     {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
5963   };
5964
5965   if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
5966       || ((int) type != bptypes[(int) type].type))
5967     internal_error (__FILE__, __LINE__,
5968                     _("bptypes table does not describe type #%d."),
5969                     (int) type);
5970
5971   return bptypes[(int) type].description;
5972 }
5973
5974 /* For MI, output a field named 'thread-groups' with a list as the value.
5975    For CLI, prefix the list with the string 'inf'. */
5976
5977 static void
5978 output_thread_groups (struct ui_out *uiout,
5979                       const char *field_name,
5980                       const std::vector<int> &inf_nums,
5981                       int mi_only)
5982 {
5983   int is_mi = uiout->is_mi_like_p ();
5984
5985   /* For backward compatibility, don't display inferiors in CLI unless
5986      there are several.  Always display them for MI. */
5987   if (!is_mi && mi_only)
5988     return;
5989
5990   ui_out_emit_list list_emitter (uiout, field_name);
5991
5992   for (size_t i = 0; i < inf_nums.size (); i++)
5993     {
5994       if (is_mi)
5995         {
5996           char mi_group[10];
5997
5998           xsnprintf (mi_group, sizeof (mi_group), "i%d", inf_nums[i]);
5999           uiout->field_string (NULL, mi_group);
6000         }
6001       else
6002         {
6003           if (i == 0)
6004             uiout->text (" inf ");
6005           else
6006             uiout->text (", ");
6007         
6008           uiout->text (plongest (inf_nums[i]));
6009         }
6010     }
6011 }
6012
6013 /* Print B to gdb_stdout.  */
6014
6015 static void
6016 print_one_breakpoint_location (struct breakpoint *b,
6017                                struct bp_location *loc,
6018                                int loc_number,
6019                                struct bp_location **last_loc,
6020                                int allflag)
6021 {
6022   struct command_line *l;
6023   static char bpenables[] = "nynny";
6024
6025   struct ui_out *uiout = current_uiout;
6026   int header_of_multiple = 0;
6027   int part_of_multiple = (loc != NULL);
6028   struct value_print_options opts;
6029
6030   get_user_print_options (&opts);
6031
6032   gdb_assert (!loc || loc_number != 0);
6033   /* See comment in print_one_breakpoint concerning treatment of
6034      breakpoints with single disabled location.  */
6035   if (loc == NULL 
6036       && (b->loc != NULL 
6037           && (b->loc->next != NULL || !b->loc->enabled)))
6038     header_of_multiple = 1;
6039   if (loc == NULL)
6040     loc = b->loc;
6041
6042   annotate_record ();
6043
6044   /* 1 */
6045   annotate_field (0);
6046   if (part_of_multiple)
6047     uiout->field_fmt ("number", "%d.%d", b->number, loc_number);
6048   else
6049     uiout->field_int ("number", b->number);
6050
6051   /* 2 */
6052   annotate_field (1);
6053   if (part_of_multiple)
6054     uiout->field_skip ("type");
6055   else
6056     uiout->field_string ("type", bptype_string (b->type));
6057
6058   /* 3 */
6059   annotate_field (2);
6060   if (part_of_multiple)
6061     uiout->field_skip ("disp");
6062   else
6063     uiout->field_string ("disp", bpdisp_text (b->disposition));
6064
6065
6066   /* 4 */
6067   annotate_field (3);
6068   if (part_of_multiple)
6069     uiout->field_string ("enabled", loc->enabled ? "y" : "n");
6070   else
6071     uiout->field_fmt ("enabled", "%c", bpenables[(int) b->enable_state]);
6072   uiout->spaces (2);
6073
6074   
6075   /* 5 and 6 */
6076   if (b->ops != NULL && b->ops->print_one != NULL)
6077     {
6078       /* Although the print_one can possibly print all locations,
6079          calling it here is not likely to get any nice result.  So,
6080          make sure there's just one location.  */
6081       gdb_assert (b->loc == NULL || b->loc->next == NULL);
6082       b->ops->print_one (b, last_loc);
6083     }
6084   else
6085     switch (b->type)
6086       {
6087       case bp_none:
6088         internal_error (__FILE__, __LINE__,
6089                         _("print_one_breakpoint: bp_none encountered\n"));
6090         break;
6091
6092       case bp_watchpoint:
6093       case bp_hardware_watchpoint:
6094       case bp_read_watchpoint:
6095       case bp_access_watchpoint:
6096         {
6097           struct watchpoint *w = (struct watchpoint *) b;
6098
6099           /* Field 4, the address, is omitted (which makes the columns
6100              not line up too nicely with the headers, but the effect
6101              is relatively readable).  */
6102           if (opts.addressprint)
6103             uiout->field_skip ("addr");
6104           annotate_field (5);
6105           uiout->field_string ("what", w->exp_string);
6106         }
6107         break;
6108
6109       case bp_breakpoint:
6110       case bp_hardware_breakpoint:
6111       case bp_single_step:
6112       case bp_until:
6113       case bp_finish:
6114       case bp_longjmp:
6115       case bp_longjmp_resume:
6116       case bp_longjmp_call_dummy:
6117       case bp_exception:
6118       case bp_exception_resume:
6119       case bp_step_resume:
6120       case bp_hp_step_resume:
6121       case bp_watchpoint_scope:
6122       case bp_call_dummy:
6123       case bp_std_terminate:
6124       case bp_shlib_event:
6125       case bp_thread_event:
6126       case bp_overlay_event:
6127       case bp_longjmp_master:
6128       case bp_std_terminate_master:
6129       case bp_exception_master:
6130       case bp_tracepoint:
6131       case bp_fast_tracepoint:
6132       case bp_static_tracepoint:
6133       case bp_dprintf:
6134       case bp_jit_event:
6135       case bp_gnu_ifunc_resolver:
6136       case bp_gnu_ifunc_resolver_return:
6137         if (opts.addressprint)
6138           {
6139             annotate_field (4);
6140             if (header_of_multiple)
6141               uiout->field_string ("addr", "<MULTIPLE>");
6142             else if (b->loc == NULL || loc->shlib_disabled)
6143               uiout->field_string ("addr", "<PENDING>");
6144             else
6145               uiout->field_core_addr ("addr",
6146                                       loc->gdbarch, loc->address);
6147           }
6148         annotate_field (5);
6149         if (!header_of_multiple)
6150           print_breakpoint_location (b, loc);
6151         if (b->loc)
6152           *last_loc = b->loc;
6153         break;
6154       }
6155
6156
6157   if (loc != NULL && !header_of_multiple)
6158     {
6159       struct inferior *inf;
6160       std::vector<int> inf_nums;
6161       int mi_only = 1;
6162
6163       ALL_INFERIORS (inf)
6164         {
6165           if (inf->pspace == loc->pspace)
6166             inf_nums.push_back (inf->num);
6167         }
6168
6169         /* For backward compatibility, don't display inferiors in CLI unless
6170            there are several.  Always display for MI. */
6171         if (allflag
6172             || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6173                 && (number_of_program_spaces () > 1
6174                     || number_of_inferiors () > 1)
6175                 /* LOC is for existing B, it cannot be in
6176                    moribund_locations and thus having NULL OWNER.  */
6177                 && loc->owner->type != bp_catchpoint))
6178         mi_only = 0;
6179       output_thread_groups (uiout, "thread-groups", inf_nums, mi_only);
6180     }
6181
6182   if (!part_of_multiple)
6183     {
6184       if (b->thread != -1)
6185         {
6186           /* FIXME: This seems to be redundant and lost here; see the
6187              "stop only in" line a little further down.  */
6188           uiout->text (" thread ");
6189           uiout->field_int ("thread", b->thread);
6190         }
6191       else if (b->task != 0)
6192         {
6193           uiout->text (" task ");
6194           uiout->field_int ("task", b->task);
6195         }
6196     }
6197
6198   uiout->text ("\n");
6199
6200   if (!part_of_multiple)
6201     b->ops->print_one_detail (b, uiout);
6202
6203   if (part_of_multiple && frame_id_p (b->frame_id))
6204     {
6205       annotate_field (6);
6206       uiout->text ("\tstop only in stack frame at ");
6207       /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6208          the frame ID.  */
6209       uiout->field_core_addr ("frame",
6210                               b->gdbarch, b->frame_id.stack_addr);
6211       uiout->text ("\n");
6212     }
6213   
6214   if (!part_of_multiple && b->cond_string)
6215     {
6216       annotate_field (7);
6217       if (is_tracepoint (b))
6218         uiout->text ("\ttrace only if ");
6219       else
6220         uiout->text ("\tstop only if ");
6221       uiout->field_string ("cond", b->cond_string);
6222
6223       /* Print whether the target is doing the breakpoint's condition
6224          evaluation.  If GDB is doing the evaluation, don't print anything.  */
6225       if (is_breakpoint (b)
6226           && breakpoint_condition_evaluation_mode ()
6227           == condition_evaluation_target)
6228         {
6229           uiout->text (" (");
6230           uiout->field_string ("evaluated-by",
6231                                bp_condition_evaluator (b));
6232           uiout->text (" evals)");
6233         }
6234       uiout->text ("\n");
6235     }
6236
6237   if (!part_of_multiple && b->thread != -1)
6238     {
6239       /* FIXME should make an annotation for this.  */
6240       uiout->text ("\tstop only in thread ");
6241       if (uiout->is_mi_like_p ())
6242         uiout->field_int ("thread", b->thread);
6243       else
6244         {
6245           struct thread_info *thr = find_thread_global_id (b->thread);
6246
6247           uiout->field_string ("thread", print_thread_id (thr));
6248         }
6249       uiout->text ("\n");
6250     }
6251   
6252   if (!part_of_multiple)
6253     {
6254       if (b->hit_count)
6255         {
6256           /* FIXME should make an annotation for this.  */
6257           if (is_catchpoint (b))
6258             uiout->text ("\tcatchpoint");
6259           else if (is_tracepoint (b))
6260             uiout->text ("\ttracepoint");
6261           else
6262             uiout->text ("\tbreakpoint");
6263           uiout->text (" already hit ");
6264           uiout->field_int ("times", b->hit_count);
6265           if (b->hit_count == 1)
6266             uiout->text (" time\n");
6267           else
6268             uiout->text (" times\n");
6269         }
6270       else
6271         {
6272           /* Output the count also if it is zero, but only if this is mi.  */
6273           if (uiout->is_mi_like_p ())
6274             uiout->field_int ("times", b->hit_count);
6275         }
6276     }
6277
6278   if (!part_of_multiple && b->ignore_count)
6279     {
6280       annotate_field (8);
6281       uiout->text ("\tignore next ");
6282       uiout->field_int ("ignore", b->ignore_count);
6283       uiout->text (" hits\n");
6284     }
6285
6286   /* Note that an enable count of 1 corresponds to "enable once"
6287      behavior, which is reported by the combination of enablement and
6288      disposition, so we don't need to mention it here.  */
6289   if (!part_of_multiple && b->enable_count > 1)
6290     {
6291       annotate_field (8);
6292       uiout->text ("\tdisable after ");
6293       /* Tweak the wording to clarify that ignore and enable counts
6294          are distinct, and have additive effect.  */
6295       if (b->ignore_count)
6296         uiout->text ("additional ");
6297       else
6298         uiout->text ("next ");
6299       uiout->field_int ("enable", b->enable_count);
6300       uiout->text (" hits\n");
6301     }
6302
6303   if (!part_of_multiple && is_tracepoint (b))
6304     {
6305       struct tracepoint *tp = (struct tracepoint *) b;
6306
6307       if (tp->traceframe_usage)
6308         {
6309           uiout->text ("\ttrace buffer usage ");
6310           uiout->field_int ("traceframe-usage", tp->traceframe_usage);
6311           uiout->text (" bytes\n");
6312         }
6313     }
6314
6315   l = b->commands ? b->commands.get () : NULL;
6316   if (!part_of_multiple && l)
6317     {
6318       annotate_field (9);
6319       ui_out_emit_tuple tuple_emitter (uiout, "script");
6320       print_command_lines (uiout, l, 4);
6321     }
6322
6323   if (is_tracepoint (b))
6324     {
6325       struct tracepoint *t = (struct tracepoint *) b;
6326
6327       if (!part_of_multiple && t->pass_count)
6328         {
6329           annotate_field (10);
6330           uiout->text ("\tpass count ");
6331           uiout->field_int ("pass", t->pass_count);
6332           uiout->text (" \n");
6333         }
6334
6335       /* Don't display it when tracepoint or tracepoint location is
6336          pending.   */
6337       if (!header_of_multiple && loc != NULL && !loc->shlib_disabled)
6338         {
6339           annotate_field (11);
6340
6341           if (uiout->is_mi_like_p ())
6342             uiout->field_string ("installed",
6343                                  loc->inserted ? "y" : "n");
6344           else
6345             {
6346               if (loc->inserted)
6347                 uiout->text ("\t");
6348               else
6349                 uiout->text ("\tnot ");
6350               uiout->text ("installed on target\n");
6351             }
6352         }
6353     }
6354
6355   if (uiout->is_mi_like_p () && !part_of_multiple)
6356     {
6357       if (is_watchpoint (b))
6358         {
6359           struct watchpoint *w = (struct watchpoint *) b;
6360
6361           uiout->field_string ("original-location", w->exp_string);
6362         }
6363       else if (b->location != NULL
6364                && event_location_to_string (b->location.get ()) != NULL)
6365         uiout->field_string ("original-location",
6366                              event_location_to_string (b->location.get ()));
6367     }
6368 }
6369
6370 static void
6371 print_one_breakpoint (struct breakpoint *b,
6372                       struct bp_location **last_loc, 
6373                       int allflag)
6374 {
6375   struct ui_out *uiout = current_uiout;
6376
6377   {
6378     ui_out_emit_tuple tuple_emitter (uiout, "bkpt");
6379
6380     print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
6381   }
6382
6383   /* If this breakpoint has custom print function,
6384      it's already printed.  Otherwise, print individual
6385      locations, if any.  */
6386   if (b->ops == NULL || b->ops->print_one == NULL)
6387     {
6388       /* If breakpoint has a single location that is disabled, we
6389          print it as if it had several locations, since otherwise it's
6390          hard to represent "breakpoint enabled, location disabled"
6391          situation.
6392
6393          Note that while hardware watchpoints have several locations
6394          internally, that's not a property exposed to user.  */
6395       if (b->loc 
6396           && !is_hardware_watchpoint (b)
6397           && (b->loc->next || !b->loc->enabled))
6398         {
6399           struct bp_location *loc;
6400           int n = 1;
6401
6402           for (loc = b->loc; loc; loc = loc->next, ++n)
6403             {
6404               ui_out_emit_tuple tuple_emitter (uiout, NULL);
6405               print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6406             }
6407         }
6408     }
6409 }
6410
6411 static int
6412 breakpoint_address_bits (struct breakpoint *b)
6413 {
6414   int print_address_bits = 0;
6415   struct bp_location *loc;
6416
6417   /* Software watchpoints that aren't watching memory don't have an
6418      address to print.  */
6419   if (is_no_memory_software_watchpoint (b))
6420     return 0;
6421
6422   for (loc = b->loc; loc; loc = loc->next)
6423     {
6424       int addr_bit;
6425
6426       addr_bit = gdbarch_addr_bit (loc->gdbarch);
6427       if (addr_bit > print_address_bits)
6428         print_address_bits = addr_bit;
6429     }
6430
6431   return print_address_bits;
6432 }
6433
6434 /* See breakpoint.h.  */
6435
6436 void
6437 print_breakpoint (breakpoint *b)
6438 {
6439   struct bp_location *dummy_loc = NULL;
6440   print_one_breakpoint (b, &dummy_loc, 0);
6441 }
6442
6443 /* Return true if this breakpoint was set by the user, false if it is
6444    internal or momentary.  */
6445
6446 int
6447 user_breakpoint_p (struct breakpoint *b)
6448 {
6449   return b->number > 0;
6450 }
6451
6452 /* See breakpoint.h.  */
6453
6454 int
6455 pending_breakpoint_p (struct breakpoint *b)
6456 {
6457   return b->loc == NULL;
6458 }
6459
6460 /* Print information on user settable breakpoint (watchpoint, etc)
6461    number BNUM.  If BNUM is -1 print all user-settable breakpoints.
6462    If ALLFLAG is non-zero, include non-user-settable breakpoints.  If
6463    FILTER is non-NULL, call it on each breakpoint and only include the
6464    ones for which it returns non-zero.  Return the total number of
6465    breakpoints listed.  */
6466
6467 static int
6468 breakpoint_1 (const char *args, int allflag, 
6469               int (*filter) (const struct breakpoint *))
6470 {
6471   struct breakpoint *b;
6472   struct bp_location *last_loc = NULL;
6473   int nr_printable_breakpoints;
6474   struct value_print_options opts;
6475   int print_address_bits = 0;
6476   int print_type_col_width = 14;
6477   struct ui_out *uiout = current_uiout;
6478
6479   get_user_print_options (&opts);
6480
6481   /* Compute the number of rows in the table, as well as the size
6482      required for address fields.  */
6483   nr_printable_breakpoints = 0;
6484   ALL_BREAKPOINTS (b)
6485     {
6486       /* If we have a filter, only list the breakpoints it accepts.  */
6487       if (filter && !filter (b))
6488         continue;
6489
6490       /* If we have an "args" string, it is a list of breakpoints to 
6491          accept.  Skip the others.  */
6492       if (args != NULL && *args != '\0')
6493         {
6494           if (allflag && parse_and_eval_long (args) != b->number)
6495             continue;
6496           if (!allflag && !number_is_in_list (args, b->number))
6497             continue;
6498         }
6499
6500       if (allflag || user_breakpoint_p (b))
6501         {
6502           int addr_bit, type_len;
6503
6504           addr_bit = breakpoint_address_bits (b);
6505           if (addr_bit > print_address_bits)
6506             print_address_bits = addr_bit;
6507
6508           type_len = strlen (bptype_string (b->type));
6509           if (type_len > print_type_col_width)
6510             print_type_col_width = type_len;
6511
6512           nr_printable_breakpoints++;
6513         }
6514     }
6515
6516   {
6517     ui_out_emit_table table_emitter (uiout,
6518                                      opts.addressprint ? 6 : 5,
6519                                      nr_printable_breakpoints,
6520                                      "BreakpointTable");
6521
6522     if (nr_printable_breakpoints > 0)
6523       annotate_breakpoints_headers ();
6524     if (nr_printable_breakpoints > 0)
6525       annotate_field (0);
6526     uiout->table_header (7, ui_left, "number", "Num"); /* 1 */
6527     if (nr_printable_breakpoints > 0)
6528       annotate_field (1);
6529     uiout->table_header (print_type_col_width, ui_left, "type", "Type"); /* 2 */
6530     if (nr_printable_breakpoints > 0)
6531       annotate_field (2);
6532     uiout->table_header (4, ui_left, "disp", "Disp"); /* 3 */
6533     if (nr_printable_breakpoints > 0)
6534       annotate_field (3);
6535     uiout->table_header (3, ui_left, "enabled", "Enb"); /* 4 */
6536     if (opts.addressprint)
6537       {
6538         if (nr_printable_breakpoints > 0)
6539           annotate_field (4);
6540         if (print_address_bits <= 32)
6541           uiout->table_header (10, ui_left, "addr", "Address"); /* 5 */
6542         else
6543           uiout->table_header (18, ui_left, "addr", "Address"); /* 5 */
6544       }
6545     if (nr_printable_breakpoints > 0)
6546       annotate_field (5);
6547     uiout->table_header (40, ui_noalign, "what", "What"); /* 6 */
6548     uiout->table_body ();
6549     if (nr_printable_breakpoints > 0)
6550       annotate_breakpoints_table ();
6551
6552     ALL_BREAKPOINTS (b)
6553       {
6554         QUIT;
6555         /* If we have a filter, only list the breakpoints it accepts.  */
6556         if (filter && !filter (b))
6557           continue;
6558
6559         /* If we have an "args" string, it is a list of breakpoints to 
6560            accept.  Skip the others.  */
6561
6562         if (args != NULL && *args != '\0')
6563           {
6564             if (allflag)        /* maintenance info breakpoint */
6565               {
6566                 if (parse_and_eval_long (args) != b->number)
6567                   continue;
6568               }
6569             else                /* all others */
6570               {
6571                 if (!number_is_in_list (args, b->number))
6572                   continue;
6573               }
6574           }
6575         /* We only print out user settable breakpoints unless the
6576            allflag is set.  */
6577         if (allflag || user_breakpoint_p (b))
6578           print_one_breakpoint (b, &last_loc, allflag);
6579       }
6580   }
6581
6582   if (nr_printable_breakpoints == 0)
6583     {
6584       /* If there's a filter, let the caller decide how to report
6585          empty list.  */
6586       if (!filter)
6587         {
6588           if (args == NULL || *args == '\0')
6589             uiout->message ("No breakpoints or watchpoints.\n");
6590           else
6591             uiout->message ("No breakpoint or watchpoint matching '%s'.\n",
6592                             args);
6593         }
6594     }
6595   else
6596     {
6597       if (last_loc && !server_command)
6598         set_next_address (last_loc->gdbarch, last_loc->address);
6599     }
6600
6601   /* FIXME?  Should this be moved up so that it is only called when
6602      there have been breakpoints? */
6603   annotate_breakpoints_table_end ();
6604
6605   return nr_printable_breakpoints;
6606 }
6607
6608 /* Display the value of default-collect in a way that is generally
6609    compatible with the breakpoint list.  */
6610
6611 static void
6612 default_collect_info (void)
6613 {
6614   struct ui_out *uiout = current_uiout;
6615
6616   /* If it has no value (which is frequently the case), say nothing; a
6617      message like "No default-collect." gets in user's face when it's
6618      not wanted.  */
6619   if (!*default_collect)
6620     return;
6621
6622   /* The following phrase lines up nicely with per-tracepoint collect
6623      actions.  */
6624   uiout->text ("default collect ");
6625   uiout->field_string ("default-collect", default_collect);
6626   uiout->text (" \n");
6627 }
6628   
6629 static void
6630 info_breakpoints_command (const char *args, int from_tty)
6631 {
6632   breakpoint_1 (args, 0, NULL);
6633
6634   default_collect_info ();
6635 }
6636
6637 static void
6638 info_watchpoints_command (const char *args, int from_tty)
6639 {
6640   int num_printed = breakpoint_1 (args, 0, is_watchpoint);
6641   struct ui_out *uiout = current_uiout;
6642
6643   if (num_printed == 0)
6644     {
6645       if (args == NULL || *args == '\0')
6646         uiout->message ("No watchpoints.\n");
6647       else
6648         uiout->message ("No watchpoint matching '%s'.\n", args);
6649     }
6650 }
6651
6652 static void
6653 maintenance_info_breakpoints (const char *args, int from_tty)
6654 {
6655   breakpoint_1 (args, 1, NULL);
6656
6657   default_collect_info ();
6658 }
6659
6660 static int
6661 breakpoint_has_pc (struct breakpoint *b,
6662                    struct program_space *pspace,
6663                    CORE_ADDR pc, struct obj_section *section)
6664 {
6665   struct bp_location *bl = b->loc;
6666
6667   for (; bl; bl = bl->next)
6668     {
6669       if (bl->pspace == pspace
6670           && bl->address == pc
6671           && (!overlay_debugging || bl->section == section))
6672         return 1;         
6673     }
6674   return 0;
6675 }
6676
6677 /* Print a message describing any user-breakpoints set at PC.  This
6678    concerns with logical breakpoints, so we match program spaces, not
6679    address spaces.  */
6680
6681 static void
6682 describe_other_breakpoints (struct gdbarch *gdbarch,
6683                             struct program_space *pspace, CORE_ADDR pc,
6684                             struct obj_section *section, int thread)
6685 {
6686   int others = 0;
6687   struct breakpoint *b;
6688
6689   ALL_BREAKPOINTS (b)
6690     others += (user_breakpoint_p (b)
6691                && breakpoint_has_pc (b, pspace, pc, section));
6692   if (others > 0)
6693     {
6694       if (others == 1)
6695         printf_filtered (_("Note: breakpoint "));
6696       else /* if (others == ???) */
6697         printf_filtered (_("Note: breakpoints "));
6698       ALL_BREAKPOINTS (b)
6699         if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
6700           {
6701             others--;
6702             printf_filtered ("%d", b->number);
6703             if (b->thread == -1 && thread != -1)
6704               printf_filtered (" (all threads)");
6705             else if (b->thread != -1)
6706               printf_filtered (" (thread %d)", b->thread);
6707             printf_filtered ("%s%s ",
6708                              ((b->enable_state == bp_disabled
6709                                || b->enable_state == bp_call_disabled)
6710                               ? " (disabled)"
6711                               : ""),
6712                              (others > 1) ? "," 
6713                              : ((others == 1) ? " and" : ""));
6714           }
6715       printf_filtered (_("also set at pc "));
6716       fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
6717       printf_filtered (".\n");
6718     }
6719 }
6720 \f
6721
6722 /* Return true iff it is meaningful to use the address member of
6723    BPT locations.  For some breakpoint types, the locations' address members
6724    are irrelevant and it makes no sense to attempt to compare them to other
6725    addresses (or use them for any other purpose either).
6726
6727    More specifically, each of the following breakpoint types will
6728    always have a zero valued location address and we don't want to mark
6729    breakpoints of any of these types to be a duplicate of an actual
6730    breakpoint location at address zero:
6731
6732       bp_watchpoint
6733       bp_catchpoint
6734
6735 */
6736
6737 static int
6738 breakpoint_address_is_meaningful (struct breakpoint *bpt)
6739 {
6740   enum bptype type = bpt->type;
6741
6742   return (type != bp_watchpoint && type != bp_catchpoint);
6743 }
6744
6745 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6746    true if LOC1 and LOC2 represent the same watchpoint location.  */
6747
6748 static int
6749 watchpoint_locations_match (struct bp_location *loc1, 
6750                             struct bp_location *loc2)
6751 {
6752   struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
6753   struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
6754
6755   /* Both of them must exist.  */
6756   gdb_assert (w1 != NULL);
6757   gdb_assert (w2 != NULL);
6758
6759   /* If the target can evaluate the condition expression in hardware,
6760      then we we need to insert both watchpoints even if they are at
6761      the same place.  Otherwise the watchpoint will only trigger when
6762      the condition of whichever watchpoint was inserted evaluates to
6763      true, not giving a chance for GDB to check the condition of the
6764      other watchpoint.  */
6765   if ((w1->cond_exp
6766        && target_can_accel_watchpoint_condition (loc1->address, 
6767                                                  loc1->length,
6768                                                  loc1->watchpoint_type,
6769                                                  w1->cond_exp.get ()))
6770       || (w2->cond_exp
6771           && target_can_accel_watchpoint_condition (loc2->address, 
6772                                                     loc2->length,
6773                                                     loc2->watchpoint_type,
6774                                                     w2->cond_exp.get ())))
6775     return 0;
6776
6777   /* Note that this checks the owner's type, not the location's.  In
6778      case the target does not support read watchpoints, but does
6779      support access watchpoints, we'll have bp_read_watchpoint
6780      watchpoints with hw_access locations.  Those should be considered
6781      duplicates of hw_read locations.  The hw_read locations will
6782      become hw_access locations later.  */
6783   return (loc1->owner->type == loc2->owner->type
6784           && loc1->pspace->aspace == loc2->pspace->aspace
6785           && loc1->address == loc2->address
6786           && loc1->length == loc2->length);
6787 }
6788
6789 /* See breakpoint.h.  */
6790
6791 int
6792 breakpoint_address_match (const address_space *aspace1, CORE_ADDR addr1,
6793                           const address_space *aspace2, CORE_ADDR addr2)
6794 {
6795   return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6796            || aspace1 == aspace2)
6797           && addr1 == addr2);
6798 }
6799
6800 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6801    {ASPACE1,ADDR1,LEN1}.  In most targets, this can only be true if ASPACE1
6802    matches ASPACE2.  On targets that have global breakpoints, the address
6803    space doesn't really matter.  */
6804
6805 static int
6806 breakpoint_address_match_range (const address_space *aspace1,
6807                                 CORE_ADDR addr1,
6808                                 int len1, const address_space *aspace2,
6809                                 CORE_ADDR addr2)
6810 {
6811   return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6812            || aspace1 == aspace2)
6813           && addr2 >= addr1 && addr2 < addr1 + len1);
6814 }
6815
6816 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL.  BL may be
6817    a ranged breakpoint.  In most targets, a match happens only if ASPACE
6818    matches the breakpoint's address space.  On targets that have global
6819    breakpoints, the address space doesn't really matter.  */
6820
6821 static int
6822 breakpoint_location_address_match (struct bp_location *bl,
6823                                    const address_space *aspace,
6824                                    CORE_ADDR addr)
6825 {
6826   return (breakpoint_address_match (bl->pspace->aspace, bl->address,
6827                                     aspace, addr)
6828           || (bl->length
6829               && breakpoint_address_match_range (bl->pspace->aspace,
6830                                                  bl->address, bl->length,
6831                                                  aspace, addr)));
6832 }
6833
6834 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6835    breakpoint BL.  BL may be a ranged breakpoint.  In most targets, a
6836    match happens only if ASPACE matches the breakpoint's address
6837    space.  On targets that have global breakpoints, the address space
6838    doesn't really matter.  */
6839
6840 static int
6841 breakpoint_location_address_range_overlap (struct bp_location *bl,
6842                                            const address_space *aspace,
6843                                            CORE_ADDR addr, int len)
6844 {
6845   if (gdbarch_has_global_breakpoints (target_gdbarch ())
6846       || bl->pspace->aspace == aspace)
6847     {
6848       int bl_len = bl->length != 0 ? bl->length : 1;
6849
6850       if (mem_ranges_overlap (addr, len, bl->address, bl_len))
6851         return 1;
6852     }
6853   return 0;
6854 }
6855
6856 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6857    Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6858    true, otherwise returns false.  */
6859
6860 static int
6861 tracepoint_locations_match (struct bp_location *loc1,
6862                             struct bp_location *loc2)
6863 {
6864   if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
6865     /* Since tracepoint locations are never duplicated with others', tracepoint
6866        locations at the same address of different tracepoints are regarded as
6867        different locations.  */
6868     return (loc1->address == loc2->address && loc1->owner == loc2->owner);
6869   else
6870     return 0;
6871 }
6872
6873 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6874    (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6875    represent the same location.  */
6876
6877 static int
6878 breakpoint_locations_match (struct bp_location *loc1, 
6879                             struct bp_location *loc2)
6880 {
6881   int hw_point1, hw_point2;
6882
6883   /* Both of them must not be in moribund_locations.  */
6884   gdb_assert (loc1->owner != NULL);
6885   gdb_assert (loc2->owner != NULL);
6886
6887   hw_point1 = is_hardware_watchpoint (loc1->owner);
6888   hw_point2 = is_hardware_watchpoint (loc2->owner);
6889
6890   if (hw_point1 != hw_point2)
6891     return 0;
6892   else if (hw_point1)
6893     return watchpoint_locations_match (loc1, loc2);
6894   else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
6895     return tracepoint_locations_match (loc1, loc2);
6896   else
6897     /* We compare bp_location.length in order to cover ranged breakpoints.  */
6898     return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
6899                                      loc2->pspace->aspace, loc2->address)
6900             && loc1->length == loc2->length);
6901 }
6902
6903 static void
6904 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
6905                                int bnum, int have_bnum)
6906 {
6907   /* The longest string possibly returned by hex_string_custom
6908      is 50 chars.  These must be at least that big for safety.  */
6909   char astr1[64];
6910   char astr2[64];
6911
6912   strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
6913   strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
6914   if (have_bnum)
6915     warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6916              bnum, astr1, astr2);
6917   else
6918     warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
6919 }
6920
6921 /* Adjust a breakpoint's address to account for architectural
6922    constraints on breakpoint placement.  Return the adjusted address.
6923    Note: Very few targets require this kind of adjustment.  For most
6924    targets, this function is simply the identity function.  */
6925
6926 static CORE_ADDR
6927 adjust_breakpoint_address (struct gdbarch *gdbarch,
6928                            CORE_ADDR bpaddr, enum bptype bptype)
6929 {
6930   if (bptype == bp_watchpoint
6931       || bptype == bp_hardware_watchpoint
6932       || bptype == bp_read_watchpoint
6933       || bptype == bp_access_watchpoint
6934       || bptype == bp_catchpoint)
6935     {
6936       /* Watchpoints and the various bp_catch_* eventpoints should not
6937          have their addresses modified.  */
6938       return bpaddr;
6939     }
6940   else if (bptype == bp_single_step)
6941     {
6942       /* Single-step breakpoints should not have their addresses
6943          modified.  If there's any architectural constrain that
6944          applies to this address, then it should have already been
6945          taken into account when the breakpoint was created in the
6946          first place.  If we didn't do this, stepping through e.g.,
6947          Thumb-2 IT blocks would break.  */
6948       return bpaddr;
6949     }
6950   else
6951     {
6952       CORE_ADDR adjusted_bpaddr = bpaddr;
6953
6954       if (gdbarch_adjust_breakpoint_address_p (gdbarch))
6955         {
6956           /* Some targets have architectural constraints on the placement
6957              of breakpoint instructions.  Obtain the adjusted address.  */
6958           adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
6959         }
6960
6961       adjusted_bpaddr = address_significant (gdbarch, adjusted_bpaddr);
6962
6963       /* An adjusted breakpoint address can significantly alter
6964          a user's expectations.  Print a warning if an adjustment
6965          is required.  */
6966       if (adjusted_bpaddr != bpaddr)
6967         breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
6968
6969       return adjusted_bpaddr;
6970     }
6971 }
6972
6973 bp_location::bp_location (const bp_location_ops *ops, breakpoint *owner)
6974 {
6975   bp_location *loc = this;
6976
6977   gdb_assert (ops != NULL);
6978
6979   loc->ops = ops;
6980   loc->owner = owner;
6981   loc->cond_bytecode = NULL;
6982   loc->shlib_disabled = 0;
6983   loc->enabled = 1;
6984
6985   switch (owner->type)
6986     {
6987     case bp_breakpoint:
6988     case bp_single_step:
6989     case bp_until:
6990     case bp_finish:
6991     case bp_longjmp:
6992     case bp_longjmp_resume:
6993     case bp_longjmp_call_dummy:
6994     case bp_exception:
6995     case bp_exception_resume:
6996     case bp_step_resume:
6997     case bp_hp_step_resume:
6998     case bp_watchpoint_scope:
6999     case bp_call_dummy:
7000     case bp_std_terminate:
7001     case bp_shlib_event:
7002     case bp_thread_event:
7003     case bp_overlay_event:
7004     case bp_jit_event:
7005     case bp_longjmp_master:
7006     case bp_std_terminate_master:
7007     case bp_exception_master:
7008     case bp_gnu_ifunc_resolver:
7009     case bp_gnu_ifunc_resolver_return:
7010     case bp_dprintf:
7011       loc->loc_type = bp_loc_software_breakpoint;
7012       mark_breakpoint_location_modified (loc);
7013       break;
7014     case bp_hardware_breakpoint:
7015       loc->loc_type = bp_loc_hardware_breakpoint;
7016       mark_breakpoint_location_modified (loc);
7017       break;
7018     case bp_hardware_watchpoint:
7019     case bp_read_watchpoint:
7020     case bp_access_watchpoint:
7021       loc->loc_type = bp_loc_hardware_watchpoint;
7022       break;
7023     case bp_watchpoint:
7024     case bp_catchpoint:
7025     case bp_tracepoint:
7026     case bp_fast_tracepoint:
7027     case bp_static_tracepoint:
7028       loc->loc_type = bp_loc_other;
7029       break;
7030     default:
7031       internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
7032     }
7033
7034   loc->refc = 1;
7035 }
7036
7037 /* Allocate a struct bp_location.  */
7038
7039 static struct bp_location *
7040 allocate_bp_location (struct breakpoint *bpt)
7041 {
7042   return bpt->ops->allocate_location (bpt);
7043 }
7044
7045 static void
7046 free_bp_location (struct bp_location *loc)
7047 {
7048   loc->ops->dtor (loc);
7049   delete loc;
7050 }
7051
7052 /* Increment reference count.  */
7053
7054 static void
7055 incref_bp_location (struct bp_location *bl)
7056 {
7057   ++bl->refc;
7058 }
7059
7060 /* Decrement reference count.  If the reference count reaches 0,
7061    destroy the bp_location.  Sets *BLP to NULL.  */
7062
7063 static void
7064 decref_bp_location (struct bp_location **blp)
7065 {
7066   gdb_assert ((*blp)->refc > 0);
7067
7068   if (--(*blp)->refc == 0)
7069     free_bp_location (*blp);
7070   *blp = NULL;
7071 }
7072
7073 /* Add breakpoint B at the end of the global breakpoint chain.  */
7074
7075 static breakpoint *
7076 add_to_breakpoint_chain (std::unique_ptr<breakpoint> &&b)
7077 {
7078   struct breakpoint *b1;
7079   struct breakpoint *result = b.get ();
7080
7081   /* Add this breakpoint to the end of the chain so that a list of
7082      breakpoints will come out in order of increasing numbers.  */
7083
7084   b1 = breakpoint_chain;
7085   if (b1 == 0)
7086     breakpoint_chain = b.release ();
7087   else
7088     {
7089       while (b1->next)
7090         b1 = b1->next;
7091       b1->next = b.release ();
7092     }
7093
7094   return result;
7095 }
7096
7097 /* Initializes breakpoint B with type BPTYPE and no locations yet.  */
7098
7099 static void
7100 init_raw_breakpoint_without_location (struct breakpoint *b,
7101                                       struct gdbarch *gdbarch,
7102                                       enum bptype bptype,
7103                                       const struct breakpoint_ops *ops)
7104 {
7105   gdb_assert (ops != NULL);
7106
7107   b->ops = ops;
7108   b->type = bptype;
7109   b->gdbarch = gdbarch;
7110   b->language = current_language->la_language;
7111   b->input_radix = input_radix;
7112   b->related_breakpoint = b;
7113 }
7114
7115 /* Helper to set_raw_breakpoint below.  Creates a breakpoint
7116    that has type BPTYPE and has no locations as yet.  */
7117
7118 static struct breakpoint *
7119 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
7120                                      enum bptype bptype,
7121                                      const struct breakpoint_ops *ops)
7122 {
7123   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7124
7125   init_raw_breakpoint_without_location (b.get (), gdbarch, bptype, ops);
7126   return add_to_breakpoint_chain (std::move (b));
7127 }
7128
7129 /* Initialize loc->function_name.  EXPLICIT_LOC says no indirect function
7130    resolutions should be made as the user specified the location explicitly
7131    enough.  */
7132
7133 static void
7134 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
7135 {
7136   gdb_assert (loc->owner != NULL);
7137
7138   if (loc->owner->type == bp_breakpoint
7139       || loc->owner->type == bp_hardware_breakpoint
7140       || is_tracepoint (loc->owner))
7141     {
7142       const char *function_name;
7143
7144       if (loc->msymbol != NULL
7145           && (MSYMBOL_TYPE (loc->msymbol) == mst_text_gnu_ifunc
7146               || MSYMBOL_TYPE (loc->msymbol) == mst_data_gnu_ifunc)
7147           && !explicit_loc)
7148         {
7149           struct breakpoint *b = loc->owner;
7150
7151           function_name = MSYMBOL_LINKAGE_NAME (loc->msymbol);
7152
7153           if (b->type == bp_breakpoint && b->loc == loc
7154               && loc->next == NULL && b->related_breakpoint == b)
7155             {
7156               /* Create only the whole new breakpoint of this type but do not
7157                  mess more complicated breakpoints with multiple locations.  */
7158               b->type = bp_gnu_ifunc_resolver;
7159               /* Remember the resolver's address for use by the return
7160                  breakpoint.  */
7161               loc->related_address = loc->address;
7162             }
7163         }
7164       else
7165         find_pc_partial_function (loc->address, &function_name, NULL, NULL);
7166
7167       if (function_name)
7168         loc->function_name = xstrdup (function_name);
7169     }
7170 }
7171
7172 /* Attempt to determine architecture of location identified by SAL.  */
7173 struct gdbarch *
7174 get_sal_arch (struct symtab_and_line sal)
7175 {
7176   if (sal.section)
7177     return get_objfile_arch (sal.section->objfile);
7178   if (sal.symtab)
7179     return get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
7180
7181   return NULL;
7182 }
7183
7184 /* Low level routine for partially initializing a breakpoint of type
7185    BPTYPE.  The newly created breakpoint's address, section, source
7186    file name, and line number are provided by SAL.
7187
7188    It is expected that the caller will complete the initialization of
7189    the newly created breakpoint struct as well as output any status
7190    information regarding the creation of a new breakpoint.  */
7191
7192 static void
7193 init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
7194                      struct symtab_and_line sal, enum bptype bptype,
7195                      const struct breakpoint_ops *ops)
7196 {
7197   init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
7198
7199   add_location_to_breakpoint (b, &sal);
7200
7201   if (bptype != bp_catchpoint)
7202     gdb_assert (sal.pspace != NULL);
7203
7204   /* Store the program space that was used to set the breakpoint,
7205      except for ordinary breakpoints, which are independent of the
7206      program space.  */
7207   if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
7208     b->pspace = sal.pspace;
7209 }
7210
7211 /* set_raw_breakpoint is a low level routine for allocating and
7212    partially initializing a breakpoint of type BPTYPE.  The newly
7213    created breakpoint's address, section, source file name, and line
7214    number are provided by SAL.  The newly created and partially
7215    initialized breakpoint is added to the breakpoint chain and
7216    is also returned as the value of this function.
7217
7218    It is expected that the caller will complete the initialization of
7219    the newly created breakpoint struct as well as output any status
7220    information regarding the creation of a new breakpoint.  In
7221    particular, set_raw_breakpoint does NOT set the breakpoint
7222    number!  Care should be taken to not allow an error to occur
7223    prior to completing the initialization of the breakpoint.  If this
7224    should happen, a bogus breakpoint will be left on the chain.  */
7225
7226 struct breakpoint *
7227 set_raw_breakpoint (struct gdbarch *gdbarch,
7228                     struct symtab_and_line sal, enum bptype bptype,
7229                     const struct breakpoint_ops *ops)
7230 {
7231   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7232
7233   init_raw_breakpoint (b.get (), gdbarch, sal, bptype, ops);
7234   return add_to_breakpoint_chain (std::move (b));
7235 }
7236
7237 /* Call this routine when stepping and nexting to enable a breakpoint
7238    if we do a longjmp() or 'throw' in TP.  FRAME is the frame which
7239    initiated the operation.  */
7240
7241 void
7242 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
7243 {
7244   struct breakpoint *b, *b_tmp;
7245   int thread = tp->global_num;
7246
7247   /* To avoid having to rescan all objfile symbols at every step,
7248      we maintain a list of continually-inserted but always disabled
7249      longjmp "master" breakpoints.  Here, we simply create momentary
7250      clones of those and enable them for the requested thread.  */
7251   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7252     if (b->pspace == current_program_space
7253         && (b->type == bp_longjmp_master
7254             || b->type == bp_exception_master))
7255       {
7256         enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7257         struct breakpoint *clone;
7258
7259         /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7260            after their removal.  */
7261         clone = momentary_breakpoint_from_master (b, type,
7262                                                   &momentary_breakpoint_ops, 1);
7263         clone->thread = thread;
7264       }
7265
7266   tp->initiating_frame = frame;
7267 }
7268
7269 /* Delete all longjmp breakpoints from THREAD.  */
7270 void
7271 delete_longjmp_breakpoint (int thread)
7272 {
7273   struct breakpoint *b, *b_tmp;
7274
7275   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7276     if (b->type == bp_longjmp || b->type == bp_exception)
7277       {
7278         if (b->thread == thread)
7279           delete_breakpoint (b);
7280       }
7281 }
7282
7283 void
7284 delete_longjmp_breakpoint_at_next_stop (int thread)
7285 {
7286   struct breakpoint *b, *b_tmp;
7287
7288   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7289     if (b->type == bp_longjmp || b->type == bp_exception)
7290       {
7291         if (b->thread == thread)
7292           b->disposition = disp_del_at_next_stop;
7293       }
7294 }
7295
7296 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7297    INFERIOR_PTID thread.  Chain them all by RELATED_BREAKPOINT and return
7298    pointer to any of them.  Return NULL if this system cannot place longjmp
7299    breakpoints.  */
7300
7301 struct breakpoint *
7302 set_longjmp_breakpoint_for_call_dummy (void)
7303 {
7304   struct breakpoint *b, *retval = NULL;
7305
7306   ALL_BREAKPOINTS (b)
7307     if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7308       {
7309         struct breakpoint *new_b;
7310
7311         new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
7312                                                   &momentary_breakpoint_ops,
7313                                                   1);
7314         new_b->thread = inferior_thread ()->global_num;
7315
7316         /* Link NEW_B into the chain of RETVAL breakpoints.  */
7317
7318         gdb_assert (new_b->related_breakpoint == new_b);
7319         if (retval == NULL)
7320           retval = new_b;
7321         new_b->related_breakpoint = retval;
7322         while (retval->related_breakpoint != new_b->related_breakpoint)
7323           retval = retval->related_breakpoint;
7324         retval->related_breakpoint = new_b;
7325       }
7326
7327   return retval;
7328 }
7329
7330 /* Verify all existing dummy frames and their associated breakpoints for
7331    TP.  Remove those which can no longer be found in the current frame
7332    stack.
7333
7334    You should call this function only at places where it is safe to currently
7335    unwind the whole stack.  Failed stack unwind would discard live dummy
7336    frames.  */
7337
7338 void
7339 check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp)
7340 {
7341   struct breakpoint *b, *b_tmp;
7342
7343   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7344     if (b->type == bp_longjmp_call_dummy && b->thread == tp->global_num)
7345       {
7346         struct breakpoint *dummy_b = b->related_breakpoint;
7347
7348         while (dummy_b != b && dummy_b->type != bp_call_dummy)
7349           dummy_b = dummy_b->related_breakpoint;
7350         if (dummy_b->type != bp_call_dummy
7351             || frame_find_by_id (dummy_b->frame_id) != NULL)
7352           continue;
7353         
7354         dummy_frame_discard (dummy_b->frame_id, tp);
7355
7356         while (b->related_breakpoint != b)
7357           {
7358             if (b_tmp == b->related_breakpoint)
7359               b_tmp = b->related_breakpoint->next;
7360             delete_breakpoint (b->related_breakpoint);
7361           }
7362         delete_breakpoint (b);
7363       }
7364 }
7365
7366 void
7367 enable_overlay_breakpoints (void)
7368 {
7369   struct breakpoint *b;
7370
7371   ALL_BREAKPOINTS (b)
7372     if (b->type == bp_overlay_event)
7373     {
7374       b->enable_state = bp_enabled;
7375       update_global_location_list (UGLL_MAY_INSERT);
7376       overlay_events_enabled = 1;
7377     }
7378 }
7379
7380 void
7381 disable_overlay_breakpoints (void)
7382 {
7383   struct breakpoint *b;
7384
7385   ALL_BREAKPOINTS (b)
7386     if (b->type == bp_overlay_event)
7387     {
7388       b->enable_state = bp_disabled;
7389       update_global_location_list (UGLL_DONT_INSERT);
7390       overlay_events_enabled = 0;
7391     }
7392 }
7393
7394 /* Set an active std::terminate breakpoint for each std::terminate
7395    master breakpoint.  */
7396 void
7397 set_std_terminate_breakpoint (void)
7398 {
7399   struct breakpoint *b, *b_tmp;
7400
7401   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7402     if (b->pspace == current_program_space
7403         && b->type == bp_std_terminate_master)
7404       {
7405         momentary_breakpoint_from_master (b, bp_std_terminate,
7406                                           &momentary_breakpoint_ops, 1);
7407       }
7408 }
7409
7410 /* Delete all the std::terminate breakpoints.  */
7411 void
7412 delete_std_terminate_breakpoint (void)
7413 {
7414   struct breakpoint *b, *b_tmp;
7415
7416   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7417     if (b->type == bp_std_terminate)
7418       delete_breakpoint (b);
7419 }
7420
7421 struct breakpoint *
7422 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7423 {
7424   struct breakpoint *b;
7425
7426   b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7427                                   &internal_breakpoint_ops);
7428
7429   b->enable_state = bp_enabled;
7430   /* location has to be used or breakpoint_re_set will delete me.  */
7431   b->location = new_address_location (b->loc->address, NULL, 0);
7432
7433   update_global_location_list_nothrow (UGLL_MAY_INSERT);
7434
7435   return b;
7436 }
7437
7438 struct lang_and_radix
7439   {
7440     enum language lang;
7441     int radix;
7442   };
7443
7444 /* Create a breakpoint for JIT code registration and unregistration.  */
7445
7446 struct breakpoint *
7447 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7448 {
7449   return create_internal_breakpoint (gdbarch, address, bp_jit_event,
7450                                      &internal_breakpoint_ops);
7451 }
7452
7453 /* Remove JIT code registration and unregistration breakpoint(s).  */
7454
7455 void
7456 remove_jit_event_breakpoints (void)
7457 {
7458   struct breakpoint *b, *b_tmp;
7459
7460   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7461     if (b->type == bp_jit_event
7462         && b->loc->pspace == current_program_space)
7463       delete_breakpoint (b);
7464 }
7465
7466 void
7467 remove_solib_event_breakpoints (void)
7468 {
7469   struct breakpoint *b, *b_tmp;
7470
7471   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7472     if (b->type == bp_shlib_event
7473         && b->loc->pspace == current_program_space)
7474       delete_breakpoint (b);
7475 }
7476
7477 /* See breakpoint.h.  */
7478
7479 void
7480 remove_solib_event_breakpoints_at_next_stop (void)
7481 {
7482   struct breakpoint *b, *b_tmp;
7483
7484   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7485     if (b->type == bp_shlib_event
7486         && b->loc->pspace == current_program_space)
7487       b->disposition = disp_del_at_next_stop;
7488 }
7489
7490 /* Helper for create_solib_event_breakpoint /
7491    create_and_insert_solib_event_breakpoint.  Allows specifying which
7492    INSERT_MODE to pass through to update_global_location_list.  */
7493
7494 static struct breakpoint *
7495 create_solib_event_breakpoint_1 (struct gdbarch *gdbarch, CORE_ADDR address,
7496                                  enum ugll_insert_mode insert_mode)
7497 {
7498   struct breakpoint *b;
7499
7500   b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7501                                   &internal_breakpoint_ops);
7502   update_global_location_list_nothrow (insert_mode);
7503   return b;
7504 }
7505
7506 struct breakpoint *
7507 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7508 {
7509   return create_solib_event_breakpoint_1 (gdbarch, address, UGLL_MAY_INSERT);
7510 }
7511
7512 /* See breakpoint.h.  */
7513
7514 struct breakpoint *
7515 create_and_insert_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7516 {
7517   struct breakpoint *b;
7518
7519   /* Explicitly tell update_global_location_list to insert
7520      locations.  */
7521   b = create_solib_event_breakpoint_1 (gdbarch, address, UGLL_INSERT);
7522   if (!b->loc->inserted)
7523     {
7524       delete_breakpoint (b);
7525       return NULL;
7526     }
7527   return b;
7528 }
7529
7530 /* Disable any breakpoints that are on code in shared libraries.  Only
7531    apply to enabled breakpoints, disabled ones can just stay disabled.  */
7532
7533 void
7534 disable_breakpoints_in_shlibs (void)
7535 {
7536   struct bp_location *loc, **locp_tmp;
7537
7538   ALL_BP_LOCATIONS (loc, locp_tmp)
7539   {
7540     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7541     struct breakpoint *b = loc->owner;
7542
7543     /* We apply the check to all breakpoints, including disabled for
7544        those with loc->duplicate set.  This is so that when breakpoint
7545        becomes enabled, or the duplicate is removed, gdb will try to
7546        insert all breakpoints.  If we don't set shlib_disabled here,
7547        we'll try to insert those breakpoints and fail.  */
7548     if (((b->type == bp_breakpoint)
7549          || (b->type == bp_jit_event)
7550          || (b->type == bp_hardware_breakpoint)
7551          || (is_tracepoint (b)))
7552         && loc->pspace == current_program_space
7553         && !loc->shlib_disabled
7554         && solib_name_from_address (loc->pspace, loc->address)
7555         )
7556       {
7557         loc->shlib_disabled = 1;
7558       }
7559   }
7560 }
7561
7562 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7563    notification of unloaded_shlib.  Only apply to enabled breakpoints,
7564    disabled ones can just stay disabled.  */
7565
7566 static void
7567 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7568 {
7569   struct bp_location *loc, **locp_tmp;
7570   int disabled_shlib_breaks = 0;
7571
7572   ALL_BP_LOCATIONS (loc, locp_tmp)
7573   {
7574     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7575     struct breakpoint *b = loc->owner;
7576
7577     if (solib->pspace == loc->pspace
7578         && !loc->shlib_disabled
7579         && (((b->type == bp_breakpoint
7580               || b->type == bp_jit_event
7581               || b->type == bp_hardware_breakpoint)
7582              && (loc->loc_type == bp_loc_hardware_breakpoint
7583                  || loc->loc_type == bp_loc_software_breakpoint))
7584             || is_tracepoint (b))
7585         && solib_contains_address_p (solib, loc->address))
7586       {
7587         loc->shlib_disabled = 1;
7588         /* At this point, we cannot rely on remove_breakpoint
7589            succeeding so we must mark the breakpoint as not inserted
7590            to prevent future errors occurring in remove_breakpoints.  */
7591         loc->inserted = 0;
7592
7593         /* This may cause duplicate notifications for the same breakpoint.  */
7594         gdb::observers::breakpoint_modified.notify (b);
7595
7596         if (!disabled_shlib_breaks)
7597           {
7598             target_terminal::ours_for_output ();
7599             warning (_("Temporarily disabling breakpoints "
7600                        "for unloaded shared library \"%s\""),
7601                      solib->so_name);
7602           }
7603         disabled_shlib_breaks = 1;
7604       }
7605   }
7606 }
7607
7608 /* Disable any breakpoints and tracepoints in OBJFILE upon
7609    notification of free_objfile.  Only apply to enabled breakpoints,
7610    disabled ones can just stay disabled.  */
7611
7612 static void
7613 disable_breakpoints_in_freed_objfile (struct objfile *objfile)
7614 {
7615   struct breakpoint *b;
7616
7617   if (objfile == NULL)
7618     return;
7619
7620   /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7621      managed by the user with add-symbol-file/remove-symbol-file.
7622      Similarly to how breakpoints in shared libraries are handled in
7623      response to "nosharedlibrary", mark breakpoints in such modules
7624      shlib_disabled so they end up uninserted on the next global
7625      location list update.  Shared libraries not loaded by the user
7626      aren't handled here -- they're already handled in
7627      disable_breakpoints_in_unloaded_shlib, called by solib.c's
7628      solib_unloaded observer.  We skip objfiles that are not
7629      OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7630      main objfile).  */
7631   if ((objfile->flags & OBJF_SHARED) == 0
7632       || (objfile->flags & OBJF_USERLOADED) == 0)
7633     return;
7634
7635   ALL_BREAKPOINTS (b)
7636     {
7637       struct bp_location *loc;
7638       int bp_modified = 0;
7639
7640       if (!is_breakpoint (b) && !is_tracepoint (b))
7641         continue;
7642
7643       for (loc = b->loc; loc != NULL; loc = loc->next)
7644         {
7645           CORE_ADDR loc_addr = loc->address;
7646
7647           if (loc->loc_type != bp_loc_hardware_breakpoint
7648               && loc->loc_type != bp_loc_software_breakpoint)
7649             continue;
7650
7651           if (loc->shlib_disabled != 0)
7652             continue;
7653
7654           if (objfile->pspace != loc->pspace)
7655             continue;
7656
7657           if (loc->loc_type != bp_loc_hardware_breakpoint
7658               && loc->loc_type != bp_loc_software_breakpoint)
7659             continue;
7660
7661           if (is_addr_in_objfile (loc_addr, objfile))
7662             {
7663               loc->shlib_disabled = 1;
7664               /* At this point, we don't know whether the object was
7665                  unmapped from the inferior or not, so leave the
7666                  inserted flag alone.  We'll handle failure to
7667                  uninsert quietly, in case the object was indeed
7668                  unmapped.  */
7669
7670               mark_breakpoint_location_modified (loc);
7671
7672               bp_modified = 1;
7673             }
7674         }
7675
7676       if (bp_modified)
7677         gdb::observers::breakpoint_modified.notify (b);
7678     }
7679 }
7680
7681 /* FORK & VFORK catchpoints.  */
7682
7683 /* An instance of this type is used to represent a fork or vfork
7684    catchpoint.  A breakpoint is really of this type iff its ops pointer points
7685    to CATCH_FORK_BREAKPOINT_OPS.  */
7686
7687 struct fork_catchpoint : public breakpoint
7688 {
7689   /* Process id of a child process whose forking triggered this
7690      catchpoint.  This field is only valid immediately after this
7691      catchpoint has triggered.  */
7692   ptid_t forked_inferior_pid;
7693 };
7694
7695 /* Implement the "insert" breakpoint_ops method for fork
7696    catchpoints.  */
7697
7698 static int
7699 insert_catch_fork (struct bp_location *bl)
7700 {
7701   return target_insert_fork_catchpoint (inferior_ptid.pid ());
7702 }
7703
7704 /* Implement the "remove" breakpoint_ops method for fork
7705    catchpoints.  */
7706
7707 static int
7708 remove_catch_fork (struct bp_location *bl, enum remove_bp_reason reason)
7709 {
7710   return target_remove_fork_catchpoint (inferior_ptid.pid ());
7711 }
7712
7713 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7714    catchpoints.  */
7715
7716 static int
7717 breakpoint_hit_catch_fork (const struct bp_location *bl,
7718                            const address_space *aspace, CORE_ADDR bp_addr,
7719                            const struct target_waitstatus *ws)
7720 {
7721   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7722
7723   if (ws->kind != TARGET_WAITKIND_FORKED)
7724     return 0;
7725
7726   c->forked_inferior_pid = ws->value.related_pid;
7727   return 1;
7728 }
7729
7730 /* Implement the "print_it" breakpoint_ops method for fork
7731    catchpoints.  */
7732
7733 static enum print_stop_action
7734 print_it_catch_fork (bpstat bs)
7735 {
7736   struct ui_out *uiout = current_uiout;
7737   struct breakpoint *b = bs->breakpoint_at;
7738   struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
7739
7740   annotate_catchpoint (b->number);
7741   maybe_print_thread_hit_breakpoint (uiout);
7742   if (b->disposition == disp_del)
7743     uiout->text ("Temporary catchpoint ");
7744   else
7745     uiout->text ("Catchpoint ");
7746   if (uiout->is_mi_like_p ())
7747     {
7748       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK));
7749       uiout->field_string ("disp", bpdisp_text (b->disposition));
7750     }
7751   uiout->field_int ("bkptno", b->number);
7752   uiout->text (" (forked process ");
7753   uiout->field_int ("newpid", c->forked_inferior_pid.pid ());
7754   uiout->text ("), ");
7755   return PRINT_SRC_AND_LOC;
7756 }
7757
7758 /* Implement the "print_one" breakpoint_ops method for fork
7759    catchpoints.  */
7760
7761 static void
7762 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
7763 {
7764   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7765   struct value_print_options opts;
7766   struct ui_out *uiout = current_uiout;
7767
7768   get_user_print_options (&opts);
7769
7770   /* Field 4, the address, is omitted (which makes the columns not
7771      line up too nicely with the headers, but the effect is relatively
7772      readable).  */
7773   if (opts.addressprint)
7774     uiout->field_skip ("addr");
7775   annotate_field (5);
7776   uiout->text ("fork");
7777   if (c->forked_inferior_pid != null_ptid)
7778     {
7779       uiout->text (", process ");
7780       uiout->field_int ("what", c->forked_inferior_pid.pid ());
7781       uiout->spaces (1);
7782     }
7783
7784   if (uiout->is_mi_like_p ())
7785     uiout->field_string ("catch-type", "fork");
7786 }
7787
7788 /* Implement the "print_mention" breakpoint_ops method for fork
7789    catchpoints.  */
7790
7791 static void
7792 print_mention_catch_fork (struct breakpoint *b)
7793 {
7794   printf_filtered (_("Catchpoint %d (fork)"), b->number);
7795 }
7796
7797 /* Implement the "print_recreate" breakpoint_ops method for fork
7798    catchpoints.  */
7799
7800 static void
7801 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
7802 {
7803   fprintf_unfiltered (fp, "catch fork");
7804   print_recreate_thread (b, fp);
7805 }
7806
7807 /* The breakpoint_ops structure to be used in fork catchpoints.  */
7808
7809 static struct breakpoint_ops catch_fork_breakpoint_ops;
7810
7811 /* Implement the "insert" breakpoint_ops method for vfork
7812    catchpoints.  */
7813
7814 static int
7815 insert_catch_vfork (struct bp_location *bl)
7816 {
7817   return target_insert_vfork_catchpoint (inferior_ptid.pid ());
7818 }
7819
7820 /* Implement the "remove" breakpoint_ops method for vfork
7821    catchpoints.  */
7822
7823 static int
7824 remove_catch_vfork (struct bp_location *bl, enum remove_bp_reason reason)
7825 {
7826   return target_remove_vfork_catchpoint (inferior_ptid.pid ());
7827 }
7828
7829 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7830    catchpoints.  */
7831
7832 static int
7833 breakpoint_hit_catch_vfork (const struct bp_location *bl,
7834                             const address_space *aspace, CORE_ADDR bp_addr,
7835                             const struct target_waitstatus *ws)
7836 {
7837   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7838
7839   if (ws->kind != TARGET_WAITKIND_VFORKED)
7840     return 0;
7841
7842   c->forked_inferior_pid = ws->value.related_pid;
7843   return 1;
7844 }
7845
7846 /* Implement the "print_it" breakpoint_ops method for vfork
7847    catchpoints.  */
7848
7849 static enum print_stop_action
7850 print_it_catch_vfork (bpstat bs)
7851 {
7852   struct ui_out *uiout = current_uiout;
7853   struct breakpoint *b = bs->breakpoint_at;
7854   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7855
7856   annotate_catchpoint (b->number);
7857   maybe_print_thread_hit_breakpoint (uiout);
7858   if (b->disposition == disp_del)
7859     uiout->text ("Temporary catchpoint ");
7860   else
7861     uiout->text ("Catchpoint ");
7862   if (uiout->is_mi_like_p ())
7863     {
7864       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK));
7865       uiout->field_string ("disp", bpdisp_text (b->disposition));
7866     }
7867   uiout->field_int ("bkptno", b->number);
7868   uiout->text (" (vforked process ");
7869   uiout->field_int ("newpid", c->forked_inferior_pid.pid ());
7870   uiout->text ("), ");
7871   return PRINT_SRC_AND_LOC;
7872 }
7873
7874 /* Implement the "print_one" breakpoint_ops method for vfork
7875    catchpoints.  */
7876
7877 static void
7878 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
7879 {
7880   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7881   struct value_print_options opts;
7882   struct ui_out *uiout = current_uiout;
7883
7884   get_user_print_options (&opts);
7885   /* Field 4, the address, is omitted (which makes the columns not
7886      line up too nicely with the headers, but the effect is relatively
7887      readable).  */
7888   if (opts.addressprint)
7889     uiout->field_skip ("addr");
7890   annotate_field (5);
7891   uiout->text ("vfork");
7892   if (c->forked_inferior_pid != null_ptid)
7893     {
7894       uiout->text (", process ");
7895       uiout->field_int ("what", c->forked_inferior_pid.pid ());
7896       uiout->spaces (1);
7897     }
7898
7899   if (uiout->is_mi_like_p ())
7900     uiout->field_string ("catch-type", "vfork");
7901 }
7902
7903 /* Implement the "print_mention" breakpoint_ops method for vfork
7904    catchpoints.  */
7905
7906 static void
7907 print_mention_catch_vfork (struct breakpoint *b)
7908 {
7909   printf_filtered (_("Catchpoint %d (vfork)"), b->number);
7910 }
7911
7912 /* Implement the "print_recreate" breakpoint_ops method for vfork
7913    catchpoints.  */
7914
7915 static void
7916 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
7917 {
7918   fprintf_unfiltered (fp, "catch vfork");
7919   print_recreate_thread (b, fp);
7920 }
7921
7922 /* The breakpoint_ops structure to be used in vfork catchpoints.  */
7923
7924 static struct breakpoint_ops catch_vfork_breakpoint_ops;
7925
7926 /* An instance of this type is used to represent an solib catchpoint.
7927    A breakpoint is really of this type iff its ops pointer points to
7928    CATCH_SOLIB_BREAKPOINT_OPS.  */
7929
7930 struct solib_catchpoint : public breakpoint
7931 {
7932   ~solib_catchpoint () override;
7933
7934   /* True for "catch load", false for "catch unload".  */
7935   unsigned char is_load;
7936
7937   /* Regular expression to match, if any.  COMPILED is only valid when
7938      REGEX is non-NULL.  */
7939   char *regex;
7940   std::unique_ptr<compiled_regex> compiled;
7941 };
7942
7943 solib_catchpoint::~solib_catchpoint ()
7944 {
7945   xfree (this->regex);
7946 }
7947
7948 static int
7949 insert_catch_solib (struct bp_location *ignore)
7950 {
7951   return 0;
7952 }
7953
7954 static int
7955 remove_catch_solib (struct bp_location *ignore, enum remove_bp_reason reason)
7956 {
7957   return 0;
7958 }
7959
7960 static int
7961 breakpoint_hit_catch_solib (const struct bp_location *bl,
7962                             const address_space *aspace,
7963                             CORE_ADDR bp_addr,
7964                             const struct target_waitstatus *ws)
7965 {
7966   struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
7967   struct breakpoint *other;
7968
7969   if (ws->kind == TARGET_WAITKIND_LOADED)
7970     return 1;
7971
7972   ALL_BREAKPOINTS (other)
7973   {
7974     struct bp_location *other_bl;
7975
7976     if (other == bl->owner)
7977       continue;
7978
7979     if (other->type != bp_shlib_event)
7980       continue;
7981
7982     if (self->pspace != NULL && other->pspace != self->pspace)
7983       continue;
7984
7985     for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
7986       {
7987         if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
7988           return 1;
7989       }
7990   }
7991
7992   return 0;
7993 }
7994
7995 static void
7996 check_status_catch_solib (struct bpstats *bs)
7997 {
7998   struct solib_catchpoint *self
7999     = (struct solib_catchpoint *) bs->breakpoint_at;
8000
8001   if (self->is_load)
8002     {
8003       for (so_list *iter : current_program_space->added_solibs)
8004         {
8005           if (!self->regex
8006               || self->compiled->exec (iter->so_name, 0, NULL, 0) == 0)
8007             return;
8008         }
8009     }
8010   else
8011     {
8012       for (const std::string &iter : current_program_space->deleted_solibs)
8013         {
8014           if (!self->regex
8015               || self->compiled->exec (iter.c_str (), 0, NULL, 0) == 0)
8016             return;
8017         }
8018     }
8019
8020   bs->stop = 0;
8021   bs->print_it = print_it_noop;
8022 }
8023
8024 static enum print_stop_action
8025 print_it_catch_solib (bpstat bs)
8026 {
8027   struct breakpoint *b = bs->breakpoint_at;
8028   struct ui_out *uiout = current_uiout;
8029
8030   annotate_catchpoint (b->number);
8031   maybe_print_thread_hit_breakpoint (uiout);
8032   if (b->disposition == disp_del)
8033     uiout->text ("Temporary catchpoint ");
8034   else
8035     uiout->text ("Catchpoint ");
8036   uiout->field_int ("bkptno", b->number);
8037   uiout->text ("\n");
8038   if (uiout->is_mi_like_p ())
8039     uiout->field_string ("disp", bpdisp_text (b->disposition));
8040   print_solib_event (1);
8041   return PRINT_SRC_AND_LOC;
8042 }
8043
8044 static void
8045 print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
8046 {
8047   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8048   struct value_print_options opts;
8049   struct ui_out *uiout = current_uiout;
8050
8051   get_user_print_options (&opts);
8052   /* Field 4, the address, is omitted (which makes the columns not
8053      line up too nicely with the headers, but the effect is relatively
8054      readable).  */
8055   if (opts.addressprint)
8056     {
8057       annotate_field (4);
8058       uiout->field_skip ("addr");
8059     }
8060
8061   std::string msg;
8062   annotate_field (5);
8063   if (self->is_load)
8064     {
8065       if (self->regex)
8066         msg = string_printf (_("load of library matching %s"), self->regex);
8067       else
8068         msg = _("load of library");
8069     }
8070   else
8071     {
8072       if (self->regex)
8073         msg = string_printf (_("unload of library matching %s"), self->regex);
8074       else
8075         msg = _("unload of library");
8076     }
8077   uiout->field_string ("what", msg);
8078
8079   if (uiout->is_mi_like_p ())
8080     uiout->field_string ("catch-type", self->is_load ? "load" : "unload");
8081 }
8082
8083 static void
8084 print_mention_catch_solib (struct breakpoint *b)
8085 {
8086   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8087
8088   printf_filtered (_("Catchpoint %d (%s)"), b->number,
8089                    self->is_load ? "load" : "unload");
8090 }
8091
8092 static void
8093 print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
8094 {
8095   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8096
8097   fprintf_unfiltered (fp, "%s %s",
8098                       b->disposition == disp_del ? "tcatch" : "catch",
8099                       self->is_load ? "load" : "unload");
8100   if (self->regex)
8101     fprintf_unfiltered (fp, " %s", self->regex);
8102   fprintf_unfiltered (fp, "\n");
8103 }
8104
8105 static struct breakpoint_ops catch_solib_breakpoint_ops;
8106
8107 /* Shared helper function (MI and CLI) for creating and installing
8108    a shared object event catchpoint.  If IS_LOAD is non-zero then
8109    the events to be caught are load events, otherwise they are
8110    unload events.  If IS_TEMP is non-zero the catchpoint is a
8111    temporary one.  If ENABLED is non-zero the catchpoint is
8112    created in an enabled state.  */
8113
8114 void
8115 add_solib_catchpoint (const char *arg, int is_load, int is_temp, int enabled)
8116 {
8117   struct gdbarch *gdbarch = get_current_arch ();
8118
8119   if (!arg)
8120     arg = "";
8121   arg = skip_spaces (arg);
8122
8123   std::unique_ptr<solib_catchpoint> c (new solib_catchpoint ());
8124
8125   if (*arg != '\0')
8126     {
8127       c->compiled.reset (new compiled_regex (arg, REG_NOSUB,
8128                                              _("Invalid regexp")));
8129       c->regex = xstrdup (arg);
8130     }
8131
8132   c->is_load = is_load;
8133   init_catchpoint (c.get (), gdbarch, is_temp, NULL,
8134                    &catch_solib_breakpoint_ops);
8135
8136   c->enable_state = enabled ? bp_enabled : bp_disabled;
8137
8138   install_breakpoint (0, std::move (c), 1);
8139 }
8140
8141 /* A helper function that does all the work for "catch load" and
8142    "catch unload".  */
8143
8144 static void
8145 catch_load_or_unload (const char *arg, int from_tty, int is_load,
8146                       struct cmd_list_element *command)
8147 {
8148   int tempflag;
8149   const int enabled = 1;
8150
8151   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8152
8153   add_solib_catchpoint (arg, is_load, tempflag, enabled);
8154 }
8155
8156 static void
8157 catch_load_command_1 (const char *arg, int from_tty,
8158                       struct cmd_list_element *command)
8159 {
8160   catch_load_or_unload (arg, from_tty, 1, command);
8161 }
8162
8163 static void
8164 catch_unload_command_1 (const char *arg, int from_tty,
8165                         struct cmd_list_element *command)
8166 {
8167   catch_load_or_unload (arg, from_tty, 0, command);
8168 }
8169
8170 /* Initialize a new breakpoint of the bp_catchpoint kind.  If TEMPFLAG
8171    is non-zero, then make the breakpoint temporary.  If COND_STRING is
8172    not NULL, then store it in the breakpoint.  OPS, if not NULL, is
8173    the breakpoint_ops structure associated to the catchpoint.  */
8174
8175 void
8176 init_catchpoint (struct breakpoint *b,
8177                  struct gdbarch *gdbarch, int tempflag,
8178                  const char *cond_string,
8179                  const struct breakpoint_ops *ops)
8180 {
8181   symtab_and_line sal;
8182   sal.pspace = current_program_space;
8183
8184   init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
8185
8186   b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
8187   b->disposition = tempflag ? disp_del : disp_donttouch;
8188 }
8189
8190 void
8191 install_breakpoint (int internal, std::unique_ptr<breakpoint> &&arg, int update_gll)
8192 {
8193   breakpoint *b = add_to_breakpoint_chain (std::move (arg));
8194   set_breakpoint_number (internal, b);
8195   if (is_tracepoint (b))
8196     set_tracepoint_count (breakpoint_count);
8197   if (!internal)
8198     mention (b);
8199   gdb::observers::breakpoint_created.notify (b);
8200
8201   if (update_gll)
8202     update_global_location_list (UGLL_MAY_INSERT);
8203 }
8204
8205 static void
8206 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
8207                                     int tempflag, const char *cond_string,
8208                                     const struct breakpoint_ops *ops)
8209 {
8210   std::unique_ptr<fork_catchpoint> c (new fork_catchpoint ());
8211
8212   init_catchpoint (c.get (), gdbarch, tempflag, cond_string, ops);
8213
8214   c->forked_inferior_pid = null_ptid;
8215
8216   install_breakpoint (0, std::move (c), 1);
8217 }
8218
8219 /* Exec catchpoints.  */
8220
8221 /* An instance of this type is used to represent an exec catchpoint.
8222    A breakpoint is really of this type iff its ops pointer points to
8223    CATCH_EXEC_BREAKPOINT_OPS.  */
8224
8225 struct exec_catchpoint : public breakpoint
8226 {
8227   ~exec_catchpoint () override;
8228
8229   /* Filename of a program whose exec triggered this catchpoint.
8230      This field is only valid immediately after this catchpoint has
8231      triggered.  */
8232   char *exec_pathname;
8233 };
8234
8235 /* Exec catchpoint destructor.  */
8236
8237 exec_catchpoint::~exec_catchpoint ()
8238 {
8239   xfree (this->exec_pathname);
8240 }
8241
8242 static int
8243 insert_catch_exec (struct bp_location *bl)
8244 {
8245   return target_insert_exec_catchpoint (inferior_ptid.pid ());
8246 }
8247
8248 static int
8249 remove_catch_exec (struct bp_location *bl, enum remove_bp_reason reason)
8250 {
8251   return target_remove_exec_catchpoint (inferior_ptid.pid ());
8252 }
8253
8254 static int
8255 breakpoint_hit_catch_exec (const struct bp_location *bl,
8256                            const address_space *aspace, CORE_ADDR bp_addr,
8257                            const struct target_waitstatus *ws)
8258 {
8259   struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8260
8261   if (ws->kind != TARGET_WAITKIND_EXECD)
8262     return 0;
8263
8264   c->exec_pathname = xstrdup (ws->value.execd_pathname);
8265   return 1;
8266 }
8267
8268 static enum print_stop_action
8269 print_it_catch_exec (bpstat bs)
8270 {
8271   struct ui_out *uiout = current_uiout;
8272   struct breakpoint *b = bs->breakpoint_at;
8273   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8274
8275   annotate_catchpoint (b->number);
8276   maybe_print_thread_hit_breakpoint (uiout);
8277   if (b->disposition == disp_del)
8278     uiout->text ("Temporary catchpoint ");
8279   else
8280     uiout->text ("Catchpoint ");
8281   if (uiout->is_mi_like_p ())
8282     {
8283       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC));
8284       uiout->field_string ("disp", bpdisp_text (b->disposition));
8285     }
8286   uiout->field_int ("bkptno", b->number);
8287   uiout->text (" (exec'd ");
8288   uiout->field_string ("new-exec", c->exec_pathname);
8289   uiout->text ("), ");
8290
8291   return PRINT_SRC_AND_LOC;
8292 }
8293
8294 static void
8295 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
8296 {
8297   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8298   struct value_print_options opts;
8299   struct ui_out *uiout = current_uiout;
8300
8301   get_user_print_options (&opts);
8302
8303   /* Field 4, the address, is omitted (which makes the columns
8304      not line up too nicely with the headers, but the effect
8305      is relatively readable).  */
8306   if (opts.addressprint)
8307     uiout->field_skip ("addr");
8308   annotate_field (5);
8309   uiout->text ("exec");
8310   if (c->exec_pathname != NULL)
8311     {
8312       uiout->text (", program \"");
8313       uiout->field_string ("what", c->exec_pathname);
8314       uiout->text ("\" ");
8315     }
8316
8317   if (uiout->is_mi_like_p ())
8318     uiout->field_string ("catch-type", "exec");
8319 }
8320
8321 static void
8322 print_mention_catch_exec (struct breakpoint *b)
8323 {
8324   printf_filtered (_("Catchpoint %d (exec)"), b->number);
8325 }
8326
8327 /* Implement the "print_recreate" breakpoint_ops method for exec
8328    catchpoints.  */
8329
8330 static void
8331 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8332 {
8333   fprintf_unfiltered (fp, "catch exec");
8334   print_recreate_thread (b, fp);
8335 }
8336
8337 static struct breakpoint_ops catch_exec_breakpoint_ops;
8338
8339 static int
8340 hw_breakpoint_used_count (void)
8341 {
8342   int i = 0;
8343   struct breakpoint *b;
8344   struct bp_location *bl;
8345
8346   ALL_BREAKPOINTS (b)
8347   {
8348     if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
8349       for (bl = b->loc; bl; bl = bl->next)
8350         {
8351           /* Special types of hardware breakpoints may use more than
8352              one register.  */
8353           i += b->ops->resources_needed (bl);
8354         }
8355   }
8356
8357   return i;
8358 }
8359
8360 /* Returns the resources B would use if it were a hardware
8361    watchpoint.  */
8362
8363 static int
8364 hw_watchpoint_use_count (struct breakpoint *b)
8365 {
8366   int i = 0;
8367   struct bp_location *bl;
8368
8369   if (!breakpoint_enabled (b))
8370     return 0;
8371
8372   for (bl = b->loc; bl; bl = bl->next)
8373     {
8374       /* Special types of hardware watchpoints may use more than
8375          one register.  */
8376       i += b->ops->resources_needed (bl);
8377     }
8378
8379   return i;
8380 }
8381
8382 /* Returns the sum the used resources of all hardware watchpoints of
8383    type TYPE in the breakpoints list.  Also returns in OTHER_TYPE_USED
8384    the sum of the used resources of all hardware watchpoints of other
8385    types _not_ TYPE.  */
8386
8387 static int
8388 hw_watchpoint_used_count_others (struct breakpoint *except,
8389                                  enum bptype type, int *other_type_used)
8390 {
8391   int i = 0;
8392   struct breakpoint *b;
8393
8394   *other_type_used = 0;
8395   ALL_BREAKPOINTS (b)
8396     {
8397       if (b == except)
8398         continue;
8399       if (!breakpoint_enabled (b))
8400         continue;
8401
8402       if (b->type == type)
8403         i += hw_watchpoint_use_count (b);
8404       else if (is_hardware_watchpoint (b))
8405         *other_type_used = 1;
8406     }
8407
8408   return i;
8409 }
8410
8411 void
8412 disable_watchpoints_before_interactive_call_start (void)
8413 {
8414   struct breakpoint *b;
8415
8416   ALL_BREAKPOINTS (b)
8417   {
8418     if (is_watchpoint (b) && breakpoint_enabled (b))
8419       {
8420         b->enable_state = bp_call_disabled;
8421         update_global_location_list (UGLL_DONT_INSERT);
8422       }
8423   }
8424 }
8425
8426 void
8427 enable_watchpoints_after_interactive_call_stop (void)
8428 {
8429   struct breakpoint *b;
8430
8431   ALL_BREAKPOINTS (b)
8432   {
8433     if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
8434       {
8435         b->enable_state = bp_enabled;
8436         update_global_location_list (UGLL_MAY_INSERT);
8437       }
8438   }
8439 }
8440
8441 void
8442 disable_breakpoints_before_startup (void)
8443 {
8444   current_program_space->executing_startup = 1;
8445   update_global_location_list (UGLL_DONT_INSERT);
8446 }
8447
8448 void
8449 enable_breakpoints_after_startup (void)
8450 {
8451   current_program_space->executing_startup = 0;
8452   breakpoint_re_set ();
8453 }
8454
8455 /* Create a new single-step breakpoint for thread THREAD, with no
8456    locations.  */
8457
8458 static struct breakpoint *
8459 new_single_step_breakpoint (int thread, struct gdbarch *gdbarch)
8460 {
8461   std::unique_ptr<breakpoint> b (new breakpoint ());
8462
8463   init_raw_breakpoint_without_location (b.get (), gdbarch, bp_single_step,
8464                                         &momentary_breakpoint_ops);
8465
8466   b->disposition = disp_donttouch;
8467   b->frame_id = null_frame_id;
8468
8469   b->thread = thread;
8470   gdb_assert (b->thread != 0);
8471
8472   return add_to_breakpoint_chain (std::move (b));
8473 }
8474
8475 /* Set a momentary breakpoint of type TYPE at address specified by
8476    SAL.  If FRAME_ID is valid, the breakpoint is restricted to that
8477    frame.  */
8478
8479 breakpoint_up
8480 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8481                           struct frame_id frame_id, enum bptype type)
8482 {
8483   struct breakpoint *b;
8484
8485   /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8486      tail-called one.  */
8487   gdb_assert (!frame_id_artificial_p (frame_id));
8488
8489   b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
8490   b->enable_state = bp_enabled;
8491   b->disposition = disp_donttouch;
8492   b->frame_id = frame_id;
8493
8494   b->thread = inferior_thread ()->global_num;
8495
8496   update_global_location_list_nothrow (UGLL_MAY_INSERT);
8497
8498   return breakpoint_up (b);
8499 }
8500
8501 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8502    The new breakpoint will have type TYPE, use OPS as its
8503    breakpoint_ops, and will set enabled to LOC_ENABLED.  */
8504
8505 static struct breakpoint *
8506 momentary_breakpoint_from_master (struct breakpoint *orig,
8507                                   enum bptype type,
8508                                   const struct breakpoint_ops *ops,
8509                                   int loc_enabled)
8510 {
8511   struct breakpoint *copy;
8512
8513   copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
8514   copy->loc = allocate_bp_location (copy);
8515   set_breakpoint_location_function (copy->loc, 1);
8516
8517   copy->loc->gdbarch = orig->loc->gdbarch;
8518   copy->loc->requested_address = orig->loc->requested_address;
8519   copy->loc->address = orig->loc->address;
8520   copy->loc->section = orig->loc->section;
8521   copy->loc->pspace = orig->loc->pspace;
8522   copy->loc->probe = orig->loc->probe;
8523   copy->loc->line_number = orig->loc->line_number;
8524   copy->loc->symtab = orig->loc->symtab;
8525   copy->loc->enabled = loc_enabled;
8526   copy->frame_id = orig->frame_id;
8527   copy->thread = orig->thread;
8528   copy->pspace = orig->pspace;
8529
8530   copy->enable_state = bp_enabled;
8531   copy->disposition = disp_donttouch;
8532   copy->number = internal_breakpoint_number--;
8533
8534   update_global_location_list_nothrow (UGLL_DONT_INSERT);
8535   return copy;
8536 }
8537
8538 /* Make a deep copy of momentary breakpoint ORIG.  Returns NULL if
8539    ORIG is NULL.  */
8540
8541 struct breakpoint *
8542 clone_momentary_breakpoint (struct breakpoint *orig)
8543 {
8544   /* If there's nothing to clone, then return nothing.  */
8545   if (orig == NULL)
8546     return NULL;
8547
8548   return momentary_breakpoint_from_master (orig, orig->type, orig->ops, 0);
8549 }
8550
8551 breakpoint_up
8552 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8553                                 enum bptype type)
8554 {
8555   struct symtab_and_line sal;
8556
8557   sal = find_pc_line (pc, 0);
8558   sal.pc = pc;
8559   sal.section = find_pc_overlay (pc);
8560   sal.explicit_pc = 1;
8561
8562   return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
8563 }
8564 \f
8565
8566 /* Tell the user we have just set a breakpoint B.  */
8567
8568 static void
8569 mention (struct breakpoint *b)
8570 {
8571   b->ops->print_mention (b);
8572   current_uiout->text ("\n");
8573 }
8574 \f
8575
8576 static int bp_loc_is_permanent (struct bp_location *loc);
8577
8578 static struct bp_location *
8579 add_location_to_breakpoint (struct breakpoint *b,
8580                             const struct symtab_and_line *sal)
8581 {
8582   struct bp_location *loc, **tmp;
8583   CORE_ADDR adjusted_address;
8584   struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
8585
8586   if (loc_gdbarch == NULL)
8587     loc_gdbarch = b->gdbarch;
8588
8589   /* Adjust the breakpoint's address prior to allocating a location.
8590      Once we call allocate_bp_location(), that mostly uninitialized
8591      location will be placed on the location chain.  Adjustment of the
8592      breakpoint may cause target_read_memory() to be called and we do
8593      not want its scan of the location chain to find a breakpoint and
8594      location that's only been partially initialized.  */
8595   adjusted_address = adjust_breakpoint_address (loc_gdbarch,
8596                                                 sal->pc, b->type);
8597
8598   /* Sort the locations by their ADDRESS.  */
8599   loc = allocate_bp_location (b);
8600   for (tmp = &(b->loc); *tmp != NULL && (*tmp)->address <= adjusted_address;
8601        tmp = &((*tmp)->next))
8602     ;
8603   loc->next = *tmp;
8604   *tmp = loc;
8605
8606   loc->requested_address = sal->pc;
8607   loc->address = adjusted_address;
8608   loc->pspace = sal->pspace;
8609   loc->probe.prob = sal->prob;
8610   loc->probe.objfile = sal->objfile;
8611   gdb_assert (loc->pspace != NULL);
8612   loc->section = sal->section;
8613   loc->gdbarch = loc_gdbarch;
8614   loc->line_number = sal->line;
8615   loc->symtab = sal->symtab;
8616   loc->symbol = sal->symbol;
8617   loc->msymbol = sal->msymbol;
8618   loc->objfile = sal->objfile;
8619
8620   set_breakpoint_location_function (loc,
8621                                     sal->explicit_pc || sal->explicit_line);
8622
8623   /* While by definition, permanent breakpoints are already present in the
8624      code, we don't mark the location as inserted.  Normally one would expect
8625      that GDB could rely on that breakpoint instruction to stop the program,
8626      thus removing the need to insert its own breakpoint, except that executing
8627      the breakpoint instruction can kill the target instead of reporting a
8628      SIGTRAP.  E.g., on SPARC, when interrupts are disabled, executing the
8629      instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8630      with "Trap 0x02 while interrupts disabled, Error state".  Letting the
8631      breakpoint be inserted normally results in QEMU knowing about the GDB
8632      breakpoint, and thus trap before the breakpoint instruction is executed.
8633      (If GDB later needs to continue execution past the permanent breakpoint,
8634      it manually increments the PC, thus avoiding executing the breakpoint
8635      instruction.)  */
8636   if (bp_loc_is_permanent (loc))
8637     loc->permanent = 1;
8638
8639   return loc;
8640 }
8641 \f
8642
8643 /* See breakpoint.h.  */
8644
8645 int
8646 program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address)
8647 {
8648   int len;
8649   CORE_ADDR addr;
8650   const gdb_byte *bpoint;
8651   gdb_byte *target_mem;
8652
8653   addr = address;
8654   bpoint = gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
8655
8656   /* Software breakpoints unsupported?  */
8657   if (bpoint == NULL)
8658     return 0;
8659
8660   target_mem = (gdb_byte *) alloca (len);
8661
8662   /* Enable the automatic memory restoration from breakpoints while
8663      we read the memory.  Otherwise we could say about our temporary
8664      breakpoints they are permanent.  */
8665   scoped_restore restore_memory
8666     = make_scoped_restore_show_memory_breakpoints (0);
8667
8668   if (target_read_memory (address, target_mem, len) == 0
8669       && memcmp (target_mem, bpoint, len) == 0)
8670     return 1;
8671
8672   return 0;
8673 }
8674
8675 /* Return 1 if LOC is pointing to a permanent breakpoint,
8676    return 0 otherwise.  */
8677
8678 static int
8679 bp_loc_is_permanent (struct bp_location *loc)
8680 {
8681   gdb_assert (loc != NULL);
8682
8683   /* If we have a catchpoint or a watchpoint, just return 0.  We should not
8684      attempt to read from the addresses the locations of these breakpoint types
8685      point to.  program_breakpoint_here_p, below, will attempt to read
8686      memory.  */
8687   if (!breakpoint_address_is_meaningful (loc->owner))
8688     return 0;
8689
8690   scoped_restore_current_pspace_and_thread restore_pspace_thread;
8691   switch_to_program_space_and_thread (loc->pspace);
8692   return program_breakpoint_here_p (loc->gdbarch, loc->address);
8693 }
8694
8695 /* Build a command list for the dprintf corresponding to the current
8696    settings of the dprintf style options.  */
8697
8698 static void
8699 update_dprintf_command_list (struct breakpoint *b)
8700 {
8701   char *dprintf_args = b->extra_string;
8702   char *printf_line = NULL;
8703
8704   if (!dprintf_args)
8705     return;
8706
8707   dprintf_args = skip_spaces (dprintf_args);
8708
8709   /* Allow a comma, as it may have terminated a location, but don't
8710      insist on it.  */
8711   if (*dprintf_args == ',')
8712     ++dprintf_args;
8713   dprintf_args = skip_spaces (dprintf_args);
8714
8715   if (*dprintf_args != '"')
8716     error (_("Bad format string, missing '\"'."));
8717
8718   if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
8719     printf_line = xstrprintf ("printf %s", dprintf_args);
8720   else if (strcmp (dprintf_style, dprintf_style_call) == 0)
8721     {
8722       if (!dprintf_function)
8723         error (_("No function supplied for dprintf call"));
8724
8725       if (dprintf_channel && strlen (dprintf_channel) > 0)
8726         printf_line = xstrprintf ("call (void) %s (%s,%s)",
8727                                   dprintf_function,
8728                                   dprintf_channel,
8729                                   dprintf_args);
8730       else
8731         printf_line = xstrprintf ("call (void) %s (%s)",
8732                                   dprintf_function,
8733                                   dprintf_args);
8734     }
8735   else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
8736     {
8737       if (target_can_run_breakpoint_commands ())
8738         printf_line = xstrprintf ("agent-printf %s", dprintf_args);
8739       else
8740         {
8741           warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8742           printf_line = xstrprintf ("printf %s", dprintf_args);
8743         }
8744     }
8745   else
8746     internal_error (__FILE__, __LINE__,
8747                     _("Invalid dprintf style."));
8748
8749   gdb_assert (printf_line != NULL);
8750
8751   /* Manufacture a printf sequence.  */
8752   struct command_line *printf_cmd_line
8753     = new struct command_line (simple_control, printf_line);
8754   breakpoint_set_commands (b, counted_command_line (printf_cmd_line,
8755                                                     command_lines_deleter ()));
8756 }
8757
8758 /* Update all dprintf commands, making their command lists reflect
8759    current style settings.  */
8760
8761 static void
8762 update_dprintf_commands (const char *args, int from_tty,
8763                          struct cmd_list_element *c)
8764 {
8765   struct breakpoint *b;
8766
8767   ALL_BREAKPOINTS (b)
8768     {
8769       if (b->type == bp_dprintf)
8770         update_dprintf_command_list (b);
8771     }
8772 }
8773
8774 /* Create a breakpoint with SAL as location.  Use LOCATION
8775    as a description of the location, and COND_STRING
8776    as condition expression.  If LOCATION is NULL then create an
8777    "address location" from the address in the SAL.  */
8778
8779 static void
8780 init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
8781                      gdb::array_view<const symtab_and_line> sals,
8782                      event_location_up &&location,
8783                      gdb::unique_xmalloc_ptr<char> filter,
8784                      gdb::unique_xmalloc_ptr<char> cond_string,
8785                      gdb::unique_xmalloc_ptr<char> extra_string,
8786                      enum bptype type, enum bpdisp disposition,
8787                      int thread, int task, int ignore_count,
8788                      const struct breakpoint_ops *ops, int from_tty,
8789                      int enabled, int internal, unsigned flags,
8790                      int display_canonical)
8791 {
8792   int i;
8793
8794   if (type == bp_hardware_breakpoint)
8795     {
8796       int target_resources_ok;
8797
8798       i = hw_breakpoint_used_count ();
8799       target_resources_ok =
8800         target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
8801                                             i + 1, 0);
8802       if (target_resources_ok == 0)
8803         error (_("No hardware breakpoint support in the target."));
8804       else if (target_resources_ok < 0)
8805         error (_("Hardware breakpoints used exceeds limit."));
8806     }
8807
8808   gdb_assert (!sals.empty ());
8809
8810   for (const auto &sal : sals)
8811     {
8812       struct bp_location *loc;
8813
8814       if (from_tty)
8815         {
8816           struct gdbarch *loc_gdbarch = get_sal_arch (sal);
8817           if (!loc_gdbarch)
8818             loc_gdbarch = gdbarch;
8819
8820           describe_other_breakpoints (loc_gdbarch,
8821                                       sal.pspace, sal.pc, sal.section, thread);
8822         }
8823
8824       if (&sal == &sals[0])
8825         {
8826           init_raw_breakpoint (b, gdbarch, sal, type, ops);
8827           b->thread = thread;
8828           b->task = task;
8829
8830           b->cond_string = cond_string.release ();
8831           b->extra_string = extra_string.release ();
8832           b->ignore_count = ignore_count;
8833           b->enable_state = enabled ? bp_enabled : bp_disabled;
8834           b->disposition = disposition;
8835
8836           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8837             b->loc->inserted = 1;
8838
8839           if (type == bp_static_tracepoint)
8840             {
8841               struct tracepoint *t = (struct tracepoint *) b;
8842               struct static_tracepoint_marker marker;
8843
8844               if (strace_marker_p (b))
8845                 {
8846                   /* We already know the marker exists, otherwise, we
8847                      wouldn't see a sal for it.  */
8848                   const char *p
8849                     = &event_location_to_string (b->location.get ())[3];
8850                   const char *endp;
8851
8852                   p = skip_spaces (p);
8853
8854                   endp = skip_to_space (p);
8855
8856                   t->static_trace_marker_id.assign (p, endp - p);
8857
8858                   printf_filtered (_("Probed static tracepoint "
8859                                      "marker \"%s\"\n"),
8860                                    t->static_trace_marker_id.c_str ());
8861                 }
8862               else if (target_static_tracepoint_marker_at (sal.pc, &marker))
8863                 {
8864                   t->static_trace_marker_id = std::move (marker.str_id);
8865
8866                   printf_filtered (_("Probed static tracepoint "
8867                                      "marker \"%s\"\n"),
8868                                    t->static_trace_marker_id.c_str ());
8869                 }
8870               else
8871                 warning (_("Couldn't determine the static "
8872                            "tracepoint marker to probe"));
8873             }
8874
8875           loc = b->loc;
8876         }
8877       else
8878         {
8879           loc = add_location_to_breakpoint (b, &sal);
8880           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8881             loc->inserted = 1;
8882         }
8883
8884       if (b->cond_string)
8885         {
8886           const char *arg = b->cond_string;
8887
8888           loc->cond = parse_exp_1 (&arg, loc->address,
8889                                    block_for_pc (loc->address), 0);
8890           if (*arg)
8891               error (_("Garbage '%s' follows condition"), arg);
8892         }
8893
8894       /* Dynamic printf requires and uses additional arguments on the
8895          command line, otherwise it's an error.  */
8896       if (type == bp_dprintf)
8897         {
8898           if (b->extra_string)
8899             update_dprintf_command_list (b);
8900           else
8901             error (_("Format string required"));
8902         }
8903       else if (b->extra_string)
8904         error (_("Garbage '%s' at end of command"), b->extra_string);
8905     }
8906
8907   b->display_canonical = display_canonical;
8908   if (location != NULL)
8909     b->location = std::move (location);
8910   else
8911     b->location = new_address_location (b->loc->address, NULL, 0);
8912   b->filter = filter.release ();
8913 }
8914
8915 static void
8916 create_breakpoint_sal (struct gdbarch *gdbarch,
8917                        gdb::array_view<const symtab_and_line> sals,
8918                        event_location_up &&location,
8919                        gdb::unique_xmalloc_ptr<char> filter,
8920                        gdb::unique_xmalloc_ptr<char> cond_string,
8921                        gdb::unique_xmalloc_ptr<char> extra_string,
8922                        enum bptype type, enum bpdisp disposition,
8923                        int thread, int task, int ignore_count,
8924                        const struct breakpoint_ops *ops, int from_tty,
8925                        int enabled, int internal, unsigned flags,
8926                        int display_canonical)
8927 {
8928   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (type);
8929
8930   init_breakpoint_sal (b.get (), gdbarch,
8931                        sals, std::move (location),
8932                        std::move (filter),
8933                        std::move (cond_string),
8934                        std::move (extra_string),
8935                        type, disposition,
8936                        thread, task, ignore_count,
8937                        ops, from_tty,
8938                        enabled, internal, flags,
8939                        display_canonical);
8940
8941   install_breakpoint (internal, std::move (b), 0);
8942 }
8943
8944 /* Add SALS.nelts breakpoints to the breakpoint table.  For each
8945    SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
8946    value.  COND_STRING, if not NULL, specified the condition to be
8947    used for all breakpoints.  Essentially the only case where
8948    SALS.nelts is not 1 is when we set a breakpoint on an overloaded
8949    function.  In that case, it's still not possible to specify
8950    separate conditions for different overloaded functions, so
8951    we take just a single condition string.
8952    
8953    NOTE: If the function succeeds, the caller is expected to cleanup
8954    the arrays ADDR_STRING, COND_STRING, and SALS (but not the
8955    array contents).  If the function fails (error() is called), the
8956    caller is expected to cleanups both the ADDR_STRING, COND_STRING,
8957    COND and SALS arrays and each of those arrays contents.  */
8958
8959 static void
8960 create_breakpoints_sal (struct gdbarch *gdbarch,
8961                         struct linespec_result *canonical,
8962                         gdb::unique_xmalloc_ptr<char> cond_string,
8963                         gdb::unique_xmalloc_ptr<char> extra_string,
8964                         enum bptype type, enum bpdisp disposition,
8965                         int thread, int task, int ignore_count,
8966                         const struct breakpoint_ops *ops, int from_tty,
8967                         int enabled, int internal, unsigned flags)
8968 {
8969   if (canonical->pre_expanded)
8970     gdb_assert (canonical->lsals.size () == 1);
8971
8972   for (const auto &lsal : canonical->lsals)
8973     {
8974       /* Note that 'location' can be NULL in the case of a plain
8975          'break', without arguments.  */
8976       event_location_up location
8977         = (canonical->location != NULL
8978            ? copy_event_location (canonical->location.get ()) : NULL);
8979       gdb::unique_xmalloc_ptr<char> filter_string
8980         (lsal.canonical != NULL ? xstrdup (lsal.canonical) : NULL);
8981
8982       create_breakpoint_sal (gdbarch, lsal.sals,
8983                              std::move (location),
8984                              std::move (filter_string),
8985                              std::move (cond_string),
8986                              std::move (extra_string),
8987                              type, disposition,
8988                              thread, task, ignore_count, ops,
8989                              from_tty, enabled, internal, flags,
8990                              canonical->special_display);
8991     }
8992 }
8993
8994 /* Parse LOCATION which is assumed to be a SAL specification possibly
8995    followed by conditionals.  On return, SALS contains an array of SAL
8996    addresses found.  LOCATION points to the end of the SAL (for
8997    linespec locations).
8998
8999    The array and the line spec strings are allocated on the heap, it is
9000    the caller's responsibility to free them.  */
9001
9002 static void
9003 parse_breakpoint_sals (const struct event_location *location,
9004                        struct linespec_result *canonical)
9005 {
9006   struct symtab_and_line cursal;
9007
9008   if (event_location_type (location) == LINESPEC_LOCATION)
9009     {
9010       const char *spec = get_linespec_location (location)->spec_string;
9011
9012       if (spec == NULL)
9013         {
9014           /* The last displayed codepoint, if it's valid, is our default
9015              breakpoint address.  */
9016           if (last_displayed_sal_is_valid ())
9017             {
9018               /* Set sal's pspace, pc, symtab, and line to the values
9019                  corresponding to the last call to print_frame_info.
9020                  Be sure to reinitialize LINE with NOTCURRENT == 0
9021                  as the breakpoint line number is inappropriate otherwise.
9022                  find_pc_line would adjust PC, re-set it back.  */
9023               symtab_and_line sal = get_last_displayed_sal ();
9024               CORE_ADDR pc = sal.pc;
9025
9026               sal = find_pc_line (pc, 0);
9027
9028               /* "break" without arguments is equivalent to "break *PC"
9029                  where PC is the last displayed codepoint's address.  So
9030                  make sure to set sal.explicit_pc to prevent GDB from
9031                  trying to expand the list of sals to include all other
9032                  instances with the same symtab and line.  */
9033               sal.pc = pc;
9034               sal.explicit_pc = 1;
9035
9036               struct linespec_sals lsal;
9037               lsal.sals = {sal};
9038               lsal.canonical = NULL;
9039
9040               canonical->lsals.push_back (std::move (lsal));
9041               return;
9042             }
9043           else
9044             error (_("No default breakpoint address now."));
9045         }
9046     }
9047
9048   /* Force almost all breakpoints to be in terms of the
9049      current_source_symtab (which is decode_line_1's default).
9050      This should produce the results we want almost all of the
9051      time while leaving default_breakpoint_* alone.
9052
9053      ObjC: However, don't match an Objective-C method name which
9054      may have a '+' or '-' succeeded by a '['.  */
9055   cursal = get_current_source_symtab_and_line ();
9056   if (last_displayed_sal_is_valid ())
9057     {
9058       const char *spec = NULL;
9059
9060       if (event_location_type (location) == LINESPEC_LOCATION)
9061         spec = get_linespec_location (location)->spec_string;
9062
9063       if (!cursal.symtab
9064           || (spec != NULL
9065               && strchr ("+-", spec[0]) != NULL
9066               && spec[1] != '['))
9067         {
9068           decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9069                             get_last_displayed_symtab (),
9070                             get_last_displayed_line (),
9071                             canonical, NULL, NULL);
9072           return;
9073         }
9074     }
9075
9076   decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9077                     cursal.symtab, cursal.line, canonical, NULL, NULL);
9078 }
9079
9080
9081 /* Convert each SAL into a real PC.  Verify that the PC can be
9082    inserted as a breakpoint.  If it can't throw an error.  */
9083
9084 static void
9085 breakpoint_sals_to_pc (std::vector<symtab_and_line> &sals)
9086 {    
9087   for (auto &sal : sals)
9088     resolve_sal_pc (&sal);
9089 }
9090
9091 /* Fast tracepoints may have restrictions on valid locations.  For
9092    instance, a fast tracepoint using a jump instead of a trap will
9093    likely have to overwrite more bytes than a trap would, and so can
9094    only be placed where the instruction is longer than the jump, or a
9095    multi-instruction sequence does not have a jump into the middle of
9096    it, etc.  */
9097
9098 static void
9099 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9100                             gdb::array_view<const symtab_and_line> sals)
9101 {
9102   for (const auto &sal : sals)
9103     {
9104       struct gdbarch *sarch;
9105
9106       sarch = get_sal_arch (sal);
9107       /* We fall back to GDBARCH if there is no architecture
9108          associated with SAL.  */
9109       if (sarch == NULL)
9110         sarch = gdbarch;
9111       std::string msg;
9112       if (!gdbarch_fast_tracepoint_valid_at (sarch, sal.pc, &msg))
9113         error (_("May not have a fast tracepoint at %s%s"),
9114                paddress (sarch, sal.pc), msg.c_str ());
9115     }
9116 }
9117
9118 /* Given TOK, a string specification of condition and thread, as
9119    accepted by the 'break' command, extract the condition
9120    string and thread number and set *COND_STRING and *THREAD.
9121    PC identifies the context at which the condition should be parsed.
9122    If no condition is found, *COND_STRING is set to NULL.
9123    If no thread is found, *THREAD is set to -1.  */
9124
9125 static void
9126 find_condition_and_thread (const char *tok, CORE_ADDR pc,
9127                            char **cond_string, int *thread, int *task,
9128                            char **rest)
9129 {
9130   *cond_string = NULL;
9131   *thread = -1;
9132   *task = 0;
9133   *rest = NULL;
9134
9135   while (tok && *tok)
9136     {
9137       const char *end_tok;
9138       int toklen;
9139       const char *cond_start = NULL;
9140       const char *cond_end = NULL;
9141
9142       tok = skip_spaces (tok);
9143
9144       if ((*tok == '"' || *tok == ',') && rest)
9145         {
9146           *rest = savestring (tok, strlen (tok));
9147           return;
9148         }
9149
9150       end_tok = skip_to_space (tok);
9151
9152       toklen = end_tok - tok;
9153
9154       if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9155         {
9156           tok = cond_start = end_tok + 1;
9157           parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
9158           cond_end = tok;
9159           *cond_string = savestring (cond_start, cond_end - cond_start);
9160         }
9161       else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9162         {
9163           const char *tmptok;
9164           struct thread_info *thr;
9165
9166           tok = end_tok + 1;
9167           thr = parse_thread_id (tok, &tmptok);
9168           if (tok == tmptok)
9169             error (_("Junk after thread keyword."));
9170           *thread = thr->global_num;
9171           tok = tmptok;
9172         }
9173       else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9174         {
9175           char *tmptok;
9176
9177           tok = end_tok + 1;
9178           *task = strtol (tok, &tmptok, 0);
9179           if (tok == tmptok)
9180             error (_("Junk after task keyword."));
9181           if (!valid_task_id (*task))
9182             error (_("Unknown task %d."), *task);
9183           tok = tmptok;
9184         }
9185       else if (rest)
9186         {
9187           *rest = savestring (tok, strlen (tok));
9188           return;
9189         }
9190       else
9191         error (_("Junk at end of arguments."));
9192     }
9193 }
9194
9195 /* Decode a static tracepoint marker spec.  */
9196
9197 static std::vector<symtab_and_line>
9198 decode_static_tracepoint_spec (const char **arg_p)
9199 {
9200   const char *p = &(*arg_p)[3];
9201   const char *endp;
9202
9203   p = skip_spaces (p);
9204
9205   endp = skip_to_space (p);
9206
9207   std::string marker_str (p, endp - p);
9208
9209   std::vector<static_tracepoint_marker> markers
9210     = target_static_tracepoint_markers_by_strid (marker_str.c_str ());
9211   if (markers.empty ())
9212     error (_("No known static tracepoint marker named %s"),
9213            marker_str.c_str ());
9214
9215   std::vector<symtab_and_line> sals;
9216   sals.reserve (markers.size ());
9217
9218   for (const static_tracepoint_marker &marker : markers)
9219     {
9220       symtab_and_line sal = find_pc_line (marker.address, 0);
9221       sal.pc = marker.address;
9222       sals.push_back (sal);
9223    }
9224
9225   *arg_p = endp;
9226   return sals;
9227 }
9228
9229 /* See breakpoint.h.  */
9230
9231 int
9232 create_breakpoint (struct gdbarch *gdbarch,
9233                    const struct event_location *location,
9234                    const char *cond_string,
9235                    int thread, const char *extra_string,
9236                    int parse_extra,
9237                    int tempflag, enum bptype type_wanted,
9238                    int ignore_count,
9239                    enum auto_boolean pending_break_support,
9240                    const struct breakpoint_ops *ops,
9241                    int from_tty, int enabled, int internal,
9242                    unsigned flags)
9243 {
9244   struct linespec_result canonical;
9245   struct cleanup *bkpt_chain = NULL;
9246   int pending = 0;
9247   int task = 0;
9248   int prev_bkpt_count = breakpoint_count;
9249
9250   gdb_assert (ops != NULL);
9251
9252   /* If extra_string isn't useful, set it to NULL.  */
9253   if (extra_string != NULL && *extra_string == '\0')
9254     extra_string = NULL;
9255
9256   TRY
9257     {
9258       ops->create_sals_from_location (location, &canonical, type_wanted);
9259     }
9260   CATCH (e, RETURN_MASK_ERROR)
9261     {
9262       /* If caller is interested in rc value from parse, set
9263          value.  */
9264       if (e.error == NOT_FOUND_ERROR)
9265         {
9266           /* If pending breakpoint support is turned off, throw
9267              error.  */
9268
9269           if (pending_break_support == AUTO_BOOLEAN_FALSE)
9270             throw_exception (e);
9271
9272           exception_print (gdb_stderr, e);
9273
9274           /* If pending breakpoint support is auto query and the user
9275              selects no, then simply return the error code.  */
9276           if (pending_break_support == AUTO_BOOLEAN_AUTO
9277               && !nquery (_("Make %s pending on future shared library load? "),
9278                           bptype_string (type_wanted)))
9279             return 0;
9280
9281           /* At this point, either the user was queried about setting
9282              a pending breakpoint and selected yes, or pending
9283              breakpoint behavior is on and thus a pending breakpoint
9284              is defaulted on behalf of the user.  */
9285           pending = 1;
9286         }
9287       else
9288         throw_exception (e);
9289     }
9290   END_CATCH
9291
9292   if (!pending && canonical.lsals.empty ())
9293     return 0;
9294
9295   /* ----------------------------- SNIP -----------------------------
9296      Anything added to the cleanup chain beyond this point is assumed
9297      to be part of a breakpoint.  If the breakpoint create succeeds
9298      then the memory is not reclaimed.  */
9299   bkpt_chain = make_cleanup (null_cleanup, 0);
9300
9301   /* Resolve all line numbers to PC's and verify that the addresses
9302      are ok for the target.  */
9303   if (!pending)
9304     {
9305       for (auto &lsal : canonical.lsals)
9306         breakpoint_sals_to_pc (lsal.sals);
9307     }
9308
9309   /* Fast tracepoints may have additional restrictions on location.  */
9310   if (!pending && type_wanted == bp_fast_tracepoint)
9311     {
9312       for (const auto &lsal : canonical.lsals)
9313         check_fast_tracepoint_sals (gdbarch, lsal.sals);
9314     }
9315
9316   /* Verify that condition can be parsed, before setting any
9317      breakpoints.  Allocate a separate condition expression for each
9318      breakpoint.  */
9319   if (!pending)
9320     {
9321       gdb::unique_xmalloc_ptr<char> cond_string_copy;
9322       gdb::unique_xmalloc_ptr<char> extra_string_copy;
9323
9324       if (parse_extra)
9325         {
9326           char *rest;
9327           char *cond;
9328
9329           const linespec_sals &lsal = canonical.lsals[0];
9330
9331           /* Here we only parse 'arg' to separate condition
9332              from thread number, so parsing in context of first
9333              sal is OK.  When setting the breakpoint we'll
9334              re-parse it in context of each sal.  */
9335
9336           find_condition_and_thread (extra_string, lsal.sals[0].pc,
9337                                      &cond, &thread, &task, &rest);
9338           cond_string_copy.reset (cond);
9339           extra_string_copy.reset (rest);
9340         }
9341       else
9342         {
9343           if (type_wanted != bp_dprintf
9344               && extra_string != NULL && *extra_string != '\0')
9345                 error (_("Garbage '%s' at end of location"), extra_string);
9346
9347           /* Create a private copy of condition string.  */
9348           if (cond_string)
9349             cond_string_copy.reset (xstrdup (cond_string));
9350           /* Create a private copy of any extra string.  */
9351           if (extra_string)
9352             extra_string_copy.reset (xstrdup (extra_string));
9353         }
9354
9355       ops->create_breakpoints_sal (gdbarch, &canonical,
9356                                    std::move (cond_string_copy),
9357                                    std::move (extra_string_copy),
9358                                    type_wanted,
9359                                    tempflag ? disp_del : disp_donttouch,
9360                                    thread, task, ignore_count, ops,
9361                                    from_tty, enabled, internal, flags);
9362     }
9363   else
9364     {
9365       std::unique_ptr <breakpoint> b = new_breakpoint_from_type (type_wanted);
9366
9367       init_raw_breakpoint_without_location (b.get (), gdbarch, type_wanted, ops);
9368       b->location = copy_event_location (location);
9369
9370       if (parse_extra)
9371         b->cond_string = NULL;
9372       else
9373         {
9374           /* Create a private copy of condition string.  */
9375           b->cond_string = cond_string != NULL ? xstrdup (cond_string) : NULL;
9376           b->thread = thread;
9377         }
9378
9379       /* Create a private copy of any extra string.  */
9380       b->extra_string = extra_string != NULL ? xstrdup (extra_string) : NULL;
9381       b->ignore_count = ignore_count;
9382       b->disposition = tempflag ? disp_del : disp_donttouch;
9383       b->condition_not_parsed = 1;
9384       b->enable_state = enabled ? bp_enabled : bp_disabled;
9385       if ((type_wanted != bp_breakpoint
9386            && type_wanted != bp_hardware_breakpoint) || thread != -1)
9387         b->pspace = current_program_space;
9388
9389       install_breakpoint (internal, std::move (b), 0);
9390     }
9391   
9392   if (canonical.lsals.size () > 1)
9393     {
9394       warning (_("Multiple breakpoints were set.\nUse the "
9395                  "\"delete\" command to delete unwanted breakpoints."));
9396       prev_breakpoint_count = prev_bkpt_count;
9397     }
9398
9399   /* That's it.  Discard the cleanups for data inserted into the
9400      breakpoint.  */
9401   discard_cleanups (bkpt_chain);
9402
9403   /* error call may happen here - have BKPT_CHAIN already discarded.  */
9404   update_global_location_list (UGLL_MAY_INSERT);
9405
9406   return 1;
9407 }
9408
9409 /* Set a breakpoint.
9410    ARG is a string describing breakpoint address,
9411    condition, and thread.
9412    FLAG specifies if a breakpoint is hardware on,
9413    and if breakpoint is temporary, using BP_HARDWARE_FLAG
9414    and BP_TEMPFLAG.  */
9415
9416 static void
9417 break_command_1 (const char *arg, int flag, int from_tty)
9418 {
9419   int tempflag = flag & BP_TEMPFLAG;
9420   enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9421                              ? bp_hardware_breakpoint
9422                              : bp_breakpoint);
9423   struct breakpoint_ops *ops;
9424
9425   event_location_up location = string_to_event_location (&arg, current_language);
9426
9427   /* Matching breakpoints on probes.  */
9428   if (location != NULL
9429       && event_location_type (location.get ()) == PROBE_LOCATION)
9430     ops = &bkpt_probe_breakpoint_ops;
9431   else
9432     ops = &bkpt_breakpoint_ops;
9433
9434   create_breakpoint (get_current_arch (),
9435                      location.get (),
9436                      NULL, 0, arg, 1 /* parse arg */,
9437                      tempflag, type_wanted,
9438                      0 /* Ignore count */,
9439                      pending_break_support,
9440                      ops,
9441                      from_tty,
9442                      1 /* enabled */,
9443                      0 /* internal */,
9444                      0);
9445 }
9446
9447 /* Helper function for break_command_1 and disassemble_command.  */
9448
9449 void
9450 resolve_sal_pc (struct symtab_and_line *sal)
9451 {
9452   CORE_ADDR pc;
9453
9454   if (sal->pc == 0 && sal->symtab != NULL)
9455     {
9456       if (!find_line_pc (sal->symtab, sal->line, &pc))
9457         error (_("No line %d in file \"%s\"."),
9458                sal->line, symtab_to_filename_for_display (sal->symtab));
9459       sal->pc = pc;
9460
9461       /* If this SAL corresponds to a breakpoint inserted using a line
9462          number, then skip the function prologue if necessary.  */
9463       if (sal->explicit_line)
9464         skip_prologue_sal (sal);
9465     }
9466
9467   if (sal->section == 0 && sal->symtab != NULL)
9468     {
9469       const struct blockvector *bv;
9470       const struct block *b;
9471       struct symbol *sym;
9472
9473       bv = blockvector_for_pc_sect (sal->pc, 0, &b,
9474                                     SYMTAB_COMPUNIT (sal->symtab));
9475       if (bv != NULL)
9476         {
9477           sym = block_linkage_function (b);
9478           if (sym != NULL)
9479             {
9480               fixup_symbol_section (sym, SYMTAB_OBJFILE (sal->symtab));
9481               sal->section = SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal->symtab),
9482                                                  sym);
9483             }
9484           else
9485             {
9486               /* It really is worthwhile to have the section, so we'll
9487                  just have to look harder. This case can be executed
9488                  if we have line numbers but no functions (as can
9489                  happen in assembly source).  */
9490
9491               scoped_restore_current_pspace_and_thread restore_pspace_thread;
9492               switch_to_program_space_and_thread (sal->pspace);
9493
9494               bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (sal->pc);
9495               if (msym.minsym)
9496                 sal->section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
9497             }
9498         }
9499     }
9500 }
9501
9502 void
9503 break_command (const char *arg, int from_tty)
9504 {
9505   break_command_1 (arg, 0, from_tty);
9506 }
9507
9508 void
9509 tbreak_command (const char *arg, int from_tty)
9510 {
9511   break_command_1 (arg, BP_TEMPFLAG, from_tty);
9512 }
9513
9514 static void
9515 hbreak_command (const char *arg, int from_tty)
9516 {
9517   break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
9518 }
9519
9520 static void
9521 thbreak_command (const char *arg, int from_tty)
9522 {
9523   break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
9524 }
9525
9526 static void
9527 stop_command (const char *arg, int from_tty)
9528 {
9529   printf_filtered (_("Specify the type of breakpoint to set.\n\
9530 Usage: stop in <function | address>\n\
9531        stop at <line>\n"));
9532 }
9533
9534 static void
9535 stopin_command (const char *arg, int from_tty)
9536 {
9537   int badInput = 0;
9538
9539   if (arg == (char *) NULL)
9540     badInput = 1;
9541   else if (*arg != '*')
9542     {
9543       const char *argptr = arg;
9544       int hasColon = 0;
9545
9546       /* Look for a ':'.  If this is a line number specification, then
9547          say it is bad, otherwise, it should be an address or
9548          function/method name.  */
9549       while (*argptr && !hasColon)
9550         {
9551           hasColon = (*argptr == ':');
9552           argptr++;
9553         }
9554
9555       if (hasColon)
9556         badInput = (*argptr != ':');    /* Not a class::method */
9557       else
9558         badInput = isdigit (*arg);      /* a simple line number */
9559     }
9560
9561   if (badInput)
9562     printf_filtered (_("Usage: stop in <function | address>\n"));
9563   else
9564     break_command_1 (arg, 0, from_tty);
9565 }
9566
9567 static void
9568 stopat_command (const char *arg, int from_tty)
9569 {
9570   int badInput = 0;
9571
9572   if (arg == (char *) NULL || *arg == '*')      /* no line number */
9573     badInput = 1;
9574   else
9575     {
9576       const char *argptr = arg;
9577       int hasColon = 0;
9578
9579       /* Look for a ':'.  If there is a '::' then get out, otherwise
9580          it is probably a line number.  */
9581       while (*argptr && !hasColon)
9582         {
9583           hasColon = (*argptr == ':');
9584           argptr++;
9585         }
9586
9587       if (hasColon)
9588         badInput = (*argptr == ':');    /* we have class::method */
9589       else
9590         badInput = !isdigit (*arg);     /* not a line number */
9591     }
9592
9593   if (badInput)
9594     printf_filtered (_("Usage: stop at LINE\n"));
9595   else
9596     break_command_1 (arg, 0, from_tty);
9597 }
9598
9599 /* The dynamic printf command is mostly like a regular breakpoint, but
9600    with a prewired command list consisting of a single output command,
9601    built from extra arguments supplied on the dprintf command
9602    line.  */
9603
9604 static void
9605 dprintf_command (const char *arg, int from_tty)
9606 {
9607   event_location_up location = string_to_event_location (&arg, current_language);
9608
9609   /* If non-NULL, ARG should have been advanced past the location;
9610      the next character must be ','.  */
9611   if (arg != NULL)
9612     {
9613       if (arg[0] != ',' || arg[1] == '\0')
9614         error (_("Format string required"));
9615       else
9616         {
9617           /* Skip the comma.  */
9618           ++arg;
9619         }
9620     }
9621
9622   create_breakpoint (get_current_arch (),
9623                      location.get (),
9624                      NULL, 0, arg, 1 /* parse arg */,
9625                      0, bp_dprintf,
9626                      0 /* Ignore count */,
9627                      pending_break_support,
9628                      &dprintf_breakpoint_ops,
9629                      from_tty,
9630                      1 /* enabled */,
9631                      0 /* internal */,
9632                      0);
9633 }
9634
9635 static void
9636 agent_printf_command (const char *arg, int from_tty)
9637 {
9638   error (_("May only run agent-printf on the target"));
9639 }
9640
9641 /* Implement the "breakpoint_hit" breakpoint_ops method for
9642    ranged breakpoints.  */
9643
9644 static int
9645 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
9646                                   const address_space *aspace,
9647                                   CORE_ADDR bp_addr,
9648                                   const struct target_waitstatus *ws)
9649 {
9650   if (ws->kind != TARGET_WAITKIND_STOPPED
9651       || ws->value.sig != GDB_SIGNAL_TRAP)
9652     return 0;
9653
9654   return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
9655                                          bl->length, aspace, bp_addr);
9656 }
9657
9658 /* Implement the "resources_needed" breakpoint_ops method for
9659    ranged breakpoints.  */
9660
9661 static int
9662 resources_needed_ranged_breakpoint (const struct bp_location *bl)
9663 {
9664   return target_ranged_break_num_registers ();
9665 }
9666
9667 /* Implement the "print_it" breakpoint_ops method for
9668    ranged breakpoints.  */
9669
9670 static enum print_stop_action
9671 print_it_ranged_breakpoint (bpstat bs)
9672 {
9673   struct breakpoint *b = bs->breakpoint_at;
9674   struct bp_location *bl = b->loc;
9675   struct ui_out *uiout = current_uiout;
9676
9677   gdb_assert (b->type == bp_hardware_breakpoint);
9678
9679   /* Ranged breakpoints have only one location.  */
9680   gdb_assert (bl && bl->next == NULL);
9681
9682   annotate_breakpoint (b->number);
9683
9684   maybe_print_thread_hit_breakpoint (uiout);
9685
9686   if (b->disposition == disp_del)
9687     uiout->text ("Temporary ranged breakpoint ");
9688   else
9689     uiout->text ("Ranged breakpoint ");
9690   if (uiout->is_mi_like_p ())
9691     {
9692       uiout->field_string ("reason",
9693                       async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9694       uiout->field_string ("disp", bpdisp_text (b->disposition));
9695     }
9696   uiout->field_int ("bkptno", b->number);
9697   uiout->text (", ");
9698
9699   return PRINT_SRC_AND_LOC;
9700 }
9701
9702 /* Implement the "print_one" breakpoint_ops method for
9703    ranged breakpoints.  */
9704
9705 static void
9706 print_one_ranged_breakpoint (struct breakpoint *b,
9707                              struct bp_location **last_loc)
9708 {
9709   struct bp_location *bl = b->loc;
9710   struct value_print_options opts;
9711   struct ui_out *uiout = current_uiout;
9712
9713   /* Ranged breakpoints have only one location.  */
9714   gdb_assert (bl && bl->next == NULL);
9715
9716   get_user_print_options (&opts);
9717
9718   if (opts.addressprint)
9719     /* We don't print the address range here, it will be printed later
9720        by print_one_detail_ranged_breakpoint.  */
9721     uiout->field_skip ("addr");
9722   annotate_field (5);
9723   print_breakpoint_location (b, bl);
9724   *last_loc = bl;
9725 }
9726
9727 /* Implement the "print_one_detail" breakpoint_ops method for
9728    ranged breakpoints.  */
9729
9730 static void
9731 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
9732                                     struct ui_out *uiout)
9733 {
9734   CORE_ADDR address_start, address_end;
9735   struct bp_location *bl = b->loc;
9736   string_file stb;
9737
9738   gdb_assert (bl);
9739
9740   address_start = bl->address;
9741   address_end = address_start + bl->length - 1;
9742
9743   uiout->text ("\taddress range: ");
9744   stb.printf ("[%s, %s]",
9745               print_core_address (bl->gdbarch, address_start),
9746               print_core_address (bl->gdbarch, address_end));
9747   uiout->field_stream ("addr", stb);
9748   uiout->text ("\n");
9749 }
9750
9751 /* Implement the "print_mention" breakpoint_ops method for
9752    ranged breakpoints.  */
9753
9754 static void
9755 print_mention_ranged_breakpoint (struct breakpoint *b)
9756 {
9757   struct bp_location *bl = b->loc;
9758   struct ui_out *uiout = current_uiout;
9759
9760   gdb_assert (bl);
9761   gdb_assert (b->type == bp_hardware_breakpoint);
9762
9763   uiout->message (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9764                   b->number, paddress (bl->gdbarch, bl->address),
9765                   paddress (bl->gdbarch, bl->address + bl->length - 1));
9766 }
9767
9768 /* Implement the "print_recreate" breakpoint_ops method for
9769    ranged breakpoints.  */
9770
9771 static void
9772 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
9773 {
9774   fprintf_unfiltered (fp, "break-range %s, %s",
9775                       event_location_to_string (b->location.get ()),
9776                       event_location_to_string (b->location_range_end.get ()));
9777   print_recreate_thread (b, fp);
9778 }
9779
9780 /* The breakpoint_ops structure to be used in ranged breakpoints.  */
9781
9782 static struct breakpoint_ops ranged_breakpoint_ops;
9783
9784 /* Find the address where the end of the breakpoint range should be
9785    placed, given the SAL of the end of the range.  This is so that if
9786    the user provides a line number, the end of the range is set to the
9787    last instruction of the given line.  */
9788
9789 static CORE_ADDR
9790 find_breakpoint_range_end (struct symtab_and_line sal)
9791 {
9792   CORE_ADDR end;
9793
9794   /* If the user provided a PC value, use it.  Otherwise,
9795      find the address of the end of the given location.  */
9796   if (sal.explicit_pc)
9797     end = sal.pc;
9798   else
9799     {
9800       int ret;
9801       CORE_ADDR start;
9802
9803       ret = find_line_pc_range (sal, &start, &end);
9804       if (!ret)
9805         error (_("Could not find location of the end of the range."));
9806
9807       /* find_line_pc_range returns the start of the next line.  */
9808       end--;
9809     }
9810
9811   return end;
9812 }
9813
9814 /* Implement the "break-range" CLI command.  */
9815
9816 static void
9817 break_range_command (const char *arg, int from_tty)
9818 {
9819   const char *arg_start;
9820   struct linespec_result canonical_start, canonical_end;
9821   int bp_count, can_use_bp, length;
9822   CORE_ADDR end;
9823   struct breakpoint *b;
9824
9825   /* We don't support software ranged breakpoints.  */
9826   if (target_ranged_break_num_registers () < 0)
9827     error (_("This target does not support hardware ranged breakpoints."));
9828
9829   bp_count = hw_breakpoint_used_count ();
9830   bp_count += target_ranged_break_num_registers ();
9831   can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
9832                                                    bp_count, 0);
9833   if (can_use_bp < 0)
9834     error (_("Hardware breakpoints used exceeds limit."));
9835
9836   arg = skip_spaces (arg);
9837   if (arg == NULL || arg[0] == '\0')
9838     error(_("No address range specified."));
9839
9840   arg_start = arg;
9841   event_location_up start_location = string_to_event_location (&arg,
9842                                                                current_language);
9843   parse_breakpoint_sals (start_location.get (), &canonical_start);
9844
9845   if (arg[0] != ',')
9846     error (_("Too few arguments."));
9847   else if (canonical_start.lsals.empty ())
9848     error (_("Could not find location of the beginning of the range."));
9849
9850   const linespec_sals &lsal_start = canonical_start.lsals[0];
9851
9852   if (canonical_start.lsals.size () > 1
9853       || lsal_start.sals.size () != 1)
9854     error (_("Cannot create a ranged breakpoint with multiple locations."));
9855
9856   const symtab_and_line &sal_start = lsal_start.sals[0];
9857   std::string addr_string_start (arg_start, arg - arg_start);
9858
9859   arg++;        /* Skip the comma.  */
9860   arg = skip_spaces (arg);
9861
9862   /* Parse the end location.  */
9863
9864   arg_start = arg;
9865
9866   /* We call decode_line_full directly here instead of using
9867      parse_breakpoint_sals because we need to specify the start location's
9868      symtab and line as the default symtab and line for the end of the
9869      range.  This makes it possible to have ranges like "foo.c:27, +14",
9870      where +14 means 14 lines from the start location.  */
9871   event_location_up end_location = string_to_event_location (&arg,
9872                                                              current_language);
9873   decode_line_full (end_location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
9874                     sal_start.symtab, sal_start.line,
9875                     &canonical_end, NULL, NULL);
9876
9877   if (canonical_end.lsals.empty ())
9878     error (_("Could not find location of the end of the range."));
9879
9880   const linespec_sals &lsal_end = canonical_end.lsals[0];
9881   if (canonical_end.lsals.size () > 1
9882       || lsal_end.sals.size () != 1)
9883     error (_("Cannot create a ranged breakpoint with multiple locations."));
9884
9885   const symtab_and_line &sal_end = lsal_end.sals[0];
9886
9887   end = find_breakpoint_range_end (sal_end);
9888   if (sal_start.pc > end)
9889     error (_("Invalid address range, end precedes start."));
9890
9891   length = end - sal_start.pc + 1;
9892   if (length < 0)
9893     /* Length overflowed.  */
9894     error (_("Address range too large."));
9895   else if (length == 1)
9896     {
9897       /* This range is simple enough to be handled by
9898          the `hbreak' command.  */
9899       hbreak_command (&addr_string_start[0], 1);
9900
9901       return;
9902     }
9903
9904   /* Now set up the breakpoint.  */
9905   b = set_raw_breakpoint (get_current_arch (), sal_start,
9906                           bp_hardware_breakpoint, &ranged_breakpoint_ops);
9907   set_breakpoint_count (breakpoint_count + 1);
9908   b->number = breakpoint_count;
9909   b->disposition = disp_donttouch;
9910   b->location = std::move (start_location);
9911   b->location_range_end = std::move (end_location);
9912   b->loc->length = length;
9913
9914   mention (b);
9915   gdb::observers::breakpoint_created.notify (b);
9916   update_global_location_list (UGLL_MAY_INSERT);
9917 }
9918
9919 /*  Return non-zero if EXP is verified as constant.  Returned zero
9920     means EXP is variable.  Also the constant detection may fail for
9921     some constant expressions and in such case still falsely return
9922     zero.  */
9923
9924 static int
9925 watchpoint_exp_is_const (const struct expression *exp)
9926 {
9927   int i = exp->nelts;
9928
9929   while (i > 0)
9930     {
9931       int oplenp, argsp;
9932
9933       /* We are only interested in the descriptor of each element.  */
9934       operator_length (exp, i, &oplenp, &argsp);
9935       i -= oplenp;
9936
9937       switch (exp->elts[i].opcode)
9938         {
9939         case BINOP_ADD:
9940         case BINOP_SUB:
9941         case BINOP_MUL:
9942         case BINOP_DIV:
9943         case BINOP_REM:
9944         case BINOP_MOD:
9945         case BINOP_LSH:
9946         case BINOP_RSH:
9947         case BINOP_LOGICAL_AND:
9948         case BINOP_LOGICAL_OR:
9949         case BINOP_BITWISE_AND:
9950         case BINOP_BITWISE_IOR:
9951         case BINOP_BITWISE_XOR:
9952         case BINOP_EQUAL:
9953         case BINOP_NOTEQUAL:
9954         case BINOP_LESS:
9955         case BINOP_GTR:
9956         case BINOP_LEQ:
9957         case BINOP_GEQ:
9958         case BINOP_REPEAT:
9959         case BINOP_COMMA:
9960         case BINOP_EXP:
9961         case BINOP_MIN:
9962         case BINOP_MAX:
9963         case BINOP_INTDIV:
9964         case BINOP_CONCAT:
9965         case TERNOP_COND:
9966         case TERNOP_SLICE:
9967
9968         case OP_LONG:
9969         case OP_FLOAT:
9970         case OP_LAST:
9971         case OP_COMPLEX:
9972         case OP_STRING:
9973         case OP_ARRAY:
9974         case OP_TYPE:
9975         case OP_TYPEOF:
9976         case OP_DECLTYPE:
9977         case OP_TYPEID:
9978         case OP_NAME:
9979         case OP_OBJC_NSSTRING:
9980
9981         case UNOP_NEG:
9982         case UNOP_LOGICAL_NOT:
9983         case UNOP_COMPLEMENT:
9984         case UNOP_ADDR:
9985         case UNOP_HIGH:
9986         case UNOP_CAST:
9987
9988         case UNOP_CAST_TYPE:
9989         case UNOP_REINTERPRET_CAST:
9990         case UNOP_DYNAMIC_CAST:
9991           /* Unary, binary and ternary operators: We have to check
9992              their operands.  If they are constant, then so is the
9993              result of that operation.  For instance, if A and B are
9994              determined to be constants, then so is "A + B".
9995
9996              UNOP_IND is one exception to the rule above, because the
9997              value of *ADDR is not necessarily a constant, even when
9998              ADDR is.  */
9999           break;
10000
10001         case OP_VAR_VALUE:
10002           /* Check whether the associated symbol is a constant.
10003
10004              We use SYMBOL_CLASS rather than TYPE_CONST because it's
10005              possible that a buggy compiler could mark a variable as
10006              constant even when it is not, and TYPE_CONST would return
10007              true in this case, while SYMBOL_CLASS wouldn't.
10008
10009              We also have to check for function symbols because they
10010              are always constant.  */
10011           {
10012             struct symbol *s = exp->elts[i + 2].symbol;
10013
10014             if (SYMBOL_CLASS (s) != LOC_BLOCK
10015                 && SYMBOL_CLASS (s) != LOC_CONST
10016                 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
10017               return 0;
10018             break;
10019           }
10020
10021         /* The default action is to return 0 because we are using
10022            the optimistic approach here: If we don't know something,
10023            then it is not a constant.  */
10024         default:
10025           return 0;
10026         }
10027     }
10028
10029   return 1;
10030 }
10031
10032 /* Watchpoint destructor.  */
10033
10034 watchpoint::~watchpoint ()
10035 {
10036   xfree (this->exp_string);
10037   xfree (this->exp_string_reparse);
10038 }
10039
10040 /* Implement the "re_set" breakpoint_ops method for watchpoints.  */
10041
10042 static void
10043 re_set_watchpoint (struct breakpoint *b)
10044 {
10045   struct watchpoint *w = (struct watchpoint *) b;
10046
10047   /* Watchpoint can be either on expression using entirely global
10048      variables, or it can be on local variables.
10049
10050      Watchpoints of the first kind are never auto-deleted, and even
10051      persist across program restarts.  Since they can use variables
10052      from shared libraries, we need to reparse expression as libraries
10053      are loaded and unloaded.
10054
10055      Watchpoints on local variables can also change meaning as result
10056      of solib event.  For example, if a watchpoint uses both a local
10057      and a global variables in expression, it's a local watchpoint,
10058      but unloading of a shared library will make the expression
10059      invalid.  This is not a very common use case, but we still
10060      re-evaluate expression, to avoid surprises to the user.
10061
10062      Note that for local watchpoints, we re-evaluate it only if
10063      watchpoints frame id is still valid.  If it's not, it means the
10064      watchpoint is out of scope and will be deleted soon.  In fact,
10065      I'm not sure we'll ever be called in this case.
10066
10067      If a local watchpoint's frame id is still valid, then
10068      w->exp_valid_block is likewise valid, and we can safely use it.
10069
10070      Don't do anything about disabled watchpoints, since they will be
10071      reevaluated again when enabled.  */
10072   update_watchpoint (w, 1 /* reparse */);
10073 }
10074
10075 /* Implement the "insert" breakpoint_ops method for hardware watchpoints.  */
10076
10077 static int
10078 insert_watchpoint (struct bp_location *bl)
10079 {
10080   struct watchpoint *w = (struct watchpoint *) bl->owner;
10081   int length = w->exact ? 1 : bl->length;
10082
10083   return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
10084                                    w->cond_exp.get ());
10085 }
10086
10087 /* Implement the "remove" breakpoint_ops method for hardware watchpoints.  */
10088
10089 static int
10090 remove_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10091 {
10092   struct watchpoint *w = (struct watchpoint *) bl->owner;
10093   int length = w->exact ? 1 : bl->length;
10094
10095   return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
10096                                    w->cond_exp.get ());
10097 }
10098
10099 static int
10100 breakpoint_hit_watchpoint (const struct bp_location *bl,
10101                            const address_space *aspace, CORE_ADDR bp_addr,
10102                            const struct target_waitstatus *ws)
10103 {
10104   struct breakpoint *b = bl->owner;
10105   struct watchpoint *w = (struct watchpoint *) b;
10106
10107   /* Continuable hardware watchpoints are treated as non-existent if the
10108      reason we stopped wasn't a hardware watchpoint (we didn't stop on
10109      some data address).  Otherwise gdb won't stop on a break instruction
10110      in the code (not from a breakpoint) when a hardware watchpoint has
10111      been defined.  Also skip watchpoints which we know did not trigger
10112      (did not match the data address).  */
10113   if (is_hardware_watchpoint (b)
10114       && w->watchpoint_triggered == watch_triggered_no)
10115     return 0;
10116
10117   return 1;
10118 }
10119
10120 static void
10121 check_status_watchpoint (bpstat bs)
10122 {
10123   gdb_assert (is_watchpoint (bs->breakpoint_at));
10124
10125   bpstat_check_watchpoint (bs);
10126 }
10127
10128 /* Implement the "resources_needed" breakpoint_ops method for
10129    hardware watchpoints.  */
10130
10131 static int
10132 resources_needed_watchpoint (const struct bp_location *bl)
10133 {
10134   struct watchpoint *w = (struct watchpoint *) bl->owner;
10135   int length = w->exact? 1 : bl->length;
10136
10137   return target_region_ok_for_hw_watchpoint (bl->address, length);
10138 }
10139
10140 /* Implement the "works_in_software_mode" breakpoint_ops method for
10141    hardware watchpoints.  */
10142
10143 static int
10144 works_in_software_mode_watchpoint (const struct breakpoint *b)
10145 {
10146   /* Read and access watchpoints only work with hardware support.  */
10147   return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
10148 }
10149
10150 static enum print_stop_action
10151 print_it_watchpoint (bpstat bs)
10152 {
10153   struct breakpoint *b;
10154   enum print_stop_action result;
10155   struct watchpoint *w;
10156   struct ui_out *uiout = current_uiout;
10157
10158   gdb_assert (bs->bp_location_at != NULL);
10159
10160   b = bs->breakpoint_at;
10161   w = (struct watchpoint *) b;
10162
10163   annotate_watchpoint (b->number);
10164   maybe_print_thread_hit_breakpoint (uiout);
10165
10166   string_file stb;
10167
10168   gdb::optional<ui_out_emit_tuple> tuple_emitter;
10169   switch (b->type)
10170     {
10171     case bp_watchpoint:
10172     case bp_hardware_watchpoint:
10173       if (uiout->is_mi_like_p ())
10174         uiout->field_string
10175           ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10176       mention (b);
10177       tuple_emitter.emplace (uiout, "value");
10178       uiout->text ("\nOld value = ");
10179       watchpoint_value_print (bs->old_val.get (), &stb);
10180       uiout->field_stream ("old", stb);
10181       uiout->text ("\nNew value = ");
10182       watchpoint_value_print (w->val.get (), &stb);
10183       uiout->field_stream ("new", stb);
10184       uiout->text ("\n");
10185       /* More than one watchpoint may have been triggered.  */
10186       result = PRINT_UNKNOWN;
10187       break;
10188
10189     case bp_read_watchpoint:
10190       if (uiout->is_mi_like_p ())
10191         uiout->field_string
10192           ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10193       mention (b);
10194       tuple_emitter.emplace (uiout, "value");
10195       uiout->text ("\nValue = ");
10196       watchpoint_value_print (w->val.get (), &stb);
10197       uiout->field_stream ("value", stb);
10198       uiout->text ("\n");
10199       result = PRINT_UNKNOWN;
10200       break;
10201
10202     case bp_access_watchpoint:
10203       if (bs->old_val != NULL)
10204         {
10205           if (uiout->is_mi_like_p ())
10206             uiout->field_string
10207               ("reason",
10208                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10209           mention (b);
10210           tuple_emitter.emplace (uiout, "value");
10211           uiout->text ("\nOld value = ");
10212           watchpoint_value_print (bs->old_val.get (), &stb);
10213           uiout->field_stream ("old", stb);
10214           uiout->text ("\nNew value = ");
10215         }
10216       else
10217         {
10218           mention (b);
10219           if (uiout->is_mi_like_p ())
10220             uiout->field_string
10221               ("reason",
10222                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10223           tuple_emitter.emplace (uiout, "value");
10224           uiout->text ("\nValue = ");
10225         }
10226       watchpoint_value_print (w->val.get (), &stb);
10227       uiout->field_stream ("new", stb);
10228       uiout->text ("\n");
10229       result = PRINT_UNKNOWN;
10230       break;
10231     default:
10232       result = PRINT_UNKNOWN;
10233     }
10234
10235   return result;
10236 }
10237
10238 /* Implement the "print_mention" breakpoint_ops method for hardware
10239    watchpoints.  */
10240
10241 static void
10242 print_mention_watchpoint (struct breakpoint *b)
10243 {
10244   struct watchpoint *w = (struct watchpoint *) b;
10245   struct ui_out *uiout = current_uiout;
10246   const char *tuple_name;
10247
10248   switch (b->type)
10249     {
10250     case bp_watchpoint:
10251       uiout->text ("Watchpoint ");
10252       tuple_name = "wpt";
10253       break;
10254     case bp_hardware_watchpoint:
10255       uiout->text ("Hardware watchpoint ");
10256       tuple_name = "wpt";
10257       break;
10258     case bp_read_watchpoint:
10259       uiout->text ("Hardware read watchpoint ");
10260       tuple_name = "hw-rwpt";
10261       break;
10262     case bp_access_watchpoint:
10263       uiout->text ("Hardware access (read/write) watchpoint ");
10264       tuple_name = "hw-awpt";
10265       break;
10266     default:
10267       internal_error (__FILE__, __LINE__,
10268                       _("Invalid hardware watchpoint type."));
10269     }
10270
10271   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10272   uiout->field_int ("number", b->number);
10273   uiout->text (": ");
10274   uiout->field_string ("exp", w->exp_string);
10275 }
10276
10277 /* Implement the "print_recreate" breakpoint_ops method for
10278    watchpoints.  */
10279
10280 static void
10281 print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10282 {
10283   struct watchpoint *w = (struct watchpoint *) b;
10284
10285   switch (b->type)
10286     {
10287     case bp_watchpoint:
10288     case bp_hardware_watchpoint:
10289       fprintf_unfiltered (fp, "watch");
10290       break;
10291     case bp_read_watchpoint:
10292       fprintf_unfiltered (fp, "rwatch");
10293       break;
10294     case bp_access_watchpoint:
10295       fprintf_unfiltered (fp, "awatch");
10296       break;
10297     default:
10298       internal_error (__FILE__, __LINE__,
10299                       _("Invalid watchpoint type."));
10300     }
10301
10302   fprintf_unfiltered (fp, " %s", w->exp_string);
10303   print_recreate_thread (b, fp);
10304 }
10305
10306 /* Implement the "explains_signal" breakpoint_ops method for
10307    watchpoints.  */
10308
10309 static int
10310 explains_signal_watchpoint (struct breakpoint *b, enum gdb_signal sig)
10311 {
10312   /* A software watchpoint cannot cause a signal other than
10313      GDB_SIGNAL_TRAP.  */
10314   if (b->type == bp_watchpoint && sig != GDB_SIGNAL_TRAP)
10315     return 0;
10316
10317   return 1;
10318 }
10319
10320 /* The breakpoint_ops structure to be used in hardware watchpoints.  */
10321
10322 static struct breakpoint_ops watchpoint_breakpoint_ops;
10323
10324 /* Implement the "insert" breakpoint_ops method for
10325    masked hardware watchpoints.  */
10326
10327 static int
10328 insert_masked_watchpoint (struct bp_location *bl)
10329 {
10330   struct watchpoint *w = (struct watchpoint *) bl->owner;
10331
10332   return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
10333                                         bl->watchpoint_type);
10334 }
10335
10336 /* Implement the "remove" breakpoint_ops method for
10337    masked hardware watchpoints.  */
10338
10339 static int
10340 remove_masked_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10341 {
10342   struct watchpoint *w = (struct watchpoint *) bl->owner;
10343
10344   return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
10345                                         bl->watchpoint_type);
10346 }
10347
10348 /* Implement the "resources_needed" breakpoint_ops method for
10349    masked hardware watchpoints.  */
10350
10351 static int
10352 resources_needed_masked_watchpoint (const struct bp_location *bl)
10353 {
10354   struct watchpoint *w = (struct watchpoint *) bl->owner;
10355
10356   return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
10357 }
10358
10359 /* Implement the "works_in_software_mode" breakpoint_ops method for
10360    masked hardware watchpoints.  */
10361
10362 static int
10363 works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10364 {
10365   return 0;
10366 }
10367
10368 /* Implement the "print_it" breakpoint_ops method for
10369    masked hardware watchpoints.  */
10370
10371 static enum print_stop_action
10372 print_it_masked_watchpoint (bpstat bs)
10373 {
10374   struct breakpoint *b = bs->breakpoint_at;
10375   struct ui_out *uiout = current_uiout;
10376
10377   /* Masked watchpoints have only one location.  */
10378   gdb_assert (b->loc && b->loc->next == NULL);
10379
10380   annotate_watchpoint (b->number);
10381   maybe_print_thread_hit_breakpoint (uiout);
10382
10383   switch (b->type)
10384     {
10385     case bp_hardware_watchpoint:
10386       if (uiout->is_mi_like_p ())
10387         uiout->field_string
10388           ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10389       break;
10390
10391     case bp_read_watchpoint:
10392       if (uiout->is_mi_like_p ())
10393         uiout->field_string
10394           ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10395       break;
10396
10397     case bp_access_watchpoint:
10398       if (uiout->is_mi_like_p ())
10399         uiout->field_string
10400           ("reason",
10401            async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10402       break;
10403     default:
10404       internal_error (__FILE__, __LINE__,
10405                       _("Invalid hardware watchpoint type."));
10406     }
10407
10408   mention (b);
10409   uiout->text (_("\n\
10410 Check the underlying instruction at PC for the memory\n\
10411 address and value which triggered this watchpoint.\n"));
10412   uiout->text ("\n");
10413
10414   /* More than one watchpoint may have been triggered.  */
10415   return PRINT_UNKNOWN;
10416 }
10417
10418 /* Implement the "print_one_detail" breakpoint_ops method for
10419    masked hardware watchpoints.  */
10420
10421 static void
10422 print_one_detail_masked_watchpoint (const struct breakpoint *b,
10423                                     struct ui_out *uiout)
10424 {
10425   struct watchpoint *w = (struct watchpoint *) b;
10426
10427   /* Masked watchpoints have only one location.  */
10428   gdb_assert (b->loc && b->loc->next == NULL);
10429
10430   uiout->text ("\tmask ");
10431   uiout->field_core_addr ("mask", b->loc->gdbarch, w->hw_wp_mask);
10432   uiout->text ("\n");
10433 }
10434
10435 /* Implement the "print_mention" breakpoint_ops method for
10436    masked hardware watchpoints.  */
10437
10438 static void
10439 print_mention_masked_watchpoint (struct breakpoint *b)
10440 {
10441   struct watchpoint *w = (struct watchpoint *) b;
10442   struct ui_out *uiout = current_uiout;
10443   const char *tuple_name;
10444
10445   switch (b->type)
10446     {
10447     case bp_hardware_watchpoint:
10448       uiout->text ("Masked hardware watchpoint ");
10449       tuple_name = "wpt";
10450       break;
10451     case bp_read_watchpoint:
10452       uiout->text ("Masked hardware read watchpoint ");
10453       tuple_name = "hw-rwpt";
10454       break;
10455     case bp_access_watchpoint:
10456       uiout->text ("Masked hardware access (read/write) watchpoint ");
10457       tuple_name = "hw-awpt";
10458       break;
10459     default:
10460       internal_error (__FILE__, __LINE__,
10461                       _("Invalid hardware watchpoint type."));
10462     }
10463
10464   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10465   uiout->field_int ("number", b->number);
10466   uiout->text (": ");
10467   uiout->field_string ("exp", w->exp_string);
10468 }
10469
10470 /* Implement the "print_recreate" breakpoint_ops method for
10471    masked hardware watchpoints.  */
10472
10473 static void
10474 print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
10475 {
10476   struct watchpoint *w = (struct watchpoint *) b;
10477   char tmp[40];
10478
10479   switch (b->type)
10480     {
10481     case bp_hardware_watchpoint:
10482       fprintf_unfiltered (fp, "watch");
10483       break;
10484     case bp_read_watchpoint:
10485       fprintf_unfiltered (fp, "rwatch");
10486       break;
10487     case bp_access_watchpoint:
10488       fprintf_unfiltered (fp, "awatch");
10489       break;
10490     default:
10491       internal_error (__FILE__, __LINE__,
10492                       _("Invalid hardware watchpoint type."));
10493     }
10494
10495   sprintf_vma (tmp, w->hw_wp_mask);
10496   fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
10497   print_recreate_thread (b, fp);
10498 }
10499
10500 /* The breakpoint_ops structure to be used in masked hardware watchpoints.  */
10501
10502 static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
10503
10504 /* Tell whether the given watchpoint is a masked hardware watchpoint.  */
10505
10506 static int
10507 is_masked_watchpoint (const struct breakpoint *b)
10508 {
10509   return b->ops == &masked_watchpoint_breakpoint_ops;
10510 }
10511
10512 /* accessflag:  hw_write:  watch write, 
10513                 hw_read:   watch read, 
10514                 hw_access: watch access (read or write) */
10515 static void
10516 watch_command_1 (const char *arg, int accessflag, int from_tty,
10517                  int just_location, int internal)
10518 {
10519   struct breakpoint *scope_breakpoint = NULL;
10520   const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
10521   struct value *mark, *result;
10522   int saved_bitpos = 0, saved_bitsize = 0;
10523   const char *exp_start = NULL;
10524   const char *exp_end = NULL;
10525   const char *tok, *end_tok;
10526   int toklen = -1;
10527   const char *cond_start = NULL;
10528   const char *cond_end = NULL;
10529   enum bptype bp_type;
10530   int thread = -1;
10531   int pc = 0;
10532   /* Flag to indicate whether we are going to use masks for
10533      the hardware watchpoint.  */
10534   int use_mask = 0;
10535   CORE_ADDR mask = 0;
10536
10537   /* Make sure that we actually have parameters to parse.  */
10538   if (arg != NULL && arg[0] != '\0')
10539     {
10540       const char *value_start;
10541
10542       exp_end = arg + strlen (arg);
10543
10544       /* Look for "parameter value" pairs at the end
10545          of the arguments string.  */
10546       for (tok = exp_end - 1; tok > arg; tok--)
10547         {
10548           /* Skip whitespace at the end of the argument list.  */
10549           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10550             tok--;
10551
10552           /* Find the beginning of the last token.
10553              This is the value of the parameter.  */
10554           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10555             tok--;
10556           value_start = tok + 1;
10557
10558           /* Skip whitespace.  */
10559           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10560             tok--;
10561
10562           end_tok = tok;
10563
10564           /* Find the beginning of the second to last token.
10565              This is the parameter itself.  */
10566           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10567             tok--;
10568           tok++;
10569           toklen = end_tok - tok + 1;
10570
10571           if (toklen == 6 && startswith (tok, "thread"))
10572             {
10573               struct thread_info *thr;
10574               /* At this point we've found a "thread" token, which means
10575                  the user is trying to set a watchpoint that triggers
10576                  only in a specific thread.  */
10577               const char *endp;
10578
10579               if (thread != -1)
10580                 error(_("You can specify only one thread."));
10581
10582               /* Extract the thread ID from the next token.  */
10583               thr = parse_thread_id (value_start, &endp);
10584
10585               /* Check if the user provided a valid thread ID.  */
10586               if (*endp != ' ' && *endp != '\t' && *endp != '\0')
10587                 invalid_thread_id_error (value_start);
10588
10589               thread = thr->global_num;
10590             }
10591           else if (toklen == 4 && startswith (tok, "mask"))
10592             {
10593               /* We've found a "mask" token, which means the user wants to
10594                  create a hardware watchpoint that is going to have the mask
10595                  facility.  */
10596               struct value *mask_value, *mark;
10597
10598               if (use_mask)
10599                 error(_("You can specify only one mask."));
10600
10601               use_mask = just_location = 1;
10602
10603               mark = value_mark ();
10604               mask_value = parse_to_comma_and_eval (&value_start);
10605               mask = value_as_address (mask_value);
10606               value_free_to_mark (mark);
10607             }
10608           else
10609             /* We didn't recognize what we found.  We should stop here.  */
10610             break;
10611
10612           /* Truncate the string and get rid of the "parameter value" pair before
10613              the arguments string is parsed by the parse_exp_1 function.  */
10614           exp_end = tok;
10615         }
10616     }
10617   else
10618     exp_end = arg;
10619
10620   /* Parse the rest of the arguments.  From here on out, everything
10621      is in terms of a newly allocated string instead of the original
10622      ARG.  */
10623   innermost_block.reset ();
10624   std::string expression (arg, exp_end - arg);
10625   exp_start = arg = expression.c_str ();
10626   expression_up exp = parse_exp_1 (&arg, 0, 0, 0);
10627   exp_end = arg;
10628   /* Remove trailing whitespace from the expression before saving it.
10629      This makes the eventual display of the expression string a bit
10630      prettier.  */
10631   while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
10632     --exp_end;
10633
10634   /* Checking if the expression is not constant.  */
10635   if (watchpoint_exp_is_const (exp.get ()))
10636     {
10637       int len;
10638
10639       len = exp_end - exp_start;
10640       while (len > 0 && isspace (exp_start[len - 1]))
10641         len--;
10642       error (_("Cannot watch constant value `%.*s'."), len, exp_start);
10643     }
10644
10645   exp_valid_block = innermost_block.block ();
10646   mark = value_mark ();
10647   struct value *val_as_value = nullptr;
10648   fetch_subexp_value (exp.get (), &pc, &val_as_value, &result, NULL,
10649                       just_location);
10650
10651   if (val_as_value != NULL && just_location)
10652     {
10653       saved_bitpos = value_bitpos (val_as_value);
10654       saved_bitsize = value_bitsize (val_as_value);
10655     }
10656
10657   value_ref_ptr val;
10658   if (just_location)
10659     {
10660       int ret;
10661
10662       exp_valid_block = NULL;
10663       val = release_value (value_addr (result));
10664       value_free_to_mark (mark);
10665
10666       if (use_mask)
10667         {
10668           ret = target_masked_watch_num_registers (value_as_address (val.get ()),
10669                                                    mask);
10670           if (ret == -1)
10671             error (_("This target does not support masked watchpoints."));
10672           else if (ret == -2)
10673             error (_("Invalid mask or memory region."));
10674         }
10675     }
10676   else if (val_as_value != NULL)
10677     val = release_value (val_as_value);
10678
10679   tok = skip_spaces (arg);
10680   end_tok = skip_to_space (tok);
10681
10682   toklen = end_tok - tok;
10683   if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
10684     {
10685       innermost_block.reset ();
10686       tok = cond_start = end_tok + 1;
10687       parse_exp_1 (&tok, 0, 0, 0);
10688
10689       /* The watchpoint expression may not be local, but the condition
10690          may still be.  E.g.: `watch global if local > 0'.  */
10691       cond_exp_valid_block = innermost_block.block ();
10692
10693       cond_end = tok;
10694     }
10695   if (*tok)
10696     error (_("Junk at end of command."));
10697
10698   frame_info *wp_frame = block_innermost_frame (exp_valid_block);
10699
10700   /* Save this because create_internal_breakpoint below invalidates
10701      'wp_frame'.  */
10702   frame_id watchpoint_frame = get_frame_id (wp_frame);
10703
10704   /* If the expression is "local", then set up a "watchpoint scope"
10705      breakpoint at the point where we've left the scope of the watchpoint
10706      expression.  Create the scope breakpoint before the watchpoint, so
10707      that we will encounter it first in bpstat_stop_status.  */
10708   if (exp_valid_block != NULL && wp_frame != NULL)
10709     {
10710       frame_id caller_frame_id = frame_unwind_caller_id (wp_frame);
10711
10712       if (frame_id_p (caller_frame_id))
10713         {
10714           gdbarch *caller_arch = frame_unwind_caller_arch (wp_frame);
10715           CORE_ADDR caller_pc = frame_unwind_caller_pc (wp_frame);
10716
10717           scope_breakpoint
10718             = create_internal_breakpoint (caller_arch, caller_pc,
10719                                           bp_watchpoint_scope,
10720                                           &momentary_breakpoint_ops);
10721
10722           /* create_internal_breakpoint could invalidate WP_FRAME.  */
10723           wp_frame = NULL;
10724
10725           scope_breakpoint->enable_state = bp_enabled;
10726
10727           /* Automatically delete the breakpoint when it hits.  */
10728           scope_breakpoint->disposition = disp_del;
10729
10730           /* Only break in the proper frame (help with recursion).  */
10731           scope_breakpoint->frame_id = caller_frame_id;
10732
10733           /* Set the address at which we will stop.  */
10734           scope_breakpoint->loc->gdbarch = caller_arch;
10735           scope_breakpoint->loc->requested_address = caller_pc;
10736           scope_breakpoint->loc->address
10737             = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
10738                                          scope_breakpoint->loc->requested_address,
10739                                          scope_breakpoint->type);
10740         }
10741     }
10742
10743   /* Now set up the breakpoint.  We create all watchpoints as hardware
10744      watchpoints here even if hardware watchpoints are turned off, a call
10745      to update_watchpoint later in this function will cause the type to
10746      drop back to bp_watchpoint (software watchpoint) if required.  */
10747
10748   if (accessflag == hw_read)
10749     bp_type = bp_read_watchpoint;
10750   else if (accessflag == hw_access)
10751     bp_type = bp_access_watchpoint;
10752   else
10753     bp_type = bp_hardware_watchpoint;
10754
10755   std::unique_ptr<watchpoint> w (new watchpoint ());
10756
10757   if (use_mask)
10758     init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10759                                           &masked_watchpoint_breakpoint_ops);
10760   else
10761     init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10762                                           &watchpoint_breakpoint_ops);
10763   w->thread = thread;
10764   w->disposition = disp_donttouch;
10765   w->pspace = current_program_space;
10766   w->exp = std::move (exp);
10767   w->exp_valid_block = exp_valid_block;
10768   w->cond_exp_valid_block = cond_exp_valid_block;
10769   if (just_location)
10770     {
10771       struct type *t = value_type (val.get ());
10772       CORE_ADDR addr = value_as_address (val.get ());
10773
10774       w->exp_string_reparse
10775         = current_language->la_watch_location_expression (t, addr).release ();
10776
10777       w->exp_string = xstrprintf ("-location %.*s",
10778                                   (int) (exp_end - exp_start), exp_start);
10779     }
10780   else
10781     w->exp_string = savestring (exp_start, exp_end - exp_start);
10782
10783   if (use_mask)
10784     {
10785       w->hw_wp_mask = mask;
10786     }
10787   else
10788     {
10789       w->val = val;
10790       w->val_bitpos = saved_bitpos;
10791       w->val_bitsize = saved_bitsize;
10792       w->val_valid = 1;
10793     }
10794
10795   if (cond_start)
10796     w->cond_string = savestring (cond_start, cond_end - cond_start);
10797   else
10798     w->cond_string = 0;
10799
10800   if (frame_id_p (watchpoint_frame))
10801     {
10802       w->watchpoint_frame = watchpoint_frame;
10803       w->watchpoint_thread = inferior_ptid;
10804     }
10805   else
10806     {
10807       w->watchpoint_frame = null_frame_id;
10808       w->watchpoint_thread = null_ptid;
10809     }
10810
10811   if (scope_breakpoint != NULL)
10812     {
10813       /* The scope breakpoint is related to the watchpoint.  We will
10814          need to act on them together.  */
10815       w->related_breakpoint = scope_breakpoint;
10816       scope_breakpoint->related_breakpoint = w.get ();
10817     }
10818
10819   if (!just_location)
10820     value_free_to_mark (mark);
10821
10822   /* Finally update the new watchpoint.  This creates the locations
10823      that should be inserted.  */
10824   update_watchpoint (w.get (), 1);
10825
10826   install_breakpoint (internal, std::move (w), 1);
10827 }
10828
10829 /* Return count of debug registers needed to watch the given expression.
10830    If the watchpoint cannot be handled in hardware return zero.  */
10831
10832 static int
10833 can_use_hardware_watchpoint (const std::vector<value_ref_ptr> &vals)
10834 {
10835   int found_memory_cnt = 0;
10836
10837   /* Did the user specifically forbid us to use hardware watchpoints? */
10838   if (!can_use_hw_watchpoints)
10839     return 0;
10840
10841   gdb_assert (!vals.empty ());
10842   struct value *head = vals[0].get ();
10843
10844   /* Make sure that the value of the expression depends only upon
10845      memory contents, and values computed from them within GDB.  If we
10846      find any register references or function calls, we can't use a
10847      hardware watchpoint.
10848
10849      The idea here is that evaluating an expression generates a series
10850      of values, one holding the value of every subexpression.  (The
10851      expression a*b+c has five subexpressions: a, b, a*b, c, and
10852      a*b+c.)  GDB's values hold almost enough information to establish
10853      the criteria given above --- they identify memory lvalues,
10854      register lvalues, computed values, etcetera.  So we can evaluate
10855      the expression, and then scan the chain of values that leaves
10856      behind to decide whether we can detect any possible change to the
10857      expression's final value using only hardware watchpoints.
10858
10859      However, I don't think that the values returned by inferior
10860      function calls are special in any way.  So this function may not
10861      notice that an expression involving an inferior function call
10862      can't be watched with hardware watchpoints.  FIXME.  */
10863   for (const value_ref_ptr &iter : vals)
10864     {
10865       struct value *v = iter.get ();
10866
10867       if (VALUE_LVAL (v) == lval_memory)
10868         {
10869           if (v != head && value_lazy (v))
10870             /* A lazy memory lvalue in the chain is one that GDB never
10871                needed to fetch; we either just used its address (e.g.,
10872                `a' in `a.b') or we never needed it at all (e.g., `a'
10873                in `a,b').  This doesn't apply to HEAD; if that is
10874                lazy then it was not readable, but watch it anyway.  */
10875             ;
10876           else
10877             {
10878               /* Ahh, memory we actually used!  Check if we can cover
10879                  it with hardware watchpoints.  */
10880               struct type *vtype = check_typedef (value_type (v));
10881
10882               /* We only watch structs and arrays if user asked for it
10883                  explicitly, never if they just happen to appear in a
10884                  middle of some value chain.  */
10885               if (v == head
10886                   || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
10887                       && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
10888                 {
10889                   CORE_ADDR vaddr = value_address (v);
10890                   int len;
10891                   int num_regs;
10892
10893                   len = (target_exact_watchpoints
10894                          && is_scalar_type_recursive (vtype))?
10895                     1 : TYPE_LENGTH (value_type (v));
10896
10897                   num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
10898                   if (!num_regs)
10899                     return 0;
10900                   else
10901                     found_memory_cnt += num_regs;
10902                 }
10903             }
10904         }
10905       else if (VALUE_LVAL (v) != not_lval
10906                && deprecated_value_modifiable (v) == 0)
10907         return 0;       /* These are values from the history (e.g., $1).  */
10908       else if (VALUE_LVAL (v) == lval_register)
10909         return 0;       /* Cannot watch a register with a HW watchpoint.  */
10910     }
10911
10912   /* The expression itself looks suitable for using a hardware
10913      watchpoint, but give the target machine a chance to reject it.  */
10914   return found_memory_cnt;
10915 }
10916
10917 void
10918 watch_command_wrapper (const char *arg, int from_tty, int internal)
10919 {
10920   watch_command_1 (arg, hw_write, from_tty, 0, internal);
10921 }
10922
10923 /* A helper function that looks for the "-location" argument and then
10924    calls watch_command_1.  */
10925
10926 static void
10927 watch_maybe_just_location (const char *arg, int accessflag, int from_tty)
10928 {
10929   int just_location = 0;
10930
10931   if (arg
10932       && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
10933           || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
10934     {
10935       arg = skip_spaces (arg);
10936       just_location = 1;
10937     }
10938
10939   watch_command_1 (arg, accessflag, from_tty, just_location, 0);
10940 }
10941
10942 static void
10943 watch_command (const char *arg, int from_tty)
10944 {
10945   watch_maybe_just_location (arg, hw_write, from_tty);
10946 }
10947
10948 void
10949 rwatch_command_wrapper (const char *arg, int from_tty, int internal)
10950 {
10951   watch_command_1 (arg, hw_read, from_tty, 0, internal);
10952 }
10953
10954 static void
10955 rwatch_command (const char *arg, int from_tty)
10956 {
10957   watch_maybe_just_location (arg, hw_read, from_tty);
10958 }
10959
10960 void
10961 awatch_command_wrapper (const char *arg, int from_tty, int internal)
10962 {
10963   watch_command_1 (arg, hw_access, from_tty, 0, internal);
10964 }
10965
10966 static void
10967 awatch_command (const char *arg, int from_tty)
10968 {
10969   watch_maybe_just_location (arg, hw_access, from_tty);
10970 }
10971 \f
10972
10973 /* Data for the FSM that manages the until(location)/advance commands
10974    in infcmd.c.  Here because it uses the mechanisms of
10975    breakpoints.  */
10976
10977 struct until_break_fsm
10978 {
10979   /* The base class.  */
10980   struct thread_fsm thread_fsm;
10981
10982   /* The thread that as current when the command was executed.  */
10983   int thread;
10984
10985   /* The breakpoint set at the destination location.  */
10986   struct breakpoint *location_breakpoint;
10987
10988   /* Breakpoint set at the return address in the caller frame.  May be
10989      NULL.  */
10990   struct breakpoint *caller_breakpoint;
10991 };
10992
10993 static void until_break_fsm_clean_up (struct thread_fsm *self,
10994                                       struct thread_info *thread);
10995 static int until_break_fsm_should_stop (struct thread_fsm *self,
10996                                         struct thread_info *thread);
10997 static enum async_reply_reason
10998   until_break_fsm_async_reply_reason (struct thread_fsm *self);
10999
11000 /* until_break_fsm's vtable.  */
11001
11002 static struct thread_fsm_ops until_break_fsm_ops =
11003 {
11004   NULL, /* dtor */
11005   until_break_fsm_clean_up,
11006   until_break_fsm_should_stop,
11007   NULL, /* return_value */
11008   until_break_fsm_async_reply_reason,
11009 };
11010
11011 /* Allocate a new until_break_command_fsm.  */
11012
11013 static struct until_break_fsm *
11014 new_until_break_fsm (struct interp *cmd_interp, int thread,
11015                      breakpoint_up &&location_breakpoint,
11016                      breakpoint_up &&caller_breakpoint)
11017 {
11018   struct until_break_fsm *sm;
11019
11020   sm = XCNEW (struct until_break_fsm);
11021   thread_fsm_ctor (&sm->thread_fsm, &until_break_fsm_ops, cmd_interp);
11022
11023   sm->thread = thread;
11024   sm->location_breakpoint = location_breakpoint.release ();
11025   sm->caller_breakpoint = caller_breakpoint.release ();
11026
11027   return sm;
11028 }
11029
11030 /* Implementation of the 'should_stop' FSM method for the
11031    until(location)/advance commands.  */
11032
11033 static int
11034 until_break_fsm_should_stop (struct thread_fsm *self,
11035                              struct thread_info *tp)
11036 {
11037   struct until_break_fsm *sm = (struct until_break_fsm *) self;
11038
11039   if (bpstat_find_breakpoint (tp->control.stop_bpstat,
11040                               sm->location_breakpoint) != NULL
11041       || (sm->caller_breakpoint != NULL
11042           && bpstat_find_breakpoint (tp->control.stop_bpstat,
11043                                      sm->caller_breakpoint) != NULL))
11044     thread_fsm_set_finished (self);
11045
11046   return 1;
11047 }
11048
11049 /* Implementation of the 'clean_up' FSM method for the
11050    until(location)/advance commands.  */
11051
11052 static void
11053 until_break_fsm_clean_up (struct thread_fsm *self,
11054                           struct thread_info *thread)
11055 {
11056   struct until_break_fsm *sm = (struct until_break_fsm *) self;
11057
11058   /* Clean up our temporary breakpoints.  */
11059   if (sm->location_breakpoint != NULL)
11060     {
11061       delete_breakpoint (sm->location_breakpoint);
11062       sm->location_breakpoint = NULL;
11063     }
11064   if (sm->caller_breakpoint != NULL)
11065     {
11066       delete_breakpoint (sm->caller_breakpoint);
11067       sm->caller_breakpoint = NULL;
11068     }
11069   delete_longjmp_breakpoint (sm->thread);
11070 }
11071
11072 /* Implementation of the 'async_reply_reason' FSM method for the
11073    until(location)/advance commands.  */
11074
11075 static enum async_reply_reason
11076 until_break_fsm_async_reply_reason (struct thread_fsm *self)
11077 {
11078   return EXEC_ASYNC_LOCATION_REACHED;
11079 }
11080
11081 void
11082 until_break_command (const char *arg, int from_tty, int anywhere)
11083 {
11084   struct frame_info *frame;
11085   struct gdbarch *frame_gdbarch;
11086   struct frame_id stack_frame_id;
11087   struct frame_id caller_frame_id;
11088   struct cleanup *old_chain;
11089   int thread;
11090   struct thread_info *tp;
11091   struct until_break_fsm *sm;
11092
11093   clear_proceed_status (0);
11094
11095   /* Set a breakpoint where the user wants it and at return from
11096      this function.  */
11097
11098   event_location_up location = string_to_event_location (&arg, current_language);
11099
11100   std::vector<symtab_and_line> sals
11101     = (last_displayed_sal_is_valid ()
11102        ? decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
11103                         get_last_displayed_symtab (),
11104                         get_last_displayed_line ())
11105        : decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
11106                         NULL, (struct symtab *) NULL, 0));
11107
11108   if (sals.size () != 1)
11109     error (_("Couldn't get information on specified line."));
11110
11111   symtab_and_line &sal = sals[0];
11112
11113   if (*arg)
11114     error (_("Junk at end of arguments."));
11115
11116   resolve_sal_pc (&sal);
11117
11118   tp = inferior_thread ();
11119   thread = tp->global_num;
11120
11121   old_chain = make_cleanup (null_cleanup, NULL);
11122
11123   /* Note linespec handling above invalidates the frame chain.
11124      Installing a breakpoint also invalidates the frame chain (as it
11125      may need to switch threads), so do any frame handling before
11126      that.  */
11127
11128   frame = get_selected_frame (NULL);
11129   frame_gdbarch = get_frame_arch (frame);
11130   stack_frame_id = get_stack_frame_id (frame);
11131   caller_frame_id = frame_unwind_caller_id (frame);
11132
11133   /* Keep within the current frame, or in frames called by the current
11134      one.  */
11135
11136   breakpoint_up caller_breakpoint;
11137   if (frame_id_p (caller_frame_id))
11138     {
11139       struct symtab_and_line sal2;
11140       struct gdbarch *caller_gdbarch;
11141
11142       sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11143       sal2.pc = frame_unwind_caller_pc (frame);
11144       caller_gdbarch = frame_unwind_caller_arch (frame);
11145       caller_breakpoint = set_momentary_breakpoint (caller_gdbarch,
11146                                                     sal2,
11147                                                     caller_frame_id,
11148                                                     bp_until);
11149
11150       set_longjmp_breakpoint (tp, caller_frame_id);
11151       make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
11152     }
11153
11154   /* set_momentary_breakpoint could invalidate FRAME.  */
11155   frame = NULL;
11156
11157   breakpoint_up location_breakpoint;
11158   if (anywhere)
11159     /* If the user told us to continue until a specified location,
11160        we don't specify a frame at which we need to stop.  */
11161     location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11162                                                     null_frame_id, bp_until);
11163   else
11164     /* Otherwise, specify the selected frame, because we want to stop
11165        only at the very same frame.  */
11166     location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11167                                                     stack_frame_id, bp_until);
11168
11169   sm = new_until_break_fsm (command_interp (), tp->global_num,
11170                             std::move (location_breakpoint),
11171                             std::move (caller_breakpoint));
11172   tp->thread_fsm = &sm->thread_fsm;
11173
11174   discard_cleanups (old_chain);
11175
11176   proceed (-1, GDB_SIGNAL_DEFAULT);
11177 }
11178
11179 /* This function attempts to parse an optional "if <cond>" clause
11180    from the arg string.  If one is not found, it returns NULL.
11181
11182    Else, it returns a pointer to the condition string.  (It does not
11183    attempt to evaluate the string against a particular block.)  And,
11184    it updates arg to point to the first character following the parsed
11185    if clause in the arg string.  */
11186
11187 const char *
11188 ep_parse_optional_if_clause (const char **arg)
11189 {
11190   const char *cond_string;
11191
11192   if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
11193     return NULL;
11194
11195   /* Skip the "if" keyword.  */
11196   (*arg) += 2;
11197
11198   /* Skip any extra leading whitespace, and record the start of the
11199      condition string.  */
11200   *arg = skip_spaces (*arg);
11201   cond_string = *arg;
11202
11203   /* Assume that the condition occupies the remainder of the arg
11204      string.  */
11205   (*arg) += strlen (cond_string);
11206
11207   return cond_string;
11208 }
11209
11210 /* Commands to deal with catching events, such as signals, exceptions,
11211    process start/exit, etc.  */
11212
11213 typedef enum
11214 {
11215   catch_fork_temporary, catch_vfork_temporary,
11216   catch_fork_permanent, catch_vfork_permanent
11217 }
11218 catch_fork_kind;
11219
11220 static void
11221 catch_fork_command_1 (const char *arg, int from_tty,
11222                       struct cmd_list_element *command)
11223 {
11224   struct gdbarch *gdbarch = get_current_arch ();
11225   const char *cond_string = NULL;
11226   catch_fork_kind fork_kind;
11227   int tempflag;
11228
11229   fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11230   tempflag = (fork_kind == catch_fork_temporary
11231               || fork_kind == catch_vfork_temporary);
11232
11233   if (!arg)
11234     arg = "";
11235   arg = skip_spaces (arg);
11236
11237   /* The allowed syntax is:
11238      catch [v]fork
11239      catch [v]fork if <cond>
11240
11241      First, check if there's an if clause.  */
11242   cond_string = ep_parse_optional_if_clause (&arg);
11243
11244   if ((*arg != '\0') && !isspace (*arg))
11245     error (_("Junk at end of arguments."));
11246
11247   /* If this target supports it, create a fork or vfork catchpoint
11248      and enable reporting of such events.  */
11249   switch (fork_kind)
11250     {
11251     case catch_fork_temporary:
11252     case catch_fork_permanent:
11253       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11254                                           &catch_fork_breakpoint_ops);
11255       break;
11256     case catch_vfork_temporary:
11257     case catch_vfork_permanent:
11258       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11259                                           &catch_vfork_breakpoint_ops);
11260       break;
11261     default:
11262       error (_("unsupported or unknown fork kind; cannot catch it"));
11263       break;
11264     }
11265 }
11266
11267 static void
11268 catch_exec_command_1 (const char *arg, int from_tty,
11269                       struct cmd_list_element *command)
11270 {
11271   struct gdbarch *gdbarch = get_current_arch ();
11272   int tempflag;
11273   const char *cond_string = NULL;
11274
11275   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11276
11277   if (!arg)
11278     arg = "";
11279   arg = skip_spaces (arg);
11280
11281   /* The allowed syntax is:
11282      catch exec
11283      catch exec if <cond>
11284
11285      First, check if there's an if clause.  */
11286   cond_string = ep_parse_optional_if_clause (&arg);
11287
11288   if ((*arg != '\0') && !isspace (*arg))
11289     error (_("Junk at end of arguments."));
11290
11291   std::unique_ptr<exec_catchpoint> c (new exec_catchpoint ());
11292   init_catchpoint (c.get (), gdbarch, tempflag, cond_string,
11293                    &catch_exec_breakpoint_ops);
11294   c->exec_pathname = NULL;
11295
11296   install_breakpoint (0, std::move (c), 1);
11297 }
11298
11299 void
11300 init_ada_exception_breakpoint (struct breakpoint *b,
11301                                struct gdbarch *gdbarch,
11302                                struct symtab_and_line sal,
11303                                const char *addr_string,
11304                                const struct breakpoint_ops *ops,
11305                                int tempflag,
11306                                int enabled,
11307                                int from_tty)
11308 {
11309   if (from_tty)
11310     {
11311       struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11312       if (!loc_gdbarch)
11313         loc_gdbarch = gdbarch;
11314
11315       describe_other_breakpoints (loc_gdbarch,
11316                                   sal.pspace, sal.pc, sal.section, -1);
11317       /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11318          version for exception catchpoints, because two catchpoints
11319          used for different exception names will use the same address.
11320          In this case, a "breakpoint ... also set at..." warning is
11321          unproductive.  Besides, the warning phrasing is also a bit
11322          inappropriate, we should use the word catchpoint, and tell
11323          the user what type of catchpoint it is.  The above is good
11324          enough for now, though.  */
11325     }
11326
11327   init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
11328
11329   b->enable_state = enabled ? bp_enabled : bp_disabled;
11330   b->disposition = tempflag ? disp_del : disp_donttouch;
11331   b->location = string_to_event_location (&addr_string,
11332                                           language_def (language_ada));
11333   b->language = language_ada;
11334 }
11335
11336 static void
11337 catch_command (const char *arg, int from_tty)
11338 {
11339   error (_("Catch requires an event name."));
11340 }
11341 \f
11342
11343 static void
11344 tcatch_command (const char *arg, int from_tty)
11345 {
11346   error (_("Catch requires an event name."));
11347 }
11348
11349 /* Compare two breakpoints and return a strcmp-like result.  */
11350
11351 static int
11352 compare_breakpoints (const breakpoint *a, const breakpoint *b)
11353 {
11354   uintptr_t ua = (uintptr_t) a;
11355   uintptr_t ub = (uintptr_t) b;
11356
11357   if (a->number < b->number)
11358     return -1;
11359   else if (a->number > b->number)
11360     return 1;
11361
11362   /* Now sort by address, in case we see, e..g, two breakpoints with
11363      the number 0.  */
11364   if (ua < ub)
11365     return -1;
11366   return ua > ub ? 1 : 0;
11367 }
11368
11369 /* Delete breakpoints by address or line.  */
11370
11371 static void
11372 clear_command (const char *arg, int from_tty)
11373 {
11374   struct breakpoint *b;
11375   int default_match;
11376
11377   std::vector<symtab_and_line> decoded_sals;
11378   symtab_and_line last_sal;
11379   gdb::array_view<symtab_and_line> sals;
11380   if (arg)
11381     {
11382       decoded_sals
11383         = decode_line_with_current_source (arg,
11384                                            (DECODE_LINE_FUNFIRSTLINE
11385                                             | DECODE_LINE_LIST_MODE));
11386       default_match = 0;
11387       sals = decoded_sals;
11388     }
11389   else
11390     {
11391       /* Set sal's line, symtab, pc, and pspace to the values
11392          corresponding to the last call to print_frame_info.  If the
11393          codepoint is not valid, this will set all the fields to 0.  */
11394       last_sal = get_last_displayed_sal ();
11395       if (last_sal.symtab == 0)
11396         error (_("No source file specified."));
11397
11398       default_match = 1;
11399       sals = last_sal;
11400     }
11401
11402   /* We don't call resolve_sal_pc here.  That's not as bad as it
11403      seems, because all existing breakpoints typically have both
11404      file/line and pc set.  So, if clear is given file/line, we can
11405      match this to existing breakpoint without obtaining pc at all.
11406
11407      We only support clearing given the address explicitly 
11408      present in breakpoint table.  Say, we've set breakpoint 
11409      at file:line.  There were several PC values for that file:line,
11410      due to optimization, all in one block.
11411
11412      We've picked one PC value.  If "clear" is issued with another
11413      PC corresponding to the same file:line, the breakpoint won't
11414      be cleared.  We probably can still clear the breakpoint, but 
11415      since the other PC value is never presented to user, user
11416      can only find it by guessing, and it does not seem important
11417      to support that.  */
11418
11419   /* For each line spec given, delete bps which correspond to it.  Do
11420      it in two passes, solely to preserve the current behavior that
11421      from_tty is forced true if we delete more than one
11422      breakpoint.  */
11423
11424   std::vector<struct breakpoint *> found;
11425   for (const auto &sal : sals)
11426     {
11427       const char *sal_fullname;
11428
11429       /* If exact pc given, clear bpts at that pc.
11430          If line given (pc == 0), clear all bpts on specified line.
11431          If defaulting, clear all bpts on default line
11432          or at default pc.
11433
11434          defaulting    sal.pc != 0    tests to do
11435
11436          0              1             pc
11437          1              1             pc _and_ line
11438          0              0             line
11439          1              0             <can't happen> */
11440
11441       sal_fullname = (sal.symtab == NULL
11442                       ? NULL : symtab_to_fullname (sal.symtab));
11443
11444       /* Find all matching breakpoints and add them to 'found'.  */
11445       ALL_BREAKPOINTS (b)
11446         {
11447           int match = 0;
11448           /* Are we going to delete b?  */
11449           if (b->type != bp_none && !is_watchpoint (b))
11450             {
11451               struct bp_location *loc = b->loc;
11452               for (; loc; loc = loc->next)
11453                 {
11454                   /* If the user specified file:line, don't allow a PC
11455                      match.  This matches historical gdb behavior.  */
11456                   int pc_match = (!sal.explicit_line
11457                                   && sal.pc
11458                                   && (loc->pspace == sal.pspace)
11459                                   && (loc->address == sal.pc)
11460                                   && (!section_is_overlay (loc->section)
11461                                       || loc->section == sal.section));
11462                   int line_match = 0;
11463
11464                   if ((default_match || sal.explicit_line)
11465                       && loc->symtab != NULL
11466                       && sal_fullname != NULL
11467                       && sal.pspace == loc->pspace
11468                       && loc->line_number == sal.line
11469                       && filename_cmp (symtab_to_fullname (loc->symtab),
11470                                        sal_fullname) == 0)
11471                     line_match = 1;
11472
11473                   if (pc_match || line_match)
11474                     {
11475                       match = 1;
11476                       break;
11477                     }
11478                 }
11479             }
11480
11481           if (match)
11482             found.push_back (b);
11483         }
11484     }
11485
11486   /* Now go thru the 'found' chain and delete them.  */
11487   if (found.empty ())
11488     {
11489       if (arg)
11490         error (_("No breakpoint at %s."), arg);
11491       else
11492         error (_("No breakpoint at this line."));
11493     }
11494
11495   /* Remove duplicates from the vec.  */
11496   std::sort (found.begin (), found.end (),
11497              [] (const breakpoint *a, const breakpoint *b)
11498              {
11499                return compare_breakpoints (a, b) < 0;
11500              });
11501   found.erase (std::unique (found.begin (), found.end (),
11502                             [] (const breakpoint *a, const breakpoint *b)
11503                             {
11504                               return compare_breakpoints (a, b) == 0;
11505                             }),
11506                found.end ());
11507
11508   if (found.size () > 1)
11509     from_tty = 1;       /* Always report if deleted more than one.  */
11510   if (from_tty)
11511     {
11512       if (found.size () == 1)
11513         printf_unfiltered (_("Deleted breakpoint "));
11514       else
11515         printf_unfiltered (_("Deleted breakpoints "));
11516     }
11517
11518   for (breakpoint *iter : found)
11519     {
11520       if (from_tty)
11521         printf_unfiltered ("%d ", iter->number);
11522       delete_breakpoint (iter);
11523     }
11524   if (from_tty)
11525     putchar_unfiltered ('\n');
11526 }
11527 \f
11528 /* Delete breakpoint in BS if they are `delete' breakpoints and
11529    all breakpoints that are marked for deletion, whether hit or not.
11530    This is called after any breakpoint is hit, or after errors.  */
11531
11532 void
11533 breakpoint_auto_delete (bpstat bs)
11534 {
11535   struct breakpoint *b, *b_tmp;
11536
11537   for (; bs; bs = bs->next)
11538     if (bs->breakpoint_at
11539         && bs->breakpoint_at->disposition == disp_del
11540         && bs->stop)
11541       delete_breakpoint (bs->breakpoint_at);
11542
11543   ALL_BREAKPOINTS_SAFE (b, b_tmp)
11544   {
11545     if (b->disposition == disp_del_at_next_stop)
11546       delete_breakpoint (b);
11547   }
11548 }
11549
11550 /* A comparison function for bp_location AP and BP being interfaced to
11551    qsort.  Sort elements primarily by their ADDRESS (no matter what
11552    does breakpoint_address_is_meaningful say for its OWNER),
11553    secondarily by ordering first permanent elements and
11554    terciarily just ensuring the array is sorted stable way despite
11555    qsort being an unstable algorithm.  */
11556
11557 static int
11558 bp_locations_compare (const void *ap, const void *bp)
11559 {
11560   const struct bp_location *a = *(const struct bp_location **) ap;
11561   const struct bp_location *b = *(const struct bp_location **) bp;
11562
11563   if (a->address != b->address)
11564     return (a->address > b->address) - (a->address < b->address);
11565
11566   /* Sort locations at the same address by their pspace number, keeping
11567      locations of the same inferior (in a multi-inferior environment)
11568      grouped.  */
11569
11570   if (a->pspace->num != b->pspace->num)
11571     return ((a->pspace->num > b->pspace->num)
11572             - (a->pspace->num < b->pspace->num));
11573
11574   /* Sort permanent breakpoints first.  */
11575   if (a->permanent != b->permanent)
11576     return (a->permanent < b->permanent) - (a->permanent > b->permanent);
11577
11578   /* Make the internal GDB representation stable across GDB runs
11579      where A and B memory inside GDB can differ.  Breakpoint locations of
11580      the same type at the same address can be sorted in arbitrary order.  */
11581
11582   if (a->owner->number != b->owner->number)
11583     return ((a->owner->number > b->owner->number)
11584             - (a->owner->number < b->owner->number));
11585
11586   return (a > b) - (a < b);
11587 }
11588
11589 /* Set bp_locations_placed_address_before_address_max and
11590    bp_locations_shadow_len_after_address_max according to the current
11591    content of the bp_locations array.  */
11592
11593 static void
11594 bp_locations_target_extensions_update (void)
11595 {
11596   struct bp_location *bl, **blp_tmp;
11597
11598   bp_locations_placed_address_before_address_max = 0;
11599   bp_locations_shadow_len_after_address_max = 0;
11600
11601   ALL_BP_LOCATIONS (bl, blp_tmp)
11602     {
11603       CORE_ADDR start, end, addr;
11604
11605       if (!bp_location_has_shadow (bl))
11606         continue;
11607
11608       start = bl->target_info.placed_address;
11609       end = start + bl->target_info.shadow_len;
11610
11611       gdb_assert (bl->address >= start);
11612       addr = bl->address - start;
11613       if (addr > bp_locations_placed_address_before_address_max)
11614         bp_locations_placed_address_before_address_max = addr;
11615
11616       /* Zero SHADOW_LEN would not pass bp_location_has_shadow.  */
11617
11618       gdb_assert (bl->address < end);
11619       addr = end - bl->address;
11620       if (addr > bp_locations_shadow_len_after_address_max)
11621         bp_locations_shadow_len_after_address_max = addr;
11622     }
11623 }
11624
11625 /* Download tracepoint locations if they haven't been.  */
11626
11627 static void
11628 download_tracepoint_locations (void)
11629 {
11630   struct breakpoint *b;
11631   enum tribool can_download_tracepoint = TRIBOOL_UNKNOWN;
11632
11633   scoped_restore_current_pspace_and_thread restore_pspace_thread;
11634
11635   ALL_TRACEPOINTS (b)
11636     {
11637       struct bp_location *bl;
11638       struct tracepoint *t;
11639       int bp_location_downloaded = 0;
11640
11641       if ((b->type == bp_fast_tracepoint
11642            ? !may_insert_fast_tracepoints
11643            : !may_insert_tracepoints))
11644         continue;
11645
11646       if (can_download_tracepoint == TRIBOOL_UNKNOWN)
11647         {
11648           if (target_can_download_tracepoint ())
11649             can_download_tracepoint = TRIBOOL_TRUE;
11650           else
11651             can_download_tracepoint = TRIBOOL_FALSE;
11652         }
11653
11654       if (can_download_tracepoint == TRIBOOL_FALSE)
11655         break;
11656
11657       for (bl = b->loc; bl; bl = bl->next)
11658         {
11659           /* In tracepoint, locations are _never_ duplicated, so
11660              should_be_inserted is equivalent to
11661              unduplicated_should_be_inserted.  */
11662           if (!should_be_inserted (bl) || bl->inserted)
11663             continue;
11664
11665           switch_to_program_space_and_thread (bl->pspace);
11666
11667           target_download_tracepoint (bl);
11668
11669           bl->inserted = 1;
11670           bp_location_downloaded = 1;
11671         }
11672       t = (struct tracepoint *) b;
11673       t->number_on_target = b->number;
11674       if (bp_location_downloaded)
11675         gdb::observers::breakpoint_modified.notify (b);
11676     }
11677 }
11678
11679 /* Swap the insertion/duplication state between two locations.  */
11680
11681 static void
11682 swap_insertion (struct bp_location *left, struct bp_location *right)
11683 {
11684   const int left_inserted = left->inserted;
11685   const int left_duplicate = left->duplicate;
11686   const int left_needs_update = left->needs_update;
11687   const struct bp_target_info left_target_info = left->target_info;
11688
11689   /* Locations of tracepoints can never be duplicated.  */
11690   if (is_tracepoint (left->owner))
11691     gdb_assert (!left->duplicate);
11692   if (is_tracepoint (right->owner))
11693     gdb_assert (!right->duplicate);
11694
11695   left->inserted = right->inserted;
11696   left->duplicate = right->duplicate;
11697   left->needs_update = right->needs_update;
11698   left->target_info = right->target_info;
11699   right->inserted = left_inserted;
11700   right->duplicate = left_duplicate;
11701   right->needs_update = left_needs_update;
11702   right->target_info = left_target_info;
11703 }
11704
11705 /* Force the re-insertion of the locations at ADDRESS.  This is called
11706    once a new/deleted/modified duplicate location is found and we are evaluating
11707    conditions on the target's side.  Such conditions need to be updated on
11708    the target.  */
11709
11710 static void
11711 force_breakpoint_reinsertion (struct bp_location *bl)
11712 {
11713   struct bp_location **locp = NULL, **loc2p;
11714   struct bp_location *loc;
11715   CORE_ADDR address = 0;
11716   int pspace_num;
11717
11718   address = bl->address;
11719   pspace_num = bl->pspace->num;
11720
11721   /* This is only meaningful if the target is
11722      evaluating conditions and if the user has
11723      opted for condition evaluation on the target's
11724      side.  */
11725   if (gdb_evaluates_breakpoint_condition_p ()
11726       || !target_supports_evaluation_of_breakpoint_conditions ())
11727     return;
11728
11729   /* Flag all breakpoint locations with this address and
11730      the same program space as the location
11731      as "its condition has changed".  We need to
11732      update the conditions on the target's side.  */
11733   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
11734     {
11735       loc = *loc2p;
11736
11737       if (!is_breakpoint (loc->owner)
11738           || pspace_num != loc->pspace->num)
11739         continue;
11740
11741       /* Flag the location appropriately.  We use a different state to
11742          let everyone know that we already updated the set of locations
11743          with addr bl->address and program space bl->pspace.  This is so
11744          we don't have to keep calling these functions just to mark locations
11745          that have already been marked.  */
11746       loc->condition_changed = condition_updated;
11747
11748       /* Free the agent expression bytecode as well.  We will compute
11749          it later on.  */
11750       loc->cond_bytecode.reset ();
11751     }
11752 }
11753 /* Called whether new breakpoints are created, or existing breakpoints
11754    deleted, to update the global location list and recompute which
11755    locations are duplicate of which.
11756
11757    The INSERT_MODE flag determines whether locations may not, may, or
11758    shall be inserted now.  See 'enum ugll_insert_mode' for more
11759    info.  */
11760
11761 static void
11762 update_global_location_list (enum ugll_insert_mode insert_mode)
11763 {
11764   struct breakpoint *b;
11765   struct bp_location **locp, *loc;
11766   /* Last breakpoint location address that was marked for update.  */
11767   CORE_ADDR last_addr = 0;
11768   /* Last breakpoint location program space that was marked for update.  */
11769   int last_pspace_num = -1;
11770
11771   /* Used in the duplicates detection below.  When iterating over all
11772      bp_locations, points to the first bp_location of a given address.
11773      Breakpoints and watchpoints of different types are never
11774      duplicates of each other.  Keep one pointer for each type of
11775      breakpoint/watchpoint, so we only need to loop over all locations
11776      once.  */
11777   struct bp_location *bp_loc_first;  /* breakpoint */
11778   struct bp_location *wp_loc_first;  /* hardware watchpoint */
11779   struct bp_location *awp_loc_first; /* access watchpoint */
11780   struct bp_location *rwp_loc_first; /* read watchpoint */
11781
11782   /* Saved former bp_locations array which we compare against the newly
11783      built bp_locations from the current state of ALL_BREAKPOINTS.  */
11784   struct bp_location **old_locp;
11785   unsigned old_locations_count;
11786   gdb::unique_xmalloc_ptr<struct bp_location *> old_locations (bp_locations);
11787
11788   old_locations_count = bp_locations_count;
11789   bp_locations = NULL;
11790   bp_locations_count = 0;
11791
11792   ALL_BREAKPOINTS (b)
11793     for (loc = b->loc; loc; loc = loc->next)
11794       bp_locations_count++;
11795
11796   bp_locations = XNEWVEC (struct bp_location *, bp_locations_count);
11797   locp = bp_locations;
11798   ALL_BREAKPOINTS (b)
11799     for (loc = b->loc; loc; loc = loc->next)
11800       *locp++ = loc;
11801   qsort (bp_locations, bp_locations_count, sizeof (*bp_locations),
11802          bp_locations_compare);
11803
11804   bp_locations_target_extensions_update ();
11805
11806   /* Identify bp_location instances that are no longer present in the
11807      new list, and therefore should be freed.  Note that it's not
11808      necessary that those locations should be removed from inferior --
11809      if there's another location at the same address (previously
11810      marked as duplicate), we don't need to remove/insert the
11811      location.
11812      
11813      LOCP is kept in sync with OLD_LOCP, each pointing to the current
11814      and former bp_location array state respectively.  */
11815
11816   locp = bp_locations;
11817   for (old_locp = old_locations.get ();
11818        old_locp < old_locations.get () + old_locations_count;
11819        old_locp++)
11820     {
11821       struct bp_location *old_loc = *old_locp;
11822       struct bp_location **loc2p;
11823
11824       /* Tells if 'old_loc' is found among the new locations.  If
11825          not, we have to free it.  */
11826       int found_object = 0;
11827       /* Tells if the location should remain inserted in the target.  */
11828       int keep_in_target = 0;
11829       int removed = 0;
11830
11831       /* Skip LOCP entries which will definitely never be needed.
11832          Stop either at or being the one matching OLD_LOC.  */
11833       while (locp < bp_locations + bp_locations_count
11834              && (*locp)->address < old_loc->address)
11835         locp++;
11836
11837       for (loc2p = locp;
11838            (loc2p < bp_locations + bp_locations_count
11839             && (*loc2p)->address == old_loc->address);
11840            loc2p++)
11841         {
11842           /* Check if this is a new/duplicated location or a duplicated
11843              location that had its condition modified.  If so, we want to send
11844              its condition to the target if evaluation of conditions is taking
11845              place there.  */
11846           if ((*loc2p)->condition_changed == condition_modified
11847               && (last_addr != old_loc->address
11848                   || last_pspace_num != old_loc->pspace->num))
11849             {
11850               force_breakpoint_reinsertion (*loc2p);
11851               last_pspace_num = old_loc->pspace->num;
11852             }
11853
11854           if (*loc2p == old_loc)
11855             found_object = 1;
11856         }
11857
11858       /* We have already handled this address, update it so that we don't
11859          have to go through updates again.  */
11860       last_addr = old_loc->address;
11861
11862       /* Target-side condition evaluation: Handle deleted locations.  */
11863       if (!found_object)
11864         force_breakpoint_reinsertion (old_loc);
11865
11866       /* If this location is no longer present, and inserted, look if
11867          there's maybe a new location at the same address.  If so,
11868          mark that one inserted, and don't remove this one.  This is
11869          needed so that we don't have a time window where a breakpoint
11870          at certain location is not inserted.  */
11871
11872       if (old_loc->inserted)
11873         {
11874           /* If the location is inserted now, we might have to remove
11875              it.  */
11876
11877           if (found_object && should_be_inserted (old_loc))
11878             {
11879               /* The location is still present in the location list,
11880                  and still should be inserted.  Don't do anything.  */
11881               keep_in_target = 1;
11882             }
11883           else
11884             {
11885               /* This location still exists, but it won't be kept in the
11886                  target since it may have been disabled.  We proceed to
11887                  remove its target-side condition.  */
11888
11889               /* The location is either no longer present, or got
11890                  disabled.  See if there's another location at the
11891                  same address, in which case we don't need to remove
11892                  this one from the target.  */
11893
11894               /* OLD_LOC comes from existing struct breakpoint.  */
11895               if (breakpoint_address_is_meaningful (old_loc->owner))
11896                 {
11897                   for (loc2p = locp;
11898                        (loc2p < bp_locations + bp_locations_count
11899                         && (*loc2p)->address == old_loc->address);
11900                        loc2p++)
11901                     {
11902                       struct bp_location *loc2 = *loc2p;
11903
11904                       if (breakpoint_locations_match (loc2, old_loc))
11905                         {
11906                           /* Read watchpoint locations are switched to
11907                              access watchpoints, if the former are not
11908                              supported, but the latter are.  */
11909                           if (is_hardware_watchpoint (old_loc->owner))
11910                             {
11911                               gdb_assert (is_hardware_watchpoint (loc2->owner));
11912                               loc2->watchpoint_type = old_loc->watchpoint_type;
11913                             }
11914
11915                           /* loc2 is a duplicated location. We need to check
11916                              if it should be inserted in case it will be
11917                              unduplicated.  */
11918                           if (loc2 != old_loc
11919                               && unduplicated_should_be_inserted (loc2))
11920                             {
11921                               swap_insertion (old_loc, loc2);
11922                               keep_in_target = 1;
11923                               break;
11924                             }
11925                         }
11926                     }
11927                 }
11928             }
11929
11930           if (!keep_in_target)
11931             {
11932               if (remove_breakpoint (old_loc))
11933                 {
11934                   /* This is just about all we can do.  We could keep
11935                      this location on the global list, and try to
11936                      remove it next time, but there's no particular
11937                      reason why we will succeed next time.
11938                      
11939                      Note that at this point, old_loc->owner is still
11940                      valid, as delete_breakpoint frees the breakpoint
11941                      only after calling us.  */
11942                   printf_filtered (_("warning: Error removing "
11943                                      "breakpoint %d\n"), 
11944                                    old_loc->owner->number);
11945                 }
11946               removed = 1;
11947             }
11948         }
11949
11950       if (!found_object)
11951         {
11952           if (removed && target_is_non_stop_p ()
11953               && need_moribund_for_location_type (old_loc))
11954             {
11955               /* This location was removed from the target.  In
11956                  non-stop mode, a race condition is possible where
11957                  we've removed a breakpoint, but stop events for that
11958                  breakpoint are already queued and will arrive later.
11959                  We apply an heuristic to be able to distinguish such
11960                  SIGTRAPs from other random SIGTRAPs: we keep this
11961                  breakpoint location for a bit, and will retire it
11962                  after we see some number of events.  The theory here
11963                  is that reporting of events should, "on the average",
11964                  be fair, so after a while we'll see events from all
11965                  threads that have anything of interest, and no longer
11966                  need to keep this breakpoint location around.  We
11967                  don't hold locations forever so to reduce chances of
11968                  mistaking a non-breakpoint SIGTRAP for a breakpoint
11969                  SIGTRAP.
11970
11971                  The heuristic failing can be disastrous on
11972                  decr_pc_after_break targets.
11973
11974                  On decr_pc_after_break targets, like e.g., x86-linux,
11975                  if we fail to recognize a late breakpoint SIGTRAP,
11976                  because events_till_retirement has reached 0 too
11977                  soon, we'll fail to do the PC adjustment, and report
11978                  a random SIGTRAP to the user.  When the user resumes
11979                  the inferior, it will most likely immediately crash
11980                  with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
11981                  corrupted, because of being resumed e.g., in the
11982                  middle of a multi-byte instruction, or skipped a
11983                  one-byte instruction.  This was actually seen happen
11984                  on native x86-linux, and should be less rare on
11985                  targets that do not support new thread events, like
11986                  remote, due to the heuristic depending on
11987                  thread_count.
11988
11989                  Mistaking a random SIGTRAP for a breakpoint trap
11990                  causes similar symptoms (PC adjustment applied when
11991                  it shouldn't), but then again, playing with SIGTRAPs
11992                  behind the debugger's back is asking for trouble.
11993
11994                  Since hardware watchpoint traps are always
11995                  distinguishable from other traps, so we don't need to
11996                  apply keep hardware watchpoint moribund locations
11997                  around.  We simply always ignore hardware watchpoint
11998                  traps we can no longer explain.  */
11999
12000               old_loc->events_till_retirement = 3 * (thread_count () + 1);
12001               old_loc->owner = NULL;
12002
12003               moribund_locations.push_back (old_loc);
12004             }
12005           else
12006             {
12007               old_loc->owner = NULL;
12008               decref_bp_location (&old_loc);
12009             }
12010         }
12011     }
12012
12013   /* Rescan breakpoints at the same address and section, marking the
12014      first one as "first" and any others as "duplicates".  This is so
12015      that the bpt instruction is only inserted once.  If we have a
12016      permanent breakpoint at the same place as BPT, make that one the
12017      official one, and the rest as duplicates.  Permanent breakpoints
12018      are sorted first for the same address.
12019
12020      Do the same for hardware watchpoints, but also considering the
12021      watchpoint's type (regular/access/read) and length.  */
12022
12023   bp_loc_first = NULL;
12024   wp_loc_first = NULL;
12025   awp_loc_first = NULL;
12026   rwp_loc_first = NULL;
12027   ALL_BP_LOCATIONS (loc, locp)
12028     {
12029       /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12030          non-NULL.  */
12031       struct bp_location **loc_first_p;
12032       b = loc->owner;
12033
12034       if (!unduplicated_should_be_inserted (loc)
12035           || !breakpoint_address_is_meaningful (b)
12036           /* Don't detect duplicate for tracepoint locations because they are
12037            never duplicated.  See the comments in field `duplicate' of
12038            `struct bp_location'.  */
12039           || is_tracepoint (b))
12040         {
12041           /* Clear the condition modification flag.  */
12042           loc->condition_changed = condition_unchanged;
12043           continue;
12044         }
12045
12046       if (b->type == bp_hardware_watchpoint)
12047         loc_first_p = &wp_loc_first;
12048       else if (b->type == bp_read_watchpoint)
12049         loc_first_p = &rwp_loc_first;
12050       else if (b->type == bp_access_watchpoint)
12051         loc_first_p = &awp_loc_first;
12052       else
12053         loc_first_p = &bp_loc_first;
12054
12055       if (*loc_first_p == NULL
12056           || (overlay_debugging && loc->section != (*loc_first_p)->section)
12057           || !breakpoint_locations_match (loc, *loc_first_p))
12058         {
12059           *loc_first_p = loc;
12060           loc->duplicate = 0;
12061
12062           if (is_breakpoint (loc->owner) && loc->condition_changed)
12063             {
12064               loc->needs_update = 1;
12065               /* Clear the condition modification flag.  */
12066               loc->condition_changed = condition_unchanged;
12067             }
12068           continue;
12069         }
12070
12071
12072       /* This and the above ensure the invariant that the first location
12073          is not duplicated, and is the inserted one.
12074          All following are marked as duplicated, and are not inserted.  */
12075       if (loc->inserted)
12076         swap_insertion (loc, *loc_first_p);
12077       loc->duplicate = 1;
12078
12079       /* Clear the condition modification flag.  */
12080       loc->condition_changed = condition_unchanged;
12081     }
12082
12083   if (insert_mode == UGLL_INSERT || breakpoints_should_be_inserted_now ())
12084     {
12085       if (insert_mode != UGLL_DONT_INSERT)
12086         insert_breakpoint_locations ();
12087       else
12088         {
12089           /* Even though the caller told us to not insert new
12090              locations, we may still need to update conditions on the
12091              target's side of breakpoints that were already inserted
12092              if the target is evaluating breakpoint conditions.  We
12093              only update conditions for locations that are marked
12094              "needs_update".  */
12095           update_inserted_breakpoint_locations ();
12096         }
12097     }
12098
12099   if (insert_mode != UGLL_DONT_INSERT)
12100     download_tracepoint_locations ();
12101 }
12102
12103 void
12104 breakpoint_retire_moribund (void)
12105 {
12106   for (int ix = 0; ix < moribund_locations.size (); ++ix)
12107     {
12108       struct bp_location *loc = moribund_locations[ix];
12109       if (--(loc->events_till_retirement) == 0)
12110         {
12111           decref_bp_location (&loc);
12112           unordered_remove (moribund_locations, ix);
12113           --ix;
12114         }
12115     }
12116 }
12117
12118 static void
12119 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode)
12120 {
12121
12122   TRY
12123     {
12124       update_global_location_list (insert_mode);
12125     }
12126   CATCH (e, RETURN_MASK_ERROR)
12127     {
12128     }
12129   END_CATCH
12130 }
12131
12132 /* Clear BKP from a BPS.  */
12133
12134 static void
12135 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12136 {
12137   bpstat bs;
12138
12139   for (bs = bps; bs; bs = bs->next)
12140     if (bs->breakpoint_at == bpt)
12141       {
12142         bs->breakpoint_at = NULL;
12143         bs->old_val = NULL;
12144         /* bs->commands will be freed later.  */
12145       }
12146 }
12147
12148 /* Callback for iterate_over_threads.  */
12149 static int
12150 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12151 {
12152   struct breakpoint *bpt = (struct breakpoint *) data;
12153
12154   bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12155   return 0;
12156 }
12157
12158 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12159    callbacks.  */
12160
12161 static void
12162 say_where (struct breakpoint *b)
12163 {
12164   struct value_print_options opts;
12165
12166   get_user_print_options (&opts);
12167
12168   /* i18n: cagney/2005-02-11: Below needs to be merged into a
12169      single string.  */
12170   if (b->loc == NULL)
12171     {
12172       /* For pending locations, the output differs slightly based
12173          on b->extra_string.  If this is non-NULL, it contains either
12174          a condition or dprintf arguments.  */
12175       if (b->extra_string == NULL)
12176         {
12177           printf_filtered (_(" (%s) pending."),
12178                            event_location_to_string (b->location.get ()));
12179         }
12180       else if (b->type == bp_dprintf)
12181         {
12182           printf_filtered (_(" (%s,%s) pending."),
12183                            event_location_to_string (b->location.get ()),
12184                            b->extra_string);
12185         }
12186       else
12187         {
12188           printf_filtered (_(" (%s %s) pending."),
12189                            event_location_to_string (b->location.get ()),
12190                            b->extra_string);
12191         }
12192     }
12193   else
12194     {
12195       if (opts.addressprint || b->loc->symtab == NULL)
12196         {
12197           printf_filtered (" at ");
12198           fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
12199                           gdb_stdout);
12200         }
12201       if (b->loc->symtab != NULL)
12202         {
12203           /* If there is a single location, we can print the location
12204              more nicely.  */
12205           if (b->loc->next == NULL)
12206             printf_filtered (": file %s, line %d.",
12207                              symtab_to_filename_for_display (b->loc->symtab),
12208                              b->loc->line_number);
12209           else
12210             /* This is not ideal, but each location may have a
12211                different file name, and this at least reflects the
12212                real situation somewhat.  */
12213             printf_filtered (": %s.",
12214                              event_location_to_string (b->location.get ()));
12215         }
12216
12217       if (b->loc->next)
12218         {
12219           struct bp_location *loc = b->loc;
12220           int n = 0;
12221           for (; loc; loc = loc->next)
12222             ++n;
12223           printf_filtered (" (%d locations)", n);
12224         }
12225     }
12226 }
12227
12228 /* Default bp_location_ops methods.  */
12229
12230 static void
12231 bp_location_dtor (struct bp_location *self)
12232 {
12233   xfree (self->function_name);
12234 }
12235
12236 static const struct bp_location_ops bp_location_ops =
12237 {
12238   bp_location_dtor
12239 };
12240
12241 /* Destructor for the breakpoint base class.  */
12242
12243 breakpoint::~breakpoint ()
12244 {
12245   xfree (this->cond_string);
12246   xfree (this->extra_string);
12247   xfree (this->filter);
12248 }
12249
12250 static struct bp_location *
12251 base_breakpoint_allocate_location (struct breakpoint *self)
12252 {
12253   return new bp_location (&bp_location_ops, self);
12254 }
12255
12256 static void
12257 base_breakpoint_re_set (struct breakpoint *b)
12258 {
12259   /* Nothing to re-set. */
12260 }
12261
12262 #define internal_error_pure_virtual_called() \
12263   gdb_assert_not_reached ("pure virtual function called")
12264
12265 static int
12266 base_breakpoint_insert_location (struct bp_location *bl)
12267 {
12268   internal_error_pure_virtual_called ();
12269 }
12270
12271 static int
12272 base_breakpoint_remove_location (struct bp_location *bl,
12273                                  enum remove_bp_reason reason)
12274 {
12275   internal_error_pure_virtual_called ();
12276 }
12277
12278 static int
12279 base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12280                                 const address_space *aspace,
12281                                 CORE_ADDR bp_addr,
12282                                 const struct target_waitstatus *ws)
12283 {
12284   internal_error_pure_virtual_called ();
12285 }
12286
12287 static void
12288 base_breakpoint_check_status (bpstat bs)
12289 {
12290   /* Always stop.   */
12291 }
12292
12293 /* A "works_in_software_mode" breakpoint_ops method that just internal
12294    errors.  */
12295
12296 static int
12297 base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12298 {
12299   internal_error_pure_virtual_called ();
12300 }
12301
12302 /* A "resources_needed" breakpoint_ops method that just internal
12303    errors.  */
12304
12305 static int
12306 base_breakpoint_resources_needed (const struct bp_location *bl)
12307 {
12308   internal_error_pure_virtual_called ();
12309 }
12310
12311 static enum print_stop_action
12312 base_breakpoint_print_it (bpstat bs)
12313 {
12314   internal_error_pure_virtual_called ();
12315 }
12316
12317 static void
12318 base_breakpoint_print_one_detail (const struct breakpoint *self,
12319                                   struct ui_out *uiout)
12320 {
12321   /* nothing */
12322 }
12323
12324 static void
12325 base_breakpoint_print_mention (struct breakpoint *b)
12326 {
12327   internal_error_pure_virtual_called ();
12328 }
12329
12330 static void
12331 base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12332 {
12333   internal_error_pure_virtual_called ();
12334 }
12335
12336 static void
12337 base_breakpoint_create_sals_from_location
12338   (const struct event_location *location,
12339    struct linespec_result *canonical,
12340    enum bptype type_wanted)
12341 {
12342   internal_error_pure_virtual_called ();
12343 }
12344
12345 static void
12346 base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12347                                         struct linespec_result *c,
12348                                         gdb::unique_xmalloc_ptr<char> cond_string,
12349                                         gdb::unique_xmalloc_ptr<char> extra_string,
12350                                         enum bptype type_wanted,
12351                                         enum bpdisp disposition,
12352                                         int thread,
12353                                         int task, int ignore_count,
12354                                         const struct breakpoint_ops *o,
12355                                         int from_tty, int enabled,
12356                                         int internal, unsigned flags)
12357 {
12358   internal_error_pure_virtual_called ();
12359 }
12360
12361 static std::vector<symtab_and_line>
12362 base_breakpoint_decode_location (struct breakpoint *b,
12363                                  const struct event_location *location,
12364                                  struct program_space *search_pspace)
12365 {
12366   internal_error_pure_virtual_called ();
12367 }
12368
12369 /* The default 'explains_signal' method.  */
12370
12371 static int
12372 base_breakpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
12373 {
12374   return 1;
12375 }
12376
12377 /* The default "after_condition_true" method.  */
12378
12379 static void
12380 base_breakpoint_after_condition_true (struct bpstats *bs)
12381 {
12382   /* Nothing to do.   */
12383 }
12384
12385 struct breakpoint_ops base_breakpoint_ops =
12386 {
12387   base_breakpoint_allocate_location,
12388   base_breakpoint_re_set,
12389   base_breakpoint_insert_location,
12390   base_breakpoint_remove_location,
12391   base_breakpoint_breakpoint_hit,
12392   base_breakpoint_check_status,
12393   base_breakpoint_resources_needed,
12394   base_breakpoint_works_in_software_mode,
12395   base_breakpoint_print_it,
12396   NULL,
12397   base_breakpoint_print_one_detail,
12398   base_breakpoint_print_mention,
12399   base_breakpoint_print_recreate,
12400   base_breakpoint_create_sals_from_location,
12401   base_breakpoint_create_breakpoints_sal,
12402   base_breakpoint_decode_location,
12403   base_breakpoint_explains_signal,
12404   base_breakpoint_after_condition_true,
12405 };
12406
12407 /* Default breakpoint_ops methods.  */
12408
12409 static void
12410 bkpt_re_set (struct breakpoint *b)
12411 {
12412   /* FIXME: is this still reachable?  */
12413   if (breakpoint_event_location_empty_p (b))
12414     {
12415       /* Anything without a location can't be re-set.  */
12416       delete_breakpoint (b);
12417       return;
12418     }
12419
12420   breakpoint_re_set_default (b);
12421 }
12422
12423 static int
12424 bkpt_insert_location (struct bp_location *bl)
12425 {
12426   CORE_ADDR addr = bl->target_info.reqstd_address;
12427
12428   bl->target_info.kind = breakpoint_kind (bl, &addr);
12429   bl->target_info.placed_address = addr;
12430
12431   if (bl->loc_type == bp_loc_hardware_breakpoint)
12432     return target_insert_hw_breakpoint (bl->gdbarch, &bl->target_info);
12433   else
12434     return target_insert_breakpoint (bl->gdbarch, &bl->target_info);
12435 }
12436
12437 static int
12438 bkpt_remove_location (struct bp_location *bl, enum remove_bp_reason reason)
12439 {
12440   if (bl->loc_type == bp_loc_hardware_breakpoint)
12441     return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
12442   else
12443     return target_remove_breakpoint (bl->gdbarch, &bl->target_info, reason);
12444 }
12445
12446 static int
12447 bkpt_breakpoint_hit (const struct bp_location *bl,
12448                      const address_space *aspace, CORE_ADDR bp_addr,
12449                      const struct target_waitstatus *ws)
12450 {
12451   if (ws->kind != TARGET_WAITKIND_STOPPED
12452       || ws->value.sig != GDB_SIGNAL_TRAP)
12453     return 0;
12454
12455   if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
12456                                  aspace, bp_addr))
12457     return 0;
12458
12459   if (overlay_debugging         /* unmapped overlay section */
12460       && section_is_overlay (bl->section)
12461       && !section_is_mapped (bl->section))
12462     return 0;
12463
12464   return 1;
12465 }
12466
12467 static int
12468 dprintf_breakpoint_hit (const struct bp_location *bl,
12469                         const address_space *aspace, CORE_ADDR bp_addr,
12470                         const struct target_waitstatus *ws)
12471 {
12472   if (dprintf_style == dprintf_style_agent
12473       && target_can_run_breakpoint_commands ())
12474     {
12475       /* An agent-style dprintf never causes a stop.  If we see a trap
12476          for this address it must be for a breakpoint that happens to
12477          be set at the same address.  */
12478       return 0;
12479     }
12480
12481   return bkpt_breakpoint_hit (bl, aspace, bp_addr, ws);
12482 }
12483
12484 static int
12485 bkpt_resources_needed (const struct bp_location *bl)
12486 {
12487   gdb_assert (bl->owner->type == bp_hardware_breakpoint);
12488
12489   return 1;
12490 }
12491
12492 static enum print_stop_action
12493 bkpt_print_it (bpstat bs)
12494 {
12495   struct breakpoint *b;
12496   const struct bp_location *bl;
12497   int bp_temp;
12498   struct ui_out *uiout = current_uiout;
12499
12500   gdb_assert (bs->bp_location_at != NULL);
12501
12502   bl = bs->bp_location_at;
12503   b = bs->breakpoint_at;
12504
12505   bp_temp = b->disposition == disp_del;
12506   if (bl->address != bl->requested_address)
12507     breakpoint_adjustment_warning (bl->requested_address,
12508                                    bl->address,
12509                                    b->number, 1);
12510   annotate_breakpoint (b->number);
12511   maybe_print_thread_hit_breakpoint (uiout);
12512
12513   if (bp_temp)
12514     uiout->text ("Temporary breakpoint ");
12515   else
12516     uiout->text ("Breakpoint ");
12517   if (uiout->is_mi_like_p ())
12518     {
12519       uiout->field_string ("reason",
12520                            async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
12521       uiout->field_string ("disp", bpdisp_text (b->disposition));
12522     }
12523   uiout->field_int ("bkptno", b->number);
12524   uiout->text (", ");
12525
12526   return PRINT_SRC_AND_LOC;
12527 }
12528
12529 static void
12530 bkpt_print_mention (struct breakpoint *b)
12531 {
12532   if (current_uiout->is_mi_like_p ())
12533     return;
12534
12535   switch (b->type)
12536     {
12537     case bp_breakpoint:
12538     case bp_gnu_ifunc_resolver:
12539       if (b->disposition == disp_del)
12540         printf_filtered (_("Temporary breakpoint"));
12541       else
12542         printf_filtered (_("Breakpoint"));
12543       printf_filtered (_(" %d"), b->number);
12544       if (b->type == bp_gnu_ifunc_resolver)
12545         printf_filtered (_(" at gnu-indirect-function resolver"));
12546       break;
12547     case bp_hardware_breakpoint:
12548       printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
12549       break;
12550     case bp_dprintf:
12551       printf_filtered (_("Dprintf %d"), b->number);
12552       break;
12553     }
12554
12555   say_where (b);
12556 }
12557
12558 static void
12559 bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
12560 {
12561   if (tp->type == bp_breakpoint && tp->disposition == disp_del)
12562     fprintf_unfiltered (fp, "tbreak");
12563   else if (tp->type == bp_breakpoint)
12564     fprintf_unfiltered (fp, "break");
12565   else if (tp->type == bp_hardware_breakpoint
12566            && tp->disposition == disp_del)
12567     fprintf_unfiltered (fp, "thbreak");
12568   else if (tp->type == bp_hardware_breakpoint)
12569     fprintf_unfiltered (fp, "hbreak");
12570   else
12571     internal_error (__FILE__, __LINE__,
12572                     _("unhandled breakpoint type %d"), (int) tp->type);
12573
12574   fprintf_unfiltered (fp, " %s",
12575                       event_location_to_string (tp->location.get ()));
12576
12577   /* Print out extra_string if this breakpoint is pending.  It might
12578      contain, for example, conditions that were set by the user.  */
12579   if (tp->loc == NULL && tp->extra_string != NULL)
12580     fprintf_unfiltered (fp, " %s", tp->extra_string);
12581
12582   print_recreate_thread (tp, fp);
12583 }
12584
12585 static void
12586 bkpt_create_sals_from_location (const struct event_location *location,
12587                                 struct linespec_result *canonical,
12588                                 enum bptype type_wanted)
12589 {
12590   create_sals_from_location_default (location, canonical, type_wanted);
12591 }
12592
12593 static void
12594 bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
12595                              struct linespec_result *canonical,
12596                              gdb::unique_xmalloc_ptr<char> cond_string,
12597                              gdb::unique_xmalloc_ptr<char> extra_string,
12598                              enum bptype type_wanted,
12599                              enum bpdisp disposition,
12600                              int thread,
12601                              int task, int ignore_count,
12602                              const struct breakpoint_ops *ops,
12603                              int from_tty, int enabled,
12604                              int internal, unsigned flags)
12605 {
12606   create_breakpoints_sal_default (gdbarch, canonical,
12607                                   std::move (cond_string),
12608                                   std::move (extra_string),
12609                                   type_wanted,
12610                                   disposition, thread, task,
12611                                   ignore_count, ops, from_tty,
12612                                   enabled, internal, flags);
12613 }
12614
12615 static std::vector<symtab_and_line>
12616 bkpt_decode_location (struct breakpoint *b,
12617                       const struct event_location *location,
12618                       struct program_space *search_pspace)
12619 {
12620   return decode_location_default (b, location, search_pspace);
12621 }
12622
12623 /* Virtual table for internal breakpoints.  */
12624
12625 static void
12626 internal_bkpt_re_set (struct breakpoint *b)
12627 {
12628   switch (b->type)
12629     {
12630       /* Delete overlay event and longjmp master breakpoints; they
12631          will be reset later by breakpoint_re_set.  */
12632     case bp_overlay_event:
12633     case bp_longjmp_master:
12634     case bp_std_terminate_master:
12635     case bp_exception_master:
12636       delete_breakpoint (b);
12637       break;
12638
12639       /* This breakpoint is special, it's set up when the inferior
12640          starts and we really don't want to touch it.  */
12641     case bp_shlib_event:
12642
12643       /* Like bp_shlib_event, this breakpoint type is special.  Once
12644          it is set up, we do not want to touch it.  */
12645     case bp_thread_event:
12646       break;
12647     }
12648 }
12649
12650 static void
12651 internal_bkpt_check_status (bpstat bs)
12652 {
12653   if (bs->breakpoint_at->type == bp_shlib_event)
12654     {
12655       /* If requested, stop when the dynamic linker notifies GDB of
12656          events.  This allows the user to get control and place
12657          breakpoints in initializer routines for dynamically loaded
12658          objects (among other things).  */
12659       bs->stop = stop_on_solib_events;
12660       bs->print = stop_on_solib_events;
12661     }
12662   else
12663     bs->stop = 0;
12664 }
12665
12666 static enum print_stop_action
12667 internal_bkpt_print_it (bpstat bs)
12668 {
12669   struct breakpoint *b;
12670
12671   b = bs->breakpoint_at;
12672
12673   switch (b->type)
12674     {
12675     case bp_shlib_event:
12676       /* Did we stop because the user set the stop_on_solib_events
12677          variable?  (If so, we report this as a generic, "Stopped due
12678          to shlib event" message.) */
12679       print_solib_event (0);
12680       break;
12681
12682     case bp_thread_event:
12683       /* Not sure how we will get here.
12684          GDB should not stop for these breakpoints.  */
12685       printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12686       break;
12687
12688     case bp_overlay_event:
12689       /* By analogy with the thread event, GDB should not stop for these.  */
12690       printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12691       break;
12692
12693     case bp_longjmp_master:
12694       /* These should never be enabled.  */
12695       printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12696       break;
12697
12698     case bp_std_terminate_master:
12699       /* These should never be enabled.  */
12700       printf_filtered (_("std::terminate Master Breakpoint: "
12701                          "gdb should not stop!\n"));
12702       break;
12703
12704     case bp_exception_master:
12705       /* These should never be enabled.  */
12706       printf_filtered (_("Exception Master Breakpoint: "
12707                          "gdb should not stop!\n"));
12708       break;
12709     }
12710
12711   return PRINT_NOTHING;
12712 }
12713
12714 static void
12715 internal_bkpt_print_mention (struct breakpoint *b)
12716 {
12717   /* Nothing to mention.  These breakpoints are internal.  */
12718 }
12719
12720 /* Virtual table for momentary breakpoints  */
12721
12722 static void
12723 momentary_bkpt_re_set (struct breakpoint *b)
12724 {
12725   /* Keep temporary breakpoints, which can be encountered when we step
12726      over a dlopen call and solib_add is resetting the breakpoints.
12727      Otherwise these should have been blown away via the cleanup chain
12728      or by breakpoint_init_inferior when we rerun the executable.  */
12729 }
12730
12731 static void
12732 momentary_bkpt_check_status (bpstat bs)
12733 {
12734   /* Nothing.  The point of these breakpoints is causing a stop.  */
12735 }
12736
12737 static enum print_stop_action
12738 momentary_bkpt_print_it (bpstat bs)
12739 {
12740   return PRINT_UNKNOWN;
12741 }
12742
12743 static void
12744 momentary_bkpt_print_mention (struct breakpoint *b)
12745 {
12746   /* Nothing to mention.  These breakpoints are internal.  */
12747 }
12748
12749 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12750
12751    It gets cleared already on the removal of the first one of such placed
12752    breakpoints.  This is OK as they get all removed altogether.  */
12753
12754 longjmp_breakpoint::~longjmp_breakpoint ()
12755 {
12756   thread_info *tp = find_thread_global_id (this->thread);
12757
12758   if (tp != NULL)
12759     tp->initiating_frame = null_frame_id;
12760 }
12761
12762 /* Specific methods for probe breakpoints.  */
12763
12764 static int
12765 bkpt_probe_insert_location (struct bp_location *bl)
12766 {
12767   int v = bkpt_insert_location (bl);
12768
12769   if (v == 0)
12770     {
12771       /* The insertion was successful, now let's set the probe's semaphore
12772          if needed.  */
12773       bl->probe.prob->set_semaphore (bl->probe.objfile, bl->gdbarch);
12774     }
12775
12776   return v;
12777 }
12778
12779 static int
12780 bkpt_probe_remove_location (struct bp_location *bl,
12781                             enum remove_bp_reason reason)
12782 {
12783   /* Let's clear the semaphore before removing the location.  */
12784   bl->probe.prob->clear_semaphore (bl->probe.objfile, bl->gdbarch);
12785
12786   return bkpt_remove_location (bl, reason);
12787 }
12788
12789 static void
12790 bkpt_probe_create_sals_from_location (const struct event_location *location,
12791                                       struct linespec_result *canonical,
12792                                       enum bptype type_wanted)
12793 {
12794   struct linespec_sals lsal;
12795
12796   lsal.sals = parse_probes (location, NULL, canonical);
12797   lsal.canonical
12798     = xstrdup (event_location_to_string (canonical->location.get ()));
12799   canonical->lsals.push_back (std::move (lsal));
12800 }
12801
12802 static std::vector<symtab_and_line>
12803 bkpt_probe_decode_location (struct breakpoint *b,
12804                             const struct event_location *location,
12805                             struct program_space *search_pspace)
12806 {
12807   std::vector<symtab_and_line> sals = parse_probes (location, search_pspace, NULL);
12808   if (sals.empty ())
12809     error (_("probe not found"));
12810   return sals;
12811 }
12812
12813 /* The breakpoint_ops structure to be used in tracepoints.  */
12814
12815 static void
12816 tracepoint_re_set (struct breakpoint *b)
12817 {
12818   breakpoint_re_set_default (b);
12819 }
12820
12821 static int
12822 tracepoint_breakpoint_hit (const struct bp_location *bl,
12823                            const address_space *aspace, CORE_ADDR bp_addr,
12824                            const struct target_waitstatus *ws)
12825 {
12826   /* By definition, the inferior does not report stops at
12827      tracepoints.  */
12828   return 0;
12829 }
12830
12831 static void
12832 tracepoint_print_one_detail (const struct breakpoint *self,
12833                              struct ui_out *uiout)
12834 {
12835   struct tracepoint *tp = (struct tracepoint *) self;
12836   if (!tp->static_trace_marker_id.empty ())
12837     {
12838       gdb_assert (self->type == bp_static_tracepoint);
12839
12840       uiout->text ("\tmarker id is ");
12841       uiout->field_string ("static-tracepoint-marker-string-id",
12842                            tp->static_trace_marker_id);
12843       uiout->text ("\n");
12844     }
12845 }
12846
12847 static void
12848 tracepoint_print_mention (struct breakpoint *b)
12849 {
12850   if (current_uiout->is_mi_like_p ())
12851     return;
12852
12853   switch (b->type)
12854     {
12855     case bp_tracepoint:
12856       printf_filtered (_("Tracepoint"));
12857       printf_filtered (_(" %d"), b->number);
12858       break;
12859     case bp_fast_tracepoint:
12860       printf_filtered (_("Fast tracepoint"));
12861       printf_filtered (_(" %d"), b->number);
12862       break;
12863     case bp_static_tracepoint:
12864       printf_filtered (_("Static tracepoint"));
12865       printf_filtered (_(" %d"), b->number);
12866       break;
12867     default:
12868       internal_error (__FILE__, __LINE__,
12869                       _("unhandled tracepoint type %d"), (int) b->type);
12870     }
12871
12872   say_where (b);
12873 }
12874
12875 static void
12876 tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
12877 {
12878   struct tracepoint *tp = (struct tracepoint *) self;
12879
12880   if (self->type == bp_fast_tracepoint)
12881     fprintf_unfiltered (fp, "ftrace");
12882   else if (self->type == bp_static_tracepoint)
12883     fprintf_unfiltered (fp, "strace");
12884   else if (self->type == bp_tracepoint)
12885     fprintf_unfiltered (fp, "trace");
12886   else
12887     internal_error (__FILE__, __LINE__,
12888                     _("unhandled tracepoint type %d"), (int) self->type);
12889
12890   fprintf_unfiltered (fp, " %s",
12891                       event_location_to_string (self->location.get ()));
12892   print_recreate_thread (self, fp);
12893
12894   if (tp->pass_count)
12895     fprintf_unfiltered (fp, "  passcount %d\n", tp->pass_count);
12896 }
12897
12898 static void
12899 tracepoint_create_sals_from_location (const struct event_location *location,
12900                                       struct linespec_result *canonical,
12901                                       enum bptype type_wanted)
12902 {
12903   create_sals_from_location_default (location, canonical, type_wanted);
12904 }
12905
12906 static void
12907 tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12908                                    struct linespec_result *canonical,
12909                                    gdb::unique_xmalloc_ptr<char> cond_string,
12910                                    gdb::unique_xmalloc_ptr<char> extra_string,
12911                                    enum bptype type_wanted,
12912                                    enum bpdisp disposition,
12913                                    int thread,
12914                                    int task, int ignore_count,
12915                                    const struct breakpoint_ops *ops,
12916                                    int from_tty, int enabled,
12917                                    int internal, unsigned flags)
12918 {
12919   create_breakpoints_sal_default (gdbarch, canonical,
12920                                   std::move (cond_string),
12921                                   std::move (extra_string),
12922                                   type_wanted,
12923                                   disposition, thread, task,
12924                                   ignore_count, ops, from_tty,
12925                                   enabled, internal, flags);
12926 }
12927
12928 static std::vector<symtab_and_line>
12929 tracepoint_decode_location (struct breakpoint *b,
12930                             const struct event_location *location,
12931                             struct program_space *search_pspace)
12932 {
12933   return decode_location_default (b, location, search_pspace);
12934 }
12935
12936 struct breakpoint_ops tracepoint_breakpoint_ops;
12937
12938 /* The breakpoint_ops structure to be use on tracepoints placed in a
12939    static probe.  */
12940
12941 static void
12942 tracepoint_probe_create_sals_from_location
12943   (const struct event_location *location,
12944    struct linespec_result *canonical,
12945    enum bptype type_wanted)
12946 {
12947   /* We use the same method for breakpoint on probes.  */
12948   bkpt_probe_create_sals_from_location (location, canonical, type_wanted);
12949 }
12950
12951 static std::vector<symtab_and_line>
12952 tracepoint_probe_decode_location (struct breakpoint *b,
12953                                   const struct event_location *location,
12954                                   struct program_space *search_pspace)
12955 {
12956   /* We use the same method for breakpoint on probes.  */
12957   return bkpt_probe_decode_location (b, location, search_pspace);
12958 }
12959
12960 static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
12961
12962 /* Dprintf breakpoint_ops methods.  */
12963
12964 static void
12965 dprintf_re_set (struct breakpoint *b)
12966 {
12967   breakpoint_re_set_default (b);
12968
12969   /* extra_string should never be non-NULL for dprintf.  */
12970   gdb_assert (b->extra_string != NULL);
12971
12972   /* 1 - connect to target 1, that can run breakpoint commands.
12973      2 - create a dprintf, which resolves fine.
12974      3 - disconnect from target 1
12975      4 - connect to target 2, that can NOT run breakpoint commands.
12976
12977      After steps #3/#4, you'll want the dprintf command list to
12978      be updated, because target 1 and 2 may well return different
12979      answers for target_can_run_breakpoint_commands().
12980      Given absence of finer grained resetting, we get to do
12981      it all the time.  */
12982   if (b->extra_string != NULL)
12983     update_dprintf_command_list (b);
12984 }
12985
12986 /* Implement the "print_recreate" breakpoint_ops method for dprintf.  */
12987
12988 static void
12989 dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp)
12990 {
12991   fprintf_unfiltered (fp, "dprintf %s,%s",
12992                       event_location_to_string (tp->location.get ()),
12993                       tp->extra_string);
12994   print_recreate_thread (tp, fp);
12995 }
12996
12997 /* Implement the "after_condition_true" breakpoint_ops method for
12998    dprintf.
12999
13000    dprintf's are implemented with regular commands in their command
13001    list, but we run the commands here instead of before presenting the
13002    stop to the user, as dprintf's don't actually cause a stop.  This
13003    also makes it so that the commands of multiple dprintfs at the same
13004    address are all handled.  */
13005
13006 static void
13007 dprintf_after_condition_true (struct bpstats *bs)
13008 {
13009   struct bpstats tmp_bs;
13010   struct bpstats *tmp_bs_p = &tmp_bs;
13011
13012   /* dprintf's never cause a stop.  This wasn't set in the
13013      check_status hook instead because that would make the dprintf's
13014      condition not be evaluated.  */
13015   bs->stop = 0;
13016
13017   /* Run the command list here.  Take ownership of it instead of
13018      copying.  We never want these commands to run later in
13019      bpstat_do_actions, if a breakpoint that causes a stop happens to
13020      be set at same address as this dprintf, or even if running the
13021      commands here throws.  */
13022   tmp_bs.commands = bs->commands;
13023   bs->commands = NULL;
13024
13025   bpstat_do_actions_1 (&tmp_bs_p);
13026
13027   /* 'tmp_bs.commands' will usually be NULL by now, but
13028      bpstat_do_actions_1 may return early without processing the whole
13029      list.  */
13030 }
13031
13032 /* The breakpoint_ops structure to be used on static tracepoints with
13033    markers (`-m').  */
13034
13035 static void
13036 strace_marker_create_sals_from_location (const struct event_location *location,
13037                                          struct linespec_result *canonical,
13038                                          enum bptype type_wanted)
13039 {
13040   struct linespec_sals lsal;
13041   const char *arg_start, *arg;
13042
13043   arg = arg_start = get_linespec_location (location)->spec_string;
13044   lsal.sals = decode_static_tracepoint_spec (&arg);
13045
13046   std::string str (arg_start, arg - arg_start);
13047   const char *ptr = str.c_str ();
13048   canonical->location
13049     = new_linespec_location (&ptr, symbol_name_match_type::FULL);
13050
13051   lsal.canonical
13052     = xstrdup (event_location_to_string (canonical->location.get ()));
13053   canonical->lsals.push_back (std::move (lsal));
13054 }
13055
13056 static void
13057 strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
13058                                       struct linespec_result *canonical,
13059                                       gdb::unique_xmalloc_ptr<char> cond_string,
13060                                       gdb::unique_xmalloc_ptr<char> extra_string,
13061                                       enum bptype type_wanted,
13062                                       enum bpdisp disposition,
13063                                       int thread,
13064                                       int task, int ignore_count,
13065                                       const struct breakpoint_ops *ops,
13066                                       int from_tty, int enabled,
13067                                       int internal, unsigned flags)
13068 {
13069   const linespec_sals &lsal = canonical->lsals[0];
13070
13071   /* If the user is creating a static tracepoint by marker id
13072      (strace -m MARKER_ID), then store the sals index, so that
13073      breakpoint_re_set can try to match up which of the newly
13074      found markers corresponds to this one, and, don't try to
13075      expand multiple locations for each sal, given than SALS
13076      already should contain all sals for MARKER_ID.  */
13077
13078   for (size_t i = 0; i < lsal.sals.size (); i++)
13079     {
13080       event_location_up location
13081         = copy_event_location (canonical->location.get ());
13082
13083       std::unique_ptr<tracepoint> tp (new tracepoint ());
13084       init_breakpoint_sal (tp.get (), gdbarch, lsal.sals[i],
13085                            std::move (location), NULL,
13086                            std::move (cond_string),
13087                            std::move (extra_string),
13088                            type_wanted, disposition,
13089                            thread, task, ignore_count, ops,
13090                            from_tty, enabled, internal, flags,
13091                            canonical->special_display);
13092       /* Given that its possible to have multiple markers with
13093          the same string id, if the user is creating a static
13094          tracepoint by marker id ("strace -m MARKER_ID"), then
13095          store the sals index, so that breakpoint_re_set can
13096          try to match up which of the newly found markers
13097          corresponds to this one  */
13098       tp->static_trace_marker_id_idx = i;
13099
13100       install_breakpoint (internal, std::move (tp), 0);
13101     }
13102 }
13103
13104 static std::vector<symtab_and_line>
13105 strace_marker_decode_location (struct breakpoint *b,
13106                                const struct event_location *location,
13107                                struct program_space *search_pspace)
13108 {
13109   struct tracepoint *tp = (struct tracepoint *) b;
13110   const char *s = get_linespec_location (location)->spec_string;
13111
13112   std::vector<symtab_and_line> sals = decode_static_tracepoint_spec (&s);
13113   if (sals.size () > tp->static_trace_marker_id_idx)
13114     {
13115       sals[0] = sals[tp->static_trace_marker_id_idx];
13116       sals.resize (1);
13117       return sals;
13118     }
13119   else
13120     error (_("marker %s not found"), tp->static_trace_marker_id.c_str ());
13121 }
13122
13123 static struct breakpoint_ops strace_marker_breakpoint_ops;
13124
13125 static int
13126 strace_marker_p (struct breakpoint *b)
13127 {
13128   return b->ops == &strace_marker_breakpoint_ops;
13129 }
13130
13131 /* Delete a breakpoint and clean up all traces of it in the data
13132    structures.  */
13133
13134 void
13135 delete_breakpoint (struct breakpoint *bpt)
13136 {
13137   struct breakpoint *b;
13138
13139   gdb_assert (bpt != NULL);
13140
13141   /* Has this bp already been deleted?  This can happen because
13142      multiple lists can hold pointers to bp's.  bpstat lists are
13143      especial culprits.
13144
13145      One example of this happening is a watchpoint's scope bp.  When
13146      the scope bp triggers, we notice that the watchpoint is out of
13147      scope, and delete it.  We also delete its scope bp.  But the
13148      scope bp is marked "auto-deleting", and is already on a bpstat.
13149      That bpstat is then checked for auto-deleting bp's, which are
13150      deleted.
13151
13152      A real solution to this problem might involve reference counts in
13153      bp's, and/or giving them pointers back to their referencing
13154      bpstat's, and teaching delete_breakpoint to only free a bp's
13155      storage when no more references were extent.  A cheaper bandaid
13156      was chosen.  */
13157   if (bpt->type == bp_none)
13158     return;
13159
13160   /* At least avoid this stale reference until the reference counting
13161      of breakpoints gets resolved.  */
13162   if (bpt->related_breakpoint != bpt)
13163     {
13164       struct breakpoint *related;
13165       struct watchpoint *w;
13166
13167       if (bpt->type == bp_watchpoint_scope)
13168         w = (struct watchpoint *) bpt->related_breakpoint;
13169       else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
13170         w = (struct watchpoint *) bpt;
13171       else
13172         w = NULL;
13173       if (w != NULL)
13174         watchpoint_del_at_next_stop (w);
13175
13176       /* Unlink bpt from the bpt->related_breakpoint ring.  */
13177       for (related = bpt; related->related_breakpoint != bpt;
13178            related = related->related_breakpoint);
13179       related->related_breakpoint = bpt->related_breakpoint;
13180       bpt->related_breakpoint = bpt;
13181     }
13182
13183   /* watch_command_1 creates a watchpoint but only sets its number if
13184      update_watchpoint succeeds in creating its bp_locations.  If there's
13185      a problem in that process, we'll be asked to delete the half-created
13186      watchpoint.  In that case, don't announce the deletion.  */
13187   if (bpt->number)
13188     gdb::observers::breakpoint_deleted.notify (bpt);
13189
13190   if (breakpoint_chain == bpt)
13191     breakpoint_chain = bpt->next;
13192
13193   ALL_BREAKPOINTS (b)
13194     if (b->next == bpt)
13195     {
13196       b->next = bpt->next;
13197       break;
13198     }
13199
13200   /* Be sure no bpstat's are pointing at the breakpoint after it's
13201      been freed.  */
13202   /* FIXME, how can we find all bpstat's?  We just check stop_bpstat
13203      in all threads for now.  Note that we cannot just remove bpstats
13204      pointing at bpt from the stop_bpstat list entirely, as breakpoint
13205      commands are associated with the bpstat; if we remove it here,
13206      then the later call to bpstat_do_actions (&stop_bpstat); in
13207      event-top.c won't do anything, and temporary breakpoints with
13208      commands won't work.  */
13209
13210   iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13211
13212   /* Now that breakpoint is removed from breakpoint list, update the
13213      global location list.  This will remove locations that used to
13214      belong to this breakpoint.  Do this before freeing the breakpoint
13215      itself, since remove_breakpoint looks at location's owner.  It
13216      might be better design to have location completely
13217      self-contained, but it's not the case now.  */
13218   update_global_location_list (UGLL_DONT_INSERT);
13219
13220   /* On the chance that someone will soon try again to delete this
13221      same bp, we mark it as deleted before freeing its storage.  */
13222   bpt->type = bp_none;
13223   delete bpt;
13224 }
13225
13226 /* Iterator function to call a user-provided callback function once
13227    for each of B and its related breakpoints.  */
13228
13229 static void
13230 iterate_over_related_breakpoints (struct breakpoint *b,
13231                                   gdb::function_view<void (breakpoint *)> function)
13232 {
13233   struct breakpoint *related;
13234
13235   related = b;
13236   do
13237     {
13238       struct breakpoint *next;
13239
13240       /* FUNCTION may delete RELATED.  */
13241       next = related->related_breakpoint;
13242
13243       if (next == related)
13244         {
13245           /* RELATED is the last ring entry.  */
13246           function (related);
13247
13248           /* FUNCTION may have deleted it, so we'd never reach back to
13249              B.  There's nothing left to do anyway, so just break
13250              out.  */
13251           break;
13252         }
13253       else
13254         function (related);
13255
13256       related = next;
13257     }
13258   while (related != b);
13259 }
13260
13261 static void
13262 delete_command (const char *arg, int from_tty)
13263 {
13264   struct breakpoint *b, *b_tmp;
13265
13266   dont_repeat ();
13267
13268   if (arg == 0)
13269     {
13270       int breaks_to_delete = 0;
13271
13272       /* Delete all breakpoints if no argument.  Do not delete
13273          internal breakpoints, these have to be deleted with an
13274          explicit breakpoint number argument.  */
13275       ALL_BREAKPOINTS (b)
13276         if (user_breakpoint_p (b))
13277           {
13278             breaks_to_delete = 1;
13279             break;
13280           }
13281
13282       /* Ask user only if there are some breakpoints to delete.  */
13283       if (!from_tty
13284           || (breaks_to_delete && query (_("Delete all breakpoints? "))))
13285         {
13286           ALL_BREAKPOINTS_SAFE (b, b_tmp)
13287             if (user_breakpoint_p (b))
13288               delete_breakpoint (b);
13289         }
13290     }
13291   else
13292     map_breakpoint_numbers
13293       (arg, [&] (breakpoint *b)
13294        {
13295          iterate_over_related_breakpoints (b, delete_breakpoint);
13296        });
13297 }
13298
13299 /* Return true if all locations of B bound to PSPACE are pending.  If
13300    PSPACE is NULL, all locations of all program spaces are
13301    considered.  */
13302
13303 static int
13304 all_locations_are_pending (struct breakpoint *b, struct program_space *pspace)
13305 {
13306   struct bp_location *loc;
13307
13308   for (loc = b->loc; loc != NULL; loc = loc->next)
13309     if ((pspace == NULL
13310          || loc->pspace == pspace)
13311         && !loc->shlib_disabled
13312         && !loc->pspace->executing_startup)
13313       return 0;
13314   return 1;
13315 }
13316
13317 /* Subroutine of update_breakpoint_locations to simplify it.
13318    Return non-zero if multiple fns in list LOC have the same name.
13319    Null names are ignored.  */
13320
13321 static int
13322 ambiguous_names_p (struct bp_location *loc)
13323 {
13324   struct bp_location *l;
13325   htab_t htab = htab_create_alloc (13, htab_hash_string, streq_hash, NULL,
13326                                    xcalloc, xfree);
13327
13328   for (l = loc; l != NULL; l = l->next)
13329     {
13330       const char **slot;
13331       const char *name = l->function_name;
13332
13333       /* Allow for some names to be NULL, ignore them.  */
13334       if (name == NULL)
13335         continue;
13336
13337       slot = (const char **) htab_find_slot (htab, (const void *) name,
13338                                              INSERT);
13339       /* NOTE: We can assume slot != NULL here because xcalloc never
13340          returns NULL.  */
13341       if (*slot != NULL)
13342         {
13343           htab_delete (htab);
13344           return 1;
13345         }
13346       *slot = name;
13347     }
13348
13349   htab_delete (htab);
13350   return 0;
13351 }
13352
13353 /* When symbols change, it probably means the sources changed as well,
13354    and it might mean the static tracepoint markers are no longer at
13355    the same address or line numbers they used to be at last we
13356    checked.  Losing your static tracepoints whenever you rebuild is
13357    undesirable.  This function tries to resync/rematch gdb static
13358    tracepoints with the markers on the target, for static tracepoints
13359    that have not been set by marker id.  Static tracepoint that have
13360    been set by marker id are reset by marker id in breakpoint_re_set.
13361    The heuristic is:
13362
13363    1) For a tracepoint set at a specific address, look for a marker at
13364    the old PC.  If one is found there, assume to be the same marker.
13365    If the name / string id of the marker found is different from the
13366    previous known name, assume that means the user renamed the marker
13367    in the sources, and output a warning.
13368
13369    2) For a tracepoint set at a given line number, look for a marker
13370    at the new address of the old line number.  If one is found there,
13371    assume to be the same marker.  If the name / string id of the
13372    marker found is different from the previous known name, assume that
13373    means the user renamed the marker in the sources, and output a
13374    warning.
13375
13376    3) If a marker is no longer found at the same address or line, it
13377    may mean the marker no longer exists.  But it may also just mean
13378    the code changed a bit.  Maybe the user added a few lines of code
13379    that made the marker move up or down (in line number terms).  Ask
13380    the target for info about the marker with the string id as we knew
13381    it.  If found, update line number and address in the matching
13382    static tracepoint.  This will get confused if there's more than one
13383    marker with the same ID (possible in UST, although unadvised
13384    precisely because it confuses tools).  */
13385
13386 static struct symtab_and_line
13387 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
13388 {
13389   struct tracepoint *tp = (struct tracepoint *) b;
13390   struct static_tracepoint_marker marker;
13391   CORE_ADDR pc;
13392
13393   pc = sal.pc;
13394   if (sal.line)
13395     find_line_pc (sal.symtab, sal.line, &pc);
13396
13397   if (target_static_tracepoint_marker_at (pc, &marker))
13398     {
13399       if (tp->static_trace_marker_id != marker.str_id)
13400         warning (_("static tracepoint %d changed probed marker from %s to %s"),
13401                  b->number, tp->static_trace_marker_id.c_str (),
13402                  marker.str_id.c_str ());
13403
13404       tp->static_trace_marker_id = std::move (marker.str_id);
13405
13406       return sal;
13407     }
13408
13409   /* Old marker wasn't found on target at lineno.  Try looking it up
13410      by string ID.  */
13411   if (!sal.explicit_pc
13412       && sal.line != 0
13413       && sal.symtab != NULL
13414       && !tp->static_trace_marker_id.empty ())
13415     {
13416       std::vector<static_tracepoint_marker> markers
13417         = target_static_tracepoint_markers_by_strid
13418             (tp->static_trace_marker_id.c_str ());
13419
13420       if (!markers.empty ())
13421         {
13422           struct symbol *sym;
13423           struct static_tracepoint_marker *tpmarker;
13424           struct ui_out *uiout = current_uiout;
13425           struct explicit_location explicit_loc;
13426
13427           tpmarker = &markers[0];
13428
13429           tp->static_trace_marker_id = std::move (tpmarker->str_id);
13430
13431           warning (_("marker for static tracepoint %d (%s) not "
13432                      "found at previous line number"),
13433                    b->number, tp->static_trace_marker_id.c_str ());
13434
13435           symtab_and_line sal2 = find_pc_line (tpmarker->address, 0);
13436           sym = find_pc_sect_function (tpmarker->address, NULL);
13437           uiout->text ("Now in ");
13438           if (sym)
13439             {
13440               uiout->field_string ("func", SYMBOL_PRINT_NAME (sym));
13441               uiout->text (" at ");
13442             }
13443           uiout->field_string ("file",
13444                                symtab_to_filename_for_display (sal2.symtab));
13445           uiout->text (":");
13446
13447           if (uiout->is_mi_like_p ())
13448             {
13449               const char *fullname = symtab_to_fullname (sal2.symtab);
13450
13451               uiout->field_string ("fullname", fullname);
13452             }
13453
13454           uiout->field_int ("line", sal2.line);
13455           uiout->text ("\n");
13456
13457           b->loc->line_number = sal2.line;
13458           b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
13459
13460           b->location.reset (NULL);
13461           initialize_explicit_location (&explicit_loc);
13462           explicit_loc.source_filename
13463             = ASTRDUP (symtab_to_filename_for_display (sal2.symtab));
13464           explicit_loc.line_offset.offset = b->loc->line_number;
13465           explicit_loc.line_offset.sign = LINE_OFFSET_NONE;
13466           b->location = new_explicit_location (&explicit_loc);
13467
13468           /* Might be nice to check if function changed, and warn if
13469              so.  */
13470         }
13471     }
13472   return sal;
13473 }
13474
13475 /* Returns 1 iff locations A and B are sufficiently same that
13476    we don't need to report breakpoint as changed.  */
13477
13478 static int
13479 locations_are_equal (struct bp_location *a, struct bp_location *b)
13480 {
13481   while (a && b)
13482     {
13483       if (a->address != b->address)
13484         return 0;
13485
13486       if (a->shlib_disabled != b->shlib_disabled)
13487         return 0;
13488
13489       if (a->enabled != b->enabled)
13490         return 0;
13491
13492       a = a->next;
13493       b = b->next;
13494     }
13495
13496   if ((a == NULL) != (b == NULL))
13497     return 0;
13498
13499   return 1;
13500 }
13501
13502 /* Split all locations of B that are bound to PSPACE out of B's
13503    location list to a separate list and return that list's head.  If
13504    PSPACE is NULL, hoist out all locations of B.  */
13505
13506 static struct bp_location *
13507 hoist_existing_locations (struct breakpoint *b, struct program_space *pspace)
13508 {
13509   struct bp_location head;
13510   struct bp_location *i = b->loc;
13511   struct bp_location **i_link = &b->loc;
13512   struct bp_location *hoisted = &head;
13513
13514   if (pspace == NULL)
13515     {
13516       i = b->loc;
13517       b->loc = NULL;
13518       return i;
13519     }
13520
13521   head.next = NULL;
13522
13523   while (i != NULL)
13524     {
13525       if (i->pspace == pspace)
13526         {
13527           *i_link = i->next;
13528           i->next = NULL;
13529           hoisted->next = i;
13530           hoisted = i;
13531         }
13532       else
13533         i_link = &i->next;
13534       i = *i_link;
13535     }
13536
13537   return head.next;
13538 }
13539
13540 /* Create new breakpoint locations for B (a hardware or software
13541    breakpoint) based on SALS and SALS_END.  If SALS_END.NELTS is not
13542    zero, then B is a ranged breakpoint.  Only recreates locations for
13543    FILTER_PSPACE.  Locations of other program spaces are left
13544    untouched.  */
13545
13546 void
13547 update_breakpoint_locations (struct breakpoint *b,
13548                              struct program_space *filter_pspace,
13549                              gdb::array_view<const symtab_and_line> sals,
13550                              gdb::array_view<const symtab_and_line> sals_end)
13551 {
13552   struct bp_location *existing_locations;
13553
13554   if (!sals_end.empty () && (sals.size () != 1 || sals_end.size () != 1))
13555     {
13556       /* Ranged breakpoints have only one start location and one end
13557          location.  */
13558       b->enable_state = bp_disabled;
13559       printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13560                            "multiple locations found\n"),
13561                          b->number);
13562       return;
13563     }
13564
13565   /* If there's no new locations, and all existing locations are
13566      pending, don't do anything.  This optimizes the common case where
13567      all locations are in the same shared library, that was unloaded.
13568      We'd like to retain the location, so that when the library is
13569      loaded again, we don't loose the enabled/disabled status of the
13570      individual locations.  */
13571   if (all_locations_are_pending (b, filter_pspace) && sals.empty ())
13572     return;
13573
13574   existing_locations = hoist_existing_locations (b, filter_pspace);
13575
13576   for (const auto &sal : sals)
13577     {
13578       struct bp_location *new_loc;
13579
13580       switch_to_program_space_and_thread (sal.pspace);
13581
13582       new_loc = add_location_to_breakpoint (b, &sal);
13583
13584       /* Reparse conditions, they might contain references to the
13585          old symtab.  */
13586       if (b->cond_string != NULL)
13587         {
13588           const char *s;
13589
13590           s = b->cond_string;
13591           TRY
13592             {
13593               new_loc->cond = parse_exp_1 (&s, sal.pc,
13594                                            block_for_pc (sal.pc),
13595                                            0);
13596             }
13597           CATCH (e, RETURN_MASK_ERROR)
13598             {
13599               warning (_("failed to reevaluate condition "
13600                          "for breakpoint %d: %s"), 
13601                        b->number, e.message);
13602               new_loc->enabled = 0;
13603             }
13604           END_CATCH
13605         }
13606
13607       if (!sals_end.empty ())
13608         {
13609           CORE_ADDR end = find_breakpoint_range_end (sals_end[0]);
13610
13611           new_loc->length = end - sals[0].pc + 1;
13612         }
13613     }
13614
13615   /* If possible, carry over 'disable' status from existing
13616      breakpoints.  */
13617   {
13618     struct bp_location *e = existing_locations;
13619     /* If there are multiple breakpoints with the same function name,
13620        e.g. for inline functions, comparing function names won't work.
13621        Instead compare pc addresses; this is just a heuristic as things
13622        may have moved, but in practice it gives the correct answer
13623        often enough until a better solution is found.  */
13624     int have_ambiguous_names = ambiguous_names_p (b->loc);
13625
13626     for (; e; e = e->next)
13627       {
13628         if (!e->enabled && e->function_name)
13629           {
13630             struct bp_location *l = b->loc;
13631             if (have_ambiguous_names)
13632               {
13633                 for (; l; l = l->next)
13634                   if (breakpoint_locations_match (e, l))
13635                     {
13636                       l->enabled = 0;
13637                       break;
13638                     }
13639               }
13640             else
13641               {
13642                 for (; l; l = l->next)
13643                   if (l->function_name
13644                       && strcmp (e->function_name, l->function_name) == 0)
13645                     {
13646                       l->enabled = 0;
13647                       break;
13648                     }
13649               }
13650           }
13651       }
13652   }
13653
13654   if (!locations_are_equal (existing_locations, b->loc))
13655     gdb::observers::breakpoint_modified.notify (b);
13656 }
13657
13658 /* Find the SaL locations corresponding to the given LOCATION.
13659    On return, FOUND will be 1 if any SaL was found, zero otherwise.  */
13660
13661 static std::vector<symtab_and_line>
13662 location_to_sals (struct breakpoint *b, struct event_location *location,
13663                   struct program_space *search_pspace, int *found)
13664 {
13665   struct gdb_exception exception = exception_none;
13666
13667   gdb_assert (b->ops != NULL);
13668
13669   std::vector<symtab_and_line> sals;
13670
13671   TRY
13672     {
13673       sals = b->ops->decode_location (b, location, search_pspace);
13674     }
13675   CATCH (e, RETURN_MASK_ERROR)
13676     {
13677       int not_found_and_ok = 0;
13678
13679       exception = e;
13680
13681       /* For pending breakpoints, it's expected that parsing will
13682          fail until the right shared library is loaded.  User has
13683          already told to create pending breakpoints and don't need
13684          extra messages.  If breakpoint is in bp_shlib_disabled
13685          state, then user already saw the message about that
13686          breakpoint being disabled, and don't want to see more
13687          errors.  */
13688       if (e.error == NOT_FOUND_ERROR
13689           && (b->condition_not_parsed
13690               || (b->loc != NULL
13691                   && search_pspace != NULL
13692                   && b->loc->pspace != search_pspace)
13693               || (b->loc && b->loc->shlib_disabled)
13694               || (b->loc && b->loc->pspace->executing_startup)
13695               || b->enable_state == bp_disabled))
13696         not_found_and_ok = 1;
13697
13698       if (!not_found_and_ok)
13699         {
13700           /* We surely don't want to warn about the same breakpoint
13701              10 times.  One solution, implemented here, is disable
13702              the breakpoint on error.  Another solution would be to
13703              have separate 'warning emitted' flag.  Since this
13704              happens only when a binary has changed, I don't know
13705              which approach is better.  */
13706           b->enable_state = bp_disabled;
13707           throw_exception (e);
13708         }
13709     }
13710   END_CATCH
13711
13712   if (exception.reason == 0 || exception.error != NOT_FOUND_ERROR)
13713     {
13714       for (auto &sal : sals)
13715         resolve_sal_pc (&sal);
13716       if (b->condition_not_parsed && b->extra_string != NULL)
13717         {
13718           char *cond_string, *extra_string;
13719           int thread, task;
13720
13721           find_condition_and_thread (b->extra_string, sals[0].pc,
13722                                      &cond_string, &thread, &task,
13723                                      &extra_string);
13724           gdb_assert (b->cond_string == NULL);
13725           if (cond_string)
13726             b->cond_string = cond_string;
13727           b->thread = thread;
13728           b->task = task;
13729           if (extra_string)
13730             {
13731               xfree (b->extra_string);
13732               b->extra_string = extra_string;
13733             }
13734           b->condition_not_parsed = 0;
13735         }
13736
13737       if (b->type == bp_static_tracepoint && !strace_marker_p (b))
13738         sals[0] = update_static_tracepoint (b, sals[0]);
13739
13740       *found = 1;
13741     }
13742   else
13743     *found = 0;
13744
13745   return sals;
13746 }
13747
13748 /* The default re_set method, for typical hardware or software
13749    breakpoints.  Reevaluate the breakpoint and recreate its
13750    locations.  */
13751
13752 static void
13753 breakpoint_re_set_default (struct breakpoint *b)
13754 {
13755   struct program_space *filter_pspace = current_program_space;
13756   std::vector<symtab_and_line> expanded, expanded_end;
13757
13758   int found;
13759   std::vector<symtab_and_line> sals = location_to_sals (b, b->location.get (),
13760                                                         filter_pspace, &found);
13761   if (found)
13762     expanded = std::move (sals);
13763
13764   if (b->location_range_end != NULL)
13765     {
13766       std::vector<symtab_and_line> sals_end
13767         = location_to_sals (b, b->location_range_end.get (),
13768                             filter_pspace, &found);
13769       if (found)
13770         expanded_end = std::move (sals_end);
13771     }
13772
13773   update_breakpoint_locations (b, filter_pspace, expanded, expanded_end);
13774 }
13775
13776 /* Default method for creating SALs from an address string.  It basically
13777    calls parse_breakpoint_sals.  Return 1 for success, zero for failure.  */
13778
13779 static void
13780 create_sals_from_location_default (const struct event_location *location,
13781                                    struct linespec_result *canonical,
13782                                    enum bptype type_wanted)
13783 {
13784   parse_breakpoint_sals (location, canonical);
13785 }
13786
13787 /* Call create_breakpoints_sal for the given arguments.  This is the default
13788    function for the `create_breakpoints_sal' method of
13789    breakpoint_ops.  */
13790
13791 static void
13792 create_breakpoints_sal_default (struct gdbarch *gdbarch,
13793                                 struct linespec_result *canonical,
13794                                 gdb::unique_xmalloc_ptr<char> cond_string,
13795                                 gdb::unique_xmalloc_ptr<char> extra_string,
13796                                 enum bptype type_wanted,
13797                                 enum bpdisp disposition,
13798                                 int thread,
13799                                 int task, int ignore_count,
13800                                 const struct breakpoint_ops *ops,
13801                                 int from_tty, int enabled,
13802                                 int internal, unsigned flags)
13803 {
13804   create_breakpoints_sal (gdbarch, canonical,
13805                           std::move (cond_string),
13806                           std::move (extra_string),
13807                           type_wanted, disposition,
13808                           thread, task, ignore_count, ops, from_tty,
13809                           enabled, internal, flags);
13810 }
13811
13812 /* Decode the line represented by S by calling decode_line_full.  This is the
13813    default function for the `decode_location' method of breakpoint_ops.  */
13814
13815 static std::vector<symtab_and_line>
13816 decode_location_default (struct breakpoint *b,
13817                          const struct event_location *location,
13818                          struct program_space *search_pspace)
13819 {
13820   struct linespec_result canonical;
13821
13822   decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, search_pspace,
13823                     (struct symtab *) NULL, 0,
13824                     &canonical, multiple_symbols_all,
13825                     b->filter);
13826
13827   /* We should get 0 or 1 resulting SALs.  */
13828   gdb_assert (canonical.lsals.size () < 2);
13829
13830   if (!canonical.lsals.empty ())
13831     {
13832       const linespec_sals &lsal = canonical.lsals[0];
13833       return std::move (lsal.sals);
13834     }
13835   return {};
13836 }
13837
13838 /* Reset a breakpoint.  */
13839
13840 static void
13841 breakpoint_re_set_one (breakpoint *b)
13842 {
13843   input_radix = b->input_radix;
13844   set_language (b->language);
13845
13846   b->ops->re_set (b);
13847 }
13848
13849 /* Re-set breakpoint locations for the current program space.
13850    Locations bound to other program spaces are left untouched.  */
13851
13852 void
13853 breakpoint_re_set (void)
13854 {
13855   struct breakpoint *b, *b_tmp;
13856
13857   {
13858     scoped_restore_current_language save_language;
13859     scoped_restore save_input_radix = make_scoped_restore (&input_radix);
13860     scoped_restore_current_pspace_and_thread restore_pspace_thread;
13861
13862     /* breakpoint_re_set_one sets the current_language to the language
13863        of the breakpoint it is resetting (see prepare_re_set_context)
13864        before re-evaluating the breakpoint's location.  This change can
13865        unfortunately get undone by accident if the language_mode is set
13866        to auto, and we either switch frames, or more likely in this context,
13867        we select the current frame.
13868
13869        We prevent this by temporarily turning the language_mode to
13870        language_mode_manual.  We restore it once all breakpoints
13871        have been reset.  */
13872     scoped_restore save_language_mode = make_scoped_restore (&language_mode);
13873     language_mode = language_mode_manual;
13874
13875     /* Note: we must not try to insert locations until after all
13876        breakpoints have been re-set.  Otherwise, e.g., when re-setting
13877        breakpoint 1, we'd insert the locations of breakpoint 2, which
13878        hadn't been re-set yet, and thus may have stale locations.  */
13879
13880     ALL_BREAKPOINTS_SAFE (b, b_tmp)
13881       {
13882         TRY
13883           {
13884             breakpoint_re_set_one (b);
13885           }
13886         CATCH (ex, RETURN_MASK_ALL)
13887           {
13888             exception_fprintf (gdb_stderr, ex,
13889                                "Error in re-setting breakpoint %d: ",
13890                                b->number);
13891           }
13892         END_CATCH
13893       }
13894
13895     jit_breakpoint_re_set ();
13896   }
13897
13898   create_overlay_event_breakpoint ();
13899   create_longjmp_master_breakpoint ();
13900   create_std_terminate_master_breakpoint ();
13901   create_exception_master_breakpoint ();
13902
13903   /* Now we can insert.  */
13904   update_global_location_list (UGLL_MAY_INSERT);
13905 }
13906 \f
13907 /* Reset the thread number of this breakpoint:
13908
13909    - If the breakpoint is for all threads, leave it as-is.
13910    - Else, reset it to the current thread for inferior_ptid.  */
13911 void
13912 breakpoint_re_set_thread (struct breakpoint *b)
13913 {
13914   if (b->thread != -1)
13915     {
13916       b->thread = inferior_thread ()->global_num;
13917
13918       /* We're being called after following a fork.  The new fork is
13919          selected as current, and unless this was a vfork will have a
13920          different program space from the original thread.  Reset that
13921          as well.  */
13922       b->loc->pspace = current_program_space;
13923     }
13924 }
13925
13926 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13927    If from_tty is nonzero, it prints a message to that effect,
13928    which ends with a period (no newline).  */
13929
13930 void
13931 set_ignore_count (int bptnum, int count, int from_tty)
13932 {
13933   struct breakpoint *b;
13934
13935   if (count < 0)
13936     count = 0;
13937
13938   ALL_BREAKPOINTS (b)
13939     if (b->number == bptnum)
13940     {
13941       if (is_tracepoint (b))
13942         {
13943           if (from_tty && count != 0)
13944             printf_filtered (_("Ignore count ignored for tracepoint %d."),
13945                              bptnum);
13946           return;
13947         }
13948       
13949       b->ignore_count = count;
13950       if (from_tty)
13951         {
13952           if (count == 0)
13953             printf_filtered (_("Will stop next time "
13954                                "breakpoint %d is reached."),
13955                              bptnum);
13956           else if (count == 1)
13957             printf_filtered (_("Will ignore next crossing of breakpoint %d."),
13958                              bptnum);
13959           else
13960             printf_filtered (_("Will ignore next %d "
13961                                "crossings of breakpoint %d."),
13962                              count, bptnum);
13963         }
13964       gdb::observers::breakpoint_modified.notify (b);
13965       return;
13966     }
13967
13968   error (_("No breakpoint number %d."), bptnum);
13969 }
13970
13971 /* Command to set ignore-count of breakpoint N to COUNT.  */
13972
13973 static void
13974 ignore_command (const char *args, int from_tty)
13975 {
13976   const char *p = args;
13977   int num;
13978
13979   if (p == 0)
13980     error_no_arg (_("a breakpoint number"));
13981
13982   num = get_number (&p);
13983   if (num == 0)
13984     error (_("bad breakpoint number: '%s'"), args);
13985   if (*p == 0)
13986     error (_("Second argument (specified ignore-count) is missing."));
13987
13988   set_ignore_count (num,
13989                     longest_to_int (value_as_long (parse_and_eval (p))),
13990                     from_tty);
13991   if (from_tty)
13992     printf_filtered ("\n");
13993 }
13994 \f
13995
13996 /* Call FUNCTION on each of the breakpoints with numbers in the range
13997    defined by BP_NUM_RANGE (an inclusive range).  */
13998
13999 static void
14000 map_breakpoint_number_range (std::pair<int, int> bp_num_range,
14001                              gdb::function_view<void (breakpoint *)> function)
14002 {
14003   if (bp_num_range.first == 0)
14004     {
14005       warning (_("bad breakpoint number at or near '%d'"),
14006                bp_num_range.first);
14007     }
14008   else
14009     {
14010       struct breakpoint *b, *tmp;
14011
14012       for (int i = bp_num_range.first; i <= bp_num_range.second; i++)
14013         {
14014           bool match = false;
14015
14016           ALL_BREAKPOINTS_SAFE (b, tmp)
14017             if (b->number == i)
14018               {
14019                 match = true;
14020                 function (b);
14021                 break;
14022               }
14023           if (!match)
14024             printf_unfiltered (_("No breakpoint number %d.\n"), i);
14025         }
14026     }
14027 }
14028
14029 /* Call FUNCTION on each of the breakpoints whose numbers are given in
14030    ARGS.  */
14031
14032 static void
14033 map_breakpoint_numbers (const char *args,
14034                         gdb::function_view<void (breakpoint *)> function)
14035 {
14036   if (args == NULL || *args == '\0')
14037     error_no_arg (_("one or more breakpoint numbers"));
14038
14039   number_or_range_parser parser (args);
14040
14041   while (!parser.finished ())
14042     {
14043       int num = parser.get_number ();
14044       map_breakpoint_number_range (std::make_pair (num, num), function);
14045     }
14046 }
14047
14048 /* Return the breakpoint location structure corresponding to the
14049    BP_NUM and LOC_NUM values.  */
14050
14051 static struct bp_location *
14052 find_location_by_number (int bp_num, int loc_num)
14053 {
14054   struct breakpoint *b;
14055
14056   ALL_BREAKPOINTS (b)
14057     if (b->number == bp_num)
14058       {
14059         break;
14060       }
14061
14062   if (!b || b->number != bp_num)
14063     error (_("Bad breakpoint number '%d'"), bp_num);
14064   
14065   if (loc_num == 0)
14066     error (_("Bad breakpoint location number '%d'"), loc_num);
14067
14068   int n = 0;
14069   for (bp_location *loc = b->loc; loc != NULL; loc = loc->next)
14070     if (++n == loc_num)
14071       return loc;
14072
14073   error (_("Bad breakpoint location number '%d'"), loc_num);
14074 }
14075
14076 /* Modes of operation for extract_bp_num.  */
14077 enum class extract_bp_kind
14078 {
14079   /* Extracting a breakpoint number.  */
14080   bp,
14081
14082   /* Extracting a location number.  */
14083   loc,
14084 };
14085
14086 /* Extract a breakpoint or location number (as determined by KIND)
14087    from the string starting at START.  TRAILER is a character which
14088    can be found after the number.  If you don't want a trailer, use
14089    '\0'.  If END_OUT is not NULL, it is set to point after the parsed
14090    string.  This always returns a positive integer.  */
14091
14092 static int
14093 extract_bp_num (extract_bp_kind kind, const char *start,
14094                 int trailer, const char **end_out = NULL)
14095 {
14096   const char *end = start;
14097   int num = get_number_trailer (&end, trailer);
14098   if (num < 0)
14099     error (kind == extract_bp_kind::bp
14100            ? _("Negative breakpoint number '%.*s'")
14101            : _("Negative breakpoint location number '%.*s'"),
14102            int (end - start), start);
14103   if (num == 0)
14104     error (kind == extract_bp_kind::bp
14105            ? _("Bad breakpoint number '%.*s'")
14106            : _("Bad breakpoint location number '%.*s'"),
14107            int (end - start), start);
14108
14109   if (end_out != NULL)
14110     *end_out = end;
14111   return num;
14112 }
14113
14114 /* Extract a breakpoint or location range (as determined by KIND) in
14115    the form NUM1-NUM2 stored at &ARG[arg_offset].  Returns a std::pair
14116    representing the (inclusive) range.  The returned pair's elements
14117    are always positive integers.  */
14118
14119 static std::pair<int, int>
14120 extract_bp_or_bp_range (extract_bp_kind kind,
14121                         const std::string &arg,
14122                         std::string::size_type arg_offset)
14123 {
14124   std::pair<int, int> range;
14125   const char *bp_loc = &arg[arg_offset];
14126   std::string::size_type dash = arg.find ('-', arg_offset);
14127   if (dash != std::string::npos)
14128     {
14129       /* bp_loc is a range (x-z).  */
14130       if (arg.length () == dash + 1)
14131         error (kind == extract_bp_kind::bp
14132                ? _("Bad breakpoint number at or near: '%s'")
14133                : _("Bad breakpoint location number at or near: '%s'"),
14134                bp_loc);
14135
14136       const char *end;
14137       const char *start_first = bp_loc;
14138       const char *start_second = &arg[dash + 1];
14139       range.first = extract_bp_num (kind, start_first, '-');
14140       range.second = extract_bp_num (kind, start_second, '\0', &end);
14141
14142       if (range.first > range.second)
14143         error (kind == extract_bp_kind::bp
14144                ? _("Inverted breakpoint range at '%.*s'")
14145                : _("Inverted breakpoint location range at '%.*s'"),
14146                int (end - start_first), start_first);
14147     }
14148   else
14149     {
14150       /* bp_loc is a single value.  */
14151       range.first = extract_bp_num (kind, bp_loc, '\0');
14152       range.second = range.first;
14153     }
14154   return range;
14155 }
14156
14157 /* Extract the breakpoint/location range specified by ARG.  Returns
14158    the breakpoint range in BP_NUM_RANGE, and the location range in
14159    BP_LOC_RANGE.
14160
14161    ARG may be in any of the following forms:
14162
14163    x     where 'x' is a breakpoint number.
14164    x-y   where 'x' and 'y' specify a breakpoint numbers range.
14165    x.y   where 'x' is a breakpoint number and 'y' a location number.
14166    x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14167          location number range.
14168 */
14169
14170 static void
14171 extract_bp_number_and_location (const std::string &arg,
14172                                 std::pair<int, int> &bp_num_range,
14173                                 std::pair<int, int> &bp_loc_range)
14174 {
14175   std::string::size_type dot = arg.find ('.');
14176
14177   if (dot != std::string::npos)
14178     {
14179       /* Handle 'x.y' and 'x.y-z' cases.  */
14180
14181       if (arg.length () == dot + 1 || dot == 0)
14182         error (_("Bad breakpoint number at or near: '%s'"), arg.c_str ());
14183
14184       bp_num_range.first
14185         = extract_bp_num (extract_bp_kind::bp, arg.c_str (), '.');
14186       bp_num_range.second = bp_num_range.first;
14187
14188       bp_loc_range = extract_bp_or_bp_range (extract_bp_kind::loc,
14189                                              arg, dot + 1);
14190     }
14191   else
14192     {
14193       /* Handle x and x-y cases.  */
14194
14195       bp_num_range = extract_bp_or_bp_range (extract_bp_kind::bp, arg, 0);
14196       bp_loc_range.first = 0;
14197       bp_loc_range.second = 0;
14198     }
14199 }
14200
14201 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM.  ENABLE
14202    specifies whether to enable or disable.  */
14203
14204 static void
14205 enable_disable_bp_num_loc (int bp_num, int loc_num, bool enable)
14206 {
14207   struct bp_location *loc = find_location_by_number (bp_num, loc_num);
14208   if (loc != NULL)
14209     {
14210       if (loc->enabled != enable)
14211         {
14212           loc->enabled = enable;
14213           mark_breakpoint_location_modified (loc);
14214         }
14215       if (target_supports_enable_disable_tracepoint ()
14216           && current_trace_status ()->running && loc->owner
14217           && is_tracepoint (loc->owner))
14218         target_disable_tracepoint (loc);
14219     }
14220   update_global_location_list (UGLL_DONT_INSERT);
14221
14222   gdb::observers::breakpoint_modified.notify (loc->owner);
14223 }
14224
14225 /* Enable or disable a range of breakpoint locations.  BP_NUM is the
14226    number of the breakpoint, and BP_LOC_RANGE specifies the
14227    (inclusive) range of location numbers of that breakpoint to
14228    enable/disable.  ENABLE specifies whether to enable or disable the
14229    location.  */
14230
14231 static void
14232 enable_disable_breakpoint_location_range (int bp_num,
14233                                           std::pair<int, int> &bp_loc_range,
14234                                           bool enable)
14235 {
14236   for (int i = bp_loc_range.first; i <= bp_loc_range.second; i++)
14237     enable_disable_bp_num_loc (bp_num, i, enable);
14238 }
14239
14240 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14241    If from_tty is nonzero, it prints a message to that effect,
14242    which ends with a period (no newline).  */
14243
14244 void
14245 disable_breakpoint (struct breakpoint *bpt)
14246 {
14247   /* Never disable a watchpoint scope breakpoint; we want to
14248      hit them when we leave scope so we can delete both the
14249      watchpoint and its scope breakpoint at that time.  */
14250   if (bpt->type == bp_watchpoint_scope)
14251     return;
14252
14253   bpt->enable_state = bp_disabled;
14254
14255   /* Mark breakpoint locations modified.  */
14256   mark_breakpoint_modified (bpt);
14257
14258   if (target_supports_enable_disable_tracepoint ()
14259       && current_trace_status ()->running && is_tracepoint (bpt))
14260     {
14261       struct bp_location *location;
14262      
14263       for (location = bpt->loc; location; location = location->next)
14264         target_disable_tracepoint (location);
14265     }
14266
14267   update_global_location_list (UGLL_DONT_INSERT);
14268
14269   gdb::observers::breakpoint_modified.notify (bpt);
14270 }
14271
14272 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14273    specified in ARGS.  ARGS may be in any of the formats handled by
14274    extract_bp_number_and_location.  ENABLE specifies whether to enable
14275    or disable the breakpoints/locations.  */
14276
14277 static void
14278 enable_disable_command (const char *args, int from_tty, bool enable)
14279 {
14280   if (args == 0)
14281     {
14282       struct breakpoint *bpt;
14283
14284       ALL_BREAKPOINTS (bpt)
14285         if (user_breakpoint_p (bpt))
14286           {
14287             if (enable)
14288               enable_breakpoint (bpt);
14289             else
14290               disable_breakpoint (bpt);
14291           }
14292     }
14293   else
14294     {
14295       std::string num = extract_arg (&args);
14296
14297       while (!num.empty ())
14298         {
14299           std::pair<int, int> bp_num_range, bp_loc_range;
14300
14301           extract_bp_number_and_location (num, bp_num_range, bp_loc_range);
14302
14303           if (bp_loc_range.first == bp_loc_range.second
14304               && bp_loc_range.first == 0)
14305             {
14306               /* Handle breakpoint ids with formats 'x' or 'x-z'.  */
14307               map_breakpoint_number_range (bp_num_range,
14308                                            enable
14309                                            ? enable_breakpoint
14310                                            : disable_breakpoint);
14311             }
14312           else
14313             {
14314               /* Handle breakpoint ids with formats 'x.y' or
14315                  'x.y-z'.  */
14316               enable_disable_breakpoint_location_range
14317                 (bp_num_range.first, bp_loc_range, enable);
14318             }
14319           num = extract_arg (&args);
14320         }
14321     }
14322 }
14323
14324 /* The disable command disables the specified breakpoints/locations
14325    (or all defined breakpoints) so they're no longer effective in
14326    stopping the inferior.  ARGS may be in any of the forms defined in
14327    extract_bp_number_and_location.  */
14328
14329 static void
14330 disable_command (const char *args, int from_tty)
14331 {
14332   enable_disable_command (args, from_tty, false);
14333 }
14334
14335 static void
14336 enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14337                         int count)
14338 {
14339   int target_resources_ok;
14340
14341   if (bpt->type == bp_hardware_breakpoint)
14342     {
14343       int i;
14344       i = hw_breakpoint_used_count ();
14345       target_resources_ok = 
14346         target_can_use_hardware_watchpoint (bp_hardware_breakpoint, 
14347                                             i + 1, 0);
14348       if (target_resources_ok == 0)
14349         error (_("No hardware breakpoint support in the target."));
14350       else if (target_resources_ok < 0)
14351         error (_("Hardware breakpoints used exceeds limit."));
14352     }
14353
14354   if (is_watchpoint (bpt))
14355     {
14356       /* Initialize it just to avoid a GCC false warning.  */
14357       enum enable_state orig_enable_state = bp_disabled;
14358
14359       TRY
14360         {
14361           struct watchpoint *w = (struct watchpoint *) bpt;
14362
14363           orig_enable_state = bpt->enable_state;
14364           bpt->enable_state = bp_enabled;
14365           update_watchpoint (w, 1 /* reparse */);
14366         }
14367       CATCH (e, RETURN_MASK_ALL)
14368         {
14369           bpt->enable_state = orig_enable_state;
14370           exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14371                              bpt->number);
14372           return;
14373         }
14374       END_CATCH
14375     }
14376
14377   bpt->enable_state = bp_enabled;
14378
14379   /* Mark breakpoint locations modified.  */
14380   mark_breakpoint_modified (bpt);
14381
14382   if (target_supports_enable_disable_tracepoint ()
14383       && current_trace_status ()->running && is_tracepoint (bpt))
14384     {
14385       struct bp_location *location;
14386
14387       for (location = bpt->loc; location; location = location->next)
14388         target_enable_tracepoint (location);
14389     }
14390
14391   bpt->disposition = disposition;
14392   bpt->enable_count = count;
14393   update_global_location_list (UGLL_MAY_INSERT);
14394
14395   gdb::observers::breakpoint_modified.notify (bpt);
14396 }
14397
14398
14399 void
14400 enable_breakpoint (struct breakpoint *bpt)
14401 {
14402   enable_breakpoint_disp (bpt, bpt->disposition, 0);
14403 }
14404
14405 /* The enable command enables the specified breakpoints/locations (or
14406    all defined breakpoints) so they once again become (or continue to
14407    be) effective in stopping the inferior.  ARGS may be in any of the
14408    forms defined in extract_bp_number_and_location.  */
14409
14410 static void
14411 enable_command (const char *args, int from_tty)
14412 {
14413   enable_disable_command (args, from_tty, true);
14414 }
14415
14416 static void
14417 enable_once_command (const char *args, int from_tty)
14418 {
14419   map_breakpoint_numbers
14420     (args, [&] (breakpoint *b)
14421      {
14422        iterate_over_related_breakpoints
14423          (b, [&] (breakpoint *bpt)
14424           {
14425             enable_breakpoint_disp (bpt, disp_disable, 1);
14426           });
14427      });
14428 }
14429
14430 static void
14431 enable_count_command (const char *args, int from_tty)
14432 {
14433   int count;
14434
14435   if (args == NULL)
14436     error_no_arg (_("hit count"));
14437
14438   count = get_number (&args);
14439
14440   map_breakpoint_numbers
14441     (args, [&] (breakpoint *b)
14442      {
14443        iterate_over_related_breakpoints
14444          (b, [&] (breakpoint *bpt)
14445           {
14446             enable_breakpoint_disp (bpt, disp_disable, count);
14447           });
14448      });
14449 }
14450
14451 static void
14452 enable_delete_command (const char *args, int from_tty)
14453 {
14454   map_breakpoint_numbers
14455     (args, [&] (breakpoint *b)
14456      {
14457        iterate_over_related_breakpoints
14458          (b, [&] (breakpoint *bpt)
14459           {
14460             enable_breakpoint_disp (bpt, disp_del, 1);
14461           });
14462      });
14463 }
14464 \f
14465 static void
14466 set_breakpoint_cmd (const char *args, int from_tty)
14467 {
14468 }
14469
14470 static void
14471 show_breakpoint_cmd (const char *args, int from_tty)
14472 {
14473 }
14474
14475 /* Invalidate last known value of any hardware watchpoint if
14476    the memory which that value represents has been written to by
14477    GDB itself.  */
14478
14479 static void
14480 invalidate_bp_value_on_memory_change (struct inferior *inferior,
14481                                       CORE_ADDR addr, ssize_t len,
14482                                       const bfd_byte *data)
14483 {
14484   struct breakpoint *bp;
14485
14486   ALL_BREAKPOINTS (bp)
14487     if (bp->enable_state == bp_enabled
14488         && bp->type == bp_hardware_watchpoint)
14489       {
14490         struct watchpoint *wp = (struct watchpoint *) bp;
14491
14492         if (wp->val_valid && wp->val != nullptr)
14493           {
14494             struct bp_location *loc;
14495
14496             for (loc = bp->loc; loc != NULL; loc = loc->next)
14497               if (loc->loc_type == bp_loc_hardware_watchpoint
14498                   && loc->address + loc->length > addr
14499                   && addr + len > loc->address)
14500                 {
14501                   wp->val = NULL;
14502                   wp->val_valid = 0;
14503                 }
14504           }
14505       }
14506 }
14507
14508 /* Create and insert a breakpoint for software single step.  */
14509
14510 void
14511 insert_single_step_breakpoint (struct gdbarch *gdbarch,
14512                                const address_space *aspace,
14513                                CORE_ADDR next_pc)
14514 {
14515   struct thread_info *tp = inferior_thread ();
14516   struct symtab_and_line sal;
14517   CORE_ADDR pc = next_pc;
14518
14519   if (tp->control.single_step_breakpoints == NULL)
14520     {
14521       tp->control.single_step_breakpoints
14522         = new_single_step_breakpoint (tp->global_num, gdbarch);
14523     }
14524
14525   sal = find_pc_line (pc, 0);
14526   sal.pc = pc;
14527   sal.section = find_pc_overlay (pc);
14528   sal.explicit_pc = 1;
14529   add_location_to_breakpoint (tp->control.single_step_breakpoints, &sal);
14530
14531   update_global_location_list (UGLL_INSERT);
14532 }
14533
14534 /* Insert single step breakpoints according to the current state.  */
14535
14536 int
14537 insert_single_step_breakpoints (struct gdbarch *gdbarch)
14538 {
14539   struct regcache *regcache = get_current_regcache ();
14540   std::vector<CORE_ADDR> next_pcs;
14541
14542   next_pcs = gdbarch_software_single_step (gdbarch, regcache);
14543
14544   if (!next_pcs.empty ())
14545     {
14546       struct frame_info *frame = get_current_frame ();
14547       const address_space *aspace = get_frame_address_space (frame);
14548
14549       for (CORE_ADDR pc : next_pcs)
14550         insert_single_step_breakpoint (gdbarch, aspace, pc);
14551
14552       return 1;
14553     }
14554   else
14555     return 0;
14556 }
14557
14558 /* See breakpoint.h.  */
14559
14560 int
14561 breakpoint_has_location_inserted_here (struct breakpoint *bp,
14562                                        const address_space *aspace,
14563                                        CORE_ADDR pc)
14564 {
14565   struct bp_location *loc;
14566
14567   for (loc = bp->loc; loc != NULL; loc = loc->next)
14568     if (loc->inserted
14569         && breakpoint_location_address_match (loc, aspace, pc))
14570       return 1;
14571
14572   return 0;
14573 }
14574
14575 /* Check whether a software single-step breakpoint is inserted at
14576    PC.  */
14577
14578 int
14579 single_step_breakpoint_inserted_here_p (const address_space *aspace,
14580                                         CORE_ADDR pc)
14581 {
14582   struct breakpoint *bpt;
14583
14584   ALL_BREAKPOINTS (bpt)
14585     {
14586       if (bpt->type == bp_single_step
14587           && breakpoint_has_location_inserted_here (bpt, aspace, pc))
14588         return 1;
14589     }
14590   return 0;
14591 }
14592
14593 /* Tracepoint-specific operations.  */
14594
14595 /* Set tracepoint count to NUM.  */
14596 static void
14597 set_tracepoint_count (int num)
14598 {
14599   tracepoint_count = num;
14600   set_internalvar_integer (lookup_internalvar ("tpnum"), num);
14601 }
14602
14603 static void
14604 trace_command (const char *arg, int from_tty)
14605 {
14606   struct breakpoint_ops *ops;
14607
14608   event_location_up location = string_to_event_location (&arg,
14609                                                          current_language);
14610   if (location != NULL
14611       && event_location_type (location.get ()) == PROBE_LOCATION)
14612     ops = &tracepoint_probe_breakpoint_ops;
14613   else
14614     ops = &tracepoint_breakpoint_ops;
14615
14616   create_breakpoint (get_current_arch (),
14617                      location.get (),
14618                      NULL, 0, arg, 1 /* parse arg */,
14619                      0 /* tempflag */,
14620                      bp_tracepoint /* type_wanted */,
14621                      0 /* Ignore count */,
14622                      pending_break_support,
14623                      ops,
14624                      from_tty,
14625                      1 /* enabled */,
14626                      0 /* internal */, 0);
14627 }
14628
14629 static void
14630 ftrace_command (const char *arg, int from_tty)
14631 {
14632   event_location_up location = string_to_event_location (&arg,
14633                                                          current_language);
14634   create_breakpoint (get_current_arch (),
14635                      location.get (),
14636                      NULL, 0, arg, 1 /* parse arg */,
14637                      0 /* tempflag */,
14638                      bp_fast_tracepoint /* type_wanted */,
14639                      0 /* Ignore count */,
14640                      pending_break_support,
14641                      &tracepoint_breakpoint_ops,
14642                      from_tty,
14643                      1 /* enabled */,
14644                      0 /* internal */, 0);
14645 }
14646
14647 /* strace command implementation.  Creates a static tracepoint.  */
14648
14649 static void
14650 strace_command (const char *arg, int from_tty)
14651 {
14652   struct breakpoint_ops *ops;
14653   event_location_up location;
14654
14655   /* Decide if we are dealing with a static tracepoint marker (`-m'),
14656      or with a normal static tracepoint.  */
14657   if (arg && startswith (arg, "-m") && isspace (arg[2]))
14658     {
14659       ops = &strace_marker_breakpoint_ops;
14660       location = new_linespec_location (&arg, symbol_name_match_type::FULL);
14661     }
14662   else
14663     {
14664       ops = &tracepoint_breakpoint_ops;
14665       location = string_to_event_location (&arg, current_language);
14666     }
14667
14668   create_breakpoint (get_current_arch (),
14669                      location.get (),
14670                      NULL, 0, arg, 1 /* parse arg */,
14671                      0 /* tempflag */,
14672                      bp_static_tracepoint /* type_wanted */,
14673                      0 /* Ignore count */,
14674                      pending_break_support,
14675                      ops,
14676                      from_tty,
14677                      1 /* enabled */,
14678                      0 /* internal */, 0);
14679 }
14680
14681 /* Set up a fake reader function that gets command lines from a linked
14682    list that was acquired during tracepoint uploading.  */
14683
14684 static struct uploaded_tp *this_utp;
14685 static int next_cmd;
14686
14687 static char *
14688 read_uploaded_action (void)
14689 {
14690   char *rslt = nullptr;
14691
14692   if (next_cmd < this_utp->cmd_strings.size ())
14693     {
14694       rslt = this_utp->cmd_strings[next_cmd];
14695       next_cmd++;
14696     }
14697
14698   return rslt;
14699 }
14700
14701 /* Given information about a tracepoint as recorded on a target (which
14702    can be either a live system or a trace file), attempt to create an
14703    equivalent GDB tracepoint.  This is not a reliable process, since
14704    the target does not necessarily have all the information used when
14705    the tracepoint was originally defined.  */
14706   
14707 struct tracepoint *
14708 create_tracepoint_from_upload (struct uploaded_tp *utp)
14709 {
14710   const char *addr_str;
14711   char small_buf[100];
14712   struct tracepoint *tp;
14713
14714   if (utp->at_string)
14715     addr_str = utp->at_string;
14716   else
14717     {
14718       /* In the absence of a source location, fall back to raw
14719          address.  Since there is no way to confirm that the address
14720          means the same thing as when the trace was started, warn the
14721          user.  */
14722       warning (_("Uploaded tracepoint %d has no "
14723                  "source location, using raw address"),
14724                utp->number);
14725       xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (utp->addr));
14726       addr_str = small_buf;
14727     }
14728
14729   /* There's not much we can do with a sequence of bytecodes.  */
14730   if (utp->cond && !utp->cond_string)
14731     warning (_("Uploaded tracepoint %d condition "
14732                "has no source form, ignoring it"),
14733              utp->number);
14734
14735   event_location_up location = string_to_event_location (&addr_str,
14736                                                          current_language);
14737   if (!create_breakpoint (get_current_arch (),
14738                           location.get (),
14739                           utp->cond_string, -1, addr_str,
14740                           0 /* parse cond/thread */,
14741                           0 /* tempflag */,
14742                           utp->type /* type_wanted */,
14743                           0 /* Ignore count */,
14744                           pending_break_support,
14745                           &tracepoint_breakpoint_ops,
14746                           0 /* from_tty */,
14747                           utp->enabled /* enabled */,
14748                           0 /* internal */,
14749                           CREATE_BREAKPOINT_FLAGS_INSERTED))
14750     return NULL;
14751
14752   /* Get the tracepoint we just created.  */
14753   tp = get_tracepoint (tracepoint_count);
14754   gdb_assert (tp != NULL);
14755
14756   if (utp->pass > 0)
14757     {
14758       xsnprintf (small_buf, sizeof (small_buf), "%d %d", utp->pass,
14759                  tp->number);
14760
14761       trace_pass_command (small_buf, 0);
14762     }
14763
14764   /* If we have uploaded versions of the original commands, set up a
14765      special-purpose "reader" function and call the usual command line
14766      reader, then pass the result to the breakpoint command-setting
14767      function.  */
14768   if (!utp->cmd_strings.empty ())
14769     {
14770       counted_command_line cmd_list;
14771
14772       this_utp = utp;
14773       next_cmd = 0;
14774
14775       cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL);
14776
14777       breakpoint_set_commands (tp, std::move (cmd_list));
14778     }
14779   else if (!utp->actions.empty ()
14780            || !utp->step_actions.empty ())
14781     warning (_("Uploaded tracepoint %d actions "
14782                "have no source form, ignoring them"),
14783              utp->number);
14784
14785   /* Copy any status information that might be available.  */
14786   tp->hit_count = utp->hit_count;
14787   tp->traceframe_usage = utp->traceframe_usage;
14788
14789   return tp;
14790 }
14791   
14792 /* Print information on tracepoint number TPNUM_EXP, or all if
14793    omitted.  */
14794
14795 static void
14796 info_tracepoints_command (const char *args, int from_tty)
14797 {
14798   struct ui_out *uiout = current_uiout;
14799   int num_printed;
14800
14801   num_printed = breakpoint_1 (args, 0, is_tracepoint);
14802
14803   if (num_printed == 0)
14804     {
14805       if (args == NULL || *args == '\0')
14806         uiout->message ("No tracepoints.\n");
14807       else
14808         uiout->message ("No tracepoint matching '%s'.\n", args);
14809     }
14810
14811   default_collect_info ();
14812 }
14813
14814 /* The 'enable trace' command enables tracepoints.
14815    Not supported by all targets.  */
14816 static void
14817 enable_trace_command (const char *args, int from_tty)
14818 {
14819   enable_command (args, from_tty);
14820 }
14821
14822 /* The 'disable trace' command disables tracepoints.
14823    Not supported by all targets.  */
14824 static void
14825 disable_trace_command (const char *args, int from_tty)
14826 {
14827   disable_command (args, from_tty);
14828 }
14829
14830 /* Remove a tracepoint (or all if no argument).  */
14831 static void
14832 delete_trace_command (const char *arg, int from_tty)
14833 {
14834   struct breakpoint *b, *b_tmp;
14835
14836   dont_repeat ();
14837
14838   if (arg == 0)
14839     {
14840       int breaks_to_delete = 0;
14841
14842       /* Delete all breakpoints if no argument.
14843          Do not delete internal or call-dummy breakpoints, these
14844          have to be deleted with an explicit breakpoint number 
14845          argument.  */
14846       ALL_TRACEPOINTS (b)
14847         if (is_tracepoint (b) && user_breakpoint_p (b))
14848           {
14849             breaks_to_delete = 1;
14850             break;
14851           }
14852
14853       /* Ask user only if there are some breakpoints to delete.  */
14854       if (!from_tty
14855           || (breaks_to_delete && query (_("Delete all tracepoints? "))))
14856         {
14857           ALL_BREAKPOINTS_SAFE (b, b_tmp)
14858             if (is_tracepoint (b) && user_breakpoint_p (b))
14859               delete_breakpoint (b);
14860         }
14861     }
14862   else
14863     map_breakpoint_numbers
14864       (arg, [&] (breakpoint *b)
14865        {
14866          iterate_over_related_breakpoints (b, delete_breakpoint);
14867        });
14868 }
14869
14870 /* Helper function for trace_pass_command.  */
14871
14872 static void
14873 trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
14874 {
14875   tp->pass_count = count;
14876   gdb::observers::breakpoint_modified.notify (tp);
14877   if (from_tty)
14878     printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14879                      tp->number, count);
14880 }
14881
14882 /* Set passcount for tracepoint.
14883
14884    First command argument is passcount, second is tracepoint number.
14885    If tracepoint number omitted, apply to most recently defined.
14886    Also accepts special argument "all".  */
14887
14888 static void
14889 trace_pass_command (const char *args, int from_tty)
14890 {
14891   struct tracepoint *t1;
14892   ULONGEST count;
14893
14894   if (args == 0 || *args == 0)
14895     error (_("passcount command requires an "
14896              "argument (count + optional TP num)"));
14897
14898   count = strtoulst (args, &args, 10);  /* Count comes first, then TP num.  */
14899
14900   args = skip_spaces (args);
14901   if (*args && strncasecmp (args, "all", 3) == 0)
14902     {
14903       struct breakpoint *b;
14904
14905       args += 3;                        /* Skip special argument "all".  */
14906       if (*args)
14907         error (_("Junk at end of arguments."));
14908
14909       ALL_TRACEPOINTS (b)
14910       {
14911         t1 = (struct tracepoint *) b;
14912         trace_pass_set_count (t1, count, from_tty);
14913       }
14914     }
14915   else if (*args == '\0')
14916     {
14917       t1 = get_tracepoint_by_number (&args, NULL);
14918       if (t1)
14919         trace_pass_set_count (t1, count, from_tty);
14920     }
14921   else
14922     {
14923       number_or_range_parser parser (args);
14924       while (!parser.finished ())
14925         {
14926           t1 = get_tracepoint_by_number (&args, &parser);
14927           if (t1)
14928             trace_pass_set_count (t1, count, from_tty);
14929         }
14930     }
14931 }
14932
14933 struct tracepoint *
14934 get_tracepoint (int num)
14935 {
14936   struct breakpoint *t;
14937
14938   ALL_TRACEPOINTS (t)
14939     if (t->number == num)
14940       return (struct tracepoint *) t;
14941
14942   return NULL;
14943 }
14944
14945 /* Find the tracepoint with the given target-side number (which may be
14946    different from the tracepoint number after disconnecting and
14947    reconnecting).  */
14948
14949 struct tracepoint *
14950 get_tracepoint_by_number_on_target (int num)
14951 {
14952   struct breakpoint *b;
14953
14954   ALL_TRACEPOINTS (b)
14955     {
14956       struct tracepoint *t = (struct tracepoint *) b;
14957
14958       if (t->number_on_target == num)
14959         return t;
14960     }
14961
14962   return NULL;
14963 }
14964
14965 /* Utility: parse a tracepoint number and look it up in the list.
14966    If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
14967    If the argument is missing, the most recent tracepoint
14968    (tracepoint_count) is returned.  */
14969
14970 struct tracepoint *
14971 get_tracepoint_by_number (const char **arg,
14972                           number_or_range_parser *parser)
14973 {
14974   struct breakpoint *t;
14975   int tpnum;
14976   const char *instring = arg == NULL ? NULL : *arg;
14977
14978   if (parser != NULL)
14979     {
14980       gdb_assert (!parser->finished ());
14981       tpnum = parser->get_number ();
14982     }
14983   else if (arg == NULL || *arg == NULL || ! **arg)
14984     tpnum = tracepoint_count;
14985   else
14986     tpnum = get_number (arg);
14987
14988   if (tpnum <= 0)
14989     {
14990       if (instring && *instring)
14991         printf_filtered (_("bad tracepoint number at or near '%s'\n"), 
14992                          instring);
14993       else
14994         printf_filtered (_("No previous tracepoint\n"));
14995       return NULL;
14996     }
14997
14998   ALL_TRACEPOINTS (t)
14999     if (t->number == tpnum)
15000     {
15001       return (struct tracepoint *) t;
15002     }
15003
15004   printf_unfiltered ("No tracepoint number %d.\n", tpnum);
15005   return NULL;
15006 }
15007
15008 void
15009 print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
15010 {
15011   if (b->thread != -1)
15012     fprintf_unfiltered (fp, " thread %d", b->thread);
15013
15014   if (b->task != 0)
15015     fprintf_unfiltered (fp, " task %d", b->task);
15016
15017   fprintf_unfiltered (fp, "\n");
15018 }
15019
15020 /* Save information on user settable breakpoints (watchpoints, etc) to
15021    a new script file named FILENAME.  If FILTER is non-NULL, call it
15022    on each breakpoint and only include the ones for which it returns
15023    non-zero.  */
15024
15025 static void
15026 save_breakpoints (const char *filename, int from_tty,
15027                   int (*filter) (const struct breakpoint *))
15028 {
15029   struct breakpoint *tp;
15030   int any = 0;
15031   int extra_trace_bits = 0;
15032
15033   if (filename == 0 || *filename == 0)
15034     error (_("Argument required (file name in which to save)"));
15035
15036   /* See if we have anything to save.  */
15037   ALL_BREAKPOINTS (tp)
15038   {
15039     /* Skip internal and momentary breakpoints.  */
15040     if (!user_breakpoint_p (tp))
15041       continue;
15042
15043     /* If we have a filter, only save the breakpoints it accepts.  */
15044     if (filter && !filter (tp))
15045       continue;
15046
15047     any = 1;
15048
15049     if (is_tracepoint (tp))
15050       {
15051         extra_trace_bits = 1;
15052
15053         /* We can stop searching.  */
15054         break;
15055       }
15056   }
15057
15058   if (!any)
15059     {
15060       warning (_("Nothing to save."));
15061       return;
15062     }
15063
15064   gdb::unique_xmalloc_ptr<char> expanded_filename (tilde_expand (filename));
15065
15066   stdio_file fp;
15067
15068   if (!fp.open (expanded_filename.get (), "w"))
15069     error (_("Unable to open file '%s' for saving (%s)"),
15070            expanded_filename.get (), safe_strerror (errno));
15071
15072   if (extra_trace_bits)
15073     save_trace_state_variables (&fp);
15074
15075   ALL_BREAKPOINTS (tp)
15076   {
15077     /* Skip internal and momentary breakpoints.  */
15078     if (!user_breakpoint_p (tp))
15079       continue;
15080
15081     /* If we have a filter, only save the breakpoints it accepts.  */
15082     if (filter && !filter (tp))
15083       continue;
15084
15085     tp->ops->print_recreate (tp, &fp);
15086
15087     /* Note, we can't rely on tp->number for anything, as we can't
15088        assume the recreated breakpoint numbers will match.  Use $bpnum
15089        instead.  */
15090
15091     if (tp->cond_string)
15092       fp.printf ("  condition $bpnum %s\n", tp->cond_string);
15093
15094     if (tp->ignore_count)
15095       fp.printf ("  ignore $bpnum %d\n", tp->ignore_count);
15096
15097     if (tp->type != bp_dprintf && tp->commands)
15098       {
15099         fp.puts ("  commands\n");
15100         
15101         current_uiout->redirect (&fp);
15102         TRY
15103           {
15104             print_command_lines (current_uiout, tp->commands.get (), 2);
15105           }
15106         CATCH (ex, RETURN_MASK_ALL)
15107           {
15108           current_uiout->redirect (NULL);
15109             throw_exception (ex);
15110           }
15111         END_CATCH
15112
15113         current_uiout->redirect (NULL);
15114         fp.puts ("  end\n");
15115       }
15116
15117     if (tp->enable_state == bp_disabled)
15118       fp.puts ("disable $bpnum\n");
15119
15120     /* If this is a multi-location breakpoint, check if the locations
15121        should be individually disabled.  Watchpoint locations are
15122        special, and not user visible.  */
15123     if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15124       {
15125         struct bp_location *loc;
15126         int n = 1;
15127
15128         for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15129           if (!loc->enabled)
15130             fp.printf ("disable $bpnum.%d\n", n);
15131       }
15132   }
15133
15134   if (extra_trace_bits && *default_collect)
15135     fp.printf ("set default-collect %s\n", default_collect);
15136
15137   if (from_tty)
15138     printf_filtered (_("Saved to file '%s'.\n"), expanded_filename.get ());
15139 }
15140
15141 /* The `save breakpoints' command.  */
15142
15143 static void
15144 save_breakpoints_command (const char *args, int from_tty)
15145 {
15146   save_breakpoints (args, from_tty, NULL);
15147 }
15148
15149 /* The `save tracepoints' command.  */
15150
15151 static void
15152 save_tracepoints_command (const char *args, int from_tty)
15153 {
15154   save_breakpoints (args, from_tty, is_tracepoint);
15155 }
15156
15157 /* Create a vector of all tracepoints.  */
15158
15159 std::vector<breakpoint *>
15160 all_tracepoints (void)
15161 {
15162   std::vector<breakpoint *> tp_vec;
15163   struct breakpoint *tp;
15164
15165   ALL_TRACEPOINTS (tp)
15166   {
15167     tp_vec.push_back (tp);
15168   }
15169
15170   return tp_vec;
15171 }
15172
15173 \f
15174 /* This help string is used to consolidate all the help string for specifying
15175    locations used by several commands.  */
15176
15177 #define LOCATION_HELP_STRING \
15178 "Linespecs are colon-separated lists of location parameters, such as\n\
15179 source filename, function name, label name, and line number.\n\
15180 Example: To specify the start of a label named \"the_top\" in the\n\
15181 function \"fact\" in the file \"factorial.c\", use\n\
15182 \"factorial.c:fact:the_top\".\n\
15183 \n\
15184 Address locations begin with \"*\" and specify an exact address in the\n\
15185 program.  Example: To specify the fourth byte past the start function\n\
15186 \"main\", use \"*main + 4\".\n\
15187 \n\
15188 Explicit locations are similar to linespecs but use an option/argument\n\
15189 syntax to specify location parameters.\n\
15190 Example: To specify the start of the label named \"the_top\" in the\n\
15191 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15192 -function fact -label the_top\".\n\
15193 \n\
15194 By default, a specified function is matched against the program's\n\
15195 functions in all scopes.  For C++, this means in all namespaces and\n\
15196 classes.  For Ada, this means in all packages.  E.g., in C++,\n\
15197 \"func()\" matches \"A::func()\", \"A::B::func()\", etc.  The\n\
15198 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15199 specified name as a complete fully-qualified name instead.\n"
15200
15201 /* This help string is used for the break, hbreak, tbreak and thbreak
15202    commands.  It is defined as a macro to prevent duplication.
15203    COMMAND should be a string constant containing the name of the
15204    command.  */
15205
15206 #define BREAK_ARGS_HELP(command) \
15207 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15208 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15209 probe point.  Accepted values are `-probe' (for a generic, automatically\n\
15210 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15211 `-probe-dtrace' (for a DTrace probe).\n\
15212 LOCATION may be a linespec, address, or explicit location as described\n\
15213 below.\n\
15214 \n\
15215 With no LOCATION, uses current execution address of the selected\n\
15216 stack frame.  This is useful for breaking on return to a stack frame.\n\
15217 \n\
15218 THREADNUM is the number from \"info threads\".\n\
15219 CONDITION is a boolean expression.\n\
15220 \n" LOCATION_HELP_STRING "\n\
15221 Multiple breakpoints at one place are permitted, and useful if their\n\
15222 conditions are different.\n\
15223 \n\
15224 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15225
15226 /* List of subcommands for "catch".  */
15227 static struct cmd_list_element *catch_cmdlist;
15228
15229 /* List of subcommands for "tcatch".  */
15230 static struct cmd_list_element *tcatch_cmdlist;
15231
15232 void
15233 add_catch_command (const char *name, const char *docstring,
15234                    cmd_const_sfunc_ftype *sfunc,
15235                    completer_ftype *completer,
15236                    void *user_data_catch,
15237                    void *user_data_tcatch)
15238 {
15239   struct cmd_list_element *command;
15240
15241   command = add_cmd (name, class_breakpoint, docstring,
15242                      &catch_cmdlist);
15243   set_cmd_sfunc (command, sfunc);
15244   set_cmd_context (command, user_data_catch);
15245   set_cmd_completer (command, completer);
15246
15247   command = add_cmd (name, class_breakpoint, docstring,
15248                      &tcatch_cmdlist);
15249   set_cmd_sfunc (command, sfunc);
15250   set_cmd_context (command, user_data_tcatch);
15251   set_cmd_completer (command, completer);
15252 }
15253
15254 static void
15255 save_command (const char *arg, int from_tty)
15256 {
15257   printf_unfiltered (_("\"save\" must be followed by "
15258                        "the name of a save subcommand.\n"));
15259   help_list (save_cmdlist, "save ", all_commands, gdb_stdout);
15260 }
15261
15262 struct breakpoint *
15263 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15264                           void *data)
15265 {
15266   struct breakpoint *b, *b_tmp;
15267
15268   ALL_BREAKPOINTS_SAFE (b, b_tmp)
15269     {
15270       if ((*callback) (b, data))
15271         return b;
15272     }
15273
15274   return NULL;
15275 }
15276
15277 /* Zero if any of the breakpoint's locations could be a location where
15278    functions have been inlined, nonzero otherwise.  */
15279
15280 static int
15281 is_non_inline_function (struct breakpoint *b)
15282 {
15283   /* The shared library event breakpoint is set on the address of a
15284      non-inline function.  */
15285   if (b->type == bp_shlib_event)
15286     return 1;
15287
15288   return 0;
15289 }
15290
15291 /* Nonzero if the specified PC cannot be a location where functions
15292    have been inlined.  */
15293
15294 int
15295 pc_at_non_inline_function (const address_space *aspace, CORE_ADDR pc,
15296                            const struct target_waitstatus *ws)
15297 {
15298   struct breakpoint *b;
15299   struct bp_location *bl;
15300
15301   ALL_BREAKPOINTS (b)
15302     {
15303       if (!is_non_inline_function (b))
15304         continue;
15305
15306       for (bl = b->loc; bl != NULL; bl = bl->next)
15307         {
15308           if (!bl->shlib_disabled
15309               && bpstat_check_location (bl, aspace, pc, ws))
15310             return 1;
15311         }
15312     }
15313
15314   return 0;
15315 }
15316
15317 /* Remove any references to OBJFILE which is going to be freed.  */
15318
15319 void
15320 breakpoint_free_objfile (struct objfile *objfile)
15321 {
15322   struct bp_location **locp, *loc;
15323
15324   ALL_BP_LOCATIONS (loc, locp)
15325     if (loc->symtab != NULL && SYMTAB_OBJFILE (loc->symtab) == objfile)
15326       loc->symtab = NULL;
15327 }
15328
15329 void
15330 initialize_breakpoint_ops (void)
15331 {
15332   static int initialized = 0;
15333
15334   struct breakpoint_ops *ops;
15335
15336   if (initialized)
15337     return;
15338   initialized = 1;
15339
15340   /* The breakpoint_ops structure to be inherit by all kinds of
15341      breakpoints (real breakpoints, i.e., user "break" breakpoints,
15342      internal and momentary breakpoints, etc.).  */
15343   ops = &bkpt_base_breakpoint_ops;
15344   *ops = base_breakpoint_ops;
15345   ops->re_set = bkpt_re_set;
15346   ops->insert_location = bkpt_insert_location;
15347   ops->remove_location = bkpt_remove_location;
15348   ops->breakpoint_hit = bkpt_breakpoint_hit;
15349   ops->create_sals_from_location = bkpt_create_sals_from_location;
15350   ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
15351   ops->decode_location = bkpt_decode_location;
15352
15353   /* The breakpoint_ops structure to be used in regular breakpoints.  */
15354   ops = &bkpt_breakpoint_ops;
15355   *ops = bkpt_base_breakpoint_ops;
15356   ops->re_set = bkpt_re_set;
15357   ops->resources_needed = bkpt_resources_needed;
15358   ops->print_it = bkpt_print_it;
15359   ops->print_mention = bkpt_print_mention;
15360   ops->print_recreate = bkpt_print_recreate;
15361
15362   /* Ranged breakpoints.  */
15363   ops = &ranged_breakpoint_ops;
15364   *ops = bkpt_breakpoint_ops;
15365   ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15366   ops->resources_needed = resources_needed_ranged_breakpoint;
15367   ops->print_it = print_it_ranged_breakpoint;
15368   ops->print_one = print_one_ranged_breakpoint;
15369   ops->print_one_detail = print_one_detail_ranged_breakpoint;
15370   ops->print_mention = print_mention_ranged_breakpoint;
15371   ops->print_recreate = print_recreate_ranged_breakpoint;
15372
15373   /* Internal breakpoints.  */
15374   ops = &internal_breakpoint_ops;
15375   *ops = bkpt_base_breakpoint_ops;
15376   ops->re_set = internal_bkpt_re_set;
15377   ops->check_status = internal_bkpt_check_status;
15378   ops->print_it = internal_bkpt_print_it;
15379   ops->print_mention = internal_bkpt_print_mention;
15380
15381   /* Momentary breakpoints.  */
15382   ops = &momentary_breakpoint_ops;
15383   *ops = bkpt_base_breakpoint_ops;
15384   ops->re_set = momentary_bkpt_re_set;
15385   ops->check_status = momentary_bkpt_check_status;
15386   ops->print_it = momentary_bkpt_print_it;
15387   ops->print_mention = momentary_bkpt_print_mention;
15388
15389   /* Probe breakpoints.  */
15390   ops = &bkpt_probe_breakpoint_ops;
15391   *ops = bkpt_breakpoint_ops;
15392   ops->insert_location = bkpt_probe_insert_location;
15393   ops->remove_location = bkpt_probe_remove_location;
15394   ops->create_sals_from_location = bkpt_probe_create_sals_from_location;
15395   ops->decode_location = bkpt_probe_decode_location;
15396
15397   /* Watchpoints.  */
15398   ops = &watchpoint_breakpoint_ops;
15399   *ops = base_breakpoint_ops;
15400   ops->re_set = re_set_watchpoint;
15401   ops->insert_location = insert_watchpoint;
15402   ops->remove_location = remove_watchpoint;
15403   ops->breakpoint_hit = breakpoint_hit_watchpoint;
15404   ops->check_status = check_status_watchpoint;
15405   ops->resources_needed = resources_needed_watchpoint;
15406   ops->works_in_software_mode = works_in_software_mode_watchpoint;
15407   ops->print_it = print_it_watchpoint;
15408   ops->print_mention = print_mention_watchpoint;
15409   ops->print_recreate = print_recreate_watchpoint;
15410   ops->explains_signal = explains_signal_watchpoint;
15411
15412   /* Masked watchpoints.  */
15413   ops = &masked_watchpoint_breakpoint_ops;
15414   *ops = watchpoint_breakpoint_ops;
15415   ops->insert_location = insert_masked_watchpoint;
15416   ops->remove_location = remove_masked_watchpoint;
15417   ops->resources_needed = resources_needed_masked_watchpoint;
15418   ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15419   ops->print_it = print_it_masked_watchpoint;
15420   ops->print_one_detail = print_one_detail_masked_watchpoint;
15421   ops->print_mention = print_mention_masked_watchpoint;
15422   ops->print_recreate = print_recreate_masked_watchpoint;
15423
15424   /* Tracepoints.  */
15425   ops = &tracepoint_breakpoint_ops;
15426   *ops = base_breakpoint_ops;
15427   ops->re_set = tracepoint_re_set;
15428   ops->breakpoint_hit = tracepoint_breakpoint_hit;
15429   ops->print_one_detail = tracepoint_print_one_detail;
15430   ops->print_mention = tracepoint_print_mention;
15431   ops->print_recreate = tracepoint_print_recreate;
15432   ops->create_sals_from_location = tracepoint_create_sals_from_location;
15433   ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
15434   ops->decode_location = tracepoint_decode_location;
15435
15436   /* Probe tracepoints.  */
15437   ops = &tracepoint_probe_breakpoint_ops;
15438   *ops = tracepoint_breakpoint_ops;
15439   ops->create_sals_from_location = tracepoint_probe_create_sals_from_location;
15440   ops->decode_location = tracepoint_probe_decode_location;
15441
15442   /* Static tracepoints with marker (`-m').  */
15443   ops = &strace_marker_breakpoint_ops;
15444   *ops = tracepoint_breakpoint_ops;
15445   ops->create_sals_from_location = strace_marker_create_sals_from_location;
15446   ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
15447   ops->decode_location = strace_marker_decode_location;
15448
15449   /* Fork catchpoints.  */
15450   ops = &catch_fork_breakpoint_ops;
15451   *ops = base_breakpoint_ops;
15452   ops->insert_location = insert_catch_fork;
15453   ops->remove_location = remove_catch_fork;
15454   ops->breakpoint_hit = breakpoint_hit_catch_fork;
15455   ops->print_it = print_it_catch_fork;
15456   ops->print_one = print_one_catch_fork;
15457   ops->print_mention = print_mention_catch_fork;
15458   ops->print_recreate = print_recreate_catch_fork;
15459
15460   /* Vfork catchpoints.  */
15461   ops = &catch_vfork_breakpoint_ops;
15462   *ops = base_breakpoint_ops;
15463   ops->insert_location = insert_catch_vfork;
15464   ops->remove_location = remove_catch_vfork;
15465   ops->breakpoint_hit = breakpoint_hit_catch_vfork;
15466   ops->print_it = print_it_catch_vfork;
15467   ops->print_one = print_one_catch_vfork;
15468   ops->print_mention = print_mention_catch_vfork;
15469   ops->print_recreate = print_recreate_catch_vfork;
15470
15471   /* Exec catchpoints.  */
15472   ops = &catch_exec_breakpoint_ops;
15473   *ops = base_breakpoint_ops;
15474   ops->insert_location = insert_catch_exec;
15475   ops->remove_location = remove_catch_exec;
15476   ops->breakpoint_hit = breakpoint_hit_catch_exec;
15477   ops->print_it = print_it_catch_exec;
15478   ops->print_one = print_one_catch_exec;
15479   ops->print_mention = print_mention_catch_exec;
15480   ops->print_recreate = print_recreate_catch_exec;
15481
15482   /* Solib-related catchpoints.  */
15483   ops = &catch_solib_breakpoint_ops;
15484   *ops = base_breakpoint_ops;
15485   ops->insert_location = insert_catch_solib;
15486   ops->remove_location = remove_catch_solib;
15487   ops->breakpoint_hit = breakpoint_hit_catch_solib;
15488   ops->check_status = check_status_catch_solib;
15489   ops->print_it = print_it_catch_solib;
15490   ops->print_one = print_one_catch_solib;
15491   ops->print_mention = print_mention_catch_solib;
15492   ops->print_recreate = print_recreate_catch_solib;
15493
15494   ops = &dprintf_breakpoint_ops;
15495   *ops = bkpt_base_breakpoint_ops;
15496   ops->re_set = dprintf_re_set;
15497   ops->resources_needed = bkpt_resources_needed;
15498   ops->print_it = bkpt_print_it;
15499   ops->print_mention = bkpt_print_mention;
15500   ops->print_recreate = dprintf_print_recreate;
15501   ops->after_condition_true = dprintf_after_condition_true;
15502   ops->breakpoint_hit = dprintf_breakpoint_hit;
15503 }
15504
15505 /* Chain containing all defined "enable breakpoint" subcommands.  */
15506
15507 static struct cmd_list_element *enablebreaklist = NULL;
15508
15509 /* See breakpoint.h.  */
15510
15511 cmd_list_element *commands_cmd_element = nullptr;
15512
15513 void
15514 _initialize_breakpoint (void)
15515 {
15516   struct cmd_list_element *c;
15517
15518   initialize_breakpoint_ops ();
15519
15520   gdb::observers::solib_unloaded.attach (disable_breakpoints_in_unloaded_shlib);
15521   gdb::observers::free_objfile.attach (disable_breakpoints_in_freed_objfile);
15522   gdb::observers::memory_changed.attach (invalidate_bp_value_on_memory_change);
15523
15524   breakpoint_objfile_key
15525     = register_objfile_data_with_cleanup (NULL, free_breakpoint_objfile_data);
15526
15527   breakpoint_chain = 0;
15528   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
15529      before a breakpoint is set.  */
15530   breakpoint_count = 0;
15531
15532   tracepoint_count = 0;
15533
15534   add_com ("ignore", class_breakpoint, ignore_command, _("\
15535 Set ignore-count of breakpoint number N to COUNT.\n\
15536 Usage is `ignore N COUNT'."));
15537
15538   commands_cmd_element = add_com ("commands", class_breakpoint,
15539                                   commands_command, _("\
15540 Set commands to be executed when the given breakpoints are hit.\n\
15541 Give a space-separated breakpoint list as argument after \"commands\".\n\
15542 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15543 (e.g. `5-7').\n\
15544 With no argument, the targeted breakpoint is the last one set.\n\
15545 The commands themselves follow starting on the next line.\n\
15546 Type a line containing \"end\" to indicate the end of them.\n\
15547 Give \"silent\" as the first line to make the breakpoint silent;\n\
15548 then no output is printed when it is hit, except what the commands print."));
15549
15550   c = add_com ("condition", class_breakpoint, condition_command, _("\
15551 Specify breakpoint number N to break only if COND is true.\n\
15552 Usage is `condition N COND', where N is an integer and COND is an\n\
15553 expression to be evaluated whenever breakpoint N is reached."));
15554   set_cmd_completer (c, condition_completer);
15555
15556   c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
15557 Set a temporary breakpoint.\n\
15558 Like \"break\" except the breakpoint is only temporary,\n\
15559 so it will be deleted when hit.  Equivalent to \"break\" followed\n\
15560 by using \"enable delete\" on the breakpoint number.\n\
15561 \n"
15562 BREAK_ARGS_HELP ("tbreak")));
15563   set_cmd_completer (c, location_completer);
15564
15565   c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
15566 Set a hardware assisted breakpoint.\n\
15567 Like \"break\" except the breakpoint requires hardware support,\n\
15568 some target hardware may not have this support.\n\
15569 \n"
15570 BREAK_ARGS_HELP ("hbreak")));
15571   set_cmd_completer (c, location_completer);
15572
15573   c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
15574 Set a temporary hardware assisted breakpoint.\n\
15575 Like \"hbreak\" except the breakpoint is only temporary,\n\
15576 so it will be deleted when hit.\n\
15577 \n"
15578 BREAK_ARGS_HELP ("thbreak")));
15579   set_cmd_completer (c, location_completer);
15580
15581   add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
15582 Enable some breakpoints.\n\
15583 Give breakpoint numbers (separated by spaces) as arguments.\n\
15584 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15585 This is used to cancel the effect of the \"disable\" command.\n\
15586 With a subcommand you can enable temporarily."),
15587                   &enablelist, "enable ", 1, &cmdlist);
15588
15589   add_com_alias ("en", "enable", class_breakpoint, 1);
15590
15591   add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
15592 Enable some breakpoints.\n\
15593 Give breakpoint numbers (separated by spaces) as arguments.\n\
15594 This is used to cancel the effect of the \"disable\" command.\n\
15595 May be abbreviated to simply \"enable\".\n"),
15596                    &enablebreaklist, "enable breakpoints ", 1, &enablelist);
15597
15598   add_cmd ("once", no_class, enable_once_command, _("\
15599 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
15600 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15601            &enablebreaklist);
15602
15603   add_cmd ("delete", no_class, enable_delete_command, _("\
15604 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
15605 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15606            &enablebreaklist);
15607
15608   add_cmd ("count", no_class, enable_count_command, _("\
15609 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
15610 If a breakpoint is hit while enabled in this fashion,\n\
15611 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15612            &enablebreaklist);
15613
15614   add_cmd ("delete", no_class, enable_delete_command, _("\
15615 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
15616 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15617            &enablelist);
15618
15619   add_cmd ("once", no_class, enable_once_command, _("\
15620 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
15621 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15622            &enablelist);
15623
15624   add_cmd ("count", no_class, enable_count_command, _("\
15625 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
15626 If a breakpoint is hit while enabled in this fashion,\n\
15627 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15628            &enablelist);
15629
15630   add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
15631 Disable some breakpoints.\n\
15632 Arguments are breakpoint numbers with spaces in between.\n\
15633 To disable all breakpoints, give no argument.\n\
15634 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15635                   &disablelist, "disable ", 1, &cmdlist);
15636   add_com_alias ("dis", "disable", class_breakpoint, 1);
15637   add_com_alias ("disa", "disable", class_breakpoint, 1);
15638
15639   add_cmd ("breakpoints", class_alias, disable_command, _("\
15640 Disable some breakpoints.\n\
15641 Arguments are breakpoint numbers with spaces in between.\n\
15642 To disable all breakpoints, give no argument.\n\
15643 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15644 This command may be abbreviated \"disable\"."),
15645            &disablelist);
15646
15647   add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
15648 Delete some breakpoints or auto-display expressions.\n\
15649 Arguments are breakpoint numbers with spaces in between.\n\
15650 To delete all breakpoints, give no argument.\n\
15651 \n\
15652 Also a prefix command for deletion of other GDB objects.\n\
15653 The \"unset\" command is also an alias for \"delete\"."),
15654                   &deletelist, "delete ", 1, &cmdlist);
15655   add_com_alias ("d", "delete", class_breakpoint, 1);
15656   add_com_alias ("del", "delete", class_breakpoint, 1);
15657
15658   add_cmd ("breakpoints", class_alias, delete_command, _("\
15659 Delete some breakpoints or auto-display expressions.\n\
15660 Arguments are breakpoint numbers with spaces in between.\n\
15661 To delete all breakpoints, give no argument.\n\
15662 This command may be abbreviated \"delete\"."),
15663            &deletelist);
15664
15665   add_com ("clear", class_breakpoint, clear_command, _("\
15666 Clear breakpoint at specified location.\n\
15667 Argument may be a linespec, explicit, or address location as described below.\n\
15668 \n\
15669 With no argument, clears all breakpoints in the line that the selected frame\n\
15670 is executing in.\n"
15671 "\n" LOCATION_HELP_STRING "\n\
15672 See also the \"delete\" command which clears breakpoints by number."));
15673   add_com_alias ("cl", "clear", class_breakpoint, 1);
15674
15675   c = add_com ("break", class_breakpoint, break_command, _("\
15676 Set breakpoint at specified location.\n"
15677 BREAK_ARGS_HELP ("break")));
15678   set_cmd_completer (c, location_completer);
15679
15680   add_com_alias ("b", "break", class_run, 1);
15681   add_com_alias ("br", "break", class_run, 1);
15682   add_com_alias ("bre", "break", class_run, 1);
15683   add_com_alias ("brea", "break", class_run, 1);
15684
15685   if (dbx_commands)
15686     {
15687       add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
15688 Break in function/address or break at a line in the current file."),
15689                              &stoplist, "stop ", 1, &cmdlist);
15690       add_cmd ("in", class_breakpoint, stopin_command,
15691                _("Break in function or address."), &stoplist);
15692       add_cmd ("at", class_breakpoint, stopat_command,
15693                _("Break at a line in the current file."), &stoplist);
15694       add_com ("status", class_info, info_breakpoints_command, _("\
15695 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15696 The \"Type\" column indicates one of:\n\
15697 \tbreakpoint     - normal breakpoint\n\
15698 \twatchpoint     - watchpoint\n\
15699 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15700 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15701 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15702 address and file/line number respectively.\n\
15703 \n\
15704 Convenience variable \"$_\" and default examine address for \"x\"\n\
15705 are set to the address of the last breakpoint listed unless the command\n\
15706 is prefixed with \"server \".\n\n\
15707 Convenience variable \"$bpnum\" contains the number of the last\n\
15708 breakpoint set."));
15709     }
15710
15711   add_info ("breakpoints", info_breakpoints_command, _("\
15712 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15713 The \"Type\" column indicates one of:\n\
15714 \tbreakpoint     - normal breakpoint\n\
15715 \twatchpoint     - watchpoint\n\
15716 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15717 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15718 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15719 address and file/line number respectively.\n\
15720 \n\
15721 Convenience variable \"$_\" and default examine address for \"x\"\n\
15722 are set to the address of the last breakpoint listed unless the command\n\
15723 is prefixed with \"server \".\n\n\
15724 Convenience variable \"$bpnum\" contains the number of the last\n\
15725 breakpoint set."));
15726
15727   add_info_alias ("b", "breakpoints", 1);
15728
15729   add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
15730 Status of all breakpoints, or breakpoint number NUMBER.\n\
15731 The \"Type\" column indicates one of:\n\
15732 \tbreakpoint     - normal breakpoint\n\
15733 \twatchpoint     - watchpoint\n\
15734 \tlongjmp        - internal breakpoint used to step through longjmp()\n\
15735 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15736 \tuntil          - internal breakpoint used by the \"until\" command\n\
15737 \tfinish         - internal breakpoint used by the \"finish\" command\n\
15738 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15739 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15740 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15741 address and file/line number respectively.\n\
15742 \n\
15743 Convenience variable \"$_\" and default examine address for \"x\"\n\
15744 are set to the address of the last breakpoint listed unless the command\n\
15745 is prefixed with \"server \".\n\n\
15746 Convenience variable \"$bpnum\" contains the number of the last\n\
15747 breakpoint set."),
15748            &maintenanceinfolist);
15749
15750   add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
15751 Set catchpoints to catch events."),
15752                   &catch_cmdlist, "catch ",
15753                   0/*allow-unknown*/, &cmdlist);
15754
15755   add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
15756 Set temporary catchpoints to catch events."),
15757                   &tcatch_cmdlist, "tcatch ",
15758                   0/*allow-unknown*/, &cmdlist);
15759
15760   add_catch_command ("fork", _("Catch calls to fork."),
15761                      catch_fork_command_1,
15762                      NULL,
15763                      (void *) (uintptr_t) catch_fork_permanent,
15764                      (void *) (uintptr_t) catch_fork_temporary);
15765   add_catch_command ("vfork", _("Catch calls to vfork."),
15766                      catch_fork_command_1,
15767                      NULL,
15768                      (void *) (uintptr_t) catch_vfork_permanent,
15769                      (void *) (uintptr_t) catch_vfork_temporary);
15770   add_catch_command ("exec", _("Catch calls to exec."),
15771                      catch_exec_command_1,
15772                      NULL,
15773                      CATCH_PERMANENT,
15774                      CATCH_TEMPORARY);
15775   add_catch_command ("load", _("Catch loads of shared libraries.\n\
15776 Usage: catch load [REGEX]\n\
15777 If REGEX is given, only stop for libraries matching the regular expression."),
15778                      catch_load_command_1,
15779                      NULL,
15780                      CATCH_PERMANENT,
15781                      CATCH_TEMPORARY);
15782   add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15783 Usage: catch unload [REGEX]\n\
15784 If REGEX is given, only stop for libraries matching the regular expression."),
15785                      catch_unload_command_1,
15786                      NULL,
15787                      CATCH_PERMANENT,
15788                      CATCH_TEMPORARY);
15789
15790   c = add_com ("watch", class_breakpoint, watch_command, _("\
15791 Set a watchpoint for an expression.\n\
15792 Usage: watch [-l|-location] EXPRESSION\n\
15793 A watchpoint stops execution of your program whenever the value of\n\
15794 an expression changes.\n\
15795 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15796 the memory to which it refers."));
15797   set_cmd_completer (c, expression_completer);
15798
15799   c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
15800 Set a read watchpoint for an expression.\n\
15801 Usage: rwatch [-l|-location] EXPRESSION\n\
15802 A watchpoint stops execution of your program whenever the value of\n\
15803 an expression is read.\n\
15804 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15805 the memory to which it refers."));
15806   set_cmd_completer (c, expression_completer);
15807
15808   c = add_com ("awatch", class_breakpoint, awatch_command, _("\
15809 Set a watchpoint for an expression.\n\
15810 Usage: awatch [-l|-location] EXPRESSION\n\
15811 A watchpoint stops execution of your program whenever the value of\n\
15812 an expression is either read or written.\n\
15813 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15814 the memory to which it refers."));
15815   set_cmd_completer (c, expression_completer);
15816
15817   add_info ("watchpoints", info_watchpoints_command, _("\
15818 Status of specified watchpoints (all watchpoints if no argument)."));
15819
15820   /* XXX: cagney/2005-02-23: This should be a boolean, and should
15821      respond to changes - contrary to the description.  */
15822   add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
15823                             &can_use_hw_watchpoints, _("\
15824 Set debugger's willingness to use watchpoint hardware."), _("\
15825 Show debugger's willingness to use watchpoint hardware."), _("\
15826 If zero, gdb will not use hardware for new watchpoints, even if\n\
15827 such is available.  (However, any hardware watchpoints that were\n\
15828 created before setting this to nonzero, will continue to use watchpoint\n\
15829 hardware.)"),
15830                             NULL,
15831                             show_can_use_hw_watchpoints,
15832                             &setlist, &showlist);
15833
15834   can_use_hw_watchpoints = 1;
15835
15836   /* Tracepoint manipulation commands.  */
15837
15838   c = add_com ("trace", class_breakpoint, trace_command, _("\
15839 Set a tracepoint at specified location.\n\
15840 \n"
15841 BREAK_ARGS_HELP ("trace") "\n\
15842 Do \"help tracepoints\" for info on other tracepoint commands."));
15843   set_cmd_completer (c, location_completer);
15844
15845   add_com_alias ("tp", "trace", class_alias, 0);
15846   add_com_alias ("tr", "trace", class_alias, 1);
15847   add_com_alias ("tra", "trace", class_alias, 1);
15848   add_com_alias ("trac", "trace", class_alias, 1);
15849
15850   c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
15851 Set a fast tracepoint at specified location.\n\
15852 \n"
15853 BREAK_ARGS_HELP ("ftrace") "\n\
15854 Do \"help tracepoints\" for info on other tracepoint commands."));
15855   set_cmd_completer (c, location_completer);
15856
15857   c = add_com ("strace", class_breakpoint, strace_command, _("\
15858 Set a static tracepoint at location or marker.\n\
15859 \n\
15860 strace [LOCATION] [if CONDITION]\n\
15861 LOCATION may be a linespec, explicit, or address location (described below) \n\
15862 or -m MARKER_ID.\n\n\
15863 If a marker id is specified, probe the marker with that name.  With\n\
15864 no LOCATION, uses current execution address of the selected stack frame.\n\
15865 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15866 This collects arbitrary user data passed in the probe point call to the\n\
15867 tracing library.  You can inspect it when analyzing the trace buffer,\n\
15868 by printing the $_sdata variable like any other convenience variable.\n\
15869 \n\
15870 CONDITION is a boolean expression.\n\
15871 \n" LOCATION_HELP_STRING "\n\
15872 Multiple tracepoints at one place are permitted, and useful if their\n\
15873 conditions are different.\n\
15874 \n\
15875 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15876 Do \"help tracepoints\" for info on other tracepoint commands."));
15877   set_cmd_completer (c, location_completer);
15878
15879   add_info ("tracepoints", info_tracepoints_command, _("\
15880 Status of specified tracepoints (all tracepoints if no argument).\n\
15881 Convenience variable \"$tpnum\" contains the number of the\n\
15882 last tracepoint set."));
15883
15884   add_info_alias ("tp", "tracepoints", 1);
15885
15886   add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
15887 Delete specified tracepoints.\n\
15888 Arguments are tracepoint numbers, separated by spaces.\n\
15889 No argument means delete all tracepoints."),
15890            &deletelist);
15891   add_alias_cmd ("tr", "tracepoints", class_trace, 1, &deletelist);
15892
15893   c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
15894 Disable specified tracepoints.\n\
15895 Arguments are tracepoint numbers, separated by spaces.\n\
15896 No argument means disable all tracepoints."),
15897            &disablelist);
15898   deprecate_cmd (c, "disable");
15899
15900   c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
15901 Enable specified tracepoints.\n\
15902 Arguments are tracepoint numbers, separated by spaces.\n\
15903 No argument means enable all tracepoints."),
15904            &enablelist);
15905   deprecate_cmd (c, "enable");
15906
15907   add_com ("passcount", class_trace, trace_pass_command, _("\
15908 Set the passcount for a tracepoint.\n\
15909 The trace will end when the tracepoint has been passed 'count' times.\n\
15910 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15911 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15912
15913   add_prefix_cmd ("save", class_breakpoint, save_command,
15914                   _("Save breakpoint definitions as a script."),
15915                   &save_cmdlist, "save ",
15916                   0/*allow-unknown*/, &cmdlist);
15917
15918   c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
15919 Save current breakpoint definitions as a script.\n\
15920 This includes all types of breakpoints (breakpoints, watchpoints,\n\
15921 catchpoints, tracepoints).  Use the 'source' command in another debug\n\
15922 session to restore them."),
15923                &save_cmdlist);
15924   set_cmd_completer (c, filename_completer);
15925
15926   c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
15927 Save current tracepoint definitions as a script.\n\
15928 Use the 'source' command in another debug session to restore them."),
15929                &save_cmdlist);
15930   set_cmd_completer (c, filename_completer);
15931
15932   c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
15933   deprecate_cmd (c, "save tracepoints");
15934
15935   add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
15936 Breakpoint specific settings\n\
15937 Configure various breakpoint-specific variables such as\n\
15938 pending breakpoint behavior"),
15939                   &breakpoint_set_cmdlist, "set breakpoint ",
15940                   0/*allow-unknown*/, &setlist);
15941   add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
15942 Breakpoint specific settings\n\
15943 Configure various breakpoint-specific variables such as\n\
15944 pending breakpoint behavior"),
15945                   &breakpoint_show_cmdlist, "show breakpoint ",
15946                   0/*allow-unknown*/, &showlist);
15947
15948   add_setshow_auto_boolean_cmd ("pending", no_class,
15949                                 &pending_break_support, _("\
15950 Set debugger's behavior regarding pending breakpoints."), _("\
15951 Show debugger's behavior regarding pending breakpoints."), _("\
15952 If on, an unrecognized breakpoint location will cause gdb to create a\n\
15953 pending breakpoint.  If off, an unrecognized breakpoint location results in\n\
15954 an error.  If auto, an unrecognized breakpoint location results in a\n\
15955 user-query to see if a pending breakpoint should be created."),
15956                                 NULL,
15957                                 show_pending_break_support,
15958                                 &breakpoint_set_cmdlist,
15959                                 &breakpoint_show_cmdlist);
15960
15961   pending_break_support = AUTO_BOOLEAN_AUTO;
15962
15963   add_setshow_boolean_cmd ("auto-hw", no_class,
15964                            &automatic_hardware_breakpoints, _("\
15965 Set automatic usage of hardware breakpoints."), _("\
15966 Show automatic usage of hardware breakpoints."), _("\
15967 If set, the debugger will automatically use hardware breakpoints for\n\
15968 breakpoints set with \"break\" but falling in read-only memory.  If not set,\n\
15969 a warning will be emitted for such breakpoints."),
15970                            NULL,
15971                            show_automatic_hardware_breakpoints,
15972                            &breakpoint_set_cmdlist,
15973                            &breakpoint_show_cmdlist);
15974
15975   add_setshow_boolean_cmd ("always-inserted", class_support,
15976                            &always_inserted_mode, _("\
15977 Set mode for inserting breakpoints."), _("\
15978 Show mode for inserting breakpoints."), _("\
15979 When this mode is on, breakpoints are inserted immediately as soon as\n\
15980 they're created, kept inserted even when execution stops, and removed\n\
15981 only when the user deletes them.  When this mode is off (the default),\n\
15982 breakpoints are inserted only when execution continues, and removed\n\
15983 when execution stops."),
15984                                 NULL,
15985                                 &show_always_inserted_mode,
15986                                 &breakpoint_set_cmdlist,
15987                                 &breakpoint_show_cmdlist);
15988
15989   add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
15990                         condition_evaluation_enums,
15991                         &condition_evaluation_mode_1, _("\
15992 Set mode of breakpoint condition evaluation."), _("\
15993 Show mode of breakpoint condition evaluation."), _("\
15994 When this is set to \"host\", breakpoint conditions will be\n\
15995 evaluated on the host's side by GDB.  When it is set to \"target\",\n\
15996 breakpoint conditions will be downloaded to the target (if the target\n\
15997 supports such feature) and conditions will be evaluated on the target's side.\n\
15998 If this is set to \"auto\" (default), this will be automatically set to\n\
15999 \"target\" if it supports condition evaluation, otherwise it will\n\
16000 be set to \"gdb\""),
16001                            &set_condition_evaluation_mode,
16002                            &show_condition_evaluation_mode,
16003                            &breakpoint_set_cmdlist,
16004                            &breakpoint_show_cmdlist);
16005
16006   add_com ("break-range", class_breakpoint, break_range_command, _("\
16007 Set a breakpoint for an address range.\n\
16008 break-range START-LOCATION, END-LOCATION\n\
16009 where START-LOCATION and END-LOCATION can be one of the following:\n\
16010   LINENUM, for that line in the current file,\n\
16011   FILE:LINENUM, for that line in that file,\n\
16012   +OFFSET, for that number of lines after the current line\n\
16013            or the start of the range\n\
16014   FUNCTION, for the first line in that function,\n\
16015   FILE:FUNCTION, to distinguish among like-named static functions.\n\
16016   *ADDRESS, for the instruction at that address.\n\
16017 \n\
16018 The breakpoint will stop execution of the inferior whenever it executes\n\
16019 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16020 range (including START-LOCATION and END-LOCATION)."));
16021
16022   c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
16023 Set a dynamic printf at specified location.\n\
16024 dprintf location,format string,arg1,arg2,...\n\
16025 location may be a linespec, explicit, or address location.\n"
16026 "\n" LOCATION_HELP_STRING));
16027   set_cmd_completer (c, location_completer);
16028
16029   add_setshow_enum_cmd ("dprintf-style", class_support,
16030                         dprintf_style_enums, &dprintf_style, _("\
16031 Set the style of usage for dynamic printf."), _("\
16032 Show the style of usage for dynamic printf."), _("\
16033 This setting chooses how GDB will do a dynamic printf.\n\
16034 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16035 console, as with the \"printf\" command.\n\
16036 If the value is \"call\", the print is done by calling a function in your\n\
16037 program; by default printf(), but you can choose a different function or\n\
16038 output stream by setting dprintf-function and dprintf-channel."),
16039                         update_dprintf_commands, NULL,
16040                         &setlist, &showlist);
16041
16042   dprintf_function = xstrdup ("printf");
16043   add_setshow_string_cmd ("dprintf-function", class_support,
16044                           &dprintf_function, _("\
16045 Set the function to use for dynamic printf"), _("\
16046 Show the function to use for dynamic printf"), NULL,
16047                           update_dprintf_commands, NULL,
16048                           &setlist, &showlist);
16049
16050   dprintf_channel = xstrdup ("");
16051   add_setshow_string_cmd ("dprintf-channel", class_support,
16052                           &dprintf_channel, _("\
16053 Set the channel to use for dynamic printf"), _("\
16054 Show the channel to use for dynamic printf"), NULL,
16055                           update_dprintf_commands, NULL,
16056                           &setlist, &showlist);
16057
16058   add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
16059                            &disconnected_dprintf, _("\
16060 Set whether dprintf continues after GDB disconnects."), _("\
16061 Show whether dprintf continues after GDB disconnects."), _("\
16062 Use this to let dprintf commands continue to hit and produce output\n\
16063 even if GDB disconnects or detaches from the target."),
16064                            NULL,
16065                            NULL,
16066                            &setlist, &showlist);
16067
16068   add_com ("agent-printf", class_vars, agent_printf_command, _("\
16069 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16070 (target agent only) This is useful for formatted output in user-defined commands."));
16071
16072   automatic_hardware_breakpoints = 1;
16073
16074   gdb::observers::about_to_proceed.attach (breakpoint_about_to_proceed);
16075   gdb::observers::thread_exit.attach (remove_threaded_breakpoints);
16076 }