* breakpoint.c (catch_syscall_split_args): Use skip_spaces.
[platform/upstream/binutils.git] / gdb / breakpoint.c
1 /* Everything about breakpoints, for GDB.
2
3    Copyright (C) 1986-2013 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 "gdbthread.h"
36 #include "target.h"
37 #include "language.h"
38 #include "gdb_string.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 "gdb.h"
48 #include "ui-out.h"
49 #include "cli/cli-script.h"
50 #include "gdb_assert.h"
51 #include "block.h"
52 #include "solib.h"
53 #include "solist.h"
54 #include "observer.h"
55 #include "exceptions.h"
56 #include "memattr.h"
57 #include "ada-lang.h"
58 #include "top.h"
59 #include "valprint.h"
60 #include "jit.h"
61 #include "xml-syscall.h"
62 #include "parser-defs.h"
63 #include "gdb_regex.h"
64 #include "probe.h"
65 #include "cli/cli-utils.h"
66 #include "continuations.h"
67 #include "stack.h"
68 #include "skip.h"
69 #include "gdb_regex.h"
70 #include "ax-gdb.h"
71 #include "dummy-frame.h"
72
73 #include "format.h"
74
75 /* readline include files */
76 #include "readline/readline.h"
77 #include "readline/history.h"
78
79 /* readline defines this.  */
80 #undef savestring
81
82 #include "mi/mi-common.h"
83 #include "python/python.h"
84
85 /* Enums for exception-handling support.  */
86 enum exception_event_kind
87 {
88   EX_EVENT_THROW,
89   EX_EVENT_CATCH
90 };
91
92 /* Prototypes for local functions.  */
93
94 static void enable_delete_command (char *, int);
95
96 static void enable_once_command (char *, int);
97
98 static void enable_count_command (char *, int);
99
100 static void disable_command (char *, int);
101
102 static void enable_command (char *, int);
103
104 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint *,
105                                                       void *),
106                                     void *);
107
108 static void ignore_command (char *, int);
109
110 static int breakpoint_re_set_one (void *);
111
112 static void breakpoint_re_set_default (struct breakpoint *);
113
114 static void create_sals_from_address_default (char **,
115                                               struct linespec_result *,
116                                               enum bptype, char *,
117                                               char **);
118
119 static void create_breakpoints_sal_default (struct gdbarch *,
120                                             struct linespec_result *,
121                                             struct linespec_sals *,
122                                             char *, char *, enum bptype,
123                                             enum bpdisp, int, int,
124                                             int,
125                                             const struct breakpoint_ops *,
126                                             int, int, int, unsigned);
127
128 static void decode_linespec_default (struct breakpoint *, char **,
129                                      struct symtabs_and_lines *);
130
131 static void clear_command (char *, int);
132
133 static void catch_command (char *, int);
134
135 static int can_use_hardware_watchpoint (struct value *);
136
137 static void break_command_1 (char *, int, int);
138
139 static void mention (struct breakpoint *);
140
141 static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
142                                                                enum bptype,
143                                                                const struct breakpoint_ops *);
144 static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
145                                                        const struct symtab_and_line *);
146
147 /* This function is used in gdbtk sources and thus can not be made
148    static.  */
149 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
150                                        struct symtab_and_line,
151                                        enum bptype,
152                                        const struct breakpoint_ops *);
153
154 static struct breakpoint *
155   momentary_breakpoint_from_master (struct breakpoint *orig,
156                                     enum bptype type,
157                                     const struct breakpoint_ops *ops);
158
159 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
160
161 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
162                                             CORE_ADDR bpaddr,
163                                             enum bptype bptype);
164
165 static void describe_other_breakpoints (struct gdbarch *,
166                                         struct program_space *, CORE_ADDR,
167                                         struct obj_section *, int);
168
169 static int breakpoint_address_match (struct address_space *aspace1,
170                                      CORE_ADDR addr1,
171                                      struct address_space *aspace2,
172                                      CORE_ADDR addr2);
173
174 static int watchpoint_locations_match (struct bp_location *loc1,
175                                        struct bp_location *loc2);
176
177 static int breakpoint_location_address_match (struct bp_location *bl,
178                                               struct address_space *aspace,
179                                               CORE_ADDR addr);
180
181 static void breakpoints_info (char *, int);
182
183 static void watchpoints_info (char *, int);
184
185 static int breakpoint_1 (char *, int, 
186                          int (*) (const struct breakpoint *));
187
188 static int breakpoint_cond_eval (void *);
189
190 static void cleanup_executing_breakpoints (void *);
191
192 static void commands_command (char *, int);
193
194 static void condition_command (char *, int);
195
196 typedef enum
197   {
198     mark_inserted,
199     mark_uninserted
200   }
201 insertion_state_t;
202
203 static int remove_breakpoint (struct bp_location *, insertion_state_t);
204 static int remove_breakpoint_1 (struct bp_location *, insertion_state_t);
205
206 static enum print_stop_action print_bp_stop_message (bpstat bs);
207
208 static int watchpoint_check (void *);
209
210 static void maintenance_info_breakpoints (char *, int);
211
212 static int hw_breakpoint_used_count (void);
213
214 static int hw_watchpoint_use_count (struct breakpoint *);
215
216 static int hw_watchpoint_used_count_others (struct breakpoint *except,
217                                             enum bptype type,
218                                             int *other_type_used);
219
220 static void hbreak_command (char *, int);
221
222 static void thbreak_command (char *, int);
223
224 static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
225                                     int count);
226
227 static void stop_command (char *arg, int from_tty);
228
229 static void stopin_command (char *arg, int from_tty);
230
231 static void stopat_command (char *arg, int from_tty);
232
233 static char *ep_parse_optional_if_clause (char **arg);
234
235 static void catch_exception_command_1 (enum exception_event_kind ex_event, 
236                                        char *arg, int tempflag, int from_tty);
237
238 static void tcatch_command (char *arg, int from_tty);
239
240 static void detach_single_step_breakpoints (void);
241
242 static int single_step_breakpoint_inserted_here_p (struct address_space *,
243                                                    CORE_ADDR pc);
244
245 static void free_bp_location (struct bp_location *loc);
246 static void incref_bp_location (struct bp_location *loc);
247 static void decref_bp_location (struct bp_location **loc);
248
249 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
250
251 static void update_global_location_list (int);
252
253 static void update_global_location_list_nothrow (int);
254
255 static int is_hardware_watchpoint (const struct breakpoint *bpt);
256
257 static void insert_breakpoint_locations (void);
258
259 static int syscall_catchpoint_p (struct breakpoint *b);
260
261 static void tracepoints_info (char *, int);
262
263 static void delete_trace_command (char *, int);
264
265 static void enable_trace_command (char *, int);
266
267 static void disable_trace_command (char *, int);
268
269 static void trace_pass_command (char *, int);
270
271 static void set_tracepoint_count (int num);
272
273 static int is_masked_watchpoint (const struct breakpoint *b);
274
275 static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
276
277 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
278    otherwise.  */
279
280 static int strace_marker_p (struct breakpoint *b);
281
282 /* The abstract base class all breakpoint_ops structures inherit
283    from.  */
284 struct breakpoint_ops base_breakpoint_ops;
285
286 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
287    that are implemented on top of software or hardware breakpoints
288    (user breakpoints, internal and momentary breakpoints, etc.).  */
289 static struct breakpoint_ops bkpt_base_breakpoint_ops;
290
291 /* Internal breakpoints class type.  */
292 static struct breakpoint_ops internal_breakpoint_ops;
293
294 /* Momentary breakpoints class type.  */
295 static struct breakpoint_ops momentary_breakpoint_ops;
296
297 /* Momentary breakpoints for bp_longjmp and bp_exception class type.  */
298 static struct breakpoint_ops longjmp_breakpoint_ops;
299
300 /* The breakpoint_ops structure to be used in regular user created
301    breakpoints.  */
302 struct breakpoint_ops bkpt_breakpoint_ops;
303
304 /* Breakpoints set on probes.  */
305 static struct breakpoint_ops bkpt_probe_breakpoint_ops;
306
307 /* Dynamic printf class type.  */
308 static struct breakpoint_ops dprintf_breakpoint_ops;
309
310 /* The style in which to perform a dynamic printf.  This is a user
311    option because different output options have different tradeoffs;
312    if GDB does the printing, there is better error handling if there
313    is a problem with any of the arguments, but using an inferior
314    function lets you have special-purpose printers and sending of
315    output to the same place as compiled-in print functions.  */
316
317 static const char dprintf_style_gdb[] = "gdb";
318 static const char dprintf_style_call[] = "call";
319 static const char dprintf_style_agent[] = "agent";
320 static const char *const dprintf_style_enums[] = {
321   dprintf_style_gdb,
322   dprintf_style_call,
323   dprintf_style_agent,
324   NULL
325 };
326 static const char *dprintf_style = dprintf_style_gdb;
327
328 /* The function to use for dynamic printf if the preferred style is to
329    call into the inferior.  The value is simply a string that is
330    copied into the command, so it can be anything that GDB can
331    evaluate to a callable address, not necessarily a function name.  */
332
333 static char *dprintf_function = "";
334
335 /* The channel to use for dynamic printf if the preferred style is to
336    call into the inferior; if a nonempty string, it will be passed to
337    the call as the first argument, with the format string as the
338    second.  As with the dprintf function, this can be anything that
339    GDB knows how to evaluate, so in addition to common choices like
340    "stderr", this could be an app-specific expression like
341    "mystreams[curlogger]".  */
342
343 static char *dprintf_channel = "";
344
345 /* True if dprintf commands should continue to operate even if GDB
346    has disconnected.  */
347 static int disconnected_dprintf = 1;
348
349 /* A reference-counted struct command_line.  This lets multiple
350    breakpoints share a single command list.  */
351 struct counted_command_line
352 {
353   /* The reference count.  */
354   int refc;
355
356   /* The command list.  */
357   struct command_line *commands;
358 };
359
360 struct command_line *
361 breakpoint_commands (struct breakpoint *b)
362 {
363   return b->commands ? b->commands->commands : NULL;
364 }
365
366 /* Flag indicating that a command has proceeded the inferior past the
367    current breakpoint.  */
368
369 static int breakpoint_proceeded;
370
371 const char *
372 bpdisp_text (enum bpdisp disp)
373 {
374   /* NOTE: the following values are a part of MI protocol and
375      represent values of 'disp' field returned when inferior stops at
376      a breakpoint.  */
377   static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
378
379   return bpdisps[(int) disp];
380 }
381
382 /* Prototypes for exported functions.  */
383 /* If FALSE, gdb will not use hardware support for watchpoints, even
384    if such is available.  */
385 static int can_use_hw_watchpoints;
386
387 static void
388 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
389                              struct cmd_list_element *c,
390                              const char *value)
391 {
392   fprintf_filtered (file,
393                     _("Debugger's willingness to use "
394                       "watchpoint hardware is %s.\n"),
395                     value);
396 }
397
398 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
399    If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
400    for unrecognized breakpoint locations.
401    If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized.  */
402 static enum auto_boolean pending_break_support;
403 static void
404 show_pending_break_support (struct ui_file *file, int from_tty,
405                             struct cmd_list_element *c,
406                             const char *value)
407 {
408   fprintf_filtered (file,
409                     _("Debugger's behavior regarding "
410                       "pending breakpoints is %s.\n"),
411                     value);
412 }
413
414 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
415    set with "break" but falling in read-only memory.
416    If 0, gdb will warn about such breakpoints, but won't automatically
417    use hardware breakpoints.  */
418 static int automatic_hardware_breakpoints;
419 static void
420 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
421                                      struct cmd_list_element *c,
422                                      const char *value)
423 {
424   fprintf_filtered (file,
425                     _("Automatic usage of hardware breakpoints is %s.\n"),
426                     value);
427 }
428
429 /* If on, gdb will keep breakpoints inserted even as inferior is
430    stopped, and immediately insert any new breakpoints.  If off, gdb
431    will insert breakpoints into inferior only when resuming it, and
432    will remove breakpoints upon stop.  If auto, GDB will behave as ON
433    if in non-stop mode, and as OFF if all-stop mode.*/
434
435 static enum auto_boolean always_inserted_mode = AUTO_BOOLEAN_AUTO;
436
437 static void
438 show_always_inserted_mode (struct ui_file *file, int from_tty,
439                      struct cmd_list_element *c, const char *value)
440 {
441   if (always_inserted_mode == AUTO_BOOLEAN_AUTO)
442     fprintf_filtered (file,
443                       _("Always inserted breakpoint "
444                         "mode is %s (currently %s).\n"),
445                       value,
446                       breakpoints_always_inserted_mode () ? "on" : "off");
447   else
448     fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
449                       value);
450 }
451
452 int
453 breakpoints_always_inserted_mode (void)
454 {
455   return (always_inserted_mode == AUTO_BOOLEAN_TRUE
456           || (always_inserted_mode == AUTO_BOOLEAN_AUTO && non_stop));
457 }
458
459 static const char condition_evaluation_both[] = "host or target";
460
461 /* Modes for breakpoint condition evaluation.  */
462 static const char condition_evaluation_auto[] = "auto";
463 static const char condition_evaluation_host[] = "host";
464 static const char condition_evaluation_target[] = "target";
465 static const char *const condition_evaluation_enums[] = {
466   condition_evaluation_auto,
467   condition_evaluation_host,
468   condition_evaluation_target,
469   NULL
470 };
471
472 /* Global that holds the current mode for breakpoint condition evaluation.  */
473 static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
474
475 /* Global that we use to display information to the user (gets its value from
476    condition_evaluation_mode_1.  */
477 static const char *condition_evaluation_mode = condition_evaluation_auto;
478
479 /* Translate a condition evaluation mode MODE into either "host"
480    or "target".  This is used mostly to translate from "auto" to the
481    real setting that is being used.  It returns the translated
482    evaluation mode.  */
483
484 static const char *
485 translate_condition_evaluation_mode (const char *mode)
486 {
487   if (mode == condition_evaluation_auto)
488     {
489       if (target_supports_evaluation_of_breakpoint_conditions ())
490         return condition_evaluation_target;
491       else
492         return condition_evaluation_host;
493     }
494   else
495     return mode;
496 }
497
498 /* Discovers what condition_evaluation_auto translates to.  */
499
500 static const char *
501 breakpoint_condition_evaluation_mode (void)
502 {
503   return translate_condition_evaluation_mode (condition_evaluation_mode);
504 }
505
506 /* Return true if GDB should evaluate breakpoint conditions or false
507    otherwise.  */
508
509 static int
510 gdb_evaluates_breakpoint_condition_p (void)
511 {
512   const char *mode = breakpoint_condition_evaluation_mode ();
513
514   return (mode == condition_evaluation_host);
515 }
516
517 void _initialize_breakpoint (void);
518
519 /* Are we executing breakpoint commands?  */
520 static int executing_breakpoint_commands;
521
522 /* Are overlay event breakpoints enabled? */
523 static int overlay_events_enabled;
524
525 /* See description in breakpoint.h. */
526 int target_exact_watchpoints = 0;
527
528 /* Walk the following statement or block through all breakpoints.
529    ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
530    current breakpoint.  */
531
532 #define ALL_BREAKPOINTS(B)  for (B = breakpoint_chain; B; B = B->next)
533
534 #define ALL_BREAKPOINTS_SAFE(B,TMP)     \
535         for (B = breakpoint_chain;      \
536              B ? (TMP=B->next, 1): 0;   \
537              B = TMP)
538
539 /* Similar iterator for the low-level breakpoints.  SAFE variant is
540    not provided so update_global_location_list must not be called
541    while executing the block of ALL_BP_LOCATIONS.  */
542
543 #define ALL_BP_LOCATIONS(B,BP_TMP)                                      \
544         for (BP_TMP = bp_location;                                      \
545              BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
546              BP_TMP++)
547
548 /* Iterates through locations with address ADDRESS for the currently selected
549    program space.  BP_LOCP_TMP points to each object.  BP_LOCP_START points
550    to where the loop should start from.
551    If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
552    appropriate location to start with.  */
553
554 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS)   \
555         for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
556              BP_LOCP_TMP = BP_LOCP_START;                               \
557              BP_LOCP_START                                              \
558              && (BP_LOCP_TMP < bp_location + bp_location_count          \
559              && (*BP_LOCP_TMP)->address == ADDRESS);                    \
560              BP_LOCP_TMP++)
561
562 /* Iterator for tracepoints only.  */
563
564 #define ALL_TRACEPOINTS(B)  \
565   for (B = breakpoint_chain; B; B = B->next)  \
566     if (is_tracepoint (B))
567
568 /* Chains of all breakpoints defined.  */
569
570 struct breakpoint *breakpoint_chain;
571
572 /* Array is sorted by bp_location_compare - primarily by the ADDRESS.  */
573
574 static struct bp_location **bp_location;
575
576 /* Number of elements of BP_LOCATION.  */
577
578 static unsigned bp_location_count;
579
580 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
581    ADDRESS for the current elements of BP_LOCATION which get a valid
582    result from bp_location_has_shadow.  You can use it for roughly
583    limiting the subrange of BP_LOCATION to scan for shadow bytes for
584    an address you need to read.  */
585
586 static CORE_ADDR bp_location_placed_address_before_address_max;
587
588 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
589    + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
590    BP_LOCATION which get a valid result from bp_location_has_shadow.
591    You can use it for roughly limiting the subrange of BP_LOCATION to
592    scan for shadow bytes for an address you need to read.  */
593
594 static CORE_ADDR bp_location_shadow_len_after_address_max;
595
596 /* The locations that no longer correspond to any breakpoint, unlinked
597    from bp_location array, but for which a hit may still be reported
598    by a target.  */
599 VEC(bp_location_p) *moribund_locations = NULL;
600
601 /* Number of last breakpoint made.  */
602
603 static int breakpoint_count;
604
605 /* The value of `breakpoint_count' before the last command that
606    created breakpoints.  If the last (break-like) command created more
607    than one breakpoint, then the difference between BREAKPOINT_COUNT
608    and PREV_BREAKPOINT_COUNT is more than one.  */
609 static int prev_breakpoint_count;
610
611 /* Number of last tracepoint made.  */
612
613 static int tracepoint_count;
614
615 static struct cmd_list_element *breakpoint_set_cmdlist;
616 static struct cmd_list_element *breakpoint_show_cmdlist;
617 struct cmd_list_element *save_cmdlist;
618
619 /* Return whether a breakpoint is an active enabled breakpoint.  */
620 static int
621 breakpoint_enabled (struct breakpoint *b)
622 {
623   return (b->enable_state == bp_enabled);
624 }
625
626 /* Set breakpoint count to NUM.  */
627
628 static void
629 set_breakpoint_count (int num)
630 {
631   prev_breakpoint_count = breakpoint_count;
632   breakpoint_count = num;
633   set_internalvar_integer (lookup_internalvar ("bpnum"), num);
634 }
635
636 /* Used by `start_rbreak_breakpoints' below, to record the current
637    breakpoint count before "rbreak" creates any breakpoint.  */
638 static int rbreak_start_breakpoint_count;
639
640 /* Called at the start an "rbreak" command to record the first
641    breakpoint made.  */
642
643 void
644 start_rbreak_breakpoints (void)
645 {
646   rbreak_start_breakpoint_count = breakpoint_count;
647 }
648
649 /* Called at the end of an "rbreak" command to record the last
650    breakpoint made.  */
651
652 void
653 end_rbreak_breakpoints (void)
654 {
655   prev_breakpoint_count = rbreak_start_breakpoint_count;
656 }
657
658 /* Used in run_command to zero the hit count when a new run starts.  */
659
660 void
661 clear_breakpoint_hit_counts (void)
662 {
663   struct breakpoint *b;
664
665   ALL_BREAKPOINTS (b)
666     b->hit_count = 0;
667 }
668
669 /* Allocate a new counted_command_line with reference count of 1.
670    The new structure owns COMMANDS.  */
671
672 static struct counted_command_line *
673 alloc_counted_command_line (struct command_line *commands)
674 {
675   struct counted_command_line *result
676     = xmalloc (sizeof (struct counted_command_line));
677
678   result->refc = 1;
679   result->commands = commands;
680   return result;
681 }
682
683 /* Increment reference count.  This does nothing if CMD is NULL.  */
684
685 static void
686 incref_counted_command_line (struct counted_command_line *cmd)
687 {
688   if (cmd)
689     ++cmd->refc;
690 }
691
692 /* Decrement reference count.  If the reference count reaches 0,
693    destroy the counted_command_line.  Sets *CMDP to NULL.  This does
694    nothing if *CMDP is NULL.  */
695
696 static void
697 decref_counted_command_line (struct counted_command_line **cmdp)
698 {
699   if (*cmdp)
700     {
701       if (--(*cmdp)->refc == 0)
702         {
703           free_command_lines (&(*cmdp)->commands);
704           xfree (*cmdp);
705         }
706       *cmdp = NULL;
707     }
708 }
709
710 /* A cleanup function that calls decref_counted_command_line.  */
711
712 static void
713 do_cleanup_counted_command_line (void *arg)
714 {
715   decref_counted_command_line (arg);
716 }
717
718 /* Create a cleanup that calls decref_counted_command_line on the
719    argument.  */
720
721 static struct cleanup *
722 make_cleanup_decref_counted_command_line (struct counted_command_line **cmdp)
723 {
724   return make_cleanup (do_cleanup_counted_command_line, cmdp);
725 }
726
727 \f
728 /* Return the breakpoint with the specified number, or NULL
729    if the number does not refer to an existing breakpoint.  */
730
731 struct breakpoint *
732 get_breakpoint (int num)
733 {
734   struct breakpoint *b;
735
736   ALL_BREAKPOINTS (b)
737     if (b->number == num)
738       return b;
739   
740   return NULL;
741 }
742
743 \f
744
745 /* Mark locations as "conditions have changed" in case the target supports
746    evaluating conditions on its side.  */
747
748 static void
749 mark_breakpoint_modified (struct breakpoint *b)
750 {
751   struct bp_location *loc;
752
753   /* This is only meaningful if the target is
754      evaluating conditions and if the user has
755      opted for condition evaluation on the target's
756      side.  */
757   if (gdb_evaluates_breakpoint_condition_p ()
758       || !target_supports_evaluation_of_breakpoint_conditions ())
759     return;
760
761   if (!is_breakpoint (b))
762     return;
763
764   for (loc = b->loc; loc; loc = loc->next)
765     loc->condition_changed = condition_modified;
766 }
767
768 /* Mark location as "conditions have changed" in case the target supports
769    evaluating conditions on its side.  */
770
771 static void
772 mark_breakpoint_location_modified (struct bp_location *loc)
773 {
774   /* This is only meaningful if the target is
775      evaluating conditions and if the user has
776      opted for condition evaluation on the target's
777      side.  */
778   if (gdb_evaluates_breakpoint_condition_p ()
779       || !target_supports_evaluation_of_breakpoint_conditions ())
780
781     return;
782
783   if (!is_breakpoint (loc->owner))
784     return;
785
786   loc->condition_changed = condition_modified;
787 }
788
789 /* Sets the condition-evaluation mode using the static global
790    condition_evaluation_mode.  */
791
792 static void
793 set_condition_evaluation_mode (char *args, int from_tty,
794                                struct cmd_list_element *c)
795 {
796   const char *old_mode, *new_mode;
797
798   if ((condition_evaluation_mode_1 == condition_evaluation_target)
799       && !target_supports_evaluation_of_breakpoint_conditions ())
800     {
801       condition_evaluation_mode_1 = condition_evaluation_mode;
802       warning (_("Target does not support breakpoint condition evaluation.\n"
803                  "Using host evaluation mode instead."));
804       return;
805     }
806
807   new_mode = translate_condition_evaluation_mode (condition_evaluation_mode_1);
808   old_mode = translate_condition_evaluation_mode (condition_evaluation_mode);
809
810   /* Flip the switch.  Flip it even if OLD_MODE == NEW_MODE as one of the
811      settings was "auto".  */
812   condition_evaluation_mode = condition_evaluation_mode_1;
813
814   /* Only update the mode if the user picked a different one.  */
815   if (new_mode != old_mode)
816     {
817       struct bp_location *loc, **loc_tmp;
818       /* If the user switched to a different evaluation mode, we
819          need to synch the changes with the target as follows:
820
821          "host" -> "target": Send all (valid) conditions to the target.
822          "target" -> "host": Remove all the conditions from the target.
823       */
824
825       if (new_mode == condition_evaluation_target)
826         {
827           /* Mark everything modified and synch conditions with the
828              target.  */
829           ALL_BP_LOCATIONS (loc, loc_tmp)
830             mark_breakpoint_location_modified (loc);
831         }
832       else
833         {
834           /* Manually mark non-duplicate locations to synch conditions
835              with the target.  We do this to remove all the conditions the
836              target knows about.  */
837           ALL_BP_LOCATIONS (loc, loc_tmp)
838             if (is_breakpoint (loc->owner) && loc->inserted)
839               loc->needs_update = 1;
840         }
841
842       /* Do the update.  */
843       update_global_location_list (1);
844     }
845
846   return;
847 }
848
849 /* Shows the current mode of breakpoint condition evaluation.  Explicitly shows
850    what "auto" is translating to.  */
851
852 static void
853 show_condition_evaluation_mode (struct ui_file *file, int from_tty,
854                                 struct cmd_list_element *c, const char *value)
855 {
856   if (condition_evaluation_mode == condition_evaluation_auto)
857     fprintf_filtered (file,
858                       _("Breakpoint condition evaluation "
859                         "mode is %s (currently %s).\n"),
860                       value,
861                       breakpoint_condition_evaluation_mode ());
862   else
863     fprintf_filtered (file, _("Breakpoint condition evaluation mode is %s.\n"),
864                       value);
865 }
866
867 /* A comparison function for bp_location AP and BP that is used by
868    bsearch.  This comparison function only cares about addresses, unlike
869    the more general bp_location_compare function.  */
870
871 static int
872 bp_location_compare_addrs (const void *ap, const void *bp)
873 {
874   struct bp_location *a = *(void **) ap;
875   struct bp_location *b = *(void **) bp;
876
877   if (a->address == b->address)
878     return 0;
879   else
880     return ((a->address > b->address) - (a->address < b->address));
881 }
882
883 /* Helper function to skip all bp_locations with addresses
884    less than ADDRESS.  It returns the first bp_location that
885    is greater than or equal to ADDRESS.  If none is found, just
886    return NULL.  */
887
888 static struct bp_location **
889 get_first_locp_gte_addr (CORE_ADDR address)
890 {
891   struct bp_location dummy_loc;
892   struct bp_location *dummy_locp = &dummy_loc;
893   struct bp_location **locp_found = NULL;
894
895   /* Initialize the dummy location's address field.  */
896   memset (&dummy_loc, 0, sizeof (struct bp_location));
897   dummy_loc.address = address;
898
899   /* Find a close match to the first location at ADDRESS.  */
900   locp_found = bsearch (&dummy_locp, bp_location, bp_location_count,
901                         sizeof (struct bp_location **),
902                         bp_location_compare_addrs);
903
904   /* Nothing was found, nothing left to do.  */
905   if (locp_found == NULL)
906     return NULL;
907
908   /* We may have found a location that is at ADDRESS but is not the first in the
909      location's list.  Go backwards (if possible) and locate the first one.  */
910   while ((locp_found - 1) >= bp_location
911          && (*(locp_found - 1))->address == address)
912     locp_found--;
913
914   return locp_found;
915 }
916
917 void
918 set_breakpoint_condition (struct breakpoint *b, char *exp,
919                           int from_tty)
920 {
921   xfree (b->cond_string);
922   b->cond_string = NULL;
923
924   if (is_watchpoint (b))
925     {
926       struct watchpoint *w = (struct watchpoint *) b;
927
928       xfree (w->cond_exp);
929       w->cond_exp = NULL;
930     }
931   else
932     {
933       struct bp_location *loc;
934
935       for (loc = b->loc; loc; loc = loc->next)
936         {
937           xfree (loc->cond);
938           loc->cond = NULL;
939
940           /* No need to free the condition agent expression
941              bytecode (if we have one).  We will handle this
942              when we go through update_global_location_list.  */
943         }
944     }
945
946   if (*exp == 0)
947     {
948       if (from_tty)
949         printf_filtered (_("Breakpoint %d now unconditional.\n"), b->number);
950     }
951   else
952     {
953       char *arg = exp;
954
955       /* I don't know if it matters whether this is the string the user
956          typed in or the decompiled expression.  */
957       b->cond_string = xstrdup (arg);
958       b->condition_not_parsed = 0;
959
960       if (is_watchpoint (b))
961         {
962           struct watchpoint *w = (struct watchpoint *) b;
963
964           innermost_block = NULL;
965           arg = exp;
966           w->cond_exp = parse_exp_1 (&arg, 0, 0, 0);
967           if (*arg)
968             error (_("Junk at end of expression"));
969           w->cond_exp_valid_block = innermost_block;
970         }
971       else
972         {
973           struct bp_location *loc;
974
975           for (loc = b->loc; loc; loc = loc->next)
976             {
977               arg = exp;
978               loc->cond =
979                 parse_exp_1 (&arg, loc->address,
980                              block_for_pc (loc->address), 0);
981               if (*arg)
982                 error (_("Junk at end of expression"));
983             }
984         }
985     }
986   mark_breakpoint_modified (b);
987
988   observer_notify_breakpoint_modified (b);
989 }
990
991 /* Completion for the "condition" command.  */
992
993 static VEC (char_ptr) *
994 condition_completer (struct cmd_list_element *cmd, char *text, char *word)
995 {
996   char *space;
997
998   text = skip_spaces (text);
999   space = skip_to_space (text);
1000   if (*space == '\0')
1001     {
1002       int len;
1003       struct breakpoint *b;
1004       VEC (char_ptr) *result = NULL;
1005
1006       if (text[0] == '$')
1007         {
1008           /* We don't support completion of history indices.  */
1009           if (isdigit (text[1]))
1010             return NULL;
1011           return complete_internalvar (&text[1]);
1012         }
1013
1014       /* We're completing the breakpoint number.  */
1015       len = strlen (text);
1016
1017       ALL_BREAKPOINTS (b)
1018       {
1019         int single = b->loc->next == NULL;
1020         struct bp_location *loc;
1021         int count = 1;
1022
1023         for (loc = b->loc; loc; loc = loc->next)
1024           {
1025             char location[50];
1026
1027             if (single)
1028               xsnprintf (location, sizeof (location), "%d", b->number);
1029             else
1030               xsnprintf (location, sizeof (location),  "%d.%d", b->number,
1031                          count);
1032
1033             if (strncmp (location, text, len) == 0)
1034               VEC_safe_push (char_ptr, result, xstrdup (location));
1035
1036             ++count;
1037           }
1038       }
1039
1040       return result;
1041     }
1042
1043   /* We're completing the expression part.  */
1044   text = skip_spaces (space);
1045   return expression_completer (cmd, text, word);
1046 }
1047
1048 /* condition N EXP -- set break condition of breakpoint N to EXP.  */
1049
1050 static void
1051 condition_command (char *arg, int from_tty)
1052 {
1053   struct breakpoint *b;
1054   char *p;
1055   int bnum;
1056
1057   if (arg == 0)
1058     error_no_arg (_("breakpoint number"));
1059
1060   p = arg;
1061   bnum = get_number (&p);
1062   if (bnum == 0)
1063     error (_("Bad breakpoint argument: '%s'"), arg);
1064
1065   ALL_BREAKPOINTS (b)
1066     if (b->number == bnum)
1067       {
1068         /* Check if this breakpoint has a Python object assigned to
1069            it, and if it has a definition of the "stop"
1070            method.  This method and conditions entered into GDB from
1071            the CLI are mutually exclusive.  */
1072         if (b->py_bp_object
1073             && gdbpy_breakpoint_has_py_cond (b->py_bp_object))
1074           error (_("Cannot set a condition where a Python 'stop' "
1075                    "method has been defined in the breakpoint."));
1076         set_breakpoint_condition (b, p, from_tty);
1077
1078         if (is_breakpoint (b))
1079           update_global_location_list (1);
1080
1081         return;
1082       }
1083
1084   error (_("No breakpoint number %d."), bnum);
1085 }
1086
1087 /* Check that COMMAND do not contain commands that are suitable
1088    only for tracepoints and not suitable for ordinary breakpoints.
1089    Throw if any such commands is found.  */
1090
1091 static void
1092 check_no_tracepoint_commands (struct command_line *commands)
1093 {
1094   struct command_line *c;
1095
1096   for (c = commands; c; c = c->next)
1097     {
1098       int i;
1099
1100       if (c->control_type == while_stepping_control)
1101         error (_("The 'while-stepping' command can "
1102                  "only be used for tracepoints"));
1103
1104       for (i = 0; i < c->body_count; ++i)
1105         check_no_tracepoint_commands ((c->body_list)[i]);
1106
1107       /* Not that command parsing removes leading whitespace and comment
1108          lines and also empty lines.  So, we only need to check for
1109          command directly.  */
1110       if (strstr (c->line, "collect ") == c->line)
1111         error (_("The 'collect' command can only be used for tracepoints"));
1112
1113       if (strstr (c->line, "teval ") == c->line)
1114         error (_("The 'teval' command can only be used for tracepoints"));
1115     }
1116 }
1117
1118 /* Encapsulate tests for different types of tracepoints.  */
1119
1120 static int
1121 is_tracepoint_type (enum bptype type)
1122 {
1123   return (type == bp_tracepoint
1124           || type == bp_fast_tracepoint
1125           || type == bp_static_tracepoint);
1126 }
1127
1128 int
1129 is_tracepoint (const struct breakpoint *b)
1130 {
1131   return is_tracepoint_type (b->type);
1132 }
1133
1134 /* A helper function that validates that COMMANDS are valid for a
1135    breakpoint.  This function will throw an exception if a problem is
1136    found.  */
1137
1138 static void
1139 validate_commands_for_breakpoint (struct breakpoint *b,
1140                                   struct command_line *commands)
1141 {
1142   if (is_tracepoint (b))
1143     {
1144       /* We need to verify that each top-level element of commands is
1145          valid for tracepoints, that there's at most one
1146          while-stepping element, and that while-stepping's body has
1147          valid tracing commands excluding nested while-stepping.  */
1148       struct command_line *c;
1149       struct command_line *while_stepping = 0;
1150       for (c = commands; c; c = c->next)
1151         {
1152           if (c->control_type == while_stepping_control)
1153             {
1154               if (b->type == bp_fast_tracepoint)
1155                 error (_("The 'while-stepping' command "
1156                          "cannot be used for fast tracepoint"));
1157               else if (b->type == bp_static_tracepoint)
1158                 error (_("The 'while-stepping' command "
1159                          "cannot be used for static tracepoint"));
1160
1161               if (while_stepping)
1162                 error (_("The 'while-stepping' command "
1163                          "can be used only once"));
1164               else
1165                 while_stepping = c;
1166             }
1167         }
1168       if (while_stepping)
1169         {
1170           struct command_line *c2;
1171
1172           gdb_assert (while_stepping->body_count == 1);
1173           c2 = while_stepping->body_list[0];
1174           for (; c2; c2 = c2->next)
1175             {
1176               if (c2->control_type == while_stepping_control)
1177                 error (_("The 'while-stepping' command cannot be nested"));
1178             }
1179         }
1180     }
1181   else
1182     {
1183       check_no_tracepoint_commands (commands);
1184     }
1185 }
1186
1187 /* Return a vector of all the static tracepoints set at ADDR.  The
1188    caller is responsible for releasing the vector.  */
1189
1190 VEC(breakpoint_p) *
1191 static_tracepoints_here (CORE_ADDR addr)
1192 {
1193   struct breakpoint *b;
1194   VEC(breakpoint_p) *found = 0;
1195   struct bp_location *loc;
1196
1197   ALL_BREAKPOINTS (b)
1198     if (b->type == bp_static_tracepoint)
1199       {
1200         for (loc = b->loc; loc; loc = loc->next)
1201           if (loc->address == addr)
1202             VEC_safe_push(breakpoint_p, found, b);
1203       }
1204
1205   return found;
1206 }
1207
1208 /* Set the command list of B to COMMANDS.  If breakpoint is tracepoint,
1209    validate that only allowed commands are included.  */
1210
1211 void
1212 breakpoint_set_commands (struct breakpoint *b, 
1213                          struct command_line *commands)
1214 {
1215   validate_commands_for_breakpoint (b, commands);
1216
1217   decref_counted_command_line (&b->commands);
1218   b->commands = alloc_counted_command_line (commands);
1219   observer_notify_breakpoint_modified (b);
1220 }
1221
1222 /* Set the internal `silent' flag on the breakpoint.  Note that this
1223    is not the same as the "silent" that may appear in the breakpoint's
1224    commands.  */
1225
1226 void
1227 breakpoint_set_silent (struct breakpoint *b, int silent)
1228 {
1229   int old_silent = b->silent;
1230
1231   b->silent = silent;
1232   if (old_silent != silent)
1233     observer_notify_breakpoint_modified (b);
1234 }
1235
1236 /* Set the thread for this breakpoint.  If THREAD is -1, make the
1237    breakpoint work for any thread.  */
1238
1239 void
1240 breakpoint_set_thread (struct breakpoint *b, int thread)
1241 {
1242   int old_thread = b->thread;
1243
1244   b->thread = thread;
1245   if (old_thread != thread)
1246     observer_notify_breakpoint_modified (b);
1247 }
1248
1249 /* Set the task for this breakpoint.  If TASK is 0, make the
1250    breakpoint work for any task.  */
1251
1252 void
1253 breakpoint_set_task (struct breakpoint *b, int task)
1254 {
1255   int old_task = b->task;
1256
1257   b->task = task;
1258   if (old_task != task)
1259     observer_notify_breakpoint_modified (b);
1260 }
1261
1262 void
1263 check_tracepoint_command (char *line, void *closure)
1264 {
1265   struct breakpoint *b = closure;
1266
1267   validate_actionline (&line, b);
1268 }
1269
1270 /* A structure used to pass information through
1271    map_breakpoint_numbers.  */
1272
1273 struct commands_info
1274 {
1275   /* True if the command was typed at a tty.  */
1276   int from_tty;
1277
1278   /* The breakpoint range spec.  */
1279   char *arg;
1280
1281   /* Non-NULL if the body of the commands are being read from this
1282      already-parsed command.  */
1283   struct command_line *control;
1284
1285   /* The command lines read from the user, or NULL if they have not
1286      yet been read.  */
1287   struct counted_command_line *cmd;
1288 };
1289
1290 /* A callback for map_breakpoint_numbers that sets the commands for
1291    commands_command.  */
1292
1293 static void
1294 do_map_commands_command (struct breakpoint *b, void *data)
1295 {
1296   struct commands_info *info = data;
1297
1298   if (info->cmd == NULL)
1299     {
1300       struct command_line *l;
1301
1302       if (info->control != NULL)
1303         l = copy_command_lines (info->control->body_list[0]);
1304       else
1305         {
1306           struct cleanup *old_chain;
1307           char *str;
1308
1309           str = xstrprintf (_("Type commands for breakpoint(s) "
1310                               "%s, one per line."),
1311                             info->arg);
1312
1313           old_chain = make_cleanup (xfree, str);
1314
1315           l = read_command_lines (str,
1316                                   info->from_tty, 1,
1317                                   (is_tracepoint (b)
1318                                    ? check_tracepoint_command : 0),
1319                                   b);
1320
1321           do_cleanups (old_chain);
1322         }
1323
1324       info->cmd = alloc_counted_command_line (l);
1325     }
1326
1327   /* If a breakpoint was on the list more than once, we don't need to
1328      do anything.  */
1329   if (b->commands != info->cmd)
1330     {
1331       validate_commands_for_breakpoint (b, info->cmd->commands);
1332       incref_counted_command_line (info->cmd);
1333       decref_counted_command_line (&b->commands);
1334       b->commands = info->cmd;
1335       observer_notify_breakpoint_modified (b);
1336     }
1337 }
1338
1339 static void
1340 commands_command_1 (char *arg, int from_tty, 
1341                     struct command_line *control)
1342 {
1343   struct cleanup *cleanups;
1344   struct commands_info info;
1345
1346   info.from_tty = from_tty;
1347   info.control = control;
1348   info.cmd = NULL;
1349   /* If we read command lines from the user, then `info' will hold an
1350      extra reference to the commands that we must clean up.  */
1351   cleanups = make_cleanup_decref_counted_command_line (&info.cmd);
1352
1353   if (arg == NULL || !*arg)
1354     {
1355       if (breakpoint_count - prev_breakpoint_count > 1)
1356         arg = xstrprintf ("%d-%d", prev_breakpoint_count + 1, 
1357                           breakpoint_count);
1358       else if (breakpoint_count > 0)
1359         arg = xstrprintf ("%d", breakpoint_count);
1360       else
1361         {
1362           /* So that we don't try to free the incoming non-NULL
1363              argument in the cleanup below.  Mapping breakpoint
1364              numbers will fail in this case.  */
1365           arg = NULL;
1366         }
1367     }
1368   else
1369     /* The command loop has some static state, so we need to preserve
1370        our argument.  */
1371     arg = xstrdup (arg);
1372
1373   if (arg != NULL)
1374     make_cleanup (xfree, arg);
1375
1376   info.arg = arg;
1377
1378   map_breakpoint_numbers (arg, do_map_commands_command, &info);
1379
1380   if (info.cmd == NULL)
1381     error (_("No breakpoints specified."));
1382
1383   do_cleanups (cleanups);
1384 }
1385
1386 static void
1387 commands_command (char *arg, int from_tty)
1388 {
1389   commands_command_1 (arg, from_tty, NULL);
1390 }
1391
1392 /* Like commands_command, but instead of reading the commands from
1393    input stream, takes them from an already parsed command structure.
1394
1395    This is used by cli-script.c to DTRT with breakpoint commands
1396    that are part of if and while bodies.  */
1397 enum command_control_type
1398 commands_from_control_command (char *arg, struct command_line *cmd)
1399 {
1400   commands_command_1 (arg, 0, cmd);
1401   return simple_control;
1402 }
1403
1404 /* Return non-zero if BL->TARGET_INFO contains valid information.  */
1405
1406 static int
1407 bp_location_has_shadow (struct bp_location *bl)
1408 {
1409   if (bl->loc_type != bp_loc_software_breakpoint)
1410     return 0;
1411   if (!bl->inserted)
1412     return 0;
1413   if (bl->target_info.shadow_len == 0)
1414     /* BL isn't valid, or doesn't shadow memory.  */
1415     return 0;
1416   return 1;
1417 }
1418
1419 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1420    by replacing any memory breakpoints with their shadowed contents.
1421
1422    If READBUF is not NULL, this buffer must not overlap with any of
1423    the breakpoint location's shadow_contents buffers.  Otherwise,
1424    a failed assertion internal error will be raised.
1425
1426    The range of shadowed area by each bp_location is:
1427      bl->address - bp_location_placed_address_before_address_max
1428      up to bl->address + bp_location_shadow_len_after_address_max
1429    The range we were requested to resolve shadows for is:
1430      memaddr ... memaddr + len
1431    Thus the safe cutoff boundaries for performance optimization are
1432      memaddr + len <= (bl->address
1433                        - bp_location_placed_address_before_address_max)
1434    and:
1435      bl->address + bp_location_shadow_len_after_address_max <= memaddr  */
1436
1437 void
1438 breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1439                         const gdb_byte *writebuf_org,
1440                         ULONGEST memaddr, LONGEST len)
1441 {
1442   /* Left boundary, right boundary and median element of our binary
1443      search.  */
1444   unsigned bc_l, bc_r, bc;
1445
1446   /* Find BC_L which is a leftmost element which may affect BUF
1447      content.  It is safe to report lower value but a failure to
1448      report higher one.  */
1449
1450   bc_l = 0;
1451   bc_r = bp_location_count;
1452   while (bc_l + 1 < bc_r)
1453     {
1454       struct bp_location *bl;
1455
1456       bc = (bc_l + bc_r) / 2;
1457       bl = bp_location[bc];
1458
1459       /* Check first BL->ADDRESS will not overflow due to the added
1460          constant.  Then advance the left boundary only if we are sure
1461          the BC element can in no way affect the BUF content (MEMADDR
1462          to MEMADDR + LEN range).
1463
1464          Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1465          offset so that we cannot miss a breakpoint with its shadow
1466          range tail still reaching MEMADDR.  */
1467
1468       if ((bl->address + bp_location_shadow_len_after_address_max
1469            >= bl->address)
1470           && (bl->address + bp_location_shadow_len_after_address_max
1471               <= memaddr))
1472         bc_l = bc;
1473       else
1474         bc_r = bc;
1475     }
1476
1477   /* Due to the binary search above, we need to make sure we pick the
1478      first location that's at BC_L's address.  E.g., if there are
1479      multiple locations at the same address, BC_L may end up pointing
1480      at a duplicate location, and miss the "master"/"inserted"
1481      location.  Say, given locations L1, L2 and L3 at addresses A and
1482      B:
1483
1484       L1@A, L2@A, L3@B, ...
1485
1486      BC_L could end up pointing at location L2, while the "master"
1487      location could be L1.  Since the `loc->inserted' flag is only set
1488      on "master" locations, we'd forget to restore the shadow of L1
1489      and L2.  */
1490   while (bc_l > 0
1491          && bp_location[bc_l]->address == bp_location[bc_l - 1]->address)
1492     bc_l--;
1493
1494   /* Now do full processing of the found relevant range of elements.  */
1495
1496   for (bc = bc_l; bc < bp_location_count; bc++)
1497   {
1498     struct bp_location *bl = bp_location[bc];
1499     CORE_ADDR bp_addr = 0;
1500     int bp_size = 0;
1501     int bptoffset = 0;
1502
1503     /* bp_location array has BL->OWNER always non-NULL.  */
1504     if (bl->owner->type == bp_none)
1505       warning (_("reading through apparently deleted breakpoint #%d?"),
1506                bl->owner->number);
1507
1508     /* Performance optimization: any further element can no longer affect BUF
1509        content.  */
1510
1511     if (bl->address >= bp_location_placed_address_before_address_max
1512         && memaddr + len <= (bl->address
1513                              - bp_location_placed_address_before_address_max))
1514       break;
1515
1516     if (!bp_location_has_shadow (bl))
1517       continue;
1518     if (!breakpoint_address_match (bl->target_info.placed_address_space, 0,
1519                                    current_program_space->aspace, 0))
1520       continue;
1521
1522     /* Addresses and length of the part of the breakpoint that
1523        we need to copy.  */
1524     bp_addr = bl->target_info.placed_address;
1525     bp_size = bl->target_info.shadow_len;
1526
1527     if (bp_addr + bp_size <= memaddr)
1528       /* The breakpoint is entirely before the chunk of memory we
1529          are reading.  */
1530       continue;
1531
1532     if (bp_addr >= memaddr + len)
1533       /* The breakpoint is entirely after the chunk of memory we are
1534          reading.  */
1535       continue;
1536
1537     /* Offset within shadow_contents.  */
1538     if (bp_addr < memaddr)
1539       {
1540         /* Only copy the second part of the breakpoint.  */
1541         bp_size -= memaddr - bp_addr;
1542         bptoffset = memaddr - bp_addr;
1543         bp_addr = memaddr;
1544       }
1545
1546     if (bp_addr + bp_size > memaddr + len)
1547       {
1548         /* Only copy the first part of the breakpoint.  */
1549         bp_size -= (bp_addr + bp_size) - (memaddr + len);
1550       }
1551
1552     if (readbuf != NULL)
1553       {
1554         /* Verify that the readbuf buffer does not overlap with
1555            the shadow_contents buffer.  */
1556         gdb_assert (bl->target_info.shadow_contents >= readbuf + len
1557                     || readbuf >= (bl->target_info.shadow_contents
1558                                    + bl->target_info.shadow_len));
1559
1560         /* Update the read buffer with this inserted breakpoint's
1561            shadow.  */
1562         memcpy (readbuf + bp_addr - memaddr,
1563                 bl->target_info.shadow_contents + bptoffset, bp_size);
1564       }
1565     else
1566       {
1567         struct gdbarch *gdbarch = bl->gdbarch;
1568         const unsigned char *bp;
1569         CORE_ADDR placed_address = bl->target_info.placed_address;
1570         int placed_size = bl->target_info.placed_size;
1571
1572         /* Update the shadow with what we want to write to memory.  */
1573         memcpy (bl->target_info.shadow_contents + bptoffset,
1574                 writebuf_org + bp_addr - memaddr, bp_size);
1575
1576         /* Determine appropriate breakpoint contents and size for this
1577            address.  */
1578         bp = gdbarch_breakpoint_from_pc (gdbarch, &placed_address, &placed_size);
1579
1580         /* Update the final write buffer with this inserted
1581            breakpoint's INSN.  */
1582         memcpy (writebuf + bp_addr - memaddr, bp + bptoffset, bp_size);
1583       }
1584   }
1585 }
1586 \f
1587
1588 /* Return true if BPT is either a software breakpoint or a hardware
1589    breakpoint.  */
1590
1591 int
1592 is_breakpoint (const struct breakpoint *bpt)
1593 {
1594   return (bpt->type == bp_breakpoint
1595           || bpt->type == bp_hardware_breakpoint
1596           || bpt->type == bp_dprintf);
1597 }
1598
1599 /* Return true if BPT is of any hardware watchpoint kind.  */
1600
1601 static int
1602 is_hardware_watchpoint (const struct breakpoint *bpt)
1603 {
1604   return (bpt->type == bp_hardware_watchpoint
1605           || bpt->type == bp_read_watchpoint
1606           || bpt->type == bp_access_watchpoint);
1607 }
1608
1609 /* Return true if BPT is of any watchpoint kind, hardware or
1610    software.  */
1611
1612 int
1613 is_watchpoint (const struct breakpoint *bpt)
1614 {
1615   return (is_hardware_watchpoint (bpt)
1616           || bpt->type == bp_watchpoint);
1617 }
1618
1619 /* Returns true if the current thread and its running state are safe
1620    to evaluate or update watchpoint B.  Watchpoints on local
1621    expressions need to be evaluated in the context of the thread that
1622    was current when the watchpoint was created, and, that thread needs
1623    to be stopped to be able to select the correct frame context.
1624    Watchpoints on global expressions can be evaluated on any thread,
1625    and in any state.  It is presently left to the target allowing
1626    memory accesses when threads are running.  */
1627
1628 static int
1629 watchpoint_in_thread_scope (struct watchpoint *b)
1630 {
1631   return (b->base.pspace == current_program_space
1632           && (ptid_equal (b->watchpoint_thread, null_ptid)
1633               || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1634                   && !is_executing (inferior_ptid))));
1635 }
1636
1637 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1638    associated bp_watchpoint_scope breakpoint.  */
1639
1640 static void
1641 watchpoint_del_at_next_stop (struct watchpoint *w)
1642 {
1643   struct breakpoint *b = &w->base;
1644
1645   if (b->related_breakpoint != b)
1646     {
1647       gdb_assert (b->related_breakpoint->type == bp_watchpoint_scope);
1648       gdb_assert (b->related_breakpoint->related_breakpoint == b);
1649       b->related_breakpoint->disposition = disp_del_at_next_stop;
1650       b->related_breakpoint->related_breakpoint = b->related_breakpoint;
1651       b->related_breakpoint = b;
1652     }
1653   b->disposition = disp_del_at_next_stop;
1654 }
1655
1656 /* Assuming that B is a watchpoint:
1657    - Reparse watchpoint expression, if REPARSE is non-zero
1658    - Evaluate expression and store the result in B->val
1659    - Evaluate the condition if there is one, and store the result
1660      in b->loc->cond.
1661    - Update the list of values that must be watched in B->loc.
1662
1663    If the watchpoint disposition is disp_del_at_next_stop, then do
1664    nothing.  If this is local watchpoint that is out of scope, delete
1665    it.
1666
1667    Even with `set breakpoint always-inserted on' the watchpoints are
1668    removed + inserted on each stop here.  Normal breakpoints must
1669    never be removed because they might be missed by a running thread
1670    when debugging in non-stop mode.  On the other hand, hardware
1671    watchpoints (is_hardware_watchpoint; processed here) are specific
1672    to each LWP since they are stored in each LWP's hardware debug
1673    registers.  Therefore, such LWP must be stopped first in order to
1674    be able to modify its hardware watchpoints.
1675
1676    Hardware watchpoints must be reset exactly once after being
1677    presented to the user.  It cannot be done sooner, because it would
1678    reset the data used to present the watchpoint hit to the user.  And
1679    it must not be done later because it could display the same single
1680    watchpoint hit during multiple GDB stops.  Note that the latter is
1681    relevant only to the hardware watchpoint types bp_read_watchpoint
1682    and bp_access_watchpoint.  False hit by bp_hardware_watchpoint is
1683    not user-visible - its hit is suppressed if the memory content has
1684    not changed.
1685
1686    The following constraints influence the location where we can reset
1687    hardware watchpoints:
1688
1689    * target_stopped_by_watchpoint and target_stopped_data_address are
1690      called several times when GDB stops.
1691
1692    [linux] 
1693    * Multiple hardware watchpoints can be hit at the same time,
1694      causing GDB to stop.  GDB only presents one hardware watchpoint
1695      hit at a time as the reason for stopping, and all the other hits
1696      are presented later, one after the other, each time the user
1697      requests the execution to be resumed.  Execution is not resumed
1698      for the threads still having pending hit event stored in
1699      LWP_INFO->STATUS.  While the watchpoint is already removed from
1700      the inferior on the first stop the thread hit event is kept being
1701      reported from its cached value by linux_nat_stopped_data_address
1702      until the real thread resume happens after the watchpoint gets
1703      presented and thus its LWP_INFO->STATUS gets reset.
1704
1705    Therefore the hardware watchpoint hit can get safely reset on the
1706    watchpoint removal from inferior.  */
1707
1708 static void
1709 update_watchpoint (struct watchpoint *b, int reparse)
1710 {
1711   int within_current_scope;
1712   struct frame_id saved_frame_id;
1713   int frame_saved;
1714
1715   /* If this is a local watchpoint, we only want to check if the
1716      watchpoint frame is in scope if the current thread is the thread
1717      that was used to create the watchpoint.  */
1718   if (!watchpoint_in_thread_scope (b))
1719     return;
1720
1721   if (b->base.disposition == disp_del_at_next_stop)
1722     return;
1723  
1724   frame_saved = 0;
1725
1726   /* Determine if the watchpoint is within scope.  */
1727   if (b->exp_valid_block == NULL)
1728     within_current_scope = 1;
1729   else
1730     {
1731       struct frame_info *fi = get_current_frame ();
1732       struct gdbarch *frame_arch = get_frame_arch (fi);
1733       CORE_ADDR frame_pc = get_frame_pc (fi);
1734
1735       /* If we're in a function epilogue, unwinding may not work
1736          properly, so do not attempt to recreate locations at this
1737          point.  See similar comments in watchpoint_check.  */
1738       if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
1739         return;
1740
1741       /* Save the current frame's ID so we can restore it after
1742          evaluating the watchpoint expression on its own frame.  */
1743       /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1744          took a frame parameter, so that we didn't have to change the
1745          selected frame.  */
1746       frame_saved = 1;
1747       saved_frame_id = get_frame_id (get_selected_frame (NULL));
1748
1749       fi = frame_find_by_id (b->watchpoint_frame);
1750       within_current_scope = (fi != NULL);
1751       if (within_current_scope)
1752         select_frame (fi);
1753     }
1754
1755   /* We don't free locations.  They are stored in the bp_location array
1756      and update_global_location_list will eventually delete them and
1757      remove breakpoints if needed.  */
1758   b->base.loc = NULL;
1759
1760   if (within_current_scope && reparse)
1761     {
1762       char *s;
1763
1764       if (b->exp)
1765         {
1766           xfree (b->exp);
1767           b->exp = NULL;
1768         }
1769       s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1770       b->exp = parse_exp_1 (&s, 0, b->exp_valid_block, 0);
1771       /* If the meaning of expression itself changed, the old value is
1772          no longer relevant.  We don't want to report a watchpoint hit
1773          to the user when the old value and the new value may actually
1774          be completely different objects.  */
1775       value_free (b->val);
1776       b->val = NULL;
1777       b->val_valid = 0;
1778
1779       /* Note that unlike with breakpoints, the watchpoint's condition
1780          expression is stored in the breakpoint object, not in the
1781          locations (re)created below.  */
1782       if (b->base.cond_string != NULL)
1783         {
1784           if (b->cond_exp != NULL)
1785             {
1786               xfree (b->cond_exp);
1787               b->cond_exp = NULL;
1788             }
1789
1790           s = b->base.cond_string;
1791           b->cond_exp = parse_exp_1 (&s, 0, b->cond_exp_valid_block, 0);
1792         }
1793     }
1794
1795   /* If we failed to parse the expression, for example because
1796      it refers to a global variable in a not-yet-loaded shared library,
1797      don't try to insert watchpoint.  We don't automatically delete
1798      such watchpoint, though, since failure to parse expression
1799      is different from out-of-scope watchpoint.  */
1800   if ( !target_has_execution)
1801     {
1802       /* Without execution, memory can't change.  No use to try and
1803          set watchpoint locations.  The watchpoint will be reset when
1804          the target gains execution, through breakpoint_re_set.  */
1805     }
1806   else if (within_current_scope && b->exp)
1807     {
1808       int pc = 0;
1809       struct value *val_chain, *v, *result, *next;
1810       struct program_space *frame_pspace;
1811
1812       fetch_subexp_value (b->exp, &pc, &v, &result, &val_chain);
1813
1814       /* Avoid setting b->val if it's already set.  The meaning of
1815          b->val is 'the last value' user saw, and we should update
1816          it only if we reported that last value to user.  As it
1817          happens, the code that reports it updates b->val directly.
1818          We don't keep track of the memory value for masked
1819          watchpoints.  */
1820       if (!b->val_valid && !is_masked_watchpoint (&b->base))
1821         {
1822           b->val = v;
1823           b->val_valid = 1;
1824         }
1825
1826       frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1827
1828       /* Look at each value on the value chain.  */
1829       for (v = val_chain; v; v = value_next (v))
1830         {
1831           /* If it's a memory location, and GDB actually needed
1832              its contents to evaluate the expression, then we
1833              must watch it.  If the first value returned is
1834              still lazy, that means an error occurred reading it;
1835              watch it anyway in case it becomes readable.  */
1836           if (VALUE_LVAL (v) == lval_memory
1837               && (v == val_chain || ! value_lazy (v)))
1838             {
1839               struct type *vtype = check_typedef (value_type (v));
1840
1841               /* We only watch structs and arrays if user asked
1842                  for it explicitly, never if they just happen to
1843                  appear in the middle of some value chain.  */
1844               if (v == result
1845                   || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1846                       && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1847                 {
1848                   CORE_ADDR addr;
1849                   int type;
1850                   struct bp_location *loc, **tmp;
1851
1852                   addr = value_address (v);
1853                   type = hw_write;
1854                   if (b->base.type == bp_read_watchpoint)
1855                     type = hw_read;
1856                   else if (b->base.type == bp_access_watchpoint)
1857                     type = hw_access;
1858
1859                   loc = allocate_bp_location (&b->base);
1860                   for (tmp = &(b->base.loc); *tmp != NULL; tmp = &((*tmp)->next))
1861                     ;
1862                   *tmp = loc;
1863                   loc->gdbarch = get_type_arch (value_type (v));
1864
1865                   loc->pspace = frame_pspace;
1866                   loc->address = addr;
1867                   loc->length = TYPE_LENGTH (value_type (v));
1868                   loc->watchpoint_type = type;
1869                 }
1870             }
1871         }
1872
1873       /* Change the type of breakpoint between hardware assisted or
1874          an ordinary watchpoint depending on the hardware support
1875          and free hardware slots.  REPARSE is set when the inferior
1876          is started.  */
1877       if (reparse)
1878         {
1879           int reg_cnt;
1880           enum bp_loc_type loc_type;
1881           struct bp_location *bl;
1882
1883           reg_cnt = can_use_hardware_watchpoint (val_chain);
1884
1885           if (reg_cnt)
1886             {
1887               int i, target_resources_ok, other_type_used;
1888               enum bptype type;
1889
1890               /* Use an exact watchpoint when there's only one memory region to be
1891                  watched, and only one debug register is needed to watch it.  */
1892               b->exact = target_exact_watchpoints && reg_cnt == 1;
1893
1894               /* We need to determine how many resources are already
1895                  used for all other hardware watchpoints plus this one
1896                  to see if we still have enough resources to also fit
1897                  this watchpoint in as well.  */
1898
1899               /* If this is a software watchpoint, we try to turn it
1900                  to a hardware one -- count resources as if B was of
1901                  hardware watchpoint type.  */
1902               type = b->base.type;
1903               if (type == bp_watchpoint)
1904                 type = bp_hardware_watchpoint;
1905
1906               /* This watchpoint may or may not have been placed on
1907                  the list yet at this point (it won't be in the list
1908                  if we're trying to create it for the first time,
1909                  through watch_command), so always account for it
1910                  manually.  */
1911
1912               /* Count resources used by all watchpoints except B.  */
1913               i = hw_watchpoint_used_count_others (&b->base, type, &other_type_used);
1914
1915               /* Add in the resources needed for B.  */
1916               i += hw_watchpoint_use_count (&b->base);
1917
1918               target_resources_ok
1919                 = target_can_use_hardware_watchpoint (type, i, other_type_used);
1920               if (target_resources_ok <= 0)
1921                 {
1922                   int sw_mode = b->base.ops->works_in_software_mode (&b->base);
1923
1924                   if (target_resources_ok == 0 && !sw_mode)
1925                     error (_("Target does not support this type of "
1926                              "hardware watchpoint."));
1927                   else if (target_resources_ok < 0 && !sw_mode)
1928                     error (_("There are not enough available hardware "
1929                              "resources for this watchpoint."));
1930
1931                   /* Downgrade to software watchpoint.  */
1932                   b->base.type = bp_watchpoint;
1933                 }
1934               else
1935                 {
1936                   /* If this was a software watchpoint, we've just
1937                      found we have enough resources to turn it to a
1938                      hardware watchpoint.  Otherwise, this is a
1939                      nop.  */
1940                   b->base.type = type;
1941                 }
1942             }
1943           else if (!b->base.ops->works_in_software_mode (&b->base))
1944             error (_("Expression cannot be implemented with "
1945                      "read/access watchpoint."));
1946           else
1947             b->base.type = bp_watchpoint;
1948
1949           loc_type = (b->base.type == bp_watchpoint? bp_loc_other
1950                       : bp_loc_hardware_watchpoint);
1951           for (bl = b->base.loc; bl; bl = bl->next)
1952             bl->loc_type = loc_type;
1953         }
1954
1955       for (v = val_chain; v; v = next)
1956         {
1957           next = value_next (v);
1958           if (v != b->val)
1959             value_free (v);
1960         }
1961
1962       /* If a software watchpoint is not watching any memory, then the
1963          above left it without any location set up.  But,
1964          bpstat_stop_status requires a location to be able to report
1965          stops, so make sure there's at least a dummy one.  */
1966       if (b->base.type == bp_watchpoint && b->base.loc == NULL)
1967         {
1968           struct breakpoint *base = &b->base;
1969           base->loc = allocate_bp_location (base);
1970           base->loc->pspace = frame_pspace;
1971           base->loc->address = -1;
1972           base->loc->length = -1;
1973           base->loc->watchpoint_type = -1;
1974         }
1975     }
1976   else if (!within_current_scope)
1977     {
1978       printf_filtered (_("\
1979 Watchpoint %d deleted because the program has left the block\n\
1980 in which its expression is valid.\n"),
1981                        b->base.number);
1982       watchpoint_del_at_next_stop (b);
1983     }
1984
1985   /* Restore the selected frame.  */
1986   if (frame_saved)
1987     select_frame (frame_find_by_id (saved_frame_id));
1988 }
1989
1990
1991 /* Returns 1 iff breakpoint location should be
1992    inserted in the inferior.  We don't differentiate the type of BL's owner
1993    (breakpoint vs. tracepoint), although insert_location in tracepoint's
1994    breakpoint_ops is not defined, because in insert_bp_location,
1995    tracepoint's insert_location will not be called.  */
1996 static int
1997 should_be_inserted (struct bp_location *bl)
1998 {
1999   if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
2000     return 0;
2001
2002   if (bl->owner->disposition == disp_del_at_next_stop)
2003     return 0;
2004
2005   if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
2006     return 0;
2007
2008   if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
2009     return 0;
2010
2011   /* This is set for example, when we're attached to the parent of a
2012      vfork, and have detached from the child.  The child is running
2013      free, and we expect it to do an exec or exit, at which point the
2014      OS makes the parent schedulable again (and the target reports
2015      that the vfork is done).  Until the child is done with the shared
2016      memory region, do not insert breakpoints in the parent, otherwise
2017      the child could still trip on the parent's breakpoints.  Since
2018      the parent is blocked anyway, it won't miss any breakpoint.  */
2019   if (bl->pspace->breakpoints_not_allowed)
2020     return 0;
2021
2022   return 1;
2023 }
2024
2025 /* Same as should_be_inserted but does the check assuming
2026    that the location is not duplicated.  */
2027
2028 static int
2029 unduplicated_should_be_inserted (struct bp_location *bl)
2030 {
2031   int result;
2032   const int save_duplicate = bl->duplicate;
2033
2034   bl->duplicate = 0;
2035   result = should_be_inserted (bl);
2036   bl->duplicate = save_duplicate;
2037   return result;
2038 }
2039
2040 /* Parses a conditional described by an expression COND into an
2041    agent expression bytecode suitable for evaluation
2042    by the bytecode interpreter.  Return NULL if there was
2043    any error during parsing.  */
2044
2045 static struct agent_expr *
2046 parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
2047 {
2048   struct agent_expr *aexpr = NULL;
2049   struct cleanup *old_chain = NULL;
2050   volatile struct gdb_exception ex;
2051
2052   if (!cond)
2053     return NULL;
2054
2055   /* We don't want to stop processing, so catch any errors
2056      that may show up.  */
2057   TRY_CATCH (ex, RETURN_MASK_ERROR)
2058     {
2059       aexpr = gen_eval_for_expr (scope, cond);
2060     }
2061
2062   if (ex.reason < 0)
2063     {
2064       /* If we got here, it means the condition could not be parsed to a valid
2065          bytecode expression and thus can't be evaluated on the target's side.
2066          It's no use iterating through the conditions.  */
2067       return NULL;
2068     }
2069
2070   /* We have a valid agent expression.  */
2071   return aexpr;
2072 }
2073
2074 /* Based on location BL, create a list of breakpoint conditions to be
2075    passed on to the target.  If we have duplicated locations with different
2076    conditions, we will add such conditions to the list.  The idea is that the
2077    target will evaluate the list of conditions and will only notify GDB when
2078    one of them is true.  */
2079
2080 static void
2081 build_target_condition_list (struct bp_location *bl)
2082 {
2083   struct bp_location **locp = NULL, **loc2p;
2084   int null_condition_or_parse_error = 0;
2085   int modified = bl->needs_update;
2086   struct bp_location *loc;
2087
2088   /* This is only meaningful if the target is
2089      evaluating conditions and if the user has
2090      opted for condition evaluation on the target's
2091      side.  */
2092   if (gdb_evaluates_breakpoint_condition_p ()
2093       || !target_supports_evaluation_of_breakpoint_conditions ())
2094     return;
2095
2096   /* Do a first pass to check for locations with no assigned
2097      conditions or conditions that fail to parse to a valid agent expression
2098      bytecode.  If any of these happen, then it's no use to send conditions
2099      to the target since this location will always trigger and generate a
2100      response back to GDB.  */
2101   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2102     {
2103       loc = (*loc2p);
2104       if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2105         {
2106           if (modified)
2107             {
2108               struct agent_expr *aexpr;
2109
2110               /* Re-parse the conditions since something changed.  In that
2111                  case we already freed the condition bytecodes (see
2112                  force_breakpoint_reinsertion).  We just
2113                  need to parse the condition to bytecodes again.  */
2114               aexpr = parse_cond_to_aexpr (bl->address, loc->cond);
2115               loc->cond_bytecode = aexpr;
2116
2117               /* Check if we managed to parse the conditional expression
2118                  correctly.  If not, we will not send this condition
2119                  to the target.  */
2120               if (aexpr)
2121                 continue;
2122             }
2123
2124           /* If we have a NULL bytecode expression, it means something
2125              went wrong or we have a null condition expression.  */
2126           if (!loc->cond_bytecode)
2127             {
2128               null_condition_or_parse_error = 1;
2129               break;
2130             }
2131         }
2132     }
2133
2134   /* If any of these happened, it means we will have to evaluate the conditions
2135      for the location's address on gdb's side.  It is no use keeping bytecodes
2136      for all the other duplicate locations, thus we free all of them here.
2137
2138      This is so we have a finer control over which locations' conditions are
2139      being evaluated by GDB or the remote stub.  */
2140   if (null_condition_or_parse_error)
2141     {
2142       ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2143         {
2144           loc = (*loc2p);
2145           if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2146             {
2147               /* Only go as far as the first NULL bytecode is
2148                  located.  */
2149               if (!loc->cond_bytecode)
2150                 return;
2151
2152               free_agent_expr (loc->cond_bytecode);
2153               loc->cond_bytecode = NULL;
2154             }
2155         }
2156     }
2157
2158   /* No NULL conditions or failed bytecode generation.  Build a condition list
2159      for this location's address.  */
2160   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2161     {
2162       loc = (*loc2p);
2163       if (loc->cond
2164           && is_breakpoint (loc->owner)
2165           && loc->pspace->num == bl->pspace->num
2166           && loc->owner->enable_state == bp_enabled
2167           && loc->enabled)
2168         /* Add the condition to the vector.  This will be used later to send the
2169            conditions to the target.  */
2170         VEC_safe_push (agent_expr_p, bl->target_info.conditions,
2171                        loc->cond_bytecode);
2172     }
2173
2174   return;
2175 }
2176
2177 /* Parses a command described by string CMD into an agent expression
2178    bytecode suitable for evaluation by the bytecode interpreter.
2179    Return NULL if there was any error during parsing.  */
2180
2181 static struct agent_expr *
2182 parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
2183 {
2184   struct cleanup *old_cleanups = 0;
2185   struct expression *expr, **argvec;
2186   struct agent_expr *aexpr = NULL;
2187   struct cleanup *old_chain = NULL;
2188   volatile struct gdb_exception ex;
2189   char *cmdrest;
2190   char *format_start, *format_end;
2191   struct format_piece *fpieces;
2192   int nargs;
2193   struct gdbarch *gdbarch = get_current_arch ();
2194
2195   if (!cmd)
2196     return NULL;
2197
2198   cmdrest = cmd;
2199
2200   if (*cmdrest == ',')
2201     ++cmdrest;
2202   cmdrest = skip_spaces (cmdrest);
2203
2204   if (*cmdrest++ != '"')
2205     error (_("No format string following the location"));
2206
2207   format_start = cmdrest;
2208
2209   fpieces = parse_format_string (&cmdrest);
2210
2211   old_cleanups = make_cleanup (free_format_pieces_cleanup, &fpieces);
2212
2213   format_end = cmdrest;
2214
2215   if (*cmdrest++ != '"')
2216     error (_("Bad format string, non-terminated '\"'."));
2217   
2218   cmdrest = skip_spaces (cmdrest);
2219
2220   if (!(*cmdrest == ',' || *cmdrest == '\0'))
2221     error (_("Invalid argument syntax"));
2222
2223   if (*cmdrest == ',')
2224     cmdrest++;
2225   cmdrest = skip_spaces (cmdrest);
2226
2227   /* For each argument, make an expression.  */
2228
2229   argvec = (struct expression **) alloca (strlen (cmd)
2230                                          * sizeof (struct expression *));
2231
2232   nargs = 0;
2233   while (*cmdrest != '\0')
2234     {
2235       char *cmd1;
2236
2237       cmd1 = cmdrest;
2238       expr = parse_exp_1 (&cmd1, scope, block_for_pc (scope), 1);
2239       argvec[nargs++] = expr;
2240       cmdrest = cmd1;
2241       if (*cmdrest == ',')
2242         ++cmdrest;
2243     }
2244
2245   /* We don't want to stop processing, so catch any errors
2246      that may show up.  */
2247   TRY_CATCH (ex, RETURN_MASK_ERROR)
2248     {
2249       aexpr = gen_printf (scope, gdbarch, 0, 0,
2250                           format_start, format_end - format_start,
2251                           fpieces, nargs, argvec);
2252     }
2253
2254   if (ex.reason < 0)
2255     {
2256       /* If we got here, it means the command could not be parsed to a valid
2257          bytecode expression and thus can't be evaluated on the target's side.
2258          It's no use iterating through the other commands.  */
2259       return NULL;
2260     }
2261
2262   do_cleanups (old_cleanups);
2263
2264   /* We have a valid agent expression, return it.  */
2265   return aexpr;
2266 }
2267
2268 /* Based on location BL, create a list of breakpoint commands to be
2269    passed on to the target.  If we have duplicated locations with
2270    different commands, we will add any such to the list.  */
2271
2272 static void
2273 build_target_command_list (struct bp_location *bl)
2274 {
2275   struct bp_location **locp = NULL, **loc2p;
2276   int null_command_or_parse_error = 0;
2277   int modified = bl->needs_update;
2278   struct bp_location *loc;
2279
2280   /* For now, limit to agent-style dprintf breakpoints.  */
2281   if (bl->owner->type != bp_dprintf
2282       || strcmp (dprintf_style, dprintf_style_agent) != 0)
2283     return;
2284
2285   if (!target_can_run_breakpoint_commands ())
2286     return;
2287
2288   /* Do a first pass to check for locations with no assigned
2289      conditions or conditions that fail to parse to a valid agent expression
2290      bytecode.  If any of these happen, then it's no use to send conditions
2291      to the target since this location will always trigger and generate a
2292      response back to GDB.  */
2293   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2294     {
2295       loc = (*loc2p);
2296       if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2297         {
2298           if (modified)
2299             {
2300               struct agent_expr *aexpr;
2301
2302               /* Re-parse the commands since something changed.  In that
2303                  case we already freed the command bytecodes (see
2304                  force_breakpoint_reinsertion).  We just
2305                  need to parse the command to bytecodes again.  */
2306               aexpr = parse_cmd_to_aexpr (bl->address,
2307                                           loc->owner->extra_string);
2308               loc->cmd_bytecode = aexpr;
2309
2310               if (!aexpr)
2311                 continue;
2312             }
2313
2314           /* If we have a NULL bytecode expression, it means something
2315              went wrong or we have a null command expression.  */
2316           if (!loc->cmd_bytecode)
2317             {
2318               null_command_or_parse_error = 1;
2319               break;
2320             }
2321         }
2322     }
2323
2324   /* If anything failed, then we're not doing target-side commands,
2325      and so clean up.  */
2326   if (null_command_or_parse_error)
2327     {
2328       ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2329         {
2330           loc = (*loc2p);
2331           if (is_breakpoint (loc->owner)
2332               && loc->pspace->num == bl->pspace->num)
2333             {
2334               /* Only go as far as the first NULL bytecode is
2335                  located.  */
2336               if (!loc->cond_bytecode)
2337                 return;
2338
2339               free_agent_expr (loc->cond_bytecode);
2340               loc->cond_bytecode = NULL;
2341             }
2342         }
2343     }
2344
2345   /* No NULL commands or failed bytecode generation.  Build a command list
2346      for this location's address.  */
2347   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2348     {
2349       loc = (*loc2p);
2350       if (loc->owner->extra_string
2351           && is_breakpoint (loc->owner)
2352           && loc->pspace->num == bl->pspace->num
2353           && loc->owner->enable_state == bp_enabled
2354           && loc->enabled)
2355         /* Add the command to the vector.  This will be used later
2356            to send the commands to the target.  */
2357         VEC_safe_push (agent_expr_p, bl->target_info.tcommands,
2358                        loc->cmd_bytecode);
2359     }
2360
2361   bl->target_info.persist = 0;
2362   /* Maybe flag this location as persistent.  */
2363   if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2364     bl->target_info.persist = 1;
2365 }
2366
2367 /* Insert a low-level "breakpoint" of some type.  BL is the breakpoint
2368    location.  Any error messages are printed to TMP_ERROR_STREAM; and
2369    DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2370    Returns 0 for success, 1 if the bp_location type is not supported or
2371    -1 for failure.
2372
2373    NOTE drow/2003-09-09: This routine could be broken down to an
2374    object-style method for each breakpoint or catchpoint type.  */
2375 static int
2376 insert_bp_location (struct bp_location *bl,
2377                     struct ui_file *tmp_error_stream,
2378                     int *disabled_breaks,
2379                     int *hw_breakpoint_error,
2380                     int *hw_bp_error_explained_already)
2381 {
2382   int val = 0;
2383   char *hw_bp_err_string = NULL;
2384   struct gdb_exception e;
2385
2386   if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2387     return 0;
2388
2389   /* Note we don't initialize bl->target_info, as that wipes out
2390      the breakpoint location's shadow_contents if the breakpoint
2391      is still inserted at that location.  This in turn breaks
2392      target_read_memory which depends on these buffers when
2393      a memory read is requested at the breakpoint location:
2394      Once the target_info has been wiped, we fail to see that
2395      we have a breakpoint inserted at that address and thus
2396      read the breakpoint instead of returning the data saved in
2397      the breakpoint location's shadow contents.  */
2398   bl->target_info.placed_address = bl->address;
2399   bl->target_info.placed_address_space = bl->pspace->aspace;
2400   bl->target_info.length = bl->length;
2401
2402   /* When working with target-side conditions, we must pass all the conditions
2403      for the same breakpoint address down to the target since GDB will not
2404      insert those locations.  With a list of breakpoint conditions, the target
2405      can decide when to stop and notify GDB.  */
2406
2407   if (is_breakpoint (bl->owner))
2408     {
2409       build_target_condition_list (bl);
2410       build_target_command_list (bl);
2411       /* Reset the modification marker.  */
2412       bl->needs_update = 0;
2413     }
2414
2415   if (bl->loc_type == bp_loc_software_breakpoint
2416       || bl->loc_type == bp_loc_hardware_breakpoint)
2417     {
2418       if (bl->owner->type != bp_hardware_breakpoint)
2419         {
2420           /* If the explicitly specified breakpoint type
2421              is not hardware breakpoint, check the memory map to see
2422              if the breakpoint address is in read only memory or not.
2423
2424              Two important cases are:
2425              - location type is not hardware breakpoint, memory
2426              is readonly.  We change the type of the location to
2427              hardware breakpoint.
2428              - location type is hardware breakpoint, memory is
2429              read-write.  This means we've previously made the
2430              location hardware one, but then the memory map changed,
2431              so we undo.
2432              
2433              When breakpoints are removed, remove_breakpoints will use
2434              location types we've just set here, the only possible
2435              problem is that memory map has changed during running
2436              program, but it's not going to work anyway with current
2437              gdb.  */
2438           struct mem_region *mr 
2439             = lookup_mem_region (bl->target_info.placed_address);
2440           
2441           if (mr)
2442             {
2443               if (automatic_hardware_breakpoints)
2444                 {
2445                   enum bp_loc_type new_type;
2446                   
2447                   if (mr->attrib.mode != MEM_RW)
2448                     new_type = bp_loc_hardware_breakpoint;
2449                   else 
2450                     new_type = bp_loc_software_breakpoint;
2451                   
2452                   if (new_type != bl->loc_type)
2453                     {
2454                       static int said = 0;
2455
2456                       bl->loc_type = new_type;
2457                       if (!said)
2458                         {
2459                           fprintf_filtered (gdb_stdout,
2460                                             _("Note: automatically using "
2461                                               "hardware breakpoints for "
2462                                               "read-only addresses.\n"));
2463                           said = 1;
2464                         }
2465                     }
2466                 }
2467               else if (bl->loc_type == bp_loc_software_breakpoint
2468                        && mr->attrib.mode != MEM_RW)        
2469                 warning (_("cannot set software breakpoint "
2470                            "at readonly address %s"),
2471                          paddress (bl->gdbarch, bl->address));
2472             }
2473         }
2474         
2475       /* First check to see if we have to handle an overlay.  */
2476       if (overlay_debugging == ovly_off
2477           || bl->section == NULL
2478           || !(section_is_overlay (bl->section)))
2479         {
2480           /* No overlay handling: just set the breakpoint.  */
2481           TRY_CATCH (e, RETURN_MASK_ALL)
2482             {
2483               val = bl->owner->ops->insert_location (bl);
2484             }
2485           if (e.reason < 0)
2486             {
2487               val = 1;
2488               hw_bp_err_string = (char *) e.message;
2489             }
2490         }
2491       else
2492         {
2493           /* This breakpoint is in an overlay section.
2494              Shall we set a breakpoint at the LMA?  */
2495           if (!overlay_events_enabled)
2496             {
2497               /* Yes -- overlay event support is not active, 
2498                  so we must try to set a breakpoint at the LMA.
2499                  This will not work for a hardware breakpoint.  */
2500               if (bl->loc_type == bp_loc_hardware_breakpoint)
2501                 warning (_("hardware breakpoint %d not supported in overlay!"),
2502                          bl->owner->number);
2503               else
2504                 {
2505                   CORE_ADDR addr = overlay_unmapped_address (bl->address,
2506                                                              bl->section);
2507                   /* Set a software (trap) breakpoint at the LMA.  */
2508                   bl->overlay_target_info = bl->target_info;
2509                   bl->overlay_target_info.placed_address = addr;
2510                   val = target_insert_breakpoint (bl->gdbarch,
2511                                                   &bl->overlay_target_info);
2512                   if (val != 0)
2513                     fprintf_unfiltered (tmp_error_stream,
2514                                         "Overlay breakpoint %d "
2515                                         "failed: in ROM?\n",
2516                                         bl->owner->number);
2517                 }
2518             }
2519           /* Shall we set a breakpoint at the VMA? */
2520           if (section_is_mapped (bl->section))
2521             {
2522               /* Yes.  This overlay section is mapped into memory.  */
2523               TRY_CATCH (e, RETURN_MASK_ALL)
2524                 {
2525                   val = bl->owner->ops->insert_location (bl);
2526                 }
2527               if (e.reason < 0)
2528                 {
2529                   val = 1;
2530                   hw_bp_err_string = (char *) e.message;
2531                 }
2532             }
2533           else
2534             {
2535               /* No.  This breakpoint will not be inserted.  
2536                  No error, but do not mark the bp as 'inserted'.  */
2537               return 0;
2538             }
2539         }
2540
2541       if (val)
2542         {
2543           /* Can't set the breakpoint.  */
2544           if (solib_name_from_address (bl->pspace, bl->address))
2545             {
2546               /* See also: disable_breakpoints_in_shlibs.  */
2547               val = 0;
2548               bl->shlib_disabled = 1;
2549               observer_notify_breakpoint_modified (bl->owner);
2550               if (!*disabled_breaks)
2551                 {
2552                   fprintf_unfiltered (tmp_error_stream, 
2553                                       "Cannot insert breakpoint %d.\n", 
2554                                       bl->owner->number);
2555                   fprintf_unfiltered (tmp_error_stream, 
2556                                       "Temporarily disabling shared "
2557                                       "library breakpoints:\n");
2558                 }
2559               *disabled_breaks = 1;
2560               fprintf_unfiltered (tmp_error_stream,
2561                                   "breakpoint #%d\n", bl->owner->number);
2562             }
2563           else
2564             {
2565               if (bl->loc_type == bp_loc_hardware_breakpoint)
2566                 {
2567                   *hw_breakpoint_error = 1;
2568                   *hw_bp_error_explained_already = hw_bp_err_string != NULL;
2569                   fprintf_unfiltered (tmp_error_stream,
2570                                       "Cannot insert hardware breakpoint %d%s",
2571                                       bl->owner->number, hw_bp_err_string ? ":" : ".\n");
2572                   if (hw_bp_err_string)
2573                     fprintf_unfiltered (tmp_error_stream, "%s.\n", hw_bp_err_string);
2574                 }
2575               else
2576                 {
2577                   fprintf_unfiltered (tmp_error_stream, 
2578                                       "Cannot insert breakpoint %d.\n", 
2579                                       bl->owner->number);
2580                   fprintf_filtered (tmp_error_stream, 
2581                                     "Error accessing memory address ");
2582                   fputs_filtered (paddress (bl->gdbarch, bl->address),
2583                                   tmp_error_stream);
2584                   fprintf_filtered (tmp_error_stream, ": %s.\n",
2585                                     safe_strerror (val));
2586                 }
2587
2588             }
2589         }
2590       else
2591         bl->inserted = 1;
2592
2593       return val;
2594     }
2595
2596   else if (bl->loc_type == bp_loc_hardware_watchpoint
2597            /* NOTE drow/2003-09-08: This state only exists for removing
2598               watchpoints.  It's not clear that it's necessary...  */
2599            && bl->owner->disposition != disp_del_at_next_stop)
2600     {
2601       gdb_assert (bl->owner->ops != NULL
2602                   && bl->owner->ops->insert_location != NULL);
2603
2604       val = bl->owner->ops->insert_location (bl);
2605
2606       /* If trying to set a read-watchpoint, and it turns out it's not
2607          supported, try emulating one with an access watchpoint.  */
2608       if (val == 1 && bl->watchpoint_type == hw_read)
2609         {
2610           struct bp_location *loc, **loc_temp;
2611
2612           /* But don't try to insert it, if there's already another
2613              hw_access location that would be considered a duplicate
2614              of this one.  */
2615           ALL_BP_LOCATIONS (loc, loc_temp)
2616             if (loc != bl
2617                 && loc->watchpoint_type == hw_access
2618                 && watchpoint_locations_match (bl, loc))
2619               {
2620                 bl->duplicate = 1;
2621                 bl->inserted = 1;
2622                 bl->target_info = loc->target_info;
2623                 bl->watchpoint_type = hw_access;
2624                 val = 0;
2625                 break;
2626               }
2627
2628           if (val == 1)
2629             {
2630               bl->watchpoint_type = hw_access;
2631               val = bl->owner->ops->insert_location (bl);
2632
2633               if (val)
2634                 /* Back to the original value.  */
2635                 bl->watchpoint_type = hw_read;
2636             }
2637         }
2638
2639       bl->inserted = (val == 0);
2640     }
2641
2642   else if (bl->owner->type == bp_catchpoint)
2643     {
2644       gdb_assert (bl->owner->ops != NULL
2645                   && bl->owner->ops->insert_location != NULL);
2646
2647       val = bl->owner->ops->insert_location (bl);
2648       if (val)
2649         {
2650           bl->owner->enable_state = bp_disabled;
2651
2652           if (val == 1)
2653             warning (_("\
2654 Error inserting catchpoint %d: Your system does not support this type\n\
2655 of catchpoint."), bl->owner->number);
2656           else
2657             warning (_("Error inserting catchpoint %d."), bl->owner->number);
2658         }
2659
2660       bl->inserted = (val == 0);
2661
2662       /* We've already printed an error message if there was a problem
2663          inserting this catchpoint, and we've disabled the catchpoint,
2664          so just return success.  */
2665       return 0;
2666     }
2667
2668   return 0;
2669 }
2670
2671 /* This function is called when program space PSPACE is about to be
2672    deleted.  It takes care of updating breakpoints to not reference
2673    PSPACE anymore.  */
2674
2675 void
2676 breakpoint_program_space_exit (struct program_space *pspace)
2677 {
2678   struct breakpoint *b, *b_temp;
2679   struct bp_location *loc, **loc_temp;
2680
2681   /* Remove any breakpoint that was set through this program space.  */
2682   ALL_BREAKPOINTS_SAFE (b, b_temp)
2683     {
2684       if (b->pspace == pspace)
2685         delete_breakpoint (b);
2686     }
2687
2688   /* Breakpoints set through other program spaces could have locations
2689      bound to PSPACE as well.  Remove those.  */
2690   ALL_BP_LOCATIONS (loc, loc_temp)
2691     {
2692       struct bp_location *tmp;
2693
2694       if (loc->pspace == pspace)
2695         {
2696           /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
2697           if (loc->owner->loc == loc)
2698             loc->owner->loc = loc->next;
2699           else
2700             for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
2701               if (tmp->next == loc)
2702                 {
2703                   tmp->next = loc->next;
2704                   break;
2705                 }
2706         }
2707     }
2708
2709   /* Now update the global location list to permanently delete the
2710      removed locations above.  */
2711   update_global_location_list (0);
2712 }
2713
2714 /* Make sure all breakpoints are inserted in inferior.
2715    Throws exception on any error.
2716    A breakpoint that is already inserted won't be inserted
2717    again, so calling this function twice is safe.  */
2718 void
2719 insert_breakpoints (void)
2720 {
2721   struct breakpoint *bpt;
2722
2723   ALL_BREAKPOINTS (bpt)
2724     if (is_hardware_watchpoint (bpt))
2725       {
2726         struct watchpoint *w = (struct watchpoint *) bpt;
2727
2728         update_watchpoint (w, 0 /* don't reparse.  */);
2729       }
2730
2731   update_global_location_list (1);
2732
2733   /* update_global_location_list does not insert breakpoints when
2734      always_inserted_mode is not enabled.  Explicitly insert them
2735      now.  */
2736   if (!breakpoints_always_inserted_mode ())
2737     insert_breakpoint_locations ();
2738 }
2739
2740 /* Invoke CALLBACK for each of bp_location.  */
2741
2742 void
2743 iterate_over_bp_locations (walk_bp_location_callback callback)
2744 {
2745   struct bp_location *loc, **loc_tmp;
2746
2747   ALL_BP_LOCATIONS (loc, loc_tmp)
2748     {
2749       callback (loc, NULL);
2750     }
2751 }
2752
2753 /* This is used when we need to synch breakpoint conditions between GDB and the
2754    target.  It is the case with deleting and disabling of breakpoints when using
2755    always-inserted mode.  */
2756
2757 static void
2758 update_inserted_breakpoint_locations (void)
2759 {
2760   struct bp_location *bl, **blp_tmp;
2761   int error_flag = 0;
2762   int val = 0;
2763   int disabled_breaks = 0;
2764   int hw_breakpoint_error = 0;
2765   int hw_bp_details_reported = 0;
2766
2767   struct ui_file *tmp_error_stream = mem_fileopen ();
2768   struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
2769
2770   /* Explicitly mark the warning -- this will only be printed if
2771      there was an error.  */
2772   fprintf_unfiltered (tmp_error_stream, "Warning:\n");
2773
2774   save_current_space_and_thread ();
2775
2776   ALL_BP_LOCATIONS (bl, blp_tmp)
2777     {
2778       /* We only want to update software breakpoints and hardware
2779          breakpoints.  */
2780       if (!is_breakpoint (bl->owner))
2781         continue;
2782
2783       /* We only want to update locations that are already inserted
2784          and need updating.  This is to avoid unwanted insertion during
2785          deletion of breakpoints.  */
2786       if (!bl->inserted || (bl->inserted && !bl->needs_update))
2787         continue;
2788
2789       switch_to_program_space_and_thread (bl->pspace);
2790
2791       /* For targets that support global breakpoints, there's no need
2792          to select an inferior to insert breakpoint to.  In fact, even
2793          if we aren't attached to any process yet, we should still
2794          insert breakpoints.  */
2795       if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2796           && ptid_equal (inferior_ptid, null_ptid))
2797         continue;
2798
2799       val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
2800                                     &hw_breakpoint_error, &hw_bp_details_reported);
2801       if (val)
2802         error_flag = val;
2803     }
2804
2805   if (error_flag)
2806     {
2807       target_terminal_ours_for_output ();
2808       error_stream (tmp_error_stream);
2809     }
2810
2811   do_cleanups (cleanups);
2812 }
2813
2814 /* Used when starting or continuing the program.  */
2815
2816 static void
2817 insert_breakpoint_locations (void)
2818 {
2819   struct breakpoint *bpt;
2820   struct bp_location *bl, **blp_tmp;
2821   int error_flag = 0;
2822   int val = 0;
2823   int disabled_breaks = 0;
2824   int hw_breakpoint_error = 0;
2825   int hw_bp_error_explained_already = 0;
2826
2827   struct ui_file *tmp_error_stream = mem_fileopen ();
2828   struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
2829   
2830   /* Explicitly mark the warning -- this will only be printed if
2831      there was an error.  */
2832   fprintf_unfiltered (tmp_error_stream, "Warning:\n");
2833
2834   save_current_space_and_thread ();
2835
2836   ALL_BP_LOCATIONS (bl, blp_tmp)
2837     {
2838       if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2839         continue;
2840
2841       /* There is no point inserting thread-specific breakpoints if
2842          the thread no longer exists.  ALL_BP_LOCATIONS bp_location
2843          has BL->OWNER always non-NULL.  */
2844       if (bl->owner->thread != -1
2845           && !valid_thread_id (bl->owner->thread))
2846         continue;
2847
2848       switch_to_program_space_and_thread (bl->pspace);
2849
2850       /* For targets that support global breakpoints, there's no need
2851          to select an inferior to insert breakpoint to.  In fact, even
2852          if we aren't attached to any process yet, we should still
2853          insert breakpoints.  */
2854       if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2855           && ptid_equal (inferior_ptid, null_ptid))
2856         continue;
2857
2858       val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
2859                                     &hw_breakpoint_error, &hw_bp_error_explained_already);
2860       if (val)
2861         error_flag = val;
2862     }
2863
2864   /* If we failed to insert all locations of a watchpoint, remove
2865      them, as half-inserted watchpoint is of limited use.  */
2866   ALL_BREAKPOINTS (bpt)  
2867     {
2868       int some_failed = 0;
2869       struct bp_location *loc;
2870
2871       if (!is_hardware_watchpoint (bpt))
2872         continue;
2873
2874       if (!breakpoint_enabled (bpt))
2875         continue;
2876
2877       if (bpt->disposition == disp_del_at_next_stop)
2878         continue;
2879       
2880       for (loc = bpt->loc; loc; loc = loc->next)
2881         if (!loc->inserted && should_be_inserted (loc))
2882           {
2883             some_failed = 1;
2884             break;
2885           }
2886       if (some_failed)
2887         {
2888           for (loc = bpt->loc; loc; loc = loc->next)
2889             if (loc->inserted)
2890               remove_breakpoint (loc, mark_uninserted);
2891
2892           hw_breakpoint_error = 1;
2893           fprintf_unfiltered (tmp_error_stream,
2894                               "Could not insert hardware watchpoint %d.\n", 
2895                               bpt->number);
2896           error_flag = -1;
2897         }
2898     }
2899
2900   if (error_flag)
2901     {
2902       /* If a hardware breakpoint or watchpoint was inserted, add a
2903          message about possibly exhausted resources.  */
2904       if (hw_breakpoint_error && !hw_bp_error_explained_already)
2905         {
2906           fprintf_unfiltered (tmp_error_stream, 
2907                               "Could not insert hardware breakpoints:\n\
2908 You may have requested too many hardware breakpoints/watchpoints.\n");
2909         }
2910       target_terminal_ours_for_output ();
2911       error_stream (tmp_error_stream);
2912     }
2913
2914   do_cleanups (cleanups);
2915 }
2916
2917 /* Used when the program stops.
2918    Returns zero if successful, or non-zero if there was a problem
2919    removing a breakpoint location.  */
2920
2921 int
2922 remove_breakpoints (void)
2923 {
2924   struct bp_location *bl, **blp_tmp;
2925   int val = 0;
2926
2927   ALL_BP_LOCATIONS (bl, blp_tmp)
2928   {
2929     if (bl->inserted && !is_tracepoint (bl->owner))
2930       val |= remove_breakpoint (bl, mark_uninserted);
2931   }
2932   return val;
2933 }
2934
2935 /* Remove breakpoints of process PID.  */
2936
2937 int
2938 remove_breakpoints_pid (int pid)
2939 {
2940   struct bp_location *bl, **blp_tmp;
2941   int val;
2942   struct inferior *inf = find_inferior_pid (pid);
2943
2944   ALL_BP_LOCATIONS (bl, blp_tmp)
2945   {
2946     if (bl->pspace != inf->pspace)
2947       continue;
2948
2949     if (bl->owner->type == bp_dprintf)
2950       continue;
2951
2952     if (bl->inserted)
2953       {
2954         val = remove_breakpoint (bl, mark_uninserted);
2955         if (val != 0)
2956           return val;
2957       }
2958   }
2959   return 0;
2960 }
2961
2962 int
2963 reattach_breakpoints (int pid)
2964 {
2965   struct cleanup *old_chain;
2966   struct bp_location *bl, **blp_tmp;
2967   int val;
2968   struct ui_file *tmp_error_stream;
2969   int dummy1 = 0, dummy2 = 0, dummy3 = 0;
2970   struct inferior *inf;
2971   struct thread_info *tp;
2972
2973   tp = any_live_thread_of_process (pid);
2974   if (tp == NULL)
2975     return 1;
2976
2977   inf = find_inferior_pid (pid);
2978   old_chain = save_inferior_ptid ();
2979
2980   inferior_ptid = tp->ptid;
2981
2982   tmp_error_stream = mem_fileopen ();
2983   make_cleanup_ui_file_delete (tmp_error_stream);
2984
2985   ALL_BP_LOCATIONS (bl, blp_tmp)
2986   {
2987     if (bl->pspace != inf->pspace)
2988       continue;
2989
2990     if (bl->inserted)
2991       {
2992         bl->inserted = 0;
2993         val = insert_bp_location (bl, tmp_error_stream, &dummy1, &dummy2, &dummy3);
2994         if (val != 0)
2995           {
2996             do_cleanups (old_chain);
2997             return val;
2998           }
2999       }
3000   }
3001   do_cleanups (old_chain);
3002   return 0;
3003 }
3004
3005 static int internal_breakpoint_number = -1;
3006
3007 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3008    If INTERNAL is non-zero, the breakpoint number will be populated
3009    from internal_breakpoint_number and that variable decremented.
3010    Otherwise the breakpoint number will be populated from
3011    breakpoint_count and that value incremented.  Internal breakpoints
3012    do not set the internal var bpnum.  */
3013 static void
3014 set_breakpoint_number (int internal, struct breakpoint *b)
3015 {
3016   if (internal)
3017     b->number = internal_breakpoint_number--;
3018   else
3019     {
3020       set_breakpoint_count (breakpoint_count + 1);
3021       b->number = breakpoint_count;
3022     }
3023 }
3024
3025 static struct breakpoint *
3026 create_internal_breakpoint (struct gdbarch *gdbarch,
3027                             CORE_ADDR address, enum bptype type,
3028                             const struct breakpoint_ops *ops)
3029 {
3030   struct symtab_and_line sal;
3031   struct breakpoint *b;
3032
3033   init_sal (&sal);              /* Initialize to zeroes.  */
3034
3035   sal.pc = address;
3036   sal.section = find_pc_overlay (sal.pc);
3037   sal.pspace = current_program_space;
3038
3039   b = set_raw_breakpoint (gdbarch, sal, type, ops);
3040   b->number = internal_breakpoint_number--;
3041   b->disposition = disp_donttouch;
3042
3043   return b;
3044 }
3045
3046 static const char *const longjmp_names[] =
3047   {
3048     "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3049   };
3050 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3051
3052 /* Per-objfile data private to breakpoint.c.  */
3053 struct breakpoint_objfile_data
3054 {
3055   /* Minimal symbol for "_ovly_debug_event" (if any).  */
3056   struct minimal_symbol *overlay_msym;
3057
3058   /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any).  */
3059   struct minimal_symbol *longjmp_msym[NUM_LONGJMP_NAMES];
3060
3061   /* True if we have looked for longjmp probes.  */
3062   int longjmp_searched;
3063
3064   /* SystemTap probe points for longjmp (if any).  */
3065   VEC (probe_p) *longjmp_probes;
3066
3067   /* Minimal symbol for "std::terminate()" (if any).  */
3068   struct minimal_symbol *terminate_msym;
3069
3070   /* Minimal symbol for "_Unwind_DebugHook" (if any).  */
3071   struct minimal_symbol *exception_msym;
3072
3073   /* True if we have looked for exception probes.  */
3074   int exception_searched;
3075
3076   /* SystemTap probe points for unwinding (if any).  */
3077   VEC (probe_p) *exception_probes;
3078 };
3079
3080 static const struct objfile_data *breakpoint_objfile_key;
3081
3082 /* Minimal symbol not found sentinel.  */
3083 static struct minimal_symbol msym_not_found;
3084
3085 /* Returns TRUE if MSYM point to the "not found" sentinel.  */
3086
3087 static int
3088 msym_not_found_p (const struct minimal_symbol *msym)
3089 {
3090   return msym == &msym_not_found;
3091 }
3092
3093 /* Return per-objfile data needed by breakpoint.c.
3094    Allocate the data if necessary.  */
3095
3096 static struct breakpoint_objfile_data *
3097 get_breakpoint_objfile_data (struct objfile *objfile)
3098 {
3099   struct breakpoint_objfile_data *bp_objfile_data;
3100
3101   bp_objfile_data = objfile_data (objfile, breakpoint_objfile_key);
3102   if (bp_objfile_data == NULL)
3103     {
3104       bp_objfile_data = obstack_alloc (&objfile->objfile_obstack,
3105                                        sizeof (*bp_objfile_data));
3106
3107       memset (bp_objfile_data, 0, sizeof (*bp_objfile_data));
3108       set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
3109     }
3110   return bp_objfile_data;
3111 }
3112
3113 static void
3114 free_breakpoint_probes (struct objfile *obj, void *data)
3115 {
3116   struct breakpoint_objfile_data *bp_objfile_data = data;
3117
3118   VEC_free (probe_p, bp_objfile_data->longjmp_probes);
3119   VEC_free (probe_p, bp_objfile_data->exception_probes);
3120 }
3121
3122 static void
3123 create_overlay_event_breakpoint (void)
3124 {
3125   struct objfile *objfile;
3126   const char *const func_name = "_ovly_debug_event";
3127
3128   ALL_OBJFILES (objfile)
3129     {
3130       struct breakpoint *b;
3131       struct breakpoint_objfile_data *bp_objfile_data;
3132       CORE_ADDR addr;
3133
3134       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3135
3136       if (msym_not_found_p (bp_objfile_data->overlay_msym))
3137         continue;
3138
3139       if (bp_objfile_data->overlay_msym == NULL)
3140         {
3141           struct minimal_symbol *m;
3142
3143           m = lookup_minimal_symbol_text (func_name, objfile);
3144           if (m == NULL)
3145             {
3146               /* Avoid future lookups in this objfile.  */
3147               bp_objfile_data->overlay_msym = &msym_not_found;
3148               continue;
3149             }
3150           bp_objfile_data->overlay_msym = m;
3151         }
3152
3153       addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
3154       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3155                                       bp_overlay_event,
3156                                       &internal_breakpoint_ops);
3157       b->addr_string = xstrdup (func_name);
3158
3159       if (overlay_debugging == ovly_auto)
3160         {
3161           b->enable_state = bp_enabled;
3162           overlay_events_enabled = 1;
3163         }
3164       else
3165        {
3166          b->enable_state = bp_disabled;
3167          overlay_events_enabled = 0;
3168        }
3169     }
3170   update_global_location_list (1);
3171 }
3172
3173 static void
3174 create_longjmp_master_breakpoint (void)
3175 {
3176   struct program_space *pspace;
3177   struct cleanup *old_chain;
3178
3179   old_chain = save_current_program_space ();
3180
3181   ALL_PSPACES (pspace)
3182   {
3183     struct objfile *objfile;
3184
3185     set_current_program_space (pspace);
3186
3187     ALL_OBJFILES (objfile)
3188     {
3189       int i;
3190       struct gdbarch *gdbarch;
3191       struct breakpoint_objfile_data *bp_objfile_data;
3192
3193       gdbarch = get_objfile_arch (objfile);
3194       if (!gdbarch_get_longjmp_target_p (gdbarch))
3195         continue;
3196
3197       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3198
3199       if (!bp_objfile_data->longjmp_searched)
3200         {
3201           bp_objfile_data->longjmp_probes
3202             = find_probes_in_objfile (objfile, "libc", "longjmp");
3203           bp_objfile_data->longjmp_searched = 1;
3204         }
3205
3206       if (bp_objfile_data->longjmp_probes != NULL)
3207         {
3208           int i;
3209           struct probe *probe;
3210           struct gdbarch *gdbarch = get_objfile_arch (objfile);
3211
3212           for (i = 0;
3213                VEC_iterate (probe_p,
3214                             bp_objfile_data->longjmp_probes,
3215                             i, probe);
3216                ++i)
3217             {
3218               struct breakpoint *b;
3219
3220               b = create_internal_breakpoint (gdbarch, probe->address,
3221                                               bp_longjmp_master,
3222                                               &internal_breakpoint_ops);
3223               b->addr_string = xstrdup ("-probe-stap libc:longjmp");
3224               b->enable_state = bp_disabled;
3225             }
3226
3227           continue;
3228         }
3229
3230       for (i = 0; i < NUM_LONGJMP_NAMES; i++)
3231         {
3232           struct breakpoint *b;
3233           const char *func_name;
3234           CORE_ADDR addr;
3235
3236           if (msym_not_found_p (bp_objfile_data->longjmp_msym[i]))
3237             continue;
3238
3239           func_name = longjmp_names[i];
3240           if (bp_objfile_data->longjmp_msym[i] == NULL)
3241             {
3242               struct minimal_symbol *m;
3243
3244               m = lookup_minimal_symbol_text (func_name, objfile);
3245               if (m == NULL)
3246                 {
3247                   /* Prevent future lookups in this objfile.  */
3248                   bp_objfile_data->longjmp_msym[i] = &msym_not_found;
3249                   continue;
3250                 }
3251               bp_objfile_data->longjmp_msym[i] = m;
3252             }
3253
3254           addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
3255           b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3256                                           &internal_breakpoint_ops);
3257           b->addr_string = xstrdup (func_name);
3258           b->enable_state = bp_disabled;
3259         }
3260     }
3261   }
3262   update_global_location_list (1);
3263
3264   do_cleanups (old_chain);
3265 }
3266
3267 /* Create a master std::terminate breakpoint.  */
3268 static void
3269 create_std_terminate_master_breakpoint (void)
3270 {
3271   struct program_space *pspace;
3272   struct cleanup *old_chain;
3273   const char *const func_name = "std::terminate()";
3274
3275   old_chain = save_current_program_space ();
3276
3277   ALL_PSPACES (pspace)
3278   {
3279     struct objfile *objfile;
3280     CORE_ADDR addr;
3281
3282     set_current_program_space (pspace);
3283
3284     ALL_OBJFILES (objfile)
3285     {
3286       struct breakpoint *b;
3287       struct breakpoint_objfile_data *bp_objfile_data;
3288
3289       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3290
3291       if (msym_not_found_p (bp_objfile_data->terminate_msym))
3292         continue;
3293
3294       if (bp_objfile_data->terminate_msym == NULL)
3295         {
3296           struct minimal_symbol *m;
3297
3298           m = lookup_minimal_symbol (func_name, NULL, objfile);
3299           if (m == NULL || (MSYMBOL_TYPE (m) != mst_text
3300                             && MSYMBOL_TYPE (m) != mst_file_text))
3301             {
3302               /* Prevent future lookups in this objfile.  */
3303               bp_objfile_data->terminate_msym = &msym_not_found;
3304               continue;
3305             }
3306           bp_objfile_data->terminate_msym = m;
3307         }
3308
3309       addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
3310       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3311                                       bp_std_terminate_master,
3312                                       &internal_breakpoint_ops);
3313       b->addr_string = xstrdup (func_name);
3314       b->enable_state = bp_disabled;
3315     }
3316   }
3317
3318   update_global_location_list (1);
3319
3320   do_cleanups (old_chain);
3321 }
3322
3323 /* Install a master breakpoint on the unwinder's debug hook.  */
3324
3325 static void
3326 create_exception_master_breakpoint (void)
3327 {
3328   struct objfile *objfile;
3329   const char *const func_name = "_Unwind_DebugHook";
3330
3331   ALL_OBJFILES (objfile)
3332     {
3333       struct breakpoint *b;
3334       struct gdbarch *gdbarch;
3335       struct breakpoint_objfile_data *bp_objfile_data;
3336       CORE_ADDR addr;
3337
3338       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3339
3340       /* We prefer the SystemTap probe point if it exists.  */
3341       if (!bp_objfile_data->exception_searched)
3342         {
3343           bp_objfile_data->exception_probes
3344             = find_probes_in_objfile (objfile, "libgcc", "unwind");
3345           bp_objfile_data->exception_searched = 1;
3346         }
3347
3348       if (bp_objfile_data->exception_probes != NULL)
3349         {
3350           struct gdbarch *gdbarch = get_objfile_arch (objfile);
3351           int i;
3352           struct probe *probe;
3353
3354           for (i = 0;
3355                VEC_iterate (probe_p,
3356                             bp_objfile_data->exception_probes,
3357                             i, probe);
3358                ++i)
3359             {
3360               struct breakpoint *b;
3361
3362               b = create_internal_breakpoint (gdbarch, probe->address,
3363                                               bp_exception_master,
3364                                               &internal_breakpoint_ops);
3365               b->addr_string = xstrdup ("-probe-stap libgcc:unwind");
3366               b->enable_state = bp_disabled;
3367             }
3368
3369           continue;
3370         }
3371
3372       /* Otherwise, try the hook function.  */
3373
3374       if (msym_not_found_p (bp_objfile_data->exception_msym))
3375         continue;
3376
3377       gdbarch = get_objfile_arch (objfile);
3378
3379       if (bp_objfile_data->exception_msym == NULL)
3380         {
3381           struct minimal_symbol *debug_hook;
3382
3383           debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3384           if (debug_hook == NULL)
3385             {
3386               bp_objfile_data->exception_msym = &msym_not_found;
3387               continue;
3388             }
3389
3390           bp_objfile_data->exception_msym = debug_hook;
3391         }
3392
3393       addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
3394       addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3395                                                  &current_target);
3396       b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3397                                       &internal_breakpoint_ops);
3398       b->addr_string = xstrdup (func_name);
3399       b->enable_state = bp_disabled;
3400     }
3401
3402   update_global_location_list (1);
3403 }
3404
3405 void
3406 update_breakpoints_after_exec (void)
3407 {
3408   struct breakpoint *b, *b_tmp;
3409   struct bp_location *bploc, **bplocp_tmp;
3410
3411   /* We're about to delete breakpoints from GDB's lists.  If the
3412      INSERTED flag is true, GDB will try to lift the breakpoints by
3413      writing the breakpoints' "shadow contents" back into memory.  The
3414      "shadow contents" are NOT valid after an exec, so GDB should not
3415      do that.  Instead, the target is responsible from marking
3416      breakpoints out as soon as it detects an exec.  We don't do that
3417      here instead, because there may be other attempts to delete
3418      breakpoints after detecting an exec and before reaching here.  */
3419   ALL_BP_LOCATIONS (bploc, bplocp_tmp)
3420     if (bploc->pspace == current_program_space)
3421       gdb_assert (!bploc->inserted);
3422
3423   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3424   {
3425     if (b->pspace != current_program_space)
3426       continue;
3427
3428     /* Solib breakpoints must be explicitly reset after an exec().  */
3429     if (b->type == bp_shlib_event)
3430       {
3431         delete_breakpoint (b);
3432         continue;
3433       }
3434
3435     /* JIT breakpoints must be explicitly reset after an exec().  */
3436     if (b->type == bp_jit_event)
3437       {
3438         delete_breakpoint (b);
3439         continue;
3440       }
3441
3442     /* Thread event breakpoints must be set anew after an exec(),
3443        as must overlay event and longjmp master breakpoints.  */
3444     if (b->type == bp_thread_event || b->type == bp_overlay_event
3445         || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3446         || b->type == bp_exception_master)
3447       {
3448         delete_breakpoint (b);
3449         continue;
3450       }
3451
3452     /* Step-resume breakpoints are meaningless after an exec().  */
3453     if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
3454       {
3455         delete_breakpoint (b);
3456         continue;
3457       }
3458
3459     /* Longjmp and longjmp-resume breakpoints are also meaningless
3460        after an exec.  */
3461     if (b->type == bp_longjmp || b->type == bp_longjmp_resume
3462         || b->type == bp_longjmp_call_dummy
3463         || b->type == bp_exception || b->type == bp_exception_resume)
3464       {
3465         delete_breakpoint (b);
3466         continue;
3467       }
3468
3469     if (b->type == bp_catchpoint)
3470       {
3471         /* For now, none of the bp_catchpoint breakpoints need to
3472            do anything at this point.  In the future, if some of
3473            the catchpoints need to something, we will need to add
3474            a new method, and call this method from here.  */
3475         continue;
3476       }
3477
3478     /* bp_finish is a special case.  The only way we ought to be able
3479        to see one of these when an exec() has happened, is if the user
3480        caught a vfork, and then said "finish".  Ordinarily a finish just
3481        carries them to the call-site of the current callee, by setting
3482        a temporary bp there and resuming.  But in this case, the finish
3483        will carry them entirely through the vfork & exec.
3484
3485        We don't want to allow a bp_finish to remain inserted now.  But
3486        we can't safely delete it, 'cause finish_command has a handle to
3487        the bp on a bpstat, and will later want to delete it.  There's a
3488        chance (and I've seen it happen) that if we delete the bp_finish
3489        here, that its storage will get reused by the time finish_command
3490        gets 'round to deleting the "use to be a bp_finish" breakpoint.
3491        We really must allow finish_command to delete a bp_finish.
3492
3493        In the absence of a general solution for the "how do we know
3494        it's safe to delete something others may have handles to?"
3495        problem, what we'll do here is just uninsert the bp_finish, and
3496        let finish_command delete it.
3497
3498        (We know the bp_finish is "doomed" in the sense that it's
3499        momentary, and will be deleted as soon as finish_command sees
3500        the inferior stopped.  So it doesn't matter that the bp's
3501        address is probably bogus in the new a.out, unlike e.g., the
3502        solib breakpoints.)  */
3503
3504     if (b->type == bp_finish)
3505       {
3506         continue;
3507       }
3508
3509     /* Without a symbolic address, we have little hope of the
3510        pre-exec() address meaning the same thing in the post-exec()
3511        a.out.  */
3512     if (b->addr_string == NULL)
3513       {
3514         delete_breakpoint (b);
3515         continue;
3516       }
3517   }
3518   /* FIXME what about longjmp breakpoints?  Re-create them here?  */
3519   create_overlay_event_breakpoint ();
3520   create_longjmp_master_breakpoint ();
3521   create_std_terminate_master_breakpoint ();
3522   create_exception_master_breakpoint ();
3523 }
3524
3525 int
3526 detach_breakpoints (ptid_t ptid)
3527 {
3528   struct bp_location *bl, **blp_tmp;
3529   int val = 0;
3530   struct cleanup *old_chain = save_inferior_ptid ();
3531   struct inferior *inf = current_inferior ();
3532
3533   if (PIDGET (ptid) == PIDGET (inferior_ptid))
3534     error (_("Cannot detach breakpoints of inferior_ptid"));
3535
3536   /* Set inferior_ptid; remove_breakpoint_1 uses this global.  */
3537   inferior_ptid = ptid;
3538   ALL_BP_LOCATIONS (bl, blp_tmp)
3539   {
3540     if (bl->pspace != inf->pspace)
3541       continue;
3542
3543     if (bl->inserted)
3544       val |= remove_breakpoint_1 (bl, mark_inserted);
3545   }
3546
3547   /* Detach single-step breakpoints as well.  */
3548   detach_single_step_breakpoints ();
3549
3550   do_cleanups (old_chain);
3551   return val;
3552 }
3553
3554 /* Remove the breakpoint location BL from the current address space.
3555    Note that this is used to detach breakpoints from a child fork.
3556    When we get here, the child isn't in the inferior list, and neither
3557    do we have objects to represent its address space --- we should
3558    *not* look at bl->pspace->aspace here.  */
3559
3560 static int
3561 remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is)
3562 {
3563   int val;
3564
3565   /* BL is never in moribund_locations by our callers.  */
3566   gdb_assert (bl->owner != NULL);
3567
3568   if (bl->owner->enable_state == bp_permanent)
3569     /* Permanent breakpoints cannot be inserted or removed.  */
3570     return 0;
3571
3572   /* The type of none suggests that owner is actually deleted.
3573      This should not ever happen.  */
3574   gdb_assert (bl->owner->type != bp_none);
3575
3576   if (bl->loc_type == bp_loc_software_breakpoint
3577       || bl->loc_type == bp_loc_hardware_breakpoint)
3578     {
3579       /* "Normal" instruction breakpoint: either the standard
3580          trap-instruction bp (bp_breakpoint), or a
3581          bp_hardware_breakpoint.  */
3582
3583       /* First check to see if we have to handle an overlay.  */
3584       if (overlay_debugging == ovly_off
3585           || bl->section == NULL
3586           || !(section_is_overlay (bl->section)))
3587         {
3588           /* No overlay handling: just remove the breakpoint.  */
3589           val = bl->owner->ops->remove_location (bl);
3590         }
3591       else
3592         {
3593           /* This breakpoint is in an overlay section.
3594              Did we set a breakpoint at the LMA?  */
3595           if (!overlay_events_enabled)
3596               {
3597                 /* Yes -- overlay event support is not active, so we
3598                    should have set a breakpoint at the LMA.  Remove it.  
3599                 */
3600                 /* Ignore any failures: if the LMA is in ROM, we will
3601                    have already warned when we failed to insert it.  */
3602                 if (bl->loc_type == bp_loc_hardware_breakpoint)
3603                   target_remove_hw_breakpoint (bl->gdbarch,
3604                                                &bl->overlay_target_info);
3605                 else
3606                   target_remove_breakpoint (bl->gdbarch,
3607                                             &bl->overlay_target_info);
3608               }
3609           /* Did we set a breakpoint at the VMA? 
3610              If so, we will have marked the breakpoint 'inserted'.  */
3611           if (bl->inserted)
3612             {
3613               /* Yes -- remove it.  Previously we did not bother to
3614                  remove the breakpoint if the section had been
3615                  unmapped, but let's not rely on that being safe.  We
3616                  don't know what the overlay manager might do.  */
3617
3618               /* However, we should remove *software* breakpoints only
3619                  if the section is still mapped, or else we overwrite
3620                  wrong code with the saved shadow contents.  */
3621               if (bl->loc_type == bp_loc_hardware_breakpoint
3622                   || section_is_mapped (bl->section))
3623                 val = bl->owner->ops->remove_location (bl);
3624               else
3625                 val = 0;
3626             }
3627           else
3628             {
3629               /* No -- not inserted, so no need to remove.  No error.  */
3630               val = 0;
3631             }
3632         }
3633
3634       /* In some cases, we might not be able to remove a breakpoint
3635          in a shared library that has already been removed, but we
3636          have not yet processed the shlib unload event.  */
3637       if (val && solib_name_from_address (bl->pspace, bl->address))
3638         val = 0;
3639
3640       if (val)
3641         return val;
3642       bl->inserted = (is == mark_inserted);
3643     }
3644   else if (bl->loc_type == bp_loc_hardware_watchpoint)
3645     {
3646       gdb_assert (bl->owner->ops != NULL
3647                   && bl->owner->ops->remove_location != NULL);
3648
3649       bl->inserted = (is == mark_inserted);
3650       bl->owner->ops->remove_location (bl);
3651
3652       /* Failure to remove any of the hardware watchpoints comes here.  */
3653       if ((is == mark_uninserted) && (bl->inserted))
3654         warning (_("Could not remove hardware watchpoint %d."),
3655                  bl->owner->number);
3656     }
3657   else if (bl->owner->type == bp_catchpoint
3658            && breakpoint_enabled (bl->owner)
3659            && !bl->duplicate)
3660     {
3661       gdb_assert (bl->owner->ops != NULL
3662                   && bl->owner->ops->remove_location != NULL);
3663
3664       val = bl->owner->ops->remove_location (bl);
3665       if (val)
3666         return val;
3667
3668       bl->inserted = (is == mark_inserted);
3669     }
3670
3671   return 0;
3672 }
3673
3674 static int
3675 remove_breakpoint (struct bp_location *bl, insertion_state_t is)
3676 {
3677   int ret;
3678   struct cleanup *old_chain;
3679
3680   /* BL is never in moribund_locations by our callers.  */
3681   gdb_assert (bl->owner != NULL);
3682
3683   if (bl->owner->enable_state == bp_permanent)
3684     /* Permanent breakpoints cannot be inserted or removed.  */
3685     return 0;
3686
3687   /* The type of none suggests that owner is actually deleted.
3688      This should not ever happen.  */
3689   gdb_assert (bl->owner->type != bp_none);
3690
3691   old_chain = save_current_space_and_thread ();
3692
3693   switch_to_program_space_and_thread (bl->pspace);
3694
3695   ret = remove_breakpoint_1 (bl, is);
3696
3697   do_cleanups (old_chain);
3698   return ret;
3699 }
3700
3701 /* Clear the "inserted" flag in all breakpoints.  */
3702
3703 void
3704 mark_breakpoints_out (void)
3705 {
3706   struct bp_location *bl, **blp_tmp;
3707
3708   ALL_BP_LOCATIONS (bl, blp_tmp)
3709     if (bl->pspace == current_program_space)
3710       bl->inserted = 0;
3711 }
3712
3713 /* Clear the "inserted" flag in all breakpoints and delete any
3714    breakpoints which should go away between runs of the program.
3715
3716    Plus other such housekeeping that has to be done for breakpoints
3717    between runs.
3718
3719    Note: this function gets called at the end of a run (by
3720    generic_mourn_inferior) and when a run begins (by
3721    init_wait_for_inferior).  */
3722
3723
3724
3725 void
3726 breakpoint_init_inferior (enum inf_context context)
3727 {
3728   struct breakpoint *b, *b_tmp;
3729   struct bp_location *bl, **blp_tmp;
3730   int ix;
3731   struct program_space *pspace = current_program_space;
3732
3733   /* If breakpoint locations are shared across processes, then there's
3734      nothing to do.  */
3735   if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3736     return;
3737
3738   ALL_BP_LOCATIONS (bl, blp_tmp)
3739   {
3740     /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL.  */
3741     if (bl->pspace == pspace
3742         && bl->owner->enable_state != bp_permanent)
3743       bl->inserted = 0;
3744   }
3745
3746   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3747   {
3748     if (b->loc && b->loc->pspace != pspace)
3749       continue;
3750
3751     switch (b->type)
3752       {
3753       case bp_call_dummy:
3754       case bp_longjmp_call_dummy:
3755
3756         /* If the call dummy breakpoint is at the entry point it will
3757            cause problems when the inferior is rerun, so we better get
3758            rid of it.  */
3759
3760       case bp_watchpoint_scope:
3761
3762         /* Also get rid of scope breakpoints.  */
3763
3764       case bp_shlib_event:
3765
3766         /* Also remove solib event breakpoints.  Their addresses may
3767            have changed since the last time we ran the program.
3768            Actually we may now be debugging against different target;
3769            and so the solib backend that installed this breakpoint may
3770            not be used in by the target.  E.g.,
3771
3772            (gdb) file prog-linux
3773            (gdb) run               # native linux target
3774            ...
3775            (gdb) kill
3776            (gdb) file prog-win.exe
3777            (gdb) tar rem :9999     # remote Windows gdbserver.
3778         */
3779
3780       case bp_step_resume:
3781
3782         /* Also remove step-resume breakpoints.  */
3783
3784         delete_breakpoint (b);
3785         break;
3786
3787       case bp_watchpoint:
3788       case bp_hardware_watchpoint:
3789       case bp_read_watchpoint:
3790       case bp_access_watchpoint:
3791         {
3792           struct watchpoint *w = (struct watchpoint *) b;
3793
3794           /* Likewise for watchpoints on local expressions.  */
3795           if (w->exp_valid_block != NULL)
3796             delete_breakpoint (b);
3797           else if (context == inf_starting)
3798             {
3799               /* Reset val field to force reread of starting value in
3800                  insert_breakpoints.  */
3801               if (w->val)
3802                 value_free (w->val);
3803               w->val = NULL;
3804               w->val_valid = 0;
3805           }
3806         }
3807         break;
3808       default:
3809         break;
3810       }
3811   }
3812
3813   /* Get rid of the moribund locations.  */
3814   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
3815     decref_bp_location (&bl);
3816   VEC_free (bp_location_p, moribund_locations);
3817 }
3818
3819 /* These functions concern about actual breakpoints inserted in the
3820    target --- to e.g. check if we need to do decr_pc adjustment or if
3821    we need to hop over the bkpt --- so we check for address space
3822    match, not program space.  */
3823
3824 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3825    exists at PC.  It returns ordinary_breakpoint_here if it's an
3826    ordinary breakpoint, or permanent_breakpoint_here if it's a
3827    permanent breakpoint.
3828    - When continuing from a location with an ordinary breakpoint, we
3829      actually single step once before calling insert_breakpoints.
3830    - When continuing from a location with a permanent breakpoint, we
3831      need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3832      the target, to advance the PC past the breakpoint.  */
3833
3834 enum breakpoint_here
3835 breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
3836 {
3837   struct bp_location *bl, **blp_tmp;
3838   int any_breakpoint_here = 0;
3839
3840   ALL_BP_LOCATIONS (bl, blp_tmp)
3841     {
3842       if (bl->loc_type != bp_loc_software_breakpoint
3843           && bl->loc_type != bp_loc_hardware_breakpoint)
3844         continue;
3845
3846       /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL.  */
3847       if ((breakpoint_enabled (bl->owner)
3848            || bl->owner->enable_state == bp_permanent)
3849           && breakpoint_location_address_match (bl, aspace, pc))
3850         {
3851           if (overlay_debugging 
3852               && section_is_overlay (bl->section)
3853               && !section_is_mapped (bl->section))
3854             continue;           /* unmapped overlay -- can't be a match */
3855           else if (bl->owner->enable_state == bp_permanent)
3856             return permanent_breakpoint_here;
3857           else
3858             any_breakpoint_here = 1;
3859         }
3860     }
3861
3862   return any_breakpoint_here ? ordinary_breakpoint_here : 0;
3863 }
3864
3865 /* Return true if there's a moribund breakpoint at PC.  */
3866
3867 int
3868 moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
3869 {
3870   struct bp_location *loc;
3871   int ix;
3872
3873   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
3874     if (breakpoint_location_address_match (loc, aspace, pc))
3875       return 1;
3876
3877   return 0;
3878 }
3879
3880 /* Returns non-zero if there's a breakpoint inserted at PC, which is
3881    inserted using regular breakpoint_chain / bp_location array
3882    mechanism.  This does not check for single-step breakpoints, which
3883    are inserted and removed using direct target manipulation.  */
3884
3885 int
3886 regular_breakpoint_inserted_here_p (struct address_space *aspace, 
3887                                     CORE_ADDR pc)
3888 {
3889   struct bp_location *bl, **blp_tmp;
3890
3891   ALL_BP_LOCATIONS (bl, blp_tmp)
3892     {
3893       if (bl->loc_type != bp_loc_software_breakpoint
3894           && bl->loc_type != bp_loc_hardware_breakpoint)
3895         continue;
3896
3897       if (bl->inserted
3898           && breakpoint_location_address_match (bl, aspace, pc))
3899         {
3900           if (overlay_debugging 
3901               && section_is_overlay (bl->section)
3902               && !section_is_mapped (bl->section))
3903             continue;           /* unmapped overlay -- can't be a match */
3904           else
3905             return 1;
3906         }
3907     }
3908   return 0;
3909 }
3910
3911 /* Returns non-zero iff there's either regular breakpoint
3912    or a single step breakpoint inserted at PC.  */
3913
3914 int
3915 breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
3916 {
3917   if (regular_breakpoint_inserted_here_p (aspace, pc))
3918     return 1;
3919
3920   if (single_step_breakpoint_inserted_here_p (aspace, pc))
3921     return 1;
3922
3923   return 0;
3924 }
3925
3926 /* This function returns non-zero iff there is a software breakpoint
3927    inserted at PC.  */
3928
3929 int
3930 software_breakpoint_inserted_here_p (struct address_space *aspace,
3931                                      CORE_ADDR pc)
3932 {
3933   struct bp_location *bl, **blp_tmp;
3934
3935   ALL_BP_LOCATIONS (bl, blp_tmp)
3936     {
3937       if (bl->loc_type != bp_loc_software_breakpoint)
3938         continue;
3939
3940       if (bl->inserted
3941           && breakpoint_address_match (bl->pspace->aspace, bl->address,
3942                                        aspace, pc))
3943         {
3944           if (overlay_debugging 
3945               && section_is_overlay (bl->section)
3946               && !section_is_mapped (bl->section))
3947             continue;           /* unmapped overlay -- can't be a match */
3948           else
3949             return 1;
3950         }
3951     }
3952
3953   /* Also check for software single-step breakpoints.  */
3954   if (single_step_breakpoint_inserted_here_p (aspace, pc))
3955     return 1;
3956
3957   return 0;
3958 }
3959
3960 int
3961 hardware_watchpoint_inserted_in_range (struct address_space *aspace,
3962                                        CORE_ADDR addr, ULONGEST len)
3963 {
3964   struct breakpoint *bpt;
3965
3966   ALL_BREAKPOINTS (bpt)
3967     {
3968       struct bp_location *loc;
3969
3970       if (bpt->type != bp_hardware_watchpoint
3971           && bpt->type != bp_access_watchpoint)
3972         continue;
3973
3974       if (!breakpoint_enabled (bpt))
3975         continue;
3976
3977       for (loc = bpt->loc; loc; loc = loc->next)
3978         if (loc->pspace->aspace == aspace && loc->inserted)
3979           {
3980             CORE_ADDR l, h;
3981
3982             /* Check for intersection.  */
3983             l = max (loc->address, addr);
3984             h = min (loc->address + loc->length, addr + len);
3985             if (l < h)
3986               return 1;
3987           }
3988     }
3989   return 0;
3990 }
3991
3992 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
3993    PC is valid for process/thread PTID.  */
3994
3995 int
3996 breakpoint_thread_match (struct address_space *aspace, CORE_ADDR pc,
3997                          ptid_t ptid)
3998 {
3999   struct bp_location *bl, **blp_tmp;
4000   /* The thread and task IDs associated to PTID, computed lazily.  */
4001   int thread = -1;
4002   int task = 0;
4003   
4004   ALL_BP_LOCATIONS (bl, blp_tmp)
4005     {
4006       if (bl->loc_type != bp_loc_software_breakpoint
4007           && bl->loc_type != bp_loc_hardware_breakpoint)
4008         continue;
4009
4010       /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL.  */
4011       if (!breakpoint_enabled (bl->owner)
4012           && bl->owner->enable_state != bp_permanent)
4013         continue;
4014
4015       if (!breakpoint_location_address_match (bl, aspace, pc))
4016         continue;
4017
4018       if (bl->owner->thread != -1)
4019         {
4020           /* This is a thread-specific breakpoint.  Check that ptid
4021              matches that thread.  If thread hasn't been computed yet,
4022              it is now time to do so.  */
4023           if (thread == -1)
4024             thread = pid_to_thread_id (ptid);
4025           if (bl->owner->thread != thread)
4026             continue;
4027         }
4028
4029       if (bl->owner->task != 0)
4030         {
4031           /* This is a task-specific breakpoint.  Check that ptid
4032              matches that task.  If task hasn't been computed yet,
4033              it is now time to do so.  */
4034           if (task == 0)
4035             task = ada_get_task_number (ptid);
4036           if (bl->owner->task != task)
4037             continue;
4038         }
4039
4040       if (overlay_debugging 
4041           && section_is_overlay (bl->section)
4042           && !section_is_mapped (bl->section))
4043         continue;           /* unmapped overlay -- can't be a match */
4044
4045       return 1;
4046     }
4047
4048   return 0;
4049 }
4050 \f
4051
4052 /* bpstat stuff.  External routines' interfaces are documented
4053    in breakpoint.h.  */
4054
4055 int
4056 is_catchpoint (struct breakpoint *ep)
4057 {
4058   return (ep->type == bp_catchpoint);
4059 }
4060
4061 /* Frees any storage that is part of a bpstat.  Does not walk the
4062    'next' chain.  */
4063
4064 static void
4065 bpstat_free (bpstat bs)
4066 {
4067   if (bs->old_val != NULL)
4068     value_free (bs->old_val);
4069   decref_counted_command_line (&bs->commands);
4070   decref_bp_location (&bs->bp_location_at);
4071   xfree (bs);
4072 }
4073
4074 /* Clear a bpstat so that it says we are not at any breakpoint.
4075    Also free any storage that is part of a bpstat.  */
4076
4077 void
4078 bpstat_clear (bpstat *bsp)
4079 {
4080   bpstat p;
4081   bpstat q;
4082
4083   if (bsp == 0)
4084     return;
4085   p = *bsp;
4086   while (p != NULL)
4087     {
4088       q = p->next;
4089       bpstat_free (p);
4090       p = q;
4091     }
4092   *bsp = NULL;
4093 }
4094
4095 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
4096    is part of the bpstat is copied as well.  */
4097
4098 bpstat
4099 bpstat_copy (bpstat bs)
4100 {
4101   bpstat p = NULL;
4102   bpstat tmp;
4103   bpstat retval = NULL;
4104
4105   if (bs == NULL)
4106     return bs;
4107
4108   for (; bs != NULL; bs = bs->next)
4109     {
4110       tmp = (bpstat) xmalloc (sizeof (*tmp));
4111       memcpy (tmp, bs, sizeof (*tmp));
4112       incref_counted_command_line (tmp->commands);
4113       incref_bp_location (tmp->bp_location_at);
4114       if (bs->old_val != NULL)
4115         {
4116           tmp->old_val = value_copy (bs->old_val);
4117           release_value (tmp->old_val);
4118         }
4119
4120       if (p == NULL)
4121         /* This is the first thing in the chain.  */
4122         retval = tmp;
4123       else
4124         p->next = tmp;
4125       p = tmp;
4126     }
4127   p->next = NULL;
4128   return retval;
4129 }
4130
4131 /* Find the bpstat associated with this breakpoint.  */
4132
4133 bpstat
4134 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
4135 {
4136   if (bsp == NULL)
4137     return NULL;
4138
4139   for (; bsp != NULL; bsp = bsp->next)
4140     {
4141       if (bsp->breakpoint_at == breakpoint)
4142         return bsp;
4143     }
4144   return NULL;
4145 }
4146
4147 /* See breakpoint.h.  */
4148
4149 enum bpstat_signal_value
4150 bpstat_explains_signal (bpstat bsp)
4151 {
4152   enum bpstat_signal_value result = BPSTAT_SIGNAL_NO;
4153
4154   for (; bsp != NULL; bsp = bsp->next)
4155     {
4156       /* Ensure that, if we ever entered this loop, then we at least
4157          return BPSTAT_SIGNAL_HIDE.  */
4158       enum bpstat_signal_value newval = BPSTAT_SIGNAL_HIDE;
4159
4160       if (bsp->breakpoint_at != NULL)
4161         newval = bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at);
4162
4163       if (newval > result)
4164         result = newval;
4165     }
4166
4167   return result;
4168 }
4169
4170 /* Put in *NUM the breakpoint number of the first breakpoint we are
4171    stopped at.  *BSP upon return is a bpstat which points to the
4172    remaining breakpoints stopped at (but which is not guaranteed to be
4173    good for anything but further calls to bpstat_num).
4174
4175    Return 0 if passed a bpstat which does not indicate any breakpoints.
4176    Return -1 if stopped at a breakpoint that has been deleted since
4177    we set it.
4178    Return 1 otherwise.  */
4179
4180 int
4181 bpstat_num (bpstat *bsp, int *num)
4182 {
4183   struct breakpoint *b;
4184
4185   if ((*bsp) == NULL)
4186     return 0;                   /* No more breakpoint values */
4187
4188   /* We assume we'll never have several bpstats that correspond to a
4189      single breakpoint -- otherwise, this function might return the
4190      same number more than once and this will look ugly.  */
4191   b = (*bsp)->breakpoint_at;
4192   *bsp = (*bsp)->next;
4193   if (b == NULL)
4194     return -1;                  /* breakpoint that's been deleted since */
4195
4196   *num = b->number;             /* We have its number */
4197   return 1;
4198 }
4199
4200 /* See breakpoint.h.  */
4201
4202 void
4203 bpstat_clear_actions (void)
4204 {
4205   struct thread_info *tp;
4206   bpstat bs;
4207
4208   if (ptid_equal (inferior_ptid, null_ptid))
4209     return;
4210
4211   tp = find_thread_ptid (inferior_ptid);
4212   if (tp == NULL)
4213     return;
4214
4215   for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
4216     {
4217       decref_counted_command_line (&bs->commands);
4218
4219       if (bs->old_val != NULL)
4220         {
4221           value_free (bs->old_val);
4222           bs->old_val = NULL;
4223         }
4224     }
4225 }
4226
4227 /* Called when a command is about to proceed the inferior.  */
4228
4229 static void
4230 breakpoint_about_to_proceed (void)
4231 {
4232   if (!ptid_equal (inferior_ptid, null_ptid))
4233     {
4234       struct thread_info *tp = inferior_thread ();
4235
4236       /* Allow inferior function calls in breakpoint commands to not
4237          interrupt the command list.  When the call finishes
4238          successfully, the inferior will be standing at the same
4239          breakpoint as if nothing happened.  */
4240       if (tp->control.in_infcall)
4241         return;
4242     }
4243
4244   breakpoint_proceeded = 1;
4245 }
4246
4247 /* Stub for cleaning up our state if we error-out of a breakpoint
4248    command.  */
4249 static void
4250 cleanup_executing_breakpoints (void *ignore)
4251 {
4252   executing_breakpoint_commands = 0;
4253 }
4254
4255 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4256    or its equivalent.  */
4257
4258 static int
4259 command_line_is_silent (struct command_line *cmd)
4260 {
4261   return cmd && (strcmp ("silent", cmd->line) == 0
4262                  || (xdb_commands && strcmp ("Q", cmd->line) == 0));
4263 }
4264
4265 /* Execute all the commands associated with all the breakpoints at
4266    this location.  Any of these commands could cause the process to
4267    proceed beyond this point, etc.  We look out for such changes by
4268    checking the global "breakpoint_proceeded" after each command.
4269
4270    Returns true if a breakpoint command resumed the inferior.  In that
4271    case, it is the caller's responsibility to recall it again with the
4272    bpstat of the current thread.  */
4273
4274 static int
4275 bpstat_do_actions_1 (bpstat *bsp)
4276 {
4277   bpstat bs;
4278   struct cleanup *old_chain;
4279   int again = 0;
4280
4281   /* Avoid endless recursion if a `source' command is contained
4282      in bs->commands.  */
4283   if (executing_breakpoint_commands)
4284     return 0;
4285
4286   executing_breakpoint_commands = 1;
4287   old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
4288
4289   prevent_dont_repeat ();
4290
4291   /* This pointer will iterate over the list of bpstat's.  */
4292   bs = *bsp;
4293
4294   breakpoint_proceeded = 0;
4295   for (; bs != NULL; bs = bs->next)
4296     {
4297       struct counted_command_line *ccmd;
4298       struct command_line *cmd;
4299       struct cleanup *this_cmd_tree_chain;
4300
4301       /* Take ownership of the BSP's command tree, if it has one.
4302
4303          The command tree could legitimately contain commands like
4304          'step' and 'next', which call clear_proceed_status, which
4305          frees stop_bpstat's command tree.  To make sure this doesn't
4306          free the tree we're executing out from under us, we need to
4307          take ownership of the tree ourselves.  Since a given bpstat's
4308          commands are only executed once, we don't need to copy it; we
4309          can clear the pointer in the bpstat, and make sure we free
4310          the tree when we're done.  */
4311       ccmd = bs->commands;
4312       bs->commands = NULL;
4313       this_cmd_tree_chain = make_cleanup_decref_counted_command_line (&ccmd);
4314       cmd = ccmd ? ccmd->commands : NULL;
4315       if (command_line_is_silent (cmd))
4316         {
4317           /* The action has been already done by bpstat_stop_status.  */
4318           cmd = cmd->next;
4319         }
4320
4321       while (cmd != NULL)
4322         {
4323           execute_control_command (cmd);
4324
4325           if (breakpoint_proceeded)
4326             break;
4327           else
4328             cmd = cmd->next;
4329         }
4330
4331       /* We can free this command tree now.  */
4332       do_cleanups (this_cmd_tree_chain);
4333
4334       if (breakpoint_proceeded)
4335         {
4336           if (target_can_async_p ())
4337             /* If we are in async mode, then the target might be still
4338                running, not stopped at any breakpoint, so nothing for
4339                us to do here -- just return to the event loop.  */
4340             ;
4341           else
4342             /* In sync mode, when execute_control_command returns
4343                we're already standing on the next breakpoint.
4344                Breakpoint commands for that stop were not run, since
4345                execute_command does not run breakpoint commands --
4346                only command_line_handler does, but that one is not
4347                involved in execution of breakpoint commands.  So, we
4348                can now execute breakpoint commands.  It should be
4349                noted that making execute_command do bpstat actions is
4350                not an option -- in this case we'll have recursive
4351                invocation of bpstat for each breakpoint with a
4352                command, and can easily blow up GDB stack.  Instead, we
4353                return true, which will trigger the caller to recall us
4354                with the new stop_bpstat.  */
4355             again = 1;
4356           break;
4357         }
4358     }
4359   do_cleanups (old_chain);
4360   return again;
4361 }
4362
4363 void
4364 bpstat_do_actions (void)
4365 {
4366   struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
4367
4368   /* Do any commands attached to breakpoint we are stopped at.  */
4369   while (!ptid_equal (inferior_ptid, null_ptid)
4370          && target_has_execution
4371          && !is_exited (inferior_ptid)
4372          && !is_executing (inferior_ptid))
4373     /* Since in sync mode, bpstat_do_actions may resume the inferior,
4374        and only return when it is stopped at the next breakpoint, we
4375        keep doing breakpoint actions until it returns false to
4376        indicate the inferior was not resumed.  */
4377     if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
4378       break;
4379
4380   discard_cleanups (cleanup_if_error);
4381 }
4382
4383 /* Print out the (old or new) value associated with a watchpoint.  */
4384
4385 static void
4386 watchpoint_value_print (struct value *val, struct ui_file *stream)
4387 {
4388   if (val == NULL)
4389     fprintf_unfiltered (stream, _("<unreadable>"));
4390   else
4391     {
4392       struct value_print_options opts;
4393       get_user_print_options (&opts);
4394       value_print (val, stream, &opts);
4395     }
4396 }
4397
4398 /* Generic routine for printing messages indicating why we
4399    stopped.  The behavior of this function depends on the value
4400    'print_it' in the bpstat structure.  Under some circumstances we
4401    may decide not to print anything here and delegate the task to
4402    normal_stop().  */
4403
4404 static enum print_stop_action
4405 print_bp_stop_message (bpstat bs)
4406 {
4407   switch (bs->print_it)
4408     {
4409     case print_it_noop:
4410       /* Nothing should be printed for this bpstat entry.  */
4411       return PRINT_UNKNOWN;
4412       break;
4413
4414     case print_it_done:
4415       /* We still want to print the frame, but we already printed the
4416          relevant messages.  */
4417       return PRINT_SRC_AND_LOC;
4418       break;
4419
4420     case print_it_normal:
4421       {
4422         struct breakpoint *b = bs->breakpoint_at;
4423
4424         /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4425            which has since been deleted.  */
4426         if (b == NULL)
4427           return PRINT_UNKNOWN;
4428
4429         /* Normal case.  Call the breakpoint's print_it method.  */
4430         return b->ops->print_it (bs);
4431       }
4432       break;
4433
4434     default:
4435       internal_error (__FILE__, __LINE__,
4436                       _("print_bp_stop_message: unrecognized enum value"));
4437       break;
4438     }
4439 }
4440
4441 /* A helper function that prints a shared library stopped event.  */
4442
4443 static void
4444 print_solib_event (int is_catchpoint)
4445 {
4446   int any_deleted
4447     = !VEC_empty (char_ptr, current_program_space->deleted_solibs);
4448   int any_added
4449     = !VEC_empty (so_list_ptr, current_program_space->added_solibs);
4450
4451   if (!is_catchpoint)
4452     {
4453       if (any_added || any_deleted)
4454         ui_out_text (current_uiout,
4455                      _("Stopped due to shared library event:\n"));
4456       else
4457         ui_out_text (current_uiout,
4458                      _("Stopped due to shared library event (no "
4459                        "libraries added or removed)\n"));
4460     }
4461
4462   if (ui_out_is_mi_like_p (current_uiout))
4463     ui_out_field_string (current_uiout, "reason",
4464                          async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
4465
4466   if (any_deleted)
4467     {
4468       struct cleanup *cleanup;
4469       char *name;
4470       int ix;
4471
4472       ui_out_text (current_uiout, _("  Inferior unloaded "));
4473       cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
4474                                                     "removed");
4475       for (ix = 0;
4476            VEC_iterate (char_ptr, current_program_space->deleted_solibs,
4477                         ix, name);
4478            ++ix)
4479         {
4480           if (ix > 0)
4481             ui_out_text (current_uiout, "    ");
4482           ui_out_field_string (current_uiout, "library", name);
4483           ui_out_text (current_uiout, "\n");
4484         }
4485
4486       do_cleanups (cleanup);
4487     }
4488
4489   if (any_added)
4490     {
4491       struct so_list *iter;
4492       int ix;
4493       struct cleanup *cleanup;
4494
4495       ui_out_text (current_uiout, _("  Inferior loaded "));
4496       cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
4497                                                     "added");
4498       for (ix = 0;
4499            VEC_iterate (so_list_ptr, current_program_space->added_solibs,
4500                         ix, iter);
4501            ++ix)
4502         {
4503           if (ix > 0)
4504             ui_out_text (current_uiout, "    ");
4505           ui_out_field_string (current_uiout, "library", iter->so_name);
4506           ui_out_text (current_uiout, "\n");
4507         }
4508
4509       do_cleanups (cleanup);
4510     }
4511 }
4512
4513 /* Print a message indicating what happened.  This is called from
4514    normal_stop().  The input to this routine is the head of the bpstat
4515    list - a list of the eventpoints that caused this stop.  KIND is
4516    the target_waitkind for the stopping event.  This
4517    routine calls the generic print routine for printing a message
4518    about reasons for stopping.  This will print (for example) the
4519    "Breakpoint n," part of the output.  The return value of this
4520    routine is one of:
4521
4522    PRINT_UNKNOWN: Means we printed nothing.
4523    PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4524    code to print the location.  An example is 
4525    "Breakpoint 1, " which should be followed by
4526    the location.
4527    PRINT_SRC_ONLY: Means we printed something, but there is no need
4528    to also print the location part of the message.
4529    An example is the catch/throw messages, which
4530    don't require a location appended to the end.
4531    PRINT_NOTHING: We have done some printing and we don't need any 
4532    further info to be printed.  */
4533
4534 enum print_stop_action
4535 bpstat_print (bpstat bs, int kind)
4536 {
4537   int val;
4538
4539   /* Maybe another breakpoint in the chain caused us to stop.
4540      (Currently all watchpoints go on the bpstat whether hit or not.
4541      That probably could (should) be changed, provided care is taken
4542      with respect to bpstat_explains_signal).  */
4543   for (; bs; bs = bs->next)
4544     {
4545       val = print_bp_stop_message (bs);
4546       if (val == PRINT_SRC_ONLY 
4547           || val == PRINT_SRC_AND_LOC 
4548           || val == PRINT_NOTHING)
4549         return val;
4550     }
4551
4552   /* If we had hit a shared library event breakpoint,
4553      print_bp_stop_message would print out this message.  If we hit an
4554      OS-level shared library event, do the same thing.  */
4555   if (kind == TARGET_WAITKIND_LOADED)
4556     {
4557       print_solib_event (0);
4558       return PRINT_NOTHING;
4559     }
4560
4561   /* We reached the end of the chain, or we got a null BS to start
4562      with and nothing was printed.  */
4563   return PRINT_UNKNOWN;
4564 }
4565
4566 /* Evaluate the expression EXP and return 1 if value is zero.  This is
4567    used inside a catch_errors to evaluate the breakpoint condition.
4568    The argument is a "struct expression *" that has been cast to a
4569    "char *" to make it pass through catch_errors.  */
4570
4571 static int
4572 breakpoint_cond_eval (void *exp)
4573 {
4574   struct value *mark = value_mark ();
4575   int i = !value_true (evaluate_expression ((struct expression *) exp));
4576
4577   value_free_to_mark (mark);
4578   return i;
4579 }
4580
4581 /* Allocate a new bpstat.  Link it to the FIFO list by BS_LINK_POINTER.  */
4582
4583 static bpstat
4584 bpstat_alloc (struct bp_location *bl, bpstat **bs_link_pointer)
4585 {
4586   bpstat bs;
4587
4588   bs = (bpstat) xmalloc (sizeof (*bs));
4589   bs->next = NULL;
4590   **bs_link_pointer = bs;
4591   *bs_link_pointer = &bs->next;
4592   bs->breakpoint_at = bl->owner;
4593   bs->bp_location_at = bl;
4594   incref_bp_location (bl);
4595   /* If the condition is false, etc., don't do the commands.  */
4596   bs->commands = NULL;
4597   bs->old_val = NULL;
4598   bs->print_it = print_it_normal;
4599   return bs;
4600 }
4601 \f
4602 /* The target has stopped with waitstatus WS.  Check if any hardware
4603    watchpoints have triggered, according to the target.  */
4604
4605 int
4606 watchpoints_triggered (struct target_waitstatus *ws)
4607 {
4608   int stopped_by_watchpoint = target_stopped_by_watchpoint ();
4609   CORE_ADDR addr;
4610   struct breakpoint *b;
4611
4612   if (!stopped_by_watchpoint)
4613     {
4614       /* We were not stopped by a watchpoint.  Mark all watchpoints
4615          as not triggered.  */
4616       ALL_BREAKPOINTS (b)
4617         if (is_hardware_watchpoint (b))
4618           {
4619             struct watchpoint *w = (struct watchpoint *) b;
4620
4621             w->watchpoint_triggered = watch_triggered_no;
4622           }
4623
4624       return 0;
4625     }
4626
4627   if (!target_stopped_data_address (&current_target, &addr))
4628     {
4629       /* We were stopped by a watchpoint, but we don't know where.
4630          Mark all watchpoints as unknown.  */
4631       ALL_BREAKPOINTS (b)
4632         if (is_hardware_watchpoint (b))
4633           {
4634             struct watchpoint *w = (struct watchpoint *) b;
4635
4636             w->watchpoint_triggered = watch_triggered_unknown;
4637           }
4638
4639       return stopped_by_watchpoint;
4640     }
4641
4642   /* The target could report the data address.  Mark watchpoints
4643      affected by this data address as triggered, and all others as not
4644      triggered.  */
4645
4646   ALL_BREAKPOINTS (b)
4647     if (is_hardware_watchpoint (b))
4648       {
4649         struct watchpoint *w = (struct watchpoint *) b;
4650         struct bp_location *loc;
4651
4652         w->watchpoint_triggered = watch_triggered_no;
4653         for (loc = b->loc; loc; loc = loc->next)
4654           {
4655             if (is_masked_watchpoint (b))
4656               {
4657                 CORE_ADDR newaddr = addr & w->hw_wp_mask;
4658                 CORE_ADDR start = loc->address & w->hw_wp_mask;
4659
4660                 if (newaddr == start)
4661                   {
4662                     w->watchpoint_triggered = watch_triggered_yes;
4663                     break;
4664                   }
4665               }
4666             /* Exact match not required.  Within range is sufficient.  */
4667             else if (target_watchpoint_addr_within_range (&current_target,
4668                                                          addr, loc->address,
4669                                                          loc->length))
4670               {
4671                 w->watchpoint_triggered = watch_triggered_yes;
4672                 break;
4673               }
4674           }
4675       }
4676
4677   return 1;
4678 }
4679
4680 /* Possible return values for watchpoint_check (this can't be an enum
4681    because of check_errors).  */
4682 /* The watchpoint has been deleted.  */
4683 #define WP_DELETED 1
4684 /* The value has changed.  */
4685 #define WP_VALUE_CHANGED 2
4686 /* The value has not changed.  */
4687 #define WP_VALUE_NOT_CHANGED 3
4688 /* Ignore this watchpoint, no matter if the value changed or not.  */
4689 #define WP_IGNORE 4
4690
4691 #define BP_TEMPFLAG 1
4692 #define BP_HARDWAREFLAG 2
4693
4694 /* Evaluate watchpoint condition expression and check if its value
4695    changed.
4696
4697    P should be a pointer to struct bpstat, but is defined as a void *
4698    in order for this function to be usable with catch_errors.  */
4699
4700 static int
4701 watchpoint_check (void *p)
4702 {
4703   bpstat bs = (bpstat) p;
4704   struct watchpoint *b;
4705   struct frame_info *fr;
4706   int within_current_scope;
4707
4708   /* BS is built from an existing struct breakpoint.  */
4709   gdb_assert (bs->breakpoint_at != NULL);
4710   b = (struct watchpoint *) bs->breakpoint_at;
4711
4712   /* If this is a local watchpoint, we only want to check if the
4713      watchpoint frame is in scope if the current thread is the thread
4714      that was used to create the watchpoint.  */
4715   if (!watchpoint_in_thread_scope (b))
4716     return WP_IGNORE;
4717
4718   if (b->exp_valid_block == NULL)
4719     within_current_scope = 1;
4720   else
4721     {
4722       struct frame_info *frame = get_current_frame ();
4723       struct gdbarch *frame_arch = get_frame_arch (frame);
4724       CORE_ADDR frame_pc = get_frame_pc (frame);
4725
4726       /* in_function_epilogue_p() returns a non-zero value if we're
4727          still in the function but the stack frame has already been
4728          invalidated.  Since we can't rely on the values of local
4729          variables after the stack has been destroyed, we are treating
4730          the watchpoint in that state as `not changed' without further
4731          checking.  Don't mark watchpoints as changed if the current
4732          frame is in an epilogue - even if they are in some other
4733          frame, our view of the stack is likely to be wrong and
4734          frame_find_by_id could error out.  */
4735       if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
4736         return WP_IGNORE;
4737
4738       fr = frame_find_by_id (b->watchpoint_frame);
4739       within_current_scope = (fr != NULL);
4740
4741       /* If we've gotten confused in the unwinder, we might have
4742          returned a frame that can't describe this variable.  */
4743       if (within_current_scope)
4744         {
4745           struct symbol *function;
4746
4747           function = get_frame_function (fr);
4748           if (function == NULL
4749               || !contained_in (b->exp_valid_block,
4750                                 SYMBOL_BLOCK_VALUE (function)))
4751             within_current_scope = 0;
4752         }
4753
4754       if (within_current_scope)
4755         /* If we end up stopping, the current frame will get selected
4756            in normal_stop.  So this call to select_frame won't affect
4757            the user.  */
4758         select_frame (fr);
4759     }
4760
4761   if (within_current_scope)
4762     {
4763       /* We use value_{,free_to_}mark because it could be a *long*
4764          time before we return to the command level and call
4765          free_all_values.  We can't call free_all_values because we
4766          might be in the middle of evaluating a function call.  */
4767
4768       int pc = 0;
4769       struct value *mark;
4770       struct value *new_val;
4771
4772       if (is_masked_watchpoint (&b->base))
4773         /* Since we don't know the exact trigger address (from
4774            stopped_data_address), just tell the user we've triggered
4775            a mask watchpoint.  */
4776         return WP_VALUE_CHANGED;
4777
4778       mark = value_mark ();
4779       fetch_subexp_value (b->exp, &pc, &new_val, NULL, NULL);
4780
4781       /* We use value_equal_contents instead of value_equal because
4782          the latter coerces an array to a pointer, thus comparing just
4783          the address of the array instead of its contents.  This is
4784          not what we want.  */
4785       if ((b->val != NULL) != (new_val != NULL)
4786           || (b->val != NULL && !value_equal_contents (b->val, new_val)))
4787         {
4788           if (new_val != NULL)
4789             {
4790               release_value (new_val);
4791               value_free_to_mark (mark);
4792             }
4793           bs->old_val = b->val;
4794           b->val = new_val;
4795           b->val_valid = 1;
4796           return WP_VALUE_CHANGED;
4797         }
4798       else
4799         {
4800           /* Nothing changed.  */
4801           value_free_to_mark (mark);
4802           return WP_VALUE_NOT_CHANGED;
4803         }
4804     }
4805   else
4806     {
4807       struct ui_out *uiout = current_uiout;
4808
4809       /* This seems like the only logical thing to do because
4810          if we temporarily ignored the watchpoint, then when
4811          we reenter the block in which it is valid it contains
4812          garbage (in the case of a function, it may have two
4813          garbage values, one before and one after the prologue).
4814          So we can't even detect the first assignment to it and
4815          watch after that (since the garbage may or may not equal
4816          the first value assigned).  */
4817       /* We print all the stop information in
4818          breakpoint_ops->print_it, but in this case, by the time we
4819          call breakpoint_ops->print_it this bp will be deleted
4820          already.  So we have no choice but print the information
4821          here.  */
4822       if (ui_out_is_mi_like_p (uiout))
4823         ui_out_field_string
4824           (uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
4825       ui_out_text (uiout, "\nWatchpoint ");
4826       ui_out_field_int (uiout, "wpnum", b->base.number);
4827       ui_out_text (uiout,
4828                    " deleted because the program has left the block in\n\
4829 which its expression is valid.\n");     
4830
4831       /* Make sure the watchpoint's commands aren't executed.  */
4832       decref_counted_command_line (&b->base.commands);
4833       watchpoint_del_at_next_stop (b);
4834
4835       return WP_DELETED;
4836     }
4837 }
4838
4839 /* Return true if it looks like target has stopped due to hitting
4840    breakpoint location BL.  This function does not check if we should
4841    stop, only if BL explains the stop.  */
4842
4843 static int
4844 bpstat_check_location (const struct bp_location *bl,
4845                        struct address_space *aspace, CORE_ADDR bp_addr,
4846                        const struct target_waitstatus *ws)
4847 {
4848   struct breakpoint *b = bl->owner;
4849
4850   /* BL is from an existing breakpoint.  */
4851   gdb_assert (b != NULL);
4852
4853   return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
4854 }
4855
4856 /* Determine if the watched values have actually changed, and we
4857    should stop.  If not, set BS->stop to 0.  */
4858
4859 static void
4860 bpstat_check_watchpoint (bpstat bs)
4861 {
4862   const struct bp_location *bl;
4863   struct watchpoint *b;
4864
4865   /* BS is built for existing struct breakpoint.  */
4866   bl = bs->bp_location_at;
4867   gdb_assert (bl != NULL);
4868   b = (struct watchpoint *) bs->breakpoint_at;
4869   gdb_assert (b != NULL);
4870
4871     {
4872       int must_check_value = 0;
4873       
4874       if (b->base.type == bp_watchpoint)
4875         /* For a software watchpoint, we must always check the
4876            watched value.  */
4877         must_check_value = 1;
4878       else if (b->watchpoint_triggered == watch_triggered_yes)
4879         /* We have a hardware watchpoint (read, write, or access)
4880            and the target earlier reported an address watched by
4881            this watchpoint.  */
4882         must_check_value = 1;
4883       else if (b->watchpoint_triggered == watch_triggered_unknown
4884                && b->base.type == bp_hardware_watchpoint)
4885         /* We were stopped by a hardware watchpoint, but the target could
4886            not report the data address.  We must check the watchpoint's
4887            value.  Access and read watchpoints are out of luck; without
4888            a data address, we can't figure it out.  */
4889         must_check_value = 1;
4890
4891       if (must_check_value)
4892         {
4893           char *message
4894             = xstrprintf ("Error evaluating expression for watchpoint %d\n",
4895                           b->base.number);
4896           struct cleanup *cleanups = make_cleanup (xfree, message);
4897           int e = catch_errors (watchpoint_check, bs, message,
4898                                 RETURN_MASK_ALL);
4899           do_cleanups (cleanups);
4900           switch (e)
4901             {
4902             case WP_DELETED:
4903               /* We've already printed what needs to be printed.  */
4904               bs->print_it = print_it_done;
4905               /* Stop.  */
4906               break;
4907             case WP_IGNORE:
4908               bs->print_it = print_it_noop;
4909               bs->stop = 0;
4910               break;
4911             case WP_VALUE_CHANGED:
4912               if (b->base.type == bp_read_watchpoint)
4913                 {
4914                   /* There are two cases to consider here:
4915
4916                      1. We're watching the triggered memory for reads.
4917                      In that case, trust the target, and always report
4918                      the watchpoint hit to the user.  Even though
4919                      reads don't cause value changes, the value may
4920                      have changed since the last time it was read, and
4921                      since we're not trapping writes, we will not see
4922                      those, and as such we should ignore our notion of
4923                      old value.
4924
4925                      2. We're watching the triggered memory for both
4926                      reads and writes.  There are two ways this may
4927                      happen:
4928
4929                      2.1. This is a target that can't break on data
4930                      reads only, but can break on accesses (reads or
4931                      writes), such as e.g., x86.  We detect this case
4932                      at the time we try to insert read watchpoints.
4933
4934                      2.2. Otherwise, the target supports read
4935                      watchpoints, but, the user set an access or write
4936                      watchpoint watching the same memory as this read
4937                      watchpoint.
4938
4939                      If we're watching memory writes as well as reads,
4940                      ignore watchpoint hits when we find that the
4941                      value hasn't changed, as reads don't cause
4942                      changes.  This still gives false positives when
4943                      the program writes the same value to memory as
4944                      what there was already in memory (we will confuse
4945                      it for a read), but it's much better than
4946                      nothing.  */
4947
4948                   int other_write_watchpoint = 0;
4949
4950                   if (bl->watchpoint_type == hw_read)
4951                     {
4952                       struct breakpoint *other_b;
4953
4954                       ALL_BREAKPOINTS (other_b)
4955                         if (other_b->type == bp_hardware_watchpoint
4956                             || other_b->type == bp_access_watchpoint)
4957                           {
4958                             struct watchpoint *other_w =
4959                               (struct watchpoint *) other_b;
4960
4961                             if (other_w->watchpoint_triggered
4962                                 == watch_triggered_yes)
4963                               {
4964                                 other_write_watchpoint = 1;
4965                                 break;
4966                               }
4967                           }
4968                     }
4969
4970                   if (other_write_watchpoint
4971                       || bl->watchpoint_type == hw_access)
4972                     {
4973                       /* We're watching the same memory for writes,
4974                          and the value changed since the last time we
4975                          updated it, so this trap must be for a write.
4976                          Ignore it.  */
4977                       bs->print_it = print_it_noop;
4978                       bs->stop = 0;
4979                     }
4980                 }
4981               break;
4982             case WP_VALUE_NOT_CHANGED:
4983               if (b->base.type == bp_hardware_watchpoint
4984                   || b->base.type == bp_watchpoint)
4985                 {
4986                   /* Don't stop: write watchpoints shouldn't fire if
4987                      the value hasn't changed.  */
4988                   bs->print_it = print_it_noop;
4989                   bs->stop = 0;
4990                 }
4991               /* Stop.  */
4992               break;
4993             default:
4994               /* Can't happen.  */
4995             case 0:
4996               /* Error from catch_errors.  */
4997               printf_filtered (_("Watchpoint %d deleted.\n"), b->base.number);
4998               watchpoint_del_at_next_stop (b);
4999               /* We've already printed what needs to be printed.  */
5000               bs->print_it = print_it_done;
5001               break;
5002             }
5003         }
5004       else      /* must_check_value == 0 */
5005         {
5006           /* This is a case where some watchpoint(s) triggered, but
5007              not at the address of this watchpoint, or else no
5008              watchpoint triggered after all.  So don't print
5009              anything for this watchpoint.  */
5010           bs->print_it = print_it_noop;
5011           bs->stop = 0;
5012         }
5013     }
5014 }
5015
5016
5017 /* Check conditions (condition proper, frame, thread and ignore count)
5018    of breakpoint referred to by BS.  If we should not stop for this
5019    breakpoint, set BS->stop to 0.  */
5020
5021 static void
5022 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
5023 {
5024   int thread_id = pid_to_thread_id (ptid);
5025   const struct bp_location *bl;
5026   struct breakpoint *b;
5027
5028   /* BS is built for existing struct breakpoint.  */
5029   bl = bs->bp_location_at;
5030   gdb_assert (bl != NULL);
5031   b = bs->breakpoint_at;
5032   gdb_assert (b != NULL);
5033
5034   /* Even if the target evaluated the condition on its end and notified GDB, we
5035      need to do so again since GDB does not know if we stopped due to a
5036      breakpoint or a single step breakpoint.  */
5037
5038   if (frame_id_p (b->frame_id)
5039       && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
5040     bs->stop = 0;
5041   else if (bs->stop)
5042     {
5043       int value_is_zero = 0;
5044       struct expression *cond;
5045
5046       /* Evaluate Python breakpoints that have a "stop"
5047          method implemented.  */
5048       if (b->py_bp_object)
5049         bs->stop = gdbpy_should_stop (b->py_bp_object);
5050
5051       if (is_watchpoint (b))
5052         {
5053           struct watchpoint *w = (struct watchpoint *) b;
5054
5055           cond = w->cond_exp;
5056         }
5057       else
5058         cond = bl->cond;
5059
5060       if (cond && b->disposition != disp_del_at_next_stop)
5061         {
5062           int within_current_scope = 1;
5063           struct watchpoint * w;
5064
5065           /* We use value_mark and value_free_to_mark because it could
5066              be a long time before we return to the command level and
5067              call free_all_values.  We can't call free_all_values
5068              because we might be in the middle of evaluating a
5069              function call.  */
5070           struct value *mark = value_mark ();
5071
5072           if (is_watchpoint (b))
5073             w = (struct watchpoint *) b;
5074           else
5075             w = NULL;
5076
5077           /* Need to select the frame, with all that implies so that
5078              the conditions will have the right context.  Because we
5079              use the frame, we will not see an inlined function's
5080              variables when we arrive at a breakpoint at the start
5081              of the inlined function; the current frame will be the
5082              call site.  */
5083           if (w == NULL || w->cond_exp_valid_block == NULL)
5084             select_frame (get_current_frame ());
5085           else
5086             {
5087               struct frame_info *frame;
5088
5089               /* For local watchpoint expressions, which particular
5090                  instance of a local is being watched matters, so we
5091                  keep track of the frame to evaluate the expression
5092                  in.  To evaluate the condition however, it doesn't
5093                  really matter which instantiation of the function
5094                  where the condition makes sense triggers the
5095                  watchpoint.  This allows an expression like "watch
5096                  global if q > 10" set in `func', catch writes to
5097                  global on all threads that call `func', or catch
5098                  writes on all recursive calls of `func' by a single
5099                  thread.  We simply always evaluate the condition in
5100                  the innermost frame that's executing where it makes
5101                  sense to evaluate the condition.  It seems
5102                  intuitive.  */
5103               frame = block_innermost_frame (w->cond_exp_valid_block);
5104               if (frame != NULL)
5105                 select_frame (frame);
5106               else
5107                 within_current_scope = 0;
5108             }
5109           if (within_current_scope)
5110             value_is_zero
5111               = catch_errors (breakpoint_cond_eval, cond,
5112                               "Error in testing breakpoint condition:\n",
5113                               RETURN_MASK_ALL);
5114           else
5115             {
5116               warning (_("Watchpoint condition cannot be tested "
5117                          "in the current scope"));
5118               /* If we failed to set the right context for this
5119                  watchpoint, unconditionally report it.  */
5120               value_is_zero = 0;
5121             }
5122           /* FIXME-someday, should give breakpoint #.  */
5123           value_free_to_mark (mark);
5124         }
5125
5126       if (cond && value_is_zero)
5127         {
5128           bs->stop = 0;
5129         }
5130       else if (b->thread != -1 && b->thread != thread_id)
5131         {
5132           bs->stop = 0;
5133         }
5134       else if (b->ignore_count > 0)
5135         {
5136           b->ignore_count--;
5137           bs->stop = 0;
5138           /* Increase the hit count even though we don't stop.  */
5139           ++(b->hit_count);
5140           observer_notify_breakpoint_modified (b);
5141         }       
5142     }
5143 }
5144
5145
5146 /* Get a bpstat associated with having just stopped at address
5147    BP_ADDR in thread PTID.
5148
5149    Determine whether we stopped at a breakpoint, etc, or whether we
5150    don't understand this stop.  Result is a chain of bpstat's such
5151    that:
5152
5153    if we don't understand the stop, the result is a null pointer.
5154
5155    if we understand why we stopped, the result is not null.
5156
5157    Each element of the chain refers to a particular breakpoint or
5158    watchpoint at which we have stopped.  (We may have stopped for
5159    several reasons concurrently.)
5160
5161    Each element of the chain has valid next, breakpoint_at,
5162    commands, FIXME??? fields.  */
5163
5164 bpstat
5165 bpstat_stop_status (struct address_space *aspace,
5166                     CORE_ADDR bp_addr, ptid_t ptid,
5167                     const struct target_waitstatus *ws)
5168 {
5169   struct breakpoint *b = NULL;
5170   struct bp_location *bl;
5171   struct bp_location *loc;
5172   /* First item of allocated bpstat's.  */
5173   bpstat bs_head = NULL, *bs_link = &bs_head;
5174   /* Pointer to the last thing in the chain currently.  */
5175   bpstat bs;
5176   int ix;
5177   int need_remove_insert;
5178   int removed_any;
5179
5180   /* First, build the bpstat chain with locations that explain a
5181      target stop, while being careful to not set the target running,
5182      as that may invalidate locations (in particular watchpoint
5183      locations are recreated).  Resuming will happen here with
5184      breakpoint conditions or watchpoint expressions that include
5185      inferior function calls.  */
5186
5187   ALL_BREAKPOINTS (b)
5188     {
5189       if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
5190         continue;
5191
5192       for (bl = b->loc; bl != NULL; bl = bl->next)
5193         {
5194           /* For hardware watchpoints, we look only at the first
5195              location.  The watchpoint_check function will work on the
5196              entire expression, not the individual locations.  For
5197              read watchpoints, the watchpoints_triggered function has
5198              checked all locations already.  */
5199           if (b->type == bp_hardware_watchpoint && bl != b->loc)
5200             break;
5201
5202           if (!bl->enabled || bl->shlib_disabled)
5203             continue;
5204
5205           if (!bpstat_check_location (bl, aspace, bp_addr, ws))
5206             continue;
5207
5208           /* Come here if it's a watchpoint, or if the break address
5209              matches.  */
5210
5211           bs = bpstat_alloc (bl, &bs_link);     /* Alloc a bpstat to
5212                                                    explain stop.  */
5213
5214           /* Assume we stop.  Should we find a watchpoint that is not
5215              actually triggered, or if the condition of the breakpoint
5216              evaluates as false, we'll reset 'stop' to 0.  */
5217           bs->stop = 1;
5218           bs->print = 1;
5219
5220           /* If this is a scope breakpoint, mark the associated
5221              watchpoint as triggered so that we will handle the
5222              out-of-scope event.  We'll get to the watchpoint next
5223              iteration.  */
5224           if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
5225             {
5226               struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5227
5228               w->watchpoint_triggered = watch_triggered_yes;
5229             }
5230         }
5231     }
5232
5233   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
5234     {
5235       if (breakpoint_location_address_match (loc, aspace, bp_addr))
5236         {
5237           bs = bpstat_alloc (loc, &bs_link);
5238           /* For hits of moribund locations, we should just proceed.  */
5239           bs->stop = 0;
5240           bs->print = 0;
5241           bs->print_it = print_it_noop;
5242         }
5243     }
5244
5245   /* A bit of special processing for shlib breakpoints.  We need to
5246      process solib loading here, so that the lists of loaded and
5247      unloaded libraries are correct before we handle "catch load" and
5248      "catch unload".  */
5249   for (bs = bs_head; bs != NULL; bs = bs->next)
5250     {
5251       if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
5252         {
5253           handle_solib_event ();
5254           break;
5255         }
5256     }
5257
5258   /* Now go through the locations that caused the target to stop, and
5259      check whether we're interested in reporting this stop to higher
5260      layers, or whether we should resume the target transparently.  */
5261
5262   removed_any = 0;
5263
5264   for (bs = bs_head; bs != NULL; bs = bs->next)
5265     {
5266       if (!bs->stop)
5267         continue;
5268
5269       b = bs->breakpoint_at;
5270       b->ops->check_status (bs);
5271       if (bs->stop)
5272         {
5273           bpstat_check_breakpoint_conditions (bs, ptid);
5274
5275           if (bs->stop)
5276             {
5277               ++(b->hit_count);
5278               observer_notify_breakpoint_modified (b);
5279
5280               /* We will stop here.  */
5281               if (b->disposition == disp_disable)
5282                 {
5283                   --(b->enable_count);
5284                   if (b->enable_count <= 0
5285                       && b->enable_state != bp_permanent)
5286                     b->enable_state = bp_disabled;
5287                   removed_any = 1;
5288                 }
5289               if (b->silent)
5290                 bs->print = 0;
5291               bs->commands = b->commands;
5292               incref_counted_command_line (bs->commands);
5293               if (command_line_is_silent (bs->commands
5294                                           ? bs->commands->commands : NULL))
5295                 bs->print = 0;
5296             }
5297
5298         }
5299
5300       /* Print nothing for this entry if we don't stop or don't
5301          print.  */
5302       if (!bs->stop || !bs->print)
5303         bs->print_it = print_it_noop;
5304     }
5305
5306   /* If we aren't stopping, the value of some hardware watchpoint may
5307      not have changed, but the intermediate memory locations we are
5308      watching may have.  Don't bother if we're stopping; this will get
5309      done later.  */
5310   need_remove_insert = 0;
5311   if (! bpstat_causes_stop (bs_head))
5312     for (bs = bs_head; bs != NULL; bs = bs->next)
5313       if (!bs->stop
5314           && bs->breakpoint_at
5315           && is_hardware_watchpoint (bs->breakpoint_at))
5316         {
5317           struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5318
5319           update_watchpoint (w, 0 /* don't reparse.  */);
5320           need_remove_insert = 1;
5321         }
5322
5323   if (need_remove_insert)
5324     update_global_location_list (1);
5325   else if (removed_any)
5326     update_global_location_list (0);
5327
5328   return bs_head;
5329 }
5330
5331 static void
5332 handle_jit_event (void)
5333 {
5334   struct frame_info *frame;
5335   struct gdbarch *gdbarch;
5336
5337   /* Switch terminal for any messages produced by
5338      breakpoint_re_set.  */
5339   target_terminal_ours_for_output ();
5340
5341   frame = get_current_frame ();
5342   gdbarch = get_frame_arch (frame);
5343
5344   jit_event_handler (gdbarch);
5345
5346   target_terminal_inferior ();
5347 }
5348
5349 /* Handle an solib event by calling solib_add.  */
5350
5351 void
5352 handle_solib_event (void)
5353 {
5354   clear_program_space_solib_cache (current_inferior ()->pspace);
5355
5356   /* Check for any newly added shared libraries if we're supposed to
5357      be adding them automatically.  Switch terminal for any messages
5358      produced by breakpoint_re_set.  */
5359   target_terminal_ours_for_output ();
5360 #ifdef SOLIB_ADD
5361   SOLIB_ADD (NULL, 0, &current_target, auto_solib_add);
5362 #else
5363   solib_add (NULL, 0, &current_target, auto_solib_add);
5364 #endif
5365   target_terminal_inferior ();
5366 }
5367
5368 /* Prepare WHAT final decision for infrun.  */
5369
5370 /* Decide what infrun needs to do with this bpstat.  */
5371
5372 struct bpstat_what
5373 bpstat_what (bpstat bs_head)
5374 {
5375   struct bpstat_what retval;
5376   int jit_event = 0;
5377   bpstat bs;
5378
5379   retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
5380   retval.call_dummy = STOP_NONE;
5381   retval.is_longjmp = 0;
5382
5383   for (bs = bs_head; bs != NULL; bs = bs->next)
5384     {
5385       /* Extract this BS's action.  After processing each BS, we check
5386          if its action overrides all we've seem so far.  */
5387       enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5388       enum bptype bptype;
5389
5390       if (bs->breakpoint_at == NULL)
5391         {
5392           /* I suspect this can happen if it was a momentary
5393              breakpoint which has since been deleted.  */
5394           bptype = bp_none;
5395         }
5396       else
5397         bptype = bs->breakpoint_at->type;
5398
5399       switch (bptype)
5400         {
5401         case bp_none:
5402           break;
5403         case bp_breakpoint:
5404         case bp_hardware_breakpoint:
5405         case bp_until:
5406         case bp_finish:
5407         case bp_shlib_event:
5408           if (bs->stop)
5409             {
5410               if (bs->print)
5411                 this_action = BPSTAT_WHAT_STOP_NOISY;
5412               else
5413                 this_action = BPSTAT_WHAT_STOP_SILENT;
5414             }
5415           else
5416             this_action = BPSTAT_WHAT_SINGLE;
5417           break;
5418         case bp_watchpoint:
5419         case bp_hardware_watchpoint:
5420         case bp_read_watchpoint:
5421         case bp_access_watchpoint:
5422           if (bs->stop)
5423             {
5424               if (bs->print)
5425                 this_action = BPSTAT_WHAT_STOP_NOISY;
5426               else
5427                 this_action = BPSTAT_WHAT_STOP_SILENT;
5428             }
5429           else
5430             {
5431               /* There was a watchpoint, but we're not stopping.
5432                  This requires no further action.  */
5433             }
5434           break;
5435         case bp_longjmp:
5436         case bp_longjmp_call_dummy:
5437         case bp_exception:
5438           this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5439           retval.is_longjmp = bptype != bp_exception;
5440           break;
5441         case bp_longjmp_resume:
5442         case bp_exception_resume:
5443           this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5444           retval.is_longjmp = bptype == bp_longjmp_resume;
5445           break;
5446         case bp_step_resume:
5447           if (bs->stop)
5448             this_action = BPSTAT_WHAT_STEP_RESUME;
5449           else
5450             {
5451               /* It is for the wrong frame.  */
5452               this_action = BPSTAT_WHAT_SINGLE;
5453             }
5454           break;
5455         case bp_hp_step_resume:
5456           if (bs->stop)
5457             this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5458           else
5459             {
5460               /* It is for the wrong frame.  */
5461               this_action = BPSTAT_WHAT_SINGLE;
5462             }
5463           break;
5464         case bp_watchpoint_scope:
5465         case bp_thread_event:
5466         case bp_overlay_event:
5467         case bp_longjmp_master:
5468         case bp_std_terminate_master:
5469         case bp_exception_master:
5470           this_action = BPSTAT_WHAT_SINGLE;
5471           break;
5472         case bp_catchpoint:
5473           if (bs->stop)
5474             {
5475               if (bs->print)
5476                 this_action = BPSTAT_WHAT_STOP_NOISY;
5477               else
5478                 this_action = BPSTAT_WHAT_STOP_SILENT;
5479             }
5480           else
5481             {
5482               /* There was a catchpoint, but we're not stopping.
5483                  This requires no further action.  */
5484             }
5485           break;
5486         case bp_jit_event:
5487           jit_event = 1;
5488           this_action = BPSTAT_WHAT_SINGLE;
5489           break;
5490         case bp_call_dummy:
5491           /* Make sure the action is stop (silent or noisy),
5492              so infrun.c pops the dummy frame.  */
5493           retval.call_dummy = STOP_STACK_DUMMY;
5494           this_action = BPSTAT_WHAT_STOP_SILENT;
5495           break;
5496         case bp_std_terminate:
5497           /* Make sure the action is stop (silent or noisy),
5498              so infrun.c pops the dummy frame.  */
5499           retval.call_dummy = STOP_STD_TERMINATE;
5500           this_action = BPSTAT_WHAT_STOP_SILENT;
5501           break;
5502         case bp_tracepoint:
5503         case bp_fast_tracepoint:
5504         case bp_static_tracepoint:
5505           /* Tracepoint hits should not be reported back to GDB, and
5506              if one got through somehow, it should have been filtered
5507              out already.  */
5508           internal_error (__FILE__, __LINE__,
5509                           _("bpstat_what: tracepoint encountered"));
5510           break;
5511         case bp_gnu_ifunc_resolver:
5512           /* Step over it (and insert bp_gnu_ifunc_resolver_return).  */
5513           this_action = BPSTAT_WHAT_SINGLE;
5514           break;
5515         case bp_gnu_ifunc_resolver_return:
5516           /* The breakpoint will be removed, execution will restart from the
5517              PC of the former breakpoint.  */
5518           this_action = BPSTAT_WHAT_KEEP_CHECKING;
5519           break;
5520
5521         case bp_dprintf:
5522           this_action = BPSTAT_WHAT_STOP_SILENT;
5523           break;
5524
5525         default:
5526           internal_error (__FILE__, __LINE__,
5527                           _("bpstat_what: unhandled bptype %d"), (int) bptype);
5528         }
5529
5530       retval.main_action = max (retval.main_action, this_action);
5531     }
5532
5533   /* These operations may affect the bs->breakpoint_at state so they are
5534      delayed after MAIN_ACTION is decided above.  */
5535
5536   if (jit_event)
5537     {
5538       if (debug_infrun)
5539         fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_jit_event\n");
5540
5541       handle_jit_event ();
5542     }
5543
5544   for (bs = bs_head; bs != NULL; bs = bs->next)
5545     {
5546       struct breakpoint *b = bs->breakpoint_at;
5547
5548       if (b == NULL)
5549         continue;
5550       switch (b->type)
5551         {
5552         case bp_gnu_ifunc_resolver:
5553           gnu_ifunc_resolver_stop (b);
5554           break;
5555         case bp_gnu_ifunc_resolver_return:
5556           gnu_ifunc_resolver_return_stop (b);
5557           break;
5558         }
5559     }
5560
5561   return retval;
5562 }
5563
5564 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5565    without hardware support).  This isn't related to a specific bpstat,
5566    just to things like whether watchpoints are set.  */
5567
5568 int
5569 bpstat_should_step (void)
5570 {
5571   struct breakpoint *b;
5572
5573   ALL_BREAKPOINTS (b)
5574     if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
5575       return 1;
5576   return 0;
5577 }
5578
5579 int
5580 bpstat_causes_stop (bpstat bs)
5581 {
5582   for (; bs != NULL; bs = bs->next)
5583     if (bs->stop)
5584       return 1;
5585
5586   return 0;
5587 }
5588
5589 \f
5590
5591 /* Compute a string of spaces suitable to indent the next line
5592    so it starts at the position corresponding to the table column
5593    named COL_NAME in the currently active table of UIOUT.  */
5594
5595 static char *
5596 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
5597 {
5598   static char wrap_indent[80];
5599   int i, total_width, width, align;
5600   char *text;
5601
5602   total_width = 0;
5603   for (i = 1; ui_out_query_field (uiout, i, &width, &align, &text); i++)
5604     {
5605       if (strcmp (text, col_name) == 0)
5606         {
5607           gdb_assert (total_width < sizeof wrap_indent);
5608           memset (wrap_indent, ' ', total_width);
5609           wrap_indent[total_width] = 0;
5610
5611           return wrap_indent;
5612         }
5613
5614       total_width += width + 1;
5615     }
5616
5617   return NULL;
5618 }
5619
5620 /* Determine if the locations of this breakpoint will have their conditions
5621    evaluated by the target, host or a mix of both.  Returns the following:
5622
5623     "host": Host evals condition.
5624     "host or target": Host or Target evals condition.
5625     "target": Target evals condition.
5626 */
5627
5628 static const char *
5629 bp_condition_evaluator (struct breakpoint *b)
5630 {
5631   struct bp_location *bl;
5632   char host_evals = 0;
5633   char target_evals = 0;
5634
5635   if (!b)
5636     return NULL;
5637
5638   if (!is_breakpoint (b))
5639     return NULL;
5640
5641   if (gdb_evaluates_breakpoint_condition_p ()
5642       || !target_supports_evaluation_of_breakpoint_conditions ())
5643     return condition_evaluation_host;
5644
5645   for (bl = b->loc; bl; bl = bl->next)
5646     {
5647       if (bl->cond_bytecode)
5648         target_evals++;
5649       else
5650         host_evals++;
5651     }
5652
5653   if (host_evals && target_evals)
5654     return condition_evaluation_both;
5655   else if (target_evals)
5656     return condition_evaluation_target;
5657   else
5658     return condition_evaluation_host;
5659 }
5660
5661 /* Determine the breakpoint location's condition evaluator.  This is
5662    similar to bp_condition_evaluator, but for locations.  */
5663
5664 static const char *
5665 bp_location_condition_evaluator (struct bp_location *bl)
5666 {
5667   if (bl && !is_breakpoint (bl->owner))
5668     return NULL;
5669
5670   if (gdb_evaluates_breakpoint_condition_p ()
5671       || !target_supports_evaluation_of_breakpoint_conditions ())
5672     return condition_evaluation_host;
5673
5674   if (bl && bl->cond_bytecode)
5675     return condition_evaluation_target;
5676   else
5677     return condition_evaluation_host;
5678 }
5679
5680 /* Print the LOC location out of the list of B->LOC locations.  */
5681
5682 static void
5683 print_breakpoint_location (struct breakpoint *b,
5684                            struct bp_location *loc)
5685 {
5686   struct ui_out *uiout = current_uiout;
5687   struct cleanup *old_chain = save_current_program_space ();
5688
5689   if (loc != NULL && loc->shlib_disabled)
5690     loc = NULL;
5691
5692   if (loc != NULL)
5693     set_current_program_space (loc->pspace);
5694
5695   if (b->display_canonical)
5696     ui_out_field_string (uiout, "what", b->addr_string);
5697   else if (loc && loc->symtab)
5698     {
5699       struct symbol *sym 
5700         = find_pc_sect_function (loc->address, loc->section);
5701       if (sym)
5702         {
5703           ui_out_text (uiout, "in ");
5704           ui_out_field_string (uiout, "func",
5705                                SYMBOL_PRINT_NAME (sym));
5706           ui_out_text (uiout, " ");
5707           ui_out_wrap_hint (uiout, wrap_indent_at_field (uiout, "what"));
5708           ui_out_text (uiout, "at ");
5709         }
5710       ui_out_field_string (uiout, "file",
5711                            symtab_to_filename_for_display (loc->symtab));
5712       ui_out_text (uiout, ":");
5713
5714       if (ui_out_is_mi_like_p (uiout))
5715         ui_out_field_string (uiout, "fullname",
5716                              symtab_to_fullname (loc->symtab));
5717       
5718       ui_out_field_int (uiout, "line", loc->line_number);
5719     }
5720   else if (loc)
5721     {
5722       struct ui_file *stb = mem_fileopen ();
5723       struct cleanup *stb_chain = make_cleanup_ui_file_delete (stb);
5724
5725       print_address_symbolic (loc->gdbarch, loc->address, stb,
5726                               demangle, "");
5727       ui_out_field_stream (uiout, "at", stb);
5728
5729       do_cleanups (stb_chain);
5730     }
5731   else
5732     ui_out_field_string (uiout, "pending", b->addr_string);
5733
5734   if (loc && is_breakpoint (b)
5735       && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5736       && bp_condition_evaluator (b) == condition_evaluation_both)
5737     {
5738       ui_out_text (uiout, " (");
5739       ui_out_field_string (uiout, "evaluated-by",
5740                            bp_location_condition_evaluator (loc));
5741       ui_out_text (uiout, ")");
5742     }
5743
5744   do_cleanups (old_chain);
5745 }
5746
5747 static const char *
5748 bptype_string (enum bptype type)
5749 {
5750   struct ep_type_description
5751     {
5752       enum bptype type;
5753       char *description;
5754     };
5755   static struct ep_type_description bptypes[] =
5756   {
5757     {bp_none, "?deleted?"},
5758     {bp_breakpoint, "breakpoint"},
5759     {bp_hardware_breakpoint, "hw breakpoint"},
5760     {bp_until, "until"},
5761     {bp_finish, "finish"},
5762     {bp_watchpoint, "watchpoint"},
5763     {bp_hardware_watchpoint, "hw watchpoint"},
5764     {bp_read_watchpoint, "read watchpoint"},
5765     {bp_access_watchpoint, "acc watchpoint"},
5766     {bp_longjmp, "longjmp"},
5767     {bp_longjmp_resume, "longjmp resume"},
5768     {bp_longjmp_call_dummy, "longjmp for call dummy"},
5769     {bp_exception, "exception"},
5770     {bp_exception_resume, "exception resume"},
5771     {bp_step_resume, "step resume"},
5772     {bp_hp_step_resume, "high-priority step resume"},
5773     {bp_watchpoint_scope, "watchpoint scope"},
5774     {bp_call_dummy, "call dummy"},
5775     {bp_std_terminate, "std::terminate"},
5776     {bp_shlib_event, "shlib events"},
5777     {bp_thread_event, "thread events"},
5778     {bp_overlay_event, "overlay events"},
5779     {bp_longjmp_master, "longjmp master"},
5780     {bp_std_terminate_master, "std::terminate master"},
5781     {bp_exception_master, "exception master"},
5782     {bp_catchpoint, "catchpoint"},
5783     {bp_tracepoint, "tracepoint"},
5784     {bp_fast_tracepoint, "fast tracepoint"},
5785     {bp_static_tracepoint, "static tracepoint"},
5786     {bp_dprintf, "dprintf"},
5787     {bp_jit_event, "jit events"},
5788     {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
5789     {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
5790   };
5791
5792   if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
5793       || ((int) type != bptypes[(int) type].type))
5794     internal_error (__FILE__, __LINE__,
5795                     _("bptypes table does not describe type #%d."),
5796                     (int) type);
5797
5798   return bptypes[(int) type].description;
5799 }
5800
5801 DEF_VEC_I(int);
5802
5803 /* For MI, output a field named 'thread-groups' with a list as the value.
5804    For CLI, prefix the list with the string 'inf'. */
5805
5806 static void
5807 output_thread_groups (struct ui_out *uiout,
5808                       const char *field_name,
5809                       VEC(int) *inf_num,
5810                       int mi_only)
5811 {
5812   struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
5813                                                                 field_name);
5814   int is_mi = ui_out_is_mi_like_p (uiout);
5815   int inf;
5816   int i;
5817
5818   /* For backward compatibility, don't display inferiors in CLI unless
5819      there are several.  Always display them for MI. */
5820   if (!is_mi && mi_only)
5821     return;
5822
5823   for (i = 0; VEC_iterate (int, inf_num, i, inf); ++i)
5824     {
5825       if (is_mi)
5826         {
5827           char mi_group[10];
5828
5829           xsnprintf (mi_group, sizeof (mi_group), "i%d", inf);
5830           ui_out_field_string (uiout, NULL, mi_group);
5831         }
5832       else
5833         {
5834           if (i == 0)
5835             ui_out_text (uiout, " inf ");
5836           else
5837             ui_out_text (uiout, ", ");
5838         
5839           ui_out_text (uiout, plongest (inf));
5840         }
5841     }
5842
5843   do_cleanups (back_to);
5844 }
5845
5846 /* Print B to gdb_stdout.  */
5847
5848 static void
5849 print_one_breakpoint_location (struct breakpoint *b,
5850                                struct bp_location *loc,
5851                                int loc_number,
5852                                struct bp_location **last_loc,
5853                                int allflag)
5854 {
5855   struct command_line *l;
5856   static char bpenables[] = "nynny";
5857
5858   struct ui_out *uiout = current_uiout;
5859   int header_of_multiple = 0;
5860   int part_of_multiple = (loc != NULL);
5861   struct value_print_options opts;
5862
5863   get_user_print_options (&opts);
5864
5865   gdb_assert (!loc || loc_number != 0);
5866   /* See comment in print_one_breakpoint concerning treatment of
5867      breakpoints with single disabled location.  */
5868   if (loc == NULL 
5869       && (b->loc != NULL 
5870           && (b->loc->next != NULL || !b->loc->enabled)))
5871     header_of_multiple = 1;
5872   if (loc == NULL)
5873     loc = b->loc;
5874
5875   annotate_record ();
5876
5877   /* 1 */
5878   annotate_field (0);
5879   if (part_of_multiple)
5880     {
5881       char *formatted;
5882       formatted = xstrprintf ("%d.%d", b->number, loc_number);
5883       ui_out_field_string (uiout, "number", formatted);
5884       xfree (formatted);
5885     }
5886   else
5887     {
5888       ui_out_field_int (uiout, "number", b->number);
5889     }
5890
5891   /* 2 */
5892   annotate_field (1);
5893   if (part_of_multiple)
5894     ui_out_field_skip (uiout, "type");
5895   else
5896     ui_out_field_string (uiout, "type", bptype_string (b->type));
5897
5898   /* 3 */
5899   annotate_field (2);
5900   if (part_of_multiple)
5901     ui_out_field_skip (uiout, "disp");
5902   else
5903     ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
5904
5905
5906   /* 4 */
5907   annotate_field (3);
5908   if (part_of_multiple)
5909     ui_out_field_string (uiout, "enabled", loc->enabled ? "y" : "n");
5910   else
5911     ui_out_field_fmt (uiout, "enabled", "%c", 
5912                       bpenables[(int) b->enable_state]);
5913   ui_out_spaces (uiout, 2);
5914
5915   
5916   /* 5 and 6 */
5917   if (b->ops != NULL && b->ops->print_one != NULL)
5918     {
5919       /* Although the print_one can possibly print all locations,
5920          calling it here is not likely to get any nice result.  So,
5921          make sure there's just one location.  */
5922       gdb_assert (b->loc == NULL || b->loc->next == NULL);
5923       b->ops->print_one (b, last_loc);
5924     }
5925   else
5926     switch (b->type)
5927       {
5928       case bp_none:
5929         internal_error (__FILE__, __LINE__,
5930                         _("print_one_breakpoint: bp_none encountered\n"));
5931         break;
5932
5933       case bp_watchpoint:
5934       case bp_hardware_watchpoint:
5935       case bp_read_watchpoint:
5936       case bp_access_watchpoint:
5937         {
5938           struct watchpoint *w = (struct watchpoint *) b;
5939
5940           /* Field 4, the address, is omitted (which makes the columns
5941              not line up too nicely with the headers, but the effect
5942              is relatively readable).  */
5943           if (opts.addressprint)
5944             ui_out_field_skip (uiout, "addr");
5945           annotate_field (5);
5946           ui_out_field_string (uiout, "what", w->exp_string);
5947         }
5948         break;
5949
5950       case bp_breakpoint:
5951       case bp_hardware_breakpoint:
5952       case bp_until:
5953       case bp_finish:
5954       case bp_longjmp:
5955       case bp_longjmp_resume:
5956       case bp_longjmp_call_dummy:
5957       case bp_exception:
5958       case bp_exception_resume:
5959       case bp_step_resume:
5960       case bp_hp_step_resume:
5961       case bp_watchpoint_scope:
5962       case bp_call_dummy:
5963       case bp_std_terminate:
5964       case bp_shlib_event:
5965       case bp_thread_event:
5966       case bp_overlay_event:
5967       case bp_longjmp_master:
5968       case bp_std_terminate_master:
5969       case bp_exception_master:
5970       case bp_tracepoint:
5971       case bp_fast_tracepoint:
5972       case bp_static_tracepoint:
5973       case bp_dprintf:
5974       case bp_jit_event:
5975       case bp_gnu_ifunc_resolver:
5976       case bp_gnu_ifunc_resolver_return:
5977         if (opts.addressprint)
5978           {
5979             annotate_field (4);
5980             if (header_of_multiple)
5981               ui_out_field_string (uiout, "addr", "<MULTIPLE>");
5982             else if (b->loc == NULL || loc->shlib_disabled)
5983               ui_out_field_string (uiout, "addr", "<PENDING>");
5984             else
5985               ui_out_field_core_addr (uiout, "addr",
5986                                       loc->gdbarch, loc->address);
5987           }
5988         annotate_field (5);
5989         if (!header_of_multiple)
5990           print_breakpoint_location (b, loc);
5991         if (b->loc)
5992           *last_loc = b->loc;
5993         break;
5994       }
5995
5996
5997   if (loc != NULL && !header_of_multiple)
5998     {
5999       struct inferior *inf;
6000       VEC(int) *inf_num = NULL;
6001       int mi_only = 1;
6002
6003       ALL_INFERIORS (inf)
6004         {
6005           if (inf->pspace == loc->pspace)
6006             VEC_safe_push (int, inf_num, inf->num);
6007         }
6008
6009         /* For backward compatibility, don't display inferiors in CLI unless
6010            there are several.  Always display for MI. */
6011         if (allflag
6012             || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6013                 && (number_of_program_spaces () > 1
6014                     || number_of_inferiors () > 1)
6015                 /* LOC is for existing B, it cannot be in
6016                    moribund_locations and thus having NULL OWNER.  */
6017                 && loc->owner->type != bp_catchpoint))
6018         mi_only = 0;
6019       output_thread_groups (uiout, "thread-groups", inf_num, mi_only);
6020       VEC_free (int, inf_num);
6021     }
6022
6023   if (!part_of_multiple)
6024     {
6025       if (b->thread != -1)
6026         {
6027           /* FIXME: This seems to be redundant and lost here; see the
6028              "stop only in" line a little further down.  */
6029           ui_out_text (uiout, " thread ");
6030           ui_out_field_int (uiout, "thread", b->thread);
6031         }
6032       else if (b->task != 0)
6033         {
6034           ui_out_text (uiout, " task ");
6035           ui_out_field_int (uiout, "task", b->task);
6036         }
6037     }
6038
6039   ui_out_text (uiout, "\n");
6040
6041   if (!part_of_multiple)
6042     b->ops->print_one_detail (b, uiout);
6043
6044   if (part_of_multiple && frame_id_p (b->frame_id))
6045     {
6046       annotate_field (6);
6047       ui_out_text (uiout, "\tstop only in stack frame at ");
6048       /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6049          the frame ID.  */
6050       ui_out_field_core_addr (uiout, "frame",
6051                               b->gdbarch, b->frame_id.stack_addr);
6052       ui_out_text (uiout, "\n");
6053     }
6054   
6055   if (!part_of_multiple && b->cond_string)
6056     {
6057       annotate_field (7);
6058       if (is_tracepoint (b))
6059         ui_out_text (uiout, "\ttrace only if ");
6060       else
6061         ui_out_text (uiout, "\tstop only if ");
6062       ui_out_field_string (uiout, "cond", b->cond_string);
6063
6064       /* Print whether the target is doing the breakpoint's condition
6065          evaluation.  If GDB is doing the evaluation, don't print anything.  */
6066       if (is_breakpoint (b)
6067           && breakpoint_condition_evaluation_mode ()
6068           == condition_evaluation_target)
6069         {
6070           ui_out_text (uiout, " (");
6071           ui_out_field_string (uiout, "evaluated-by",
6072                                bp_condition_evaluator (b));
6073           ui_out_text (uiout, " evals)");
6074         }
6075       ui_out_text (uiout, "\n");
6076     }
6077
6078   if (!part_of_multiple && b->thread != -1)
6079     {
6080       /* FIXME should make an annotation for this.  */
6081       ui_out_text (uiout, "\tstop only in thread ");
6082       ui_out_field_int (uiout, "thread", b->thread);
6083       ui_out_text (uiout, "\n");
6084     }
6085   
6086   if (!part_of_multiple)
6087     {
6088       if (b->hit_count)
6089         {
6090           /* FIXME should make an annotation for this.  */
6091           if (is_catchpoint (b))
6092             ui_out_text (uiout, "\tcatchpoint");
6093           else if (is_tracepoint (b))
6094             ui_out_text (uiout, "\ttracepoint");
6095           else
6096             ui_out_text (uiout, "\tbreakpoint");
6097           ui_out_text (uiout, " already hit ");
6098           ui_out_field_int (uiout, "times", b->hit_count);
6099           if (b->hit_count == 1)
6100             ui_out_text (uiout, " time\n");
6101           else
6102             ui_out_text (uiout, " times\n");
6103         }
6104       else
6105         {
6106           /* Output the count also if it is zero, but only if this is mi.  */
6107           if (ui_out_is_mi_like_p (uiout))
6108             ui_out_field_int (uiout, "times", b->hit_count);
6109         }
6110     }
6111
6112   if (!part_of_multiple && b->ignore_count)
6113     {
6114       annotate_field (8);
6115       ui_out_text (uiout, "\tignore next ");
6116       ui_out_field_int (uiout, "ignore", b->ignore_count);
6117       ui_out_text (uiout, " hits\n");
6118     }
6119
6120   /* Note that an enable count of 1 corresponds to "enable once"
6121      behavior, which is reported by the combination of enablement and
6122      disposition, so we don't need to mention it here.  */
6123   if (!part_of_multiple && b->enable_count > 1)
6124     {
6125       annotate_field (8);
6126       ui_out_text (uiout, "\tdisable after ");
6127       /* Tweak the wording to clarify that ignore and enable counts
6128          are distinct, and have additive effect.  */
6129       if (b->ignore_count)
6130         ui_out_text (uiout, "additional ");
6131       else
6132         ui_out_text (uiout, "next ");
6133       ui_out_field_int (uiout, "enable", b->enable_count);
6134       ui_out_text (uiout, " hits\n");
6135     }
6136
6137   if (!part_of_multiple && is_tracepoint (b))
6138     {
6139       struct tracepoint *tp = (struct tracepoint *) b;
6140
6141       if (tp->traceframe_usage)
6142         {
6143           ui_out_text (uiout, "\ttrace buffer usage ");
6144           ui_out_field_int (uiout, "traceframe-usage", tp->traceframe_usage);
6145           ui_out_text (uiout, " bytes\n");
6146         }
6147     }
6148
6149   l = b->commands ? b->commands->commands : NULL;
6150   if (!part_of_multiple && l)
6151     {
6152       struct cleanup *script_chain;
6153
6154       annotate_field (9);
6155       script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
6156       print_command_lines (uiout, l, 4);
6157       do_cleanups (script_chain);
6158     }
6159
6160   if (is_tracepoint (b))
6161     {
6162       struct tracepoint *t = (struct tracepoint *) b;
6163
6164       if (!part_of_multiple && t->pass_count)
6165         {
6166           annotate_field (10);
6167           ui_out_text (uiout, "\tpass count ");
6168           ui_out_field_int (uiout, "pass", t->pass_count);
6169           ui_out_text (uiout, " \n");
6170         }
6171
6172       /* Don't display it when tracepoint or tracepoint location is
6173          pending.   */
6174       if (!header_of_multiple && loc != NULL && !loc->shlib_disabled)
6175         {
6176           annotate_field (11);
6177
6178           if (ui_out_is_mi_like_p (uiout))
6179             ui_out_field_string (uiout, "installed",
6180                                  loc->inserted ? "y" : "n");
6181           else
6182             {
6183               if (loc->inserted)
6184                 ui_out_text (uiout, "\t");
6185               else
6186                 ui_out_text (uiout, "\tnot ");
6187               ui_out_text (uiout, "installed on target\n");
6188             }
6189         }
6190     }
6191
6192   if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
6193     {
6194       if (is_watchpoint (b))
6195         {
6196           struct watchpoint *w = (struct watchpoint *) b;
6197
6198           ui_out_field_string (uiout, "original-location", w->exp_string);
6199         }
6200       else if (b->addr_string)
6201         ui_out_field_string (uiout, "original-location", b->addr_string);
6202     }
6203 }
6204
6205 static void
6206 print_one_breakpoint (struct breakpoint *b,
6207                       struct bp_location **last_loc, 
6208                       int allflag)
6209 {
6210   struct cleanup *bkpt_chain;
6211   struct ui_out *uiout = current_uiout;
6212
6213   bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
6214
6215   print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
6216   do_cleanups (bkpt_chain);
6217
6218   /* If this breakpoint has custom print function,
6219      it's already printed.  Otherwise, print individual
6220      locations, if any.  */
6221   if (b->ops == NULL || b->ops->print_one == NULL)
6222     {
6223       /* If breakpoint has a single location that is disabled, we
6224          print it as if it had several locations, since otherwise it's
6225          hard to represent "breakpoint enabled, location disabled"
6226          situation.
6227
6228          Note that while hardware watchpoints have several locations
6229          internally, that's not a property exposed to user.  */
6230       if (b->loc 
6231           && !is_hardware_watchpoint (b)
6232           && (b->loc->next || !b->loc->enabled))
6233         {
6234           struct bp_location *loc;
6235           int n = 1;
6236
6237           for (loc = b->loc; loc; loc = loc->next, ++n)
6238             {
6239               struct cleanup *inner2 =
6240                 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
6241               print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6242               do_cleanups (inner2);
6243             }
6244         }
6245     }
6246 }
6247
6248 static int
6249 breakpoint_address_bits (struct breakpoint *b)
6250 {
6251   int print_address_bits = 0;
6252   struct bp_location *loc;
6253
6254   for (loc = b->loc; loc; loc = loc->next)
6255     {
6256       int addr_bit;
6257
6258       /* Software watchpoints that aren't watching memory don't have
6259          an address to print.  */
6260       if (b->type == bp_watchpoint && loc->watchpoint_type == -1)
6261         continue;
6262
6263       addr_bit = gdbarch_addr_bit (loc->gdbarch);
6264       if (addr_bit > print_address_bits)
6265         print_address_bits = addr_bit;
6266     }
6267
6268   return print_address_bits;
6269 }
6270
6271 struct captured_breakpoint_query_args
6272   {
6273     int bnum;
6274   };
6275
6276 static int
6277 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
6278 {
6279   struct captured_breakpoint_query_args *args = data;
6280   struct breakpoint *b;
6281   struct bp_location *dummy_loc = NULL;
6282
6283   ALL_BREAKPOINTS (b)
6284     {
6285       if (args->bnum == b->number)
6286         {
6287           print_one_breakpoint (b, &dummy_loc, 0);
6288           return GDB_RC_OK;
6289         }
6290     }
6291   return GDB_RC_NONE;
6292 }
6293
6294 enum gdb_rc
6295 gdb_breakpoint_query (struct ui_out *uiout, int bnum, 
6296                       char **error_message)
6297 {
6298   struct captured_breakpoint_query_args args;
6299
6300   args.bnum = bnum;
6301   /* For the moment we don't trust print_one_breakpoint() to not throw
6302      an error.  */
6303   if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
6304                                  error_message, RETURN_MASK_ALL) < 0)
6305     return GDB_RC_FAIL;
6306   else
6307     return GDB_RC_OK;
6308 }
6309
6310 /* Return true if this breakpoint was set by the user, false if it is
6311    internal or momentary.  */
6312
6313 int
6314 user_breakpoint_p (struct breakpoint *b)
6315 {
6316   return b->number > 0;
6317 }
6318
6319 /* Print information on user settable breakpoint (watchpoint, etc)
6320    number BNUM.  If BNUM is -1 print all user-settable breakpoints.
6321    If ALLFLAG is non-zero, include non-user-settable breakpoints.  If
6322    FILTER is non-NULL, call it on each breakpoint and only include the
6323    ones for which it returns non-zero.  Return the total number of
6324    breakpoints listed.  */
6325
6326 static int
6327 breakpoint_1 (char *args, int allflag, 
6328               int (*filter) (const struct breakpoint *))
6329 {
6330   struct breakpoint *b;
6331   struct bp_location *last_loc = NULL;
6332   int nr_printable_breakpoints;
6333   struct cleanup *bkpttbl_chain;
6334   struct value_print_options opts;
6335   int print_address_bits = 0;
6336   int print_type_col_width = 14;
6337   struct ui_out *uiout = current_uiout;
6338
6339   get_user_print_options (&opts);
6340
6341   /* Compute the number of rows in the table, as well as the size
6342      required for address fields.  */
6343   nr_printable_breakpoints = 0;
6344   ALL_BREAKPOINTS (b)
6345     {
6346       /* If we have a filter, only list the breakpoints it accepts.  */
6347       if (filter && !filter (b))
6348         continue;
6349
6350       /* If we have an "args" string, it is a list of breakpoints to 
6351          accept.  Skip the others.  */
6352       if (args != NULL && *args != '\0')
6353         {
6354           if (allflag && parse_and_eval_long (args) != b->number)
6355             continue;
6356           if (!allflag && !number_is_in_list (args, b->number))
6357             continue;
6358         }
6359
6360       if (allflag || user_breakpoint_p (b))
6361         {
6362           int addr_bit, type_len;
6363
6364           addr_bit = breakpoint_address_bits (b);
6365           if (addr_bit > print_address_bits)
6366             print_address_bits = addr_bit;
6367
6368           type_len = strlen (bptype_string (b->type));
6369           if (type_len > print_type_col_width)
6370             print_type_col_width = type_len;
6371
6372           nr_printable_breakpoints++;
6373         }
6374     }
6375
6376   if (opts.addressprint)
6377     bkpttbl_chain 
6378       = make_cleanup_ui_out_table_begin_end (uiout, 6,
6379                                              nr_printable_breakpoints,
6380                                              "BreakpointTable");
6381   else
6382     bkpttbl_chain 
6383       = make_cleanup_ui_out_table_begin_end (uiout, 5,
6384                                              nr_printable_breakpoints,
6385                                              "BreakpointTable");
6386
6387   if (nr_printable_breakpoints > 0)
6388     annotate_breakpoints_headers ();
6389   if (nr_printable_breakpoints > 0)
6390     annotate_field (0);
6391   ui_out_table_header (uiout, 7, ui_left, "number", "Num");     /* 1 */
6392   if (nr_printable_breakpoints > 0)
6393     annotate_field (1);
6394   ui_out_table_header (uiout, print_type_col_width, ui_left,
6395                        "type", "Type");                         /* 2 */
6396   if (nr_printable_breakpoints > 0)
6397     annotate_field (2);
6398   ui_out_table_header (uiout, 4, ui_left, "disp", "Disp");      /* 3 */
6399   if (nr_printable_breakpoints > 0)
6400     annotate_field (3);
6401   ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");    /* 4 */
6402   if (opts.addressprint)
6403     {
6404       if (nr_printable_breakpoints > 0)
6405         annotate_field (4);
6406       if (print_address_bits <= 32)
6407         ui_out_table_header (uiout, 10, ui_left, 
6408                              "addr", "Address");                /* 5 */
6409       else
6410         ui_out_table_header (uiout, 18, ui_left, 
6411                              "addr", "Address");                /* 5 */
6412     }
6413   if (nr_printable_breakpoints > 0)
6414     annotate_field (5);
6415   ui_out_table_header (uiout, 40, ui_noalign, "what", "What");  /* 6 */
6416   ui_out_table_body (uiout);
6417   if (nr_printable_breakpoints > 0)
6418     annotate_breakpoints_table ();
6419
6420   ALL_BREAKPOINTS (b)
6421     {
6422       QUIT;
6423       /* If we have a filter, only list the breakpoints it accepts.  */
6424       if (filter && !filter (b))
6425         continue;
6426
6427       /* If we have an "args" string, it is a list of breakpoints to 
6428          accept.  Skip the others.  */
6429
6430       if (args != NULL && *args != '\0')
6431         {
6432           if (allflag)  /* maintenance info breakpoint */
6433             {
6434               if (parse_and_eval_long (args) != b->number)
6435                 continue;
6436             }
6437           else          /* all others */
6438             {
6439               if (!number_is_in_list (args, b->number))
6440                 continue;
6441             }
6442         }
6443       /* We only print out user settable breakpoints unless the
6444          allflag is set.  */
6445       if (allflag || user_breakpoint_p (b))
6446         print_one_breakpoint (b, &last_loc, allflag);
6447     }
6448
6449   do_cleanups (bkpttbl_chain);
6450
6451   if (nr_printable_breakpoints == 0)
6452     {
6453       /* If there's a filter, let the caller decide how to report
6454          empty list.  */
6455       if (!filter)
6456         {
6457           if (args == NULL || *args == '\0')
6458             ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
6459           else
6460             ui_out_message (uiout, 0, 
6461                             "No breakpoint or watchpoint matching '%s'.\n",
6462                             args);
6463         }
6464     }
6465   else
6466     {
6467       if (last_loc && !server_command)
6468         set_next_address (last_loc->gdbarch, last_loc->address);
6469     }
6470
6471   /* FIXME?  Should this be moved up so that it is only called when
6472      there have been breakpoints? */
6473   annotate_breakpoints_table_end ();
6474
6475   return nr_printable_breakpoints;
6476 }
6477
6478 /* Display the value of default-collect in a way that is generally
6479    compatible with the breakpoint list.  */
6480
6481 static void
6482 default_collect_info (void)
6483 {
6484   struct ui_out *uiout = current_uiout;
6485
6486   /* If it has no value (which is frequently the case), say nothing; a
6487      message like "No default-collect." gets in user's face when it's
6488      not wanted.  */
6489   if (!*default_collect)
6490     return;
6491
6492   /* The following phrase lines up nicely with per-tracepoint collect
6493      actions.  */
6494   ui_out_text (uiout, "default collect ");
6495   ui_out_field_string (uiout, "default-collect", default_collect);
6496   ui_out_text (uiout, " \n");
6497 }
6498   
6499 static void
6500 breakpoints_info (char *args, int from_tty)
6501 {
6502   breakpoint_1 (args, 0, NULL);
6503
6504   default_collect_info ();
6505 }
6506
6507 static void
6508 watchpoints_info (char *args, int from_tty)
6509 {
6510   int num_printed = breakpoint_1 (args, 0, is_watchpoint);
6511   struct ui_out *uiout = current_uiout;
6512
6513   if (num_printed == 0)
6514     {
6515       if (args == NULL || *args == '\0')
6516         ui_out_message (uiout, 0, "No watchpoints.\n");
6517       else
6518         ui_out_message (uiout, 0, "No watchpoint matching '%s'.\n", args);
6519     }
6520 }
6521
6522 static void
6523 maintenance_info_breakpoints (char *args, int from_tty)
6524 {
6525   breakpoint_1 (args, 1, NULL);
6526
6527   default_collect_info ();
6528 }
6529
6530 static int
6531 breakpoint_has_pc (struct breakpoint *b,
6532                    struct program_space *pspace,
6533                    CORE_ADDR pc, struct obj_section *section)
6534 {
6535   struct bp_location *bl = b->loc;
6536
6537   for (; bl; bl = bl->next)
6538     {
6539       if (bl->pspace == pspace
6540           && bl->address == pc
6541           && (!overlay_debugging || bl->section == section))
6542         return 1;         
6543     }
6544   return 0;
6545 }
6546
6547 /* Print a message describing any user-breakpoints set at PC.  This
6548    concerns with logical breakpoints, so we match program spaces, not
6549    address spaces.  */
6550
6551 static void
6552 describe_other_breakpoints (struct gdbarch *gdbarch,
6553                             struct program_space *pspace, CORE_ADDR pc,
6554                             struct obj_section *section, int thread)
6555 {
6556   int others = 0;
6557   struct breakpoint *b;
6558
6559   ALL_BREAKPOINTS (b)
6560     others += (user_breakpoint_p (b)
6561                && breakpoint_has_pc (b, pspace, pc, section));
6562   if (others > 0)
6563     {
6564       if (others == 1)
6565         printf_filtered (_("Note: breakpoint "));
6566       else /* if (others == ???) */
6567         printf_filtered (_("Note: breakpoints "));
6568       ALL_BREAKPOINTS (b)
6569         if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
6570           {
6571             others--;
6572             printf_filtered ("%d", b->number);
6573             if (b->thread == -1 && thread != -1)
6574               printf_filtered (" (all threads)");
6575             else if (b->thread != -1)
6576               printf_filtered (" (thread %d)", b->thread);
6577             printf_filtered ("%s%s ",
6578                              ((b->enable_state == bp_disabled
6579                                || b->enable_state == bp_call_disabled)
6580                               ? " (disabled)"
6581                               : b->enable_state == bp_permanent 
6582                               ? " (permanent)"
6583                               : ""),
6584                              (others > 1) ? "," 
6585                              : ((others == 1) ? " and" : ""));
6586           }
6587       printf_filtered (_("also set at pc "));
6588       fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
6589       printf_filtered (".\n");
6590     }
6591 }
6592 \f
6593
6594 /* Return true iff it is meaningful to use the address member of
6595    BPT.  For some breakpoint types, the address member is irrelevant
6596    and it makes no sense to attempt to compare it to other addresses
6597    (or use it for any other purpose either).
6598
6599    More specifically, each of the following breakpoint types will
6600    always have a zero valued address and we don't want to mark
6601    breakpoints of any of these types to be a duplicate of an actual
6602    breakpoint at address zero:
6603
6604       bp_watchpoint
6605       bp_catchpoint
6606
6607 */
6608
6609 static int
6610 breakpoint_address_is_meaningful (struct breakpoint *bpt)
6611 {
6612   enum bptype type = bpt->type;
6613
6614   return (type != bp_watchpoint && type != bp_catchpoint);
6615 }
6616
6617 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6618    true if LOC1 and LOC2 represent the same watchpoint location.  */
6619
6620 static int
6621 watchpoint_locations_match (struct bp_location *loc1, 
6622                             struct bp_location *loc2)
6623 {
6624   struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
6625   struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
6626
6627   /* Both of them must exist.  */
6628   gdb_assert (w1 != NULL);
6629   gdb_assert (w2 != NULL);
6630
6631   /* If the target can evaluate the condition expression in hardware,
6632      then we we need to insert both watchpoints even if they are at
6633      the same place.  Otherwise the watchpoint will only trigger when
6634      the condition of whichever watchpoint was inserted evaluates to
6635      true, not giving a chance for GDB to check the condition of the
6636      other watchpoint.  */
6637   if ((w1->cond_exp
6638        && target_can_accel_watchpoint_condition (loc1->address, 
6639                                                  loc1->length,
6640                                                  loc1->watchpoint_type,
6641                                                  w1->cond_exp))
6642       || (w2->cond_exp
6643           && target_can_accel_watchpoint_condition (loc2->address, 
6644                                                     loc2->length,
6645                                                     loc2->watchpoint_type,
6646                                                     w2->cond_exp)))
6647     return 0;
6648
6649   /* Note that this checks the owner's type, not the location's.  In
6650      case the target does not support read watchpoints, but does
6651      support access watchpoints, we'll have bp_read_watchpoint
6652      watchpoints with hw_access locations.  Those should be considered
6653      duplicates of hw_read locations.  The hw_read locations will
6654      become hw_access locations later.  */
6655   return (loc1->owner->type == loc2->owner->type
6656           && loc1->pspace->aspace == loc2->pspace->aspace
6657           && loc1->address == loc2->address
6658           && loc1->length == loc2->length);
6659 }
6660
6661 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
6662    same breakpoint location.  In most targets, this can only be true
6663    if ASPACE1 matches ASPACE2.  On targets that have global
6664    breakpoints, the address space doesn't really matter.  */
6665
6666 static int
6667 breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
6668                           struct address_space *aspace2, CORE_ADDR addr2)
6669 {
6670   return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6671            || aspace1 == aspace2)
6672           && addr1 == addr2);
6673 }
6674
6675 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6676    {ASPACE1,ADDR1,LEN1}.  In most targets, this can only be true if ASPACE1
6677    matches ASPACE2.  On targets that have global breakpoints, the address
6678    space doesn't really matter.  */
6679
6680 static int
6681 breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
6682                                 int len1, struct address_space *aspace2,
6683                                 CORE_ADDR addr2)
6684 {
6685   return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6686            || aspace1 == aspace2)
6687           && addr2 >= addr1 && addr2 < addr1 + len1);
6688 }
6689
6690 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL.  BL may be
6691    a ranged breakpoint.  In most targets, a match happens only if ASPACE
6692    matches the breakpoint's address space.  On targets that have global
6693    breakpoints, the address space doesn't really matter.  */
6694
6695 static int
6696 breakpoint_location_address_match (struct bp_location *bl,
6697                                    struct address_space *aspace,
6698                                    CORE_ADDR addr)
6699 {
6700   return (breakpoint_address_match (bl->pspace->aspace, bl->address,
6701                                     aspace, addr)
6702           || (bl->length
6703               && breakpoint_address_match_range (bl->pspace->aspace,
6704                                                  bl->address, bl->length,
6705                                                  aspace, addr)));
6706 }
6707
6708 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6709    Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6710    true, otherwise returns false.  */
6711
6712 static int
6713 tracepoint_locations_match (struct bp_location *loc1,
6714                             struct bp_location *loc2)
6715 {
6716   if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
6717     /* Since tracepoint locations are never duplicated with others', tracepoint
6718        locations at the same address of different tracepoints are regarded as
6719        different locations.  */
6720     return (loc1->address == loc2->address && loc1->owner == loc2->owner);
6721   else
6722     return 0;
6723 }
6724
6725 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6726    (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6727    represent the same location.  */
6728
6729 static int
6730 breakpoint_locations_match (struct bp_location *loc1, 
6731                             struct bp_location *loc2)
6732 {
6733   int hw_point1, hw_point2;
6734
6735   /* Both of them must not be in moribund_locations.  */
6736   gdb_assert (loc1->owner != NULL);
6737   gdb_assert (loc2->owner != NULL);
6738
6739   hw_point1 = is_hardware_watchpoint (loc1->owner);
6740   hw_point2 = is_hardware_watchpoint (loc2->owner);
6741
6742   if (hw_point1 != hw_point2)
6743     return 0;
6744   else if (hw_point1)
6745     return watchpoint_locations_match (loc1, loc2);
6746   else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
6747     return tracepoint_locations_match (loc1, loc2);
6748   else
6749     /* We compare bp_location.length in order to cover ranged breakpoints.  */
6750     return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
6751                                      loc2->pspace->aspace, loc2->address)
6752             && loc1->length == loc2->length);
6753 }
6754
6755 static void
6756 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
6757                                int bnum, int have_bnum)
6758 {
6759   /* The longest string possibly returned by hex_string_custom
6760      is 50 chars.  These must be at least that big for safety.  */
6761   char astr1[64];
6762   char astr2[64];
6763
6764   strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
6765   strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
6766   if (have_bnum)
6767     warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6768              bnum, astr1, astr2);
6769   else
6770     warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
6771 }
6772
6773 /* Adjust a breakpoint's address to account for architectural
6774    constraints on breakpoint placement.  Return the adjusted address.
6775    Note: Very few targets require this kind of adjustment.  For most
6776    targets, this function is simply the identity function.  */
6777
6778 static CORE_ADDR
6779 adjust_breakpoint_address (struct gdbarch *gdbarch,
6780                            CORE_ADDR bpaddr, enum bptype bptype)
6781 {
6782   if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
6783     {
6784       /* Very few targets need any kind of breakpoint adjustment.  */
6785       return bpaddr;
6786     }
6787   else if (bptype == bp_watchpoint
6788            || bptype == bp_hardware_watchpoint
6789            || bptype == bp_read_watchpoint
6790            || bptype == bp_access_watchpoint
6791            || bptype == bp_catchpoint)
6792     {
6793       /* Watchpoints and the various bp_catch_* eventpoints should not
6794          have their addresses modified.  */
6795       return bpaddr;
6796     }
6797   else
6798     {
6799       CORE_ADDR adjusted_bpaddr;
6800
6801       /* Some targets have architectural constraints on the placement
6802          of breakpoint instructions.  Obtain the adjusted address.  */
6803       adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
6804
6805       /* An adjusted breakpoint address can significantly alter
6806          a user's expectations.  Print a warning if an adjustment
6807          is required.  */
6808       if (adjusted_bpaddr != bpaddr)
6809         breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
6810
6811       return adjusted_bpaddr;
6812     }
6813 }
6814
6815 void
6816 init_bp_location (struct bp_location *loc, const struct bp_location_ops *ops,
6817                   struct breakpoint *owner)
6818 {
6819   memset (loc, 0, sizeof (*loc));
6820
6821   gdb_assert (ops != NULL);
6822
6823   loc->ops = ops;
6824   loc->owner = owner;
6825   loc->cond = NULL;
6826   loc->cond_bytecode = NULL;
6827   loc->shlib_disabled = 0;
6828   loc->enabled = 1;
6829
6830   switch (owner->type)
6831     {
6832     case bp_breakpoint:
6833     case bp_until:
6834     case bp_finish:
6835     case bp_longjmp:
6836     case bp_longjmp_resume:
6837     case bp_longjmp_call_dummy:
6838     case bp_exception:
6839     case bp_exception_resume:
6840     case bp_step_resume:
6841     case bp_hp_step_resume:
6842     case bp_watchpoint_scope:
6843     case bp_call_dummy:
6844     case bp_std_terminate:
6845     case bp_shlib_event:
6846     case bp_thread_event:
6847     case bp_overlay_event:
6848     case bp_jit_event:
6849     case bp_longjmp_master:
6850     case bp_std_terminate_master:
6851     case bp_exception_master:
6852     case bp_gnu_ifunc_resolver:
6853     case bp_gnu_ifunc_resolver_return:
6854     case bp_dprintf:
6855       loc->loc_type = bp_loc_software_breakpoint;
6856       mark_breakpoint_location_modified (loc);
6857       break;
6858     case bp_hardware_breakpoint:
6859       loc->loc_type = bp_loc_hardware_breakpoint;
6860       mark_breakpoint_location_modified (loc);
6861       break;
6862     case bp_hardware_watchpoint:
6863     case bp_read_watchpoint:
6864     case bp_access_watchpoint:
6865       loc->loc_type = bp_loc_hardware_watchpoint;
6866       break;
6867     case bp_watchpoint:
6868     case bp_catchpoint:
6869     case bp_tracepoint:
6870     case bp_fast_tracepoint:
6871     case bp_static_tracepoint:
6872       loc->loc_type = bp_loc_other;
6873       break;
6874     default:
6875       internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
6876     }
6877
6878   loc->refc = 1;
6879 }
6880
6881 /* Allocate a struct bp_location.  */
6882
6883 static struct bp_location *
6884 allocate_bp_location (struct breakpoint *bpt)
6885 {
6886   return bpt->ops->allocate_location (bpt);
6887 }
6888
6889 static void
6890 free_bp_location (struct bp_location *loc)
6891 {
6892   loc->ops->dtor (loc);
6893   xfree (loc);
6894 }
6895
6896 /* Increment reference count.  */
6897
6898 static void
6899 incref_bp_location (struct bp_location *bl)
6900 {
6901   ++bl->refc;
6902 }
6903
6904 /* Decrement reference count.  If the reference count reaches 0,
6905    destroy the bp_location.  Sets *BLP to NULL.  */
6906
6907 static void
6908 decref_bp_location (struct bp_location **blp)
6909 {
6910   gdb_assert ((*blp)->refc > 0);
6911
6912   if (--(*blp)->refc == 0)
6913     free_bp_location (*blp);
6914   *blp = NULL;
6915 }
6916
6917 /* Add breakpoint B at the end of the global breakpoint chain.  */
6918
6919 static void
6920 add_to_breakpoint_chain (struct breakpoint *b)
6921 {
6922   struct breakpoint *b1;
6923
6924   /* Add this breakpoint to the end of the chain so that a list of
6925      breakpoints will come out in order of increasing numbers.  */
6926
6927   b1 = breakpoint_chain;
6928   if (b1 == 0)
6929     breakpoint_chain = b;
6930   else
6931     {
6932       while (b1->next)
6933         b1 = b1->next;
6934       b1->next = b;
6935     }
6936 }
6937
6938 /* Initializes breakpoint B with type BPTYPE and no locations yet.  */
6939
6940 static void
6941 init_raw_breakpoint_without_location (struct breakpoint *b,
6942                                       struct gdbarch *gdbarch,
6943                                       enum bptype bptype,
6944                                       const struct breakpoint_ops *ops)
6945 {
6946   memset (b, 0, sizeof (*b));
6947
6948   gdb_assert (ops != NULL);
6949
6950   b->ops = ops;
6951   b->type = bptype;
6952   b->gdbarch = gdbarch;
6953   b->language = current_language->la_language;
6954   b->input_radix = input_radix;
6955   b->thread = -1;
6956   b->enable_state = bp_enabled;
6957   b->next = 0;
6958   b->silent = 0;
6959   b->ignore_count = 0;
6960   b->commands = NULL;
6961   b->frame_id = null_frame_id;
6962   b->condition_not_parsed = 0;
6963   b->py_bp_object = NULL;
6964   b->related_breakpoint = b;
6965 }
6966
6967 /* Helper to set_raw_breakpoint below.  Creates a breakpoint
6968    that has type BPTYPE and has no locations as yet.  */
6969
6970 static struct breakpoint *
6971 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
6972                                      enum bptype bptype,
6973                                      const struct breakpoint_ops *ops)
6974 {
6975   struct breakpoint *b = XNEW (struct breakpoint);
6976
6977   init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
6978   add_to_breakpoint_chain (b);
6979   return b;
6980 }
6981
6982 /* Initialize loc->function_name.  EXPLICIT_LOC says no indirect function
6983    resolutions should be made as the user specified the location explicitly
6984    enough.  */
6985
6986 static void
6987 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
6988 {
6989   gdb_assert (loc->owner != NULL);
6990
6991   if (loc->owner->type == bp_breakpoint
6992       || loc->owner->type == bp_hardware_breakpoint
6993       || is_tracepoint (loc->owner))
6994     {
6995       int is_gnu_ifunc;
6996       const char *function_name;
6997       CORE_ADDR func_addr;
6998
6999       find_pc_partial_function_gnu_ifunc (loc->address, &function_name,
7000                                           &func_addr, NULL, &is_gnu_ifunc);
7001
7002       if (is_gnu_ifunc && !explicit_loc)
7003         {
7004           struct breakpoint *b = loc->owner;
7005
7006           gdb_assert (loc->pspace == current_program_space);
7007           if (gnu_ifunc_resolve_name (function_name,
7008                                       &loc->requested_address))
7009             {
7010               /* Recalculate ADDRESS based on new REQUESTED_ADDRESS.  */
7011               loc->address = adjust_breakpoint_address (loc->gdbarch,
7012                                                         loc->requested_address,
7013                                                         b->type);
7014             }
7015           else if (b->type == bp_breakpoint && b->loc == loc
7016                    && loc->next == NULL && b->related_breakpoint == b)
7017             {
7018               /* Create only the whole new breakpoint of this type but do not
7019                  mess more complicated breakpoints with multiple locations.  */
7020               b->type = bp_gnu_ifunc_resolver;
7021               /* Remember the resolver's address for use by the return
7022                  breakpoint.  */
7023               loc->related_address = func_addr;
7024             }
7025         }
7026
7027       if (function_name)
7028         loc->function_name = xstrdup (function_name);
7029     }
7030 }
7031
7032 /* Attempt to determine architecture of location identified by SAL.  */
7033 struct gdbarch *
7034 get_sal_arch (struct symtab_and_line sal)
7035 {
7036   if (sal.section)
7037     return get_objfile_arch (sal.section->objfile);
7038   if (sal.symtab)
7039     return get_objfile_arch (sal.symtab->objfile);
7040
7041   return NULL;
7042 }
7043
7044 /* Low level routine for partially initializing a breakpoint of type
7045    BPTYPE.  The newly created breakpoint's address, section, source
7046    file name, and line number are provided by SAL.
7047
7048    It is expected that the caller will complete the initialization of
7049    the newly created breakpoint struct as well as output any status
7050    information regarding the creation of a new breakpoint.  */
7051
7052 static void
7053 init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
7054                      struct symtab_and_line sal, enum bptype bptype,
7055                      const struct breakpoint_ops *ops)
7056 {
7057   init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
7058
7059   add_location_to_breakpoint (b, &sal);
7060
7061   if (bptype != bp_catchpoint)
7062     gdb_assert (sal.pspace != NULL);
7063
7064   /* Store the program space that was used to set the breakpoint,
7065      except for ordinary breakpoints, which are independent of the
7066      program space.  */
7067   if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
7068     b->pspace = sal.pspace;
7069 }
7070
7071 /* set_raw_breakpoint is a low level routine for allocating and
7072    partially initializing a breakpoint of type BPTYPE.  The newly
7073    created breakpoint's address, section, source file name, and line
7074    number are provided by SAL.  The newly created and partially
7075    initialized breakpoint is added to the breakpoint chain and
7076    is also returned as the value of this function.
7077
7078    It is expected that the caller will complete the initialization of
7079    the newly created breakpoint struct as well as output any status
7080    information regarding the creation of a new breakpoint.  In
7081    particular, set_raw_breakpoint does NOT set the breakpoint
7082    number!  Care should be taken to not allow an error to occur
7083    prior to completing the initialization of the breakpoint.  If this
7084    should happen, a bogus breakpoint will be left on the chain.  */
7085
7086 struct breakpoint *
7087 set_raw_breakpoint (struct gdbarch *gdbarch,
7088                     struct symtab_and_line sal, enum bptype bptype,
7089                     const struct breakpoint_ops *ops)
7090 {
7091   struct breakpoint *b = XNEW (struct breakpoint);
7092
7093   init_raw_breakpoint (b, gdbarch, sal, bptype, ops);
7094   add_to_breakpoint_chain (b);
7095   return b;
7096 }
7097
7098
7099 /* Note that the breakpoint object B describes a permanent breakpoint
7100    instruction, hard-wired into the inferior's code.  */
7101 void
7102 make_breakpoint_permanent (struct breakpoint *b)
7103 {
7104   struct bp_location *bl;
7105
7106   b->enable_state = bp_permanent;
7107
7108   /* By definition, permanent breakpoints are already present in the
7109      code.  Mark all locations as inserted.  For now,
7110      make_breakpoint_permanent is called in just one place, so it's
7111      hard to say if it's reasonable to have permanent breakpoint with
7112      multiple locations or not, but it's easy to implement.  */
7113   for (bl = b->loc; bl; bl = bl->next)
7114     bl->inserted = 1;
7115 }
7116
7117 /* Call this routine when stepping and nexting to enable a breakpoint
7118    if we do a longjmp() or 'throw' in TP.  FRAME is the frame which
7119    initiated the operation.  */
7120
7121 void
7122 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
7123 {
7124   struct breakpoint *b, *b_tmp;
7125   int thread = tp->num;
7126
7127   /* To avoid having to rescan all objfile symbols at every step,
7128      we maintain a list of continually-inserted but always disabled
7129      longjmp "master" breakpoints.  Here, we simply create momentary
7130      clones of those and enable them for the requested thread.  */
7131   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7132     if (b->pspace == current_program_space
7133         && (b->type == bp_longjmp_master
7134             || b->type == bp_exception_master))
7135       {
7136         enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7137         struct breakpoint *clone;
7138
7139         /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7140            after their removal.  */
7141         clone = momentary_breakpoint_from_master (b, type,
7142                                                   &longjmp_breakpoint_ops);
7143         clone->thread = thread;
7144       }
7145
7146   tp->initiating_frame = frame;
7147 }
7148
7149 /* Delete all longjmp breakpoints from THREAD.  */
7150 void
7151 delete_longjmp_breakpoint (int thread)
7152 {
7153   struct breakpoint *b, *b_tmp;
7154
7155   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7156     if (b->type == bp_longjmp || b->type == bp_exception)
7157       {
7158         if (b->thread == thread)
7159           delete_breakpoint (b);
7160       }
7161 }
7162
7163 void
7164 delete_longjmp_breakpoint_at_next_stop (int thread)
7165 {
7166   struct breakpoint *b, *b_tmp;
7167
7168   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7169     if (b->type == bp_longjmp || b->type == bp_exception)
7170       {
7171         if (b->thread == thread)
7172           b->disposition = disp_del_at_next_stop;
7173       }
7174 }
7175
7176 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7177    INFERIOR_PTID thread.  Chain them all by RELATED_BREAKPOINT and return
7178    pointer to any of them.  Return NULL if this system cannot place longjmp
7179    breakpoints.  */
7180
7181 struct breakpoint *
7182 set_longjmp_breakpoint_for_call_dummy (void)
7183 {
7184   struct breakpoint *b, *retval = NULL;
7185
7186   ALL_BREAKPOINTS (b)
7187     if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7188       {
7189         struct breakpoint *new_b;
7190
7191         new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
7192                                                   &momentary_breakpoint_ops);
7193         new_b->thread = pid_to_thread_id (inferior_ptid);
7194
7195         /* Link NEW_B into the chain of RETVAL breakpoints.  */
7196
7197         gdb_assert (new_b->related_breakpoint == new_b);
7198         if (retval == NULL)
7199           retval = new_b;
7200         new_b->related_breakpoint = retval;
7201         while (retval->related_breakpoint != new_b->related_breakpoint)
7202           retval = retval->related_breakpoint;
7203         retval->related_breakpoint = new_b;
7204       }
7205
7206   return retval;
7207 }
7208
7209 /* Verify all existing dummy frames and their associated breakpoints for
7210    THREAD.  Remove those which can no longer be found in the current frame
7211    stack.
7212
7213    You should call this function only at places where it is safe to currently
7214    unwind the whole stack.  Failed stack unwind would discard live dummy
7215    frames.  */
7216
7217 void
7218 check_longjmp_breakpoint_for_call_dummy (int thread)
7219 {
7220   struct breakpoint *b, *b_tmp;
7221
7222   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7223     if (b->type == bp_longjmp_call_dummy && b->thread == thread)
7224       {
7225         struct breakpoint *dummy_b = b->related_breakpoint;
7226
7227         while (dummy_b != b && dummy_b->type != bp_call_dummy)
7228           dummy_b = dummy_b->related_breakpoint;
7229         if (dummy_b->type != bp_call_dummy
7230             || frame_find_by_id (dummy_b->frame_id) != NULL)
7231           continue;
7232         
7233         dummy_frame_discard (dummy_b->frame_id);
7234
7235         while (b->related_breakpoint != b)
7236           {
7237             if (b_tmp == b->related_breakpoint)
7238               b_tmp = b->related_breakpoint->next;
7239             delete_breakpoint (b->related_breakpoint);
7240           }
7241         delete_breakpoint (b);
7242       }
7243 }
7244
7245 void
7246 enable_overlay_breakpoints (void)
7247 {
7248   struct breakpoint *b;
7249
7250   ALL_BREAKPOINTS (b)
7251     if (b->type == bp_overlay_event)
7252     {
7253       b->enable_state = bp_enabled;
7254       update_global_location_list (1);
7255       overlay_events_enabled = 1;
7256     }
7257 }
7258
7259 void
7260 disable_overlay_breakpoints (void)
7261 {
7262   struct breakpoint *b;
7263
7264   ALL_BREAKPOINTS (b)
7265     if (b->type == bp_overlay_event)
7266     {
7267       b->enable_state = bp_disabled;
7268       update_global_location_list (0);
7269       overlay_events_enabled = 0;
7270     }
7271 }
7272
7273 /* Set an active std::terminate breakpoint for each std::terminate
7274    master breakpoint.  */
7275 void
7276 set_std_terminate_breakpoint (void)
7277 {
7278   struct breakpoint *b, *b_tmp;
7279
7280   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7281     if (b->pspace == current_program_space
7282         && b->type == bp_std_terminate_master)
7283       {
7284         momentary_breakpoint_from_master (b, bp_std_terminate,
7285                                           &momentary_breakpoint_ops);
7286       }
7287 }
7288
7289 /* Delete all the std::terminate breakpoints.  */
7290 void
7291 delete_std_terminate_breakpoint (void)
7292 {
7293   struct breakpoint *b, *b_tmp;
7294
7295   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7296     if (b->type == bp_std_terminate)
7297       delete_breakpoint (b);
7298 }
7299
7300 struct breakpoint *
7301 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7302 {
7303   struct breakpoint *b;
7304
7305   b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7306                                   &internal_breakpoint_ops);
7307
7308   b->enable_state = bp_enabled;
7309   /* addr_string has to be used or breakpoint_re_set will delete me.  */
7310   b->addr_string
7311     = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
7312
7313   update_global_location_list_nothrow (1);
7314
7315   return b;
7316 }
7317
7318 void
7319 remove_thread_event_breakpoints (void)
7320 {
7321   struct breakpoint *b, *b_tmp;
7322
7323   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7324     if (b->type == bp_thread_event
7325         && b->loc->pspace == current_program_space)
7326       delete_breakpoint (b);
7327 }
7328
7329 struct lang_and_radix
7330   {
7331     enum language lang;
7332     int radix;
7333   };
7334
7335 /* Create a breakpoint for JIT code registration and unregistration.  */
7336
7337 struct breakpoint *
7338 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7339 {
7340   struct breakpoint *b;
7341
7342   b = create_internal_breakpoint (gdbarch, address, bp_jit_event,
7343                                   &internal_breakpoint_ops);
7344   update_global_location_list_nothrow (1);
7345   return b;
7346 }
7347
7348 /* Remove JIT code registration and unregistration breakpoint(s).  */
7349
7350 void
7351 remove_jit_event_breakpoints (void)
7352 {
7353   struct breakpoint *b, *b_tmp;
7354
7355   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7356     if (b->type == bp_jit_event
7357         && b->loc->pspace == current_program_space)
7358       delete_breakpoint (b);
7359 }
7360
7361 void
7362 remove_solib_event_breakpoints (void)
7363 {
7364   struct breakpoint *b, *b_tmp;
7365
7366   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7367     if (b->type == bp_shlib_event
7368         && b->loc->pspace == current_program_space)
7369       delete_breakpoint (b);
7370 }
7371
7372 struct breakpoint *
7373 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7374 {
7375   struct breakpoint *b;
7376
7377   b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7378                                   &internal_breakpoint_ops);
7379   update_global_location_list_nothrow (1);
7380   return b;
7381 }
7382
7383 /* Disable any breakpoints that are on code in shared libraries.  Only
7384    apply to enabled breakpoints, disabled ones can just stay disabled.  */
7385
7386 void
7387 disable_breakpoints_in_shlibs (void)
7388 {
7389   struct bp_location *loc, **locp_tmp;
7390
7391   ALL_BP_LOCATIONS (loc, locp_tmp)
7392   {
7393     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7394     struct breakpoint *b = loc->owner;
7395
7396     /* We apply the check to all breakpoints, including disabled for
7397        those with loc->duplicate set.  This is so that when breakpoint
7398        becomes enabled, or the duplicate is removed, gdb will try to
7399        insert all breakpoints.  If we don't set shlib_disabled here,
7400        we'll try to insert those breakpoints and fail.  */
7401     if (((b->type == bp_breakpoint)
7402          || (b->type == bp_jit_event)
7403          || (b->type == bp_hardware_breakpoint)
7404          || (is_tracepoint (b)))
7405         && loc->pspace == current_program_space
7406         && !loc->shlib_disabled
7407 #ifdef PC_SOLIB
7408         && PC_SOLIB (loc->address)
7409 #else
7410         && solib_name_from_address (loc->pspace, loc->address)
7411 #endif
7412         )
7413       {
7414         loc->shlib_disabled = 1;
7415       }
7416   }
7417 }
7418
7419 /* Disable any breakpoints and tracepoints that are in an unloaded shared
7420    library.  Only apply to enabled breakpoints, disabled ones can just stay
7421    disabled.  */
7422
7423 static void
7424 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7425 {
7426   struct bp_location *loc, **locp_tmp;
7427   int disabled_shlib_breaks = 0;
7428
7429   /* SunOS a.out shared libraries are always mapped, so do not
7430      disable breakpoints; they will only be reported as unloaded
7431      through clear_solib when GDB discards its shared library
7432      list.  See clear_solib for more information.  */
7433   if (exec_bfd != NULL
7434       && bfd_get_flavour (exec_bfd) == bfd_target_aout_flavour)
7435     return;
7436
7437   ALL_BP_LOCATIONS (loc, locp_tmp)
7438   {
7439     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7440     struct breakpoint *b = loc->owner;
7441
7442     if (solib->pspace == loc->pspace
7443         && !loc->shlib_disabled
7444         && (((b->type == bp_breakpoint
7445               || b->type == bp_jit_event
7446               || b->type == bp_hardware_breakpoint)
7447              && (loc->loc_type == bp_loc_hardware_breakpoint
7448                  || loc->loc_type == bp_loc_software_breakpoint))
7449             || is_tracepoint (b))
7450         && solib_contains_address_p (solib, loc->address))
7451       {
7452         loc->shlib_disabled = 1;
7453         /* At this point, we cannot rely on remove_breakpoint
7454            succeeding so we must mark the breakpoint as not inserted
7455            to prevent future errors occurring in remove_breakpoints.  */
7456         loc->inserted = 0;
7457
7458         /* This may cause duplicate notifications for the same breakpoint.  */
7459         observer_notify_breakpoint_modified (b);
7460
7461         if (!disabled_shlib_breaks)
7462           {
7463             target_terminal_ours_for_output ();
7464             warning (_("Temporarily disabling breakpoints "
7465                        "for unloaded shared library \"%s\""),
7466                      solib->so_name);
7467           }
7468         disabled_shlib_breaks = 1;
7469       }
7470   }
7471 }
7472
7473 /* FORK & VFORK catchpoints.  */
7474
7475 /* An instance of this type is used to represent a fork or vfork
7476    catchpoint.  It includes a "struct breakpoint" as a kind of base
7477    class; users downcast to "struct breakpoint *" when needed.  A
7478    breakpoint is really of this type iff its ops pointer points to
7479    CATCH_FORK_BREAKPOINT_OPS.  */
7480
7481 struct fork_catchpoint
7482 {
7483   /* The base class.  */
7484   struct breakpoint base;
7485
7486   /* Process id of a child process whose forking triggered this
7487      catchpoint.  This field is only valid immediately after this
7488      catchpoint has triggered.  */
7489   ptid_t forked_inferior_pid;
7490 };
7491
7492 /* Implement the "insert" breakpoint_ops method for fork
7493    catchpoints.  */
7494
7495 static int
7496 insert_catch_fork (struct bp_location *bl)
7497 {
7498   return target_insert_fork_catchpoint (PIDGET (inferior_ptid));
7499 }
7500
7501 /* Implement the "remove" breakpoint_ops method for fork
7502    catchpoints.  */
7503
7504 static int
7505 remove_catch_fork (struct bp_location *bl)
7506 {
7507   return target_remove_fork_catchpoint (PIDGET (inferior_ptid));
7508 }
7509
7510 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7511    catchpoints.  */
7512
7513 static int
7514 breakpoint_hit_catch_fork (const struct bp_location *bl,
7515                            struct address_space *aspace, CORE_ADDR bp_addr,
7516                            const struct target_waitstatus *ws)
7517 {
7518   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7519
7520   if (ws->kind != TARGET_WAITKIND_FORKED)
7521     return 0;
7522
7523   c->forked_inferior_pid = ws->value.related_pid;
7524   return 1;
7525 }
7526
7527 /* Implement the "print_it" breakpoint_ops method for fork
7528    catchpoints.  */
7529
7530 static enum print_stop_action
7531 print_it_catch_fork (bpstat bs)
7532 {
7533   struct ui_out *uiout = current_uiout;
7534   struct breakpoint *b = bs->breakpoint_at;
7535   struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
7536
7537   annotate_catchpoint (b->number);
7538   if (b->disposition == disp_del)
7539     ui_out_text (uiout, "\nTemporary catchpoint ");
7540   else
7541     ui_out_text (uiout, "\nCatchpoint ");
7542   if (ui_out_is_mi_like_p (uiout))
7543     {
7544       ui_out_field_string (uiout, "reason",
7545                            async_reason_lookup (EXEC_ASYNC_FORK));
7546       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7547     }
7548   ui_out_field_int (uiout, "bkptno", b->number);
7549   ui_out_text (uiout, " (forked process ");
7550   ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
7551   ui_out_text (uiout, "), ");
7552   return PRINT_SRC_AND_LOC;
7553 }
7554
7555 /* Implement the "print_one" breakpoint_ops method for fork
7556    catchpoints.  */
7557
7558 static void
7559 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
7560 {
7561   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7562   struct value_print_options opts;
7563   struct ui_out *uiout = current_uiout;
7564
7565   get_user_print_options (&opts);
7566
7567   /* Field 4, the address, is omitted (which makes the columns not
7568      line up too nicely with the headers, but the effect is relatively
7569      readable).  */
7570   if (opts.addressprint)
7571     ui_out_field_skip (uiout, "addr");
7572   annotate_field (5);
7573   ui_out_text (uiout, "fork");
7574   if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7575     {
7576       ui_out_text (uiout, ", process ");
7577       ui_out_field_int (uiout, "what",
7578                         ptid_get_pid (c->forked_inferior_pid));
7579       ui_out_spaces (uiout, 1);
7580     }
7581
7582   if (ui_out_is_mi_like_p (uiout))
7583     ui_out_field_string (uiout, "catch-type", "fork");
7584 }
7585
7586 /* Implement the "print_mention" breakpoint_ops method for fork
7587    catchpoints.  */
7588
7589 static void
7590 print_mention_catch_fork (struct breakpoint *b)
7591 {
7592   printf_filtered (_("Catchpoint %d (fork)"), b->number);
7593 }
7594
7595 /* Implement the "print_recreate" breakpoint_ops method for fork
7596    catchpoints.  */
7597
7598 static void
7599 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
7600 {
7601   fprintf_unfiltered (fp, "catch fork");
7602   print_recreate_thread (b, fp);
7603 }
7604
7605 /* The breakpoint_ops structure to be used in fork catchpoints.  */
7606
7607 static struct breakpoint_ops catch_fork_breakpoint_ops;
7608
7609 /* Implement the "insert" breakpoint_ops method for vfork
7610    catchpoints.  */
7611
7612 static int
7613 insert_catch_vfork (struct bp_location *bl)
7614 {
7615   return target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
7616 }
7617
7618 /* Implement the "remove" breakpoint_ops method for vfork
7619    catchpoints.  */
7620
7621 static int
7622 remove_catch_vfork (struct bp_location *bl)
7623 {
7624   return target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
7625 }
7626
7627 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7628    catchpoints.  */
7629
7630 static int
7631 breakpoint_hit_catch_vfork (const struct bp_location *bl,
7632                             struct address_space *aspace, CORE_ADDR bp_addr,
7633                             const struct target_waitstatus *ws)
7634 {
7635   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7636
7637   if (ws->kind != TARGET_WAITKIND_VFORKED)
7638     return 0;
7639
7640   c->forked_inferior_pid = ws->value.related_pid;
7641   return 1;
7642 }
7643
7644 /* Implement the "print_it" breakpoint_ops method for vfork
7645    catchpoints.  */
7646
7647 static enum print_stop_action
7648 print_it_catch_vfork (bpstat bs)
7649 {
7650   struct ui_out *uiout = current_uiout;
7651   struct breakpoint *b = bs->breakpoint_at;
7652   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7653
7654   annotate_catchpoint (b->number);
7655   if (b->disposition == disp_del)
7656     ui_out_text (uiout, "\nTemporary catchpoint ");
7657   else
7658     ui_out_text (uiout, "\nCatchpoint ");
7659   if (ui_out_is_mi_like_p (uiout))
7660     {
7661       ui_out_field_string (uiout, "reason",
7662                            async_reason_lookup (EXEC_ASYNC_VFORK));
7663       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7664     }
7665   ui_out_field_int (uiout, "bkptno", b->number);
7666   ui_out_text (uiout, " (vforked process ");
7667   ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
7668   ui_out_text (uiout, "), ");
7669   return PRINT_SRC_AND_LOC;
7670 }
7671
7672 /* Implement the "print_one" breakpoint_ops method for vfork
7673    catchpoints.  */
7674
7675 static void
7676 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
7677 {
7678   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7679   struct value_print_options opts;
7680   struct ui_out *uiout = current_uiout;
7681
7682   get_user_print_options (&opts);
7683   /* Field 4, the address, is omitted (which makes the columns not
7684      line up too nicely with the headers, but the effect is relatively
7685      readable).  */
7686   if (opts.addressprint)
7687     ui_out_field_skip (uiout, "addr");
7688   annotate_field (5);
7689   ui_out_text (uiout, "vfork");
7690   if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7691     {
7692       ui_out_text (uiout, ", process ");
7693       ui_out_field_int (uiout, "what",
7694                         ptid_get_pid (c->forked_inferior_pid));
7695       ui_out_spaces (uiout, 1);
7696     }
7697
7698   if (ui_out_is_mi_like_p (uiout))
7699     ui_out_field_string (uiout, "catch-type", "vfork");
7700 }
7701
7702 /* Implement the "print_mention" breakpoint_ops method for vfork
7703    catchpoints.  */
7704
7705 static void
7706 print_mention_catch_vfork (struct breakpoint *b)
7707 {
7708   printf_filtered (_("Catchpoint %d (vfork)"), b->number);
7709 }
7710
7711 /* Implement the "print_recreate" breakpoint_ops method for vfork
7712    catchpoints.  */
7713
7714 static void
7715 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
7716 {
7717   fprintf_unfiltered (fp, "catch vfork");
7718   print_recreate_thread (b, fp);
7719 }
7720
7721 /* The breakpoint_ops structure to be used in vfork catchpoints.  */
7722
7723 static struct breakpoint_ops catch_vfork_breakpoint_ops;
7724
7725 /* An instance of this type is used to represent an solib catchpoint.
7726    It includes a "struct breakpoint" as a kind of base class; users
7727    downcast to "struct breakpoint *" when needed.  A breakpoint is
7728    really of this type iff its ops pointer points to
7729    CATCH_SOLIB_BREAKPOINT_OPS.  */
7730
7731 struct solib_catchpoint
7732 {
7733   /* The base class.  */
7734   struct breakpoint base;
7735
7736   /* True for "catch load", false for "catch unload".  */
7737   unsigned char is_load;
7738
7739   /* Regular expression to match, if any.  COMPILED is only valid when
7740      REGEX is non-NULL.  */
7741   char *regex;
7742   regex_t compiled;
7743 };
7744
7745 static void
7746 dtor_catch_solib (struct breakpoint *b)
7747 {
7748   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7749
7750   if (self->regex)
7751     regfree (&self->compiled);
7752   xfree (self->regex);
7753
7754   base_breakpoint_ops.dtor (b);
7755 }
7756
7757 static int
7758 insert_catch_solib (struct bp_location *ignore)
7759 {
7760   return 0;
7761 }
7762
7763 static int
7764 remove_catch_solib (struct bp_location *ignore)
7765 {
7766   return 0;
7767 }
7768
7769 static int
7770 breakpoint_hit_catch_solib (const struct bp_location *bl,
7771                             struct address_space *aspace,
7772                             CORE_ADDR bp_addr,
7773                             const struct target_waitstatus *ws)
7774 {
7775   struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
7776   struct breakpoint *other;
7777
7778   if (ws->kind == TARGET_WAITKIND_LOADED)
7779     return 1;
7780
7781   ALL_BREAKPOINTS (other)
7782   {
7783     struct bp_location *other_bl;
7784
7785     if (other == bl->owner)
7786       continue;
7787
7788     if (other->type != bp_shlib_event)
7789       continue;
7790
7791     if (self->base.pspace != NULL && other->pspace != self->base.pspace)
7792       continue;
7793
7794     for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
7795       {
7796         if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
7797           return 1;
7798       }
7799   }
7800
7801   return 0;
7802 }
7803
7804 static void
7805 check_status_catch_solib (struct bpstats *bs)
7806 {
7807   struct solib_catchpoint *self
7808     = (struct solib_catchpoint *) bs->breakpoint_at;
7809   int ix;
7810
7811   if (self->is_load)
7812     {
7813       struct so_list *iter;
7814
7815       for (ix = 0;
7816            VEC_iterate (so_list_ptr, current_program_space->added_solibs,
7817                         ix, iter);
7818            ++ix)
7819         {
7820           if (!self->regex
7821               || regexec (&self->compiled, iter->so_name, 0, NULL, 0) == 0)
7822             return;
7823         }
7824     }
7825   else
7826     {
7827       char *iter;
7828
7829       for (ix = 0;
7830            VEC_iterate (char_ptr, current_program_space->deleted_solibs,
7831                         ix, iter);
7832            ++ix)
7833         {
7834           if (!self->regex
7835               || regexec (&self->compiled, iter, 0, NULL, 0) == 0)
7836             return;
7837         }
7838     }
7839
7840   bs->stop = 0;
7841   bs->print_it = print_it_noop;
7842 }
7843
7844 static enum print_stop_action
7845 print_it_catch_solib (bpstat bs)
7846 {
7847   struct breakpoint *b = bs->breakpoint_at;
7848   struct ui_out *uiout = current_uiout;
7849
7850   annotate_catchpoint (b->number);
7851   if (b->disposition == disp_del)
7852     ui_out_text (uiout, "\nTemporary catchpoint ");
7853   else
7854     ui_out_text (uiout, "\nCatchpoint ");
7855   ui_out_field_int (uiout, "bkptno", b->number);
7856   ui_out_text (uiout, "\n");
7857   if (ui_out_is_mi_like_p (uiout))
7858     ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7859   print_solib_event (1);
7860   return PRINT_SRC_AND_LOC;
7861 }
7862
7863 static void
7864 print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
7865 {
7866   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7867   struct value_print_options opts;
7868   struct ui_out *uiout = current_uiout;
7869   char *msg;
7870
7871   get_user_print_options (&opts);
7872   /* Field 4, the address, is omitted (which makes the columns not
7873      line up too nicely with the headers, but the effect is relatively
7874      readable).  */
7875   if (opts.addressprint)
7876     {
7877       annotate_field (4);
7878       ui_out_field_skip (uiout, "addr");
7879     }
7880
7881   annotate_field (5);
7882   if (self->is_load)
7883     {
7884       if (self->regex)
7885         msg = xstrprintf (_("load of library matching %s"), self->regex);
7886       else
7887         msg = xstrdup (_("load of library"));
7888     }
7889   else
7890     {
7891       if (self->regex)
7892         msg = xstrprintf (_("unload of library matching %s"), self->regex);
7893       else
7894         msg = xstrdup (_("unload of library"));
7895     }
7896   ui_out_field_string (uiout, "what", msg);
7897   xfree (msg);
7898
7899   if (ui_out_is_mi_like_p (uiout))
7900     ui_out_field_string (uiout, "catch-type",
7901                          self->is_load ? "load" : "unload");
7902 }
7903
7904 static void
7905 print_mention_catch_solib (struct breakpoint *b)
7906 {
7907   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7908
7909   printf_filtered (_("Catchpoint %d (%s)"), b->number,
7910                    self->is_load ? "load" : "unload");
7911 }
7912
7913 static void
7914 print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
7915 {
7916   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7917
7918   fprintf_unfiltered (fp, "%s %s",
7919                       b->disposition == disp_del ? "tcatch" : "catch",
7920                       self->is_load ? "load" : "unload");
7921   if (self->regex)
7922     fprintf_unfiltered (fp, " %s", self->regex);
7923   fprintf_unfiltered (fp, "\n");
7924 }
7925
7926 static struct breakpoint_ops catch_solib_breakpoint_ops;
7927
7928 /* Shared helper function (MI and CLI) for creating and installing
7929    a shared object event catchpoint.  If IS_LOAD is non-zero then
7930    the events to be caught are load events, otherwise they are
7931    unload events.  If IS_TEMP is non-zero the catchpoint is a
7932    temporary one.  If ENABLED is non-zero the catchpoint is
7933    created in an enabled state.  */
7934
7935 void
7936 add_solib_catchpoint (char *arg, int is_load, int is_temp, int enabled)
7937 {
7938   struct solib_catchpoint *c;
7939   struct gdbarch *gdbarch = get_current_arch ();
7940   struct cleanup *cleanup;
7941
7942   if (!arg)
7943     arg = "";
7944   arg = skip_spaces (arg);
7945
7946   c = XCNEW (struct solib_catchpoint);
7947   cleanup = make_cleanup (xfree, c);
7948
7949   if (*arg != '\0')
7950     {
7951       int errcode;
7952
7953       errcode = regcomp (&c->compiled, arg, REG_NOSUB);
7954       if (errcode != 0)
7955         {
7956           char *err = get_regcomp_error (errcode, &c->compiled);
7957
7958           make_cleanup (xfree, err);
7959           error (_("Invalid regexp (%s): %s"), err, arg);
7960         }
7961       c->regex = xstrdup (arg);
7962     }
7963
7964   c->is_load = is_load;
7965   init_catchpoint (&c->base, gdbarch, is_temp, NULL,
7966                    &catch_solib_breakpoint_ops);
7967
7968   c->base.enable_state = enabled ? bp_enabled : bp_disabled;
7969
7970   discard_cleanups (cleanup);
7971   install_breakpoint (0, &c->base, 1);
7972 }
7973
7974 /* A helper function that does all the work for "catch load" and
7975    "catch unload".  */
7976
7977 static void
7978 catch_load_or_unload (char *arg, int from_tty, int is_load,
7979                       struct cmd_list_element *command)
7980 {
7981   int tempflag;
7982   const int enabled = 1;
7983
7984   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
7985
7986   add_solib_catchpoint (arg, is_load, tempflag, enabled);
7987 }
7988
7989 static void
7990 catch_load_command_1 (char *arg, int from_tty,
7991                       struct cmd_list_element *command)
7992 {
7993   catch_load_or_unload (arg, from_tty, 1, command);
7994 }
7995
7996 static void
7997 catch_unload_command_1 (char *arg, int from_tty,
7998                         struct cmd_list_element *command)
7999 {
8000   catch_load_or_unload (arg, from_tty, 0, command);
8001 }
8002
8003 /* An instance of this type is used to represent a syscall catchpoint.
8004    It includes a "struct breakpoint" as a kind of base class; users
8005    downcast to "struct breakpoint *" when needed.  A breakpoint is
8006    really of this type iff its ops pointer points to
8007    CATCH_SYSCALL_BREAKPOINT_OPS.  */
8008
8009 struct syscall_catchpoint
8010 {
8011   /* The base class.  */
8012   struct breakpoint base;
8013
8014   /* Syscall numbers used for the 'catch syscall' feature.  If no
8015      syscall has been specified for filtering, its value is NULL.
8016      Otherwise, it holds a list of all syscalls to be caught.  The
8017      list elements are allocated with xmalloc.  */
8018   VEC(int) *syscalls_to_be_caught;
8019 };
8020
8021 /* Implement the "dtor" breakpoint_ops method for syscall
8022    catchpoints.  */
8023
8024 static void
8025 dtor_catch_syscall (struct breakpoint *b)
8026 {
8027   struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8028
8029   VEC_free (int, c->syscalls_to_be_caught);
8030
8031   base_breakpoint_ops.dtor (b);
8032 }
8033
8034 static const struct inferior_data *catch_syscall_inferior_data = NULL;
8035
8036 struct catch_syscall_inferior_data
8037 {
8038   /* We keep a count of the number of times the user has requested a
8039      particular syscall to be tracked, and pass this information to the
8040      target.  This lets capable targets implement filtering directly.  */
8041
8042   /* Number of times that "any" syscall is requested.  */
8043   int any_syscall_count;
8044
8045   /* Count of each system call.  */
8046   VEC(int) *syscalls_counts;
8047
8048   /* This counts all syscall catch requests, so we can readily determine
8049      if any catching is necessary.  */
8050   int total_syscalls_count;
8051 };
8052
8053 static struct catch_syscall_inferior_data*
8054 get_catch_syscall_inferior_data (struct inferior *inf)
8055 {
8056   struct catch_syscall_inferior_data *inf_data;
8057
8058   inf_data = inferior_data (inf, catch_syscall_inferior_data);
8059   if (inf_data == NULL)
8060     {
8061       inf_data = XZALLOC (struct catch_syscall_inferior_data);
8062       set_inferior_data (inf, catch_syscall_inferior_data, inf_data);
8063     }
8064
8065   return inf_data;
8066 }
8067
8068 static void
8069 catch_syscall_inferior_data_cleanup (struct inferior *inf, void *arg)
8070 {
8071   xfree (arg);
8072 }
8073
8074
8075 /* Implement the "insert" breakpoint_ops method for syscall
8076    catchpoints.  */
8077
8078 static int
8079 insert_catch_syscall (struct bp_location *bl)
8080 {
8081   struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
8082   struct inferior *inf = current_inferior ();
8083   struct catch_syscall_inferior_data *inf_data
8084     = get_catch_syscall_inferior_data (inf);
8085
8086   ++inf_data->total_syscalls_count;
8087   if (!c->syscalls_to_be_caught)
8088     ++inf_data->any_syscall_count;
8089   else
8090     {
8091       int i, iter;
8092
8093       for (i = 0;
8094            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8095            i++)
8096         {
8097           int elem;
8098
8099           if (iter >= VEC_length (int, inf_data->syscalls_counts))
8100             {
8101               int old_size = VEC_length (int, inf_data->syscalls_counts);
8102               uintptr_t vec_addr_offset
8103                 = old_size * ((uintptr_t) sizeof (int));
8104               uintptr_t vec_addr;
8105               VEC_safe_grow (int, inf_data->syscalls_counts, iter + 1);
8106               vec_addr = ((uintptr_t) VEC_address (int,
8107                                                   inf_data->syscalls_counts)
8108                           + vec_addr_offset);
8109               memset ((void *) vec_addr, 0,
8110                       (iter + 1 - old_size) * sizeof (int));
8111             }
8112           elem = VEC_index (int, inf_data->syscalls_counts, iter);
8113           VEC_replace (int, inf_data->syscalls_counts, iter, ++elem);
8114         }
8115     }
8116
8117   return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
8118                                         inf_data->total_syscalls_count != 0,
8119                                         inf_data->any_syscall_count,
8120                                         VEC_length (int,
8121                                                     inf_data->syscalls_counts),
8122                                         VEC_address (int,
8123                                                      inf_data->syscalls_counts));
8124 }
8125
8126 /* Implement the "remove" breakpoint_ops method for syscall
8127    catchpoints.  */
8128
8129 static int
8130 remove_catch_syscall (struct bp_location *bl)
8131 {
8132   struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
8133   struct inferior *inf = current_inferior ();
8134   struct catch_syscall_inferior_data *inf_data
8135     = get_catch_syscall_inferior_data (inf);
8136
8137   --inf_data->total_syscalls_count;
8138   if (!c->syscalls_to_be_caught)
8139     --inf_data->any_syscall_count;
8140   else
8141     {
8142       int i, iter;
8143
8144       for (i = 0;
8145            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8146            i++)
8147         {
8148           int elem;
8149           if (iter >= VEC_length (int, inf_data->syscalls_counts))
8150             /* Shouldn't happen.  */
8151             continue;
8152           elem = VEC_index (int, inf_data->syscalls_counts, iter);
8153           VEC_replace (int, inf_data->syscalls_counts, iter, --elem);
8154         }
8155     }
8156
8157   return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
8158                                         inf_data->total_syscalls_count != 0,
8159                                         inf_data->any_syscall_count,
8160                                         VEC_length (int,
8161                                                     inf_data->syscalls_counts),
8162                                         VEC_address (int,
8163                                                      inf_data->syscalls_counts));
8164 }
8165
8166 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
8167    catchpoints.  */
8168
8169 static int
8170 breakpoint_hit_catch_syscall (const struct bp_location *bl,
8171                               struct address_space *aspace, CORE_ADDR bp_addr,
8172                               const struct target_waitstatus *ws)
8173 {
8174   /* We must check if we are catching specific syscalls in this
8175      breakpoint.  If we are, then we must guarantee that the called
8176      syscall is the same syscall we are catching.  */
8177   int syscall_number = 0;
8178   const struct syscall_catchpoint *c
8179     = (const struct syscall_catchpoint *) bl->owner;
8180
8181   if (ws->kind != TARGET_WAITKIND_SYSCALL_ENTRY
8182       && ws->kind != TARGET_WAITKIND_SYSCALL_RETURN)
8183     return 0;
8184
8185   syscall_number = ws->value.syscall_number;
8186
8187   /* Now, checking if the syscall is the same.  */
8188   if (c->syscalls_to_be_caught)
8189     {
8190       int i, iter;
8191
8192       for (i = 0;
8193            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8194            i++)
8195         if (syscall_number == iter)
8196           break;
8197       /* Not the same.  */
8198       if (!iter)
8199         return 0;
8200     }
8201
8202   return 1;
8203 }
8204
8205 /* Implement the "print_it" breakpoint_ops method for syscall
8206    catchpoints.  */
8207
8208 static enum print_stop_action
8209 print_it_catch_syscall (bpstat bs)
8210 {
8211   struct ui_out *uiout = current_uiout;
8212   struct breakpoint *b = bs->breakpoint_at;
8213   /* These are needed because we want to know in which state a
8214      syscall is.  It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
8215      or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
8216      must print "called syscall" or "returned from syscall".  */
8217   ptid_t ptid;
8218   struct target_waitstatus last;
8219   struct syscall s;
8220
8221   get_last_target_status (&ptid, &last);
8222
8223   get_syscall_by_number (last.value.syscall_number, &s);
8224
8225   annotate_catchpoint (b->number);
8226
8227   if (b->disposition == disp_del)
8228     ui_out_text (uiout, "\nTemporary catchpoint ");
8229   else
8230     ui_out_text (uiout, "\nCatchpoint ");
8231   if (ui_out_is_mi_like_p (uiout))
8232     {
8233       ui_out_field_string (uiout, "reason",
8234                            async_reason_lookup (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY
8235                                                 ? EXEC_ASYNC_SYSCALL_ENTRY
8236                                                 : EXEC_ASYNC_SYSCALL_RETURN));
8237       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8238     }
8239   ui_out_field_int (uiout, "bkptno", b->number);
8240
8241   if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
8242     ui_out_text (uiout, " (call to syscall ");
8243   else
8244     ui_out_text (uiout, " (returned from syscall ");
8245
8246   if (s.name == NULL || ui_out_is_mi_like_p (uiout))
8247     ui_out_field_int (uiout, "syscall-number", last.value.syscall_number);
8248   if (s.name != NULL)
8249     ui_out_field_string (uiout, "syscall-name", s.name);
8250
8251   ui_out_text (uiout, "), ");
8252
8253   return PRINT_SRC_AND_LOC;
8254 }
8255
8256 /* Implement the "print_one" breakpoint_ops method for syscall
8257    catchpoints.  */
8258
8259 static void
8260 print_one_catch_syscall (struct breakpoint *b,
8261                          struct bp_location **last_loc)
8262 {
8263   struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8264   struct value_print_options opts;
8265   struct ui_out *uiout = current_uiout;
8266
8267   get_user_print_options (&opts);
8268   /* Field 4, the address, is omitted (which makes the columns not
8269      line up too nicely with the headers, but the effect is relatively
8270      readable).  */
8271   if (opts.addressprint)
8272     ui_out_field_skip (uiout, "addr");
8273   annotate_field (5);
8274
8275   if (c->syscalls_to_be_caught
8276       && VEC_length (int, c->syscalls_to_be_caught) > 1)
8277     ui_out_text (uiout, "syscalls \"");
8278   else
8279     ui_out_text (uiout, "syscall \"");
8280
8281   if (c->syscalls_to_be_caught)
8282     {
8283       int i, iter;
8284       char *text = xstrprintf ("%s", "");
8285
8286       for (i = 0;
8287            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8288            i++)
8289         {
8290           char *x = text;
8291           struct syscall s;
8292           get_syscall_by_number (iter, &s);
8293
8294           if (s.name != NULL)
8295             text = xstrprintf ("%s%s, ", text, s.name);
8296           else
8297             text = xstrprintf ("%s%d, ", text, iter);
8298
8299           /* We have to xfree the last 'text' (now stored at 'x')
8300              because xstrprintf dynamically allocates new space for it
8301              on every call.  */
8302           xfree (x);
8303         }
8304       /* Remove the last comma.  */
8305       text[strlen (text) - 2] = '\0';
8306       ui_out_field_string (uiout, "what", text);
8307     }
8308   else
8309     ui_out_field_string (uiout, "what", "<any syscall>");
8310   ui_out_text (uiout, "\" ");
8311
8312   if (ui_out_is_mi_like_p (uiout))
8313     ui_out_field_string (uiout, "catch-type", "syscall");
8314 }
8315
8316 /* Implement the "print_mention" breakpoint_ops method for syscall
8317    catchpoints.  */
8318
8319 static void
8320 print_mention_catch_syscall (struct breakpoint *b)
8321 {
8322   struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8323
8324   if (c->syscalls_to_be_caught)
8325     {
8326       int i, iter;
8327
8328       if (VEC_length (int, c->syscalls_to_be_caught) > 1)
8329         printf_filtered (_("Catchpoint %d (syscalls"), b->number);
8330       else
8331         printf_filtered (_("Catchpoint %d (syscall"), b->number);
8332
8333       for (i = 0;
8334            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8335            i++)
8336         {
8337           struct syscall s;
8338           get_syscall_by_number (iter, &s);
8339
8340           if (s.name)
8341             printf_filtered (" '%s' [%d]", s.name, s.number);
8342           else
8343             printf_filtered (" %d", s.number);
8344         }
8345       printf_filtered (")");
8346     }
8347   else
8348     printf_filtered (_("Catchpoint %d (any syscall)"),
8349                      b->number);
8350 }
8351
8352 /* Implement the "print_recreate" breakpoint_ops method for syscall
8353    catchpoints.  */
8354
8355 static void
8356 print_recreate_catch_syscall (struct breakpoint *b, struct ui_file *fp)
8357 {
8358   struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8359
8360   fprintf_unfiltered (fp, "catch syscall");
8361
8362   if (c->syscalls_to_be_caught)
8363     {
8364       int i, iter;
8365
8366       for (i = 0;
8367            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8368            i++)
8369         {
8370           struct syscall s;
8371
8372           get_syscall_by_number (iter, &s);
8373           if (s.name)
8374             fprintf_unfiltered (fp, " %s", s.name);
8375           else
8376             fprintf_unfiltered (fp, " %d", s.number);
8377         }
8378     }
8379   print_recreate_thread (b, fp);
8380 }
8381
8382 /* The breakpoint_ops structure to be used in syscall catchpoints.  */
8383
8384 static struct breakpoint_ops catch_syscall_breakpoint_ops;
8385
8386 /* Returns non-zero if 'b' is a syscall catchpoint.  */
8387
8388 static int
8389 syscall_catchpoint_p (struct breakpoint *b)
8390 {
8391   return (b->ops == &catch_syscall_breakpoint_ops);
8392 }
8393
8394 /* Initialize a new breakpoint of the bp_catchpoint kind.  If TEMPFLAG
8395    is non-zero, then make the breakpoint temporary.  If COND_STRING is
8396    not NULL, then store it in the breakpoint.  OPS, if not NULL, is
8397    the breakpoint_ops structure associated to the catchpoint.  */
8398
8399 void
8400 init_catchpoint (struct breakpoint *b,
8401                  struct gdbarch *gdbarch, int tempflag,
8402                  char *cond_string,
8403                  const struct breakpoint_ops *ops)
8404 {
8405   struct symtab_and_line sal;
8406
8407   init_sal (&sal);
8408   sal.pspace = current_program_space;
8409
8410   init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
8411
8412   b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
8413   b->disposition = tempflag ? disp_del : disp_donttouch;
8414 }
8415
8416 void
8417 install_breakpoint (int internal, struct breakpoint *b, int update_gll)
8418 {
8419   add_to_breakpoint_chain (b);
8420   set_breakpoint_number (internal, b);
8421   if (is_tracepoint (b))
8422     set_tracepoint_count (breakpoint_count);
8423   if (!internal)
8424     mention (b);
8425   observer_notify_breakpoint_created (b);
8426
8427   if (update_gll)
8428     update_global_location_list (1);
8429 }
8430
8431 static void
8432 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
8433                                     int tempflag, char *cond_string,
8434                                     const struct breakpoint_ops *ops)
8435 {
8436   struct fork_catchpoint *c = XNEW (struct fork_catchpoint);
8437
8438   init_catchpoint (&c->base, gdbarch, tempflag, cond_string, ops);
8439
8440   c->forked_inferior_pid = null_ptid;
8441
8442   install_breakpoint (0, &c->base, 1);
8443 }
8444
8445 /* Exec catchpoints.  */
8446
8447 /* An instance of this type is used to represent an exec catchpoint.
8448    It includes a "struct breakpoint" as a kind of base class; users
8449    downcast to "struct breakpoint *" when needed.  A breakpoint is
8450    really of this type iff its ops pointer points to
8451    CATCH_EXEC_BREAKPOINT_OPS.  */
8452
8453 struct exec_catchpoint
8454 {
8455   /* The base class.  */
8456   struct breakpoint base;
8457
8458   /* Filename of a program whose exec triggered this catchpoint.
8459      This field is only valid immediately after this catchpoint has
8460      triggered.  */
8461   char *exec_pathname;
8462 };
8463
8464 /* Implement the "dtor" breakpoint_ops method for exec
8465    catchpoints.  */
8466
8467 static void
8468 dtor_catch_exec (struct breakpoint *b)
8469 {
8470   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8471
8472   xfree (c->exec_pathname);
8473
8474   base_breakpoint_ops.dtor (b);
8475 }
8476
8477 static int
8478 insert_catch_exec (struct bp_location *bl)
8479 {
8480   return target_insert_exec_catchpoint (PIDGET (inferior_ptid));
8481 }
8482
8483 static int
8484 remove_catch_exec (struct bp_location *bl)
8485 {
8486   return target_remove_exec_catchpoint (PIDGET (inferior_ptid));
8487 }
8488
8489 static int
8490 breakpoint_hit_catch_exec (const struct bp_location *bl,
8491                            struct address_space *aspace, CORE_ADDR bp_addr,
8492                            const struct target_waitstatus *ws)
8493 {
8494   struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8495
8496   if (ws->kind != TARGET_WAITKIND_EXECD)
8497     return 0;
8498
8499   c->exec_pathname = xstrdup (ws->value.execd_pathname);
8500   return 1;
8501 }
8502
8503 static enum print_stop_action
8504 print_it_catch_exec (bpstat bs)
8505 {
8506   struct ui_out *uiout = current_uiout;
8507   struct breakpoint *b = bs->breakpoint_at;
8508   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8509
8510   annotate_catchpoint (b->number);
8511   if (b->disposition == disp_del)
8512     ui_out_text (uiout, "\nTemporary catchpoint ");
8513   else
8514     ui_out_text (uiout, "\nCatchpoint ");
8515   if (ui_out_is_mi_like_p (uiout))
8516     {
8517       ui_out_field_string (uiout, "reason",
8518                            async_reason_lookup (EXEC_ASYNC_EXEC));
8519       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8520     }
8521   ui_out_field_int (uiout, "bkptno", b->number);
8522   ui_out_text (uiout, " (exec'd ");
8523   ui_out_field_string (uiout, "new-exec", c->exec_pathname);
8524   ui_out_text (uiout, "), ");
8525
8526   return PRINT_SRC_AND_LOC;
8527 }
8528
8529 static void
8530 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
8531 {
8532   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8533   struct value_print_options opts;
8534   struct ui_out *uiout = current_uiout;
8535
8536   get_user_print_options (&opts);
8537
8538   /* Field 4, the address, is omitted (which makes the columns
8539      not line up too nicely with the headers, but the effect
8540      is relatively readable).  */
8541   if (opts.addressprint)
8542     ui_out_field_skip (uiout, "addr");
8543   annotate_field (5);
8544   ui_out_text (uiout, "exec");
8545   if (c->exec_pathname != NULL)
8546     {
8547       ui_out_text (uiout, ", program \"");
8548       ui_out_field_string (uiout, "what", c->exec_pathname);
8549       ui_out_text (uiout, "\" ");
8550     }
8551
8552   if (ui_out_is_mi_like_p (uiout))
8553     ui_out_field_string (uiout, "catch-type", "exec");
8554 }
8555
8556 static void
8557 print_mention_catch_exec (struct breakpoint *b)
8558 {
8559   printf_filtered (_("Catchpoint %d (exec)"), b->number);
8560 }
8561
8562 /* Implement the "print_recreate" breakpoint_ops method for exec
8563    catchpoints.  */
8564
8565 static void
8566 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8567 {
8568   fprintf_unfiltered (fp, "catch exec");
8569   print_recreate_thread (b, fp);
8570 }
8571
8572 static struct breakpoint_ops catch_exec_breakpoint_ops;
8573
8574 static void
8575 create_syscall_event_catchpoint (int tempflag, VEC(int) *filter,
8576                                  const struct breakpoint_ops *ops)
8577 {
8578   struct syscall_catchpoint *c;
8579   struct gdbarch *gdbarch = get_current_arch ();
8580
8581   c = XNEW (struct syscall_catchpoint);
8582   init_catchpoint (&c->base, gdbarch, tempflag, NULL, ops);
8583   c->syscalls_to_be_caught = filter;
8584
8585   install_breakpoint (0, &c->base, 1);
8586 }
8587
8588 static int
8589 hw_breakpoint_used_count (void)
8590 {
8591   int i = 0;
8592   struct breakpoint *b;
8593   struct bp_location *bl;
8594
8595   ALL_BREAKPOINTS (b)
8596   {
8597     if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
8598       for (bl = b->loc; bl; bl = bl->next)
8599         {
8600           /* Special types of hardware breakpoints may use more than
8601              one register.  */
8602           i += b->ops->resources_needed (bl);
8603         }
8604   }
8605
8606   return i;
8607 }
8608
8609 /* Returns the resources B would use if it were a hardware
8610    watchpoint.  */
8611
8612 static int
8613 hw_watchpoint_use_count (struct breakpoint *b)
8614 {
8615   int i = 0;
8616   struct bp_location *bl;
8617
8618   if (!breakpoint_enabled (b))
8619     return 0;
8620
8621   for (bl = b->loc; bl; bl = bl->next)
8622     {
8623       /* Special types of hardware watchpoints may use more than
8624          one register.  */
8625       i += b->ops->resources_needed (bl);
8626     }
8627
8628   return i;
8629 }
8630
8631 /* Returns the sum the used resources of all hardware watchpoints of
8632    type TYPE in the breakpoints list.  Also returns in OTHER_TYPE_USED
8633    the sum of the used resources of all hardware watchpoints of other
8634    types _not_ TYPE.  */
8635
8636 static int
8637 hw_watchpoint_used_count_others (struct breakpoint *except,
8638                                  enum bptype type, int *other_type_used)
8639 {
8640   int i = 0;
8641   struct breakpoint *b;
8642
8643   *other_type_used = 0;
8644   ALL_BREAKPOINTS (b)
8645     {
8646       if (b == except)
8647         continue;
8648       if (!breakpoint_enabled (b))
8649         continue;
8650
8651       if (b->type == type)
8652         i += hw_watchpoint_use_count (b);
8653       else if (is_hardware_watchpoint (b))
8654         *other_type_used = 1;
8655     }
8656
8657   return i;
8658 }
8659
8660 void
8661 disable_watchpoints_before_interactive_call_start (void)
8662 {
8663   struct breakpoint *b;
8664
8665   ALL_BREAKPOINTS (b)
8666   {
8667     if (is_watchpoint (b) && breakpoint_enabled (b))
8668       {
8669         b->enable_state = bp_call_disabled;
8670         update_global_location_list (0);
8671       }
8672   }
8673 }
8674
8675 void
8676 enable_watchpoints_after_interactive_call_stop (void)
8677 {
8678   struct breakpoint *b;
8679
8680   ALL_BREAKPOINTS (b)
8681   {
8682     if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
8683       {
8684         b->enable_state = bp_enabled;
8685         update_global_location_list (1);
8686       }
8687   }
8688 }
8689
8690 void
8691 disable_breakpoints_before_startup (void)
8692 {
8693   current_program_space->executing_startup = 1;
8694   update_global_location_list (0);
8695 }
8696
8697 void
8698 enable_breakpoints_after_startup (void)
8699 {
8700   current_program_space->executing_startup = 0;
8701   breakpoint_re_set ();
8702 }
8703
8704
8705 /* Set a breakpoint that will evaporate an end of command
8706    at address specified by SAL.
8707    Restrict it to frame FRAME if FRAME is nonzero.  */
8708
8709 struct breakpoint *
8710 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8711                           struct frame_id frame_id, enum bptype type)
8712 {
8713   struct breakpoint *b;
8714
8715   /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8716      tail-called one.  */
8717   gdb_assert (!frame_id_artificial_p (frame_id));
8718
8719   b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
8720   b->enable_state = bp_enabled;
8721   b->disposition = disp_donttouch;
8722   b->frame_id = frame_id;
8723
8724   /* If we're debugging a multi-threaded program, then we want
8725      momentary breakpoints to be active in only a single thread of
8726      control.  */
8727   if (in_thread_list (inferior_ptid))
8728     b->thread = pid_to_thread_id (inferior_ptid);
8729
8730   update_global_location_list_nothrow (1);
8731
8732   return b;
8733 }
8734
8735 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8736    The new breakpoint will have type TYPE, and use OPS as it
8737    breakpoint_ops.  */
8738
8739 static struct breakpoint *
8740 momentary_breakpoint_from_master (struct breakpoint *orig,
8741                                   enum bptype type,
8742                                   const struct breakpoint_ops *ops)
8743 {
8744   struct breakpoint *copy;
8745
8746   copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
8747   copy->loc = allocate_bp_location (copy);
8748   set_breakpoint_location_function (copy->loc, 1);
8749
8750   copy->loc->gdbarch = orig->loc->gdbarch;
8751   copy->loc->requested_address = orig->loc->requested_address;
8752   copy->loc->address = orig->loc->address;
8753   copy->loc->section = orig->loc->section;
8754   copy->loc->pspace = orig->loc->pspace;
8755   copy->loc->probe = orig->loc->probe;
8756   copy->loc->line_number = orig->loc->line_number;
8757   copy->loc->symtab = orig->loc->symtab;
8758   copy->frame_id = orig->frame_id;
8759   copy->thread = orig->thread;
8760   copy->pspace = orig->pspace;
8761
8762   copy->enable_state = bp_enabled;
8763   copy->disposition = disp_donttouch;
8764   copy->number = internal_breakpoint_number--;
8765
8766   update_global_location_list_nothrow (0);
8767   return copy;
8768 }
8769
8770 /* Make a deep copy of momentary breakpoint ORIG.  Returns NULL if
8771    ORIG is NULL.  */
8772
8773 struct breakpoint *
8774 clone_momentary_breakpoint (struct breakpoint *orig)
8775 {
8776   /* If there's nothing to clone, then return nothing.  */
8777   if (orig == NULL)
8778     return NULL;
8779
8780   return momentary_breakpoint_from_master (orig, orig->type, orig->ops);
8781 }
8782
8783 struct breakpoint *
8784 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8785                                 enum bptype type)
8786 {
8787   struct symtab_and_line sal;
8788
8789   sal = find_pc_line (pc, 0);
8790   sal.pc = pc;
8791   sal.section = find_pc_overlay (pc);
8792   sal.explicit_pc = 1;
8793
8794   return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
8795 }
8796 \f
8797
8798 /* Tell the user we have just set a breakpoint B.  */
8799
8800 static void
8801 mention (struct breakpoint *b)
8802 {
8803   b->ops->print_mention (b);
8804   if (ui_out_is_mi_like_p (current_uiout))
8805     return;
8806   printf_filtered ("\n");
8807 }
8808 \f
8809
8810 static struct bp_location *
8811 add_location_to_breakpoint (struct breakpoint *b,
8812                             const struct symtab_and_line *sal)
8813 {
8814   struct bp_location *loc, **tmp;
8815   CORE_ADDR adjusted_address;
8816   struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
8817
8818   if (loc_gdbarch == NULL)
8819     loc_gdbarch = b->gdbarch;
8820
8821   /* Adjust the breakpoint's address prior to allocating a location.
8822      Once we call allocate_bp_location(), that mostly uninitialized
8823      location will be placed on the location chain.  Adjustment of the
8824      breakpoint may cause target_read_memory() to be called and we do
8825      not want its scan of the location chain to find a breakpoint and
8826      location that's only been partially initialized.  */
8827   adjusted_address = adjust_breakpoint_address (loc_gdbarch,
8828                                                 sal->pc, b->type);
8829
8830   /* Sort the locations by their ADDRESS.  */
8831   loc = allocate_bp_location (b);
8832   for (tmp = &(b->loc); *tmp != NULL && (*tmp)->address <= adjusted_address;
8833        tmp = &((*tmp)->next))
8834     ;
8835   loc->next = *tmp;
8836   *tmp = loc;
8837
8838   loc->requested_address = sal->pc;
8839   loc->address = adjusted_address;
8840   loc->pspace = sal->pspace;
8841   loc->probe = sal->probe;
8842   gdb_assert (loc->pspace != NULL);
8843   loc->section = sal->section;
8844   loc->gdbarch = loc_gdbarch;
8845   loc->line_number = sal->line;
8846   loc->symtab = sal->symtab;
8847
8848   set_breakpoint_location_function (loc,
8849                                     sal->explicit_pc || sal->explicit_line);
8850   return loc;
8851 }
8852 \f
8853
8854 /* Return 1 if LOC is pointing to a permanent breakpoint, 
8855    return 0 otherwise.  */
8856
8857 static int
8858 bp_loc_is_permanent (struct bp_location *loc)
8859 {
8860   int len;
8861   CORE_ADDR addr;
8862   const gdb_byte *bpoint;
8863   gdb_byte *target_mem;
8864   struct cleanup *cleanup;
8865   int retval = 0;
8866
8867   gdb_assert (loc != NULL);
8868
8869   addr = loc->address;
8870   bpoint = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
8871
8872   /* Software breakpoints unsupported?  */
8873   if (bpoint == NULL)
8874     return 0;
8875
8876   target_mem = alloca (len);
8877
8878   /* Enable the automatic memory restoration from breakpoints while
8879      we read the memory.  Otherwise we could say about our temporary
8880      breakpoints they are permanent.  */
8881   cleanup = save_current_space_and_thread ();
8882
8883   switch_to_program_space_and_thread (loc->pspace);
8884   make_show_memory_breakpoints_cleanup (0);
8885
8886   if (target_read_memory (loc->address, target_mem, len) == 0
8887       && memcmp (target_mem, bpoint, len) == 0)
8888     retval = 1;
8889
8890   do_cleanups (cleanup);
8891
8892   return retval;
8893 }
8894
8895 /* Build a command list for the dprintf corresponding to the current
8896    settings of the dprintf style options.  */
8897
8898 static void
8899 update_dprintf_command_list (struct breakpoint *b)
8900 {
8901   char *dprintf_args = b->extra_string;
8902   char *printf_line = NULL;
8903
8904   if (!dprintf_args)
8905     return;
8906
8907   dprintf_args = skip_spaces (dprintf_args);
8908
8909   /* Allow a comma, as it may have terminated a location, but don't
8910      insist on it.  */
8911   if (*dprintf_args == ',')
8912     ++dprintf_args;
8913   dprintf_args = skip_spaces (dprintf_args);
8914
8915   if (*dprintf_args != '"')
8916     error (_("Bad format string, missing '\"'."));
8917
8918   if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
8919     printf_line = xstrprintf ("printf %s", dprintf_args);
8920   else if (strcmp (dprintf_style, dprintf_style_call) == 0)
8921     {
8922       if (!dprintf_function)
8923         error (_("No function supplied for dprintf call"));
8924
8925       if (dprintf_channel && strlen (dprintf_channel) > 0)
8926         printf_line = xstrprintf ("call (void) %s (%s,%s)",
8927                                   dprintf_function,
8928                                   dprintf_channel,
8929                                   dprintf_args);
8930       else
8931         printf_line = xstrprintf ("call (void) %s (%s)",
8932                                   dprintf_function,
8933                                   dprintf_args);
8934     }
8935   else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
8936     {
8937       if (target_can_run_breakpoint_commands ())
8938         printf_line = xstrprintf ("agent-printf %s", dprintf_args);
8939       else
8940         {
8941           warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8942           printf_line = xstrprintf ("printf %s", dprintf_args);
8943         }
8944     }
8945   else
8946     internal_error (__FILE__, __LINE__,
8947                     _("Invalid dprintf style."));
8948
8949   gdb_assert (printf_line != NULL);
8950   /* Manufacture a printf/continue sequence.  */
8951   {
8952     struct command_line *printf_cmd_line, *cont_cmd_line = NULL;
8953
8954     if (strcmp (dprintf_style, dprintf_style_agent) != 0)
8955       {
8956         cont_cmd_line = xmalloc (sizeof (struct command_line));
8957         cont_cmd_line->control_type = simple_control;
8958         cont_cmd_line->body_count = 0;
8959         cont_cmd_line->body_list = NULL;
8960         cont_cmd_line->next = NULL;
8961         cont_cmd_line->line = xstrdup ("continue");
8962       }
8963
8964     printf_cmd_line = xmalloc (sizeof (struct command_line));
8965     printf_cmd_line->control_type = simple_control;
8966     printf_cmd_line->body_count = 0;
8967     printf_cmd_line->body_list = NULL;
8968     printf_cmd_line->next = cont_cmd_line;
8969     printf_cmd_line->line = printf_line;
8970
8971     breakpoint_set_commands (b, printf_cmd_line);
8972   }
8973 }
8974
8975 /* Update all dprintf commands, making their command lists reflect
8976    current style settings.  */
8977
8978 static void
8979 update_dprintf_commands (char *args, int from_tty,
8980                          struct cmd_list_element *c)
8981 {
8982   struct breakpoint *b;
8983
8984   ALL_BREAKPOINTS (b)
8985     {
8986       if (b->type == bp_dprintf)
8987         update_dprintf_command_list (b);
8988     }
8989 }
8990
8991 /* Create a breakpoint with SAL as location.  Use ADDR_STRING
8992    as textual description of the location, and COND_STRING
8993    as condition expression.  */
8994
8995 static void
8996 init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
8997                      struct symtabs_and_lines sals, char *addr_string,
8998                      char *filter, char *cond_string,
8999                      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   int i;
9007
9008   if (type == bp_hardware_breakpoint)
9009     {
9010       int target_resources_ok;
9011
9012       i = hw_breakpoint_used_count ();
9013       target_resources_ok =
9014         target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
9015                                             i + 1, 0);
9016       if (target_resources_ok == 0)
9017         error (_("No hardware breakpoint support in the target."));
9018       else if (target_resources_ok < 0)
9019         error (_("Hardware breakpoints used exceeds limit."));
9020     }
9021
9022   gdb_assert (sals.nelts > 0);
9023
9024   for (i = 0; i < sals.nelts; ++i)
9025     {
9026       struct symtab_and_line sal = sals.sals[i];
9027       struct bp_location *loc;
9028
9029       if (from_tty)
9030         {
9031           struct gdbarch *loc_gdbarch = get_sal_arch (sal);
9032           if (!loc_gdbarch)
9033             loc_gdbarch = gdbarch;
9034
9035           describe_other_breakpoints (loc_gdbarch,
9036                                       sal.pspace, sal.pc, sal.section, thread);
9037         }
9038
9039       if (i == 0)
9040         {
9041           init_raw_breakpoint (b, gdbarch, sal, type, ops);
9042           b->thread = thread;
9043           b->task = task;
9044
9045           b->cond_string = cond_string;
9046           b->extra_string = extra_string;
9047           b->ignore_count = ignore_count;
9048           b->enable_state = enabled ? bp_enabled : bp_disabled;
9049           b->disposition = disposition;
9050
9051           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
9052             b->loc->inserted = 1;
9053
9054           if (type == bp_static_tracepoint)
9055             {
9056               struct tracepoint *t = (struct tracepoint *) b;
9057               struct static_tracepoint_marker marker;
9058
9059               if (strace_marker_p (b))
9060                 {
9061                   /* We already know the marker exists, otherwise, we
9062                      wouldn't see a sal for it.  */
9063                   char *p = &addr_string[3];
9064                   char *endp;
9065                   char *marker_str;
9066
9067                   p = skip_spaces (p);
9068
9069                   endp = skip_to_space (p);
9070
9071                   marker_str = savestring (p, endp - p);
9072                   t->static_trace_marker_id = marker_str;
9073
9074                   printf_filtered (_("Probed static tracepoint "
9075                                      "marker \"%s\"\n"),
9076                                    t->static_trace_marker_id);
9077                 }
9078               else if (target_static_tracepoint_marker_at (sal.pc, &marker))
9079                 {
9080                   t->static_trace_marker_id = xstrdup (marker.str_id);
9081                   release_static_tracepoint_marker (&marker);
9082
9083                   printf_filtered (_("Probed static tracepoint "
9084                                      "marker \"%s\"\n"),
9085                                    t->static_trace_marker_id);
9086                 }
9087               else
9088                 warning (_("Couldn't determine the static "
9089                            "tracepoint marker to probe"));
9090             }
9091
9092           loc = b->loc;
9093         }
9094       else
9095         {
9096           loc = add_location_to_breakpoint (b, &sal);
9097           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
9098             loc->inserted = 1;
9099         }
9100
9101       if (bp_loc_is_permanent (loc))
9102         make_breakpoint_permanent (b);
9103
9104       if (b->cond_string)
9105         {
9106           char *arg = b->cond_string;
9107           loc->cond = parse_exp_1 (&arg, loc->address,
9108                                    block_for_pc (loc->address), 0);
9109           if (*arg)
9110               error (_("Garbage '%s' follows condition"), arg);
9111         }
9112
9113       /* Dynamic printf requires and uses additional arguments on the
9114          command line, otherwise it's an error.  */
9115       if (type == bp_dprintf)
9116         {
9117           if (b->extra_string)
9118             update_dprintf_command_list (b);
9119           else
9120             error (_("Format string required"));
9121         }
9122       else if (b->extra_string)
9123         error (_("Garbage '%s' at end of command"), b->extra_string);
9124     }
9125
9126   b->display_canonical = display_canonical;
9127   if (addr_string)
9128     b->addr_string = addr_string;
9129   else
9130     /* addr_string has to be used or breakpoint_re_set will delete
9131        me.  */
9132     b->addr_string
9133       = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
9134   b->filter = filter;
9135 }
9136
9137 static void
9138 create_breakpoint_sal (struct gdbarch *gdbarch,
9139                        struct symtabs_and_lines sals, char *addr_string,
9140                        char *filter, char *cond_string,
9141                        char *extra_string,
9142                        enum bptype type, enum bpdisp disposition,
9143                        int thread, int task, int ignore_count,
9144                        const struct breakpoint_ops *ops, int from_tty,
9145                        int enabled, int internal, unsigned flags,
9146                        int display_canonical)
9147 {
9148   struct breakpoint *b;
9149   struct cleanup *old_chain;
9150
9151   if (is_tracepoint_type (type))
9152     {
9153       struct tracepoint *t;
9154
9155       t = XCNEW (struct tracepoint);
9156       b = &t->base;
9157     }
9158   else
9159     b = XNEW (struct breakpoint);
9160
9161   old_chain = make_cleanup (xfree, b);
9162
9163   init_breakpoint_sal (b, gdbarch,
9164                        sals, addr_string,
9165                        filter, cond_string, extra_string,
9166                        type, disposition,
9167                        thread, task, ignore_count,
9168                        ops, from_tty,
9169                        enabled, internal, flags,
9170                        display_canonical);
9171   discard_cleanups (old_chain);
9172
9173   install_breakpoint (internal, b, 0);
9174 }
9175
9176 /* Add SALS.nelts breakpoints to the breakpoint table.  For each
9177    SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9178    value.  COND_STRING, if not NULL, specified the condition to be
9179    used for all breakpoints.  Essentially the only case where
9180    SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9181    function.  In that case, it's still not possible to specify
9182    separate conditions for different overloaded functions, so
9183    we take just a single condition string.
9184    
9185    NOTE: If the function succeeds, the caller is expected to cleanup
9186    the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9187    array contents).  If the function fails (error() is called), the
9188    caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9189    COND and SALS arrays and each of those arrays contents.  */
9190
9191 static void
9192 create_breakpoints_sal (struct gdbarch *gdbarch,
9193                         struct linespec_result *canonical,
9194                         char *cond_string, char *extra_string,
9195                         enum bptype type, enum bpdisp disposition,
9196                         int thread, int task, int ignore_count,
9197                         const struct breakpoint_ops *ops, int from_tty,
9198                         int enabled, int internal, unsigned flags)
9199 {
9200   int i;
9201   struct linespec_sals *lsal;
9202
9203   if (canonical->pre_expanded)
9204     gdb_assert (VEC_length (linespec_sals, canonical->sals) == 1);
9205
9206   for (i = 0; VEC_iterate (linespec_sals, canonical->sals, i, lsal); ++i)
9207     {
9208       /* Note that 'addr_string' can be NULL in the case of a plain
9209          'break', without arguments.  */
9210       char *addr_string = (canonical->addr_string
9211                            ? xstrdup (canonical->addr_string)
9212                            : NULL);
9213       char *filter_string = lsal->canonical ? xstrdup (lsal->canonical) : NULL;
9214       struct cleanup *inner = make_cleanup (xfree, addr_string);
9215
9216       make_cleanup (xfree, filter_string);
9217       create_breakpoint_sal (gdbarch, lsal->sals,
9218                              addr_string,
9219                              filter_string,
9220                              cond_string, extra_string,
9221                              type, disposition,
9222                              thread, task, ignore_count, ops,
9223                              from_tty, enabled, internal, flags,
9224                              canonical->special_display);
9225       discard_cleanups (inner);
9226     }
9227 }
9228
9229 /* Parse ADDRESS which is assumed to be a SAL specification possibly
9230    followed by conditionals.  On return, SALS contains an array of SAL
9231    addresses found.  ADDR_STRING contains a vector of (canonical)
9232    address strings.  ADDRESS points to the end of the SAL.
9233
9234    The array and the line spec strings are allocated on the heap, it is
9235    the caller's responsibility to free them.  */
9236
9237 static void
9238 parse_breakpoint_sals (char **address,
9239                        struct linespec_result *canonical)
9240 {
9241   /* If no arg given, or if first arg is 'if ', use the default
9242      breakpoint.  */
9243   if ((*address) == NULL
9244       || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
9245     {
9246       /* The last displayed codepoint, if it's valid, is our default breakpoint
9247          address.  */
9248       if (last_displayed_sal_is_valid ())
9249         {
9250           struct linespec_sals lsal;
9251           struct symtab_and_line sal;
9252           CORE_ADDR pc;
9253
9254           init_sal (&sal);              /* Initialize to zeroes.  */
9255           lsal.sals.sals = (struct symtab_and_line *)
9256             xmalloc (sizeof (struct symtab_and_line));
9257
9258           /* Set sal's pspace, pc, symtab, and line to the values
9259              corresponding to the last call to print_frame_info.
9260              Be sure to reinitialize LINE with NOTCURRENT == 0
9261              as the breakpoint line number is inappropriate otherwise.
9262              find_pc_line would adjust PC, re-set it back.  */
9263           get_last_displayed_sal (&sal);
9264           pc = sal.pc;
9265           sal = find_pc_line (pc, 0);
9266
9267           /* "break" without arguments is equivalent to "break *PC"
9268              where PC is the last displayed codepoint's address.  So
9269              make sure to set sal.explicit_pc to prevent GDB from
9270              trying to expand the list of sals to include all other
9271              instances with the same symtab and line.  */
9272           sal.pc = pc;
9273           sal.explicit_pc = 1;
9274
9275           lsal.sals.sals[0] = sal;
9276           lsal.sals.nelts = 1;
9277           lsal.canonical = NULL;
9278
9279           VEC_safe_push (linespec_sals, canonical->sals, &lsal);
9280         }
9281       else
9282         error (_("No default breakpoint address now."));
9283     }
9284   else
9285     {
9286       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
9287
9288       /* Force almost all breakpoints to be in terms of the
9289          current_source_symtab (which is decode_line_1's default).
9290          This should produce the results we want almost all of the
9291          time while leaving default_breakpoint_* alone.
9292
9293          ObjC: However, don't match an Objective-C method name which
9294          may have a '+' or '-' succeeded by a '['.  */
9295       if (last_displayed_sal_is_valid ()
9296           && (!cursal.symtab
9297               || ((strchr ("+-", (*address)[0]) != NULL)
9298                   && ((*address)[1] != '['))))
9299         decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
9300                           get_last_displayed_symtab (),
9301                           get_last_displayed_line (),
9302                           canonical, NULL, NULL);
9303       else
9304         decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
9305                           cursal.symtab, cursal.line, canonical, NULL, NULL);
9306     }
9307 }
9308
9309
9310 /* Convert each SAL into a real PC.  Verify that the PC can be
9311    inserted as a breakpoint.  If it can't throw an error.  */
9312
9313 static void
9314 breakpoint_sals_to_pc (struct symtabs_and_lines *sals)
9315 {    
9316   int i;
9317
9318   for (i = 0; i < sals->nelts; i++)
9319     resolve_sal_pc (&sals->sals[i]);
9320 }
9321
9322 /* Fast tracepoints may have restrictions on valid locations.  For
9323    instance, a fast tracepoint using a jump instead of a trap will
9324    likely have to overwrite more bytes than a trap would, and so can
9325    only be placed where the instruction is longer than the jump, or a
9326    multi-instruction sequence does not have a jump into the middle of
9327    it, etc.  */
9328
9329 static void
9330 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9331                             struct symtabs_and_lines *sals)
9332 {
9333   int i, rslt;
9334   struct symtab_and_line *sal;
9335   char *msg;
9336   struct cleanup *old_chain;
9337
9338   for (i = 0; i < sals->nelts; i++)
9339     {
9340       struct gdbarch *sarch;
9341
9342       sal = &sals->sals[i];
9343
9344       sarch = get_sal_arch (*sal);
9345       /* We fall back to GDBARCH if there is no architecture
9346          associated with SAL.  */
9347       if (sarch == NULL)
9348         sarch = gdbarch;
9349       rslt = gdbarch_fast_tracepoint_valid_at (sarch, sal->pc,
9350                                                NULL, &msg);
9351       old_chain = make_cleanup (xfree, msg);
9352
9353       if (!rslt)
9354         error (_("May not have a fast tracepoint at 0x%s%s"),
9355                paddress (sarch, sal->pc), (msg ? msg : ""));
9356
9357       do_cleanups (old_chain);
9358     }
9359 }
9360
9361 /* Issue an invalid thread ID error.  */
9362
9363 static void ATTRIBUTE_NORETURN
9364 invalid_thread_id_error (int id)
9365 {
9366   error (_("Unknown thread %d."), id);
9367 }
9368
9369 /* Given TOK, a string specification of condition and thread, as
9370    accepted by the 'break' command, extract the condition
9371    string and thread number and set *COND_STRING and *THREAD.
9372    PC identifies the context at which the condition should be parsed.
9373    If no condition is found, *COND_STRING is set to NULL.
9374    If no thread is found, *THREAD is set to -1.  */
9375
9376 static void
9377 find_condition_and_thread (char *tok, CORE_ADDR pc,
9378                            char **cond_string, int *thread, int *task,
9379                            char **rest)
9380 {
9381   *cond_string = NULL;
9382   *thread = -1;
9383   *task = 0;
9384   *rest = NULL;
9385
9386   while (tok && *tok)
9387     {
9388       char *end_tok;
9389       int toklen;
9390       char *cond_start = NULL;
9391       char *cond_end = NULL;
9392
9393       tok = skip_spaces (tok);
9394
9395       if ((*tok == '"' || *tok == ',') && rest)
9396         {
9397           *rest = savestring (tok, strlen (tok));
9398           return;
9399         }
9400
9401       end_tok = skip_to_space (tok);
9402
9403       toklen = end_tok - tok;
9404
9405       if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9406         {
9407           struct expression *expr;
9408
9409           tok = cond_start = end_tok + 1;
9410           expr = parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
9411           xfree (expr);
9412           cond_end = tok;
9413           *cond_string = savestring (cond_start, cond_end - cond_start);
9414         }
9415       else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9416         {
9417           char *tmptok;
9418
9419           tok = end_tok + 1;
9420           tmptok = tok;
9421           *thread = strtol (tok, &tok, 0);
9422           if (tok == tmptok)
9423             error (_("Junk after thread keyword."));
9424           if (!valid_thread_id (*thread))
9425             invalid_thread_id_error (*thread);
9426         }
9427       else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9428         {
9429           char *tmptok;
9430
9431           tok = end_tok + 1;
9432           tmptok = tok;
9433           *task = strtol (tok, &tok, 0);
9434           if (tok == tmptok)
9435             error (_("Junk after task keyword."));
9436           if (!valid_task_id (*task))
9437             error (_("Unknown task %d."), *task);
9438         }
9439       else if (rest)
9440         {
9441           *rest = savestring (tok, strlen (tok));
9442           return;
9443         }
9444       else
9445         error (_("Junk at end of arguments."));
9446     }
9447 }
9448
9449 /* Decode a static tracepoint marker spec.  */
9450
9451 static struct symtabs_and_lines
9452 decode_static_tracepoint_spec (char **arg_p)
9453 {
9454   VEC(static_tracepoint_marker_p) *markers = NULL;
9455   struct symtabs_and_lines sals;
9456   struct cleanup *old_chain;
9457   char *p = &(*arg_p)[3];
9458   char *endp;
9459   char *marker_str;
9460   int i;
9461
9462   p = skip_spaces (p);
9463
9464   endp = skip_to_space (p);
9465
9466   marker_str = savestring (p, endp - p);
9467   old_chain = make_cleanup (xfree, marker_str);
9468
9469   markers = target_static_tracepoint_markers_by_strid (marker_str);
9470   if (VEC_empty(static_tracepoint_marker_p, markers))
9471     error (_("No known static tracepoint marker named %s"), marker_str);
9472
9473   sals.nelts = VEC_length(static_tracepoint_marker_p, markers);
9474   sals.sals = xmalloc (sizeof *sals.sals * sals.nelts);
9475
9476   for (i = 0; i < sals.nelts; i++)
9477     {
9478       struct static_tracepoint_marker *marker;
9479
9480       marker = VEC_index (static_tracepoint_marker_p, markers, i);
9481
9482       init_sal (&sals.sals[i]);
9483
9484       sals.sals[i] = find_pc_line (marker->address, 0);
9485       sals.sals[i].pc = marker->address;
9486
9487       release_static_tracepoint_marker (marker);
9488     }
9489
9490   do_cleanups (old_chain);
9491
9492   *arg_p = endp;
9493   return sals;
9494 }
9495
9496 /* Set a breakpoint.  This function is shared between CLI and MI
9497    functions for setting a breakpoint.  This function has two major
9498    modes of operations, selected by the PARSE_CONDITION_AND_THREAD
9499    parameter.  If non-zero, the function will parse arg, extracting
9500    breakpoint location, address and thread.  Otherwise, ARG is just
9501    the location of breakpoint, with condition and thread specified by
9502    the COND_STRING and THREAD parameters.  If INTERNAL is non-zero,
9503    the breakpoint number will be allocated from the internal
9504    breakpoint count.  Returns true if any breakpoint was created;
9505    false otherwise.  */
9506
9507 int
9508 create_breakpoint (struct gdbarch *gdbarch,
9509                    char *arg, char *cond_string,
9510                    int thread, char *extra_string,
9511                    int parse_condition_and_thread,
9512                    int tempflag, enum bptype type_wanted,
9513                    int ignore_count,
9514                    enum auto_boolean pending_break_support,
9515                    const struct breakpoint_ops *ops,
9516                    int from_tty, int enabled, int internal,
9517                    unsigned flags)
9518 {
9519   volatile struct gdb_exception e;
9520   char *copy_arg = NULL;
9521   char *addr_start = arg;
9522   struct linespec_result canonical;
9523   struct cleanup *old_chain;
9524   struct cleanup *bkpt_chain = NULL;
9525   int pending = 0;
9526   int task = 0;
9527   int prev_bkpt_count = breakpoint_count;
9528
9529   gdb_assert (ops != NULL);
9530
9531   init_linespec_result (&canonical);
9532
9533   TRY_CATCH (e, RETURN_MASK_ALL)
9534     {
9535       ops->create_sals_from_address (&arg, &canonical, type_wanted,
9536                                      addr_start, &copy_arg);
9537     }
9538
9539   /* If caller is interested in rc value from parse, set value.  */
9540   switch (e.reason)
9541     {
9542     case GDB_NO_ERROR:
9543       if (VEC_empty (linespec_sals, canonical.sals))
9544         return 0;
9545       break;
9546     case RETURN_ERROR:
9547       switch (e.error)
9548         {
9549         case NOT_FOUND_ERROR:
9550
9551           /* If pending breakpoint support is turned off, throw
9552              error.  */
9553
9554           if (pending_break_support == AUTO_BOOLEAN_FALSE)
9555             throw_exception (e);
9556
9557           exception_print (gdb_stderr, e);
9558
9559           /* If pending breakpoint support is auto query and the user
9560              selects no, then simply return the error code.  */
9561           if (pending_break_support == AUTO_BOOLEAN_AUTO
9562               && !nquery (_("Make %s pending on future shared library load? "),
9563                           bptype_string (type_wanted)))
9564             return 0;
9565
9566           /* At this point, either the user was queried about setting
9567              a pending breakpoint and selected yes, or pending
9568              breakpoint behavior is on and thus a pending breakpoint
9569              is defaulted on behalf of the user.  */
9570           {
9571             struct linespec_sals lsal;
9572
9573             copy_arg = xstrdup (addr_start);
9574             lsal.canonical = xstrdup (copy_arg);
9575             lsal.sals.nelts = 1;
9576             lsal.sals.sals = XNEW (struct symtab_and_line);
9577             init_sal (&lsal.sals.sals[0]);
9578             pending = 1;
9579             VEC_safe_push (linespec_sals, canonical.sals, &lsal);
9580           }
9581           break;
9582         default:
9583           throw_exception (e);
9584         }
9585       break;
9586     default:
9587       throw_exception (e);
9588     }
9589
9590   /* Create a chain of things that always need to be cleaned up.  */
9591   old_chain = make_cleanup_destroy_linespec_result (&canonical);
9592
9593   /* ----------------------------- SNIP -----------------------------
9594      Anything added to the cleanup chain beyond this point is assumed
9595      to be part of a breakpoint.  If the breakpoint create succeeds
9596      then the memory is not reclaimed.  */
9597   bkpt_chain = make_cleanup (null_cleanup, 0);
9598
9599   /* Resolve all line numbers to PC's and verify that the addresses
9600      are ok for the target.  */
9601   if (!pending)
9602     {
9603       int ix;
9604       struct linespec_sals *iter;
9605
9606       for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9607         breakpoint_sals_to_pc (&iter->sals);
9608     }
9609
9610   /* Fast tracepoints may have additional restrictions on location.  */
9611   if (!pending && type_wanted == bp_fast_tracepoint)
9612     {
9613       int ix;
9614       struct linespec_sals *iter;
9615
9616       for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9617         check_fast_tracepoint_sals (gdbarch, &iter->sals);
9618     }
9619
9620   /* Verify that condition can be parsed, before setting any
9621      breakpoints.  Allocate a separate condition expression for each
9622      breakpoint.  */
9623   if (!pending)
9624     {
9625       struct linespec_sals *lsal;
9626
9627       lsal = VEC_index (linespec_sals, canonical.sals, 0);
9628
9629       if (parse_condition_and_thread)
9630         {
9631             char *rest;
9632             /* Here we only parse 'arg' to separate condition
9633                from thread number, so parsing in context of first
9634                sal is OK.  When setting the breakpoint we'll 
9635                re-parse it in context of each sal.  */
9636
9637             find_condition_and_thread (arg, lsal->sals.sals[0].pc, &cond_string,
9638                                        &thread, &task, &rest);
9639             if (cond_string)
9640                 make_cleanup (xfree, cond_string);
9641             if (rest)
9642               make_cleanup (xfree, rest);
9643             if (rest)
9644               extra_string = rest;
9645         }
9646       else
9647         {
9648             /* Create a private copy of condition string.  */
9649             if (cond_string)
9650             {
9651                 cond_string = xstrdup (cond_string);
9652                 make_cleanup (xfree, cond_string);
9653             }
9654             /* Create a private copy of any extra string.  */
9655             if (extra_string)
9656               {
9657                 extra_string = xstrdup (extra_string);
9658                 make_cleanup (xfree, extra_string);
9659               }
9660         }
9661
9662       ops->create_breakpoints_sal (gdbarch, &canonical, lsal,
9663                                    cond_string, extra_string, type_wanted,
9664                                    tempflag ? disp_del : disp_donttouch,
9665                                    thread, task, ignore_count, ops,
9666                                    from_tty, enabled, internal, flags);
9667     }
9668   else
9669     {
9670       struct breakpoint *b;
9671
9672       make_cleanup (xfree, copy_arg);
9673
9674       if (is_tracepoint_type (type_wanted))
9675         {
9676           struct tracepoint *t;
9677
9678           t = XCNEW (struct tracepoint);
9679           b = &t->base;
9680         }
9681       else
9682         b = XNEW (struct breakpoint);
9683
9684       init_raw_breakpoint_without_location (b, gdbarch, type_wanted, ops);
9685
9686       b->addr_string = copy_arg;
9687       if (parse_condition_and_thread)
9688         b->cond_string = NULL;
9689       else
9690         {
9691           /* Create a private copy of condition string.  */
9692           if (cond_string)
9693             {
9694               cond_string = xstrdup (cond_string);
9695               make_cleanup (xfree, cond_string);
9696             }
9697           b->cond_string = cond_string;
9698         }
9699       b->extra_string = NULL;
9700       b->ignore_count = ignore_count;
9701       b->disposition = tempflag ? disp_del : disp_donttouch;
9702       b->condition_not_parsed = 1;
9703       b->enable_state = enabled ? bp_enabled : bp_disabled;
9704       if ((type_wanted != bp_breakpoint
9705            && type_wanted != bp_hardware_breakpoint) || thread != -1)
9706         b->pspace = current_program_space;
9707
9708       install_breakpoint (internal, b, 0);
9709     }
9710   
9711   if (VEC_length (linespec_sals, canonical.sals) > 1)
9712     {
9713       warning (_("Multiple breakpoints were set.\nUse the "
9714                  "\"delete\" command to delete unwanted breakpoints."));
9715       prev_breakpoint_count = prev_bkpt_count;
9716     }
9717
9718   /* That's it.  Discard the cleanups for data inserted into the
9719      breakpoint.  */
9720   discard_cleanups (bkpt_chain);
9721   /* But cleanup everything else.  */
9722   do_cleanups (old_chain);
9723
9724   /* error call may happen here - have BKPT_CHAIN already discarded.  */
9725   update_global_location_list (1);
9726
9727   return 1;
9728 }
9729
9730 /* Set a breakpoint.
9731    ARG is a string describing breakpoint address,
9732    condition, and thread.
9733    FLAG specifies if a breakpoint is hardware on,
9734    and if breakpoint is temporary, using BP_HARDWARE_FLAG
9735    and BP_TEMPFLAG.  */
9736
9737 static void
9738 break_command_1 (char *arg, int flag, int from_tty)
9739 {
9740   int tempflag = flag & BP_TEMPFLAG;
9741   enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9742                              ? bp_hardware_breakpoint
9743                              : bp_breakpoint);
9744   struct breakpoint_ops *ops;
9745   const char *arg_cp = arg;
9746
9747   /* Matching breakpoints on probes.  */
9748   if (arg && probe_linespec_to_ops (&arg_cp) != NULL)
9749     ops = &bkpt_probe_breakpoint_ops;
9750   else
9751     ops = &bkpt_breakpoint_ops;
9752
9753   create_breakpoint (get_current_arch (),
9754                      arg,
9755                      NULL, 0, NULL, 1 /* parse arg */,
9756                      tempflag, type_wanted,
9757                      0 /* Ignore count */,
9758                      pending_break_support,
9759                      ops,
9760                      from_tty,
9761                      1 /* enabled */,
9762                      0 /* internal */,
9763                      0);
9764 }
9765
9766 /* Helper function for break_command_1 and disassemble_command.  */
9767
9768 void
9769 resolve_sal_pc (struct symtab_and_line *sal)
9770 {
9771   CORE_ADDR pc;
9772
9773   if (sal->pc == 0 && sal->symtab != NULL)
9774     {
9775       if (!find_line_pc (sal->symtab, sal->line, &pc))
9776         error (_("No line %d in file \"%s\"."),
9777                sal->line, symtab_to_filename_for_display (sal->symtab));
9778       sal->pc = pc;
9779
9780       /* If this SAL corresponds to a breakpoint inserted using a line
9781          number, then skip the function prologue if necessary.  */
9782       if (sal->explicit_line)
9783         skip_prologue_sal (sal);
9784     }
9785
9786   if (sal->section == 0 && sal->symtab != NULL)
9787     {
9788       struct blockvector *bv;
9789       struct block *b;
9790       struct symbol *sym;
9791
9792       bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
9793       if (bv != NULL)
9794         {
9795           sym = block_linkage_function (b);
9796           if (sym != NULL)
9797             {
9798               fixup_symbol_section (sym, sal->symtab->objfile);
9799               sal->section = SYMBOL_OBJ_SECTION (sym);
9800             }
9801           else
9802             {
9803               /* It really is worthwhile to have the section, so we'll
9804                  just have to look harder. This case can be executed
9805                  if we have line numbers but no functions (as can
9806                  happen in assembly source).  */
9807
9808               struct minimal_symbol *msym;
9809               struct cleanup *old_chain = save_current_space_and_thread ();
9810
9811               switch_to_program_space_and_thread (sal->pspace);
9812
9813               msym = lookup_minimal_symbol_by_pc (sal->pc);
9814               if (msym)
9815                 sal->section = SYMBOL_OBJ_SECTION (msym);
9816
9817               do_cleanups (old_chain);
9818             }
9819         }
9820     }
9821 }
9822
9823 void
9824 break_command (char *arg, int from_tty)
9825 {
9826   break_command_1 (arg, 0, from_tty);
9827 }
9828
9829 void
9830 tbreak_command (char *arg, int from_tty)
9831 {
9832   break_command_1 (arg, BP_TEMPFLAG, from_tty);
9833 }
9834
9835 static void
9836 hbreak_command (char *arg, int from_tty)
9837 {
9838   break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
9839 }
9840
9841 static void
9842 thbreak_command (char *arg, int from_tty)
9843 {
9844   break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
9845 }
9846
9847 static void
9848 stop_command (char *arg, int from_tty)
9849 {
9850   printf_filtered (_("Specify the type of breakpoint to set.\n\
9851 Usage: stop in <function | address>\n\
9852        stop at <line>\n"));
9853 }
9854
9855 static void
9856 stopin_command (char *arg, int from_tty)
9857 {
9858   int badInput = 0;
9859
9860   if (arg == (char *) NULL)
9861     badInput = 1;
9862   else if (*arg != '*')
9863     {
9864       char *argptr = arg;
9865       int hasColon = 0;
9866
9867       /* Look for a ':'.  If this is a line number specification, then
9868          say it is bad, otherwise, it should be an address or
9869          function/method name.  */
9870       while (*argptr && !hasColon)
9871         {
9872           hasColon = (*argptr == ':');
9873           argptr++;
9874         }
9875
9876       if (hasColon)
9877         badInput = (*argptr != ':');    /* Not a class::method */
9878       else
9879         badInput = isdigit (*arg);      /* a simple line number */
9880     }
9881
9882   if (badInput)
9883     printf_filtered (_("Usage: stop in <function | address>\n"));
9884   else
9885     break_command_1 (arg, 0, from_tty);
9886 }
9887
9888 static void
9889 stopat_command (char *arg, int from_tty)
9890 {
9891   int badInput = 0;
9892
9893   if (arg == (char *) NULL || *arg == '*')      /* no line number */
9894     badInput = 1;
9895   else
9896     {
9897       char *argptr = arg;
9898       int hasColon = 0;
9899
9900       /* Look for a ':'.  If there is a '::' then get out, otherwise
9901          it is probably a line number.  */
9902       while (*argptr && !hasColon)
9903         {
9904           hasColon = (*argptr == ':');
9905           argptr++;
9906         }
9907
9908       if (hasColon)
9909         badInput = (*argptr == ':');    /* we have class::method */
9910       else
9911         badInput = !isdigit (*arg);     /* not a line number */
9912     }
9913
9914   if (badInput)
9915     printf_filtered (_("Usage: stop at <line>\n"));
9916   else
9917     break_command_1 (arg, 0, from_tty);
9918 }
9919
9920 /* The dynamic printf command is mostly like a regular breakpoint, but
9921    with a prewired command list consisting of a single output command,
9922    built from extra arguments supplied on the dprintf command
9923    line.  */
9924
9925 static void
9926 dprintf_command (char *arg, int from_tty)
9927 {
9928   create_breakpoint (get_current_arch (),
9929                      arg,
9930                      NULL, 0, NULL, 1 /* parse arg */,
9931                      0, bp_dprintf,
9932                      0 /* Ignore count */,
9933                      pending_break_support,
9934                      &dprintf_breakpoint_ops,
9935                      from_tty,
9936                      1 /* enabled */,
9937                      0 /* internal */,
9938                      0);
9939 }
9940
9941 static void
9942 agent_printf_command (char *arg, int from_tty)
9943 {
9944   error (_("May only run agent-printf on the target"));
9945 }
9946
9947 /* Implement the "breakpoint_hit" breakpoint_ops method for
9948    ranged breakpoints.  */
9949
9950 static int
9951 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
9952                                   struct address_space *aspace,
9953                                   CORE_ADDR bp_addr,
9954                                   const struct target_waitstatus *ws)
9955 {
9956   if (ws->kind != TARGET_WAITKIND_STOPPED
9957       || ws->value.sig != GDB_SIGNAL_TRAP)
9958     return 0;
9959
9960   return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
9961                                          bl->length, aspace, bp_addr);
9962 }
9963
9964 /* Implement the "resources_needed" breakpoint_ops method for
9965    ranged breakpoints.  */
9966
9967 static int
9968 resources_needed_ranged_breakpoint (const struct bp_location *bl)
9969 {
9970   return target_ranged_break_num_registers ();
9971 }
9972
9973 /* Implement the "print_it" breakpoint_ops method for
9974    ranged breakpoints.  */
9975
9976 static enum print_stop_action
9977 print_it_ranged_breakpoint (bpstat bs)
9978 {
9979   struct breakpoint *b = bs->breakpoint_at;
9980   struct bp_location *bl = b->loc;
9981   struct ui_out *uiout = current_uiout;
9982
9983   gdb_assert (b->type == bp_hardware_breakpoint);
9984
9985   /* Ranged breakpoints have only one location.  */
9986   gdb_assert (bl && bl->next == NULL);
9987
9988   annotate_breakpoint (b->number);
9989   if (b->disposition == disp_del)
9990     ui_out_text (uiout, "\nTemporary ranged breakpoint ");
9991   else
9992     ui_out_text (uiout, "\nRanged breakpoint ");
9993   if (ui_out_is_mi_like_p (uiout))
9994     {
9995       ui_out_field_string (uiout, "reason",
9996                       async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9997       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
9998     }
9999   ui_out_field_int (uiout, "bkptno", b->number);
10000   ui_out_text (uiout, ", ");
10001
10002   return PRINT_SRC_AND_LOC;
10003 }
10004
10005 /* Implement the "print_one" breakpoint_ops method for
10006    ranged breakpoints.  */
10007
10008 static void
10009 print_one_ranged_breakpoint (struct breakpoint *b,
10010                              struct bp_location **last_loc)
10011 {
10012   struct bp_location *bl = b->loc;
10013   struct value_print_options opts;
10014   struct ui_out *uiout = current_uiout;
10015
10016   /* Ranged breakpoints have only one location.  */
10017   gdb_assert (bl && bl->next == NULL);
10018
10019   get_user_print_options (&opts);
10020
10021   if (opts.addressprint)
10022     /* We don't print the address range here, it will be printed later
10023        by print_one_detail_ranged_breakpoint.  */
10024     ui_out_field_skip (uiout, "addr");
10025   annotate_field (5);
10026   print_breakpoint_location (b, bl);
10027   *last_loc = bl;
10028 }
10029
10030 /* Implement the "print_one_detail" breakpoint_ops method for
10031    ranged breakpoints.  */
10032
10033 static void
10034 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
10035                                     struct ui_out *uiout)
10036 {
10037   CORE_ADDR address_start, address_end;
10038   struct bp_location *bl = b->loc;
10039   struct ui_file *stb = mem_fileopen ();
10040   struct cleanup *cleanup = make_cleanup_ui_file_delete (stb);
10041
10042   gdb_assert (bl);
10043
10044   address_start = bl->address;
10045   address_end = address_start + bl->length - 1;
10046
10047   ui_out_text (uiout, "\taddress range: ");
10048   fprintf_unfiltered (stb, "[%s, %s]",
10049                       print_core_address (bl->gdbarch, address_start),
10050                       print_core_address (bl->gdbarch, address_end));
10051   ui_out_field_stream (uiout, "addr", stb);
10052   ui_out_text (uiout, "\n");
10053
10054   do_cleanups (cleanup);
10055 }
10056
10057 /* Implement the "print_mention" breakpoint_ops method for
10058    ranged breakpoints.  */
10059
10060 static void
10061 print_mention_ranged_breakpoint (struct breakpoint *b)
10062 {
10063   struct bp_location *bl = b->loc;
10064   struct ui_out *uiout = current_uiout;
10065
10066   gdb_assert (bl);
10067   gdb_assert (b->type == bp_hardware_breakpoint);
10068
10069   if (ui_out_is_mi_like_p (uiout))
10070     return;
10071
10072   printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
10073                    b->number, paddress (bl->gdbarch, bl->address),
10074                    paddress (bl->gdbarch, bl->address + bl->length - 1));
10075 }
10076
10077 /* Implement the "print_recreate" breakpoint_ops method for
10078    ranged breakpoints.  */
10079
10080 static void
10081 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
10082 {
10083   fprintf_unfiltered (fp, "break-range %s, %s", b->addr_string,
10084                       b->addr_string_range_end);
10085   print_recreate_thread (b, fp);
10086 }
10087
10088 /* The breakpoint_ops structure to be used in ranged breakpoints.  */
10089
10090 static struct breakpoint_ops ranged_breakpoint_ops;
10091
10092 /* Find the address where the end of the breakpoint range should be
10093    placed, given the SAL of the end of the range.  This is so that if
10094    the user provides a line number, the end of the range is set to the
10095    last instruction of the given line.  */
10096
10097 static CORE_ADDR
10098 find_breakpoint_range_end (struct symtab_and_line sal)
10099 {
10100   CORE_ADDR end;
10101
10102   /* If the user provided a PC value, use it.  Otherwise,
10103      find the address of the end of the given location.  */
10104   if (sal.explicit_pc)
10105     end = sal.pc;
10106   else
10107     {
10108       int ret;
10109       CORE_ADDR start;
10110
10111       ret = find_line_pc_range (sal, &start, &end);
10112       if (!ret)
10113         error (_("Could not find location of the end of the range."));
10114
10115       /* find_line_pc_range returns the start of the next line.  */
10116       end--;
10117     }
10118
10119   return end;
10120 }
10121
10122 /* Implement the "break-range" CLI command.  */
10123
10124 static void
10125 break_range_command (char *arg, int from_tty)
10126 {
10127   char *arg_start, *addr_string_start, *addr_string_end;
10128   struct linespec_result canonical_start, canonical_end;
10129   int bp_count, can_use_bp, length;
10130   CORE_ADDR end;
10131   struct breakpoint *b;
10132   struct symtab_and_line sal_start, sal_end;
10133   struct cleanup *cleanup_bkpt;
10134   struct linespec_sals *lsal_start, *lsal_end;
10135
10136   /* We don't support software ranged breakpoints.  */
10137   if (target_ranged_break_num_registers () < 0)
10138     error (_("This target does not support hardware ranged breakpoints."));
10139
10140   bp_count = hw_breakpoint_used_count ();
10141   bp_count += target_ranged_break_num_registers ();
10142   can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
10143                                                    bp_count, 0);
10144   if (can_use_bp < 0)
10145     error (_("Hardware breakpoints used exceeds limit."));
10146
10147   arg = skip_spaces (arg);
10148   if (arg == NULL || arg[0] == '\0')
10149     error(_("No address range specified."));
10150
10151   init_linespec_result (&canonical_start);
10152
10153   arg_start = arg;
10154   parse_breakpoint_sals (&arg, &canonical_start);
10155
10156   cleanup_bkpt = make_cleanup_destroy_linespec_result (&canonical_start);
10157
10158   if (arg[0] != ',')
10159     error (_("Too few arguments."));
10160   else if (VEC_empty (linespec_sals, canonical_start.sals))
10161     error (_("Could not find location of the beginning of the range."));
10162
10163   lsal_start = VEC_index (linespec_sals, canonical_start.sals, 0);
10164
10165   if (VEC_length (linespec_sals, canonical_start.sals) > 1
10166       || lsal_start->sals.nelts != 1)
10167     error (_("Cannot create a ranged breakpoint with multiple locations."));
10168
10169   sal_start = lsal_start->sals.sals[0];
10170   addr_string_start = savestring (arg_start, arg - arg_start);
10171   make_cleanup (xfree, addr_string_start);
10172
10173   arg++;        /* Skip the comma.  */
10174   arg = skip_spaces (arg);
10175
10176   /* Parse the end location.  */
10177
10178   init_linespec_result (&canonical_end);
10179   arg_start = arg;
10180
10181   /* We call decode_line_full directly here instead of using
10182      parse_breakpoint_sals because we need to specify the start location's
10183      symtab and line as the default symtab and line for the end of the
10184      range.  This makes it possible to have ranges like "foo.c:27, +14",
10185      where +14 means 14 lines from the start location.  */
10186   decode_line_full (&arg, DECODE_LINE_FUNFIRSTLINE,
10187                     sal_start.symtab, sal_start.line,
10188                     &canonical_end, NULL, NULL);
10189
10190   make_cleanup_destroy_linespec_result (&canonical_end);
10191
10192   if (VEC_empty (linespec_sals, canonical_end.sals))
10193     error (_("Could not find location of the end of the range."));
10194
10195   lsal_end = VEC_index (linespec_sals, canonical_end.sals, 0);
10196   if (VEC_length (linespec_sals, canonical_end.sals) > 1
10197       || lsal_end->sals.nelts != 1)
10198     error (_("Cannot create a ranged breakpoint with multiple locations."));
10199
10200   sal_end = lsal_end->sals.sals[0];
10201   addr_string_end = savestring (arg_start, arg - arg_start);
10202   make_cleanup (xfree, addr_string_end);
10203
10204   end = find_breakpoint_range_end (sal_end);
10205   if (sal_start.pc > end)
10206     error (_("Invalid address range, end precedes start."));
10207
10208   length = end - sal_start.pc + 1;
10209   if (length < 0)
10210     /* Length overflowed.  */
10211     error (_("Address range too large."));
10212   else if (length == 1)
10213     {
10214       /* This range is simple enough to be handled by
10215          the `hbreak' command.  */
10216       hbreak_command (addr_string_start, 1);
10217
10218       do_cleanups (cleanup_bkpt);
10219
10220       return;
10221     }
10222
10223   /* Now set up the breakpoint.  */
10224   b = set_raw_breakpoint (get_current_arch (), sal_start,
10225                           bp_hardware_breakpoint, &ranged_breakpoint_ops);
10226   set_breakpoint_count (breakpoint_count + 1);
10227   b->number = breakpoint_count;
10228   b->disposition = disp_donttouch;
10229   b->addr_string = xstrdup (addr_string_start);
10230   b->addr_string_range_end = xstrdup (addr_string_end);
10231   b->loc->length = length;
10232
10233   do_cleanups (cleanup_bkpt);
10234
10235   mention (b);
10236   observer_notify_breakpoint_created (b);
10237   update_global_location_list (1);
10238 }
10239
10240 /*  Return non-zero if EXP is verified as constant.  Returned zero
10241     means EXP is variable.  Also the constant detection may fail for
10242     some constant expressions and in such case still falsely return
10243     zero.  */
10244
10245 static int
10246 watchpoint_exp_is_const (const struct expression *exp)
10247 {
10248   int i = exp->nelts;
10249
10250   while (i > 0)
10251     {
10252       int oplenp, argsp;
10253
10254       /* We are only interested in the descriptor of each element.  */
10255       operator_length (exp, i, &oplenp, &argsp);
10256       i -= oplenp;
10257
10258       switch (exp->elts[i].opcode)
10259         {
10260         case BINOP_ADD:
10261         case BINOP_SUB:
10262         case BINOP_MUL:
10263         case BINOP_DIV:
10264         case BINOP_REM:
10265         case BINOP_MOD:
10266         case BINOP_LSH:
10267         case BINOP_RSH:
10268         case BINOP_LOGICAL_AND:
10269         case BINOP_LOGICAL_OR:
10270         case BINOP_BITWISE_AND:
10271         case BINOP_BITWISE_IOR:
10272         case BINOP_BITWISE_XOR:
10273         case BINOP_EQUAL:
10274         case BINOP_NOTEQUAL:
10275         case BINOP_LESS:
10276         case BINOP_GTR:
10277         case BINOP_LEQ:
10278         case BINOP_GEQ:
10279         case BINOP_REPEAT:
10280         case BINOP_COMMA:
10281         case BINOP_EXP:
10282         case BINOP_MIN:
10283         case BINOP_MAX:
10284         case BINOP_INTDIV:
10285         case BINOP_CONCAT:
10286         case BINOP_IN:
10287         case BINOP_RANGE:
10288         case TERNOP_COND:
10289         case TERNOP_SLICE:
10290
10291         case OP_LONG:
10292         case OP_DOUBLE:
10293         case OP_DECFLOAT:
10294         case OP_LAST:
10295         case OP_COMPLEX:
10296         case OP_STRING:
10297         case OP_ARRAY:
10298         case OP_TYPE:
10299         case OP_TYPEOF:
10300         case OP_DECLTYPE:
10301         case OP_NAME:
10302         case OP_OBJC_NSSTRING:
10303
10304         case UNOP_NEG:
10305         case UNOP_LOGICAL_NOT:
10306         case UNOP_COMPLEMENT:
10307         case UNOP_ADDR:
10308         case UNOP_HIGH:
10309         case UNOP_CAST:
10310
10311         case UNOP_CAST_TYPE:
10312         case UNOP_REINTERPRET_CAST:
10313         case UNOP_DYNAMIC_CAST:
10314           /* Unary, binary and ternary operators: We have to check
10315              their operands.  If they are constant, then so is the
10316              result of that operation.  For instance, if A and B are
10317              determined to be constants, then so is "A + B".
10318
10319              UNOP_IND is one exception to the rule above, because the
10320              value of *ADDR is not necessarily a constant, even when
10321              ADDR is.  */
10322           break;
10323
10324         case OP_VAR_VALUE:
10325           /* Check whether the associated symbol is a constant.
10326
10327              We use SYMBOL_CLASS rather than TYPE_CONST because it's
10328              possible that a buggy compiler could mark a variable as
10329              constant even when it is not, and TYPE_CONST would return
10330              true in this case, while SYMBOL_CLASS wouldn't.
10331
10332              We also have to check for function symbols because they
10333              are always constant.  */
10334           {
10335             struct symbol *s = exp->elts[i + 2].symbol;
10336
10337             if (SYMBOL_CLASS (s) != LOC_BLOCK
10338                 && SYMBOL_CLASS (s) != LOC_CONST
10339                 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
10340               return 0;
10341             break;
10342           }
10343
10344         /* The default action is to return 0 because we are using
10345            the optimistic approach here: If we don't know something,
10346            then it is not a constant.  */
10347         default:
10348           return 0;
10349         }
10350     }
10351
10352   return 1;
10353 }
10354
10355 /* Implement the "dtor" breakpoint_ops method for watchpoints.  */
10356
10357 static void
10358 dtor_watchpoint (struct breakpoint *self)
10359 {
10360   struct watchpoint *w = (struct watchpoint *) self;
10361
10362   xfree (w->cond_exp);
10363   xfree (w->exp);
10364   xfree (w->exp_string);
10365   xfree (w->exp_string_reparse);
10366   value_free (w->val);
10367
10368   base_breakpoint_ops.dtor (self);
10369 }
10370
10371 /* Implement the "re_set" breakpoint_ops method for watchpoints.  */
10372
10373 static void
10374 re_set_watchpoint (struct breakpoint *b)
10375 {
10376   struct watchpoint *w = (struct watchpoint *) b;
10377
10378   /* Watchpoint can be either on expression using entirely global
10379      variables, or it can be on local variables.
10380
10381      Watchpoints of the first kind are never auto-deleted, and even
10382      persist across program restarts.  Since they can use variables
10383      from shared libraries, we need to reparse expression as libraries
10384      are loaded and unloaded.
10385
10386      Watchpoints on local variables can also change meaning as result
10387      of solib event.  For example, if a watchpoint uses both a local
10388      and a global variables in expression, it's a local watchpoint,
10389      but unloading of a shared library will make the expression
10390      invalid.  This is not a very common use case, but we still
10391      re-evaluate expression, to avoid surprises to the user.
10392
10393      Note that for local watchpoints, we re-evaluate it only if
10394      watchpoints frame id is still valid.  If it's not, it means the
10395      watchpoint is out of scope and will be deleted soon.  In fact,
10396      I'm not sure we'll ever be called in this case.
10397
10398      If a local watchpoint's frame id is still valid, then
10399      w->exp_valid_block is likewise valid, and we can safely use it.
10400
10401      Don't do anything about disabled watchpoints, since they will be
10402      reevaluated again when enabled.  */
10403   update_watchpoint (w, 1 /* reparse */);
10404 }
10405
10406 /* Implement the "insert" breakpoint_ops method for hardware watchpoints.  */
10407
10408 static int
10409 insert_watchpoint (struct bp_location *bl)
10410 {
10411   struct watchpoint *w = (struct watchpoint *) bl->owner;
10412   int length = w->exact ? 1 : bl->length;
10413
10414   return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
10415                                    w->cond_exp);
10416 }
10417
10418 /* Implement the "remove" breakpoint_ops method for hardware watchpoints.  */
10419
10420 static int
10421 remove_watchpoint (struct bp_location *bl)
10422 {
10423   struct watchpoint *w = (struct watchpoint *) bl->owner;
10424   int length = w->exact ? 1 : bl->length;
10425
10426   return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
10427                                    w->cond_exp);
10428 }
10429
10430 static int
10431 breakpoint_hit_watchpoint (const struct bp_location *bl,
10432                            struct address_space *aspace, CORE_ADDR bp_addr,
10433                            const struct target_waitstatus *ws)
10434 {
10435   struct breakpoint *b = bl->owner;
10436   struct watchpoint *w = (struct watchpoint *) b;
10437
10438   /* Continuable hardware watchpoints are treated as non-existent if the
10439      reason we stopped wasn't a hardware watchpoint (we didn't stop on
10440      some data address).  Otherwise gdb won't stop on a break instruction
10441      in the code (not from a breakpoint) when a hardware watchpoint has
10442      been defined.  Also skip watchpoints which we know did not trigger
10443      (did not match the data address).  */
10444   if (is_hardware_watchpoint (b)
10445       && w->watchpoint_triggered == watch_triggered_no)
10446     return 0;
10447
10448   return 1;
10449 }
10450
10451 static void
10452 check_status_watchpoint (bpstat bs)
10453 {
10454   gdb_assert (is_watchpoint (bs->breakpoint_at));
10455
10456   bpstat_check_watchpoint (bs);
10457 }
10458
10459 /* Implement the "resources_needed" breakpoint_ops method for
10460    hardware watchpoints.  */
10461
10462 static int
10463 resources_needed_watchpoint (const struct bp_location *bl)
10464 {
10465   struct watchpoint *w = (struct watchpoint *) bl->owner;
10466   int length = w->exact? 1 : bl->length;
10467
10468   return target_region_ok_for_hw_watchpoint (bl->address, length);
10469 }
10470
10471 /* Implement the "works_in_software_mode" breakpoint_ops method for
10472    hardware watchpoints.  */
10473
10474 static int
10475 works_in_software_mode_watchpoint (const struct breakpoint *b)
10476 {
10477   /* Read and access watchpoints only work with hardware support.  */
10478   return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
10479 }
10480
10481 static enum print_stop_action
10482 print_it_watchpoint (bpstat bs)
10483 {
10484   struct cleanup *old_chain;
10485   struct breakpoint *b;
10486   const struct bp_location *bl;
10487   struct ui_file *stb;
10488   enum print_stop_action result;
10489   struct watchpoint *w;
10490   struct ui_out *uiout = current_uiout;
10491
10492   gdb_assert (bs->bp_location_at != NULL);
10493
10494   bl = bs->bp_location_at;
10495   b = bs->breakpoint_at;
10496   w = (struct watchpoint *) b;
10497
10498   stb = mem_fileopen ();
10499   old_chain = make_cleanup_ui_file_delete (stb);
10500
10501   switch (b->type)
10502     {
10503     case bp_watchpoint:
10504     case bp_hardware_watchpoint:
10505       annotate_watchpoint (b->number);
10506       if (ui_out_is_mi_like_p (uiout))
10507         ui_out_field_string
10508           (uiout, "reason",
10509            async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10510       mention (b);
10511       make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10512       ui_out_text (uiout, "\nOld value = ");
10513       watchpoint_value_print (bs->old_val, stb);
10514       ui_out_field_stream (uiout, "old", stb);
10515       ui_out_text (uiout, "\nNew value = ");
10516       watchpoint_value_print (w->val, stb);
10517       ui_out_field_stream (uiout, "new", stb);
10518       ui_out_text (uiout, "\n");
10519       /* More than one watchpoint may have been triggered.  */
10520       result = PRINT_UNKNOWN;
10521       break;
10522
10523     case bp_read_watchpoint:
10524       if (ui_out_is_mi_like_p (uiout))
10525         ui_out_field_string
10526           (uiout, "reason",
10527            async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10528       mention (b);
10529       make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10530       ui_out_text (uiout, "\nValue = ");
10531       watchpoint_value_print (w->val, stb);
10532       ui_out_field_stream (uiout, "value", stb);
10533       ui_out_text (uiout, "\n");
10534       result = PRINT_UNKNOWN;
10535       break;
10536
10537     case bp_access_watchpoint:
10538       if (bs->old_val != NULL)
10539         {
10540           annotate_watchpoint (b->number);
10541           if (ui_out_is_mi_like_p (uiout))
10542             ui_out_field_string
10543               (uiout, "reason",
10544                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10545           mention (b);
10546           make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10547           ui_out_text (uiout, "\nOld value = ");
10548           watchpoint_value_print (bs->old_val, stb);
10549           ui_out_field_stream (uiout, "old", stb);
10550           ui_out_text (uiout, "\nNew value = ");
10551         }
10552       else
10553         {
10554           mention (b);
10555           if (ui_out_is_mi_like_p (uiout))
10556             ui_out_field_string
10557               (uiout, "reason",
10558                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10559           make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10560           ui_out_text (uiout, "\nValue = ");
10561         }
10562       watchpoint_value_print (w->val, stb);
10563       ui_out_field_stream (uiout, "new", stb);
10564       ui_out_text (uiout, "\n");
10565       result = PRINT_UNKNOWN;
10566       break;
10567     default:
10568       result = PRINT_UNKNOWN;
10569     }
10570
10571   do_cleanups (old_chain);
10572   return result;
10573 }
10574
10575 /* Implement the "print_mention" breakpoint_ops method for hardware
10576    watchpoints.  */
10577
10578 static void
10579 print_mention_watchpoint (struct breakpoint *b)
10580 {
10581   struct cleanup *ui_out_chain;
10582   struct watchpoint *w = (struct watchpoint *) b;
10583   struct ui_out *uiout = current_uiout;
10584
10585   switch (b->type)
10586     {
10587     case bp_watchpoint:
10588       ui_out_text (uiout, "Watchpoint ");
10589       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10590       break;
10591     case bp_hardware_watchpoint:
10592       ui_out_text (uiout, "Hardware watchpoint ");
10593       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10594       break;
10595     case bp_read_watchpoint:
10596       ui_out_text (uiout, "Hardware read watchpoint ");
10597       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10598       break;
10599     case bp_access_watchpoint:
10600       ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
10601       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
10602       break;
10603     default:
10604       internal_error (__FILE__, __LINE__,
10605                       _("Invalid hardware watchpoint type."));
10606     }
10607
10608   ui_out_field_int (uiout, "number", b->number);
10609   ui_out_text (uiout, ": ");
10610   ui_out_field_string (uiout, "exp", w->exp_string);
10611   do_cleanups (ui_out_chain);
10612 }
10613
10614 /* Implement the "print_recreate" breakpoint_ops method for
10615    watchpoints.  */
10616
10617 static void
10618 print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10619 {
10620   struct watchpoint *w = (struct watchpoint *) b;
10621
10622   switch (b->type)
10623     {
10624     case bp_watchpoint:
10625     case bp_hardware_watchpoint:
10626       fprintf_unfiltered (fp, "watch");
10627       break;
10628     case bp_read_watchpoint:
10629       fprintf_unfiltered (fp, "rwatch");
10630       break;
10631     case bp_access_watchpoint:
10632       fprintf_unfiltered (fp, "awatch");
10633       break;
10634     default:
10635       internal_error (__FILE__, __LINE__,
10636                       _("Invalid watchpoint type."));
10637     }
10638
10639   fprintf_unfiltered (fp, " %s", w->exp_string);
10640   print_recreate_thread (b, fp);
10641 }
10642
10643 /* The breakpoint_ops structure to be used in hardware watchpoints.  */
10644
10645 static struct breakpoint_ops watchpoint_breakpoint_ops;
10646
10647 /* Implement the "insert" breakpoint_ops method for
10648    masked hardware watchpoints.  */
10649
10650 static int
10651 insert_masked_watchpoint (struct bp_location *bl)
10652 {
10653   struct watchpoint *w = (struct watchpoint *) bl->owner;
10654
10655   return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
10656                                         bl->watchpoint_type);
10657 }
10658
10659 /* Implement the "remove" breakpoint_ops method for
10660    masked hardware watchpoints.  */
10661
10662 static int
10663 remove_masked_watchpoint (struct bp_location *bl)
10664 {
10665   struct watchpoint *w = (struct watchpoint *) bl->owner;
10666
10667   return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
10668                                         bl->watchpoint_type);
10669 }
10670
10671 /* Implement the "resources_needed" breakpoint_ops method for
10672    masked hardware watchpoints.  */
10673
10674 static int
10675 resources_needed_masked_watchpoint (const struct bp_location *bl)
10676 {
10677   struct watchpoint *w = (struct watchpoint *) bl->owner;
10678
10679   return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
10680 }
10681
10682 /* Implement the "works_in_software_mode" breakpoint_ops method for
10683    masked hardware watchpoints.  */
10684
10685 static int
10686 works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10687 {
10688   return 0;
10689 }
10690
10691 /* Implement the "print_it" breakpoint_ops method for
10692    masked hardware watchpoints.  */
10693
10694 static enum print_stop_action
10695 print_it_masked_watchpoint (bpstat bs)
10696 {
10697   struct breakpoint *b = bs->breakpoint_at;
10698   struct ui_out *uiout = current_uiout;
10699
10700   /* Masked watchpoints have only one location.  */
10701   gdb_assert (b->loc && b->loc->next == NULL);
10702
10703   switch (b->type)
10704     {
10705     case bp_hardware_watchpoint:
10706       annotate_watchpoint (b->number);
10707       if (ui_out_is_mi_like_p (uiout))
10708         ui_out_field_string
10709           (uiout, "reason",
10710            async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10711       break;
10712
10713     case bp_read_watchpoint:
10714       if (ui_out_is_mi_like_p (uiout))
10715         ui_out_field_string
10716           (uiout, "reason",
10717            async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10718       break;
10719
10720     case bp_access_watchpoint:
10721       if (ui_out_is_mi_like_p (uiout))
10722         ui_out_field_string
10723           (uiout, "reason",
10724            async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10725       break;
10726     default:
10727       internal_error (__FILE__, __LINE__,
10728                       _("Invalid hardware watchpoint type."));
10729     }
10730
10731   mention (b);
10732   ui_out_text (uiout, _("\n\
10733 Check the underlying instruction at PC for the memory\n\
10734 address and value which triggered this watchpoint.\n"));
10735   ui_out_text (uiout, "\n");
10736
10737   /* More than one watchpoint may have been triggered.  */
10738   return PRINT_UNKNOWN;
10739 }
10740
10741 /* Implement the "print_one_detail" breakpoint_ops method for
10742    masked hardware watchpoints.  */
10743
10744 static void
10745 print_one_detail_masked_watchpoint (const struct breakpoint *b,
10746                                     struct ui_out *uiout)
10747 {
10748   struct watchpoint *w = (struct watchpoint *) b;
10749
10750   /* Masked watchpoints have only one location.  */
10751   gdb_assert (b->loc && b->loc->next == NULL);
10752
10753   ui_out_text (uiout, "\tmask ");
10754   ui_out_field_core_addr (uiout, "mask", b->loc->gdbarch, w->hw_wp_mask);
10755   ui_out_text (uiout, "\n");
10756 }
10757
10758 /* Implement the "print_mention" breakpoint_ops method for
10759    masked hardware watchpoints.  */
10760
10761 static void
10762 print_mention_masked_watchpoint (struct breakpoint *b)
10763 {
10764   struct watchpoint *w = (struct watchpoint *) b;
10765   struct ui_out *uiout = current_uiout;
10766   struct cleanup *ui_out_chain;
10767
10768   switch (b->type)
10769     {
10770     case bp_hardware_watchpoint:
10771       ui_out_text (uiout, "Masked hardware watchpoint ");
10772       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10773       break;
10774     case bp_read_watchpoint:
10775       ui_out_text (uiout, "Masked hardware read watchpoint ");
10776       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10777       break;
10778     case bp_access_watchpoint:
10779       ui_out_text (uiout, "Masked hardware access (read/write) watchpoint ");
10780       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
10781       break;
10782     default:
10783       internal_error (__FILE__, __LINE__,
10784                       _("Invalid hardware watchpoint type."));
10785     }
10786
10787   ui_out_field_int (uiout, "number", b->number);
10788   ui_out_text (uiout, ": ");
10789   ui_out_field_string (uiout, "exp", w->exp_string);
10790   do_cleanups (ui_out_chain);
10791 }
10792
10793 /* Implement the "print_recreate" breakpoint_ops method for
10794    masked hardware watchpoints.  */
10795
10796 static void
10797 print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
10798 {
10799   struct watchpoint *w = (struct watchpoint *) b;
10800   char tmp[40];
10801
10802   switch (b->type)
10803     {
10804     case bp_hardware_watchpoint:
10805       fprintf_unfiltered (fp, "watch");
10806       break;
10807     case bp_read_watchpoint:
10808       fprintf_unfiltered (fp, "rwatch");
10809       break;
10810     case bp_access_watchpoint:
10811       fprintf_unfiltered (fp, "awatch");
10812       break;
10813     default:
10814       internal_error (__FILE__, __LINE__,
10815                       _("Invalid hardware watchpoint type."));
10816     }
10817
10818   sprintf_vma (tmp, w->hw_wp_mask);
10819   fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
10820   print_recreate_thread (b, fp);
10821 }
10822
10823 /* The breakpoint_ops structure to be used in masked hardware watchpoints.  */
10824
10825 static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
10826
10827 /* Tell whether the given watchpoint is a masked hardware watchpoint.  */
10828
10829 static int
10830 is_masked_watchpoint (const struct breakpoint *b)
10831 {
10832   return b->ops == &masked_watchpoint_breakpoint_ops;
10833 }
10834
10835 /* accessflag:  hw_write:  watch write, 
10836                 hw_read:   watch read, 
10837                 hw_access: watch access (read or write) */
10838 static void
10839 watch_command_1 (char *arg, int accessflag, int from_tty,
10840                  int just_location, int internal)
10841 {
10842   volatile struct gdb_exception e;
10843   struct breakpoint *b, *scope_breakpoint = NULL;
10844   struct expression *exp;
10845   const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
10846   struct value *val, *mark, *result;
10847   struct frame_info *frame;
10848   char *exp_start = NULL;
10849   char *exp_end = NULL;
10850   char *tok, *end_tok;
10851   int toklen = -1;
10852   char *cond_start = NULL;
10853   char *cond_end = NULL;
10854   enum bptype bp_type;
10855   int thread = -1;
10856   int pc = 0;
10857   /* Flag to indicate whether we are going to use masks for
10858      the hardware watchpoint.  */
10859   int use_mask = 0;
10860   CORE_ADDR mask = 0;
10861   struct watchpoint *w;
10862
10863   /* Make sure that we actually have parameters to parse.  */
10864   if (arg != NULL && arg[0] != '\0')
10865     {
10866       char *value_start;
10867
10868       /* Look for "parameter value" pairs at the end
10869          of the arguments string.  */
10870       for (tok = arg + strlen (arg) - 1; tok > arg; tok--)
10871         {
10872           /* Skip whitespace at the end of the argument list.  */
10873           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10874             tok--;
10875
10876           /* Find the beginning of the last token.
10877              This is the value of the parameter.  */
10878           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10879             tok--;
10880           value_start = tok + 1;
10881
10882           /* Skip whitespace.  */
10883           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10884             tok--;
10885
10886           end_tok = tok;
10887
10888           /* Find the beginning of the second to last token.
10889              This is the parameter itself.  */
10890           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10891             tok--;
10892           tok++;
10893           toklen = end_tok - tok + 1;
10894
10895           if (toklen == 6 && !strncmp (tok, "thread", 6))
10896             {
10897               /* At this point we've found a "thread" token, which means
10898                  the user is trying to set a watchpoint that triggers
10899                  only in a specific thread.  */
10900               char *endp;
10901
10902               if (thread != -1)
10903                 error(_("You can specify only one thread."));
10904
10905               /* Extract the thread ID from the next token.  */
10906               thread = strtol (value_start, &endp, 0);
10907
10908               /* Check if the user provided a valid numeric value for the
10909                  thread ID.  */
10910               if (*endp != ' ' && *endp != '\t' && *endp != '\0')
10911                 error (_("Invalid thread ID specification %s."), value_start);
10912
10913               /* Check if the thread actually exists.  */
10914               if (!valid_thread_id (thread))
10915                 invalid_thread_id_error (thread);
10916             }
10917           else if (toklen == 4 && !strncmp (tok, "mask", 4))
10918             {
10919               /* We've found a "mask" token, which means the user wants to
10920                  create a hardware watchpoint that is going to have the mask
10921                  facility.  */
10922               struct value *mask_value, *mark;
10923
10924               if (use_mask)
10925                 error(_("You can specify only one mask."));
10926
10927               use_mask = just_location = 1;
10928
10929               mark = value_mark ();
10930               mask_value = parse_to_comma_and_eval (&value_start);
10931               mask = value_as_address (mask_value);
10932               value_free_to_mark (mark);
10933             }
10934           else
10935             /* We didn't recognize what we found.  We should stop here.  */
10936             break;
10937
10938           /* Truncate the string and get rid of the "parameter value" pair before
10939              the arguments string is parsed by the parse_exp_1 function.  */
10940           *tok = '\0';
10941         }
10942     }
10943
10944   /* Parse the rest of the arguments.  */
10945   innermost_block = NULL;
10946   exp_start = arg;
10947   exp = parse_exp_1 (&arg, 0, 0, 0);
10948   exp_end = arg;
10949   /* Remove trailing whitespace from the expression before saving it.
10950      This makes the eventual display of the expression string a bit
10951      prettier.  */
10952   while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
10953     --exp_end;
10954
10955   /* Checking if the expression is not constant.  */
10956   if (watchpoint_exp_is_const (exp))
10957     {
10958       int len;
10959
10960       len = exp_end - exp_start;
10961       while (len > 0 && isspace (exp_start[len - 1]))
10962         len--;
10963       error (_("Cannot watch constant value `%.*s'."), len, exp_start);
10964     }
10965
10966   exp_valid_block = innermost_block;
10967   mark = value_mark ();
10968   fetch_subexp_value (exp, &pc, &val, &result, NULL);
10969
10970   if (just_location)
10971     {
10972       int ret;
10973
10974       exp_valid_block = NULL;
10975       val = value_addr (result);
10976       release_value (val);
10977       value_free_to_mark (mark);
10978
10979       if (use_mask)
10980         {
10981           ret = target_masked_watch_num_registers (value_as_address (val),
10982                                                    mask);
10983           if (ret == -1)
10984             error (_("This target does not support masked watchpoints."));
10985           else if (ret == -2)
10986             error (_("Invalid mask or memory region."));
10987         }
10988     }
10989   else if (val != NULL)
10990     release_value (val);
10991
10992   tok = skip_spaces (arg);
10993   end_tok = skip_to_space (tok);
10994
10995   toklen = end_tok - tok;
10996   if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
10997     {
10998       struct expression *cond;
10999
11000       innermost_block = NULL;
11001       tok = cond_start = end_tok + 1;
11002       cond = parse_exp_1 (&tok, 0, 0, 0);
11003
11004       /* The watchpoint expression may not be local, but the condition
11005          may still be.  E.g.: `watch global if local > 0'.  */
11006       cond_exp_valid_block = innermost_block;
11007
11008       xfree (cond);
11009       cond_end = tok;
11010     }
11011   if (*tok)
11012     error (_("Junk at end of command."));
11013
11014   if (accessflag == hw_read)
11015     bp_type = bp_read_watchpoint;
11016   else if (accessflag == hw_access)
11017     bp_type = bp_access_watchpoint;
11018   else
11019     bp_type = bp_hardware_watchpoint;
11020
11021   frame = block_innermost_frame (exp_valid_block);
11022
11023   /* If the expression is "local", then set up a "watchpoint scope"
11024      breakpoint at the point where we've left the scope of the watchpoint
11025      expression.  Create the scope breakpoint before the watchpoint, so
11026      that we will encounter it first in bpstat_stop_status.  */
11027   if (exp_valid_block && frame)
11028     {
11029       if (frame_id_p (frame_unwind_caller_id (frame)))
11030         {
11031           scope_breakpoint
11032             = create_internal_breakpoint (frame_unwind_caller_arch (frame),
11033                                           frame_unwind_caller_pc (frame),
11034                                           bp_watchpoint_scope,
11035                                           &momentary_breakpoint_ops);
11036
11037           scope_breakpoint->enable_state = bp_enabled;
11038
11039           /* Automatically delete the breakpoint when it hits.  */
11040           scope_breakpoint->disposition = disp_del;
11041
11042           /* Only break in the proper frame (help with recursion).  */
11043           scope_breakpoint->frame_id = frame_unwind_caller_id (frame);
11044
11045           /* Set the address at which we will stop.  */
11046           scope_breakpoint->loc->gdbarch
11047             = frame_unwind_caller_arch (frame);
11048           scope_breakpoint->loc->requested_address
11049             = frame_unwind_caller_pc (frame);
11050           scope_breakpoint->loc->address
11051             = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
11052                                          scope_breakpoint->loc->requested_address,
11053                                          scope_breakpoint->type);
11054         }
11055     }
11056
11057   /* Now set up the breakpoint.  */
11058
11059   w = XCNEW (struct watchpoint);
11060   b = &w->base;
11061   if (use_mask)
11062     init_raw_breakpoint_without_location (b, NULL, bp_type,
11063                                           &masked_watchpoint_breakpoint_ops);
11064   else
11065     init_raw_breakpoint_without_location (b, NULL, bp_type,
11066                                           &watchpoint_breakpoint_ops);
11067   b->thread = thread;
11068   b->disposition = disp_donttouch;
11069   b->pspace = current_program_space;
11070   w->exp = exp;
11071   w->exp_valid_block = exp_valid_block;
11072   w->cond_exp_valid_block = cond_exp_valid_block;
11073   if (just_location)
11074     {
11075       struct type *t = value_type (val);
11076       CORE_ADDR addr = value_as_address (val);
11077       char *name;
11078
11079       t = check_typedef (TYPE_TARGET_TYPE (check_typedef (t)));
11080       name = type_to_string (t);
11081
11082       w->exp_string_reparse = xstrprintf ("* (%s *) %s", name,
11083                                           core_addr_to_string (addr));
11084       xfree (name);
11085
11086       w->exp_string = xstrprintf ("-location %.*s",
11087                                   (int) (exp_end - exp_start), exp_start);
11088
11089       /* The above expression is in C.  */
11090       b->language = language_c;
11091     }
11092   else
11093     w->exp_string = savestring (exp_start, exp_end - exp_start);
11094
11095   if (use_mask)
11096     {
11097       w->hw_wp_mask = mask;
11098     }
11099   else
11100     {
11101       w->val = val;
11102       w->val_valid = 1;
11103     }
11104
11105   if (cond_start)
11106     b->cond_string = savestring (cond_start, cond_end - cond_start);
11107   else
11108     b->cond_string = 0;
11109
11110   if (frame)
11111     {
11112       w->watchpoint_frame = get_frame_id (frame);
11113       w->watchpoint_thread = inferior_ptid;
11114     }
11115   else
11116     {
11117       w->watchpoint_frame = null_frame_id;
11118       w->watchpoint_thread = null_ptid;
11119     }
11120
11121   if (scope_breakpoint != NULL)
11122     {
11123       /* The scope breakpoint is related to the watchpoint.  We will
11124          need to act on them together.  */
11125       b->related_breakpoint = scope_breakpoint;
11126       scope_breakpoint->related_breakpoint = b;
11127     }
11128
11129   if (!just_location)
11130     value_free_to_mark (mark);
11131
11132   TRY_CATCH (e, RETURN_MASK_ALL)
11133     {
11134       /* Finally update the new watchpoint.  This creates the locations
11135          that should be inserted.  */
11136       update_watchpoint (w, 1);
11137     }
11138   if (e.reason < 0)
11139     {
11140       delete_breakpoint (b);
11141       throw_exception (e);
11142     }
11143
11144   install_breakpoint (internal, b, 1);
11145 }
11146
11147 /* Return count of debug registers needed to watch the given expression.
11148    If the watchpoint cannot be handled in hardware return zero.  */
11149
11150 static int
11151 can_use_hardware_watchpoint (struct value *v)
11152 {
11153   int found_memory_cnt = 0;
11154   struct value *head = v;
11155
11156   /* Did the user specifically forbid us to use hardware watchpoints? */
11157   if (!can_use_hw_watchpoints)
11158     return 0;
11159
11160   /* Make sure that the value of the expression depends only upon
11161      memory contents, and values computed from them within GDB.  If we
11162      find any register references or function calls, we can't use a
11163      hardware watchpoint.
11164
11165      The idea here is that evaluating an expression generates a series
11166      of values, one holding the value of every subexpression.  (The
11167      expression a*b+c has five subexpressions: a, b, a*b, c, and
11168      a*b+c.)  GDB's values hold almost enough information to establish
11169      the criteria given above --- they identify memory lvalues,
11170      register lvalues, computed values, etcetera.  So we can evaluate
11171      the expression, and then scan the chain of values that leaves
11172      behind to decide whether we can detect any possible change to the
11173      expression's final value using only hardware watchpoints.
11174
11175      However, I don't think that the values returned by inferior
11176      function calls are special in any way.  So this function may not
11177      notice that an expression involving an inferior function call
11178      can't be watched with hardware watchpoints.  FIXME.  */
11179   for (; v; v = value_next (v))
11180     {
11181       if (VALUE_LVAL (v) == lval_memory)
11182         {
11183           if (v != head && value_lazy (v))
11184             /* A lazy memory lvalue in the chain is one that GDB never
11185                needed to fetch; we either just used its address (e.g.,
11186                `a' in `a.b') or we never needed it at all (e.g., `a'
11187                in `a,b').  This doesn't apply to HEAD; if that is
11188                lazy then it was not readable, but watch it anyway.  */
11189             ;
11190           else
11191             {
11192               /* Ahh, memory we actually used!  Check if we can cover
11193                  it with hardware watchpoints.  */
11194               struct type *vtype = check_typedef (value_type (v));
11195
11196               /* We only watch structs and arrays if user asked for it
11197                  explicitly, never if they just happen to appear in a
11198                  middle of some value chain.  */
11199               if (v == head
11200                   || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
11201                       && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
11202                 {
11203                   CORE_ADDR vaddr = value_address (v);
11204                   int len;
11205                   int num_regs;
11206
11207                   len = (target_exact_watchpoints
11208                          && is_scalar_type_recursive (vtype))?
11209                     1 : TYPE_LENGTH (value_type (v));
11210
11211                   num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
11212                   if (!num_regs)
11213                     return 0;
11214                   else
11215                     found_memory_cnt += num_regs;
11216                 }
11217             }
11218         }
11219       else if (VALUE_LVAL (v) != not_lval
11220                && deprecated_value_modifiable (v) == 0)
11221         return 0;       /* These are values from the history (e.g., $1).  */
11222       else if (VALUE_LVAL (v) == lval_register)
11223         return 0;       /* Cannot watch a register with a HW watchpoint.  */
11224     }
11225
11226   /* The expression itself looks suitable for using a hardware
11227      watchpoint, but give the target machine a chance to reject it.  */
11228   return found_memory_cnt;
11229 }
11230
11231 void
11232 watch_command_wrapper (char *arg, int from_tty, int internal)
11233 {
11234   watch_command_1 (arg, hw_write, from_tty, 0, internal);
11235 }
11236
11237 /* A helper function that looks for the "-location" argument and then
11238    calls watch_command_1.  */
11239
11240 static void
11241 watch_maybe_just_location (char *arg, int accessflag, int from_tty)
11242 {
11243   int just_location = 0;
11244
11245   if (arg
11246       && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
11247           || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
11248     {
11249       arg = skip_spaces (arg);
11250       just_location = 1;
11251     }
11252
11253   watch_command_1 (arg, accessflag, from_tty, just_location, 0);
11254 }
11255
11256 static void
11257 watch_command (char *arg, int from_tty)
11258 {
11259   watch_maybe_just_location (arg, hw_write, from_tty);
11260 }
11261
11262 void
11263 rwatch_command_wrapper (char *arg, int from_tty, int internal)
11264 {
11265   watch_command_1 (arg, hw_read, from_tty, 0, internal);
11266 }
11267
11268 static void
11269 rwatch_command (char *arg, int from_tty)
11270 {
11271   watch_maybe_just_location (arg, hw_read, from_tty);
11272 }
11273
11274 void
11275 awatch_command_wrapper (char *arg, int from_tty, int internal)
11276 {
11277   watch_command_1 (arg, hw_access, from_tty, 0, internal);
11278 }
11279
11280 static void
11281 awatch_command (char *arg, int from_tty)
11282 {
11283   watch_maybe_just_location (arg, hw_access, from_tty);
11284 }
11285 \f
11286
11287 /* Helper routines for the until_command routine in infcmd.c.  Here
11288    because it uses the mechanisms of breakpoints.  */
11289
11290 struct until_break_command_continuation_args
11291 {
11292   struct breakpoint *breakpoint;
11293   struct breakpoint *breakpoint2;
11294   int thread_num;
11295 };
11296
11297 /* This function is called by fetch_inferior_event via the
11298    cmd_continuation pointer, to complete the until command.  It takes
11299    care of cleaning up the temporary breakpoints set up by the until
11300    command.  */
11301 static void
11302 until_break_command_continuation (void *arg, int err)
11303 {
11304   struct until_break_command_continuation_args *a = arg;
11305
11306   delete_breakpoint (a->breakpoint);
11307   if (a->breakpoint2)
11308     delete_breakpoint (a->breakpoint2);
11309   delete_longjmp_breakpoint (a->thread_num);
11310 }
11311
11312 void
11313 until_break_command (char *arg, int from_tty, int anywhere)
11314 {
11315   struct symtabs_and_lines sals;
11316   struct symtab_and_line sal;
11317   struct frame_info *frame;
11318   struct gdbarch *frame_gdbarch;
11319   struct frame_id stack_frame_id;
11320   struct frame_id caller_frame_id;
11321   struct breakpoint *breakpoint;
11322   struct breakpoint *breakpoint2 = NULL;
11323   struct cleanup *old_chain;
11324   int thread;
11325   struct thread_info *tp;
11326
11327   clear_proceed_status ();
11328
11329   /* Set a breakpoint where the user wants it and at return from
11330      this function.  */
11331
11332   if (last_displayed_sal_is_valid ())
11333     sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
11334                           get_last_displayed_symtab (),
11335                           get_last_displayed_line ());
11336   else
11337     sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
11338                           (struct symtab *) NULL, 0);
11339
11340   if (sals.nelts != 1)
11341     error (_("Couldn't get information on specified line."));
11342
11343   sal = sals.sals[0];
11344   xfree (sals.sals);    /* malloc'd, so freed.  */
11345
11346   if (*arg)
11347     error (_("Junk at end of arguments."));
11348
11349   resolve_sal_pc (&sal);
11350
11351   tp = inferior_thread ();
11352   thread = tp->num;
11353
11354   old_chain = make_cleanup (null_cleanup, NULL);
11355
11356   /* Note linespec handling above invalidates the frame chain.
11357      Installing a breakpoint also invalidates the frame chain (as it
11358      may need to switch threads), so do any frame handling before
11359      that.  */
11360
11361   frame = get_selected_frame (NULL);
11362   frame_gdbarch = get_frame_arch (frame);
11363   stack_frame_id = get_stack_frame_id (frame);
11364   caller_frame_id = frame_unwind_caller_id (frame);
11365
11366   /* Keep within the current frame, or in frames called by the current
11367      one.  */
11368
11369   if (frame_id_p (caller_frame_id))
11370     {
11371       struct symtab_and_line sal2;
11372
11373       sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11374       sal2.pc = frame_unwind_caller_pc (frame);
11375       breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
11376                                               sal2,
11377                                               caller_frame_id,
11378                                               bp_until);
11379       make_cleanup_delete_breakpoint (breakpoint2);
11380
11381       set_longjmp_breakpoint (tp, caller_frame_id);
11382       make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
11383     }
11384
11385   /* set_momentary_breakpoint could invalidate FRAME.  */
11386   frame = NULL;
11387
11388   if (anywhere)
11389     /* If the user told us to continue until a specified location,
11390        we don't specify a frame at which we need to stop.  */
11391     breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11392                                            null_frame_id, bp_until);
11393   else
11394     /* Otherwise, specify the selected frame, because we want to stop
11395        only at the very same frame.  */
11396     breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11397                                            stack_frame_id, bp_until);
11398   make_cleanup_delete_breakpoint (breakpoint);
11399
11400   proceed (-1, GDB_SIGNAL_DEFAULT, 0);
11401
11402   /* If we are running asynchronously, and proceed call above has
11403      actually managed to start the target, arrange for breakpoints to
11404      be deleted when the target stops.  Otherwise, we're already
11405      stopped and delete breakpoints via cleanup chain.  */
11406
11407   if (target_can_async_p () && is_running (inferior_ptid))
11408     {
11409       struct until_break_command_continuation_args *args;
11410       args = xmalloc (sizeof (*args));
11411
11412       args->breakpoint = breakpoint;
11413       args->breakpoint2 = breakpoint2;
11414       args->thread_num = thread;
11415
11416       discard_cleanups (old_chain);
11417       add_continuation (inferior_thread (),
11418                         until_break_command_continuation, args,
11419                         xfree);
11420     }
11421   else
11422     do_cleanups (old_chain);
11423 }
11424
11425 /* This function attempts to parse an optional "if <cond>" clause
11426    from the arg string.  If one is not found, it returns NULL.
11427
11428    Else, it returns a pointer to the condition string.  (It does not
11429    attempt to evaluate the string against a particular block.)  And,
11430    it updates arg to point to the first character following the parsed
11431    if clause in the arg string.  */
11432
11433 static char *
11434 ep_parse_optional_if_clause (char **arg)
11435 {
11436   char *cond_string;
11437
11438   if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
11439     return NULL;
11440
11441   /* Skip the "if" keyword.  */
11442   (*arg) += 2;
11443
11444   /* Skip any extra leading whitespace, and record the start of the
11445      condition string.  */
11446   *arg = skip_spaces (*arg);
11447   cond_string = *arg;
11448
11449   /* Assume that the condition occupies the remainder of the arg
11450      string.  */
11451   (*arg) += strlen (cond_string);
11452
11453   return cond_string;
11454 }
11455
11456 /* Commands to deal with catching events, such as signals, exceptions,
11457    process start/exit, etc.  */
11458
11459 typedef enum
11460 {
11461   catch_fork_temporary, catch_vfork_temporary,
11462   catch_fork_permanent, catch_vfork_permanent
11463 }
11464 catch_fork_kind;
11465
11466 static void
11467 catch_fork_command_1 (char *arg, int from_tty, 
11468                       struct cmd_list_element *command)
11469 {
11470   struct gdbarch *gdbarch = get_current_arch ();
11471   char *cond_string = NULL;
11472   catch_fork_kind fork_kind;
11473   int tempflag;
11474
11475   fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11476   tempflag = (fork_kind == catch_fork_temporary
11477               || fork_kind == catch_vfork_temporary);
11478
11479   if (!arg)
11480     arg = "";
11481   arg = skip_spaces (arg);
11482
11483   /* The allowed syntax is:
11484      catch [v]fork
11485      catch [v]fork if <cond>
11486
11487      First, check if there's an if clause.  */
11488   cond_string = ep_parse_optional_if_clause (&arg);
11489
11490   if ((*arg != '\0') && !isspace (*arg))
11491     error (_("Junk at end of arguments."));
11492
11493   /* If this target supports it, create a fork or vfork catchpoint
11494      and enable reporting of such events.  */
11495   switch (fork_kind)
11496     {
11497     case catch_fork_temporary:
11498     case catch_fork_permanent:
11499       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11500                                           &catch_fork_breakpoint_ops);
11501       break;
11502     case catch_vfork_temporary:
11503     case catch_vfork_permanent:
11504       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11505                                           &catch_vfork_breakpoint_ops);
11506       break;
11507     default:
11508       error (_("unsupported or unknown fork kind; cannot catch it"));
11509       break;
11510     }
11511 }
11512
11513 static void
11514 catch_exec_command_1 (char *arg, int from_tty, 
11515                       struct cmd_list_element *command)
11516 {
11517   struct exec_catchpoint *c;
11518   struct gdbarch *gdbarch = get_current_arch ();
11519   int tempflag;
11520   char *cond_string = NULL;
11521
11522   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11523
11524   if (!arg)
11525     arg = "";
11526   arg = skip_spaces (arg);
11527
11528   /* The allowed syntax is:
11529      catch exec
11530      catch exec if <cond>
11531
11532      First, check if there's an if clause.  */
11533   cond_string = ep_parse_optional_if_clause (&arg);
11534
11535   if ((*arg != '\0') && !isspace (*arg))
11536     error (_("Junk at end of arguments."));
11537
11538   c = XNEW (struct exec_catchpoint);
11539   init_catchpoint (&c->base, gdbarch, tempflag, cond_string,
11540                    &catch_exec_breakpoint_ops);
11541   c->exec_pathname = NULL;
11542
11543   install_breakpoint (0, &c->base, 1);
11544 }
11545
11546 static enum print_stop_action
11547 print_it_exception_catchpoint (bpstat bs)
11548 {
11549   struct ui_out *uiout = current_uiout;
11550   struct breakpoint *b = bs->breakpoint_at;
11551   int bp_temp, bp_throw;
11552
11553   annotate_catchpoint (b->number);
11554
11555   bp_throw = strstr (b->addr_string, "throw") != NULL;
11556   if (b->loc->address != b->loc->requested_address)
11557     breakpoint_adjustment_warning (b->loc->requested_address,
11558                                    b->loc->address,
11559                                    b->number, 1);
11560   bp_temp = b->disposition == disp_del;
11561   ui_out_text (uiout, 
11562                bp_temp ? "Temporary catchpoint "
11563                        : "Catchpoint ");
11564   if (!ui_out_is_mi_like_p (uiout))
11565     ui_out_field_int (uiout, "bkptno", b->number);
11566   ui_out_text (uiout,
11567                bp_throw ? " (exception thrown), "
11568                         : " (exception caught), ");
11569   if (ui_out_is_mi_like_p (uiout))
11570     {
11571       ui_out_field_string (uiout, "reason", 
11572                            async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
11573       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
11574       ui_out_field_int (uiout, "bkptno", b->number);
11575     }
11576   return PRINT_SRC_AND_LOC;
11577 }
11578
11579 static void
11580 print_one_exception_catchpoint (struct breakpoint *b, 
11581                                 struct bp_location **last_loc)
11582 {
11583   struct value_print_options opts;
11584   struct ui_out *uiout = current_uiout;
11585
11586   get_user_print_options (&opts);
11587   if (opts.addressprint)
11588     {
11589       annotate_field (4);
11590       if (b->loc == NULL || b->loc->shlib_disabled)
11591         ui_out_field_string (uiout, "addr", "<PENDING>");
11592       else
11593         ui_out_field_core_addr (uiout, "addr",
11594                                 b->loc->gdbarch, b->loc->address);
11595     }
11596   annotate_field (5);
11597   if (b->loc)
11598     *last_loc = b->loc;
11599   if (strstr (b->addr_string, "throw") != NULL)
11600     {
11601       ui_out_field_string (uiout, "what", "exception throw");
11602       if (ui_out_is_mi_like_p (uiout))
11603         ui_out_field_string (uiout, "catch-type", "throw");
11604     }
11605   else
11606     {
11607       ui_out_field_string (uiout, "what", "exception catch");
11608       if (ui_out_is_mi_like_p (uiout))
11609         ui_out_field_string (uiout, "catch-type", "catch");
11610     }
11611 }
11612
11613 static void
11614 print_mention_exception_catchpoint (struct breakpoint *b)
11615 {
11616   struct ui_out *uiout = current_uiout;
11617   int bp_temp;
11618   int bp_throw;
11619
11620   bp_temp = b->disposition == disp_del;
11621   bp_throw = strstr (b->addr_string, "throw") != NULL;
11622   ui_out_text (uiout, bp_temp ? _("Temporary catchpoint ")
11623                               : _("Catchpoint "));
11624   ui_out_field_int (uiout, "bkptno", b->number);
11625   ui_out_text (uiout, bp_throw ? _(" (throw)")
11626                                : _(" (catch)"));
11627 }
11628
11629 /* Implement the "print_recreate" breakpoint_ops method for throw and
11630    catch catchpoints.  */
11631
11632 static void
11633 print_recreate_exception_catchpoint (struct breakpoint *b, 
11634                                      struct ui_file *fp)
11635 {
11636   int bp_temp;
11637   int bp_throw;
11638
11639   bp_temp = b->disposition == disp_del;
11640   bp_throw = strstr (b->addr_string, "throw") != NULL;
11641   fprintf_unfiltered (fp, bp_temp ? "tcatch " : "catch ");
11642   fprintf_unfiltered (fp, bp_throw ? "throw" : "catch");
11643   print_recreate_thread (b, fp);
11644 }
11645
11646 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops;
11647
11648 static int
11649 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
11650                           enum exception_event_kind ex_event, int from_tty)
11651 {
11652   char *trigger_func_name;
11653  
11654   if (ex_event == EX_EVENT_CATCH)
11655     trigger_func_name = "__cxa_begin_catch";
11656   else
11657     trigger_func_name = "__cxa_throw";
11658
11659   create_breakpoint (get_current_arch (),
11660                      trigger_func_name, cond_string, -1, NULL,
11661                      0 /* condition and thread are valid.  */,
11662                      tempflag, bp_breakpoint,
11663                      0,
11664                      AUTO_BOOLEAN_TRUE /* pending */,
11665                      &gnu_v3_exception_catchpoint_ops, from_tty,
11666                      1 /* enabled */,
11667                      0 /* internal */,
11668                      0);
11669
11670   return 1;
11671 }
11672
11673 /* Deal with "catch catch" and "catch throw" commands.  */
11674
11675 static void
11676 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
11677                            int tempflag, int from_tty)
11678 {
11679   char *cond_string = NULL;
11680
11681   if (!arg)
11682     arg = "";
11683   arg = skip_spaces (arg);
11684
11685   cond_string = ep_parse_optional_if_clause (&arg);
11686
11687   if ((*arg != '\0') && !isspace (*arg))
11688     error (_("Junk at end of arguments."));
11689
11690   if (ex_event != EX_EVENT_THROW
11691       && ex_event != EX_EVENT_CATCH)
11692     error (_("Unsupported or unknown exception event; cannot catch it"));
11693
11694   if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
11695     return;
11696
11697   warning (_("Unsupported with this platform/compiler combination."));
11698 }
11699
11700 /* Implementation of "catch catch" command.  */
11701
11702 static void
11703 catch_catch_command (char *arg, int from_tty, struct cmd_list_element *command)
11704 {
11705   int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11706
11707   catch_exception_command_1 (EX_EVENT_CATCH, arg, tempflag, from_tty);
11708 }
11709
11710 /* Implementation of "catch throw" command.  */
11711
11712 static void
11713 catch_throw_command (char *arg, int from_tty, struct cmd_list_element *command)
11714 {
11715   int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11716
11717   catch_exception_command_1 (EX_EVENT_THROW, arg, tempflag, from_tty);
11718 }
11719
11720 void
11721 init_ada_exception_breakpoint (struct breakpoint *b,
11722                                struct gdbarch *gdbarch,
11723                                struct symtab_and_line sal,
11724                                char *addr_string,
11725                                const struct breakpoint_ops *ops,
11726                                int tempflag,
11727                                int from_tty)
11728 {
11729   if (from_tty)
11730     {
11731       struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11732       if (!loc_gdbarch)
11733         loc_gdbarch = gdbarch;
11734
11735       describe_other_breakpoints (loc_gdbarch,
11736                                   sal.pspace, sal.pc, sal.section, -1);
11737       /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11738          version for exception catchpoints, because two catchpoints
11739          used for different exception names will use the same address.
11740          In this case, a "breakpoint ... also set at..." warning is
11741          unproductive.  Besides, the warning phrasing is also a bit
11742          inappropriate, we should use the word catchpoint, and tell
11743          the user what type of catchpoint it is.  The above is good
11744          enough for now, though.  */
11745     }
11746
11747   init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
11748
11749   b->enable_state = bp_enabled;
11750   b->disposition = tempflag ? disp_del : disp_donttouch;
11751   b->addr_string = addr_string;
11752   b->language = language_ada;
11753 }
11754
11755 /* Splits the argument using space as delimiter.  Returns an xmalloc'd
11756    filter list, or NULL if no filtering is required.  */
11757 static VEC(int) *
11758 catch_syscall_split_args (char *arg)
11759 {
11760   VEC(int) *result = NULL;
11761   struct cleanup *cleanup = make_cleanup (VEC_cleanup (int), &result);
11762
11763   while (*arg != '\0')
11764     {
11765       int i, syscall_number;
11766       char *endptr;
11767       char cur_name[128];
11768       struct syscall s;
11769
11770       /* Skip whitespace.  */
11771       arg = skip_spaces (arg);
11772
11773       for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
11774         cur_name[i] = arg[i];
11775       cur_name[i] = '\0';
11776       arg += i;
11777
11778       /* Check if the user provided a syscall name or a number.  */
11779       syscall_number = (int) strtol (cur_name, &endptr, 0);
11780       if (*endptr == '\0')
11781         get_syscall_by_number (syscall_number, &s);
11782       else
11783         {
11784           /* We have a name.  Let's check if it's valid and convert it
11785              to a number.  */
11786           get_syscall_by_name (cur_name, &s);
11787
11788           if (s.number == UNKNOWN_SYSCALL)
11789             /* Here we have to issue an error instead of a warning,
11790                because GDB cannot do anything useful if there's no
11791                syscall number to be caught.  */
11792             error (_("Unknown syscall name '%s'."), cur_name);
11793         }
11794
11795       /* Ok, it's valid.  */
11796       VEC_safe_push (int, result, s.number);
11797     }
11798
11799   discard_cleanups (cleanup);
11800   return result;
11801 }
11802
11803 /* Implement the "catch syscall" command.  */
11804
11805 static void
11806 catch_syscall_command_1 (char *arg, int from_tty, 
11807                          struct cmd_list_element *command)
11808 {
11809   int tempflag;
11810   VEC(int) *filter;
11811   struct syscall s;
11812   struct gdbarch *gdbarch = get_current_arch ();
11813
11814   /* Checking if the feature if supported.  */
11815   if (gdbarch_get_syscall_number_p (gdbarch) == 0)
11816     error (_("The feature 'catch syscall' is not supported on \
11817 this architecture yet."));
11818
11819   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11820
11821   arg = skip_spaces (arg);
11822
11823   /* We need to do this first "dummy" translation in order
11824      to get the syscall XML file loaded or, most important,
11825      to display a warning to the user if there's no XML file
11826      for his/her architecture.  */
11827   get_syscall_by_number (0, &s);
11828
11829   /* The allowed syntax is:
11830      catch syscall
11831      catch syscall <name | number> [<name | number> ... <name | number>]
11832
11833      Let's check if there's a syscall name.  */
11834
11835   if (arg != NULL)
11836     filter = catch_syscall_split_args (arg);
11837   else
11838     filter = NULL;
11839
11840   create_syscall_event_catchpoint (tempflag, filter,
11841                                    &catch_syscall_breakpoint_ops);
11842 }
11843
11844 static void
11845 catch_command (char *arg, int from_tty)
11846 {
11847   error (_("Catch requires an event name."));
11848 }
11849 \f
11850
11851 static void
11852 tcatch_command (char *arg, int from_tty)
11853 {
11854   error (_("Catch requires an event name."));
11855 }
11856
11857 /* A qsort comparison function that sorts breakpoints in order.  */
11858
11859 static int
11860 compare_breakpoints (const void *a, const void *b)
11861 {
11862   const breakpoint_p *ba = a;
11863   uintptr_t ua = (uintptr_t) *ba;
11864   const breakpoint_p *bb = b;
11865   uintptr_t ub = (uintptr_t) *bb;
11866
11867   if ((*ba)->number < (*bb)->number)
11868     return -1;
11869   else if ((*ba)->number > (*bb)->number)
11870     return 1;
11871
11872   /* Now sort by address, in case we see, e..g, two breakpoints with
11873      the number 0.  */
11874   if (ua < ub)
11875     return -1;
11876   return ua > ub ? 1 : 0;
11877 }
11878
11879 /* Delete breakpoints by address or line.  */
11880
11881 static void
11882 clear_command (char *arg, int from_tty)
11883 {
11884   struct breakpoint *b, *prev;
11885   VEC(breakpoint_p) *found = 0;
11886   int ix;
11887   int default_match;
11888   struct symtabs_and_lines sals;
11889   struct symtab_and_line sal;
11890   int i;
11891   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
11892
11893   if (arg)
11894     {
11895       sals = decode_line_with_current_source (arg,
11896                                               (DECODE_LINE_FUNFIRSTLINE
11897                                                | DECODE_LINE_LIST_MODE));
11898       make_cleanup (xfree, sals.sals);
11899       default_match = 0;
11900     }
11901   else
11902     {
11903       sals.sals = (struct symtab_and_line *)
11904         xmalloc (sizeof (struct symtab_and_line));
11905       make_cleanup (xfree, sals.sals);
11906       init_sal (&sal);          /* Initialize to zeroes.  */
11907
11908       /* Set sal's line, symtab, pc, and pspace to the values
11909          corresponding to the last call to print_frame_info.  If the
11910          codepoint is not valid, this will set all the fields to 0.  */
11911       get_last_displayed_sal (&sal);
11912       if (sal.symtab == 0)
11913         error (_("No source file specified."));
11914
11915       sals.sals[0] = sal;
11916       sals.nelts = 1;
11917
11918       default_match = 1;
11919     }
11920
11921   /* We don't call resolve_sal_pc here.  That's not as bad as it
11922      seems, because all existing breakpoints typically have both
11923      file/line and pc set.  So, if clear is given file/line, we can
11924      match this to existing breakpoint without obtaining pc at all.
11925
11926      We only support clearing given the address explicitly 
11927      present in breakpoint table.  Say, we've set breakpoint 
11928      at file:line.  There were several PC values for that file:line,
11929      due to optimization, all in one block.
11930
11931      We've picked one PC value.  If "clear" is issued with another
11932      PC corresponding to the same file:line, the breakpoint won't
11933      be cleared.  We probably can still clear the breakpoint, but 
11934      since the other PC value is never presented to user, user
11935      can only find it by guessing, and it does not seem important
11936      to support that.  */
11937
11938   /* For each line spec given, delete bps which correspond to it.  Do
11939      it in two passes, solely to preserve the current behavior that
11940      from_tty is forced true if we delete more than one
11941      breakpoint.  */
11942
11943   found = NULL;
11944   make_cleanup (VEC_cleanup (breakpoint_p), &found);
11945   for (i = 0; i < sals.nelts; i++)
11946     {
11947       const char *sal_fullname;
11948
11949       /* If exact pc given, clear bpts at that pc.
11950          If line given (pc == 0), clear all bpts on specified line.
11951          If defaulting, clear all bpts on default line
11952          or at default pc.
11953
11954          defaulting    sal.pc != 0    tests to do
11955
11956          0              1             pc
11957          1              1             pc _and_ line
11958          0              0             line
11959          1              0             <can't happen> */
11960
11961       sal = sals.sals[i];
11962       sal_fullname = (sal.symtab == NULL
11963                       ? NULL : symtab_to_fullname (sal.symtab));
11964
11965       /* Find all matching breakpoints and add them to 'found'.  */
11966       ALL_BREAKPOINTS (b)
11967         {
11968           int match = 0;
11969           /* Are we going to delete b?  */
11970           if (b->type != bp_none && !is_watchpoint (b))
11971             {
11972               struct bp_location *loc = b->loc;
11973               for (; loc; loc = loc->next)
11974                 {
11975                   /* If the user specified file:line, don't allow a PC
11976                      match.  This matches historical gdb behavior.  */
11977                   int pc_match = (!sal.explicit_line
11978                                   && sal.pc
11979                                   && (loc->pspace == sal.pspace)
11980                                   && (loc->address == sal.pc)
11981                                   && (!section_is_overlay (loc->section)
11982                                       || loc->section == sal.section));
11983                   int line_match = 0;
11984
11985                   if ((default_match || sal.explicit_line)
11986                       && loc->symtab != NULL
11987                       && sal_fullname != NULL
11988                       && sal.pspace == loc->pspace
11989                       && loc->line_number == sal.line
11990                       && filename_cmp (symtab_to_fullname (loc->symtab),
11991                                        sal_fullname) == 0)
11992                     line_match = 1;
11993
11994                   if (pc_match || line_match)
11995                     {
11996                       match = 1;
11997                       break;
11998                     }
11999                 }
12000             }
12001
12002           if (match)
12003             VEC_safe_push(breakpoint_p, found, b);
12004         }
12005     }
12006
12007   /* Now go thru the 'found' chain and delete them.  */
12008   if (VEC_empty(breakpoint_p, found))
12009     {
12010       if (arg)
12011         error (_("No breakpoint at %s."), arg);
12012       else
12013         error (_("No breakpoint at this line."));
12014     }
12015
12016   /* Remove duplicates from the vec.  */
12017   qsort (VEC_address (breakpoint_p, found),
12018          VEC_length (breakpoint_p, found),
12019          sizeof (breakpoint_p),
12020          compare_breakpoints);
12021   prev = VEC_index (breakpoint_p, found, 0);
12022   for (ix = 1; VEC_iterate (breakpoint_p, found, ix, b); ++ix)
12023     {
12024       if (b == prev)
12025         {
12026           VEC_ordered_remove (breakpoint_p, found, ix);
12027           --ix;
12028         }
12029     }
12030
12031   if (VEC_length(breakpoint_p, found) > 1)
12032     from_tty = 1;       /* Always report if deleted more than one.  */
12033   if (from_tty)
12034     {
12035       if (VEC_length(breakpoint_p, found) == 1)
12036         printf_unfiltered (_("Deleted breakpoint "));
12037       else
12038         printf_unfiltered (_("Deleted breakpoints "));
12039     }
12040
12041   for (ix = 0; VEC_iterate(breakpoint_p, found, ix, b); ix++)
12042     {
12043       if (from_tty)
12044         printf_unfiltered ("%d ", b->number);
12045       delete_breakpoint (b);
12046     }
12047   if (from_tty)
12048     putchar_unfiltered ('\n');
12049
12050   do_cleanups (cleanups);
12051 }
12052 \f
12053 /* Delete breakpoint in BS if they are `delete' breakpoints and
12054    all breakpoints that are marked for deletion, whether hit or not.
12055    This is called after any breakpoint is hit, or after errors.  */
12056
12057 void
12058 breakpoint_auto_delete (bpstat bs)
12059 {
12060   struct breakpoint *b, *b_tmp;
12061
12062   for (; bs; bs = bs->next)
12063     if (bs->breakpoint_at
12064         && bs->breakpoint_at->disposition == disp_del
12065         && bs->stop)
12066       delete_breakpoint (bs->breakpoint_at);
12067
12068   ALL_BREAKPOINTS_SAFE (b, b_tmp)
12069   {
12070     if (b->disposition == disp_del_at_next_stop)
12071       delete_breakpoint (b);
12072   }
12073 }
12074
12075 /* A comparison function for bp_location AP and BP being interfaced to
12076    qsort.  Sort elements primarily by their ADDRESS (no matter what
12077    does breakpoint_address_is_meaningful say for its OWNER),
12078    secondarily by ordering first bp_permanent OWNERed elements and
12079    terciarily just ensuring the array is sorted stable way despite
12080    qsort being an unstable algorithm.  */
12081
12082 static int
12083 bp_location_compare (const void *ap, const void *bp)
12084 {
12085   struct bp_location *a = *(void **) ap;
12086   struct bp_location *b = *(void **) bp;
12087   /* A and B come from existing breakpoints having non-NULL OWNER.  */
12088   int a_perm = a->owner->enable_state == bp_permanent;
12089   int b_perm = b->owner->enable_state == bp_permanent;
12090
12091   if (a->address != b->address)
12092     return (a->address > b->address) - (a->address < b->address);
12093
12094   /* Sort locations at the same address by their pspace number, keeping
12095      locations of the same inferior (in a multi-inferior environment)
12096      grouped.  */
12097
12098   if (a->pspace->num != b->pspace->num)
12099     return ((a->pspace->num > b->pspace->num)
12100             - (a->pspace->num < b->pspace->num));
12101
12102   /* Sort permanent breakpoints first.  */
12103   if (a_perm != b_perm)
12104     return (a_perm < b_perm) - (a_perm > b_perm);
12105
12106   /* Make the internal GDB representation stable across GDB runs
12107      where A and B memory inside GDB can differ.  Breakpoint locations of
12108      the same type at the same address can be sorted in arbitrary order.  */
12109
12110   if (a->owner->number != b->owner->number)
12111     return ((a->owner->number > b->owner->number)
12112             - (a->owner->number < b->owner->number));
12113
12114   return (a > b) - (a < b);
12115 }
12116
12117 /* Set bp_location_placed_address_before_address_max and
12118    bp_location_shadow_len_after_address_max according to the current
12119    content of the bp_location array.  */
12120
12121 static void
12122 bp_location_target_extensions_update (void)
12123 {
12124   struct bp_location *bl, **blp_tmp;
12125
12126   bp_location_placed_address_before_address_max = 0;
12127   bp_location_shadow_len_after_address_max = 0;
12128
12129   ALL_BP_LOCATIONS (bl, blp_tmp)
12130     {
12131       CORE_ADDR start, end, addr;
12132
12133       if (!bp_location_has_shadow (bl))
12134         continue;
12135
12136       start = bl->target_info.placed_address;
12137       end = start + bl->target_info.shadow_len;
12138
12139       gdb_assert (bl->address >= start);
12140       addr = bl->address - start;
12141       if (addr > bp_location_placed_address_before_address_max)
12142         bp_location_placed_address_before_address_max = addr;
12143
12144       /* Zero SHADOW_LEN would not pass bp_location_has_shadow.  */
12145
12146       gdb_assert (bl->address < end);
12147       addr = end - bl->address;
12148       if (addr > bp_location_shadow_len_after_address_max)
12149         bp_location_shadow_len_after_address_max = addr;
12150     }
12151 }
12152
12153 /* Download tracepoint locations if they haven't been.  */
12154
12155 static void
12156 download_tracepoint_locations (void)
12157 {
12158   struct breakpoint *b;
12159   struct cleanup *old_chain;
12160
12161   if (!target_can_download_tracepoint ())
12162     return;
12163
12164   old_chain = save_current_space_and_thread ();
12165
12166   ALL_TRACEPOINTS (b)
12167     {
12168       struct bp_location *bl;
12169       struct tracepoint *t;
12170       int bp_location_downloaded = 0;
12171
12172       if ((b->type == bp_fast_tracepoint
12173            ? !may_insert_fast_tracepoints
12174            : !may_insert_tracepoints))
12175         continue;
12176
12177       for (bl = b->loc; bl; bl = bl->next)
12178         {
12179           /* In tracepoint, locations are _never_ duplicated, so
12180              should_be_inserted is equivalent to
12181              unduplicated_should_be_inserted.  */
12182           if (!should_be_inserted (bl) || bl->inserted)
12183             continue;
12184
12185           switch_to_program_space_and_thread (bl->pspace);
12186
12187           target_download_tracepoint (bl);
12188
12189           bl->inserted = 1;
12190           bp_location_downloaded = 1;
12191         }
12192       t = (struct tracepoint *) b;
12193       t->number_on_target = b->number;
12194       if (bp_location_downloaded)
12195         observer_notify_breakpoint_modified (b);
12196     }
12197
12198   do_cleanups (old_chain);
12199 }
12200
12201 /* Swap the insertion/duplication state between two locations.  */
12202
12203 static void
12204 swap_insertion (struct bp_location *left, struct bp_location *right)
12205 {
12206   const int left_inserted = left->inserted;
12207   const int left_duplicate = left->duplicate;
12208   const int left_needs_update = left->needs_update;
12209   const struct bp_target_info left_target_info = left->target_info;
12210
12211   /* Locations of tracepoints can never be duplicated.  */
12212   if (is_tracepoint (left->owner))
12213     gdb_assert (!left->duplicate);
12214   if (is_tracepoint (right->owner))
12215     gdb_assert (!right->duplicate);
12216
12217   left->inserted = right->inserted;
12218   left->duplicate = right->duplicate;
12219   left->needs_update = right->needs_update;
12220   left->target_info = right->target_info;
12221   right->inserted = left_inserted;
12222   right->duplicate = left_duplicate;
12223   right->needs_update = left_needs_update;
12224   right->target_info = left_target_info;
12225 }
12226
12227 /* Force the re-insertion of the locations at ADDRESS.  This is called
12228    once a new/deleted/modified duplicate location is found and we are evaluating
12229    conditions on the target's side.  Such conditions need to be updated on
12230    the target.  */
12231
12232 static void
12233 force_breakpoint_reinsertion (struct bp_location *bl)
12234 {
12235   struct bp_location **locp = NULL, **loc2p;
12236   struct bp_location *loc;
12237   CORE_ADDR address = 0;
12238   int pspace_num;
12239
12240   address = bl->address;
12241   pspace_num = bl->pspace->num;
12242
12243   /* This is only meaningful if the target is
12244      evaluating conditions and if the user has
12245      opted for condition evaluation on the target's
12246      side.  */
12247   if (gdb_evaluates_breakpoint_condition_p ()
12248       || !target_supports_evaluation_of_breakpoint_conditions ())
12249     return;
12250
12251   /* Flag all breakpoint locations with this address and
12252      the same program space as the location
12253      as "its condition has changed".  We need to
12254      update the conditions on the target's side.  */
12255   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
12256     {
12257       loc = *loc2p;
12258
12259       if (!is_breakpoint (loc->owner)
12260           || pspace_num != loc->pspace->num)
12261         continue;
12262
12263       /* Flag the location appropriately.  We use a different state to
12264          let everyone know that we already updated the set of locations
12265          with addr bl->address and program space bl->pspace.  This is so
12266          we don't have to keep calling these functions just to mark locations
12267          that have already been marked.  */
12268       loc->condition_changed = condition_updated;
12269
12270       /* Free the agent expression bytecode as well.  We will compute
12271          it later on.  */
12272       if (loc->cond_bytecode)
12273         {
12274           free_agent_expr (loc->cond_bytecode);
12275           loc->cond_bytecode = NULL;
12276         }
12277     }
12278 }
12279
12280 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
12281    into the inferior, only remove already-inserted locations that no
12282    longer should be inserted.  Functions that delete a breakpoint or
12283    breakpoints should pass false, so that deleting a breakpoint
12284    doesn't have the side effect of inserting the locations of other
12285    breakpoints that are marked not-inserted, but should_be_inserted
12286    returns true on them.
12287
12288    This behaviour is useful is situations close to tear-down -- e.g.,
12289    after an exec, while the target still has execution, but breakpoint
12290    shadows of the previous executable image should *NOT* be restored
12291    to the new image; or before detaching, where the target still has
12292    execution and wants to delete breakpoints from GDB's lists, and all
12293    breakpoints had already been removed from the inferior.  */
12294
12295 static void
12296 update_global_location_list (int should_insert)
12297 {
12298   struct breakpoint *b;
12299   struct bp_location **locp, *loc;
12300   struct cleanup *cleanups;
12301   /* Last breakpoint location address that was marked for update.  */
12302   CORE_ADDR last_addr = 0;
12303   /* Last breakpoint location program space that was marked for update.  */
12304   int last_pspace_num = -1;
12305
12306   /* Used in the duplicates detection below.  When iterating over all
12307      bp_locations, points to the first bp_location of a given address.
12308      Breakpoints and watchpoints of different types are never
12309      duplicates of each other.  Keep one pointer for each type of
12310      breakpoint/watchpoint, so we only need to loop over all locations
12311      once.  */
12312   struct bp_location *bp_loc_first;  /* breakpoint */
12313   struct bp_location *wp_loc_first;  /* hardware watchpoint */
12314   struct bp_location *awp_loc_first; /* access watchpoint */
12315   struct bp_location *rwp_loc_first; /* read watchpoint */
12316
12317   /* Saved former bp_location array which we compare against the newly
12318      built bp_location from the current state of ALL_BREAKPOINTS.  */
12319   struct bp_location **old_location, **old_locp;
12320   unsigned old_location_count;
12321
12322   old_location = bp_location;
12323   old_location_count = bp_location_count;
12324   bp_location = NULL;
12325   bp_location_count = 0;
12326   cleanups = make_cleanup (xfree, old_location);
12327
12328   ALL_BREAKPOINTS (b)
12329     for (loc = b->loc; loc; loc = loc->next)
12330       bp_location_count++;
12331
12332   bp_location = xmalloc (sizeof (*bp_location) * bp_location_count);
12333   locp = bp_location;
12334   ALL_BREAKPOINTS (b)
12335     for (loc = b->loc; loc; loc = loc->next)
12336       *locp++ = loc;
12337   qsort (bp_location, bp_location_count, sizeof (*bp_location),
12338          bp_location_compare);
12339
12340   bp_location_target_extensions_update ();
12341
12342   /* Identify bp_location instances that are no longer present in the
12343      new list, and therefore should be freed.  Note that it's not
12344      necessary that those locations should be removed from inferior --
12345      if there's another location at the same address (previously
12346      marked as duplicate), we don't need to remove/insert the
12347      location.
12348      
12349      LOCP is kept in sync with OLD_LOCP, each pointing to the current
12350      and former bp_location array state respectively.  */
12351
12352   locp = bp_location;
12353   for (old_locp = old_location; old_locp < old_location + old_location_count;
12354        old_locp++)
12355     {
12356       struct bp_location *old_loc = *old_locp;
12357       struct bp_location **loc2p;
12358
12359       /* Tells if 'old_loc' is found among the new locations.  If
12360          not, we have to free it.  */
12361       int found_object = 0;
12362       /* Tells if the location should remain inserted in the target.  */
12363       int keep_in_target = 0;
12364       int removed = 0;
12365
12366       /* Skip LOCP entries which will definitely never be needed.
12367          Stop either at or being the one matching OLD_LOC.  */
12368       while (locp < bp_location + bp_location_count
12369              && (*locp)->address < old_loc->address)
12370         locp++;
12371
12372       for (loc2p = locp;
12373            (loc2p < bp_location + bp_location_count
12374             && (*loc2p)->address == old_loc->address);
12375            loc2p++)
12376         {
12377           /* Check if this is a new/duplicated location or a duplicated
12378              location that had its condition modified.  If so, we want to send
12379              its condition to the target if evaluation of conditions is taking
12380              place there.  */
12381           if ((*loc2p)->condition_changed == condition_modified
12382               && (last_addr != old_loc->address
12383                   || last_pspace_num != old_loc->pspace->num))
12384             {
12385               force_breakpoint_reinsertion (*loc2p);
12386               last_pspace_num = old_loc->pspace->num;
12387             }
12388
12389           if (*loc2p == old_loc)
12390             found_object = 1;
12391         }
12392
12393       /* We have already handled this address, update it so that we don't
12394          have to go through updates again.  */
12395       last_addr = old_loc->address;
12396
12397       /* Target-side condition evaluation: Handle deleted locations.  */
12398       if (!found_object)
12399         force_breakpoint_reinsertion (old_loc);
12400
12401       /* If this location is no longer present, and inserted, look if
12402          there's maybe a new location at the same address.  If so,
12403          mark that one inserted, and don't remove this one.  This is
12404          needed so that we don't have a time window where a breakpoint
12405          at certain location is not inserted.  */
12406
12407       if (old_loc->inserted)
12408         {
12409           /* If the location is inserted now, we might have to remove
12410              it.  */
12411
12412           if (found_object && should_be_inserted (old_loc))
12413             {
12414               /* The location is still present in the location list,
12415                  and still should be inserted.  Don't do anything.  */
12416               keep_in_target = 1;
12417             }
12418           else
12419             {
12420               /* This location still exists, but it won't be kept in the
12421                  target since it may have been disabled.  We proceed to
12422                  remove its target-side condition.  */
12423
12424               /* The location is either no longer present, or got
12425                  disabled.  See if there's another location at the
12426                  same address, in which case we don't need to remove
12427                  this one from the target.  */
12428
12429               /* OLD_LOC comes from existing struct breakpoint.  */
12430               if (breakpoint_address_is_meaningful (old_loc->owner))
12431                 {
12432                   for (loc2p = locp;
12433                        (loc2p < bp_location + bp_location_count
12434                         && (*loc2p)->address == old_loc->address);
12435                        loc2p++)
12436                     {
12437                       struct bp_location *loc2 = *loc2p;
12438
12439                       if (breakpoint_locations_match (loc2, old_loc))
12440                         {
12441                           /* Read watchpoint locations are switched to
12442                              access watchpoints, if the former are not
12443                              supported, but the latter are.  */
12444                           if (is_hardware_watchpoint (old_loc->owner))
12445                             {
12446                               gdb_assert (is_hardware_watchpoint (loc2->owner));
12447                               loc2->watchpoint_type = old_loc->watchpoint_type;
12448                             }
12449
12450                           /* loc2 is a duplicated location. We need to check
12451                              if it should be inserted in case it will be
12452                              unduplicated.  */
12453                           if (loc2 != old_loc
12454                               && unduplicated_should_be_inserted (loc2))
12455                             {
12456                               swap_insertion (old_loc, loc2);
12457                               keep_in_target = 1;
12458                               break;
12459                             }
12460                         }
12461                     }
12462                 }
12463             }
12464
12465           if (!keep_in_target)
12466             {
12467               if (remove_breakpoint (old_loc, mark_uninserted))
12468                 {
12469                   /* This is just about all we can do.  We could keep
12470                      this location on the global list, and try to
12471                      remove it next time, but there's no particular
12472                      reason why we will succeed next time.
12473                      
12474                      Note that at this point, old_loc->owner is still
12475                      valid, as delete_breakpoint frees the breakpoint
12476                      only after calling us.  */
12477                   printf_filtered (_("warning: Error removing "
12478                                      "breakpoint %d\n"), 
12479                                    old_loc->owner->number);
12480                 }
12481               removed = 1;
12482             }
12483         }
12484
12485       if (!found_object)
12486         {
12487           if (removed && non_stop
12488               && breakpoint_address_is_meaningful (old_loc->owner)
12489               && !is_hardware_watchpoint (old_loc->owner))
12490             {
12491               /* This location was removed from the target.  In
12492                  non-stop mode, a race condition is possible where
12493                  we've removed a breakpoint, but stop events for that
12494                  breakpoint are already queued and will arrive later.
12495                  We apply an heuristic to be able to distinguish such
12496                  SIGTRAPs from other random SIGTRAPs: we keep this
12497                  breakpoint location for a bit, and will retire it
12498                  after we see some number of events.  The theory here
12499                  is that reporting of events should, "on the average",
12500                  be fair, so after a while we'll see events from all
12501                  threads that have anything of interest, and no longer
12502                  need to keep this breakpoint location around.  We
12503                  don't hold locations forever so to reduce chances of
12504                  mistaking a non-breakpoint SIGTRAP for a breakpoint
12505                  SIGTRAP.
12506
12507                  The heuristic failing can be disastrous on
12508                  decr_pc_after_break targets.
12509
12510                  On decr_pc_after_break targets, like e.g., x86-linux,
12511                  if we fail to recognize a late breakpoint SIGTRAP,
12512                  because events_till_retirement has reached 0 too
12513                  soon, we'll fail to do the PC adjustment, and report
12514                  a random SIGTRAP to the user.  When the user resumes
12515                  the inferior, it will most likely immediately crash
12516                  with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12517                  corrupted, because of being resumed e.g., in the
12518                  middle of a multi-byte instruction, or skipped a
12519                  one-byte instruction.  This was actually seen happen
12520                  on native x86-linux, and should be less rare on
12521                  targets that do not support new thread events, like
12522                  remote, due to the heuristic depending on
12523                  thread_count.
12524
12525                  Mistaking a random SIGTRAP for a breakpoint trap
12526                  causes similar symptoms (PC adjustment applied when
12527                  it shouldn't), but then again, playing with SIGTRAPs
12528                  behind the debugger's back is asking for trouble.
12529
12530                  Since hardware watchpoint traps are always
12531                  distinguishable from other traps, so we don't need to
12532                  apply keep hardware watchpoint moribund locations
12533                  around.  We simply always ignore hardware watchpoint
12534                  traps we can no longer explain.  */
12535
12536               old_loc->events_till_retirement = 3 * (thread_count () + 1);
12537               old_loc->owner = NULL;
12538
12539               VEC_safe_push (bp_location_p, moribund_locations, old_loc);
12540             }
12541           else
12542             {
12543               old_loc->owner = NULL;
12544               decref_bp_location (&old_loc);
12545             }
12546         }
12547     }
12548
12549   /* Rescan breakpoints at the same address and section, marking the
12550      first one as "first" and any others as "duplicates".  This is so
12551      that the bpt instruction is only inserted once.  If we have a
12552      permanent breakpoint at the same place as BPT, make that one the
12553      official one, and the rest as duplicates.  Permanent breakpoints
12554      are sorted first for the same address.
12555
12556      Do the same for hardware watchpoints, but also considering the
12557      watchpoint's type (regular/access/read) and length.  */
12558
12559   bp_loc_first = NULL;
12560   wp_loc_first = NULL;
12561   awp_loc_first = NULL;
12562   rwp_loc_first = NULL;
12563   ALL_BP_LOCATIONS (loc, locp)
12564     {
12565       /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12566          non-NULL.  */
12567       struct bp_location **loc_first_p;
12568       b = loc->owner;
12569
12570       if (!unduplicated_should_be_inserted (loc)
12571           || !breakpoint_address_is_meaningful (b)
12572           /* Don't detect duplicate for tracepoint locations because they are
12573            never duplicated.  See the comments in field `duplicate' of
12574            `struct bp_location'.  */
12575           || is_tracepoint (b))
12576         {
12577           /* Clear the condition modification flag.  */
12578           loc->condition_changed = condition_unchanged;
12579           continue;
12580         }
12581
12582       /* Permanent breakpoint should always be inserted.  */
12583       if (b->enable_state == bp_permanent && ! loc->inserted)
12584         internal_error (__FILE__, __LINE__,
12585                         _("allegedly permanent breakpoint is not "
12586                         "actually inserted"));
12587
12588       if (b->type == bp_hardware_watchpoint)
12589         loc_first_p = &wp_loc_first;
12590       else if (b->type == bp_read_watchpoint)
12591         loc_first_p = &rwp_loc_first;
12592       else if (b->type == bp_access_watchpoint)
12593         loc_first_p = &awp_loc_first;
12594       else
12595         loc_first_p = &bp_loc_first;
12596
12597       if (*loc_first_p == NULL
12598           || (overlay_debugging && loc->section != (*loc_first_p)->section)
12599           || !breakpoint_locations_match (loc, *loc_first_p))
12600         {
12601           *loc_first_p = loc;
12602           loc->duplicate = 0;
12603
12604           if (is_breakpoint (loc->owner) && loc->condition_changed)
12605             {
12606               loc->needs_update = 1;
12607               /* Clear the condition modification flag.  */
12608               loc->condition_changed = condition_unchanged;
12609             }
12610           continue;
12611         }
12612
12613
12614       /* This and the above ensure the invariant that the first location
12615          is not duplicated, and is the inserted one.
12616          All following are marked as duplicated, and are not inserted.  */
12617       if (loc->inserted)
12618         swap_insertion (loc, *loc_first_p);
12619       loc->duplicate = 1;
12620
12621       /* Clear the condition modification flag.  */
12622       loc->condition_changed = condition_unchanged;
12623
12624       if ((*loc_first_p)->owner->enable_state == bp_permanent && loc->inserted
12625           && b->enable_state != bp_permanent)
12626         internal_error (__FILE__, __LINE__,
12627                         _("another breakpoint was inserted on top of "
12628                         "a permanent breakpoint"));
12629     }
12630
12631   if (breakpoints_always_inserted_mode ()
12632       && (have_live_inferiors ()
12633           || (gdbarch_has_global_breakpoints (target_gdbarch ()))))
12634     {
12635       if (should_insert)
12636         insert_breakpoint_locations ();
12637       else
12638         {
12639           /* Though should_insert is false, we may need to update conditions
12640              on the target's side if it is evaluating such conditions.  We
12641              only update conditions for locations that are marked
12642              "needs_update".  */
12643           update_inserted_breakpoint_locations ();
12644         }
12645     }
12646
12647   if (should_insert)
12648     download_tracepoint_locations ();
12649
12650   do_cleanups (cleanups);
12651 }
12652
12653 void
12654 breakpoint_retire_moribund (void)
12655 {
12656   struct bp_location *loc;
12657   int ix;
12658
12659   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
12660     if (--(loc->events_till_retirement) == 0)
12661       {
12662         decref_bp_location (&loc);
12663         VEC_unordered_remove (bp_location_p, moribund_locations, ix);
12664         --ix;
12665       }
12666 }
12667
12668 static void
12669 update_global_location_list_nothrow (int inserting)
12670 {
12671   volatile struct gdb_exception e;
12672
12673   TRY_CATCH (e, RETURN_MASK_ERROR)
12674     update_global_location_list (inserting);
12675 }
12676
12677 /* Clear BKP from a BPS.  */
12678
12679 static void
12680 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12681 {
12682   bpstat bs;
12683
12684   for (bs = bps; bs; bs = bs->next)
12685     if (bs->breakpoint_at == bpt)
12686       {
12687         bs->breakpoint_at = NULL;
12688         bs->old_val = NULL;
12689         /* bs->commands will be freed later.  */
12690       }
12691 }
12692
12693 /* Callback for iterate_over_threads.  */
12694 static int
12695 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12696 {
12697   struct breakpoint *bpt = data;
12698
12699   bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12700   return 0;
12701 }
12702
12703 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12704    callbacks.  */
12705
12706 static void
12707 say_where (struct breakpoint *b)
12708 {
12709   struct ui_out *uiout = current_uiout;
12710   struct value_print_options opts;
12711
12712   get_user_print_options (&opts);
12713
12714   /* i18n: cagney/2005-02-11: Below needs to be merged into a
12715      single string.  */
12716   if (b->loc == NULL)
12717     {
12718       printf_filtered (_(" (%s) pending."), b->addr_string);
12719     }
12720   else
12721     {
12722       if (opts.addressprint || b->loc->symtab == NULL)
12723         {
12724           printf_filtered (" at ");
12725           fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
12726                           gdb_stdout);
12727         }
12728       if (b->loc->symtab != NULL)
12729         {
12730           /* If there is a single location, we can print the location
12731              more nicely.  */
12732           if (b->loc->next == NULL)
12733             printf_filtered (": file %s, line %d.",
12734                              symtab_to_filename_for_display (b->loc->symtab),
12735                              b->loc->line_number);
12736           else
12737             /* This is not ideal, but each location may have a
12738                different file name, and this at least reflects the
12739                real situation somewhat.  */
12740             printf_filtered (": %s.", b->addr_string);
12741         }
12742
12743       if (b->loc->next)
12744         {
12745           struct bp_location *loc = b->loc;
12746           int n = 0;
12747           for (; loc; loc = loc->next)
12748             ++n;
12749           printf_filtered (" (%d locations)", n);
12750         }
12751     }
12752 }
12753
12754 /* Default bp_location_ops methods.  */
12755
12756 static void
12757 bp_location_dtor (struct bp_location *self)
12758 {
12759   xfree (self->cond);
12760   if (self->cond_bytecode)
12761     free_agent_expr (self->cond_bytecode);
12762   xfree (self->function_name);
12763 }
12764
12765 static const struct bp_location_ops bp_location_ops =
12766 {
12767   bp_location_dtor
12768 };
12769
12770 /* Default breakpoint_ops methods all breakpoint_ops ultimately
12771    inherit from.  */
12772
12773 static void
12774 base_breakpoint_dtor (struct breakpoint *self)
12775 {
12776   decref_counted_command_line (&self->commands);
12777   xfree (self->cond_string);
12778   xfree (self->addr_string);
12779   xfree (self->filter);
12780   xfree (self->addr_string_range_end);
12781 }
12782
12783 static struct bp_location *
12784 base_breakpoint_allocate_location (struct breakpoint *self)
12785 {
12786   struct bp_location *loc;
12787
12788   loc = XNEW (struct bp_location);
12789   init_bp_location (loc, &bp_location_ops, self);
12790   return loc;
12791 }
12792
12793 static void
12794 base_breakpoint_re_set (struct breakpoint *b)
12795 {
12796   /* Nothing to re-set. */
12797 }
12798
12799 #define internal_error_pure_virtual_called() \
12800   gdb_assert_not_reached ("pure virtual function called")
12801
12802 static int
12803 base_breakpoint_insert_location (struct bp_location *bl)
12804 {
12805   internal_error_pure_virtual_called ();
12806 }
12807
12808 static int
12809 base_breakpoint_remove_location (struct bp_location *bl)
12810 {
12811   internal_error_pure_virtual_called ();
12812 }
12813
12814 static int
12815 base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12816                                 struct address_space *aspace,
12817                                 CORE_ADDR bp_addr,
12818                                 const struct target_waitstatus *ws)
12819 {
12820   internal_error_pure_virtual_called ();
12821 }
12822
12823 static void
12824 base_breakpoint_check_status (bpstat bs)
12825 {
12826   /* Always stop.   */
12827 }
12828
12829 /* A "works_in_software_mode" breakpoint_ops method that just internal
12830    errors.  */
12831
12832 static int
12833 base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12834 {
12835   internal_error_pure_virtual_called ();
12836 }
12837
12838 /* A "resources_needed" breakpoint_ops method that just internal
12839    errors.  */
12840
12841 static int
12842 base_breakpoint_resources_needed (const struct bp_location *bl)
12843 {
12844   internal_error_pure_virtual_called ();
12845 }
12846
12847 static enum print_stop_action
12848 base_breakpoint_print_it (bpstat bs)
12849 {
12850   internal_error_pure_virtual_called ();
12851 }
12852
12853 static void
12854 base_breakpoint_print_one_detail (const struct breakpoint *self,
12855                                   struct ui_out *uiout)
12856 {
12857   /* nothing */
12858 }
12859
12860 static void
12861 base_breakpoint_print_mention (struct breakpoint *b)
12862 {
12863   internal_error_pure_virtual_called ();
12864 }
12865
12866 static void
12867 base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12868 {
12869   internal_error_pure_virtual_called ();
12870 }
12871
12872 static void
12873 base_breakpoint_create_sals_from_address (char **arg,
12874                                           struct linespec_result *canonical,
12875                                           enum bptype type_wanted,
12876                                           char *addr_start,
12877                                           char **copy_arg)
12878 {
12879   internal_error_pure_virtual_called ();
12880 }
12881
12882 static void
12883 base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12884                                         struct linespec_result *c,
12885                                         struct linespec_sals *lsal,
12886                                         char *cond_string,
12887                                         char *extra_string,
12888                                         enum bptype type_wanted,
12889                                         enum bpdisp disposition,
12890                                         int thread,
12891                                         int task, int ignore_count,
12892                                         const struct breakpoint_ops *o,
12893                                         int from_tty, int enabled,
12894                                         int internal, unsigned flags)
12895 {
12896   internal_error_pure_virtual_called ();
12897 }
12898
12899 static void
12900 base_breakpoint_decode_linespec (struct breakpoint *b, char **s,
12901                                  struct symtabs_and_lines *sals)
12902 {
12903   internal_error_pure_virtual_called ();
12904 }
12905
12906 /* The default 'explains_signal' method.  */
12907
12908 static enum bpstat_signal_value
12909 base_breakpoint_explains_signal (struct breakpoint *b)
12910 {
12911   return BPSTAT_SIGNAL_HIDE;
12912 }
12913
12914 struct breakpoint_ops base_breakpoint_ops =
12915 {
12916   base_breakpoint_dtor,
12917   base_breakpoint_allocate_location,
12918   base_breakpoint_re_set,
12919   base_breakpoint_insert_location,
12920   base_breakpoint_remove_location,
12921   base_breakpoint_breakpoint_hit,
12922   base_breakpoint_check_status,
12923   base_breakpoint_resources_needed,
12924   base_breakpoint_works_in_software_mode,
12925   base_breakpoint_print_it,
12926   NULL,
12927   base_breakpoint_print_one_detail,
12928   base_breakpoint_print_mention,
12929   base_breakpoint_print_recreate,
12930   base_breakpoint_create_sals_from_address,
12931   base_breakpoint_create_breakpoints_sal,
12932   base_breakpoint_decode_linespec,
12933   base_breakpoint_explains_signal
12934 };
12935
12936 /* Default breakpoint_ops methods.  */
12937
12938 static void
12939 bkpt_re_set (struct breakpoint *b)
12940 {
12941   /* FIXME: is this still reachable?  */
12942   if (b->addr_string == NULL)
12943     {
12944       /* Anything without a string can't be re-set.  */
12945       delete_breakpoint (b);
12946       return;
12947     }
12948
12949   breakpoint_re_set_default (b);
12950 }
12951
12952 static int
12953 bkpt_insert_location (struct bp_location *bl)
12954 {
12955   if (bl->loc_type == bp_loc_hardware_breakpoint)
12956     return target_insert_hw_breakpoint (bl->gdbarch,
12957                                         &bl->target_info);
12958   else
12959     return target_insert_breakpoint (bl->gdbarch,
12960                                      &bl->target_info);
12961 }
12962
12963 static int
12964 bkpt_remove_location (struct bp_location *bl)
12965 {
12966   if (bl->loc_type == bp_loc_hardware_breakpoint)
12967     return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
12968   else
12969     return target_remove_breakpoint (bl->gdbarch, &bl->target_info);
12970 }
12971
12972 static int
12973 bkpt_breakpoint_hit (const struct bp_location *bl,
12974                      struct address_space *aspace, CORE_ADDR bp_addr,
12975                      const struct target_waitstatus *ws)
12976 {
12977   struct breakpoint *b = bl->owner;
12978
12979   if (ws->kind != TARGET_WAITKIND_STOPPED
12980       || ws->value.sig != GDB_SIGNAL_TRAP)
12981     return 0;
12982
12983   if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
12984                                  aspace, bp_addr))
12985     return 0;
12986
12987   if (overlay_debugging         /* unmapped overlay section */
12988       && section_is_overlay (bl->section)
12989       && !section_is_mapped (bl->section))
12990     return 0;
12991
12992   return 1;
12993 }
12994
12995 static int
12996 bkpt_resources_needed (const struct bp_location *bl)
12997 {
12998   gdb_assert (bl->owner->type == bp_hardware_breakpoint);
12999
13000   return 1;
13001 }
13002
13003 static enum print_stop_action
13004 bkpt_print_it (bpstat bs)
13005 {
13006   struct breakpoint *b;
13007   const struct bp_location *bl;
13008   int bp_temp;
13009   struct ui_out *uiout = current_uiout;
13010
13011   gdb_assert (bs->bp_location_at != NULL);
13012
13013   bl = bs->bp_location_at;
13014   b = bs->breakpoint_at;
13015
13016   bp_temp = b->disposition == disp_del;
13017   if (bl->address != bl->requested_address)
13018     breakpoint_adjustment_warning (bl->requested_address,
13019                                    bl->address,
13020                                    b->number, 1);
13021   annotate_breakpoint (b->number);
13022   if (bp_temp)
13023     ui_out_text (uiout, "\nTemporary breakpoint ");
13024   else
13025     ui_out_text (uiout, "\nBreakpoint ");
13026   if (ui_out_is_mi_like_p (uiout))
13027     {
13028       ui_out_field_string (uiout, "reason",
13029                            async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
13030       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
13031     }
13032   ui_out_field_int (uiout, "bkptno", b->number);
13033   ui_out_text (uiout, ", ");
13034
13035   return PRINT_SRC_AND_LOC;
13036 }
13037
13038 static void
13039 bkpt_print_mention (struct breakpoint *b)
13040 {
13041   if (ui_out_is_mi_like_p (current_uiout))
13042     return;
13043
13044   switch (b->type)
13045     {
13046     case bp_breakpoint:
13047     case bp_gnu_ifunc_resolver:
13048       if (b->disposition == disp_del)
13049         printf_filtered (_("Temporary breakpoint"));
13050       else
13051         printf_filtered (_("Breakpoint"));
13052       printf_filtered (_(" %d"), b->number);
13053       if (b->type == bp_gnu_ifunc_resolver)
13054         printf_filtered (_(" at gnu-indirect-function resolver"));
13055       break;
13056     case bp_hardware_breakpoint:
13057       printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
13058       break;
13059     case bp_dprintf:
13060       printf_filtered (_("Dprintf %d"), b->number);
13061       break;
13062     }
13063
13064   say_where (b);
13065 }
13066
13067 static void
13068 bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
13069 {
13070   if (tp->type == bp_breakpoint && tp->disposition == disp_del)
13071     fprintf_unfiltered (fp, "tbreak");
13072   else if (tp->type == bp_breakpoint)
13073     fprintf_unfiltered (fp, "break");
13074   else if (tp->type == bp_hardware_breakpoint
13075            && tp->disposition == disp_del)
13076     fprintf_unfiltered (fp, "thbreak");
13077   else if (tp->type == bp_hardware_breakpoint)
13078     fprintf_unfiltered (fp, "hbreak");
13079   else
13080     internal_error (__FILE__, __LINE__,
13081                     _("unhandled breakpoint type %d"), (int) tp->type);
13082
13083   fprintf_unfiltered (fp, " %s", tp->addr_string);
13084   print_recreate_thread (tp, fp);
13085 }
13086
13087 static void
13088 bkpt_create_sals_from_address (char **arg,
13089                                struct linespec_result *canonical,
13090                                enum bptype type_wanted,
13091                                char *addr_start, char **copy_arg)
13092 {
13093   create_sals_from_address_default (arg, canonical, type_wanted,
13094                                     addr_start, copy_arg);
13095 }
13096
13097 static void
13098 bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
13099                              struct linespec_result *canonical,
13100                              struct linespec_sals *lsal,
13101                              char *cond_string,
13102                              char *extra_string,
13103                              enum bptype type_wanted,
13104                              enum bpdisp disposition,
13105                              int thread,
13106                              int task, int ignore_count,
13107                              const struct breakpoint_ops *ops,
13108                              int from_tty, int enabled,
13109                              int internal, unsigned flags)
13110 {
13111   create_breakpoints_sal_default (gdbarch, canonical, lsal,
13112                                   cond_string, extra_string,
13113                                   type_wanted,
13114                                   disposition, thread, task,
13115                                   ignore_count, ops, from_tty,
13116                                   enabled, internal, flags);
13117 }
13118
13119 static void
13120 bkpt_decode_linespec (struct breakpoint *b, char **s,
13121                       struct symtabs_and_lines *sals)
13122 {
13123   decode_linespec_default (b, s, sals);
13124 }
13125
13126 /* Virtual table for internal breakpoints.  */
13127
13128 static void
13129 internal_bkpt_re_set (struct breakpoint *b)
13130 {
13131   switch (b->type)
13132     {
13133       /* Delete overlay event and longjmp master breakpoints; they
13134          will be reset later by breakpoint_re_set.  */
13135     case bp_overlay_event:
13136     case bp_longjmp_master:
13137     case bp_std_terminate_master:
13138     case bp_exception_master:
13139       delete_breakpoint (b);
13140       break;
13141
13142       /* This breakpoint is special, it's set up when the inferior
13143          starts and we really don't want to touch it.  */
13144     case bp_shlib_event:
13145
13146       /* Like bp_shlib_event, this breakpoint type is special.  Once
13147          it is set up, we do not want to touch it.  */
13148     case bp_thread_event:
13149       break;
13150     }
13151 }
13152
13153 static void
13154 internal_bkpt_check_status (bpstat bs)
13155 {
13156   if (bs->breakpoint_at->type == bp_shlib_event)
13157     {
13158       /* If requested, stop when the dynamic linker notifies GDB of
13159          events.  This allows the user to get control and place
13160          breakpoints in initializer routines for dynamically loaded
13161          objects (among other things).  */
13162       bs->stop = stop_on_solib_events;
13163       bs->print = stop_on_solib_events;
13164     }
13165   else
13166     bs->stop = 0;
13167 }
13168
13169 static enum print_stop_action
13170 internal_bkpt_print_it (bpstat bs)
13171 {
13172   struct ui_out *uiout = current_uiout;
13173   struct breakpoint *b;
13174
13175   b = bs->breakpoint_at;
13176
13177   switch (b->type)
13178     {
13179     case bp_shlib_event:
13180       /* Did we stop because the user set the stop_on_solib_events
13181          variable?  (If so, we report this as a generic, "Stopped due
13182          to shlib event" message.) */
13183       print_solib_event (0);
13184       break;
13185
13186     case bp_thread_event:
13187       /* Not sure how we will get here.
13188          GDB should not stop for these breakpoints.  */
13189       printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
13190       break;
13191
13192     case bp_overlay_event:
13193       /* By analogy with the thread event, GDB should not stop for these.  */
13194       printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
13195       break;
13196
13197     case bp_longjmp_master:
13198       /* These should never be enabled.  */
13199       printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
13200       break;
13201
13202     case bp_std_terminate_master:
13203       /* These should never be enabled.  */
13204       printf_filtered (_("std::terminate Master Breakpoint: "
13205                          "gdb should not stop!\n"));
13206       break;
13207
13208     case bp_exception_master:
13209       /* These should never be enabled.  */
13210       printf_filtered (_("Exception Master Breakpoint: "
13211                          "gdb should not stop!\n"));
13212       break;
13213     }
13214
13215   return PRINT_NOTHING;
13216 }
13217
13218 static void
13219 internal_bkpt_print_mention (struct breakpoint *b)
13220 {
13221   /* Nothing to mention.  These breakpoints are internal.  */
13222 }
13223
13224 /* Virtual table for momentary breakpoints  */
13225
13226 static void
13227 momentary_bkpt_re_set (struct breakpoint *b)
13228 {
13229   /* Keep temporary breakpoints, which can be encountered when we step
13230      over a dlopen call and SOLIB_ADD is resetting the breakpoints.
13231      Otherwise these should have been blown away via the cleanup chain
13232      or by breakpoint_init_inferior when we rerun the executable.  */
13233 }
13234
13235 static void
13236 momentary_bkpt_check_status (bpstat bs)
13237 {
13238   /* Nothing.  The point of these breakpoints is causing a stop.  */
13239 }
13240
13241 static enum print_stop_action
13242 momentary_bkpt_print_it (bpstat bs)
13243 {
13244   struct ui_out *uiout = current_uiout;
13245
13246   if (ui_out_is_mi_like_p (uiout))
13247     {
13248       struct breakpoint *b = bs->breakpoint_at;
13249
13250       switch (b->type)
13251         {
13252         case bp_finish:
13253           ui_out_field_string
13254             (uiout, "reason",
13255              async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED));
13256           break;
13257
13258         case bp_until:
13259           ui_out_field_string
13260             (uiout, "reason",
13261              async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED));
13262           break;
13263         }
13264     }
13265
13266   return PRINT_UNKNOWN;
13267 }
13268
13269 static void
13270 momentary_bkpt_print_mention (struct breakpoint *b)
13271 {
13272   /* Nothing to mention.  These breakpoints are internal.  */
13273 }
13274
13275 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13276
13277    It gets cleared already on the removal of the first one of such placed
13278    breakpoints.  This is OK as they get all removed altogether.  */
13279
13280 static void
13281 longjmp_bkpt_dtor (struct breakpoint *self)
13282 {
13283   struct thread_info *tp = find_thread_id (self->thread);
13284
13285   if (tp)
13286     tp->initiating_frame = null_frame_id;
13287
13288   momentary_breakpoint_ops.dtor (self);
13289 }
13290
13291 /* Specific methods for probe breakpoints.  */
13292
13293 static int
13294 bkpt_probe_insert_location (struct bp_location *bl)
13295 {
13296   int v = bkpt_insert_location (bl);
13297
13298   if (v == 0)
13299     {
13300       /* The insertion was successful, now let's set the probe's semaphore
13301          if needed.  */
13302       bl->probe->pops->set_semaphore (bl->probe, bl->gdbarch);
13303     }
13304
13305   return v;
13306 }
13307
13308 static int
13309 bkpt_probe_remove_location (struct bp_location *bl)
13310 {
13311   /* Let's clear the semaphore before removing the location.  */
13312   bl->probe->pops->clear_semaphore (bl->probe, bl->gdbarch);
13313
13314   return bkpt_remove_location (bl);
13315 }
13316
13317 static void
13318 bkpt_probe_create_sals_from_address (char **arg,
13319                                      struct linespec_result *canonical,
13320                                      enum bptype type_wanted,
13321                                      char *addr_start, char **copy_arg)
13322 {
13323   struct linespec_sals lsal;
13324
13325   lsal.sals = parse_probes (arg, canonical);
13326
13327   *copy_arg = xstrdup (canonical->addr_string);
13328   lsal.canonical = xstrdup (*copy_arg);
13329
13330   VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13331 }
13332
13333 static void
13334 bkpt_probe_decode_linespec (struct breakpoint *b, char **s,
13335                             struct symtabs_and_lines *sals)
13336 {
13337   *sals = parse_probes (s, NULL);
13338   if (!sals->sals)
13339     error (_("probe not found"));
13340 }
13341
13342 /* The breakpoint_ops structure to be used in tracepoints.  */
13343
13344 static void
13345 tracepoint_re_set (struct breakpoint *b)
13346 {
13347   breakpoint_re_set_default (b);
13348 }
13349
13350 static int
13351 tracepoint_breakpoint_hit (const struct bp_location *bl,
13352                            struct address_space *aspace, CORE_ADDR bp_addr,
13353                            const struct target_waitstatus *ws)
13354 {
13355   /* By definition, the inferior does not report stops at
13356      tracepoints.  */
13357   return 0;
13358 }
13359
13360 static void
13361 tracepoint_print_one_detail (const struct breakpoint *self,
13362                              struct ui_out *uiout)
13363 {
13364   struct tracepoint *tp = (struct tracepoint *) self;
13365   if (tp->static_trace_marker_id)
13366     {
13367       gdb_assert (self->type == bp_static_tracepoint);
13368
13369       ui_out_text (uiout, "\tmarker id is ");
13370       ui_out_field_string (uiout, "static-tracepoint-marker-string-id",
13371                            tp->static_trace_marker_id);
13372       ui_out_text (uiout, "\n");
13373     }
13374 }
13375
13376 static void
13377 tracepoint_print_mention (struct breakpoint *b)
13378 {
13379   if (ui_out_is_mi_like_p (current_uiout))
13380     return;
13381
13382   switch (b->type)
13383     {
13384     case bp_tracepoint:
13385       printf_filtered (_("Tracepoint"));
13386       printf_filtered (_(" %d"), b->number);
13387       break;
13388     case bp_fast_tracepoint:
13389       printf_filtered (_("Fast tracepoint"));
13390       printf_filtered (_(" %d"), b->number);
13391       break;
13392     case bp_static_tracepoint:
13393       printf_filtered (_("Static tracepoint"));
13394       printf_filtered (_(" %d"), b->number);
13395       break;
13396     default:
13397       internal_error (__FILE__, __LINE__,
13398                       _("unhandled tracepoint type %d"), (int) b->type);
13399     }
13400
13401   say_where (b);
13402 }
13403
13404 static void
13405 tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
13406 {
13407   struct tracepoint *tp = (struct tracepoint *) self;
13408
13409   if (self->type == bp_fast_tracepoint)
13410     fprintf_unfiltered (fp, "ftrace");
13411   if (self->type == bp_static_tracepoint)
13412     fprintf_unfiltered (fp, "strace");
13413   else if (self->type == bp_tracepoint)
13414     fprintf_unfiltered (fp, "trace");
13415   else
13416     internal_error (__FILE__, __LINE__,
13417                     _("unhandled tracepoint type %d"), (int) self->type);
13418
13419   fprintf_unfiltered (fp, " %s", self->addr_string);
13420   print_recreate_thread (self, fp);
13421
13422   if (tp->pass_count)
13423     fprintf_unfiltered (fp, "  passcount %d\n", tp->pass_count);
13424 }
13425
13426 static void
13427 tracepoint_create_sals_from_address (char **arg,
13428                                      struct linespec_result *canonical,
13429                                      enum bptype type_wanted,
13430                                      char *addr_start, char **copy_arg)
13431 {
13432   create_sals_from_address_default (arg, canonical, type_wanted,
13433                                     addr_start, copy_arg);
13434 }
13435
13436 static void
13437 tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
13438                                    struct linespec_result *canonical,
13439                                    struct linespec_sals *lsal,
13440                                    char *cond_string,
13441                                    char *extra_string,
13442                                    enum bptype type_wanted,
13443                                    enum bpdisp disposition,
13444                                    int thread,
13445                                    int task, int ignore_count,
13446                                    const struct breakpoint_ops *ops,
13447                                    int from_tty, int enabled,
13448                                    int internal, unsigned flags)
13449 {
13450   create_breakpoints_sal_default (gdbarch, canonical, lsal,
13451                                   cond_string, extra_string,
13452                                   type_wanted,
13453                                   disposition, thread, task,
13454                                   ignore_count, ops, from_tty,
13455                                   enabled, internal, flags);
13456 }
13457
13458 static void
13459 tracepoint_decode_linespec (struct breakpoint *b, char **s,
13460                             struct symtabs_and_lines *sals)
13461 {
13462   decode_linespec_default (b, s, sals);
13463 }
13464
13465 struct breakpoint_ops tracepoint_breakpoint_ops;
13466
13467 /* The breakpoint_ops structure to be use on tracepoints placed in a
13468    static probe.  */
13469
13470 static void
13471 tracepoint_probe_create_sals_from_address (char **arg,
13472                                            struct linespec_result *canonical,
13473                                            enum bptype type_wanted,
13474                                            char *addr_start, char **copy_arg)
13475 {
13476   /* We use the same method for breakpoint on probes.  */
13477   bkpt_probe_create_sals_from_address (arg, canonical, type_wanted,
13478                                        addr_start, copy_arg);
13479 }
13480
13481 static void
13482 tracepoint_probe_decode_linespec (struct breakpoint *b, char **s,
13483                                   struct symtabs_and_lines *sals)
13484 {
13485   /* We use the same method for breakpoint on probes.  */
13486   bkpt_probe_decode_linespec (b, s, sals);
13487 }
13488
13489 static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
13490
13491 /* The breakpoint_ops structure to be used on static tracepoints with
13492    markers (`-m').  */
13493
13494 static void
13495 strace_marker_create_sals_from_address (char **arg,
13496                                         struct linespec_result *canonical,
13497                                         enum bptype type_wanted,
13498                                         char *addr_start, char **copy_arg)
13499 {
13500   struct linespec_sals lsal;
13501
13502   lsal.sals = decode_static_tracepoint_spec (arg);
13503
13504   *copy_arg = savestring (addr_start, *arg - addr_start);
13505
13506   canonical->addr_string = xstrdup (*copy_arg);
13507   lsal.canonical = xstrdup (*copy_arg);
13508   VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13509 }
13510
13511 static void
13512 strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
13513                                       struct linespec_result *canonical,
13514                                       struct linespec_sals *lsal,
13515                                       char *cond_string,
13516                                       char *extra_string,
13517                                       enum bptype type_wanted,
13518                                       enum bpdisp disposition,
13519                                       int thread,
13520                                       int task, int ignore_count,
13521                                       const struct breakpoint_ops *ops,
13522                                       int from_tty, int enabled,
13523                                       int internal, unsigned flags)
13524 {
13525   int i;
13526
13527   /* If the user is creating a static tracepoint by marker id
13528      (strace -m MARKER_ID), then store the sals index, so that
13529      breakpoint_re_set can try to match up which of the newly
13530      found markers corresponds to this one, and, don't try to
13531      expand multiple locations for each sal, given than SALS
13532      already should contain all sals for MARKER_ID.  */
13533
13534   for (i = 0; i < lsal->sals.nelts; ++i)
13535     {
13536       struct symtabs_and_lines expanded;
13537       struct tracepoint *tp;
13538       struct cleanup *old_chain;
13539       char *addr_string;
13540
13541       expanded.nelts = 1;
13542       expanded.sals = &lsal->sals.sals[i];
13543
13544       addr_string = xstrdup (canonical->addr_string);
13545       old_chain = make_cleanup (xfree, addr_string);
13546
13547       tp = XCNEW (struct tracepoint);
13548       init_breakpoint_sal (&tp->base, gdbarch, expanded,
13549                            addr_string, NULL,
13550                            cond_string, extra_string,
13551                            type_wanted, disposition,
13552                            thread, task, ignore_count, ops,
13553                            from_tty, enabled, internal, flags,
13554                            canonical->special_display);
13555       /* Given that its possible to have multiple markers with
13556          the same string id, if the user is creating a static
13557          tracepoint by marker id ("strace -m MARKER_ID"), then
13558          store the sals index, so that breakpoint_re_set can
13559          try to match up which of the newly found markers
13560          corresponds to this one  */
13561       tp->static_trace_marker_id_idx = i;
13562
13563       install_breakpoint (internal, &tp->base, 0);
13564
13565       discard_cleanups (old_chain);
13566     }
13567 }
13568
13569 static void
13570 strace_marker_decode_linespec (struct breakpoint *b, char **s,
13571                                struct symtabs_and_lines *sals)
13572 {
13573   struct tracepoint *tp = (struct tracepoint *) b;
13574
13575   *sals = decode_static_tracepoint_spec (s);
13576   if (sals->nelts > tp->static_trace_marker_id_idx)
13577     {
13578       sals->sals[0] = sals->sals[tp->static_trace_marker_id_idx];
13579       sals->nelts = 1;
13580     }
13581   else
13582     error (_("marker %s not found"), tp->static_trace_marker_id);
13583 }
13584
13585 static struct breakpoint_ops strace_marker_breakpoint_ops;
13586
13587 static int
13588 strace_marker_p (struct breakpoint *b)
13589 {
13590   return b->ops == &strace_marker_breakpoint_ops;
13591 }
13592
13593 /* Delete a breakpoint and clean up all traces of it in the data
13594    structures.  */
13595
13596 void
13597 delete_breakpoint (struct breakpoint *bpt)
13598 {
13599   struct breakpoint *b;
13600
13601   gdb_assert (bpt != NULL);
13602
13603   /* Has this bp already been deleted?  This can happen because
13604      multiple lists can hold pointers to bp's.  bpstat lists are
13605      especial culprits.
13606
13607      One example of this happening is a watchpoint's scope bp.  When
13608      the scope bp triggers, we notice that the watchpoint is out of
13609      scope, and delete it.  We also delete its scope bp.  But the
13610      scope bp is marked "auto-deleting", and is already on a bpstat.
13611      That bpstat is then checked for auto-deleting bp's, which are
13612      deleted.
13613
13614      A real solution to this problem might involve reference counts in
13615      bp's, and/or giving them pointers back to their referencing
13616      bpstat's, and teaching delete_breakpoint to only free a bp's
13617      storage when no more references were extent.  A cheaper bandaid
13618      was chosen.  */
13619   if (bpt->type == bp_none)
13620     return;
13621
13622   /* At least avoid this stale reference until the reference counting
13623      of breakpoints gets resolved.  */
13624   if (bpt->related_breakpoint != bpt)
13625     {
13626       struct breakpoint *related;
13627       struct watchpoint *w;
13628
13629       if (bpt->type == bp_watchpoint_scope)
13630         w = (struct watchpoint *) bpt->related_breakpoint;
13631       else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
13632         w = (struct watchpoint *) bpt;
13633       else
13634         w = NULL;
13635       if (w != NULL)
13636         watchpoint_del_at_next_stop (w);
13637
13638       /* Unlink bpt from the bpt->related_breakpoint ring.  */
13639       for (related = bpt; related->related_breakpoint != bpt;
13640            related = related->related_breakpoint);
13641       related->related_breakpoint = bpt->related_breakpoint;
13642       bpt->related_breakpoint = bpt;
13643     }
13644
13645   /* watch_command_1 creates a watchpoint but only sets its number if
13646      update_watchpoint succeeds in creating its bp_locations.  If there's
13647      a problem in that process, we'll be asked to delete the half-created
13648      watchpoint.  In that case, don't announce the deletion.  */
13649   if (bpt->number)
13650     observer_notify_breakpoint_deleted (bpt);
13651
13652   if (breakpoint_chain == bpt)
13653     breakpoint_chain = bpt->next;
13654
13655   ALL_BREAKPOINTS (b)
13656     if (b->next == bpt)
13657     {
13658       b->next = bpt->next;
13659       break;
13660     }
13661
13662   /* Be sure no bpstat's are pointing at the breakpoint after it's
13663      been freed.  */
13664   /* FIXME, how can we find all bpstat's?  We just check stop_bpstat
13665      in all threads for now.  Note that we cannot just remove bpstats
13666      pointing at bpt from the stop_bpstat list entirely, as breakpoint
13667      commands are associated with the bpstat; if we remove it here,
13668      then the later call to bpstat_do_actions (&stop_bpstat); in
13669      event-top.c won't do anything, and temporary breakpoints with
13670      commands won't work.  */
13671
13672   iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13673
13674   /* Now that breakpoint is removed from breakpoint list, update the
13675      global location list.  This will remove locations that used to
13676      belong to this breakpoint.  Do this before freeing the breakpoint
13677      itself, since remove_breakpoint looks at location's owner.  It
13678      might be better design to have location completely
13679      self-contained, but it's not the case now.  */
13680   update_global_location_list (0);
13681
13682   bpt->ops->dtor (bpt);
13683   /* On the chance that someone will soon try again to delete this
13684      same bp, we mark it as deleted before freeing its storage.  */
13685   bpt->type = bp_none;
13686   xfree (bpt);
13687 }
13688
13689 static void
13690 do_delete_breakpoint_cleanup (void *b)
13691 {
13692   delete_breakpoint (b);
13693 }
13694
13695 struct cleanup *
13696 make_cleanup_delete_breakpoint (struct breakpoint *b)
13697 {
13698   return make_cleanup (do_delete_breakpoint_cleanup, b);
13699 }
13700
13701 /* Iterator function to call a user-provided callback function once
13702    for each of B and its related breakpoints.  */
13703
13704 static void
13705 iterate_over_related_breakpoints (struct breakpoint *b,
13706                                   void (*function) (struct breakpoint *,
13707                                                     void *),
13708                                   void *data)
13709 {
13710   struct breakpoint *related;
13711
13712   related = b;
13713   do
13714     {
13715       struct breakpoint *next;
13716
13717       /* FUNCTION may delete RELATED.  */
13718       next = related->related_breakpoint;
13719
13720       if (next == related)
13721         {
13722           /* RELATED is the last ring entry.  */
13723           function (related, data);
13724
13725           /* FUNCTION may have deleted it, so we'd never reach back to
13726              B.  There's nothing left to do anyway, so just break
13727              out.  */
13728           break;
13729         }
13730       else
13731         function (related, data);
13732
13733       related = next;
13734     }
13735   while (related != b);
13736 }
13737
13738 static void
13739 do_delete_breakpoint (struct breakpoint *b, void *ignore)
13740 {
13741   delete_breakpoint (b);
13742 }
13743
13744 /* A callback for map_breakpoint_numbers that calls
13745    delete_breakpoint.  */
13746
13747 static void
13748 do_map_delete_breakpoint (struct breakpoint *b, void *ignore)
13749 {
13750   iterate_over_related_breakpoints (b, do_delete_breakpoint, NULL);
13751 }
13752
13753 void
13754 delete_command (char *arg, int from_tty)
13755 {
13756   struct breakpoint *b, *b_tmp;
13757
13758   dont_repeat ();
13759
13760   if (arg == 0)
13761     {
13762       int breaks_to_delete = 0;
13763
13764       /* Delete all breakpoints if no argument.  Do not delete
13765          internal breakpoints, these have to be deleted with an
13766          explicit breakpoint number argument.  */
13767       ALL_BREAKPOINTS (b)
13768         if (user_breakpoint_p (b))
13769           {
13770             breaks_to_delete = 1;
13771             break;
13772           }
13773
13774       /* Ask user only if there are some breakpoints to delete.  */
13775       if (!from_tty
13776           || (breaks_to_delete && query (_("Delete all breakpoints? "))))
13777         {
13778           ALL_BREAKPOINTS_SAFE (b, b_tmp)
13779             if (user_breakpoint_p (b))
13780               delete_breakpoint (b);
13781         }
13782     }
13783   else
13784     map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
13785 }
13786
13787 static int
13788 all_locations_are_pending (struct bp_location *loc)
13789 {
13790   for (; loc; loc = loc->next)
13791     if (!loc->shlib_disabled
13792         && !loc->pspace->executing_startup)
13793       return 0;
13794   return 1;
13795 }
13796
13797 /* Subroutine of update_breakpoint_locations to simplify it.
13798    Return non-zero if multiple fns in list LOC have the same name.
13799    Null names are ignored.  */
13800
13801 static int
13802 ambiguous_names_p (struct bp_location *loc)
13803 {
13804   struct bp_location *l;
13805   htab_t htab = htab_create_alloc (13, htab_hash_string,
13806                                    (int (*) (const void *, 
13807                                              const void *)) streq,
13808                                    NULL, xcalloc, xfree);
13809
13810   for (l = loc; l != NULL; l = l->next)
13811     {
13812       const char **slot;
13813       const char *name = l->function_name;
13814
13815       /* Allow for some names to be NULL, ignore them.  */
13816       if (name == NULL)
13817         continue;
13818
13819       slot = (const char **) htab_find_slot (htab, (const void *) name,
13820                                              INSERT);
13821       /* NOTE: We can assume slot != NULL here because xcalloc never
13822          returns NULL.  */
13823       if (*slot != NULL)
13824         {
13825           htab_delete (htab);
13826           return 1;
13827         }
13828       *slot = name;
13829     }
13830
13831   htab_delete (htab);
13832   return 0;
13833 }
13834
13835 /* When symbols change, it probably means the sources changed as well,
13836    and it might mean the static tracepoint markers are no longer at
13837    the same address or line numbers they used to be at last we
13838    checked.  Losing your static tracepoints whenever you rebuild is
13839    undesirable.  This function tries to resync/rematch gdb static
13840    tracepoints with the markers on the target, for static tracepoints
13841    that have not been set by marker id.  Static tracepoint that have
13842    been set by marker id are reset by marker id in breakpoint_re_set.
13843    The heuristic is:
13844
13845    1) For a tracepoint set at a specific address, look for a marker at
13846    the old PC.  If one is found there, assume to be the same marker.
13847    If the name / string id of the marker found is different from the
13848    previous known name, assume that means the user renamed the marker
13849    in the sources, and output a warning.
13850
13851    2) For a tracepoint set at a given line number, look for a marker
13852    at the new address of the old line number.  If one is found there,
13853    assume to be the same marker.  If the name / string id of the
13854    marker found is different from the previous known name, assume that
13855    means the user renamed the marker in the sources, and output a
13856    warning.
13857
13858    3) If a marker is no longer found at the same address or line, it
13859    may mean the marker no longer exists.  But it may also just mean
13860    the code changed a bit.  Maybe the user added a few lines of code
13861    that made the marker move up or down (in line number terms).  Ask
13862    the target for info about the marker with the string id as we knew
13863    it.  If found, update line number and address in the matching
13864    static tracepoint.  This will get confused if there's more than one
13865    marker with the same ID (possible in UST, although unadvised
13866    precisely because it confuses tools).  */
13867
13868 static struct symtab_and_line
13869 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
13870 {
13871   struct tracepoint *tp = (struct tracepoint *) b;
13872   struct static_tracepoint_marker marker;
13873   CORE_ADDR pc;
13874
13875   pc = sal.pc;
13876   if (sal.line)
13877     find_line_pc (sal.symtab, sal.line, &pc);
13878
13879   if (target_static_tracepoint_marker_at (pc, &marker))
13880     {
13881       if (strcmp (tp->static_trace_marker_id, marker.str_id) != 0)
13882         warning (_("static tracepoint %d changed probed marker from %s to %s"),
13883                  b->number,
13884                  tp->static_trace_marker_id, marker.str_id);
13885
13886       xfree (tp->static_trace_marker_id);
13887       tp->static_trace_marker_id = xstrdup (marker.str_id);
13888       release_static_tracepoint_marker (&marker);
13889
13890       return sal;
13891     }
13892
13893   /* Old marker wasn't found on target at lineno.  Try looking it up
13894      by string ID.  */
13895   if (!sal.explicit_pc
13896       && sal.line != 0
13897       && sal.symtab != NULL
13898       && tp->static_trace_marker_id != NULL)
13899     {
13900       VEC(static_tracepoint_marker_p) *markers;
13901
13902       markers
13903         = target_static_tracepoint_markers_by_strid (tp->static_trace_marker_id);
13904
13905       if (!VEC_empty(static_tracepoint_marker_p, markers))
13906         {
13907           struct symtab_and_line sal2;
13908           struct symbol *sym;
13909           struct static_tracepoint_marker *tpmarker;
13910           struct ui_out *uiout = current_uiout;
13911
13912           tpmarker = VEC_index (static_tracepoint_marker_p, markers, 0);
13913
13914           xfree (tp->static_trace_marker_id);
13915           tp->static_trace_marker_id = xstrdup (tpmarker->str_id);
13916
13917           warning (_("marker for static tracepoint %d (%s) not "
13918                      "found at previous line number"),
13919                    b->number, tp->static_trace_marker_id);
13920
13921           init_sal (&sal2);
13922
13923           sal2.pc = tpmarker->address;
13924
13925           sal2 = find_pc_line (tpmarker->address, 0);
13926           sym = find_pc_sect_function (tpmarker->address, NULL);
13927           ui_out_text (uiout, "Now in ");
13928           if (sym)
13929             {
13930               ui_out_field_string (uiout, "func",
13931                                    SYMBOL_PRINT_NAME (sym));
13932               ui_out_text (uiout, " at ");
13933             }
13934           ui_out_field_string (uiout, "file",
13935                                symtab_to_filename_for_display (sal2.symtab));
13936           ui_out_text (uiout, ":");
13937
13938           if (ui_out_is_mi_like_p (uiout))
13939             {
13940               const char *fullname = symtab_to_fullname (sal2.symtab);
13941
13942               ui_out_field_string (uiout, "fullname", fullname);
13943             }
13944
13945           ui_out_field_int (uiout, "line", sal2.line);
13946           ui_out_text (uiout, "\n");
13947
13948           b->loc->line_number = sal2.line;
13949           b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
13950
13951           xfree (b->addr_string);
13952           b->addr_string = xstrprintf ("%s:%d",
13953                                    symtab_to_filename_for_display (sal2.symtab),
13954                                        b->loc->line_number);
13955
13956           /* Might be nice to check if function changed, and warn if
13957              so.  */
13958
13959           release_static_tracepoint_marker (tpmarker);
13960         }
13961     }
13962   return sal;
13963 }
13964
13965 /* Returns 1 iff locations A and B are sufficiently same that
13966    we don't need to report breakpoint as changed.  */
13967
13968 static int
13969 locations_are_equal (struct bp_location *a, struct bp_location *b)
13970 {
13971   while (a && b)
13972     {
13973       if (a->address != b->address)
13974         return 0;
13975
13976       if (a->shlib_disabled != b->shlib_disabled)
13977         return 0;
13978
13979       if (a->enabled != b->enabled)
13980         return 0;
13981
13982       a = a->next;
13983       b = b->next;
13984     }
13985
13986   if ((a == NULL) != (b == NULL))
13987     return 0;
13988
13989   return 1;
13990 }
13991
13992 /* Create new breakpoint locations for B (a hardware or software breakpoint)
13993    based on SALS and SALS_END.  If SALS_END.NELTS is not zero, then B is
13994    a ranged breakpoint.  */
13995
13996 void
13997 update_breakpoint_locations (struct breakpoint *b,
13998                              struct symtabs_and_lines sals,
13999                              struct symtabs_and_lines sals_end)
14000 {
14001   int i;
14002   struct bp_location *existing_locations = b->loc;
14003
14004   if (sals_end.nelts != 0 && (sals.nelts != 1 || sals_end.nelts != 1))
14005     {
14006       /* Ranged breakpoints have only one start location and one end
14007          location.  */
14008       b->enable_state = bp_disabled;
14009       update_global_location_list (1);
14010       printf_unfiltered (_("Could not reset ranged breakpoint %d: "
14011                            "multiple locations found\n"),
14012                          b->number);
14013       return;
14014     }
14015
14016   /* If there's no new locations, and all existing locations are
14017      pending, don't do anything.  This optimizes the common case where
14018      all locations are in the same shared library, that was unloaded.
14019      We'd like to retain the location, so that when the library is
14020      loaded again, we don't loose the enabled/disabled status of the
14021      individual locations.  */
14022   if (all_locations_are_pending (existing_locations) && sals.nelts == 0)
14023     return;
14024
14025   b->loc = NULL;
14026
14027   for (i = 0; i < sals.nelts; ++i)
14028     {
14029       struct bp_location *new_loc;
14030
14031       switch_to_program_space_and_thread (sals.sals[i].pspace);
14032
14033       new_loc = add_location_to_breakpoint (b, &(sals.sals[i]));
14034
14035       /* Reparse conditions, they might contain references to the
14036          old symtab.  */
14037       if (b->cond_string != NULL)
14038         {
14039           char *s;
14040           volatile struct gdb_exception e;
14041
14042           s = b->cond_string;
14043           TRY_CATCH (e, RETURN_MASK_ERROR)
14044             {
14045               new_loc->cond = parse_exp_1 (&s, sals.sals[i].pc,
14046                                            block_for_pc (sals.sals[i].pc), 
14047                                            0);
14048             }
14049           if (e.reason < 0)
14050             {
14051               warning (_("failed to reevaluate condition "
14052                          "for breakpoint %d: %s"), 
14053                        b->number, e.message);
14054               new_loc->enabled = 0;
14055             }
14056         }
14057
14058       if (sals_end.nelts)
14059         {
14060           CORE_ADDR end = find_breakpoint_range_end (sals_end.sals[0]);
14061
14062           new_loc->length = end - sals.sals[0].pc + 1;
14063         }
14064     }
14065
14066   /* Update locations of permanent breakpoints.  */
14067   if (b->enable_state == bp_permanent)
14068     make_breakpoint_permanent (b);
14069
14070   /* If possible, carry over 'disable' status from existing
14071      breakpoints.  */
14072   {
14073     struct bp_location *e = existing_locations;
14074     /* If there are multiple breakpoints with the same function name,
14075        e.g. for inline functions, comparing function names won't work.
14076        Instead compare pc addresses; this is just a heuristic as things
14077        may have moved, but in practice it gives the correct answer
14078        often enough until a better solution is found.  */
14079     int have_ambiguous_names = ambiguous_names_p (b->loc);
14080
14081     for (; e; e = e->next)
14082       {
14083         if (!e->enabled && e->function_name)
14084           {
14085             struct bp_location *l = b->loc;
14086             if (have_ambiguous_names)
14087               {
14088                 for (; l; l = l->next)
14089                   if (breakpoint_locations_match (e, l))
14090                     {
14091                       l->enabled = 0;
14092                       break;
14093                     }
14094               }
14095             else
14096               {
14097                 for (; l; l = l->next)
14098                   if (l->function_name
14099                       && strcmp (e->function_name, l->function_name) == 0)
14100                     {
14101                       l->enabled = 0;
14102                       break;
14103                     }
14104               }
14105           }
14106       }
14107   }
14108
14109   if (!locations_are_equal (existing_locations, b->loc))
14110     observer_notify_breakpoint_modified (b);
14111
14112   update_global_location_list (1);
14113 }
14114
14115 /* Find the SaL locations corresponding to the given ADDR_STRING.
14116    On return, FOUND will be 1 if any SaL was found, zero otherwise.  */
14117
14118 static struct symtabs_and_lines
14119 addr_string_to_sals (struct breakpoint *b, char *addr_string, int *found)
14120 {
14121   char *s;
14122   struct symtabs_and_lines sals = {0};
14123   volatile struct gdb_exception e;
14124
14125   gdb_assert (b->ops != NULL);
14126   s = addr_string;
14127
14128   TRY_CATCH (e, RETURN_MASK_ERROR)
14129     {
14130       b->ops->decode_linespec (b, &s, &sals);
14131     }
14132   if (e.reason < 0)
14133     {
14134       int not_found_and_ok = 0;
14135       /* For pending breakpoints, it's expected that parsing will
14136          fail until the right shared library is loaded.  User has
14137          already told to create pending breakpoints and don't need
14138          extra messages.  If breakpoint is in bp_shlib_disabled
14139          state, then user already saw the message about that
14140          breakpoint being disabled, and don't want to see more
14141          errors.  */
14142       if (e.error == NOT_FOUND_ERROR
14143           && (b->condition_not_parsed 
14144               || (b->loc && b->loc->shlib_disabled)
14145               || (b->loc && b->loc->pspace->executing_startup)
14146               || b->enable_state == bp_disabled))
14147         not_found_and_ok = 1;
14148
14149       if (!not_found_and_ok)
14150         {
14151           /* We surely don't want to warn about the same breakpoint
14152              10 times.  One solution, implemented here, is disable
14153              the breakpoint on error.  Another solution would be to
14154              have separate 'warning emitted' flag.  Since this
14155              happens only when a binary has changed, I don't know
14156              which approach is better.  */
14157           b->enable_state = bp_disabled;
14158           throw_exception (e);
14159         }
14160     }
14161
14162   if (e.reason == 0 || e.error != NOT_FOUND_ERROR)
14163     {
14164       int i;
14165
14166       for (i = 0; i < sals.nelts; ++i)
14167         resolve_sal_pc (&sals.sals[i]);
14168       if (b->condition_not_parsed && s && s[0])
14169         {
14170           char *cond_string, *extra_string;
14171           int thread, task;
14172
14173           find_condition_and_thread (s, sals.sals[0].pc,
14174                                      &cond_string, &thread, &task,
14175                                      &extra_string);
14176           if (cond_string)
14177             b->cond_string = cond_string;
14178           b->thread = thread;
14179           b->task = task;
14180           if (extra_string)
14181             b->extra_string = extra_string;
14182           b->condition_not_parsed = 0;
14183         }
14184
14185       if (b->type == bp_static_tracepoint && !strace_marker_p (b))
14186         sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
14187
14188       *found = 1;
14189     }
14190   else
14191     *found = 0;
14192
14193   return sals;
14194 }
14195
14196 /* The default re_set method, for typical hardware or software
14197    breakpoints.  Reevaluate the breakpoint and recreate its
14198    locations.  */
14199
14200 static void
14201 breakpoint_re_set_default (struct breakpoint *b)
14202 {
14203   int found;
14204   struct symtabs_and_lines sals, sals_end;
14205   struct symtabs_and_lines expanded = {0};
14206   struct symtabs_and_lines expanded_end = {0};
14207
14208   sals = addr_string_to_sals (b, b->addr_string, &found);
14209   if (found)
14210     {
14211       make_cleanup (xfree, sals.sals);
14212       expanded = sals;
14213     }
14214
14215   if (b->addr_string_range_end)
14216     {
14217       sals_end = addr_string_to_sals (b, b->addr_string_range_end, &found);
14218       if (found)
14219         {
14220           make_cleanup (xfree, sals_end.sals);
14221           expanded_end = sals_end;
14222         }
14223     }
14224
14225   update_breakpoint_locations (b, expanded, expanded_end);
14226 }
14227
14228 /* Default method for creating SALs from an address string.  It basically
14229    calls parse_breakpoint_sals.  Return 1 for success, zero for failure.  */
14230
14231 static void
14232 create_sals_from_address_default (char **arg,
14233                                   struct linespec_result *canonical,
14234                                   enum bptype type_wanted,
14235                                   char *addr_start, char **copy_arg)
14236 {
14237   parse_breakpoint_sals (arg, canonical);
14238 }
14239
14240 /* Call create_breakpoints_sal for the given arguments.  This is the default
14241    function for the `create_breakpoints_sal' method of
14242    breakpoint_ops.  */
14243
14244 static void
14245 create_breakpoints_sal_default (struct gdbarch *gdbarch,
14246                                 struct linespec_result *canonical,
14247                                 struct linespec_sals *lsal,
14248                                 char *cond_string,
14249                                 char *extra_string,
14250                                 enum bptype type_wanted,
14251                                 enum bpdisp disposition,
14252                                 int thread,
14253                                 int task, int ignore_count,
14254                                 const struct breakpoint_ops *ops,
14255                                 int from_tty, int enabled,
14256                                 int internal, unsigned flags)
14257 {
14258   create_breakpoints_sal (gdbarch, canonical, cond_string,
14259                           extra_string,
14260                           type_wanted, disposition,
14261                           thread, task, ignore_count, ops, from_tty,
14262                           enabled, internal, flags);
14263 }
14264
14265 /* Decode the line represented by S by calling decode_line_full.  This is the
14266    default function for the `decode_linespec' method of breakpoint_ops.  */
14267
14268 static void
14269 decode_linespec_default (struct breakpoint *b, char **s,
14270                          struct symtabs_and_lines *sals)
14271 {
14272   struct linespec_result canonical;
14273
14274   init_linespec_result (&canonical);
14275   decode_line_full (s, DECODE_LINE_FUNFIRSTLINE,
14276                     (struct symtab *) NULL, 0,
14277                     &canonical, multiple_symbols_all,
14278                     b->filter);
14279
14280   /* We should get 0 or 1 resulting SALs.  */
14281   gdb_assert (VEC_length (linespec_sals, canonical.sals) < 2);
14282
14283   if (VEC_length (linespec_sals, canonical.sals) > 0)
14284     {
14285       struct linespec_sals *lsal;
14286
14287       lsal = VEC_index (linespec_sals, canonical.sals, 0);
14288       *sals = lsal->sals;
14289       /* Arrange it so the destructor does not free the
14290          contents.  */
14291       lsal->sals.sals = NULL;
14292     }
14293
14294   destroy_linespec_result (&canonical);
14295 }
14296
14297 /* Prepare the global context for a re-set of breakpoint B.  */
14298
14299 static struct cleanup *
14300 prepare_re_set_context (struct breakpoint *b)
14301 {
14302   struct cleanup *cleanups;
14303
14304   input_radix = b->input_radix;
14305   cleanups = save_current_space_and_thread ();
14306   if (b->pspace != NULL)
14307     switch_to_program_space_and_thread (b->pspace);
14308   set_language (b->language);
14309
14310   return cleanups;
14311 }
14312
14313 /* Reset a breakpoint given it's struct breakpoint * BINT.
14314    The value we return ends up being the return value from catch_errors.
14315    Unused in this case.  */
14316
14317 static int
14318 breakpoint_re_set_one (void *bint)
14319 {
14320   /* Get past catch_errs.  */
14321   struct breakpoint *b = (struct breakpoint *) bint;
14322   struct cleanup *cleanups;
14323
14324   cleanups = prepare_re_set_context (b);
14325   b->ops->re_set (b);
14326   do_cleanups (cleanups);
14327   return 0;
14328 }
14329
14330 /* Re-set all breakpoints after symbols have been re-loaded.  */
14331 void
14332 breakpoint_re_set (void)
14333 {
14334   struct breakpoint *b, *b_tmp;
14335   enum language save_language;
14336   int save_input_radix;
14337   struct cleanup *old_chain;
14338
14339   save_language = current_language->la_language;
14340   save_input_radix = input_radix;
14341   old_chain = save_current_program_space ();
14342
14343   ALL_BREAKPOINTS_SAFE (b, b_tmp)
14344   {
14345     /* Format possible error msg.  */
14346     char *message = xstrprintf ("Error in re-setting breakpoint %d: ",
14347                                 b->number);
14348     struct cleanup *cleanups = make_cleanup (xfree, message);
14349     catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
14350     do_cleanups (cleanups);
14351   }
14352   set_language (save_language);
14353   input_radix = save_input_radix;
14354
14355   jit_breakpoint_re_set ();
14356
14357   do_cleanups (old_chain);
14358
14359   create_overlay_event_breakpoint ();
14360   create_longjmp_master_breakpoint ();
14361   create_std_terminate_master_breakpoint ();
14362   create_exception_master_breakpoint ();
14363 }
14364 \f
14365 /* Reset the thread number of this breakpoint:
14366
14367    - If the breakpoint is for all threads, leave it as-is.
14368    - Else, reset it to the current thread for inferior_ptid.  */
14369 void
14370 breakpoint_re_set_thread (struct breakpoint *b)
14371 {
14372   if (b->thread != -1)
14373     {
14374       if (in_thread_list (inferior_ptid))
14375         b->thread = pid_to_thread_id (inferior_ptid);
14376
14377       /* We're being called after following a fork.  The new fork is
14378          selected as current, and unless this was a vfork will have a
14379          different program space from the original thread.  Reset that
14380          as well.  */
14381       b->loc->pspace = current_program_space;
14382     }
14383 }
14384
14385 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14386    If from_tty is nonzero, it prints a message to that effect,
14387    which ends with a period (no newline).  */
14388
14389 void
14390 set_ignore_count (int bptnum, int count, int from_tty)
14391 {
14392   struct breakpoint *b;
14393
14394   if (count < 0)
14395     count = 0;
14396
14397   ALL_BREAKPOINTS (b)
14398     if (b->number == bptnum)
14399     {
14400       if (is_tracepoint (b))
14401         {
14402           if (from_tty && count != 0)
14403             printf_filtered (_("Ignore count ignored for tracepoint %d."),
14404                              bptnum);
14405           return;
14406         }
14407       
14408       b->ignore_count = count;
14409       if (from_tty)
14410         {
14411           if (count == 0)
14412             printf_filtered (_("Will stop next time "
14413                                "breakpoint %d is reached."),
14414                              bptnum);
14415           else if (count == 1)
14416             printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14417                              bptnum);
14418           else
14419             printf_filtered (_("Will ignore next %d "
14420                                "crossings of breakpoint %d."),
14421                              count, bptnum);
14422         }
14423       observer_notify_breakpoint_modified (b);
14424       return;
14425     }
14426
14427   error (_("No breakpoint number %d."), bptnum);
14428 }
14429
14430 /* Command to set ignore-count of breakpoint N to COUNT.  */
14431
14432 static void
14433 ignore_command (char *args, int from_tty)
14434 {
14435   char *p = args;
14436   int num;
14437
14438   if (p == 0)
14439     error_no_arg (_("a breakpoint number"));
14440
14441   num = get_number (&p);
14442   if (num == 0)
14443     error (_("bad breakpoint number: '%s'"), args);
14444   if (*p == 0)
14445     error (_("Second argument (specified ignore-count) is missing."));
14446
14447   set_ignore_count (num,
14448                     longest_to_int (value_as_long (parse_and_eval (p))),
14449                     from_tty);
14450   if (from_tty)
14451     printf_filtered ("\n");
14452 }
14453 \f
14454 /* Call FUNCTION on each of the breakpoints
14455    whose numbers are given in ARGS.  */
14456
14457 static void
14458 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *,
14459                                                       void *),
14460                         void *data)
14461 {
14462   int num;
14463   struct breakpoint *b, *tmp;
14464   int match;
14465   struct get_number_or_range_state state;
14466
14467   if (args == 0)
14468     error_no_arg (_("one or more breakpoint numbers"));
14469
14470   init_number_or_range (&state, args);
14471
14472   while (!state.finished)
14473     {
14474       char *p = state.string;
14475
14476       match = 0;
14477
14478       num = get_number_or_range (&state);
14479       if (num == 0)
14480         {
14481           warning (_("bad breakpoint number at or near '%s'"), p);
14482         }
14483       else
14484         {
14485           ALL_BREAKPOINTS_SAFE (b, tmp)
14486             if (b->number == num)
14487               {
14488                 match = 1;
14489                 function (b, data);
14490                 break;
14491               }
14492           if (match == 0)
14493             printf_unfiltered (_("No breakpoint number %d.\n"), num);
14494         }
14495     }
14496 }
14497
14498 static struct bp_location *
14499 find_location_by_number (char *number)
14500 {
14501   char *dot = strchr (number, '.');
14502   char *p1;
14503   int bp_num;
14504   int loc_num;
14505   struct breakpoint *b;
14506   struct bp_location *loc;  
14507
14508   *dot = '\0';
14509
14510   p1 = number;
14511   bp_num = get_number (&p1);
14512   if (bp_num == 0)
14513     error (_("Bad breakpoint number '%s'"), number);
14514
14515   ALL_BREAKPOINTS (b)
14516     if (b->number == bp_num)
14517       {
14518         break;
14519       }
14520
14521   if (!b || b->number != bp_num)
14522     error (_("Bad breakpoint number '%s'"), number);
14523   
14524   p1 = dot+1;
14525   loc_num = get_number (&p1);
14526   if (loc_num == 0)
14527     error (_("Bad breakpoint location number '%s'"), number);
14528
14529   --loc_num;
14530   loc = b->loc;
14531   for (;loc_num && loc; --loc_num, loc = loc->next)
14532     ;
14533   if (!loc)
14534     error (_("Bad breakpoint location number '%s'"), dot+1);
14535     
14536   return loc;  
14537 }
14538
14539
14540 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14541    If from_tty is nonzero, it prints a message to that effect,
14542    which ends with a period (no newline).  */
14543
14544 void
14545 disable_breakpoint (struct breakpoint *bpt)
14546 {
14547   /* Never disable a watchpoint scope breakpoint; we want to
14548      hit them when we leave scope so we can delete both the
14549      watchpoint and its scope breakpoint at that time.  */
14550   if (bpt->type == bp_watchpoint_scope)
14551     return;
14552
14553   /* You can't disable permanent breakpoints.  */
14554   if (bpt->enable_state == bp_permanent)
14555     return;
14556
14557   bpt->enable_state = bp_disabled;
14558
14559   /* Mark breakpoint locations modified.  */
14560   mark_breakpoint_modified (bpt);
14561
14562   if (target_supports_enable_disable_tracepoint ()
14563       && current_trace_status ()->running && is_tracepoint (bpt))
14564     {
14565       struct bp_location *location;
14566      
14567       for (location = bpt->loc; location; location = location->next)
14568         target_disable_tracepoint (location);
14569     }
14570
14571   update_global_location_list (0);
14572
14573   observer_notify_breakpoint_modified (bpt);
14574 }
14575
14576 /* A callback for iterate_over_related_breakpoints.  */
14577
14578 static void
14579 do_disable_breakpoint (struct breakpoint *b, void *ignore)
14580 {
14581   disable_breakpoint (b);
14582 }
14583
14584 /* A callback for map_breakpoint_numbers that calls
14585    disable_breakpoint.  */
14586
14587 static void
14588 do_map_disable_breakpoint (struct breakpoint *b, void *ignore)
14589 {
14590   iterate_over_related_breakpoints (b, do_disable_breakpoint, NULL);
14591 }
14592
14593 static void
14594 disable_command (char *args, int from_tty)
14595 {
14596   if (args == 0)
14597     {
14598       struct breakpoint *bpt;
14599
14600       ALL_BREAKPOINTS (bpt)
14601         if (user_breakpoint_p (bpt))
14602           disable_breakpoint (bpt);
14603     }
14604   else if (strchr (args, '.'))
14605     {
14606       struct bp_location *loc = find_location_by_number (args);
14607       if (loc)
14608         {
14609           if (loc->enabled)
14610             {
14611               loc->enabled = 0;
14612               mark_breakpoint_location_modified (loc);
14613             }
14614           if (target_supports_enable_disable_tracepoint ()
14615               && current_trace_status ()->running && loc->owner
14616               && is_tracepoint (loc->owner))
14617             target_disable_tracepoint (loc);
14618         }
14619       update_global_location_list (0);
14620     }
14621   else
14622     map_breakpoint_numbers (args, do_map_disable_breakpoint, NULL);
14623 }
14624
14625 static void
14626 enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14627                         int count)
14628 {
14629   int target_resources_ok;
14630
14631   if (bpt->type == bp_hardware_breakpoint)
14632     {
14633       int i;
14634       i = hw_breakpoint_used_count ();
14635       target_resources_ok = 
14636         target_can_use_hardware_watchpoint (bp_hardware_breakpoint, 
14637                                             i + 1, 0);
14638       if (target_resources_ok == 0)
14639         error (_("No hardware breakpoint support in the target."));
14640       else if (target_resources_ok < 0)
14641         error (_("Hardware breakpoints used exceeds limit."));
14642     }
14643
14644   if (is_watchpoint (bpt))
14645     {
14646       /* Initialize it just to avoid a GCC false warning.  */
14647       enum enable_state orig_enable_state = 0;
14648       volatile struct gdb_exception e;
14649
14650       TRY_CATCH (e, RETURN_MASK_ALL)
14651         {
14652           struct watchpoint *w = (struct watchpoint *) bpt;
14653
14654           orig_enable_state = bpt->enable_state;
14655           bpt->enable_state = bp_enabled;
14656           update_watchpoint (w, 1 /* reparse */);
14657         }
14658       if (e.reason < 0)
14659         {
14660           bpt->enable_state = orig_enable_state;
14661           exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14662                              bpt->number);
14663           return;
14664         }
14665     }
14666
14667   if (bpt->enable_state != bp_permanent)
14668     bpt->enable_state = bp_enabled;
14669
14670   bpt->enable_state = bp_enabled;
14671
14672   /* Mark breakpoint locations modified.  */
14673   mark_breakpoint_modified (bpt);
14674
14675   if (target_supports_enable_disable_tracepoint ()
14676       && current_trace_status ()->running && is_tracepoint (bpt))
14677     {
14678       struct bp_location *location;
14679
14680       for (location = bpt->loc; location; location = location->next)
14681         target_enable_tracepoint (location);
14682     }
14683
14684   bpt->disposition = disposition;
14685   bpt->enable_count = count;
14686   update_global_location_list (1);
14687
14688   observer_notify_breakpoint_modified (bpt);
14689 }
14690
14691
14692 void
14693 enable_breakpoint (struct breakpoint *bpt)
14694 {
14695   enable_breakpoint_disp (bpt, bpt->disposition, 0);
14696 }
14697
14698 static void
14699 do_enable_breakpoint (struct breakpoint *bpt, void *arg)
14700 {
14701   enable_breakpoint (bpt);
14702 }
14703
14704 /* A callback for map_breakpoint_numbers that calls
14705    enable_breakpoint.  */
14706
14707 static void
14708 do_map_enable_breakpoint (struct breakpoint *b, void *ignore)
14709 {
14710   iterate_over_related_breakpoints (b, do_enable_breakpoint, NULL);
14711 }
14712
14713 /* The enable command enables the specified breakpoints (or all defined
14714    breakpoints) so they once again become (or continue to be) effective
14715    in stopping the inferior.  */
14716
14717 static void
14718 enable_command (char *args, int from_tty)
14719 {
14720   if (args == 0)
14721     {
14722       struct breakpoint *bpt;
14723
14724       ALL_BREAKPOINTS (bpt)
14725         if (user_breakpoint_p (bpt))
14726           enable_breakpoint (bpt);
14727     }
14728   else if (strchr (args, '.'))
14729     {
14730       struct bp_location *loc = find_location_by_number (args);
14731       if (loc)
14732         {
14733           if (!loc->enabled)
14734             {
14735               loc->enabled = 1;
14736               mark_breakpoint_location_modified (loc);
14737             }
14738           if (target_supports_enable_disable_tracepoint ()
14739               && current_trace_status ()->running && loc->owner
14740               && is_tracepoint (loc->owner))
14741             target_enable_tracepoint (loc);
14742         }
14743       update_global_location_list (1);
14744     }
14745   else
14746     map_breakpoint_numbers (args, do_map_enable_breakpoint, NULL);
14747 }
14748
14749 /* This struct packages up disposition data for application to multiple
14750    breakpoints.  */
14751
14752 struct disp_data
14753 {
14754   enum bpdisp disp;
14755   int count;
14756 };
14757
14758 static void
14759 do_enable_breakpoint_disp (struct breakpoint *bpt, void *arg)
14760 {
14761   struct disp_data disp_data = *(struct disp_data *) arg;
14762
14763   enable_breakpoint_disp (bpt, disp_data.disp, disp_data.count);
14764 }
14765
14766 static void
14767 do_map_enable_once_breakpoint (struct breakpoint *bpt, void *ignore)
14768 {
14769   struct disp_data disp = { disp_disable, 1 };
14770
14771   iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14772 }
14773
14774 static void
14775 enable_once_command (char *args, int from_tty)
14776 {
14777   map_breakpoint_numbers (args, do_map_enable_once_breakpoint, NULL);
14778 }
14779
14780 static void
14781 do_map_enable_count_breakpoint (struct breakpoint *bpt, void *countptr)
14782 {
14783   struct disp_data disp = { disp_disable, *(int *) countptr };
14784
14785   iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14786 }
14787
14788 static void
14789 enable_count_command (char *args, int from_tty)
14790 {
14791   int count = get_number (&args);
14792
14793   map_breakpoint_numbers (args, do_map_enable_count_breakpoint, &count);
14794 }
14795
14796 static void
14797 do_map_enable_delete_breakpoint (struct breakpoint *bpt, void *ignore)
14798 {
14799   struct disp_data disp = { disp_del, 1 };
14800
14801   iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14802 }
14803
14804 static void
14805 enable_delete_command (char *args, int from_tty)
14806 {
14807   map_breakpoint_numbers (args, do_map_enable_delete_breakpoint, NULL);
14808 }
14809 \f
14810 static void
14811 set_breakpoint_cmd (char *args, int from_tty)
14812 {
14813 }
14814
14815 static void
14816 show_breakpoint_cmd (char *args, int from_tty)
14817 {
14818 }
14819
14820 /* Invalidate last known value of any hardware watchpoint if
14821    the memory which that value represents has been written to by
14822    GDB itself.  */
14823
14824 static void
14825 invalidate_bp_value_on_memory_change (struct inferior *inferior,
14826                                       CORE_ADDR addr, ssize_t len,
14827                                       const bfd_byte *data)
14828 {
14829   struct breakpoint *bp;
14830
14831   ALL_BREAKPOINTS (bp)
14832     if (bp->enable_state == bp_enabled
14833         && bp->type == bp_hardware_watchpoint)
14834       {
14835         struct watchpoint *wp = (struct watchpoint *) bp;
14836
14837         if (wp->val_valid && wp->val)
14838           {
14839             struct bp_location *loc;
14840
14841             for (loc = bp->loc; loc != NULL; loc = loc->next)
14842               if (loc->loc_type == bp_loc_hardware_watchpoint
14843                   && loc->address + loc->length > addr
14844                   && addr + len > loc->address)
14845                 {
14846                   value_free (wp->val);
14847                   wp->val = NULL;
14848                   wp->val_valid = 0;
14849                 }
14850           }
14851       }
14852 }
14853
14854 /* Create and insert a raw software breakpoint at PC.  Return an
14855    identifier, which should be used to remove the breakpoint later.
14856    In general, places which call this should be using something on the
14857    breakpoint chain instead; this function should be eliminated
14858    someday.  */
14859
14860 void *
14861 deprecated_insert_raw_breakpoint (struct gdbarch *gdbarch,
14862                                   struct address_space *aspace, CORE_ADDR pc)
14863 {
14864   struct bp_target_info *bp_tgt;
14865
14866   bp_tgt = XZALLOC (struct bp_target_info);
14867
14868   bp_tgt->placed_address_space = aspace;
14869   bp_tgt->placed_address = pc;
14870
14871   if (target_insert_breakpoint (gdbarch, bp_tgt) != 0)
14872     {
14873       /* Could not insert the breakpoint.  */
14874       xfree (bp_tgt);
14875       return NULL;
14876     }
14877
14878   return bp_tgt;
14879 }
14880
14881 /* Remove a breakpoint BP inserted by
14882    deprecated_insert_raw_breakpoint.  */
14883
14884 int
14885 deprecated_remove_raw_breakpoint (struct gdbarch *gdbarch, void *bp)
14886 {
14887   struct bp_target_info *bp_tgt = bp;
14888   int ret;
14889
14890   ret = target_remove_breakpoint (gdbarch, bp_tgt);
14891   xfree (bp_tgt);
14892
14893   return ret;
14894 }
14895
14896 /* One (or perhaps two) breakpoints used for software single
14897    stepping.  */
14898
14899 static void *single_step_breakpoints[2];
14900 static struct gdbarch *single_step_gdbarch[2];
14901
14902 /* Create and insert a breakpoint for software single step.  */
14903
14904 void
14905 insert_single_step_breakpoint (struct gdbarch *gdbarch,
14906                                struct address_space *aspace, 
14907                                CORE_ADDR next_pc)
14908 {
14909   void **bpt_p;
14910
14911   if (single_step_breakpoints[0] == NULL)
14912     {
14913       bpt_p = &single_step_breakpoints[0];
14914       single_step_gdbarch[0] = gdbarch;
14915     }
14916   else
14917     {
14918       gdb_assert (single_step_breakpoints[1] == NULL);
14919       bpt_p = &single_step_breakpoints[1];
14920       single_step_gdbarch[1] = gdbarch;
14921     }
14922
14923   /* NOTE drow/2006-04-11: A future improvement to this function would
14924      be to only create the breakpoints once, and actually put them on
14925      the breakpoint chain.  That would let us use set_raw_breakpoint.
14926      We could adjust the addresses each time they were needed.  Doing
14927      this requires corresponding changes elsewhere where single step
14928      breakpoints are handled, however.  So, for now, we use this.  */
14929
14930   *bpt_p = deprecated_insert_raw_breakpoint (gdbarch, aspace, next_pc);
14931   if (*bpt_p == NULL)
14932     error (_("Could not insert single-step breakpoint at %s"),
14933              paddress (gdbarch, next_pc));
14934 }
14935
14936 /* Check if the breakpoints used for software single stepping
14937    were inserted or not.  */
14938
14939 int
14940 single_step_breakpoints_inserted (void)
14941 {
14942   return (single_step_breakpoints[0] != NULL
14943           || single_step_breakpoints[1] != NULL);
14944 }
14945
14946 /* Remove and delete any breakpoints used for software single step.  */
14947
14948 void
14949 remove_single_step_breakpoints (void)
14950 {
14951   gdb_assert (single_step_breakpoints[0] != NULL);
14952
14953   /* See insert_single_step_breakpoint for more about this deprecated
14954      call.  */
14955   deprecated_remove_raw_breakpoint (single_step_gdbarch[0],
14956                                     single_step_breakpoints[0]);
14957   single_step_gdbarch[0] = NULL;
14958   single_step_breakpoints[0] = NULL;
14959
14960   if (single_step_breakpoints[1] != NULL)
14961     {
14962       deprecated_remove_raw_breakpoint (single_step_gdbarch[1],
14963                                         single_step_breakpoints[1]);
14964       single_step_gdbarch[1] = NULL;
14965       single_step_breakpoints[1] = NULL;
14966     }
14967 }
14968
14969 /* Delete software single step breakpoints without removing them from
14970    the inferior.  This is intended to be used if the inferior's address
14971    space where they were inserted is already gone, e.g. after exit or
14972    exec.  */
14973
14974 void
14975 cancel_single_step_breakpoints (void)
14976 {
14977   int i;
14978
14979   for (i = 0; i < 2; i++)
14980     if (single_step_breakpoints[i])
14981       {
14982         xfree (single_step_breakpoints[i]);
14983         single_step_breakpoints[i] = NULL;
14984         single_step_gdbarch[i] = NULL;
14985       }
14986 }
14987
14988 /* Detach software single-step breakpoints from INFERIOR_PTID without
14989    removing them.  */
14990
14991 static void
14992 detach_single_step_breakpoints (void)
14993 {
14994   int i;
14995
14996   for (i = 0; i < 2; i++)
14997     if (single_step_breakpoints[i])
14998       target_remove_breakpoint (single_step_gdbarch[i],
14999                                 single_step_breakpoints[i]);
15000 }
15001
15002 /* Check whether a software single-step breakpoint is inserted at
15003    PC.  */
15004
15005 static int
15006 single_step_breakpoint_inserted_here_p (struct address_space *aspace, 
15007                                         CORE_ADDR pc)
15008 {
15009   int i;
15010
15011   for (i = 0; i < 2; i++)
15012     {
15013       struct bp_target_info *bp_tgt = single_step_breakpoints[i];
15014       if (bp_tgt
15015           && breakpoint_address_match (bp_tgt->placed_address_space,
15016                                        bp_tgt->placed_address,
15017                                        aspace, pc))
15018         return 1;
15019     }
15020
15021   return 0;
15022 }
15023
15024 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
15025    non-zero otherwise.  */
15026 static int
15027 is_syscall_catchpoint_enabled (struct breakpoint *bp)
15028 {
15029   if (syscall_catchpoint_p (bp)
15030       && bp->enable_state != bp_disabled
15031       && bp->enable_state != bp_call_disabled)
15032     return 1;
15033   else
15034     return 0;
15035 }
15036
15037 int
15038 catch_syscall_enabled (void)
15039 {
15040   struct catch_syscall_inferior_data *inf_data
15041     = get_catch_syscall_inferior_data (current_inferior ());
15042
15043   return inf_data->total_syscalls_count != 0;
15044 }
15045
15046 int
15047 catching_syscall_number (int syscall_number)
15048 {
15049   struct breakpoint *bp;
15050
15051   ALL_BREAKPOINTS (bp)
15052     if (is_syscall_catchpoint_enabled (bp))
15053       {
15054         struct syscall_catchpoint *c = (struct syscall_catchpoint *) bp;
15055
15056         if (c->syscalls_to_be_caught)
15057           {
15058             int i, iter;
15059             for (i = 0;
15060                  VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
15061                  i++)
15062               if (syscall_number == iter)
15063                 return 1;
15064           }
15065         else
15066           return 1;
15067       }
15068
15069   return 0;
15070 }
15071
15072 /* Complete syscall names.  Used by "catch syscall".  */
15073 static VEC (char_ptr) *
15074 catch_syscall_completer (struct cmd_list_element *cmd,
15075                          char *text, char *word)
15076 {
15077   const char **list = get_syscall_names ();
15078   VEC (char_ptr) *retlist
15079     = (list == NULL) ? NULL : complete_on_enum (list, word, word);
15080
15081   xfree (list);
15082   return retlist;
15083 }
15084
15085 /* Tracepoint-specific operations.  */
15086
15087 /* Set tracepoint count to NUM.  */
15088 static void
15089 set_tracepoint_count (int num)
15090 {
15091   tracepoint_count = num;
15092   set_internalvar_integer (lookup_internalvar ("tpnum"), num);
15093 }
15094
15095 static void
15096 trace_command (char *arg, int from_tty)
15097 {
15098   struct breakpoint_ops *ops;
15099   const char *arg_cp = arg;
15100
15101   if (arg && probe_linespec_to_ops (&arg_cp))
15102     ops = &tracepoint_probe_breakpoint_ops;
15103   else
15104     ops = &tracepoint_breakpoint_ops;
15105
15106   create_breakpoint (get_current_arch (),
15107                      arg,
15108                      NULL, 0, NULL, 1 /* parse arg */,
15109                      0 /* tempflag */,
15110                      bp_tracepoint /* type_wanted */,
15111                      0 /* Ignore count */,
15112                      pending_break_support,
15113                      ops,
15114                      from_tty,
15115                      1 /* enabled */,
15116                      0 /* internal */, 0);
15117 }
15118
15119 static void
15120 ftrace_command (char *arg, int from_tty)
15121 {
15122   create_breakpoint (get_current_arch (),
15123                      arg,
15124                      NULL, 0, NULL, 1 /* parse arg */,
15125                      0 /* tempflag */,
15126                      bp_fast_tracepoint /* type_wanted */,
15127                      0 /* Ignore count */,
15128                      pending_break_support,
15129                      &tracepoint_breakpoint_ops,
15130                      from_tty,
15131                      1 /* enabled */,
15132                      0 /* internal */, 0);
15133 }
15134
15135 /* strace command implementation.  Creates a static tracepoint.  */
15136
15137 static void
15138 strace_command (char *arg, int from_tty)
15139 {
15140   struct breakpoint_ops *ops;
15141
15142   /* Decide if we are dealing with a static tracepoint marker (`-m'),
15143      or with a normal static tracepoint.  */
15144   if (arg && strncmp (arg, "-m", 2) == 0 && isspace (arg[2]))
15145     ops = &strace_marker_breakpoint_ops;
15146   else
15147     ops = &tracepoint_breakpoint_ops;
15148
15149   create_breakpoint (get_current_arch (),
15150                      arg,
15151                      NULL, 0, NULL, 1 /* parse arg */,
15152                      0 /* tempflag */,
15153                      bp_static_tracepoint /* type_wanted */,
15154                      0 /* Ignore count */,
15155                      pending_break_support,
15156                      ops,
15157                      from_tty,
15158                      1 /* enabled */,
15159                      0 /* internal */, 0);
15160 }
15161
15162 /* Set up a fake reader function that gets command lines from a linked
15163    list that was acquired during tracepoint uploading.  */
15164
15165 static struct uploaded_tp *this_utp;
15166 static int next_cmd;
15167
15168 static char *
15169 read_uploaded_action (void)
15170 {
15171   char *rslt;
15172
15173   VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
15174
15175   next_cmd++;
15176
15177   return rslt;
15178 }
15179
15180 /* Given information about a tracepoint as recorded on a target (which
15181    can be either a live system or a trace file), attempt to create an
15182    equivalent GDB tracepoint.  This is not a reliable process, since
15183    the target does not necessarily have all the information used when
15184    the tracepoint was originally defined.  */
15185   
15186 struct tracepoint *
15187 create_tracepoint_from_upload (struct uploaded_tp *utp)
15188 {
15189   char *addr_str, small_buf[100];
15190   struct tracepoint *tp;
15191
15192   if (utp->at_string)
15193     addr_str = utp->at_string;
15194   else
15195     {
15196       /* In the absence of a source location, fall back to raw
15197          address.  Since there is no way to confirm that the address
15198          means the same thing as when the trace was started, warn the
15199          user.  */
15200       warning (_("Uploaded tracepoint %d has no "
15201                  "source location, using raw address"),
15202                utp->number);
15203       xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (utp->addr));
15204       addr_str = small_buf;
15205     }
15206
15207   /* There's not much we can do with a sequence of bytecodes.  */
15208   if (utp->cond && !utp->cond_string)
15209     warning (_("Uploaded tracepoint %d condition "
15210                "has no source form, ignoring it"),
15211              utp->number);
15212
15213   if (!create_breakpoint (get_current_arch (),
15214                           addr_str,
15215                           utp->cond_string, -1, NULL,
15216                           0 /* parse cond/thread */,
15217                           0 /* tempflag */,
15218                           utp->type /* type_wanted */,
15219                           0 /* Ignore count */,
15220                           pending_break_support,
15221                           &tracepoint_breakpoint_ops,
15222                           0 /* from_tty */,
15223                           utp->enabled /* enabled */,
15224                           0 /* internal */,
15225                           CREATE_BREAKPOINT_FLAGS_INSERTED))
15226     return NULL;
15227
15228   /* Get the tracepoint we just created.  */
15229   tp = get_tracepoint (tracepoint_count);
15230   gdb_assert (tp != NULL);
15231
15232   if (utp->pass > 0)
15233     {
15234       xsnprintf (small_buf, sizeof (small_buf), "%d %d", utp->pass,
15235                  tp->base.number);
15236
15237       trace_pass_command (small_buf, 0);
15238     }
15239
15240   /* If we have uploaded versions of the original commands, set up a
15241      special-purpose "reader" function and call the usual command line
15242      reader, then pass the result to the breakpoint command-setting
15243      function.  */
15244   if (!VEC_empty (char_ptr, utp->cmd_strings))
15245     {
15246       struct command_line *cmd_list;
15247
15248       this_utp = utp;
15249       next_cmd = 0;
15250
15251       cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
15252
15253       breakpoint_set_commands (&tp->base, cmd_list);
15254     }
15255   else if (!VEC_empty (char_ptr, utp->actions)
15256            || !VEC_empty (char_ptr, utp->step_actions))
15257     warning (_("Uploaded tracepoint %d actions "
15258                "have no source form, ignoring them"),
15259              utp->number);
15260
15261   /* Copy any status information that might be available.  */
15262   tp->base.hit_count = utp->hit_count;
15263   tp->traceframe_usage = utp->traceframe_usage;
15264
15265   return tp;
15266 }
15267   
15268 /* Print information on tracepoint number TPNUM_EXP, or all if
15269    omitted.  */
15270
15271 static void
15272 tracepoints_info (char *args, int from_tty)
15273 {
15274   struct ui_out *uiout = current_uiout;
15275   int num_printed;
15276
15277   num_printed = breakpoint_1 (args, 0, is_tracepoint);
15278
15279   if (num_printed == 0)
15280     {
15281       if (args == NULL || *args == '\0')
15282         ui_out_message (uiout, 0, "No tracepoints.\n");
15283       else
15284         ui_out_message (uiout, 0, "No tracepoint matching '%s'.\n", args);
15285     }
15286
15287   default_collect_info ();
15288 }
15289
15290 /* The 'enable trace' command enables tracepoints.
15291    Not supported by all targets.  */
15292 static void
15293 enable_trace_command (char *args, int from_tty)
15294 {
15295   enable_command (args, from_tty);
15296 }
15297
15298 /* The 'disable trace' command disables tracepoints.
15299    Not supported by all targets.  */
15300 static void
15301 disable_trace_command (char *args, int from_tty)
15302 {
15303   disable_command (args, from_tty);
15304 }
15305
15306 /* Remove a tracepoint (or all if no argument).  */
15307 static void
15308 delete_trace_command (char *arg, int from_tty)
15309 {
15310   struct breakpoint *b, *b_tmp;
15311
15312   dont_repeat ();
15313
15314   if (arg == 0)
15315     {
15316       int breaks_to_delete = 0;
15317
15318       /* Delete all breakpoints if no argument.
15319          Do not delete internal or call-dummy breakpoints, these
15320          have to be deleted with an explicit breakpoint number 
15321          argument.  */
15322       ALL_TRACEPOINTS (b)
15323         if (is_tracepoint (b) && user_breakpoint_p (b))
15324           {
15325             breaks_to_delete = 1;
15326             break;
15327           }
15328
15329       /* Ask user only if there are some breakpoints to delete.  */
15330       if (!from_tty
15331           || (breaks_to_delete && query (_("Delete all tracepoints? "))))
15332         {
15333           ALL_BREAKPOINTS_SAFE (b, b_tmp)
15334             if (is_tracepoint (b) && user_breakpoint_p (b))
15335               delete_breakpoint (b);
15336         }
15337     }
15338   else
15339     map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
15340 }
15341
15342 /* Helper function for trace_pass_command.  */
15343
15344 static void
15345 trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
15346 {
15347   tp->pass_count = count;
15348   observer_notify_breakpoint_modified (&tp->base);
15349   if (from_tty)
15350     printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15351                      tp->base.number, count);
15352 }
15353
15354 /* Set passcount for tracepoint.
15355
15356    First command argument is passcount, second is tracepoint number.
15357    If tracepoint number omitted, apply to most recently defined.
15358    Also accepts special argument "all".  */
15359
15360 static void
15361 trace_pass_command (char *args, int from_tty)
15362 {
15363   struct tracepoint *t1;
15364   unsigned int count;
15365
15366   if (args == 0 || *args == 0)
15367     error (_("passcount command requires an "
15368              "argument (count + optional TP num)"));
15369
15370   count = strtoul (args, &args, 10);    /* Count comes first, then TP num.  */
15371
15372   args = skip_spaces (args);
15373   if (*args && strncasecmp (args, "all", 3) == 0)
15374     {
15375       struct breakpoint *b;
15376
15377       args += 3;                        /* Skip special argument "all".  */
15378       if (*args)
15379         error (_("Junk at end of arguments."));
15380
15381       ALL_TRACEPOINTS (b)
15382       {
15383         t1 = (struct tracepoint *) b;
15384         trace_pass_set_count (t1, count, from_tty);
15385       }
15386     }
15387   else if (*args == '\0')
15388     {
15389       t1 = get_tracepoint_by_number (&args, NULL, 1);
15390       if (t1)
15391         trace_pass_set_count (t1, count, from_tty);
15392     }
15393   else
15394     {
15395       struct get_number_or_range_state state;
15396
15397       init_number_or_range (&state, args);
15398       while (!state.finished)
15399         {
15400           t1 = get_tracepoint_by_number (&args, &state, 1);
15401           if (t1)
15402             trace_pass_set_count (t1, count, from_tty);
15403         }
15404     }
15405 }
15406
15407 struct tracepoint *
15408 get_tracepoint (int num)
15409 {
15410   struct breakpoint *t;
15411
15412   ALL_TRACEPOINTS (t)
15413     if (t->number == num)
15414       return (struct tracepoint *) t;
15415
15416   return NULL;
15417 }
15418
15419 /* Find the tracepoint with the given target-side number (which may be
15420    different from the tracepoint number after disconnecting and
15421    reconnecting).  */
15422
15423 struct tracepoint *
15424 get_tracepoint_by_number_on_target (int num)
15425 {
15426   struct breakpoint *b;
15427
15428   ALL_TRACEPOINTS (b)
15429     {
15430       struct tracepoint *t = (struct tracepoint *) b;
15431
15432       if (t->number_on_target == num)
15433         return t;
15434     }
15435
15436   return NULL;
15437 }
15438
15439 /* Utility: parse a tracepoint number and look it up in the list.
15440    If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15441    If OPTIONAL_P is true, then if the argument is missing, the most
15442    recent tracepoint (tracepoint_count) is returned.  */
15443 struct tracepoint *
15444 get_tracepoint_by_number (char **arg,
15445                           struct get_number_or_range_state *state,
15446                           int optional_p)
15447 {
15448   struct breakpoint *t;
15449   int tpnum;
15450   char *instring = arg == NULL ? NULL : *arg;
15451
15452   if (state)
15453     {
15454       gdb_assert (!state->finished);
15455       tpnum = get_number_or_range (state);
15456     }
15457   else if (arg == NULL || *arg == NULL || ! **arg)
15458     {
15459       if (optional_p)
15460         tpnum = tracepoint_count;
15461       else
15462         error_no_arg (_("tracepoint number"));
15463     }
15464   else
15465     tpnum = get_number (arg);
15466
15467   if (tpnum <= 0)
15468     {
15469       if (instring && *instring)
15470         printf_filtered (_("bad tracepoint number at or near '%s'\n"), 
15471                          instring);
15472       else
15473         printf_filtered (_("Tracepoint argument missing "
15474                            "and no previous tracepoint\n"));
15475       return NULL;
15476     }
15477
15478   ALL_TRACEPOINTS (t)
15479     if (t->number == tpnum)
15480     {
15481       return (struct tracepoint *) t;
15482     }
15483
15484   printf_unfiltered ("No tracepoint number %d.\n", tpnum);
15485   return NULL;
15486 }
15487
15488 void
15489 print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
15490 {
15491   if (b->thread != -1)
15492     fprintf_unfiltered (fp, " thread %d", b->thread);
15493
15494   if (b->task != 0)
15495     fprintf_unfiltered (fp, " task %d", b->task);
15496
15497   fprintf_unfiltered (fp, "\n");
15498 }
15499
15500 /* Save information on user settable breakpoints (watchpoints, etc) to
15501    a new script file named FILENAME.  If FILTER is non-NULL, call it
15502    on each breakpoint and only include the ones for which it returns
15503    non-zero.  */
15504
15505 static void
15506 save_breakpoints (char *filename, int from_tty,
15507                   int (*filter) (const struct breakpoint *))
15508 {
15509   struct breakpoint *tp;
15510   int any = 0;
15511   char *pathname;
15512   struct cleanup *cleanup;
15513   struct ui_file *fp;
15514   int extra_trace_bits = 0;
15515
15516   if (filename == 0 || *filename == 0)
15517     error (_("Argument required (file name in which to save)"));
15518
15519   /* See if we have anything to save.  */
15520   ALL_BREAKPOINTS (tp)
15521   {
15522     /* Skip internal and momentary breakpoints.  */
15523     if (!user_breakpoint_p (tp))
15524       continue;
15525
15526     /* If we have a filter, only save the breakpoints it accepts.  */
15527     if (filter && !filter (tp))
15528       continue;
15529
15530     any = 1;
15531
15532     if (is_tracepoint (tp))
15533       {
15534         extra_trace_bits = 1;
15535
15536         /* We can stop searching.  */
15537         break;
15538       }
15539   }
15540
15541   if (!any)
15542     {
15543       warning (_("Nothing to save."));
15544       return;
15545     }
15546
15547   pathname = tilde_expand (filename);
15548   cleanup = make_cleanup (xfree, pathname);
15549   fp = gdb_fopen (pathname, "w");
15550   if (!fp)
15551     error (_("Unable to open file '%s' for saving (%s)"),
15552            filename, safe_strerror (errno));
15553   make_cleanup_ui_file_delete (fp);
15554
15555   if (extra_trace_bits)
15556     save_trace_state_variables (fp);
15557
15558   ALL_BREAKPOINTS (tp)
15559   {
15560     /* Skip internal and momentary breakpoints.  */
15561     if (!user_breakpoint_p (tp))
15562       continue;
15563
15564     /* If we have a filter, only save the breakpoints it accepts.  */
15565     if (filter && !filter (tp))
15566       continue;
15567
15568     tp->ops->print_recreate (tp, fp);
15569
15570     /* Note, we can't rely on tp->number for anything, as we can't
15571        assume the recreated breakpoint numbers will match.  Use $bpnum
15572        instead.  */
15573
15574     if (tp->cond_string)
15575       fprintf_unfiltered (fp, "  condition $bpnum %s\n", tp->cond_string);
15576
15577     if (tp->ignore_count)
15578       fprintf_unfiltered (fp, "  ignore $bpnum %d\n", tp->ignore_count);
15579
15580     if (tp->commands)
15581       {
15582         volatile struct gdb_exception ex;       
15583
15584         fprintf_unfiltered (fp, "  commands\n");
15585         
15586         ui_out_redirect (current_uiout, fp);
15587         TRY_CATCH (ex, RETURN_MASK_ALL)
15588           {
15589             print_command_lines (current_uiout, tp->commands->commands, 2);
15590           }
15591         ui_out_redirect (current_uiout, NULL);
15592
15593         if (ex.reason < 0)
15594           throw_exception (ex);
15595
15596         fprintf_unfiltered (fp, "  end\n");
15597       }
15598
15599     if (tp->enable_state == bp_disabled)
15600       fprintf_unfiltered (fp, "disable\n");
15601
15602     /* If this is a multi-location breakpoint, check if the locations
15603        should be individually disabled.  Watchpoint locations are
15604        special, and not user visible.  */
15605     if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15606       {
15607         struct bp_location *loc;
15608         int n = 1;
15609
15610         for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15611           if (!loc->enabled)
15612             fprintf_unfiltered (fp, "disable $bpnum.%d\n", n);
15613       }
15614   }
15615
15616   if (extra_trace_bits && *default_collect)
15617     fprintf_unfiltered (fp, "set default-collect %s\n", default_collect);
15618
15619   do_cleanups (cleanup);
15620   if (from_tty)
15621     printf_filtered (_("Saved to file '%s'.\n"), filename);
15622 }
15623
15624 /* The `save breakpoints' command.  */
15625
15626 static void
15627 save_breakpoints_command (char *args, int from_tty)
15628 {
15629   save_breakpoints (args, from_tty, NULL);
15630 }
15631
15632 /* The `save tracepoints' command.  */
15633
15634 static void
15635 save_tracepoints_command (char *args, int from_tty)
15636 {
15637   save_breakpoints (args, from_tty, is_tracepoint);
15638 }
15639
15640 /* Create a vector of all tracepoints.  */
15641
15642 VEC(breakpoint_p) *
15643 all_tracepoints (void)
15644 {
15645   VEC(breakpoint_p) *tp_vec = 0;
15646   struct breakpoint *tp;
15647
15648   ALL_TRACEPOINTS (tp)
15649   {
15650     VEC_safe_push (breakpoint_p, tp_vec, tp);
15651   }
15652
15653   return tp_vec;
15654 }
15655
15656 \f
15657 /* This help string is used for the break, hbreak, tbreak and thbreak
15658    commands.  It is defined as a macro to prevent duplication.
15659    COMMAND should be a string constant containing the name of the
15660    command.  */
15661 #define BREAK_ARGS_HELP(command) \
15662 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15663 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15664 probe point.  Accepted values are `-probe' (for a generic, automatically\n\
15665 guessed probe type) or `-probe-stap' (for a SystemTap probe).\n\
15666 LOCATION may be a line number, function name, or \"*\" and an address.\n\
15667 If a line number is specified, break at start of code for that line.\n\
15668 If a function is specified, break at start of code for that function.\n\
15669 If an address is specified, break at that exact address.\n\
15670 With no LOCATION, uses current execution address of the selected\n\
15671 stack frame.  This is useful for breaking on return to a stack frame.\n\
15672 \n\
15673 THREADNUM is the number from \"info threads\".\n\
15674 CONDITION is a boolean expression.\n\
15675 \n\
15676 Multiple breakpoints at one place are permitted, and useful if their\n\
15677 conditions are different.\n\
15678 \n\
15679 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15680
15681 /* List of subcommands for "catch".  */
15682 static struct cmd_list_element *catch_cmdlist;
15683
15684 /* List of subcommands for "tcatch".  */
15685 static struct cmd_list_element *tcatch_cmdlist;
15686
15687 void
15688 add_catch_command (char *name, char *docstring,
15689                    void (*sfunc) (char *args, int from_tty,
15690                                   struct cmd_list_element *command),
15691                    completer_ftype *completer,
15692                    void *user_data_catch,
15693                    void *user_data_tcatch)
15694 {
15695   struct cmd_list_element *command;
15696
15697   command = add_cmd (name, class_breakpoint, NULL, docstring,
15698                      &catch_cmdlist);
15699   set_cmd_sfunc (command, sfunc);
15700   set_cmd_context (command, user_data_catch);
15701   set_cmd_completer (command, completer);
15702
15703   command = add_cmd (name, class_breakpoint, NULL, docstring,
15704                      &tcatch_cmdlist);
15705   set_cmd_sfunc (command, sfunc);
15706   set_cmd_context (command, user_data_tcatch);
15707   set_cmd_completer (command, completer);
15708 }
15709
15710 static void
15711 clear_syscall_counts (struct inferior *inf)
15712 {
15713   struct catch_syscall_inferior_data *inf_data
15714     = get_catch_syscall_inferior_data (inf);
15715
15716   inf_data->total_syscalls_count = 0;
15717   inf_data->any_syscall_count = 0;
15718   VEC_free (int, inf_data->syscalls_counts);
15719 }
15720
15721 static void
15722 save_command (char *arg, int from_tty)
15723 {
15724   printf_unfiltered (_("\"save\" must be followed by "
15725                        "the name of a save subcommand.\n"));
15726   help_list (save_cmdlist, "save ", -1, gdb_stdout);
15727 }
15728
15729 struct breakpoint *
15730 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15731                           void *data)
15732 {
15733   struct breakpoint *b, *b_tmp;
15734
15735   ALL_BREAKPOINTS_SAFE (b, b_tmp)
15736     {
15737       if ((*callback) (b, data))
15738         return b;
15739     }
15740
15741   return NULL;
15742 }
15743
15744 /* Zero if any of the breakpoint's locations could be a location where
15745    functions have been inlined, nonzero otherwise.  */
15746
15747 static int
15748 is_non_inline_function (struct breakpoint *b)
15749 {
15750   /* The shared library event breakpoint is set on the address of a
15751      non-inline function.  */
15752   if (b->type == bp_shlib_event)
15753     return 1;
15754
15755   return 0;
15756 }
15757
15758 /* Nonzero if the specified PC cannot be a location where functions
15759    have been inlined.  */
15760
15761 int
15762 pc_at_non_inline_function (struct address_space *aspace, CORE_ADDR pc,
15763                            const struct target_waitstatus *ws)
15764 {
15765   struct breakpoint *b;
15766   struct bp_location *bl;
15767
15768   ALL_BREAKPOINTS (b)
15769     {
15770       if (!is_non_inline_function (b))
15771         continue;
15772
15773       for (bl = b->loc; bl != NULL; bl = bl->next)
15774         {
15775           if (!bl->shlib_disabled
15776               && bpstat_check_location (bl, aspace, pc, ws))
15777             return 1;
15778         }
15779     }
15780
15781   return 0;
15782 }
15783
15784 /* Remove any references to OBJFILE which is going to be freed.  */
15785
15786 void
15787 breakpoint_free_objfile (struct objfile *objfile)
15788 {
15789   struct bp_location **locp, *loc;
15790
15791   ALL_BP_LOCATIONS (loc, locp)
15792     if (loc->symtab != NULL && loc->symtab->objfile == objfile)
15793       loc->symtab = NULL;
15794 }
15795
15796 void
15797 initialize_breakpoint_ops (void)
15798 {
15799   static int initialized = 0;
15800
15801   struct breakpoint_ops *ops;
15802
15803   if (initialized)
15804     return;
15805   initialized = 1;
15806
15807   /* The breakpoint_ops structure to be inherit by all kinds of
15808      breakpoints (real breakpoints, i.e., user "break" breakpoints,
15809      internal and momentary breakpoints, etc.).  */
15810   ops = &bkpt_base_breakpoint_ops;
15811   *ops = base_breakpoint_ops;
15812   ops->re_set = bkpt_re_set;
15813   ops->insert_location = bkpt_insert_location;
15814   ops->remove_location = bkpt_remove_location;
15815   ops->breakpoint_hit = bkpt_breakpoint_hit;
15816   ops->create_sals_from_address = bkpt_create_sals_from_address;
15817   ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
15818   ops->decode_linespec = bkpt_decode_linespec;
15819
15820   /* The breakpoint_ops structure to be used in regular breakpoints.  */
15821   ops = &bkpt_breakpoint_ops;
15822   *ops = bkpt_base_breakpoint_ops;
15823   ops->re_set = bkpt_re_set;
15824   ops->resources_needed = bkpt_resources_needed;
15825   ops->print_it = bkpt_print_it;
15826   ops->print_mention = bkpt_print_mention;
15827   ops->print_recreate = bkpt_print_recreate;
15828
15829   /* Ranged breakpoints.  */
15830   ops = &ranged_breakpoint_ops;
15831   *ops = bkpt_breakpoint_ops;
15832   ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15833   ops->resources_needed = resources_needed_ranged_breakpoint;
15834   ops->print_it = print_it_ranged_breakpoint;
15835   ops->print_one = print_one_ranged_breakpoint;
15836   ops->print_one_detail = print_one_detail_ranged_breakpoint;
15837   ops->print_mention = print_mention_ranged_breakpoint;
15838   ops->print_recreate = print_recreate_ranged_breakpoint;
15839
15840   /* Internal breakpoints.  */
15841   ops = &internal_breakpoint_ops;
15842   *ops = bkpt_base_breakpoint_ops;
15843   ops->re_set = internal_bkpt_re_set;
15844   ops->check_status = internal_bkpt_check_status;
15845   ops->print_it = internal_bkpt_print_it;
15846   ops->print_mention = internal_bkpt_print_mention;
15847
15848   /* Momentary breakpoints.  */
15849   ops = &momentary_breakpoint_ops;
15850   *ops = bkpt_base_breakpoint_ops;
15851   ops->re_set = momentary_bkpt_re_set;
15852   ops->check_status = momentary_bkpt_check_status;
15853   ops->print_it = momentary_bkpt_print_it;
15854   ops->print_mention = momentary_bkpt_print_mention;
15855
15856   /* Momentary breakpoints for bp_longjmp and bp_exception.  */
15857   ops = &longjmp_breakpoint_ops;
15858   *ops = momentary_breakpoint_ops;
15859   ops->dtor = longjmp_bkpt_dtor;
15860
15861   /* Probe breakpoints.  */
15862   ops = &bkpt_probe_breakpoint_ops;
15863   *ops = bkpt_breakpoint_ops;
15864   ops->insert_location = bkpt_probe_insert_location;
15865   ops->remove_location = bkpt_probe_remove_location;
15866   ops->create_sals_from_address = bkpt_probe_create_sals_from_address;
15867   ops->decode_linespec = bkpt_probe_decode_linespec;
15868
15869   /* GNU v3 exception catchpoints.  */
15870   ops = &gnu_v3_exception_catchpoint_ops;
15871   *ops = bkpt_breakpoint_ops;
15872   ops->print_it = print_it_exception_catchpoint;
15873   ops->print_one = print_one_exception_catchpoint;
15874   ops->print_mention = print_mention_exception_catchpoint;
15875   ops->print_recreate = print_recreate_exception_catchpoint;
15876
15877   /* Watchpoints.  */
15878   ops = &watchpoint_breakpoint_ops;
15879   *ops = base_breakpoint_ops;
15880   ops->dtor = dtor_watchpoint;
15881   ops->re_set = re_set_watchpoint;
15882   ops->insert_location = insert_watchpoint;
15883   ops->remove_location = remove_watchpoint;
15884   ops->breakpoint_hit = breakpoint_hit_watchpoint;
15885   ops->check_status = check_status_watchpoint;
15886   ops->resources_needed = resources_needed_watchpoint;
15887   ops->works_in_software_mode = works_in_software_mode_watchpoint;
15888   ops->print_it = print_it_watchpoint;
15889   ops->print_mention = print_mention_watchpoint;
15890   ops->print_recreate = print_recreate_watchpoint;
15891
15892   /* Masked watchpoints.  */
15893   ops = &masked_watchpoint_breakpoint_ops;
15894   *ops = watchpoint_breakpoint_ops;
15895   ops->insert_location = insert_masked_watchpoint;
15896   ops->remove_location = remove_masked_watchpoint;
15897   ops->resources_needed = resources_needed_masked_watchpoint;
15898   ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15899   ops->print_it = print_it_masked_watchpoint;
15900   ops->print_one_detail = print_one_detail_masked_watchpoint;
15901   ops->print_mention = print_mention_masked_watchpoint;
15902   ops->print_recreate = print_recreate_masked_watchpoint;
15903
15904   /* Tracepoints.  */
15905   ops = &tracepoint_breakpoint_ops;
15906   *ops = base_breakpoint_ops;
15907   ops->re_set = tracepoint_re_set;
15908   ops->breakpoint_hit = tracepoint_breakpoint_hit;
15909   ops->print_one_detail = tracepoint_print_one_detail;
15910   ops->print_mention = tracepoint_print_mention;
15911   ops->print_recreate = tracepoint_print_recreate;
15912   ops->create_sals_from_address = tracepoint_create_sals_from_address;
15913   ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
15914   ops->decode_linespec = tracepoint_decode_linespec;
15915
15916   /* Probe tracepoints.  */
15917   ops = &tracepoint_probe_breakpoint_ops;
15918   *ops = tracepoint_breakpoint_ops;
15919   ops->create_sals_from_address = tracepoint_probe_create_sals_from_address;
15920   ops->decode_linespec = tracepoint_probe_decode_linespec;
15921
15922   /* Static tracepoints with marker (`-m').  */
15923   ops = &strace_marker_breakpoint_ops;
15924   *ops = tracepoint_breakpoint_ops;
15925   ops->create_sals_from_address = strace_marker_create_sals_from_address;
15926   ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
15927   ops->decode_linespec = strace_marker_decode_linespec;
15928
15929   /* Fork catchpoints.  */
15930   ops = &catch_fork_breakpoint_ops;
15931   *ops = base_breakpoint_ops;
15932   ops->insert_location = insert_catch_fork;
15933   ops->remove_location = remove_catch_fork;
15934   ops->breakpoint_hit = breakpoint_hit_catch_fork;
15935   ops->print_it = print_it_catch_fork;
15936   ops->print_one = print_one_catch_fork;
15937   ops->print_mention = print_mention_catch_fork;
15938   ops->print_recreate = print_recreate_catch_fork;
15939
15940   /* Vfork catchpoints.  */
15941   ops = &catch_vfork_breakpoint_ops;
15942   *ops = base_breakpoint_ops;
15943   ops->insert_location = insert_catch_vfork;
15944   ops->remove_location = remove_catch_vfork;
15945   ops->breakpoint_hit = breakpoint_hit_catch_vfork;
15946   ops->print_it = print_it_catch_vfork;
15947   ops->print_one = print_one_catch_vfork;
15948   ops->print_mention = print_mention_catch_vfork;
15949   ops->print_recreate = print_recreate_catch_vfork;
15950
15951   /* Exec catchpoints.  */
15952   ops = &catch_exec_breakpoint_ops;
15953   *ops = base_breakpoint_ops;
15954   ops->dtor = dtor_catch_exec;
15955   ops->insert_location = insert_catch_exec;
15956   ops->remove_location = remove_catch_exec;
15957   ops->breakpoint_hit = breakpoint_hit_catch_exec;
15958   ops->print_it = print_it_catch_exec;
15959   ops->print_one = print_one_catch_exec;
15960   ops->print_mention = print_mention_catch_exec;
15961   ops->print_recreate = print_recreate_catch_exec;
15962
15963   /* Syscall catchpoints.  */
15964   ops = &catch_syscall_breakpoint_ops;
15965   *ops = base_breakpoint_ops;
15966   ops->dtor = dtor_catch_syscall;
15967   ops->insert_location = insert_catch_syscall;
15968   ops->remove_location = remove_catch_syscall;
15969   ops->breakpoint_hit = breakpoint_hit_catch_syscall;
15970   ops->print_it = print_it_catch_syscall;
15971   ops->print_one = print_one_catch_syscall;
15972   ops->print_mention = print_mention_catch_syscall;
15973   ops->print_recreate = print_recreate_catch_syscall;
15974
15975   /* Solib-related catchpoints.  */
15976   ops = &catch_solib_breakpoint_ops;
15977   *ops = base_breakpoint_ops;
15978   ops->dtor = dtor_catch_solib;
15979   ops->insert_location = insert_catch_solib;
15980   ops->remove_location = remove_catch_solib;
15981   ops->breakpoint_hit = breakpoint_hit_catch_solib;
15982   ops->check_status = check_status_catch_solib;
15983   ops->print_it = print_it_catch_solib;
15984   ops->print_one = print_one_catch_solib;
15985   ops->print_mention = print_mention_catch_solib;
15986   ops->print_recreate = print_recreate_catch_solib;
15987
15988   ops = &dprintf_breakpoint_ops;
15989   *ops = bkpt_base_breakpoint_ops;
15990   ops->re_set = bkpt_re_set;
15991   ops->resources_needed = bkpt_resources_needed;
15992   ops->print_it = bkpt_print_it;
15993   ops->print_mention = bkpt_print_mention;
15994   ops->print_recreate = bkpt_print_recreate;
15995 }
15996
15997 /* Chain containing all defined "enable breakpoint" subcommands.  */
15998
15999 static struct cmd_list_element *enablebreaklist = NULL;
16000
16001 void
16002 _initialize_breakpoint (void)
16003 {
16004   struct cmd_list_element *c;
16005
16006   initialize_breakpoint_ops ();
16007
16008   observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
16009   observer_attach_inferior_exit (clear_syscall_counts);
16010   observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
16011
16012   breakpoint_objfile_key
16013     = register_objfile_data_with_cleanup (NULL, free_breakpoint_probes);
16014
16015   catch_syscall_inferior_data
16016     = register_inferior_data_with_cleanup (NULL,
16017                                            catch_syscall_inferior_data_cleanup);
16018
16019   breakpoint_chain = 0;
16020   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
16021      before a breakpoint is set.  */
16022   breakpoint_count = 0;
16023
16024   tracepoint_count = 0;
16025
16026   add_com ("ignore", class_breakpoint, ignore_command, _("\
16027 Set ignore-count of breakpoint number N to COUNT.\n\
16028 Usage is `ignore N COUNT'."));
16029   if (xdb_commands)
16030     add_com_alias ("bc", "ignore", class_breakpoint, 1);
16031
16032   add_com ("commands", class_breakpoint, commands_command, _("\
16033 Set commands to be executed when a breakpoint is hit.\n\
16034 Give breakpoint number as argument after \"commands\".\n\
16035 With no argument, the targeted breakpoint is the last one set.\n\
16036 The commands themselves follow starting on the next line.\n\
16037 Type a line containing \"end\" to indicate the end of them.\n\
16038 Give \"silent\" as the first line to make the breakpoint silent;\n\
16039 then no output is printed when it is hit, except what the commands print."));
16040
16041   c = add_com ("condition", class_breakpoint, condition_command, _("\
16042 Specify breakpoint number N to break only if COND is true.\n\
16043 Usage is `condition N COND', where N is an integer and COND is an\n\
16044 expression to be evaluated whenever breakpoint N is reached."));
16045   set_cmd_completer (c, condition_completer);
16046
16047   c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
16048 Set a temporary breakpoint.\n\
16049 Like \"break\" except the breakpoint is only temporary,\n\
16050 so it will be deleted when hit.  Equivalent to \"break\" followed\n\
16051 by using \"enable delete\" on the breakpoint number.\n\
16052 \n"
16053 BREAK_ARGS_HELP ("tbreak")));
16054   set_cmd_completer (c, location_completer);
16055
16056   c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
16057 Set a hardware assisted breakpoint.\n\
16058 Like \"break\" except the breakpoint requires hardware support,\n\
16059 some target hardware may not have this support.\n\
16060 \n"
16061 BREAK_ARGS_HELP ("hbreak")));
16062   set_cmd_completer (c, location_completer);
16063
16064   c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
16065 Set a temporary hardware assisted breakpoint.\n\
16066 Like \"hbreak\" except the breakpoint is only temporary,\n\
16067 so it will be deleted when hit.\n\
16068 \n"
16069 BREAK_ARGS_HELP ("thbreak")));
16070   set_cmd_completer (c, location_completer);
16071
16072   add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
16073 Enable some breakpoints.\n\
16074 Give breakpoint numbers (separated by spaces) as arguments.\n\
16075 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16076 This is used to cancel the effect of the \"disable\" command.\n\
16077 With a subcommand you can enable temporarily."),
16078                   &enablelist, "enable ", 1, &cmdlist);
16079   if (xdb_commands)
16080     add_com ("ab", class_breakpoint, enable_command, _("\
16081 Enable some breakpoints.\n\
16082 Give breakpoint numbers (separated by spaces) as arguments.\n\
16083 With no subcommand, breakpoints are enabled until you command otherwise.\n\
16084 This is used to cancel the effect of the \"disable\" command.\n\
16085 With a subcommand you can enable temporarily."));
16086
16087   add_com_alias ("en", "enable", class_breakpoint, 1);
16088
16089   add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
16090 Enable some breakpoints.\n\
16091 Give breakpoint numbers (separated by spaces) as arguments.\n\
16092 This is used to cancel the effect of the \"disable\" command.\n\
16093 May be abbreviated to simply \"enable\".\n"),
16094                    &enablebreaklist, "enable breakpoints ", 1, &enablelist);
16095
16096   add_cmd ("once", no_class, enable_once_command, _("\
16097 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
16098 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16099            &enablebreaklist);
16100
16101   add_cmd ("delete", no_class, enable_delete_command, _("\
16102 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
16103 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16104            &enablebreaklist);
16105
16106   add_cmd ("count", no_class, enable_count_command, _("\
16107 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
16108 If a breakpoint is hit while enabled in this fashion,\n\
16109 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16110            &enablebreaklist);
16111
16112   add_cmd ("delete", no_class, enable_delete_command, _("\
16113 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
16114 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16115            &enablelist);
16116
16117   add_cmd ("once", no_class, enable_once_command, _("\
16118 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
16119 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16120            &enablelist);
16121
16122   add_cmd ("count", no_class, enable_count_command, _("\
16123 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
16124 If a breakpoint is hit while enabled in this fashion,\n\
16125 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16126            &enablelist);
16127
16128   add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
16129 Disable some breakpoints.\n\
16130 Arguments are breakpoint numbers with spaces in between.\n\
16131 To disable all breakpoints, give no argument.\n\
16132 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
16133                   &disablelist, "disable ", 1, &cmdlist);
16134   add_com_alias ("dis", "disable", class_breakpoint, 1);
16135   add_com_alias ("disa", "disable", class_breakpoint, 1);
16136   if (xdb_commands)
16137     add_com ("sb", class_breakpoint, disable_command, _("\
16138 Disable some breakpoints.\n\
16139 Arguments are breakpoint numbers with spaces in between.\n\
16140 To disable all breakpoints, give no argument.\n\
16141 A disabled breakpoint is not forgotten, but has no effect until re-enabled."));
16142
16143   add_cmd ("breakpoints", class_alias, disable_command, _("\
16144 Disable some breakpoints.\n\
16145 Arguments are breakpoint numbers with spaces in between.\n\
16146 To disable all breakpoints, give no argument.\n\
16147 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
16148 This command may be abbreviated \"disable\"."),
16149            &disablelist);
16150
16151   add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
16152 Delete some breakpoints or auto-display expressions.\n\
16153 Arguments are breakpoint numbers with spaces in between.\n\
16154 To delete all breakpoints, give no argument.\n\
16155 \n\
16156 Also a prefix command for deletion of other GDB objects.\n\
16157 The \"unset\" command is also an alias for \"delete\"."),
16158                   &deletelist, "delete ", 1, &cmdlist);
16159   add_com_alias ("d", "delete", class_breakpoint, 1);
16160   add_com_alias ("del", "delete", class_breakpoint, 1);
16161   if (xdb_commands)
16162     add_com ("db", class_breakpoint, delete_command, _("\
16163 Delete some breakpoints.\n\
16164 Arguments are breakpoint numbers with spaces in between.\n\
16165 To delete all breakpoints, give no argument.\n"));
16166
16167   add_cmd ("breakpoints", class_alias, delete_command, _("\
16168 Delete some breakpoints or auto-display expressions.\n\
16169 Arguments are breakpoint numbers with spaces in between.\n\
16170 To delete all breakpoints, give no argument.\n\
16171 This command may be abbreviated \"delete\"."),
16172            &deletelist);
16173
16174   add_com ("clear", class_breakpoint, clear_command, _("\
16175 Clear breakpoint at specified line or function.\n\
16176 Argument may be line number, function name, or \"*\" and an address.\n\
16177 If line number is specified, all breakpoints in that line are cleared.\n\
16178 If function is specified, breakpoints at beginning of function are cleared.\n\
16179 If an address is specified, breakpoints at that address are cleared.\n\
16180 \n\
16181 With no argument, clears all breakpoints in the line that the selected frame\n\
16182 is executing in.\n\
16183 \n\
16184 See also the \"delete\" command which clears breakpoints by number."));
16185   add_com_alias ("cl", "clear", class_breakpoint, 1);
16186
16187   c = add_com ("break", class_breakpoint, break_command, _("\
16188 Set breakpoint at specified line or function.\n"
16189 BREAK_ARGS_HELP ("break")));
16190   set_cmd_completer (c, location_completer);
16191
16192   add_com_alias ("b", "break", class_run, 1);
16193   add_com_alias ("br", "break", class_run, 1);
16194   add_com_alias ("bre", "break", class_run, 1);
16195   add_com_alias ("brea", "break", class_run, 1);
16196
16197   if (xdb_commands)
16198    add_com_alias ("ba", "break", class_breakpoint, 1);
16199
16200   if (dbx_commands)
16201     {
16202       add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
16203 Break in function/address or break at a line in the current file."),
16204                              &stoplist, "stop ", 1, &cmdlist);
16205       add_cmd ("in", class_breakpoint, stopin_command,
16206                _("Break in function or address."), &stoplist);
16207       add_cmd ("at", class_breakpoint, stopat_command,
16208                _("Break at a line in the current file."), &stoplist);
16209       add_com ("status", class_info, breakpoints_info, _("\
16210 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16211 The \"Type\" column indicates one of:\n\
16212 \tbreakpoint     - normal breakpoint\n\
16213 \twatchpoint     - watchpoint\n\
16214 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16215 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
16216 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
16217 address and file/line number respectively.\n\
16218 \n\
16219 Convenience variable \"$_\" and default examine address for \"x\"\n\
16220 are set to the address of the last breakpoint listed unless the command\n\
16221 is prefixed with \"server \".\n\n\
16222 Convenience variable \"$bpnum\" contains the number of the last\n\
16223 breakpoint set."));
16224     }
16225
16226   add_info ("breakpoints", breakpoints_info, _("\
16227 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
16228 The \"Type\" column indicates one of:\n\
16229 \tbreakpoint     - normal breakpoint\n\
16230 \twatchpoint     - watchpoint\n\
16231 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16232 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
16233 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
16234 address and file/line number respectively.\n\
16235 \n\
16236 Convenience variable \"$_\" and default examine address for \"x\"\n\
16237 are set to the address of the last breakpoint listed unless the command\n\
16238 is prefixed with \"server \".\n\n\
16239 Convenience variable \"$bpnum\" contains the number of the last\n\
16240 breakpoint set."));
16241
16242   add_info_alias ("b", "breakpoints", 1);
16243
16244   if (xdb_commands)
16245     add_com ("lb", class_breakpoint, breakpoints_info, _("\
16246 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16247 The \"Type\" column indicates one of:\n\
16248 \tbreakpoint     - normal breakpoint\n\
16249 \twatchpoint     - watchpoint\n\
16250 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16251 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
16252 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
16253 address and file/line number respectively.\n\
16254 \n\
16255 Convenience variable \"$_\" and default examine address for \"x\"\n\
16256 are set to the address of the last breakpoint listed unless the command\n\
16257 is prefixed with \"server \".\n\n\
16258 Convenience variable \"$bpnum\" contains the number of the last\n\
16259 breakpoint set."));
16260
16261   add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
16262 Status of all breakpoints, or breakpoint number NUMBER.\n\
16263 The \"Type\" column indicates one of:\n\
16264 \tbreakpoint     - normal breakpoint\n\
16265 \twatchpoint     - watchpoint\n\
16266 \tlongjmp        - internal breakpoint used to step through longjmp()\n\
16267 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16268 \tuntil          - internal breakpoint used by the \"until\" command\n\
16269 \tfinish         - internal breakpoint used by the \"finish\" command\n\
16270 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16271 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
16272 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
16273 address and file/line number respectively.\n\
16274 \n\
16275 Convenience variable \"$_\" and default examine address for \"x\"\n\
16276 are set to the address of the last breakpoint listed unless the command\n\
16277 is prefixed with \"server \".\n\n\
16278 Convenience variable \"$bpnum\" contains the number of the last\n\
16279 breakpoint set."),
16280            &maintenanceinfolist);
16281
16282   add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
16283 Set catchpoints to catch events."),
16284                   &catch_cmdlist, "catch ",
16285                   0/*allow-unknown*/, &cmdlist);
16286
16287   add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
16288 Set temporary catchpoints to catch events."),
16289                   &tcatch_cmdlist, "tcatch ",
16290                   0/*allow-unknown*/, &cmdlist);
16291
16292   /* Add catch and tcatch sub-commands.  */
16293   add_catch_command ("catch", _("\
16294 Catch an exception, when caught."),
16295                      catch_catch_command,
16296                      NULL,
16297                      CATCH_PERMANENT,
16298                      CATCH_TEMPORARY);
16299   add_catch_command ("throw", _("\
16300 Catch an exception, when thrown."),
16301                      catch_throw_command,
16302                      NULL,
16303                      CATCH_PERMANENT,
16304                      CATCH_TEMPORARY);
16305   add_catch_command ("fork", _("Catch calls to fork."),
16306                      catch_fork_command_1,
16307                      NULL,
16308                      (void *) (uintptr_t) catch_fork_permanent,
16309                      (void *) (uintptr_t) catch_fork_temporary);
16310   add_catch_command ("vfork", _("Catch calls to vfork."),
16311                      catch_fork_command_1,
16312                      NULL,
16313                      (void *) (uintptr_t) catch_vfork_permanent,
16314                      (void *) (uintptr_t) catch_vfork_temporary);
16315   add_catch_command ("exec", _("Catch calls to exec."),
16316                      catch_exec_command_1,
16317                      NULL,
16318                      CATCH_PERMANENT,
16319                      CATCH_TEMPORARY);
16320   add_catch_command ("load", _("Catch loads of shared libraries.\n\
16321 Usage: catch load [REGEX]\n\
16322 If REGEX is given, only stop for libraries matching the regular expression."),
16323                      catch_load_command_1,
16324                      NULL,
16325                      CATCH_PERMANENT,
16326                      CATCH_TEMPORARY);
16327   add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16328 Usage: catch unload [REGEX]\n\
16329 If REGEX is given, only stop for libraries matching the regular expression."),
16330                      catch_unload_command_1,
16331                      NULL,
16332                      CATCH_PERMANENT,
16333                      CATCH_TEMPORARY);
16334   add_catch_command ("syscall", _("\
16335 Catch system calls by their names and/or numbers.\n\
16336 Arguments say which system calls to catch.  If no arguments\n\
16337 are given, every system call will be caught.\n\
16338 Arguments, if given, should be one or more system call names\n\
16339 (if your system supports that), or system call numbers."),
16340                      catch_syscall_command_1,
16341                      catch_syscall_completer,
16342                      CATCH_PERMANENT,
16343                      CATCH_TEMPORARY);
16344
16345   c = add_com ("watch", class_breakpoint, watch_command, _("\
16346 Set a watchpoint for an expression.\n\
16347 Usage: watch [-l|-location] EXPRESSION\n\
16348 A watchpoint stops execution of your program whenever the value of\n\
16349 an expression changes.\n\
16350 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16351 the memory to which it refers."));
16352   set_cmd_completer (c, expression_completer);
16353
16354   c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
16355 Set a read watchpoint for an expression.\n\
16356 Usage: rwatch [-l|-location] EXPRESSION\n\
16357 A watchpoint stops execution of your program whenever the value of\n\
16358 an expression is read.\n\
16359 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16360 the memory to which it refers."));
16361   set_cmd_completer (c, expression_completer);
16362
16363   c = add_com ("awatch", class_breakpoint, awatch_command, _("\
16364 Set a watchpoint for an expression.\n\
16365 Usage: awatch [-l|-location] EXPRESSION\n\
16366 A watchpoint stops execution of your program whenever the value of\n\
16367 an expression is either read or written.\n\
16368 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16369 the memory to which it refers."));
16370   set_cmd_completer (c, expression_completer);
16371
16372   add_info ("watchpoints", watchpoints_info, _("\
16373 Status of specified watchpoints (all watchpoints if no argument)."));
16374
16375   /* XXX: cagney/2005-02-23: This should be a boolean, and should
16376      respond to changes - contrary to the description.  */
16377   add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
16378                             &can_use_hw_watchpoints, _("\
16379 Set debugger's willingness to use watchpoint hardware."), _("\
16380 Show debugger's willingness to use watchpoint hardware."), _("\
16381 If zero, gdb will not use hardware for new watchpoints, even if\n\
16382 such is available.  (However, any hardware watchpoints that were\n\
16383 created before setting this to nonzero, will continue to use watchpoint\n\
16384 hardware.)"),
16385                             NULL,
16386                             show_can_use_hw_watchpoints,
16387                             &setlist, &showlist);
16388
16389   can_use_hw_watchpoints = 1;
16390
16391   /* Tracepoint manipulation commands.  */
16392
16393   c = add_com ("trace", class_breakpoint, trace_command, _("\
16394 Set a tracepoint at specified line or function.\n\
16395 \n"
16396 BREAK_ARGS_HELP ("trace") "\n\
16397 Do \"help tracepoints\" for info on other tracepoint commands."));
16398   set_cmd_completer (c, location_completer);
16399
16400   add_com_alias ("tp", "trace", class_alias, 0);
16401   add_com_alias ("tr", "trace", class_alias, 1);
16402   add_com_alias ("tra", "trace", class_alias, 1);
16403   add_com_alias ("trac", "trace", class_alias, 1);
16404
16405   c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
16406 Set a fast tracepoint at specified line or function.\n\
16407 \n"
16408 BREAK_ARGS_HELP ("ftrace") "\n\
16409 Do \"help tracepoints\" for info on other tracepoint commands."));
16410   set_cmd_completer (c, location_completer);
16411
16412   c = add_com ("strace", class_breakpoint, strace_command, _("\
16413 Set a static tracepoint at specified line, function or marker.\n\
16414 \n\
16415 strace [LOCATION] [if CONDITION]\n\
16416 LOCATION may be a line number, function name, \"*\" and an address,\n\
16417 or -m MARKER_ID.\n\
16418 If a line number is specified, probe the marker at start of code\n\
16419 for that line.  If a function is specified, probe the marker at start\n\
16420 of code for that function.  If an address is specified, probe the marker\n\
16421 at that exact address.  If a marker id is specified, probe the marker\n\
16422 with that name.  With no LOCATION, uses current execution address of\n\
16423 the selected stack frame.\n\
16424 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16425 This collects arbitrary user data passed in the probe point call to the\n\
16426 tracing library.  You can inspect it when analyzing the trace buffer,\n\
16427 by printing the $_sdata variable like any other convenience variable.\n\
16428 \n\
16429 CONDITION is a boolean expression.\n\
16430 \n\
16431 Multiple tracepoints at one place are permitted, and useful if their\n\
16432 conditions are different.\n\
16433 \n\
16434 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16435 Do \"help tracepoints\" for info on other tracepoint commands."));
16436   set_cmd_completer (c, location_completer);
16437
16438   add_info ("tracepoints", tracepoints_info, _("\
16439 Status of specified tracepoints (all tracepoints if no argument).\n\
16440 Convenience variable \"$tpnum\" contains the number of the\n\
16441 last tracepoint set."));
16442
16443   add_info_alias ("tp", "tracepoints", 1);
16444
16445   add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
16446 Delete specified tracepoints.\n\
16447 Arguments are tracepoint numbers, separated by spaces.\n\
16448 No argument means delete all tracepoints."),
16449            &deletelist);
16450   add_alias_cmd ("tr", "tracepoints", class_trace, 1, &deletelist);
16451
16452   c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
16453 Disable specified tracepoints.\n\
16454 Arguments are tracepoint numbers, separated by spaces.\n\
16455 No argument means disable all tracepoints."),
16456            &disablelist);
16457   deprecate_cmd (c, "disable");
16458
16459   c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
16460 Enable specified tracepoints.\n\
16461 Arguments are tracepoint numbers, separated by spaces.\n\
16462 No argument means enable all tracepoints."),
16463            &enablelist);
16464   deprecate_cmd (c, "enable");
16465
16466   add_com ("passcount", class_trace, trace_pass_command, _("\
16467 Set the passcount for a tracepoint.\n\
16468 The trace will end when the tracepoint has been passed 'count' times.\n\
16469 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16470 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16471
16472   add_prefix_cmd ("save", class_breakpoint, save_command,
16473                   _("Save breakpoint definitions as a script."),
16474                   &save_cmdlist, "save ",
16475                   0/*allow-unknown*/, &cmdlist);
16476
16477   c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
16478 Save current breakpoint definitions as a script.\n\
16479 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16480 catchpoints, tracepoints).  Use the 'source' command in another debug\n\
16481 session to restore them."),
16482                &save_cmdlist);
16483   set_cmd_completer (c, filename_completer);
16484
16485   c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
16486 Save current tracepoint definitions as a script.\n\
16487 Use the 'source' command in another debug session to restore them."),
16488                &save_cmdlist);
16489   set_cmd_completer (c, filename_completer);
16490
16491   c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
16492   deprecate_cmd (c, "save tracepoints");
16493
16494   add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
16495 Breakpoint specific settings\n\
16496 Configure various breakpoint-specific variables such as\n\
16497 pending breakpoint behavior"),
16498                   &breakpoint_set_cmdlist, "set breakpoint ",
16499                   0/*allow-unknown*/, &setlist);
16500   add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
16501 Breakpoint specific settings\n\
16502 Configure various breakpoint-specific variables such as\n\
16503 pending breakpoint behavior"),
16504                   &breakpoint_show_cmdlist, "show breakpoint ",
16505                   0/*allow-unknown*/, &showlist);
16506
16507   add_setshow_auto_boolean_cmd ("pending", no_class,
16508                                 &pending_break_support, _("\
16509 Set debugger's behavior regarding pending breakpoints."), _("\
16510 Show debugger's behavior regarding pending breakpoints."), _("\
16511 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16512 pending breakpoint.  If off, an unrecognized breakpoint location results in\n\
16513 an error.  If auto, an unrecognized breakpoint location results in a\n\
16514 user-query to see if a pending breakpoint should be created."),
16515                                 NULL,
16516                                 show_pending_break_support,
16517                                 &breakpoint_set_cmdlist,
16518                                 &breakpoint_show_cmdlist);
16519
16520   pending_break_support = AUTO_BOOLEAN_AUTO;
16521
16522   add_setshow_boolean_cmd ("auto-hw", no_class,
16523                            &automatic_hardware_breakpoints, _("\
16524 Set automatic usage of hardware breakpoints."), _("\
16525 Show automatic usage of hardware breakpoints."), _("\
16526 If set, the debugger will automatically use hardware breakpoints for\n\
16527 breakpoints set with \"break\" but falling in read-only memory.  If not set,\n\
16528 a warning will be emitted for such breakpoints."),
16529                            NULL,
16530                            show_automatic_hardware_breakpoints,
16531                            &breakpoint_set_cmdlist,
16532                            &breakpoint_show_cmdlist);
16533
16534   add_setshow_auto_boolean_cmd ("always-inserted", class_support,
16535                                 &always_inserted_mode, _("\
16536 Set mode for inserting breakpoints."), _("\
16537 Show mode for inserting breakpoints."), _("\
16538 When this mode is off, breakpoints are inserted in inferior when it is\n\
16539 resumed, and removed when execution stops.  When this mode is on,\n\
16540 breakpoints are inserted immediately and removed only when the user\n\
16541 deletes the breakpoint.  When this mode is auto (which is the default),\n\
16542 the behaviour depends on the non-stop setting (see help set non-stop).\n\
16543 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
16544 behaves as if always-inserted mode is on; if gdb is controlling the\n\
16545 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
16546                                 NULL,
16547                                 &show_always_inserted_mode,
16548                                 &breakpoint_set_cmdlist,
16549                                 &breakpoint_show_cmdlist);
16550
16551   add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
16552                         condition_evaluation_enums,
16553                         &condition_evaluation_mode_1, _("\
16554 Set mode of breakpoint condition evaluation."), _("\
16555 Show mode of breakpoint condition evaluation."), _("\
16556 When this is set to \"host\", breakpoint conditions will be\n\
16557 evaluated on the host's side by GDB.  When it is set to \"target\",\n\
16558 breakpoint conditions will be downloaded to the target (if the target\n\
16559 supports such feature) and conditions will be evaluated on the target's side.\n\
16560 If this is set to \"auto\" (default), this will be automatically set to\n\
16561 \"target\" if it supports condition evaluation, otherwise it will\n\
16562 be set to \"gdb\""),
16563                            &set_condition_evaluation_mode,
16564                            &show_condition_evaluation_mode,
16565                            &breakpoint_set_cmdlist,
16566                            &breakpoint_show_cmdlist);
16567
16568   add_com ("break-range", class_breakpoint, break_range_command, _("\
16569 Set a breakpoint for an address range.\n\
16570 break-range START-LOCATION, END-LOCATION\n\
16571 where START-LOCATION and END-LOCATION can be one of the following:\n\
16572   LINENUM, for that line in the current file,\n\
16573   FILE:LINENUM, for that line in that file,\n\
16574   +OFFSET, for that number of lines after the current line\n\
16575            or the start of the range\n\
16576   FUNCTION, for the first line in that function,\n\
16577   FILE:FUNCTION, to distinguish among like-named static functions.\n\
16578   *ADDRESS, for the instruction at that address.\n\
16579 \n\
16580 The breakpoint will stop execution of the inferior whenever it executes\n\
16581 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16582 range (including START-LOCATION and END-LOCATION)."));
16583
16584   c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
16585 Set a dynamic printf at specified line or function.\n\
16586 dprintf location,format string,arg1,arg2,...\n\
16587 location may be a line number, function name, or \"*\" and an address.\n\
16588 If a line number is specified, break at start of code for that line.\n\
16589 If a function is specified, break at start of code for that function.\n\
16590 "));
16591   set_cmd_completer (c, location_completer);
16592
16593   add_setshow_enum_cmd ("dprintf-style", class_support,
16594                         dprintf_style_enums, &dprintf_style, _("\
16595 Set the style of usage for dynamic printf."), _("\
16596 Show the style of usage for dynamic printf."), _("\
16597 This setting chooses how GDB will do a dynamic printf.\n\
16598 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16599 console, as with the \"printf\" command.\n\
16600 If the value is \"call\", the print is done by calling a function in your\n\
16601 program; by default printf(), but you can choose a different function or\n\
16602 output stream by setting dprintf-function and dprintf-channel."),
16603                         update_dprintf_commands, NULL,
16604                         &setlist, &showlist);
16605
16606   dprintf_function = xstrdup ("printf");
16607   add_setshow_string_cmd ("dprintf-function", class_support,
16608                           &dprintf_function, _("\
16609 Set the function to use for dynamic printf"), _("\
16610 Show the function to use for dynamic printf"), NULL,
16611                           update_dprintf_commands, NULL,
16612                           &setlist, &showlist);
16613
16614   dprintf_channel = xstrdup ("");
16615   add_setshow_string_cmd ("dprintf-channel", class_support,
16616                           &dprintf_channel, _("\
16617 Set the channel to use for dynamic printf"), _("\
16618 Show the channel to use for dynamic printf"), NULL,
16619                           update_dprintf_commands, NULL,
16620                           &setlist, &showlist);
16621
16622   add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
16623                            &disconnected_dprintf, _("\
16624 Set whether dprintf continues after GDB disconnects."), _("\
16625 Show whether dprintf continues after GDB disconnects."), _("\
16626 Use this to let dprintf commands continue to hit and produce output\n\
16627 even if GDB disconnects or detaches from the target."),
16628                            NULL,
16629                            NULL,
16630                            &setlist, &showlist);
16631
16632   add_com ("agent-printf", class_vars, agent_printf_command, _("\
16633 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16634 (target agent only) This is useful for formatted output in user-defined commands."));
16635
16636   automatic_hardware_breakpoints = 1;
16637
16638   observer_attach_about_to_proceed (breakpoint_about_to_proceed);
16639 }