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