Clear non-significant bits of address in watchpoint
[external/binutils.git] / gdb / breakpoint.c
1 /* Everything about breakpoints, for GDB.
2
3    Copyright (C) 1986-2017 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include <ctype.h>
23 #include "hashtab.h"
24 #include "symtab.h"
25 #include "frame.h"
26 #include "breakpoint.h"
27 #include "tracepoint.h"
28 #include "gdbtypes.h"
29 #include "expression.h"
30 #include "gdbcore.h"
31 #include "gdbcmd.h"
32 #include "value.h"
33 #include "command.h"
34 #include "inferior.h"
35 #include "infrun.h"
36 #include "gdbthread.h"
37 #include "target.h"
38 #include "language.h"
39 #include "gdb-demangle.h"
40 #include "filenames.h"
41 #include "annotate.h"
42 #include "symfile.h"
43 #include "objfiles.h"
44 #include "source.h"
45 #include "linespec.h"
46 #include "completer.h"
47 #include "ui-out.h"
48 #include "cli/cli-script.h"
49 #include "block.h"
50 #include "solib.h"
51 #include "solist.h"
52 #include "observer.h"
53 #include "memattr.h"
54 #include "ada-lang.h"
55 #include "top.h"
56 #include "valprint.h"
57 #include "jit.h"
58 #include "parser-defs.h"
59 #include "gdb_regex.h"
60 #include "probe.h"
61 #include "cli/cli-utils.h"
62 #include "continuations.h"
63 #include "stack.h"
64 #include "skip.h"
65 #include "ax-gdb.h"
66 #include "dummy-frame.h"
67 #include "interps.h"
68 #include "format.h"
69 #include "thread-fsm.h"
70 #include "tid-parse.h"
71
72 /* readline include files */
73 #include "readline/readline.h"
74 #include "readline/history.h"
75
76 /* readline defines this.  */
77 #undef savestring
78
79 #include "mi/mi-common.h"
80 #include "extension.h"
81 #include <algorithm>
82 #include "progspace-and-thread.h"
83 #include "common/array-view.h"
84 #include "common/gdb_optional.h"
85
86 /* Enums for exception-handling support.  */
87 enum exception_event_kind
88 {
89   EX_EVENT_THROW,
90   EX_EVENT_RETHROW,
91   EX_EVENT_CATCH
92 };
93
94 /* Prototypes for local functions.  */
95
96 static void map_breakpoint_numbers (const char *,
97                                     gdb::function_view<void (breakpoint *)>);
98
99 static void breakpoint_re_set_default (struct breakpoint *);
100
101 static void
102   create_sals_from_location_default (const struct event_location *location,
103                                      struct linespec_result *canonical,
104                                      enum bptype type_wanted);
105
106 static void create_breakpoints_sal_default (struct gdbarch *,
107                                             struct linespec_result *,
108                                             gdb::unique_xmalloc_ptr<char>,
109                                             gdb::unique_xmalloc_ptr<char>,
110                                             enum bptype,
111                                             enum bpdisp, int, int,
112                                             int,
113                                             const struct breakpoint_ops *,
114                                             int, int, int, unsigned);
115
116 static std::vector<symtab_and_line> decode_location_default
117   (struct breakpoint *b, const struct event_location *location,
118    struct program_space *search_pspace);
119
120 static int can_use_hardware_watchpoint (struct value *);
121
122 static void mention (struct breakpoint *);
123
124 static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
125                                                                enum bptype,
126                                                                const struct breakpoint_ops *);
127 static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
128                                                        const struct symtab_and_line *);
129
130 /* This function is used in gdbtk sources and thus can not be made
131    static.  */
132 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
133                                        struct symtab_and_line,
134                                        enum bptype,
135                                        const struct breakpoint_ops *);
136
137 static struct breakpoint *
138   momentary_breakpoint_from_master (struct breakpoint *orig,
139                                     enum bptype type,
140                                     const struct breakpoint_ops *ops,
141                                     int loc_enabled);
142
143 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
144
145 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
146                                             CORE_ADDR bpaddr,
147                                             enum bptype bptype);
148
149 static void describe_other_breakpoints (struct gdbarch *,
150                                         struct program_space *, CORE_ADDR,
151                                         struct obj_section *, int);
152
153 static int watchpoint_locations_match (struct bp_location *loc1,
154                                        struct bp_location *loc2);
155
156 static int breakpoint_location_address_match (struct bp_location *bl,
157                                               const struct address_space *aspace,
158                                               CORE_ADDR addr);
159
160 static int breakpoint_location_address_range_overlap (struct bp_location *,
161                                                       const address_space *,
162                                                       CORE_ADDR, int);
163
164 static int remove_breakpoint (struct bp_location *);
165 static int remove_breakpoint_1 (struct bp_location *, enum remove_bp_reason);
166
167 static enum print_stop_action print_bp_stop_message (bpstat bs);
168
169 static int hw_breakpoint_used_count (void);
170
171 static int hw_watchpoint_use_count (struct breakpoint *);
172
173 static int hw_watchpoint_used_count_others (struct breakpoint *except,
174                                             enum bptype type,
175                                             int *other_type_used);
176
177 static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
178                                     int count);
179
180 static void free_bp_location (struct bp_location *loc);
181 static void incref_bp_location (struct bp_location *loc);
182 static void decref_bp_location (struct bp_location **loc);
183
184 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
185
186 /* update_global_location_list's modes of operation wrt to whether to
187    insert locations now.  */
188 enum ugll_insert_mode
189 {
190   /* Don't insert any breakpoint locations into the inferior, only
191      remove already-inserted locations that no longer should be
192      inserted.  Functions that delete a breakpoint or breakpoints
193      should specify this mode, so that deleting a breakpoint doesn't
194      have the side effect of inserting the locations of other
195      breakpoints that are marked not-inserted, but should_be_inserted
196      returns true on them.
197
198      This behavior is useful is situations close to tear-down -- e.g.,
199      after an exec, while the target still has execution, but
200      breakpoint shadows of the previous executable image should *NOT*
201      be restored to the new image; or before detaching, where the
202      target still has execution and wants to delete breakpoints from
203      GDB's lists, and all breakpoints had already been removed from
204      the inferior.  */
205   UGLL_DONT_INSERT,
206
207   /* May insert breakpoints iff breakpoints_should_be_inserted_now
208      claims breakpoints should be inserted now.  */
209   UGLL_MAY_INSERT,
210
211   /* Insert locations now, irrespective of
212      breakpoints_should_be_inserted_now.  E.g., say all threads are
213      stopped right now, and the user did "continue".  We need to
214      insert breakpoints _before_ resuming the target, but
215      UGLL_MAY_INSERT wouldn't insert them, because
216      breakpoints_should_be_inserted_now returns false at that point,
217      as no thread is running yet.  */
218   UGLL_INSERT
219 };
220
221 static void update_global_location_list (enum ugll_insert_mode);
222
223 static void update_global_location_list_nothrow (enum ugll_insert_mode);
224
225 static int is_hardware_watchpoint (const struct breakpoint *bpt);
226
227 static void insert_breakpoint_locations (void);
228
229 static void trace_pass_command (const char *, int);
230
231 static void set_tracepoint_count (int num);
232
233 static int is_masked_watchpoint (const struct breakpoint *b);
234
235 static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
236
237 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
238    otherwise.  */
239
240 static int strace_marker_p (struct breakpoint *b);
241
242 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
243    that are implemented on top of software or hardware breakpoints
244    (user breakpoints, internal and momentary breakpoints, etc.).  */
245 static struct breakpoint_ops bkpt_base_breakpoint_ops;
246
247 /* Internal breakpoints class type.  */
248 static struct breakpoint_ops internal_breakpoint_ops;
249
250 /* Momentary breakpoints class type.  */
251 static struct breakpoint_ops momentary_breakpoint_ops;
252
253 /* The breakpoint_ops structure to be used in regular user created
254    breakpoints.  */
255 struct breakpoint_ops bkpt_breakpoint_ops;
256
257 /* Breakpoints set on probes.  */
258 static struct breakpoint_ops bkpt_probe_breakpoint_ops;
259
260 /* Dynamic printf class type.  */
261 struct breakpoint_ops dprintf_breakpoint_ops;
262
263 /* The style in which to perform a dynamic printf.  This is a user
264    option because different output options have different tradeoffs;
265    if GDB does the printing, there is better error handling if there
266    is a problem with any of the arguments, but using an inferior
267    function lets you have special-purpose printers and sending of
268    output to the same place as compiled-in print functions.  */
269
270 static const char dprintf_style_gdb[] = "gdb";
271 static const char dprintf_style_call[] = "call";
272 static const char dprintf_style_agent[] = "agent";
273 static const char *const dprintf_style_enums[] = {
274   dprintf_style_gdb,
275   dprintf_style_call,
276   dprintf_style_agent,
277   NULL
278 };
279 static const char *dprintf_style = dprintf_style_gdb;
280
281 /* The function to use for dynamic printf if the preferred style is to
282    call into the inferior.  The value is simply a string that is
283    copied into the command, so it can be anything that GDB can
284    evaluate to a callable address, not necessarily a function name.  */
285
286 static char *dprintf_function;
287
288 /* The channel to use for dynamic printf if the preferred style is to
289    call into the inferior; if a nonempty string, it will be passed to
290    the call as the first argument, with the format string as the
291    second.  As with the dprintf function, this can be anything that
292    GDB knows how to evaluate, so in addition to common choices like
293    "stderr", this could be an app-specific expression like
294    "mystreams[curlogger]".  */
295
296 static char *dprintf_channel;
297
298 /* True if dprintf commands should continue to operate even if GDB
299    has disconnected.  */
300 static int disconnected_dprintf = 1;
301
302 struct command_line *
303 breakpoint_commands (struct breakpoint *b)
304 {
305   return b->commands ? b->commands.get () : NULL;
306 }
307
308 /* Flag indicating that a command has proceeded the inferior past the
309    current breakpoint.  */
310
311 static int breakpoint_proceeded;
312
313 const char *
314 bpdisp_text (enum bpdisp disp)
315 {
316   /* NOTE: the following values are a part of MI protocol and
317      represent values of 'disp' field returned when inferior stops at
318      a breakpoint.  */
319   static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
320
321   return bpdisps[(int) disp];
322 }
323
324 /* Prototypes for exported functions.  */
325 /* If FALSE, gdb will not use hardware support for watchpoints, even
326    if such is available.  */
327 static int can_use_hw_watchpoints;
328
329 static void
330 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
331                              struct cmd_list_element *c,
332                              const char *value)
333 {
334   fprintf_filtered (file,
335                     _("Debugger's willingness to use "
336                       "watchpoint hardware is %s.\n"),
337                     value);
338 }
339
340 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
341    If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
342    for unrecognized breakpoint locations.
343    If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized.  */
344 static enum auto_boolean pending_break_support;
345 static void
346 show_pending_break_support (struct ui_file *file, int from_tty,
347                             struct cmd_list_element *c,
348                             const char *value)
349 {
350   fprintf_filtered (file,
351                     _("Debugger's behavior regarding "
352                       "pending breakpoints is %s.\n"),
353                     value);
354 }
355
356 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
357    set with "break" but falling in read-only memory.
358    If 0, gdb will warn about such breakpoints, but won't automatically
359    use hardware breakpoints.  */
360 static int automatic_hardware_breakpoints;
361 static void
362 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
363                                      struct cmd_list_element *c,
364                                      const char *value)
365 {
366   fprintf_filtered (file,
367                     _("Automatic usage of hardware breakpoints is %s.\n"),
368                     value);
369 }
370
371 /* If on, GDB keeps breakpoints inserted even if the inferior is
372    stopped, and immediately inserts any new breakpoints as soon as
373    they're created.  If off (default), GDB keeps breakpoints off of
374    the target as long as possible.  That is, it delays inserting
375    breakpoints until the next resume, and removes them again when the
376    target fully stops.  This is a bit safer in case GDB crashes while
377    processing user input.  */
378 static int always_inserted_mode = 0;
379
380 static void
381 show_always_inserted_mode (struct ui_file *file, int from_tty,
382                      struct cmd_list_element *c, const char *value)
383 {
384   fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
385                     value);
386 }
387
388 /* See breakpoint.h.  */
389
390 int
391 breakpoints_should_be_inserted_now (void)
392 {
393   if (gdbarch_has_global_breakpoints (target_gdbarch ()))
394     {
395       /* If breakpoints are global, they should be inserted even if no
396          thread under gdb's control is running, or even if there are
397          no threads under GDB's control yet.  */
398       return 1;
399     }
400   else if (target_has_execution)
401     {
402       struct thread_info *tp;
403
404       if (always_inserted_mode)
405         {
406           /* The user wants breakpoints inserted even if all threads
407              are stopped.  */
408           return 1;
409         }
410
411       if (threads_are_executing ())
412         return 1;
413
414       /* Don't remove breakpoints yet if, even though all threads are
415          stopped, we still have events to process.  */
416       ALL_NON_EXITED_THREADS (tp)
417         if (tp->resumed
418             && tp->suspend.waitstatus_pending_p)
419           return 1;
420     }
421   return 0;
422 }
423
424 static const char condition_evaluation_both[] = "host or target";
425
426 /* Modes for breakpoint condition evaluation.  */
427 static const char condition_evaluation_auto[] = "auto";
428 static const char condition_evaluation_host[] = "host";
429 static const char condition_evaluation_target[] = "target";
430 static const char *const condition_evaluation_enums[] = {
431   condition_evaluation_auto,
432   condition_evaluation_host,
433   condition_evaluation_target,
434   NULL
435 };
436
437 /* Global that holds the current mode for breakpoint condition evaluation.  */
438 static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
439
440 /* Global that we use to display information to the user (gets its value from
441    condition_evaluation_mode_1.  */
442 static const char *condition_evaluation_mode = condition_evaluation_auto;
443
444 /* Translate a condition evaluation mode MODE into either "host"
445    or "target".  This is used mostly to translate from "auto" to the
446    real setting that is being used.  It returns the translated
447    evaluation mode.  */
448
449 static const char *
450 translate_condition_evaluation_mode (const char *mode)
451 {
452   if (mode == condition_evaluation_auto)
453     {
454       if (target_supports_evaluation_of_breakpoint_conditions ())
455         return condition_evaluation_target;
456       else
457         return condition_evaluation_host;
458     }
459   else
460     return mode;
461 }
462
463 /* Discovers what condition_evaluation_auto translates to.  */
464
465 static const char *
466 breakpoint_condition_evaluation_mode (void)
467 {
468   return translate_condition_evaluation_mode (condition_evaluation_mode);
469 }
470
471 /* Return true if GDB should evaluate breakpoint conditions or false
472    otherwise.  */
473
474 static int
475 gdb_evaluates_breakpoint_condition_p (void)
476 {
477   const char *mode = breakpoint_condition_evaluation_mode ();
478
479   return (mode == condition_evaluation_host);
480 }
481
482 /* Are we executing breakpoint commands?  */
483 static int executing_breakpoint_commands;
484
485 /* Are overlay event breakpoints enabled? */
486 static int overlay_events_enabled;
487
488 /* See description in breakpoint.h. */
489 int target_exact_watchpoints = 0;
490
491 /* Walk the following statement or block through all breakpoints.
492    ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
493    current breakpoint.  */
494
495 #define ALL_BREAKPOINTS(B)  for (B = breakpoint_chain; B; B = B->next)
496
497 #define ALL_BREAKPOINTS_SAFE(B,TMP)     \
498         for (B = breakpoint_chain;      \
499              B ? (TMP=B->next, 1): 0;   \
500              B = TMP)
501
502 /* Similar iterator for the low-level breakpoints.  SAFE variant is
503    not provided so update_global_location_list must not be called
504    while executing the block of ALL_BP_LOCATIONS.  */
505
506 #define ALL_BP_LOCATIONS(B,BP_TMP)                                      \
507         for (BP_TMP = bp_locations;                                     \
508              BP_TMP < bp_locations + bp_locations_count && (B = *BP_TMP);\
509              BP_TMP++)
510
511 /* Iterates through locations with address ADDRESS for the currently selected
512    program space.  BP_LOCP_TMP points to each object.  BP_LOCP_START points
513    to where the loop should start from.
514    If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
515    appropriate location to start with.  */
516
517 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS)   \
518         for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
519              BP_LOCP_TMP = BP_LOCP_START;                               \
520              BP_LOCP_START                                              \
521              && (BP_LOCP_TMP < bp_locations + bp_locations_count        \
522              && (*BP_LOCP_TMP)->address == ADDRESS);                    \
523              BP_LOCP_TMP++)
524
525 /* Iterator for tracepoints only.  */
526
527 #define ALL_TRACEPOINTS(B)  \
528   for (B = breakpoint_chain; B; B = B->next)  \
529     if (is_tracepoint (B))
530
531 /* Chains of all breakpoints defined.  */
532
533 struct breakpoint *breakpoint_chain;
534
535 /* Array is sorted by bp_locations_compare - primarily by the ADDRESS.  */
536
537 static struct bp_location **bp_locations;
538
539 /* Number of elements of BP_LOCATIONS.  */
540
541 static unsigned bp_locations_count;
542
543 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
544    ADDRESS for the current elements of BP_LOCATIONS which get a valid
545    result from bp_location_has_shadow.  You can use it for roughly
546    limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
547    an address you need to read.  */
548
549 static CORE_ADDR bp_locations_placed_address_before_address_max;
550
551 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
552    + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
553    BP_LOCATIONS which get a valid result from bp_location_has_shadow.
554    You can use it for roughly limiting the subrange of BP_LOCATIONS to
555    scan for shadow bytes for an address you need to read.  */
556
557 static CORE_ADDR bp_locations_shadow_len_after_address_max;
558
559 /* The locations that no longer correspond to any breakpoint, unlinked
560    from the bp_locations array, but for which a hit may still be
561    reported by a target.  */
562 VEC(bp_location_p) *moribund_locations = NULL;
563
564 /* Number of last breakpoint made.  */
565
566 static int breakpoint_count;
567
568 /* The value of `breakpoint_count' before the last command that
569    created breakpoints.  If the last (break-like) command created more
570    than one breakpoint, then the difference between BREAKPOINT_COUNT
571    and PREV_BREAKPOINT_COUNT is more than one.  */
572 static int prev_breakpoint_count;
573
574 /* Number of last tracepoint made.  */
575
576 static int tracepoint_count;
577
578 static struct cmd_list_element *breakpoint_set_cmdlist;
579 static struct cmd_list_element *breakpoint_show_cmdlist;
580 struct cmd_list_element *save_cmdlist;
581
582 /* See declaration at breakpoint.h.  */
583
584 struct breakpoint *
585 breakpoint_find_if (int (*func) (struct breakpoint *b, void *d),
586                     void *user_data)
587 {
588   struct breakpoint *b = NULL;
589
590   ALL_BREAKPOINTS (b)
591     {
592       if (func (b, user_data) != 0)
593         break;
594     }
595
596   return b;
597 }
598
599 /* Return whether a breakpoint is an active enabled breakpoint.  */
600 static int
601 breakpoint_enabled (struct breakpoint *b)
602 {
603   return (b->enable_state == bp_enabled);
604 }
605
606 /* Set breakpoint count to NUM.  */
607
608 static void
609 set_breakpoint_count (int num)
610 {
611   prev_breakpoint_count = breakpoint_count;
612   breakpoint_count = num;
613   set_internalvar_integer (lookup_internalvar ("bpnum"), num);
614 }
615
616 /* Used by `start_rbreak_breakpoints' below, to record the current
617    breakpoint count before "rbreak" creates any breakpoint.  */
618 static int rbreak_start_breakpoint_count;
619
620 /* Called at the start an "rbreak" command to record the first
621    breakpoint made.  */
622
623 scoped_rbreak_breakpoints::scoped_rbreak_breakpoints ()
624 {
625   rbreak_start_breakpoint_count = breakpoint_count;
626 }
627
628 /* Called at the end of an "rbreak" command to record the last
629    breakpoint made.  */
630
631 scoped_rbreak_breakpoints::~scoped_rbreak_breakpoints ()
632 {
633   prev_breakpoint_count = rbreak_start_breakpoint_count;
634 }
635
636 /* Used in run_command to zero the hit count when a new run starts.  */
637
638 void
639 clear_breakpoint_hit_counts (void)
640 {
641   struct breakpoint *b;
642
643   ALL_BREAKPOINTS (b)
644     b->hit_count = 0;
645 }
646
647 \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 = NULL;
883           arg = exp;
884           w->cond_exp = parse_exp_1 (&arg, 0, 0, 0);
885           if (*arg)
886             error (_("Junk at end of expression"));
887           w->cond_exp_valid_block = innermost_block;
888         }
889       else
890         {
891           struct bp_location *loc;
892
893           for (loc = b->loc; loc; loc = loc->next)
894             {
895               arg = exp;
896               loc->cond =
897                 parse_exp_1 (&arg, loc->address,
898                              block_for_pc (loc->address), 0);
899               if (*arg)
900                 error (_("Junk at end of expression"));
901             }
902         }
903     }
904   mark_breakpoint_modified (b);
905
906   observer_notify_breakpoint_modified (b);
907 }
908
909 /* Completion for the "condition" command.  */
910
911 static void
912 condition_completer (struct cmd_list_element *cmd,
913                      completion_tracker &tracker,
914                      const char *text, const char *word)
915 {
916   const char *space;
917
918   text = skip_spaces (text);
919   space = skip_to_space (text);
920   if (*space == '\0')
921     {
922       int len;
923       struct breakpoint *b;
924
925       if (text[0] == '$')
926         {
927           /* We don't support completion of history indices.  */
928           if (!isdigit (text[1]))
929             complete_internalvar (tracker, &text[1]);
930           return;
931         }
932
933       /* We're completing the breakpoint number.  */
934       len = strlen (text);
935
936       ALL_BREAKPOINTS (b)
937         {
938           char number[50];
939
940           xsnprintf (number, sizeof (number), "%d", b->number);
941
942           if (strncmp (number, text, len) == 0)
943             {
944               gdb::unique_xmalloc_ptr<char> copy (xstrdup (number));
945               tracker.add_completion (std::move (copy));
946             }
947         }
948
949       return;
950     }
951
952   /* We're completing the expression part.  */
953   text = skip_spaces (space);
954   expression_completer (cmd, tracker, text, word);
955 }
956
957 /* condition N EXP -- set break condition of breakpoint N to EXP.  */
958
959 static void
960 condition_command (const char *arg, int from_tty)
961 {
962   struct breakpoint *b;
963   const char *p;
964   int bnum;
965
966   if (arg == 0)
967     error_no_arg (_("breakpoint number"));
968
969   p = arg;
970   bnum = get_number (&p);
971   if (bnum == 0)
972     error (_("Bad breakpoint argument: '%s'"), arg);
973
974   ALL_BREAKPOINTS (b)
975     if (b->number == bnum)
976       {
977         /* Check if this breakpoint has a "stop" method implemented in an
978            extension language.  This method and conditions entered into GDB
979            from the CLI are mutually exclusive.  */
980         const struct extension_language_defn *extlang
981           = get_breakpoint_cond_ext_lang (b, EXT_LANG_NONE);
982
983         if (extlang != NULL)
984           {
985             error (_("Only one stop condition allowed.  There is currently"
986                      " a %s stop condition defined for this breakpoint."),
987                    ext_lang_capitalized_name (extlang));
988           }
989         set_breakpoint_condition (b, p, from_tty);
990
991         if (is_breakpoint (b))
992           update_global_location_list (UGLL_MAY_INSERT);
993
994         return;
995       }
996
997   error (_("No breakpoint number %d."), bnum);
998 }
999
1000 /* Check that COMMAND do not contain commands that are suitable
1001    only for tracepoints and not suitable for ordinary breakpoints.
1002    Throw if any such commands is found.  */
1003
1004 static void
1005 check_no_tracepoint_commands (struct command_line *commands)
1006 {
1007   struct command_line *c;
1008
1009   for (c = commands; c; c = c->next)
1010     {
1011       int i;
1012
1013       if (c->control_type == while_stepping_control)
1014         error (_("The 'while-stepping' command can "
1015                  "only be used for tracepoints"));
1016
1017       for (i = 0; i < c->body_count; ++i)
1018         check_no_tracepoint_commands ((c->body_list)[i]);
1019
1020       /* Not that command parsing removes leading whitespace and comment
1021          lines and also empty lines.  So, we only need to check for
1022          command directly.  */
1023       if (strstr (c->line, "collect ") == c->line)
1024         error (_("The 'collect' command can only be used for tracepoints"));
1025
1026       if (strstr (c->line, "teval ") == c->line)
1027         error (_("The 'teval' command can only be used for tracepoints"));
1028     }
1029 }
1030
1031 struct longjmp_breakpoint : public breakpoint
1032 {
1033   ~longjmp_breakpoint () override;
1034 };
1035
1036 /* Encapsulate tests for different types of tracepoints.  */
1037
1038 static bool
1039 is_tracepoint_type (bptype type)
1040 {
1041   return (type == bp_tracepoint
1042           || type == bp_fast_tracepoint
1043           || type == bp_static_tracepoint);
1044 }
1045
1046 static bool
1047 is_longjmp_type (bptype type)
1048 {
1049   return type == bp_longjmp || type == bp_exception;
1050 }
1051
1052 int
1053 is_tracepoint (const struct breakpoint *b)
1054 {
1055   return is_tracepoint_type (b->type);
1056 }
1057
1058 /* Factory function to create an appropriate instance of breakpoint given
1059    TYPE.  */
1060
1061 static std::unique_ptr<breakpoint>
1062 new_breakpoint_from_type (bptype type)
1063 {
1064   breakpoint *b;
1065
1066   if (is_tracepoint_type (type))
1067     b = new tracepoint ();
1068   else if (is_longjmp_type (type))
1069     b = new longjmp_breakpoint ();
1070   else
1071     b = new breakpoint ();
1072
1073   return std::unique_ptr<breakpoint> (b);
1074 }
1075
1076 /* A helper function that validates that COMMANDS are valid for a
1077    breakpoint.  This function will throw an exception if a problem is
1078    found.  */
1079
1080 static void
1081 validate_commands_for_breakpoint (struct breakpoint *b,
1082                                   struct command_line *commands)
1083 {
1084   if (is_tracepoint (b))
1085     {
1086       struct tracepoint *t = (struct tracepoint *) b;
1087       struct command_line *c;
1088       struct command_line *while_stepping = 0;
1089
1090       /* Reset the while-stepping step count.  The previous commands
1091          might have included a while-stepping action, while the new
1092          ones might not.  */
1093       t->step_count = 0;
1094
1095       /* We need to verify that each top-level element of commands is
1096          valid for tracepoints, that there's at most one
1097          while-stepping element, and that the while-stepping's body
1098          has valid tracing commands excluding nested while-stepping.
1099          We also need to validate the tracepoint action line in the
1100          context of the tracepoint --- validate_actionline actually
1101          has side effects, like setting the tracepoint's
1102          while-stepping STEP_COUNT, in addition to checking if the
1103          collect/teval actions parse and make sense in the
1104          tracepoint's context.  */
1105       for (c = commands; c; c = c->next)
1106         {
1107           if (c->control_type == while_stepping_control)
1108             {
1109               if (b->type == bp_fast_tracepoint)
1110                 error (_("The 'while-stepping' command "
1111                          "cannot be used for fast tracepoint"));
1112               else if (b->type == bp_static_tracepoint)
1113                 error (_("The 'while-stepping' command "
1114                          "cannot be used for static tracepoint"));
1115
1116               if (while_stepping)
1117                 error (_("The 'while-stepping' command "
1118                          "can be used only once"));
1119               else
1120                 while_stepping = c;
1121             }
1122
1123           validate_actionline (c->line, b);
1124         }
1125       if (while_stepping)
1126         {
1127           struct command_line *c2;
1128
1129           gdb_assert (while_stepping->body_count == 1);
1130           c2 = while_stepping->body_list[0];
1131           for (; c2; c2 = c2->next)
1132             {
1133               if (c2->control_type == while_stepping_control)
1134                 error (_("The 'while-stepping' command cannot be nested"));
1135             }
1136         }
1137     }
1138   else
1139     {
1140       check_no_tracepoint_commands (commands);
1141     }
1142 }
1143
1144 /* Return a vector of all the static tracepoints set at ADDR.  The
1145    caller is responsible for releasing the vector.  */
1146
1147 VEC(breakpoint_p) *
1148 static_tracepoints_here (CORE_ADDR addr)
1149 {
1150   struct breakpoint *b;
1151   VEC(breakpoint_p) *found = 0;
1152   struct bp_location *loc;
1153
1154   ALL_BREAKPOINTS (b)
1155     if (b->type == bp_static_tracepoint)
1156       {
1157         for (loc = b->loc; loc; loc = loc->next)
1158           if (loc->address == addr)
1159             VEC_safe_push(breakpoint_p, found, b);
1160       }
1161
1162   return found;
1163 }
1164
1165 /* Set the command list of B to COMMANDS.  If breakpoint is tracepoint,
1166    validate that only allowed commands are included.  */
1167
1168 void
1169 breakpoint_set_commands (struct breakpoint *b, 
1170                          command_line_up &&commands)
1171 {
1172   validate_commands_for_breakpoint (b, commands.get ());
1173
1174   b->commands = std::move (commands);
1175   observer_notify_breakpoint_modified (b);
1176 }
1177
1178 /* Set the internal `silent' flag on the breakpoint.  Note that this
1179    is not the same as the "silent" that may appear in the breakpoint's
1180    commands.  */
1181
1182 void
1183 breakpoint_set_silent (struct breakpoint *b, int silent)
1184 {
1185   int old_silent = b->silent;
1186
1187   b->silent = silent;
1188   if (old_silent != silent)
1189     observer_notify_breakpoint_modified (b);
1190 }
1191
1192 /* Set the thread for this breakpoint.  If THREAD is -1, make the
1193    breakpoint work for any thread.  */
1194
1195 void
1196 breakpoint_set_thread (struct breakpoint *b, int thread)
1197 {
1198   int old_thread = b->thread;
1199
1200   b->thread = thread;
1201   if (old_thread != thread)
1202     observer_notify_breakpoint_modified (b);
1203 }
1204
1205 /* Set the task for this breakpoint.  If TASK is 0, make the
1206    breakpoint work for any task.  */
1207
1208 void
1209 breakpoint_set_task (struct breakpoint *b, int task)
1210 {
1211   int old_task = b->task;
1212
1213   b->task = task;
1214   if (old_task != task)
1215     observer_notify_breakpoint_modified (b);
1216 }
1217
1218 void
1219 check_tracepoint_command (char *line, void *closure)
1220 {
1221   struct breakpoint *b = (struct breakpoint *) closure;
1222
1223   validate_actionline (line, b);
1224 }
1225
1226 static void
1227 commands_command_1 (const char *arg, int from_tty,
1228                     struct command_line *control)
1229 {
1230   counted_command_line cmd;
1231
1232   std::string new_arg;
1233
1234   if (arg == NULL || !*arg)
1235     {
1236       if (breakpoint_count - prev_breakpoint_count > 1)
1237         new_arg = string_printf ("%d-%d", prev_breakpoint_count + 1,
1238                                  breakpoint_count);
1239       else if (breakpoint_count > 0)
1240         new_arg = string_printf ("%d", breakpoint_count);
1241       arg = new_arg.c_str ();
1242     }
1243
1244   map_breakpoint_numbers
1245     (arg, [&] (breakpoint *b)
1246      {
1247        if (cmd == NULL)
1248          {
1249            if (control != NULL)
1250              cmd = copy_command_lines (control->body_list[0]);
1251            else
1252              {
1253                std::string str
1254                  = string_printf (_("Type commands for breakpoint(s) "
1255                                     "%s, one per line."),
1256                                   arg);
1257
1258                cmd = read_command_lines (&str[0],
1259                                          from_tty, 1,
1260                                          (is_tracepoint (b)
1261                                           ? check_tracepoint_command : 0),
1262                                          b);
1263              }
1264          }
1265
1266        /* If a breakpoint was on the list more than once, we don't need to
1267           do anything.  */
1268        if (b->commands != cmd)
1269          {
1270            validate_commands_for_breakpoint (b, cmd.get ());
1271            b->commands = cmd;
1272            observer_notify_breakpoint_modified (b);
1273          }
1274      });
1275 }
1276
1277 static void
1278 commands_command (const char *arg, int from_tty)
1279 {
1280   commands_command_1 (arg, from_tty, NULL);
1281 }
1282
1283 /* Like commands_command, but instead of reading the commands from
1284    input stream, takes them from an already parsed command structure.
1285
1286    This is used by cli-script.c to DTRT with breakpoint commands
1287    that are part of if and while bodies.  */
1288 enum command_control_type
1289 commands_from_control_command (const char *arg, struct command_line *cmd)
1290 {
1291   commands_command_1 (arg, 0, cmd);
1292   return simple_control;
1293 }
1294
1295 /* Return non-zero if BL->TARGET_INFO contains valid information.  */
1296
1297 static int
1298 bp_location_has_shadow (struct bp_location *bl)
1299 {
1300   if (bl->loc_type != bp_loc_software_breakpoint)
1301     return 0;
1302   if (!bl->inserted)
1303     return 0;
1304   if (bl->target_info.shadow_len == 0)
1305     /* BL isn't valid, or doesn't shadow memory.  */
1306     return 0;
1307   return 1;
1308 }
1309
1310 /* Update BUF, which is LEN bytes read from the target address
1311    MEMADDR, by replacing a memory breakpoint with its shadowed
1312    contents.
1313
1314    If READBUF is not NULL, this buffer must not overlap with the of
1315    the breakpoint location's shadow_contents buffer.  Otherwise, a
1316    failed assertion internal error will be raised.  */
1317
1318 static void
1319 one_breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1320                             const gdb_byte *writebuf_org,
1321                             ULONGEST memaddr, LONGEST len,
1322                             struct bp_target_info *target_info,
1323                             struct gdbarch *gdbarch)
1324 {
1325   /* Now do full processing of the found relevant range of elements.  */
1326   CORE_ADDR bp_addr = 0;
1327   int bp_size = 0;
1328   int bptoffset = 0;
1329
1330   if (!breakpoint_address_match (target_info->placed_address_space, 0,
1331                                  current_program_space->aspace, 0))
1332     {
1333       /* The breakpoint is inserted in a different address space.  */
1334       return;
1335     }
1336
1337   /* Addresses and length of the part of the breakpoint that
1338      we need to copy.  */
1339   bp_addr = target_info->placed_address;
1340   bp_size = target_info->shadow_len;
1341
1342   if (bp_addr + bp_size <= memaddr)
1343     {
1344       /* The breakpoint is entirely before the chunk of memory we are
1345          reading.  */
1346       return;
1347     }
1348
1349   if (bp_addr >= memaddr + len)
1350     {
1351       /* The breakpoint is entirely after the chunk of memory we are
1352          reading.  */
1353       return;
1354     }
1355
1356   /* Offset within shadow_contents.  */
1357   if (bp_addr < memaddr)
1358     {
1359       /* Only copy the second part of the breakpoint.  */
1360       bp_size -= memaddr - bp_addr;
1361       bptoffset = memaddr - bp_addr;
1362       bp_addr = memaddr;
1363     }
1364
1365   if (bp_addr + bp_size > memaddr + len)
1366     {
1367       /* Only copy the first part of the breakpoint.  */
1368       bp_size -= (bp_addr + bp_size) - (memaddr + len);
1369     }
1370
1371   if (readbuf != NULL)
1372     {
1373       /* Verify that the readbuf buffer does not overlap with the
1374          shadow_contents buffer.  */
1375       gdb_assert (target_info->shadow_contents >= readbuf + len
1376                   || readbuf >= (target_info->shadow_contents
1377                                  + target_info->shadow_len));
1378
1379       /* Update the read buffer with this inserted breakpoint's
1380          shadow.  */
1381       memcpy (readbuf + bp_addr - memaddr,
1382               target_info->shadow_contents + bptoffset, bp_size);
1383     }
1384   else
1385     {
1386       const unsigned char *bp;
1387       CORE_ADDR addr = target_info->reqstd_address;
1388       int placed_size;
1389
1390       /* Update the shadow with what we want to write to memory.  */
1391       memcpy (target_info->shadow_contents + bptoffset,
1392               writebuf_org + bp_addr - memaddr, bp_size);
1393
1394       /* Determine appropriate breakpoint contents and size for this
1395          address.  */
1396       bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &placed_size);
1397
1398       /* Update the final write buffer with this inserted
1399          breakpoint's INSN.  */
1400       memcpy (writebuf + bp_addr - memaddr, bp + bptoffset, bp_size);
1401     }
1402 }
1403
1404 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1405    by replacing any memory breakpoints with their shadowed contents.
1406
1407    If READBUF is not NULL, this buffer must not overlap with any of
1408    the breakpoint location's shadow_contents buffers.  Otherwise,
1409    a failed assertion internal error will be raised.
1410
1411    The range of shadowed area by each bp_location is:
1412      bl->address - bp_locations_placed_address_before_address_max
1413      up to bl->address + bp_locations_shadow_len_after_address_max
1414    The range we were requested to resolve shadows for is:
1415      memaddr ... memaddr + len
1416    Thus the safe cutoff boundaries for performance optimization are
1417      memaddr + len <= (bl->address
1418                        - bp_locations_placed_address_before_address_max)
1419    and:
1420      bl->address + bp_locations_shadow_len_after_address_max <= memaddr  */
1421
1422 void
1423 breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1424                         const gdb_byte *writebuf_org,
1425                         ULONGEST memaddr, LONGEST len)
1426 {
1427   /* Left boundary, right boundary and median element of our binary
1428      search.  */
1429   unsigned bc_l, bc_r, bc;
1430
1431   /* Find BC_L which is a leftmost element which may affect BUF
1432      content.  It is safe to report lower value but a failure to
1433      report higher one.  */
1434
1435   bc_l = 0;
1436   bc_r = bp_locations_count;
1437   while (bc_l + 1 < bc_r)
1438     {
1439       struct bp_location *bl;
1440
1441       bc = (bc_l + bc_r) / 2;
1442       bl = bp_locations[bc];
1443
1444       /* Check first BL->ADDRESS will not overflow due to the added
1445          constant.  Then advance the left boundary only if we are sure
1446          the BC element can in no way affect the BUF content (MEMADDR
1447          to MEMADDR + LEN range).
1448
1449          Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1450          offset so that we cannot miss a breakpoint with its shadow
1451          range tail still reaching MEMADDR.  */
1452
1453       if ((bl->address + bp_locations_shadow_len_after_address_max
1454            >= bl->address)
1455           && (bl->address + bp_locations_shadow_len_after_address_max
1456               <= memaddr))
1457         bc_l = bc;
1458       else
1459         bc_r = bc;
1460     }
1461
1462   /* Due to the binary search above, we need to make sure we pick the
1463      first location that's at BC_L's address.  E.g., if there are
1464      multiple locations at the same address, BC_L may end up pointing
1465      at a duplicate location, and miss the "master"/"inserted"
1466      location.  Say, given locations L1, L2 and L3 at addresses A and
1467      B:
1468
1469       L1@A, L2@A, L3@B, ...
1470
1471      BC_L could end up pointing at location L2, while the "master"
1472      location could be L1.  Since the `loc->inserted' flag is only set
1473      on "master" locations, we'd forget to restore the shadow of L1
1474      and L2.  */
1475   while (bc_l > 0
1476          && bp_locations[bc_l]->address == bp_locations[bc_l - 1]->address)
1477     bc_l--;
1478
1479   /* Now do full processing of the found relevant range of elements.  */
1480
1481   for (bc = bc_l; bc < bp_locations_count; bc++)
1482   {
1483     struct bp_location *bl = bp_locations[bc];
1484
1485     /* bp_location array has BL->OWNER always non-NULL.  */
1486     if (bl->owner->type == bp_none)
1487       warning (_("reading through apparently deleted breakpoint #%d?"),
1488                bl->owner->number);
1489
1490     /* Performance optimization: any further element can no longer affect BUF
1491        content.  */
1492
1493     if (bl->address >= bp_locations_placed_address_before_address_max
1494         && memaddr + len <= (bl->address
1495                              - bp_locations_placed_address_before_address_max))
1496       break;
1497
1498     if (!bp_location_has_shadow (bl))
1499       continue;
1500
1501     one_breakpoint_xfer_memory (readbuf, writebuf, writebuf_org,
1502                                 memaddr, len, &bl->target_info, bl->gdbarch);
1503   }
1504 }
1505
1506 \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           && (ptid_equal (b->watchpoint_thread, null_ptid)
1553               || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1554                   && !is_executing (inferior_ptid))));
1555 }
1556
1557 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1558    associated bp_watchpoint_scope breakpoint.  */
1559
1560 static void
1561 watchpoint_del_at_next_stop (struct watchpoint *w)
1562 {
1563   if (w->related_breakpoint != w)
1564     {
1565       gdb_assert (w->related_breakpoint->type == bp_watchpoint_scope);
1566       gdb_assert (w->related_breakpoint->related_breakpoint == w);
1567       w->related_breakpoint->disposition = disp_del_at_next_stop;
1568       w->related_breakpoint->related_breakpoint = w->related_breakpoint;
1569       w->related_breakpoint = w;
1570     }
1571   w->disposition = disp_del_at_next_stop;
1572 }
1573
1574 /* Extract a bitfield value from value VAL using the bit parameters contained in
1575    watchpoint W.  */
1576
1577 static struct value *
1578 extract_bitfield_from_watchpoint_value (struct watchpoint *w, struct value *val)
1579 {
1580   struct value *bit_val;
1581
1582   if (val == NULL)
1583     return NULL;
1584
1585   bit_val = allocate_value (value_type (val));
1586
1587   unpack_value_bitfield (bit_val,
1588                          w->val_bitpos,
1589                          w->val_bitsize,
1590                          value_contents_for_printing (val),
1591                          value_offset (val),
1592                          val);
1593
1594   return bit_val;
1595 }
1596
1597 /* Allocate a dummy location and add it to B, which must be a software
1598    watchpoint.  This is required because even if a software watchpoint
1599    is not watching any memory, bpstat_stop_status requires a location
1600    to be able to report stops.  */
1601
1602 static void
1603 software_watchpoint_add_no_memory_location (struct breakpoint *b,
1604                                             struct program_space *pspace)
1605 {
1606   gdb_assert (b->type == bp_watchpoint && b->loc == NULL);
1607
1608   b->loc = allocate_bp_location (b);
1609   b->loc->pspace = pspace;
1610   b->loc->address = -1;
1611   b->loc->length = -1;
1612 }
1613
1614 /* Returns true if B is a software watchpoint that is not watching any
1615    memory (e.g., "watch $pc").  */
1616
1617 static int
1618 is_no_memory_software_watchpoint (struct breakpoint *b)
1619 {
1620   return (b->type == bp_watchpoint
1621           && b->loc != NULL
1622           && b->loc->next == NULL
1623           && b->loc->address == -1
1624           && b->loc->length == -1);
1625 }
1626
1627 /* Assuming that B is a watchpoint:
1628    - Reparse watchpoint expression, if REPARSE is non-zero
1629    - Evaluate expression and store the result in B->val
1630    - Evaluate the condition if there is one, and store the result
1631      in b->loc->cond.
1632    - Update the list of values that must be watched in B->loc.
1633
1634    If the watchpoint disposition is disp_del_at_next_stop, then do
1635    nothing.  If this is local watchpoint that is out of scope, delete
1636    it.
1637
1638    Even with `set breakpoint always-inserted on' the watchpoints are
1639    removed + inserted on each stop here.  Normal breakpoints must
1640    never be removed because they might be missed by a running thread
1641    when debugging in non-stop mode.  On the other hand, hardware
1642    watchpoints (is_hardware_watchpoint; processed here) are specific
1643    to each LWP since they are stored in each LWP's hardware debug
1644    registers.  Therefore, such LWP must be stopped first in order to
1645    be able to modify its hardware watchpoints.
1646
1647    Hardware watchpoints must be reset exactly once after being
1648    presented to the user.  It cannot be done sooner, because it would
1649    reset the data used to present the watchpoint hit to the user.  And
1650    it must not be done later because it could display the same single
1651    watchpoint hit during multiple GDB stops.  Note that the latter is
1652    relevant only to the hardware watchpoint types bp_read_watchpoint
1653    and bp_access_watchpoint.  False hit by bp_hardware_watchpoint is
1654    not user-visible - its hit is suppressed if the memory content has
1655    not changed.
1656
1657    The following constraints influence the location where we can reset
1658    hardware watchpoints:
1659
1660    * target_stopped_by_watchpoint and target_stopped_data_address are
1661      called several times when GDB stops.
1662
1663    [linux] 
1664    * Multiple hardware watchpoints can be hit at the same time,
1665      causing GDB to stop.  GDB only presents one hardware watchpoint
1666      hit at a time as the reason for stopping, and all the other hits
1667      are presented later, one after the other, each time the user
1668      requests the execution to be resumed.  Execution is not resumed
1669      for the threads still having pending hit event stored in
1670      LWP_INFO->STATUS.  While the watchpoint is already removed from
1671      the inferior on the first stop the thread hit event is kept being
1672      reported from its cached value by linux_nat_stopped_data_address
1673      until the real thread resume happens after the watchpoint gets
1674      presented and thus its LWP_INFO->STATUS gets reset.
1675
1676    Therefore the hardware watchpoint hit can get safely reset on the
1677    watchpoint removal from inferior.  */
1678
1679 static void
1680 update_watchpoint (struct watchpoint *b, int reparse)
1681 {
1682   int within_current_scope;
1683   struct frame_id saved_frame_id;
1684   int frame_saved;
1685
1686   /* If this is a local watchpoint, we only want to check if the
1687      watchpoint frame is in scope if the current thread is the thread
1688      that was used to create the watchpoint.  */
1689   if (!watchpoint_in_thread_scope (b))
1690     return;
1691
1692   if (b->disposition == disp_del_at_next_stop)
1693     return;
1694  
1695   frame_saved = 0;
1696
1697   /* Determine if the watchpoint is within scope.  */
1698   if (b->exp_valid_block == NULL)
1699     within_current_scope = 1;
1700   else
1701     {
1702       struct frame_info *fi = get_current_frame ();
1703       struct gdbarch *frame_arch = get_frame_arch (fi);
1704       CORE_ADDR frame_pc = get_frame_pc (fi);
1705
1706       /* If we're at a point where the stack has been destroyed
1707          (e.g. in a function epilogue), unwinding may not work
1708          properly. Do not attempt to recreate locations at this
1709          point.  See similar comments in watchpoint_check.  */
1710       if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
1711         return;
1712
1713       /* Save the current frame's ID so we can restore it after
1714          evaluating the watchpoint expression on its own frame.  */
1715       /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1716          took a frame parameter, so that we didn't have to change the
1717          selected frame.  */
1718       frame_saved = 1;
1719       saved_frame_id = get_frame_id (get_selected_frame (NULL));
1720
1721       fi = frame_find_by_id (b->watchpoint_frame);
1722       within_current_scope = (fi != NULL);
1723       if (within_current_scope)
1724         select_frame (fi);
1725     }
1726
1727   /* We don't free locations.  They are stored in the bp_location array
1728      and update_global_location_list will eventually delete them and
1729      remove breakpoints if needed.  */
1730   b->loc = NULL;
1731
1732   if (within_current_scope && reparse)
1733     {
1734       const char *s;
1735
1736       b->exp.reset ();
1737       s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1738       b->exp = parse_exp_1 (&s, 0, b->exp_valid_block, 0);
1739       /* If the meaning of expression itself changed, the old value is
1740          no longer relevant.  We don't want to report a watchpoint hit
1741          to the user when the old value and the new value may actually
1742          be completely different objects.  */
1743       value_free (b->val);
1744       b->val = NULL;
1745       b->val_valid = 0;
1746
1747       /* Note that unlike with breakpoints, the watchpoint's condition
1748          expression is stored in the breakpoint object, not in the
1749          locations (re)created below.  */
1750       if (b->cond_string != NULL)
1751         {
1752           b->cond_exp.reset ();
1753
1754           s = b->cond_string;
1755           b->cond_exp = parse_exp_1 (&s, 0, b->cond_exp_valid_block, 0);
1756         }
1757     }
1758
1759   /* If we failed to parse the expression, for example because
1760      it refers to a global variable in a not-yet-loaded shared library,
1761      don't try to insert watchpoint.  We don't automatically delete
1762      such watchpoint, though, since failure to parse expression
1763      is different from out-of-scope watchpoint.  */
1764   if (!target_has_execution)
1765     {
1766       /* Without execution, memory can't change.  No use to try and
1767          set watchpoint locations.  The watchpoint will be reset when
1768          the target gains execution, through breakpoint_re_set.  */
1769       if (!can_use_hw_watchpoints)
1770         {
1771           if (b->ops->works_in_software_mode (b))
1772             b->type = bp_watchpoint;
1773           else
1774             error (_("Can't set read/access watchpoint when "
1775                      "hardware watchpoints are disabled."));
1776         }
1777     }
1778   else if (within_current_scope && b->exp)
1779     {
1780       int pc = 0;
1781       struct value *val_chain, *v, *result, *next;
1782       struct program_space *frame_pspace;
1783
1784       fetch_subexp_value (b->exp.get (), &pc, &v, &result, &val_chain, 0);
1785
1786       /* Avoid setting b->val if it's already set.  The meaning of
1787          b->val is 'the last value' user saw, and we should update
1788          it only if we reported that last value to user.  As it
1789          happens, the code that reports it updates b->val directly.
1790          We don't keep track of the memory value for masked
1791          watchpoints.  */
1792       if (!b->val_valid && !is_masked_watchpoint (b))
1793         {
1794           if (b->val_bitsize != 0)
1795             {
1796               v = extract_bitfield_from_watchpoint_value (b, v);
1797               if (v != NULL)
1798                 release_value (v);
1799             }
1800           b->val = v;
1801           b->val_valid = 1;
1802         }
1803
1804       frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1805
1806       /* Look at each value on the value chain.  */
1807       for (v = val_chain; v; v = value_next (v))
1808         {
1809           /* If it's a memory location, and GDB actually needed
1810              its contents to evaluate the expression, then we
1811              must watch it.  If the first value returned is
1812              still lazy, that means an error occurred reading it;
1813              watch it anyway in case it becomes readable.  */
1814           if (VALUE_LVAL (v) == lval_memory
1815               && (v == val_chain || ! value_lazy (v)))
1816             {
1817               struct type *vtype = check_typedef (value_type (v));
1818
1819               /* We only watch structs and arrays if user asked
1820                  for it explicitly, never if they just happen to
1821                  appear in the middle of some value chain.  */
1822               if (v == result
1823                   || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1824                       && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1825                 {
1826                   CORE_ADDR addr;
1827                   enum target_hw_bp_type type;
1828                   struct bp_location *loc, **tmp;
1829                   int bitpos = 0, bitsize = 0;
1830
1831                   if (value_bitsize (v) != 0)
1832                     {
1833                       /* Extract the bit parameters out from the bitfield
1834                          sub-expression.  */
1835                       bitpos = value_bitpos (v);
1836                       bitsize = value_bitsize (v);
1837                     }
1838                   else if (v == result && b->val_bitsize != 0)
1839                     {
1840                      /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1841                         lvalue whose bit parameters are saved in the fields
1842                         VAL_BITPOS and VAL_BITSIZE.  */
1843                       bitpos = b->val_bitpos;
1844                       bitsize = b->val_bitsize;
1845                     }
1846
1847                   addr = value_address (v);
1848                   if (bitsize != 0)
1849                     {
1850                       /* Skip the bytes that don't contain the bitfield.  */
1851                       addr += bitpos / 8;
1852                     }
1853
1854                   type = hw_write;
1855                   if (b->type == bp_read_watchpoint)
1856                     type = hw_read;
1857                   else if (b->type == bp_access_watchpoint)
1858                     type = hw_access;
1859
1860                   loc = allocate_bp_location (b);
1861                   for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
1862                     ;
1863                   *tmp = loc;
1864                   loc->gdbarch = get_type_arch (value_type (v));
1865
1866                   loc->pspace = frame_pspace;
1867                   loc->address = address_significant (loc->gdbarch, addr);
1868
1869                   if (bitsize != 0)
1870                     {
1871                       /* Just cover the bytes that make up the bitfield.  */
1872                       loc->length = ((bitpos % 8) + bitsize + 7) / 8;
1873                     }
1874                   else
1875                     loc->length = TYPE_LENGTH (value_type (v));
1876
1877                   loc->watchpoint_type = type;
1878                 }
1879             }
1880         }
1881
1882       /* Change the type of breakpoint between hardware assisted or
1883          an ordinary watchpoint depending on the hardware support
1884          and free hardware slots.  REPARSE is set when the inferior
1885          is started.  */
1886       if (reparse)
1887         {
1888           int reg_cnt;
1889           enum bp_loc_type loc_type;
1890           struct bp_location *bl;
1891
1892           reg_cnt = can_use_hardware_watchpoint (val_chain);
1893
1894           if (reg_cnt)
1895             {
1896               int i, target_resources_ok, other_type_used;
1897               enum bptype type;
1898
1899               /* Use an exact watchpoint when there's only one memory region to be
1900                  watched, and only one debug register is needed to watch it.  */
1901               b->exact = target_exact_watchpoints && reg_cnt == 1;
1902
1903               /* We need to determine how many resources are already
1904                  used for all other hardware watchpoints plus this one
1905                  to see if we still have enough resources to also fit
1906                  this watchpoint in as well.  */
1907
1908               /* If this is a software watchpoint, we try to turn it
1909                  to a hardware one -- count resources as if B was of
1910                  hardware watchpoint type.  */
1911               type = b->type;
1912               if (type == bp_watchpoint)
1913                 type = bp_hardware_watchpoint;
1914
1915               /* This watchpoint may or may not have been placed on
1916                  the list yet at this point (it won't be in the list
1917                  if we're trying to create it for the first time,
1918                  through watch_command), so always account for it
1919                  manually.  */
1920
1921               /* Count resources used by all watchpoints except B.  */
1922               i = hw_watchpoint_used_count_others (b, type, &other_type_used);
1923
1924               /* Add in the resources needed for B.  */
1925               i += hw_watchpoint_use_count (b);
1926
1927               target_resources_ok
1928                 = target_can_use_hardware_watchpoint (type, i, other_type_used);
1929               if (target_resources_ok <= 0)
1930                 {
1931                   int sw_mode = b->ops->works_in_software_mode (b);
1932
1933                   if (target_resources_ok == 0 && !sw_mode)
1934                     error (_("Target does not support this type of "
1935                              "hardware watchpoint."));
1936                   else if (target_resources_ok < 0 && !sw_mode)
1937                     error (_("There are not enough available hardware "
1938                              "resources for this watchpoint."));
1939
1940                   /* Downgrade to software watchpoint.  */
1941                   b->type = bp_watchpoint;
1942                 }
1943               else
1944                 {
1945                   /* If this was a software watchpoint, we've just
1946                      found we have enough resources to turn it to a
1947                      hardware watchpoint.  Otherwise, this is a
1948                      nop.  */
1949                   b->type = type;
1950                 }
1951             }
1952           else if (!b->ops->works_in_software_mode (b))
1953             {
1954               if (!can_use_hw_watchpoints)
1955                 error (_("Can't set read/access watchpoint when "
1956                          "hardware watchpoints are disabled."));
1957               else
1958                 error (_("Expression cannot be implemented with "
1959                          "read/access watchpoint."));
1960             }
1961           else
1962             b->type = bp_watchpoint;
1963
1964           loc_type = (b->type == bp_watchpoint? bp_loc_other
1965                       : bp_loc_hardware_watchpoint);
1966           for (bl = b->loc; bl; bl = bl->next)
1967             bl->loc_type = loc_type;
1968         }
1969
1970       for (v = val_chain; v; v = next)
1971         {
1972           next = value_next (v);
1973           if (v != b->val)
1974             value_free (v);
1975         }
1976
1977       /* If a software watchpoint is not watching any memory, then the
1978          above left it without any location set up.  But,
1979          bpstat_stop_status requires a location to be able to report
1980          stops, so make sure there's at least a dummy one.  */
1981       if (b->type == bp_watchpoint && b->loc == NULL)
1982         software_watchpoint_add_no_memory_location (b, frame_pspace);
1983     }
1984   else if (!within_current_scope)
1985     {
1986       printf_filtered (_("\
1987 Watchpoint %d deleted because the program has left the block\n\
1988 in which its expression is valid.\n"),
1989                        b->number);
1990       watchpoint_del_at_next_stop (b);
1991     }
1992
1993   /* Restore the selected frame.  */
1994   if (frame_saved)
1995     select_frame (frame_find_by_id (saved_frame_id));
1996 }
1997
1998
1999 /* Returns 1 iff breakpoint location should be
2000    inserted in the inferior.  We don't differentiate the type of BL's owner
2001    (breakpoint vs. tracepoint), although insert_location in tracepoint's
2002    breakpoint_ops is not defined, because in insert_bp_location,
2003    tracepoint's insert_location will not be called.  */
2004 static int
2005 should_be_inserted (struct bp_location *bl)
2006 {
2007   if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
2008     return 0;
2009
2010   if (bl->owner->disposition == disp_del_at_next_stop)
2011     return 0;
2012
2013   if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
2014     return 0;
2015
2016   if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
2017     return 0;
2018
2019   /* This is set for example, when we're attached to the parent of a
2020      vfork, and have detached from the child.  The child is running
2021      free, and we expect it to do an exec or exit, at which point the
2022      OS makes the parent schedulable again (and the target reports
2023      that the vfork is done).  Until the child is done with the shared
2024      memory region, do not insert breakpoints in the parent, otherwise
2025      the child could still trip on the parent's breakpoints.  Since
2026      the parent is blocked anyway, it won't miss any breakpoint.  */
2027   if (bl->pspace->breakpoints_not_allowed)
2028     return 0;
2029
2030   /* Don't insert a breakpoint if we're trying to step past its
2031      location, except if the breakpoint is a single-step breakpoint,
2032      and the breakpoint's thread is the thread which is stepping past
2033      a breakpoint.  */
2034   if ((bl->loc_type == bp_loc_software_breakpoint
2035        || bl->loc_type == bp_loc_hardware_breakpoint)
2036       && stepping_past_instruction_at (bl->pspace->aspace,
2037                                        bl->address)
2038       /* The single-step breakpoint may be inserted at the location
2039          we're trying to step if the instruction branches to itself.
2040          However, the instruction won't be executed at all and it may
2041          break the semantics of the instruction, for example, the
2042          instruction is a conditional branch or updates some flags.
2043          We can't fix it unless GDB is able to emulate the instruction
2044          or switch to displaced stepping.  */
2045       && !(bl->owner->type == bp_single_step
2046            && thread_is_stepping_over_breakpoint (bl->owner->thread)))
2047     {
2048       if (debug_infrun)
2049         {
2050           fprintf_unfiltered (gdb_stdlog,
2051                               "infrun: skipping breakpoint: "
2052                               "stepping past insn at: %s\n",
2053                               paddress (bl->gdbarch, bl->address));
2054         }
2055       return 0;
2056     }
2057
2058   /* Don't insert watchpoints if we're trying to step past the
2059      instruction that triggered one.  */
2060   if ((bl->loc_type == bp_loc_hardware_watchpoint)
2061       && stepping_past_nonsteppable_watchpoint ())
2062     {
2063       if (debug_infrun)
2064         {
2065           fprintf_unfiltered (gdb_stdlog,
2066                               "infrun: stepping past non-steppable watchpoint. "
2067                               "skipping watchpoint at %s:%d\n",
2068                               paddress (bl->gdbarch, bl->address),
2069                               bl->length);
2070         }
2071       return 0;
2072     }
2073
2074   return 1;
2075 }
2076
2077 /* Same as should_be_inserted but does the check assuming
2078    that the location is not duplicated.  */
2079
2080 static int
2081 unduplicated_should_be_inserted (struct bp_location *bl)
2082 {
2083   int result;
2084   const int save_duplicate = bl->duplicate;
2085
2086   bl->duplicate = 0;
2087   result = should_be_inserted (bl);
2088   bl->duplicate = save_duplicate;
2089   return result;
2090 }
2091
2092 /* Parses a conditional described by an expression COND into an
2093    agent expression bytecode suitable for evaluation
2094    by the bytecode interpreter.  Return NULL if there was
2095    any error during parsing.  */
2096
2097 static agent_expr_up
2098 parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
2099 {
2100   if (cond == NULL)
2101     return NULL;
2102
2103   agent_expr_up aexpr;
2104
2105   /* We don't want to stop processing, so catch any errors
2106      that may show up.  */
2107   TRY
2108     {
2109       aexpr = gen_eval_for_expr (scope, cond);
2110     }
2111
2112   CATCH (ex, RETURN_MASK_ERROR)
2113     {
2114       /* If we got here, it means the condition could not be parsed to a valid
2115          bytecode expression and thus can't be evaluated on the target's side.
2116          It's no use iterating through the conditions.  */
2117     }
2118   END_CATCH
2119
2120   /* We have a valid agent expression.  */
2121   return aexpr;
2122 }
2123
2124 /* Based on location BL, create a list of breakpoint conditions to be
2125    passed on to the target.  If we have duplicated locations with different
2126    conditions, we will add such conditions to the list.  The idea is that the
2127    target will evaluate the list of conditions and will only notify GDB when
2128    one of them is true.  */
2129
2130 static void
2131 build_target_condition_list (struct bp_location *bl)
2132 {
2133   struct bp_location **locp = NULL, **loc2p;
2134   int null_condition_or_parse_error = 0;
2135   int modified = bl->needs_update;
2136   struct bp_location *loc;
2137
2138   /* Release conditions left over from a previous insert.  */
2139   bl->target_info.conditions.clear ();
2140
2141   /* This is only meaningful if the target is
2142      evaluating conditions and if the user has
2143      opted for condition evaluation on the target's
2144      side.  */
2145   if (gdb_evaluates_breakpoint_condition_p ()
2146       || !target_supports_evaluation_of_breakpoint_conditions ())
2147     return;
2148
2149   /* Do a first pass to check for locations with no assigned
2150      conditions or conditions that fail to parse to a valid agent expression
2151      bytecode.  If any of these happen, then it's no use to send conditions
2152      to the target since this location will always trigger and generate a
2153      response back to GDB.  */
2154   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2155     {
2156       loc = (*loc2p);
2157       if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2158         {
2159           if (modified)
2160             {
2161               /* Re-parse the conditions since something changed.  In that
2162                  case we already freed the condition bytecodes (see
2163                  force_breakpoint_reinsertion).  We just
2164                  need to parse the condition to bytecodes again.  */
2165               loc->cond_bytecode = parse_cond_to_aexpr (bl->address,
2166                                                         loc->cond.get ());
2167             }
2168
2169           /* If we have a NULL bytecode expression, it means something
2170              went wrong or we have a null condition expression.  */
2171           if (!loc->cond_bytecode)
2172             {
2173               null_condition_or_parse_error = 1;
2174               break;
2175             }
2176         }
2177     }
2178
2179   /* If any of these happened, it means we will have to evaluate the conditions
2180      for the location's address on gdb's side.  It is no use keeping bytecodes
2181      for all the other duplicate locations, thus we free all of them here.
2182
2183      This is so we have a finer control over which locations' conditions are
2184      being evaluated by GDB or the remote stub.  */
2185   if (null_condition_or_parse_error)
2186     {
2187       ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2188         {
2189           loc = (*loc2p);
2190           if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2191             {
2192               /* Only go as far as the first NULL bytecode is
2193                  located.  */
2194               if (!loc->cond_bytecode)
2195                 return;
2196
2197               loc->cond_bytecode.reset ();
2198             }
2199         }
2200     }
2201
2202   /* No NULL conditions or failed bytecode generation.  Build a condition list
2203      for this location's address.  */
2204   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2205     {
2206       loc = (*loc2p);
2207       if (loc->cond
2208           && is_breakpoint (loc->owner)
2209           && loc->pspace->num == bl->pspace->num
2210           && loc->owner->enable_state == bp_enabled
2211           && loc->enabled)
2212         {
2213           /* Add the condition to the vector.  This will be used later
2214              to send the conditions to the target.  */
2215           bl->target_info.conditions.push_back (loc->cond_bytecode.get ());
2216         }
2217     }
2218
2219   return;
2220 }
2221
2222 /* Parses a command described by string CMD into an agent expression
2223    bytecode suitable for evaluation by the bytecode interpreter.
2224    Return NULL if there was any error during parsing.  */
2225
2226 static agent_expr_up
2227 parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
2228 {
2229   const char *cmdrest;
2230   const char *format_start, *format_end;
2231   struct gdbarch *gdbarch = get_current_arch ();
2232
2233   if (cmd == NULL)
2234     return NULL;
2235
2236   cmdrest = cmd;
2237
2238   if (*cmdrest == ',')
2239     ++cmdrest;
2240   cmdrest = skip_spaces (cmdrest);
2241
2242   if (*cmdrest++ != '"')
2243     error (_("No format string following the location"));
2244
2245   format_start = cmdrest;
2246
2247   format_pieces fpieces (&cmdrest);
2248
2249   format_end = cmdrest;
2250
2251   if (*cmdrest++ != '"')
2252     error (_("Bad format string, non-terminated '\"'."));
2253   
2254   cmdrest = skip_spaces (cmdrest);
2255
2256   if (!(*cmdrest == ',' || *cmdrest == '\0'))
2257     error (_("Invalid argument syntax"));
2258
2259   if (*cmdrest == ',')
2260     cmdrest++;
2261   cmdrest = skip_spaces (cmdrest);
2262
2263   /* For each argument, make an expression.  */
2264
2265   std::vector<struct expression *> argvec;
2266   while (*cmdrest != '\0')
2267     {
2268       const char *cmd1;
2269
2270       cmd1 = cmdrest;
2271       expression_up expr = parse_exp_1 (&cmd1, scope, block_for_pc (scope), 1);
2272       argvec.push_back (expr.release ());
2273       cmdrest = cmd1;
2274       if (*cmdrest == ',')
2275         ++cmdrest;
2276     }
2277
2278   agent_expr_up aexpr;
2279
2280   /* We don't want to stop processing, so catch any errors
2281      that may show up.  */
2282   TRY
2283     {
2284       aexpr = gen_printf (scope, gdbarch, 0, 0,
2285                           format_start, format_end - format_start,
2286                           argvec.size (), argvec.data ());
2287     }
2288   CATCH (ex, RETURN_MASK_ERROR)
2289     {
2290       /* If we got here, it means the command could not be parsed to a valid
2291          bytecode expression and thus can't be evaluated on the target's side.
2292          It's no use iterating through the other commands.  */
2293     }
2294   END_CATCH
2295
2296   /* We have a valid agent expression, return it.  */
2297   return aexpr;
2298 }
2299
2300 /* Based on location BL, create a list of breakpoint commands to be
2301    passed on to the target.  If we have duplicated locations with
2302    different commands, we will add any such to the list.  */
2303
2304 static void
2305 build_target_command_list (struct bp_location *bl)
2306 {
2307   struct bp_location **locp = NULL, **loc2p;
2308   int null_command_or_parse_error = 0;
2309   int modified = bl->needs_update;
2310   struct bp_location *loc;
2311
2312   /* Clear commands left over from a previous insert.  */
2313   bl->target_info.tcommands.clear ();
2314
2315   if (!target_can_run_breakpoint_commands ())
2316     return;
2317
2318   /* For now, limit to agent-style dprintf breakpoints.  */
2319   if (dprintf_style != dprintf_style_agent)
2320     return;
2321
2322   /* For now, if we have any duplicate location that isn't a dprintf,
2323      don't install the target-side commands, as that would make the
2324      breakpoint not be reported to the core, and we'd lose
2325      control.  */
2326   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2327     {
2328       loc = (*loc2p);
2329       if (is_breakpoint (loc->owner)
2330           && loc->pspace->num == bl->pspace->num
2331           && loc->owner->type != bp_dprintf)
2332         return;
2333     }
2334
2335   /* Do a first pass to check for locations with no assigned
2336      conditions or conditions that fail to parse to a valid agent expression
2337      bytecode.  If any of these happen, then it's no use to send conditions
2338      to the target since this location will always trigger and generate a
2339      response back to GDB.  */
2340   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2341     {
2342       loc = (*loc2p);
2343       if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2344         {
2345           if (modified)
2346             {
2347               /* Re-parse the commands since something changed.  In that
2348                  case we already freed the command bytecodes (see
2349                  force_breakpoint_reinsertion).  We just
2350                  need to parse the command to bytecodes again.  */
2351               loc->cmd_bytecode
2352                 = parse_cmd_to_aexpr (bl->address,
2353                                       loc->owner->extra_string);
2354             }
2355
2356           /* If we have a NULL bytecode expression, it means something
2357              went wrong or we have a null command expression.  */
2358           if (!loc->cmd_bytecode)
2359             {
2360               null_command_or_parse_error = 1;
2361               break;
2362             }
2363         }
2364     }
2365
2366   /* If anything failed, then we're not doing target-side commands,
2367      and so clean up.  */
2368   if (null_command_or_parse_error)
2369     {
2370       ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2371         {
2372           loc = (*loc2p);
2373           if (is_breakpoint (loc->owner)
2374               && loc->pspace->num == bl->pspace->num)
2375             {
2376               /* Only go as far as the first NULL bytecode is
2377                  located.  */
2378               if (loc->cmd_bytecode == NULL)
2379                 return;
2380
2381               loc->cmd_bytecode.reset ();
2382             }
2383         }
2384     }
2385
2386   /* No NULL commands or failed bytecode generation.  Build a command list
2387      for this location's address.  */
2388   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2389     {
2390       loc = (*loc2p);
2391       if (loc->owner->extra_string
2392           && is_breakpoint (loc->owner)
2393           && loc->pspace->num == bl->pspace->num
2394           && loc->owner->enable_state == bp_enabled
2395           && loc->enabled)
2396         {
2397           /* Add the command to the vector.  This will be used later
2398              to send the commands to the target.  */
2399           bl->target_info.tcommands.push_back (loc->cmd_bytecode.get ());
2400         }
2401     }
2402
2403   bl->target_info.persist = 0;
2404   /* Maybe flag this location as persistent.  */
2405   if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2406     bl->target_info.persist = 1;
2407 }
2408
2409 /* Return the kind of breakpoint on address *ADDR.  Get the kind
2410    of breakpoint according to ADDR except single-step breakpoint.
2411    Get the kind of single-step breakpoint according to the current
2412    registers state.  */
2413
2414 static int
2415 breakpoint_kind (struct bp_location *bl, CORE_ADDR *addr)
2416 {
2417   if (bl->owner->type == bp_single_step)
2418     {
2419       struct thread_info *thr = find_thread_global_id (bl->owner->thread);
2420       struct regcache *regcache;
2421
2422       regcache = get_thread_regcache (thr->ptid);
2423
2424       return gdbarch_breakpoint_kind_from_current_state (bl->gdbarch,
2425                                                          regcache, addr);
2426     }
2427   else
2428     return gdbarch_breakpoint_kind_from_pc (bl->gdbarch, addr);
2429 }
2430
2431 /* Insert a low-level "breakpoint" of some type.  BL is the breakpoint
2432    location.  Any error messages are printed to TMP_ERROR_STREAM; and
2433    DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2434    Returns 0 for success, 1 if the bp_location type is not supported or
2435    -1 for failure.
2436
2437    NOTE drow/2003-09-09: This routine could be broken down to an
2438    object-style method for each breakpoint or catchpoint type.  */
2439 static int
2440 insert_bp_location (struct bp_location *bl,
2441                     struct ui_file *tmp_error_stream,
2442                     int *disabled_breaks,
2443                     int *hw_breakpoint_error,
2444                     int *hw_bp_error_explained_already)
2445 {
2446   gdb_exception bp_excpt = exception_none;
2447
2448   if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2449     return 0;
2450
2451   /* Note we don't initialize bl->target_info, as that wipes out
2452      the breakpoint location's shadow_contents if the breakpoint
2453      is still inserted at that location.  This in turn breaks
2454      target_read_memory which depends on these buffers when
2455      a memory read is requested at the breakpoint location:
2456      Once the target_info has been wiped, we fail to see that
2457      we have a breakpoint inserted at that address and thus
2458      read the breakpoint instead of returning the data saved in
2459      the breakpoint location's shadow contents.  */
2460   bl->target_info.reqstd_address = bl->address;
2461   bl->target_info.placed_address_space = bl->pspace->aspace;
2462   bl->target_info.length = bl->length;
2463
2464   /* When working with target-side conditions, we must pass all the conditions
2465      for the same breakpoint address down to the target since GDB will not
2466      insert those locations.  With a list of breakpoint conditions, the target
2467      can decide when to stop and notify GDB.  */
2468
2469   if (is_breakpoint (bl->owner))
2470     {
2471       build_target_condition_list (bl);
2472       build_target_command_list (bl);
2473       /* Reset the modification marker.  */
2474       bl->needs_update = 0;
2475     }
2476
2477   if (bl->loc_type == bp_loc_software_breakpoint
2478       || bl->loc_type == bp_loc_hardware_breakpoint)
2479     {
2480       if (bl->owner->type != bp_hardware_breakpoint)
2481         {
2482           /* If the explicitly specified breakpoint type
2483              is not hardware breakpoint, check the memory map to see
2484              if the breakpoint address is in read only memory or not.
2485
2486              Two important cases are:
2487              - location type is not hardware breakpoint, memory
2488              is readonly.  We change the type of the location to
2489              hardware breakpoint.
2490              - location type is hardware breakpoint, memory is
2491              read-write.  This means we've previously made the
2492              location hardware one, but then the memory map changed,
2493              so we undo.
2494              
2495              When breakpoints are removed, remove_breakpoints will use
2496              location types we've just set here, the only possible
2497              problem is that memory map has changed during running
2498              program, but it's not going to work anyway with current
2499              gdb.  */
2500           struct mem_region *mr 
2501             = lookup_mem_region (bl->target_info.reqstd_address);
2502           
2503           if (mr)
2504             {
2505               if (automatic_hardware_breakpoints)
2506                 {
2507                   enum bp_loc_type new_type;
2508                   
2509                   if (mr->attrib.mode != MEM_RW)
2510                     new_type = bp_loc_hardware_breakpoint;
2511                   else 
2512                     new_type = bp_loc_software_breakpoint;
2513                   
2514                   if (new_type != bl->loc_type)
2515                     {
2516                       static int said = 0;
2517
2518                       bl->loc_type = new_type;
2519                       if (!said)
2520                         {
2521                           fprintf_filtered (gdb_stdout,
2522                                             _("Note: automatically using "
2523                                               "hardware breakpoints for "
2524                                               "read-only addresses.\n"));
2525                           said = 1;
2526                         }
2527                     }
2528                 }
2529               else if (bl->loc_type == bp_loc_software_breakpoint
2530                        && mr->attrib.mode != MEM_RW)
2531                 {
2532                   fprintf_unfiltered (tmp_error_stream,
2533                                       _("Cannot insert breakpoint %d.\n"
2534                                         "Cannot set software breakpoint "
2535                                         "at read-only address %s\n"),
2536                                       bl->owner->number,
2537                                       paddress (bl->gdbarch, bl->address));
2538                   return 1;
2539                 }
2540             }
2541         }
2542         
2543       /* First check to see if we have to handle an overlay.  */
2544       if (overlay_debugging == ovly_off
2545           || bl->section == NULL
2546           || !(section_is_overlay (bl->section)))
2547         {
2548           /* No overlay handling: just set the breakpoint.  */
2549           TRY
2550             {
2551               int val;
2552
2553               val = bl->owner->ops->insert_location (bl);
2554               if (val)
2555                 bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2556             }
2557           CATCH (e, RETURN_MASK_ALL)
2558             {
2559               bp_excpt = e;
2560             }
2561           END_CATCH
2562         }
2563       else
2564         {
2565           /* This breakpoint is in an overlay section.
2566              Shall we set a breakpoint at the LMA?  */
2567           if (!overlay_events_enabled)
2568             {
2569               /* Yes -- overlay event support is not active, 
2570                  so we must try to set a breakpoint at the LMA.
2571                  This will not work for a hardware breakpoint.  */
2572               if (bl->loc_type == bp_loc_hardware_breakpoint)
2573                 warning (_("hardware breakpoint %d not supported in overlay!"),
2574                          bl->owner->number);
2575               else
2576                 {
2577                   CORE_ADDR addr = overlay_unmapped_address (bl->address,
2578                                                              bl->section);
2579                   /* Set a software (trap) breakpoint at the LMA.  */
2580                   bl->overlay_target_info = bl->target_info;
2581                   bl->overlay_target_info.reqstd_address = addr;
2582
2583                   /* No overlay handling: just set the breakpoint.  */
2584                   TRY
2585                     {
2586                       int val;
2587
2588                       bl->overlay_target_info.kind
2589                         = breakpoint_kind (bl, &addr);
2590                       bl->overlay_target_info.placed_address = addr;
2591                       val = target_insert_breakpoint (bl->gdbarch,
2592                                                       &bl->overlay_target_info);
2593                       if (val)
2594                         bp_excpt
2595                           = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2596                     }
2597                   CATCH (e, RETURN_MASK_ALL)
2598                     {
2599                       bp_excpt = e;
2600                     }
2601                   END_CATCH
2602
2603                   if (bp_excpt.reason != 0)
2604                     fprintf_unfiltered (tmp_error_stream,
2605                                         "Overlay breakpoint %d "
2606                                         "failed: in ROM?\n",
2607                                         bl->owner->number);
2608                 }
2609             }
2610           /* Shall we set a breakpoint at the VMA? */
2611           if (section_is_mapped (bl->section))
2612             {
2613               /* Yes.  This overlay section is mapped into memory.  */
2614               TRY
2615                 {
2616                   int val;
2617
2618                   val = bl->owner->ops->insert_location (bl);
2619                   if (val)
2620                     bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
2621                 }
2622               CATCH (e, RETURN_MASK_ALL)
2623                 {
2624                   bp_excpt = e;
2625                 }
2626               END_CATCH
2627             }
2628           else
2629             {
2630               /* No.  This breakpoint will not be inserted.  
2631                  No error, but do not mark the bp as 'inserted'.  */
2632               return 0;
2633             }
2634         }
2635
2636       if (bp_excpt.reason != 0)
2637         {
2638           /* Can't set the breakpoint.  */
2639
2640           /* In some cases, we might not be able to insert a
2641              breakpoint in a shared library that has already been
2642              removed, but we have not yet processed the shlib unload
2643              event.  Unfortunately, some targets that implement
2644              breakpoint insertion themselves can't tell why the
2645              breakpoint insertion failed (e.g., the remote target
2646              doesn't define error codes), so we must treat generic
2647              errors as memory errors.  */
2648           if (bp_excpt.reason == RETURN_ERROR
2649               && (bp_excpt.error == GENERIC_ERROR
2650                   || bp_excpt.error == MEMORY_ERROR)
2651               && bl->loc_type == bp_loc_software_breakpoint
2652               && (solib_name_from_address (bl->pspace, bl->address)
2653                   || shared_objfile_contains_address_p (bl->pspace,
2654                                                         bl->address)))
2655             {
2656               /* See also: disable_breakpoints_in_shlibs.  */
2657               bl->shlib_disabled = 1;
2658               observer_notify_breakpoint_modified (bl->owner);
2659               if (!*disabled_breaks)
2660                 {
2661                   fprintf_unfiltered (tmp_error_stream, 
2662                                       "Cannot insert breakpoint %d.\n", 
2663                                       bl->owner->number);
2664                   fprintf_unfiltered (tmp_error_stream, 
2665                                       "Temporarily disabling shared "
2666                                       "library breakpoints:\n");
2667                 }
2668               *disabled_breaks = 1;
2669               fprintf_unfiltered (tmp_error_stream,
2670                                   "breakpoint #%d\n", bl->owner->number);
2671               return 0;
2672             }
2673           else
2674             {
2675               if (bl->loc_type == bp_loc_hardware_breakpoint)
2676                 {
2677                   *hw_breakpoint_error = 1;
2678                   *hw_bp_error_explained_already = bp_excpt.message != NULL;
2679                   fprintf_unfiltered (tmp_error_stream,
2680                                       "Cannot insert hardware breakpoint %d%s",
2681                                       bl->owner->number,
2682                                       bp_excpt.message ? ":" : ".\n");
2683                   if (bp_excpt.message != NULL)
2684                     fprintf_unfiltered (tmp_error_stream, "%s.\n",
2685                                         bp_excpt.message);
2686                 }
2687               else
2688                 {
2689                   if (bp_excpt.message == NULL)
2690                     {
2691                       std::string message
2692                         = memory_error_message (TARGET_XFER_E_IO,
2693                                                 bl->gdbarch, bl->address);
2694
2695                       fprintf_unfiltered (tmp_error_stream,
2696                                           "Cannot insert breakpoint %d.\n"
2697                                           "%s\n",
2698                                           bl->owner->number, message.c_str ());
2699                     }
2700                   else
2701                     {
2702                       fprintf_unfiltered (tmp_error_stream,
2703                                           "Cannot insert breakpoint %d: %s\n",
2704                                           bl->owner->number,
2705                                           bp_excpt.message);
2706                     }
2707                 }
2708               return 1;
2709
2710             }
2711         }
2712       else
2713         bl->inserted = 1;
2714
2715       return 0;
2716     }
2717
2718   else if (bl->loc_type == bp_loc_hardware_watchpoint
2719            /* NOTE drow/2003-09-08: This state only exists for removing
2720               watchpoints.  It's not clear that it's necessary...  */
2721            && bl->owner->disposition != disp_del_at_next_stop)
2722     {
2723       int val;
2724
2725       gdb_assert (bl->owner->ops != NULL
2726                   && bl->owner->ops->insert_location != NULL);
2727
2728       val = bl->owner->ops->insert_location (bl);
2729
2730       /* If trying to set a read-watchpoint, and it turns out it's not
2731          supported, try emulating one with an access watchpoint.  */
2732       if (val == 1 && bl->watchpoint_type == hw_read)
2733         {
2734           struct bp_location *loc, **loc_temp;
2735
2736           /* But don't try to insert it, if there's already another
2737              hw_access location that would be considered a duplicate
2738              of this one.  */
2739           ALL_BP_LOCATIONS (loc, loc_temp)
2740             if (loc != bl
2741                 && loc->watchpoint_type == hw_access
2742                 && watchpoint_locations_match (bl, loc))
2743               {
2744                 bl->duplicate = 1;
2745                 bl->inserted = 1;
2746                 bl->target_info = loc->target_info;
2747                 bl->watchpoint_type = hw_access;
2748                 val = 0;
2749                 break;
2750               }
2751
2752           if (val == 1)
2753             {
2754               bl->watchpoint_type = hw_access;
2755               val = bl->owner->ops->insert_location (bl);
2756
2757               if (val)
2758                 /* Back to the original value.  */
2759                 bl->watchpoint_type = hw_read;
2760             }
2761         }
2762
2763       bl->inserted = (val == 0);
2764     }
2765
2766   else if (bl->owner->type == bp_catchpoint)
2767     {
2768       int val;
2769
2770       gdb_assert (bl->owner->ops != NULL
2771                   && bl->owner->ops->insert_location != NULL);
2772
2773       val = bl->owner->ops->insert_location (bl);
2774       if (val)
2775         {
2776           bl->owner->enable_state = bp_disabled;
2777
2778           if (val == 1)
2779             warning (_("\
2780 Error inserting catchpoint %d: Your system does not support this type\n\
2781 of catchpoint."), bl->owner->number);
2782           else
2783             warning (_("Error inserting catchpoint %d."), bl->owner->number);
2784         }
2785
2786       bl->inserted = (val == 0);
2787
2788       /* We've already printed an error message if there was a problem
2789          inserting this catchpoint, and we've disabled the catchpoint,
2790          so just return success.  */
2791       return 0;
2792     }
2793
2794   return 0;
2795 }
2796
2797 /* This function is called when program space PSPACE is about to be
2798    deleted.  It takes care of updating breakpoints to not reference
2799    PSPACE anymore.  */
2800
2801 void
2802 breakpoint_program_space_exit (struct program_space *pspace)
2803 {
2804   struct breakpoint *b, *b_temp;
2805   struct bp_location *loc, **loc_temp;
2806
2807   /* Remove any breakpoint that was set through this program space.  */
2808   ALL_BREAKPOINTS_SAFE (b, b_temp)
2809     {
2810       if (b->pspace == pspace)
2811         delete_breakpoint (b);
2812     }
2813
2814   /* Breakpoints set through other program spaces could have locations
2815      bound to PSPACE as well.  Remove those.  */
2816   ALL_BP_LOCATIONS (loc, loc_temp)
2817     {
2818       struct bp_location *tmp;
2819
2820       if (loc->pspace == pspace)
2821         {
2822           /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
2823           if (loc->owner->loc == loc)
2824             loc->owner->loc = loc->next;
2825           else
2826             for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
2827               if (tmp->next == loc)
2828                 {
2829                   tmp->next = loc->next;
2830                   break;
2831                 }
2832         }
2833     }
2834
2835   /* Now update the global location list to permanently delete the
2836      removed locations above.  */
2837   update_global_location_list (UGLL_DONT_INSERT);
2838 }
2839
2840 /* Make sure all breakpoints are inserted in inferior.
2841    Throws exception on any error.
2842    A breakpoint that is already inserted won't be inserted
2843    again, so calling this function twice is safe.  */
2844 void
2845 insert_breakpoints (void)
2846 {
2847   struct breakpoint *bpt;
2848
2849   ALL_BREAKPOINTS (bpt)
2850     if (is_hardware_watchpoint (bpt))
2851       {
2852         struct watchpoint *w = (struct watchpoint *) bpt;
2853
2854         update_watchpoint (w, 0 /* don't reparse.  */);
2855       }
2856
2857   /* Updating watchpoints creates new locations, so update the global
2858      location list.  Explicitly tell ugll to insert locations and
2859      ignore breakpoints_always_inserted_mode.  */
2860   update_global_location_list (UGLL_INSERT);
2861 }
2862
2863 /* Invoke CALLBACK for each of bp_location.  */
2864
2865 void
2866 iterate_over_bp_locations (walk_bp_location_callback callback)
2867 {
2868   struct bp_location *loc, **loc_tmp;
2869
2870   ALL_BP_LOCATIONS (loc, loc_tmp)
2871     {
2872       callback (loc, NULL);
2873     }
2874 }
2875
2876 /* This is used when we need to synch breakpoint conditions between GDB and the
2877    target.  It is the case with deleting and disabling of breakpoints when using
2878    always-inserted mode.  */
2879
2880 static void
2881 update_inserted_breakpoint_locations (void)
2882 {
2883   struct bp_location *bl, **blp_tmp;
2884   int error_flag = 0;
2885   int val = 0;
2886   int disabled_breaks = 0;
2887   int hw_breakpoint_error = 0;
2888   int hw_bp_details_reported = 0;
2889
2890   string_file tmp_error_stream;
2891
2892   /* Explicitly mark the warning -- this will only be printed if
2893      there was an error.  */
2894   tmp_error_stream.puts ("Warning:\n");
2895
2896   scoped_restore_current_pspace_and_thread restore_pspace_thread;
2897
2898   ALL_BP_LOCATIONS (bl, blp_tmp)
2899     {
2900       /* We only want to update software breakpoints and hardware
2901          breakpoints.  */
2902       if (!is_breakpoint (bl->owner))
2903         continue;
2904
2905       /* We only want to update locations that are already inserted
2906          and need updating.  This is to avoid unwanted insertion during
2907          deletion of breakpoints.  */
2908       if (!bl->inserted || (bl->inserted && !bl->needs_update))
2909         continue;
2910
2911       switch_to_program_space_and_thread (bl->pspace);
2912
2913       /* For targets that support global breakpoints, there's no need
2914          to select an inferior to insert breakpoint to.  In fact, even
2915          if we aren't attached to any process yet, we should still
2916          insert breakpoints.  */
2917       if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2918           && ptid_equal (inferior_ptid, null_ptid))
2919         continue;
2920
2921       val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
2922                                     &hw_breakpoint_error, &hw_bp_details_reported);
2923       if (val)
2924         error_flag = val;
2925     }
2926
2927   if (error_flag)
2928     {
2929       target_terminal::ours_for_output ();
2930       error_stream (tmp_error_stream);
2931     }
2932 }
2933
2934 /* Used when starting or continuing the program.  */
2935
2936 static void
2937 insert_breakpoint_locations (void)
2938 {
2939   struct breakpoint *bpt;
2940   struct bp_location *bl, **blp_tmp;
2941   int error_flag = 0;
2942   int val = 0;
2943   int disabled_breaks = 0;
2944   int hw_breakpoint_error = 0;
2945   int hw_bp_error_explained_already = 0;
2946
2947   string_file tmp_error_stream;
2948
2949   /* Explicitly mark the warning -- this will only be printed if
2950      there was an error.  */
2951   tmp_error_stream.puts ("Warning:\n");
2952
2953   scoped_restore_current_pspace_and_thread restore_pspace_thread;
2954
2955   ALL_BP_LOCATIONS (bl, blp_tmp)
2956     {
2957       if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2958         continue;
2959
2960       /* There is no point inserting thread-specific breakpoints if
2961          the thread no longer exists.  ALL_BP_LOCATIONS bp_location
2962          has BL->OWNER always non-NULL.  */
2963       if (bl->owner->thread != -1
2964           && !valid_global_thread_id (bl->owner->thread))
2965         continue;
2966
2967       switch_to_program_space_and_thread (bl->pspace);
2968
2969       /* For targets that support global breakpoints, there's no need
2970          to select an inferior to insert breakpoint to.  In fact, even
2971          if we aren't attached to any process yet, we should still
2972          insert breakpoints.  */
2973       if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2974           && ptid_equal (inferior_ptid, null_ptid))
2975         continue;
2976
2977       val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
2978                                     &hw_breakpoint_error, &hw_bp_error_explained_already);
2979       if (val)
2980         error_flag = val;
2981     }
2982
2983   /* If we failed to insert all locations of a watchpoint, remove
2984      them, as half-inserted watchpoint is of limited use.  */
2985   ALL_BREAKPOINTS (bpt)  
2986     {
2987       int some_failed = 0;
2988       struct bp_location *loc;
2989
2990       if (!is_hardware_watchpoint (bpt))
2991         continue;
2992
2993       if (!breakpoint_enabled (bpt))
2994         continue;
2995
2996       if (bpt->disposition == disp_del_at_next_stop)
2997         continue;
2998       
2999       for (loc = bpt->loc; loc; loc = loc->next)
3000         if (!loc->inserted && should_be_inserted (loc))
3001           {
3002             some_failed = 1;
3003             break;
3004           }
3005       if (some_failed)
3006         {
3007           for (loc = bpt->loc; loc; loc = loc->next)
3008             if (loc->inserted)
3009               remove_breakpoint (loc);
3010
3011           hw_breakpoint_error = 1;
3012           tmp_error_stream.printf ("Could not insert "
3013                                    "hardware watchpoint %d.\n",
3014                                    bpt->number);
3015           error_flag = -1;
3016         }
3017     }
3018
3019   if (error_flag)
3020     {
3021       /* If a hardware breakpoint or watchpoint was inserted, add a
3022          message about possibly exhausted resources.  */
3023       if (hw_breakpoint_error && !hw_bp_error_explained_already)
3024         {
3025           tmp_error_stream.printf ("Could not insert hardware breakpoints:\n\
3026 You may have requested too many hardware breakpoints/watchpoints.\n");
3027         }
3028       target_terminal::ours_for_output ();
3029       error_stream (tmp_error_stream);
3030     }
3031 }
3032
3033 /* Used when the program stops.
3034    Returns zero if successful, or non-zero if there was a problem
3035    removing a breakpoint location.  */
3036
3037 int
3038 remove_breakpoints (void)
3039 {
3040   struct bp_location *bl, **blp_tmp;
3041   int val = 0;
3042
3043   ALL_BP_LOCATIONS (bl, blp_tmp)
3044   {
3045     if (bl->inserted && !is_tracepoint (bl->owner))
3046       val |= remove_breakpoint (bl);
3047   }
3048   return val;
3049 }
3050
3051 /* When a thread exits, remove breakpoints that are related to
3052    that thread.  */
3053
3054 static void
3055 remove_threaded_breakpoints (struct thread_info *tp, int silent)
3056 {
3057   struct breakpoint *b, *b_tmp;
3058
3059   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3060     {
3061       if (b->thread == tp->global_num && user_breakpoint_p (b))
3062         {
3063           b->disposition = disp_del_at_next_stop;
3064
3065           printf_filtered (_("\
3066 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3067                            b->number, print_thread_id (tp));
3068
3069           /* Hide it from the user.  */
3070           b->number = 0;
3071        }
3072     }
3073 }
3074
3075 /* Remove breakpoints of process PID.  */
3076
3077 int
3078 remove_breakpoints_pid (int pid)
3079 {
3080   struct bp_location *bl, **blp_tmp;
3081   int val;
3082   struct inferior *inf = find_inferior_pid (pid);
3083
3084   ALL_BP_LOCATIONS (bl, blp_tmp)
3085   {
3086     if (bl->pspace != inf->pspace)
3087       continue;
3088
3089     if (bl->inserted && !bl->target_info.persist)
3090       {
3091         val = remove_breakpoint (bl);
3092         if (val != 0)
3093           return val;
3094       }
3095   }
3096   return 0;
3097 }
3098
3099 static int internal_breakpoint_number = -1;
3100
3101 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3102    If INTERNAL is non-zero, the breakpoint number will be populated
3103    from internal_breakpoint_number and that variable decremented.
3104    Otherwise the breakpoint number will be populated from
3105    breakpoint_count and that value incremented.  Internal breakpoints
3106    do not set the internal var bpnum.  */
3107 static void
3108 set_breakpoint_number (int internal, struct breakpoint *b)
3109 {
3110   if (internal)
3111     b->number = internal_breakpoint_number--;
3112   else
3113     {
3114       set_breakpoint_count (breakpoint_count + 1);
3115       b->number = breakpoint_count;
3116     }
3117 }
3118
3119 static struct breakpoint *
3120 create_internal_breakpoint (struct gdbarch *gdbarch,
3121                             CORE_ADDR address, enum bptype type,
3122                             const struct breakpoint_ops *ops)
3123 {
3124   symtab_and_line sal;
3125   sal.pc = address;
3126   sal.section = find_pc_overlay (sal.pc);
3127   sal.pspace = current_program_space;
3128
3129   breakpoint *b = set_raw_breakpoint (gdbarch, sal, type, ops);
3130   b->number = internal_breakpoint_number--;
3131   b->disposition = disp_donttouch;
3132
3133   return b;
3134 }
3135
3136 static const char *const longjmp_names[] =
3137   {
3138     "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3139   };
3140 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3141
3142 /* Per-objfile data private to breakpoint.c.  */
3143 struct breakpoint_objfile_data
3144 {
3145   /* Minimal symbol for "_ovly_debug_event" (if any).  */
3146   struct bound_minimal_symbol overlay_msym {};
3147
3148   /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any).  */
3149   struct bound_minimal_symbol longjmp_msym[NUM_LONGJMP_NAMES] {};
3150
3151   /* True if we have looked for longjmp probes.  */
3152   int longjmp_searched = 0;
3153
3154   /* SystemTap probe points for longjmp (if any).  These are non-owning
3155      references.  */
3156   std::vector<probe *> longjmp_probes;
3157
3158   /* Minimal symbol for "std::terminate()" (if any).  */
3159   struct bound_minimal_symbol terminate_msym {};
3160
3161   /* Minimal symbol for "_Unwind_DebugHook" (if any).  */
3162   struct bound_minimal_symbol exception_msym {};
3163
3164   /* True if we have looked for exception probes.  */
3165   int exception_searched = 0;
3166
3167   /* SystemTap probe points for unwinding (if any).  These are non-owning
3168      references.  */
3169   std::vector<probe *> exception_probes;
3170 };
3171
3172 static const struct objfile_data *breakpoint_objfile_key;
3173
3174 /* Minimal symbol not found sentinel.  */
3175 static struct minimal_symbol msym_not_found;
3176
3177 /* Returns TRUE if MSYM point to the "not found" sentinel.  */
3178
3179 static int
3180 msym_not_found_p (const struct minimal_symbol *msym)
3181 {
3182   return msym == &msym_not_found;
3183 }
3184
3185 /* Return per-objfile data needed by breakpoint.c.
3186    Allocate the data if necessary.  */
3187
3188 static struct breakpoint_objfile_data *
3189 get_breakpoint_objfile_data (struct objfile *objfile)
3190 {
3191   struct breakpoint_objfile_data *bp_objfile_data;
3192
3193   bp_objfile_data = ((struct breakpoint_objfile_data *)
3194                      objfile_data (objfile, breakpoint_objfile_key));
3195   if (bp_objfile_data == NULL)
3196     {
3197       bp_objfile_data = new breakpoint_objfile_data ();
3198       set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
3199     }
3200   return bp_objfile_data;
3201 }
3202
3203 static void
3204 free_breakpoint_objfile_data (struct objfile *obj, void *data)
3205 {
3206   struct breakpoint_objfile_data *bp_objfile_data
3207     = (struct breakpoint_objfile_data *) data;
3208
3209   delete bp_objfile_data;
3210 }
3211
3212 static void
3213 create_overlay_event_breakpoint (void)
3214 {
3215   struct objfile *objfile;
3216   const char *const func_name = "_ovly_debug_event";
3217
3218   ALL_OBJFILES (objfile)
3219     {
3220       struct breakpoint *b;
3221       struct breakpoint_objfile_data *bp_objfile_data;
3222       CORE_ADDR addr;
3223       struct explicit_location explicit_loc;
3224
3225       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3226
3227       if (msym_not_found_p (bp_objfile_data->overlay_msym.minsym))
3228         continue;
3229
3230       if (bp_objfile_data->overlay_msym.minsym == NULL)
3231         {
3232           struct bound_minimal_symbol m;
3233
3234           m = lookup_minimal_symbol_text (func_name, objfile);
3235           if (m.minsym == NULL)
3236             {
3237               /* Avoid future lookups in this objfile.  */
3238               bp_objfile_data->overlay_msym.minsym = &msym_not_found;
3239               continue;
3240             }
3241           bp_objfile_data->overlay_msym = m;
3242         }
3243
3244       addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
3245       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3246                                       bp_overlay_event,
3247                                       &internal_breakpoint_ops);
3248       initialize_explicit_location (&explicit_loc);
3249       explicit_loc.function_name = ASTRDUP (func_name);
3250       b->location = new_explicit_location (&explicit_loc);
3251
3252       if (overlay_debugging == ovly_auto)
3253         {
3254           b->enable_state = bp_enabled;
3255           overlay_events_enabled = 1;
3256         }
3257       else
3258        {
3259          b->enable_state = bp_disabled;
3260          overlay_events_enabled = 0;
3261        }
3262     }
3263 }
3264
3265 static void
3266 create_longjmp_master_breakpoint (void)
3267 {
3268   struct program_space *pspace;
3269
3270   scoped_restore_current_program_space restore_pspace;
3271
3272   ALL_PSPACES (pspace)
3273   {
3274     struct objfile *objfile;
3275
3276     set_current_program_space (pspace);
3277
3278     ALL_OBJFILES (objfile)
3279     {
3280       int i;
3281       struct gdbarch *gdbarch;
3282       struct breakpoint_objfile_data *bp_objfile_data;
3283
3284       gdbarch = get_objfile_arch (objfile);
3285
3286       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3287
3288       if (!bp_objfile_data->longjmp_searched)
3289         {
3290           std::vector<probe *> ret
3291             = find_probes_in_objfile (objfile, "libc", "longjmp");
3292
3293           if (!ret.empty ())
3294             {
3295               /* We are only interested in checking one element.  */
3296               probe *p = ret[0];
3297
3298               if (!p->can_evaluate_arguments ())
3299                 {
3300                   /* We cannot use the probe interface here, because it does
3301                      not know how to evaluate arguments.  */
3302                   ret.clear ();
3303                 }
3304             }
3305           bp_objfile_data->longjmp_probes = ret;
3306           bp_objfile_data->longjmp_searched = 1;
3307         }
3308
3309       if (!bp_objfile_data->longjmp_probes.empty ())
3310         {
3311           struct gdbarch *gdbarch = get_objfile_arch (objfile);
3312
3313           for (probe *p : bp_objfile_data->longjmp_probes)
3314             {
3315               struct breakpoint *b;
3316
3317               b = create_internal_breakpoint (gdbarch,
3318                                               p->get_relocated_address (objfile),
3319                                               bp_longjmp_master,
3320                                               &internal_breakpoint_ops);
3321               b->location = new_probe_location ("-probe-stap libc:longjmp");
3322               b->enable_state = bp_disabled;
3323             }
3324
3325           continue;
3326         }
3327
3328       if (!gdbarch_get_longjmp_target_p (gdbarch))
3329         continue;
3330
3331       for (i = 0; i < NUM_LONGJMP_NAMES; i++)
3332         {
3333           struct breakpoint *b;
3334           const char *func_name;
3335           CORE_ADDR addr;
3336           struct explicit_location explicit_loc;
3337
3338           if (msym_not_found_p (bp_objfile_data->longjmp_msym[i].minsym))
3339             continue;
3340
3341           func_name = longjmp_names[i];
3342           if (bp_objfile_data->longjmp_msym[i].minsym == NULL)
3343             {
3344               struct bound_minimal_symbol m;
3345
3346               m = lookup_minimal_symbol_text (func_name, objfile);
3347               if (m.minsym == NULL)
3348                 {
3349                   /* Prevent future lookups in this objfile.  */
3350                   bp_objfile_data->longjmp_msym[i].minsym = &msym_not_found;
3351                   continue;
3352                 }
3353               bp_objfile_data->longjmp_msym[i] = m;
3354             }
3355
3356           addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
3357           b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3358                                           &internal_breakpoint_ops);
3359           initialize_explicit_location (&explicit_loc);
3360           explicit_loc.function_name = ASTRDUP (func_name);
3361           b->location = new_explicit_location (&explicit_loc);
3362           b->enable_state = bp_disabled;
3363         }
3364     }
3365   }
3366 }
3367
3368 /* Create a master std::terminate breakpoint.  */
3369 static void
3370 create_std_terminate_master_breakpoint (void)
3371 {
3372   struct program_space *pspace;
3373   const char *const func_name = "std::terminate()";
3374
3375   scoped_restore_current_program_space restore_pspace;
3376
3377   ALL_PSPACES (pspace)
3378   {
3379     struct objfile *objfile;
3380     CORE_ADDR addr;
3381
3382     set_current_program_space (pspace);
3383
3384     ALL_OBJFILES (objfile)
3385     {
3386       struct breakpoint *b;
3387       struct breakpoint_objfile_data *bp_objfile_data;
3388       struct explicit_location explicit_loc;
3389
3390       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3391
3392       if (msym_not_found_p (bp_objfile_data->terminate_msym.minsym))
3393         continue;
3394
3395       if (bp_objfile_data->terminate_msym.minsym == NULL)
3396         {
3397           struct bound_minimal_symbol m;
3398
3399           m = lookup_minimal_symbol (func_name, NULL, objfile);
3400           if (m.minsym == NULL || (MSYMBOL_TYPE (m.minsym) != mst_text
3401                                    && MSYMBOL_TYPE (m.minsym) != mst_file_text))
3402             {
3403               /* Prevent future lookups in this objfile.  */
3404               bp_objfile_data->terminate_msym.minsym = &msym_not_found;
3405               continue;
3406             }
3407           bp_objfile_data->terminate_msym = m;
3408         }
3409
3410       addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
3411       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3412                                       bp_std_terminate_master,
3413                                       &internal_breakpoint_ops);
3414       initialize_explicit_location (&explicit_loc);
3415       explicit_loc.function_name = ASTRDUP (func_name);
3416       b->location = new_explicit_location (&explicit_loc);
3417       b->enable_state = bp_disabled;
3418     }
3419   }
3420 }
3421
3422 /* Install a master breakpoint on the unwinder's debug hook.  */
3423
3424 static void
3425 create_exception_master_breakpoint (void)
3426 {
3427   struct objfile *objfile;
3428   const char *const func_name = "_Unwind_DebugHook";
3429
3430   ALL_OBJFILES (objfile)
3431     {
3432       struct breakpoint *b;
3433       struct gdbarch *gdbarch;
3434       struct breakpoint_objfile_data *bp_objfile_data;
3435       CORE_ADDR addr;
3436       struct explicit_location explicit_loc;
3437
3438       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3439
3440       /* We prefer the SystemTap probe point if it exists.  */
3441       if (!bp_objfile_data->exception_searched)
3442         {
3443           std::vector<probe *> ret
3444             = find_probes_in_objfile (objfile, "libgcc", "unwind");
3445
3446           if (!ret.empty ())
3447             {
3448               /* We are only interested in checking one element.  */
3449               probe *p = ret[0];
3450
3451               if (!p->can_evaluate_arguments ())
3452                 {
3453                   /* We cannot use the probe interface here, because it does
3454                      not know how to evaluate arguments.  */
3455                   ret.clear ();
3456                 }
3457             }
3458           bp_objfile_data->exception_probes = ret;
3459           bp_objfile_data->exception_searched = 1;
3460         }
3461
3462       if (!bp_objfile_data->exception_probes.empty ())
3463         {
3464           struct gdbarch *gdbarch = get_objfile_arch (objfile);
3465
3466           for (probe *p : bp_objfile_data->exception_probes)
3467             {
3468               struct breakpoint *b;
3469
3470               b = create_internal_breakpoint (gdbarch,
3471                                               p->get_relocated_address (objfile),
3472                                               bp_exception_master,
3473                                               &internal_breakpoint_ops);
3474               b->location = new_probe_location ("-probe-stap libgcc:unwind");
3475               b->enable_state = bp_disabled;
3476             }
3477
3478           continue;
3479         }
3480
3481       /* Otherwise, try the hook function.  */
3482
3483       if (msym_not_found_p (bp_objfile_data->exception_msym.minsym))
3484         continue;
3485
3486       gdbarch = get_objfile_arch (objfile);
3487
3488       if (bp_objfile_data->exception_msym.minsym == NULL)
3489         {
3490           struct bound_minimal_symbol debug_hook;
3491
3492           debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3493           if (debug_hook.minsym == NULL)
3494             {
3495               bp_objfile_data->exception_msym.minsym = &msym_not_found;
3496               continue;
3497             }
3498
3499           bp_objfile_data->exception_msym = debug_hook;
3500         }
3501
3502       addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
3503       addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3504                                                  &current_target);
3505       b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3506                                       &internal_breakpoint_ops);
3507       initialize_explicit_location (&explicit_loc);
3508       explicit_loc.function_name = ASTRDUP (func_name);
3509       b->location = new_explicit_location (&explicit_loc);
3510       b->enable_state = bp_disabled;
3511     }
3512 }
3513
3514 /* Does B have a location spec?  */
3515
3516 static int
3517 breakpoint_event_location_empty_p (const struct breakpoint *b)
3518 {
3519   return b->location != NULL && event_location_empty_p (b->location.get ());
3520 }
3521
3522 void
3523 update_breakpoints_after_exec (void)
3524 {
3525   struct breakpoint *b, *b_tmp;
3526   struct bp_location *bploc, **bplocp_tmp;
3527
3528   /* We're about to delete breakpoints from GDB's lists.  If the
3529      INSERTED flag is true, GDB will try to lift the breakpoints by
3530      writing the breakpoints' "shadow contents" back into memory.  The
3531      "shadow contents" are NOT valid after an exec, so GDB should not
3532      do that.  Instead, the target is responsible from marking
3533      breakpoints out as soon as it detects an exec.  We don't do that
3534      here instead, because there may be other attempts to delete
3535      breakpoints after detecting an exec and before reaching here.  */
3536   ALL_BP_LOCATIONS (bploc, bplocp_tmp)
3537     if (bploc->pspace == current_program_space)
3538       gdb_assert (!bploc->inserted);
3539
3540   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3541   {
3542     if (b->pspace != current_program_space)
3543       continue;
3544
3545     /* Solib breakpoints must be explicitly reset after an exec().  */
3546     if (b->type == bp_shlib_event)
3547       {
3548         delete_breakpoint (b);
3549         continue;
3550       }
3551
3552     /* JIT breakpoints must be explicitly reset after an exec().  */
3553     if (b->type == bp_jit_event)
3554       {
3555         delete_breakpoint (b);
3556         continue;
3557       }
3558
3559     /* Thread event breakpoints must be set anew after an exec(),
3560        as must overlay event and longjmp master breakpoints.  */
3561     if (b->type == bp_thread_event || b->type == bp_overlay_event
3562         || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3563         || b->type == bp_exception_master)
3564       {
3565         delete_breakpoint (b);
3566         continue;
3567       }
3568
3569     /* Step-resume breakpoints are meaningless after an exec().  */
3570     if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
3571       {
3572         delete_breakpoint (b);
3573         continue;
3574       }
3575
3576     /* Just like single-step breakpoints.  */
3577     if (b->type == bp_single_step)
3578       {
3579         delete_breakpoint (b);
3580         continue;
3581       }
3582
3583     /* Longjmp and longjmp-resume breakpoints are also meaningless
3584        after an exec.  */
3585     if (b->type == bp_longjmp || b->type == bp_longjmp_resume
3586         || b->type == bp_longjmp_call_dummy
3587         || b->type == bp_exception || b->type == bp_exception_resume)
3588       {
3589         delete_breakpoint (b);
3590         continue;
3591       }
3592
3593     if (b->type == bp_catchpoint)
3594       {
3595         /* For now, none of the bp_catchpoint breakpoints need to
3596            do anything at this point.  In the future, if some of
3597            the catchpoints need to something, we will need to add
3598            a new method, and call this method from here.  */
3599         continue;
3600       }
3601
3602     /* bp_finish is a special case.  The only way we ought to be able
3603        to see one of these when an exec() has happened, is if the user
3604        caught a vfork, and then said "finish".  Ordinarily a finish just
3605        carries them to the call-site of the current callee, by setting
3606        a temporary bp there and resuming.  But in this case, the finish
3607        will carry them entirely through the vfork & exec.
3608
3609        We don't want to allow a bp_finish to remain inserted now.  But
3610        we can't safely delete it, 'cause finish_command has a handle to
3611        the bp on a bpstat, and will later want to delete it.  There's a
3612        chance (and I've seen it happen) that if we delete the bp_finish
3613        here, that its storage will get reused by the time finish_command
3614        gets 'round to deleting the "use to be a bp_finish" breakpoint.
3615        We really must allow finish_command to delete a bp_finish.
3616
3617        In the absence of a general solution for the "how do we know
3618        it's safe to delete something others may have handles to?"
3619        problem, what we'll do here is just uninsert the bp_finish, and
3620        let finish_command delete it.
3621
3622        (We know the bp_finish is "doomed" in the sense that it's
3623        momentary, and will be deleted as soon as finish_command sees
3624        the inferior stopped.  So it doesn't matter that the bp's
3625        address is probably bogus in the new a.out, unlike e.g., the
3626        solib breakpoints.)  */
3627
3628     if (b->type == bp_finish)
3629       {
3630         continue;
3631       }
3632
3633     /* Without a symbolic address, we have little hope of the
3634        pre-exec() address meaning the same thing in the post-exec()
3635        a.out.  */
3636     if (breakpoint_event_location_empty_p (b))
3637       {
3638         delete_breakpoint (b);
3639         continue;
3640       }
3641   }
3642 }
3643
3644 int
3645 detach_breakpoints (ptid_t ptid)
3646 {
3647   struct bp_location *bl, **blp_tmp;
3648   int val = 0;
3649   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
3650   struct inferior *inf = current_inferior ();
3651
3652   if (ptid_get_pid (ptid) == ptid_get_pid (inferior_ptid))
3653     error (_("Cannot detach breakpoints of inferior_ptid"));
3654
3655   /* Set inferior_ptid; remove_breakpoint_1 uses this global.  */
3656   inferior_ptid = ptid;
3657   ALL_BP_LOCATIONS (bl, blp_tmp)
3658   {
3659     if (bl->pspace != inf->pspace)
3660       continue;
3661
3662     /* This function must physically remove breakpoints locations
3663        from the specified ptid, without modifying the breakpoint
3664        package's state.  Locations of type bp_loc_other are only
3665        maintained at GDB side.  So, there is no need to remove
3666        these bp_loc_other locations.  Moreover, removing these
3667        would modify the breakpoint package's state.  */
3668     if (bl->loc_type == bp_loc_other)
3669       continue;
3670
3671     if (bl->inserted)
3672       val |= remove_breakpoint_1 (bl, DETACH_BREAKPOINT);
3673   }
3674
3675   return val;
3676 }
3677
3678 /* Remove the breakpoint location BL from the current address space.
3679    Note that this is used to detach breakpoints from a child fork.
3680    When we get here, the child isn't in the inferior list, and neither
3681    do we have objects to represent its address space --- we should
3682    *not* look at bl->pspace->aspace here.  */
3683
3684 static int
3685 remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason)
3686 {
3687   int val;
3688
3689   /* BL is never in moribund_locations by our callers.  */
3690   gdb_assert (bl->owner != NULL);
3691
3692   /* The type of none suggests that owner is actually deleted.
3693      This should not ever happen.  */
3694   gdb_assert (bl->owner->type != bp_none);
3695
3696   if (bl->loc_type == bp_loc_software_breakpoint
3697       || bl->loc_type == bp_loc_hardware_breakpoint)
3698     {
3699       /* "Normal" instruction breakpoint: either the standard
3700          trap-instruction bp (bp_breakpoint), or a
3701          bp_hardware_breakpoint.  */
3702
3703       /* First check to see if we have to handle an overlay.  */
3704       if (overlay_debugging == ovly_off
3705           || bl->section == NULL
3706           || !(section_is_overlay (bl->section)))
3707         {
3708           /* No overlay handling: just remove the breakpoint.  */
3709
3710           /* If we're trying to uninsert a memory breakpoint that we
3711              know is set in a dynamic object that is marked
3712              shlib_disabled, then either the dynamic object was
3713              removed with "remove-symbol-file" or with
3714              "nosharedlibrary".  In the former case, we don't know
3715              whether another dynamic object might have loaded over the
3716              breakpoint's address -- the user might well let us know
3717              about it next with add-symbol-file (the whole point of
3718              add-symbol-file is letting the user manually maintain a
3719              list of dynamically loaded objects).  If we have the
3720              breakpoint's shadow memory, that is, this is a software
3721              breakpoint managed by GDB, check whether the breakpoint
3722              is still inserted in memory, to avoid overwriting wrong
3723              code with stale saved shadow contents.  Note that HW
3724              breakpoints don't have shadow memory, as they're
3725              implemented using a mechanism that is not dependent on
3726              being able to modify the target's memory, and as such
3727              they should always be removed.  */
3728           if (bl->shlib_disabled
3729               && bl->target_info.shadow_len != 0
3730               && !memory_validate_breakpoint (bl->gdbarch, &bl->target_info))
3731             val = 0;
3732           else
3733             val = bl->owner->ops->remove_location (bl, reason);
3734         }
3735       else
3736         {
3737           /* This breakpoint is in an overlay section.
3738              Did we set a breakpoint at the LMA?  */
3739           if (!overlay_events_enabled)
3740               {
3741                 /* Yes -- overlay event support is not active, so we
3742                    should have set a breakpoint at the LMA.  Remove it.  
3743                 */
3744                 /* Ignore any failures: if the LMA is in ROM, we will
3745                    have already warned when we failed to insert it.  */
3746                 if (bl->loc_type == bp_loc_hardware_breakpoint)
3747                   target_remove_hw_breakpoint (bl->gdbarch,
3748                                                &bl->overlay_target_info);
3749                 else
3750                   target_remove_breakpoint (bl->gdbarch,
3751                                             &bl->overlay_target_info,
3752                                             reason);
3753               }
3754           /* Did we set a breakpoint at the VMA? 
3755              If so, we will have marked the breakpoint 'inserted'.  */
3756           if (bl->inserted)
3757             {
3758               /* Yes -- remove it.  Previously we did not bother to
3759                  remove the breakpoint if the section had been
3760                  unmapped, but let's not rely on that being safe.  We
3761                  don't know what the overlay manager might do.  */
3762
3763               /* However, we should remove *software* breakpoints only
3764                  if the section is still mapped, or else we overwrite
3765                  wrong code with the saved shadow contents.  */
3766               if (bl->loc_type == bp_loc_hardware_breakpoint
3767                   || section_is_mapped (bl->section))
3768                 val = bl->owner->ops->remove_location (bl, reason);
3769               else
3770                 val = 0;
3771             }
3772           else
3773             {
3774               /* No -- not inserted, so no need to remove.  No error.  */
3775               val = 0;
3776             }
3777         }
3778
3779       /* In some cases, we might not be able to remove a breakpoint in
3780          a shared library that has already been removed, but we have
3781          not yet processed the shlib unload event.  Similarly for an
3782          unloaded add-symbol-file object - the user might not yet have
3783          had the chance to remove-symbol-file it.  shlib_disabled will
3784          be set if the library/object has already been removed, but
3785          the breakpoint hasn't been uninserted yet, e.g., after
3786          "nosharedlibrary" or "remove-symbol-file" with breakpoints
3787          always-inserted mode.  */
3788       if (val
3789           && (bl->loc_type == bp_loc_software_breakpoint
3790               && (bl->shlib_disabled
3791                   || solib_name_from_address (bl->pspace, bl->address)
3792                   || shared_objfile_contains_address_p (bl->pspace,
3793                                                         bl->address))))
3794         val = 0;
3795
3796       if (val)
3797         return val;
3798       bl->inserted = (reason == DETACH_BREAKPOINT);
3799     }
3800   else if (bl->loc_type == bp_loc_hardware_watchpoint)
3801     {
3802       gdb_assert (bl->owner->ops != NULL
3803                   && bl->owner->ops->remove_location != NULL);
3804
3805       bl->inserted = (reason == DETACH_BREAKPOINT);
3806       bl->owner->ops->remove_location (bl, reason);
3807
3808       /* Failure to remove any of the hardware watchpoints comes here.  */
3809       if (reason == REMOVE_BREAKPOINT && bl->inserted)
3810         warning (_("Could not remove hardware watchpoint %d."),
3811                  bl->owner->number);
3812     }
3813   else if (bl->owner->type == bp_catchpoint
3814            && breakpoint_enabled (bl->owner)
3815            && !bl->duplicate)
3816     {
3817       gdb_assert (bl->owner->ops != NULL
3818                   && bl->owner->ops->remove_location != NULL);
3819
3820       val = bl->owner->ops->remove_location (bl, reason);
3821       if (val)
3822         return val;
3823
3824       bl->inserted = (reason == DETACH_BREAKPOINT);
3825     }
3826
3827   return 0;
3828 }
3829
3830 static int
3831 remove_breakpoint (struct bp_location *bl)
3832 {
3833   /* BL is never in moribund_locations by our callers.  */
3834   gdb_assert (bl->owner != NULL);
3835
3836   /* The type of none suggests that owner is actually deleted.
3837      This should not ever happen.  */
3838   gdb_assert (bl->owner->type != bp_none);
3839
3840   scoped_restore_current_pspace_and_thread restore_pspace_thread;
3841
3842   switch_to_program_space_and_thread (bl->pspace);
3843
3844   return remove_breakpoint_1 (bl, REMOVE_BREAKPOINT);
3845 }
3846
3847 /* Clear the "inserted" flag in all breakpoints.  */
3848
3849 void
3850 mark_breakpoints_out (void)
3851 {
3852   struct bp_location *bl, **blp_tmp;
3853
3854   ALL_BP_LOCATIONS (bl, blp_tmp)
3855     if (bl->pspace == current_program_space)
3856       bl->inserted = 0;
3857 }
3858
3859 /* Clear the "inserted" flag in all breakpoints and delete any
3860    breakpoints which should go away between runs of the program.
3861
3862    Plus other such housekeeping that has to be done for breakpoints
3863    between runs.
3864
3865    Note: this function gets called at the end of a run (by
3866    generic_mourn_inferior) and when a run begins (by
3867    init_wait_for_inferior).  */
3868
3869
3870
3871 void
3872 breakpoint_init_inferior (enum inf_context context)
3873 {
3874   struct breakpoint *b, *b_tmp;
3875   struct bp_location *bl;
3876   int ix;
3877   struct program_space *pspace = current_program_space;
3878
3879   /* If breakpoint locations are shared across processes, then there's
3880      nothing to do.  */
3881   if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3882     return;
3883
3884   mark_breakpoints_out ();
3885
3886   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3887   {
3888     if (b->loc && b->loc->pspace != pspace)
3889       continue;
3890
3891     switch (b->type)
3892       {
3893       case bp_call_dummy:
3894       case bp_longjmp_call_dummy:
3895
3896         /* If the call dummy breakpoint is at the entry point it will
3897            cause problems when the inferior is rerun, so we better get
3898            rid of it.  */
3899
3900       case bp_watchpoint_scope:
3901
3902         /* Also get rid of scope breakpoints.  */
3903
3904       case bp_shlib_event:
3905
3906         /* Also remove solib event breakpoints.  Their addresses may
3907            have changed since the last time we ran the program.
3908            Actually we may now be debugging against different target;
3909            and so the solib backend that installed this breakpoint may
3910            not be used in by the target.  E.g.,
3911
3912            (gdb) file prog-linux
3913            (gdb) run               # native linux target
3914            ...
3915            (gdb) kill
3916            (gdb) file prog-win.exe
3917            (gdb) tar rem :9999     # remote Windows gdbserver.
3918         */
3919
3920       case bp_step_resume:
3921
3922         /* Also remove step-resume breakpoints.  */
3923
3924       case bp_single_step:
3925
3926         /* Also remove single-step breakpoints.  */
3927
3928         delete_breakpoint (b);
3929         break;
3930
3931       case bp_watchpoint:
3932       case bp_hardware_watchpoint:
3933       case bp_read_watchpoint:
3934       case bp_access_watchpoint:
3935         {
3936           struct watchpoint *w = (struct watchpoint *) b;
3937
3938           /* Likewise for watchpoints on local expressions.  */
3939           if (w->exp_valid_block != NULL)
3940             delete_breakpoint (b);
3941           else
3942             {
3943               /* Get rid of existing locations, which are no longer
3944                  valid.  New ones will be created in
3945                  update_watchpoint, when the inferior is restarted.
3946                  The next update_global_location_list call will
3947                  garbage collect them.  */
3948               b->loc = NULL;
3949
3950               if (context == inf_starting)
3951                 {
3952                   /* Reset val field to force reread of starting value in
3953                      insert_breakpoints.  */
3954                   if (w->val)
3955                     value_free (w->val);
3956                   w->val = NULL;
3957                   w->val_valid = 0;
3958                 }
3959             }
3960         }
3961         break;
3962       default:
3963         break;
3964       }
3965   }
3966
3967   /* Get rid of the moribund locations.  */
3968   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
3969     decref_bp_location (&bl);
3970   VEC_free (bp_location_p, moribund_locations);
3971 }
3972
3973 /* These functions concern about actual breakpoints inserted in the
3974    target --- to e.g. check if we need to do decr_pc adjustment or if
3975    we need to hop over the bkpt --- so we check for address space
3976    match, not program space.  */
3977
3978 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3979    exists at PC.  It returns ordinary_breakpoint_here if it's an
3980    ordinary breakpoint, or permanent_breakpoint_here if it's a
3981    permanent breakpoint.
3982    - When continuing from a location with an ordinary breakpoint, we
3983      actually single step once before calling insert_breakpoints.
3984    - When continuing from a location with a permanent breakpoint, we
3985      need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3986      the target, to advance the PC past the breakpoint.  */
3987
3988 enum breakpoint_here
3989 breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
3990 {
3991   struct bp_location *bl, **blp_tmp;
3992   int any_breakpoint_here = 0;
3993
3994   ALL_BP_LOCATIONS (bl, blp_tmp)
3995     {
3996       if (bl->loc_type != bp_loc_software_breakpoint
3997           && bl->loc_type != bp_loc_hardware_breakpoint)
3998         continue;
3999
4000       /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL.  */
4001       if ((breakpoint_enabled (bl->owner)
4002            || bl->permanent)
4003           && breakpoint_location_address_match (bl, aspace, pc))
4004         {
4005           if (overlay_debugging 
4006               && section_is_overlay (bl->section)
4007               && !section_is_mapped (bl->section))
4008             continue;           /* unmapped overlay -- can't be a match */
4009           else if (bl->permanent)
4010             return permanent_breakpoint_here;
4011           else
4012             any_breakpoint_here = 1;
4013         }
4014     }
4015
4016   return any_breakpoint_here ? ordinary_breakpoint_here : no_breakpoint_here;
4017 }
4018
4019 /* See breakpoint.h.  */
4020
4021 int
4022 breakpoint_in_range_p (const address_space *aspace,
4023                        CORE_ADDR addr, ULONGEST len)
4024 {
4025   struct bp_location *bl, **blp_tmp;
4026
4027   ALL_BP_LOCATIONS (bl, blp_tmp)
4028     {
4029       if (bl->loc_type != bp_loc_software_breakpoint
4030           && bl->loc_type != bp_loc_hardware_breakpoint)
4031         continue;
4032
4033       if ((breakpoint_enabled (bl->owner)
4034            || bl->permanent)
4035           && breakpoint_location_address_range_overlap (bl, aspace,
4036                                                         addr, len))
4037         {
4038           if (overlay_debugging
4039               && section_is_overlay (bl->section)
4040               && !section_is_mapped (bl->section))
4041             {
4042               /* Unmapped overlay -- can't be a match.  */
4043               continue;
4044             }
4045
4046           return 1;
4047         }
4048     }
4049
4050   return 0;
4051 }
4052
4053 /* Return true if there's a moribund breakpoint at PC.  */
4054
4055 int
4056 moribund_breakpoint_here_p (const address_space *aspace, CORE_ADDR pc)
4057 {
4058   struct bp_location *loc;
4059   int ix;
4060
4061   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
4062     if (breakpoint_location_address_match (loc, aspace, pc))
4063       return 1;
4064
4065   return 0;
4066 }
4067
4068 /* Returns non-zero iff BL is inserted at PC, in address space
4069    ASPACE.  */
4070
4071 static int
4072 bp_location_inserted_here_p (struct bp_location *bl,
4073                              const address_space *aspace, CORE_ADDR pc)
4074 {
4075   if (bl->inserted
4076       && breakpoint_address_match (bl->pspace->aspace, bl->address,
4077                                    aspace, pc))
4078     {
4079       if (overlay_debugging
4080           && section_is_overlay (bl->section)
4081           && !section_is_mapped (bl->section))
4082         return 0;               /* unmapped overlay -- can't be a match */
4083       else
4084         return 1;
4085     }
4086   return 0;
4087 }
4088
4089 /* Returns non-zero iff there's a breakpoint inserted at PC.  */
4090
4091 int
4092 breakpoint_inserted_here_p (const address_space *aspace, CORE_ADDR pc)
4093 {
4094   struct bp_location **blp, **blp_tmp = NULL;
4095
4096   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4097     {
4098       struct bp_location *bl = *blp;
4099
4100       if (bl->loc_type != bp_loc_software_breakpoint
4101           && bl->loc_type != bp_loc_hardware_breakpoint)
4102         continue;
4103
4104       if (bp_location_inserted_here_p (bl, aspace, pc))
4105         return 1;
4106     }
4107   return 0;
4108 }
4109
4110 /* This function returns non-zero iff there is a software breakpoint
4111    inserted at PC.  */
4112
4113 int
4114 software_breakpoint_inserted_here_p (const address_space *aspace,
4115                                      CORE_ADDR pc)
4116 {
4117   struct bp_location **blp, **blp_tmp = NULL;
4118
4119   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4120     {
4121       struct bp_location *bl = *blp;
4122
4123       if (bl->loc_type != bp_loc_software_breakpoint)
4124         continue;
4125
4126       if (bp_location_inserted_here_p (bl, aspace, pc))
4127         return 1;
4128     }
4129
4130   return 0;
4131 }
4132
4133 /* See breakpoint.h.  */
4134
4135 int
4136 hardware_breakpoint_inserted_here_p (const address_space *aspace,
4137                                      CORE_ADDR pc)
4138 {
4139   struct bp_location **blp, **blp_tmp = NULL;
4140
4141   ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4142     {
4143       struct bp_location *bl = *blp;
4144
4145       if (bl->loc_type != bp_loc_hardware_breakpoint)
4146         continue;
4147
4148       if (bp_location_inserted_here_p (bl, aspace, pc))
4149         return 1;
4150     }
4151
4152   return 0;
4153 }
4154
4155 int
4156 hardware_watchpoint_inserted_in_range (const address_space *aspace,
4157                                        CORE_ADDR addr, ULONGEST len)
4158 {
4159   struct breakpoint *bpt;
4160
4161   ALL_BREAKPOINTS (bpt)
4162     {
4163       struct bp_location *loc;
4164
4165       if (bpt->type != bp_hardware_watchpoint
4166           && bpt->type != bp_access_watchpoint)
4167         continue;
4168
4169       if (!breakpoint_enabled (bpt))
4170         continue;
4171
4172       for (loc = bpt->loc; loc; loc = loc->next)
4173         if (loc->pspace->aspace == aspace && loc->inserted)
4174           {
4175             CORE_ADDR l, h;
4176
4177             /* Check for intersection.  */
4178             l = std::max<CORE_ADDR> (loc->address, addr);
4179             h = std::min<CORE_ADDR> (loc->address + loc->length, addr + len);
4180             if (l < h)
4181               return 1;
4182           }
4183     }
4184   return 0;
4185 }
4186 \f
4187
4188 /* bpstat stuff.  External routines' interfaces are documented
4189    in breakpoint.h.  */
4190
4191 int
4192 is_catchpoint (struct breakpoint *ep)
4193 {
4194   return (ep->type == bp_catchpoint);
4195 }
4196
4197 /* Frees any storage that is part of a bpstat.  Does not walk the
4198    'next' chain.  */
4199
4200 bpstats::~bpstats ()
4201 {
4202   if (old_val != NULL)
4203     value_free (old_val);
4204   if (bp_location_at != NULL)
4205     decref_bp_location (&bp_location_at);
4206 }
4207
4208 /* Clear a bpstat so that it says we are not at any breakpoint.
4209    Also free any storage that is part of a bpstat.  */
4210
4211 void
4212 bpstat_clear (bpstat *bsp)
4213 {
4214   bpstat p;
4215   bpstat q;
4216
4217   if (bsp == 0)
4218     return;
4219   p = *bsp;
4220   while (p != NULL)
4221     {
4222       q = p->next;
4223       delete p;
4224       p = q;
4225     }
4226   *bsp = NULL;
4227 }
4228
4229 bpstats::bpstats (const bpstats &other)
4230   : next (NULL),
4231     bp_location_at (other.bp_location_at),
4232     breakpoint_at (other.breakpoint_at),
4233     commands (other.commands),
4234     old_val (other.old_val),
4235     print (other.print),
4236     stop (other.stop),
4237     print_it (other.print_it)
4238 {
4239   if (old_val != NULL)
4240     {
4241       old_val = value_copy (old_val);
4242       release_value (old_val);
4243     }
4244   incref_bp_location (bp_location_at);
4245 }
4246
4247 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
4248    is part of the bpstat is copied as well.  */
4249
4250 bpstat
4251 bpstat_copy (bpstat bs)
4252 {
4253   bpstat p = NULL;
4254   bpstat tmp;
4255   bpstat retval = NULL;
4256
4257   if (bs == NULL)
4258     return bs;
4259
4260   for (; bs != NULL; bs = bs->next)
4261     {
4262       tmp = new bpstats (*bs);
4263
4264       if (p == NULL)
4265         /* This is the first thing in the chain.  */
4266         retval = tmp;
4267       else
4268         p->next = tmp;
4269       p = tmp;
4270     }
4271   p->next = NULL;
4272   return retval;
4273 }
4274
4275 /* Find the bpstat associated with this breakpoint.  */
4276
4277 bpstat
4278 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
4279 {
4280   if (bsp == NULL)
4281     return NULL;
4282
4283   for (; bsp != NULL; bsp = bsp->next)
4284     {
4285       if (bsp->breakpoint_at == breakpoint)
4286         return bsp;
4287     }
4288   return NULL;
4289 }
4290
4291 /* See breakpoint.h.  */
4292
4293 int
4294 bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
4295 {
4296   for (; bsp != NULL; bsp = bsp->next)
4297     {
4298       if (bsp->breakpoint_at == NULL)
4299         {
4300           /* A moribund location can never explain a signal other than
4301              GDB_SIGNAL_TRAP.  */
4302           if (sig == GDB_SIGNAL_TRAP)
4303             return 1;
4304         }
4305       else
4306         {
4307           if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
4308                                                         sig))
4309             return 1;
4310         }
4311     }
4312
4313   return 0;
4314 }
4315
4316 /* Put in *NUM the breakpoint number of the first breakpoint we are
4317    stopped at.  *BSP upon return is a bpstat which points to the
4318    remaining breakpoints stopped at (but which is not guaranteed to be
4319    good for anything but further calls to bpstat_num).
4320
4321    Return 0 if passed a bpstat which does not indicate any breakpoints.
4322    Return -1 if stopped at a breakpoint that has been deleted since
4323    we set it.
4324    Return 1 otherwise.  */
4325
4326 int
4327 bpstat_num (bpstat *bsp, int *num)
4328 {
4329   struct breakpoint *b;
4330
4331   if ((*bsp) == NULL)
4332     return 0;                   /* No more breakpoint values */
4333
4334   /* We assume we'll never have several bpstats that correspond to a
4335      single breakpoint -- otherwise, this function might return the
4336      same number more than once and this will look ugly.  */
4337   b = (*bsp)->breakpoint_at;
4338   *bsp = (*bsp)->next;
4339   if (b == NULL)
4340     return -1;                  /* breakpoint that's been deleted since */
4341
4342   *num = b->number;             /* We have its number */
4343   return 1;
4344 }
4345
4346 /* See breakpoint.h.  */
4347
4348 void
4349 bpstat_clear_actions (void)
4350 {
4351   struct thread_info *tp;
4352   bpstat bs;
4353
4354   if (ptid_equal (inferior_ptid, null_ptid))
4355     return;
4356
4357   tp = find_thread_ptid (inferior_ptid);
4358   if (tp == NULL)
4359     return;
4360
4361   for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
4362     {
4363       bs->commands = NULL;
4364
4365       if (bs->old_val != NULL)
4366         {
4367           value_free (bs->old_val);
4368           bs->old_val = NULL;
4369         }
4370     }
4371 }
4372
4373 /* Called when a command is about to proceed the inferior.  */
4374
4375 static void
4376 breakpoint_about_to_proceed (void)
4377 {
4378   if (!ptid_equal (inferior_ptid, null_ptid))
4379     {
4380       struct thread_info *tp = inferior_thread ();
4381
4382       /* Allow inferior function calls in breakpoint commands to not
4383          interrupt the command list.  When the call finishes
4384          successfully, the inferior will be standing at the same
4385          breakpoint as if nothing happened.  */
4386       if (tp->control.in_infcall)
4387         return;
4388     }
4389
4390   breakpoint_proceeded = 1;
4391 }
4392
4393 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4394    or its equivalent.  */
4395
4396 static int
4397 command_line_is_silent (struct command_line *cmd)
4398 {
4399   return cmd && (strcmp ("silent", cmd->line) == 0);
4400 }
4401
4402 /* Execute all the commands associated with all the breakpoints at
4403    this location.  Any of these commands could cause the process to
4404    proceed beyond this point, etc.  We look out for such changes by
4405    checking the global "breakpoint_proceeded" after each command.
4406
4407    Returns true if a breakpoint command resumed the inferior.  In that
4408    case, it is the caller's responsibility to recall it again with the
4409    bpstat of the current thread.  */
4410
4411 static int
4412 bpstat_do_actions_1 (bpstat *bsp)
4413 {
4414   bpstat bs;
4415   int again = 0;
4416
4417   /* Avoid endless recursion if a `source' command is contained
4418      in bs->commands.  */
4419   if (executing_breakpoint_commands)
4420     return 0;
4421
4422   scoped_restore save_executing
4423     = make_scoped_restore (&executing_breakpoint_commands, 1);
4424
4425   scoped_restore preventer = prevent_dont_repeat ();
4426
4427   /* This pointer will iterate over the list of bpstat's.  */
4428   bs = *bsp;
4429
4430   breakpoint_proceeded = 0;
4431   for (; bs != NULL; bs = bs->next)
4432     {
4433       struct command_line *cmd = NULL;
4434
4435       /* Take ownership of the BSP's command tree, if it has one.
4436
4437          The command tree could legitimately contain commands like
4438          'step' and 'next', which call clear_proceed_status, which
4439          frees stop_bpstat's command tree.  To make sure this doesn't
4440          free the tree we're executing out from under us, we need to
4441          take ownership of the tree ourselves.  Since a given bpstat's
4442          commands are only executed once, we don't need to copy it; we
4443          can clear the pointer in the bpstat, and make sure we free
4444          the tree when we're done.  */
4445       counted_command_line ccmd = bs->commands;
4446       bs->commands = NULL;
4447       if (ccmd != NULL)
4448         cmd = ccmd.get ();
4449       if (command_line_is_silent (cmd))
4450         {
4451           /* The action has been already done by bpstat_stop_status.  */
4452           cmd = cmd->next;
4453         }
4454
4455       while (cmd != NULL)
4456         {
4457           execute_control_command (cmd);
4458
4459           if (breakpoint_proceeded)
4460             break;
4461           else
4462             cmd = cmd->next;
4463         }
4464
4465       if (breakpoint_proceeded)
4466         {
4467           if (current_ui->async)
4468             /* If we are in async mode, then the target might be still
4469                running, not stopped at any breakpoint, so nothing for
4470                us to do here -- just return to the event loop.  */
4471             ;
4472           else
4473             /* In sync mode, when execute_control_command returns
4474                we're already standing on the next breakpoint.
4475                Breakpoint commands for that stop were not run, since
4476                execute_command does not run breakpoint commands --
4477                only command_line_handler does, but that one is not
4478                involved in execution of breakpoint commands.  So, we
4479                can now execute breakpoint commands.  It should be
4480                noted that making execute_command do bpstat actions is
4481                not an option -- in this case we'll have recursive
4482                invocation of bpstat for each breakpoint with a
4483                command, and can easily blow up GDB stack.  Instead, we
4484                return true, which will trigger the caller to recall us
4485                with the new stop_bpstat.  */
4486             again = 1;
4487           break;
4488         }
4489     }
4490   return again;
4491 }
4492
4493 void
4494 bpstat_do_actions (void)
4495 {
4496   struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
4497
4498   /* Do any commands attached to breakpoint we are stopped at.  */
4499   while (!ptid_equal (inferior_ptid, null_ptid)
4500          && target_has_execution
4501          && !is_exited (inferior_ptid)
4502          && !is_executing (inferior_ptid))
4503     /* Since in sync mode, bpstat_do_actions may resume the inferior,
4504        and only return when it is stopped at the next breakpoint, we
4505        keep doing breakpoint actions until it returns false to
4506        indicate the inferior was not resumed.  */
4507     if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
4508       break;
4509
4510   discard_cleanups (cleanup_if_error);
4511 }
4512
4513 /* Print out the (old or new) value associated with a watchpoint.  */
4514
4515 static void
4516 watchpoint_value_print (struct value *val, struct ui_file *stream)
4517 {
4518   if (val == NULL)
4519     fprintf_unfiltered (stream, _("<unreadable>"));
4520   else
4521     {
4522       struct value_print_options opts;
4523       get_user_print_options (&opts);
4524       value_print (val, stream, &opts);
4525     }
4526 }
4527
4528 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4529    debugging multiple threads.  */
4530
4531 void
4532 maybe_print_thread_hit_breakpoint (struct ui_out *uiout)
4533 {
4534   if (uiout->is_mi_like_p ())
4535     return;
4536
4537   uiout->text ("\n");
4538
4539   if (show_thread_that_caused_stop ())
4540     {
4541       const char *name;
4542       struct thread_info *thr = inferior_thread ();
4543
4544       uiout->text ("Thread ");
4545       uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
4546
4547       name = thr->name != NULL ? thr->name : target_thread_name (thr);
4548       if (name != NULL)
4549         {
4550           uiout->text (" \"");
4551           uiout->field_fmt ("name", "%s", name);
4552           uiout->text ("\"");
4553         }
4554
4555       uiout->text (" hit ");
4556     }
4557 }
4558
4559 /* Generic routine for printing messages indicating why we
4560    stopped.  The behavior of this function depends on the value
4561    'print_it' in the bpstat structure.  Under some circumstances we
4562    may decide not to print anything here and delegate the task to
4563    normal_stop().  */
4564
4565 static enum print_stop_action
4566 print_bp_stop_message (bpstat bs)
4567 {
4568   switch (bs->print_it)
4569     {
4570     case print_it_noop:
4571       /* Nothing should be printed for this bpstat entry.  */
4572       return PRINT_UNKNOWN;
4573       break;
4574
4575     case print_it_done:
4576       /* We still want to print the frame, but we already printed the
4577          relevant messages.  */
4578       return PRINT_SRC_AND_LOC;
4579       break;
4580
4581     case print_it_normal:
4582       {
4583         struct breakpoint *b = bs->breakpoint_at;
4584
4585         /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4586            which has since been deleted.  */
4587         if (b == NULL)
4588           return PRINT_UNKNOWN;
4589
4590         /* Normal case.  Call the breakpoint's print_it method.  */
4591         return b->ops->print_it (bs);
4592       }
4593       break;
4594
4595     default:
4596       internal_error (__FILE__, __LINE__,
4597                       _("print_bp_stop_message: unrecognized enum value"));
4598       break;
4599     }
4600 }
4601
4602 /* A helper function that prints a shared library stopped event.  */
4603
4604 static void
4605 print_solib_event (int is_catchpoint)
4606 {
4607   int any_deleted
4608     = !VEC_empty (char_ptr, current_program_space->deleted_solibs);
4609   int any_added
4610     = !VEC_empty (so_list_ptr, current_program_space->added_solibs);
4611
4612   if (!is_catchpoint)
4613     {
4614       if (any_added || any_deleted)
4615         current_uiout->text (_("Stopped due to shared library event:\n"));
4616       else
4617         current_uiout->text (_("Stopped due to shared library event (no "
4618                                "libraries added or removed)\n"));
4619     }
4620
4621   if (current_uiout->is_mi_like_p ())
4622     current_uiout->field_string ("reason",
4623                                  async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
4624
4625   if (any_deleted)
4626     {
4627       char *name;
4628       int ix;
4629
4630       current_uiout->text (_("  Inferior unloaded "));
4631       ui_out_emit_list list_emitter (current_uiout, "removed");
4632       for (ix = 0;
4633            VEC_iterate (char_ptr, current_program_space->deleted_solibs,
4634                         ix, name);
4635            ++ix)
4636         {
4637           if (ix > 0)
4638             current_uiout->text ("    ");
4639           current_uiout->field_string ("library", name);
4640           current_uiout->text ("\n");
4641         }
4642     }
4643
4644   if (any_added)
4645     {
4646       struct so_list *iter;
4647       int ix;
4648
4649       current_uiout->text (_("  Inferior loaded "));
4650       ui_out_emit_list list_emitter (current_uiout, "added");
4651       for (ix = 0;
4652            VEC_iterate (so_list_ptr, current_program_space->added_solibs,
4653                         ix, iter);
4654            ++ix)
4655         {
4656           if (ix > 0)
4657             current_uiout->text ("    ");
4658           current_uiout->field_string ("library", iter->so_name);
4659           current_uiout->text ("\n");
4660         }
4661     }
4662 }
4663
4664 /* Print a message indicating what happened.  This is called from
4665    normal_stop().  The input to this routine is the head of the bpstat
4666    list - a list of the eventpoints that caused this stop.  KIND is
4667    the target_waitkind for the stopping event.  This
4668    routine calls the generic print routine for printing a message
4669    about reasons for stopping.  This will print (for example) the
4670    "Breakpoint n," part of the output.  The return value of this
4671    routine is one of:
4672
4673    PRINT_UNKNOWN: Means we printed nothing.
4674    PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4675    code to print the location.  An example is 
4676    "Breakpoint 1, " which should be followed by
4677    the location.
4678    PRINT_SRC_ONLY: Means we printed something, but there is no need
4679    to also print the location part of the message.
4680    An example is the catch/throw messages, which
4681    don't require a location appended to the end.
4682    PRINT_NOTHING: We have done some printing and we don't need any 
4683    further info to be printed.  */
4684
4685 enum print_stop_action
4686 bpstat_print (bpstat bs, int kind)
4687 {
4688   enum print_stop_action val;
4689
4690   /* Maybe another breakpoint in the chain caused us to stop.
4691      (Currently all watchpoints go on the bpstat whether hit or not.
4692      That probably could (should) be changed, provided care is taken
4693      with respect to bpstat_explains_signal).  */
4694   for (; bs; bs = bs->next)
4695     {
4696       val = print_bp_stop_message (bs);
4697       if (val == PRINT_SRC_ONLY 
4698           || val == PRINT_SRC_AND_LOC 
4699           || val == PRINT_NOTHING)
4700         return val;
4701     }
4702
4703   /* If we had hit a shared library event breakpoint,
4704      print_bp_stop_message would print out this message.  If we hit an
4705      OS-level shared library event, do the same thing.  */
4706   if (kind == TARGET_WAITKIND_LOADED)
4707     {
4708       print_solib_event (0);
4709       return PRINT_NOTHING;
4710     }
4711
4712   /* We reached the end of the chain, or we got a null BS to start
4713      with and nothing was printed.  */
4714   return PRINT_UNKNOWN;
4715 }
4716
4717 /* Evaluate the boolean expression EXP and return the result.  */
4718
4719 static bool
4720 breakpoint_cond_eval (expression *exp)
4721 {
4722   struct value *mark = value_mark ();
4723   bool res = value_true (evaluate_expression (exp));
4724
4725   value_free_to_mark (mark);
4726   return res;
4727 }
4728
4729 /* Allocate a new bpstat.  Link it to the FIFO list by BS_LINK_POINTER.  */
4730
4731 bpstats::bpstats (struct bp_location *bl, bpstat **bs_link_pointer)
4732   : next (NULL),
4733     bp_location_at (bl),
4734     breakpoint_at (bl->owner),
4735     commands (NULL),
4736     old_val (NULL),
4737     print (0),
4738     stop (0),
4739     print_it (print_it_normal)
4740 {
4741   incref_bp_location (bl);
4742   **bs_link_pointer = this;
4743   *bs_link_pointer = &next;
4744 }
4745
4746 bpstats::bpstats ()
4747   : next (NULL),
4748     bp_location_at (NULL),
4749     breakpoint_at (NULL),
4750     commands (NULL),
4751     old_val (NULL),
4752     print (0),
4753     stop (0),
4754     print_it (print_it_normal)
4755 {
4756 }
4757 \f
4758 /* The target has stopped with waitstatus WS.  Check if any hardware
4759    watchpoints have triggered, according to the target.  */
4760
4761 int
4762 watchpoints_triggered (struct target_waitstatus *ws)
4763 {
4764   int stopped_by_watchpoint = target_stopped_by_watchpoint ();
4765   CORE_ADDR addr;
4766   struct breakpoint *b;
4767
4768   if (!stopped_by_watchpoint)
4769     {
4770       /* We were not stopped by a watchpoint.  Mark all watchpoints
4771          as not triggered.  */
4772       ALL_BREAKPOINTS (b)
4773         if (is_hardware_watchpoint (b))
4774           {
4775             struct watchpoint *w = (struct watchpoint *) b;
4776
4777             w->watchpoint_triggered = watch_triggered_no;
4778           }
4779
4780       return 0;
4781     }
4782
4783   if (!target_stopped_data_address (&current_target, &addr))
4784     {
4785       /* We were stopped by a watchpoint, but we don't know where.
4786          Mark all watchpoints as unknown.  */
4787       ALL_BREAKPOINTS (b)
4788         if (is_hardware_watchpoint (b))
4789           {
4790             struct watchpoint *w = (struct watchpoint *) b;
4791
4792             w->watchpoint_triggered = watch_triggered_unknown;
4793           }
4794
4795       return 1;
4796     }
4797
4798   /* The target could report the data address.  Mark watchpoints
4799      affected by this data address as triggered, and all others as not
4800      triggered.  */
4801
4802   ALL_BREAKPOINTS (b)
4803     if (is_hardware_watchpoint (b))
4804       {
4805         struct watchpoint *w = (struct watchpoint *) b;
4806         struct bp_location *loc;
4807
4808         w->watchpoint_triggered = watch_triggered_no;
4809         for (loc = b->loc; loc; loc = loc->next)
4810           {
4811             if (is_masked_watchpoint (b))
4812               {
4813                 CORE_ADDR newaddr = addr & w->hw_wp_mask;
4814                 CORE_ADDR start = loc->address & w->hw_wp_mask;
4815
4816                 if (newaddr == start)
4817                   {
4818                     w->watchpoint_triggered = watch_triggered_yes;
4819                     break;
4820                   }
4821               }
4822             /* Exact match not required.  Within range is sufficient.  */
4823             else if (target_watchpoint_addr_within_range (&current_target,
4824                                                          addr, loc->address,
4825                                                          loc->length))
4826               {
4827                 w->watchpoint_triggered = watch_triggered_yes;
4828                 break;
4829               }
4830           }
4831       }
4832
4833   return 1;
4834 }
4835
4836 /* Possible return values for watchpoint_check.  */
4837 enum wp_check_result
4838   {
4839     /* The watchpoint has been deleted.  */
4840     WP_DELETED = 1,
4841
4842     /* The value has changed.  */
4843     WP_VALUE_CHANGED = 2,
4844
4845     /* The value has not changed.  */
4846     WP_VALUE_NOT_CHANGED = 3,
4847
4848     /* Ignore this watchpoint, no matter if the value changed or not.  */
4849     WP_IGNORE = 4,
4850   };
4851
4852 #define BP_TEMPFLAG 1
4853 #define BP_HARDWAREFLAG 2
4854
4855 /* Evaluate watchpoint condition expression and check if its value
4856    changed.  */
4857
4858 static wp_check_result
4859 watchpoint_check (bpstat bs)
4860 {
4861   struct watchpoint *b;
4862   struct frame_info *fr;
4863   int within_current_scope;
4864
4865   /* BS is built from an existing struct breakpoint.  */
4866   gdb_assert (bs->breakpoint_at != NULL);
4867   b = (struct watchpoint *) bs->breakpoint_at;
4868
4869   /* If this is a local watchpoint, we only want to check if the
4870      watchpoint frame is in scope if the current thread is the thread
4871      that was used to create the watchpoint.  */
4872   if (!watchpoint_in_thread_scope (b))
4873     return WP_IGNORE;
4874
4875   if (b->exp_valid_block == NULL)
4876     within_current_scope = 1;
4877   else
4878     {
4879       struct frame_info *frame = get_current_frame ();
4880       struct gdbarch *frame_arch = get_frame_arch (frame);
4881       CORE_ADDR frame_pc = get_frame_pc (frame);
4882
4883       /* stack_frame_destroyed_p() returns a non-zero value if we're
4884          still in the function but the stack frame has already been
4885          invalidated.  Since we can't rely on the values of local
4886          variables after the stack has been destroyed, we are treating
4887          the watchpoint in that state as `not changed' without further
4888          checking.  Don't mark watchpoints as changed if the current
4889          frame is in an epilogue - even if they are in some other
4890          frame, our view of the stack is likely to be wrong and
4891          frame_find_by_id could error out.  */
4892       if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
4893         return WP_IGNORE;
4894
4895       fr = frame_find_by_id (b->watchpoint_frame);
4896       within_current_scope = (fr != NULL);
4897
4898       /* If we've gotten confused in the unwinder, we might have
4899          returned a frame that can't describe this variable.  */
4900       if (within_current_scope)
4901         {
4902           struct symbol *function;
4903
4904           function = get_frame_function (fr);
4905           if (function == NULL
4906               || !contained_in (b->exp_valid_block,
4907                                 SYMBOL_BLOCK_VALUE (function)))
4908             within_current_scope = 0;
4909         }
4910
4911       if (within_current_scope)
4912         /* If we end up stopping, the current frame will get selected
4913            in normal_stop.  So this call to select_frame won't affect
4914            the user.  */
4915         select_frame (fr);
4916     }
4917
4918   if (within_current_scope)
4919     {
4920       /* We use value_{,free_to_}mark because it could be a *long*
4921          time before we return to the command level and call
4922          free_all_values.  We can't call free_all_values because we
4923          might be in the middle of evaluating a function call.  */
4924
4925       int pc = 0;
4926       struct value *mark;
4927       struct value *new_val;
4928
4929       if (is_masked_watchpoint (b))
4930         /* Since we don't know the exact trigger address (from
4931            stopped_data_address), just tell the user we've triggered
4932            a mask watchpoint.  */
4933         return WP_VALUE_CHANGED;
4934
4935       mark = value_mark ();
4936       fetch_subexp_value (b->exp.get (), &pc, &new_val, NULL, NULL, 0);
4937
4938       if (b->val_bitsize != 0)
4939         new_val = extract_bitfield_from_watchpoint_value (b, new_val);
4940
4941       /* We use value_equal_contents instead of value_equal because
4942          the latter coerces an array to a pointer, thus comparing just
4943          the address of the array instead of its contents.  This is
4944          not what we want.  */
4945       if ((b->val != NULL) != (new_val != NULL)
4946           || (b->val != NULL && !value_equal_contents (b->val, new_val)))
4947         {
4948           if (new_val != NULL)
4949             {
4950               release_value (new_val);
4951               value_free_to_mark (mark);
4952             }
4953           bs->old_val = b->val;
4954           b->val = new_val;
4955           b->val_valid = 1;
4956           return WP_VALUE_CHANGED;
4957         }
4958       else
4959         {
4960           /* Nothing changed.  */
4961           value_free_to_mark (mark);
4962           return WP_VALUE_NOT_CHANGED;
4963         }
4964     }
4965   else
4966     {
4967       /* This seems like the only logical thing to do because
4968          if we temporarily ignored the watchpoint, then when
4969          we reenter the block in which it is valid it contains
4970          garbage (in the case of a function, it may have two
4971          garbage values, one before and one after the prologue).
4972          So we can't even detect the first assignment to it and
4973          watch after that (since the garbage may or may not equal
4974          the first value assigned).  */
4975       /* We print all the stop information in
4976          breakpoint_ops->print_it, but in this case, by the time we
4977          call breakpoint_ops->print_it this bp will be deleted
4978          already.  So we have no choice but print the information
4979          here.  */
4980
4981       SWITCH_THRU_ALL_UIS ()
4982         {
4983           struct ui_out *uiout = current_uiout;
4984
4985           if (uiout->is_mi_like_p ())
4986             uiout->field_string
4987               ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
4988           uiout->text ("\nWatchpoint ");
4989           uiout->field_int ("wpnum", b->number);
4990           uiout->text (" deleted because the program has left the block in\n"
4991                        "which its expression is valid.\n");
4992         }
4993
4994       /* Make sure the watchpoint's commands aren't executed.  */
4995       b->commands = NULL;
4996       watchpoint_del_at_next_stop (b);
4997
4998       return WP_DELETED;
4999     }
5000 }
5001
5002 /* Return true if it looks like target has stopped due to hitting
5003    breakpoint location BL.  This function does not check if we should
5004    stop, only if BL explains the stop.  */
5005
5006 static int
5007 bpstat_check_location (const struct bp_location *bl,
5008                        const address_space *aspace, CORE_ADDR bp_addr,
5009                        const struct target_waitstatus *ws)
5010 {
5011   struct breakpoint *b = bl->owner;
5012
5013   /* BL is from an existing breakpoint.  */
5014   gdb_assert (b != NULL);
5015
5016   return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
5017 }
5018
5019 /* Determine if the watched values have actually changed, and we
5020    should stop.  If not, set BS->stop to 0.  */
5021
5022 static void
5023 bpstat_check_watchpoint (bpstat bs)
5024 {
5025   const struct bp_location *bl;
5026   struct watchpoint *b;
5027
5028   /* BS is built for existing struct breakpoint.  */
5029   bl = bs->bp_location_at;
5030   gdb_assert (bl != NULL);
5031   b = (struct watchpoint *) bs->breakpoint_at;
5032   gdb_assert (b != NULL);
5033
5034     {
5035       int must_check_value = 0;
5036       
5037       if (b->type == bp_watchpoint)
5038         /* For a software watchpoint, we must always check the
5039            watched value.  */
5040         must_check_value = 1;
5041       else if (b->watchpoint_triggered == watch_triggered_yes)
5042         /* We have a hardware watchpoint (read, write, or access)
5043            and the target earlier reported an address watched by
5044            this watchpoint.  */
5045         must_check_value = 1;
5046       else if (b->watchpoint_triggered == watch_triggered_unknown
5047                && b->type == bp_hardware_watchpoint)
5048         /* We were stopped by a hardware watchpoint, but the target could
5049            not report the data address.  We must check the watchpoint's
5050            value.  Access and read watchpoints are out of luck; without
5051            a data address, we can't figure it out.  */
5052         must_check_value = 1;
5053
5054       if (must_check_value)
5055         {
5056           wp_check_result e;
5057
5058           TRY
5059             {
5060               e = watchpoint_check (bs);
5061             }
5062           CATCH (ex, RETURN_MASK_ALL)
5063             {
5064               exception_fprintf (gdb_stderr, ex,
5065                                  "Error evaluating expression "
5066                                  "for watchpoint %d\n",
5067                                  b->number);
5068
5069               SWITCH_THRU_ALL_UIS ()
5070                 {
5071                   printf_filtered (_("Watchpoint %d deleted.\n"),
5072                                    b->number);
5073                 }
5074               watchpoint_del_at_next_stop (b);
5075               e = WP_DELETED;
5076             }
5077           END_CATCH
5078
5079           switch (e)
5080             {
5081             case WP_DELETED:
5082               /* We've already printed what needs to be printed.  */
5083               bs->print_it = print_it_done;
5084               /* Stop.  */
5085               break;
5086             case WP_IGNORE:
5087               bs->print_it = print_it_noop;
5088               bs->stop = 0;
5089               break;
5090             case WP_VALUE_CHANGED:
5091               if (b->type == bp_read_watchpoint)
5092                 {
5093                   /* There are two cases to consider here:
5094
5095                      1. We're watching the triggered memory for reads.
5096                      In that case, trust the target, and always report
5097                      the watchpoint hit to the user.  Even though
5098                      reads don't cause value changes, the value may
5099                      have changed since the last time it was read, and
5100                      since we're not trapping writes, we will not see
5101                      those, and as such we should ignore our notion of
5102                      old value.
5103
5104                      2. We're watching the triggered memory for both
5105                      reads and writes.  There are two ways this may
5106                      happen:
5107
5108                      2.1. This is a target that can't break on data
5109                      reads only, but can break on accesses (reads or
5110                      writes), such as e.g., x86.  We detect this case
5111                      at the time we try to insert read watchpoints.
5112
5113                      2.2. Otherwise, the target supports read
5114                      watchpoints, but, the user set an access or write
5115                      watchpoint watching the same memory as this read
5116                      watchpoint.
5117
5118                      If we're watching memory writes as well as reads,
5119                      ignore watchpoint hits when we find that the
5120                      value hasn't changed, as reads don't cause
5121                      changes.  This still gives false positives when
5122                      the program writes the same value to memory as
5123                      what there was already in memory (we will confuse
5124                      it for a read), but it's much better than
5125                      nothing.  */
5126
5127                   int other_write_watchpoint = 0;
5128
5129                   if (bl->watchpoint_type == hw_read)
5130                     {
5131                       struct breakpoint *other_b;
5132
5133                       ALL_BREAKPOINTS (other_b)
5134                         if (other_b->type == bp_hardware_watchpoint
5135                             || other_b->type == bp_access_watchpoint)
5136                           {
5137                             struct watchpoint *other_w =
5138                               (struct watchpoint *) other_b;
5139
5140                             if (other_w->watchpoint_triggered
5141                                 == watch_triggered_yes)
5142                               {
5143                                 other_write_watchpoint = 1;
5144                                 break;
5145                               }
5146                           }
5147                     }
5148
5149                   if (other_write_watchpoint
5150                       || bl->watchpoint_type == hw_access)
5151                     {
5152                       /* We're watching the same memory for writes,
5153                          and the value changed since the last time we
5154                          updated it, so this trap must be for a write.
5155                          Ignore it.  */
5156                       bs->print_it = print_it_noop;
5157                       bs->stop = 0;
5158                     }
5159                 }
5160               break;
5161             case WP_VALUE_NOT_CHANGED:
5162               if (b->type == bp_hardware_watchpoint
5163                   || b->type == bp_watchpoint)
5164                 {
5165                   /* Don't stop: write watchpoints shouldn't fire if
5166                      the value hasn't changed.  */
5167                   bs->print_it = print_it_noop;
5168                   bs->stop = 0;
5169                 }
5170               /* Stop.  */
5171               break;
5172             default:
5173               /* Can't happen.  */
5174               break;
5175             }
5176         }
5177       else      /* must_check_value == 0 */
5178         {
5179           /* This is a case where some watchpoint(s) triggered, but
5180              not at the address of this watchpoint, or else no
5181              watchpoint triggered after all.  So don't print
5182              anything for this watchpoint.  */
5183           bs->print_it = print_it_noop;
5184           bs->stop = 0;
5185         }
5186     }
5187 }
5188
5189 /* For breakpoints that are currently marked as telling gdb to stop,
5190    check conditions (condition proper, frame, thread and ignore count)
5191    of breakpoint referred to by BS.  If we should not stop for this
5192    breakpoint, set BS->stop to 0.  */
5193
5194 static void
5195 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
5196 {
5197   const struct bp_location *bl;
5198   struct breakpoint *b;
5199   /* Assume stop.  */
5200   bool condition_result = true;
5201   struct expression *cond;
5202
5203   gdb_assert (bs->stop);
5204
5205   /* BS is built for existing struct breakpoint.  */
5206   bl = bs->bp_location_at;
5207   gdb_assert (bl != NULL);
5208   b = bs->breakpoint_at;
5209   gdb_assert (b != NULL);
5210
5211   /* Even if the target evaluated the condition on its end and notified GDB, we
5212      need to do so again since GDB does not know if we stopped due to a
5213      breakpoint or a single step breakpoint.  */
5214
5215   if (frame_id_p (b->frame_id)
5216       && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
5217     {
5218       bs->stop = 0;
5219       return;
5220     }
5221
5222   /* If this is a thread/task-specific breakpoint, don't waste cpu
5223      evaluating the condition if this isn't the specified
5224      thread/task.  */
5225   if ((b->thread != -1 && b->thread != ptid_to_global_thread_id (ptid))
5226       || (b->task != 0 && b->task != ada_get_task_number (ptid)))
5227
5228     {
5229       bs->stop = 0;
5230       return;
5231     }
5232
5233   /* Evaluate extension language breakpoints that have a "stop" method
5234      implemented.  */
5235   bs->stop = breakpoint_ext_lang_cond_says_stop (b);
5236
5237   if (is_watchpoint (b))
5238     {
5239       struct watchpoint *w = (struct watchpoint *) b;
5240
5241       cond = w->cond_exp.get ();
5242     }
5243   else
5244     cond = bl->cond.get ();
5245
5246   if (cond && b->disposition != disp_del_at_next_stop)
5247     {
5248       int within_current_scope = 1;
5249       struct watchpoint * w;
5250
5251       /* We use value_mark and value_free_to_mark because it could
5252          be a long time before we return to the command level and
5253          call free_all_values.  We can't call free_all_values
5254          because we might be in the middle of evaluating a
5255          function call.  */
5256       struct value *mark = value_mark ();
5257
5258       if (is_watchpoint (b))
5259         w = (struct watchpoint *) b;
5260       else
5261         w = NULL;
5262
5263       /* Need to select the frame, with all that implies so that
5264          the conditions will have the right context.  Because we
5265          use the frame, we will not see an inlined function's
5266          variables when we arrive at a breakpoint at the start
5267          of the inlined function; the current frame will be the
5268          call site.  */
5269       if (w == NULL || w->cond_exp_valid_block == NULL)
5270         select_frame (get_current_frame ());
5271       else
5272         {
5273           struct frame_info *frame;
5274
5275           /* For local watchpoint expressions, which particular
5276              instance of a local is being watched matters, so we
5277              keep track of the frame to evaluate the expression
5278              in.  To evaluate the condition however, it doesn't
5279              really matter which instantiation of the function
5280              where the condition makes sense triggers the
5281              watchpoint.  This allows an expression like "watch
5282              global if q > 10" set in `func', catch writes to
5283              global on all threads that call `func', or catch
5284              writes on all recursive calls of `func' by a single
5285              thread.  We simply always evaluate the condition in
5286              the innermost frame that's executing where it makes
5287              sense to evaluate the condition.  It seems
5288              intuitive.  */
5289           frame = block_innermost_frame (w->cond_exp_valid_block);
5290           if (frame != NULL)
5291             select_frame (frame);
5292           else
5293             within_current_scope = 0;
5294         }
5295       if (within_current_scope)
5296         {
5297           TRY
5298             {
5299               condition_result = breakpoint_cond_eval (cond);
5300             }
5301           CATCH (ex, RETURN_MASK_ALL)
5302             {
5303               exception_fprintf (gdb_stderr, ex,
5304                                  "Error in testing breakpoint condition:\n");
5305             }
5306           END_CATCH
5307         }
5308       else
5309         {
5310           warning (_("Watchpoint condition cannot be tested "
5311                      "in the current scope"));
5312           /* If we failed to set the right context for this
5313              watchpoint, unconditionally report it.  */
5314         }
5315       /* FIXME-someday, should give breakpoint #.  */
5316       value_free_to_mark (mark);
5317     }
5318
5319   if (cond && !condition_result)
5320     {
5321       bs->stop = 0;
5322     }
5323   else if (b->ignore_count > 0)
5324     {
5325       b->ignore_count--;
5326       bs->stop = 0;
5327       /* Increase the hit count even though we don't stop.  */
5328       ++(b->hit_count);
5329       observer_notify_breakpoint_modified (b);
5330     }   
5331 }
5332
5333 /* Returns true if we need to track moribund locations of LOC's type
5334    on the current target.  */
5335
5336 static int
5337 need_moribund_for_location_type (struct bp_location *loc)
5338 {
5339   return ((loc->loc_type == bp_loc_software_breakpoint
5340            && !target_supports_stopped_by_sw_breakpoint ())
5341           || (loc->loc_type == bp_loc_hardware_breakpoint
5342               && !target_supports_stopped_by_hw_breakpoint ()));
5343 }
5344
5345
5346 /* Get a bpstat associated with having just stopped at address
5347    BP_ADDR in thread PTID.
5348
5349    Determine whether we stopped at a breakpoint, etc, or whether we
5350    don't understand this stop.  Result is a chain of bpstat's such
5351    that:
5352
5353    if we don't understand the stop, the result is a null pointer.
5354
5355    if we understand why we stopped, the result is not null.
5356
5357    Each element of the chain refers to a particular breakpoint or
5358    watchpoint at which we have stopped.  (We may have stopped for
5359    several reasons concurrently.)
5360
5361    Each element of the chain has valid next, breakpoint_at,
5362    commands, FIXME??? fields.  */
5363
5364 bpstat
5365 bpstat_stop_status (const address_space *aspace,
5366                     CORE_ADDR bp_addr, ptid_t ptid,
5367                     const struct target_waitstatus *ws)
5368 {
5369   struct breakpoint *b = NULL;
5370   struct bp_location *bl;
5371   struct bp_location *loc;
5372   /* First item of allocated bpstat's.  */
5373   bpstat bs_head = NULL, *bs_link = &bs_head;
5374   /* Pointer to the last thing in the chain currently.  */
5375   bpstat bs;
5376   int ix;
5377   int need_remove_insert;
5378   int removed_any;
5379
5380   /* First, build the bpstat chain with locations that explain a
5381      target stop, while being careful to not set the target running,
5382      as that may invalidate locations (in particular watchpoint
5383      locations are recreated).  Resuming will happen here with
5384      breakpoint conditions or watchpoint expressions that include
5385      inferior function calls.  */
5386
5387   ALL_BREAKPOINTS (b)
5388     {
5389       if (!breakpoint_enabled (b))
5390         continue;
5391
5392       for (bl = b->loc; bl != NULL; bl = bl->next)
5393         {
5394           /* For hardware watchpoints, we look only at the first
5395              location.  The watchpoint_check function will work on the
5396              entire expression, not the individual locations.  For
5397              read watchpoints, the watchpoints_triggered function has
5398              checked all locations already.  */
5399           if (b->type == bp_hardware_watchpoint && bl != b->loc)
5400             break;
5401
5402           if (!bl->enabled || bl->shlib_disabled)
5403             continue;
5404
5405           if (!bpstat_check_location (bl, aspace, bp_addr, ws))
5406             continue;
5407
5408           /* Come here if it's a watchpoint, or if the break address
5409              matches.  */
5410
5411           bs = new bpstats (bl, &bs_link);      /* Alloc a bpstat to
5412                                                    explain stop.  */
5413
5414           /* Assume we stop.  Should we find a watchpoint that is not
5415              actually triggered, or if the condition of the breakpoint
5416              evaluates as false, we'll reset 'stop' to 0.  */
5417           bs->stop = 1;
5418           bs->print = 1;
5419
5420           /* If this is a scope breakpoint, mark the associated
5421              watchpoint as triggered so that we will handle the
5422              out-of-scope event.  We'll get to the watchpoint next
5423              iteration.  */
5424           if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
5425             {
5426               struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5427
5428               w->watchpoint_triggered = watch_triggered_yes;
5429             }
5430         }
5431     }
5432
5433   /* Check if a moribund breakpoint explains the stop.  */
5434   if (!target_supports_stopped_by_sw_breakpoint ()
5435       || !target_supports_stopped_by_hw_breakpoint ())
5436     {
5437       for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
5438         {
5439           if (breakpoint_location_address_match (loc, aspace, bp_addr)
5440               && need_moribund_for_location_type (loc))
5441             {
5442               bs = new bpstats (loc, &bs_link);
5443               /* For hits of moribund locations, we should just proceed.  */
5444               bs->stop = 0;
5445               bs->print = 0;
5446               bs->print_it = print_it_noop;
5447             }
5448         }
5449     }
5450
5451   /* A bit of special processing for shlib breakpoints.  We need to
5452      process solib loading here, so that the lists of loaded and
5453      unloaded libraries are correct before we handle "catch load" and
5454      "catch unload".  */
5455   for (bs = bs_head; bs != NULL; bs = bs->next)
5456     {
5457       if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
5458         {
5459           handle_solib_event ();
5460           break;
5461         }
5462     }
5463
5464   /* Now go through the locations that caused the target to stop, and
5465      check whether we're interested in reporting this stop to higher
5466      layers, or whether we should resume the target transparently.  */
5467
5468   removed_any = 0;
5469
5470   for (bs = bs_head; bs != NULL; bs = bs->next)
5471     {
5472       if (!bs->stop)
5473         continue;
5474
5475       b = bs->breakpoint_at;
5476       b->ops->check_status (bs);
5477       if (bs->stop)
5478         {
5479           bpstat_check_breakpoint_conditions (bs, ptid);
5480
5481           if (bs->stop)
5482             {
5483               ++(b->hit_count);
5484               observer_notify_breakpoint_modified (b);
5485
5486               /* We will stop here.  */
5487               if (b->disposition == disp_disable)
5488                 {
5489                   --(b->enable_count);
5490                   if (b->enable_count <= 0)
5491                     b->enable_state = bp_disabled;
5492                   removed_any = 1;
5493                 }
5494               if (b->silent)
5495                 bs->print = 0;
5496               bs->commands = b->commands;
5497               if (command_line_is_silent (bs->commands
5498                                           ? bs->commands.get () : NULL))
5499                 bs->print = 0;
5500
5501               b->ops->after_condition_true (bs);
5502             }
5503
5504         }
5505
5506       /* Print nothing for this entry if we don't stop or don't
5507          print.  */
5508       if (!bs->stop || !bs->print)
5509         bs->print_it = print_it_noop;
5510     }
5511
5512   /* If we aren't stopping, the value of some hardware watchpoint may
5513      not have changed, but the intermediate memory locations we are
5514      watching may have.  Don't bother if we're stopping; this will get
5515      done later.  */
5516   need_remove_insert = 0;
5517   if (! bpstat_causes_stop (bs_head))
5518     for (bs = bs_head; bs != NULL; bs = bs->next)
5519       if (!bs->stop
5520           && bs->breakpoint_at
5521           && is_hardware_watchpoint (bs->breakpoint_at))
5522         {
5523           struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5524
5525           update_watchpoint (w, 0 /* don't reparse.  */);
5526           need_remove_insert = 1;
5527         }
5528
5529   if (need_remove_insert)
5530     update_global_location_list (UGLL_MAY_INSERT);
5531   else if (removed_any)
5532     update_global_location_list (UGLL_DONT_INSERT);
5533
5534   return bs_head;
5535 }
5536
5537 static void
5538 handle_jit_event (void)
5539 {
5540   struct frame_info *frame;
5541   struct gdbarch *gdbarch;
5542
5543   if (debug_infrun)
5544     fprintf_unfiltered (gdb_stdlog, "handling bp_jit_event\n");
5545
5546   /* Switch terminal for any messages produced by
5547      breakpoint_re_set.  */
5548   target_terminal::ours_for_output ();
5549
5550   frame = get_current_frame ();
5551   gdbarch = get_frame_arch (frame);
5552
5553   jit_event_handler (gdbarch);
5554
5555   target_terminal::inferior ();
5556 }
5557
5558 /* Prepare WHAT final decision for infrun.  */
5559
5560 /* Decide what infrun needs to do with this bpstat.  */
5561
5562 struct bpstat_what
5563 bpstat_what (bpstat bs_head)
5564 {
5565   struct bpstat_what retval;
5566   bpstat bs;
5567
5568   retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
5569   retval.call_dummy = STOP_NONE;
5570   retval.is_longjmp = 0;
5571
5572   for (bs = bs_head; bs != NULL; bs = bs->next)
5573     {
5574       /* Extract this BS's action.  After processing each BS, we check
5575          if its action overrides all we've seem so far.  */
5576       enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5577       enum bptype bptype;
5578
5579       if (bs->breakpoint_at == NULL)
5580         {
5581           /* I suspect this can happen if it was a momentary
5582              breakpoint which has since been deleted.  */
5583           bptype = bp_none;
5584         }
5585       else
5586         bptype = bs->breakpoint_at->type;
5587
5588       switch (bptype)
5589         {
5590         case bp_none:
5591           break;
5592         case bp_breakpoint:
5593         case bp_hardware_breakpoint:
5594         case bp_single_step:
5595         case bp_until:
5596         case bp_finish:
5597         case bp_shlib_event:
5598           if (bs->stop)
5599             {
5600               if (bs->print)
5601                 this_action = BPSTAT_WHAT_STOP_NOISY;
5602               else
5603                 this_action = BPSTAT_WHAT_STOP_SILENT;
5604             }
5605           else
5606             this_action = BPSTAT_WHAT_SINGLE;
5607           break;
5608         case bp_watchpoint:
5609         case bp_hardware_watchpoint:
5610         case bp_read_watchpoint:
5611         case bp_access_watchpoint:
5612           if (bs->stop)
5613             {
5614               if (bs->print)
5615                 this_action = BPSTAT_WHAT_STOP_NOISY;
5616               else
5617                 this_action = BPSTAT_WHAT_STOP_SILENT;
5618             }
5619           else
5620             {
5621               /* There was a watchpoint, but we're not stopping.
5622                  This requires no further action.  */
5623             }
5624           break;
5625         case bp_longjmp:
5626         case bp_longjmp_call_dummy:
5627         case bp_exception:
5628           if (bs->stop)
5629             {
5630               this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5631               retval.is_longjmp = bptype != bp_exception;
5632             }
5633           else
5634             this_action = BPSTAT_WHAT_SINGLE;
5635           break;
5636         case bp_longjmp_resume:
5637         case bp_exception_resume:
5638           if (bs->stop)
5639             {
5640               this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5641               retval.is_longjmp = bptype == bp_longjmp_resume;
5642             }
5643           else
5644             this_action = BPSTAT_WHAT_SINGLE;
5645           break;
5646         case bp_step_resume:
5647           if (bs->stop)
5648             this_action = BPSTAT_WHAT_STEP_RESUME;
5649           else
5650             {
5651               /* It is for the wrong frame.  */
5652               this_action = BPSTAT_WHAT_SINGLE;
5653             }
5654           break;
5655         case bp_hp_step_resume:
5656           if (bs->stop)
5657             this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5658           else
5659             {
5660               /* It is for the wrong frame.  */
5661               this_action = BPSTAT_WHAT_SINGLE;
5662             }
5663           break;
5664         case bp_watchpoint_scope:
5665         case bp_thread_event:
5666         case bp_overlay_event:
5667         case bp_longjmp_master:
5668         case bp_std_terminate_master:
5669         case bp_exception_master:
5670           this_action = BPSTAT_WHAT_SINGLE;
5671           break;
5672         case bp_catchpoint:
5673           if (bs->stop)
5674             {
5675               if (bs->print)
5676                 this_action = BPSTAT_WHAT_STOP_NOISY;
5677               else
5678                 this_action = BPSTAT_WHAT_STOP_SILENT;
5679             }
5680           else
5681             {
5682               /* There was a catchpoint, but we're not stopping.
5683                  This requires no further action.  */
5684             }
5685           break;
5686         case bp_jit_event:
5687           this_action = BPSTAT_WHAT_SINGLE;
5688           break;
5689         case bp_call_dummy:
5690           /* Make sure the action is stop (silent or noisy),
5691              so infrun.c pops the dummy frame.  */
5692           retval.call_dummy = STOP_STACK_DUMMY;
5693           this_action = BPSTAT_WHAT_STOP_SILENT;
5694           break;
5695         case bp_std_terminate:
5696           /* Make sure the action is stop (silent or noisy),
5697              so infrun.c pops the dummy frame.  */
5698           retval.call_dummy = STOP_STD_TERMINATE;
5699           this_action = BPSTAT_WHAT_STOP_SILENT;
5700           break;
5701         case bp_tracepoint:
5702         case bp_fast_tracepoint:
5703         case bp_static_tracepoint:
5704           /* Tracepoint hits should not be reported back to GDB, and
5705              if one got through somehow, it should have been filtered
5706              out already.  */
5707           internal_error (__FILE__, __LINE__,
5708                           _("bpstat_what: tracepoint encountered"));
5709           break;
5710         case bp_gnu_ifunc_resolver:
5711           /* Step over it (and insert bp_gnu_ifunc_resolver_return).  */
5712           this_action = BPSTAT_WHAT_SINGLE;
5713           break;
5714         case bp_gnu_ifunc_resolver_return:
5715           /* The breakpoint will be removed, execution will restart from the
5716              PC of the former breakpoint.  */
5717           this_action = BPSTAT_WHAT_KEEP_CHECKING;
5718           break;
5719
5720         case bp_dprintf:
5721           if (bs->stop)
5722             this_action = BPSTAT_WHAT_STOP_SILENT;
5723           else
5724             this_action = BPSTAT_WHAT_SINGLE;
5725           break;
5726
5727         default:
5728           internal_error (__FILE__, __LINE__,
5729                           _("bpstat_what: unhandled bptype %d"), (int) bptype);
5730         }
5731
5732       retval.main_action = std::max (retval.main_action, this_action);
5733     }
5734
5735   return retval;
5736 }
5737
5738 void
5739 bpstat_run_callbacks (bpstat bs_head)
5740 {
5741   bpstat bs;
5742
5743   for (bs = bs_head; bs != NULL; bs = bs->next)
5744     {
5745       struct breakpoint *b = bs->breakpoint_at;
5746
5747       if (b == NULL)
5748         continue;
5749       switch (b->type)
5750         {
5751         case bp_jit_event:
5752           handle_jit_event ();
5753           break;
5754         case bp_gnu_ifunc_resolver:
5755           gnu_ifunc_resolver_stop (b);
5756           break;
5757         case bp_gnu_ifunc_resolver_return:
5758           gnu_ifunc_resolver_return_stop (b);
5759           break;
5760         }
5761     }
5762 }
5763
5764 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5765    without hardware support).  This isn't related to a specific bpstat,
5766    just to things like whether watchpoints are set.  */
5767
5768 int
5769 bpstat_should_step (void)
5770 {
5771   struct breakpoint *b;
5772
5773   ALL_BREAKPOINTS (b)
5774     if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
5775       return 1;
5776   return 0;
5777 }
5778
5779 int
5780 bpstat_causes_stop (bpstat bs)
5781 {
5782   for (; bs != NULL; bs = bs->next)
5783     if (bs->stop)
5784       return 1;
5785
5786   return 0;
5787 }
5788
5789 \f
5790
5791 /* Compute a string of spaces suitable to indent the next line
5792    so it starts at the position corresponding to the table column
5793    named COL_NAME in the currently active table of UIOUT.  */
5794
5795 static char *
5796 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
5797 {
5798   static char wrap_indent[80];
5799   int i, total_width, width, align;
5800   const char *text;
5801
5802   total_width = 0;
5803   for (i = 1; uiout->query_table_field (i, &width, &align, &text); i++)
5804     {
5805       if (strcmp (text, col_name) == 0)
5806         {
5807           gdb_assert (total_width < sizeof wrap_indent);
5808           memset (wrap_indent, ' ', total_width);
5809           wrap_indent[total_width] = 0;
5810
5811           return wrap_indent;
5812         }
5813
5814       total_width += width + 1;
5815     }
5816
5817   return NULL;
5818 }
5819
5820 /* Determine if the locations of this breakpoint will have their conditions
5821    evaluated by the target, host or a mix of both.  Returns the following:
5822
5823     "host": Host evals condition.
5824     "host or target": Host or Target evals condition.
5825     "target": Target evals condition.
5826 */
5827
5828 static const char *
5829 bp_condition_evaluator (struct breakpoint *b)
5830 {
5831   struct bp_location *bl;
5832   char host_evals = 0;
5833   char target_evals = 0;
5834
5835   if (!b)
5836     return NULL;
5837
5838   if (!is_breakpoint (b))
5839     return NULL;
5840
5841   if (gdb_evaluates_breakpoint_condition_p ()
5842       || !target_supports_evaluation_of_breakpoint_conditions ())
5843     return condition_evaluation_host;
5844
5845   for (bl = b->loc; bl; bl = bl->next)
5846     {
5847       if (bl->cond_bytecode)
5848         target_evals++;
5849       else
5850         host_evals++;
5851     }
5852
5853   if (host_evals && target_evals)
5854     return condition_evaluation_both;
5855   else if (target_evals)
5856     return condition_evaluation_target;
5857   else
5858     return condition_evaluation_host;
5859 }
5860
5861 /* Determine the breakpoint location's condition evaluator.  This is
5862    similar to bp_condition_evaluator, but for locations.  */
5863
5864 static const char *
5865 bp_location_condition_evaluator (struct bp_location *bl)
5866 {
5867   if (bl && !is_breakpoint (bl->owner))
5868     return NULL;
5869
5870   if (gdb_evaluates_breakpoint_condition_p ()
5871       || !target_supports_evaluation_of_breakpoint_conditions ())
5872     return condition_evaluation_host;
5873
5874   if (bl && bl->cond_bytecode)
5875     return condition_evaluation_target;
5876   else
5877     return condition_evaluation_host;
5878 }
5879
5880 /* Print the LOC location out of the list of B->LOC locations.  */
5881
5882 static void
5883 print_breakpoint_location (struct breakpoint *b,
5884                            struct bp_location *loc)
5885 {
5886   struct ui_out *uiout = current_uiout;
5887
5888   scoped_restore_current_program_space restore_pspace;
5889
5890   if (loc != NULL && loc->shlib_disabled)
5891     loc = NULL;
5892
5893   if (loc != NULL)
5894     set_current_program_space (loc->pspace);
5895
5896   if (b->display_canonical)
5897     uiout->field_string ("what", event_location_to_string (b->location.get ()));
5898   else if (loc && loc->symtab)
5899     {
5900       const struct symbol *sym = loc->symbol;
5901
5902       if (sym == NULL)
5903         sym = find_pc_sect_function (loc->address, loc->section);
5904
5905       if (sym)
5906         {
5907           uiout->text ("in ");
5908           uiout->field_string ("func", SYMBOL_PRINT_NAME (sym));
5909           uiout->text (" ");
5910           uiout->wrap_hint (wrap_indent_at_field (uiout, "what"));
5911           uiout->text ("at ");
5912         }
5913       uiout->field_string ("file",
5914                            symtab_to_filename_for_display (loc->symtab));
5915       uiout->text (":");
5916
5917       if (uiout->is_mi_like_p ())
5918         uiout->field_string ("fullname", symtab_to_fullname (loc->symtab));
5919       
5920       uiout->field_int ("line", loc->line_number);
5921     }
5922   else if (loc)
5923     {
5924       string_file stb;
5925
5926       print_address_symbolic (loc->gdbarch, loc->address, &stb,
5927                               demangle, "");
5928       uiout->field_stream ("at", stb);
5929     }
5930   else
5931     {
5932       uiout->field_string ("pending",
5933                            event_location_to_string (b->location.get ()));
5934       /* If extra_string is available, it could be holding a condition
5935          or dprintf arguments.  In either case, make sure it is printed,
5936          too, but only for non-MI streams.  */
5937       if (!uiout->is_mi_like_p () && b->extra_string != NULL)
5938         {
5939           if (b->type == bp_dprintf)
5940             uiout->text (",");
5941           else
5942             uiout->text (" ");
5943           uiout->text (b->extra_string);
5944         }
5945     }
5946
5947   if (loc && is_breakpoint (b)
5948       && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5949       && bp_condition_evaluator (b) == condition_evaluation_both)
5950     {
5951       uiout->text (" (");
5952       uiout->field_string ("evaluated-by",
5953                            bp_location_condition_evaluator (loc));
5954       uiout->text (")");
5955     }
5956 }
5957
5958 static const char *
5959 bptype_string (enum bptype type)
5960 {
5961   struct ep_type_description
5962     {
5963       enum bptype type;
5964       const char *description;
5965     };
5966   static struct ep_type_description bptypes[] =
5967   {
5968     {bp_none, "?deleted?"},
5969     {bp_breakpoint, "breakpoint"},
5970     {bp_hardware_breakpoint, "hw breakpoint"},
5971     {bp_single_step, "sw single-step"},
5972     {bp_until, "until"},
5973     {bp_finish, "finish"},
5974     {bp_watchpoint, "watchpoint"},
5975     {bp_hardware_watchpoint, "hw watchpoint"},
5976     {bp_read_watchpoint, "read watchpoint"},
5977     {bp_access_watchpoint, "acc watchpoint"},
5978     {bp_longjmp, "longjmp"},
5979     {bp_longjmp_resume, "longjmp resume"},
5980     {bp_longjmp_call_dummy, "longjmp for call dummy"},
5981     {bp_exception, "exception"},
5982     {bp_exception_resume, "exception resume"},
5983     {bp_step_resume, "step resume"},
5984     {bp_hp_step_resume, "high-priority step resume"},
5985     {bp_watchpoint_scope, "watchpoint scope"},
5986     {bp_call_dummy, "call dummy"},
5987     {bp_std_terminate, "std::terminate"},
5988     {bp_shlib_event, "shlib events"},
5989     {bp_thread_event, "thread events"},
5990     {bp_overlay_event, "overlay events"},
5991     {bp_longjmp_master, "longjmp master"},
5992     {bp_std_terminate_master, "std::terminate master"},
5993     {bp_exception_master, "exception master"},
5994     {bp_catchpoint, "catchpoint"},
5995     {bp_tracepoint, "tracepoint"},
5996     {bp_fast_tracepoint, "fast tracepoint"},
5997     {bp_static_tracepoint, "static tracepoint"},
5998     {bp_dprintf, "dprintf"},
5999     {bp_jit_event, "jit events"},
6000     {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
6001     {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
6002   };
6003
6004   if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
6005       || ((int) type != bptypes[(int) type].type))
6006     internal_error (__FILE__, __LINE__,
6007                     _("bptypes table does not describe type #%d."),
6008                     (int) type);
6009
6010   return bptypes[(int) type].description;
6011 }
6012
6013 /* For MI, output a field named 'thread-groups' with a list as the value.
6014    For CLI, prefix the list with the string 'inf'. */
6015
6016 static void
6017 output_thread_groups (struct ui_out *uiout,
6018                       const char *field_name,
6019                       const std::vector<int> &inf_nums,
6020                       int mi_only)
6021 {
6022   int is_mi = uiout->is_mi_like_p ();
6023
6024   /* For backward compatibility, don't display inferiors in CLI unless
6025      there are several.  Always display them for MI. */
6026   if (!is_mi && mi_only)
6027     return;
6028
6029   ui_out_emit_list list_emitter (uiout, field_name);
6030
6031   for (size_t i = 0; i < inf_nums.size (); i++)
6032     {
6033       if (is_mi)
6034         {
6035           char mi_group[10];
6036
6037           xsnprintf (mi_group, sizeof (mi_group), "i%d", inf_nums[i]);
6038           uiout->field_string (NULL, mi_group);
6039         }
6040       else
6041         {
6042           if (i == 0)
6043             uiout->text (" inf ");
6044           else
6045             uiout->text (", ");
6046         
6047           uiout->text (plongest (inf_nums[i]));
6048         }
6049     }
6050 }
6051
6052 /* Print B to gdb_stdout.  */
6053
6054 static void
6055 print_one_breakpoint_location (struct breakpoint *b,
6056                                struct bp_location *loc,
6057                                int loc_number,
6058                                struct bp_location **last_loc,
6059                                int allflag)
6060 {
6061   struct command_line *l;
6062   static char bpenables[] = "nynny";
6063
6064   struct ui_out *uiout = current_uiout;
6065   int header_of_multiple = 0;
6066   int part_of_multiple = (loc != NULL);
6067   struct value_print_options opts;
6068
6069   get_user_print_options (&opts);
6070
6071   gdb_assert (!loc || loc_number != 0);
6072   /* See comment in print_one_breakpoint concerning treatment of
6073      breakpoints with single disabled location.  */
6074   if (loc == NULL 
6075       && (b->loc != NULL 
6076           && (b->loc->next != NULL || !b->loc->enabled)))
6077     header_of_multiple = 1;
6078   if (loc == NULL)
6079     loc = b->loc;
6080
6081   annotate_record ();
6082
6083   /* 1 */
6084   annotate_field (0);
6085   if (part_of_multiple)
6086     {
6087       char *formatted;
6088       formatted = xstrprintf ("%d.%d", b->number, loc_number);
6089       uiout->field_string ("number", formatted);
6090       xfree (formatted);
6091     }
6092   else
6093     {
6094       uiout->field_int ("number", b->number);
6095     }
6096
6097   /* 2 */
6098   annotate_field (1);
6099   if (part_of_multiple)
6100     uiout->field_skip ("type");
6101   else
6102     uiout->field_string ("type", bptype_string (b->type));
6103
6104   /* 3 */
6105   annotate_field (2);
6106   if (part_of_multiple)
6107     uiout->field_skip ("disp");
6108   else
6109     uiout->field_string ("disp", bpdisp_text (b->disposition));
6110
6111
6112   /* 4 */
6113   annotate_field (3);
6114   if (part_of_multiple)
6115     uiout->field_string ("enabled", loc->enabled ? "y" : "n");
6116   else
6117     uiout->field_fmt ("enabled", "%c", bpenables[(int) b->enable_state]);
6118   uiout->spaces (2);
6119
6120   
6121   /* 5 and 6 */
6122   if (b->ops != NULL && b->ops->print_one != NULL)
6123     {
6124       /* Although the print_one can possibly print all locations,
6125          calling it here is not likely to get any nice result.  So,
6126          make sure there's just one location.  */
6127       gdb_assert (b->loc == NULL || b->loc->next == NULL);
6128       b->ops->print_one (b, last_loc);
6129     }
6130   else
6131     switch (b->type)
6132       {
6133       case bp_none:
6134         internal_error (__FILE__, __LINE__,
6135                         _("print_one_breakpoint: bp_none encountered\n"));
6136         break;
6137
6138       case bp_watchpoint:
6139       case bp_hardware_watchpoint:
6140       case bp_read_watchpoint:
6141       case bp_access_watchpoint:
6142         {
6143           struct watchpoint *w = (struct watchpoint *) b;
6144
6145           /* Field 4, the address, is omitted (which makes the columns
6146              not line up too nicely with the headers, but the effect
6147              is relatively readable).  */
6148           if (opts.addressprint)
6149             uiout->field_skip ("addr");
6150           annotate_field (5);
6151           uiout->field_string ("what", w->exp_string);
6152         }
6153         break;
6154
6155       case bp_breakpoint:
6156       case bp_hardware_breakpoint:
6157       case bp_single_step:
6158       case bp_until:
6159       case bp_finish:
6160       case bp_longjmp:
6161       case bp_longjmp_resume:
6162       case bp_longjmp_call_dummy:
6163       case bp_exception:
6164       case bp_exception_resume:
6165       case bp_step_resume:
6166       case bp_hp_step_resume:
6167       case bp_watchpoint_scope:
6168       case bp_call_dummy:
6169       case bp_std_terminate:
6170       case bp_shlib_event:
6171       case bp_thread_event:
6172       case bp_overlay_event:
6173       case bp_longjmp_master:
6174       case bp_std_terminate_master:
6175       case bp_exception_master:
6176       case bp_tracepoint:
6177       case bp_fast_tracepoint:
6178       case bp_static_tracepoint:
6179       case bp_dprintf:
6180       case bp_jit_event:
6181       case bp_gnu_ifunc_resolver:
6182       case bp_gnu_ifunc_resolver_return:
6183         if (opts.addressprint)
6184           {
6185             annotate_field (4);
6186             if (header_of_multiple)
6187               uiout->field_string ("addr", "<MULTIPLE>");
6188             else if (b->loc == NULL || loc->shlib_disabled)
6189               uiout->field_string ("addr", "<PENDING>");
6190             else
6191               uiout->field_core_addr ("addr",
6192                                       loc->gdbarch, loc->address);
6193           }
6194         annotate_field (5);
6195         if (!header_of_multiple)
6196           print_breakpoint_location (b, loc);
6197         if (b->loc)
6198           *last_loc = b->loc;
6199         break;
6200       }
6201
6202
6203   if (loc != NULL && !header_of_multiple)
6204     {
6205       struct inferior *inf;
6206       std::vector<int> inf_nums;
6207       int mi_only = 1;
6208
6209       ALL_INFERIORS (inf)
6210         {
6211           if (inf->pspace == loc->pspace)
6212             inf_nums.push_back (inf->num);
6213         }
6214
6215         /* For backward compatibility, don't display inferiors in CLI unless
6216            there are several.  Always display for MI. */
6217         if (allflag
6218             || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6219                 && (number_of_program_spaces () > 1
6220                     || number_of_inferiors () > 1)
6221                 /* LOC is for existing B, it cannot be in
6222                    moribund_locations and thus having NULL OWNER.  */
6223                 && loc->owner->type != bp_catchpoint))
6224         mi_only = 0;
6225       output_thread_groups (uiout, "thread-groups", inf_nums, mi_only);
6226     }
6227
6228   if (!part_of_multiple)
6229     {
6230       if (b->thread != -1)
6231         {
6232           /* FIXME: This seems to be redundant and lost here; see the
6233              "stop only in" line a little further down.  */
6234           uiout->text (" thread ");
6235           uiout->field_int ("thread", b->thread);
6236         }
6237       else if (b->task != 0)
6238         {
6239           uiout->text (" task ");
6240           uiout->field_int ("task", b->task);
6241         }
6242     }
6243
6244   uiout->text ("\n");
6245
6246   if (!part_of_multiple)
6247     b->ops->print_one_detail (b, uiout);
6248
6249   if (part_of_multiple && frame_id_p (b->frame_id))
6250     {
6251       annotate_field (6);
6252       uiout->text ("\tstop only in stack frame at ");
6253       /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6254          the frame ID.  */
6255       uiout->field_core_addr ("frame",
6256                               b->gdbarch, b->frame_id.stack_addr);
6257       uiout->text ("\n");
6258     }
6259   
6260   if (!part_of_multiple && b->cond_string)
6261     {
6262       annotate_field (7);
6263       if (is_tracepoint (b))
6264         uiout->text ("\ttrace only if ");
6265       else
6266         uiout->text ("\tstop only if ");
6267       uiout->field_string ("cond", b->cond_string);
6268
6269       /* Print whether the target is doing the breakpoint's condition
6270          evaluation.  If GDB is doing the evaluation, don't print anything.  */
6271       if (is_breakpoint (b)
6272           && breakpoint_condition_evaluation_mode ()
6273           == condition_evaluation_target)
6274         {
6275           uiout->text (" (");
6276           uiout->field_string ("evaluated-by",
6277                                bp_condition_evaluator (b));
6278           uiout->text (" evals)");
6279         }
6280       uiout->text ("\n");
6281     }
6282
6283   if (!part_of_multiple && b->thread != -1)
6284     {
6285       /* FIXME should make an annotation for this.  */
6286       uiout->text ("\tstop only in thread ");
6287       if (uiout->is_mi_like_p ())
6288         uiout->field_int ("thread", b->thread);
6289       else
6290         {
6291           struct thread_info *thr = find_thread_global_id (b->thread);
6292
6293           uiout->field_string ("thread", print_thread_id (thr));
6294         }
6295       uiout->text ("\n");
6296     }
6297   
6298   if (!part_of_multiple)
6299     {
6300       if (b->hit_count)
6301         {
6302           /* FIXME should make an annotation for this.  */
6303           if (is_catchpoint (b))
6304             uiout->text ("\tcatchpoint");
6305           else if (is_tracepoint (b))
6306             uiout->text ("\ttracepoint");
6307           else
6308             uiout->text ("\tbreakpoint");
6309           uiout->text (" already hit ");
6310           uiout->field_int ("times", b->hit_count);
6311           if (b->hit_count == 1)
6312             uiout->text (" time\n");
6313           else
6314             uiout->text (" times\n");
6315         }
6316       else
6317         {
6318           /* Output the count also if it is zero, but only if this is mi.  */
6319           if (uiout->is_mi_like_p ())
6320             uiout->field_int ("times", b->hit_count);
6321         }
6322     }
6323
6324   if (!part_of_multiple && b->ignore_count)
6325     {
6326       annotate_field (8);
6327       uiout->text ("\tignore next ");
6328       uiout->field_int ("ignore", b->ignore_count);
6329       uiout->text (" hits\n");
6330     }
6331
6332   /* Note that an enable count of 1 corresponds to "enable once"
6333      behavior, which is reported by the combination of enablement and
6334      disposition, so we don't need to mention it here.  */
6335   if (!part_of_multiple && b->enable_count > 1)
6336     {
6337       annotate_field (8);
6338       uiout->text ("\tdisable after ");
6339       /* Tweak the wording to clarify that ignore and enable counts
6340          are distinct, and have additive effect.  */
6341       if (b->ignore_count)
6342         uiout->text ("additional ");
6343       else
6344         uiout->text ("next ");
6345       uiout->field_int ("enable", b->enable_count);
6346       uiout->text (" hits\n");
6347     }
6348
6349   if (!part_of_multiple && is_tracepoint (b))
6350     {
6351       struct tracepoint *tp = (struct tracepoint *) b;
6352
6353       if (tp->traceframe_usage)
6354         {
6355           uiout->text ("\ttrace buffer usage ");
6356           uiout->field_int ("traceframe-usage", tp->traceframe_usage);
6357           uiout->text (" bytes\n");
6358         }
6359     }
6360
6361   l = b->commands ? b->commands.get () : NULL;
6362   if (!part_of_multiple && l)
6363     {
6364       annotate_field (9);
6365       ui_out_emit_tuple tuple_emitter (uiout, "script");
6366       print_command_lines (uiout, l, 4);
6367     }
6368
6369   if (is_tracepoint (b))
6370     {
6371       struct tracepoint *t = (struct tracepoint *) b;
6372
6373       if (!part_of_multiple && t->pass_count)
6374         {
6375           annotate_field (10);
6376           uiout->text ("\tpass count ");
6377           uiout->field_int ("pass", t->pass_count);
6378           uiout->text (" \n");
6379         }
6380
6381       /* Don't display it when tracepoint or tracepoint location is
6382          pending.   */
6383       if (!header_of_multiple && loc != NULL && !loc->shlib_disabled)
6384         {
6385           annotate_field (11);
6386
6387           if (uiout->is_mi_like_p ())
6388             uiout->field_string ("installed",
6389                                  loc->inserted ? "y" : "n");
6390           else
6391             {
6392               if (loc->inserted)
6393                 uiout->text ("\t");
6394               else
6395                 uiout->text ("\tnot ");
6396               uiout->text ("installed on target\n");
6397             }
6398         }
6399     }
6400
6401   if (uiout->is_mi_like_p () && !part_of_multiple)
6402     {
6403       if (is_watchpoint (b))
6404         {
6405           struct watchpoint *w = (struct watchpoint *) b;
6406
6407           uiout->field_string ("original-location", w->exp_string);
6408         }
6409       else if (b->location != NULL
6410                && event_location_to_string (b->location.get ()) != NULL)
6411         uiout->field_string ("original-location",
6412                              event_location_to_string (b->location.get ()));
6413     }
6414 }
6415
6416 static void
6417 print_one_breakpoint (struct breakpoint *b,
6418                       struct bp_location **last_loc, 
6419                       int allflag)
6420 {
6421   struct ui_out *uiout = current_uiout;
6422
6423   {
6424     ui_out_emit_tuple tuple_emitter (uiout, "bkpt");
6425
6426     print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
6427   }
6428
6429   /* If this breakpoint has custom print function,
6430      it's already printed.  Otherwise, print individual
6431      locations, if any.  */
6432   if (b->ops == NULL || b->ops->print_one == NULL)
6433     {
6434       /* If breakpoint has a single location that is disabled, we
6435          print it as if it had several locations, since otherwise it's
6436          hard to represent "breakpoint enabled, location disabled"
6437          situation.
6438
6439          Note that while hardware watchpoints have several locations
6440          internally, that's not a property exposed to user.  */
6441       if (b->loc 
6442           && !is_hardware_watchpoint (b)
6443           && (b->loc->next || !b->loc->enabled))
6444         {
6445           struct bp_location *loc;
6446           int n = 1;
6447
6448           for (loc = b->loc; loc; loc = loc->next, ++n)
6449             {
6450               ui_out_emit_tuple tuple_emitter (uiout, NULL);
6451               print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6452             }
6453         }
6454     }
6455 }
6456
6457 static int
6458 breakpoint_address_bits (struct breakpoint *b)
6459 {
6460   int print_address_bits = 0;
6461   struct bp_location *loc;
6462
6463   /* Software watchpoints that aren't watching memory don't have an
6464      address to print.  */
6465   if (is_no_memory_software_watchpoint (b))
6466     return 0;
6467
6468   for (loc = b->loc; loc; loc = loc->next)
6469     {
6470       int addr_bit;
6471
6472       addr_bit = gdbarch_addr_bit (loc->gdbarch);
6473       if (addr_bit > print_address_bits)
6474         print_address_bits = addr_bit;
6475     }
6476
6477   return print_address_bits;
6478 }
6479
6480 /* See breakpoint.h.  */
6481
6482 void
6483 print_breakpoint (breakpoint *b)
6484 {
6485   struct bp_location *dummy_loc = NULL;
6486   print_one_breakpoint (b, &dummy_loc, 0);
6487 }
6488
6489 /* Return true if this breakpoint was set by the user, false if it is
6490    internal or momentary.  */
6491
6492 int
6493 user_breakpoint_p (struct breakpoint *b)
6494 {
6495   return b->number > 0;
6496 }
6497
6498 /* See breakpoint.h.  */
6499
6500 int
6501 pending_breakpoint_p (struct breakpoint *b)
6502 {
6503   return b->loc == NULL;
6504 }
6505
6506 /* Print information on user settable breakpoint (watchpoint, etc)
6507    number BNUM.  If BNUM is -1 print all user-settable breakpoints.
6508    If ALLFLAG is non-zero, include non-user-settable breakpoints.  If
6509    FILTER is non-NULL, call it on each breakpoint and only include the
6510    ones for which it returns non-zero.  Return the total number of
6511    breakpoints listed.  */
6512
6513 static int
6514 breakpoint_1 (const char *args, int allflag, 
6515               int (*filter) (const struct breakpoint *))
6516 {
6517   struct breakpoint *b;
6518   struct bp_location *last_loc = NULL;
6519   int nr_printable_breakpoints;
6520   struct value_print_options opts;
6521   int print_address_bits = 0;
6522   int print_type_col_width = 14;
6523   struct ui_out *uiout = current_uiout;
6524
6525   get_user_print_options (&opts);
6526
6527   /* Compute the number of rows in the table, as well as the size
6528      required for address fields.  */
6529   nr_printable_breakpoints = 0;
6530   ALL_BREAKPOINTS (b)
6531     {
6532       /* If we have a filter, only list the breakpoints it accepts.  */
6533       if (filter && !filter (b))
6534         continue;
6535
6536       /* If we have an "args" string, it is a list of breakpoints to 
6537          accept.  Skip the others.  */
6538       if (args != NULL && *args != '\0')
6539         {
6540           if (allflag && parse_and_eval_long (args) != b->number)
6541             continue;
6542           if (!allflag && !number_is_in_list (args, b->number))
6543             continue;
6544         }
6545
6546       if (allflag || user_breakpoint_p (b))
6547         {
6548           int addr_bit, type_len;
6549
6550           addr_bit = breakpoint_address_bits (b);
6551           if (addr_bit > print_address_bits)
6552             print_address_bits = addr_bit;
6553
6554           type_len = strlen (bptype_string (b->type));
6555           if (type_len > print_type_col_width)
6556             print_type_col_width = type_len;
6557
6558           nr_printable_breakpoints++;
6559         }
6560     }
6561
6562   {
6563     ui_out_emit_table table_emitter (uiout,
6564                                      opts.addressprint ? 6 : 5,
6565                                      nr_printable_breakpoints,
6566                                      "BreakpointTable");
6567
6568     if (nr_printable_breakpoints > 0)
6569       annotate_breakpoints_headers ();
6570     if (nr_printable_breakpoints > 0)
6571       annotate_field (0);
6572     uiout->table_header (7, ui_left, "number", "Num"); /* 1 */
6573     if (nr_printable_breakpoints > 0)
6574       annotate_field (1);
6575     uiout->table_header (print_type_col_width, ui_left, "type", "Type"); /* 2 */
6576     if (nr_printable_breakpoints > 0)
6577       annotate_field (2);
6578     uiout->table_header (4, ui_left, "disp", "Disp"); /* 3 */
6579     if (nr_printable_breakpoints > 0)
6580       annotate_field (3);
6581     uiout->table_header (3, ui_left, "enabled", "Enb"); /* 4 */
6582     if (opts.addressprint)
6583       {
6584         if (nr_printable_breakpoints > 0)
6585           annotate_field (4);
6586         if (print_address_bits <= 32)
6587           uiout->table_header (10, ui_left, "addr", "Address"); /* 5 */
6588         else
6589           uiout->table_header (18, ui_left, "addr", "Address"); /* 5 */
6590       }
6591     if (nr_printable_breakpoints > 0)
6592       annotate_field (5);
6593     uiout->table_header (40, ui_noalign, "what", "What"); /* 6 */
6594     uiout->table_body ();
6595     if (nr_printable_breakpoints > 0)
6596       annotate_breakpoints_table ();
6597
6598     ALL_BREAKPOINTS (b)
6599       {
6600         QUIT;
6601         /* If we have a filter, only list the breakpoints it accepts.  */
6602         if (filter && !filter (b))
6603           continue;
6604
6605         /* If we have an "args" string, it is a list of breakpoints to 
6606            accept.  Skip the others.  */
6607
6608         if (args != NULL && *args != '\0')
6609           {
6610             if (allflag)        /* maintenance info breakpoint */
6611               {
6612                 if (parse_and_eval_long (args) != b->number)
6613                   continue;
6614               }
6615             else                /* all others */
6616               {
6617                 if (!number_is_in_list (args, b->number))
6618                   continue;
6619               }
6620           }
6621         /* We only print out user settable breakpoints unless the
6622            allflag is set.  */
6623         if (allflag || user_breakpoint_p (b))
6624           print_one_breakpoint (b, &last_loc, allflag);
6625       }
6626   }
6627
6628   if (nr_printable_breakpoints == 0)
6629     {
6630       /* If there's a filter, let the caller decide how to report
6631          empty list.  */
6632       if (!filter)
6633         {
6634           if (args == NULL || *args == '\0')
6635             uiout->message ("No breakpoints or watchpoints.\n");
6636           else
6637             uiout->message ("No breakpoint or watchpoint matching '%s'.\n",
6638                             args);
6639         }
6640     }
6641   else
6642     {
6643       if (last_loc && !server_command)
6644         set_next_address (last_loc->gdbarch, last_loc->address);
6645     }
6646
6647   /* FIXME?  Should this be moved up so that it is only called when
6648      there have been breakpoints? */
6649   annotate_breakpoints_table_end ();
6650
6651   return nr_printable_breakpoints;
6652 }
6653
6654 /* Display the value of default-collect in a way that is generally
6655    compatible with the breakpoint list.  */
6656
6657 static void
6658 default_collect_info (void)
6659 {
6660   struct ui_out *uiout = current_uiout;
6661
6662   /* If it has no value (which is frequently the case), say nothing; a
6663      message like "No default-collect." gets in user's face when it's
6664      not wanted.  */
6665   if (!*default_collect)
6666     return;
6667
6668   /* The following phrase lines up nicely with per-tracepoint collect
6669      actions.  */
6670   uiout->text ("default collect ");
6671   uiout->field_string ("default-collect", default_collect);
6672   uiout->text (" \n");
6673 }
6674   
6675 static void
6676 info_breakpoints_command (const char *args, int from_tty)
6677 {
6678   breakpoint_1 (args, 0, NULL);
6679
6680   default_collect_info ();
6681 }
6682
6683 static void
6684 info_watchpoints_command (const char *args, int from_tty)
6685 {
6686   int num_printed = breakpoint_1 (args, 0, is_watchpoint);
6687   struct ui_out *uiout = current_uiout;
6688
6689   if (num_printed == 0)
6690     {
6691       if (args == NULL || *args == '\0')
6692         uiout->message ("No watchpoints.\n");
6693       else
6694         uiout->message ("No watchpoint matching '%s'.\n", args);
6695     }
6696 }
6697
6698 static void
6699 maintenance_info_breakpoints (const char *args, int from_tty)
6700 {
6701   breakpoint_1 (args, 1, NULL);
6702
6703   default_collect_info ();
6704 }
6705
6706 static int
6707 breakpoint_has_pc (struct breakpoint *b,
6708                    struct program_space *pspace,
6709                    CORE_ADDR pc, struct obj_section *section)
6710 {
6711   struct bp_location *bl = b->loc;
6712
6713   for (; bl; bl = bl->next)
6714     {
6715       if (bl->pspace == pspace
6716           && bl->address == pc
6717           && (!overlay_debugging || bl->section == section))
6718         return 1;         
6719     }
6720   return 0;
6721 }
6722
6723 /* Print a message describing any user-breakpoints set at PC.  This
6724    concerns with logical breakpoints, so we match program spaces, not
6725    address spaces.  */
6726
6727 static void
6728 describe_other_breakpoints (struct gdbarch *gdbarch,
6729                             struct program_space *pspace, CORE_ADDR pc,
6730                             struct obj_section *section, int thread)
6731 {
6732   int others = 0;
6733   struct breakpoint *b;
6734
6735   ALL_BREAKPOINTS (b)
6736     others += (user_breakpoint_p (b)
6737                && breakpoint_has_pc (b, pspace, pc, section));
6738   if (others > 0)
6739     {
6740       if (others == 1)
6741         printf_filtered (_("Note: breakpoint "));
6742       else /* if (others == ???) */
6743         printf_filtered (_("Note: breakpoints "));
6744       ALL_BREAKPOINTS (b)
6745         if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
6746           {
6747             others--;
6748             printf_filtered ("%d", b->number);
6749             if (b->thread == -1 && thread != -1)
6750               printf_filtered (" (all threads)");
6751             else if (b->thread != -1)
6752               printf_filtered (" (thread %d)", b->thread);
6753             printf_filtered ("%s%s ",
6754                              ((b->enable_state == bp_disabled
6755                                || b->enable_state == bp_call_disabled)
6756                               ? " (disabled)"
6757                               : ""),
6758                              (others > 1) ? "," 
6759                              : ((others == 1) ? " and" : ""));
6760           }
6761       printf_filtered (_("also set at pc "));
6762       fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
6763       printf_filtered (".\n");
6764     }
6765 }
6766 \f
6767
6768 /* Return true iff it is meaningful to use the address member of
6769    BPT locations.  For some breakpoint types, the locations' address members
6770    are irrelevant and it makes no sense to attempt to compare them to other
6771    addresses (or use them for any other purpose either).
6772
6773    More specifically, each of the following breakpoint types will
6774    always have a zero valued location address and we don't want to mark
6775    breakpoints of any of these types to be a duplicate of an actual
6776    breakpoint location at address zero:
6777
6778       bp_watchpoint
6779       bp_catchpoint
6780
6781 */
6782
6783 static int
6784 breakpoint_address_is_meaningful (struct breakpoint *bpt)
6785 {
6786   enum bptype type = bpt->type;
6787
6788   return (type != bp_watchpoint && type != bp_catchpoint);
6789 }
6790
6791 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6792    true if LOC1 and LOC2 represent the same watchpoint location.  */
6793
6794 static int
6795 watchpoint_locations_match (struct bp_location *loc1, 
6796                             struct bp_location *loc2)
6797 {
6798   struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
6799   struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
6800
6801   /* Both of them must exist.  */
6802   gdb_assert (w1 != NULL);
6803   gdb_assert (w2 != NULL);
6804
6805   /* If the target can evaluate the condition expression in hardware,
6806      then we we need to insert both watchpoints even if they are at
6807      the same place.  Otherwise the watchpoint will only trigger when
6808      the condition of whichever watchpoint was inserted evaluates to
6809      true, not giving a chance for GDB to check the condition of the
6810      other watchpoint.  */
6811   if ((w1->cond_exp
6812        && target_can_accel_watchpoint_condition (loc1->address, 
6813                                                  loc1->length,
6814                                                  loc1->watchpoint_type,
6815                                                  w1->cond_exp.get ()))
6816       || (w2->cond_exp
6817           && target_can_accel_watchpoint_condition (loc2->address, 
6818                                                     loc2->length,
6819                                                     loc2->watchpoint_type,
6820                                                     w2->cond_exp.get ())))
6821     return 0;
6822
6823   /* Note that this checks the owner's type, not the location's.  In
6824      case the target does not support read watchpoints, but does
6825      support access watchpoints, we'll have bp_read_watchpoint
6826      watchpoints with hw_access locations.  Those should be considered
6827      duplicates of hw_read locations.  The hw_read locations will
6828      become hw_access locations later.  */
6829   return (loc1->owner->type == loc2->owner->type
6830           && loc1->pspace->aspace == loc2->pspace->aspace
6831           && loc1->address == loc2->address
6832           && loc1->length == loc2->length);
6833 }
6834
6835 /* See breakpoint.h.  */
6836
6837 int
6838 breakpoint_address_match (const address_space *aspace1, CORE_ADDR addr1,
6839                           const address_space *aspace2, CORE_ADDR addr2)
6840 {
6841   return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6842            || aspace1 == aspace2)
6843           && addr1 == addr2);
6844 }
6845
6846 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6847    {ASPACE1,ADDR1,LEN1}.  In most targets, this can only be true if ASPACE1
6848    matches ASPACE2.  On targets that have global breakpoints, the address
6849    space doesn't really matter.  */
6850
6851 static int
6852 breakpoint_address_match_range (const address_space *aspace1,
6853                                 CORE_ADDR addr1,
6854                                 int len1, const address_space *aspace2,
6855                                 CORE_ADDR addr2)
6856 {
6857   return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6858            || aspace1 == aspace2)
6859           && addr2 >= addr1 && addr2 < addr1 + len1);
6860 }
6861
6862 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL.  BL may be
6863    a ranged breakpoint.  In most targets, a match happens only if ASPACE
6864    matches the breakpoint's address space.  On targets that have global
6865    breakpoints, the address space doesn't really matter.  */
6866
6867 static int
6868 breakpoint_location_address_match (struct bp_location *bl,
6869                                    const address_space *aspace,
6870                                    CORE_ADDR addr)
6871 {
6872   return (breakpoint_address_match (bl->pspace->aspace, bl->address,
6873                                     aspace, addr)
6874           || (bl->length
6875               && breakpoint_address_match_range (bl->pspace->aspace,
6876                                                  bl->address, bl->length,
6877                                                  aspace, addr)));
6878 }
6879
6880 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6881    breakpoint BL.  BL may be a ranged breakpoint.  In most targets, a
6882    match happens only if ASPACE matches the breakpoint's address
6883    space.  On targets that have global breakpoints, the address space
6884    doesn't really matter.  */
6885
6886 static int
6887 breakpoint_location_address_range_overlap (struct bp_location *bl,
6888                                            const address_space *aspace,
6889                                            CORE_ADDR addr, int len)
6890 {
6891   if (gdbarch_has_global_breakpoints (target_gdbarch ())
6892       || bl->pspace->aspace == aspace)
6893     {
6894       int bl_len = bl->length != 0 ? bl->length : 1;
6895
6896       if (mem_ranges_overlap (addr, len, bl->address, bl_len))
6897         return 1;
6898     }
6899   return 0;
6900 }
6901
6902 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6903    Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6904    true, otherwise returns false.  */
6905
6906 static int
6907 tracepoint_locations_match (struct bp_location *loc1,
6908                             struct bp_location *loc2)
6909 {
6910   if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
6911     /* Since tracepoint locations are never duplicated with others', tracepoint
6912        locations at the same address of different tracepoints are regarded as
6913        different locations.  */
6914     return (loc1->address == loc2->address && loc1->owner == loc2->owner);
6915   else
6916     return 0;
6917 }
6918
6919 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6920    (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6921    represent the same location.  */
6922
6923 static int
6924 breakpoint_locations_match (struct bp_location *loc1, 
6925                             struct bp_location *loc2)
6926 {
6927   int hw_point1, hw_point2;
6928
6929   /* Both of them must not be in moribund_locations.  */
6930   gdb_assert (loc1->owner != NULL);
6931   gdb_assert (loc2->owner != NULL);
6932
6933   hw_point1 = is_hardware_watchpoint (loc1->owner);
6934   hw_point2 = is_hardware_watchpoint (loc2->owner);
6935
6936   if (hw_point1 != hw_point2)
6937     return 0;
6938   else if (hw_point1)
6939     return watchpoint_locations_match (loc1, loc2);
6940   else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
6941     return tracepoint_locations_match (loc1, loc2);
6942   else
6943     /* We compare bp_location.length in order to cover ranged breakpoints.  */
6944     return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
6945                                      loc2->pspace->aspace, loc2->address)
6946             && loc1->length == loc2->length);
6947 }
6948
6949 static void
6950 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
6951                                int bnum, int have_bnum)
6952 {
6953   /* The longest string possibly returned by hex_string_custom
6954      is 50 chars.  These must be at least that big for safety.  */
6955   char astr1[64];
6956   char astr2[64];
6957
6958   strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
6959   strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
6960   if (have_bnum)
6961     warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6962              bnum, astr1, astr2);
6963   else
6964     warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
6965 }
6966
6967 /* Adjust a breakpoint's address to account for architectural
6968    constraints on breakpoint placement.  Return the adjusted address.
6969    Note: Very few targets require this kind of adjustment.  For most
6970    targets, this function is simply the identity function.  */
6971
6972 static CORE_ADDR
6973 adjust_breakpoint_address (struct gdbarch *gdbarch,
6974                            CORE_ADDR bpaddr, enum bptype bptype)
6975 {
6976   if (bptype == bp_watchpoint
6977       || bptype == bp_hardware_watchpoint
6978       || bptype == bp_read_watchpoint
6979       || bptype == bp_access_watchpoint
6980       || bptype == bp_catchpoint)
6981     {
6982       /* Watchpoints and the various bp_catch_* eventpoints should not
6983          have their addresses modified.  */
6984       return bpaddr;
6985     }
6986   else if (bptype == bp_single_step)
6987     {
6988       /* Single-step breakpoints should not have their addresses
6989          modified.  If there's any architectural constrain that
6990          applies to this address, then it should have already been
6991          taken into account when the breakpoint was created in the
6992          first place.  If we didn't do this, stepping through e.g.,
6993          Thumb-2 IT blocks would break.  */
6994       return bpaddr;
6995     }
6996   else
6997     {
6998       CORE_ADDR adjusted_bpaddr = bpaddr;
6999
7000       if (gdbarch_adjust_breakpoint_address_p (gdbarch))
7001         {
7002           /* Some targets have architectural constraints on the placement
7003              of breakpoint instructions.  Obtain the adjusted address.  */
7004           adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
7005         }
7006
7007       adjusted_bpaddr = address_significant (gdbarch, adjusted_bpaddr);
7008
7009       /* An adjusted breakpoint address can significantly alter
7010          a user's expectations.  Print a warning if an adjustment
7011          is required.  */
7012       if (adjusted_bpaddr != bpaddr)
7013         breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
7014
7015       return adjusted_bpaddr;
7016     }
7017 }
7018
7019 bp_location::bp_location (const bp_location_ops *ops, breakpoint *owner)
7020 {
7021   bp_location *loc = this;
7022
7023   gdb_assert (ops != NULL);
7024
7025   loc->ops = ops;
7026   loc->owner = owner;
7027   loc->cond_bytecode = NULL;
7028   loc->shlib_disabled = 0;
7029   loc->enabled = 1;
7030
7031   switch (owner->type)
7032     {
7033     case bp_breakpoint:
7034     case bp_single_step:
7035     case bp_until:
7036     case bp_finish:
7037     case bp_longjmp:
7038     case bp_longjmp_resume:
7039     case bp_longjmp_call_dummy:
7040     case bp_exception:
7041     case bp_exception_resume:
7042     case bp_step_resume:
7043     case bp_hp_step_resume:
7044     case bp_watchpoint_scope:
7045     case bp_call_dummy:
7046     case bp_std_terminate:
7047     case bp_shlib_event:
7048     case bp_thread_event:
7049     case bp_overlay_event:
7050     case bp_jit_event:
7051     case bp_longjmp_master:
7052     case bp_std_terminate_master:
7053     case bp_exception_master:
7054     case bp_gnu_ifunc_resolver:
7055     case bp_gnu_ifunc_resolver_return:
7056     case bp_dprintf:
7057       loc->loc_type = bp_loc_software_breakpoint;
7058       mark_breakpoint_location_modified (loc);
7059       break;
7060     case bp_hardware_breakpoint:
7061       loc->loc_type = bp_loc_hardware_breakpoint;
7062       mark_breakpoint_location_modified (loc);
7063       break;
7064     case bp_hardware_watchpoint:
7065     case bp_read_watchpoint:
7066     case bp_access_watchpoint:
7067       loc->loc_type = bp_loc_hardware_watchpoint;
7068       break;
7069     case bp_watchpoint:
7070     case bp_catchpoint:
7071     case bp_tracepoint:
7072     case bp_fast_tracepoint:
7073     case bp_static_tracepoint:
7074       loc->loc_type = bp_loc_other;
7075       break;
7076     default:
7077       internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
7078     }
7079
7080   loc->refc = 1;
7081 }
7082
7083 /* Allocate a struct bp_location.  */
7084
7085 static struct bp_location *
7086 allocate_bp_location (struct breakpoint *bpt)
7087 {
7088   return bpt->ops->allocate_location (bpt);
7089 }
7090
7091 static void
7092 free_bp_location (struct bp_location *loc)
7093 {
7094   loc->ops->dtor (loc);
7095   delete loc;
7096 }
7097
7098 /* Increment reference count.  */
7099
7100 static void
7101 incref_bp_location (struct bp_location *bl)
7102 {
7103   ++bl->refc;
7104 }
7105
7106 /* Decrement reference count.  If the reference count reaches 0,
7107    destroy the bp_location.  Sets *BLP to NULL.  */
7108
7109 static void
7110 decref_bp_location (struct bp_location **blp)
7111 {
7112   gdb_assert ((*blp)->refc > 0);
7113
7114   if (--(*blp)->refc == 0)
7115     free_bp_location (*blp);
7116   *blp = NULL;
7117 }
7118
7119 /* Add breakpoint B at the end of the global breakpoint chain.  */
7120
7121 static breakpoint *
7122 add_to_breakpoint_chain (std::unique_ptr<breakpoint> &&b)
7123 {
7124   struct breakpoint *b1;
7125   struct breakpoint *result = b.get ();
7126
7127   /* Add this breakpoint to the end of the chain so that a list of
7128      breakpoints will come out in order of increasing numbers.  */
7129
7130   b1 = breakpoint_chain;
7131   if (b1 == 0)
7132     breakpoint_chain = b.release ();
7133   else
7134     {
7135       while (b1->next)
7136         b1 = b1->next;
7137       b1->next = b.release ();
7138     }
7139
7140   return result;
7141 }
7142
7143 /* Initializes breakpoint B with type BPTYPE and no locations yet.  */
7144
7145 static void
7146 init_raw_breakpoint_without_location (struct breakpoint *b,
7147                                       struct gdbarch *gdbarch,
7148                                       enum bptype bptype,
7149                                       const struct breakpoint_ops *ops)
7150 {
7151   gdb_assert (ops != NULL);
7152
7153   b->ops = ops;
7154   b->type = bptype;
7155   b->gdbarch = gdbarch;
7156   b->language = current_language->la_language;
7157   b->input_radix = input_radix;
7158   b->related_breakpoint = b;
7159 }
7160
7161 /* Helper to set_raw_breakpoint below.  Creates a breakpoint
7162    that has type BPTYPE and has no locations as yet.  */
7163
7164 static struct breakpoint *
7165 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
7166                                      enum bptype bptype,
7167                                      const struct breakpoint_ops *ops)
7168 {
7169   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7170
7171   init_raw_breakpoint_without_location (b.get (), gdbarch, bptype, ops);
7172   return add_to_breakpoint_chain (std::move (b));
7173 }
7174
7175 /* Initialize loc->function_name.  EXPLICIT_LOC says no indirect function
7176    resolutions should be made as the user specified the location explicitly
7177    enough.  */
7178
7179 static void
7180 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
7181 {
7182   gdb_assert (loc->owner != NULL);
7183
7184   if (loc->owner->type == bp_breakpoint
7185       || loc->owner->type == bp_hardware_breakpoint
7186       || is_tracepoint (loc->owner))
7187     {
7188       int is_gnu_ifunc;
7189       const char *function_name;
7190       CORE_ADDR func_addr;
7191
7192       find_pc_partial_function_gnu_ifunc (loc->address, &function_name,
7193                                           &func_addr, NULL, &is_gnu_ifunc);
7194
7195       if (is_gnu_ifunc && !explicit_loc)
7196         {
7197           struct breakpoint *b = loc->owner;
7198
7199           gdb_assert (loc->pspace == current_program_space);
7200           if (gnu_ifunc_resolve_name (function_name,
7201                                       &loc->requested_address))
7202             {
7203               /* Recalculate ADDRESS based on new REQUESTED_ADDRESS.  */
7204               loc->address = adjust_breakpoint_address (loc->gdbarch,
7205                                                         loc->requested_address,
7206                                                         b->type);
7207             }
7208           else if (b->type == bp_breakpoint && b->loc == loc
7209                    && loc->next == NULL && b->related_breakpoint == b)
7210             {
7211               /* Create only the whole new breakpoint of this type but do not
7212                  mess more complicated breakpoints with multiple locations.  */
7213               b->type = bp_gnu_ifunc_resolver;
7214               /* Remember the resolver's address for use by the return
7215                  breakpoint.  */
7216               loc->related_address = func_addr;
7217             }
7218         }
7219
7220       if (function_name)
7221         loc->function_name = xstrdup (function_name);
7222     }
7223 }
7224
7225 /* Attempt to determine architecture of location identified by SAL.  */
7226 struct gdbarch *
7227 get_sal_arch (struct symtab_and_line sal)
7228 {
7229   if (sal.section)
7230     return get_objfile_arch (sal.section->objfile);
7231   if (sal.symtab)
7232     return get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
7233
7234   return NULL;
7235 }
7236
7237 /* Low level routine for partially initializing a breakpoint of type
7238    BPTYPE.  The newly created breakpoint's address, section, source
7239    file name, and line number are provided by SAL.
7240
7241    It is expected that the caller will complete the initialization of
7242    the newly created breakpoint struct as well as output any status
7243    information regarding the creation of a new breakpoint.  */
7244
7245 static void
7246 init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
7247                      struct symtab_and_line sal, enum bptype bptype,
7248                      const struct breakpoint_ops *ops)
7249 {
7250   init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
7251
7252   add_location_to_breakpoint (b, &sal);
7253
7254   if (bptype != bp_catchpoint)
7255     gdb_assert (sal.pspace != NULL);
7256
7257   /* Store the program space that was used to set the breakpoint,
7258      except for ordinary breakpoints, which are independent of the
7259      program space.  */
7260   if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
7261     b->pspace = sal.pspace;
7262 }
7263
7264 /* set_raw_breakpoint is a low level routine for allocating and
7265    partially initializing a breakpoint of type BPTYPE.  The newly
7266    created breakpoint's address, section, source file name, and line
7267    number are provided by SAL.  The newly created and partially
7268    initialized breakpoint is added to the breakpoint chain and
7269    is also returned as the value of this function.
7270
7271    It is expected that the caller will complete the initialization of
7272    the newly created breakpoint struct as well as output any status
7273    information regarding the creation of a new breakpoint.  In
7274    particular, set_raw_breakpoint does NOT set the breakpoint
7275    number!  Care should be taken to not allow an error to occur
7276    prior to completing the initialization of the breakpoint.  If this
7277    should happen, a bogus breakpoint will be left on the chain.  */
7278
7279 struct breakpoint *
7280 set_raw_breakpoint (struct gdbarch *gdbarch,
7281                     struct symtab_and_line sal, enum bptype bptype,
7282                     const struct breakpoint_ops *ops)
7283 {
7284   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (bptype);
7285
7286   init_raw_breakpoint (b.get (), gdbarch, sal, bptype, ops);
7287   return add_to_breakpoint_chain (std::move (b));
7288 }
7289
7290 /* Call this routine when stepping and nexting to enable a breakpoint
7291    if we do a longjmp() or 'throw' in TP.  FRAME is the frame which
7292    initiated the operation.  */
7293
7294 void
7295 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
7296 {
7297   struct breakpoint *b, *b_tmp;
7298   int thread = tp->global_num;
7299
7300   /* To avoid having to rescan all objfile symbols at every step,
7301      we maintain a list of continually-inserted but always disabled
7302      longjmp "master" breakpoints.  Here, we simply create momentary
7303      clones of those and enable them for the requested thread.  */
7304   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7305     if (b->pspace == current_program_space
7306         && (b->type == bp_longjmp_master
7307             || b->type == bp_exception_master))
7308       {
7309         enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7310         struct breakpoint *clone;
7311
7312         /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7313            after their removal.  */
7314         clone = momentary_breakpoint_from_master (b, type,
7315                                                   &momentary_breakpoint_ops, 1);
7316         clone->thread = thread;
7317       }
7318
7319   tp->initiating_frame = frame;
7320 }
7321
7322 /* Delete all longjmp breakpoints from THREAD.  */
7323 void
7324 delete_longjmp_breakpoint (int thread)
7325 {
7326   struct breakpoint *b, *b_tmp;
7327
7328   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7329     if (b->type == bp_longjmp || b->type == bp_exception)
7330       {
7331         if (b->thread == thread)
7332           delete_breakpoint (b);
7333       }
7334 }
7335
7336 void
7337 delete_longjmp_breakpoint_at_next_stop (int thread)
7338 {
7339   struct breakpoint *b, *b_tmp;
7340
7341   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7342     if (b->type == bp_longjmp || b->type == bp_exception)
7343       {
7344         if (b->thread == thread)
7345           b->disposition = disp_del_at_next_stop;
7346       }
7347 }
7348
7349 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7350    INFERIOR_PTID thread.  Chain them all by RELATED_BREAKPOINT and return
7351    pointer to any of them.  Return NULL if this system cannot place longjmp
7352    breakpoints.  */
7353
7354 struct breakpoint *
7355 set_longjmp_breakpoint_for_call_dummy (void)
7356 {
7357   struct breakpoint *b, *retval = NULL;
7358
7359   ALL_BREAKPOINTS (b)
7360     if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7361       {
7362         struct breakpoint *new_b;
7363
7364         new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
7365                                                   &momentary_breakpoint_ops,
7366                                                   1);
7367         new_b->thread = ptid_to_global_thread_id (inferior_ptid);
7368
7369         /* Link NEW_B into the chain of RETVAL breakpoints.  */
7370
7371         gdb_assert (new_b->related_breakpoint == new_b);
7372         if (retval == NULL)
7373           retval = new_b;
7374         new_b->related_breakpoint = retval;
7375         while (retval->related_breakpoint != new_b->related_breakpoint)
7376           retval = retval->related_breakpoint;
7377         retval->related_breakpoint = new_b;
7378       }
7379
7380   return retval;
7381 }
7382
7383 /* Verify all existing dummy frames and their associated breakpoints for
7384    TP.  Remove those which can no longer be found in the current frame
7385    stack.
7386
7387    You should call this function only at places where it is safe to currently
7388    unwind the whole stack.  Failed stack unwind would discard live dummy
7389    frames.  */
7390
7391 void
7392 check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp)
7393 {
7394   struct breakpoint *b, *b_tmp;
7395
7396   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7397     if (b->type == bp_longjmp_call_dummy && b->thread == tp->global_num)
7398       {
7399         struct breakpoint *dummy_b = b->related_breakpoint;
7400
7401         while (dummy_b != b && dummy_b->type != bp_call_dummy)
7402           dummy_b = dummy_b->related_breakpoint;
7403         if (dummy_b->type != bp_call_dummy
7404             || frame_find_by_id (dummy_b->frame_id) != NULL)
7405           continue;
7406         
7407         dummy_frame_discard (dummy_b->frame_id, tp->ptid);
7408
7409         while (b->related_breakpoint != b)
7410           {
7411             if (b_tmp == b->related_breakpoint)
7412               b_tmp = b->related_breakpoint->next;
7413             delete_breakpoint (b->related_breakpoint);
7414           }
7415         delete_breakpoint (b);
7416       }
7417 }
7418
7419 void
7420 enable_overlay_breakpoints (void)
7421 {
7422   struct breakpoint *b;
7423
7424   ALL_BREAKPOINTS (b)
7425     if (b->type == bp_overlay_event)
7426     {
7427       b->enable_state = bp_enabled;
7428       update_global_location_list (UGLL_MAY_INSERT);
7429       overlay_events_enabled = 1;
7430     }
7431 }
7432
7433 void
7434 disable_overlay_breakpoints (void)
7435 {
7436   struct breakpoint *b;
7437
7438   ALL_BREAKPOINTS (b)
7439     if (b->type == bp_overlay_event)
7440     {
7441       b->enable_state = bp_disabled;
7442       update_global_location_list (UGLL_DONT_INSERT);
7443       overlay_events_enabled = 0;
7444     }
7445 }
7446
7447 /* Set an active std::terminate breakpoint for each std::terminate
7448    master breakpoint.  */
7449 void
7450 set_std_terminate_breakpoint (void)
7451 {
7452   struct breakpoint *b, *b_tmp;
7453
7454   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7455     if (b->pspace == current_program_space
7456         && b->type == bp_std_terminate_master)
7457       {
7458         momentary_breakpoint_from_master (b, bp_std_terminate,
7459                                           &momentary_breakpoint_ops, 1);
7460       }
7461 }
7462
7463 /* Delete all the std::terminate breakpoints.  */
7464 void
7465 delete_std_terminate_breakpoint (void)
7466 {
7467   struct breakpoint *b, *b_tmp;
7468
7469   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7470     if (b->type == bp_std_terminate)
7471       delete_breakpoint (b);
7472 }
7473
7474 struct breakpoint *
7475 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7476 {
7477   struct breakpoint *b;
7478
7479   b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7480                                   &internal_breakpoint_ops);
7481
7482   b->enable_state = bp_enabled;
7483   /* location has to be used or breakpoint_re_set will delete me.  */
7484   b->location = new_address_location (b->loc->address, NULL, 0);
7485
7486   update_global_location_list_nothrow (UGLL_MAY_INSERT);
7487
7488   return b;
7489 }
7490
7491 struct lang_and_radix
7492   {
7493     enum language lang;
7494     int radix;
7495   };
7496
7497 /* Create a breakpoint for JIT code registration and unregistration.  */
7498
7499 struct breakpoint *
7500 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7501 {
7502   return create_internal_breakpoint (gdbarch, address, bp_jit_event,
7503                                      &internal_breakpoint_ops);
7504 }
7505
7506 /* Remove JIT code registration and unregistration breakpoint(s).  */
7507
7508 void
7509 remove_jit_event_breakpoints (void)
7510 {
7511   struct breakpoint *b, *b_tmp;
7512
7513   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7514     if (b->type == bp_jit_event
7515         && b->loc->pspace == current_program_space)
7516       delete_breakpoint (b);
7517 }
7518
7519 void
7520 remove_solib_event_breakpoints (void)
7521 {
7522   struct breakpoint *b, *b_tmp;
7523
7524   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7525     if (b->type == bp_shlib_event
7526         && b->loc->pspace == current_program_space)
7527       delete_breakpoint (b);
7528 }
7529
7530 /* See breakpoint.h.  */
7531
7532 void
7533 remove_solib_event_breakpoints_at_next_stop (void)
7534 {
7535   struct breakpoint *b, *b_tmp;
7536
7537   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7538     if (b->type == bp_shlib_event
7539         && b->loc->pspace == current_program_space)
7540       b->disposition = disp_del_at_next_stop;
7541 }
7542
7543 /* Helper for create_solib_event_breakpoint /
7544    create_and_insert_solib_event_breakpoint.  Allows specifying which
7545    INSERT_MODE to pass through to update_global_location_list.  */
7546
7547 static struct breakpoint *
7548 create_solib_event_breakpoint_1 (struct gdbarch *gdbarch, CORE_ADDR address,
7549                                  enum ugll_insert_mode insert_mode)
7550 {
7551   struct breakpoint *b;
7552
7553   b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7554                                   &internal_breakpoint_ops);
7555   update_global_location_list_nothrow (insert_mode);
7556   return b;
7557 }
7558
7559 struct breakpoint *
7560 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7561 {
7562   return create_solib_event_breakpoint_1 (gdbarch, address, UGLL_MAY_INSERT);
7563 }
7564
7565 /* See breakpoint.h.  */
7566
7567 struct breakpoint *
7568 create_and_insert_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7569 {
7570   struct breakpoint *b;
7571
7572   /* Explicitly tell update_global_location_list to insert
7573      locations.  */
7574   b = create_solib_event_breakpoint_1 (gdbarch, address, UGLL_INSERT);
7575   if (!b->loc->inserted)
7576     {
7577       delete_breakpoint (b);
7578       return NULL;
7579     }
7580   return b;
7581 }
7582
7583 /* Disable any breakpoints that are on code in shared libraries.  Only
7584    apply to enabled breakpoints, disabled ones can just stay disabled.  */
7585
7586 void
7587 disable_breakpoints_in_shlibs (void)
7588 {
7589   struct bp_location *loc, **locp_tmp;
7590
7591   ALL_BP_LOCATIONS (loc, locp_tmp)
7592   {
7593     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7594     struct breakpoint *b = loc->owner;
7595
7596     /* We apply the check to all breakpoints, including disabled for
7597        those with loc->duplicate set.  This is so that when breakpoint
7598        becomes enabled, or the duplicate is removed, gdb will try to
7599        insert all breakpoints.  If we don't set shlib_disabled here,
7600        we'll try to insert those breakpoints and fail.  */
7601     if (((b->type == bp_breakpoint)
7602          || (b->type == bp_jit_event)
7603          || (b->type == bp_hardware_breakpoint)
7604          || (is_tracepoint (b)))
7605         && loc->pspace == current_program_space
7606         && !loc->shlib_disabled
7607         && solib_name_from_address (loc->pspace, loc->address)
7608         )
7609       {
7610         loc->shlib_disabled = 1;
7611       }
7612   }
7613 }
7614
7615 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7616    notification of unloaded_shlib.  Only apply to enabled breakpoints,
7617    disabled ones can just stay disabled.  */
7618
7619 static void
7620 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7621 {
7622   struct bp_location *loc, **locp_tmp;
7623   int disabled_shlib_breaks = 0;
7624
7625   ALL_BP_LOCATIONS (loc, locp_tmp)
7626   {
7627     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7628     struct breakpoint *b = loc->owner;
7629
7630     if (solib->pspace == loc->pspace
7631         && !loc->shlib_disabled
7632         && (((b->type == bp_breakpoint
7633               || b->type == bp_jit_event
7634               || b->type == bp_hardware_breakpoint)
7635              && (loc->loc_type == bp_loc_hardware_breakpoint
7636                  || loc->loc_type == bp_loc_software_breakpoint))
7637             || is_tracepoint (b))
7638         && solib_contains_address_p (solib, loc->address))
7639       {
7640         loc->shlib_disabled = 1;
7641         /* At this point, we cannot rely on remove_breakpoint
7642            succeeding so we must mark the breakpoint as not inserted
7643            to prevent future errors occurring in remove_breakpoints.  */
7644         loc->inserted = 0;
7645
7646         /* This may cause duplicate notifications for the same breakpoint.  */
7647         observer_notify_breakpoint_modified (b);
7648
7649         if (!disabled_shlib_breaks)
7650           {
7651             target_terminal::ours_for_output ();
7652             warning (_("Temporarily disabling breakpoints "
7653                        "for unloaded shared library \"%s\""),
7654                      solib->so_name);
7655           }
7656         disabled_shlib_breaks = 1;
7657       }
7658   }
7659 }
7660
7661 /* Disable any breakpoints and tracepoints in OBJFILE upon
7662    notification of free_objfile.  Only apply to enabled breakpoints,
7663    disabled ones can just stay disabled.  */
7664
7665 static void
7666 disable_breakpoints_in_freed_objfile (struct objfile *objfile)
7667 {
7668   struct breakpoint *b;
7669
7670   if (objfile == NULL)
7671     return;
7672
7673   /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7674      managed by the user with add-symbol-file/remove-symbol-file.
7675      Similarly to how breakpoints in shared libraries are handled in
7676      response to "nosharedlibrary", mark breakpoints in such modules
7677      shlib_disabled so they end up uninserted on the next global
7678      location list update.  Shared libraries not loaded by the user
7679      aren't handled here -- they're already handled in
7680      disable_breakpoints_in_unloaded_shlib, called by solib.c's
7681      solib_unloaded observer.  We skip objfiles that are not
7682      OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7683      main objfile).  */
7684   if ((objfile->flags & OBJF_SHARED) == 0
7685       || (objfile->flags & OBJF_USERLOADED) == 0)
7686     return;
7687
7688   ALL_BREAKPOINTS (b)
7689     {
7690       struct bp_location *loc;
7691       int bp_modified = 0;
7692
7693       if (!is_breakpoint (b) && !is_tracepoint (b))
7694         continue;
7695
7696       for (loc = b->loc; loc != NULL; loc = loc->next)
7697         {
7698           CORE_ADDR loc_addr = loc->address;
7699
7700           if (loc->loc_type != bp_loc_hardware_breakpoint
7701               && loc->loc_type != bp_loc_software_breakpoint)
7702             continue;
7703
7704           if (loc->shlib_disabled != 0)
7705             continue;
7706
7707           if (objfile->pspace != loc->pspace)
7708             continue;
7709
7710           if (loc->loc_type != bp_loc_hardware_breakpoint
7711               && loc->loc_type != bp_loc_software_breakpoint)
7712             continue;
7713
7714           if (is_addr_in_objfile (loc_addr, objfile))
7715             {
7716               loc->shlib_disabled = 1;
7717               /* At this point, we don't know whether the object was
7718                  unmapped from the inferior or not, so leave the
7719                  inserted flag alone.  We'll handle failure to
7720                  uninsert quietly, in case the object was indeed
7721                  unmapped.  */
7722
7723               mark_breakpoint_location_modified (loc);
7724
7725               bp_modified = 1;
7726             }
7727         }
7728
7729       if (bp_modified)
7730         observer_notify_breakpoint_modified (b);
7731     }
7732 }
7733
7734 /* FORK & VFORK catchpoints.  */
7735
7736 /* An instance of this type is used to represent a fork or vfork
7737    catchpoint.  A breakpoint is really of this type iff its ops pointer points
7738    to CATCH_FORK_BREAKPOINT_OPS.  */
7739
7740 struct fork_catchpoint : public breakpoint
7741 {
7742   /* Process id of a child process whose forking triggered this
7743      catchpoint.  This field is only valid immediately after this
7744      catchpoint has triggered.  */
7745   ptid_t forked_inferior_pid;
7746 };
7747
7748 /* Implement the "insert" breakpoint_ops method for fork
7749    catchpoints.  */
7750
7751 static int
7752 insert_catch_fork (struct bp_location *bl)
7753 {
7754   return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid));
7755 }
7756
7757 /* Implement the "remove" breakpoint_ops method for fork
7758    catchpoints.  */
7759
7760 static int
7761 remove_catch_fork (struct bp_location *bl, enum remove_bp_reason reason)
7762 {
7763   return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid));
7764 }
7765
7766 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7767    catchpoints.  */
7768
7769 static int
7770 breakpoint_hit_catch_fork (const struct bp_location *bl,
7771                            const address_space *aspace, CORE_ADDR bp_addr,
7772                            const struct target_waitstatus *ws)
7773 {
7774   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7775
7776   if (ws->kind != TARGET_WAITKIND_FORKED)
7777     return 0;
7778
7779   c->forked_inferior_pid = ws->value.related_pid;
7780   return 1;
7781 }
7782
7783 /* Implement the "print_it" breakpoint_ops method for fork
7784    catchpoints.  */
7785
7786 static enum print_stop_action
7787 print_it_catch_fork (bpstat bs)
7788 {
7789   struct ui_out *uiout = current_uiout;
7790   struct breakpoint *b = bs->breakpoint_at;
7791   struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
7792
7793   annotate_catchpoint (b->number);
7794   maybe_print_thread_hit_breakpoint (uiout);
7795   if (b->disposition == disp_del)
7796     uiout->text ("Temporary catchpoint ");
7797   else
7798     uiout->text ("Catchpoint ");
7799   if (uiout->is_mi_like_p ())
7800     {
7801       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK));
7802       uiout->field_string ("disp", bpdisp_text (b->disposition));
7803     }
7804   uiout->field_int ("bkptno", b->number);
7805   uiout->text (" (forked process ");
7806   uiout->field_int ("newpid", ptid_get_pid (c->forked_inferior_pid));
7807   uiout->text ("), ");
7808   return PRINT_SRC_AND_LOC;
7809 }
7810
7811 /* Implement the "print_one" breakpoint_ops method for fork
7812    catchpoints.  */
7813
7814 static void
7815 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
7816 {
7817   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7818   struct value_print_options opts;
7819   struct ui_out *uiout = current_uiout;
7820
7821   get_user_print_options (&opts);
7822
7823   /* Field 4, the address, is omitted (which makes the columns not
7824      line up too nicely with the headers, but the effect is relatively
7825      readable).  */
7826   if (opts.addressprint)
7827     uiout->field_skip ("addr");
7828   annotate_field (5);
7829   uiout->text ("fork");
7830   if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7831     {
7832       uiout->text (", process ");
7833       uiout->field_int ("what", ptid_get_pid (c->forked_inferior_pid));
7834       uiout->spaces (1);
7835     }
7836
7837   if (uiout->is_mi_like_p ())
7838     uiout->field_string ("catch-type", "fork");
7839 }
7840
7841 /* Implement the "print_mention" breakpoint_ops method for fork
7842    catchpoints.  */
7843
7844 static void
7845 print_mention_catch_fork (struct breakpoint *b)
7846 {
7847   printf_filtered (_("Catchpoint %d (fork)"), b->number);
7848 }
7849
7850 /* Implement the "print_recreate" breakpoint_ops method for fork
7851    catchpoints.  */
7852
7853 static void
7854 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
7855 {
7856   fprintf_unfiltered (fp, "catch fork");
7857   print_recreate_thread (b, fp);
7858 }
7859
7860 /* The breakpoint_ops structure to be used in fork catchpoints.  */
7861
7862 static struct breakpoint_ops catch_fork_breakpoint_ops;
7863
7864 /* Implement the "insert" breakpoint_ops method for vfork
7865    catchpoints.  */
7866
7867 static int
7868 insert_catch_vfork (struct bp_location *bl)
7869 {
7870   return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid));
7871 }
7872
7873 /* Implement the "remove" breakpoint_ops method for vfork
7874    catchpoints.  */
7875
7876 static int
7877 remove_catch_vfork (struct bp_location *bl, enum remove_bp_reason reason)
7878 {
7879   return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid));
7880 }
7881
7882 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7883    catchpoints.  */
7884
7885 static int
7886 breakpoint_hit_catch_vfork (const struct bp_location *bl,
7887                             const address_space *aspace, CORE_ADDR bp_addr,
7888                             const struct target_waitstatus *ws)
7889 {
7890   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7891
7892   if (ws->kind != TARGET_WAITKIND_VFORKED)
7893     return 0;
7894
7895   c->forked_inferior_pid = ws->value.related_pid;
7896   return 1;
7897 }
7898
7899 /* Implement the "print_it" breakpoint_ops method for vfork
7900    catchpoints.  */
7901
7902 static enum print_stop_action
7903 print_it_catch_vfork (bpstat bs)
7904 {
7905   struct ui_out *uiout = current_uiout;
7906   struct breakpoint *b = bs->breakpoint_at;
7907   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7908
7909   annotate_catchpoint (b->number);
7910   maybe_print_thread_hit_breakpoint (uiout);
7911   if (b->disposition == disp_del)
7912     uiout->text ("Temporary catchpoint ");
7913   else
7914     uiout->text ("Catchpoint ");
7915   if (uiout->is_mi_like_p ())
7916     {
7917       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK));
7918       uiout->field_string ("disp", bpdisp_text (b->disposition));
7919     }
7920   uiout->field_int ("bkptno", b->number);
7921   uiout->text (" (vforked process ");
7922   uiout->field_int ("newpid", ptid_get_pid (c->forked_inferior_pid));
7923   uiout->text ("), ");
7924   return PRINT_SRC_AND_LOC;
7925 }
7926
7927 /* Implement the "print_one" breakpoint_ops method for vfork
7928    catchpoints.  */
7929
7930 static void
7931 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
7932 {
7933   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7934   struct value_print_options opts;
7935   struct ui_out *uiout = current_uiout;
7936
7937   get_user_print_options (&opts);
7938   /* Field 4, the address, is omitted (which makes the columns not
7939      line up too nicely with the headers, but the effect is relatively
7940      readable).  */
7941   if (opts.addressprint)
7942     uiout->field_skip ("addr");
7943   annotate_field (5);
7944   uiout->text ("vfork");
7945   if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7946     {
7947       uiout->text (", process ");
7948       uiout->field_int ("what", ptid_get_pid (c->forked_inferior_pid));
7949       uiout->spaces (1);
7950     }
7951
7952   if (uiout->is_mi_like_p ())
7953     uiout->field_string ("catch-type", "vfork");
7954 }
7955
7956 /* Implement the "print_mention" breakpoint_ops method for vfork
7957    catchpoints.  */
7958
7959 static void
7960 print_mention_catch_vfork (struct breakpoint *b)
7961 {
7962   printf_filtered (_("Catchpoint %d (vfork)"), b->number);
7963 }
7964
7965 /* Implement the "print_recreate" breakpoint_ops method for vfork
7966    catchpoints.  */
7967
7968 static void
7969 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
7970 {
7971   fprintf_unfiltered (fp, "catch vfork");
7972   print_recreate_thread (b, fp);
7973 }
7974
7975 /* The breakpoint_ops structure to be used in vfork catchpoints.  */
7976
7977 static struct breakpoint_ops catch_vfork_breakpoint_ops;
7978
7979 /* An instance of this type is used to represent an solib catchpoint.
7980    A breakpoint is really of this type iff its ops pointer points to
7981    CATCH_SOLIB_BREAKPOINT_OPS.  */
7982
7983 struct solib_catchpoint : public breakpoint
7984 {
7985   ~solib_catchpoint () override;
7986
7987   /* True for "catch load", false for "catch unload".  */
7988   unsigned char is_load;
7989
7990   /* Regular expression to match, if any.  COMPILED is only valid when
7991      REGEX is non-NULL.  */
7992   char *regex;
7993   std::unique_ptr<compiled_regex> compiled;
7994 };
7995
7996 solib_catchpoint::~solib_catchpoint ()
7997 {
7998   xfree (this->regex);
7999 }
8000
8001 static int
8002 insert_catch_solib (struct bp_location *ignore)
8003 {
8004   return 0;
8005 }
8006
8007 static int
8008 remove_catch_solib (struct bp_location *ignore, enum remove_bp_reason reason)
8009 {
8010   return 0;
8011 }
8012
8013 static int
8014 breakpoint_hit_catch_solib (const struct bp_location *bl,
8015                             const address_space *aspace,
8016                             CORE_ADDR bp_addr,
8017                             const struct target_waitstatus *ws)
8018 {
8019   struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
8020   struct breakpoint *other;
8021
8022   if (ws->kind == TARGET_WAITKIND_LOADED)
8023     return 1;
8024
8025   ALL_BREAKPOINTS (other)
8026   {
8027     struct bp_location *other_bl;
8028
8029     if (other == bl->owner)
8030       continue;
8031
8032     if (other->type != bp_shlib_event)
8033       continue;
8034
8035     if (self->pspace != NULL && other->pspace != self->pspace)
8036       continue;
8037
8038     for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
8039       {
8040         if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
8041           return 1;
8042       }
8043   }
8044
8045   return 0;
8046 }
8047
8048 static void
8049 check_status_catch_solib (struct bpstats *bs)
8050 {
8051   struct solib_catchpoint *self
8052     = (struct solib_catchpoint *) bs->breakpoint_at;
8053   int ix;
8054
8055   if (self->is_load)
8056     {
8057       struct so_list *iter;
8058
8059       for (ix = 0;
8060            VEC_iterate (so_list_ptr, current_program_space->added_solibs,
8061                         ix, iter);
8062            ++ix)
8063         {
8064           if (!self->regex
8065               || self->compiled->exec (iter->so_name, 0, NULL, 0) == 0)
8066             return;
8067         }
8068     }
8069   else
8070     {
8071       char *iter;
8072
8073       for (ix = 0;
8074            VEC_iterate (char_ptr, current_program_space->deleted_solibs,
8075                         ix, iter);
8076            ++ix)
8077         {
8078           if (!self->regex
8079               || self->compiled->exec (iter, 0, NULL, 0) == 0)
8080             return;
8081         }
8082     }
8083
8084   bs->stop = 0;
8085   bs->print_it = print_it_noop;
8086 }
8087
8088 static enum print_stop_action
8089 print_it_catch_solib (bpstat bs)
8090 {
8091   struct breakpoint *b = bs->breakpoint_at;
8092   struct ui_out *uiout = current_uiout;
8093
8094   annotate_catchpoint (b->number);
8095   maybe_print_thread_hit_breakpoint (uiout);
8096   if (b->disposition == disp_del)
8097     uiout->text ("Temporary catchpoint ");
8098   else
8099     uiout->text ("Catchpoint ");
8100   uiout->field_int ("bkptno", b->number);
8101   uiout->text ("\n");
8102   if (uiout->is_mi_like_p ())
8103     uiout->field_string ("disp", bpdisp_text (b->disposition));
8104   print_solib_event (1);
8105   return PRINT_SRC_AND_LOC;
8106 }
8107
8108 static void
8109 print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
8110 {
8111   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8112   struct value_print_options opts;
8113   struct ui_out *uiout = current_uiout;
8114   char *msg;
8115
8116   get_user_print_options (&opts);
8117   /* Field 4, the address, is omitted (which makes the columns not
8118      line up too nicely with the headers, but the effect is relatively
8119      readable).  */
8120   if (opts.addressprint)
8121     {
8122       annotate_field (4);
8123       uiout->field_skip ("addr");
8124     }
8125
8126   annotate_field (5);
8127   if (self->is_load)
8128     {
8129       if (self->regex)
8130         msg = xstrprintf (_("load of library matching %s"), self->regex);
8131       else
8132         msg = xstrdup (_("load of library"));
8133     }
8134   else
8135     {
8136       if (self->regex)
8137         msg = xstrprintf (_("unload of library matching %s"), self->regex);
8138       else
8139         msg = xstrdup (_("unload of library"));
8140     }
8141   uiout->field_string ("what", msg);
8142   xfree (msg);
8143
8144   if (uiout->is_mi_like_p ())
8145     uiout->field_string ("catch-type", self->is_load ? "load" : "unload");
8146 }
8147
8148 static void
8149 print_mention_catch_solib (struct breakpoint *b)
8150 {
8151   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8152
8153   printf_filtered (_("Catchpoint %d (%s)"), b->number,
8154                    self->is_load ? "load" : "unload");
8155 }
8156
8157 static void
8158 print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
8159 {
8160   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8161
8162   fprintf_unfiltered (fp, "%s %s",
8163                       b->disposition == disp_del ? "tcatch" : "catch",
8164                       self->is_load ? "load" : "unload");
8165   if (self->regex)
8166     fprintf_unfiltered (fp, " %s", self->regex);
8167   fprintf_unfiltered (fp, "\n");
8168 }
8169
8170 static struct breakpoint_ops catch_solib_breakpoint_ops;
8171
8172 /* Shared helper function (MI and CLI) for creating and installing
8173    a shared object event catchpoint.  If IS_LOAD is non-zero then
8174    the events to be caught are load events, otherwise they are
8175    unload events.  If IS_TEMP is non-zero the catchpoint is a
8176    temporary one.  If ENABLED is non-zero the catchpoint is
8177    created in an enabled state.  */
8178
8179 void
8180 add_solib_catchpoint (const char *arg, int is_load, int is_temp, int enabled)
8181 {
8182   struct gdbarch *gdbarch = get_current_arch ();
8183
8184   if (!arg)
8185     arg = "";
8186   arg = skip_spaces (arg);
8187
8188   std::unique_ptr<solib_catchpoint> c (new solib_catchpoint ());
8189
8190   if (*arg != '\0')
8191     {
8192       c->compiled.reset (new compiled_regex (arg, REG_NOSUB,
8193                                              _("Invalid regexp")));
8194       c->regex = xstrdup (arg);
8195     }
8196
8197   c->is_load = is_load;
8198   init_catchpoint (c.get (), gdbarch, is_temp, NULL,
8199                    &catch_solib_breakpoint_ops);
8200
8201   c->enable_state = enabled ? bp_enabled : bp_disabled;
8202
8203   install_breakpoint (0, std::move (c), 1);
8204 }
8205
8206 /* A helper function that does all the work for "catch load" and
8207    "catch unload".  */
8208
8209 static void
8210 catch_load_or_unload (const char *arg, int from_tty, int is_load,
8211                       struct cmd_list_element *command)
8212 {
8213   int tempflag;
8214   const int enabled = 1;
8215
8216   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8217
8218   add_solib_catchpoint (arg, is_load, tempflag, enabled);
8219 }
8220
8221 static void
8222 catch_load_command_1 (const char *arg, int from_tty,
8223                       struct cmd_list_element *command)
8224 {
8225   catch_load_or_unload (arg, from_tty, 1, command);
8226 }
8227
8228 static void
8229 catch_unload_command_1 (const char *arg, int from_tty,
8230                         struct cmd_list_element *command)
8231 {
8232   catch_load_or_unload (arg, from_tty, 0, command);
8233 }
8234
8235 /* Initialize a new breakpoint of the bp_catchpoint kind.  If TEMPFLAG
8236    is non-zero, then make the breakpoint temporary.  If COND_STRING is
8237    not NULL, then store it in the breakpoint.  OPS, if not NULL, is
8238    the breakpoint_ops structure associated to the catchpoint.  */
8239
8240 void
8241 init_catchpoint (struct breakpoint *b,
8242                  struct gdbarch *gdbarch, int tempflag,
8243                  const char *cond_string,
8244                  const struct breakpoint_ops *ops)
8245 {
8246   symtab_and_line sal;
8247   sal.pspace = current_program_space;
8248
8249   init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
8250
8251   b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
8252   b->disposition = tempflag ? disp_del : disp_donttouch;
8253 }
8254
8255 void
8256 install_breakpoint (int internal, std::unique_ptr<breakpoint> &&arg, int update_gll)
8257 {
8258   breakpoint *b = add_to_breakpoint_chain (std::move (arg));
8259   set_breakpoint_number (internal, b);
8260   if (is_tracepoint (b))
8261     set_tracepoint_count (breakpoint_count);
8262   if (!internal)
8263     mention (b);
8264   observer_notify_breakpoint_created (b);
8265
8266   if (update_gll)
8267     update_global_location_list (UGLL_MAY_INSERT);
8268 }
8269
8270 static void
8271 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
8272                                     int tempflag, const char *cond_string,
8273                                     const struct breakpoint_ops *ops)
8274 {
8275   std::unique_ptr<fork_catchpoint> c (new fork_catchpoint ());
8276
8277   init_catchpoint (c.get (), gdbarch, tempflag, cond_string, ops);
8278
8279   c->forked_inferior_pid = null_ptid;
8280
8281   install_breakpoint (0, std::move (c), 1);
8282 }
8283
8284 /* Exec catchpoints.  */
8285
8286 /* An instance of this type is used to represent an exec catchpoint.
8287    A breakpoint is really of this type iff its ops pointer points to
8288    CATCH_EXEC_BREAKPOINT_OPS.  */
8289
8290 struct exec_catchpoint : public breakpoint
8291 {
8292   ~exec_catchpoint () override;
8293
8294   /* Filename of a program whose exec triggered this catchpoint.
8295      This field is only valid immediately after this catchpoint has
8296      triggered.  */
8297   char *exec_pathname;
8298 };
8299
8300 /* Exec catchpoint destructor.  */
8301
8302 exec_catchpoint::~exec_catchpoint ()
8303 {
8304   xfree (this->exec_pathname);
8305 }
8306
8307 static int
8308 insert_catch_exec (struct bp_location *bl)
8309 {
8310   return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid));
8311 }
8312
8313 static int
8314 remove_catch_exec (struct bp_location *bl, enum remove_bp_reason reason)
8315 {
8316   return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid));
8317 }
8318
8319 static int
8320 breakpoint_hit_catch_exec (const struct bp_location *bl,
8321                            const address_space *aspace, CORE_ADDR bp_addr,
8322                            const struct target_waitstatus *ws)
8323 {
8324   struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8325
8326   if (ws->kind != TARGET_WAITKIND_EXECD)
8327     return 0;
8328
8329   c->exec_pathname = xstrdup (ws->value.execd_pathname);
8330   return 1;
8331 }
8332
8333 static enum print_stop_action
8334 print_it_catch_exec (bpstat bs)
8335 {
8336   struct ui_out *uiout = current_uiout;
8337   struct breakpoint *b = bs->breakpoint_at;
8338   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8339
8340   annotate_catchpoint (b->number);
8341   maybe_print_thread_hit_breakpoint (uiout);
8342   if (b->disposition == disp_del)
8343     uiout->text ("Temporary catchpoint ");
8344   else
8345     uiout->text ("Catchpoint ");
8346   if (uiout->is_mi_like_p ())
8347     {
8348       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC));
8349       uiout->field_string ("disp", bpdisp_text (b->disposition));
8350     }
8351   uiout->field_int ("bkptno", b->number);
8352   uiout->text (" (exec'd ");
8353   uiout->field_string ("new-exec", c->exec_pathname);
8354   uiout->text ("), ");
8355
8356   return PRINT_SRC_AND_LOC;
8357 }
8358
8359 static void
8360 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
8361 {
8362   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8363   struct value_print_options opts;
8364   struct ui_out *uiout = current_uiout;
8365
8366   get_user_print_options (&opts);
8367
8368   /* Field 4, the address, is omitted (which makes the columns
8369      not line up too nicely with the headers, but the effect
8370      is relatively readable).  */
8371   if (opts.addressprint)
8372     uiout->field_skip ("addr");
8373   annotate_field (5);
8374   uiout->text ("exec");
8375   if (c->exec_pathname != NULL)
8376     {
8377       uiout->text (", program \"");
8378       uiout->field_string ("what", c->exec_pathname);
8379       uiout->text ("\" ");
8380     }
8381
8382   if (uiout->is_mi_like_p ())
8383     uiout->field_string ("catch-type", "exec");
8384 }
8385
8386 static void
8387 print_mention_catch_exec (struct breakpoint *b)
8388 {
8389   printf_filtered (_("Catchpoint %d (exec)"), b->number);
8390 }
8391
8392 /* Implement the "print_recreate" breakpoint_ops method for exec
8393    catchpoints.  */
8394
8395 static void
8396 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8397 {
8398   fprintf_unfiltered (fp, "catch exec");
8399   print_recreate_thread (b, fp);
8400 }
8401
8402 static struct breakpoint_ops catch_exec_breakpoint_ops;
8403
8404 static int
8405 hw_breakpoint_used_count (void)
8406 {
8407   int i = 0;
8408   struct breakpoint *b;
8409   struct bp_location *bl;
8410
8411   ALL_BREAKPOINTS (b)
8412   {
8413     if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
8414       for (bl = b->loc; bl; bl = bl->next)
8415         {
8416           /* Special types of hardware breakpoints may use more than
8417              one register.  */
8418           i += b->ops->resources_needed (bl);
8419         }
8420   }
8421
8422   return i;
8423 }
8424
8425 /* Returns the resources B would use if it were a hardware
8426    watchpoint.  */
8427
8428 static int
8429 hw_watchpoint_use_count (struct breakpoint *b)
8430 {
8431   int i = 0;
8432   struct bp_location *bl;
8433
8434   if (!breakpoint_enabled (b))
8435     return 0;
8436
8437   for (bl = b->loc; bl; bl = bl->next)
8438     {
8439       /* Special types of hardware watchpoints may use more than
8440          one register.  */
8441       i += b->ops->resources_needed (bl);
8442     }
8443
8444   return i;
8445 }
8446
8447 /* Returns the sum the used resources of all hardware watchpoints of
8448    type TYPE in the breakpoints list.  Also returns in OTHER_TYPE_USED
8449    the sum of the used resources of all hardware watchpoints of other
8450    types _not_ TYPE.  */
8451
8452 static int
8453 hw_watchpoint_used_count_others (struct breakpoint *except,
8454                                  enum bptype type, int *other_type_used)
8455 {
8456   int i = 0;
8457   struct breakpoint *b;
8458
8459   *other_type_used = 0;
8460   ALL_BREAKPOINTS (b)
8461     {
8462       if (b == except)
8463         continue;
8464       if (!breakpoint_enabled (b))
8465         continue;
8466
8467       if (b->type == type)
8468         i += hw_watchpoint_use_count (b);
8469       else if (is_hardware_watchpoint (b))
8470         *other_type_used = 1;
8471     }
8472
8473   return i;
8474 }
8475
8476 void
8477 disable_watchpoints_before_interactive_call_start (void)
8478 {
8479   struct breakpoint *b;
8480
8481   ALL_BREAKPOINTS (b)
8482   {
8483     if (is_watchpoint (b) && breakpoint_enabled (b))
8484       {
8485         b->enable_state = bp_call_disabled;
8486         update_global_location_list (UGLL_DONT_INSERT);
8487       }
8488   }
8489 }
8490
8491 void
8492 enable_watchpoints_after_interactive_call_stop (void)
8493 {
8494   struct breakpoint *b;
8495
8496   ALL_BREAKPOINTS (b)
8497   {
8498     if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
8499       {
8500         b->enable_state = bp_enabled;
8501         update_global_location_list (UGLL_MAY_INSERT);
8502       }
8503   }
8504 }
8505
8506 void
8507 disable_breakpoints_before_startup (void)
8508 {
8509   current_program_space->executing_startup = 1;
8510   update_global_location_list (UGLL_DONT_INSERT);
8511 }
8512
8513 void
8514 enable_breakpoints_after_startup (void)
8515 {
8516   current_program_space->executing_startup = 0;
8517   breakpoint_re_set ();
8518 }
8519
8520 /* Create a new single-step breakpoint for thread THREAD, with no
8521    locations.  */
8522
8523 static struct breakpoint *
8524 new_single_step_breakpoint (int thread, struct gdbarch *gdbarch)
8525 {
8526   std::unique_ptr<breakpoint> b (new breakpoint ());
8527
8528   init_raw_breakpoint_without_location (b.get (), gdbarch, bp_single_step,
8529                                         &momentary_breakpoint_ops);
8530
8531   b->disposition = disp_donttouch;
8532   b->frame_id = null_frame_id;
8533
8534   b->thread = thread;
8535   gdb_assert (b->thread != 0);
8536
8537   return add_to_breakpoint_chain (std::move (b));
8538 }
8539
8540 /* Set a momentary breakpoint of type TYPE at address specified by
8541    SAL.  If FRAME_ID is valid, the breakpoint is restricted to that
8542    frame.  */
8543
8544 breakpoint_up
8545 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8546                           struct frame_id frame_id, enum bptype type)
8547 {
8548   struct breakpoint *b;
8549
8550   /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8551      tail-called one.  */
8552   gdb_assert (!frame_id_artificial_p (frame_id));
8553
8554   b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
8555   b->enable_state = bp_enabled;
8556   b->disposition = disp_donttouch;
8557   b->frame_id = frame_id;
8558
8559   /* If we're debugging a multi-threaded program, then we want
8560      momentary breakpoints to be active in only a single thread of
8561      control.  */
8562   if (in_thread_list (inferior_ptid))
8563     b->thread = ptid_to_global_thread_id (inferior_ptid);
8564
8565   update_global_location_list_nothrow (UGLL_MAY_INSERT);
8566
8567   return breakpoint_up (b);
8568 }
8569
8570 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8571    The new breakpoint will have type TYPE, use OPS as its
8572    breakpoint_ops, and will set enabled to LOC_ENABLED.  */
8573
8574 static struct breakpoint *
8575 momentary_breakpoint_from_master (struct breakpoint *orig,
8576                                   enum bptype type,
8577                                   const struct breakpoint_ops *ops,
8578                                   int loc_enabled)
8579 {
8580   struct breakpoint *copy;
8581
8582   copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
8583   copy->loc = allocate_bp_location (copy);
8584   set_breakpoint_location_function (copy->loc, 1);
8585
8586   copy->loc->gdbarch = orig->loc->gdbarch;
8587   copy->loc->requested_address = orig->loc->requested_address;
8588   copy->loc->address = orig->loc->address;
8589   copy->loc->section = orig->loc->section;
8590   copy->loc->pspace = orig->loc->pspace;
8591   copy->loc->probe = orig->loc->probe;
8592   copy->loc->line_number = orig->loc->line_number;
8593   copy->loc->symtab = orig->loc->symtab;
8594   copy->loc->enabled = loc_enabled;
8595   copy->frame_id = orig->frame_id;
8596   copy->thread = orig->thread;
8597   copy->pspace = orig->pspace;
8598
8599   copy->enable_state = bp_enabled;
8600   copy->disposition = disp_donttouch;
8601   copy->number = internal_breakpoint_number--;
8602
8603   update_global_location_list_nothrow (UGLL_DONT_INSERT);
8604   return copy;
8605 }
8606
8607 /* Make a deep copy of momentary breakpoint ORIG.  Returns NULL if
8608    ORIG is NULL.  */
8609
8610 struct breakpoint *
8611 clone_momentary_breakpoint (struct breakpoint *orig)
8612 {
8613   /* If there's nothing to clone, then return nothing.  */
8614   if (orig == NULL)
8615     return NULL;
8616
8617   return momentary_breakpoint_from_master (orig, orig->type, orig->ops, 0);
8618 }
8619
8620 breakpoint_up
8621 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8622                                 enum bptype type)
8623 {
8624   struct symtab_and_line sal;
8625
8626   sal = find_pc_line (pc, 0);
8627   sal.pc = pc;
8628   sal.section = find_pc_overlay (pc);
8629   sal.explicit_pc = 1;
8630
8631   return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
8632 }
8633 \f
8634
8635 /* Tell the user we have just set a breakpoint B.  */
8636
8637 static void
8638 mention (struct breakpoint *b)
8639 {
8640   b->ops->print_mention (b);
8641   if (current_uiout->is_mi_like_p ())
8642     return;
8643   printf_filtered ("\n");
8644 }
8645 \f
8646
8647 static int bp_loc_is_permanent (struct bp_location *loc);
8648
8649 static struct bp_location *
8650 add_location_to_breakpoint (struct breakpoint *b,
8651                             const struct symtab_and_line *sal)
8652 {
8653   struct bp_location *loc, **tmp;
8654   CORE_ADDR adjusted_address;
8655   struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
8656
8657   if (loc_gdbarch == NULL)
8658     loc_gdbarch = b->gdbarch;
8659
8660   /* Adjust the breakpoint's address prior to allocating a location.
8661      Once we call allocate_bp_location(), that mostly uninitialized
8662      location will be placed on the location chain.  Adjustment of the
8663      breakpoint may cause target_read_memory() to be called and we do
8664      not want its scan of the location chain to find a breakpoint and
8665      location that's only been partially initialized.  */
8666   adjusted_address = adjust_breakpoint_address (loc_gdbarch,
8667                                                 sal->pc, b->type);
8668
8669   /* Sort the locations by their ADDRESS.  */
8670   loc = allocate_bp_location (b);
8671   for (tmp = &(b->loc); *tmp != NULL && (*tmp)->address <= adjusted_address;
8672        tmp = &((*tmp)->next))
8673     ;
8674   loc->next = *tmp;
8675   *tmp = loc;
8676
8677   loc->requested_address = sal->pc;
8678   loc->address = adjusted_address;
8679   loc->pspace = sal->pspace;
8680   loc->probe.prob = sal->prob;
8681   loc->probe.objfile = sal->objfile;
8682   gdb_assert (loc->pspace != NULL);
8683   loc->section = sal->section;
8684   loc->gdbarch = loc_gdbarch;
8685   loc->line_number = sal->line;
8686   loc->symtab = sal->symtab;
8687   loc->symbol = sal->symbol;
8688
8689   set_breakpoint_location_function (loc,
8690                                     sal->explicit_pc || sal->explicit_line);
8691
8692   /* While by definition, permanent breakpoints are already present in the
8693      code, we don't mark the location as inserted.  Normally one would expect
8694      that GDB could rely on that breakpoint instruction to stop the program,
8695      thus removing the need to insert its own breakpoint, except that executing
8696      the breakpoint instruction can kill the target instead of reporting a
8697      SIGTRAP.  E.g., on SPARC, when interrupts are disabled, executing the
8698      instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8699      with "Trap 0x02 while interrupts disabled, Error state".  Letting the
8700      breakpoint be inserted normally results in QEMU knowing about the GDB
8701      breakpoint, and thus trap before the breakpoint instruction is executed.
8702      (If GDB later needs to continue execution past the permanent breakpoint,
8703      it manually increments the PC, thus avoiding executing the breakpoint
8704      instruction.)  */
8705   if (bp_loc_is_permanent (loc))
8706     loc->permanent = 1;
8707
8708   return loc;
8709 }
8710 \f
8711
8712 /* See breakpoint.h.  */
8713
8714 int
8715 program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address)
8716 {
8717   int len;
8718   CORE_ADDR addr;
8719   const gdb_byte *bpoint;
8720   gdb_byte *target_mem;
8721
8722   addr = address;
8723   bpoint = gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
8724
8725   /* Software breakpoints unsupported?  */
8726   if (bpoint == NULL)
8727     return 0;
8728
8729   target_mem = (gdb_byte *) alloca (len);
8730
8731   /* Enable the automatic memory restoration from breakpoints while
8732      we read the memory.  Otherwise we could say about our temporary
8733      breakpoints they are permanent.  */
8734   scoped_restore restore_memory
8735     = make_scoped_restore_show_memory_breakpoints (0);
8736
8737   if (target_read_memory (address, target_mem, len) == 0
8738       && memcmp (target_mem, bpoint, len) == 0)
8739     return 1;
8740
8741   return 0;
8742 }
8743
8744 /* Return 1 if LOC is pointing to a permanent breakpoint,
8745    return 0 otherwise.  */
8746
8747 static int
8748 bp_loc_is_permanent (struct bp_location *loc)
8749 {
8750   gdb_assert (loc != NULL);
8751
8752   /* If we have a catchpoint or a watchpoint, just return 0.  We should not
8753      attempt to read from the addresses the locations of these breakpoint types
8754      point to.  program_breakpoint_here_p, below, will attempt to read
8755      memory.  */
8756   if (!breakpoint_address_is_meaningful (loc->owner))
8757     return 0;
8758
8759   scoped_restore_current_pspace_and_thread restore_pspace_thread;
8760   switch_to_program_space_and_thread (loc->pspace);
8761   return program_breakpoint_here_p (loc->gdbarch, loc->address);
8762 }
8763
8764 /* Build a command list for the dprintf corresponding to the current
8765    settings of the dprintf style options.  */
8766
8767 static void
8768 update_dprintf_command_list (struct breakpoint *b)
8769 {
8770   char *dprintf_args = b->extra_string;
8771   char *printf_line = NULL;
8772
8773   if (!dprintf_args)
8774     return;
8775
8776   dprintf_args = skip_spaces (dprintf_args);
8777
8778   /* Allow a comma, as it may have terminated a location, but don't
8779      insist on it.  */
8780   if (*dprintf_args == ',')
8781     ++dprintf_args;
8782   dprintf_args = skip_spaces (dprintf_args);
8783
8784   if (*dprintf_args != '"')
8785     error (_("Bad format string, missing '\"'."));
8786
8787   if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
8788     printf_line = xstrprintf ("printf %s", dprintf_args);
8789   else if (strcmp (dprintf_style, dprintf_style_call) == 0)
8790     {
8791       if (!dprintf_function)
8792         error (_("No function supplied for dprintf call"));
8793
8794       if (dprintf_channel && strlen (dprintf_channel) > 0)
8795         printf_line = xstrprintf ("call (void) %s (%s,%s)",
8796                                   dprintf_function,
8797                                   dprintf_channel,
8798                                   dprintf_args);
8799       else
8800         printf_line = xstrprintf ("call (void) %s (%s)",
8801                                   dprintf_function,
8802                                   dprintf_args);
8803     }
8804   else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
8805     {
8806       if (target_can_run_breakpoint_commands ())
8807         printf_line = xstrprintf ("agent-printf %s", dprintf_args);
8808       else
8809         {
8810           warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8811           printf_line = xstrprintf ("printf %s", dprintf_args);
8812         }
8813     }
8814   else
8815     internal_error (__FILE__, __LINE__,
8816                     _("Invalid dprintf style."));
8817
8818   gdb_assert (printf_line != NULL);
8819   /* Manufacture a printf sequence.  */
8820   {
8821     struct command_line *printf_cmd_line = XNEW (struct command_line);
8822
8823     printf_cmd_line->control_type = simple_control;
8824     printf_cmd_line->body_count = 0;
8825     printf_cmd_line->body_list = NULL;
8826     printf_cmd_line->next = NULL;
8827     printf_cmd_line->line = printf_line;
8828
8829     breakpoint_set_commands (b, command_line_up (printf_cmd_line));
8830   }
8831 }
8832
8833 /* Update all dprintf commands, making their command lists reflect
8834    current style settings.  */
8835
8836 static void
8837 update_dprintf_commands (const char *args, int from_tty,
8838                          struct cmd_list_element *c)
8839 {
8840   struct breakpoint *b;
8841
8842   ALL_BREAKPOINTS (b)
8843     {
8844       if (b->type == bp_dprintf)
8845         update_dprintf_command_list (b);
8846     }
8847 }
8848
8849 /* Create a breakpoint with SAL as location.  Use LOCATION
8850    as a description of the location, and COND_STRING
8851    as condition expression.  If LOCATION is NULL then create an
8852    "address location" from the address in the SAL.  */
8853
8854 static void
8855 init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
8856                      gdb::array_view<const symtab_and_line> sals,
8857                      event_location_up &&location,
8858                      gdb::unique_xmalloc_ptr<char> filter,
8859                      gdb::unique_xmalloc_ptr<char> cond_string,
8860                      gdb::unique_xmalloc_ptr<char> extra_string,
8861                      enum bptype type, enum bpdisp disposition,
8862                      int thread, int task, int ignore_count,
8863                      const struct breakpoint_ops *ops, int from_tty,
8864                      int enabled, int internal, unsigned flags,
8865                      int display_canonical)
8866 {
8867   int i;
8868
8869   if (type == bp_hardware_breakpoint)
8870     {
8871       int target_resources_ok;
8872
8873       i = hw_breakpoint_used_count ();
8874       target_resources_ok =
8875         target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
8876                                             i + 1, 0);
8877       if (target_resources_ok == 0)
8878         error (_("No hardware breakpoint support in the target."));
8879       else if (target_resources_ok < 0)
8880         error (_("Hardware breakpoints used exceeds limit."));
8881     }
8882
8883   gdb_assert (!sals.empty ());
8884
8885   for (const auto &sal : sals)
8886     {
8887       struct bp_location *loc;
8888
8889       if (from_tty)
8890         {
8891           struct gdbarch *loc_gdbarch = get_sal_arch (sal);
8892           if (!loc_gdbarch)
8893             loc_gdbarch = gdbarch;
8894
8895           describe_other_breakpoints (loc_gdbarch,
8896                                       sal.pspace, sal.pc, sal.section, thread);
8897         }
8898
8899       if (&sal == &sals[0])
8900         {
8901           init_raw_breakpoint (b, gdbarch, sal, type, ops);
8902           b->thread = thread;
8903           b->task = task;
8904
8905           b->cond_string = cond_string.release ();
8906           b->extra_string = extra_string.release ();
8907           b->ignore_count = ignore_count;
8908           b->enable_state = enabled ? bp_enabled : bp_disabled;
8909           b->disposition = disposition;
8910
8911           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8912             b->loc->inserted = 1;
8913
8914           if (type == bp_static_tracepoint)
8915             {
8916               struct tracepoint *t = (struct tracepoint *) b;
8917               struct static_tracepoint_marker marker;
8918
8919               if (strace_marker_p (b))
8920                 {
8921                   /* We already know the marker exists, otherwise, we
8922                      wouldn't see a sal for it.  */
8923                   const char *p
8924                     = &event_location_to_string (b->location.get ())[3];
8925                   const char *endp;
8926                   char *marker_str;
8927
8928                   p = skip_spaces (p);
8929
8930                   endp = skip_to_space (p);
8931
8932                   marker_str = savestring (p, endp - p);
8933                   t->static_trace_marker_id = marker_str;
8934
8935                   printf_filtered (_("Probed static tracepoint "
8936                                      "marker \"%s\"\n"),
8937                                    t->static_trace_marker_id);
8938                 }
8939               else if (target_static_tracepoint_marker_at (sal.pc, &marker))
8940                 {
8941                   t->static_trace_marker_id = xstrdup (marker.str_id);
8942                   release_static_tracepoint_marker (&marker);
8943
8944                   printf_filtered (_("Probed static tracepoint "
8945                                      "marker \"%s\"\n"),
8946                                    t->static_trace_marker_id);
8947                 }
8948               else
8949                 warning (_("Couldn't determine the static "
8950                            "tracepoint marker to probe"));
8951             }
8952
8953           loc = b->loc;
8954         }
8955       else
8956         {
8957           loc = add_location_to_breakpoint (b, &sal);
8958           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8959             loc->inserted = 1;
8960         }
8961
8962       if (b->cond_string)
8963         {
8964           const char *arg = b->cond_string;
8965
8966           loc->cond = parse_exp_1 (&arg, loc->address,
8967                                    block_for_pc (loc->address), 0);
8968           if (*arg)
8969               error (_("Garbage '%s' follows condition"), arg);
8970         }
8971
8972       /* Dynamic printf requires and uses additional arguments on the
8973          command line, otherwise it's an error.  */
8974       if (type == bp_dprintf)
8975         {
8976           if (b->extra_string)
8977             update_dprintf_command_list (b);
8978           else
8979             error (_("Format string required"));
8980         }
8981       else if (b->extra_string)
8982         error (_("Garbage '%s' at end of command"), b->extra_string);
8983     }
8984
8985   b->display_canonical = display_canonical;
8986   if (location != NULL)
8987     b->location = std::move (location);
8988   else
8989     b->location = new_address_location (b->loc->address, NULL, 0);
8990   b->filter = filter.release ();
8991 }
8992
8993 static void
8994 create_breakpoint_sal (struct gdbarch *gdbarch,
8995                        gdb::array_view<const symtab_and_line> sals,
8996                        event_location_up &&location,
8997                        gdb::unique_xmalloc_ptr<char> filter,
8998                        gdb::unique_xmalloc_ptr<char> cond_string,
8999                        gdb::unique_xmalloc_ptr<char> extra_string,
9000                        enum bptype type, enum bpdisp disposition,
9001                        int thread, int task, int ignore_count,
9002                        const struct breakpoint_ops *ops, int from_tty,
9003                        int enabled, int internal, unsigned flags,
9004                        int display_canonical)
9005 {
9006   std::unique_ptr<breakpoint> b = new_breakpoint_from_type (type);
9007
9008   init_breakpoint_sal (b.get (), gdbarch,
9009                        sals, std::move (location),
9010                        std::move (filter),
9011                        std::move (cond_string),
9012                        std::move (extra_string),
9013                        type, disposition,
9014                        thread, task, ignore_count,
9015                        ops, from_tty,
9016                        enabled, internal, flags,
9017                        display_canonical);
9018
9019   install_breakpoint (internal, std::move (b), 0);
9020 }
9021
9022 /* Add SALS.nelts breakpoints to the breakpoint table.  For each
9023    SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9024    value.  COND_STRING, if not NULL, specified the condition to be
9025    used for all breakpoints.  Essentially the only case where
9026    SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9027    function.  In that case, it's still not possible to specify
9028    separate conditions for different overloaded functions, so
9029    we take just a single condition string.
9030    
9031    NOTE: If the function succeeds, the caller is expected to cleanup
9032    the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9033    array contents).  If the function fails (error() is called), the
9034    caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9035    COND and SALS arrays and each of those arrays contents.  */
9036
9037 static void
9038 create_breakpoints_sal (struct gdbarch *gdbarch,
9039                         struct linespec_result *canonical,
9040                         gdb::unique_xmalloc_ptr<char> cond_string,
9041                         gdb::unique_xmalloc_ptr<char> extra_string,
9042                         enum bptype type, enum bpdisp disposition,
9043                         int thread, int task, int ignore_count,
9044                         const struct breakpoint_ops *ops, int from_tty,
9045                         int enabled, int internal, unsigned flags)
9046 {
9047   if (canonical->pre_expanded)
9048     gdb_assert (canonical->lsals.size () == 1);
9049
9050   for (const auto &lsal : canonical->lsals)
9051     {
9052       /* Note that 'location' can be NULL in the case of a plain
9053          'break', without arguments.  */
9054       event_location_up location
9055         = (canonical->location != NULL
9056            ? copy_event_location (canonical->location.get ()) : NULL);
9057       gdb::unique_xmalloc_ptr<char> filter_string
9058         (lsal.canonical != NULL ? xstrdup (lsal.canonical) : NULL);
9059
9060       create_breakpoint_sal (gdbarch, lsal.sals,
9061                              std::move (location),
9062                              std::move (filter_string),
9063                              std::move (cond_string),
9064                              std::move (extra_string),
9065                              type, disposition,
9066                              thread, task, ignore_count, ops,
9067                              from_tty, enabled, internal, flags,
9068                              canonical->special_display);
9069     }
9070 }
9071
9072 /* Parse LOCATION which is assumed to be a SAL specification possibly
9073    followed by conditionals.  On return, SALS contains an array of SAL
9074    addresses found.  LOCATION points to the end of the SAL (for
9075    linespec locations).
9076
9077    The array and the line spec strings are allocated on the heap, it is
9078    the caller's responsibility to free them.  */
9079
9080 static void
9081 parse_breakpoint_sals (const struct event_location *location,
9082                        struct linespec_result *canonical)
9083 {
9084   struct symtab_and_line cursal;
9085
9086   if (event_location_type (location) == LINESPEC_LOCATION)
9087     {
9088       const char *spec = get_linespec_location (location)->spec_string;
9089
9090       if (spec == NULL)
9091         {
9092           /* The last displayed codepoint, if it's valid, is our default
9093              breakpoint address.  */
9094           if (last_displayed_sal_is_valid ())
9095             {
9096               /* Set sal's pspace, pc, symtab, and line to the values
9097                  corresponding to the last call to print_frame_info.
9098                  Be sure to reinitialize LINE with NOTCURRENT == 0
9099                  as the breakpoint line number is inappropriate otherwise.
9100                  find_pc_line would adjust PC, re-set it back.  */
9101               symtab_and_line sal = get_last_displayed_sal ();
9102               CORE_ADDR pc = sal.pc;
9103
9104               sal = find_pc_line (pc, 0);
9105
9106               /* "break" without arguments is equivalent to "break *PC"
9107                  where PC is the last displayed codepoint's address.  So
9108                  make sure to set sal.explicit_pc to prevent GDB from
9109                  trying to expand the list of sals to include all other
9110                  instances with the same symtab and line.  */
9111               sal.pc = pc;
9112               sal.explicit_pc = 1;
9113
9114               struct linespec_sals lsal;
9115               lsal.sals = {sal};
9116               lsal.canonical = NULL;
9117
9118               canonical->lsals.push_back (std::move (lsal));
9119               return;
9120             }
9121           else
9122             error (_("No default breakpoint address now."));
9123         }
9124     }
9125
9126   /* Force almost all breakpoints to be in terms of the
9127      current_source_symtab (which is decode_line_1's default).
9128      This should produce the results we want almost all of the
9129      time while leaving default_breakpoint_* alone.
9130
9131      ObjC: However, don't match an Objective-C method name which
9132      may have a '+' or '-' succeeded by a '['.  */
9133   cursal = get_current_source_symtab_and_line ();
9134   if (last_displayed_sal_is_valid ())
9135     {
9136       const char *spec = NULL;
9137
9138       if (event_location_type (location) == LINESPEC_LOCATION)
9139         spec = get_linespec_location (location)->spec_string;
9140
9141       if (!cursal.symtab
9142           || (spec != NULL
9143               && strchr ("+-", spec[0]) != NULL
9144               && spec[1] != '['))
9145         {
9146           decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9147                             get_last_displayed_symtab (),
9148                             get_last_displayed_line (),
9149                             canonical, NULL, NULL);
9150           return;
9151         }
9152     }
9153
9154   decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
9155                     cursal.symtab, cursal.line, canonical, NULL, NULL);
9156 }
9157
9158
9159 /* Convert each SAL into a real PC.  Verify that the PC can be
9160    inserted as a breakpoint.  If it can't throw an error.  */
9161
9162 static void
9163 breakpoint_sals_to_pc (std::vector<symtab_and_line> &sals)
9164 {    
9165   for (auto &sal : sals)
9166     resolve_sal_pc (&sal);
9167 }
9168
9169 /* Fast tracepoints may have restrictions on valid locations.  For
9170    instance, a fast tracepoint using a jump instead of a trap will
9171    likely have to overwrite more bytes than a trap would, and so can
9172    only be placed where the instruction is longer than the jump, or a
9173    multi-instruction sequence does not have a jump into the middle of
9174    it, etc.  */
9175
9176 static void
9177 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9178                             gdb::array_view<const symtab_and_line> sals)
9179 {
9180   int rslt;
9181   char *msg;
9182   struct cleanup *old_chain;
9183
9184   for (const auto &sal : sals)
9185     {
9186       struct gdbarch *sarch;
9187
9188       sarch = get_sal_arch (sal);
9189       /* We fall back to GDBARCH if there is no architecture
9190          associated with SAL.  */
9191       if (sarch == NULL)
9192         sarch = gdbarch;
9193       rslt = gdbarch_fast_tracepoint_valid_at (sarch, sal.pc, &msg);
9194       old_chain = make_cleanup (xfree, msg);
9195
9196       if (!rslt)
9197         error (_("May not have a fast tracepoint at %s%s"),
9198                paddress (sarch, sal.pc), (msg ? msg : ""));
9199
9200       do_cleanups (old_chain);
9201     }
9202 }
9203
9204 /* Given TOK, a string specification of condition and thread, as
9205    accepted by the 'break' command, extract the condition
9206    string and thread number and set *COND_STRING and *THREAD.
9207    PC identifies the context at which the condition should be parsed.
9208    If no condition is found, *COND_STRING is set to NULL.
9209    If no thread is found, *THREAD is set to -1.  */
9210
9211 static void
9212 find_condition_and_thread (const char *tok, CORE_ADDR pc,
9213                            char **cond_string, int *thread, int *task,
9214                            char **rest)
9215 {
9216   *cond_string = NULL;
9217   *thread = -1;
9218   *task = 0;
9219   *rest = NULL;
9220
9221   while (tok && *tok)
9222     {
9223       const char *end_tok;
9224       int toklen;
9225       const char *cond_start = NULL;
9226       const char *cond_end = NULL;
9227
9228       tok = skip_spaces (tok);
9229
9230       if ((*tok == '"' || *tok == ',') && rest)
9231         {
9232           *rest = savestring (tok, strlen (tok));
9233           return;
9234         }
9235
9236       end_tok = skip_to_space (tok);
9237
9238       toklen = end_tok - tok;
9239
9240       if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9241         {
9242           tok = cond_start = end_tok + 1;
9243           parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
9244           cond_end = tok;
9245           *cond_string = savestring (cond_start, cond_end - cond_start);
9246         }
9247       else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9248         {
9249           const char *tmptok;
9250           struct thread_info *thr;
9251
9252           tok = end_tok + 1;
9253           thr = parse_thread_id (tok, &tmptok);
9254           if (tok == tmptok)
9255             error (_("Junk after thread keyword."));
9256           *thread = thr->global_num;
9257           tok = tmptok;
9258         }
9259       else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9260         {
9261           char *tmptok;
9262
9263           tok = end_tok + 1;
9264           *task = strtol (tok, &tmptok, 0);
9265           if (tok == tmptok)
9266             error (_("Junk after task keyword."));
9267           if (!valid_task_id (*task))
9268             error (_("Unknown task %d."), *task);
9269           tok = tmptok;
9270         }
9271       else if (rest)
9272         {
9273           *rest = savestring (tok, strlen (tok));
9274           return;
9275         }
9276       else
9277         error (_("Junk at end of arguments."));
9278     }
9279 }
9280
9281 /* Decode a static tracepoint marker spec.  */
9282
9283 static std::vector<symtab_and_line>
9284 decode_static_tracepoint_spec (const char **arg_p)
9285 {
9286   VEC(static_tracepoint_marker_p) *markers = NULL;
9287   const char *p = &(*arg_p)[3];
9288   const char *endp;
9289   int i;
9290
9291   p = skip_spaces (p);
9292
9293   endp = skip_to_space (p);
9294
9295   std::string marker_str (p, endp - p);
9296
9297   markers = target_static_tracepoint_markers_by_strid (marker_str.c_str ());
9298   if (VEC_empty(static_tracepoint_marker_p, markers))
9299     error (_("No known static tracepoint marker named %s"),
9300            marker_str.c_str ());
9301
9302   std::vector<symtab_and_line> sals;
9303   sals.reserve (VEC_length(static_tracepoint_marker_p, markers));
9304
9305   for (i = 0; i < VEC_length(static_tracepoint_marker_p, markers); i++)
9306     {
9307       struct static_tracepoint_marker *marker;
9308
9309       marker = VEC_index (static_tracepoint_marker_p, markers, i);
9310
9311       symtab_and_line sal = find_pc_line (marker->address, 0);
9312       sal.pc = marker->address;
9313       sals.push_back (sal);
9314
9315       release_static_tracepoint_marker (marker);
9316     }
9317
9318   *arg_p = endp;
9319   return sals;
9320 }
9321
9322 /* See breakpoint.h.  */
9323
9324 int
9325 create_breakpoint (struct gdbarch *gdbarch,
9326                    const struct event_location *location,
9327                    const char *cond_string,
9328                    int thread, const char *extra_string,
9329                    int parse_extra,
9330                    int tempflag, enum bptype type_wanted,
9331                    int ignore_count,
9332                    enum auto_boolean pending_break_support,
9333                    const struct breakpoint_ops *ops,
9334                    int from_tty, int enabled, int internal,
9335                    unsigned flags)
9336 {
9337   struct linespec_result canonical;
9338   struct cleanup *bkpt_chain = NULL;
9339   int pending = 0;
9340   int task = 0;
9341   int prev_bkpt_count = breakpoint_count;
9342
9343   gdb_assert (ops != NULL);
9344
9345   /* If extra_string isn't useful, set it to NULL.  */
9346   if (extra_string != NULL && *extra_string == '\0')
9347     extra_string = NULL;
9348
9349   TRY
9350     {
9351       ops->create_sals_from_location (location, &canonical, type_wanted);
9352     }
9353   CATCH (e, RETURN_MASK_ERROR)
9354     {
9355       /* If caller is interested in rc value from parse, set
9356          value.  */
9357       if (e.error == NOT_FOUND_ERROR)
9358         {
9359           /* If pending breakpoint support is turned off, throw
9360              error.  */
9361
9362           if (pending_break_support == AUTO_BOOLEAN_FALSE)
9363             throw_exception (e);
9364
9365           exception_print (gdb_stderr, e);
9366
9367           /* If pending breakpoint support is auto query and the user
9368              selects no, then simply return the error code.  */
9369           if (pending_break_support == AUTO_BOOLEAN_AUTO
9370               && !nquery (_("Make %s pending on future shared library load? "),
9371                           bptype_string (type_wanted)))
9372             return 0;
9373
9374           /* At this point, either the user was queried about setting
9375              a pending breakpoint and selected yes, or pending
9376              breakpoint behavior is on and thus a pending breakpoint
9377              is defaulted on behalf of the user.  */
9378           pending = 1;
9379         }
9380       else
9381         throw_exception (e);
9382     }
9383   END_CATCH
9384
9385   if (!pending && canonical.lsals.empty ())
9386     return 0;
9387
9388   /* ----------------------------- SNIP -----------------------------
9389      Anything added to the cleanup chain beyond this point is assumed
9390      to be part of a breakpoint.  If the breakpoint create succeeds
9391      then the memory is not reclaimed.  */
9392   bkpt_chain = make_cleanup (null_cleanup, 0);
9393
9394   /* Resolve all line numbers to PC's and verify that the addresses
9395      are ok for the target.  */
9396   if (!pending)
9397     {
9398       for (auto &lsal : canonical.lsals)
9399         breakpoint_sals_to_pc (lsal.sals);
9400     }
9401
9402   /* Fast tracepoints may have additional restrictions on location.  */
9403   if (!pending && type_wanted == bp_fast_tracepoint)
9404     {
9405       for (const auto &lsal : canonical.lsals)
9406         check_fast_tracepoint_sals (gdbarch, lsal.sals);
9407     }
9408
9409   /* Verify that condition can be parsed, before setting any
9410      breakpoints.  Allocate a separate condition expression for each
9411      breakpoint.  */
9412   if (!pending)
9413     {
9414       gdb::unique_xmalloc_ptr<char> cond_string_copy;
9415       gdb::unique_xmalloc_ptr<char> extra_string_copy;
9416
9417       if (parse_extra)
9418         {
9419           char *rest;
9420           char *cond;
9421
9422           const linespec_sals &lsal = canonical.lsals[0];
9423
9424           /* Here we only parse 'arg' to separate condition
9425              from thread number, so parsing in context of first
9426              sal is OK.  When setting the breakpoint we'll
9427              re-parse it in context of each sal.  */
9428
9429           find_condition_and_thread (extra_string, lsal.sals[0].pc,
9430                                      &cond, &thread, &task, &rest);
9431           cond_string_copy.reset (cond);
9432           extra_string_copy.reset (rest);
9433         }
9434       else
9435         {
9436           if (type_wanted != bp_dprintf
9437               && extra_string != NULL && *extra_string != '\0')
9438                 error (_("Garbage '%s' at end of location"), extra_string);
9439
9440           /* Create a private copy of condition string.  */
9441           if (cond_string)
9442             cond_string_copy.reset (xstrdup (cond_string));
9443           /* Create a private copy of any extra string.  */
9444           if (extra_string)
9445             extra_string_copy.reset (xstrdup (extra_string));
9446         }
9447
9448       ops->create_breakpoints_sal (gdbarch, &canonical,
9449                                    std::move (cond_string_copy),
9450                                    std::move (extra_string_copy),
9451                                    type_wanted,
9452                                    tempflag ? disp_del : disp_donttouch,
9453                                    thread, task, ignore_count, ops,
9454                                    from_tty, enabled, internal, flags);
9455     }
9456   else
9457     {
9458       std::unique_ptr <breakpoint> b = new_breakpoint_from_type (type_wanted);
9459
9460       init_raw_breakpoint_without_location (b.get (), gdbarch, type_wanted, ops);
9461       b->location = copy_event_location (location);
9462
9463       if (parse_extra)
9464         b->cond_string = NULL;
9465       else
9466         {
9467           /* Create a private copy of condition string.  */
9468           b->cond_string = cond_string != NULL ? xstrdup (cond_string) : NULL;
9469           b->thread = thread;
9470         }
9471
9472       /* Create a private copy of any extra string.  */
9473       b->extra_string = extra_string != NULL ? xstrdup (extra_string) : NULL;
9474       b->ignore_count = ignore_count;
9475       b->disposition = tempflag ? disp_del : disp_donttouch;
9476       b->condition_not_parsed = 1;
9477       b->enable_state = enabled ? bp_enabled : bp_disabled;
9478       if ((type_wanted != bp_breakpoint
9479            && type_wanted != bp_hardware_breakpoint) || thread != -1)
9480         b->pspace = current_program_space;
9481
9482       install_breakpoint (internal, std::move (b), 0);
9483     }
9484   
9485   if (canonical.lsals.size () > 1)
9486     {
9487       warning (_("Multiple breakpoints were set.\nUse the "
9488                  "\"delete\" command to delete unwanted breakpoints."));
9489       prev_breakpoint_count = prev_bkpt_count;
9490     }
9491
9492   /* That's it.  Discard the cleanups for data inserted into the
9493      breakpoint.  */
9494   discard_cleanups (bkpt_chain);
9495
9496   /* error call may happen here - have BKPT_CHAIN already discarded.  */
9497   update_global_location_list (UGLL_MAY_INSERT);
9498
9499   return 1;
9500 }
9501
9502 /* Set a breakpoint.
9503    ARG is a string describing breakpoint address,
9504    condition, and thread.
9505    FLAG specifies if a breakpoint is hardware on,
9506    and if breakpoint is temporary, using BP_HARDWARE_FLAG
9507    and BP_TEMPFLAG.  */
9508
9509 static void
9510 break_command_1 (const char *arg, int flag, int from_tty)
9511 {
9512   int tempflag = flag & BP_TEMPFLAG;
9513   enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9514                              ? bp_hardware_breakpoint
9515                              : bp_breakpoint);
9516   struct breakpoint_ops *ops;
9517
9518   event_location_up location = string_to_event_location (&arg, current_language);
9519
9520   /* Matching breakpoints on probes.  */
9521   if (location != NULL
9522       && event_location_type (location.get ()) == PROBE_LOCATION)
9523     ops = &bkpt_probe_breakpoint_ops;
9524   else
9525     ops = &bkpt_breakpoint_ops;
9526
9527   create_breakpoint (get_current_arch (),
9528                      location.get (),
9529                      NULL, 0, arg, 1 /* parse arg */,
9530                      tempflag, type_wanted,
9531                      0 /* Ignore count */,
9532                      pending_break_support,
9533                      ops,
9534                      from_tty,
9535                      1 /* enabled */,
9536                      0 /* internal */,
9537                      0);
9538 }
9539
9540 /* Helper function for break_command_1 and disassemble_command.  */
9541
9542 void
9543 resolve_sal_pc (struct symtab_and_line *sal)
9544 {
9545   CORE_ADDR pc;
9546
9547   if (sal->pc == 0 && sal->symtab != NULL)
9548     {
9549       if (!find_line_pc (sal->symtab, sal->line, &pc))
9550         error (_("No line %d in file \"%s\"."),
9551                sal->line, symtab_to_filename_for_display (sal->symtab));
9552       sal->pc = pc;
9553
9554       /* If this SAL corresponds to a breakpoint inserted using a line
9555          number, then skip the function prologue if necessary.  */
9556       if (sal->explicit_line)
9557         skip_prologue_sal (sal);
9558     }
9559
9560   if (sal->section == 0 && sal->symtab != NULL)
9561     {
9562       const struct blockvector *bv;
9563       const struct block *b;
9564       struct symbol *sym;
9565
9566       bv = blockvector_for_pc_sect (sal->pc, 0, &b,
9567                                     SYMTAB_COMPUNIT (sal->symtab));
9568       if (bv != NULL)
9569         {
9570           sym = block_linkage_function (b);
9571           if (sym != NULL)
9572             {
9573               fixup_symbol_section (sym, SYMTAB_OBJFILE (sal->symtab));
9574               sal->section = SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal->symtab),
9575                                                  sym);
9576             }
9577           else
9578             {
9579               /* It really is worthwhile to have the section, so we'll
9580                  just have to look harder. This case can be executed
9581                  if we have line numbers but no functions (as can
9582                  happen in assembly source).  */
9583
9584               scoped_restore_current_pspace_and_thread restore_pspace_thread;
9585               switch_to_program_space_and_thread (sal->pspace);
9586
9587               bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (sal->pc);
9588               if (msym.minsym)
9589                 sal->section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
9590             }
9591         }
9592     }
9593 }
9594
9595 void
9596 break_command (const char *arg, int from_tty)
9597 {
9598   break_command_1 (arg, 0, from_tty);
9599 }
9600
9601 void
9602 tbreak_command (const char *arg, int from_tty)
9603 {
9604   break_command_1 (arg, BP_TEMPFLAG, from_tty);
9605 }
9606
9607 static void
9608 hbreak_command (const char *arg, int from_tty)
9609 {
9610   break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
9611 }
9612
9613 static void
9614 thbreak_command (const char *arg, int from_tty)
9615 {
9616   break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
9617 }
9618
9619 static void
9620 stop_command (const char *arg, int from_tty)
9621 {
9622   printf_filtered (_("Specify the type of breakpoint to set.\n\
9623 Usage: stop in <function | address>\n\
9624        stop at <line>\n"));
9625 }
9626
9627 static void
9628 stopin_command (const char *arg, int from_tty)
9629 {
9630   int badInput = 0;
9631
9632   if (arg == (char *) NULL)
9633     badInput = 1;
9634   else if (*arg != '*')
9635     {
9636       const char *argptr = arg;
9637       int hasColon = 0;
9638
9639       /* Look for a ':'.  If this is a line number specification, then
9640          say it is bad, otherwise, it should be an address or
9641          function/method name.  */
9642       while (*argptr && !hasColon)
9643         {
9644           hasColon = (*argptr == ':');
9645           argptr++;
9646         }
9647
9648       if (hasColon)
9649         badInput = (*argptr != ':');    /* Not a class::method */
9650       else
9651         badInput = isdigit (*arg);      /* a simple line number */
9652     }
9653
9654   if (badInput)
9655     printf_filtered (_("Usage: stop in <function | address>\n"));
9656   else
9657     break_command_1 (arg, 0, from_tty);
9658 }
9659
9660 static void
9661 stopat_command (const char *arg, int from_tty)
9662 {
9663   int badInput = 0;
9664
9665   if (arg == (char *) NULL || *arg == '*')      /* no line number */
9666     badInput = 1;
9667   else
9668     {
9669       const char *argptr = arg;
9670       int hasColon = 0;
9671
9672       /* Look for a ':'.  If there is a '::' then get out, otherwise
9673          it is probably a line number.  */
9674       while (*argptr && !hasColon)
9675         {
9676           hasColon = (*argptr == ':');
9677           argptr++;
9678         }
9679
9680       if (hasColon)
9681         badInput = (*argptr == ':');    /* we have class::method */
9682       else
9683         badInput = !isdigit (*arg);     /* not a line number */
9684     }
9685
9686   if (badInput)
9687     printf_filtered (_("Usage: stop at <line>\n"));
9688   else
9689     break_command_1 (arg, 0, from_tty);
9690 }
9691
9692 /* The dynamic printf command is mostly like a regular breakpoint, but
9693    with a prewired command list consisting of a single output command,
9694    built from extra arguments supplied on the dprintf command
9695    line.  */
9696
9697 static void
9698 dprintf_command (const char *arg, int from_tty)
9699 {
9700   event_location_up location = string_to_event_location (&arg, current_language);
9701
9702   /* If non-NULL, ARG should have been advanced past the location;
9703      the next character must be ','.  */
9704   if (arg != NULL)
9705     {
9706       if (arg[0] != ',' || arg[1] == '\0')
9707         error (_("Format string required"));
9708       else
9709         {
9710           /* Skip the comma.  */
9711           ++arg;
9712         }
9713     }
9714
9715   create_breakpoint (get_current_arch (),
9716                      location.get (),
9717                      NULL, 0, arg, 1 /* parse arg */,
9718                      0, bp_dprintf,
9719                      0 /* Ignore count */,
9720                      pending_break_support,
9721                      &dprintf_breakpoint_ops,
9722                      from_tty,
9723                      1 /* enabled */,
9724                      0 /* internal */,
9725                      0);
9726 }
9727
9728 static void
9729 agent_printf_command (const char *arg, int from_tty)
9730 {
9731   error (_("May only run agent-printf on the target"));
9732 }
9733
9734 /* Implement the "breakpoint_hit" breakpoint_ops method for
9735    ranged breakpoints.  */
9736
9737 static int
9738 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
9739                                   const address_space *aspace,
9740                                   CORE_ADDR bp_addr,
9741                                   const struct target_waitstatus *ws)
9742 {
9743   if (ws->kind != TARGET_WAITKIND_STOPPED
9744       || ws->value.sig != GDB_SIGNAL_TRAP)
9745     return 0;
9746
9747   return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
9748                                          bl->length, aspace, bp_addr);
9749 }
9750
9751 /* Implement the "resources_needed" breakpoint_ops method for
9752    ranged breakpoints.  */
9753
9754 static int
9755 resources_needed_ranged_breakpoint (const struct bp_location *bl)
9756 {
9757   return target_ranged_break_num_registers ();
9758 }
9759
9760 /* Implement the "print_it" breakpoint_ops method for
9761    ranged breakpoints.  */
9762
9763 static enum print_stop_action
9764 print_it_ranged_breakpoint (bpstat bs)
9765 {
9766   struct breakpoint *b = bs->breakpoint_at;
9767   struct bp_location *bl = b->loc;
9768   struct ui_out *uiout = current_uiout;
9769
9770   gdb_assert (b->type == bp_hardware_breakpoint);
9771
9772   /* Ranged breakpoints have only one location.  */
9773   gdb_assert (bl && bl->next == NULL);
9774
9775   annotate_breakpoint (b->number);
9776
9777   maybe_print_thread_hit_breakpoint (uiout);
9778
9779   if (b->disposition == disp_del)
9780     uiout->text ("Temporary ranged breakpoint ");
9781   else
9782     uiout->text ("Ranged breakpoint ");
9783   if (uiout->is_mi_like_p ())
9784     {
9785       uiout->field_string ("reason",
9786                       async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9787       uiout->field_string ("disp", bpdisp_text (b->disposition));
9788     }
9789   uiout->field_int ("bkptno", b->number);
9790   uiout->text (", ");
9791
9792   return PRINT_SRC_AND_LOC;
9793 }
9794
9795 /* Implement the "print_one" breakpoint_ops method for
9796    ranged breakpoints.  */
9797
9798 static void
9799 print_one_ranged_breakpoint (struct breakpoint *b,
9800                              struct bp_location **last_loc)
9801 {
9802   struct bp_location *bl = b->loc;
9803   struct value_print_options opts;
9804   struct ui_out *uiout = current_uiout;
9805
9806   /* Ranged breakpoints have only one location.  */
9807   gdb_assert (bl && bl->next == NULL);
9808
9809   get_user_print_options (&opts);
9810
9811   if (opts.addressprint)
9812     /* We don't print the address range here, it will be printed later
9813        by print_one_detail_ranged_breakpoint.  */
9814     uiout->field_skip ("addr");
9815   annotate_field (5);
9816   print_breakpoint_location (b, bl);
9817   *last_loc = bl;
9818 }
9819
9820 /* Implement the "print_one_detail" breakpoint_ops method for
9821    ranged breakpoints.  */
9822
9823 static void
9824 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
9825                                     struct ui_out *uiout)
9826 {
9827   CORE_ADDR address_start, address_end;
9828   struct bp_location *bl = b->loc;
9829   string_file stb;
9830
9831   gdb_assert (bl);
9832
9833   address_start = bl->address;
9834   address_end = address_start + bl->length - 1;
9835
9836   uiout->text ("\taddress range: ");
9837   stb.printf ("[%s, %s]",
9838               print_core_address (bl->gdbarch, address_start),
9839               print_core_address (bl->gdbarch, address_end));
9840   uiout->field_stream ("addr", stb);
9841   uiout->text ("\n");
9842 }
9843
9844 /* Implement the "print_mention" breakpoint_ops method for
9845    ranged breakpoints.  */
9846
9847 static void
9848 print_mention_ranged_breakpoint (struct breakpoint *b)
9849 {
9850   struct bp_location *bl = b->loc;
9851   struct ui_out *uiout = current_uiout;
9852
9853   gdb_assert (bl);
9854   gdb_assert (b->type == bp_hardware_breakpoint);
9855
9856   if (uiout->is_mi_like_p ())
9857     return;
9858
9859   printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9860                    b->number, paddress (bl->gdbarch, bl->address),
9861                    paddress (bl->gdbarch, bl->address + bl->length - 1));
9862 }
9863
9864 /* Implement the "print_recreate" breakpoint_ops method for
9865    ranged breakpoints.  */
9866
9867 static void
9868 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
9869 {
9870   fprintf_unfiltered (fp, "break-range %s, %s",
9871                       event_location_to_string (b->location.get ()),
9872                       event_location_to_string (b->location_range_end.get ()));
9873   print_recreate_thread (b, fp);
9874 }
9875
9876 /* The breakpoint_ops structure to be used in ranged breakpoints.  */
9877
9878 static struct breakpoint_ops ranged_breakpoint_ops;
9879
9880 /* Find the address where the end of the breakpoint range should be
9881    placed, given the SAL of the end of the range.  This is so that if
9882    the user provides a line number, the end of the range is set to the
9883    last instruction of the given line.  */
9884
9885 static CORE_ADDR
9886 find_breakpoint_range_end (struct symtab_and_line sal)
9887 {
9888   CORE_ADDR end;
9889
9890   /* If the user provided a PC value, use it.  Otherwise,
9891      find the address of the end of the given location.  */
9892   if (sal.explicit_pc)
9893     end = sal.pc;
9894   else
9895     {
9896       int ret;
9897       CORE_ADDR start;
9898
9899       ret = find_line_pc_range (sal, &start, &end);
9900       if (!ret)
9901         error (_("Could not find location of the end of the range."));
9902
9903       /* find_line_pc_range returns the start of the next line.  */
9904       end--;
9905     }
9906
9907   return end;
9908 }
9909
9910 /* Implement the "break-range" CLI command.  */
9911
9912 static void
9913 break_range_command (const char *arg, int from_tty)
9914 {
9915   const char *arg_start;
9916   struct linespec_result canonical_start, canonical_end;
9917   int bp_count, can_use_bp, length;
9918   CORE_ADDR end;
9919   struct breakpoint *b;
9920
9921   /* We don't support software ranged breakpoints.  */
9922   if (target_ranged_break_num_registers () < 0)
9923     error (_("This target does not support hardware ranged breakpoints."));
9924
9925   bp_count = hw_breakpoint_used_count ();
9926   bp_count += target_ranged_break_num_registers ();
9927   can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
9928                                                    bp_count, 0);
9929   if (can_use_bp < 0)
9930     error (_("Hardware breakpoints used exceeds limit."));
9931
9932   arg = skip_spaces (arg);
9933   if (arg == NULL || arg[0] == '\0')
9934     error(_("No address range specified."));
9935
9936   arg_start = arg;
9937   event_location_up start_location = string_to_event_location (&arg,
9938                                                                current_language);
9939   parse_breakpoint_sals (start_location.get (), &canonical_start);
9940
9941   if (arg[0] != ',')
9942     error (_("Too few arguments."));
9943   else if (canonical_start.lsals.empty ())
9944     error (_("Could not find location of the beginning of the range."));
9945
9946   const linespec_sals &lsal_start = canonical_start.lsals[0];
9947
9948   if (canonical_start.lsals.size () > 1
9949       || lsal_start.sals.size () != 1)
9950     error (_("Cannot create a ranged breakpoint with multiple locations."));
9951
9952   const symtab_and_line &sal_start = lsal_start.sals[0];
9953   std::string addr_string_start (arg_start, arg - arg_start);
9954
9955   arg++;        /* Skip the comma.  */
9956   arg = skip_spaces (arg);
9957
9958   /* Parse the end location.  */
9959
9960   arg_start = arg;
9961
9962   /* We call decode_line_full directly here instead of using
9963      parse_breakpoint_sals because we need to specify the start location's
9964      symtab and line as the default symtab and line for the end of the
9965      range.  This makes it possible to have ranges like "foo.c:27, +14",
9966      where +14 means 14 lines from the start location.  */
9967   event_location_up end_location = string_to_event_location (&arg,
9968                                                              current_language);
9969   decode_line_full (end_location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
9970                     sal_start.symtab, sal_start.line,
9971                     &canonical_end, NULL, NULL);
9972
9973   if (canonical_end.lsals.empty ())
9974     error (_("Could not find location of the end of the range."));
9975
9976   const linespec_sals &lsal_end = canonical_end.lsals[0];
9977   if (canonical_end.lsals.size () > 1
9978       || lsal_end.sals.size () != 1)
9979     error (_("Cannot create a ranged breakpoint with multiple locations."));
9980
9981   const symtab_and_line &sal_end = lsal_end.sals[0];
9982
9983   end = find_breakpoint_range_end (sal_end);
9984   if (sal_start.pc > end)
9985     error (_("Invalid address range, end precedes start."));
9986
9987   length = end - sal_start.pc + 1;
9988   if (length < 0)
9989     /* Length overflowed.  */
9990     error (_("Address range too large."));
9991   else if (length == 1)
9992     {
9993       /* This range is simple enough to be handled by
9994          the `hbreak' command.  */
9995       hbreak_command (&addr_string_start[0], 1);
9996
9997       return;
9998     }
9999
10000   /* Now set up the breakpoint.  */
10001   b = set_raw_breakpoint (get_current_arch (), sal_start,
10002                           bp_hardware_breakpoint, &ranged_breakpoint_ops);
10003   set_breakpoint_count (breakpoint_count + 1);
10004   b->number = breakpoint_count;
10005   b->disposition = disp_donttouch;
10006   b->location = std::move (start_location);
10007   b->location_range_end = std::move (end_location);
10008   b->loc->length = length;
10009
10010   mention (b);
10011   observer_notify_breakpoint_created (b);
10012   update_global_location_list (UGLL_MAY_INSERT);
10013 }
10014
10015 /*  Return non-zero if EXP is verified as constant.  Returned zero
10016     means EXP is variable.  Also the constant detection may fail for
10017     some constant expressions and in such case still falsely return
10018     zero.  */
10019
10020 static int
10021 watchpoint_exp_is_const (const struct expression *exp)
10022 {
10023   int i = exp->nelts;
10024
10025   while (i > 0)
10026     {
10027       int oplenp, argsp;
10028
10029       /* We are only interested in the descriptor of each element.  */
10030       operator_length (exp, i, &oplenp, &argsp);
10031       i -= oplenp;
10032
10033       switch (exp->elts[i].opcode)
10034         {
10035         case BINOP_ADD:
10036         case BINOP_SUB:
10037         case BINOP_MUL:
10038         case BINOP_DIV:
10039         case BINOP_REM:
10040         case BINOP_MOD:
10041         case BINOP_LSH:
10042         case BINOP_RSH:
10043         case BINOP_LOGICAL_AND:
10044         case BINOP_LOGICAL_OR:
10045         case BINOP_BITWISE_AND:
10046         case BINOP_BITWISE_IOR:
10047         case BINOP_BITWISE_XOR:
10048         case BINOP_EQUAL:
10049         case BINOP_NOTEQUAL:
10050         case BINOP_LESS:
10051         case BINOP_GTR:
10052         case BINOP_LEQ:
10053         case BINOP_GEQ:
10054         case BINOP_REPEAT:
10055         case BINOP_COMMA:
10056         case BINOP_EXP:
10057         case BINOP_MIN:
10058         case BINOP_MAX:
10059         case BINOP_INTDIV:
10060         case BINOP_CONCAT:
10061         case TERNOP_COND:
10062         case TERNOP_SLICE:
10063
10064         case OP_LONG:
10065         case OP_FLOAT:
10066         case OP_LAST:
10067         case OP_COMPLEX:
10068         case OP_STRING:
10069         case OP_ARRAY:
10070         case OP_TYPE:
10071         case OP_TYPEOF:
10072         case OP_DECLTYPE:
10073         case OP_TYPEID:
10074         case OP_NAME:
10075         case OP_OBJC_NSSTRING:
10076
10077         case UNOP_NEG:
10078         case UNOP_LOGICAL_NOT:
10079         case UNOP_COMPLEMENT:
10080         case UNOP_ADDR:
10081         case UNOP_HIGH:
10082         case UNOP_CAST:
10083
10084         case UNOP_CAST_TYPE:
10085         case UNOP_REINTERPRET_CAST:
10086         case UNOP_DYNAMIC_CAST:
10087           /* Unary, binary and ternary operators: We have to check
10088              their operands.  If they are constant, then so is the
10089              result of that operation.  For instance, if A and B are
10090              determined to be constants, then so is "A + B".
10091
10092              UNOP_IND is one exception to the rule above, because the
10093              value of *ADDR is not necessarily a constant, even when
10094              ADDR is.  */
10095           break;
10096
10097         case OP_VAR_VALUE:
10098           /* Check whether the associated symbol is a constant.
10099
10100              We use SYMBOL_CLASS rather than TYPE_CONST because it's
10101              possible that a buggy compiler could mark a variable as
10102              constant even when it is not, and TYPE_CONST would return
10103              true in this case, while SYMBOL_CLASS wouldn't.
10104
10105              We also have to check for function symbols because they
10106              are always constant.  */
10107           {
10108             struct symbol *s = exp->elts[i + 2].symbol;
10109
10110             if (SYMBOL_CLASS (s) != LOC_BLOCK
10111                 && SYMBOL_CLASS (s) != LOC_CONST
10112                 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
10113               return 0;
10114             break;
10115           }
10116
10117         /* The default action is to return 0 because we are using
10118            the optimistic approach here: If we don't know something,
10119            then it is not a constant.  */
10120         default:
10121           return 0;
10122         }
10123     }
10124
10125   return 1;
10126 }
10127
10128 /* Watchpoint destructor.  */
10129
10130 watchpoint::~watchpoint ()
10131 {
10132   xfree (this->exp_string);
10133   xfree (this->exp_string_reparse);
10134   value_free (this->val);
10135 }
10136
10137 /* Implement the "re_set" breakpoint_ops method for watchpoints.  */
10138
10139 static void
10140 re_set_watchpoint (struct breakpoint *b)
10141 {
10142   struct watchpoint *w = (struct watchpoint *) b;
10143
10144   /* Watchpoint can be either on expression using entirely global
10145      variables, or it can be on local variables.
10146
10147      Watchpoints of the first kind are never auto-deleted, and even
10148      persist across program restarts.  Since they can use variables
10149      from shared libraries, we need to reparse expression as libraries
10150      are loaded and unloaded.
10151
10152      Watchpoints on local variables can also change meaning as result
10153      of solib event.  For example, if a watchpoint uses both a local
10154      and a global variables in expression, it's a local watchpoint,
10155      but unloading of a shared library will make the expression
10156      invalid.  This is not a very common use case, but we still
10157      re-evaluate expression, to avoid surprises to the user.
10158
10159      Note that for local watchpoints, we re-evaluate it only if
10160      watchpoints frame id is still valid.  If it's not, it means the
10161      watchpoint is out of scope and will be deleted soon.  In fact,
10162      I'm not sure we'll ever be called in this case.
10163
10164      If a local watchpoint's frame id is still valid, then
10165      w->exp_valid_block is likewise valid, and we can safely use it.
10166
10167      Don't do anything about disabled watchpoints, since they will be
10168      reevaluated again when enabled.  */
10169   update_watchpoint (w, 1 /* reparse */);
10170 }
10171
10172 /* Implement the "insert" breakpoint_ops method for hardware watchpoints.  */
10173
10174 static int
10175 insert_watchpoint (struct bp_location *bl)
10176 {
10177   struct watchpoint *w = (struct watchpoint *) bl->owner;
10178   int length = w->exact ? 1 : bl->length;
10179
10180   return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
10181                                    w->cond_exp.get ());
10182 }
10183
10184 /* Implement the "remove" breakpoint_ops method for hardware watchpoints.  */
10185
10186 static int
10187 remove_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10188 {
10189   struct watchpoint *w = (struct watchpoint *) bl->owner;
10190   int length = w->exact ? 1 : bl->length;
10191
10192   return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
10193                                    w->cond_exp.get ());
10194 }
10195
10196 static int
10197 breakpoint_hit_watchpoint (const struct bp_location *bl,
10198                            const address_space *aspace, CORE_ADDR bp_addr,
10199                            const struct target_waitstatus *ws)
10200 {
10201   struct breakpoint *b = bl->owner;
10202   struct watchpoint *w = (struct watchpoint *) b;
10203
10204   /* Continuable hardware watchpoints are treated as non-existent if the
10205      reason we stopped wasn't a hardware watchpoint (we didn't stop on
10206      some data address).  Otherwise gdb won't stop on a break instruction
10207      in the code (not from a breakpoint) when a hardware watchpoint has
10208      been defined.  Also skip watchpoints which we know did not trigger
10209      (did not match the data address).  */
10210   if (is_hardware_watchpoint (b)
10211       && w->watchpoint_triggered == watch_triggered_no)
10212     return 0;
10213
10214   return 1;
10215 }
10216
10217 static void
10218 check_status_watchpoint (bpstat bs)
10219 {
10220   gdb_assert (is_watchpoint (bs->breakpoint_at));
10221
10222   bpstat_check_watchpoint (bs);
10223 }
10224
10225 /* Implement the "resources_needed" breakpoint_ops method for
10226    hardware watchpoints.  */
10227
10228 static int
10229 resources_needed_watchpoint (const struct bp_location *bl)
10230 {
10231   struct watchpoint *w = (struct watchpoint *) bl->owner;
10232   int length = w->exact? 1 : bl->length;
10233
10234   return target_region_ok_for_hw_watchpoint (bl->address, length);
10235 }
10236
10237 /* Implement the "works_in_software_mode" breakpoint_ops method for
10238    hardware watchpoints.  */
10239
10240 static int
10241 works_in_software_mode_watchpoint (const struct breakpoint *b)
10242 {
10243   /* Read and access watchpoints only work with hardware support.  */
10244   return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
10245 }
10246
10247 static enum print_stop_action
10248 print_it_watchpoint (bpstat bs)
10249 {
10250   struct breakpoint *b;
10251   enum print_stop_action result;
10252   struct watchpoint *w;
10253   struct ui_out *uiout = current_uiout;
10254
10255   gdb_assert (bs->bp_location_at != NULL);
10256
10257   b = bs->breakpoint_at;
10258   w = (struct watchpoint *) b;
10259
10260   annotate_watchpoint (b->number);
10261   maybe_print_thread_hit_breakpoint (uiout);
10262
10263   string_file stb;
10264
10265   gdb::optional<ui_out_emit_tuple> tuple_emitter;
10266   switch (b->type)
10267     {
10268     case bp_watchpoint:
10269     case bp_hardware_watchpoint:
10270       if (uiout->is_mi_like_p ())
10271         uiout->field_string
10272           ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10273       mention (b);
10274       tuple_emitter.emplace (uiout, "value");
10275       uiout->text ("\nOld value = ");
10276       watchpoint_value_print (bs->old_val, &stb);
10277       uiout->field_stream ("old", stb);
10278       uiout->text ("\nNew value = ");
10279       watchpoint_value_print (w->val, &stb);
10280       uiout->field_stream ("new", stb);
10281       uiout->text ("\n");
10282       /* More than one watchpoint may have been triggered.  */
10283       result = PRINT_UNKNOWN;
10284       break;
10285
10286     case bp_read_watchpoint:
10287       if (uiout->is_mi_like_p ())
10288         uiout->field_string
10289           ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10290       mention (b);
10291       tuple_emitter.emplace (uiout, "value");
10292       uiout->text ("\nValue = ");
10293       watchpoint_value_print (w->val, &stb);
10294       uiout->field_stream ("value", stb);
10295       uiout->text ("\n");
10296       result = PRINT_UNKNOWN;
10297       break;
10298
10299     case bp_access_watchpoint:
10300       if (bs->old_val != NULL)
10301         {
10302           if (uiout->is_mi_like_p ())
10303             uiout->field_string
10304               ("reason",
10305                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10306           mention (b);
10307           tuple_emitter.emplace (uiout, "value");
10308           uiout->text ("\nOld value = ");
10309           watchpoint_value_print (bs->old_val, &stb);
10310           uiout->field_stream ("old", stb);
10311           uiout->text ("\nNew value = ");
10312         }
10313       else
10314         {
10315           mention (b);
10316           if (uiout->is_mi_like_p ())
10317             uiout->field_string
10318               ("reason",
10319                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10320           tuple_emitter.emplace (uiout, "value");
10321           uiout->text ("\nValue = ");
10322         }
10323       watchpoint_value_print (w->val, &stb);
10324       uiout->field_stream ("new", stb);
10325       uiout->text ("\n");
10326       result = PRINT_UNKNOWN;
10327       break;
10328     default:
10329       result = PRINT_UNKNOWN;
10330     }
10331
10332   return result;
10333 }
10334
10335 /* Implement the "print_mention" breakpoint_ops method for hardware
10336    watchpoints.  */
10337
10338 static void
10339 print_mention_watchpoint (struct breakpoint *b)
10340 {
10341   struct watchpoint *w = (struct watchpoint *) b;
10342   struct ui_out *uiout = current_uiout;
10343   const char *tuple_name;
10344
10345   switch (b->type)
10346     {
10347     case bp_watchpoint:
10348       uiout->text ("Watchpoint ");
10349       tuple_name = "wpt";
10350       break;
10351     case bp_hardware_watchpoint:
10352       uiout->text ("Hardware watchpoint ");
10353       tuple_name = "wpt";
10354       break;
10355     case bp_read_watchpoint:
10356       uiout->text ("Hardware read watchpoint ");
10357       tuple_name = "hw-rwpt";
10358       break;
10359     case bp_access_watchpoint:
10360       uiout->text ("Hardware access (read/write) watchpoint ");
10361       tuple_name = "hw-awpt";
10362       break;
10363     default:
10364       internal_error (__FILE__, __LINE__,
10365                       _("Invalid hardware watchpoint type."));
10366     }
10367
10368   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10369   uiout->field_int ("number", b->number);
10370   uiout->text (": ");
10371   uiout->field_string ("exp", w->exp_string);
10372 }
10373
10374 /* Implement the "print_recreate" breakpoint_ops method for
10375    watchpoints.  */
10376
10377 static void
10378 print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10379 {
10380   struct watchpoint *w = (struct watchpoint *) b;
10381
10382   switch (b->type)
10383     {
10384     case bp_watchpoint:
10385     case bp_hardware_watchpoint:
10386       fprintf_unfiltered (fp, "watch");
10387       break;
10388     case bp_read_watchpoint:
10389       fprintf_unfiltered (fp, "rwatch");
10390       break;
10391     case bp_access_watchpoint:
10392       fprintf_unfiltered (fp, "awatch");
10393       break;
10394     default:
10395       internal_error (__FILE__, __LINE__,
10396                       _("Invalid watchpoint type."));
10397     }
10398
10399   fprintf_unfiltered (fp, " %s", w->exp_string);
10400   print_recreate_thread (b, fp);
10401 }
10402
10403 /* Implement the "explains_signal" breakpoint_ops method for
10404    watchpoints.  */
10405
10406 static int
10407 explains_signal_watchpoint (struct breakpoint *b, enum gdb_signal sig)
10408 {
10409   /* A software watchpoint cannot cause a signal other than
10410      GDB_SIGNAL_TRAP.  */
10411   if (b->type == bp_watchpoint && sig != GDB_SIGNAL_TRAP)
10412     return 0;
10413
10414   return 1;
10415 }
10416
10417 /* The breakpoint_ops structure to be used in hardware watchpoints.  */
10418
10419 static struct breakpoint_ops watchpoint_breakpoint_ops;
10420
10421 /* Implement the "insert" breakpoint_ops method for
10422    masked hardware watchpoints.  */
10423
10424 static int
10425 insert_masked_watchpoint (struct bp_location *bl)
10426 {
10427   struct watchpoint *w = (struct watchpoint *) bl->owner;
10428
10429   return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
10430                                         bl->watchpoint_type);
10431 }
10432
10433 /* Implement the "remove" breakpoint_ops method for
10434    masked hardware watchpoints.  */
10435
10436 static int
10437 remove_masked_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
10438 {
10439   struct watchpoint *w = (struct watchpoint *) bl->owner;
10440
10441   return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
10442                                         bl->watchpoint_type);
10443 }
10444
10445 /* Implement the "resources_needed" breakpoint_ops method for
10446    masked hardware watchpoints.  */
10447
10448 static int
10449 resources_needed_masked_watchpoint (const struct bp_location *bl)
10450 {
10451   struct watchpoint *w = (struct watchpoint *) bl->owner;
10452
10453   return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
10454 }
10455
10456 /* Implement the "works_in_software_mode" breakpoint_ops method for
10457    masked hardware watchpoints.  */
10458
10459 static int
10460 works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10461 {
10462   return 0;
10463 }
10464
10465 /* Implement the "print_it" breakpoint_ops method for
10466    masked hardware watchpoints.  */
10467
10468 static enum print_stop_action
10469 print_it_masked_watchpoint (bpstat bs)
10470 {
10471   struct breakpoint *b = bs->breakpoint_at;
10472   struct ui_out *uiout = current_uiout;
10473
10474   /* Masked watchpoints have only one location.  */
10475   gdb_assert (b->loc && b->loc->next == NULL);
10476
10477   annotate_watchpoint (b->number);
10478   maybe_print_thread_hit_breakpoint (uiout);
10479
10480   switch (b->type)
10481     {
10482     case bp_hardware_watchpoint:
10483       if (uiout->is_mi_like_p ())
10484         uiout->field_string
10485           ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10486       break;
10487
10488     case bp_read_watchpoint:
10489       if (uiout->is_mi_like_p ())
10490         uiout->field_string
10491           ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10492       break;
10493
10494     case bp_access_watchpoint:
10495       if (uiout->is_mi_like_p ())
10496         uiout->field_string
10497           ("reason",
10498            async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10499       break;
10500     default:
10501       internal_error (__FILE__, __LINE__,
10502                       _("Invalid hardware watchpoint type."));
10503     }
10504
10505   mention (b);
10506   uiout->text (_("\n\
10507 Check the underlying instruction at PC for the memory\n\
10508 address and value which triggered this watchpoint.\n"));
10509   uiout->text ("\n");
10510
10511   /* More than one watchpoint may have been triggered.  */
10512   return PRINT_UNKNOWN;
10513 }
10514
10515 /* Implement the "print_one_detail" breakpoint_ops method for
10516    masked hardware watchpoints.  */
10517
10518 static void
10519 print_one_detail_masked_watchpoint (const struct breakpoint *b,
10520                                     struct ui_out *uiout)
10521 {
10522   struct watchpoint *w = (struct watchpoint *) b;
10523
10524   /* Masked watchpoints have only one location.  */
10525   gdb_assert (b->loc && b->loc->next == NULL);
10526
10527   uiout->text ("\tmask ");
10528   uiout->field_core_addr ("mask", b->loc->gdbarch, w->hw_wp_mask);
10529   uiout->text ("\n");
10530 }
10531
10532 /* Implement the "print_mention" breakpoint_ops method for
10533    masked hardware watchpoints.  */
10534
10535 static void
10536 print_mention_masked_watchpoint (struct breakpoint *b)
10537 {
10538   struct watchpoint *w = (struct watchpoint *) b;
10539   struct ui_out *uiout = current_uiout;
10540   const char *tuple_name;
10541
10542   switch (b->type)
10543     {
10544     case bp_hardware_watchpoint:
10545       uiout->text ("Masked hardware watchpoint ");
10546       tuple_name = "wpt";
10547       break;
10548     case bp_read_watchpoint:
10549       uiout->text ("Masked hardware read watchpoint ");
10550       tuple_name = "hw-rwpt";
10551       break;
10552     case bp_access_watchpoint:
10553       uiout->text ("Masked hardware access (read/write) watchpoint ");
10554       tuple_name = "hw-awpt";
10555       break;
10556     default:
10557       internal_error (__FILE__, __LINE__,
10558                       _("Invalid hardware watchpoint type."));
10559     }
10560
10561   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
10562   uiout->field_int ("number", b->number);
10563   uiout->text (": ");
10564   uiout->field_string ("exp", w->exp_string);
10565 }
10566
10567 /* Implement the "print_recreate" breakpoint_ops method for
10568    masked hardware watchpoints.  */
10569
10570 static void
10571 print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
10572 {
10573   struct watchpoint *w = (struct watchpoint *) b;
10574   char tmp[40];
10575
10576   switch (b->type)
10577     {
10578     case bp_hardware_watchpoint:
10579       fprintf_unfiltered (fp, "watch");
10580       break;
10581     case bp_read_watchpoint:
10582       fprintf_unfiltered (fp, "rwatch");
10583       break;
10584     case bp_access_watchpoint:
10585       fprintf_unfiltered (fp, "awatch");
10586       break;
10587     default:
10588       internal_error (__FILE__, __LINE__,
10589                       _("Invalid hardware watchpoint type."));
10590     }
10591
10592   sprintf_vma (tmp, w->hw_wp_mask);
10593   fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
10594   print_recreate_thread (b, fp);
10595 }
10596
10597 /* The breakpoint_ops structure to be used in masked hardware watchpoints.  */
10598
10599 static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
10600
10601 /* Tell whether the given watchpoint is a masked hardware watchpoint.  */
10602
10603 static int
10604 is_masked_watchpoint (const struct breakpoint *b)
10605 {
10606   return b->ops == &masked_watchpoint_breakpoint_ops;
10607 }
10608
10609 /* accessflag:  hw_write:  watch write, 
10610                 hw_read:   watch read, 
10611                 hw_access: watch access (read or write) */
10612 static void
10613 watch_command_1 (const char *arg, int accessflag, int from_tty,
10614                  int just_location, int internal)
10615 {
10616   struct breakpoint *scope_breakpoint = NULL;
10617   const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
10618   struct value *val, *mark, *result;
10619   int saved_bitpos = 0, saved_bitsize = 0;
10620   const char *exp_start = NULL;
10621   const char *exp_end = NULL;
10622   const char *tok, *end_tok;
10623   int toklen = -1;
10624   const char *cond_start = NULL;
10625   const char *cond_end = NULL;
10626   enum bptype bp_type;
10627   int thread = -1;
10628   int pc = 0;
10629   /* Flag to indicate whether we are going to use masks for
10630      the hardware watchpoint.  */
10631   int use_mask = 0;
10632   CORE_ADDR mask = 0;
10633
10634   /* Make sure that we actually have parameters to parse.  */
10635   if (arg != NULL && arg[0] != '\0')
10636     {
10637       const char *value_start;
10638
10639       exp_end = arg + strlen (arg);
10640
10641       /* Look for "parameter value" pairs at the end
10642          of the arguments string.  */
10643       for (tok = exp_end - 1; tok > arg; tok--)
10644         {
10645           /* Skip whitespace at the end of the argument list.  */
10646           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10647             tok--;
10648
10649           /* Find the beginning of the last token.
10650              This is the value of the parameter.  */
10651           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10652             tok--;
10653           value_start = tok + 1;
10654
10655           /* Skip whitespace.  */
10656           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10657             tok--;
10658
10659           end_tok = tok;
10660
10661           /* Find the beginning of the second to last token.
10662              This is the parameter itself.  */
10663           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10664             tok--;
10665           tok++;
10666           toklen = end_tok - tok + 1;
10667
10668           if (toklen == 6 && startswith (tok, "thread"))
10669             {
10670               struct thread_info *thr;
10671               /* At this point we've found a "thread" token, which means
10672                  the user is trying to set a watchpoint that triggers
10673                  only in a specific thread.  */
10674               const char *endp;
10675
10676               if (thread != -1)
10677                 error(_("You can specify only one thread."));
10678
10679               /* Extract the thread ID from the next token.  */
10680               thr = parse_thread_id (value_start, &endp);
10681
10682               /* Check if the user provided a valid thread ID.  */
10683               if (*endp != ' ' && *endp != '\t' && *endp != '\0')
10684                 invalid_thread_id_error (value_start);
10685
10686               thread = thr->global_num;
10687             }
10688           else if (toklen == 4 && startswith (tok, "mask"))
10689             {
10690               /* We've found a "mask" token, which means the user wants to
10691                  create a hardware watchpoint that is going to have the mask
10692                  facility.  */
10693               struct value *mask_value, *mark;
10694
10695               if (use_mask)
10696                 error(_("You can specify only one mask."));
10697
10698               use_mask = just_location = 1;
10699
10700               mark = value_mark ();
10701               mask_value = parse_to_comma_and_eval (&value_start);
10702               mask = value_as_address (mask_value);
10703               value_free_to_mark (mark);
10704             }
10705           else
10706             /* We didn't recognize what we found.  We should stop here.  */
10707             break;
10708
10709           /* Truncate the string and get rid of the "parameter value" pair before
10710              the arguments string is parsed by the parse_exp_1 function.  */
10711           exp_end = tok;
10712         }
10713     }
10714   else
10715     exp_end = arg;
10716
10717   /* Parse the rest of the arguments.  From here on out, everything
10718      is in terms of a newly allocated string instead of the original
10719      ARG.  */
10720   innermost_block = NULL;
10721   std::string expression (arg, exp_end - arg);
10722   exp_start = arg = expression.c_str ();
10723   expression_up exp = parse_exp_1 (&arg, 0, 0, 0);
10724   exp_end = arg;
10725   /* Remove trailing whitespace from the expression before saving it.
10726      This makes the eventual display of the expression string a bit
10727      prettier.  */
10728   while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
10729     --exp_end;
10730
10731   /* Checking if the expression is not constant.  */
10732   if (watchpoint_exp_is_const (exp.get ()))
10733     {
10734       int len;
10735
10736       len = exp_end - exp_start;
10737       while (len > 0 && isspace (exp_start[len - 1]))
10738         len--;
10739       error (_("Cannot watch constant value `%.*s'."), len, exp_start);
10740     }
10741
10742   exp_valid_block = innermost_block;
10743   mark = value_mark ();
10744   fetch_subexp_value (exp.get (), &pc, &val, &result, NULL, just_location);
10745
10746   if (val != NULL && just_location)
10747     {
10748       saved_bitpos = value_bitpos (val);
10749       saved_bitsize = value_bitsize (val);
10750     }
10751
10752   if (just_location)
10753     {
10754       int ret;
10755
10756       exp_valid_block = NULL;
10757       val = value_addr (result);
10758       release_value (val);
10759       value_free_to_mark (mark);
10760
10761       if (use_mask)
10762         {
10763           ret = target_masked_watch_num_registers (value_as_address (val),
10764                                                    mask);
10765           if (ret == -1)
10766             error (_("This target does not support masked watchpoints."));
10767           else if (ret == -2)
10768             error (_("Invalid mask or memory region."));
10769         }
10770     }
10771   else if (val != NULL)
10772     release_value (val);
10773
10774   tok = skip_spaces (arg);
10775   end_tok = skip_to_space (tok);
10776
10777   toklen = end_tok - tok;
10778   if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
10779     {
10780       innermost_block = NULL;
10781       tok = cond_start = end_tok + 1;
10782       parse_exp_1 (&tok, 0, 0, 0);
10783
10784       /* The watchpoint expression may not be local, but the condition
10785          may still be.  E.g.: `watch global if local > 0'.  */
10786       cond_exp_valid_block = innermost_block;
10787
10788       cond_end = tok;
10789     }
10790   if (*tok)
10791     error (_("Junk at end of command."));
10792
10793   frame_info *wp_frame = block_innermost_frame (exp_valid_block);
10794
10795   /* Save this because create_internal_breakpoint below invalidates
10796      'wp_frame'.  */
10797   frame_id watchpoint_frame = get_frame_id (wp_frame);
10798
10799   /* If the expression is "local", then set up a "watchpoint scope"
10800      breakpoint at the point where we've left the scope of the watchpoint
10801      expression.  Create the scope breakpoint before the watchpoint, so
10802      that we will encounter it first in bpstat_stop_status.  */
10803   if (exp_valid_block != NULL && wp_frame != NULL)
10804     {
10805       frame_id caller_frame_id = frame_unwind_caller_id (wp_frame);
10806
10807       if (frame_id_p (caller_frame_id))
10808         {
10809           gdbarch *caller_arch = frame_unwind_caller_arch (wp_frame);
10810           CORE_ADDR caller_pc = frame_unwind_caller_pc (wp_frame);
10811
10812           scope_breakpoint
10813             = create_internal_breakpoint (caller_arch, caller_pc,
10814                                           bp_watchpoint_scope,
10815                                           &momentary_breakpoint_ops);
10816
10817           /* create_internal_breakpoint could invalidate WP_FRAME.  */
10818           wp_frame = NULL;
10819
10820           scope_breakpoint->enable_state = bp_enabled;
10821
10822           /* Automatically delete the breakpoint when it hits.  */
10823           scope_breakpoint->disposition = disp_del;
10824
10825           /* Only break in the proper frame (help with recursion).  */
10826           scope_breakpoint->frame_id = caller_frame_id;
10827
10828           /* Set the address at which we will stop.  */
10829           scope_breakpoint->loc->gdbarch = caller_arch;
10830           scope_breakpoint->loc->requested_address = caller_pc;
10831           scope_breakpoint->loc->address
10832             = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
10833                                          scope_breakpoint->loc->requested_address,
10834                                          scope_breakpoint->type);
10835         }
10836     }
10837
10838   /* Now set up the breakpoint.  We create all watchpoints as hardware
10839      watchpoints here even if hardware watchpoints are turned off, a call
10840      to update_watchpoint later in this function will cause the type to
10841      drop back to bp_watchpoint (software watchpoint) if required.  */
10842
10843   if (accessflag == hw_read)
10844     bp_type = bp_read_watchpoint;
10845   else if (accessflag == hw_access)
10846     bp_type = bp_access_watchpoint;
10847   else
10848     bp_type = bp_hardware_watchpoint;
10849
10850   std::unique_ptr<watchpoint> w (new watchpoint ());
10851
10852   if (use_mask)
10853     init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10854                                           &masked_watchpoint_breakpoint_ops);
10855   else
10856     init_raw_breakpoint_without_location (w.get (), NULL, bp_type,
10857                                           &watchpoint_breakpoint_ops);
10858   w->thread = thread;
10859   w->disposition = disp_donttouch;
10860   w->pspace = current_program_space;
10861   w->exp = std::move (exp);
10862   w->exp_valid_block = exp_valid_block;
10863   w->cond_exp_valid_block = cond_exp_valid_block;
10864   if (just_location)
10865     {
10866       struct type *t = value_type (val);
10867       CORE_ADDR addr = value_as_address (val);
10868
10869       w->exp_string_reparse
10870         = current_language->la_watch_location_expression (t, addr).release ();
10871
10872       w->exp_string = xstrprintf ("-location %.*s",
10873                                   (int) (exp_end - exp_start), exp_start);
10874     }
10875   else
10876     w->exp_string = savestring (exp_start, exp_end - exp_start);
10877
10878   if (use_mask)
10879     {
10880       w->hw_wp_mask = mask;
10881     }
10882   else
10883     {
10884       w->val = val;
10885       w->val_bitpos = saved_bitpos;
10886       w->val_bitsize = saved_bitsize;
10887       w->val_valid = 1;
10888     }
10889
10890   if (cond_start)
10891     w->cond_string = savestring (cond_start, cond_end - cond_start);
10892   else
10893     w->cond_string = 0;
10894
10895   if (frame_id_p (watchpoint_frame))
10896     {
10897       w->watchpoint_frame = watchpoint_frame;
10898       w->watchpoint_thread = inferior_ptid;
10899     }
10900   else
10901     {
10902       w->watchpoint_frame = null_frame_id;
10903       w->watchpoint_thread = null_ptid;
10904     }
10905
10906   if (scope_breakpoint != NULL)
10907     {
10908       /* The scope breakpoint is related to the watchpoint.  We will
10909          need to act on them together.  */
10910       w->related_breakpoint = scope_breakpoint;
10911       scope_breakpoint->related_breakpoint = w.get ();
10912     }
10913
10914   if (!just_location)
10915     value_free_to_mark (mark);
10916
10917   /* Finally update the new watchpoint.  This creates the locations
10918      that should be inserted.  */
10919   update_watchpoint (w.get (), 1);
10920
10921   install_breakpoint (internal, std::move (w), 1);
10922 }
10923
10924 /* Return count of debug registers needed to watch the given expression.
10925    If the watchpoint cannot be handled in hardware return zero.  */
10926
10927 static int
10928 can_use_hardware_watchpoint (struct value *v)
10929 {
10930   int found_memory_cnt = 0;
10931   struct value *head = v;
10932
10933   /* Did the user specifically forbid us to use hardware watchpoints? */
10934   if (!can_use_hw_watchpoints)
10935     return 0;
10936
10937   /* Make sure that the value of the expression depends only upon
10938      memory contents, and values computed from them within GDB.  If we
10939      find any register references or function calls, we can't use a
10940      hardware watchpoint.
10941
10942      The idea here is that evaluating an expression generates a series
10943      of values, one holding the value of every subexpression.  (The
10944      expression a*b+c has five subexpressions: a, b, a*b, c, and
10945      a*b+c.)  GDB's values hold almost enough information to establish
10946      the criteria given above --- they identify memory lvalues,
10947      register lvalues, computed values, etcetera.  So we can evaluate
10948      the expression, and then scan the chain of values that leaves
10949      behind to decide whether we can detect any possible change to the
10950      expression's final value using only hardware watchpoints.
10951
10952      However, I don't think that the values returned by inferior
10953      function calls are special in any way.  So this function may not
10954      notice that an expression involving an inferior function call
10955      can't be watched with hardware watchpoints.  FIXME.  */
10956   for (; v; v = value_next (v))
10957     {
10958       if (VALUE_LVAL (v) == lval_memory)
10959         {
10960           if (v != head && value_lazy (v))
10961             /* A lazy memory lvalue in the chain is one that GDB never
10962                needed to fetch; we either just used its address (e.g.,
10963                `a' in `a.b') or we never needed it at all (e.g., `a'
10964                in `a,b').  This doesn't apply to HEAD; if that is
10965                lazy then it was not readable, but watch it anyway.  */
10966             ;
10967           else
10968             {
10969               /* Ahh, memory we actually used!  Check if we can cover
10970                  it with hardware watchpoints.  */
10971               struct type *vtype = check_typedef (value_type (v));
10972
10973               /* We only watch structs and arrays if user asked for it
10974                  explicitly, never if they just happen to appear in a
10975                  middle of some value chain.  */
10976               if (v == head
10977                   || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
10978                       && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
10979                 {
10980                   CORE_ADDR vaddr = value_address (v);
10981                   int len;
10982                   int num_regs;
10983
10984                   len = (target_exact_watchpoints
10985                          && is_scalar_type_recursive (vtype))?
10986                     1 : TYPE_LENGTH (value_type (v));
10987
10988                   num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
10989                   if (!num_regs)
10990                     return 0;
10991                   else
10992                     found_memory_cnt += num_regs;
10993                 }
10994             }
10995         }
10996       else if (VALUE_LVAL (v) != not_lval
10997                && deprecated_value_modifiable (v) == 0)
10998         return 0;       /* These are values from the history (e.g., $1).  */
10999       else if (VALUE_LVAL (v) == lval_register)
11000         return 0;       /* Cannot watch a register with a HW watchpoint.  */
11001     }
11002
11003   /* The expression itself looks suitable for using a hardware
11004      watchpoint, but give the target machine a chance to reject it.  */
11005   return found_memory_cnt;
11006 }
11007
11008 void
11009 watch_command_wrapper (const char *arg, int from_tty, int internal)
11010 {
11011   watch_command_1 (arg, hw_write, from_tty, 0, internal);
11012 }
11013
11014 /* A helper function that looks for the "-location" argument and then
11015    calls watch_command_1.  */
11016
11017 static void
11018 watch_maybe_just_location (const char *arg, int accessflag, int from_tty)
11019 {
11020   int just_location = 0;
11021
11022   if (arg
11023       && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
11024           || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
11025     {
11026       arg = skip_spaces (arg);
11027       just_location = 1;
11028     }
11029
11030   watch_command_1 (arg, accessflag, from_tty, just_location, 0);
11031 }
11032
11033 static void
11034 watch_command (const char *arg, int from_tty)
11035 {
11036   watch_maybe_just_location (arg, hw_write, from_tty);
11037 }
11038
11039 void
11040 rwatch_command_wrapper (const char *arg, int from_tty, int internal)
11041 {
11042   watch_command_1 (arg, hw_read, from_tty, 0, internal);
11043 }
11044
11045 static void
11046 rwatch_command (const char *arg, int from_tty)
11047 {
11048   watch_maybe_just_location (arg, hw_read, from_tty);
11049 }
11050
11051 void
11052 awatch_command_wrapper (const char *arg, int from_tty, int internal)
11053 {
11054   watch_command_1 (arg, hw_access, from_tty, 0, internal);
11055 }
11056
11057 static void
11058 awatch_command (const char *arg, int from_tty)
11059 {
11060   watch_maybe_just_location (arg, hw_access, from_tty);
11061 }
11062 \f
11063
11064 /* Data for the FSM that manages the until(location)/advance commands
11065    in infcmd.c.  Here because it uses the mechanisms of
11066    breakpoints.  */
11067
11068 struct until_break_fsm
11069 {
11070   /* The base class.  */
11071   struct thread_fsm thread_fsm;
11072
11073   /* The thread that as current when the command was executed.  */
11074   int thread;
11075
11076   /* The breakpoint set at the destination location.  */
11077   struct breakpoint *location_breakpoint;
11078
11079   /* Breakpoint set at the return address in the caller frame.  May be
11080      NULL.  */
11081   struct breakpoint *caller_breakpoint;
11082 };
11083
11084 static void until_break_fsm_clean_up (struct thread_fsm *self,
11085                                       struct thread_info *thread);
11086 static int until_break_fsm_should_stop (struct thread_fsm *self,
11087                                         struct thread_info *thread);
11088 static enum async_reply_reason
11089   until_break_fsm_async_reply_reason (struct thread_fsm *self);
11090
11091 /* until_break_fsm's vtable.  */
11092
11093 static struct thread_fsm_ops until_break_fsm_ops =
11094 {
11095   NULL, /* dtor */
11096   until_break_fsm_clean_up,
11097   until_break_fsm_should_stop,
11098   NULL, /* return_value */
11099   until_break_fsm_async_reply_reason,
11100 };
11101
11102 /* Allocate a new until_break_command_fsm.  */
11103
11104 static struct until_break_fsm *
11105 new_until_break_fsm (struct interp *cmd_interp, int thread,
11106                      breakpoint_up &&location_breakpoint,
11107                      breakpoint_up &&caller_breakpoint)
11108 {
11109   struct until_break_fsm *sm;
11110
11111   sm = XCNEW (struct until_break_fsm);
11112   thread_fsm_ctor (&sm->thread_fsm, &until_break_fsm_ops, cmd_interp);
11113
11114   sm->thread = thread;
11115   sm->location_breakpoint = location_breakpoint.release ();
11116   sm->caller_breakpoint = caller_breakpoint.release ();
11117
11118   return sm;
11119 }
11120
11121 /* Implementation of the 'should_stop' FSM method for the
11122    until(location)/advance commands.  */
11123
11124 static int
11125 until_break_fsm_should_stop (struct thread_fsm *self,
11126                              struct thread_info *tp)
11127 {
11128   struct until_break_fsm *sm = (struct until_break_fsm *) self;
11129
11130   if (bpstat_find_breakpoint (tp->control.stop_bpstat,
11131                               sm->location_breakpoint) != NULL
11132       || (sm->caller_breakpoint != NULL
11133           && bpstat_find_breakpoint (tp->control.stop_bpstat,
11134                                      sm->caller_breakpoint) != NULL))
11135     thread_fsm_set_finished (self);
11136
11137   return 1;
11138 }
11139
11140 /* Implementation of the 'clean_up' FSM method for the
11141    until(location)/advance commands.  */
11142
11143 static void
11144 until_break_fsm_clean_up (struct thread_fsm *self,
11145                           struct thread_info *thread)
11146 {
11147   struct until_break_fsm *sm = (struct until_break_fsm *) self;
11148
11149   /* Clean up our temporary breakpoints.  */
11150   if (sm->location_breakpoint != NULL)
11151     {
11152       delete_breakpoint (sm->location_breakpoint);
11153       sm->location_breakpoint = NULL;
11154     }
11155   if (sm->caller_breakpoint != NULL)
11156     {
11157       delete_breakpoint (sm->caller_breakpoint);
11158       sm->caller_breakpoint = NULL;
11159     }
11160   delete_longjmp_breakpoint (sm->thread);
11161 }
11162
11163 /* Implementation of the 'async_reply_reason' FSM method for the
11164    until(location)/advance commands.  */
11165
11166 static enum async_reply_reason
11167 until_break_fsm_async_reply_reason (struct thread_fsm *self)
11168 {
11169   return EXEC_ASYNC_LOCATION_REACHED;
11170 }
11171
11172 void
11173 until_break_command (const char *arg, int from_tty, int anywhere)
11174 {
11175   struct frame_info *frame;
11176   struct gdbarch *frame_gdbarch;
11177   struct frame_id stack_frame_id;
11178   struct frame_id caller_frame_id;
11179   struct cleanup *old_chain;
11180   int thread;
11181   struct thread_info *tp;
11182   struct until_break_fsm *sm;
11183
11184   clear_proceed_status (0);
11185
11186   /* Set a breakpoint where the user wants it and at return from
11187      this function.  */
11188
11189   event_location_up location = string_to_event_location (&arg, current_language);
11190
11191   std::vector<symtab_and_line> sals
11192     = (last_displayed_sal_is_valid ()
11193        ? decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
11194                         get_last_displayed_symtab (),
11195                         get_last_displayed_line ())
11196        : decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
11197                         NULL, (struct symtab *) NULL, 0));
11198
11199   if (sals.size () != 1)
11200     error (_("Couldn't get information on specified line."));
11201
11202   symtab_and_line &sal = sals[0];
11203
11204   if (*arg)
11205     error (_("Junk at end of arguments."));
11206
11207   resolve_sal_pc (&sal);
11208
11209   tp = inferior_thread ();
11210   thread = tp->global_num;
11211
11212   old_chain = make_cleanup (null_cleanup, NULL);
11213
11214   /* Note linespec handling above invalidates the frame chain.
11215      Installing a breakpoint also invalidates the frame chain (as it
11216      may need to switch threads), so do any frame handling before
11217      that.  */
11218
11219   frame = get_selected_frame (NULL);
11220   frame_gdbarch = get_frame_arch (frame);
11221   stack_frame_id = get_stack_frame_id (frame);
11222   caller_frame_id = frame_unwind_caller_id (frame);
11223
11224   /* Keep within the current frame, or in frames called by the current
11225      one.  */
11226
11227   breakpoint_up caller_breakpoint;
11228   if (frame_id_p (caller_frame_id))
11229     {
11230       struct symtab_and_line sal2;
11231       struct gdbarch *caller_gdbarch;
11232
11233       sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11234       sal2.pc = frame_unwind_caller_pc (frame);
11235       caller_gdbarch = frame_unwind_caller_arch (frame);
11236       caller_breakpoint = set_momentary_breakpoint (caller_gdbarch,
11237                                                     sal2,
11238                                                     caller_frame_id,
11239                                                     bp_until);
11240
11241       set_longjmp_breakpoint (tp, caller_frame_id);
11242       make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
11243     }
11244
11245   /* set_momentary_breakpoint could invalidate FRAME.  */
11246   frame = NULL;
11247
11248   breakpoint_up location_breakpoint;
11249   if (anywhere)
11250     /* If the user told us to continue until a specified location,
11251        we don't specify a frame at which we need to stop.  */
11252     location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11253                                                     null_frame_id, bp_until);
11254   else
11255     /* Otherwise, specify the selected frame, because we want to stop
11256        only at the very same frame.  */
11257     location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11258                                                     stack_frame_id, bp_until);
11259
11260   sm = new_until_break_fsm (command_interp (), tp->global_num,
11261                             std::move (location_breakpoint),
11262                             std::move (caller_breakpoint));
11263   tp->thread_fsm = &sm->thread_fsm;
11264
11265   discard_cleanups (old_chain);
11266
11267   proceed (-1, GDB_SIGNAL_DEFAULT);
11268 }
11269
11270 /* This function attempts to parse an optional "if <cond>" clause
11271    from the arg string.  If one is not found, it returns NULL.
11272
11273    Else, it returns a pointer to the condition string.  (It does not
11274    attempt to evaluate the string against a particular block.)  And,
11275    it updates arg to point to the first character following the parsed
11276    if clause in the arg string.  */
11277
11278 const char *
11279 ep_parse_optional_if_clause (const char **arg)
11280 {
11281   const char *cond_string;
11282
11283   if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
11284     return NULL;
11285
11286   /* Skip the "if" keyword.  */
11287   (*arg) += 2;
11288
11289   /* Skip any extra leading whitespace, and record the start of the
11290      condition string.  */
11291   *arg = skip_spaces (*arg);
11292   cond_string = *arg;
11293
11294   /* Assume that the condition occupies the remainder of the arg
11295      string.  */
11296   (*arg) += strlen (cond_string);
11297
11298   return cond_string;
11299 }
11300
11301 /* Commands to deal with catching events, such as signals, exceptions,
11302    process start/exit, etc.  */
11303
11304 typedef enum
11305 {
11306   catch_fork_temporary, catch_vfork_temporary,
11307   catch_fork_permanent, catch_vfork_permanent
11308 }
11309 catch_fork_kind;
11310
11311 static void
11312 catch_fork_command_1 (const char *arg, int from_tty,
11313                       struct cmd_list_element *command)
11314 {
11315   struct gdbarch *gdbarch = get_current_arch ();
11316   const char *cond_string = NULL;
11317   catch_fork_kind fork_kind;
11318   int tempflag;
11319
11320   fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11321   tempflag = (fork_kind == catch_fork_temporary
11322               || fork_kind == catch_vfork_temporary);
11323
11324   if (!arg)
11325     arg = "";
11326   arg = skip_spaces (arg);
11327
11328   /* The allowed syntax is:
11329      catch [v]fork
11330      catch [v]fork if <cond>
11331
11332      First, check if there's an if clause.  */
11333   cond_string = ep_parse_optional_if_clause (&arg);
11334
11335   if ((*arg != '\0') && !isspace (*arg))
11336     error (_("Junk at end of arguments."));
11337
11338   /* If this target supports it, create a fork or vfork catchpoint
11339      and enable reporting of such events.  */
11340   switch (fork_kind)
11341     {
11342     case catch_fork_temporary:
11343     case catch_fork_permanent:
11344       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11345                                           &catch_fork_breakpoint_ops);
11346       break;
11347     case catch_vfork_temporary:
11348     case catch_vfork_permanent:
11349       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11350                                           &catch_vfork_breakpoint_ops);
11351       break;
11352     default:
11353       error (_("unsupported or unknown fork kind; cannot catch it"));
11354       break;
11355     }
11356 }
11357
11358 static void
11359 catch_exec_command_1 (const char *arg, int from_tty,
11360                       struct cmd_list_element *command)
11361 {
11362   struct gdbarch *gdbarch = get_current_arch ();
11363   int tempflag;
11364   const char *cond_string = NULL;
11365
11366   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11367
11368   if (!arg)
11369     arg = "";
11370   arg = skip_spaces (arg);
11371
11372   /* The allowed syntax is:
11373      catch exec
11374      catch exec if <cond>
11375
11376      First, check if there's an if clause.  */
11377   cond_string = ep_parse_optional_if_clause (&arg);
11378
11379   if ((*arg != '\0') && !isspace (*arg))
11380     error (_("Junk at end of arguments."));
11381
11382   std::unique_ptr<exec_catchpoint> c (new exec_catchpoint ());
11383   init_catchpoint (c.get (), gdbarch, tempflag, cond_string,
11384                    &catch_exec_breakpoint_ops);
11385   c->exec_pathname = NULL;
11386
11387   install_breakpoint (0, std::move (c), 1);
11388 }
11389
11390 void
11391 init_ada_exception_breakpoint (struct breakpoint *b,
11392                                struct gdbarch *gdbarch,
11393                                struct symtab_and_line sal,
11394                                const char *addr_string,
11395                                const struct breakpoint_ops *ops,
11396                                int tempflag,
11397                                int enabled,
11398                                int from_tty)
11399 {
11400   if (from_tty)
11401     {
11402       struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11403       if (!loc_gdbarch)
11404         loc_gdbarch = gdbarch;
11405
11406       describe_other_breakpoints (loc_gdbarch,
11407                                   sal.pspace, sal.pc, sal.section, -1);
11408       /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11409          version for exception catchpoints, because two catchpoints
11410          used for different exception names will use the same address.
11411          In this case, a "breakpoint ... also set at..." warning is
11412          unproductive.  Besides, the warning phrasing is also a bit
11413          inappropriate, we should use the word catchpoint, and tell
11414          the user what type of catchpoint it is.  The above is good
11415          enough for now, though.  */
11416     }
11417
11418   init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
11419
11420   b->enable_state = enabled ? bp_enabled : bp_disabled;
11421   b->disposition = tempflag ? disp_del : disp_donttouch;
11422   b->location = string_to_event_location (&addr_string,
11423                                           language_def (language_ada));
11424   b->language = language_ada;
11425 }
11426
11427 static void
11428 catch_command (const char *arg, int from_tty)
11429 {
11430   error (_("Catch requires an event name."));
11431 }
11432 \f
11433
11434 static void
11435 tcatch_command (const char *arg, int from_tty)
11436 {
11437   error (_("Catch requires an event name."));
11438 }
11439
11440 /* Compare two breakpoints and return a strcmp-like result.  */
11441
11442 static int
11443 compare_breakpoints (const breakpoint *a, const breakpoint *b)
11444 {
11445   uintptr_t ua = (uintptr_t) a;
11446   uintptr_t ub = (uintptr_t) b;
11447
11448   if (a->number < b->number)
11449     return -1;
11450   else if (a->number > b->number)
11451     return 1;
11452
11453   /* Now sort by address, in case we see, e..g, two breakpoints with
11454      the number 0.  */
11455   if (ua < ub)
11456     return -1;
11457   return ua > ub ? 1 : 0;
11458 }
11459
11460 /* Delete breakpoints by address or line.  */
11461
11462 static void
11463 clear_command (const char *arg, int from_tty)
11464 {
11465   struct breakpoint *b;
11466   int default_match;
11467
11468   std::vector<symtab_and_line> decoded_sals;
11469   symtab_and_line last_sal;
11470   gdb::array_view<symtab_and_line> sals;
11471   if (arg)
11472     {
11473       decoded_sals
11474         = decode_line_with_current_source (arg,
11475                                            (DECODE_LINE_FUNFIRSTLINE
11476                                             | DECODE_LINE_LIST_MODE));
11477       default_match = 0;
11478       sals = decoded_sals;
11479     }
11480   else
11481     {
11482       /* Set sal's line, symtab, pc, and pspace to the values
11483          corresponding to the last call to print_frame_info.  If the
11484          codepoint is not valid, this will set all the fields to 0.  */
11485       last_sal = get_last_displayed_sal ();
11486       if (last_sal.symtab == 0)
11487         error (_("No source file specified."));
11488
11489       default_match = 1;
11490       sals = last_sal;
11491     }
11492
11493   /* We don't call resolve_sal_pc here.  That's not as bad as it
11494      seems, because all existing breakpoints typically have both
11495      file/line and pc set.  So, if clear is given file/line, we can
11496      match this to existing breakpoint without obtaining pc at all.
11497
11498      We only support clearing given the address explicitly 
11499      present in breakpoint table.  Say, we've set breakpoint 
11500      at file:line.  There were several PC values for that file:line,
11501      due to optimization, all in one block.
11502
11503      We've picked one PC value.  If "clear" is issued with another
11504      PC corresponding to the same file:line, the breakpoint won't
11505      be cleared.  We probably can still clear the breakpoint, but 
11506      since the other PC value is never presented to user, user
11507      can only find it by guessing, and it does not seem important
11508      to support that.  */
11509
11510   /* For each line spec given, delete bps which correspond to it.  Do
11511      it in two passes, solely to preserve the current behavior that
11512      from_tty is forced true if we delete more than one
11513      breakpoint.  */
11514
11515   std::vector<struct breakpoint *> found;
11516   for (const auto &sal : sals)
11517     {
11518       const char *sal_fullname;
11519
11520       /* If exact pc given, clear bpts at that pc.
11521          If line given (pc == 0), clear all bpts on specified line.
11522          If defaulting, clear all bpts on default line
11523          or at default pc.
11524
11525          defaulting    sal.pc != 0    tests to do
11526
11527          0              1             pc
11528          1              1             pc _and_ line
11529          0              0             line
11530          1              0             <can't happen> */
11531
11532       sal_fullname = (sal.symtab == NULL
11533                       ? NULL : symtab_to_fullname (sal.symtab));
11534
11535       /* Find all matching breakpoints and add them to 'found'.  */
11536       ALL_BREAKPOINTS (b)
11537         {
11538           int match = 0;
11539           /* Are we going to delete b?  */
11540           if (b->type != bp_none && !is_watchpoint (b))
11541             {
11542               struct bp_location *loc = b->loc;
11543               for (; loc; loc = loc->next)
11544                 {
11545                   /* If the user specified file:line, don't allow a PC
11546                      match.  This matches historical gdb behavior.  */
11547                   int pc_match = (!sal.explicit_line
11548                                   && sal.pc
11549                                   && (loc->pspace == sal.pspace)
11550                                   && (loc->address == sal.pc)
11551                                   && (!section_is_overlay (loc->section)
11552                                       || loc->section == sal.section));
11553                   int line_match = 0;
11554
11555                   if ((default_match || sal.explicit_line)
11556                       && loc->symtab != NULL
11557                       && sal_fullname != NULL
11558                       && sal.pspace == loc->pspace
11559                       && loc->line_number == sal.line
11560                       && filename_cmp (symtab_to_fullname (loc->symtab),
11561                                        sal_fullname) == 0)
11562                     line_match = 1;
11563
11564                   if (pc_match || line_match)
11565                     {
11566                       match = 1;
11567                       break;
11568                     }
11569                 }
11570             }
11571
11572           if (match)
11573             found.push_back (b);
11574         }
11575     }
11576
11577   /* Now go thru the 'found' chain and delete them.  */
11578   if (found.empty ())
11579     {
11580       if (arg)
11581         error (_("No breakpoint at %s."), arg);
11582       else
11583         error (_("No breakpoint at this line."));
11584     }
11585
11586   /* Remove duplicates from the vec.  */
11587   std::sort (found.begin (), found.end (),
11588              [] (const breakpoint *a, const breakpoint *b)
11589              {
11590                return compare_breakpoints (a, b) < 0;
11591              });
11592   found.erase (std::unique (found.begin (), found.end (),
11593                             [] (const breakpoint *a, const breakpoint *b)
11594                             {
11595                               return compare_breakpoints (a, b) == 0;
11596                             }),
11597                found.end ());
11598
11599   if (found.size () > 1)
11600     from_tty = 1;       /* Always report if deleted more than one.  */
11601   if (from_tty)
11602     {
11603       if (found.size () == 1)
11604         printf_unfiltered (_("Deleted breakpoint "));
11605       else
11606         printf_unfiltered (_("Deleted breakpoints "));
11607     }
11608
11609   for (breakpoint *iter : found)
11610     {
11611       if (from_tty)
11612         printf_unfiltered ("%d ", iter->number);
11613       delete_breakpoint (iter);
11614     }
11615   if (from_tty)
11616     putchar_unfiltered ('\n');
11617 }
11618 \f
11619 /* Delete breakpoint in BS if they are `delete' breakpoints and
11620    all breakpoints that are marked for deletion, whether hit or not.
11621    This is called after any breakpoint is hit, or after errors.  */
11622
11623 void
11624 breakpoint_auto_delete (bpstat bs)
11625 {
11626   struct breakpoint *b, *b_tmp;
11627
11628   for (; bs; bs = bs->next)
11629     if (bs->breakpoint_at
11630         && bs->breakpoint_at->disposition == disp_del
11631         && bs->stop)
11632       delete_breakpoint (bs->breakpoint_at);
11633
11634   ALL_BREAKPOINTS_SAFE (b, b_tmp)
11635   {
11636     if (b->disposition == disp_del_at_next_stop)
11637       delete_breakpoint (b);
11638   }
11639 }
11640
11641 /* A comparison function for bp_location AP and BP being interfaced to
11642    qsort.  Sort elements primarily by their ADDRESS (no matter what
11643    does breakpoint_address_is_meaningful say for its OWNER),
11644    secondarily by ordering first permanent elements and
11645    terciarily just ensuring the array is sorted stable way despite
11646    qsort being an unstable algorithm.  */
11647
11648 static int
11649 bp_locations_compare (const void *ap, const void *bp)
11650 {
11651   const struct bp_location *a = *(const struct bp_location **) ap;
11652   const struct bp_location *b = *(const struct bp_location **) bp;
11653
11654   if (a->address != b->address)
11655     return (a->address > b->address) - (a->address < b->address);
11656
11657   /* Sort locations at the same address by their pspace number, keeping
11658      locations of the same inferior (in a multi-inferior environment)
11659      grouped.  */
11660
11661   if (a->pspace->num != b->pspace->num)
11662     return ((a->pspace->num > b->pspace->num)
11663             - (a->pspace->num < b->pspace->num));
11664
11665   /* Sort permanent breakpoints first.  */
11666   if (a->permanent != b->permanent)
11667     return (a->permanent < b->permanent) - (a->permanent > b->permanent);
11668
11669   /* Make the internal GDB representation stable across GDB runs
11670      where A and B memory inside GDB can differ.  Breakpoint locations of
11671      the same type at the same address can be sorted in arbitrary order.  */
11672
11673   if (a->owner->number != b->owner->number)
11674     return ((a->owner->number > b->owner->number)
11675             - (a->owner->number < b->owner->number));
11676
11677   return (a > b) - (a < b);
11678 }
11679
11680 /* Set bp_locations_placed_address_before_address_max and
11681    bp_locations_shadow_len_after_address_max according to the current
11682    content of the bp_locations array.  */
11683
11684 static void
11685 bp_locations_target_extensions_update (void)
11686 {
11687   struct bp_location *bl, **blp_tmp;
11688
11689   bp_locations_placed_address_before_address_max = 0;
11690   bp_locations_shadow_len_after_address_max = 0;
11691
11692   ALL_BP_LOCATIONS (bl, blp_tmp)
11693     {
11694       CORE_ADDR start, end, addr;
11695
11696       if (!bp_location_has_shadow (bl))
11697         continue;
11698
11699       start = bl->target_info.placed_address;
11700       end = start + bl->target_info.shadow_len;
11701
11702       gdb_assert (bl->address >= start);
11703       addr = bl->address - start;
11704       if (addr > bp_locations_placed_address_before_address_max)
11705         bp_locations_placed_address_before_address_max = addr;
11706
11707       /* Zero SHADOW_LEN would not pass bp_location_has_shadow.  */
11708
11709       gdb_assert (bl->address < end);
11710       addr = end - bl->address;
11711       if (addr > bp_locations_shadow_len_after_address_max)
11712         bp_locations_shadow_len_after_address_max = addr;
11713     }
11714 }
11715
11716 /* Download tracepoint locations if they haven't been.  */
11717
11718 static void
11719 download_tracepoint_locations (void)
11720 {
11721   struct breakpoint *b;
11722   enum tribool can_download_tracepoint = TRIBOOL_UNKNOWN;
11723
11724   scoped_restore_current_pspace_and_thread restore_pspace_thread;
11725
11726   ALL_TRACEPOINTS (b)
11727     {
11728       struct bp_location *bl;
11729       struct tracepoint *t;
11730       int bp_location_downloaded = 0;
11731
11732       if ((b->type == bp_fast_tracepoint
11733            ? !may_insert_fast_tracepoints
11734            : !may_insert_tracepoints))
11735         continue;
11736
11737       if (can_download_tracepoint == TRIBOOL_UNKNOWN)
11738         {
11739           if (target_can_download_tracepoint ())
11740             can_download_tracepoint = TRIBOOL_TRUE;
11741           else
11742             can_download_tracepoint = TRIBOOL_FALSE;
11743         }
11744
11745       if (can_download_tracepoint == TRIBOOL_FALSE)
11746         break;
11747
11748       for (bl = b->loc; bl; bl = bl->next)
11749         {
11750           /* In tracepoint, locations are _never_ duplicated, so
11751              should_be_inserted is equivalent to
11752              unduplicated_should_be_inserted.  */
11753           if (!should_be_inserted (bl) || bl->inserted)
11754             continue;
11755
11756           switch_to_program_space_and_thread (bl->pspace);
11757
11758           target_download_tracepoint (bl);
11759
11760           bl->inserted = 1;
11761           bp_location_downloaded = 1;
11762         }
11763       t = (struct tracepoint *) b;
11764       t->number_on_target = b->number;
11765       if (bp_location_downloaded)
11766         observer_notify_breakpoint_modified (b);
11767     }
11768 }
11769
11770 /* Swap the insertion/duplication state between two locations.  */
11771
11772 static void
11773 swap_insertion (struct bp_location *left, struct bp_location *right)
11774 {
11775   const int left_inserted = left->inserted;
11776   const int left_duplicate = left->duplicate;
11777   const int left_needs_update = left->needs_update;
11778   const struct bp_target_info left_target_info = left->target_info;
11779
11780   /* Locations of tracepoints can never be duplicated.  */
11781   if (is_tracepoint (left->owner))
11782     gdb_assert (!left->duplicate);
11783   if (is_tracepoint (right->owner))
11784     gdb_assert (!right->duplicate);
11785
11786   left->inserted = right->inserted;
11787   left->duplicate = right->duplicate;
11788   left->needs_update = right->needs_update;
11789   left->target_info = right->target_info;
11790   right->inserted = left_inserted;
11791   right->duplicate = left_duplicate;
11792   right->needs_update = left_needs_update;
11793   right->target_info = left_target_info;
11794 }
11795
11796 /* Force the re-insertion of the locations at ADDRESS.  This is called
11797    once a new/deleted/modified duplicate location is found and we are evaluating
11798    conditions on the target's side.  Such conditions need to be updated on
11799    the target.  */
11800
11801 static void
11802 force_breakpoint_reinsertion (struct bp_location *bl)
11803 {
11804   struct bp_location **locp = NULL, **loc2p;
11805   struct bp_location *loc;
11806   CORE_ADDR address = 0;
11807   int pspace_num;
11808
11809   address = bl->address;
11810   pspace_num = bl->pspace->num;
11811
11812   /* This is only meaningful if the target is
11813      evaluating conditions and if the user has
11814      opted for condition evaluation on the target's
11815      side.  */
11816   if (gdb_evaluates_breakpoint_condition_p ()
11817       || !target_supports_evaluation_of_breakpoint_conditions ())
11818     return;
11819
11820   /* Flag all breakpoint locations with this address and
11821      the same program space as the location
11822      as "its condition has changed".  We need to
11823      update the conditions on the target's side.  */
11824   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
11825     {
11826       loc = *loc2p;
11827
11828       if (!is_breakpoint (loc->owner)
11829           || pspace_num != loc->pspace->num)
11830         continue;
11831
11832       /* Flag the location appropriately.  We use a different state to
11833          let everyone know that we already updated the set of locations
11834          with addr bl->address and program space bl->pspace.  This is so
11835          we don't have to keep calling these functions just to mark locations
11836          that have already been marked.  */
11837       loc->condition_changed = condition_updated;
11838
11839       /* Free the agent expression bytecode as well.  We will compute
11840          it later on.  */
11841       loc->cond_bytecode.reset ();
11842     }
11843 }
11844 /* Called whether new breakpoints are created, or existing breakpoints
11845    deleted, to update the global location list and recompute which
11846    locations are duplicate of which.
11847
11848    The INSERT_MODE flag determines whether locations may not, may, or
11849    shall be inserted now.  See 'enum ugll_insert_mode' for more
11850    info.  */
11851
11852 static void
11853 update_global_location_list (enum ugll_insert_mode insert_mode)
11854 {
11855   struct breakpoint *b;
11856   struct bp_location **locp, *loc;
11857   /* Last breakpoint location address that was marked for update.  */
11858   CORE_ADDR last_addr = 0;
11859   /* Last breakpoint location program space that was marked for update.  */
11860   int last_pspace_num = -1;
11861
11862   /* Used in the duplicates detection below.  When iterating over all
11863      bp_locations, points to the first bp_location of a given address.
11864      Breakpoints and watchpoints of different types are never
11865      duplicates of each other.  Keep one pointer for each type of
11866      breakpoint/watchpoint, so we only need to loop over all locations
11867      once.  */
11868   struct bp_location *bp_loc_first;  /* breakpoint */
11869   struct bp_location *wp_loc_first;  /* hardware watchpoint */
11870   struct bp_location *awp_loc_first; /* access watchpoint */
11871   struct bp_location *rwp_loc_first; /* read watchpoint */
11872
11873   /* Saved former bp_locations array which we compare against the newly
11874      built bp_locations from the current state of ALL_BREAKPOINTS.  */
11875   struct bp_location **old_locp;
11876   unsigned old_locations_count;
11877   gdb::unique_xmalloc_ptr<struct bp_location *> old_locations (bp_locations);
11878
11879   old_locations_count = bp_locations_count;
11880   bp_locations = NULL;
11881   bp_locations_count = 0;
11882
11883   ALL_BREAKPOINTS (b)
11884     for (loc = b->loc; loc; loc = loc->next)
11885       bp_locations_count++;
11886
11887   bp_locations = XNEWVEC (struct bp_location *, bp_locations_count);
11888   locp = bp_locations;
11889   ALL_BREAKPOINTS (b)
11890     for (loc = b->loc; loc; loc = loc->next)
11891       *locp++ = loc;
11892   qsort (bp_locations, bp_locations_count, sizeof (*bp_locations),
11893          bp_locations_compare);
11894
11895   bp_locations_target_extensions_update ();
11896
11897   /* Identify bp_location instances that are no longer present in the
11898      new list, and therefore should be freed.  Note that it's not
11899      necessary that those locations should be removed from inferior --
11900      if there's another location at the same address (previously
11901      marked as duplicate), we don't need to remove/insert the
11902      location.
11903      
11904      LOCP is kept in sync with OLD_LOCP, each pointing to the current
11905      and former bp_location array state respectively.  */
11906
11907   locp = bp_locations;
11908   for (old_locp = old_locations.get ();
11909        old_locp < old_locations.get () + old_locations_count;
11910        old_locp++)
11911     {
11912       struct bp_location *old_loc = *old_locp;
11913       struct bp_location **loc2p;
11914
11915       /* Tells if 'old_loc' is found among the new locations.  If
11916          not, we have to free it.  */
11917       int found_object = 0;
11918       /* Tells if the location should remain inserted in the target.  */
11919       int keep_in_target = 0;
11920       int removed = 0;
11921
11922       /* Skip LOCP entries which will definitely never be needed.
11923          Stop either at or being the one matching OLD_LOC.  */
11924       while (locp < bp_locations + bp_locations_count
11925              && (*locp)->address < old_loc->address)
11926         locp++;
11927
11928       for (loc2p = locp;
11929            (loc2p < bp_locations + bp_locations_count
11930             && (*loc2p)->address == old_loc->address);
11931            loc2p++)
11932         {
11933           /* Check if this is a new/duplicated location or a duplicated
11934              location that had its condition modified.  If so, we want to send
11935              its condition to the target if evaluation of conditions is taking
11936              place there.  */
11937           if ((*loc2p)->condition_changed == condition_modified
11938               && (last_addr != old_loc->address
11939                   || last_pspace_num != old_loc->pspace->num))
11940             {
11941               force_breakpoint_reinsertion (*loc2p);
11942               last_pspace_num = old_loc->pspace->num;
11943             }
11944
11945           if (*loc2p == old_loc)
11946             found_object = 1;
11947         }
11948
11949       /* We have already handled this address, update it so that we don't
11950          have to go through updates again.  */
11951       last_addr = old_loc->address;
11952
11953       /* Target-side condition evaluation: Handle deleted locations.  */
11954       if (!found_object)
11955         force_breakpoint_reinsertion (old_loc);
11956
11957       /* If this location is no longer present, and inserted, look if
11958          there's maybe a new location at the same address.  If so,
11959          mark that one inserted, and don't remove this one.  This is
11960          needed so that we don't have a time window where a breakpoint
11961          at certain location is not inserted.  */
11962
11963       if (old_loc->inserted)
11964         {
11965           /* If the location is inserted now, we might have to remove
11966              it.  */
11967
11968           if (found_object && should_be_inserted (old_loc))
11969             {
11970               /* The location is still present in the location list,
11971                  and still should be inserted.  Don't do anything.  */
11972               keep_in_target = 1;
11973             }
11974           else
11975             {
11976               /* This location still exists, but it won't be kept in the
11977                  target since it may have been disabled.  We proceed to
11978                  remove its target-side condition.  */
11979
11980               /* The location is either no longer present, or got
11981                  disabled.  See if there's another location at the
11982                  same address, in which case we don't need to remove
11983                  this one from the target.  */
11984
11985               /* OLD_LOC comes from existing struct breakpoint.  */
11986               if (breakpoint_address_is_meaningful (old_loc->owner))
11987                 {
11988                   for (loc2p = locp;
11989                        (loc2p < bp_locations + bp_locations_count
11990                         && (*loc2p)->address == old_loc->address);
11991                        loc2p++)
11992                     {
11993                       struct bp_location *loc2 = *loc2p;
11994
11995                       if (breakpoint_locations_match (loc2, old_loc))
11996                         {
11997                           /* Read watchpoint locations are switched to
11998                              access watchpoints, if the former are not
11999                              supported, but the latter are.  */
12000                           if (is_hardware_watchpoint (old_loc->owner))
12001                             {
12002                               gdb_assert (is_hardware_watchpoint (loc2->owner));
12003                               loc2->watchpoint_type = old_loc->watchpoint_type;
12004                             }
12005
12006                           /* loc2 is a duplicated location. We need to check
12007                              if it should be inserted in case it will be
12008                              unduplicated.  */
12009                           if (loc2 != old_loc
12010                               && unduplicated_should_be_inserted (loc2))
12011                             {
12012                               swap_insertion (old_loc, loc2);
12013                               keep_in_target = 1;
12014                               break;
12015                             }
12016                         }
12017                     }
12018                 }
12019             }
12020
12021           if (!keep_in_target)
12022             {
12023               if (remove_breakpoint (old_loc))
12024                 {
12025                   /* This is just about all we can do.  We could keep
12026                      this location on the global list, and try to
12027                      remove it next time, but there's no particular
12028                      reason why we will succeed next time.
12029                      
12030                      Note that at this point, old_loc->owner is still
12031                      valid, as delete_breakpoint frees the breakpoint
12032                      only after calling us.  */
12033                   printf_filtered (_("warning: Error removing "
12034                                      "breakpoint %d\n"), 
12035                                    old_loc->owner->number);
12036                 }
12037               removed = 1;
12038             }
12039         }
12040
12041       if (!found_object)
12042         {
12043           if (removed && target_is_non_stop_p ()
12044               && need_moribund_for_location_type (old_loc))
12045             {
12046               /* This location was removed from the target.  In
12047                  non-stop mode, a race condition is possible where
12048                  we've removed a breakpoint, but stop events for that
12049                  breakpoint are already queued and will arrive later.
12050                  We apply an heuristic to be able to distinguish such
12051                  SIGTRAPs from other random SIGTRAPs: we keep this
12052                  breakpoint location for a bit, and will retire it
12053                  after we see some number of events.  The theory here
12054                  is that reporting of events should, "on the average",
12055                  be fair, so after a while we'll see events from all
12056                  threads that have anything of interest, and no longer
12057                  need to keep this breakpoint location around.  We
12058                  don't hold locations forever so to reduce chances of
12059                  mistaking a non-breakpoint SIGTRAP for a breakpoint
12060                  SIGTRAP.
12061
12062                  The heuristic failing can be disastrous on
12063                  decr_pc_after_break targets.
12064
12065                  On decr_pc_after_break targets, like e.g., x86-linux,
12066                  if we fail to recognize a late breakpoint SIGTRAP,
12067                  because events_till_retirement has reached 0 too
12068                  soon, we'll fail to do the PC adjustment, and report
12069                  a random SIGTRAP to the user.  When the user resumes
12070                  the inferior, it will most likely immediately crash
12071                  with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12072                  corrupted, because of being resumed e.g., in the
12073                  middle of a multi-byte instruction, or skipped a
12074                  one-byte instruction.  This was actually seen happen
12075                  on native x86-linux, and should be less rare on
12076                  targets that do not support new thread events, like
12077                  remote, due to the heuristic depending on
12078                  thread_count.
12079
12080                  Mistaking a random SIGTRAP for a breakpoint trap
12081                  causes similar symptoms (PC adjustment applied when
12082                  it shouldn't), but then again, playing with SIGTRAPs
12083                  behind the debugger's back is asking for trouble.
12084
12085                  Since hardware watchpoint traps are always
12086                  distinguishable from other traps, so we don't need to
12087                  apply keep hardware watchpoint moribund locations
12088                  around.  We simply always ignore hardware watchpoint
12089                  traps we can no longer explain.  */
12090
12091               old_loc->events_till_retirement = 3 * (thread_count () + 1);
12092               old_loc->owner = NULL;
12093
12094               VEC_safe_push (bp_location_p, moribund_locations, old_loc);
12095             }
12096           else
12097             {
12098               old_loc->owner = NULL;
12099               decref_bp_location (&old_loc);
12100             }
12101         }
12102     }
12103
12104   /* Rescan breakpoints at the same address and section, marking the
12105      first one as "first" and any others as "duplicates".  This is so
12106      that the bpt instruction is only inserted once.  If we have a
12107      permanent breakpoint at the same place as BPT, make that one the
12108      official one, and the rest as duplicates.  Permanent breakpoints
12109      are sorted first for the same address.
12110
12111      Do the same for hardware watchpoints, but also considering the
12112      watchpoint's type (regular/access/read) and length.  */
12113
12114   bp_loc_first = NULL;
12115   wp_loc_first = NULL;
12116   awp_loc_first = NULL;
12117   rwp_loc_first = NULL;
12118   ALL_BP_LOCATIONS (loc, locp)
12119     {
12120       /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12121          non-NULL.  */
12122       struct bp_location **loc_first_p;
12123       b = loc->owner;
12124
12125       if (!unduplicated_should_be_inserted (loc)
12126           || !breakpoint_address_is_meaningful (b)
12127           /* Don't detect duplicate for tracepoint locations because they are
12128            never duplicated.  See the comments in field `duplicate' of
12129            `struct bp_location'.  */
12130           || is_tracepoint (b))
12131         {
12132           /* Clear the condition modification flag.  */
12133           loc->condition_changed = condition_unchanged;
12134           continue;
12135         }
12136
12137       if (b->type == bp_hardware_watchpoint)
12138         loc_first_p = &wp_loc_first;
12139       else if (b->type == bp_read_watchpoint)
12140         loc_first_p = &rwp_loc_first;
12141       else if (b->type == bp_access_watchpoint)
12142         loc_first_p = &awp_loc_first;
12143       else
12144         loc_first_p = &bp_loc_first;
12145
12146       if (*loc_first_p == NULL
12147           || (overlay_debugging && loc->section != (*loc_first_p)->section)
12148           || !breakpoint_locations_match (loc, *loc_first_p))
12149         {
12150           *loc_first_p = loc;
12151           loc->duplicate = 0;
12152
12153           if (is_breakpoint (loc->owner) && loc->condition_changed)
12154             {
12155               loc->needs_update = 1;
12156               /* Clear the condition modification flag.  */
12157               loc->condition_changed = condition_unchanged;
12158             }
12159           continue;
12160         }
12161
12162
12163       /* This and the above ensure the invariant that the first location
12164          is not duplicated, and is the inserted one.
12165          All following are marked as duplicated, and are not inserted.  */
12166       if (loc->inserted)
12167         swap_insertion (loc, *loc_first_p);
12168       loc->duplicate = 1;
12169
12170       /* Clear the condition modification flag.  */
12171       loc->condition_changed = condition_unchanged;
12172     }
12173
12174   if (insert_mode == UGLL_INSERT || breakpoints_should_be_inserted_now ())
12175     {
12176       if (insert_mode != UGLL_DONT_INSERT)
12177         insert_breakpoint_locations ();
12178       else
12179         {
12180           /* Even though the caller told us to not insert new
12181              locations, we may still need to update conditions on the
12182              target's side of breakpoints that were already inserted
12183              if the target is evaluating breakpoint conditions.  We
12184              only update conditions for locations that are marked
12185              "needs_update".  */
12186           update_inserted_breakpoint_locations ();
12187         }
12188     }
12189
12190   if (insert_mode != UGLL_DONT_INSERT)
12191     download_tracepoint_locations ();
12192 }
12193
12194 void
12195 breakpoint_retire_moribund (void)
12196 {
12197   struct bp_location *loc;
12198   int ix;
12199
12200   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
12201     if (--(loc->events_till_retirement) == 0)
12202       {
12203         decref_bp_location (&loc);
12204         VEC_unordered_remove (bp_location_p, moribund_locations, ix);
12205         --ix;
12206       }
12207 }
12208
12209 static void
12210 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode)
12211 {
12212
12213   TRY
12214     {
12215       update_global_location_list (insert_mode);
12216     }
12217   CATCH (e, RETURN_MASK_ERROR)
12218     {
12219     }
12220   END_CATCH
12221 }
12222
12223 /* Clear BKP from a BPS.  */
12224
12225 static void
12226 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12227 {
12228   bpstat bs;
12229
12230   for (bs = bps; bs; bs = bs->next)
12231     if (bs->breakpoint_at == bpt)
12232       {
12233         bs->breakpoint_at = NULL;
12234         bs->old_val = NULL;
12235         /* bs->commands will be freed later.  */
12236       }
12237 }
12238
12239 /* Callback for iterate_over_threads.  */
12240 static int
12241 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12242 {
12243   struct breakpoint *bpt = (struct breakpoint *) data;
12244
12245   bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12246   return 0;
12247 }
12248
12249 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12250    callbacks.  */
12251
12252 static void
12253 say_where (struct breakpoint *b)
12254 {
12255   struct value_print_options opts;
12256
12257   get_user_print_options (&opts);
12258
12259   /* i18n: cagney/2005-02-11: Below needs to be merged into a
12260      single string.  */
12261   if (b->loc == NULL)
12262     {
12263       /* For pending locations, the output differs slightly based
12264          on b->extra_string.  If this is non-NULL, it contains either
12265          a condition or dprintf arguments.  */
12266       if (b->extra_string == NULL)
12267         {
12268           printf_filtered (_(" (%s) pending."),
12269                            event_location_to_string (b->location.get ()));
12270         }
12271       else if (b->type == bp_dprintf)
12272         {
12273           printf_filtered (_(" (%s,%s) pending."),
12274                            event_location_to_string (b->location.get ()),
12275                            b->extra_string);
12276         }
12277       else
12278         {
12279           printf_filtered (_(" (%s %s) pending."),
12280                            event_location_to_string (b->location.get ()),
12281                            b->extra_string);
12282         }
12283     }
12284   else
12285     {
12286       if (opts.addressprint || b->loc->symtab == NULL)
12287         {
12288           printf_filtered (" at ");
12289           fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
12290                           gdb_stdout);
12291         }
12292       if (b->loc->symtab != NULL)
12293         {
12294           /* If there is a single location, we can print the location
12295              more nicely.  */
12296           if (b->loc->next == NULL)
12297             printf_filtered (": file %s, line %d.",
12298                              symtab_to_filename_for_display (b->loc->symtab),
12299                              b->loc->line_number);
12300           else
12301             /* This is not ideal, but each location may have a
12302                different file name, and this at least reflects the
12303                real situation somewhat.  */
12304             printf_filtered (": %s.",
12305                              event_location_to_string (b->location.get ()));
12306         }
12307
12308       if (b->loc->next)
12309         {
12310           struct bp_location *loc = b->loc;
12311           int n = 0;
12312           for (; loc; loc = loc->next)
12313             ++n;
12314           printf_filtered (" (%d locations)", n);
12315         }
12316     }
12317 }
12318
12319 /* Default bp_location_ops methods.  */
12320
12321 static void
12322 bp_location_dtor (struct bp_location *self)
12323 {
12324   xfree (self->function_name);
12325 }
12326
12327 static const struct bp_location_ops bp_location_ops =
12328 {
12329   bp_location_dtor
12330 };
12331
12332 /* Destructor for the breakpoint base class.  */
12333
12334 breakpoint::~breakpoint ()
12335 {
12336   xfree (this->cond_string);
12337   xfree (this->extra_string);
12338   xfree (this->filter);
12339 }
12340
12341 static struct bp_location *
12342 base_breakpoint_allocate_location (struct breakpoint *self)
12343 {
12344   return new bp_location (&bp_location_ops, self);
12345 }
12346
12347 static void
12348 base_breakpoint_re_set (struct breakpoint *b)
12349 {
12350   /* Nothing to re-set. */
12351 }
12352
12353 #define internal_error_pure_virtual_called() \
12354   gdb_assert_not_reached ("pure virtual function called")
12355
12356 static int
12357 base_breakpoint_insert_location (struct bp_location *bl)
12358 {
12359   internal_error_pure_virtual_called ();
12360 }
12361
12362 static int
12363 base_breakpoint_remove_location (struct bp_location *bl,
12364                                  enum remove_bp_reason reason)
12365 {
12366   internal_error_pure_virtual_called ();
12367 }
12368
12369 static int
12370 base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12371                                 const address_space *aspace,
12372                                 CORE_ADDR bp_addr,
12373                                 const struct target_waitstatus *ws)
12374 {
12375   internal_error_pure_virtual_called ();
12376 }
12377
12378 static void
12379 base_breakpoint_check_status (bpstat bs)
12380 {
12381   /* Always stop.   */
12382 }
12383
12384 /* A "works_in_software_mode" breakpoint_ops method that just internal
12385    errors.  */
12386
12387 static int
12388 base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12389 {
12390   internal_error_pure_virtual_called ();
12391 }
12392
12393 /* A "resources_needed" breakpoint_ops method that just internal
12394    errors.  */
12395
12396 static int
12397 base_breakpoint_resources_needed (const struct bp_location *bl)
12398 {
12399   internal_error_pure_virtual_called ();
12400 }
12401
12402 static enum print_stop_action
12403 base_breakpoint_print_it (bpstat bs)
12404 {
12405   internal_error_pure_virtual_called ();
12406 }
12407
12408 static void
12409 base_breakpoint_print_one_detail (const struct breakpoint *self,
12410                                   struct ui_out *uiout)
12411 {
12412   /* nothing */
12413 }
12414
12415 static void
12416 base_breakpoint_print_mention (struct breakpoint *b)
12417 {
12418   internal_error_pure_virtual_called ();
12419 }
12420
12421 static void
12422 base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12423 {
12424   internal_error_pure_virtual_called ();
12425 }
12426
12427 static void
12428 base_breakpoint_create_sals_from_location
12429   (const struct event_location *location,
12430    struct linespec_result *canonical,
12431    enum bptype type_wanted)
12432 {
12433   internal_error_pure_virtual_called ();
12434 }
12435
12436 static void
12437 base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12438                                         struct linespec_result *c,
12439                                         gdb::unique_xmalloc_ptr<char> cond_string,
12440                                         gdb::unique_xmalloc_ptr<char> extra_string,
12441                                         enum bptype type_wanted,
12442                                         enum bpdisp disposition,
12443                                         int thread,
12444                                         int task, int ignore_count,
12445                                         const struct breakpoint_ops *o,
12446                                         int from_tty, int enabled,
12447                                         int internal, unsigned flags)
12448 {
12449   internal_error_pure_virtual_called ();
12450 }
12451
12452 static std::vector<symtab_and_line>
12453 base_breakpoint_decode_location (struct breakpoint *b,
12454                                  const struct event_location *location,
12455                                  struct program_space *search_pspace)
12456 {
12457   internal_error_pure_virtual_called ();
12458 }
12459
12460 /* The default 'explains_signal' method.  */
12461
12462 static int
12463 base_breakpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
12464 {
12465   return 1;
12466 }
12467
12468 /* The default "after_condition_true" method.  */
12469
12470 static void
12471 base_breakpoint_after_condition_true (struct bpstats *bs)
12472 {
12473   /* Nothing to do.   */
12474 }
12475
12476 struct breakpoint_ops base_breakpoint_ops =
12477 {
12478   base_breakpoint_allocate_location,
12479   base_breakpoint_re_set,
12480   base_breakpoint_insert_location,
12481   base_breakpoint_remove_location,
12482   base_breakpoint_breakpoint_hit,
12483   base_breakpoint_check_status,
12484   base_breakpoint_resources_needed,
12485   base_breakpoint_works_in_software_mode,
12486   base_breakpoint_print_it,
12487   NULL,
12488   base_breakpoint_print_one_detail,
12489   base_breakpoint_print_mention,
12490   base_breakpoint_print_recreate,
12491   base_breakpoint_create_sals_from_location,
12492   base_breakpoint_create_breakpoints_sal,
12493   base_breakpoint_decode_location,
12494   base_breakpoint_explains_signal,
12495   base_breakpoint_after_condition_true,
12496 };
12497
12498 /* Default breakpoint_ops methods.  */
12499
12500 static void
12501 bkpt_re_set (struct breakpoint *b)
12502 {
12503   /* FIXME: is this still reachable?  */
12504   if (breakpoint_event_location_empty_p (b))
12505     {
12506       /* Anything without a location can't be re-set.  */
12507       delete_breakpoint (b);
12508       return;
12509     }
12510
12511   breakpoint_re_set_default (b);
12512 }
12513
12514 static int
12515 bkpt_insert_location (struct bp_location *bl)
12516 {
12517   CORE_ADDR addr = bl->target_info.reqstd_address;
12518
12519   bl->target_info.kind = breakpoint_kind (bl, &addr);
12520   bl->target_info.placed_address = addr;
12521
12522   if (bl->loc_type == bp_loc_hardware_breakpoint)
12523     return target_insert_hw_breakpoint (bl->gdbarch, &bl->target_info);
12524   else
12525     return target_insert_breakpoint (bl->gdbarch, &bl->target_info);
12526 }
12527
12528 static int
12529 bkpt_remove_location (struct bp_location *bl, enum remove_bp_reason reason)
12530 {
12531   if (bl->loc_type == bp_loc_hardware_breakpoint)
12532     return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
12533   else
12534     return target_remove_breakpoint (bl->gdbarch, &bl->target_info, reason);
12535 }
12536
12537 static int
12538 bkpt_breakpoint_hit (const struct bp_location *bl,
12539                      const address_space *aspace, CORE_ADDR bp_addr,
12540                      const struct target_waitstatus *ws)
12541 {
12542   if (ws->kind != TARGET_WAITKIND_STOPPED
12543       || ws->value.sig != GDB_SIGNAL_TRAP)
12544     return 0;
12545
12546   if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
12547                                  aspace, bp_addr))
12548     return 0;
12549
12550   if (overlay_debugging         /* unmapped overlay section */
12551       && section_is_overlay (bl->section)
12552       && !section_is_mapped (bl->section))
12553     return 0;
12554
12555   return 1;
12556 }
12557
12558 static int
12559 dprintf_breakpoint_hit (const struct bp_location *bl,
12560                         const address_space *aspace, CORE_ADDR bp_addr,
12561                         const struct target_waitstatus *ws)
12562 {
12563   if (dprintf_style == dprintf_style_agent
12564       && target_can_run_breakpoint_commands ())
12565     {
12566       /* An agent-style dprintf never causes a stop.  If we see a trap
12567          for this address it must be for a breakpoint that happens to
12568          be set at the same address.  */
12569       return 0;
12570     }
12571
12572   return bkpt_breakpoint_hit (bl, aspace, bp_addr, ws);
12573 }
12574
12575 static int
12576 bkpt_resources_needed (const struct bp_location *bl)
12577 {
12578   gdb_assert (bl->owner->type == bp_hardware_breakpoint);
12579
12580   return 1;
12581 }
12582
12583 static enum print_stop_action
12584 bkpt_print_it (bpstat bs)
12585 {
12586   struct breakpoint *b;
12587   const struct bp_location *bl;
12588   int bp_temp;
12589   struct ui_out *uiout = current_uiout;
12590
12591   gdb_assert (bs->bp_location_at != NULL);
12592
12593   bl = bs->bp_location_at;
12594   b = bs->breakpoint_at;
12595
12596   bp_temp = b->disposition == disp_del;
12597   if (bl->address != bl->requested_address)
12598     breakpoint_adjustment_warning (bl->requested_address,
12599                                    bl->address,
12600                                    b->number, 1);
12601   annotate_breakpoint (b->number);
12602   maybe_print_thread_hit_breakpoint (uiout);
12603
12604   if (bp_temp)
12605     uiout->text ("Temporary breakpoint ");
12606   else
12607     uiout->text ("Breakpoint ");
12608   if (uiout->is_mi_like_p ())
12609     {
12610       uiout->field_string ("reason",
12611                            async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
12612       uiout->field_string ("disp", bpdisp_text (b->disposition));
12613     }
12614   uiout->field_int ("bkptno", b->number);
12615   uiout->text (", ");
12616
12617   return PRINT_SRC_AND_LOC;
12618 }
12619
12620 static void
12621 bkpt_print_mention (struct breakpoint *b)
12622 {
12623   if (current_uiout->is_mi_like_p ())
12624     return;
12625
12626   switch (b->type)
12627     {
12628     case bp_breakpoint:
12629     case bp_gnu_ifunc_resolver:
12630       if (b->disposition == disp_del)
12631         printf_filtered (_("Temporary breakpoint"));
12632       else
12633         printf_filtered (_("Breakpoint"));
12634       printf_filtered (_(" %d"), b->number);
12635       if (b->type == bp_gnu_ifunc_resolver)
12636         printf_filtered (_(" at gnu-indirect-function resolver"));
12637       break;
12638     case bp_hardware_breakpoint:
12639       printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
12640       break;
12641     case bp_dprintf:
12642       printf_filtered (_("Dprintf %d"), b->number);
12643       break;
12644     }
12645
12646   say_where (b);
12647 }
12648
12649 static void
12650 bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
12651 {
12652   if (tp->type == bp_breakpoint && tp->disposition == disp_del)
12653     fprintf_unfiltered (fp, "tbreak");
12654   else if (tp->type == bp_breakpoint)
12655     fprintf_unfiltered (fp, "break");
12656   else if (tp->type == bp_hardware_breakpoint
12657            && tp->disposition == disp_del)
12658     fprintf_unfiltered (fp, "thbreak");
12659   else if (tp->type == bp_hardware_breakpoint)
12660     fprintf_unfiltered (fp, "hbreak");
12661   else
12662     internal_error (__FILE__, __LINE__,
12663                     _("unhandled breakpoint type %d"), (int) tp->type);
12664
12665   fprintf_unfiltered (fp, " %s",
12666                       event_location_to_string (tp->location.get ()));
12667
12668   /* Print out extra_string if this breakpoint is pending.  It might
12669      contain, for example, conditions that were set by the user.  */
12670   if (tp->loc == NULL && tp->extra_string != NULL)
12671     fprintf_unfiltered (fp, " %s", tp->extra_string);
12672
12673   print_recreate_thread (tp, fp);
12674 }
12675
12676 static void
12677 bkpt_create_sals_from_location (const struct event_location *location,
12678                                 struct linespec_result *canonical,
12679                                 enum bptype type_wanted)
12680 {
12681   create_sals_from_location_default (location, canonical, type_wanted);
12682 }
12683
12684 static void
12685 bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
12686                              struct linespec_result *canonical,
12687                              gdb::unique_xmalloc_ptr<char> cond_string,
12688                              gdb::unique_xmalloc_ptr<char> extra_string,
12689                              enum bptype type_wanted,
12690                              enum bpdisp disposition,
12691                              int thread,
12692                              int task, int ignore_count,
12693                              const struct breakpoint_ops *ops,
12694                              int from_tty, int enabled,
12695                              int internal, unsigned flags)
12696 {
12697   create_breakpoints_sal_default (gdbarch, canonical,
12698                                   std::move (cond_string),
12699                                   std::move (extra_string),
12700                                   type_wanted,
12701                                   disposition, thread, task,
12702                                   ignore_count, ops, from_tty,
12703                                   enabled, internal, flags);
12704 }
12705
12706 static std::vector<symtab_and_line>
12707 bkpt_decode_location (struct breakpoint *b,
12708                       const struct event_location *location,
12709                       struct program_space *search_pspace)
12710 {
12711   return decode_location_default (b, location, search_pspace);
12712 }
12713
12714 /* Virtual table for internal breakpoints.  */
12715
12716 static void
12717 internal_bkpt_re_set (struct breakpoint *b)
12718 {
12719   switch (b->type)
12720     {
12721       /* Delete overlay event and longjmp master breakpoints; they
12722          will be reset later by breakpoint_re_set.  */
12723     case bp_overlay_event:
12724     case bp_longjmp_master:
12725     case bp_std_terminate_master:
12726     case bp_exception_master:
12727       delete_breakpoint (b);
12728       break;
12729
12730       /* This breakpoint is special, it's set up when the inferior
12731          starts and we really don't want to touch it.  */
12732     case bp_shlib_event:
12733
12734       /* Like bp_shlib_event, this breakpoint type is special.  Once
12735          it is set up, we do not want to touch it.  */
12736     case bp_thread_event:
12737       break;
12738     }
12739 }
12740
12741 static void
12742 internal_bkpt_check_status (bpstat bs)
12743 {
12744   if (bs->breakpoint_at->type == bp_shlib_event)
12745     {
12746       /* If requested, stop when the dynamic linker notifies GDB of
12747          events.  This allows the user to get control and place
12748          breakpoints in initializer routines for dynamically loaded
12749          objects (among other things).  */
12750       bs->stop = stop_on_solib_events;
12751       bs->print = stop_on_solib_events;
12752     }
12753   else
12754     bs->stop = 0;
12755 }
12756
12757 static enum print_stop_action
12758 internal_bkpt_print_it (bpstat bs)
12759 {
12760   struct breakpoint *b;
12761
12762   b = bs->breakpoint_at;
12763
12764   switch (b->type)
12765     {
12766     case bp_shlib_event:
12767       /* Did we stop because the user set the stop_on_solib_events
12768          variable?  (If so, we report this as a generic, "Stopped due
12769          to shlib event" message.) */
12770       print_solib_event (0);
12771       break;
12772
12773     case bp_thread_event:
12774       /* Not sure how we will get here.
12775          GDB should not stop for these breakpoints.  */
12776       printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12777       break;
12778
12779     case bp_overlay_event:
12780       /* By analogy with the thread event, GDB should not stop for these.  */
12781       printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12782       break;
12783
12784     case bp_longjmp_master:
12785       /* These should never be enabled.  */
12786       printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12787       break;
12788
12789     case bp_std_terminate_master:
12790       /* These should never be enabled.  */
12791       printf_filtered (_("std::terminate Master Breakpoint: "
12792                          "gdb should not stop!\n"));
12793       break;
12794
12795     case bp_exception_master:
12796       /* These should never be enabled.  */
12797       printf_filtered (_("Exception Master Breakpoint: "
12798                          "gdb should not stop!\n"));
12799       break;
12800     }
12801
12802   return PRINT_NOTHING;
12803 }
12804
12805 static void
12806 internal_bkpt_print_mention (struct breakpoint *b)
12807 {
12808   /* Nothing to mention.  These breakpoints are internal.  */
12809 }
12810
12811 /* Virtual table for momentary breakpoints  */
12812
12813 static void
12814 momentary_bkpt_re_set (struct breakpoint *b)
12815 {
12816   /* Keep temporary breakpoints, which can be encountered when we step
12817      over a dlopen call and solib_add is resetting the breakpoints.
12818      Otherwise these should have been blown away via the cleanup chain
12819      or by breakpoint_init_inferior when we rerun the executable.  */
12820 }
12821
12822 static void
12823 momentary_bkpt_check_status (bpstat bs)
12824 {
12825   /* Nothing.  The point of these breakpoints is causing a stop.  */
12826 }
12827
12828 static enum print_stop_action
12829 momentary_bkpt_print_it (bpstat bs)
12830 {
12831   return PRINT_UNKNOWN;
12832 }
12833
12834 static void
12835 momentary_bkpt_print_mention (struct breakpoint *b)
12836 {
12837   /* Nothing to mention.  These breakpoints are internal.  */
12838 }
12839
12840 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12841
12842    It gets cleared already on the removal of the first one of such placed
12843    breakpoints.  This is OK as they get all removed altogether.  */
12844
12845 longjmp_breakpoint::~longjmp_breakpoint ()
12846 {
12847   thread_info *tp = find_thread_global_id (this->thread);
12848
12849   if (tp != NULL)
12850     tp->initiating_frame = null_frame_id;
12851 }
12852
12853 /* Specific methods for probe breakpoints.  */
12854
12855 static int
12856 bkpt_probe_insert_location (struct bp_location *bl)
12857 {
12858   int v = bkpt_insert_location (bl);
12859
12860   if (v == 0)
12861     {
12862       /* The insertion was successful, now let's set the probe's semaphore
12863          if needed.  */
12864       bl->probe.prob->set_semaphore (bl->probe.objfile, bl->gdbarch);
12865     }
12866
12867   return v;
12868 }
12869
12870 static int
12871 bkpt_probe_remove_location (struct bp_location *bl,
12872                             enum remove_bp_reason reason)
12873 {
12874   /* Let's clear the semaphore before removing the location.  */
12875   bl->probe.prob->clear_semaphore (bl->probe.objfile, bl->gdbarch);
12876
12877   return bkpt_remove_location (bl, reason);
12878 }
12879
12880 static void
12881 bkpt_probe_create_sals_from_location (const struct event_location *location,
12882                                       struct linespec_result *canonical,
12883                                       enum bptype type_wanted)
12884 {
12885   struct linespec_sals lsal;
12886
12887   lsal.sals = parse_probes (location, NULL, canonical);
12888   lsal.canonical
12889     = xstrdup (event_location_to_string (canonical->location.get ()));
12890   canonical->lsals.push_back (std::move (lsal));
12891 }
12892
12893 static std::vector<symtab_and_line>
12894 bkpt_probe_decode_location (struct breakpoint *b,
12895                             const struct event_location *location,
12896                             struct program_space *search_pspace)
12897 {
12898   std::vector<symtab_and_line> sals = parse_probes (location, search_pspace, NULL);
12899   if (sals.empty ())
12900     error (_("probe not found"));
12901   return sals;
12902 }
12903
12904 /* The breakpoint_ops structure to be used in tracepoints.  */
12905
12906 static void
12907 tracepoint_re_set (struct breakpoint *b)
12908 {
12909   breakpoint_re_set_default (b);
12910 }
12911
12912 static int
12913 tracepoint_breakpoint_hit (const struct bp_location *bl,
12914                            const address_space *aspace, CORE_ADDR bp_addr,
12915                            const struct target_waitstatus *ws)
12916 {
12917   /* By definition, the inferior does not report stops at
12918      tracepoints.  */
12919   return 0;
12920 }
12921
12922 static void
12923 tracepoint_print_one_detail (const struct breakpoint *self,
12924                              struct ui_out *uiout)
12925 {
12926   struct tracepoint *tp = (struct tracepoint *) self;
12927   if (tp->static_trace_marker_id)
12928     {
12929       gdb_assert (self->type == bp_static_tracepoint);
12930
12931       uiout->text ("\tmarker id is ");
12932       uiout->field_string ("static-tracepoint-marker-string-id",
12933                            tp->static_trace_marker_id);
12934       uiout->text ("\n");
12935     }
12936 }
12937
12938 static void
12939 tracepoint_print_mention (struct breakpoint *b)
12940 {
12941   if (current_uiout->is_mi_like_p ())
12942     return;
12943
12944   switch (b->type)
12945     {
12946     case bp_tracepoint:
12947       printf_filtered (_("Tracepoint"));
12948       printf_filtered (_(" %d"), b->number);
12949       break;
12950     case bp_fast_tracepoint:
12951       printf_filtered (_("Fast tracepoint"));
12952       printf_filtered (_(" %d"), b->number);
12953       break;
12954     case bp_static_tracepoint:
12955       printf_filtered (_("Static tracepoint"));
12956       printf_filtered (_(" %d"), b->number);
12957       break;
12958     default:
12959       internal_error (__FILE__, __LINE__,
12960                       _("unhandled tracepoint type %d"), (int) b->type);
12961     }
12962
12963   say_where (b);
12964 }
12965
12966 static void
12967 tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
12968 {
12969   struct tracepoint *tp = (struct tracepoint *) self;
12970
12971   if (self->type == bp_fast_tracepoint)
12972     fprintf_unfiltered (fp, "ftrace");
12973   else if (self->type == bp_static_tracepoint)
12974     fprintf_unfiltered (fp, "strace");
12975   else if (self->type == bp_tracepoint)
12976     fprintf_unfiltered (fp, "trace");
12977   else
12978     internal_error (__FILE__, __LINE__,
12979                     _("unhandled tracepoint type %d"), (int) self->type);
12980
12981   fprintf_unfiltered (fp, " %s",
12982                       event_location_to_string (self->location.get ()));
12983   print_recreate_thread (self, fp);
12984
12985   if (tp->pass_count)
12986     fprintf_unfiltered (fp, "  passcount %d\n", tp->pass_count);
12987 }
12988
12989 static void
12990 tracepoint_create_sals_from_location (const struct event_location *location,
12991                                       struct linespec_result *canonical,
12992                                       enum bptype type_wanted)
12993 {
12994   create_sals_from_location_default (location, canonical, type_wanted);
12995 }
12996
12997 static void
12998 tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12999                                    struct linespec_result *canonical,
13000                                    gdb::unique_xmalloc_ptr<char> cond_string,
13001                                    gdb::unique_xmalloc_ptr<char> extra_string,
13002                                    enum bptype type_wanted,
13003                                    enum bpdisp disposition,
13004                                    int thread,
13005                                    int task, int ignore_count,
13006                                    const struct breakpoint_ops *ops,
13007                                    int from_tty, int enabled,
13008                                    int internal, unsigned flags)
13009 {
13010   create_breakpoints_sal_default (gdbarch, canonical,
13011                                   std::move (cond_string),
13012                                   std::move (extra_string),
13013                                   type_wanted,
13014                                   disposition, thread, task,
13015                                   ignore_count, ops, from_tty,
13016                                   enabled, internal, flags);
13017 }
13018
13019 static std::vector<symtab_and_line>
13020 tracepoint_decode_location (struct breakpoint *b,
13021                             const struct event_location *location,
13022                             struct program_space *search_pspace)
13023 {
13024   return decode_location_default (b, location, search_pspace);
13025 }
13026
13027 struct breakpoint_ops tracepoint_breakpoint_ops;
13028
13029 /* The breakpoint_ops structure to be use on tracepoints placed in a
13030    static probe.  */
13031
13032 static void
13033 tracepoint_probe_create_sals_from_location
13034   (const struct event_location *location,
13035    struct linespec_result *canonical,
13036    enum bptype type_wanted)
13037 {
13038   /* We use the same method for breakpoint on probes.  */
13039   bkpt_probe_create_sals_from_location (location, canonical, type_wanted);
13040 }
13041
13042 static std::vector<symtab_and_line>
13043 tracepoint_probe_decode_location (struct breakpoint *b,
13044                                   const struct event_location *location,
13045                                   struct program_space *search_pspace)
13046 {
13047   /* We use the same method for breakpoint on probes.  */
13048   return bkpt_probe_decode_location (b, location, search_pspace);
13049 }
13050
13051 static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
13052
13053 /* Dprintf breakpoint_ops methods.  */
13054
13055 static void
13056 dprintf_re_set (struct breakpoint *b)
13057 {
13058   breakpoint_re_set_default (b);
13059
13060   /* extra_string should never be non-NULL for dprintf.  */
13061   gdb_assert (b->extra_string != NULL);
13062
13063   /* 1 - connect to target 1, that can run breakpoint commands.
13064      2 - create a dprintf, which resolves fine.
13065      3 - disconnect from target 1
13066      4 - connect to target 2, that can NOT run breakpoint commands.
13067
13068      After steps #3/#4, you'll want the dprintf command list to
13069      be updated, because target 1 and 2 may well return different
13070      answers for target_can_run_breakpoint_commands().
13071      Given absence of finer grained resetting, we get to do
13072      it all the time.  */
13073   if (b->extra_string != NULL)
13074     update_dprintf_command_list (b);
13075 }
13076
13077 /* Implement the "print_recreate" breakpoint_ops method for dprintf.  */
13078
13079 static void
13080 dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp)
13081 {
13082   fprintf_unfiltered (fp, "dprintf %s,%s",
13083                       event_location_to_string (tp->location.get ()),
13084                       tp->extra_string);
13085   print_recreate_thread (tp, fp);
13086 }
13087
13088 /* Implement the "after_condition_true" breakpoint_ops method for
13089    dprintf.
13090
13091    dprintf's are implemented with regular commands in their command
13092    list, but we run the commands here instead of before presenting the
13093    stop to the user, as dprintf's don't actually cause a stop.  This
13094    also makes it so that the commands of multiple dprintfs at the same
13095    address are all handled.  */
13096
13097 static void
13098 dprintf_after_condition_true (struct bpstats *bs)
13099 {
13100   struct bpstats tmp_bs;
13101   struct bpstats *tmp_bs_p = &tmp_bs;
13102
13103   /* dprintf's never cause a stop.  This wasn't set in the
13104      check_status hook instead because that would make the dprintf's
13105      condition not be evaluated.  */
13106   bs->stop = 0;
13107
13108   /* Run the command list here.  Take ownership of it instead of
13109      copying.  We never want these commands to run later in
13110      bpstat_do_actions, if a breakpoint that causes a stop happens to
13111      be set at same address as this dprintf, or even if running the
13112      commands here throws.  */
13113   tmp_bs.commands = bs->commands;
13114   bs->commands = NULL;
13115
13116   bpstat_do_actions_1 (&tmp_bs_p);
13117
13118   /* 'tmp_bs.commands' will usually be NULL by now, but
13119      bpstat_do_actions_1 may return early without processing the whole
13120      list.  */
13121 }
13122
13123 /* The breakpoint_ops structure to be used on static tracepoints with
13124    markers (`-m').  */
13125
13126 static void
13127 strace_marker_create_sals_from_location (const struct event_location *location,
13128                                          struct linespec_result *canonical,
13129                                          enum bptype type_wanted)
13130 {
13131   struct linespec_sals lsal;
13132   const char *arg_start, *arg;
13133
13134   arg = arg_start = get_linespec_location (location)->spec_string;
13135   lsal.sals = decode_static_tracepoint_spec (&arg);
13136
13137   std::string str (arg_start, arg - arg_start);
13138   const char *ptr = str.c_str ();
13139   canonical->location
13140     = new_linespec_location (&ptr, symbol_name_match_type::FULL);
13141
13142   lsal.canonical
13143     = xstrdup (event_location_to_string (canonical->location.get ()));
13144   canonical->lsals.push_back (std::move (lsal));
13145 }
13146
13147 static void
13148 strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
13149                                       struct linespec_result *canonical,
13150                                       gdb::unique_xmalloc_ptr<char> cond_string,
13151                                       gdb::unique_xmalloc_ptr<char> extra_string,
13152                                       enum bptype type_wanted,
13153                                       enum bpdisp disposition,
13154                                       int thread,
13155                                       int task, int ignore_count,
13156                                       const struct breakpoint_ops *ops,
13157                                       int from_tty, int enabled,
13158                                       int internal, unsigned flags)
13159 {
13160   const linespec_sals &lsal = canonical->lsals[0];
13161
13162   /* If the user is creating a static tracepoint by marker id
13163      (strace -m MARKER_ID), then store the sals index, so that
13164      breakpoint_re_set can try to match up which of the newly
13165      found markers corresponds to this one, and, don't try to
13166      expand multiple locations for each sal, given than SALS
13167      already should contain all sals for MARKER_ID.  */
13168
13169   for (size_t i = 0; i < lsal.sals.size (); i++)
13170     {
13171       event_location_up location
13172         = copy_event_location (canonical->location.get ());
13173
13174       std::unique_ptr<tracepoint> tp (new tracepoint ());
13175       init_breakpoint_sal (tp.get (), gdbarch, lsal.sals[i],
13176                            std::move (location), NULL,
13177                            std::move (cond_string),
13178                            std::move (extra_string),
13179                            type_wanted, disposition,
13180                            thread, task, ignore_count, ops,
13181                            from_tty, enabled, internal, flags,
13182                            canonical->special_display);
13183       /* Given that its possible to have multiple markers with
13184          the same string id, if the user is creating a static
13185          tracepoint by marker id ("strace -m MARKER_ID"), then
13186          store the sals index, so that breakpoint_re_set can
13187          try to match up which of the newly found markers
13188          corresponds to this one  */
13189       tp->static_trace_marker_id_idx = i;
13190
13191       install_breakpoint (internal, std::move (tp), 0);
13192     }
13193 }
13194
13195 static std::vector<symtab_and_line>
13196 strace_marker_decode_location (struct breakpoint *b,
13197                                const struct event_location *location,
13198                                struct program_space *search_pspace)
13199 {
13200   struct tracepoint *tp = (struct tracepoint *) b;
13201   const char *s = get_linespec_location (location)->spec_string;
13202
13203   std::vector<symtab_and_line> sals = decode_static_tracepoint_spec (&s);
13204   if (sals.size () > tp->static_trace_marker_id_idx)
13205     {
13206       sals[0] = sals[tp->static_trace_marker_id_idx];
13207       sals.resize (1);
13208       return sals;
13209     }
13210   else
13211     error (_("marker %s not found"), tp->static_trace_marker_id);
13212 }
13213
13214 static struct breakpoint_ops strace_marker_breakpoint_ops;
13215
13216 static int
13217 strace_marker_p (struct breakpoint *b)
13218 {
13219   return b->ops == &strace_marker_breakpoint_ops;
13220 }
13221
13222 /* Delete a breakpoint and clean up all traces of it in the data
13223    structures.  */
13224
13225 void
13226 delete_breakpoint (struct breakpoint *bpt)
13227 {
13228   struct breakpoint *b;
13229
13230   gdb_assert (bpt != NULL);
13231
13232   /* Has this bp already been deleted?  This can happen because
13233      multiple lists can hold pointers to bp's.  bpstat lists are
13234      especial culprits.
13235
13236      One example of this happening is a watchpoint's scope bp.  When
13237      the scope bp triggers, we notice that the watchpoint is out of
13238      scope, and delete it.  We also delete its scope bp.  But the
13239      scope bp is marked "auto-deleting", and is already on a bpstat.
13240      That bpstat is then checked for auto-deleting bp's, which are
13241      deleted.
13242
13243      A real solution to this problem might involve reference counts in
13244      bp's, and/or giving them pointers back to their referencing
13245      bpstat's, and teaching delete_breakpoint to only free a bp's
13246      storage when no more references were extent.  A cheaper bandaid
13247      was chosen.  */
13248   if (bpt->type == bp_none)
13249     return;
13250
13251   /* At least avoid this stale reference until the reference counting
13252      of breakpoints gets resolved.  */
13253   if (bpt->related_breakpoint != bpt)
13254     {
13255       struct breakpoint *related;
13256       struct watchpoint *w;
13257
13258       if (bpt->type == bp_watchpoint_scope)
13259         w = (struct watchpoint *) bpt->related_breakpoint;
13260       else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
13261         w = (struct watchpoint *) bpt;
13262       else
13263         w = NULL;
13264       if (w != NULL)
13265         watchpoint_del_at_next_stop (w);
13266
13267       /* Unlink bpt from the bpt->related_breakpoint ring.  */
13268       for (related = bpt; related->related_breakpoint != bpt;
13269            related = related->related_breakpoint);
13270       related->related_breakpoint = bpt->related_breakpoint;
13271       bpt->related_breakpoint = bpt;
13272     }
13273
13274   /* watch_command_1 creates a watchpoint but only sets its number if
13275      update_watchpoint succeeds in creating its bp_locations.  If there's
13276      a problem in that process, we'll be asked to delete the half-created
13277      watchpoint.  In that case, don't announce the deletion.  */
13278   if (bpt->number)
13279     observer_notify_breakpoint_deleted (bpt);
13280
13281   if (breakpoint_chain == bpt)
13282     breakpoint_chain = bpt->next;
13283
13284   ALL_BREAKPOINTS (b)
13285     if (b->next == bpt)
13286     {
13287       b->next = bpt->next;
13288       break;
13289     }
13290
13291   /* Be sure no bpstat's are pointing at the breakpoint after it's
13292      been freed.  */
13293   /* FIXME, how can we find all bpstat's?  We just check stop_bpstat
13294      in all threads for now.  Note that we cannot just remove bpstats
13295      pointing at bpt from the stop_bpstat list entirely, as breakpoint
13296      commands are associated with the bpstat; if we remove it here,
13297      then the later call to bpstat_do_actions (&stop_bpstat); in
13298      event-top.c won't do anything, and temporary breakpoints with
13299      commands won't work.  */
13300
13301   iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13302
13303   /* Now that breakpoint is removed from breakpoint list, update the
13304      global location list.  This will remove locations that used to
13305      belong to this breakpoint.  Do this before freeing the breakpoint
13306      itself, since remove_breakpoint looks at location's owner.  It
13307      might be better design to have location completely
13308      self-contained, but it's not the case now.  */
13309   update_global_location_list (UGLL_DONT_INSERT);
13310
13311   /* On the chance that someone will soon try again to delete this
13312      same bp, we mark it as deleted before freeing its storage.  */
13313   bpt->type = bp_none;
13314   delete bpt;
13315 }
13316
13317 /* Iterator function to call a user-provided callback function once
13318    for each of B and its related breakpoints.  */
13319
13320 static void
13321 iterate_over_related_breakpoints (struct breakpoint *b,
13322                                   gdb::function_view<void (breakpoint *)> function)
13323 {
13324   struct breakpoint *related;
13325
13326   related = b;
13327   do
13328     {
13329       struct breakpoint *next;
13330
13331       /* FUNCTION may delete RELATED.  */
13332       next = related->related_breakpoint;
13333
13334       if (next == related)
13335         {
13336           /* RELATED is the last ring entry.  */
13337           function (related);
13338
13339           /* FUNCTION may have deleted it, so we'd never reach back to
13340              B.  There's nothing left to do anyway, so just break
13341              out.  */
13342           break;
13343         }
13344       else
13345         function (related);
13346
13347       related = next;
13348     }
13349   while (related != b);
13350 }
13351
13352 static void
13353 delete_command (const char *arg, int from_tty)
13354 {
13355   struct breakpoint *b, *b_tmp;
13356
13357   dont_repeat ();
13358
13359   if (arg == 0)
13360     {
13361       int breaks_to_delete = 0;
13362
13363       /* Delete all breakpoints if no argument.  Do not delete
13364          internal breakpoints, these have to be deleted with an
13365          explicit breakpoint number argument.  */
13366       ALL_BREAKPOINTS (b)
13367         if (user_breakpoint_p (b))
13368           {
13369             breaks_to_delete = 1;
13370             break;
13371           }
13372
13373       /* Ask user only if there are some breakpoints to delete.  */
13374       if (!from_tty
13375           || (breaks_to_delete && query (_("Delete all breakpoints? "))))
13376         {
13377           ALL_BREAKPOINTS_SAFE (b, b_tmp)
13378             if (user_breakpoint_p (b))
13379               delete_breakpoint (b);
13380         }
13381     }
13382   else
13383     map_breakpoint_numbers
13384       (arg, [&] (breakpoint *b)
13385        {
13386          iterate_over_related_breakpoints (b, delete_breakpoint);
13387        });
13388 }
13389
13390 /* Return true if all locations of B bound to PSPACE are pending.  If
13391    PSPACE is NULL, all locations of all program spaces are
13392    considered.  */
13393
13394 static int
13395 all_locations_are_pending (struct breakpoint *b, struct program_space *pspace)
13396 {
13397   struct bp_location *loc;
13398
13399   for (loc = b->loc; loc != NULL; loc = loc->next)
13400     if ((pspace == NULL
13401          || loc->pspace == pspace)
13402         && !loc->shlib_disabled
13403         && !loc->pspace->executing_startup)
13404       return 0;
13405   return 1;
13406 }
13407
13408 /* Subroutine of update_breakpoint_locations to simplify it.
13409    Return non-zero if multiple fns in list LOC have the same name.
13410    Null names are ignored.  */
13411
13412 static int
13413 ambiguous_names_p (struct bp_location *loc)
13414 {
13415   struct bp_location *l;
13416   htab_t htab = htab_create_alloc (13, htab_hash_string,
13417                                    (int (*) (const void *, 
13418                                              const void *)) streq,
13419                                    NULL, xcalloc, xfree);
13420
13421   for (l = loc; l != NULL; l = l->next)
13422     {
13423       const char **slot;
13424       const char *name = l->function_name;
13425
13426       /* Allow for some names to be NULL, ignore them.  */
13427       if (name == NULL)
13428         continue;
13429
13430       slot = (const char **) htab_find_slot (htab, (const void *) name,
13431                                              INSERT);
13432       /* NOTE: We can assume slot != NULL here because xcalloc never
13433          returns NULL.  */
13434       if (*slot != NULL)
13435         {
13436           htab_delete (htab);
13437           return 1;
13438         }
13439       *slot = name;
13440     }
13441
13442   htab_delete (htab);
13443   return 0;
13444 }
13445
13446 /* When symbols change, it probably means the sources changed as well,
13447    and it might mean the static tracepoint markers are no longer at
13448    the same address or line numbers they used to be at last we
13449    checked.  Losing your static tracepoints whenever you rebuild is
13450    undesirable.  This function tries to resync/rematch gdb static
13451    tracepoints with the markers on the target, for static tracepoints
13452    that have not been set by marker id.  Static tracepoint that have
13453    been set by marker id are reset by marker id in breakpoint_re_set.
13454    The heuristic is:
13455
13456    1) For a tracepoint set at a specific address, look for a marker at
13457    the old PC.  If one is found there, assume to be the same marker.
13458    If the name / string id of the marker found is different from the
13459    previous known name, assume that means the user renamed the marker
13460    in the sources, and output a warning.
13461
13462    2) For a tracepoint set at a given line number, look for a marker
13463    at the new address of the old line number.  If one is found there,
13464    assume to be the same marker.  If the name / string id of the
13465    marker found is different from the previous known name, assume that
13466    means the user renamed the marker in the sources, and output a
13467    warning.
13468
13469    3) If a marker is no longer found at the same address or line, it
13470    may mean the marker no longer exists.  But it may also just mean
13471    the code changed a bit.  Maybe the user added a few lines of code
13472    that made the marker move up or down (in line number terms).  Ask
13473    the target for info about the marker with the string id as we knew
13474    it.  If found, update line number and address in the matching
13475    static tracepoint.  This will get confused if there's more than one
13476    marker with the same ID (possible in UST, although unadvised
13477    precisely because it confuses tools).  */
13478
13479 static struct symtab_and_line
13480 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
13481 {
13482   struct tracepoint *tp = (struct tracepoint *) b;
13483   struct static_tracepoint_marker marker;
13484   CORE_ADDR pc;
13485
13486   pc = sal.pc;
13487   if (sal.line)
13488     find_line_pc (sal.symtab, sal.line, &pc);
13489
13490   if (target_static_tracepoint_marker_at (pc, &marker))
13491     {
13492       if (strcmp (tp->static_trace_marker_id, marker.str_id) != 0)
13493         warning (_("static tracepoint %d changed probed marker from %s to %s"),
13494                  b->number,
13495                  tp->static_trace_marker_id, marker.str_id);
13496
13497       xfree (tp->static_trace_marker_id);
13498       tp->static_trace_marker_id = xstrdup (marker.str_id);
13499       release_static_tracepoint_marker (&marker);
13500
13501       return sal;
13502     }
13503
13504   /* Old marker wasn't found on target at lineno.  Try looking it up
13505      by string ID.  */
13506   if (!sal.explicit_pc
13507       && sal.line != 0
13508       && sal.symtab != NULL
13509       && tp->static_trace_marker_id != NULL)
13510     {
13511       VEC(static_tracepoint_marker_p) *markers;
13512
13513       markers
13514         = target_static_tracepoint_markers_by_strid (tp->static_trace_marker_id);
13515
13516       if (!VEC_empty(static_tracepoint_marker_p, markers))
13517         {
13518           struct symbol *sym;
13519           struct static_tracepoint_marker *tpmarker;
13520           struct ui_out *uiout = current_uiout;
13521           struct explicit_location explicit_loc;
13522
13523           tpmarker = VEC_index (static_tracepoint_marker_p, markers, 0);
13524
13525           xfree (tp->static_trace_marker_id);
13526           tp->static_trace_marker_id = xstrdup (tpmarker->str_id);
13527
13528           warning (_("marker for static tracepoint %d (%s) not "
13529                      "found at previous line number"),
13530                    b->number, tp->static_trace_marker_id);
13531
13532           symtab_and_line sal2 = find_pc_line (tpmarker->address, 0);
13533           sym = find_pc_sect_function (tpmarker->address, NULL);
13534           uiout->text ("Now in ");
13535           if (sym)
13536             {
13537               uiout->field_string ("func", SYMBOL_PRINT_NAME (sym));
13538               uiout->text (" at ");
13539             }
13540           uiout->field_string ("file",
13541                                symtab_to_filename_for_display (sal2.symtab));
13542           uiout->text (":");
13543
13544           if (uiout->is_mi_like_p ())
13545             {
13546               const char *fullname = symtab_to_fullname (sal2.symtab);
13547
13548               uiout->field_string ("fullname", fullname);
13549             }
13550
13551           uiout->field_int ("line", sal2.line);
13552           uiout->text ("\n");
13553
13554           b->loc->line_number = sal2.line;
13555           b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
13556
13557           b->location.reset (NULL);
13558           initialize_explicit_location (&explicit_loc);
13559           explicit_loc.source_filename
13560             = ASTRDUP (symtab_to_filename_for_display (sal2.symtab));
13561           explicit_loc.line_offset.offset = b->loc->line_number;
13562           explicit_loc.line_offset.sign = LINE_OFFSET_NONE;
13563           b->location = new_explicit_location (&explicit_loc);
13564
13565           /* Might be nice to check if function changed, and warn if
13566              so.  */
13567
13568           release_static_tracepoint_marker (tpmarker);
13569         }
13570     }
13571   return sal;
13572 }
13573
13574 /* Returns 1 iff locations A and B are sufficiently same that
13575    we don't need to report breakpoint as changed.  */
13576
13577 static int
13578 locations_are_equal (struct bp_location *a, struct bp_location *b)
13579 {
13580   while (a && b)
13581     {
13582       if (a->address != b->address)
13583         return 0;
13584
13585       if (a->shlib_disabled != b->shlib_disabled)
13586         return 0;
13587
13588       if (a->enabled != b->enabled)
13589         return 0;
13590
13591       a = a->next;
13592       b = b->next;
13593     }
13594
13595   if ((a == NULL) != (b == NULL))
13596     return 0;
13597
13598   return 1;
13599 }
13600
13601 /* Split all locations of B that are bound to PSPACE out of B's
13602    location list to a separate list and return that list's head.  If
13603    PSPACE is NULL, hoist out all locations of B.  */
13604
13605 static struct bp_location *
13606 hoist_existing_locations (struct breakpoint *b, struct program_space *pspace)
13607 {
13608   struct bp_location head;
13609   struct bp_location *i = b->loc;
13610   struct bp_location **i_link = &b->loc;
13611   struct bp_location *hoisted = &head;
13612
13613   if (pspace == NULL)
13614     {
13615       i = b->loc;
13616       b->loc = NULL;
13617       return i;
13618     }
13619
13620   head.next = NULL;
13621
13622   while (i != NULL)
13623     {
13624       if (i->pspace == pspace)
13625         {
13626           *i_link = i->next;
13627           i->next = NULL;
13628           hoisted->next = i;
13629           hoisted = i;
13630         }
13631       else
13632         i_link = &i->next;
13633       i = *i_link;
13634     }
13635
13636   return head.next;
13637 }
13638
13639 /* Create new breakpoint locations for B (a hardware or software
13640    breakpoint) based on SALS and SALS_END.  If SALS_END.NELTS is not
13641    zero, then B is a ranged breakpoint.  Only recreates locations for
13642    FILTER_PSPACE.  Locations of other program spaces are left
13643    untouched.  */
13644
13645 void
13646 update_breakpoint_locations (struct breakpoint *b,
13647                              struct program_space *filter_pspace,
13648                              gdb::array_view<const symtab_and_line> sals,
13649                              gdb::array_view<const symtab_and_line> sals_end)
13650 {
13651   struct bp_location *existing_locations;
13652
13653   if (!sals_end.empty () && (sals.size () != 1 || sals_end.size () != 1))
13654     {
13655       /* Ranged breakpoints have only one start location and one end
13656          location.  */
13657       b->enable_state = bp_disabled;
13658       printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13659                            "multiple locations found\n"),
13660                          b->number);
13661       return;
13662     }
13663
13664   /* If there's no new locations, and all existing locations are
13665      pending, don't do anything.  This optimizes the common case where
13666      all locations are in the same shared library, that was unloaded.
13667      We'd like to retain the location, so that when the library is
13668      loaded again, we don't loose the enabled/disabled status of the
13669      individual locations.  */
13670   if (all_locations_are_pending (b, filter_pspace) && sals.empty ())
13671     return;
13672
13673   existing_locations = hoist_existing_locations (b, filter_pspace);
13674
13675   for (const auto &sal : sals)
13676     {
13677       struct bp_location *new_loc;
13678
13679       switch_to_program_space_and_thread (sal.pspace);
13680
13681       new_loc = add_location_to_breakpoint (b, &sal);
13682
13683       /* Reparse conditions, they might contain references to the
13684          old symtab.  */
13685       if (b->cond_string != NULL)
13686         {
13687           const char *s;
13688
13689           s = b->cond_string;
13690           TRY
13691             {
13692               new_loc->cond = parse_exp_1 (&s, sal.pc,
13693                                            block_for_pc (sal.pc),
13694                                            0);
13695             }
13696           CATCH (e, RETURN_MASK_ERROR)
13697             {
13698               warning (_("failed to reevaluate condition "
13699                          "for breakpoint %d: %s"), 
13700                        b->number, e.message);
13701               new_loc->enabled = 0;
13702             }
13703           END_CATCH
13704         }
13705
13706       if (!sals_end.empty ())
13707         {
13708           CORE_ADDR end = find_breakpoint_range_end (sals_end[0]);
13709
13710           new_loc->length = end - sals[0].pc + 1;
13711         }
13712     }
13713
13714   /* If possible, carry over 'disable' status from existing
13715      breakpoints.  */
13716   {
13717     struct bp_location *e = existing_locations;
13718     /* If there are multiple breakpoints with the same function name,
13719        e.g. for inline functions, comparing function names won't work.
13720        Instead compare pc addresses; this is just a heuristic as things
13721        may have moved, but in practice it gives the correct answer
13722        often enough until a better solution is found.  */
13723     int have_ambiguous_names = ambiguous_names_p (b->loc);
13724
13725     for (; e; e = e->next)
13726       {
13727         if (!e->enabled && e->function_name)
13728           {
13729             struct bp_location *l = b->loc;
13730             if (have_ambiguous_names)
13731               {
13732                 for (; l; l = l->next)
13733                   if (breakpoint_locations_match (e, l))
13734                     {
13735                       l->enabled = 0;
13736                       break;
13737                     }
13738               }
13739             else
13740               {
13741                 for (; l; l = l->next)
13742                   if (l->function_name
13743                       && strcmp (e->function_name, l->function_name) == 0)
13744                     {
13745                       l->enabled = 0;
13746                       break;
13747                     }
13748               }
13749           }
13750       }
13751   }
13752
13753   if (!locations_are_equal (existing_locations, b->loc))
13754     observer_notify_breakpoint_modified (b);
13755 }
13756
13757 /* Find the SaL locations corresponding to the given LOCATION.
13758    On return, FOUND will be 1 if any SaL was found, zero otherwise.  */
13759
13760 static std::vector<symtab_and_line>
13761 location_to_sals (struct breakpoint *b, struct event_location *location,
13762                   struct program_space *search_pspace, int *found)
13763 {
13764   struct gdb_exception exception = exception_none;
13765
13766   gdb_assert (b->ops != NULL);
13767
13768   std::vector<symtab_and_line> sals;
13769
13770   TRY
13771     {
13772       sals = b->ops->decode_location (b, location, search_pspace);
13773     }
13774   CATCH (e, RETURN_MASK_ERROR)
13775     {
13776       int not_found_and_ok = 0;
13777
13778       exception = e;
13779
13780       /* For pending breakpoints, it's expected that parsing will
13781          fail until the right shared library is loaded.  User has
13782          already told to create pending breakpoints and don't need
13783          extra messages.  If breakpoint is in bp_shlib_disabled
13784          state, then user already saw the message about that
13785          breakpoint being disabled, and don't want to see more
13786          errors.  */
13787       if (e.error == NOT_FOUND_ERROR
13788           && (b->condition_not_parsed
13789               || (b->loc != NULL
13790                   && search_pspace != NULL
13791                   && b->loc->pspace != search_pspace)
13792               || (b->loc && b->loc->shlib_disabled)
13793               || (b->loc && b->loc->pspace->executing_startup)
13794               || b->enable_state == bp_disabled))
13795         not_found_and_ok = 1;
13796
13797       if (!not_found_and_ok)
13798         {
13799           /* We surely don't want to warn about the same breakpoint
13800              10 times.  One solution, implemented here, is disable
13801              the breakpoint on error.  Another solution would be to
13802              have separate 'warning emitted' flag.  Since this
13803              happens only when a binary has changed, I don't know
13804              which approach is better.  */
13805           b->enable_state = bp_disabled;
13806           throw_exception (e);
13807         }
13808     }
13809   END_CATCH
13810
13811   if (exception.reason == 0 || exception.error != NOT_FOUND_ERROR)
13812     {
13813       for (auto &sal : sals)
13814         resolve_sal_pc (&sal);
13815       if (b->condition_not_parsed && b->extra_string != NULL)
13816         {
13817           char *cond_string, *extra_string;
13818           int thread, task;
13819
13820           find_condition_and_thread (b->extra_string, sals[0].pc,
13821                                      &cond_string, &thread, &task,
13822                                      &extra_string);
13823           gdb_assert (b->cond_string == NULL);
13824           if (cond_string)
13825             b->cond_string = cond_string;
13826           b->thread = thread;
13827           b->task = task;
13828           if (extra_string)
13829             {
13830               xfree (b->extra_string);
13831               b->extra_string = extra_string;
13832             }
13833           b->condition_not_parsed = 0;
13834         }
13835
13836       if (b->type == bp_static_tracepoint && !strace_marker_p (b))
13837         sals[0] = update_static_tracepoint (b, sals[0]);
13838
13839       *found = 1;
13840     }
13841   else
13842     *found = 0;
13843
13844   return sals;
13845 }
13846
13847 /* The default re_set method, for typical hardware or software
13848    breakpoints.  Reevaluate the breakpoint and recreate its
13849    locations.  */
13850
13851 static void
13852 breakpoint_re_set_default (struct breakpoint *b)
13853 {
13854   struct program_space *filter_pspace = current_program_space;
13855   std::vector<symtab_and_line> expanded, expanded_end;
13856
13857   int found;
13858   std::vector<symtab_and_line> sals = location_to_sals (b, b->location.get (),
13859                                                         filter_pspace, &found);
13860   if (found)
13861     expanded = std::move (sals);
13862
13863   if (b->location_range_end != NULL)
13864     {
13865       std::vector<symtab_and_line> sals_end
13866         = location_to_sals (b, b->location_range_end.get (),
13867                             filter_pspace, &found);
13868       if (found)
13869         expanded_end = std::move (sals_end);
13870     }
13871
13872   update_breakpoint_locations (b, filter_pspace, expanded, expanded_end);
13873 }
13874
13875 /* Default method for creating SALs from an address string.  It basically
13876    calls parse_breakpoint_sals.  Return 1 for success, zero for failure.  */
13877
13878 static void
13879 create_sals_from_location_default (const struct event_location *location,
13880                                    struct linespec_result *canonical,
13881                                    enum bptype type_wanted)
13882 {
13883   parse_breakpoint_sals (location, canonical);
13884 }
13885
13886 /* Call create_breakpoints_sal for the given arguments.  This is the default
13887    function for the `create_breakpoints_sal' method of
13888    breakpoint_ops.  */
13889
13890 static void
13891 create_breakpoints_sal_default (struct gdbarch *gdbarch,
13892                                 struct linespec_result *canonical,
13893                                 gdb::unique_xmalloc_ptr<char> cond_string,
13894                                 gdb::unique_xmalloc_ptr<char> extra_string,
13895                                 enum bptype type_wanted,
13896                                 enum bpdisp disposition,
13897                                 int thread,
13898                                 int task, int ignore_count,
13899                                 const struct breakpoint_ops *ops,
13900                                 int from_tty, int enabled,
13901                                 int internal, unsigned flags)
13902 {
13903   create_breakpoints_sal (gdbarch, canonical,
13904                           std::move (cond_string),
13905                           std::move (extra_string),
13906                           type_wanted, disposition,
13907                           thread, task, ignore_count, ops, from_tty,
13908                           enabled, internal, flags);
13909 }
13910
13911 /* Decode the line represented by S by calling decode_line_full.  This is the
13912    default function for the `decode_location' method of breakpoint_ops.  */
13913
13914 static std::vector<symtab_and_line>
13915 decode_location_default (struct breakpoint *b,
13916                          const struct event_location *location,
13917                          struct program_space *search_pspace)
13918 {
13919   struct linespec_result canonical;
13920
13921   decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, search_pspace,
13922                     (struct symtab *) NULL, 0,
13923                     &canonical, multiple_symbols_all,
13924                     b->filter);
13925
13926   /* We should get 0 or 1 resulting SALs.  */
13927   gdb_assert (canonical.lsals.size () < 2);
13928
13929   if (!canonical.lsals.empty ())
13930     {
13931       const linespec_sals &lsal = canonical.lsals[0];
13932       return std::move (lsal.sals);
13933     }
13934   return {};
13935 }
13936
13937 /* Reset a breakpoint.  */
13938
13939 static void
13940 breakpoint_re_set_one (breakpoint *b)
13941 {
13942   input_radix = b->input_radix;
13943   set_language (b->language);
13944
13945   b->ops->re_set (b);
13946 }
13947
13948 /* Re-set breakpoint locations for the current program space.
13949    Locations bound to other program spaces are left untouched.  */
13950
13951 void
13952 breakpoint_re_set (void)
13953 {
13954   struct breakpoint *b, *b_tmp;
13955
13956   {
13957     scoped_restore_current_language save_language;
13958     scoped_restore save_input_radix = make_scoped_restore (&input_radix);
13959     scoped_restore_current_pspace_and_thread restore_pspace_thread;
13960
13961     /* Note: we must not try to insert locations until after all
13962        breakpoints have been re-set.  Otherwise, e.g., when re-setting
13963        breakpoint 1, we'd insert the locations of breakpoint 2, which
13964        hadn't been re-set yet, and thus may have stale locations.  */
13965
13966     ALL_BREAKPOINTS_SAFE (b, b_tmp)
13967       {
13968         TRY
13969           {
13970             breakpoint_re_set_one (b);
13971           }
13972         CATCH (ex, RETURN_MASK_ALL)
13973           {
13974             exception_fprintf (gdb_stderr, ex,
13975                                "Error in re-setting breakpoint %d: ",
13976                                b->number);
13977           }
13978         END_CATCH
13979       }
13980
13981     jit_breakpoint_re_set ();
13982   }
13983
13984   create_overlay_event_breakpoint ();
13985   create_longjmp_master_breakpoint ();
13986   create_std_terminate_master_breakpoint ();
13987   create_exception_master_breakpoint ();
13988
13989   /* Now we can insert.  */
13990   update_global_location_list (UGLL_MAY_INSERT);
13991 }
13992 \f
13993 /* Reset the thread number of this breakpoint:
13994
13995    - If the breakpoint is for all threads, leave it as-is.
13996    - Else, reset it to the current thread for inferior_ptid.  */
13997 void
13998 breakpoint_re_set_thread (struct breakpoint *b)
13999 {
14000   if (b->thread != -1)
14001     {
14002       if (in_thread_list (inferior_ptid))
14003         b->thread = ptid_to_global_thread_id (inferior_ptid);
14004
14005       /* We're being called after following a fork.  The new fork is
14006          selected as current, and unless this was a vfork will have a
14007          different program space from the original thread.  Reset that
14008          as well.  */
14009       b->loc->pspace = current_program_space;
14010     }
14011 }
14012
14013 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14014    If from_tty is nonzero, it prints a message to that effect,
14015    which ends with a period (no newline).  */
14016
14017 void
14018 set_ignore_count (int bptnum, int count, int from_tty)
14019 {
14020   struct breakpoint *b;
14021
14022   if (count < 0)
14023     count = 0;
14024
14025   ALL_BREAKPOINTS (b)
14026     if (b->number == bptnum)
14027     {
14028       if (is_tracepoint (b))
14029         {
14030           if (from_tty && count != 0)
14031             printf_filtered (_("Ignore count ignored for tracepoint %d."),
14032                              bptnum);
14033           return;
14034         }
14035       
14036       b->ignore_count = count;
14037       if (from_tty)
14038         {
14039           if (count == 0)
14040             printf_filtered (_("Will stop next time "
14041                                "breakpoint %d is reached."),
14042                              bptnum);
14043           else if (count == 1)
14044             printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14045                              bptnum);
14046           else
14047             printf_filtered (_("Will ignore next %d "
14048                                "crossings of breakpoint %d."),
14049                              count, bptnum);
14050         }
14051       observer_notify_breakpoint_modified (b);
14052       return;
14053     }
14054
14055   error (_("No breakpoint number %d."), bptnum);
14056 }
14057
14058 /* Command to set ignore-count of breakpoint N to COUNT.  */
14059
14060 static void
14061 ignore_command (const char *args, int from_tty)
14062 {
14063   const char *p = args;
14064   int num;
14065
14066   if (p == 0)
14067     error_no_arg (_("a breakpoint number"));
14068
14069   num = get_number (&p);
14070   if (num == 0)
14071     error (_("bad breakpoint number: '%s'"), args);
14072   if (*p == 0)
14073     error (_("Second argument (specified ignore-count) is missing."));
14074
14075   set_ignore_count (num,
14076                     longest_to_int (value_as_long (parse_and_eval (p))),
14077                     from_tty);
14078   if (from_tty)
14079     printf_filtered ("\n");
14080 }
14081 \f
14082
14083 /* Call FUNCTION on each of the breakpoints with numbers in the range
14084    defined by BP_NUM_RANGE (an inclusive range).  */
14085
14086 static void
14087 map_breakpoint_number_range (std::pair<int, int> bp_num_range,
14088                              gdb::function_view<void (breakpoint *)> function)
14089 {
14090   if (bp_num_range.first == 0)
14091     {
14092       warning (_("bad breakpoint number at or near '%d'"),
14093                bp_num_range.first);
14094     }
14095   else
14096     {
14097       struct breakpoint *b, *tmp;
14098
14099       for (int i = bp_num_range.first; i <= bp_num_range.second; i++)
14100         {
14101           bool match = false;
14102
14103           ALL_BREAKPOINTS_SAFE (b, tmp)
14104             if (b->number == i)
14105               {
14106                 match = true;
14107                 function (b);
14108                 break;
14109               }
14110           if (!match)
14111             printf_unfiltered (_("No breakpoint number %d.\n"), i);
14112         }
14113     }
14114 }
14115
14116 /* Call FUNCTION on each of the breakpoints whose numbers are given in
14117    ARGS.  */
14118
14119 static void
14120 map_breakpoint_numbers (const char *args,
14121                         gdb::function_view<void (breakpoint *)> function)
14122 {
14123   if (args == NULL || *args == '\0')
14124     error_no_arg (_("one or more breakpoint numbers"));
14125
14126   number_or_range_parser parser (args);
14127
14128   while (!parser.finished ())
14129     {
14130       int num = parser.get_number ();
14131       map_breakpoint_number_range (std::make_pair (num, num), function);
14132     }
14133 }
14134
14135 /* Return the breakpoint location structure corresponding to the
14136    BP_NUM and LOC_NUM values.  */
14137
14138 static struct bp_location *
14139 find_location_by_number (int bp_num, int loc_num)
14140 {
14141   struct breakpoint *b;
14142
14143   ALL_BREAKPOINTS (b)
14144     if (b->number == bp_num)
14145       {
14146         break;
14147       }
14148
14149   if (!b || b->number != bp_num)
14150     error (_("Bad breakpoint number '%d'"), bp_num);
14151   
14152   if (loc_num == 0)
14153     error (_("Bad breakpoint location number '%d'"), loc_num);
14154
14155   int n = 0;
14156   for (bp_location *loc = b->loc; loc != NULL; loc = loc->next)
14157     if (++n == loc_num)
14158       return loc;
14159
14160   error (_("Bad breakpoint location number '%d'"), loc_num);
14161 }
14162
14163 /* Modes of operation for extract_bp_num.  */
14164 enum class extract_bp_kind
14165 {
14166   /* Extracting a breakpoint number.  */
14167   bp,
14168
14169   /* Extracting a location number.  */
14170   loc,
14171 };
14172
14173 /* Extract a breakpoint or location number (as determined by KIND)
14174    from the string starting at START.  TRAILER is a character which
14175    can be found after the number.  If you don't want a trailer, use
14176    '\0'.  If END_OUT is not NULL, it is set to point after the parsed
14177    string.  This always returns a positive integer.  */
14178
14179 static int
14180 extract_bp_num (extract_bp_kind kind, const char *start,
14181                 int trailer, const char **end_out = NULL)
14182 {
14183   const char *end = start;
14184   int num = get_number_trailer (&end, trailer);
14185   if (num < 0)
14186     error (kind == extract_bp_kind::bp
14187            ? _("Negative breakpoint number '%.*s'")
14188            : _("Negative breakpoint location number '%.*s'"),
14189            int (end - start), start);
14190   if (num == 0)
14191     error (kind == extract_bp_kind::bp
14192            ? _("Bad breakpoint number '%.*s'")
14193            : _("Bad breakpoint location number '%.*s'"),
14194            int (end - start), start);
14195
14196   if (end_out != NULL)
14197     *end_out = end;
14198   return num;
14199 }
14200
14201 /* Extract a breakpoint or location range (as determined by KIND) in
14202    the form NUM1-NUM2 stored at &ARG[arg_offset].  Returns a std::pair
14203    representing the (inclusive) range.  The returned pair's elements
14204    are always positive integers.  */
14205
14206 static std::pair<int, int>
14207 extract_bp_or_bp_range (extract_bp_kind kind,
14208                         const std::string &arg,
14209                         std::string::size_type arg_offset)
14210 {
14211   std::pair<int, int> range;
14212   const char *bp_loc = &arg[arg_offset];
14213   std::string::size_type dash = arg.find ('-', arg_offset);
14214   if (dash != std::string::npos)
14215     {
14216       /* bp_loc is a range (x-z).  */
14217       if (arg.length () == dash + 1)
14218         error (kind == extract_bp_kind::bp
14219                ? _("Bad breakpoint number at or near: '%s'")
14220                : _("Bad breakpoint location number at or near: '%s'"),
14221                bp_loc);
14222
14223       const char *end;
14224       const char *start_first = bp_loc;
14225       const char *start_second = &arg[dash + 1];
14226       range.first = extract_bp_num (kind, start_first, '-');
14227       range.second = extract_bp_num (kind, start_second, '\0', &end);
14228
14229       if (range.first > range.second)
14230         error (kind == extract_bp_kind::bp
14231                ? _("Inverted breakpoint range at '%.*s'")
14232                : _("Inverted breakpoint location range at '%.*s'"),
14233                int (end - start_first), start_first);
14234     }
14235   else
14236     {
14237       /* bp_loc is a single value.  */
14238       range.first = extract_bp_num (kind, bp_loc, '\0');
14239       range.second = range.first;
14240     }
14241   return range;
14242 }
14243
14244 /* Extract the breakpoint/location range specified by ARG.  Returns
14245    the breakpoint range in BP_NUM_RANGE, and the location range in
14246    BP_LOC_RANGE.
14247
14248    ARG may be in any of the following forms:
14249
14250    x     where 'x' is a breakpoint number.
14251    x-y   where 'x' and 'y' specify a breakpoint numbers range.
14252    x.y   where 'x' is a breakpoint number and 'y' a location number.
14253    x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14254          location number range.
14255 */
14256
14257 static void
14258 extract_bp_number_and_location (const std::string &arg,
14259                                 std::pair<int, int> &bp_num_range,
14260                                 std::pair<int, int> &bp_loc_range)
14261 {
14262   std::string::size_type dot = arg.find ('.');
14263
14264   if (dot != std::string::npos)
14265     {
14266       /* Handle 'x.y' and 'x.y-z' cases.  */
14267
14268       if (arg.length () == dot + 1 || dot == 0)
14269         error (_("Bad breakpoint number at or near: '%s'"), arg.c_str ());
14270
14271       bp_num_range.first
14272         = extract_bp_num (extract_bp_kind::bp, arg.c_str (), '.');
14273       bp_num_range.second = bp_num_range.first;
14274
14275       bp_loc_range = extract_bp_or_bp_range (extract_bp_kind::loc,
14276                                              arg, dot + 1);
14277     }
14278   else
14279     {
14280       /* Handle x and x-y cases.  */
14281
14282       bp_num_range = extract_bp_or_bp_range (extract_bp_kind::bp, arg, 0);
14283       bp_loc_range.first = 0;
14284       bp_loc_range.second = 0;
14285     }
14286 }
14287
14288 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM.  ENABLE
14289    specifies whether to enable or disable.  */
14290
14291 static void
14292 enable_disable_bp_num_loc (int bp_num, int loc_num, bool enable)
14293 {
14294   struct bp_location *loc = find_location_by_number (bp_num, loc_num);
14295   if (loc != NULL)
14296     {
14297       if (loc->enabled != enable)
14298         {
14299           loc->enabled = enable;
14300           mark_breakpoint_location_modified (loc);
14301         }
14302       if (target_supports_enable_disable_tracepoint ()
14303           && current_trace_status ()->running && loc->owner
14304           && is_tracepoint (loc->owner))
14305         target_disable_tracepoint (loc);
14306     }
14307   update_global_location_list (UGLL_DONT_INSERT);
14308 }
14309
14310 /* Enable or disable a range of breakpoint locations.  BP_NUM is the
14311    number of the breakpoint, and BP_LOC_RANGE specifies the
14312    (inclusive) range of location numbers of that breakpoint to
14313    enable/disable.  ENABLE specifies whether to enable or disable the
14314    location.  */
14315
14316 static void
14317 enable_disable_breakpoint_location_range (int bp_num,
14318                                           std::pair<int, int> &bp_loc_range,
14319                                           bool enable)
14320 {
14321   for (int i = bp_loc_range.first; i <= bp_loc_range.second; i++)
14322     enable_disable_bp_num_loc (bp_num, i, enable);
14323 }
14324
14325 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14326    If from_tty is nonzero, it prints a message to that effect,
14327    which ends with a period (no newline).  */
14328
14329 void
14330 disable_breakpoint (struct breakpoint *bpt)
14331 {
14332   /* Never disable a watchpoint scope breakpoint; we want to
14333      hit them when we leave scope so we can delete both the
14334      watchpoint and its scope breakpoint at that time.  */
14335   if (bpt->type == bp_watchpoint_scope)
14336     return;
14337
14338   bpt->enable_state = bp_disabled;
14339
14340   /* Mark breakpoint locations modified.  */
14341   mark_breakpoint_modified (bpt);
14342
14343   if (target_supports_enable_disable_tracepoint ()
14344       && current_trace_status ()->running && is_tracepoint (bpt))
14345     {
14346       struct bp_location *location;
14347      
14348       for (location = bpt->loc; location; location = location->next)
14349         target_disable_tracepoint (location);
14350     }
14351
14352   update_global_location_list (UGLL_DONT_INSERT);
14353
14354   observer_notify_breakpoint_modified (bpt);
14355 }
14356
14357 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14358    specified in ARGS.  ARGS may be in any of the formats handled by
14359    extract_bp_number_and_location.  ENABLE specifies whether to enable
14360    or disable the breakpoints/locations.  */
14361
14362 static void
14363 enable_disable_command (const char *args, int from_tty, bool enable)
14364 {
14365   if (args == 0)
14366     {
14367       struct breakpoint *bpt;
14368
14369       ALL_BREAKPOINTS (bpt)
14370         if (user_breakpoint_p (bpt))
14371           {
14372             if (enable)
14373               enable_breakpoint (bpt);
14374             else
14375               disable_breakpoint (bpt);
14376           }
14377     }
14378   else
14379     {
14380       std::string num = extract_arg (&args);
14381
14382       while (!num.empty ())
14383         {
14384           std::pair<int, int> bp_num_range, bp_loc_range;
14385
14386           extract_bp_number_and_location (num, bp_num_range, bp_loc_range);
14387
14388           if (bp_loc_range.first == bp_loc_range.second
14389               && bp_loc_range.first == 0)
14390             {
14391               /* Handle breakpoint ids with formats 'x' or 'x-z'.  */
14392               map_breakpoint_number_range (bp_num_range,
14393                                            enable
14394                                            ? enable_breakpoint
14395                                            : disable_breakpoint);
14396             }
14397           else
14398             {
14399               /* Handle breakpoint ids with formats 'x.y' or
14400                  'x.y-z'.  */
14401               enable_disable_breakpoint_location_range
14402                 (bp_num_range.first, bp_loc_range, enable);
14403             }
14404           num = extract_arg (&args);
14405         }
14406     }
14407 }
14408
14409 /* The disable command disables the specified breakpoints/locations
14410    (or all defined breakpoints) so they're no longer effective in
14411    stopping the inferior.  ARGS may be in any of the forms defined in
14412    extract_bp_number_and_location.  */
14413
14414 static void
14415 disable_command (const char *args, int from_tty)
14416 {
14417   enable_disable_command (args, from_tty, false);
14418 }
14419
14420 static void
14421 enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14422                         int count)
14423 {
14424   int target_resources_ok;
14425
14426   if (bpt->type == bp_hardware_breakpoint)
14427     {
14428       int i;
14429       i = hw_breakpoint_used_count ();
14430       target_resources_ok = 
14431         target_can_use_hardware_watchpoint (bp_hardware_breakpoint, 
14432                                             i + 1, 0);
14433       if (target_resources_ok == 0)
14434         error (_("No hardware breakpoint support in the target."));
14435       else if (target_resources_ok < 0)
14436         error (_("Hardware breakpoints used exceeds limit."));
14437     }
14438
14439   if (is_watchpoint (bpt))
14440     {
14441       /* Initialize it just to avoid a GCC false warning.  */
14442       enum enable_state orig_enable_state = bp_disabled;
14443
14444       TRY
14445         {
14446           struct watchpoint *w = (struct watchpoint *) bpt;
14447
14448           orig_enable_state = bpt->enable_state;
14449           bpt->enable_state = bp_enabled;
14450           update_watchpoint (w, 1 /* reparse */);
14451         }
14452       CATCH (e, RETURN_MASK_ALL)
14453         {
14454           bpt->enable_state = orig_enable_state;
14455           exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14456                              bpt->number);
14457           return;
14458         }
14459       END_CATCH
14460     }
14461
14462   bpt->enable_state = bp_enabled;
14463
14464   /* Mark breakpoint locations modified.  */
14465   mark_breakpoint_modified (bpt);
14466
14467   if (target_supports_enable_disable_tracepoint ()
14468       && current_trace_status ()->running && is_tracepoint (bpt))
14469     {
14470       struct bp_location *location;
14471
14472       for (location = bpt->loc; location; location = location->next)
14473         target_enable_tracepoint (location);
14474     }
14475
14476   bpt->disposition = disposition;
14477   bpt->enable_count = count;
14478   update_global_location_list (UGLL_MAY_INSERT);
14479
14480   observer_notify_breakpoint_modified (bpt);
14481 }
14482
14483
14484 void
14485 enable_breakpoint (struct breakpoint *bpt)
14486 {
14487   enable_breakpoint_disp (bpt, bpt->disposition, 0);
14488 }
14489
14490 /* The enable command enables the specified breakpoints/locations (or
14491    all defined breakpoints) so they once again become (or continue to
14492    be) effective in stopping the inferior.  ARGS may be in any of the
14493    forms defined in extract_bp_number_and_location.  */
14494
14495 static void
14496 enable_command (const char *args, int from_tty)
14497 {
14498   enable_disable_command (args, from_tty, true);
14499 }
14500
14501 static void
14502 enable_once_command (const char *args, int from_tty)
14503 {
14504   map_breakpoint_numbers
14505     (args, [&] (breakpoint *b)
14506      {
14507        iterate_over_related_breakpoints
14508          (b, [&] (breakpoint *bpt)
14509           {
14510             enable_breakpoint_disp (bpt, disp_disable, 1);
14511           });
14512      });
14513 }
14514
14515 static void
14516 enable_count_command (const char *args, int from_tty)
14517 {
14518   int count;
14519
14520   if (args == NULL)
14521     error_no_arg (_("hit count"));
14522
14523   count = get_number (&args);
14524
14525   map_breakpoint_numbers
14526     (args, [&] (breakpoint *b)
14527      {
14528        iterate_over_related_breakpoints
14529          (b, [&] (breakpoint *bpt)
14530           {
14531             enable_breakpoint_disp (bpt, disp_disable, count);
14532           });
14533      });
14534 }
14535
14536 static void
14537 enable_delete_command (const char *args, int from_tty)
14538 {
14539   map_breakpoint_numbers
14540     (args, [&] (breakpoint *b)
14541      {
14542        iterate_over_related_breakpoints
14543          (b, [&] (breakpoint *bpt)
14544           {
14545             enable_breakpoint_disp (bpt, disp_del, 1);
14546           });
14547      });
14548 }
14549 \f
14550 static void
14551 set_breakpoint_cmd (const char *args, int from_tty)
14552 {
14553 }
14554
14555 static void
14556 show_breakpoint_cmd (const char *args, int from_tty)
14557 {
14558 }
14559
14560 /* Invalidate last known value of any hardware watchpoint if
14561    the memory which that value represents has been written to by
14562    GDB itself.  */
14563
14564 static void
14565 invalidate_bp_value_on_memory_change (struct inferior *inferior,
14566                                       CORE_ADDR addr, ssize_t len,
14567                                       const bfd_byte *data)
14568 {
14569   struct breakpoint *bp;
14570
14571   ALL_BREAKPOINTS (bp)
14572     if (bp->enable_state == bp_enabled
14573         && bp->type == bp_hardware_watchpoint)
14574       {
14575         struct watchpoint *wp = (struct watchpoint *) bp;
14576
14577         if (wp->val_valid && wp->val)
14578           {
14579             struct bp_location *loc;
14580
14581             for (loc = bp->loc; loc != NULL; loc = loc->next)
14582               if (loc->loc_type == bp_loc_hardware_watchpoint
14583                   && loc->address + loc->length > addr
14584                   && addr + len > loc->address)
14585                 {
14586                   value_free (wp->val);
14587                   wp->val = NULL;
14588                   wp->val_valid = 0;
14589                 }
14590           }
14591       }
14592 }
14593
14594 /* Create and insert a breakpoint for software single step.  */
14595
14596 void
14597 insert_single_step_breakpoint (struct gdbarch *gdbarch,
14598                                const address_space *aspace,
14599                                CORE_ADDR next_pc)
14600 {
14601   struct thread_info *tp = inferior_thread ();
14602   struct symtab_and_line sal;
14603   CORE_ADDR pc = next_pc;
14604
14605   if (tp->control.single_step_breakpoints == NULL)
14606     {
14607       tp->control.single_step_breakpoints
14608         = new_single_step_breakpoint (tp->global_num, gdbarch);
14609     }
14610
14611   sal = find_pc_line (pc, 0);
14612   sal.pc = pc;
14613   sal.section = find_pc_overlay (pc);
14614   sal.explicit_pc = 1;
14615   add_location_to_breakpoint (tp->control.single_step_breakpoints, &sal);
14616
14617   update_global_location_list (UGLL_INSERT);
14618 }
14619
14620 /* Insert single step breakpoints according to the current state.  */
14621
14622 int
14623 insert_single_step_breakpoints (struct gdbarch *gdbarch)
14624 {
14625   struct regcache *regcache = get_current_regcache ();
14626   std::vector<CORE_ADDR> next_pcs;
14627
14628   next_pcs = gdbarch_software_single_step (gdbarch, regcache);
14629
14630   if (!next_pcs.empty ())
14631     {
14632       struct frame_info *frame = get_current_frame ();
14633       const address_space *aspace = get_frame_address_space (frame);
14634
14635       for (CORE_ADDR pc : next_pcs)
14636         insert_single_step_breakpoint (gdbarch, aspace, pc);
14637
14638       return 1;
14639     }
14640   else
14641     return 0;
14642 }
14643
14644 /* See breakpoint.h.  */
14645
14646 int
14647 breakpoint_has_location_inserted_here (struct breakpoint *bp,
14648                                        const address_space *aspace,
14649                                        CORE_ADDR pc)
14650 {
14651   struct bp_location *loc;
14652
14653   for (loc = bp->loc; loc != NULL; loc = loc->next)
14654     if (loc->inserted
14655         && breakpoint_location_address_match (loc, aspace, pc))
14656       return 1;
14657
14658   return 0;
14659 }
14660
14661 /* Check whether a software single-step breakpoint is inserted at
14662    PC.  */
14663
14664 int
14665 single_step_breakpoint_inserted_here_p (const address_space *aspace,
14666                                         CORE_ADDR pc)
14667 {
14668   struct breakpoint *bpt;
14669
14670   ALL_BREAKPOINTS (bpt)
14671     {
14672       if (bpt->type == bp_single_step
14673           && breakpoint_has_location_inserted_here (bpt, aspace, pc))
14674         return 1;
14675     }
14676   return 0;
14677 }
14678
14679 /* Tracepoint-specific operations.  */
14680
14681 /* Set tracepoint count to NUM.  */
14682 static void
14683 set_tracepoint_count (int num)
14684 {
14685   tracepoint_count = num;
14686   set_internalvar_integer (lookup_internalvar ("tpnum"), num);
14687 }
14688
14689 static void
14690 trace_command (const char *arg, int from_tty)
14691 {
14692   struct breakpoint_ops *ops;
14693
14694   event_location_up location = string_to_event_location (&arg,
14695                                                          current_language);
14696   if (location != NULL
14697       && event_location_type (location.get ()) == PROBE_LOCATION)
14698     ops = &tracepoint_probe_breakpoint_ops;
14699   else
14700     ops = &tracepoint_breakpoint_ops;
14701
14702   create_breakpoint (get_current_arch (),
14703                      location.get (),
14704                      NULL, 0, arg, 1 /* parse arg */,
14705                      0 /* tempflag */,
14706                      bp_tracepoint /* type_wanted */,
14707                      0 /* Ignore count */,
14708                      pending_break_support,
14709                      ops,
14710                      from_tty,
14711                      1 /* enabled */,
14712                      0 /* internal */, 0);
14713 }
14714
14715 static void
14716 ftrace_command (const char *arg, int from_tty)
14717 {
14718   event_location_up location = string_to_event_location (&arg,
14719                                                          current_language);
14720   create_breakpoint (get_current_arch (),
14721                      location.get (),
14722                      NULL, 0, arg, 1 /* parse arg */,
14723                      0 /* tempflag */,
14724                      bp_fast_tracepoint /* type_wanted */,
14725                      0 /* Ignore count */,
14726                      pending_break_support,
14727                      &tracepoint_breakpoint_ops,
14728                      from_tty,
14729                      1 /* enabled */,
14730                      0 /* internal */, 0);
14731 }
14732
14733 /* strace command implementation.  Creates a static tracepoint.  */
14734
14735 static void
14736 strace_command (const char *arg, int from_tty)
14737 {
14738   struct breakpoint_ops *ops;
14739   event_location_up location;
14740
14741   /* Decide if we are dealing with a static tracepoint marker (`-m'),
14742      or with a normal static tracepoint.  */
14743   if (arg && startswith (arg, "-m") && isspace (arg[2]))
14744     {
14745       ops = &strace_marker_breakpoint_ops;
14746       location = new_linespec_location (&arg, symbol_name_match_type::FULL);
14747     }
14748   else
14749     {
14750       ops = &tracepoint_breakpoint_ops;
14751       location = string_to_event_location (&arg, current_language);
14752     }
14753
14754   create_breakpoint (get_current_arch (),
14755                      location.get (),
14756                      NULL, 0, arg, 1 /* parse arg */,
14757                      0 /* tempflag */,
14758                      bp_static_tracepoint /* type_wanted */,
14759                      0 /* Ignore count */,
14760                      pending_break_support,
14761                      ops,
14762                      from_tty,
14763                      1 /* enabled */,
14764                      0 /* internal */, 0);
14765 }
14766
14767 /* Set up a fake reader function that gets command lines from a linked
14768    list that was acquired during tracepoint uploading.  */
14769
14770 static struct uploaded_tp *this_utp;
14771 static int next_cmd;
14772
14773 static char *
14774 read_uploaded_action (void)
14775 {
14776   char *rslt;
14777
14778   VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
14779
14780   next_cmd++;
14781
14782   return rslt;
14783 }
14784
14785 /* Given information about a tracepoint as recorded on a target (which
14786    can be either a live system or a trace file), attempt to create an
14787    equivalent GDB tracepoint.  This is not a reliable process, since
14788    the target does not necessarily have all the information used when
14789    the tracepoint was originally defined.  */
14790   
14791 struct tracepoint *
14792 create_tracepoint_from_upload (struct uploaded_tp *utp)
14793 {
14794   const char *addr_str;
14795   char small_buf[100];
14796   struct tracepoint *tp;
14797
14798   if (utp->at_string)
14799     addr_str = utp->at_string;
14800   else
14801     {
14802       /* In the absence of a source location, fall back to raw
14803          address.  Since there is no way to confirm that the address
14804          means the same thing as when the trace was started, warn the
14805          user.  */
14806       warning (_("Uploaded tracepoint %d has no "
14807                  "source location, using raw address"),
14808                utp->number);
14809       xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (utp->addr));
14810       addr_str = small_buf;
14811     }
14812
14813   /* There's not much we can do with a sequence of bytecodes.  */
14814   if (utp->cond && !utp->cond_string)
14815     warning (_("Uploaded tracepoint %d condition "
14816                "has no source form, ignoring it"),
14817              utp->number);
14818
14819   event_location_up location = string_to_event_location (&addr_str,
14820                                                          current_language);
14821   if (!create_breakpoint (get_current_arch (),
14822                           location.get (),
14823                           utp->cond_string, -1, addr_str,
14824                           0 /* parse cond/thread */,
14825                           0 /* tempflag */,
14826                           utp->type /* type_wanted */,
14827                           0 /* Ignore count */,
14828                           pending_break_support,
14829                           &tracepoint_breakpoint_ops,
14830                           0 /* from_tty */,
14831                           utp->enabled /* enabled */,
14832                           0 /* internal */,
14833                           CREATE_BREAKPOINT_FLAGS_INSERTED))
14834     return NULL;
14835
14836   /* Get the tracepoint we just created.  */
14837   tp = get_tracepoint (tracepoint_count);
14838   gdb_assert (tp != NULL);
14839
14840   if (utp->pass > 0)
14841     {
14842       xsnprintf (small_buf, sizeof (small_buf), "%d %d", utp->pass,
14843                  tp->number);
14844
14845       trace_pass_command (small_buf, 0);
14846     }
14847
14848   /* If we have uploaded versions of the original commands, set up a
14849      special-purpose "reader" function and call the usual command line
14850      reader, then pass the result to the breakpoint command-setting
14851      function.  */
14852   if (!VEC_empty (char_ptr, utp->cmd_strings))
14853     {
14854       command_line_up cmd_list;
14855
14856       this_utp = utp;
14857       next_cmd = 0;
14858
14859       cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
14860
14861       breakpoint_set_commands (tp, std::move (cmd_list));
14862     }
14863   else if (!VEC_empty (char_ptr, utp->actions)
14864            || !VEC_empty (char_ptr, utp->step_actions))
14865     warning (_("Uploaded tracepoint %d actions "
14866                "have no source form, ignoring them"),
14867              utp->number);
14868
14869   /* Copy any status information that might be available.  */
14870   tp->hit_count = utp->hit_count;
14871   tp->traceframe_usage = utp->traceframe_usage;
14872
14873   return tp;
14874 }
14875   
14876 /* Print information on tracepoint number TPNUM_EXP, or all if
14877    omitted.  */
14878
14879 static void
14880 info_tracepoints_command (const char *args, int from_tty)
14881 {
14882   struct ui_out *uiout = current_uiout;
14883   int num_printed;
14884
14885   num_printed = breakpoint_1 (args, 0, is_tracepoint);
14886
14887   if (num_printed == 0)
14888     {
14889       if (args == NULL || *args == '\0')
14890         uiout->message ("No tracepoints.\n");
14891       else
14892         uiout->message ("No tracepoint matching '%s'.\n", args);
14893     }
14894
14895   default_collect_info ();
14896 }
14897
14898 /* The 'enable trace' command enables tracepoints.
14899    Not supported by all targets.  */
14900 static void
14901 enable_trace_command (const char *args, int from_tty)
14902 {
14903   enable_command (args, from_tty);
14904 }
14905
14906 /* The 'disable trace' command disables tracepoints.
14907    Not supported by all targets.  */
14908 static void
14909 disable_trace_command (const char *args, int from_tty)
14910 {
14911   disable_command (args, from_tty);
14912 }
14913
14914 /* Remove a tracepoint (or all if no argument).  */
14915 static void
14916 delete_trace_command (const char *arg, int from_tty)
14917 {
14918   struct breakpoint *b, *b_tmp;
14919
14920   dont_repeat ();
14921
14922   if (arg == 0)
14923     {
14924       int breaks_to_delete = 0;
14925
14926       /* Delete all breakpoints if no argument.
14927          Do not delete internal or call-dummy breakpoints, these
14928          have to be deleted with an explicit breakpoint number 
14929          argument.  */
14930       ALL_TRACEPOINTS (b)
14931         if (is_tracepoint (b) && user_breakpoint_p (b))
14932           {
14933             breaks_to_delete = 1;
14934             break;
14935           }
14936
14937       /* Ask user only if there are some breakpoints to delete.  */
14938       if (!from_tty
14939           || (breaks_to_delete && query (_("Delete all tracepoints? "))))
14940         {
14941           ALL_BREAKPOINTS_SAFE (b, b_tmp)
14942             if (is_tracepoint (b) && user_breakpoint_p (b))
14943               delete_breakpoint (b);
14944         }
14945     }
14946   else
14947     map_breakpoint_numbers
14948       (arg, [&] (breakpoint *b)
14949        {
14950          iterate_over_related_breakpoints (b, delete_breakpoint);
14951        });
14952 }
14953
14954 /* Helper function for trace_pass_command.  */
14955
14956 static void
14957 trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
14958 {
14959   tp->pass_count = count;
14960   observer_notify_breakpoint_modified (tp);
14961   if (from_tty)
14962     printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14963                      tp->number, count);
14964 }
14965
14966 /* Set passcount for tracepoint.
14967
14968    First command argument is passcount, second is tracepoint number.
14969    If tracepoint number omitted, apply to most recently defined.
14970    Also accepts special argument "all".  */
14971
14972 static void
14973 trace_pass_command (const char *args, int from_tty)
14974 {
14975   struct tracepoint *t1;
14976   ULONGEST count;
14977
14978   if (args == 0 || *args == 0)
14979     error (_("passcount command requires an "
14980              "argument (count + optional TP num)"));
14981
14982   count = strtoulst (args, &args, 10);  /* Count comes first, then TP num.  */
14983
14984   args = skip_spaces (args);
14985   if (*args && strncasecmp (args, "all", 3) == 0)
14986     {
14987       struct breakpoint *b;
14988
14989       args += 3;                        /* Skip special argument "all".  */
14990       if (*args)
14991         error (_("Junk at end of arguments."));
14992
14993       ALL_TRACEPOINTS (b)
14994       {
14995         t1 = (struct tracepoint *) b;
14996         trace_pass_set_count (t1, count, from_tty);
14997       }
14998     }
14999   else if (*args == '\0')
15000     {
15001       t1 = get_tracepoint_by_number (&args, NULL);
15002       if (t1)
15003         trace_pass_set_count (t1, count, from_tty);
15004     }
15005   else
15006     {
15007       number_or_range_parser parser (args);
15008       while (!parser.finished ())
15009         {
15010           t1 = get_tracepoint_by_number (&args, &parser);
15011           if (t1)
15012             trace_pass_set_count (t1, count, from_tty);
15013         }
15014     }
15015 }
15016
15017 struct tracepoint *
15018 get_tracepoint (int num)
15019 {
15020   struct breakpoint *t;
15021
15022   ALL_TRACEPOINTS (t)
15023     if (t->number == num)
15024       return (struct tracepoint *) t;
15025
15026   return NULL;
15027 }
15028
15029 /* Find the tracepoint with the given target-side number (which may be
15030    different from the tracepoint number after disconnecting and
15031    reconnecting).  */
15032
15033 struct tracepoint *
15034 get_tracepoint_by_number_on_target (int num)
15035 {
15036   struct breakpoint *b;
15037
15038   ALL_TRACEPOINTS (b)
15039     {
15040       struct tracepoint *t = (struct tracepoint *) b;
15041
15042       if (t->number_on_target == num)
15043         return t;
15044     }
15045
15046   return NULL;
15047 }
15048
15049 /* Utility: parse a tracepoint number and look it up in the list.
15050    If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15051    If the argument is missing, the most recent tracepoint
15052    (tracepoint_count) is returned.  */
15053
15054 struct tracepoint *
15055 get_tracepoint_by_number (const char **arg,
15056                           number_or_range_parser *parser)
15057 {
15058   struct breakpoint *t;
15059   int tpnum;
15060   const char *instring = arg == NULL ? NULL : *arg;
15061
15062   if (parser != NULL)
15063     {
15064       gdb_assert (!parser->finished ());
15065       tpnum = parser->get_number ();
15066     }
15067   else if (arg == NULL || *arg == NULL || ! **arg)
15068     tpnum = tracepoint_count;
15069   else
15070     tpnum = get_number (arg);
15071
15072   if (tpnum <= 0)
15073     {
15074       if (instring && *instring)
15075         printf_filtered (_("bad tracepoint number at or near '%s'\n"), 
15076                          instring);
15077       else
15078         printf_filtered (_("No previous tracepoint\n"));
15079       return NULL;
15080     }
15081
15082   ALL_TRACEPOINTS (t)
15083     if (t->number == tpnum)
15084     {
15085       return (struct tracepoint *) t;
15086     }
15087
15088   printf_unfiltered ("No tracepoint number %d.\n", tpnum);
15089   return NULL;
15090 }
15091
15092 void
15093 print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
15094 {
15095   if (b->thread != -1)
15096     fprintf_unfiltered (fp, " thread %d", b->thread);
15097
15098   if (b->task != 0)
15099     fprintf_unfiltered (fp, " task %d", b->task);
15100
15101   fprintf_unfiltered (fp, "\n");
15102 }
15103
15104 /* Save information on user settable breakpoints (watchpoints, etc) to
15105    a new script file named FILENAME.  If FILTER is non-NULL, call it
15106    on each breakpoint and only include the ones for which it returns
15107    non-zero.  */
15108
15109 static void
15110 save_breakpoints (const char *filename, int from_tty,
15111                   int (*filter) (const struct breakpoint *))
15112 {
15113   struct breakpoint *tp;
15114   int any = 0;
15115   int extra_trace_bits = 0;
15116
15117   if (filename == 0 || *filename == 0)
15118     error (_("Argument required (file name in which to save)"));
15119
15120   /* See if we have anything to save.  */
15121   ALL_BREAKPOINTS (tp)
15122   {
15123     /* Skip internal and momentary breakpoints.  */
15124     if (!user_breakpoint_p (tp))
15125       continue;
15126
15127     /* If we have a filter, only save the breakpoints it accepts.  */
15128     if (filter && !filter (tp))
15129       continue;
15130
15131     any = 1;
15132
15133     if (is_tracepoint (tp))
15134       {
15135         extra_trace_bits = 1;
15136
15137         /* We can stop searching.  */
15138         break;
15139       }
15140   }
15141
15142   if (!any)
15143     {
15144       warning (_("Nothing to save."));
15145       return;
15146     }
15147
15148   gdb::unique_xmalloc_ptr<char> expanded_filename (tilde_expand (filename));
15149
15150   stdio_file fp;
15151
15152   if (!fp.open (expanded_filename.get (), "w"))
15153     error (_("Unable to open file '%s' for saving (%s)"),
15154            expanded_filename.get (), safe_strerror (errno));
15155
15156   if (extra_trace_bits)
15157     save_trace_state_variables (&fp);
15158
15159   ALL_BREAKPOINTS (tp)
15160   {
15161     /* Skip internal and momentary breakpoints.  */
15162     if (!user_breakpoint_p (tp))
15163       continue;
15164
15165     /* If we have a filter, only save the breakpoints it accepts.  */
15166     if (filter && !filter (tp))
15167       continue;
15168
15169     tp->ops->print_recreate (tp, &fp);
15170
15171     /* Note, we can't rely on tp->number for anything, as we can't
15172        assume the recreated breakpoint numbers will match.  Use $bpnum
15173        instead.  */
15174
15175     if (tp->cond_string)
15176       fp.printf ("  condition $bpnum %s\n", tp->cond_string);
15177
15178     if (tp->ignore_count)
15179       fp.printf ("  ignore $bpnum %d\n", tp->ignore_count);
15180
15181     if (tp->type != bp_dprintf && tp->commands)
15182       {
15183         fp.puts ("  commands\n");
15184         
15185         current_uiout->redirect (&fp);
15186         TRY
15187           {
15188             print_command_lines (current_uiout, tp->commands.get (), 2);
15189           }
15190         CATCH (ex, RETURN_MASK_ALL)
15191           {
15192           current_uiout->redirect (NULL);
15193             throw_exception (ex);
15194           }
15195         END_CATCH
15196
15197         current_uiout->redirect (NULL);
15198         fp.puts ("  end\n");
15199       }
15200
15201     if (tp->enable_state == bp_disabled)
15202       fp.puts ("disable $bpnum\n");
15203
15204     /* If this is a multi-location breakpoint, check if the locations
15205        should be individually disabled.  Watchpoint locations are
15206        special, and not user visible.  */
15207     if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15208       {
15209         struct bp_location *loc;
15210         int n = 1;
15211
15212         for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15213           if (!loc->enabled)
15214             fp.printf ("disable $bpnum.%d\n", n);
15215       }
15216   }
15217
15218   if (extra_trace_bits && *default_collect)
15219     fp.printf ("set default-collect %s\n", default_collect);
15220
15221   if (from_tty)
15222     printf_filtered (_("Saved to file '%s'.\n"), expanded_filename.get ());
15223 }
15224
15225 /* The `save breakpoints' command.  */
15226
15227 static void
15228 save_breakpoints_command (const char *args, int from_tty)
15229 {
15230   save_breakpoints (args, from_tty, NULL);
15231 }
15232
15233 /* The `save tracepoints' command.  */
15234
15235 static void
15236 save_tracepoints_command (const char *args, int from_tty)
15237 {
15238   save_breakpoints (args, from_tty, is_tracepoint);
15239 }
15240
15241 /* Create a vector of all tracepoints.  */
15242
15243 VEC(breakpoint_p) *
15244 all_tracepoints (void)
15245 {
15246   VEC(breakpoint_p) *tp_vec = 0;
15247   struct breakpoint *tp;
15248
15249   ALL_TRACEPOINTS (tp)
15250   {
15251     VEC_safe_push (breakpoint_p, tp_vec, tp);
15252   }
15253
15254   return tp_vec;
15255 }
15256
15257 \f
15258 /* This help string is used to consolidate all the help string for specifying
15259    locations used by several commands.  */
15260
15261 #define LOCATION_HELP_STRING \
15262 "Linespecs are colon-separated lists of location parameters, such as\n\
15263 source filename, function name, label name, and line number.\n\
15264 Example: To specify the start of a label named \"the_top\" in the\n\
15265 function \"fact\" in the file \"factorial.c\", use\n\
15266 \"factorial.c:fact:the_top\".\n\
15267 \n\
15268 Address locations begin with \"*\" and specify an exact address in the\n\
15269 program.  Example: To specify the fourth byte past the start function\n\
15270 \"main\", use \"*main + 4\".\n\
15271 \n\
15272 Explicit locations are similar to linespecs but use an option/argument\n\
15273 syntax to specify location parameters.\n\
15274 Example: To specify the start of the label named \"the_top\" in the\n\
15275 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15276 -function fact -label the_top\".\n\
15277 \n\
15278 By default, a specified function is matched against the program's\n\
15279 functions in all scopes.  For C++, this means in all namespaces and\n\
15280 classes.  For Ada, this means in all packages.  E.g., in C++,\n\
15281 \"func()\" matches \"A::func()\", \"A::B::func()\", etc.  The\n\
15282 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15283 specified name as a complete fully-qualified name instead.\n"
15284
15285 /* This help string is used for the break, hbreak, tbreak and thbreak
15286    commands.  It is defined as a macro to prevent duplication.
15287    COMMAND should be a string constant containing the name of the
15288    command.  */
15289
15290 #define BREAK_ARGS_HELP(command) \
15291 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15292 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15293 probe point.  Accepted values are `-probe' (for a generic, automatically\n\
15294 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15295 `-probe-dtrace' (for a DTrace probe).\n\
15296 LOCATION may be a linespec, address, or explicit location as described\n\
15297 below.\n\
15298 \n\
15299 With no LOCATION, uses current execution address of the selected\n\
15300 stack frame.  This is useful for breaking on return to a stack frame.\n\
15301 \n\
15302 THREADNUM is the number from \"info threads\".\n\
15303 CONDITION is a boolean expression.\n\
15304 \n" LOCATION_HELP_STRING "\n\
15305 Multiple breakpoints at one place are permitted, and useful if their\n\
15306 conditions are different.\n\
15307 \n\
15308 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15309
15310 /* List of subcommands for "catch".  */
15311 static struct cmd_list_element *catch_cmdlist;
15312
15313 /* List of subcommands for "tcatch".  */
15314 static struct cmd_list_element *tcatch_cmdlist;
15315
15316 void
15317 add_catch_command (const char *name, const char *docstring,
15318                    cmd_const_sfunc_ftype *sfunc,
15319                    completer_ftype *completer,
15320                    void *user_data_catch,
15321                    void *user_data_tcatch)
15322 {
15323   struct cmd_list_element *command;
15324
15325   command = add_cmd (name, class_breakpoint, docstring,
15326                      &catch_cmdlist);
15327   set_cmd_sfunc (command, sfunc);
15328   set_cmd_context (command, user_data_catch);
15329   set_cmd_completer (command, completer);
15330
15331   command = add_cmd (name, class_breakpoint, docstring,
15332                      &tcatch_cmdlist);
15333   set_cmd_sfunc (command, sfunc);
15334   set_cmd_context (command, user_data_tcatch);
15335   set_cmd_completer (command, completer);
15336 }
15337
15338 static void
15339 save_command (const char *arg, int from_tty)
15340 {
15341   printf_unfiltered (_("\"save\" must be followed by "
15342                        "the name of a save subcommand.\n"));
15343   help_list (save_cmdlist, "save ", all_commands, gdb_stdout);
15344 }
15345
15346 struct breakpoint *
15347 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15348                           void *data)
15349 {
15350   struct breakpoint *b, *b_tmp;
15351
15352   ALL_BREAKPOINTS_SAFE (b, b_tmp)
15353     {
15354       if ((*callback) (b, data))
15355         return b;
15356     }
15357
15358   return NULL;
15359 }
15360
15361 /* Zero if any of the breakpoint's locations could be a location where
15362    functions have been inlined, nonzero otherwise.  */
15363
15364 static int
15365 is_non_inline_function (struct breakpoint *b)
15366 {
15367   /* The shared library event breakpoint is set on the address of a
15368      non-inline function.  */
15369   if (b->type == bp_shlib_event)
15370     return 1;
15371
15372   return 0;
15373 }
15374
15375 /* Nonzero if the specified PC cannot be a location where functions
15376    have been inlined.  */
15377
15378 int
15379 pc_at_non_inline_function (const address_space *aspace, CORE_ADDR pc,
15380                            const struct target_waitstatus *ws)
15381 {
15382   struct breakpoint *b;
15383   struct bp_location *bl;
15384
15385   ALL_BREAKPOINTS (b)
15386     {
15387       if (!is_non_inline_function (b))
15388         continue;
15389
15390       for (bl = b->loc; bl != NULL; bl = bl->next)
15391         {
15392           if (!bl->shlib_disabled
15393               && bpstat_check_location (bl, aspace, pc, ws))
15394             return 1;
15395         }
15396     }
15397
15398   return 0;
15399 }
15400
15401 /* Remove any references to OBJFILE which is going to be freed.  */
15402
15403 void
15404 breakpoint_free_objfile (struct objfile *objfile)
15405 {
15406   struct bp_location **locp, *loc;
15407
15408   ALL_BP_LOCATIONS (loc, locp)
15409     if (loc->symtab != NULL && SYMTAB_OBJFILE (loc->symtab) == objfile)
15410       loc->symtab = NULL;
15411 }
15412
15413 void
15414 initialize_breakpoint_ops (void)
15415 {
15416   static int initialized = 0;
15417
15418   struct breakpoint_ops *ops;
15419
15420   if (initialized)
15421     return;
15422   initialized = 1;
15423
15424   /* The breakpoint_ops structure to be inherit by all kinds of
15425      breakpoints (real breakpoints, i.e., user "break" breakpoints,
15426      internal and momentary breakpoints, etc.).  */
15427   ops = &bkpt_base_breakpoint_ops;
15428   *ops = base_breakpoint_ops;
15429   ops->re_set = bkpt_re_set;
15430   ops->insert_location = bkpt_insert_location;
15431   ops->remove_location = bkpt_remove_location;
15432   ops->breakpoint_hit = bkpt_breakpoint_hit;
15433   ops->create_sals_from_location = bkpt_create_sals_from_location;
15434   ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
15435   ops->decode_location = bkpt_decode_location;
15436
15437   /* The breakpoint_ops structure to be used in regular breakpoints.  */
15438   ops = &bkpt_breakpoint_ops;
15439   *ops = bkpt_base_breakpoint_ops;
15440   ops->re_set = bkpt_re_set;
15441   ops->resources_needed = bkpt_resources_needed;
15442   ops->print_it = bkpt_print_it;
15443   ops->print_mention = bkpt_print_mention;
15444   ops->print_recreate = bkpt_print_recreate;
15445
15446   /* Ranged breakpoints.  */
15447   ops = &ranged_breakpoint_ops;
15448   *ops = bkpt_breakpoint_ops;
15449   ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15450   ops->resources_needed = resources_needed_ranged_breakpoint;
15451   ops->print_it = print_it_ranged_breakpoint;
15452   ops->print_one = print_one_ranged_breakpoint;
15453   ops->print_one_detail = print_one_detail_ranged_breakpoint;
15454   ops->print_mention = print_mention_ranged_breakpoint;
15455   ops->print_recreate = print_recreate_ranged_breakpoint;
15456
15457   /* Internal breakpoints.  */
15458   ops = &internal_breakpoint_ops;
15459   *ops = bkpt_base_breakpoint_ops;
15460   ops->re_set = internal_bkpt_re_set;
15461   ops->check_status = internal_bkpt_check_status;
15462   ops->print_it = internal_bkpt_print_it;
15463   ops->print_mention = internal_bkpt_print_mention;
15464
15465   /* Momentary breakpoints.  */
15466   ops = &momentary_breakpoint_ops;
15467   *ops = bkpt_base_breakpoint_ops;
15468   ops->re_set = momentary_bkpt_re_set;
15469   ops->check_status = momentary_bkpt_check_status;
15470   ops->print_it = momentary_bkpt_print_it;
15471   ops->print_mention = momentary_bkpt_print_mention;
15472
15473   /* Probe breakpoints.  */
15474   ops = &bkpt_probe_breakpoint_ops;
15475   *ops = bkpt_breakpoint_ops;
15476   ops->insert_location = bkpt_probe_insert_location;
15477   ops->remove_location = bkpt_probe_remove_location;
15478   ops->create_sals_from_location = bkpt_probe_create_sals_from_location;
15479   ops->decode_location = bkpt_probe_decode_location;
15480
15481   /* Watchpoints.  */
15482   ops = &watchpoint_breakpoint_ops;
15483   *ops = base_breakpoint_ops;
15484   ops->re_set = re_set_watchpoint;
15485   ops->insert_location = insert_watchpoint;
15486   ops->remove_location = remove_watchpoint;
15487   ops->breakpoint_hit = breakpoint_hit_watchpoint;
15488   ops->check_status = check_status_watchpoint;
15489   ops->resources_needed = resources_needed_watchpoint;
15490   ops->works_in_software_mode = works_in_software_mode_watchpoint;
15491   ops->print_it = print_it_watchpoint;
15492   ops->print_mention = print_mention_watchpoint;
15493   ops->print_recreate = print_recreate_watchpoint;
15494   ops->explains_signal = explains_signal_watchpoint;
15495
15496   /* Masked watchpoints.  */
15497   ops = &masked_watchpoint_breakpoint_ops;
15498   *ops = watchpoint_breakpoint_ops;
15499   ops->insert_location = insert_masked_watchpoint;
15500   ops->remove_location = remove_masked_watchpoint;
15501   ops->resources_needed = resources_needed_masked_watchpoint;
15502   ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15503   ops->print_it = print_it_masked_watchpoint;
15504   ops->print_one_detail = print_one_detail_masked_watchpoint;
15505   ops->print_mention = print_mention_masked_watchpoint;
15506   ops->print_recreate = print_recreate_masked_watchpoint;
15507
15508   /* Tracepoints.  */
15509   ops = &tracepoint_breakpoint_ops;
15510   *ops = base_breakpoint_ops;
15511   ops->re_set = tracepoint_re_set;
15512   ops->breakpoint_hit = tracepoint_breakpoint_hit;
15513   ops->print_one_detail = tracepoint_print_one_detail;
15514   ops->print_mention = tracepoint_print_mention;
15515   ops->print_recreate = tracepoint_print_recreate;
15516   ops->create_sals_from_location = tracepoint_create_sals_from_location;
15517   ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
15518   ops->decode_location = tracepoint_decode_location;
15519
15520   /* Probe tracepoints.  */
15521   ops = &tracepoint_probe_breakpoint_ops;
15522   *ops = tracepoint_breakpoint_ops;
15523   ops->create_sals_from_location = tracepoint_probe_create_sals_from_location;
15524   ops->decode_location = tracepoint_probe_decode_location;
15525
15526   /* Static tracepoints with marker (`-m').  */
15527   ops = &strace_marker_breakpoint_ops;
15528   *ops = tracepoint_breakpoint_ops;
15529   ops->create_sals_from_location = strace_marker_create_sals_from_location;
15530   ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
15531   ops->decode_location = strace_marker_decode_location;
15532
15533   /* Fork catchpoints.  */
15534   ops = &catch_fork_breakpoint_ops;
15535   *ops = base_breakpoint_ops;
15536   ops->insert_location = insert_catch_fork;
15537   ops->remove_location = remove_catch_fork;
15538   ops->breakpoint_hit = breakpoint_hit_catch_fork;
15539   ops->print_it = print_it_catch_fork;
15540   ops->print_one = print_one_catch_fork;
15541   ops->print_mention = print_mention_catch_fork;
15542   ops->print_recreate = print_recreate_catch_fork;
15543
15544   /* Vfork catchpoints.  */
15545   ops = &catch_vfork_breakpoint_ops;
15546   *ops = base_breakpoint_ops;
15547   ops->insert_location = insert_catch_vfork;
15548   ops->remove_location = remove_catch_vfork;
15549   ops->breakpoint_hit = breakpoint_hit_catch_vfork;
15550   ops->print_it = print_it_catch_vfork;
15551   ops->print_one = print_one_catch_vfork;
15552   ops->print_mention = print_mention_catch_vfork;
15553   ops->print_recreate = print_recreate_catch_vfork;
15554
15555   /* Exec catchpoints.  */
15556   ops = &catch_exec_breakpoint_ops;
15557   *ops = base_breakpoint_ops;
15558   ops->insert_location = insert_catch_exec;
15559   ops->remove_location = remove_catch_exec;
15560   ops->breakpoint_hit = breakpoint_hit_catch_exec;
15561   ops->print_it = print_it_catch_exec;
15562   ops->print_one = print_one_catch_exec;
15563   ops->print_mention = print_mention_catch_exec;
15564   ops->print_recreate = print_recreate_catch_exec;
15565
15566   /* Solib-related catchpoints.  */
15567   ops = &catch_solib_breakpoint_ops;
15568   *ops = base_breakpoint_ops;
15569   ops->insert_location = insert_catch_solib;
15570   ops->remove_location = remove_catch_solib;
15571   ops->breakpoint_hit = breakpoint_hit_catch_solib;
15572   ops->check_status = check_status_catch_solib;
15573   ops->print_it = print_it_catch_solib;
15574   ops->print_one = print_one_catch_solib;
15575   ops->print_mention = print_mention_catch_solib;
15576   ops->print_recreate = print_recreate_catch_solib;
15577
15578   ops = &dprintf_breakpoint_ops;
15579   *ops = bkpt_base_breakpoint_ops;
15580   ops->re_set = dprintf_re_set;
15581   ops->resources_needed = bkpt_resources_needed;
15582   ops->print_it = bkpt_print_it;
15583   ops->print_mention = bkpt_print_mention;
15584   ops->print_recreate = dprintf_print_recreate;
15585   ops->after_condition_true = dprintf_after_condition_true;
15586   ops->breakpoint_hit = dprintf_breakpoint_hit;
15587 }
15588
15589 /* Chain containing all defined "enable breakpoint" subcommands.  */
15590
15591 static struct cmd_list_element *enablebreaklist = NULL;
15592
15593 void
15594 _initialize_breakpoint (void)
15595 {
15596   struct cmd_list_element *c;
15597
15598   initialize_breakpoint_ops ();
15599
15600   observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
15601   observer_attach_free_objfile (disable_breakpoints_in_freed_objfile);
15602   observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
15603
15604   breakpoint_objfile_key
15605     = register_objfile_data_with_cleanup (NULL, free_breakpoint_objfile_data);
15606
15607   breakpoint_chain = 0;
15608   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
15609      before a breakpoint is set.  */
15610   breakpoint_count = 0;
15611
15612   tracepoint_count = 0;
15613
15614   add_com ("ignore", class_breakpoint, ignore_command, _("\
15615 Set ignore-count of breakpoint number N to COUNT.\n\
15616 Usage is `ignore N COUNT'."));
15617
15618   add_com ("commands", class_breakpoint, commands_command, _("\
15619 Set commands to be executed when the given breakpoints are hit.\n\
15620 Give a space-separated breakpoint list as argument after \"commands\".\n\
15621 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15622 (e.g. `5-7').\n\
15623 With no argument, the targeted breakpoint is the last one set.\n\
15624 The commands themselves follow starting on the next line.\n\
15625 Type a line containing \"end\" to indicate the end of them.\n\
15626 Give \"silent\" as the first line to make the breakpoint silent;\n\
15627 then no output is printed when it is hit, except what the commands print."));
15628
15629   c = add_com ("condition", class_breakpoint, condition_command, _("\
15630 Specify breakpoint number N to break only if COND is true.\n\
15631 Usage is `condition N COND', where N is an integer and COND is an\n\
15632 expression to be evaluated whenever breakpoint N is reached."));
15633   set_cmd_completer (c, condition_completer);
15634
15635   c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
15636 Set a temporary breakpoint.\n\
15637 Like \"break\" except the breakpoint is only temporary,\n\
15638 so it will be deleted when hit.  Equivalent to \"break\" followed\n\
15639 by using \"enable delete\" on the breakpoint number.\n\
15640 \n"
15641 BREAK_ARGS_HELP ("tbreak")));
15642   set_cmd_completer (c, location_completer);
15643
15644   c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
15645 Set a hardware assisted breakpoint.\n\
15646 Like \"break\" except the breakpoint requires hardware support,\n\
15647 some target hardware may not have this support.\n\
15648 \n"
15649 BREAK_ARGS_HELP ("hbreak")));
15650   set_cmd_completer (c, location_completer);
15651
15652   c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
15653 Set a temporary hardware assisted breakpoint.\n\
15654 Like \"hbreak\" except the breakpoint is only temporary,\n\
15655 so it will be deleted when hit.\n\
15656 \n"
15657 BREAK_ARGS_HELP ("thbreak")));
15658   set_cmd_completer (c, location_completer);
15659
15660   add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
15661 Enable some breakpoints.\n\
15662 Give breakpoint numbers (separated by spaces) as arguments.\n\
15663 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15664 This is used to cancel the effect of the \"disable\" command.\n\
15665 With a subcommand you can enable temporarily."),
15666                   &enablelist, "enable ", 1, &cmdlist);
15667
15668   add_com_alias ("en", "enable", class_breakpoint, 1);
15669
15670   add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
15671 Enable some breakpoints.\n\
15672 Give breakpoint numbers (separated by spaces) as arguments.\n\
15673 This is used to cancel the effect of the \"disable\" command.\n\
15674 May be abbreviated to simply \"enable\".\n"),
15675                    &enablebreaklist, "enable breakpoints ", 1, &enablelist);
15676
15677   add_cmd ("once", no_class, enable_once_command, _("\
15678 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
15679 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15680            &enablebreaklist);
15681
15682   add_cmd ("delete", no_class, enable_delete_command, _("\
15683 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
15684 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15685            &enablebreaklist);
15686
15687   add_cmd ("count", no_class, enable_count_command, _("\
15688 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
15689 If a breakpoint is hit while enabled in this fashion,\n\
15690 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15691            &enablebreaklist);
15692
15693   add_cmd ("delete", no_class, enable_delete_command, _("\
15694 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
15695 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15696            &enablelist);
15697
15698   add_cmd ("once", no_class, enable_once_command, _("\
15699 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
15700 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15701            &enablelist);
15702
15703   add_cmd ("count", no_class, enable_count_command, _("\
15704 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
15705 If a breakpoint is hit while enabled in this fashion,\n\
15706 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15707            &enablelist);
15708
15709   add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
15710 Disable some breakpoints.\n\
15711 Arguments are breakpoint numbers with spaces in between.\n\
15712 To disable all breakpoints, give no argument.\n\
15713 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15714                   &disablelist, "disable ", 1, &cmdlist);
15715   add_com_alias ("dis", "disable", class_breakpoint, 1);
15716   add_com_alias ("disa", "disable", class_breakpoint, 1);
15717
15718   add_cmd ("breakpoints", class_alias, disable_command, _("\
15719 Disable some breakpoints.\n\
15720 Arguments are breakpoint numbers with spaces in between.\n\
15721 To disable all breakpoints, give no argument.\n\
15722 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15723 This command may be abbreviated \"disable\"."),
15724            &disablelist);
15725
15726   add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
15727 Delete some breakpoints or auto-display expressions.\n\
15728 Arguments are breakpoint numbers with spaces in between.\n\
15729 To delete all breakpoints, give no argument.\n\
15730 \n\
15731 Also a prefix command for deletion of other GDB objects.\n\
15732 The \"unset\" command is also an alias for \"delete\"."),
15733                   &deletelist, "delete ", 1, &cmdlist);
15734   add_com_alias ("d", "delete", class_breakpoint, 1);
15735   add_com_alias ("del", "delete", class_breakpoint, 1);
15736
15737   add_cmd ("breakpoints", class_alias, delete_command, _("\
15738 Delete some breakpoints or auto-display expressions.\n\
15739 Arguments are breakpoint numbers with spaces in between.\n\
15740 To delete all breakpoints, give no argument.\n\
15741 This command may be abbreviated \"delete\"."),
15742            &deletelist);
15743
15744   add_com ("clear", class_breakpoint, clear_command, _("\
15745 Clear breakpoint at specified location.\n\
15746 Argument may be a linespec, explicit, or address location as described below.\n\
15747 \n\
15748 With no argument, clears all breakpoints in the line that the selected frame\n\
15749 is executing in.\n"
15750 "\n" LOCATION_HELP_STRING "\n\
15751 See also the \"delete\" command which clears breakpoints by number."));
15752   add_com_alias ("cl", "clear", class_breakpoint, 1);
15753
15754   c = add_com ("break", class_breakpoint, break_command, _("\
15755 Set breakpoint at specified location.\n"
15756 BREAK_ARGS_HELP ("break")));
15757   set_cmd_completer (c, location_completer);
15758
15759   add_com_alias ("b", "break", class_run, 1);
15760   add_com_alias ("br", "break", class_run, 1);
15761   add_com_alias ("bre", "break", class_run, 1);
15762   add_com_alias ("brea", "break", class_run, 1);
15763
15764   if (dbx_commands)
15765     {
15766       add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
15767 Break in function/address or break at a line in the current file."),
15768                              &stoplist, "stop ", 1, &cmdlist);
15769       add_cmd ("in", class_breakpoint, stopin_command,
15770                _("Break in function or address."), &stoplist);
15771       add_cmd ("at", class_breakpoint, stopat_command,
15772                _("Break at a line in the current file."), &stoplist);
15773       add_com ("status", class_info, info_breakpoints_command, _("\
15774 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15775 The \"Type\" column indicates one of:\n\
15776 \tbreakpoint     - normal breakpoint\n\
15777 \twatchpoint     - watchpoint\n\
15778 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15779 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15780 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15781 address and file/line number respectively.\n\
15782 \n\
15783 Convenience variable \"$_\" and default examine address for \"x\"\n\
15784 are set to the address of the last breakpoint listed unless the command\n\
15785 is prefixed with \"server \".\n\n\
15786 Convenience variable \"$bpnum\" contains the number of the last\n\
15787 breakpoint set."));
15788     }
15789
15790   add_info ("breakpoints", info_breakpoints_command, _("\
15791 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15792 The \"Type\" column indicates one of:\n\
15793 \tbreakpoint     - normal breakpoint\n\
15794 \twatchpoint     - watchpoint\n\
15795 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15796 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15797 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15798 address and file/line number respectively.\n\
15799 \n\
15800 Convenience variable \"$_\" and default examine address for \"x\"\n\
15801 are set to the address of the last breakpoint listed unless the command\n\
15802 is prefixed with \"server \".\n\n\
15803 Convenience variable \"$bpnum\" contains the number of the last\n\
15804 breakpoint set."));
15805
15806   add_info_alias ("b", "breakpoints", 1);
15807
15808   add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
15809 Status of all breakpoints, or breakpoint number NUMBER.\n\
15810 The \"Type\" column indicates one of:\n\
15811 \tbreakpoint     - normal breakpoint\n\
15812 \twatchpoint     - watchpoint\n\
15813 \tlongjmp        - internal breakpoint used to step through longjmp()\n\
15814 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15815 \tuntil          - internal breakpoint used by the \"until\" command\n\
15816 \tfinish         - internal breakpoint used by the \"finish\" command\n\
15817 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15818 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
15819 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
15820 address and file/line number respectively.\n\
15821 \n\
15822 Convenience variable \"$_\" and default examine address for \"x\"\n\
15823 are set to the address of the last breakpoint listed unless the command\n\
15824 is prefixed with \"server \".\n\n\
15825 Convenience variable \"$bpnum\" contains the number of the last\n\
15826 breakpoint set."),
15827            &maintenanceinfolist);
15828
15829   add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
15830 Set catchpoints to catch events."),
15831                   &catch_cmdlist, "catch ",
15832                   0/*allow-unknown*/, &cmdlist);
15833
15834   add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
15835 Set temporary catchpoints to catch events."),
15836                   &tcatch_cmdlist, "tcatch ",
15837                   0/*allow-unknown*/, &cmdlist);
15838
15839   add_catch_command ("fork", _("Catch calls to fork."),
15840                      catch_fork_command_1,
15841                      NULL,
15842                      (void *) (uintptr_t) catch_fork_permanent,
15843                      (void *) (uintptr_t) catch_fork_temporary);
15844   add_catch_command ("vfork", _("Catch calls to vfork."),
15845                      catch_fork_command_1,
15846                      NULL,
15847                      (void *) (uintptr_t) catch_vfork_permanent,
15848                      (void *) (uintptr_t) catch_vfork_temporary);
15849   add_catch_command ("exec", _("Catch calls to exec."),
15850                      catch_exec_command_1,
15851                      NULL,
15852                      CATCH_PERMANENT,
15853                      CATCH_TEMPORARY);
15854   add_catch_command ("load", _("Catch loads of shared libraries.\n\
15855 Usage: catch load [REGEX]\n\
15856 If REGEX is given, only stop for libraries matching the regular expression."),
15857                      catch_load_command_1,
15858                      NULL,
15859                      CATCH_PERMANENT,
15860                      CATCH_TEMPORARY);
15861   add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15862 Usage: catch unload [REGEX]\n\
15863 If REGEX is given, only stop for libraries matching the regular expression."),
15864                      catch_unload_command_1,
15865                      NULL,
15866                      CATCH_PERMANENT,
15867                      CATCH_TEMPORARY);
15868
15869   c = add_com ("watch", class_breakpoint, watch_command, _("\
15870 Set a watchpoint for an expression.\n\
15871 Usage: watch [-l|-location] EXPRESSION\n\
15872 A watchpoint stops execution of your program whenever the value of\n\
15873 an expression changes.\n\
15874 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15875 the memory to which it refers."));
15876   set_cmd_completer (c, expression_completer);
15877
15878   c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
15879 Set a read watchpoint for an expression.\n\
15880 Usage: rwatch [-l|-location] EXPRESSION\n\
15881 A watchpoint stops execution of your program whenever the value of\n\
15882 an expression is read.\n\
15883 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15884 the memory to which it refers."));
15885   set_cmd_completer (c, expression_completer);
15886
15887   c = add_com ("awatch", class_breakpoint, awatch_command, _("\
15888 Set a watchpoint for an expression.\n\
15889 Usage: awatch [-l|-location] EXPRESSION\n\
15890 A watchpoint stops execution of your program whenever the value of\n\
15891 an expression is either read or written.\n\
15892 If -l or -location is given, this evaluates EXPRESSION and watches\n\
15893 the memory to which it refers."));
15894   set_cmd_completer (c, expression_completer);
15895
15896   add_info ("watchpoints", info_watchpoints_command, _("\
15897 Status of specified watchpoints (all watchpoints if no argument)."));
15898
15899   /* XXX: cagney/2005-02-23: This should be a boolean, and should
15900      respond to changes - contrary to the description.  */
15901   add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
15902                             &can_use_hw_watchpoints, _("\
15903 Set debugger's willingness to use watchpoint hardware."), _("\
15904 Show debugger's willingness to use watchpoint hardware."), _("\
15905 If zero, gdb will not use hardware for new watchpoints, even if\n\
15906 such is available.  (However, any hardware watchpoints that were\n\
15907 created before setting this to nonzero, will continue to use watchpoint\n\
15908 hardware.)"),
15909                             NULL,
15910                             show_can_use_hw_watchpoints,
15911                             &setlist, &showlist);
15912
15913   can_use_hw_watchpoints = 1;
15914
15915   /* Tracepoint manipulation commands.  */
15916
15917   c = add_com ("trace", class_breakpoint, trace_command, _("\
15918 Set a tracepoint at specified location.\n\
15919 \n"
15920 BREAK_ARGS_HELP ("trace") "\n\
15921 Do \"help tracepoints\" for info on other tracepoint commands."));
15922   set_cmd_completer (c, location_completer);
15923
15924   add_com_alias ("tp", "trace", class_alias, 0);
15925   add_com_alias ("tr", "trace", class_alias, 1);
15926   add_com_alias ("tra", "trace", class_alias, 1);
15927   add_com_alias ("trac", "trace", class_alias, 1);
15928
15929   c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
15930 Set a fast tracepoint at specified location.\n\
15931 \n"
15932 BREAK_ARGS_HELP ("ftrace") "\n\
15933 Do \"help tracepoints\" for info on other tracepoint commands."));
15934   set_cmd_completer (c, location_completer);
15935
15936   c = add_com ("strace", class_breakpoint, strace_command, _("\
15937 Set a static tracepoint at location or marker.\n\
15938 \n\
15939 strace [LOCATION] [if CONDITION]\n\
15940 LOCATION may be a linespec, explicit, or address location (described below) \n\
15941 or -m MARKER_ID.\n\n\
15942 If a marker id is specified, probe the marker with that name.  With\n\
15943 no LOCATION, uses current execution address of the selected stack frame.\n\
15944 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15945 This collects arbitrary user data passed in the probe point call to the\n\
15946 tracing library.  You can inspect it when analyzing the trace buffer,\n\
15947 by printing the $_sdata variable like any other convenience variable.\n\
15948 \n\
15949 CONDITION is a boolean expression.\n\
15950 \n" LOCATION_HELP_STRING "\n\
15951 Multiple tracepoints at one place are permitted, and useful if their\n\
15952 conditions are different.\n\
15953 \n\
15954 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15955 Do \"help tracepoints\" for info on other tracepoint commands."));
15956   set_cmd_completer (c, location_completer);
15957
15958   add_info ("tracepoints", info_tracepoints_command, _("\
15959 Status of specified tracepoints (all tracepoints if no argument).\n\
15960 Convenience variable \"$tpnum\" contains the number of the\n\
15961 last tracepoint set."));
15962
15963   add_info_alias ("tp", "tracepoints", 1);
15964
15965   add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
15966 Delete specified tracepoints.\n\
15967 Arguments are tracepoint numbers, separated by spaces.\n\
15968 No argument means delete all tracepoints."),
15969            &deletelist);
15970   add_alias_cmd ("tr", "tracepoints", class_trace, 1, &deletelist);
15971
15972   c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
15973 Disable specified tracepoints.\n\
15974 Arguments are tracepoint numbers, separated by spaces.\n\
15975 No argument means disable all tracepoints."),
15976            &disablelist);
15977   deprecate_cmd (c, "disable");
15978
15979   c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
15980 Enable specified tracepoints.\n\
15981 Arguments are tracepoint numbers, separated by spaces.\n\
15982 No argument means enable all tracepoints."),
15983            &enablelist);
15984   deprecate_cmd (c, "enable");
15985
15986   add_com ("passcount", class_trace, trace_pass_command, _("\
15987 Set the passcount for a tracepoint.\n\
15988 The trace will end when the tracepoint has been passed 'count' times.\n\
15989 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15990 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15991
15992   add_prefix_cmd ("save", class_breakpoint, save_command,
15993                   _("Save breakpoint definitions as a script."),
15994                   &save_cmdlist, "save ",
15995                   0/*allow-unknown*/, &cmdlist);
15996
15997   c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
15998 Save current breakpoint definitions as a script.\n\
15999 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16000 catchpoints, tracepoints).  Use the 'source' command in another debug\n\
16001 session to restore them."),
16002                &save_cmdlist);
16003   set_cmd_completer (c, filename_completer);
16004
16005   c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
16006 Save current tracepoint definitions as a script.\n\
16007 Use the 'source' command in another debug session to restore them."),
16008                &save_cmdlist);
16009   set_cmd_completer (c, filename_completer);
16010
16011   c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
16012   deprecate_cmd (c, "save tracepoints");
16013
16014   add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
16015 Breakpoint specific settings\n\
16016 Configure various breakpoint-specific variables such as\n\
16017 pending breakpoint behavior"),
16018                   &breakpoint_set_cmdlist, "set breakpoint ",
16019                   0/*allow-unknown*/, &setlist);
16020   add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
16021 Breakpoint specific settings\n\
16022 Configure various breakpoint-specific variables such as\n\
16023 pending breakpoint behavior"),
16024                   &breakpoint_show_cmdlist, "show breakpoint ",
16025                   0/*allow-unknown*/, &showlist);
16026
16027   add_setshow_auto_boolean_cmd ("pending", no_class,
16028                                 &pending_break_support, _("\
16029 Set debugger's behavior regarding pending breakpoints."), _("\
16030 Show debugger's behavior regarding pending breakpoints."), _("\
16031 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16032 pending breakpoint.  If off, an unrecognized breakpoint location results in\n\
16033 an error.  If auto, an unrecognized breakpoint location results in a\n\
16034 user-query to see if a pending breakpoint should be created."),
16035                                 NULL,
16036                                 show_pending_break_support,
16037                                 &breakpoint_set_cmdlist,
16038                                 &breakpoint_show_cmdlist);
16039
16040   pending_break_support = AUTO_BOOLEAN_AUTO;
16041
16042   add_setshow_boolean_cmd ("auto-hw", no_class,
16043                            &automatic_hardware_breakpoints, _("\
16044 Set automatic usage of hardware breakpoints."), _("\
16045 Show automatic usage of hardware breakpoints."), _("\
16046 If set, the debugger will automatically use hardware breakpoints for\n\
16047 breakpoints set with \"break\" but falling in read-only memory.  If not set,\n\
16048 a warning will be emitted for such breakpoints."),
16049                            NULL,
16050                            show_automatic_hardware_breakpoints,
16051                            &breakpoint_set_cmdlist,
16052                            &breakpoint_show_cmdlist);
16053
16054   add_setshow_boolean_cmd ("always-inserted", class_support,
16055                            &always_inserted_mode, _("\
16056 Set mode for inserting breakpoints."), _("\
16057 Show mode for inserting breakpoints."), _("\
16058 When this mode is on, breakpoints are inserted immediately as soon as\n\
16059 they're created, kept inserted even when execution stops, and removed\n\
16060 only when the user deletes them.  When this mode is off (the default),\n\
16061 breakpoints are inserted only when execution continues, and removed\n\
16062 when execution stops."),
16063                                 NULL,
16064                                 &show_always_inserted_mode,
16065                                 &breakpoint_set_cmdlist,
16066                                 &breakpoint_show_cmdlist);
16067
16068   add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
16069                         condition_evaluation_enums,
16070                         &condition_evaluation_mode_1, _("\
16071 Set mode of breakpoint condition evaluation."), _("\
16072 Show mode of breakpoint condition evaluation."), _("\
16073 When this is set to \"host\", breakpoint conditions will be\n\
16074 evaluated on the host's side by GDB.  When it is set to \"target\",\n\
16075 breakpoint conditions will be downloaded to the target (if the target\n\
16076 supports such feature) and conditions will be evaluated on the target's side.\n\
16077 If this is set to \"auto\" (default), this will be automatically set to\n\
16078 \"target\" if it supports condition evaluation, otherwise it will\n\
16079 be set to \"gdb\""),
16080                            &set_condition_evaluation_mode,
16081                            &show_condition_evaluation_mode,
16082                            &breakpoint_set_cmdlist,
16083                            &breakpoint_show_cmdlist);
16084
16085   add_com ("break-range", class_breakpoint, break_range_command, _("\
16086 Set a breakpoint for an address range.\n\
16087 break-range START-LOCATION, END-LOCATION\n\
16088 where START-LOCATION and END-LOCATION can be one of the following:\n\
16089   LINENUM, for that line in the current file,\n\
16090   FILE:LINENUM, for that line in that file,\n\
16091   +OFFSET, for that number of lines after the current line\n\
16092            or the start of the range\n\
16093   FUNCTION, for the first line in that function,\n\
16094   FILE:FUNCTION, to distinguish among like-named static functions.\n\
16095   *ADDRESS, for the instruction at that address.\n\
16096 \n\
16097 The breakpoint will stop execution of the inferior whenever it executes\n\
16098 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16099 range (including START-LOCATION and END-LOCATION)."));
16100
16101   c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
16102 Set a dynamic printf at specified location.\n\
16103 dprintf location,format string,arg1,arg2,...\n\
16104 location may be a linespec, explicit, or address location.\n"
16105 "\n" LOCATION_HELP_STRING));
16106   set_cmd_completer (c, location_completer);
16107
16108   add_setshow_enum_cmd ("dprintf-style", class_support,
16109                         dprintf_style_enums, &dprintf_style, _("\
16110 Set the style of usage for dynamic printf."), _("\
16111 Show the style of usage for dynamic printf."), _("\
16112 This setting chooses how GDB will do a dynamic printf.\n\
16113 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16114 console, as with the \"printf\" command.\n\
16115 If the value is \"call\", the print is done by calling a function in your\n\
16116 program; by default printf(), but you can choose a different function or\n\
16117 output stream by setting dprintf-function and dprintf-channel."),
16118                         update_dprintf_commands, NULL,
16119                         &setlist, &showlist);
16120
16121   dprintf_function = xstrdup ("printf");
16122   add_setshow_string_cmd ("dprintf-function", class_support,
16123                           &dprintf_function, _("\
16124 Set the function to use for dynamic printf"), _("\
16125 Show the function to use for dynamic printf"), NULL,
16126                           update_dprintf_commands, NULL,
16127                           &setlist, &showlist);
16128
16129   dprintf_channel = xstrdup ("");
16130   add_setshow_string_cmd ("dprintf-channel", class_support,
16131                           &dprintf_channel, _("\
16132 Set the channel to use for dynamic printf"), _("\
16133 Show the channel to use for dynamic printf"), NULL,
16134                           update_dprintf_commands, NULL,
16135                           &setlist, &showlist);
16136
16137   add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
16138                            &disconnected_dprintf, _("\
16139 Set whether dprintf continues after GDB disconnects."), _("\
16140 Show whether dprintf continues after GDB disconnects."), _("\
16141 Use this to let dprintf commands continue to hit and produce output\n\
16142 even if GDB disconnects or detaches from the target."),
16143                            NULL,
16144                            NULL,
16145                            &setlist, &showlist);
16146
16147   add_com ("agent-printf", class_vars, agent_printf_command, _("\
16148 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16149 (target agent only) This is useful for formatted output in user-defined commands."));
16150
16151   automatic_hardware_breakpoints = 1;
16152
16153   observer_attach_about_to_proceed (breakpoint_about_to_proceed);
16154   observer_attach_thread_exit (remove_threaded_breakpoints);
16155 }