* breakpoint.c (catch_syscall_completer): Pass 'word' as second
[platform/upstream/binutils.git] / gdb / breakpoint.c
1 /* Everything about breakpoints, for GDB.
2
3    Copyright (C) 1986-2012 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 /* Prototypes for local functions.  */
86
87 static void enable_delete_command (char *, int);
88
89 static void enable_once_command (char *, int);
90
91 static void enable_count_command (char *, int);
92
93 static void disable_command (char *, int);
94
95 static void enable_command (char *, int);
96
97 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint *,
98                                                       void *),
99                                     void *);
100
101 static void ignore_command (char *, int);
102
103 static int breakpoint_re_set_one (void *);
104
105 static void breakpoint_re_set_default (struct breakpoint *);
106
107 static void create_sals_from_address_default (char **,
108                                               struct linespec_result *,
109                                               enum bptype, char *,
110                                               char **);
111
112 static void create_breakpoints_sal_default (struct gdbarch *,
113                                             struct linespec_result *,
114                                             struct linespec_sals *,
115                                             char *, char *, enum bptype,
116                                             enum bpdisp, int, int,
117                                             int,
118                                             const struct breakpoint_ops *,
119                                             int, int, int, unsigned);
120
121 static void decode_linespec_default (struct breakpoint *, char **,
122                                      struct symtabs_and_lines *);
123
124 static void clear_command (char *, int);
125
126 static void catch_command (char *, int);
127
128 static int can_use_hardware_watchpoint (struct value *);
129
130 static void break_command_1 (char *, int, int);
131
132 static void mention (struct breakpoint *);
133
134 static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
135                                                                enum bptype,
136                                                                const struct breakpoint_ops *);
137 static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
138                                                        const struct symtab_and_line *);
139
140 /* This function is used in gdbtk sources and thus can not be made
141    static.  */
142 struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
143                                        struct symtab_and_line,
144                                        enum bptype,
145                                        const struct breakpoint_ops *);
146
147 static struct breakpoint *
148   momentary_breakpoint_from_master (struct breakpoint *orig,
149                                     enum bptype type,
150                                     const struct breakpoint_ops *ops);
151
152 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
153
154 static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
155                                             CORE_ADDR bpaddr,
156                                             enum bptype bptype);
157
158 static void describe_other_breakpoints (struct gdbarch *,
159                                         struct program_space *, CORE_ADDR,
160                                         struct obj_section *, int);
161
162 static int breakpoint_address_match (struct address_space *aspace1,
163                                      CORE_ADDR addr1,
164                                      struct address_space *aspace2,
165                                      CORE_ADDR addr2);
166
167 static int watchpoint_locations_match (struct bp_location *loc1,
168                                        struct bp_location *loc2);
169
170 static int breakpoint_location_address_match (struct bp_location *bl,
171                                               struct address_space *aspace,
172                                               CORE_ADDR addr);
173
174 static void breakpoints_info (char *, int);
175
176 static void watchpoints_info (char *, int);
177
178 static int breakpoint_1 (char *, int, 
179                          int (*) (const struct breakpoint *));
180
181 static int breakpoint_cond_eval (void *);
182
183 static void cleanup_executing_breakpoints (void *);
184
185 static void commands_command (char *, int);
186
187 static void condition_command (char *, int);
188
189 typedef enum
190   {
191     mark_inserted,
192     mark_uninserted
193   }
194 insertion_state_t;
195
196 static int remove_breakpoint (struct bp_location *, insertion_state_t);
197 static int remove_breakpoint_1 (struct bp_location *, insertion_state_t);
198
199 static enum print_stop_action print_bp_stop_message (bpstat bs);
200
201 static int watchpoint_check (void *);
202
203 static void maintenance_info_breakpoints (char *, int);
204
205 static int hw_breakpoint_used_count (void);
206
207 static int hw_watchpoint_use_count (struct breakpoint *);
208
209 static int hw_watchpoint_used_count_others (struct breakpoint *except,
210                                             enum bptype type,
211                                             int *other_type_used);
212
213 static void hbreak_command (char *, int);
214
215 static void thbreak_command (char *, int);
216
217 static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
218                                     int count);
219
220 static void stop_command (char *arg, int from_tty);
221
222 static void stopin_command (char *arg, int from_tty);
223
224 static void stopat_command (char *arg, int from_tty);
225
226 static char *ep_parse_optional_if_clause (char **arg);
227
228 static void catch_exception_command_1 (enum exception_event_kind ex_event, 
229                                        char *arg, int tempflag, int from_tty);
230
231 static void tcatch_command (char *arg, int from_tty);
232
233 static void detach_single_step_breakpoints (void);
234
235 static int single_step_breakpoint_inserted_here_p (struct address_space *,
236                                                    CORE_ADDR pc);
237
238 static void free_bp_location (struct bp_location *loc);
239 static void incref_bp_location (struct bp_location *loc);
240 static void decref_bp_location (struct bp_location **loc);
241
242 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
243
244 static void update_global_location_list (int);
245
246 static void update_global_location_list_nothrow (int);
247
248 static int is_hardware_watchpoint (const struct breakpoint *bpt);
249
250 static void insert_breakpoint_locations (void);
251
252 static int syscall_catchpoint_p (struct breakpoint *b);
253
254 static void tracepoints_info (char *, int);
255
256 static void delete_trace_command (char *, int);
257
258 static void enable_trace_command (char *, int);
259
260 static void disable_trace_command (char *, int);
261
262 static void trace_pass_command (char *, int);
263
264 static int is_masked_watchpoint (const struct breakpoint *b);
265
266 static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
267
268 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
269    otherwise.  */
270
271 static int strace_marker_p (struct breakpoint *b);
272
273 static void init_catchpoint (struct breakpoint *b,
274                              struct gdbarch *gdbarch, int tempflag,
275                              char *cond_string,
276                              const struct breakpoint_ops *ops);
277
278 /* The abstract base class all breakpoint_ops structures inherit
279    from.  */
280 static struct breakpoint_ops base_breakpoint_ops;
281
282 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
283    that are implemented on top of software or hardware breakpoints
284    (user breakpoints, internal and momentary breakpoints, etc.).  */
285 static struct breakpoint_ops bkpt_base_breakpoint_ops;
286
287 /* Internal breakpoints class type.  */
288 static struct breakpoint_ops internal_breakpoint_ops;
289
290 /* Momentary breakpoints class type.  */
291 static struct breakpoint_ops momentary_breakpoint_ops;
292
293 /* Momentary breakpoints for bp_longjmp and bp_exception class type.  */
294 static struct breakpoint_ops longjmp_breakpoint_ops;
295
296 /* The breakpoint_ops structure to be used in regular user created
297    breakpoints.  */
298 struct breakpoint_ops bkpt_breakpoint_ops;
299
300 /* Breakpoints set on probes.  */
301 static struct breakpoint_ops bkpt_probe_breakpoint_ops;
302
303 /* Dynamic printf class type.  */
304 static struct breakpoint_ops dprintf_breakpoint_ops;
305
306 /* The style in which to perform a dynamic printf.  This is a user
307    option because different output options have different tradeoffs;
308    if GDB does the printing, there is better error handling if there
309    is a problem with any of the arguments, but using an inferior
310    function lets you have special-purpose printers and sending of
311    output to the same place as compiled-in print functions.  */
312
313 static const char dprintf_style_gdb[] = "gdb";
314 static const char dprintf_style_call[] = "call";
315 static const char dprintf_style_agent[] = "agent";
316 static const char *const dprintf_style_enums[] = {
317   dprintf_style_gdb,
318   dprintf_style_call,
319   dprintf_style_agent,
320   NULL
321 };
322 static const char *dprintf_style = dprintf_style_gdb;
323
324 /* The function to use for dynamic printf if the preferred style is to
325    call into the inferior.  The value is simply a string that is
326    copied into the command, so it can be anything that GDB can
327    evaluate to a callable address, not necessarily a function name.  */
328
329 static char *dprintf_function = "";
330
331 /* The channel to use for dynamic printf if the preferred style is to
332    call into the inferior; if a nonempty string, it will be passed to
333    the call as the first argument, with the format string as the
334    second.  As with the dprintf function, this can be anything that
335    GDB knows how to evaluate, so in addition to common choices like
336    "stderr", this could be an app-specific expression like
337    "mystreams[curlogger]".  */
338
339 static char *dprintf_channel = "";
340
341 /* True if dprintf commands should continue to operate even if GDB
342    has disconnected.  */
343 static int disconnected_dprintf = 1;
344
345 /* A reference-counted struct command_line.  This lets multiple
346    breakpoints share a single command list.  */
347 struct counted_command_line
348 {
349   /* The reference count.  */
350   int refc;
351
352   /* The command list.  */
353   struct command_line *commands;
354 };
355
356 struct command_line *
357 breakpoint_commands (struct breakpoint *b)
358 {
359   return b->commands ? b->commands->commands : NULL;
360 }
361
362 /* Flag indicating that a command has proceeded the inferior past the
363    current breakpoint.  */
364
365 static int breakpoint_proceeded;
366
367 const char *
368 bpdisp_text (enum bpdisp disp)
369 {
370   /* NOTE: the following values are a part of MI protocol and
371      represent values of 'disp' field returned when inferior stops at
372      a breakpoint.  */
373   static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
374
375   return bpdisps[(int) disp];
376 }
377
378 /* Prototypes for exported functions.  */
379 /* If FALSE, gdb will not use hardware support for watchpoints, even
380    if such is available.  */
381 static int can_use_hw_watchpoints;
382
383 static void
384 show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
385                              struct cmd_list_element *c,
386                              const char *value)
387 {
388   fprintf_filtered (file,
389                     _("Debugger's willingness to use "
390                       "watchpoint hardware is %s.\n"),
391                     value);
392 }
393
394 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
395    If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
396    for unrecognized breakpoint locations.
397    If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized.  */
398 static enum auto_boolean pending_break_support;
399 static void
400 show_pending_break_support (struct ui_file *file, int from_tty,
401                             struct cmd_list_element *c,
402                             const char *value)
403 {
404   fprintf_filtered (file,
405                     _("Debugger's behavior regarding "
406                       "pending breakpoints is %s.\n"),
407                     value);
408 }
409
410 /* If 1, gdb will automatically use hardware breakpoints for breakpoints
411    set with "break" but falling in read-only memory.
412    If 0, gdb will warn about such breakpoints, but won't automatically
413    use hardware breakpoints.  */
414 static int automatic_hardware_breakpoints;
415 static void
416 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
417                                      struct cmd_list_element *c,
418                                      const char *value)
419 {
420   fprintf_filtered (file,
421                     _("Automatic usage of hardware breakpoints is %s.\n"),
422                     value);
423 }
424
425 /* If on, gdb will keep breakpoints inserted even as inferior is
426    stopped, and immediately insert any new breakpoints.  If off, gdb
427    will insert breakpoints into inferior only when resuming it, and
428    will remove breakpoints upon stop.  If auto, GDB will behave as ON
429    if in non-stop mode, and as OFF if all-stop mode.*/
430
431 static enum auto_boolean always_inserted_mode = AUTO_BOOLEAN_AUTO;
432
433 static void
434 show_always_inserted_mode (struct ui_file *file, int from_tty,
435                      struct cmd_list_element *c, const char *value)
436 {
437   if (always_inserted_mode == AUTO_BOOLEAN_AUTO)
438     fprintf_filtered (file,
439                       _("Always inserted breakpoint "
440                         "mode is %s (currently %s).\n"),
441                       value,
442                       breakpoints_always_inserted_mode () ? "on" : "off");
443   else
444     fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
445                       value);
446 }
447
448 int
449 breakpoints_always_inserted_mode (void)
450 {
451   return (always_inserted_mode == AUTO_BOOLEAN_TRUE
452           || (always_inserted_mode == AUTO_BOOLEAN_AUTO && non_stop));
453 }
454
455 static const char condition_evaluation_both[] = "host or target";
456
457 /* Modes for breakpoint condition evaluation.  */
458 static const char condition_evaluation_auto[] = "auto";
459 static const char condition_evaluation_host[] = "host";
460 static const char condition_evaluation_target[] = "target";
461 static const char *const condition_evaluation_enums[] = {
462   condition_evaluation_auto,
463   condition_evaluation_host,
464   condition_evaluation_target,
465   NULL
466 };
467
468 /* Global that holds the current mode for breakpoint condition evaluation.  */
469 static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
470
471 /* Global that we use to display information to the user (gets its value from
472    condition_evaluation_mode_1.  */
473 static const char *condition_evaluation_mode = condition_evaluation_auto;
474
475 /* Translate a condition evaluation mode MODE into either "host"
476    or "target".  This is used mostly to translate from "auto" to the
477    real setting that is being used.  It returns the translated
478    evaluation mode.  */
479
480 static const char *
481 translate_condition_evaluation_mode (const char *mode)
482 {
483   if (mode == condition_evaluation_auto)
484     {
485       if (target_supports_evaluation_of_breakpoint_conditions ())
486         return condition_evaluation_target;
487       else
488         return condition_evaluation_host;
489     }
490   else
491     return mode;
492 }
493
494 /* Discovers what condition_evaluation_auto translates to.  */
495
496 static const char *
497 breakpoint_condition_evaluation_mode (void)
498 {
499   return translate_condition_evaluation_mode (condition_evaluation_mode);
500 }
501
502 /* Return true if GDB should evaluate breakpoint conditions or false
503    otherwise.  */
504
505 static int
506 gdb_evaluates_breakpoint_condition_p (void)
507 {
508   const char *mode = breakpoint_condition_evaluation_mode ();
509
510   return (mode == condition_evaluation_host);
511 }
512
513 void _initialize_breakpoint (void);
514
515 /* Are we executing breakpoint commands?  */
516 static int executing_breakpoint_commands;
517
518 /* Are overlay event breakpoints enabled? */
519 static int overlay_events_enabled;
520
521 /* See description in breakpoint.h. */
522 int target_exact_watchpoints = 0;
523
524 /* Walk the following statement or block through all breakpoints.
525    ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
526    current breakpoint.  */
527
528 #define ALL_BREAKPOINTS(B)  for (B = breakpoint_chain; B; B = B->next)
529
530 #define ALL_BREAKPOINTS_SAFE(B,TMP)     \
531         for (B = breakpoint_chain;      \
532              B ? (TMP=B->next, 1): 0;   \
533              B = TMP)
534
535 /* Similar iterator for the low-level breakpoints.  SAFE variant is
536    not provided so update_global_location_list must not be called
537    while executing the block of ALL_BP_LOCATIONS.  */
538
539 #define ALL_BP_LOCATIONS(B,BP_TMP)                                      \
540         for (BP_TMP = bp_location;                                      \
541              BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
542              BP_TMP++)
543
544 /* Iterates through locations with address ADDRESS for the currently selected
545    program space.  BP_LOCP_TMP points to each object.  BP_LOCP_START points
546    to where the loop should start from.
547    If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
548    appropriate location to start with.  */
549
550 #define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS)   \
551         for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
552              BP_LOCP_TMP = BP_LOCP_START;                               \
553              BP_LOCP_START                                              \
554              && (BP_LOCP_TMP < bp_location + bp_location_count          \
555              && (*BP_LOCP_TMP)->address == ADDRESS);                    \
556              BP_LOCP_TMP++)
557
558 /* Iterator for tracepoints only.  */
559
560 #define ALL_TRACEPOINTS(B)  \
561   for (B = breakpoint_chain; B; B = B->next)  \
562     if (is_tracepoint (B))
563
564 /* Chains of all breakpoints defined.  */
565
566 struct breakpoint *breakpoint_chain;
567
568 /* Array is sorted by bp_location_compare - primarily by the ADDRESS.  */
569
570 static struct bp_location **bp_location;
571
572 /* Number of elements of BP_LOCATION.  */
573
574 static unsigned bp_location_count;
575
576 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
577    ADDRESS for the current elements of BP_LOCATION which get a valid
578    result from bp_location_has_shadow.  You can use it for roughly
579    limiting the subrange of BP_LOCATION to scan for shadow bytes for
580    an address you need to read.  */
581
582 static CORE_ADDR bp_location_placed_address_before_address_max;
583
584 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
585    + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
586    BP_LOCATION which get a valid result from bp_location_has_shadow.
587    You can use it for roughly limiting the subrange of BP_LOCATION to
588    scan for shadow bytes for an address you need to read.  */
589
590 static CORE_ADDR bp_location_shadow_len_after_address_max;
591
592 /* The locations that no longer correspond to any breakpoint, unlinked
593    from bp_location array, but for which a hit may still be reported
594    by a target.  */
595 VEC(bp_location_p) *moribund_locations = NULL;
596
597 /* Number of last breakpoint made.  */
598
599 static int breakpoint_count;
600
601 /* The value of `breakpoint_count' before the last command that
602    created breakpoints.  If the last (break-like) command created more
603    than one breakpoint, then the difference between BREAKPOINT_COUNT
604    and PREV_BREAKPOINT_COUNT is more than one.  */
605 static int prev_breakpoint_count;
606
607 /* Number of last tracepoint made.  */
608
609 static int tracepoint_count;
610
611 static struct cmd_list_element *breakpoint_set_cmdlist;
612 static struct cmd_list_element *breakpoint_show_cmdlist;
613 struct cmd_list_element *save_cmdlist;
614
615 /* Return whether a breakpoint is an active enabled breakpoint.  */
616 static int
617 breakpoint_enabled (struct breakpoint *b)
618 {
619   return (b->enable_state == bp_enabled);
620 }
621
622 /* Set breakpoint count to NUM.  */
623
624 static void
625 set_breakpoint_count (int num)
626 {
627   prev_breakpoint_count = breakpoint_count;
628   breakpoint_count = num;
629   set_internalvar_integer (lookup_internalvar ("bpnum"), num);
630 }
631
632 /* Used by `start_rbreak_breakpoints' below, to record the current
633    breakpoint count before "rbreak" creates any breakpoint.  */
634 static int rbreak_start_breakpoint_count;
635
636 /* Called at the start an "rbreak" command to record the first
637    breakpoint made.  */
638
639 void
640 start_rbreak_breakpoints (void)
641 {
642   rbreak_start_breakpoint_count = breakpoint_count;
643 }
644
645 /* Called at the end of an "rbreak" command to record the last
646    breakpoint made.  */
647
648 void
649 end_rbreak_breakpoints (void)
650 {
651   prev_breakpoint_count = rbreak_start_breakpoint_count;
652 }
653
654 /* Used in run_command to zero the hit count when a new run starts.  */
655
656 void
657 clear_breakpoint_hit_counts (void)
658 {
659   struct breakpoint *b;
660
661   ALL_BREAKPOINTS (b)
662     b->hit_count = 0;
663 }
664
665 /* Allocate a new counted_command_line with reference count of 1.
666    The new structure owns COMMANDS.  */
667
668 static struct counted_command_line *
669 alloc_counted_command_line (struct command_line *commands)
670 {
671   struct counted_command_line *result
672     = xmalloc (sizeof (struct counted_command_line));
673
674   result->refc = 1;
675   result->commands = commands;
676   return result;
677 }
678
679 /* Increment reference count.  This does nothing if CMD is NULL.  */
680
681 static void
682 incref_counted_command_line (struct counted_command_line *cmd)
683 {
684   if (cmd)
685     ++cmd->refc;
686 }
687
688 /* Decrement reference count.  If the reference count reaches 0,
689    destroy the counted_command_line.  Sets *CMDP to NULL.  This does
690    nothing if *CMDP is NULL.  */
691
692 static void
693 decref_counted_command_line (struct counted_command_line **cmdp)
694 {
695   if (*cmdp)
696     {
697       if (--(*cmdp)->refc == 0)
698         {
699           free_command_lines (&(*cmdp)->commands);
700           xfree (*cmdp);
701         }
702       *cmdp = NULL;
703     }
704 }
705
706 /* A cleanup function that calls decref_counted_command_line.  */
707
708 static void
709 do_cleanup_counted_command_line (void *arg)
710 {
711   decref_counted_command_line (arg);
712 }
713
714 /* Create a cleanup that calls decref_counted_command_line on the
715    argument.  */
716
717 static struct cleanup *
718 make_cleanup_decref_counted_command_line (struct counted_command_line **cmdp)
719 {
720   return make_cleanup (do_cleanup_counted_command_line, cmdp);
721 }
722
723 \f
724 /* Return the breakpoint with the specified number, or NULL
725    if the number does not refer to an existing breakpoint.  */
726
727 struct breakpoint *
728 get_breakpoint (int num)
729 {
730   struct breakpoint *b;
731
732   ALL_BREAKPOINTS (b)
733     if (b->number == num)
734       return b;
735   
736   return NULL;
737 }
738
739 \f
740
741 /* Mark locations as "conditions have changed" in case the target supports
742    evaluating conditions on its side.  */
743
744 static void
745 mark_breakpoint_modified (struct breakpoint *b)
746 {
747   struct bp_location *loc;
748
749   /* This is only meaningful if the target is
750      evaluating conditions and if the user has
751      opted for condition evaluation on the target's
752      side.  */
753   if (gdb_evaluates_breakpoint_condition_p ()
754       || !target_supports_evaluation_of_breakpoint_conditions ())
755     return;
756
757   if (!is_breakpoint (b))
758     return;
759
760   for (loc = b->loc; loc; loc = loc->next)
761     loc->condition_changed = condition_modified;
762 }
763
764 /* Mark location as "conditions have changed" in case the target supports
765    evaluating conditions on its side.  */
766
767 static void
768 mark_breakpoint_location_modified (struct bp_location *loc)
769 {
770   /* This is only meaningful if the target is
771      evaluating conditions and if the user has
772      opted for condition evaluation on the target's
773      side.  */
774   if (gdb_evaluates_breakpoint_condition_p ()
775       || !target_supports_evaluation_of_breakpoint_conditions ())
776
777     return;
778
779   if (!is_breakpoint (loc->owner))
780     return;
781
782   loc->condition_changed = condition_modified;
783 }
784
785 /* Sets the condition-evaluation mode using the static global
786    condition_evaluation_mode.  */
787
788 static void
789 set_condition_evaluation_mode (char *args, int from_tty,
790                                struct cmd_list_element *c)
791 {
792   const char *old_mode, *new_mode;
793
794   if ((condition_evaluation_mode_1 == condition_evaluation_target)
795       && !target_supports_evaluation_of_breakpoint_conditions ())
796     {
797       condition_evaluation_mode_1 = condition_evaluation_mode;
798       warning (_("Target does not support breakpoint condition evaluation.\n"
799                  "Using host evaluation mode instead."));
800       return;
801     }
802
803   new_mode = translate_condition_evaluation_mode (condition_evaluation_mode_1);
804   old_mode = translate_condition_evaluation_mode (condition_evaluation_mode);
805
806   /* Flip the switch.  Flip it even if OLD_MODE == NEW_MODE as one of the
807      settings was "auto".  */
808   condition_evaluation_mode = condition_evaluation_mode_1;
809
810   /* Only update the mode if the user picked a different one.  */
811   if (new_mode != old_mode)
812     {
813       struct bp_location *loc, **loc_tmp;
814       /* If the user switched to a different evaluation mode, we
815          need to synch the changes with the target as follows:
816
817          "host" -> "target": Send all (valid) conditions to the target.
818          "target" -> "host": Remove all the conditions from the target.
819       */
820
821       if (new_mode == condition_evaluation_target)
822         {
823           /* Mark everything modified and synch conditions with the
824              target.  */
825           ALL_BP_LOCATIONS (loc, loc_tmp)
826             mark_breakpoint_location_modified (loc);
827         }
828       else
829         {
830           /* Manually mark non-duplicate locations to synch conditions
831              with the target.  We do this to remove all the conditions the
832              target knows about.  */
833           ALL_BP_LOCATIONS (loc, loc_tmp)
834             if (is_breakpoint (loc->owner) && loc->inserted)
835               loc->needs_update = 1;
836         }
837
838       /* Do the update.  */
839       update_global_location_list (1);
840     }
841
842   return;
843 }
844
845 /* Shows the current mode of breakpoint condition evaluation.  Explicitly shows
846    what "auto" is translating to.  */
847
848 static void
849 show_condition_evaluation_mode (struct ui_file *file, int from_tty,
850                                 struct cmd_list_element *c, const char *value)
851 {
852   if (condition_evaluation_mode == condition_evaluation_auto)
853     fprintf_filtered (file,
854                       _("Breakpoint condition evaluation "
855                         "mode is %s (currently %s).\n"),
856                       value,
857                       breakpoint_condition_evaluation_mode ());
858   else
859     fprintf_filtered (file, _("Breakpoint condition evaluation mode is %s.\n"),
860                       value);
861 }
862
863 /* A comparison function for bp_location AP and BP that is used by
864    bsearch.  This comparison function only cares about addresses, unlike
865    the more general bp_location_compare function.  */
866
867 static int
868 bp_location_compare_addrs (const void *ap, const void *bp)
869 {
870   struct bp_location *a = *(void **) ap;
871   struct bp_location *b = *(void **) bp;
872
873   if (a->address == b->address)
874     return 0;
875   else
876     return ((a->address > b->address) - (a->address < b->address));
877 }
878
879 /* Helper function to skip all bp_locations with addresses
880    less than ADDRESS.  It returns the first bp_location that
881    is greater than or equal to ADDRESS.  If none is found, just
882    return NULL.  */
883
884 static struct bp_location **
885 get_first_locp_gte_addr (CORE_ADDR address)
886 {
887   struct bp_location dummy_loc;
888   struct bp_location *dummy_locp = &dummy_loc;
889   struct bp_location **locp_found = NULL;
890
891   /* Initialize the dummy location's address field.  */
892   memset (&dummy_loc, 0, sizeof (struct bp_location));
893   dummy_loc.address = address;
894
895   /* Find a close match to the first location at ADDRESS.  */
896   locp_found = bsearch (&dummy_locp, bp_location, bp_location_count,
897                         sizeof (struct bp_location **),
898                         bp_location_compare_addrs);
899
900   /* Nothing was found, nothing left to do.  */
901   if (locp_found == NULL)
902     return NULL;
903
904   /* We may have found a location that is at ADDRESS but is not the first in the
905      location's list.  Go backwards (if possible) and locate the first one.  */
906   while ((locp_found - 1) >= bp_location
907          && (*(locp_found - 1))->address == address)
908     locp_found--;
909
910   return locp_found;
911 }
912
913 void
914 set_breakpoint_condition (struct breakpoint *b, char *exp,
915                           int from_tty)
916 {
917   xfree (b->cond_string);
918   b->cond_string = NULL;
919
920   if (is_watchpoint (b))
921     {
922       struct watchpoint *w = (struct watchpoint *) b;
923
924       xfree (w->cond_exp);
925       w->cond_exp = NULL;
926     }
927   else
928     {
929       struct bp_location *loc;
930
931       for (loc = b->loc; loc; loc = loc->next)
932         {
933           xfree (loc->cond);
934           loc->cond = NULL;
935
936           /* No need to free the condition agent expression
937              bytecode (if we have one).  We will handle this
938              when we go through update_global_location_list.  */
939         }
940     }
941
942   if (*exp == 0)
943     {
944       if (from_tty)
945         printf_filtered (_("Breakpoint %d now unconditional.\n"), b->number);
946     }
947   else
948     {
949       char *arg = exp;
950
951       /* I don't know if it matters whether this is the string the user
952          typed in or the decompiled expression.  */
953       b->cond_string = xstrdup (arg);
954       b->condition_not_parsed = 0;
955
956       if (is_watchpoint (b))
957         {
958           struct watchpoint *w = (struct watchpoint *) b;
959
960           innermost_block = NULL;
961           arg = exp;
962           w->cond_exp = parse_exp_1 (&arg, 0, 0, 0);
963           if (*arg)
964             error (_("Junk at end of expression"));
965           w->cond_exp_valid_block = innermost_block;
966         }
967       else
968         {
969           struct bp_location *loc;
970
971           for (loc = b->loc; loc; loc = loc->next)
972             {
973               arg = exp;
974               loc->cond =
975                 parse_exp_1 (&arg, loc->address,
976                              block_for_pc (loc->address), 0);
977               if (*arg)
978                 error (_("Junk at end of expression"));
979             }
980         }
981     }
982   mark_breakpoint_modified (b);
983
984   breakpoints_changed ();
985   observer_notify_breakpoint_modified (b);
986 }
987
988 /* Completion for the "condition" command.  */
989
990 static VEC (char_ptr) *
991 condition_completer (struct cmd_list_element *cmd, char *text, char *word)
992 {
993   char *space;
994
995   text = skip_spaces (text);
996   space = skip_to_space (text);
997   if (*space == '\0')
998     {
999       int len;
1000       struct breakpoint *b;
1001       VEC (char_ptr) *result = NULL;
1002
1003       if (text[0] == '$')
1004         {
1005           /* We don't support completion of history indices.  */
1006           if (isdigit (text[1]))
1007             return NULL;
1008           return complete_internalvar (&text[1]);
1009         }
1010
1011       /* We're completing the breakpoint number.  */
1012       len = strlen (text);
1013
1014       ALL_BREAKPOINTS (b)
1015       {
1016         int single = b->loc->next == NULL;
1017         struct bp_location *loc;
1018         int count = 1;
1019
1020         for (loc = b->loc; loc; loc = loc->next)
1021           {
1022             char location[50];
1023
1024             if (single)
1025               sprintf (location, "%d", b->number);
1026             else
1027               sprintf (location, "%d.%d", b->number, count);
1028
1029             if (strncmp (location, text, len) == 0)
1030               VEC_safe_push (char_ptr, result, xstrdup (location));
1031
1032             ++count;
1033           }
1034       }
1035
1036       return result;
1037     }
1038
1039   /* We're completing the expression part.  */
1040   text = skip_spaces (space);
1041   return expression_completer (cmd, text, word);
1042 }
1043
1044 /* condition N EXP -- set break condition of breakpoint N to EXP.  */
1045
1046 static void
1047 condition_command (char *arg, int from_tty)
1048 {
1049   struct breakpoint *b;
1050   char *p;
1051   int bnum;
1052
1053   if (arg == 0)
1054     error_no_arg (_("breakpoint number"));
1055
1056   p = arg;
1057   bnum = get_number (&p);
1058   if (bnum == 0)
1059     error (_("Bad breakpoint argument: '%s'"), arg);
1060
1061   ALL_BREAKPOINTS (b)
1062     if (b->number == bnum)
1063       {
1064         /* Check if this breakpoint has a Python object assigned to
1065            it, and if it has a definition of the "stop"
1066            method.  This method and conditions entered into GDB from
1067            the CLI are mutually exclusive.  */
1068         if (b->py_bp_object
1069             && gdbpy_breakpoint_has_py_cond (b->py_bp_object))
1070           error (_("Cannot set a condition where a Python 'stop' "
1071                    "method has been defined in the breakpoint."));
1072         set_breakpoint_condition (b, p, from_tty);
1073
1074         if (is_breakpoint (b))
1075           update_global_location_list (1);
1076
1077         return;
1078       }
1079
1080   error (_("No breakpoint number %d."), bnum);
1081 }
1082
1083 /* Check that COMMAND do not contain commands that are suitable
1084    only for tracepoints and not suitable for ordinary breakpoints.
1085    Throw if any such commands is found.  */
1086
1087 static void
1088 check_no_tracepoint_commands (struct command_line *commands)
1089 {
1090   struct command_line *c;
1091
1092   for (c = commands; c; c = c->next)
1093     {
1094       int i;
1095
1096       if (c->control_type == while_stepping_control)
1097         error (_("The 'while-stepping' command can "
1098                  "only be used for tracepoints"));
1099
1100       for (i = 0; i < c->body_count; ++i)
1101         check_no_tracepoint_commands ((c->body_list)[i]);
1102
1103       /* Not that command parsing removes leading whitespace and comment
1104          lines and also empty lines.  So, we only need to check for
1105          command directly.  */
1106       if (strstr (c->line, "collect ") == c->line)
1107         error (_("The 'collect' command can only be used for tracepoints"));
1108
1109       if (strstr (c->line, "teval ") == c->line)
1110         error (_("The 'teval' command can only be used for tracepoints"));
1111     }
1112 }
1113
1114 /* Encapsulate tests for different types of tracepoints.  */
1115
1116 static int
1117 is_tracepoint_type (enum bptype type)
1118 {
1119   return (type == bp_tracepoint
1120           || type == bp_fast_tracepoint
1121           || type == bp_static_tracepoint);
1122 }
1123
1124 int
1125 is_tracepoint (const struct breakpoint *b)
1126 {
1127   return is_tracepoint_type (b->type);
1128 }
1129
1130 /* A helper function that validates that COMMANDS are valid for a
1131    breakpoint.  This function will throw an exception if a problem is
1132    found.  */
1133
1134 static void
1135 validate_commands_for_breakpoint (struct breakpoint *b,
1136                                   struct command_line *commands)
1137 {
1138   if (is_tracepoint (b))
1139     {
1140       /* We need to verify that each top-level element of commands is
1141          valid for tracepoints, that there's at most one
1142          while-stepping element, and that while-stepping's body has
1143          valid tracing commands excluding nested while-stepping.  */
1144       struct command_line *c;
1145       struct command_line *while_stepping = 0;
1146       for (c = commands; c; c = c->next)
1147         {
1148           if (c->control_type == while_stepping_control)
1149             {
1150               if (b->type == bp_fast_tracepoint)
1151                 error (_("The 'while-stepping' command "
1152                          "cannot be used for fast tracepoint"));
1153               else if (b->type == bp_static_tracepoint)
1154                 error (_("The 'while-stepping' command "
1155                          "cannot be used for static tracepoint"));
1156
1157               if (while_stepping)
1158                 error (_("The 'while-stepping' command "
1159                          "can be used only once"));
1160               else
1161                 while_stepping = c;
1162             }
1163         }
1164       if (while_stepping)
1165         {
1166           struct command_line *c2;
1167
1168           gdb_assert (while_stepping->body_count == 1);
1169           c2 = while_stepping->body_list[0];
1170           for (; c2; c2 = c2->next)
1171             {
1172               if (c2->control_type == while_stepping_control)
1173                 error (_("The 'while-stepping' command cannot be nested"));
1174             }
1175         }
1176     }
1177   else
1178     {
1179       check_no_tracepoint_commands (commands);
1180     }
1181 }
1182
1183 /* Return a vector of all the static tracepoints set at ADDR.  The
1184    caller is responsible for releasing the vector.  */
1185
1186 VEC(breakpoint_p) *
1187 static_tracepoints_here (CORE_ADDR addr)
1188 {
1189   struct breakpoint *b;
1190   VEC(breakpoint_p) *found = 0;
1191   struct bp_location *loc;
1192
1193   ALL_BREAKPOINTS (b)
1194     if (b->type == bp_static_tracepoint)
1195       {
1196         for (loc = b->loc; loc; loc = loc->next)
1197           if (loc->address == addr)
1198             VEC_safe_push(breakpoint_p, found, b);
1199       }
1200
1201   return found;
1202 }
1203
1204 /* Set the command list of B to COMMANDS.  If breakpoint is tracepoint,
1205    validate that only allowed commands are included.  */
1206
1207 void
1208 breakpoint_set_commands (struct breakpoint *b, 
1209                          struct command_line *commands)
1210 {
1211   validate_commands_for_breakpoint (b, commands);
1212
1213   decref_counted_command_line (&b->commands);
1214   b->commands = alloc_counted_command_line (commands);
1215   breakpoints_changed ();
1216   observer_notify_breakpoint_modified (b);
1217 }
1218
1219 /* Set the internal `silent' flag on the breakpoint.  Note that this
1220    is not the same as the "silent" that may appear in the breakpoint's
1221    commands.  */
1222
1223 void
1224 breakpoint_set_silent (struct breakpoint *b, int silent)
1225 {
1226   int old_silent = b->silent;
1227
1228   b->silent = silent;
1229   if (old_silent != silent)
1230     observer_notify_breakpoint_modified (b);
1231 }
1232
1233 /* Set the thread for this breakpoint.  If THREAD is -1, make the
1234    breakpoint work for any thread.  */
1235
1236 void
1237 breakpoint_set_thread (struct breakpoint *b, int thread)
1238 {
1239   int old_thread = b->thread;
1240
1241   b->thread = thread;
1242   if (old_thread != thread)
1243     observer_notify_breakpoint_modified (b);
1244 }
1245
1246 /* Set the task for this breakpoint.  If TASK is 0, make the
1247    breakpoint work for any task.  */
1248
1249 void
1250 breakpoint_set_task (struct breakpoint *b, int task)
1251 {
1252   int old_task = b->task;
1253
1254   b->task = task;
1255   if (old_task != task)
1256     observer_notify_breakpoint_modified (b);
1257 }
1258
1259 void
1260 check_tracepoint_command (char *line, void *closure)
1261 {
1262   struct breakpoint *b = closure;
1263
1264   validate_actionline (&line, b);
1265 }
1266
1267 /* A structure used to pass information through
1268    map_breakpoint_numbers.  */
1269
1270 struct commands_info
1271 {
1272   /* True if the command was typed at a tty.  */
1273   int from_tty;
1274
1275   /* The breakpoint range spec.  */
1276   char *arg;
1277
1278   /* Non-NULL if the body of the commands are being read from this
1279      already-parsed command.  */
1280   struct command_line *control;
1281
1282   /* The command lines read from the user, or NULL if they have not
1283      yet been read.  */
1284   struct counted_command_line *cmd;
1285 };
1286
1287 /* A callback for map_breakpoint_numbers that sets the commands for
1288    commands_command.  */
1289
1290 static void
1291 do_map_commands_command (struct breakpoint *b, void *data)
1292 {
1293   struct commands_info *info = data;
1294
1295   if (info->cmd == NULL)
1296     {
1297       struct command_line *l;
1298
1299       if (info->control != NULL)
1300         l = copy_command_lines (info->control->body_list[0]);
1301       else
1302         {
1303           struct cleanup *old_chain;
1304           char *str;
1305
1306           str = xstrprintf (_("Type commands for breakpoint(s) "
1307                               "%s, one per line."),
1308                             info->arg);
1309
1310           old_chain = make_cleanup (xfree, str);
1311
1312           l = read_command_lines (str,
1313                                   info->from_tty, 1,
1314                                   (is_tracepoint (b)
1315                                    ? check_tracepoint_command : 0),
1316                                   b);
1317
1318           do_cleanups (old_chain);
1319         }
1320
1321       info->cmd = alloc_counted_command_line (l);
1322     }
1323
1324   /* If a breakpoint was on the list more than once, we don't need to
1325      do anything.  */
1326   if (b->commands != info->cmd)
1327     {
1328       validate_commands_for_breakpoint (b, info->cmd->commands);
1329       incref_counted_command_line (info->cmd);
1330       decref_counted_command_line (&b->commands);
1331       b->commands = info->cmd;
1332       breakpoints_changed ();
1333       observer_notify_breakpoint_modified (b);
1334     }
1335 }
1336
1337 static void
1338 commands_command_1 (char *arg, int from_tty, 
1339                     struct command_line *control)
1340 {
1341   struct cleanup *cleanups;
1342   struct commands_info info;
1343
1344   info.from_tty = from_tty;
1345   info.control = control;
1346   info.cmd = NULL;
1347   /* If we read command lines from the user, then `info' will hold an
1348      extra reference to the commands that we must clean up.  */
1349   cleanups = make_cleanup_decref_counted_command_line (&info.cmd);
1350
1351   if (arg == NULL || !*arg)
1352     {
1353       if (breakpoint_count - prev_breakpoint_count > 1)
1354         arg = xstrprintf ("%d-%d", prev_breakpoint_count + 1, 
1355                           breakpoint_count);
1356       else if (breakpoint_count > 0)
1357         arg = xstrprintf ("%d", breakpoint_count);
1358       else
1359         {
1360           /* So that we don't try to free the incoming non-NULL
1361              argument in the cleanup below.  Mapping breakpoint
1362              numbers will fail in this case.  */
1363           arg = NULL;
1364         }
1365     }
1366   else
1367     /* The command loop has some static state, so we need to preserve
1368        our argument.  */
1369     arg = xstrdup (arg);
1370
1371   if (arg != NULL)
1372     make_cleanup (xfree, arg);
1373
1374   info.arg = arg;
1375
1376   map_breakpoint_numbers (arg, do_map_commands_command, &info);
1377
1378   if (info.cmd == NULL)
1379     error (_("No breakpoints specified."));
1380
1381   do_cleanups (cleanups);
1382 }
1383
1384 static void
1385 commands_command (char *arg, int from_tty)
1386 {
1387   commands_command_1 (arg, from_tty, NULL);
1388 }
1389
1390 /* Like commands_command, but instead of reading the commands from
1391    input stream, takes them from an already parsed command structure.
1392
1393    This is used by cli-script.c to DTRT with breakpoint commands
1394    that are part of if and while bodies.  */
1395 enum command_control_type
1396 commands_from_control_command (char *arg, struct command_line *cmd)
1397 {
1398   commands_command_1 (arg, 0, cmd);
1399   return simple_control;
1400 }
1401
1402 /* Return non-zero if BL->TARGET_INFO contains valid information.  */
1403
1404 static int
1405 bp_location_has_shadow (struct bp_location *bl)
1406 {
1407   if (bl->loc_type != bp_loc_software_breakpoint)
1408     return 0;
1409   if (!bl->inserted)
1410     return 0;
1411   if (bl->target_info.shadow_len == 0)
1412     /* BL isn't valid, or doesn't shadow memory.  */
1413     return 0;
1414   return 1;
1415 }
1416
1417 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1418    by replacing any memory breakpoints with their shadowed contents.
1419
1420    If READBUF is not NULL, this buffer must not overlap with any of
1421    the breakpoint location's shadow_contents buffers.  Otherwise,
1422    a failed assertion internal error will be raised.
1423
1424    The range of shadowed area by each bp_location is:
1425      bl->address - bp_location_placed_address_before_address_max
1426      up to bl->address + bp_location_shadow_len_after_address_max
1427    The range we were requested to resolve shadows for is:
1428      memaddr ... memaddr + len
1429    Thus the safe cutoff boundaries for performance optimization are
1430      memaddr + len <= (bl->address
1431                        - bp_location_placed_address_before_address_max)
1432    and:
1433      bl->address + bp_location_shadow_len_after_address_max <= memaddr  */
1434
1435 void
1436 breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1437                         const gdb_byte *writebuf_org,
1438                         ULONGEST memaddr, LONGEST len)
1439 {
1440   /* Left boundary, right boundary and median element of our binary
1441      search.  */
1442   unsigned bc_l, bc_r, bc;
1443
1444   /* Find BC_L which is a leftmost element which may affect BUF
1445      content.  It is safe to report lower value but a failure to
1446      report higher one.  */
1447
1448   bc_l = 0;
1449   bc_r = bp_location_count;
1450   while (bc_l + 1 < bc_r)
1451     {
1452       struct bp_location *bl;
1453
1454       bc = (bc_l + bc_r) / 2;
1455       bl = bp_location[bc];
1456
1457       /* Check first BL->ADDRESS will not overflow due to the added
1458          constant.  Then advance the left boundary only if we are sure
1459          the BC element can in no way affect the BUF content (MEMADDR
1460          to MEMADDR + LEN range).
1461
1462          Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1463          offset so that we cannot miss a breakpoint with its shadow
1464          range tail still reaching MEMADDR.  */
1465
1466       if ((bl->address + bp_location_shadow_len_after_address_max
1467            >= bl->address)
1468           && (bl->address + bp_location_shadow_len_after_address_max
1469               <= memaddr))
1470         bc_l = bc;
1471       else
1472         bc_r = bc;
1473     }
1474
1475   /* Due to the binary search above, we need to make sure we pick the
1476      first location that's at BC_L's address.  E.g., if there are
1477      multiple locations at the same address, BC_L may end up pointing
1478      at a duplicate location, and miss the "master"/"inserted"
1479      location.  Say, given locations L1, L2 and L3 at addresses A and
1480      B:
1481
1482       L1@A, L2@A, L3@B, ...
1483
1484      BC_L could end up pointing at location L2, while the "master"
1485      location could be L1.  Since the `loc->inserted' flag is only set
1486      on "master" locations, we'd forget to restore the shadow of L1
1487      and L2.  */
1488   while (bc_l > 0
1489          && bp_location[bc_l]->address == bp_location[bc_l - 1]->address)
1490     bc_l--;
1491
1492   /* Now do full processing of the found relevant range of elements.  */
1493
1494   for (bc = bc_l; bc < bp_location_count; bc++)
1495   {
1496     struct bp_location *bl = bp_location[bc];
1497     CORE_ADDR bp_addr = 0;
1498     int bp_size = 0;
1499     int bptoffset = 0;
1500
1501     /* bp_location array has BL->OWNER always non-NULL.  */
1502     if (bl->owner->type == bp_none)
1503       warning (_("reading through apparently deleted breakpoint #%d?"),
1504                bl->owner->number);
1505
1506     /* Performance optimization: any further element can no longer affect BUF
1507        content.  */
1508
1509     if (bl->address >= bp_location_placed_address_before_address_max
1510         && memaddr + len <= (bl->address
1511                              - bp_location_placed_address_before_address_max))
1512       break;
1513
1514     if (!bp_location_has_shadow (bl))
1515       continue;
1516     if (!breakpoint_address_match (bl->target_info.placed_address_space, 0,
1517                                    current_program_space->aspace, 0))
1518       continue;
1519
1520     /* Addresses and length of the part of the breakpoint that
1521        we need to copy.  */
1522     bp_addr = bl->target_info.placed_address;
1523     bp_size = bl->target_info.shadow_len;
1524
1525     if (bp_addr + bp_size <= memaddr)
1526       /* The breakpoint is entirely before the chunk of memory we
1527          are reading.  */
1528       continue;
1529
1530     if (bp_addr >= memaddr + len)
1531       /* The breakpoint is entirely after the chunk of memory we are
1532          reading.  */
1533       continue;
1534
1535     /* Offset within shadow_contents.  */
1536     if (bp_addr < memaddr)
1537       {
1538         /* Only copy the second part of the breakpoint.  */
1539         bp_size -= memaddr - bp_addr;
1540         bptoffset = memaddr - bp_addr;
1541         bp_addr = memaddr;
1542       }
1543
1544     if (bp_addr + bp_size > memaddr + len)
1545       {
1546         /* Only copy the first part of the breakpoint.  */
1547         bp_size -= (bp_addr + bp_size) - (memaddr + len);
1548       }
1549
1550     if (readbuf != NULL)
1551       {
1552         /* Verify that the readbuf buffer does not overlap with
1553            the shadow_contents buffer.  */
1554         gdb_assert (bl->target_info.shadow_contents >= readbuf + len
1555                     || readbuf >= (bl->target_info.shadow_contents
1556                                    + bl->target_info.shadow_len));
1557
1558         /* Update the read buffer with this inserted breakpoint's
1559            shadow.  */
1560         memcpy (readbuf + bp_addr - memaddr,
1561                 bl->target_info.shadow_contents + bptoffset, bp_size);
1562       }
1563     else
1564       {
1565         struct gdbarch *gdbarch = bl->gdbarch;
1566         const unsigned char *bp;
1567         CORE_ADDR placed_address = bl->target_info.placed_address;
1568         unsigned placed_size = bl->target_info.placed_size;
1569
1570         /* Update the shadow with what we want to write to memory.  */
1571         memcpy (bl->target_info.shadow_contents + bptoffset,
1572                 writebuf_org + bp_addr - memaddr, bp_size);
1573
1574         /* Determine appropriate breakpoint contents and size for this
1575            address.  */
1576         bp = gdbarch_breakpoint_from_pc (gdbarch, &placed_address, &placed_size);
1577
1578         /* Update the final write buffer with this inserted
1579            breakpoint's INSN.  */
1580         memcpy (writebuf + bp_addr - memaddr, bp + bptoffset, bp_size);
1581       }
1582   }
1583 }
1584 \f
1585
1586 /* Return true if BPT is either a software breakpoint or a hardware
1587    breakpoint.  */
1588
1589 int
1590 is_breakpoint (const struct breakpoint *bpt)
1591 {
1592   return (bpt->type == bp_breakpoint
1593           || bpt->type == bp_hardware_breakpoint
1594           || bpt->type == bp_dprintf);
1595 }
1596
1597 /* Return true if BPT is of any hardware watchpoint kind.  */
1598
1599 static int
1600 is_hardware_watchpoint (const struct breakpoint *bpt)
1601 {
1602   return (bpt->type == bp_hardware_watchpoint
1603           || bpt->type == bp_read_watchpoint
1604           || bpt->type == bp_access_watchpoint);
1605 }
1606
1607 /* Return true if BPT is of any watchpoint kind, hardware or
1608    software.  */
1609
1610 int
1611 is_watchpoint (const struct breakpoint *bpt)
1612 {
1613   return (is_hardware_watchpoint (bpt)
1614           || bpt->type == bp_watchpoint);
1615 }
1616
1617 /* Returns true if the current thread and its running state are safe
1618    to evaluate or update watchpoint B.  Watchpoints on local
1619    expressions need to be evaluated in the context of the thread that
1620    was current when the watchpoint was created, and, that thread needs
1621    to be stopped to be able to select the correct frame context.
1622    Watchpoints on global expressions can be evaluated on any thread,
1623    and in any state.  It is presently left to the target allowing
1624    memory accesses when threads are running.  */
1625
1626 static int
1627 watchpoint_in_thread_scope (struct watchpoint *b)
1628 {
1629   return (b->base.pspace == current_program_space
1630           && (ptid_equal (b->watchpoint_thread, null_ptid)
1631               || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1632                   && !is_executing (inferior_ptid))));
1633 }
1634
1635 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1636    associated bp_watchpoint_scope breakpoint.  */
1637
1638 static void
1639 watchpoint_del_at_next_stop (struct watchpoint *w)
1640 {
1641   struct breakpoint *b = &w->base;
1642
1643   if (b->related_breakpoint != b)
1644     {
1645       gdb_assert (b->related_breakpoint->type == bp_watchpoint_scope);
1646       gdb_assert (b->related_breakpoint->related_breakpoint == b);
1647       b->related_breakpoint->disposition = disp_del_at_next_stop;
1648       b->related_breakpoint->related_breakpoint = b->related_breakpoint;
1649       b->related_breakpoint = b;
1650     }
1651   b->disposition = disp_del_at_next_stop;
1652 }
1653
1654 /* Assuming that B is a watchpoint:
1655    - Reparse watchpoint expression, if REPARSE is non-zero
1656    - Evaluate expression and store the result in B->val
1657    - Evaluate the condition if there is one, and store the result
1658      in b->loc->cond.
1659    - Update the list of values that must be watched in B->loc.
1660
1661    If the watchpoint disposition is disp_del_at_next_stop, then do
1662    nothing.  If this is local watchpoint that is out of scope, delete
1663    it.
1664
1665    Even with `set breakpoint always-inserted on' the watchpoints are
1666    removed + inserted on each stop here.  Normal breakpoints must
1667    never be removed because they might be missed by a running thread
1668    when debugging in non-stop mode.  On the other hand, hardware
1669    watchpoints (is_hardware_watchpoint; processed here) are specific
1670    to each LWP since they are stored in each LWP's hardware debug
1671    registers.  Therefore, such LWP must be stopped first in order to
1672    be able to modify its hardware watchpoints.
1673
1674    Hardware watchpoints must be reset exactly once after being
1675    presented to the user.  It cannot be done sooner, because it would
1676    reset the data used to present the watchpoint hit to the user.  And
1677    it must not be done later because it could display the same single
1678    watchpoint hit during multiple GDB stops.  Note that the latter is
1679    relevant only to the hardware watchpoint types bp_read_watchpoint
1680    and bp_access_watchpoint.  False hit by bp_hardware_watchpoint is
1681    not user-visible - its hit is suppressed if the memory content has
1682    not changed.
1683
1684    The following constraints influence the location where we can reset
1685    hardware watchpoints:
1686
1687    * target_stopped_by_watchpoint and target_stopped_data_address are
1688      called several times when GDB stops.
1689
1690    [linux] 
1691    * Multiple hardware watchpoints can be hit at the same time,
1692      causing GDB to stop.  GDB only presents one hardware watchpoint
1693      hit at a time as the reason for stopping, and all the other hits
1694      are presented later, one after the other, each time the user
1695      requests the execution to be resumed.  Execution is not resumed
1696      for the threads still having pending hit event stored in
1697      LWP_INFO->STATUS.  While the watchpoint is already removed from
1698      the inferior on the first stop the thread hit event is kept being
1699      reported from its cached value by linux_nat_stopped_data_address
1700      until the real thread resume happens after the watchpoint gets
1701      presented and thus its LWP_INFO->STATUS gets reset.
1702
1703    Therefore the hardware watchpoint hit can get safely reset on the
1704    watchpoint removal from inferior.  */
1705
1706 static void
1707 update_watchpoint (struct watchpoint *b, int reparse)
1708 {
1709   int within_current_scope;
1710   struct frame_id saved_frame_id;
1711   int frame_saved;
1712
1713   /* If this is a local watchpoint, we only want to check if the
1714      watchpoint frame is in scope if the current thread is the thread
1715      that was used to create the watchpoint.  */
1716   if (!watchpoint_in_thread_scope (b))
1717     return;
1718
1719   if (b->base.disposition == disp_del_at_next_stop)
1720     return;
1721  
1722   frame_saved = 0;
1723
1724   /* Determine if the watchpoint is within scope.  */
1725   if (b->exp_valid_block == NULL)
1726     within_current_scope = 1;
1727   else
1728     {
1729       struct frame_info *fi = get_current_frame ();
1730       struct gdbarch *frame_arch = get_frame_arch (fi);
1731       CORE_ADDR frame_pc = get_frame_pc (fi);
1732
1733       /* If we're in a function epilogue, unwinding may not work
1734          properly, so do not attempt to recreate locations at this
1735          point.  See similar comments in watchpoint_check.  */
1736       if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
1737         return;
1738
1739       /* Save the current frame's ID so we can restore it after
1740          evaluating the watchpoint expression on its own frame.  */
1741       /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1742          took a frame parameter, so that we didn't have to change the
1743          selected frame.  */
1744       frame_saved = 1;
1745       saved_frame_id = get_frame_id (get_selected_frame (NULL));
1746
1747       fi = frame_find_by_id (b->watchpoint_frame);
1748       within_current_scope = (fi != NULL);
1749       if (within_current_scope)
1750         select_frame (fi);
1751     }
1752
1753   /* We don't free locations.  They are stored in the bp_location array
1754      and update_global_location_list will eventually delete them and
1755      remove breakpoints if needed.  */
1756   b->base.loc = NULL;
1757
1758   if (within_current_scope && reparse)
1759     {
1760       char *s;
1761
1762       if (b->exp)
1763         {
1764           xfree (b->exp);
1765           b->exp = NULL;
1766         }
1767       s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1768       b->exp = parse_exp_1 (&s, 0, b->exp_valid_block, 0);
1769       /* If the meaning of expression itself changed, the old value is
1770          no longer relevant.  We don't want to report a watchpoint hit
1771          to the user when the old value and the new value may actually
1772          be completely different objects.  */
1773       value_free (b->val);
1774       b->val = NULL;
1775       b->val_valid = 0;
1776
1777       /* Note that unlike with breakpoints, the watchpoint's condition
1778          expression is stored in the breakpoint object, not in the
1779          locations (re)created below.  */
1780       if (b->base.cond_string != NULL)
1781         {
1782           if (b->cond_exp != NULL)
1783             {
1784               xfree (b->cond_exp);
1785               b->cond_exp = NULL;
1786             }
1787
1788           s = b->base.cond_string;
1789           b->cond_exp = parse_exp_1 (&s, 0, b->cond_exp_valid_block, 0);
1790         }
1791     }
1792
1793   /* If we failed to parse the expression, for example because
1794      it refers to a global variable in a not-yet-loaded shared library,
1795      don't try to insert watchpoint.  We don't automatically delete
1796      such watchpoint, though, since failure to parse expression
1797      is different from out-of-scope watchpoint.  */
1798   if ( !target_has_execution)
1799     {
1800       /* Without execution, memory can't change.  No use to try and
1801          set watchpoint locations.  The watchpoint will be reset when
1802          the target gains execution, through breakpoint_re_set.  */
1803     }
1804   else if (within_current_scope && b->exp)
1805     {
1806       int pc = 0;
1807       struct value *val_chain, *v, *result, *next;
1808       struct program_space *frame_pspace;
1809
1810       fetch_subexp_value (b->exp, &pc, &v, &result, &val_chain);
1811
1812       /* Avoid setting b->val if it's already set.  The meaning of
1813          b->val is 'the last value' user saw, and we should update
1814          it only if we reported that last value to user.  As it
1815          happens, the code that reports it updates b->val directly.
1816          We don't keep track of the memory value for masked
1817          watchpoints.  */
1818       if (!b->val_valid && !is_masked_watchpoint (&b->base))
1819         {
1820           b->val = v;
1821           b->val_valid = 1;
1822         }
1823
1824       frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1825
1826       /* Look at each value on the value chain.  */
1827       for (v = val_chain; v; v = value_next (v))
1828         {
1829           /* If it's a memory location, and GDB actually needed
1830              its contents to evaluate the expression, then we
1831              must watch it.  If the first value returned is
1832              still lazy, that means an error occurred reading it;
1833              watch it anyway in case it becomes readable.  */
1834           if (VALUE_LVAL (v) == lval_memory
1835               && (v == val_chain || ! value_lazy (v)))
1836             {
1837               struct type *vtype = check_typedef (value_type (v));
1838
1839               /* We only watch structs and arrays if user asked
1840                  for it explicitly, never if they just happen to
1841                  appear in the middle of some value chain.  */
1842               if (v == result
1843                   || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1844                       && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1845                 {
1846                   CORE_ADDR addr;
1847                   int type;
1848                   struct bp_location *loc, **tmp;
1849
1850                   addr = value_address (v);
1851                   type = hw_write;
1852                   if (b->base.type == bp_read_watchpoint)
1853                     type = hw_read;
1854                   else if (b->base.type == bp_access_watchpoint)
1855                     type = hw_access;
1856
1857                   loc = allocate_bp_location (&b->base);
1858                   for (tmp = &(b->base.loc); *tmp != NULL; tmp = &((*tmp)->next))
1859                     ;
1860                   *tmp = loc;
1861                   loc->gdbarch = get_type_arch (value_type (v));
1862
1863                   loc->pspace = frame_pspace;
1864                   loc->address = addr;
1865                   loc->length = TYPE_LENGTH (value_type (v));
1866                   loc->watchpoint_type = type;
1867                 }
1868             }
1869         }
1870
1871       /* Change the type of breakpoint between hardware assisted or
1872          an ordinary watchpoint depending on the hardware support
1873          and free hardware slots.  REPARSE is set when the inferior
1874          is started.  */
1875       if (reparse)
1876         {
1877           int reg_cnt;
1878           enum bp_loc_type loc_type;
1879           struct bp_location *bl;
1880
1881           reg_cnt = can_use_hardware_watchpoint (val_chain);
1882
1883           if (reg_cnt)
1884             {
1885               int i, target_resources_ok, other_type_used;
1886               enum bptype type;
1887
1888               /* Use an exact watchpoint when there's only one memory region to be
1889                  watched, and only one debug register is needed to watch it.  */
1890               b->exact = target_exact_watchpoints && reg_cnt == 1;
1891
1892               /* We need to determine how many resources are already
1893                  used for all other hardware watchpoints plus this one
1894                  to see if we still have enough resources to also fit
1895                  this watchpoint in as well.  */
1896
1897               /* If this is a software watchpoint, we try to turn it
1898                  to a hardware one -- count resources as if B was of
1899                  hardware watchpoint type.  */
1900               type = b->base.type;
1901               if (type == bp_watchpoint)
1902                 type = bp_hardware_watchpoint;
1903
1904               /* This watchpoint may or may not have been placed on
1905                  the list yet at this point (it won't be in the list
1906                  if we're trying to create it for the first time,
1907                  through watch_command), so always account for it
1908                  manually.  */
1909
1910               /* Count resources used by all watchpoints except B.  */
1911               i = hw_watchpoint_used_count_others (&b->base, type, &other_type_used);
1912
1913               /* Add in the resources needed for B.  */
1914               i += hw_watchpoint_use_count (&b->base);
1915
1916               target_resources_ok
1917                 = target_can_use_hardware_watchpoint (type, i, other_type_used);
1918               if (target_resources_ok <= 0)
1919                 {
1920                   int sw_mode = b->base.ops->works_in_software_mode (&b->base);
1921
1922                   if (target_resources_ok == 0 && !sw_mode)
1923                     error (_("Target does not support this type of "
1924                              "hardware watchpoint."));
1925                   else if (target_resources_ok < 0 && !sw_mode)
1926                     error (_("There are not enough available hardware "
1927                              "resources for this watchpoint."));
1928
1929                   /* Downgrade to software watchpoint.  */
1930                   b->base.type = bp_watchpoint;
1931                 }
1932               else
1933                 {
1934                   /* If this was a software watchpoint, we've just
1935                      found we have enough resources to turn it to a
1936                      hardware watchpoint.  Otherwise, this is a
1937                      nop.  */
1938                   b->base.type = type;
1939                 }
1940             }
1941           else if (!b->base.ops->works_in_software_mode (&b->base))
1942             error (_("Expression cannot be implemented with "
1943                      "read/access watchpoint."));
1944           else
1945             b->base.type = bp_watchpoint;
1946
1947           loc_type = (b->base.type == bp_watchpoint? bp_loc_other
1948                       : bp_loc_hardware_watchpoint);
1949           for (bl = b->base.loc; bl; bl = bl->next)
1950             bl->loc_type = loc_type;
1951         }
1952
1953       for (v = val_chain; v; v = next)
1954         {
1955           next = value_next (v);
1956           if (v != b->val)
1957             value_free (v);
1958         }
1959
1960       /* If a software watchpoint is not watching any memory, then the
1961          above left it without any location set up.  But,
1962          bpstat_stop_status requires a location to be able to report
1963          stops, so make sure there's at least a dummy one.  */
1964       if (b->base.type == bp_watchpoint && b->base.loc == NULL)
1965         {
1966           struct breakpoint *base = &b->base;
1967           base->loc = allocate_bp_location (base);
1968           base->loc->pspace = frame_pspace;
1969           base->loc->address = -1;
1970           base->loc->length = -1;
1971           base->loc->watchpoint_type = -1;
1972         }
1973     }
1974   else if (!within_current_scope)
1975     {
1976       printf_filtered (_("\
1977 Watchpoint %d deleted because the program has left the block\n\
1978 in which its expression is valid.\n"),
1979                        b->base.number);
1980       watchpoint_del_at_next_stop (b);
1981     }
1982
1983   /* Restore the selected frame.  */
1984   if (frame_saved)
1985     select_frame (frame_find_by_id (saved_frame_id));
1986 }
1987
1988
1989 /* Returns 1 iff breakpoint location should be
1990    inserted in the inferior.  We don't differentiate the type of BL's owner
1991    (breakpoint vs. tracepoint), although insert_location in tracepoint's
1992    breakpoint_ops is not defined, because in insert_bp_location,
1993    tracepoint's insert_location will not be called.  */
1994 static int
1995 should_be_inserted (struct bp_location *bl)
1996 {
1997   if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
1998     return 0;
1999
2000   if (bl->owner->disposition == disp_del_at_next_stop)
2001     return 0;
2002
2003   if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
2004     return 0;
2005
2006   if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
2007     return 0;
2008
2009   /* This is set for example, when we're attached to the parent of a
2010      vfork, and have detached from the child.  The child is running
2011      free, and we expect it to do an exec or exit, at which point the
2012      OS makes the parent schedulable again (and the target reports
2013      that the vfork is done).  Until the child is done with the shared
2014      memory region, do not insert breakpoints in the parent, otherwise
2015      the child could still trip on the parent's breakpoints.  Since
2016      the parent is blocked anyway, it won't miss any breakpoint.  */
2017   if (bl->pspace->breakpoints_not_allowed)
2018     return 0;
2019
2020   return 1;
2021 }
2022
2023 /* Same as should_be_inserted but does the check assuming
2024    that the location is not duplicated.  */
2025
2026 static int
2027 unduplicated_should_be_inserted (struct bp_location *bl)
2028 {
2029   int result;
2030   const int save_duplicate = bl->duplicate;
2031
2032   bl->duplicate = 0;
2033   result = should_be_inserted (bl);
2034   bl->duplicate = save_duplicate;
2035   return result;
2036 }
2037
2038 /* Parses a conditional described by an expression COND into an
2039    agent expression bytecode suitable for evaluation
2040    by the bytecode interpreter.  Return NULL if there was
2041    any error during parsing.  */
2042
2043 static struct agent_expr *
2044 parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
2045 {
2046   struct agent_expr *aexpr = NULL;
2047   struct cleanup *old_chain = NULL;
2048   volatile struct gdb_exception ex;
2049
2050   if (!cond)
2051     return NULL;
2052
2053   /* We don't want to stop processing, so catch any errors
2054      that may show up.  */
2055   TRY_CATCH (ex, RETURN_MASK_ERROR)
2056     {
2057       aexpr = gen_eval_for_expr (scope, cond);
2058     }
2059
2060   if (ex.reason < 0)
2061     {
2062       /* If we got here, it means the condition could not be parsed to a valid
2063          bytecode expression and thus can't be evaluated on the target's side.
2064          It's no use iterating through the conditions.  */
2065       return NULL;
2066     }
2067
2068   /* We have a valid agent expression.  */
2069   return aexpr;
2070 }
2071
2072 /* Based on location BL, create a list of breakpoint conditions to be
2073    passed on to the target.  If we have duplicated locations with different
2074    conditions, we will add such conditions to the list.  The idea is that the
2075    target will evaluate the list of conditions and will only notify GDB when
2076    one of them is true.  */
2077
2078 static void
2079 build_target_condition_list (struct bp_location *bl)
2080 {
2081   struct bp_location **locp = NULL, **loc2p;
2082   int null_condition_or_parse_error = 0;
2083   int modified = bl->needs_update;
2084   struct bp_location *loc;
2085
2086   /* This is only meaningful if the target is
2087      evaluating conditions and if the user has
2088      opted for condition evaluation on the target's
2089      side.  */
2090   if (gdb_evaluates_breakpoint_condition_p ()
2091       || !target_supports_evaluation_of_breakpoint_conditions ())
2092     return;
2093
2094   /* Do a first pass to check for locations with no assigned
2095      conditions or conditions that fail to parse to a valid agent expression
2096      bytecode.  If any of these happen, then it's no use to send conditions
2097      to the target since this location will always trigger and generate a
2098      response back to GDB.  */
2099   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2100     {
2101       loc = (*loc2p);
2102       if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2103         {
2104           if (modified)
2105             {
2106               struct agent_expr *aexpr;
2107
2108               /* Re-parse the conditions since something changed.  In that
2109                  case we already freed the condition bytecodes (see
2110                  force_breakpoint_reinsertion).  We just
2111                  need to parse the condition to bytecodes again.  */
2112               aexpr = parse_cond_to_aexpr (bl->address, loc->cond);
2113               loc->cond_bytecode = aexpr;
2114
2115               /* Check if we managed to parse the conditional expression
2116                  correctly.  If not, we will not send this condition
2117                  to the target.  */
2118               if (aexpr)
2119                 continue;
2120             }
2121
2122           /* If we have a NULL bytecode expression, it means something
2123              went wrong or we have a null condition expression.  */
2124           if (!loc->cond_bytecode)
2125             {
2126               null_condition_or_parse_error = 1;
2127               break;
2128             }
2129         }
2130     }
2131
2132   /* If any of these happened, it means we will have to evaluate the conditions
2133      for the location's address on gdb's side.  It is no use keeping bytecodes
2134      for all the other duplicate locations, thus we free all of them here.
2135
2136      This is so we have a finer control over which locations' conditions are
2137      being evaluated by GDB or the remote stub.  */
2138   if (null_condition_or_parse_error)
2139     {
2140       ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2141         {
2142           loc = (*loc2p);
2143           if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2144             {
2145               /* Only go as far as the first NULL bytecode is
2146                  located.  */
2147               if (!loc->cond_bytecode)
2148                 return;
2149
2150               free_agent_expr (loc->cond_bytecode);
2151               loc->cond_bytecode = NULL;
2152             }
2153         }
2154     }
2155
2156   /* No NULL conditions or failed bytecode generation.  Build a condition list
2157      for this location's address.  */
2158   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2159     {
2160       loc = (*loc2p);
2161       if (loc->cond
2162           && is_breakpoint (loc->owner)
2163           && loc->pspace->num == bl->pspace->num
2164           && loc->owner->enable_state == bp_enabled
2165           && loc->enabled)
2166         /* Add the condition to the vector.  This will be used later to send the
2167            conditions to the target.  */
2168         VEC_safe_push (agent_expr_p, bl->target_info.conditions,
2169                        loc->cond_bytecode);
2170     }
2171
2172   return;
2173 }
2174
2175 /* Parses a command described by string CMD into an agent expression
2176    bytecode suitable for evaluation by the bytecode interpreter.
2177    Return NULL if there was any error during parsing.  */
2178
2179 static struct agent_expr *
2180 parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
2181 {
2182   struct cleanup *old_cleanups = 0;
2183   struct expression *expr, **argvec;
2184   struct agent_expr *aexpr = NULL;
2185   struct cleanup *old_chain = NULL;
2186   volatile struct gdb_exception ex;
2187   char *cmdrest;
2188   char *format_start, *format_end;
2189   struct format_piece *fpieces;
2190   int nargs;
2191   struct gdbarch *gdbarch = get_current_arch ();
2192
2193   if (!cmd)
2194     return NULL;
2195
2196   cmdrest = cmd;
2197
2198   if (*cmdrest == ',')
2199     ++cmdrest;
2200   cmdrest = skip_spaces (cmdrest);
2201
2202   if (*cmdrest++ != '"')
2203     error (_("No format string following the location"));
2204
2205   format_start = cmdrest;
2206
2207   fpieces = parse_format_string (&cmdrest);
2208
2209   old_cleanups = make_cleanup (free_format_pieces_cleanup, &fpieces);
2210
2211   format_end = cmdrest;
2212
2213   if (*cmdrest++ != '"')
2214     error (_("Bad format string, non-terminated '\"'."));
2215   
2216   cmdrest = skip_spaces (cmdrest);
2217
2218   if (!(*cmdrest == ',' || *cmdrest == '\0'))
2219     error (_("Invalid argument syntax"));
2220
2221   if (*cmdrest == ',')
2222     cmdrest++;
2223   cmdrest = skip_spaces (cmdrest);
2224
2225   /* For each argument, make an expression.  */
2226
2227   argvec = (struct expression **) alloca (strlen (cmd)
2228                                          * sizeof (struct expression *));
2229
2230   nargs = 0;
2231   while (*cmdrest != '\0')
2232     {
2233       char *cmd1;
2234
2235       cmd1 = cmdrest;
2236       expr = parse_exp_1 (&cmd1, scope, block_for_pc (scope), 1);
2237       argvec[nargs++] = expr;
2238       cmdrest = cmd1;
2239       if (*cmdrest == ',')
2240         ++cmdrest;
2241     }
2242
2243   /* We don't want to stop processing, so catch any errors
2244      that may show up.  */
2245   TRY_CATCH (ex, RETURN_MASK_ERROR)
2246     {
2247       aexpr = gen_printf (scope, gdbarch, 0, 0,
2248                           format_start, format_end - format_start,
2249                           fpieces, nargs, argvec);
2250     }
2251
2252   if (ex.reason < 0)
2253     {
2254       /* If we got here, it means the command could not be parsed to a valid
2255          bytecode expression and thus can't be evaluated on the target's side.
2256          It's no use iterating through the other commands.  */
2257       return NULL;
2258     }
2259
2260   do_cleanups (old_cleanups);
2261
2262   /* We have a valid agent expression, return it.  */
2263   return aexpr;
2264 }
2265
2266 /* Based on location BL, create a list of breakpoint commands to be
2267    passed on to the target.  If we have duplicated locations with
2268    different commands, we will add any such to the list.  */
2269
2270 static void
2271 build_target_command_list (struct bp_location *bl)
2272 {
2273   struct bp_location **locp = NULL, **loc2p;
2274   int null_command_or_parse_error = 0;
2275   int modified = bl->needs_update;
2276   struct bp_location *loc;
2277
2278   /* For now, limit to agent-style dprintf breakpoints.  */
2279   if (bl->owner->type != bp_dprintf
2280       || strcmp (dprintf_style, dprintf_style_agent) != 0)
2281     return;
2282
2283   if (!target_can_run_breakpoint_commands ())
2284     return;
2285
2286   /* Do a first pass to check for locations with no assigned
2287      conditions or conditions that fail to parse to a valid agent expression
2288      bytecode.  If any of these happen, then it's no use to send conditions
2289      to the target since this location will always trigger and generate a
2290      response back to GDB.  */
2291   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2292     {
2293       loc = (*loc2p);
2294       if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2295         {
2296           if (modified)
2297             {
2298               struct agent_expr *aexpr;
2299
2300               /* Re-parse the commands since something changed.  In that
2301                  case we already freed the command bytecodes (see
2302                  force_breakpoint_reinsertion).  We just
2303                  need to parse the command to bytecodes again.  */
2304               aexpr = parse_cmd_to_aexpr (bl->address,
2305                                           loc->owner->extra_string);
2306               loc->cmd_bytecode = aexpr;
2307
2308               if (!aexpr)
2309                 continue;
2310             }
2311
2312           /* If we have a NULL bytecode expression, it means something
2313              went wrong or we have a null command expression.  */
2314           if (!loc->cmd_bytecode)
2315             {
2316               null_command_or_parse_error = 1;
2317               break;
2318             }
2319         }
2320     }
2321
2322   /* If anything failed, then we're not doing target-side commands,
2323      and so clean up.  */
2324   if (null_command_or_parse_error)
2325     {
2326       ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2327         {
2328           loc = (*loc2p);
2329           if (is_breakpoint (loc->owner)
2330               && loc->pspace->num == bl->pspace->num)
2331             {
2332               /* Only go as far as the first NULL bytecode is
2333                  located.  */
2334               if (!loc->cond_bytecode)
2335                 return;
2336
2337               free_agent_expr (loc->cond_bytecode);
2338               loc->cond_bytecode = NULL;
2339             }
2340         }
2341     }
2342
2343   /* No NULL commands or failed bytecode generation.  Build a command list
2344      for this location's address.  */
2345   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2346     {
2347       loc = (*loc2p);
2348       if (loc->owner->extra_string
2349           && is_breakpoint (loc->owner)
2350           && loc->pspace->num == bl->pspace->num
2351           && loc->owner->enable_state == bp_enabled
2352           && loc->enabled)
2353         /* Add the command to the vector.  This will be used later
2354            to send the commands to the target.  */
2355         VEC_safe_push (agent_expr_p, bl->target_info.tcommands,
2356                        loc->cmd_bytecode);
2357     }
2358
2359   bl->target_info.persist = 0;
2360   /* Maybe flag this location as persistent.  */
2361   if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2362     bl->target_info.persist = 1;
2363 }
2364
2365 /* Insert a low-level "breakpoint" of some type.  BL is the breakpoint
2366    location.  Any error messages are printed to TMP_ERROR_STREAM; and
2367    DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2368    Returns 0 for success, 1 if the bp_location type is not supported or
2369    -1 for failure.
2370
2371    NOTE drow/2003-09-09: This routine could be broken down to an
2372    object-style method for each breakpoint or catchpoint type.  */
2373 static int
2374 insert_bp_location (struct bp_location *bl,
2375                     struct ui_file *tmp_error_stream,
2376                     int *disabled_breaks,
2377                     int *hw_breakpoint_error,
2378                     int *hw_bp_error_explained_already)
2379 {
2380   int val = 0;
2381   char *hw_bp_err_string = NULL;
2382   struct gdb_exception e;
2383
2384   if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2385     return 0;
2386
2387   /* Note we don't initialize bl->target_info, as that wipes out
2388      the breakpoint location's shadow_contents if the breakpoint
2389      is still inserted at that location.  This in turn breaks
2390      target_read_memory which depends on these buffers when
2391      a memory read is requested at the breakpoint location:
2392      Once the target_info has been wiped, we fail to see that
2393      we have a breakpoint inserted at that address and thus
2394      read the breakpoint instead of returning the data saved in
2395      the breakpoint location's shadow contents.  */
2396   bl->target_info.placed_address = bl->address;
2397   bl->target_info.placed_address_space = bl->pspace->aspace;
2398   bl->target_info.length = bl->length;
2399
2400   /* When working with target-side conditions, we must pass all the conditions
2401      for the same breakpoint address down to the target since GDB will not
2402      insert those locations.  With a list of breakpoint conditions, the target
2403      can decide when to stop and notify GDB.  */
2404
2405   if (is_breakpoint (bl->owner))
2406     {
2407       build_target_condition_list (bl);
2408       build_target_command_list (bl);
2409       /* Reset the modification marker.  */
2410       bl->needs_update = 0;
2411     }
2412
2413   if (bl->loc_type == bp_loc_software_breakpoint
2414       || bl->loc_type == bp_loc_hardware_breakpoint)
2415     {
2416       if (bl->owner->type != bp_hardware_breakpoint)
2417         {
2418           /* If the explicitly specified breakpoint type
2419              is not hardware breakpoint, check the memory map to see
2420              if the breakpoint address is in read only memory or not.
2421
2422              Two important cases are:
2423              - location type is not hardware breakpoint, memory
2424              is readonly.  We change the type of the location to
2425              hardware breakpoint.
2426              - location type is hardware breakpoint, memory is
2427              read-write.  This means we've previously made the
2428              location hardware one, but then the memory map changed,
2429              so we undo.
2430              
2431              When breakpoints are removed, remove_breakpoints will use
2432              location types we've just set here, the only possible
2433              problem is that memory map has changed during running
2434              program, but it's not going to work anyway with current
2435              gdb.  */
2436           struct mem_region *mr 
2437             = lookup_mem_region (bl->target_info.placed_address);
2438           
2439           if (mr)
2440             {
2441               if (automatic_hardware_breakpoints)
2442                 {
2443                   enum bp_loc_type new_type;
2444                   
2445                   if (mr->attrib.mode != MEM_RW)
2446                     new_type = bp_loc_hardware_breakpoint;
2447                   else 
2448                     new_type = bp_loc_software_breakpoint;
2449                   
2450                   if (new_type != bl->loc_type)
2451                     {
2452                       static int said = 0;
2453
2454                       bl->loc_type = new_type;
2455                       if (!said)
2456                         {
2457                           fprintf_filtered (gdb_stdout,
2458                                             _("Note: automatically using "
2459                                               "hardware breakpoints for "
2460                                               "read-only addresses.\n"));
2461                           said = 1;
2462                         }
2463                     }
2464                 }
2465               else if (bl->loc_type == bp_loc_software_breakpoint
2466                        && mr->attrib.mode != MEM_RW)        
2467                 warning (_("cannot set software breakpoint "
2468                            "at readonly address %s"),
2469                          paddress (bl->gdbarch, bl->address));
2470             }
2471         }
2472         
2473       /* First check to see if we have to handle an overlay.  */
2474       if (overlay_debugging == ovly_off
2475           || bl->section == NULL
2476           || !(section_is_overlay (bl->section)))
2477         {
2478           /* No overlay handling: just set the breakpoint.  */
2479           TRY_CATCH (e, RETURN_MASK_ALL)
2480             {
2481               val = bl->owner->ops->insert_location (bl);
2482             }
2483           if (e.reason < 0)
2484             {
2485               val = 1;
2486               hw_bp_err_string = (char *) e.message;
2487             }
2488         }
2489       else
2490         {
2491           /* This breakpoint is in an overlay section.
2492              Shall we set a breakpoint at the LMA?  */
2493           if (!overlay_events_enabled)
2494             {
2495               /* Yes -- overlay event support is not active, 
2496                  so we must try to set a breakpoint at the LMA.
2497                  This will not work for a hardware breakpoint.  */
2498               if (bl->loc_type == bp_loc_hardware_breakpoint)
2499                 warning (_("hardware breakpoint %d not supported in overlay!"),
2500                          bl->owner->number);
2501               else
2502                 {
2503                   CORE_ADDR addr = overlay_unmapped_address (bl->address,
2504                                                              bl->section);
2505                   /* Set a software (trap) breakpoint at the LMA.  */
2506                   bl->overlay_target_info = bl->target_info;
2507                   bl->overlay_target_info.placed_address = addr;
2508                   val = target_insert_breakpoint (bl->gdbarch,
2509                                                   &bl->overlay_target_info);
2510                   if (val != 0)
2511                     fprintf_unfiltered (tmp_error_stream,
2512                                         "Overlay breakpoint %d "
2513                                         "failed: in ROM?\n",
2514                                         bl->owner->number);
2515                 }
2516             }
2517           /* Shall we set a breakpoint at the VMA? */
2518           if (section_is_mapped (bl->section))
2519             {
2520               /* Yes.  This overlay section is mapped into memory.  */
2521               TRY_CATCH (e, RETURN_MASK_ALL)
2522                 {
2523                   val = bl->owner->ops->insert_location (bl);
2524                 }
2525               if (e.reason < 0)
2526                 {
2527                   val = 1;
2528                   hw_bp_err_string = (char *) e.message;
2529                 }
2530             }
2531           else
2532             {
2533               /* No.  This breakpoint will not be inserted.  
2534                  No error, but do not mark the bp as 'inserted'.  */
2535               return 0;
2536             }
2537         }
2538
2539       if (val)
2540         {
2541           /* Can't set the breakpoint.  */
2542           if (solib_name_from_address (bl->pspace, bl->address))
2543             {
2544               /* See also: disable_breakpoints_in_shlibs.  */
2545               val = 0;
2546               bl->shlib_disabled = 1;
2547               observer_notify_breakpoint_modified (bl->owner);
2548               if (!*disabled_breaks)
2549                 {
2550                   fprintf_unfiltered (tmp_error_stream, 
2551                                       "Cannot insert breakpoint %d.\n", 
2552                                       bl->owner->number);
2553                   fprintf_unfiltered (tmp_error_stream, 
2554                                       "Temporarily disabling shared "
2555                                       "library breakpoints:\n");
2556                 }
2557               *disabled_breaks = 1;
2558               fprintf_unfiltered (tmp_error_stream,
2559                                   "breakpoint #%d\n", bl->owner->number);
2560             }
2561           else
2562             {
2563               if (bl->loc_type == bp_loc_hardware_breakpoint)
2564                 {
2565                   *hw_breakpoint_error = 1;
2566                   *hw_bp_error_explained_already = hw_bp_err_string != NULL;
2567                   fprintf_unfiltered (tmp_error_stream,
2568                                       "Cannot insert hardware breakpoint %d%s",
2569                                       bl->owner->number, hw_bp_err_string ? ":" : ".\n");
2570                   if (hw_bp_err_string)
2571                     fprintf_unfiltered (tmp_error_stream, "%s.\n", hw_bp_err_string);
2572                 }
2573               else
2574                 {
2575                   fprintf_unfiltered (tmp_error_stream, 
2576                                       "Cannot insert breakpoint %d.\n", 
2577                                       bl->owner->number);
2578                   fprintf_filtered (tmp_error_stream, 
2579                                     "Error accessing memory address ");
2580                   fputs_filtered (paddress (bl->gdbarch, bl->address),
2581                                   tmp_error_stream);
2582                   fprintf_filtered (tmp_error_stream, ": %s.\n",
2583                                     safe_strerror (val));
2584                 }
2585
2586             }
2587         }
2588       else
2589         bl->inserted = 1;
2590
2591       return val;
2592     }
2593
2594   else if (bl->loc_type == bp_loc_hardware_watchpoint
2595            /* NOTE drow/2003-09-08: This state only exists for removing
2596               watchpoints.  It's not clear that it's necessary...  */
2597            && bl->owner->disposition != disp_del_at_next_stop)
2598     {
2599       gdb_assert (bl->owner->ops != NULL
2600                   && bl->owner->ops->insert_location != NULL);
2601
2602       val = bl->owner->ops->insert_location (bl);
2603
2604       /* If trying to set a read-watchpoint, and it turns out it's not
2605          supported, try emulating one with an access watchpoint.  */
2606       if (val == 1 && bl->watchpoint_type == hw_read)
2607         {
2608           struct bp_location *loc, **loc_temp;
2609
2610           /* But don't try to insert it, if there's already another
2611              hw_access location that would be considered a duplicate
2612              of this one.  */
2613           ALL_BP_LOCATIONS (loc, loc_temp)
2614             if (loc != bl
2615                 && loc->watchpoint_type == hw_access
2616                 && watchpoint_locations_match (bl, loc))
2617               {
2618                 bl->duplicate = 1;
2619                 bl->inserted = 1;
2620                 bl->target_info = loc->target_info;
2621                 bl->watchpoint_type = hw_access;
2622                 val = 0;
2623                 break;
2624               }
2625
2626           if (val == 1)
2627             {
2628               bl->watchpoint_type = hw_access;
2629               val = bl->owner->ops->insert_location (bl);
2630
2631               if (val)
2632                 /* Back to the original value.  */
2633                 bl->watchpoint_type = hw_read;
2634             }
2635         }
2636
2637       bl->inserted = (val == 0);
2638     }
2639
2640   else if (bl->owner->type == bp_catchpoint)
2641     {
2642       gdb_assert (bl->owner->ops != NULL
2643                   && bl->owner->ops->insert_location != NULL);
2644
2645       val = bl->owner->ops->insert_location (bl);
2646       if (val)
2647         {
2648           bl->owner->enable_state = bp_disabled;
2649
2650           if (val == 1)
2651             warning (_("\
2652 Error inserting catchpoint %d: Your system does not support this type\n\
2653 of catchpoint."), bl->owner->number);
2654           else
2655             warning (_("Error inserting catchpoint %d."), bl->owner->number);
2656         }
2657
2658       bl->inserted = (val == 0);
2659
2660       /* We've already printed an error message if there was a problem
2661          inserting this catchpoint, and we've disabled the catchpoint,
2662          so just return success.  */
2663       return 0;
2664     }
2665
2666   return 0;
2667 }
2668
2669 /* This function is called when program space PSPACE is about to be
2670    deleted.  It takes care of updating breakpoints to not reference
2671    PSPACE anymore.  */
2672
2673 void
2674 breakpoint_program_space_exit (struct program_space *pspace)
2675 {
2676   struct breakpoint *b, *b_temp;
2677   struct bp_location *loc, **loc_temp;
2678
2679   /* Remove any breakpoint that was set through this program space.  */
2680   ALL_BREAKPOINTS_SAFE (b, b_temp)
2681     {
2682       if (b->pspace == pspace)
2683         delete_breakpoint (b);
2684     }
2685
2686   /* Breakpoints set through other program spaces could have locations
2687      bound to PSPACE as well.  Remove those.  */
2688   ALL_BP_LOCATIONS (loc, loc_temp)
2689     {
2690       struct bp_location *tmp;
2691
2692       if (loc->pspace == pspace)
2693         {
2694           /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
2695           if (loc->owner->loc == loc)
2696             loc->owner->loc = loc->next;
2697           else
2698             for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
2699               if (tmp->next == loc)
2700                 {
2701                   tmp->next = loc->next;
2702                   break;
2703                 }
2704         }
2705     }
2706
2707   /* Now update the global location list to permanently delete the
2708      removed locations above.  */
2709   update_global_location_list (0);
2710 }
2711
2712 /* Make sure all breakpoints are inserted in inferior.
2713    Throws exception on any error.
2714    A breakpoint that is already inserted won't be inserted
2715    again, so calling this function twice is safe.  */
2716 void
2717 insert_breakpoints (void)
2718 {
2719   struct breakpoint *bpt;
2720
2721   ALL_BREAKPOINTS (bpt)
2722     if (is_hardware_watchpoint (bpt))
2723       {
2724         struct watchpoint *w = (struct watchpoint *) bpt;
2725
2726         update_watchpoint (w, 0 /* don't reparse.  */);
2727       }
2728
2729   update_global_location_list (1);
2730
2731   /* update_global_location_list does not insert breakpoints when
2732      always_inserted_mode is not enabled.  Explicitly insert them
2733      now.  */
2734   if (!breakpoints_always_inserted_mode ())
2735     insert_breakpoint_locations ();
2736 }
2737
2738 /* Invoke CALLBACK for each of bp_location.  */
2739
2740 void
2741 iterate_over_bp_locations (walk_bp_location_callback callback)
2742 {
2743   struct bp_location *loc, **loc_tmp;
2744
2745   ALL_BP_LOCATIONS (loc, loc_tmp)
2746     {
2747       callback (loc, NULL);
2748     }
2749 }
2750
2751 /* This is used when we need to synch breakpoint conditions between GDB and the
2752    target.  It is the case with deleting and disabling of breakpoints when using
2753    always-inserted mode.  */
2754
2755 static void
2756 update_inserted_breakpoint_locations (void)
2757 {
2758   struct bp_location *bl, **blp_tmp;
2759   int error_flag = 0;
2760   int val = 0;
2761   int disabled_breaks = 0;
2762   int hw_breakpoint_error = 0;
2763   int hw_bp_details_reported = 0;
2764
2765   struct ui_file *tmp_error_stream = mem_fileopen ();
2766   struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
2767
2768   /* Explicitly mark the warning -- this will only be printed if
2769      there was an error.  */
2770   fprintf_unfiltered (tmp_error_stream, "Warning:\n");
2771
2772   save_current_space_and_thread ();
2773
2774   ALL_BP_LOCATIONS (bl, blp_tmp)
2775     {
2776       /* We only want to update software breakpoints and hardware
2777          breakpoints.  */
2778       if (!is_breakpoint (bl->owner))
2779         continue;
2780
2781       /* We only want to update locations that are already inserted
2782          and need updating.  This is to avoid unwanted insertion during
2783          deletion of breakpoints.  */
2784       if (!bl->inserted || (bl->inserted && !bl->needs_update))
2785         continue;
2786
2787       switch_to_program_space_and_thread (bl->pspace);
2788
2789       /* For targets that support global breakpoints, there's no need
2790          to select an inferior to insert breakpoint to.  In fact, even
2791          if we aren't attached to any process yet, we should still
2792          insert breakpoints.  */
2793       if (!gdbarch_has_global_breakpoints (target_gdbarch)
2794           && ptid_equal (inferior_ptid, null_ptid))
2795         continue;
2796
2797       val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
2798                                     &hw_breakpoint_error, &hw_bp_details_reported);
2799       if (val)
2800         error_flag = val;
2801     }
2802
2803   if (error_flag)
2804     {
2805       target_terminal_ours_for_output ();
2806       error_stream (tmp_error_stream);
2807     }
2808
2809   do_cleanups (cleanups);
2810 }
2811
2812 /* Used when starting or continuing the program.  */
2813
2814 static void
2815 insert_breakpoint_locations (void)
2816 {
2817   struct breakpoint *bpt;
2818   struct bp_location *bl, **blp_tmp;
2819   int error_flag = 0;
2820   int val = 0;
2821   int disabled_breaks = 0;
2822   int hw_breakpoint_error = 0;
2823   int hw_bp_error_explained_already = 0;
2824
2825   struct ui_file *tmp_error_stream = mem_fileopen ();
2826   struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
2827   
2828   /* Explicitly mark the warning -- this will only be printed if
2829      there was an error.  */
2830   fprintf_unfiltered (tmp_error_stream, "Warning:\n");
2831
2832   save_current_space_and_thread ();
2833
2834   ALL_BP_LOCATIONS (bl, blp_tmp)
2835     {
2836       if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
2837         continue;
2838
2839       /* There is no point inserting thread-specific breakpoints if
2840          the thread no longer exists.  ALL_BP_LOCATIONS bp_location
2841          has BL->OWNER always non-NULL.  */
2842       if (bl->owner->thread != -1
2843           && !valid_thread_id (bl->owner->thread))
2844         continue;
2845
2846       switch_to_program_space_and_thread (bl->pspace);
2847
2848       /* For targets that support global breakpoints, there's no need
2849          to select an inferior to insert breakpoint to.  In fact, even
2850          if we aren't attached to any process yet, we should still
2851          insert breakpoints.  */
2852       if (!gdbarch_has_global_breakpoints (target_gdbarch)
2853           && ptid_equal (inferior_ptid, null_ptid))
2854         continue;
2855
2856       val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
2857                                     &hw_breakpoint_error, &hw_bp_error_explained_already);
2858       if (val)
2859         error_flag = val;
2860     }
2861
2862   /* If we failed to insert all locations of a watchpoint, remove
2863      them, as half-inserted watchpoint is of limited use.  */
2864   ALL_BREAKPOINTS (bpt)  
2865     {
2866       int some_failed = 0;
2867       struct bp_location *loc;
2868
2869       if (!is_hardware_watchpoint (bpt))
2870         continue;
2871
2872       if (!breakpoint_enabled (bpt))
2873         continue;
2874
2875       if (bpt->disposition == disp_del_at_next_stop)
2876         continue;
2877       
2878       for (loc = bpt->loc; loc; loc = loc->next)
2879         if (!loc->inserted && should_be_inserted (loc))
2880           {
2881             some_failed = 1;
2882             break;
2883           }
2884       if (some_failed)
2885         {
2886           for (loc = bpt->loc; loc; loc = loc->next)
2887             if (loc->inserted)
2888               remove_breakpoint (loc, mark_uninserted);
2889
2890           hw_breakpoint_error = 1;
2891           fprintf_unfiltered (tmp_error_stream,
2892                               "Could not insert hardware watchpoint %d.\n", 
2893                               bpt->number);
2894           error_flag = -1;
2895         }
2896     }
2897
2898   if (error_flag)
2899     {
2900       /* If a hardware breakpoint or watchpoint was inserted, add a
2901          message about possibly exhausted resources.  */
2902       if (hw_breakpoint_error && !hw_bp_error_explained_already)
2903         {
2904           fprintf_unfiltered (tmp_error_stream, 
2905                               "Could not insert hardware breakpoints:\n\
2906 You may have requested too many hardware breakpoints/watchpoints.\n");
2907         }
2908       target_terminal_ours_for_output ();
2909       error_stream (tmp_error_stream);
2910     }
2911
2912   do_cleanups (cleanups);
2913 }
2914
2915 /* Used when the program stops.
2916    Returns zero if successful, or non-zero if there was a problem
2917    removing a breakpoint location.  */
2918
2919 int
2920 remove_breakpoints (void)
2921 {
2922   struct bp_location *bl, **blp_tmp;
2923   int val = 0;
2924
2925   ALL_BP_LOCATIONS (bl, blp_tmp)
2926   {
2927     if (bl->inserted && !is_tracepoint (bl->owner))
2928       val |= remove_breakpoint (bl, mark_uninserted);
2929   }
2930   return val;
2931 }
2932
2933 /* Remove breakpoints of process PID.  */
2934
2935 int
2936 remove_breakpoints_pid (int pid)
2937 {
2938   struct bp_location *bl, **blp_tmp;
2939   int val;
2940   struct inferior *inf = find_inferior_pid (pid);
2941
2942   ALL_BP_LOCATIONS (bl, blp_tmp)
2943   {
2944     if (bl->pspace != inf->pspace)
2945       continue;
2946
2947     if (bl->owner->type == bp_dprintf)
2948       continue;
2949
2950     if (bl->inserted)
2951       {
2952         val = remove_breakpoint (bl, mark_uninserted);
2953         if (val != 0)
2954           return val;
2955       }
2956   }
2957   return 0;
2958 }
2959
2960 int
2961 reattach_breakpoints (int pid)
2962 {
2963   struct cleanup *old_chain;
2964   struct bp_location *bl, **blp_tmp;
2965   int val;
2966   struct ui_file *tmp_error_stream;
2967   int dummy1 = 0, dummy2 = 0, dummy3 = 0;
2968   struct inferior *inf;
2969   struct thread_info *tp;
2970
2971   tp = any_live_thread_of_process (pid);
2972   if (tp == NULL)
2973     return 1;
2974
2975   inf = find_inferior_pid (pid);
2976   old_chain = save_inferior_ptid ();
2977
2978   inferior_ptid = tp->ptid;
2979
2980   tmp_error_stream = mem_fileopen ();
2981   make_cleanup_ui_file_delete (tmp_error_stream);
2982
2983   ALL_BP_LOCATIONS (bl, blp_tmp)
2984   {
2985     if (bl->pspace != inf->pspace)
2986       continue;
2987
2988     if (bl->inserted)
2989       {
2990         bl->inserted = 0;
2991         val = insert_bp_location (bl, tmp_error_stream, &dummy1, &dummy2, &dummy3);
2992         if (val != 0)
2993           {
2994             do_cleanups (old_chain);
2995             return val;
2996           }
2997       }
2998   }
2999   do_cleanups (old_chain);
3000   return 0;
3001 }
3002
3003 static int internal_breakpoint_number = -1;
3004
3005 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3006    If INTERNAL is non-zero, the breakpoint number will be populated
3007    from internal_breakpoint_number and that variable decremented.
3008    Otherwise the breakpoint number will be populated from
3009    breakpoint_count and that value incremented.  Internal breakpoints
3010    do not set the internal var bpnum.  */
3011 static void
3012 set_breakpoint_number (int internal, struct breakpoint *b)
3013 {
3014   if (internal)
3015     b->number = internal_breakpoint_number--;
3016   else
3017     {
3018       set_breakpoint_count (breakpoint_count + 1);
3019       b->number = breakpoint_count;
3020     }
3021 }
3022
3023 static struct breakpoint *
3024 create_internal_breakpoint (struct gdbarch *gdbarch,
3025                             CORE_ADDR address, enum bptype type,
3026                             const struct breakpoint_ops *ops)
3027 {
3028   struct symtab_and_line sal;
3029   struct breakpoint *b;
3030
3031   init_sal (&sal);              /* Initialize to zeroes.  */
3032
3033   sal.pc = address;
3034   sal.section = find_pc_overlay (sal.pc);
3035   sal.pspace = current_program_space;
3036
3037   b = set_raw_breakpoint (gdbarch, sal, type, ops);
3038   b->number = internal_breakpoint_number--;
3039   b->disposition = disp_donttouch;
3040
3041   return b;
3042 }
3043
3044 static const char *const longjmp_names[] =
3045   {
3046     "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3047   };
3048 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3049
3050 /* Per-objfile data private to breakpoint.c.  */
3051 struct breakpoint_objfile_data
3052 {
3053   /* Minimal symbol for "_ovly_debug_event" (if any).  */
3054   struct minimal_symbol *overlay_msym;
3055
3056   /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any).  */
3057   struct minimal_symbol *longjmp_msym[NUM_LONGJMP_NAMES];
3058
3059   /* True if we have looked for longjmp probes.  */
3060   int longjmp_searched;
3061
3062   /* SystemTap probe points for longjmp (if any).  */
3063   VEC (probe_p) *longjmp_probes;
3064
3065   /* Minimal symbol for "std::terminate()" (if any).  */
3066   struct minimal_symbol *terminate_msym;
3067
3068   /* Minimal symbol for "_Unwind_DebugHook" (if any).  */
3069   struct minimal_symbol *exception_msym;
3070
3071   /* True if we have looked for exception probes.  */
3072   int exception_searched;
3073
3074   /* SystemTap probe points for unwinding (if any).  */
3075   VEC (probe_p) *exception_probes;
3076 };
3077
3078 static const struct objfile_data *breakpoint_objfile_key;
3079
3080 /* Minimal symbol not found sentinel.  */
3081 static struct minimal_symbol msym_not_found;
3082
3083 /* Returns TRUE if MSYM point to the "not found" sentinel.  */
3084
3085 static int
3086 msym_not_found_p (const struct minimal_symbol *msym)
3087 {
3088   return msym == &msym_not_found;
3089 }
3090
3091 /* Return per-objfile data needed by breakpoint.c.
3092    Allocate the data if necessary.  */
3093
3094 static struct breakpoint_objfile_data *
3095 get_breakpoint_objfile_data (struct objfile *objfile)
3096 {
3097   struct breakpoint_objfile_data *bp_objfile_data;
3098
3099   bp_objfile_data = objfile_data (objfile, breakpoint_objfile_key);
3100   if (bp_objfile_data == NULL)
3101     {
3102       bp_objfile_data = obstack_alloc (&objfile->objfile_obstack,
3103                                        sizeof (*bp_objfile_data));
3104
3105       memset (bp_objfile_data, 0, sizeof (*bp_objfile_data));
3106       set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
3107     }
3108   return bp_objfile_data;
3109 }
3110
3111 static void
3112 free_breakpoint_probes (struct objfile *obj, void *data)
3113 {
3114   struct breakpoint_objfile_data *bp_objfile_data = data;
3115
3116   VEC_free (probe_p, bp_objfile_data->longjmp_probes);
3117   VEC_free (probe_p, bp_objfile_data->exception_probes);
3118 }
3119
3120 static void
3121 create_overlay_event_breakpoint (void)
3122 {
3123   struct objfile *objfile;
3124   const char *const func_name = "_ovly_debug_event";
3125
3126   ALL_OBJFILES (objfile)
3127     {
3128       struct breakpoint *b;
3129       struct breakpoint_objfile_data *bp_objfile_data;
3130       CORE_ADDR addr;
3131
3132       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3133
3134       if (msym_not_found_p (bp_objfile_data->overlay_msym))
3135         continue;
3136
3137       if (bp_objfile_data->overlay_msym == NULL)
3138         {
3139           struct minimal_symbol *m;
3140
3141           m = lookup_minimal_symbol_text (func_name, objfile);
3142           if (m == NULL)
3143             {
3144               /* Avoid future lookups in this objfile.  */
3145               bp_objfile_data->overlay_msym = &msym_not_found;
3146               continue;
3147             }
3148           bp_objfile_data->overlay_msym = m;
3149         }
3150
3151       addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
3152       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3153                                       bp_overlay_event,
3154                                       &internal_breakpoint_ops);
3155       b->addr_string = xstrdup (func_name);
3156
3157       if (overlay_debugging == ovly_auto)
3158         {
3159           b->enable_state = bp_enabled;
3160           overlay_events_enabled = 1;
3161         }
3162       else
3163        {
3164          b->enable_state = bp_disabled;
3165          overlay_events_enabled = 0;
3166        }
3167     }
3168   update_global_location_list (1);
3169 }
3170
3171 static void
3172 create_longjmp_master_breakpoint (void)
3173 {
3174   struct program_space *pspace;
3175   struct cleanup *old_chain;
3176
3177   old_chain = save_current_program_space ();
3178
3179   ALL_PSPACES (pspace)
3180   {
3181     struct objfile *objfile;
3182
3183     set_current_program_space (pspace);
3184
3185     ALL_OBJFILES (objfile)
3186     {
3187       int i;
3188       struct gdbarch *gdbarch;
3189       struct breakpoint_objfile_data *bp_objfile_data;
3190
3191       gdbarch = get_objfile_arch (objfile);
3192       if (!gdbarch_get_longjmp_target_p (gdbarch))
3193         continue;
3194
3195       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3196
3197       if (!bp_objfile_data->longjmp_searched)
3198         {
3199           bp_objfile_data->longjmp_probes
3200             = find_probes_in_objfile (objfile, "libc", "longjmp");
3201           bp_objfile_data->longjmp_searched = 1;
3202         }
3203
3204       if (bp_objfile_data->longjmp_probes != NULL)
3205         {
3206           int i;
3207           struct probe *probe;
3208           struct gdbarch *gdbarch = get_objfile_arch (objfile);
3209
3210           for (i = 0;
3211                VEC_iterate (probe_p,
3212                             bp_objfile_data->longjmp_probes,
3213                             i, probe);
3214                ++i)
3215             {
3216               struct breakpoint *b;
3217
3218               b = create_internal_breakpoint (gdbarch, probe->address,
3219                                               bp_longjmp_master,
3220                                               &internal_breakpoint_ops);
3221               b->addr_string = xstrdup ("-probe-stap libc:longjmp");
3222               b->enable_state = bp_disabled;
3223             }
3224
3225           continue;
3226         }
3227
3228       for (i = 0; i < NUM_LONGJMP_NAMES; i++)
3229         {
3230           struct breakpoint *b;
3231           const char *func_name;
3232           CORE_ADDR addr;
3233
3234           if (msym_not_found_p (bp_objfile_data->longjmp_msym[i]))
3235             continue;
3236
3237           func_name = longjmp_names[i];
3238           if (bp_objfile_data->longjmp_msym[i] == NULL)
3239             {
3240               struct minimal_symbol *m;
3241
3242               m = lookup_minimal_symbol_text (func_name, objfile);
3243               if (m == NULL)
3244                 {
3245                   /* Prevent future lookups in this objfile.  */
3246                   bp_objfile_data->longjmp_msym[i] = &msym_not_found;
3247                   continue;
3248                 }
3249               bp_objfile_data->longjmp_msym[i] = m;
3250             }
3251
3252           addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
3253           b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3254                                           &internal_breakpoint_ops);
3255           b->addr_string = xstrdup (func_name);
3256           b->enable_state = bp_disabled;
3257         }
3258     }
3259   }
3260   update_global_location_list (1);
3261
3262   do_cleanups (old_chain);
3263 }
3264
3265 /* Create a master std::terminate breakpoint.  */
3266 static void
3267 create_std_terminate_master_breakpoint (void)
3268 {
3269   struct program_space *pspace;
3270   struct cleanup *old_chain;
3271   const char *const func_name = "std::terminate()";
3272
3273   old_chain = save_current_program_space ();
3274
3275   ALL_PSPACES (pspace)
3276   {
3277     struct objfile *objfile;
3278     CORE_ADDR addr;
3279
3280     set_current_program_space (pspace);
3281
3282     ALL_OBJFILES (objfile)
3283     {
3284       struct breakpoint *b;
3285       struct breakpoint_objfile_data *bp_objfile_data;
3286
3287       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3288
3289       if (msym_not_found_p (bp_objfile_data->terminate_msym))
3290         continue;
3291
3292       if (bp_objfile_data->terminate_msym == NULL)
3293         {
3294           struct minimal_symbol *m;
3295
3296           m = lookup_minimal_symbol (func_name, NULL, objfile);
3297           if (m == NULL || (MSYMBOL_TYPE (m) != mst_text
3298                             && MSYMBOL_TYPE (m) != mst_file_text))
3299             {
3300               /* Prevent future lookups in this objfile.  */
3301               bp_objfile_data->terminate_msym = &msym_not_found;
3302               continue;
3303             }
3304           bp_objfile_data->terminate_msym = m;
3305         }
3306
3307       addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
3308       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
3309                                       bp_std_terminate_master,
3310                                       &internal_breakpoint_ops);
3311       b->addr_string = xstrdup (func_name);
3312       b->enable_state = bp_disabled;
3313     }
3314   }
3315
3316   update_global_location_list (1);
3317
3318   do_cleanups (old_chain);
3319 }
3320
3321 /* Install a master breakpoint on the unwinder's debug hook.  */
3322
3323 static void
3324 create_exception_master_breakpoint (void)
3325 {
3326   struct objfile *objfile;
3327   const char *const func_name = "_Unwind_DebugHook";
3328
3329   ALL_OBJFILES (objfile)
3330     {
3331       struct breakpoint *b;
3332       struct gdbarch *gdbarch;
3333       struct breakpoint_objfile_data *bp_objfile_data;
3334       CORE_ADDR addr;
3335
3336       bp_objfile_data = get_breakpoint_objfile_data (objfile);
3337
3338       /* We prefer the SystemTap probe point if it exists.  */
3339       if (!bp_objfile_data->exception_searched)
3340         {
3341           bp_objfile_data->exception_probes
3342             = find_probes_in_objfile (objfile, "libgcc", "unwind");
3343           bp_objfile_data->exception_searched = 1;
3344         }
3345
3346       if (bp_objfile_data->exception_probes != NULL)
3347         {
3348           struct gdbarch *gdbarch = get_objfile_arch (objfile);
3349           int i;
3350           struct probe *probe;
3351
3352           for (i = 0;
3353                VEC_iterate (probe_p,
3354                             bp_objfile_data->exception_probes,
3355                             i, probe);
3356                ++i)
3357             {
3358               struct breakpoint *b;
3359
3360               b = create_internal_breakpoint (gdbarch, probe->address,
3361                                               bp_exception_master,
3362                                               &internal_breakpoint_ops);
3363               b->addr_string = xstrdup ("-probe-stap libgcc:unwind");
3364               b->enable_state = bp_disabled;
3365             }
3366
3367           continue;
3368         }
3369
3370       /* Otherwise, try the hook function.  */
3371
3372       if (msym_not_found_p (bp_objfile_data->exception_msym))
3373         continue;
3374
3375       gdbarch = get_objfile_arch (objfile);
3376
3377       if (bp_objfile_data->exception_msym == NULL)
3378         {
3379           struct minimal_symbol *debug_hook;
3380
3381           debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3382           if (debug_hook == NULL)
3383             {
3384               bp_objfile_data->exception_msym = &msym_not_found;
3385               continue;
3386             }
3387
3388           bp_objfile_data->exception_msym = debug_hook;
3389         }
3390
3391       addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
3392       addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3393                                                  &current_target);
3394       b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3395                                       &internal_breakpoint_ops);
3396       b->addr_string = xstrdup (func_name);
3397       b->enable_state = bp_disabled;
3398     }
3399
3400   update_global_location_list (1);
3401 }
3402
3403 void
3404 update_breakpoints_after_exec (void)
3405 {
3406   struct breakpoint *b, *b_tmp;
3407   struct bp_location *bploc, **bplocp_tmp;
3408
3409   /* We're about to delete breakpoints from GDB's lists.  If the
3410      INSERTED flag is true, GDB will try to lift the breakpoints by
3411      writing the breakpoints' "shadow contents" back into memory.  The
3412      "shadow contents" are NOT valid after an exec, so GDB should not
3413      do that.  Instead, the target is responsible from marking
3414      breakpoints out as soon as it detects an exec.  We don't do that
3415      here instead, because there may be other attempts to delete
3416      breakpoints after detecting an exec and before reaching here.  */
3417   ALL_BP_LOCATIONS (bploc, bplocp_tmp)
3418     if (bploc->pspace == current_program_space)
3419       gdb_assert (!bploc->inserted);
3420
3421   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3422   {
3423     if (b->pspace != current_program_space)
3424       continue;
3425
3426     /* Solib breakpoints must be explicitly reset after an exec().  */
3427     if (b->type == bp_shlib_event)
3428       {
3429         delete_breakpoint (b);
3430         continue;
3431       }
3432
3433     /* JIT breakpoints must be explicitly reset after an exec().  */
3434     if (b->type == bp_jit_event)
3435       {
3436         delete_breakpoint (b);
3437         continue;
3438       }
3439
3440     /* Thread event breakpoints must be set anew after an exec(),
3441        as must overlay event and longjmp master breakpoints.  */
3442     if (b->type == bp_thread_event || b->type == bp_overlay_event
3443         || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3444         || b->type == bp_exception_master)
3445       {
3446         delete_breakpoint (b);
3447         continue;
3448       }
3449
3450     /* Step-resume breakpoints are meaningless after an exec().  */
3451     if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
3452       {
3453         delete_breakpoint (b);
3454         continue;
3455       }
3456
3457     /* Longjmp and longjmp-resume breakpoints are also meaningless
3458        after an exec.  */
3459     if (b->type == bp_longjmp || b->type == bp_longjmp_resume
3460         || b->type == bp_longjmp_call_dummy
3461         || b->type == bp_exception || b->type == bp_exception_resume)
3462       {
3463         delete_breakpoint (b);
3464         continue;
3465       }
3466
3467     if (b->type == bp_catchpoint)
3468       {
3469         /* For now, none of the bp_catchpoint breakpoints need to
3470            do anything at this point.  In the future, if some of
3471            the catchpoints need to something, we will need to add
3472            a new method, and call this method from here.  */
3473         continue;
3474       }
3475
3476     /* bp_finish is a special case.  The only way we ought to be able
3477        to see one of these when an exec() has happened, is if the user
3478        caught a vfork, and then said "finish".  Ordinarily a finish just
3479        carries them to the call-site of the current callee, by setting
3480        a temporary bp there and resuming.  But in this case, the finish
3481        will carry them entirely through the vfork & exec.
3482
3483        We don't want to allow a bp_finish to remain inserted now.  But
3484        we can't safely delete it, 'cause finish_command has a handle to
3485        the bp on a bpstat, and will later want to delete it.  There's a
3486        chance (and I've seen it happen) that if we delete the bp_finish
3487        here, that its storage will get reused by the time finish_command
3488        gets 'round to deleting the "use to be a bp_finish" breakpoint.
3489        We really must allow finish_command to delete a bp_finish.
3490
3491        In the absence of a general solution for the "how do we know
3492        it's safe to delete something others may have handles to?"
3493        problem, what we'll do here is just uninsert the bp_finish, and
3494        let finish_command delete it.
3495
3496        (We know the bp_finish is "doomed" in the sense that it's
3497        momentary, and will be deleted as soon as finish_command sees
3498        the inferior stopped.  So it doesn't matter that the bp's
3499        address is probably bogus in the new a.out, unlike e.g., the
3500        solib breakpoints.)  */
3501
3502     if (b->type == bp_finish)
3503       {
3504         continue;
3505       }
3506
3507     /* Without a symbolic address, we have little hope of the
3508        pre-exec() address meaning the same thing in the post-exec()
3509        a.out.  */
3510     if (b->addr_string == NULL)
3511       {
3512         delete_breakpoint (b);
3513         continue;
3514       }
3515   }
3516   /* FIXME what about longjmp breakpoints?  Re-create them here?  */
3517   create_overlay_event_breakpoint ();
3518   create_longjmp_master_breakpoint ();
3519   create_std_terminate_master_breakpoint ();
3520   create_exception_master_breakpoint ();
3521 }
3522
3523 int
3524 detach_breakpoints (ptid_t ptid)
3525 {
3526   struct bp_location *bl, **blp_tmp;
3527   int val = 0;
3528   struct cleanup *old_chain = save_inferior_ptid ();
3529   struct inferior *inf = current_inferior ();
3530
3531   if (PIDGET (ptid) == PIDGET (inferior_ptid))
3532     error (_("Cannot detach breakpoints of inferior_ptid"));
3533
3534   /* Set inferior_ptid; remove_breakpoint_1 uses this global.  */
3535   inferior_ptid = ptid;
3536   ALL_BP_LOCATIONS (bl, blp_tmp)
3537   {
3538     if (bl->pspace != inf->pspace)
3539       continue;
3540
3541     if (bl->inserted)
3542       val |= remove_breakpoint_1 (bl, mark_inserted);
3543   }
3544
3545   /* Detach single-step breakpoints as well.  */
3546   detach_single_step_breakpoints ();
3547
3548   do_cleanups (old_chain);
3549   return val;
3550 }
3551
3552 /* Remove the breakpoint location BL from the current address space.
3553    Note that this is used to detach breakpoints from a child fork.
3554    When we get here, the child isn't in the inferior list, and neither
3555    do we have objects to represent its address space --- we should
3556    *not* look at bl->pspace->aspace here.  */
3557
3558 static int
3559 remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is)
3560 {
3561   int val;
3562
3563   /* BL is never in moribund_locations by our callers.  */
3564   gdb_assert (bl->owner != NULL);
3565
3566   if (bl->owner->enable_state == bp_permanent)
3567     /* Permanent breakpoints cannot be inserted or removed.  */
3568     return 0;
3569
3570   /* The type of none suggests that owner is actually deleted.
3571      This should not ever happen.  */
3572   gdb_assert (bl->owner->type != bp_none);
3573
3574   if (bl->loc_type == bp_loc_software_breakpoint
3575       || bl->loc_type == bp_loc_hardware_breakpoint)
3576     {
3577       /* "Normal" instruction breakpoint: either the standard
3578          trap-instruction bp (bp_breakpoint), or a
3579          bp_hardware_breakpoint.  */
3580
3581       /* First check to see if we have to handle an overlay.  */
3582       if (overlay_debugging == ovly_off
3583           || bl->section == NULL
3584           || !(section_is_overlay (bl->section)))
3585         {
3586           /* No overlay handling: just remove the breakpoint.  */
3587           val = bl->owner->ops->remove_location (bl);
3588         }
3589       else
3590         {
3591           /* This breakpoint is in an overlay section.
3592              Did we set a breakpoint at the LMA?  */
3593           if (!overlay_events_enabled)
3594               {
3595                 /* Yes -- overlay event support is not active, so we
3596                    should have set a breakpoint at the LMA.  Remove it.  
3597                 */
3598                 /* Ignore any failures: if the LMA is in ROM, we will
3599                    have already warned when we failed to insert it.  */
3600                 if (bl->loc_type == bp_loc_hardware_breakpoint)
3601                   target_remove_hw_breakpoint (bl->gdbarch,
3602                                                &bl->overlay_target_info);
3603                 else
3604                   target_remove_breakpoint (bl->gdbarch,
3605                                             &bl->overlay_target_info);
3606               }
3607           /* Did we set a breakpoint at the VMA? 
3608              If so, we will have marked the breakpoint 'inserted'.  */
3609           if (bl->inserted)
3610             {
3611               /* Yes -- remove it.  Previously we did not bother to
3612                  remove the breakpoint if the section had been
3613                  unmapped, but let's not rely on that being safe.  We
3614                  don't know what the overlay manager might do.  */
3615
3616               /* However, we should remove *software* breakpoints only
3617                  if the section is still mapped, or else we overwrite
3618                  wrong code with the saved shadow contents.  */
3619               if (bl->loc_type == bp_loc_hardware_breakpoint
3620                   || section_is_mapped (bl->section))
3621                 val = bl->owner->ops->remove_location (bl);
3622               else
3623                 val = 0;
3624             }
3625           else
3626             {
3627               /* No -- not inserted, so no need to remove.  No error.  */
3628               val = 0;
3629             }
3630         }
3631
3632       /* In some cases, we might not be able to remove a breakpoint
3633          in a shared library that has already been removed, but we
3634          have not yet processed the shlib unload event.  */
3635       if (val && solib_name_from_address (bl->pspace, bl->address))
3636         val = 0;
3637
3638       if (val)
3639         return val;
3640       bl->inserted = (is == mark_inserted);
3641     }
3642   else if (bl->loc_type == bp_loc_hardware_watchpoint)
3643     {
3644       gdb_assert (bl->owner->ops != NULL
3645                   && bl->owner->ops->remove_location != NULL);
3646
3647       bl->inserted = (is == mark_inserted);
3648       bl->owner->ops->remove_location (bl);
3649
3650       /* Failure to remove any of the hardware watchpoints comes here.  */
3651       if ((is == mark_uninserted) && (bl->inserted))
3652         warning (_("Could not remove hardware watchpoint %d."),
3653                  bl->owner->number);
3654     }
3655   else if (bl->owner->type == bp_catchpoint
3656            && breakpoint_enabled (bl->owner)
3657            && !bl->duplicate)
3658     {
3659       gdb_assert (bl->owner->ops != NULL
3660                   && bl->owner->ops->remove_location != NULL);
3661
3662       val = bl->owner->ops->remove_location (bl);
3663       if (val)
3664         return val;
3665
3666       bl->inserted = (is == mark_inserted);
3667     }
3668
3669   return 0;
3670 }
3671
3672 static int
3673 remove_breakpoint (struct bp_location *bl, insertion_state_t is)
3674 {
3675   int ret;
3676   struct cleanup *old_chain;
3677
3678   /* BL is never in moribund_locations by our callers.  */
3679   gdb_assert (bl->owner != NULL);
3680
3681   if (bl->owner->enable_state == bp_permanent)
3682     /* Permanent breakpoints cannot be inserted or removed.  */
3683     return 0;
3684
3685   /* The type of none suggests that owner is actually deleted.
3686      This should not ever happen.  */
3687   gdb_assert (bl->owner->type != bp_none);
3688
3689   old_chain = save_current_space_and_thread ();
3690
3691   switch_to_program_space_and_thread (bl->pspace);
3692
3693   ret = remove_breakpoint_1 (bl, is);
3694
3695   do_cleanups (old_chain);
3696   return ret;
3697 }
3698
3699 /* Clear the "inserted" flag in all breakpoints.  */
3700
3701 void
3702 mark_breakpoints_out (void)
3703 {
3704   struct bp_location *bl, **blp_tmp;
3705
3706   ALL_BP_LOCATIONS (bl, blp_tmp)
3707     if (bl->pspace == current_program_space)
3708       bl->inserted = 0;
3709 }
3710
3711 /* Clear the "inserted" flag in all breakpoints and delete any
3712    breakpoints which should go away between runs of the program.
3713
3714    Plus other such housekeeping that has to be done for breakpoints
3715    between runs.
3716
3717    Note: this function gets called at the end of a run (by
3718    generic_mourn_inferior) and when a run begins (by
3719    init_wait_for_inferior).  */
3720
3721
3722
3723 void
3724 breakpoint_init_inferior (enum inf_context context)
3725 {
3726   struct breakpoint *b, *b_tmp;
3727   struct bp_location *bl, **blp_tmp;
3728   int ix;
3729   struct program_space *pspace = current_program_space;
3730
3731   /* If breakpoint locations are shared across processes, then there's
3732      nothing to do.  */
3733   if (gdbarch_has_global_breakpoints (target_gdbarch))
3734     return;
3735
3736   ALL_BP_LOCATIONS (bl, blp_tmp)
3737   {
3738     /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL.  */
3739     if (bl->pspace == pspace
3740         && bl->owner->enable_state != bp_permanent)
3741       bl->inserted = 0;
3742   }
3743
3744   ALL_BREAKPOINTS_SAFE (b, b_tmp)
3745   {
3746     if (b->loc && b->loc->pspace != pspace)
3747       continue;
3748
3749     switch (b->type)
3750       {
3751       case bp_call_dummy:
3752       case bp_longjmp_call_dummy:
3753
3754         /* If the call dummy breakpoint is at the entry point it will
3755            cause problems when the inferior is rerun, so we better get
3756            rid of it.  */
3757
3758       case bp_watchpoint_scope:
3759
3760         /* Also get rid of scope breakpoints.  */
3761
3762       case bp_shlib_event:
3763
3764         /* Also remove solib event breakpoints.  Their addresses may
3765            have changed since the last time we ran the program.
3766            Actually we may now be debugging against different target;
3767            and so the solib backend that installed this breakpoint may
3768            not be used in by the target.  E.g.,
3769
3770            (gdb) file prog-linux
3771            (gdb) run               # native linux target
3772            ...
3773            (gdb) kill
3774            (gdb) file prog-win.exe
3775            (gdb) tar rem :9999     # remote Windows gdbserver.
3776         */
3777
3778       case bp_step_resume:
3779
3780         /* Also remove step-resume breakpoints.  */
3781
3782         delete_breakpoint (b);
3783         break;
3784
3785       case bp_watchpoint:
3786       case bp_hardware_watchpoint:
3787       case bp_read_watchpoint:
3788       case bp_access_watchpoint:
3789         {
3790           struct watchpoint *w = (struct watchpoint *) b;
3791
3792           /* Likewise for watchpoints on local expressions.  */
3793           if (w->exp_valid_block != NULL)
3794             delete_breakpoint (b);
3795           else if (context == inf_starting)
3796             {
3797               /* Reset val field to force reread of starting value in
3798                  insert_breakpoints.  */
3799               if (w->val)
3800                 value_free (w->val);
3801               w->val = NULL;
3802               w->val_valid = 0;
3803           }
3804         }
3805         break;
3806       default:
3807         break;
3808       }
3809   }
3810
3811   /* Get rid of the moribund locations.  */
3812   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
3813     decref_bp_location (&bl);
3814   VEC_free (bp_location_p, moribund_locations);
3815 }
3816
3817 /* These functions concern about actual breakpoints inserted in the
3818    target --- to e.g. check if we need to do decr_pc adjustment or if
3819    we need to hop over the bkpt --- so we check for address space
3820    match, not program space.  */
3821
3822 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
3823    exists at PC.  It returns ordinary_breakpoint_here if it's an
3824    ordinary breakpoint, or permanent_breakpoint_here if it's a
3825    permanent breakpoint.
3826    - When continuing from a location with an ordinary breakpoint, we
3827      actually single step once before calling insert_breakpoints.
3828    - When continuing from a location with a permanent breakpoint, we
3829      need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
3830      the target, to advance the PC past the breakpoint.  */
3831
3832 enum breakpoint_here
3833 breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
3834 {
3835   struct bp_location *bl, **blp_tmp;
3836   int any_breakpoint_here = 0;
3837
3838   ALL_BP_LOCATIONS (bl, blp_tmp)
3839     {
3840       if (bl->loc_type != bp_loc_software_breakpoint
3841           && bl->loc_type != bp_loc_hardware_breakpoint)
3842         continue;
3843
3844       /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL.  */
3845       if ((breakpoint_enabled (bl->owner)
3846            || bl->owner->enable_state == bp_permanent)
3847           && breakpoint_location_address_match (bl, aspace, pc))
3848         {
3849           if (overlay_debugging 
3850               && section_is_overlay (bl->section)
3851               && !section_is_mapped (bl->section))
3852             continue;           /* unmapped overlay -- can't be a match */
3853           else if (bl->owner->enable_state == bp_permanent)
3854             return permanent_breakpoint_here;
3855           else
3856             any_breakpoint_here = 1;
3857         }
3858     }
3859
3860   return any_breakpoint_here ? ordinary_breakpoint_here : 0;
3861 }
3862
3863 /* Return true if there's a moribund breakpoint at PC.  */
3864
3865 int
3866 moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
3867 {
3868   struct bp_location *loc;
3869   int ix;
3870
3871   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
3872     if (breakpoint_location_address_match (loc, aspace, pc))
3873       return 1;
3874
3875   return 0;
3876 }
3877
3878 /* Returns non-zero if there's a breakpoint inserted at PC, which is
3879    inserted using regular breakpoint_chain / bp_location array
3880    mechanism.  This does not check for single-step breakpoints, which
3881    are inserted and removed using direct target manipulation.  */
3882
3883 int
3884 regular_breakpoint_inserted_here_p (struct address_space *aspace, 
3885                                     CORE_ADDR pc)
3886 {
3887   struct bp_location *bl, **blp_tmp;
3888
3889   ALL_BP_LOCATIONS (bl, blp_tmp)
3890     {
3891       if (bl->loc_type != bp_loc_software_breakpoint
3892           && bl->loc_type != bp_loc_hardware_breakpoint)
3893         continue;
3894
3895       if (bl->inserted
3896           && breakpoint_location_address_match (bl, aspace, pc))
3897         {
3898           if (overlay_debugging 
3899               && section_is_overlay (bl->section)
3900               && !section_is_mapped (bl->section))
3901             continue;           /* unmapped overlay -- can't be a match */
3902           else
3903             return 1;
3904         }
3905     }
3906   return 0;
3907 }
3908
3909 /* Returns non-zero iff there's either regular breakpoint
3910    or a single step breakpoint inserted at PC.  */
3911
3912 int
3913 breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
3914 {
3915   if (regular_breakpoint_inserted_here_p (aspace, pc))
3916     return 1;
3917
3918   if (single_step_breakpoint_inserted_here_p (aspace, pc))
3919     return 1;
3920
3921   return 0;
3922 }
3923
3924 /* This function returns non-zero iff there is a software breakpoint
3925    inserted at PC.  */
3926
3927 int
3928 software_breakpoint_inserted_here_p (struct address_space *aspace,
3929                                      CORE_ADDR pc)
3930 {
3931   struct bp_location *bl, **blp_tmp;
3932
3933   ALL_BP_LOCATIONS (bl, blp_tmp)
3934     {
3935       if (bl->loc_type != bp_loc_software_breakpoint)
3936         continue;
3937
3938       if (bl->inserted
3939           && breakpoint_address_match (bl->pspace->aspace, bl->address,
3940                                        aspace, pc))
3941         {
3942           if (overlay_debugging 
3943               && section_is_overlay (bl->section)
3944               && !section_is_mapped (bl->section))
3945             continue;           /* unmapped overlay -- can't be a match */
3946           else
3947             return 1;
3948         }
3949     }
3950
3951   /* Also check for software single-step breakpoints.  */
3952   if (single_step_breakpoint_inserted_here_p (aspace, pc))
3953     return 1;
3954
3955   return 0;
3956 }
3957
3958 int
3959 hardware_watchpoint_inserted_in_range (struct address_space *aspace,
3960                                        CORE_ADDR addr, ULONGEST len)
3961 {
3962   struct breakpoint *bpt;
3963
3964   ALL_BREAKPOINTS (bpt)
3965     {
3966       struct bp_location *loc;
3967
3968       if (bpt->type != bp_hardware_watchpoint
3969           && bpt->type != bp_access_watchpoint)
3970         continue;
3971
3972       if (!breakpoint_enabled (bpt))
3973         continue;
3974
3975       for (loc = bpt->loc; loc; loc = loc->next)
3976         if (loc->pspace->aspace == aspace && loc->inserted)
3977           {
3978             CORE_ADDR l, h;
3979
3980             /* Check for intersection.  */
3981             l = max (loc->address, addr);
3982             h = min (loc->address + loc->length, addr + len);
3983             if (l < h)
3984               return 1;
3985           }
3986     }
3987   return 0;
3988 }
3989
3990 /* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
3991    PC is valid for process/thread PTID.  */
3992
3993 int
3994 breakpoint_thread_match (struct address_space *aspace, CORE_ADDR pc,
3995                          ptid_t ptid)
3996 {
3997   struct bp_location *bl, **blp_tmp;
3998   /* The thread and task IDs associated to PTID, computed lazily.  */
3999   int thread = -1;
4000   int task = 0;
4001   
4002   ALL_BP_LOCATIONS (bl, blp_tmp)
4003     {
4004       if (bl->loc_type != bp_loc_software_breakpoint
4005           && bl->loc_type != bp_loc_hardware_breakpoint)
4006         continue;
4007
4008       /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL.  */
4009       if (!breakpoint_enabled (bl->owner)
4010           && bl->owner->enable_state != bp_permanent)
4011         continue;
4012
4013       if (!breakpoint_location_address_match (bl, aspace, pc))
4014         continue;
4015
4016       if (bl->owner->thread != -1)
4017         {
4018           /* This is a thread-specific breakpoint.  Check that ptid
4019              matches that thread.  If thread hasn't been computed yet,
4020              it is now time to do so.  */
4021           if (thread == -1)
4022             thread = pid_to_thread_id (ptid);
4023           if (bl->owner->thread != thread)
4024             continue;
4025         }
4026
4027       if (bl->owner->task != 0)
4028         {
4029           /* This is a task-specific breakpoint.  Check that ptid
4030              matches that task.  If task hasn't been computed yet,
4031              it is now time to do so.  */
4032           if (task == 0)
4033             task = ada_get_task_number (ptid);
4034           if (bl->owner->task != task)
4035             continue;
4036         }
4037
4038       if (overlay_debugging 
4039           && section_is_overlay (bl->section)
4040           && !section_is_mapped (bl->section))
4041         continue;           /* unmapped overlay -- can't be a match */
4042
4043       return 1;
4044     }
4045
4046   return 0;
4047 }
4048 \f
4049
4050 /* bpstat stuff.  External routines' interfaces are documented
4051    in breakpoint.h.  */
4052
4053 int
4054 is_catchpoint (struct breakpoint *ep)
4055 {
4056   return (ep->type == bp_catchpoint);
4057 }
4058
4059 /* Frees any storage that is part of a bpstat.  Does not walk the
4060    'next' chain.  */
4061
4062 static void
4063 bpstat_free (bpstat bs)
4064 {
4065   if (bs->old_val != NULL)
4066     value_free (bs->old_val);
4067   decref_counted_command_line (&bs->commands);
4068   decref_bp_location (&bs->bp_location_at);
4069   xfree (bs);
4070 }
4071
4072 /* Clear a bpstat so that it says we are not at any breakpoint.
4073    Also free any storage that is part of a bpstat.  */
4074
4075 void
4076 bpstat_clear (bpstat *bsp)
4077 {
4078   bpstat p;
4079   bpstat q;
4080
4081   if (bsp == 0)
4082     return;
4083   p = *bsp;
4084   while (p != NULL)
4085     {
4086       q = p->next;
4087       bpstat_free (p);
4088       p = q;
4089     }
4090   *bsp = NULL;
4091 }
4092
4093 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
4094    is part of the bpstat is copied as well.  */
4095
4096 bpstat
4097 bpstat_copy (bpstat bs)
4098 {
4099   bpstat p = NULL;
4100   bpstat tmp;
4101   bpstat retval = NULL;
4102
4103   if (bs == NULL)
4104     return bs;
4105
4106   for (; bs != NULL; bs = bs->next)
4107     {
4108       tmp = (bpstat) xmalloc (sizeof (*tmp));
4109       memcpy (tmp, bs, sizeof (*tmp));
4110       incref_counted_command_line (tmp->commands);
4111       incref_bp_location (tmp->bp_location_at);
4112       if (bs->old_val != NULL)
4113         {
4114           tmp->old_val = value_copy (bs->old_val);
4115           release_value (tmp->old_val);
4116         }
4117
4118       if (p == NULL)
4119         /* This is the first thing in the chain.  */
4120         retval = tmp;
4121       else
4122         p->next = tmp;
4123       p = tmp;
4124     }
4125   p->next = NULL;
4126   return retval;
4127 }
4128
4129 /* Find the bpstat associated with this breakpoint.  */
4130
4131 bpstat
4132 bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
4133 {
4134   if (bsp == NULL)
4135     return NULL;
4136
4137   for (; bsp != NULL; bsp = bsp->next)
4138     {
4139       if (bsp->breakpoint_at == breakpoint)
4140         return bsp;
4141     }
4142   return NULL;
4143 }
4144
4145 /* Put in *NUM the breakpoint number of the first breakpoint we are
4146    stopped at.  *BSP upon return is a bpstat which points to the
4147    remaining breakpoints stopped at (but which is not guaranteed to be
4148    good for anything but further calls to bpstat_num).
4149
4150    Return 0 if passed a bpstat which does not indicate any breakpoints.
4151    Return -1 if stopped at a breakpoint that has been deleted since
4152    we set it.
4153    Return 1 otherwise.  */
4154
4155 int
4156 bpstat_num (bpstat *bsp, int *num)
4157 {
4158   struct breakpoint *b;
4159
4160   if ((*bsp) == NULL)
4161     return 0;                   /* No more breakpoint values */
4162
4163   /* We assume we'll never have several bpstats that correspond to a
4164      single breakpoint -- otherwise, this function might return the
4165      same number more than once and this will look ugly.  */
4166   b = (*bsp)->breakpoint_at;
4167   *bsp = (*bsp)->next;
4168   if (b == NULL)
4169     return -1;                  /* breakpoint that's been deleted since */
4170
4171   *num = b->number;             /* We have its number */
4172   return 1;
4173 }
4174
4175 /* See breakpoint.h.  */
4176
4177 void
4178 bpstat_clear_actions (void)
4179 {
4180   struct thread_info *tp;
4181   bpstat bs;
4182
4183   if (ptid_equal (inferior_ptid, null_ptid))
4184     return;
4185
4186   tp = find_thread_ptid (inferior_ptid);
4187   if (tp == NULL)
4188     return;
4189
4190   for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
4191     {
4192       decref_counted_command_line (&bs->commands);
4193
4194       if (bs->old_val != NULL)
4195         {
4196           value_free (bs->old_val);
4197           bs->old_val = NULL;
4198         }
4199     }
4200 }
4201
4202 /* Called when a command is about to proceed the inferior.  */
4203
4204 static void
4205 breakpoint_about_to_proceed (void)
4206 {
4207   if (!ptid_equal (inferior_ptid, null_ptid))
4208     {
4209       struct thread_info *tp = inferior_thread ();
4210
4211       /* Allow inferior function calls in breakpoint commands to not
4212          interrupt the command list.  When the call finishes
4213          successfully, the inferior will be standing at the same
4214          breakpoint as if nothing happened.  */
4215       if (tp->control.in_infcall)
4216         return;
4217     }
4218
4219   breakpoint_proceeded = 1;
4220 }
4221
4222 /* Stub for cleaning up our state if we error-out of a breakpoint
4223    command.  */
4224 static void
4225 cleanup_executing_breakpoints (void *ignore)
4226 {
4227   executing_breakpoint_commands = 0;
4228 }
4229
4230 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4231    or its equivalent.  */
4232
4233 static int
4234 command_line_is_silent (struct command_line *cmd)
4235 {
4236   return cmd && (strcmp ("silent", cmd->line) == 0
4237                  || (xdb_commands && strcmp ("Q", cmd->line) == 0));
4238 }
4239
4240 /* Execute all the commands associated with all the breakpoints at
4241    this location.  Any of these commands could cause the process to
4242    proceed beyond this point, etc.  We look out for such changes by
4243    checking the global "breakpoint_proceeded" after each command.
4244
4245    Returns true if a breakpoint command resumed the inferior.  In that
4246    case, it is the caller's responsibility to recall it again with the
4247    bpstat of the current thread.  */
4248
4249 static int
4250 bpstat_do_actions_1 (bpstat *bsp)
4251 {
4252   bpstat bs;
4253   struct cleanup *old_chain;
4254   int again = 0;
4255
4256   /* Avoid endless recursion if a `source' command is contained
4257      in bs->commands.  */
4258   if (executing_breakpoint_commands)
4259     return 0;
4260
4261   executing_breakpoint_commands = 1;
4262   old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
4263
4264   prevent_dont_repeat ();
4265
4266   /* This pointer will iterate over the list of bpstat's.  */
4267   bs = *bsp;
4268
4269   breakpoint_proceeded = 0;
4270   for (; bs != NULL; bs = bs->next)
4271     {
4272       struct counted_command_line *ccmd;
4273       struct command_line *cmd;
4274       struct cleanup *this_cmd_tree_chain;
4275
4276       /* Take ownership of the BSP's command tree, if it has one.
4277
4278          The command tree could legitimately contain commands like
4279          'step' and 'next', which call clear_proceed_status, which
4280          frees stop_bpstat's command tree.  To make sure this doesn't
4281          free the tree we're executing out from under us, we need to
4282          take ownership of the tree ourselves.  Since a given bpstat's
4283          commands are only executed once, we don't need to copy it; we
4284          can clear the pointer in the bpstat, and make sure we free
4285          the tree when we're done.  */
4286       ccmd = bs->commands;
4287       bs->commands = NULL;
4288       this_cmd_tree_chain = make_cleanup_decref_counted_command_line (&ccmd);
4289       cmd = ccmd ? ccmd->commands : NULL;
4290       if (command_line_is_silent (cmd))
4291         {
4292           /* The action has been already done by bpstat_stop_status.  */
4293           cmd = cmd->next;
4294         }
4295
4296       while (cmd != NULL)
4297         {
4298           execute_control_command (cmd);
4299
4300           if (breakpoint_proceeded)
4301             break;
4302           else
4303             cmd = cmd->next;
4304         }
4305
4306       /* We can free this command tree now.  */
4307       do_cleanups (this_cmd_tree_chain);
4308
4309       if (breakpoint_proceeded)
4310         {
4311           if (target_can_async_p ())
4312             /* If we are in async mode, then the target might be still
4313                running, not stopped at any breakpoint, so nothing for
4314                us to do here -- just return to the event loop.  */
4315             ;
4316           else
4317             /* In sync mode, when execute_control_command returns
4318                we're already standing on the next breakpoint.
4319                Breakpoint commands for that stop were not run, since
4320                execute_command does not run breakpoint commands --
4321                only command_line_handler does, but that one is not
4322                involved in execution of breakpoint commands.  So, we
4323                can now execute breakpoint commands.  It should be
4324                noted that making execute_command do bpstat actions is
4325                not an option -- in this case we'll have recursive
4326                invocation of bpstat for each breakpoint with a
4327                command, and can easily blow up GDB stack.  Instead, we
4328                return true, which will trigger the caller to recall us
4329                with the new stop_bpstat.  */
4330             again = 1;
4331           break;
4332         }
4333     }
4334   do_cleanups (old_chain);
4335   return again;
4336 }
4337
4338 void
4339 bpstat_do_actions (void)
4340 {
4341   struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
4342
4343   /* Do any commands attached to breakpoint we are stopped at.  */
4344   while (!ptid_equal (inferior_ptid, null_ptid)
4345          && target_has_execution
4346          && !is_exited (inferior_ptid)
4347          && !is_executing (inferior_ptid))
4348     /* Since in sync mode, bpstat_do_actions may resume the inferior,
4349        and only return when it is stopped at the next breakpoint, we
4350        keep doing breakpoint actions until it returns false to
4351        indicate the inferior was not resumed.  */
4352     if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
4353       break;
4354
4355   discard_cleanups (cleanup_if_error);
4356 }
4357
4358 /* Print out the (old or new) value associated with a watchpoint.  */
4359
4360 static void
4361 watchpoint_value_print (struct value *val, struct ui_file *stream)
4362 {
4363   if (val == NULL)
4364     fprintf_unfiltered (stream, _("<unreadable>"));
4365   else
4366     {
4367       struct value_print_options opts;
4368       get_user_print_options (&opts);
4369       value_print (val, stream, &opts);
4370     }
4371 }
4372
4373 /* Generic routine for printing messages indicating why we
4374    stopped.  The behavior of this function depends on the value
4375    'print_it' in the bpstat structure.  Under some circumstances we
4376    may decide not to print anything here and delegate the task to
4377    normal_stop().  */
4378
4379 static enum print_stop_action
4380 print_bp_stop_message (bpstat bs)
4381 {
4382   switch (bs->print_it)
4383     {
4384     case print_it_noop:
4385       /* Nothing should be printed for this bpstat entry.  */
4386       return PRINT_UNKNOWN;
4387       break;
4388
4389     case print_it_done:
4390       /* We still want to print the frame, but we already printed the
4391          relevant messages.  */
4392       return PRINT_SRC_AND_LOC;
4393       break;
4394
4395     case print_it_normal:
4396       {
4397         struct breakpoint *b = bs->breakpoint_at;
4398
4399         /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4400            which has since been deleted.  */
4401         if (b == NULL)
4402           return PRINT_UNKNOWN;
4403
4404         /* Normal case.  Call the breakpoint's print_it method.  */
4405         return b->ops->print_it (bs);
4406       }
4407       break;
4408
4409     default:
4410       internal_error (__FILE__, __LINE__,
4411                       _("print_bp_stop_message: unrecognized enum value"));
4412       break;
4413     }
4414 }
4415
4416 /* A helper function that prints a shared library stopped event.  */
4417
4418 static void
4419 print_solib_event (int is_catchpoint)
4420 {
4421   int any_deleted
4422     = !VEC_empty (char_ptr, current_program_space->deleted_solibs);
4423   int any_added
4424     = !VEC_empty (so_list_ptr, current_program_space->added_solibs);
4425
4426   if (!is_catchpoint)
4427     {
4428       if (any_added || any_deleted)
4429         ui_out_text (current_uiout,
4430                      _("Stopped due to shared library event:\n"));
4431       else
4432         ui_out_text (current_uiout,
4433                      _("Stopped due to shared library event (no "
4434                        "libraries added or removed)\n"));
4435     }
4436
4437   if (ui_out_is_mi_like_p (current_uiout))
4438     ui_out_field_string (current_uiout, "reason",
4439                          async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
4440
4441   if (any_deleted)
4442     {
4443       struct cleanup *cleanup;
4444       char *name;
4445       int ix;
4446
4447       ui_out_text (current_uiout, _("  Inferior unloaded "));
4448       cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
4449                                                     "removed");
4450       for (ix = 0;
4451            VEC_iterate (char_ptr, current_program_space->deleted_solibs,
4452                         ix, name);
4453            ++ix)
4454         {
4455           if (ix > 0)
4456             ui_out_text (current_uiout, "    ");
4457           ui_out_field_string (current_uiout, "library", name);
4458           ui_out_text (current_uiout, "\n");
4459         }
4460
4461       do_cleanups (cleanup);
4462     }
4463
4464   if (any_added)
4465     {
4466       struct so_list *iter;
4467       int ix;
4468       struct cleanup *cleanup;
4469
4470       ui_out_text (current_uiout, _("  Inferior loaded "));
4471       cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
4472                                                     "added");
4473       for (ix = 0;
4474            VEC_iterate (so_list_ptr, current_program_space->added_solibs,
4475                         ix, iter);
4476            ++ix)
4477         {
4478           if (ix > 0)
4479             ui_out_text (current_uiout, "    ");
4480           ui_out_field_string (current_uiout, "library", iter->so_name);
4481           ui_out_text (current_uiout, "\n");
4482         }
4483
4484       do_cleanups (cleanup);
4485     }
4486 }
4487
4488 /* Print a message indicating what happened.  This is called from
4489    normal_stop().  The input to this routine is the head of the bpstat
4490    list - a list of the eventpoints that caused this stop.  KIND is
4491    the target_waitkind for the stopping event.  This
4492    routine calls the generic print routine for printing a message
4493    about reasons for stopping.  This will print (for example) the
4494    "Breakpoint n," part of the output.  The return value of this
4495    routine is one of:
4496
4497    PRINT_UNKNOWN: Means we printed nothing.
4498    PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4499    code to print the location.  An example is 
4500    "Breakpoint 1, " which should be followed by
4501    the location.
4502    PRINT_SRC_ONLY: Means we printed something, but there is no need
4503    to also print the location part of the message.
4504    An example is the catch/throw messages, which
4505    don't require a location appended to the end.
4506    PRINT_NOTHING: We have done some printing and we don't need any 
4507    further info to be printed.  */
4508
4509 enum print_stop_action
4510 bpstat_print (bpstat bs, int kind)
4511 {
4512   int val;
4513
4514   /* Maybe another breakpoint in the chain caused us to stop.
4515      (Currently all watchpoints go on the bpstat whether hit or not.
4516      That probably could (should) be changed, provided care is taken
4517      with respect to bpstat_explains_signal).  */
4518   for (; bs; bs = bs->next)
4519     {
4520       val = print_bp_stop_message (bs);
4521       if (val == PRINT_SRC_ONLY 
4522           || val == PRINT_SRC_AND_LOC 
4523           || val == PRINT_NOTHING)
4524         return val;
4525     }
4526
4527   /* If we had hit a shared library event breakpoint,
4528      print_bp_stop_message would print out this message.  If we hit an
4529      OS-level shared library event, do the same thing.  */
4530   if (kind == TARGET_WAITKIND_LOADED)
4531     {
4532       print_solib_event (0);
4533       return PRINT_NOTHING;
4534     }
4535
4536   /* We reached the end of the chain, or we got a null BS to start
4537      with and nothing was printed.  */
4538   return PRINT_UNKNOWN;
4539 }
4540
4541 /* Evaluate the expression EXP and return 1 if value is zero.  This is
4542    used inside a catch_errors to evaluate the breakpoint condition.
4543    The argument is a "struct expression *" that has been cast to a
4544    "char *" to make it pass through catch_errors.  */
4545
4546 static int
4547 breakpoint_cond_eval (void *exp)
4548 {
4549   struct value *mark = value_mark ();
4550   int i = !value_true (evaluate_expression ((struct expression *) exp));
4551
4552   value_free_to_mark (mark);
4553   return i;
4554 }
4555
4556 /* Allocate a new bpstat.  Link it to the FIFO list by BS_LINK_POINTER.  */
4557
4558 static bpstat
4559 bpstat_alloc (struct bp_location *bl, bpstat **bs_link_pointer)
4560 {
4561   bpstat bs;
4562
4563   bs = (bpstat) xmalloc (sizeof (*bs));
4564   bs->next = NULL;
4565   **bs_link_pointer = bs;
4566   *bs_link_pointer = &bs->next;
4567   bs->breakpoint_at = bl->owner;
4568   bs->bp_location_at = bl;
4569   incref_bp_location (bl);
4570   /* If the condition is false, etc., don't do the commands.  */
4571   bs->commands = NULL;
4572   bs->old_val = NULL;
4573   bs->print_it = print_it_normal;
4574   return bs;
4575 }
4576 \f
4577 /* The target has stopped with waitstatus WS.  Check if any hardware
4578    watchpoints have triggered, according to the target.  */
4579
4580 int
4581 watchpoints_triggered (struct target_waitstatus *ws)
4582 {
4583   int stopped_by_watchpoint = target_stopped_by_watchpoint ();
4584   CORE_ADDR addr;
4585   struct breakpoint *b;
4586
4587   if (!stopped_by_watchpoint)
4588     {
4589       /* We were not stopped by a watchpoint.  Mark all watchpoints
4590          as not triggered.  */
4591       ALL_BREAKPOINTS (b)
4592         if (is_hardware_watchpoint (b))
4593           {
4594             struct watchpoint *w = (struct watchpoint *) b;
4595
4596             w->watchpoint_triggered = watch_triggered_no;
4597           }
4598
4599       return 0;
4600     }
4601
4602   if (!target_stopped_data_address (&current_target, &addr))
4603     {
4604       /* We were stopped by a watchpoint, but we don't know where.
4605          Mark all watchpoints as unknown.  */
4606       ALL_BREAKPOINTS (b)
4607         if (is_hardware_watchpoint (b))
4608           {
4609             struct watchpoint *w = (struct watchpoint *) b;
4610
4611             w->watchpoint_triggered = watch_triggered_unknown;
4612           }
4613
4614       return stopped_by_watchpoint;
4615     }
4616
4617   /* The target could report the data address.  Mark watchpoints
4618      affected by this data address as triggered, and all others as not
4619      triggered.  */
4620
4621   ALL_BREAKPOINTS (b)
4622     if (is_hardware_watchpoint (b))
4623       {
4624         struct watchpoint *w = (struct watchpoint *) b;
4625         struct bp_location *loc;
4626
4627         w->watchpoint_triggered = watch_triggered_no;
4628         for (loc = b->loc; loc; loc = loc->next)
4629           {
4630             if (is_masked_watchpoint (b))
4631               {
4632                 CORE_ADDR newaddr = addr & w->hw_wp_mask;
4633                 CORE_ADDR start = loc->address & w->hw_wp_mask;
4634
4635                 if (newaddr == start)
4636                   {
4637                     w->watchpoint_triggered = watch_triggered_yes;
4638                     break;
4639                   }
4640               }
4641             /* Exact match not required.  Within range is sufficient.  */
4642             else if (target_watchpoint_addr_within_range (&current_target,
4643                                                          addr, loc->address,
4644                                                          loc->length))
4645               {
4646                 w->watchpoint_triggered = watch_triggered_yes;
4647                 break;
4648               }
4649           }
4650       }
4651
4652   return 1;
4653 }
4654
4655 /* Possible return values for watchpoint_check (this can't be an enum
4656    because of check_errors).  */
4657 /* The watchpoint has been deleted.  */
4658 #define WP_DELETED 1
4659 /* The value has changed.  */
4660 #define WP_VALUE_CHANGED 2
4661 /* The value has not changed.  */
4662 #define WP_VALUE_NOT_CHANGED 3
4663 /* Ignore this watchpoint, no matter if the value changed or not.  */
4664 #define WP_IGNORE 4
4665
4666 #define BP_TEMPFLAG 1
4667 #define BP_HARDWAREFLAG 2
4668
4669 /* Evaluate watchpoint condition expression and check if its value
4670    changed.
4671
4672    P should be a pointer to struct bpstat, but is defined as a void *
4673    in order for this function to be usable with catch_errors.  */
4674
4675 static int
4676 watchpoint_check (void *p)
4677 {
4678   bpstat bs = (bpstat) p;
4679   struct watchpoint *b;
4680   struct frame_info *fr;
4681   int within_current_scope;
4682
4683   /* BS is built from an existing struct breakpoint.  */
4684   gdb_assert (bs->breakpoint_at != NULL);
4685   b = (struct watchpoint *) bs->breakpoint_at;
4686
4687   /* If this is a local watchpoint, we only want to check if the
4688      watchpoint frame is in scope if the current thread is the thread
4689      that was used to create the watchpoint.  */
4690   if (!watchpoint_in_thread_scope (b))
4691     return WP_IGNORE;
4692
4693   if (b->exp_valid_block == NULL)
4694     within_current_scope = 1;
4695   else
4696     {
4697       struct frame_info *frame = get_current_frame ();
4698       struct gdbarch *frame_arch = get_frame_arch (frame);
4699       CORE_ADDR frame_pc = get_frame_pc (frame);
4700
4701       /* in_function_epilogue_p() returns a non-zero value if we're
4702          still in the function but the stack frame has already been
4703          invalidated.  Since we can't rely on the values of local
4704          variables after the stack has been destroyed, we are treating
4705          the watchpoint in that state as `not changed' without further
4706          checking.  Don't mark watchpoints as changed if the current
4707          frame is in an epilogue - even if they are in some other
4708          frame, our view of the stack is likely to be wrong and
4709          frame_find_by_id could error out.  */
4710       if (gdbarch_in_function_epilogue_p (frame_arch, frame_pc))
4711         return WP_IGNORE;
4712
4713       fr = frame_find_by_id (b->watchpoint_frame);
4714       within_current_scope = (fr != NULL);
4715
4716       /* If we've gotten confused in the unwinder, we might have
4717          returned a frame that can't describe this variable.  */
4718       if (within_current_scope)
4719         {
4720           struct symbol *function;
4721
4722           function = get_frame_function (fr);
4723           if (function == NULL
4724               || !contained_in (b->exp_valid_block,
4725                                 SYMBOL_BLOCK_VALUE (function)))
4726             within_current_scope = 0;
4727         }
4728
4729       if (within_current_scope)
4730         /* If we end up stopping, the current frame will get selected
4731            in normal_stop.  So this call to select_frame won't affect
4732            the user.  */
4733         select_frame (fr);
4734     }
4735
4736   if (within_current_scope)
4737     {
4738       /* We use value_{,free_to_}mark because it could be a *long*
4739          time before we return to the command level and call
4740          free_all_values.  We can't call free_all_values because we
4741          might be in the middle of evaluating a function call.  */
4742
4743       int pc = 0;
4744       struct value *mark;
4745       struct value *new_val;
4746
4747       if (is_masked_watchpoint (&b->base))
4748         /* Since we don't know the exact trigger address (from
4749            stopped_data_address), just tell the user we've triggered
4750            a mask watchpoint.  */
4751         return WP_VALUE_CHANGED;
4752
4753       mark = value_mark ();
4754       fetch_subexp_value (b->exp, &pc, &new_val, NULL, NULL);
4755
4756       /* We use value_equal_contents instead of value_equal because
4757          the latter coerces an array to a pointer, thus comparing just
4758          the address of the array instead of its contents.  This is
4759          not what we want.  */
4760       if ((b->val != NULL) != (new_val != NULL)
4761           || (b->val != NULL && !value_equal_contents (b->val, new_val)))
4762         {
4763           if (new_val != NULL)
4764             {
4765               release_value (new_val);
4766               value_free_to_mark (mark);
4767             }
4768           bs->old_val = b->val;
4769           b->val = new_val;
4770           b->val_valid = 1;
4771           return WP_VALUE_CHANGED;
4772         }
4773       else
4774         {
4775           /* Nothing changed.  */
4776           value_free_to_mark (mark);
4777           return WP_VALUE_NOT_CHANGED;
4778         }
4779     }
4780   else
4781     {
4782       struct ui_out *uiout = current_uiout;
4783
4784       /* This seems like the only logical thing to do because
4785          if we temporarily ignored the watchpoint, then when
4786          we reenter the block in which it is valid it contains
4787          garbage (in the case of a function, it may have two
4788          garbage values, one before and one after the prologue).
4789          So we can't even detect the first assignment to it and
4790          watch after that (since the garbage may or may not equal
4791          the first value assigned).  */
4792       /* We print all the stop information in
4793          breakpoint_ops->print_it, but in this case, by the time we
4794          call breakpoint_ops->print_it this bp will be deleted
4795          already.  So we have no choice but print the information
4796          here.  */
4797       if (ui_out_is_mi_like_p (uiout))
4798         ui_out_field_string
4799           (uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
4800       ui_out_text (uiout, "\nWatchpoint ");
4801       ui_out_field_int (uiout, "wpnum", b->base.number);
4802       ui_out_text (uiout,
4803                    " deleted because the program has left the block in\n\
4804 which its expression is valid.\n");     
4805
4806       /* Make sure the watchpoint's commands aren't executed.  */
4807       decref_counted_command_line (&b->base.commands);
4808       watchpoint_del_at_next_stop (b);
4809
4810       return WP_DELETED;
4811     }
4812 }
4813
4814 /* Return true if it looks like target has stopped due to hitting
4815    breakpoint location BL.  This function does not check if we should
4816    stop, only if BL explains the stop.  */
4817
4818 static int
4819 bpstat_check_location (const struct bp_location *bl,
4820                        struct address_space *aspace, CORE_ADDR bp_addr,
4821                        const struct target_waitstatus *ws)
4822 {
4823   struct breakpoint *b = bl->owner;
4824
4825   /* BL is from an existing breakpoint.  */
4826   gdb_assert (b != NULL);
4827
4828   return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
4829 }
4830
4831 /* Determine if the watched values have actually changed, and we
4832    should stop.  If not, set BS->stop to 0.  */
4833
4834 static void
4835 bpstat_check_watchpoint (bpstat bs)
4836 {
4837   const struct bp_location *bl;
4838   struct watchpoint *b;
4839
4840   /* BS is built for existing struct breakpoint.  */
4841   bl = bs->bp_location_at;
4842   gdb_assert (bl != NULL);
4843   b = (struct watchpoint *) bs->breakpoint_at;
4844   gdb_assert (b != NULL);
4845
4846     {
4847       int must_check_value = 0;
4848       
4849       if (b->base.type == bp_watchpoint)
4850         /* For a software watchpoint, we must always check the
4851            watched value.  */
4852         must_check_value = 1;
4853       else if (b->watchpoint_triggered == watch_triggered_yes)
4854         /* We have a hardware watchpoint (read, write, or access)
4855            and the target earlier reported an address watched by
4856            this watchpoint.  */
4857         must_check_value = 1;
4858       else if (b->watchpoint_triggered == watch_triggered_unknown
4859                && b->base.type == bp_hardware_watchpoint)
4860         /* We were stopped by a hardware watchpoint, but the target could
4861            not report the data address.  We must check the watchpoint's
4862            value.  Access and read watchpoints are out of luck; without
4863            a data address, we can't figure it out.  */
4864         must_check_value = 1;
4865
4866       if (must_check_value)
4867         {
4868           char *message
4869             = xstrprintf ("Error evaluating expression for watchpoint %d\n",
4870                           b->base.number);
4871           struct cleanup *cleanups = make_cleanup (xfree, message);
4872           int e = catch_errors (watchpoint_check, bs, message,
4873                                 RETURN_MASK_ALL);
4874           do_cleanups (cleanups);
4875           switch (e)
4876             {
4877             case WP_DELETED:
4878               /* We've already printed what needs to be printed.  */
4879               bs->print_it = print_it_done;
4880               /* Stop.  */
4881               break;
4882             case WP_IGNORE:
4883               bs->print_it = print_it_noop;
4884               bs->stop = 0;
4885               break;
4886             case WP_VALUE_CHANGED:
4887               if (b->base.type == bp_read_watchpoint)
4888                 {
4889                   /* There are two cases to consider here:
4890
4891                      1. We're watching the triggered memory for reads.
4892                      In that case, trust the target, and always report
4893                      the watchpoint hit to the user.  Even though
4894                      reads don't cause value changes, the value may
4895                      have changed since the last time it was read, and
4896                      since we're not trapping writes, we will not see
4897                      those, and as such we should ignore our notion of
4898                      old value.
4899
4900                      2. We're watching the triggered memory for both
4901                      reads and writes.  There are two ways this may
4902                      happen:
4903
4904                      2.1. This is a target that can't break on data
4905                      reads only, but can break on accesses (reads or
4906                      writes), such as e.g., x86.  We detect this case
4907                      at the time we try to insert read watchpoints.
4908
4909                      2.2. Otherwise, the target supports read
4910                      watchpoints, but, the user set an access or write
4911                      watchpoint watching the same memory as this read
4912                      watchpoint.
4913
4914                      If we're watching memory writes as well as reads,
4915                      ignore watchpoint hits when we find that the
4916                      value hasn't changed, as reads don't cause
4917                      changes.  This still gives false positives when
4918                      the program writes the same value to memory as
4919                      what there was already in memory (we will confuse
4920                      it for a read), but it's much better than
4921                      nothing.  */
4922
4923                   int other_write_watchpoint = 0;
4924
4925                   if (bl->watchpoint_type == hw_read)
4926                     {
4927                       struct breakpoint *other_b;
4928
4929                       ALL_BREAKPOINTS (other_b)
4930                         if (other_b->type == bp_hardware_watchpoint
4931                             || other_b->type == bp_access_watchpoint)
4932                           {
4933                             struct watchpoint *other_w =
4934                               (struct watchpoint *) other_b;
4935
4936                             if (other_w->watchpoint_triggered
4937                                 == watch_triggered_yes)
4938                               {
4939                                 other_write_watchpoint = 1;
4940                                 break;
4941                               }
4942                           }
4943                     }
4944
4945                   if (other_write_watchpoint
4946                       || bl->watchpoint_type == hw_access)
4947                     {
4948                       /* We're watching the same memory for writes,
4949                          and the value changed since the last time we
4950                          updated it, so this trap must be for a write.
4951                          Ignore it.  */
4952                       bs->print_it = print_it_noop;
4953                       bs->stop = 0;
4954                     }
4955                 }
4956               break;
4957             case WP_VALUE_NOT_CHANGED:
4958               if (b->base.type == bp_hardware_watchpoint
4959                   || b->base.type == bp_watchpoint)
4960                 {
4961                   /* Don't stop: write watchpoints shouldn't fire if
4962                      the value hasn't changed.  */
4963                   bs->print_it = print_it_noop;
4964                   bs->stop = 0;
4965                 }
4966               /* Stop.  */
4967               break;
4968             default:
4969               /* Can't happen.  */
4970             case 0:
4971               /* Error from catch_errors.  */
4972               printf_filtered (_("Watchpoint %d deleted.\n"), b->base.number);
4973               watchpoint_del_at_next_stop (b);
4974               /* We've already printed what needs to be printed.  */
4975               bs->print_it = print_it_done;
4976               break;
4977             }
4978         }
4979       else      /* must_check_value == 0 */
4980         {
4981           /* This is a case where some watchpoint(s) triggered, but
4982              not at the address of this watchpoint, or else no
4983              watchpoint triggered after all.  So don't print
4984              anything for this watchpoint.  */
4985           bs->print_it = print_it_noop;
4986           bs->stop = 0;
4987         }
4988     }
4989 }
4990
4991
4992 /* Check conditions (condition proper, frame, thread and ignore count)
4993    of breakpoint referred to by BS.  If we should not stop for this
4994    breakpoint, set BS->stop to 0.  */
4995
4996 static void
4997 bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
4998 {
4999   int thread_id = pid_to_thread_id (ptid);
5000   const struct bp_location *bl;
5001   struct breakpoint *b;
5002
5003   /* BS is built for existing struct breakpoint.  */
5004   bl = bs->bp_location_at;
5005   gdb_assert (bl != NULL);
5006   b = bs->breakpoint_at;
5007   gdb_assert (b != NULL);
5008
5009   /* Even if the target evaluated the condition on its end and notified GDB, we
5010      need to do so again since GDB does not know if we stopped due to a
5011      breakpoint or a single step breakpoint.  */
5012
5013   if (frame_id_p (b->frame_id)
5014       && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
5015     bs->stop = 0;
5016   else if (bs->stop)
5017     {
5018       int value_is_zero = 0;
5019       struct expression *cond;
5020
5021       /* Evaluate Python breakpoints that have a "stop"
5022          method implemented.  */
5023       if (b->py_bp_object)
5024         bs->stop = gdbpy_should_stop (b->py_bp_object);
5025
5026       if (is_watchpoint (b))
5027         {
5028           struct watchpoint *w = (struct watchpoint *) b;
5029
5030           cond = w->cond_exp;
5031         }
5032       else
5033         cond = bl->cond;
5034
5035       if (cond && b->disposition != disp_del_at_next_stop)
5036         {
5037           int within_current_scope = 1;
5038           struct watchpoint * w;
5039
5040           /* We use value_mark and value_free_to_mark because it could
5041              be a long time before we return to the command level and
5042              call free_all_values.  We can't call free_all_values
5043              because we might be in the middle of evaluating a
5044              function call.  */
5045           struct value *mark = value_mark ();
5046
5047           if (is_watchpoint (b))
5048             w = (struct watchpoint *) b;
5049           else
5050             w = NULL;
5051
5052           /* Need to select the frame, with all that implies so that
5053              the conditions will have the right context.  Because we
5054              use the frame, we will not see an inlined function's
5055              variables when we arrive at a breakpoint at the start
5056              of the inlined function; the current frame will be the
5057              call site.  */
5058           if (w == NULL || w->cond_exp_valid_block == NULL)
5059             select_frame (get_current_frame ());
5060           else
5061             {
5062               struct frame_info *frame;
5063
5064               /* For local watchpoint expressions, which particular
5065                  instance of a local is being watched matters, so we
5066                  keep track of the frame to evaluate the expression
5067                  in.  To evaluate the condition however, it doesn't
5068                  really matter which instantiation of the function
5069                  where the condition makes sense triggers the
5070                  watchpoint.  This allows an expression like "watch
5071                  global if q > 10" set in `func', catch writes to
5072                  global on all threads that call `func', or catch
5073                  writes on all recursive calls of `func' by a single
5074                  thread.  We simply always evaluate the condition in
5075                  the innermost frame that's executing where it makes
5076                  sense to evaluate the condition.  It seems
5077                  intuitive.  */
5078               frame = block_innermost_frame (w->cond_exp_valid_block);
5079               if (frame != NULL)
5080                 select_frame (frame);
5081               else
5082                 within_current_scope = 0;
5083             }
5084           if (within_current_scope)
5085             value_is_zero
5086               = catch_errors (breakpoint_cond_eval, cond,
5087                               "Error in testing breakpoint condition:\n",
5088                               RETURN_MASK_ALL);
5089           else
5090             {
5091               warning (_("Watchpoint condition cannot be tested "
5092                          "in the current scope"));
5093               /* If we failed to set the right context for this
5094                  watchpoint, unconditionally report it.  */
5095               value_is_zero = 0;
5096             }
5097           /* FIXME-someday, should give breakpoint #.  */
5098           value_free_to_mark (mark);
5099         }
5100
5101       if (cond && value_is_zero)
5102         {
5103           bs->stop = 0;
5104         }
5105       else if (b->thread != -1 && b->thread != thread_id)
5106         {
5107           bs->stop = 0;
5108         }
5109       else if (b->ignore_count > 0)
5110         {
5111           b->ignore_count--;
5112           annotate_ignore_count_change ();
5113           bs->stop = 0;
5114           /* Increase the hit count even though we don't stop.  */
5115           ++(b->hit_count);
5116           observer_notify_breakpoint_modified (b);
5117         }       
5118     }
5119 }
5120
5121
5122 /* Get a bpstat associated with having just stopped at address
5123    BP_ADDR in thread PTID.
5124
5125    Determine whether we stopped at a breakpoint, etc, or whether we
5126    don't understand this stop.  Result is a chain of bpstat's such
5127    that:
5128
5129    if we don't understand the stop, the result is a null pointer.
5130
5131    if we understand why we stopped, the result is not null.
5132
5133    Each element of the chain refers to a particular breakpoint or
5134    watchpoint at which we have stopped.  (We may have stopped for
5135    several reasons concurrently.)
5136
5137    Each element of the chain has valid next, breakpoint_at,
5138    commands, FIXME??? fields.  */
5139
5140 bpstat
5141 bpstat_stop_status (struct address_space *aspace,
5142                     CORE_ADDR bp_addr, ptid_t ptid,
5143                     const struct target_waitstatus *ws)
5144 {
5145   struct breakpoint *b = NULL;
5146   struct bp_location *bl;
5147   struct bp_location *loc;
5148   /* First item of allocated bpstat's.  */
5149   bpstat bs_head = NULL, *bs_link = &bs_head;
5150   /* Pointer to the last thing in the chain currently.  */
5151   bpstat bs;
5152   int ix;
5153   int need_remove_insert;
5154   int removed_any;
5155
5156   /* First, build the bpstat chain with locations that explain a
5157      target stop, while being careful to not set the target running,
5158      as that may invalidate locations (in particular watchpoint
5159      locations are recreated).  Resuming will happen here with
5160      breakpoint conditions or watchpoint expressions that include
5161      inferior function calls.  */
5162
5163   ALL_BREAKPOINTS (b)
5164     {
5165       if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
5166         continue;
5167
5168       for (bl = b->loc; bl != NULL; bl = bl->next)
5169         {
5170           /* For hardware watchpoints, we look only at the first
5171              location.  The watchpoint_check function will work on the
5172              entire expression, not the individual locations.  For
5173              read watchpoints, the watchpoints_triggered function has
5174              checked all locations already.  */
5175           if (b->type == bp_hardware_watchpoint && bl != b->loc)
5176             break;
5177
5178           if (bl->shlib_disabled)
5179             continue;
5180
5181           if (!bpstat_check_location (bl, aspace, bp_addr, ws))
5182             continue;
5183
5184           /* Come here if it's a watchpoint, or if the break address
5185              matches.  */
5186
5187           bs = bpstat_alloc (bl, &bs_link);     /* Alloc a bpstat to
5188                                                    explain stop.  */
5189
5190           /* Assume we stop.  Should we find a watchpoint that is not
5191              actually triggered, or if the condition of the breakpoint
5192              evaluates as false, we'll reset 'stop' to 0.  */
5193           bs->stop = 1;
5194           bs->print = 1;
5195
5196           /* If this is a scope breakpoint, mark the associated
5197              watchpoint as triggered so that we will handle the
5198              out-of-scope event.  We'll get to the watchpoint next
5199              iteration.  */
5200           if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
5201             {
5202               struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5203
5204               w->watchpoint_triggered = watch_triggered_yes;
5205             }
5206         }
5207     }
5208
5209   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
5210     {
5211       if (breakpoint_location_address_match (loc, aspace, bp_addr))
5212         {
5213           bs = bpstat_alloc (loc, &bs_link);
5214           /* For hits of moribund locations, we should just proceed.  */
5215           bs->stop = 0;
5216           bs->print = 0;
5217           bs->print_it = print_it_noop;
5218         }
5219     }
5220
5221   /* A bit of special processing for shlib breakpoints.  We need to
5222      process solib loading here, so that the lists of loaded and
5223      unloaded libraries are correct before we handle "catch load" and
5224      "catch unload".  */
5225   for (bs = bs_head; bs != NULL; bs = bs->next)
5226     {
5227       if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
5228         {
5229           handle_solib_event ();
5230           break;
5231         }
5232     }
5233
5234   /* Now go through the locations that caused the target to stop, and
5235      check whether we're interested in reporting this stop to higher
5236      layers, or whether we should resume the target transparently.  */
5237
5238   removed_any = 0;
5239
5240   for (bs = bs_head; bs != NULL; bs = bs->next)
5241     {
5242       if (!bs->stop)
5243         continue;
5244
5245       b = bs->breakpoint_at;
5246       b->ops->check_status (bs);
5247       if (bs->stop)
5248         {
5249           bpstat_check_breakpoint_conditions (bs, ptid);
5250
5251           if (bs->stop)
5252             {
5253               ++(b->hit_count);
5254               observer_notify_breakpoint_modified (b);
5255
5256               /* We will stop here.  */
5257               if (b->disposition == disp_disable)
5258                 {
5259                   --(b->enable_count);
5260                   if (b->enable_count <= 0
5261                       && b->enable_state != bp_permanent)
5262                     b->enable_state = bp_disabled;
5263                   removed_any = 1;
5264                 }
5265               if (b->silent)
5266                 bs->print = 0;
5267               bs->commands = b->commands;
5268               incref_counted_command_line (bs->commands);
5269               if (command_line_is_silent (bs->commands
5270                                           ? bs->commands->commands : NULL))
5271                 bs->print = 0;
5272             }
5273
5274         }
5275
5276       /* Print nothing for this entry if we don't stop or don't
5277          print.  */
5278       if (!bs->stop || !bs->print)
5279         bs->print_it = print_it_noop;
5280     }
5281
5282   /* If we aren't stopping, the value of some hardware watchpoint may
5283      not have changed, but the intermediate memory locations we are
5284      watching may have.  Don't bother if we're stopping; this will get
5285      done later.  */
5286   need_remove_insert = 0;
5287   if (! bpstat_causes_stop (bs_head))
5288     for (bs = bs_head; bs != NULL; bs = bs->next)
5289       if (!bs->stop
5290           && bs->breakpoint_at
5291           && is_hardware_watchpoint (bs->breakpoint_at))
5292         {
5293           struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5294
5295           update_watchpoint (w, 0 /* don't reparse.  */);
5296           need_remove_insert = 1;
5297         }
5298
5299   if (need_remove_insert)
5300     update_global_location_list (1);
5301   else if (removed_any)
5302     update_global_location_list (0);
5303
5304   return bs_head;
5305 }
5306
5307 static void
5308 handle_jit_event (void)
5309 {
5310   struct frame_info *frame;
5311   struct gdbarch *gdbarch;
5312
5313   /* Switch terminal for any messages produced by
5314      breakpoint_re_set.  */
5315   target_terminal_ours_for_output ();
5316
5317   frame = get_current_frame ();
5318   gdbarch = get_frame_arch (frame);
5319
5320   jit_event_handler (gdbarch);
5321
5322   target_terminal_inferior ();
5323 }
5324
5325 /* Handle an solib event by calling solib_add.  */
5326
5327 void
5328 handle_solib_event (void)
5329 {
5330   clear_program_space_solib_cache (current_inferior ()->pspace);
5331
5332   /* Check for any newly added shared libraries if we're supposed to
5333      be adding them automatically.  Switch terminal for any messages
5334      produced by breakpoint_re_set.  */
5335   target_terminal_ours_for_output ();
5336 #ifdef SOLIB_ADD
5337   SOLIB_ADD (NULL, 0, &current_target, auto_solib_add);
5338 #else
5339   solib_add (NULL, 0, &current_target, auto_solib_add);
5340 #endif
5341   target_terminal_inferior ();
5342 }
5343
5344 /* Prepare WHAT final decision for infrun.  */
5345
5346 /* Decide what infrun needs to do with this bpstat.  */
5347
5348 struct bpstat_what
5349 bpstat_what (bpstat bs_head)
5350 {
5351   struct bpstat_what retval;
5352   int jit_event = 0;
5353   bpstat bs;
5354
5355   retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
5356   retval.call_dummy = STOP_NONE;
5357   retval.is_longjmp = 0;
5358
5359   for (bs = bs_head; bs != NULL; bs = bs->next)
5360     {
5361       /* Extract this BS's action.  After processing each BS, we check
5362          if its action overrides all we've seem so far.  */
5363       enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5364       enum bptype bptype;
5365
5366       if (bs->breakpoint_at == NULL)
5367         {
5368           /* I suspect this can happen if it was a momentary
5369              breakpoint which has since been deleted.  */
5370           bptype = bp_none;
5371         }
5372       else
5373         bptype = bs->breakpoint_at->type;
5374
5375       switch (bptype)
5376         {
5377         case bp_none:
5378           break;
5379         case bp_breakpoint:
5380         case bp_hardware_breakpoint:
5381         case bp_until:
5382         case bp_finish:
5383         case bp_shlib_event:
5384           if (bs->stop)
5385             {
5386               if (bs->print)
5387                 this_action = BPSTAT_WHAT_STOP_NOISY;
5388               else
5389                 this_action = BPSTAT_WHAT_STOP_SILENT;
5390             }
5391           else
5392             this_action = BPSTAT_WHAT_SINGLE;
5393           break;
5394         case bp_watchpoint:
5395         case bp_hardware_watchpoint:
5396         case bp_read_watchpoint:
5397         case bp_access_watchpoint:
5398           if (bs->stop)
5399             {
5400               if (bs->print)
5401                 this_action = BPSTAT_WHAT_STOP_NOISY;
5402               else
5403                 this_action = BPSTAT_WHAT_STOP_SILENT;
5404             }
5405           else
5406             {
5407               /* There was a watchpoint, but we're not stopping.
5408                  This requires no further action.  */
5409             }
5410           break;
5411         case bp_longjmp:
5412         case bp_longjmp_call_dummy:
5413         case bp_exception:
5414           this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5415           retval.is_longjmp = bptype != bp_exception;
5416           break;
5417         case bp_longjmp_resume:
5418         case bp_exception_resume:
5419           this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5420           retval.is_longjmp = bptype == bp_longjmp_resume;
5421           break;
5422         case bp_step_resume:
5423           if (bs->stop)
5424             this_action = BPSTAT_WHAT_STEP_RESUME;
5425           else
5426             {
5427               /* It is for the wrong frame.  */
5428               this_action = BPSTAT_WHAT_SINGLE;
5429             }
5430           break;
5431         case bp_hp_step_resume:
5432           if (bs->stop)
5433             this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5434           else
5435             {
5436               /* It is for the wrong frame.  */
5437               this_action = BPSTAT_WHAT_SINGLE;
5438             }
5439           break;
5440         case bp_watchpoint_scope:
5441         case bp_thread_event:
5442         case bp_overlay_event:
5443         case bp_longjmp_master:
5444         case bp_std_terminate_master:
5445         case bp_exception_master:
5446           this_action = BPSTAT_WHAT_SINGLE;
5447           break;
5448         case bp_catchpoint:
5449           if (bs->stop)
5450             {
5451               if (bs->print)
5452                 this_action = BPSTAT_WHAT_STOP_NOISY;
5453               else
5454                 this_action = BPSTAT_WHAT_STOP_SILENT;
5455             }
5456           else
5457             {
5458               /* There was a catchpoint, but we're not stopping.
5459                  This requires no further action.  */
5460             }
5461           break;
5462         case bp_jit_event:
5463           jit_event = 1;
5464           this_action = BPSTAT_WHAT_SINGLE;
5465           break;
5466         case bp_call_dummy:
5467           /* Make sure the action is stop (silent or noisy),
5468              so infrun.c pops the dummy frame.  */
5469           retval.call_dummy = STOP_STACK_DUMMY;
5470           this_action = BPSTAT_WHAT_STOP_SILENT;
5471           break;
5472         case bp_std_terminate:
5473           /* Make sure the action is stop (silent or noisy),
5474              so infrun.c pops the dummy frame.  */
5475           retval.call_dummy = STOP_STD_TERMINATE;
5476           this_action = BPSTAT_WHAT_STOP_SILENT;
5477           break;
5478         case bp_tracepoint:
5479         case bp_fast_tracepoint:
5480         case bp_static_tracepoint:
5481           /* Tracepoint hits should not be reported back to GDB, and
5482              if one got through somehow, it should have been filtered
5483              out already.  */
5484           internal_error (__FILE__, __LINE__,
5485                           _("bpstat_what: tracepoint encountered"));
5486           break;
5487         case bp_gnu_ifunc_resolver:
5488           /* Step over it (and insert bp_gnu_ifunc_resolver_return).  */
5489           this_action = BPSTAT_WHAT_SINGLE;
5490           break;
5491         case bp_gnu_ifunc_resolver_return:
5492           /* The breakpoint will be removed, execution will restart from the
5493              PC of the former breakpoint.  */
5494           this_action = BPSTAT_WHAT_KEEP_CHECKING;
5495           break;
5496
5497         case bp_dprintf:
5498           this_action = BPSTAT_WHAT_STOP_SILENT;
5499           break;
5500
5501         default:
5502           internal_error (__FILE__, __LINE__,
5503                           _("bpstat_what: unhandled bptype %d"), (int) bptype);
5504         }
5505
5506       retval.main_action = max (retval.main_action, this_action);
5507     }
5508
5509   /* These operations may affect the bs->breakpoint_at state so they are
5510      delayed after MAIN_ACTION is decided above.  */
5511
5512   if (jit_event)
5513     {
5514       if (debug_infrun)
5515         fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_jit_event\n");
5516
5517       handle_jit_event ();
5518     }
5519
5520   for (bs = bs_head; bs != NULL; bs = bs->next)
5521     {
5522       struct breakpoint *b = bs->breakpoint_at;
5523
5524       if (b == NULL)
5525         continue;
5526       switch (b->type)
5527         {
5528         case bp_gnu_ifunc_resolver:
5529           gnu_ifunc_resolver_stop (b);
5530           break;
5531         case bp_gnu_ifunc_resolver_return:
5532           gnu_ifunc_resolver_return_stop (b);
5533           break;
5534         }
5535     }
5536
5537   return retval;
5538 }
5539
5540 /* Nonzero if we should step constantly (e.g. watchpoints on machines
5541    without hardware support).  This isn't related to a specific bpstat,
5542    just to things like whether watchpoints are set.  */
5543
5544 int
5545 bpstat_should_step (void)
5546 {
5547   struct breakpoint *b;
5548
5549   ALL_BREAKPOINTS (b)
5550     if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
5551       return 1;
5552   return 0;
5553 }
5554
5555 int
5556 bpstat_causes_stop (bpstat bs)
5557 {
5558   for (; bs != NULL; bs = bs->next)
5559     if (bs->stop)
5560       return 1;
5561
5562   return 0;
5563 }
5564
5565 \f
5566
5567 /* Compute a string of spaces suitable to indent the next line
5568    so it starts at the position corresponding to the table column
5569    named COL_NAME in the currently active table of UIOUT.  */
5570
5571 static char *
5572 wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
5573 {
5574   static char wrap_indent[80];
5575   int i, total_width, width, align;
5576   char *text;
5577
5578   total_width = 0;
5579   for (i = 1; ui_out_query_field (uiout, i, &width, &align, &text); i++)
5580     {
5581       if (strcmp (text, col_name) == 0)
5582         {
5583           gdb_assert (total_width < sizeof wrap_indent);
5584           memset (wrap_indent, ' ', total_width);
5585           wrap_indent[total_width] = 0;
5586
5587           return wrap_indent;
5588         }
5589
5590       total_width += width + 1;
5591     }
5592
5593   return NULL;
5594 }
5595
5596 /* Determine if the locations of this breakpoint will have their conditions
5597    evaluated by the target, host or a mix of both.  Returns the following:
5598
5599     "host": Host evals condition.
5600     "host or target": Host or Target evals condition.
5601     "target": Target evals condition.
5602 */
5603
5604 static const char *
5605 bp_condition_evaluator (struct breakpoint *b)
5606 {
5607   struct bp_location *bl;
5608   char host_evals = 0;
5609   char target_evals = 0;
5610
5611   if (!b)
5612     return NULL;
5613
5614   if (!is_breakpoint (b))
5615     return NULL;
5616
5617   if (gdb_evaluates_breakpoint_condition_p ()
5618       || !target_supports_evaluation_of_breakpoint_conditions ())
5619     return condition_evaluation_host;
5620
5621   for (bl = b->loc; bl; bl = bl->next)
5622     {
5623       if (bl->cond_bytecode)
5624         target_evals++;
5625       else
5626         host_evals++;
5627     }
5628
5629   if (host_evals && target_evals)
5630     return condition_evaluation_both;
5631   else if (target_evals)
5632     return condition_evaluation_target;
5633   else
5634     return condition_evaluation_host;
5635 }
5636
5637 /* Determine the breakpoint location's condition evaluator.  This is
5638    similar to bp_condition_evaluator, but for locations.  */
5639
5640 static const char *
5641 bp_location_condition_evaluator (struct bp_location *bl)
5642 {
5643   if (bl && !is_breakpoint (bl->owner))
5644     return NULL;
5645
5646   if (gdb_evaluates_breakpoint_condition_p ()
5647       || !target_supports_evaluation_of_breakpoint_conditions ())
5648     return condition_evaluation_host;
5649
5650   if (bl && bl->cond_bytecode)
5651     return condition_evaluation_target;
5652   else
5653     return condition_evaluation_host;
5654 }
5655
5656 /* Print the LOC location out of the list of B->LOC locations.  */
5657
5658 static void
5659 print_breakpoint_location (struct breakpoint *b,
5660                            struct bp_location *loc)
5661 {
5662   struct ui_out *uiout = current_uiout;
5663   struct cleanup *old_chain = save_current_program_space ();
5664
5665   if (loc != NULL && loc->shlib_disabled)
5666     loc = NULL;
5667
5668   if (loc != NULL)
5669     set_current_program_space (loc->pspace);
5670
5671   if (b->display_canonical)
5672     ui_out_field_string (uiout, "what", b->addr_string);
5673   else if (loc && loc->source_file)
5674     {
5675       struct symbol *sym 
5676         = find_pc_sect_function (loc->address, loc->section);
5677       if (sym)
5678         {
5679           ui_out_text (uiout, "in ");
5680           ui_out_field_string (uiout, "func",
5681                                SYMBOL_PRINT_NAME (sym));
5682           ui_out_text (uiout, " ");
5683           ui_out_wrap_hint (uiout, wrap_indent_at_field (uiout, "what"));
5684           ui_out_text (uiout, "at ");
5685         }
5686       ui_out_field_string (uiout, "file", loc->source_file);
5687       ui_out_text (uiout, ":");
5688       
5689       if (ui_out_is_mi_like_p (uiout))
5690         {
5691           struct symtab_and_line sal = find_pc_line (loc->address, 0);
5692           const char *fullname = symtab_to_fullname (sal.symtab);
5693           
5694           if (fullname)
5695             ui_out_field_string (uiout, "fullname", fullname);
5696         }
5697       
5698       ui_out_field_int (uiout, "line", loc->line_number);
5699     }
5700   else if (loc)
5701     {
5702       struct ui_file *stb = mem_fileopen ();
5703       struct cleanup *stb_chain = make_cleanup_ui_file_delete (stb);
5704
5705       print_address_symbolic (loc->gdbarch, loc->address, stb,
5706                               demangle, "");
5707       ui_out_field_stream (uiout, "at", stb);
5708
5709       do_cleanups (stb_chain);
5710     }
5711   else
5712     ui_out_field_string (uiout, "pending", b->addr_string);
5713
5714   if (loc && is_breakpoint (b)
5715       && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5716       && bp_condition_evaluator (b) == condition_evaluation_both)
5717     {
5718       ui_out_text (uiout, " (");
5719       ui_out_field_string (uiout, "evaluated-by",
5720                            bp_location_condition_evaluator (loc));
5721       ui_out_text (uiout, ")");
5722     }
5723
5724   do_cleanups (old_chain);
5725 }
5726
5727 static const char *
5728 bptype_string (enum bptype type)
5729 {
5730   struct ep_type_description
5731     {
5732       enum bptype type;
5733       char *description;
5734     };
5735   static struct ep_type_description bptypes[] =
5736   {
5737     {bp_none, "?deleted?"},
5738     {bp_breakpoint, "breakpoint"},
5739     {bp_hardware_breakpoint, "hw breakpoint"},
5740     {bp_until, "until"},
5741     {bp_finish, "finish"},
5742     {bp_watchpoint, "watchpoint"},
5743     {bp_hardware_watchpoint, "hw watchpoint"},
5744     {bp_read_watchpoint, "read watchpoint"},
5745     {bp_access_watchpoint, "acc watchpoint"},
5746     {bp_longjmp, "longjmp"},
5747     {bp_longjmp_resume, "longjmp resume"},
5748     {bp_longjmp_call_dummy, "longjmp for call dummy"},
5749     {bp_exception, "exception"},
5750     {bp_exception_resume, "exception resume"},
5751     {bp_step_resume, "step resume"},
5752     {bp_hp_step_resume, "high-priority step resume"},
5753     {bp_watchpoint_scope, "watchpoint scope"},
5754     {bp_call_dummy, "call dummy"},
5755     {bp_std_terminate, "std::terminate"},
5756     {bp_shlib_event, "shlib events"},
5757     {bp_thread_event, "thread events"},
5758     {bp_overlay_event, "overlay events"},
5759     {bp_longjmp_master, "longjmp master"},
5760     {bp_std_terminate_master, "std::terminate master"},
5761     {bp_exception_master, "exception master"},
5762     {bp_catchpoint, "catchpoint"},
5763     {bp_tracepoint, "tracepoint"},
5764     {bp_fast_tracepoint, "fast tracepoint"},
5765     {bp_static_tracepoint, "static tracepoint"},
5766     {bp_dprintf, "dprintf"},
5767     {bp_jit_event, "jit events"},
5768     {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
5769     {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
5770   };
5771
5772   if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
5773       || ((int) type != bptypes[(int) type].type))
5774     internal_error (__FILE__, __LINE__,
5775                     _("bptypes table does not describe type #%d."),
5776                     (int) type);
5777
5778   return bptypes[(int) type].description;
5779 }
5780
5781 /* Print B to gdb_stdout.  */
5782
5783 static void
5784 print_one_breakpoint_location (struct breakpoint *b,
5785                                struct bp_location *loc,
5786                                int loc_number,
5787                                struct bp_location **last_loc,
5788                                int allflag)
5789 {
5790   struct command_line *l;
5791   static char bpenables[] = "nynny";
5792
5793   struct ui_out *uiout = current_uiout;
5794   int header_of_multiple = 0;
5795   int part_of_multiple = (loc != NULL);
5796   struct value_print_options opts;
5797
5798   get_user_print_options (&opts);
5799
5800   gdb_assert (!loc || loc_number != 0);
5801   /* See comment in print_one_breakpoint concerning treatment of
5802      breakpoints with single disabled location.  */
5803   if (loc == NULL 
5804       && (b->loc != NULL 
5805           && (b->loc->next != NULL || !b->loc->enabled)))
5806     header_of_multiple = 1;
5807   if (loc == NULL)
5808     loc = b->loc;
5809
5810   annotate_record ();
5811
5812   /* 1 */
5813   annotate_field (0);
5814   if (part_of_multiple)
5815     {
5816       char *formatted;
5817       formatted = xstrprintf ("%d.%d", b->number, loc_number);
5818       ui_out_field_string (uiout, "number", formatted);
5819       xfree (formatted);
5820     }
5821   else
5822     {
5823       ui_out_field_int (uiout, "number", b->number);
5824     }
5825
5826   /* 2 */
5827   annotate_field (1);
5828   if (part_of_multiple)
5829     ui_out_field_skip (uiout, "type");
5830   else
5831     ui_out_field_string (uiout, "type", bptype_string (b->type));
5832
5833   /* 3 */
5834   annotate_field (2);
5835   if (part_of_multiple)
5836     ui_out_field_skip (uiout, "disp");
5837   else
5838     ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
5839
5840
5841   /* 4 */
5842   annotate_field (3);
5843   if (part_of_multiple)
5844     ui_out_field_string (uiout, "enabled", loc->enabled ? "y" : "n");
5845   else
5846     ui_out_field_fmt (uiout, "enabled", "%c", 
5847                       bpenables[(int) b->enable_state]);
5848   ui_out_spaces (uiout, 2);
5849
5850   
5851   /* 5 and 6 */
5852   if (b->ops != NULL && b->ops->print_one != NULL)
5853     {
5854       /* Although the print_one can possibly print all locations,
5855          calling it here is not likely to get any nice result.  So,
5856          make sure there's just one location.  */
5857       gdb_assert (b->loc == NULL || b->loc->next == NULL);
5858       b->ops->print_one (b, last_loc);
5859     }
5860   else
5861     switch (b->type)
5862       {
5863       case bp_none:
5864         internal_error (__FILE__, __LINE__,
5865                         _("print_one_breakpoint: bp_none encountered\n"));
5866         break;
5867
5868       case bp_watchpoint:
5869       case bp_hardware_watchpoint:
5870       case bp_read_watchpoint:
5871       case bp_access_watchpoint:
5872         {
5873           struct watchpoint *w = (struct watchpoint *) b;
5874
5875           /* Field 4, the address, is omitted (which makes the columns
5876              not line up too nicely with the headers, but the effect
5877              is relatively readable).  */
5878           if (opts.addressprint)
5879             ui_out_field_skip (uiout, "addr");
5880           annotate_field (5);
5881           ui_out_field_string (uiout, "what", w->exp_string);
5882         }
5883         break;
5884
5885       case bp_breakpoint:
5886       case bp_hardware_breakpoint:
5887       case bp_until:
5888       case bp_finish:
5889       case bp_longjmp:
5890       case bp_longjmp_resume:
5891       case bp_longjmp_call_dummy:
5892       case bp_exception:
5893       case bp_exception_resume:
5894       case bp_step_resume:
5895       case bp_hp_step_resume:
5896       case bp_watchpoint_scope:
5897       case bp_call_dummy:
5898       case bp_std_terminate:
5899       case bp_shlib_event:
5900       case bp_thread_event:
5901       case bp_overlay_event:
5902       case bp_longjmp_master:
5903       case bp_std_terminate_master:
5904       case bp_exception_master:
5905       case bp_tracepoint:
5906       case bp_fast_tracepoint:
5907       case bp_static_tracepoint:
5908       case bp_dprintf:
5909       case bp_jit_event:
5910       case bp_gnu_ifunc_resolver:
5911       case bp_gnu_ifunc_resolver_return:
5912         if (opts.addressprint)
5913           {
5914             annotate_field (4);
5915             if (header_of_multiple)
5916               ui_out_field_string (uiout, "addr", "<MULTIPLE>");
5917             else if (b->loc == NULL || loc->shlib_disabled)
5918               ui_out_field_string (uiout, "addr", "<PENDING>");
5919             else
5920               ui_out_field_core_addr (uiout, "addr",
5921                                       loc->gdbarch, loc->address);
5922           }
5923         annotate_field (5);
5924         if (!header_of_multiple)
5925           print_breakpoint_location (b, loc);
5926         if (b->loc)
5927           *last_loc = b->loc;
5928         break;
5929       }
5930
5931
5932   /* For backward compatibility, don't display inferiors unless there
5933      are several.  */
5934   if (loc != NULL
5935       && !header_of_multiple
5936       && (allflag
5937           || (!gdbarch_has_global_breakpoints (target_gdbarch)
5938               && (number_of_program_spaces () > 1
5939                   || number_of_inferiors () > 1)
5940               /* LOC is for existing B, it cannot be in
5941                  moribund_locations and thus having NULL OWNER.  */
5942               && loc->owner->type != bp_catchpoint)))
5943     {
5944       struct inferior *inf;
5945       int first = 1;
5946
5947       for (inf = inferior_list; inf != NULL; inf = inf->next)
5948         {
5949           if (inf->pspace == loc->pspace)
5950             {
5951               if (first)
5952                 {
5953                   first = 0;
5954                   ui_out_text (uiout, " inf ");
5955                 }
5956               else
5957                 ui_out_text (uiout, ", ");
5958               ui_out_text (uiout, plongest (inf->num));
5959             }
5960         }
5961     }
5962
5963   if (!part_of_multiple)
5964     {
5965       if (b->thread != -1)
5966         {
5967           /* FIXME: This seems to be redundant and lost here; see the
5968              "stop only in" line a little further down.  */
5969           ui_out_text (uiout, " thread ");
5970           ui_out_field_int (uiout, "thread", b->thread);
5971         }
5972       else if (b->task != 0)
5973         {
5974           ui_out_text (uiout, " task ");
5975           ui_out_field_int (uiout, "task", b->task);
5976         }
5977     }
5978
5979   ui_out_text (uiout, "\n");
5980
5981   if (!part_of_multiple)
5982     b->ops->print_one_detail (b, uiout);
5983
5984   if (part_of_multiple && frame_id_p (b->frame_id))
5985     {
5986       annotate_field (6);
5987       ui_out_text (uiout, "\tstop only in stack frame at ");
5988       /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
5989          the frame ID.  */
5990       ui_out_field_core_addr (uiout, "frame",
5991                               b->gdbarch, b->frame_id.stack_addr);
5992       ui_out_text (uiout, "\n");
5993     }
5994   
5995   if (!part_of_multiple && b->cond_string)
5996     {
5997       annotate_field (7);
5998       if (is_tracepoint (b))
5999         ui_out_text (uiout, "\ttrace only if ");
6000       else
6001         ui_out_text (uiout, "\tstop only if ");
6002       ui_out_field_string (uiout, "cond", b->cond_string);
6003
6004       /* Print whether the target is doing the breakpoint's condition
6005          evaluation.  If GDB is doing the evaluation, don't print anything.  */
6006       if (is_breakpoint (b)
6007           && breakpoint_condition_evaluation_mode ()
6008           == condition_evaluation_target)
6009         {
6010           ui_out_text (uiout, " (");
6011           ui_out_field_string (uiout, "evaluated-by",
6012                                bp_condition_evaluator (b));
6013           ui_out_text (uiout, " evals)");
6014         }
6015       ui_out_text (uiout, "\n");
6016     }
6017
6018   if (!part_of_multiple && b->thread != -1)
6019     {
6020       /* FIXME should make an annotation for this.  */
6021       ui_out_text (uiout, "\tstop only in thread ");
6022       ui_out_field_int (uiout, "thread", b->thread);
6023       ui_out_text (uiout, "\n");
6024     }
6025   
6026   if (!part_of_multiple && b->hit_count)
6027     {
6028       /* FIXME should make an annotation for this.  */
6029       if (is_catchpoint (b))
6030         ui_out_text (uiout, "\tcatchpoint");
6031       else if (is_tracepoint (b))
6032         ui_out_text (uiout, "\ttracepoint");
6033       else
6034         ui_out_text (uiout, "\tbreakpoint");
6035       ui_out_text (uiout, " already hit ");
6036       ui_out_field_int (uiout, "times", b->hit_count);
6037       if (b->hit_count == 1)
6038         ui_out_text (uiout, " time\n");
6039       else
6040         ui_out_text (uiout, " times\n");
6041     }
6042   
6043   /* Output the count also if it is zero, but only if this is mi.
6044      FIXME: Should have a better test for this.  */
6045   if (ui_out_is_mi_like_p (uiout))
6046     if (!part_of_multiple && b->hit_count == 0)
6047       ui_out_field_int (uiout, "times", b->hit_count);
6048
6049   if (!part_of_multiple && b->ignore_count)
6050     {
6051       annotate_field (8);
6052       ui_out_text (uiout, "\tignore next ");
6053       ui_out_field_int (uiout, "ignore", b->ignore_count);
6054       ui_out_text (uiout, " hits\n");
6055     }
6056
6057   /* Note that an enable count of 1 corresponds to "enable once"
6058      behavior, which is reported by the combination of enablement and
6059      disposition, so we don't need to mention it here.  */
6060   if (!part_of_multiple && b->enable_count > 1)
6061     {
6062       annotate_field (8);
6063       ui_out_text (uiout, "\tdisable after ");
6064       /* Tweak the wording to clarify that ignore and enable counts
6065          are distinct, and have additive effect.  */
6066       if (b->ignore_count)
6067         ui_out_text (uiout, "additional ");
6068       else
6069         ui_out_text (uiout, "next ");
6070       ui_out_field_int (uiout, "enable", b->enable_count);
6071       ui_out_text (uiout, " hits\n");
6072     }
6073
6074   if (!part_of_multiple && is_tracepoint (b))
6075     {
6076       struct tracepoint *tp = (struct tracepoint *) b;
6077
6078       if (tp->traceframe_usage)
6079         {
6080           ui_out_text (uiout, "\ttrace buffer usage ");
6081           ui_out_field_int (uiout, "traceframe-usage", tp->traceframe_usage);
6082           ui_out_text (uiout, " bytes\n");
6083         }
6084     }
6085   
6086   if (!part_of_multiple && b->extra_string
6087       && b->type == bp_dprintf && !b->commands)
6088     {
6089       annotate_field (7);
6090       ui_out_text (uiout, "\t(agent printf) ");
6091       ui_out_field_string (uiout, "printf", b->extra_string);
6092       ui_out_text (uiout, "\n");
6093     }
6094
6095   l = b->commands ? b->commands->commands : NULL;
6096   if (!part_of_multiple && l)
6097     {
6098       struct cleanup *script_chain;
6099
6100       annotate_field (9);
6101       script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
6102       print_command_lines (uiout, l, 4);
6103       do_cleanups (script_chain);
6104     }
6105
6106   if (is_tracepoint (b))
6107     {
6108       struct tracepoint *t = (struct tracepoint *) b;
6109
6110       if (!part_of_multiple && t->pass_count)
6111         {
6112           annotate_field (10);
6113           ui_out_text (uiout, "\tpass count ");
6114           ui_out_field_int (uiout, "pass", t->pass_count);
6115           ui_out_text (uiout, " \n");
6116         }
6117     }
6118
6119   if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
6120     {
6121       if (is_watchpoint (b))
6122         {
6123           struct watchpoint *w = (struct watchpoint *) b;
6124
6125           ui_out_field_string (uiout, "original-location", w->exp_string);
6126         }
6127       else if (b->addr_string)
6128         ui_out_field_string (uiout, "original-location", b->addr_string);
6129     }
6130 }
6131
6132 static void
6133 print_one_breakpoint (struct breakpoint *b,
6134                       struct bp_location **last_loc, 
6135                       int allflag)
6136 {
6137   struct cleanup *bkpt_chain;
6138   struct ui_out *uiout = current_uiout;
6139
6140   bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
6141
6142   print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
6143   do_cleanups (bkpt_chain);
6144
6145   /* If this breakpoint has custom print function,
6146      it's already printed.  Otherwise, print individual
6147      locations, if any.  */
6148   if (b->ops == NULL || b->ops->print_one == NULL)
6149     {
6150       /* If breakpoint has a single location that is disabled, we
6151          print it as if it had several locations, since otherwise it's
6152          hard to represent "breakpoint enabled, location disabled"
6153          situation.
6154
6155          Note that while hardware watchpoints have several locations
6156          internally, that's not a property exposed to user.  */
6157       if (b->loc 
6158           && !is_hardware_watchpoint (b)
6159           && (b->loc->next || !b->loc->enabled))
6160         {
6161           struct bp_location *loc;
6162           int n = 1;
6163
6164           for (loc = b->loc; loc; loc = loc->next, ++n)
6165             {
6166               struct cleanup *inner2 =
6167                 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
6168               print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6169               do_cleanups (inner2);
6170             }
6171         }
6172     }
6173 }
6174
6175 static int
6176 breakpoint_address_bits (struct breakpoint *b)
6177 {
6178   int print_address_bits = 0;
6179   struct bp_location *loc;
6180
6181   for (loc = b->loc; loc; loc = loc->next)
6182     {
6183       int addr_bit;
6184
6185       /* Software watchpoints that aren't watching memory don't have
6186          an address to print.  */
6187       if (b->type == bp_watchpoint && loc->watchpoint_type == -1)
6188         continue;
6189
6190       addr_bit = gdbarch_addr_bit (loc->gdbarch);
6191       if (addr_bit > print_address_bits)
6192         print_address_bits = addr_bit;
6193     }
6194
6195   return print_address_bits;
6196 }
6197
6198 struct captured_breakpoint_query_args
6199   {
6200     int bnum;
6201   };
6202
6203 static int
6204 do_captured_breakpoint_query (struct ui_out *uiout, void *data)
6205 {
6206   struct captured_breakpoint_query_args *args = data;
6207   struct breakpoint *b;
6208   struct bp_location *dummy_loc = NULL;
6209
6210   ALL_BREAKPOINTS (b)
6211     {
6212       if (args->bnum == b->number)
6213         {
6214           print_one_breakpoint (b, &dummy_loc, 0);
6215           return GDB_RC_OK;
6216         }
6217     }
6218   return GDB_RC_NONE;
6219 }
6220
6221 enum gdb_rc
6222 gdb_breakpoint_query (struct ui_out *uiout, int bnum, 
6223                       char **error_message)
6224 {
6225   struct captured_breakpoint_query_args args;
6226
6227   args.bnum = bnum;
6228   /* For the moment we don't trust print_one_breakpoint() to not throw
6229      an error.  */
6230   if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
6231                                  error_message, RETURN_MASK_ALL) < 0)
6232     return GDB_RC_FAIL;
6233   else
6234     return GDB_RC_OK;
6235 }
6236
6237 /* Return true if this breakpoint was set by the user, false if it is
6238    internal or momentary.  */
6239
6240 int
6241 user_breakpoint_p (struct breakpoint *b)
6242 {
6243   return b->number > 0;
6244 }
6245
6246 /* Print information on user settable breakpoint (watchpoint, etc)
6247    number BNUM.  If BNUM is -1 print all user-settable breakpoints.
6248    If ALLFLAG is non-zero, include non-user-settable breakpoints.  If
6249    FILTER is non-NULL, call it on each breakpoint and only include the
6250    ones for which it returns non-zero.  Return the total number of
6251    breakpoints listed.  */
6252
6253 static int
6254 breakpoint_1 (char *args, int allflag, 
6255               int (*filter) (const struct breakpoint *))
6256 {
6257   struct breakpoint *b;
6258   struct bp_location *last_loc = NULL;
6259   int nr_printable_breakpoints;
6260   struct cleanup *bkpttbl_chain;
6261   struct value_print_options opts;
6262   int print_address_bits = 0;
6263   int print_type_col_width = 14;
6264   struct ui_out *uiout = current_uiout;
6265
6266   get_user_print_options (&opts);
6267
6268   /* Compute the number of rows in the table, as well as the size
6269      required for address fields.  */
6270   nr_printable_breakpoints = 0;
6271   ALL_BREAKPOINTS (b)
6272     {
6273       /* If we have a filter, only list the breakpoints it accepts.  */
6274       if (filter && !filter (b))
6275         continue;
6276
6277       /* If we have an "args" string, it is a list of breakpoints to 
6278          accept.  Skip the others.  */
6279       if (args != NULL && *args != '\0')
6280         {
6281           if (allflag && parse_and_eval_long (args) != b->number)
6282             continue;
6283           if (!allflag && !number_is_in_list (args, b->number))
6284             continue;
6285         }
6286
6287       if (allflag || user_breakpoint_p (b))
6288         {
6289           int addr_bit, type_len;
6290
6291           addr_bit = breakpoint_address_bits (b);
6292           if (addr_bit > print_address_bits)
6293             print_address_bits = addr_bit;
6294
6295           type_len = strlen (bptype_string (b->type));
6296           if (type_len > print_type_col_width)
6297             print_type_col_width = type_len;
6298
6299           nr_printable_breakpoints++;
6300         }
6301     }
6302
6303   if (opts.addressprint)
6304     bkpttbl_chain 
6305       = make_cleanup_ui_out_table_begin_end (uiout, 6,
6306                                              nr_printable_breakpoints,
6307                                              "BreakpointTable");
6308   else
6309     bkpttbl_chain 
6310       = make_cleanup_ui_out_table_begin_end (uiout, 5,
6311                                              nr_printable_breakpoints,
6312                                              "BreakpointTable");
6313
6314   if (nr_printable_breakpoints > 0)
6315     annotate_breakpoints_headers ();
6316   if (nr_printable_breakpoints > 0)
6317     annotate_field (0);
6318   ui_out_table_header (uiout, 7, ui_left, "number", "Num");     /* 1 */
6319   if (nr_printable_breakpoints > 0)
6320     annotate_field (1);
6321   ui_out_table_header (uiout, print_type_col_width, ui_left,
6322                        "type", "Type");                         /* 2 */
6323   if (nr_printable_breakpoints > 0)
6324     annotate_field (2);
6325   ui_out_table_header (uiout, 4, ui_left, "disp", "Disp");      /* 3 */
6326   if (nr_printable_breakpoints > 0)
6327     annotate_field (3);
6328   ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");    /* 4 */
6329   if (opts.addressprint)
6330     {
6331       if (nr_printable_breakpoints > 0)
6332         annotate_field (4);
6333       if (print_address_bits <= 32)
6334         ui_out_table_header (uiout, 10, ui_left, 
6335                              "addr", "Address");                /* 5 */
6336       else
6337         ui_out_table_header (uiout, 18, ui_left, 
6338                              "addr", "Address");                /* 5 */
6339     }
6340   if (nr_printable_breakpoints > 0)
6341     annotate_field (5);
6342   ui_out_table_header (uiout, 40, ui_noalign, "what", "What");  /* 6 */
6343   ui_out_table_body (uiout);
6344   if (nr_printable_breakpoints > 0)
6345     annotate_breakpoints_table ();
6346
6347   ALL_BREAKPOINTS (b)
6348     {
6349       QUIT;
6350       /* If we have a filter, only list the breakpoints it accepts.  */
6351       if (filter && !filter (b))
6352         continue;
6353
6354       /* If we have an "args" string, it is a list of breakpoints to 
6355          accept.  Skip the others.  */
6356
6357       if (args != NULL && *args != '\0')
6358         {
6359           if (allflag)  /* maintenance info breakpoint */
6360             {
6361               if (parse_and_eval_long (args) != b->number)
6362                 continue;
6363             }
6364           else          /* all others */
6365             {
6366               if (!number_is_in_list (args, b->number))
6367                 continue;
6368             }
6369         }
6370       /* We only print out user settable breakpoints unless the
6371          allflag is set.  */
6372       if (allflag || user_breakpoint_p (b))
6373         print_one_breakpoint (b, &last_loc, allflag);
6374     }
6375
6376   do_cleanups (bkpttbl_chain);
6377
6378   if (nr_printable_breakpoints == 0)
6379     {
6380       /* If there's a filter, let the caller decide how to report
6381          empty list.  */
6382       if (!filter)
6383         {
6384           if (args == NULL || *args == '\0')
6385             ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
6386           else
6387             ui_out_message (uiout, 0, 
6388                             "No breakpoint or watchpoint matching '%s'.\n",
6389                             args);
6390         }
6391     }
6392   else
6393     {
6394       if (last_loc && !server_command)
6395         set_next_address (last_loc->gdbarch, last_loc->address);
6396     }
6397
6398   /* FIXME?  Should this be moved up so that it is only called when
6399      there have been breakpoints? */
6400   annotate_breakpoints_table_end ();
6401
6402   return nr_printable_breakpoints;
6403 }
6404
6405 /* Display the value of default-collect in a way that is generally
6406    compatible with the breakpoint list.  */
6407
6408 static void
6409 default_collect_info (void)
6410 {
6411   struct ui_out *uiout = current_uiout;
6412
6413   /* If it has no value (which is frequently the case), say nothing; a
6414      message like "No default-collect." gets in user's face when it's
6415      not wanted.  */
6416   if (!*default_collect)
6417     return;
6418
6419   /* The following phrase lines up nicely with per-tracepoint collect
6420      actions.  */
6421   ui_out_text (uiout, "default collect ");
6422   ui_out_field_string (uiout, "default-collect", default_collect);
6423   ui_out_text (uiout, " \n");
6424 }
6425   
6426 static void
6427 breakpoints_info (char *args, int from_tty)
6428 {
6429   breakpoint_1 (args, 0, NULL);
6430
6431   default_collect_info ();
6432 }
6433
6434 static void
6435 watchpoints_info (char *args, int from_tty)
6436 {
6437   int num_printed = breakpoint_1 (args, 0, is_watchpoint);
6438   struct ui_out *uiout = current_uiout;
6439
6440   if (num_printed == 0)
6441     {
6442       if (args == NULL || *args == '\0')
6443         ui_out_message (uiout, 0, "No watchpoints.\n");
6444       else
6445         ui_out_message (uiout, 0, "No watchpoint matching '%s'.\n", args);
6446     }
6447 }
6448
6449 static void
6450 maintenance_info_breakpoints (char *args, int from_tty)
6451 {
6452   breakpoint_1 (args, 1, NULL);
6453
6454   default_collect_info ();
6455 }
6456
6457 static int
6458 breakpoint_has_pc (struct breakpoint *b,
6459                    struct program_space *pspace,
6460                    CORE_ADDR pc, struct obj_section *section)
6461 {
6462   struct bp_location *bl = b->loc;
6463
6464   for (; bl; bl = bl->next)
6465     {
6466       if (bl->pspace == pspace
6467           && bl->address == pc
6468           && (!overlay_debugging || bl->section == section))
6469         return 1;         
6470     }
6471   return 0;
6472 }
6473
6474 /* Print a message describing any user-breakpoints set at PC.  This
6475    concerns with logical breakpoints, so we match program spaces, not
6476    address spaces.  */
6477
6478 static void
6479 describe_other_breakpoints (struct gdbarch *gdbarch,
6480                             struct program_space *pspace, CORE_ADDR pc,
6481                             struct obj_section *section, int thread)
6482 {
6483   int others = 0;
6484   struct breakpoint *b;
6485
6486   ALL_BREAKPOINTS (b)
6487     others += (user_breakpoint_p (b)
6488                && breakpoint_has_pc (b, pspace, pc, section));
6489   if (others > 0)
6490     {
6491       if (others == 1)
6492         printf_filtered (_("Note: breakpoint "));
6493       else /* if (others == ???) */
6494         printf_filtered (_("Note: breakpoints "));
6495       ALL_BREAKPOINTS (b)
6496         if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
6497           {
6498             others--;
6499             printf_filtered ("%d", b->number);
6500             if (b->thread == -1 && thread != -1)
6501               printf_filtered (" (all threads)");
6502             else if (b->thread != -1)
6503               printf_filtered (" (thread %d)", b->thread);
6504             printf_filtered ("%s%s ",
6505                              ((b->enable_state == bp_disabled
6506                                || b->enable_state == bp_call_disabled)
6507                               ? " (disabled)"
6508                               : b->enable_state == bp_permanent 
6509                               ? " (permanent)"
6510                               : ""),
6511                              (others > 1) ? "," 
6512                              : ((others == 1) ? " and" : ""));
6513           }
6514       printf_filtered (_("also set at pc "));
6515       fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
6516       printf_filtered (".\n");
6517     }
6518 }
6519 \f
6520
6521 /* Return true iff it is meaningful to use the address member of
6522    BPT.  For some breakpoint types, the address member is irrelevant
6523    and it makes no sense to attempt to compare it to other addresses
6524    (or use it for any other purpose either).
6525
6526    More specifically, each of the following breakpoint types will
6527    always have a zero valued address and we don't want to mark
6528    breakpoints of any of these types to be a duplicate of an actual
6529    breakpoint at address zero:
6530
6531       bp_watchpoint
6532       bp_catchpoint
6533
6534 */
6535
6536 static int
6537 breakpoint_address_is_meaningful (struct breakpoint *bpt)
6538 {
6539   enum bptype type = bpt->type;
6540
6541   return (type != bp_watchpoint && type != bp_catchpoint);
6542 }
6543
6544 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6545    true if LOC1 and LOC2 represent the same watchpoint location.  */
6546
6547 static int
6548 watchpoint_locations_match (struct bp_location *loc1, 
6549                             struct bp_location *loc2)
6550 {
6551   struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
6552   struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
6553
6554   /* Both of them must exist.  */
6555   gdb_assert (w1 != NULL);
6556   gdb_assert (w2 != NULL);
6557
6558   /* If the target can evaluate the condition expression in hardware,
6559      then we we need to insert both watchpoints even if they are at
6560      the same place.  Otherwise the watchpoint will only trigger when
6561      the condition of whichever watchpoint was inserted evaluates to
6562      true, not giving a chance for GDB to check the condition of the
6563      other watchpoint.  */
6564   if ((w1->cond_exp
6565        && target_can_accel_watchpoint_condition (loc1->address, 
6566                                                  loc1->length,
6567                                                  loc1->watchpoint_type,
6568                                                  w1->cond_exp))
6569       || (w2->cond_exp
6570           && target_can_accel_watchpoint_condition (loc2->address, 
6571                                                     loc2->length,
6572                                                     loc2->watchpoint_type,
6573                                                     w2->cond_exp)))
6574     return 0;
6575
6576   /* Note that this checks the owner's type, not the location's.  In
6577      case the target does not support read watchpoints, but does
6578      support access watchpoints, we'll have bp_read_watchpoint
6579      watchpoints with hw_access locations.  Those should be considered
6580      duplicates of hw_read locations.  The hw_read locations will
6581      become hw_access locations later.  */
6582   return (loc1->owner->type == loc2->owner->type
6583           && loc1->pspace->aspace == loc2->pspace->aspace
6584           && loc1->address == loc2->address
6585           && loc1->length == loc2->length);
6586 }
6587
6588 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
6589    same breakpoint location.  In most targets, this can only be true
6590    if ASPACE1 matches ASPACE2.  On targets that have global
6591    breakpoints, the address space doesn't really matter.  */
6592
6593 static int
6594 breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
6595                           struct address_space *aspace2, CORE_ADDR addr2)
6596 {
6597   return ((gdbarch_has_global_breakpoints (target_gdbarch)
6598            || aspace1 == aspace2)
6599           && addr1 == addr2);
6600 }
6601
6602 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6603    {ASPACE1,ADDR1,LEN1}.  In most targets, this can only be true if ASPACE1
6604    matches ASPACE2.  On targets that have global breakpoints, the address
6605    space doesn't really matter.  */
6606
6607 static int
6608 breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
6609                                 int len1, struct address_space *aspace2,
6610                                 CORE_ADDR addr2)
6611 {
6612   return ((gdbarch_has_global_breakpoints (target_gdbarch)
6613            || aspace1 == aspace2)
6614           && addr2 >= addr1 && addr2 < addr1 + len1);
6615 }
6616
6617 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL.  BL may be
6618    a ranged breakpoint.  In most targets, a match happens only if ASPACE
6619    matches the breakpoint's address space.  On targets that have global
6620    breakpoints, the address space doesn't really matter.  */
6621
6622 static int
6623 breakpoint_location_address_match (struct bp_location *bl,
6624                                    struct address_space *aspace,
6625                                    CORE_ADDR addr)
6626 {
6627   return (breakpoint_address_match (bl->pspace->aspace, bl->address,
6628                                     aspace, addr)
6629           || (bl->length
6630               && breakpoint_address_match_range (bl->pspace->aspace,
6631                                                  bl->address, bl->length,
6632                                                  aspace, addr)));
6633 }
6634
6635 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6636    Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6637    true, otherwise returns false.  */
6638
6639 static int
6640 tracepoint_locations_match (struct bp_location *loc1,
6641                             struct bp_location *loc2)
6642 {
6643   if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
6644     /* Since tracepoint locations are never duplicated with others', tracepoint
6645        locations at the same address of different tracepoints are regarded as
6646        different locations.  */
6647     return (loc1->address == loc2->address && loc1->owner == loc2->owner);
6648   else
6649     return 0;
6650 }
6651
6652 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6653    (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
6654    represent the same location.  */
6655
6656 static int
6657 breakpoint_locations_match (struct bp_location *loc1, 
6658                             struct bp_location *loc2)
6659 {
6660   int hw_point1, hw_point2;
6661
6662   /* Both of them must not be in moribund_locations.  */
6663   gdb_assert (loc1->owner != NULL);
6664   gdb_assert (loc2->owner != NULL);
6665
6666   hw_point1 = is_hardware_watchpoint (loc1->owner);
6667   hw_point2 = is_hardware_watchpoint (loc2->owner);
6668
6669   if (hw_point1 != hw_point2)
6670     return 0;
6671   else if (hw_point1)
6672     return watchpoint_locations_match (loc1, loc2);
6673   else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
6674     return tracepoint_locations_match (loc1, loc2);
6675   else
6676     /* We compare bp_location.length in order to cover ranged breakpoints.  */
6677     return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
6678                                      loc2->pspace->aspace, loc2->address)
6679             && loc1->length == loc2->length);
6680 }
6681
6682 static void
6683 breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
6684                                int bnum, int have_bnum)
6685 {
6686   /* The longest string possibly returned by hex_string_custom
6687      is 50 chars.  These must be at least that big for safety.  */
6688   char astr1[64];
6689   char astr2[64];
6690
6691   strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
6692   strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
6693   if (have_bnum)
6694     warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6695              bnum, astr1, astr2);
6696   else
6697     warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
6698 }
6699
6700 /* Adjust a breakpoint's address to account for architectural
6701    constraints on breakpoint placement.  Return the adjusted address.
6702    Note: Very few targets require this kind of adjustment.  For most
6703    targets, this function is simply the identity function.  */
6704
6705 static CORE_ADDR
6706 adjust_breakpoint_address (struct gdbarch *gdbarch,
6707                            CORE_ADDR bpaddr, enum bptype bptype)
6708 {
6709   if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
6710     {
6711       /* Very few targets need any kind of breakpoint adjustment.  */
6712       return bpaddr;
6713     }
6714   else if (bptype == bp_watchpoint
6715            || bptype == bp_hardware_watchpoint
6716            || bptype == bp_read_watchpoint
6717            || bptype == bp_access_watchpoint
6718            || bptype == bp_catchpoint)
6719     {
6720       /* Watchpoints and the various bp_catch_* eventpoints should not
6721          have their addresses modified.  */
6722       return bpaddr;
6723     }
6724   else
6725     {
6726       CORE_ADDR adjusted_bpaddr;
6727
6728       /* Some targets have architectural constraints on the placement
6729          of breakpoint instructions.  Obtain the adjusted address.  */
6730       adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
6731
6732       /* An adjusted breakpoint address can significantly alter
6733          a user's expectations.  Print a warning if an adjustment
6734          is required.  */
6735       if (adjusted_bpaddr != bpaddr)
6736         breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
6737
6738       return adjusted_bpaddr;
6739     }
6740 }
6741
6742 void
6743 init_bp_location (struct bp_location *loc, const struct bp_location_ops *ops,
6744                   struct breakpoint *owner)
6745 {
6746   memset (loc, 0, sizeof (*loc));
6747
6748   gdb_assert (ops != NULL);
6749
6750   loc->ops = ops;
6751   loc->owner = owner;
6752   loc->cond = NULL;
6753   loc->cond_bytecode = NULL;
6754   loc->shlib_disabled = 0;
6755   loc->enabled = 1;
6756
6757   switch (owner->type)
6758     {
6759     case bp_breakpoint:
6760     case bp_until:
6761     case bp_finish:
6762     case bp_longjmp:
6763     case bp_longjmp_resume:
6764     case bp_longjmp_call_dummy:
6765     case bp_exception:
6766     case bp_exception_resume:
6767     case bp_step_resume:
6768     case bp_hp_step_resume:
6769     case bp_watchpoint_scope:
6770     case bp_call_dummy:
6771     case bp_std_terminate:
6772     case bp_shlib_event:
6773     case bp_thread_event:
6774     case bp_overlay_event:
6775     case bp_jit_event:
6776     case bp_longjmp_master:
6777     case bp_std_terminate_master:
6778     case bp_exception_master:
6779     case bp_gnu_ifunc_resolver:
6780     case bp_gnu_ifunc_resolver_return:
6781     case bp_dprintf:
6782       loc->loc_type = bp_loc_software_breakpoint;
6783       mark_breakpoint_location_modified (loc);
6784       break;
6785     case bp_hardware_breakpoint:
6786       loc->loc_type = bp_loc_hardware_breakpoint;
6787       mark_breakpoint_location_modified (loc);
6788       break;
6789     case bp_hardware_watchpoint:
6790     case bp_read_watchpoint:
6791     case bp_access_watchpoint:
6792       loc->loc_type = bp_loc_hardware_watchpoint;
6793       break;
6794     case bp_watchpoint:
6795     case bp_catchpoint:
6796     case bp_tracepoint:
6797     case bp_fast_tracepoint:
6798     case bp_static_tracepoint:
6799       loc->loc_type = bp_loc_other;
6800       break;
6801     default:
6802       internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
6803     }
6804
6805   loc->refc = 1;
6806 }
6807
6808 /* Allocate a struct bp_location.  */
6809
6810 static struct bp_location *
6811 allocate_bp_location (struct breakpoint *bpt)
6812 {
6813   return bpt->ops->allocate_location (bpt);
6814 }
6815
6816 static void
6817 free_bp_location (struct bp_location *loc)
6818 {
6819   loc->ops->dtor (loc);
6820   xfree (loc);
6821 }
6822
6823 /* Increment reference count.  */
6824
6825 static void
6826 incref_bp_location (struct bp_location *bl)
6827 {
6828   ++bl->refc;
6829 }
6830
6831 /* Decrement reference count.  If the reference count reaches 0,
6832    destroy the bp_location.  Sets *BLP to NULL.  */
6833
6834 static void
6835 decref_bp_location (struct bp_location **blp)
6836 {
6837   gdb_assert ((*blp)->refc > 0);
6838
6839   if (--(*blp)->refc == 0)
6840     free_bp_location (*blp);
6841   *blp = NULL;
6842 }
6843
6844 /* Add breakpoint B at the end of the global breakpoint chain.  */
6845
6846 static void
6847 add_to_breakpoint_chain (struct breakpoint *b)
6848 {
6849   struct breakpoint *b1;
6850
6851   /* Add this breakpoint to the end of the chain so that a list of
6852      breakpoints will come out in order of increasing numbers.  */
6853
6854   b1 = breakpoint_chain;
6855   if (b1 == 0)
6856     breakpoint_chain = b;
6857   else
6858     {
6859       while (b1->next)
6860         b1 = b1->next;
6861       b1->next = b;
6862     }
6863 }
6864
6865 /* Initializes breakpoint B with type BPTYPE and no locations yet.  */
6866
6867 static void
6868 init_raw_breakpoint_without_location (struct breakpoint *b,
6869                                       struct gdbarch *gdbarch,
6870                                       enum bptype bptype,
6871                                       const struct breakpoint_ops *ops)
6872 {
6873   memset (b, 0, sizeof (*b));
6874
6875   gdb_assert (ops != NULL);
6876
6877   b->ops = ops;
6878   b->type = bptype;
6879   b->gdbarch = gdbarch;
6880   b->language = current_language->la_language;
6881   b->input_radix = input_radix;
6882   b->thread = -1;
6883   b->enable_state = bp_enabled;
6884   b->next = 0;
6885   b->silent = 0;
6886   b->ignore_count = 0;
6887   b->commands = NULL;
6888   b->frame_id = null_frame_id;
6889   b->condition_not_parsed = 0;
6890   b->py_bp_object = NULL;
6891   b->related_breakpoint = b;
6892 }
6893
6894 /* Helper to set_raw_breakpoint below.  Creates a breakpoint
6895    that has type BPTYPE and has no locations as yet.  */
6896
6897 static struct breakpoint *
6898 set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
6899                                      enum bptype bptype,
6900                                      const struct breakpoint_ops *ops)
6901 {
6902   struct breakpoint *b = XNEW (struct breakpoint);
6903
6904   init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
6905   add_to_breakpoint_chain (b);
6906   return b;
6907 }
6908
6909 /* Initialize loc->function_name.  EXPLICIT_LOC says no indirect function
6910    resolutions should be made as the user specified the location explicitly
6911    enough.  */
6912
6913 static void
6914 set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
6915 {
6916   gdb_assert (loc->owner != NULL);
6917
6918   if (loc->owner->type == bp_breakpoint
6919       || loc->owner->type == bp_hardware_breakpoint
6920       || is_tracepoint (loc->owner))
6921     {
6922       int is_gnu_ifunc;
6923       const char *function_name;
6924       CORE_ADDR func_addr;
6925
6926       find_pc_partial_function_gnu_ifunc (loc->address, &function_name,
6927                                           &func_addr, NULL, &is_gnu_ifunc);
6928
6929       if (is_gnu_ifunc && !explicit_loc)
6930         {
6931           struct breakpoint *b = loc->owner;
6932
6933           gdb_assert (loc->pspace == current_program_space);
6934           if (gnu_ifunc_resolve_name (function_name,
6935                                       &loc->requested_address))
6936             {
6937               /* Recalculate ADDRESS based on new REQUESTED_ADDRESS.  */
6938               loc->address = adjust_breakpoint_address (loc->gdbarch,
6939                                                         loc->requested_address,
6940                                                         b->type);
6941             }
6942           else if (b->type == bp_breakpoint && b->loc == loc
6943                    && loc->next == NULL && b->related_breakpoint == b)
6944             {
6945               /* Create only the whole new breakpoint of this type but do not
6946                  mess more complicated breakpoints with multiple locations.  */
6947               b->type = bp_gnu_ifunc_resolver;
6948               /* Remember the resolver's address for use by the return
6949                  breakpoint.  */
6950               loc->related_address = func_addr;
6951             }
6952         }
6953
6954       if (function_name)
6955         loc->function_name = xstrdup (function_name);
6956     }
6957 }
6958
6959 /* Attempt to determine architecture of location identified by SAL.  */
6960 struct gdbarch *
6961 get_sal_arch (struct symtab_and_line sal)
6962 {
6963   if (sal.section)
6964     return get_objfile_arch (sal.section->objfile);
6965   if (sal.symtab)
6966     return get_objfile_arch (sal.symtab->objfile);
6967
6968   return NULL;
6969 }
6970
6971 /* Low level routine for partially initializing a breakpoint of type
6972    BPTYPE.  The newly created breakpoint's address, section, source
6973    file name, and line number are provided by SAL.
6974
6975    It is expected that the caller will complete the initialization of
6976    the newly created breakpoint struct as well as output any status
6977    information regarding the creation of a new breakpoint.  */
6978
6979 static void
6980 init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
6981                      struct symtab_and_line sal, enum bptype bptype,
6982                      const struct breakpoint_ops *ops)
6983 {
6984   init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
6985
6986   add_location_to_breakpoint (b, &sal);
6987
6988   if (bptype != bp_catchpoint)
6989     gdb_assert (sal.pspace != NULL);
6990
6991   /* Store the program space that was used to set the breakpoint,
6992      except for ordinary breakpoints, which are independent of the
6993      program space.  */
6994   if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
6995     b->pspace = sal.pspace;
6996
6997   breakpoints_changed ();
6998 }
6999
7000 /* set_raw_breakpoint is a low level routine for allocating and
7001    partially initializing a breakpoint of type BPTYPE.  The newly
7002    created breakpoint's address, section, source file name, and line
7003    number are provided by SAL.  The newly created and partially
7004    initialized breakpoint is added to the breakpoint chain and
7005    is also returned as the value of this function.
7006
7007    It is expected that the caller will complete the initialization of
7008    the newly created breakpoint struct as well as output any status
7009    information regarding the creation of a new breakpoint.  In
7010    particular, set_raw_breakpoint does NOT set the breakpoint
7011    number!  Care should be taken to not allow an error to occur
7012    prior to completing the initialization of the breakpoint.  If this
7013    should happen, a bogus breakpoint will be left on the chain.  */
7014
7015 struct breakpoint *
7016 set_raw_breakpoint (struct gdbarch *gdbarch,
7017                     struct symtab_and_line sal, enum bptype bptype,
7018                     const struct breakpoint_ops *ops)
7019 {
7020   struct breakpoint *b = XNEW (struct breakpoint);
7021
7022   init_raw_breakpoint (b, gdbarch, sal, bptype, ops);
7023   add_to_breakpoint_chain (b);
7024   return b;
7025 }
7026
7027
7028 /* Note that the breakpoint object B describes a permanent breakpoint
7029    instruction, hard-wired into the inferior's code.  */
7030 void
7031 make_breakpoint_permanent (struct breakpoint *b)
7032 {
7033   struct bp_location *bl;
7034
7035   b->enable_state = bp_permanent;
7036
7037   /* By definition, permanent breakpoints are already present in the
7038      code.  Mark all locations as inserted.  For now,
7039      make_breakpoint_permanent is called in just one place, so it's
7040      hard to say if it's reasonable to have permanent breakpoint with
7041      multiple locations or not, but it's easy to implement.  */
7042   for (bl = b->loc; bl; bl = bl->next)
7043     bl->inserted = 1;
7044 }
7045
7046 /* Call this routine when stepping and nexting to enable a breakpoint
7047    if we do a longjmp() or 'throw' in TP.  FRAME is the frame which
7048    initiated the operation.  */
7049
7050 void
7051 set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
7052 {
7053   struct breakpoint *b, *b_tmp;
7054   int thread = tp->num;
7055
7056   /* To avoid having to rescan all objfile symbols at every step,
7057      we maintain a list of continually-inserted but always disabled
7058      longjmp "master" breakpoints.  Here, we simply create momentary
7059      clones of those and enable them for the requested thread.  */
7060   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7061     if (b->pspace == current_program_space
7062         && (b->type == bp_longjmp_master
7063             || b->type == bp_exception_master))
7064       {
7065         enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7066         struct breakpoint *clone;
7067
7068         /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7069            after their removal.  */
7070         clone = momentary_breakpoint_from_master (b, type,
7071                                                   &longjmp_breakpoint_ops);
7072         clone->thread = thread;
7073       }
7074
7075   tp->initiating_frame = frame;
7076 }
7077
7078 /* Delete all longjmp breakpoints from THREAD.  */
7079 void
7080 delete_longjmp_breakpoint (int thread)
7081 {
7082   struct breakpoint *b, *b_tmp;
7083
7084   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7085     if (b->type == bp_longjmp || b->type == bp_exception)
7086       {
7087         if (b->thread == thread)
7088           delete_breakpoint (b);
7089       }
7090 }
7091
7092 void
7093 delete_longjmp_breakpoint_at_next_stop (int thread)
7094 {
7095   struct breakpoint *b, *b_tmp;
7096
7097   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7098     if (b->type == bp_longjmp || b->type == bp_exception)
7099       {
7100         if (b->thread == thread)
7101           b->disposition = disp_del_at_next_stop;
7102       }
7103 }
7104
7105 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7106    INFERIOR_PTID thread.  Chain them all by RELATED_BREAKPOINT and return
7107    pointer to any of them.  Return NULL if this system cannot place longjmp
7108    breakpoints.  */
7109
7110 struct breakpoint *
7111 set_longjmp_breakpoint_for_call_dummy (void)
7112 {
7113   struct breakpoint *b, *retval = NULL;
7114
7115   ALL_BREAKPOINTS (b)
7116     if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7117       {
7118         struct breakpoint *new_b;
7119
7120         new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
7121                                                   &momentary_breakpoint_ops);
7122         new_b->thread = pid_to_thread_id (inferior_ptid);
7123
7124         /* Link NEW_B into the chain of RETVAL breakpoints.  */
7125
7126         gdb_assert (new_b->related_breakpoint == new_b);
7127         if (retval == NULL)
7128           retval = new_b;
7129         new_b->related_breakpoint = retval;
7130         while (retval->related_breakpoint != new_b->related_breakpoint)
7131           retval = retval->related_breakpoint;
7132         retval->related_breakpoint = new_b;
7133       }
7134
7135   return retval;
7136 }
7137
7138 /* Verify all existing dummy frames and their associated breakpoints for
7139    THREAD.  Remove those which can no longer be found in the current frame
7140    stack.
7141
7142    You should call this function only at places where it is safe to currently
7143    unwind the whole stack.  Failed stack unwind would discard live dummy
7144    frames.  */
7145
7146 void
7147 check_longjmp_breakpoint_for_call_dummy (int thread)
7148 {
7149   struct breakpoint *b, *b_tmp;
7150
7151   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7152     if (b->type == bp_longjmp_call_dummy && b->thread == thread)
7153       {
7154         struct breakpoint *dummy_b = b->related_breakpoint;
7155
7156         while (dummy_b != b && dummy_b->type != bp_call_dummy)
7157           dummy_b = dummy_b->related_breakpoint;
7158         if (dummy_b->type != bp_call_dummy
7159             || frame_find_by_id (dummy_b->frame_id) != NULL)
7160           continue;
7161         
7162         dummy_frame_discard (dummy_b->frame_id);
7163
7164         while (b->related_breakpoint != b)
7165           {
7166             if (b_tmp == b->related_breakpoint)
7167               b_tmp = b->related_breakpoint->next;
7168             delete_breakpoint (b->related_breakpoint);
7169           }
7170         delete_breakpoint (b);
7171       }
7172 }
7173
7174 void
7175 enable_overlay_breakpoints (void)
7176 {
7177   struct breakpoint *b;
7178
7179   ALL_BREAKPOINTS (b)
7180     if (b->type == bp_overlay_event)
7181     {
7182       b->enable_state = bp_enabled;
7183       update_global_location_list (1);
7184       overlay_events_enabled = 1;
7185     }
7186 }
7187
7188 void
7189 disable_overlay_breakpoints (void)
7190 {
7191   struct breakpoint *b;
7192
7193   ALL_BREAKPOINTS (b)
7194     if (b->type == bp_overlay_event)
7195     {
7196       b->enable_state = bp_disabled;
7197       update_global_location_list (0);
7198       overlay_events_enabled = 0;
7199     }
7200 }
7201
7202 /* Set an active std::terminate breakpoint for each std::terminate
7203    master breakpoint.  */
7204 void
7205 set_std_terminate_breakpoint (void)
7206 {
7207   struct breakpoint *b, *b_tmp;
7208
7209   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7210     if (b->pspace == current_program_space
7211         && b->type == bp_std_terminate_master)
7212       {
7213         momentary_breakpoint_from_master (b, bp_std_terminate,
7214                                           &momentary_breakpoint_ops);
7215       }
7216 }
7217
7218 /* Delete all the std::terminate breakpoints.  */
7219 void
7220 delete_std_terminate_breakpoint (void)
7221 {
7222   struct breakpoint *b, *b_tmp;
7223
7224   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7225     if (b->type == bp_std_terminate)
7226       delete_breakpoint (b);
7227 }
7228
7229 struct breakpoint *
7230 create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7231 {
7232   struct breakpoint *b;
7233
7234   b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7235                                   &internal_breakpoint_ops);
7236
7237   b->enable_state = bp_enabled;
7238   /* addr_string has to be used or breakpoint_re_set will delete me.  */
7239   b->addr_string
7240     = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
7241
7242   update_global_location_list_nothrow (1);
7243
7244   return b;
7245 }
7246
7247 void
7248 remove_thread_event_breakpoints (void)
7249 {
7250   struct breakpoint *b, *b_tmp;
7251
7252   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7253     if (b->type == bp_thread_event
7254         && b->loc->pspace == current_program_space)
7255       delete_breakpoint (b);
7256 }
7257
7258 struct lang_and_radix
7259   {
7260     enum language lang;
7261     int radix;
7262   };
7263
7264 /* Create a breakpoint for JIT code registration and unregistration.  */
7265
7266 struct breakpoint *
7267 create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7268 {
7269   struct breakpoint *b;
7270
7271   b = create_internal_breakpoint (gdbarch, address, bp_jit_event,
7272                                   &internal_breakpoint_ops);
7273   update_global_location_list_nothrow (1);
7274   return b;
7275 }
7276
7277 /* Remove JIT code registration and unregistration breakpoint(s).  */
7278
7279 void
7280 remove_jit_event_breakpoints (void)
7281 {
7282   struct breakpoint *b, *b_tmp;
7283
7284   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7285     if (b->type == bp_jit_event
7286         && b->loc->pspace == current_program_space)
7287       delete_breakpoint (b);
7288 }
7289
7290 void
7291 remove_solib_event_breakpoints (void)
7292 {
7293   struct breakpoint *b, *b_tmp;
7294
7295   ALL_BREAKPOINTS_SAFE (b, b_tmp)
7296     if (b->type == bp_shlib_event
7297         && b->loc->pspace == current_program_space)
7298       delete_breakpoint (b);
7299 }
7300
7301 struct breakpoint *
7302 create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7303 {
7304   struct breakpoint *b;
7305
7306   b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7307                                   &internal_breakpoint_ops);
7308   update_global_location_list_nothrow (1);
7309   return b;
7310 }
7311
7312 /* Disable any breakpoints that are on code in shared libraries.  Only
7313    apply to enabled breakpoints, disabled ones can just stay disabled.  */
7314
7315 void
7316 disable_breakpoints_in_shlibs (void)
7317 {
7318   struct bp_location *loc, **locp_tmp;
7319
7320   ALL_BP_LOCATIONS (loc, locp_tmp)
7321   {
7322     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7323     struct breakpoint *b = loc->owner;
7324
7325     /* We apply the check to all breakpoints, including disabled for
7326        those with loc->duplicate set.  This is so that when breakpoint
7327        becomes enabled, or the duplicate is removed, gdb will try to
7328        insert all breakpoints.  If we don't set shlib_disabled here,
7329        we'll try to insert those breakpoints and fail.  */
7330     if (((b->type == bp_breakpoint)
7331          || (b->type == bp_jit_event)
7332          || (b->type == bp_hardware_breakpoint)
7333          || (is_tracepoint (b)))
7334         && loc->pspace == current_program_space
7335         && !loc->shlib_disabled
7336 #ifdef PC_SOLIB
7337         && PC_SOLIB (loc->address)
7338 #else
7339         && solib_name_from_address (loc->pspace, loc->address)
7340 #endif
7341         )
7342       {
7343         loc->shlib_disabled = 1;
7344       }
7345   }
7346 }
7347
7348 /* Disable any breakpoints and tracepoints that are in an unloaded shared
7349    library.  Only apply to enabled breakpoints, disabled ones can just stay
7350    disabled.  */
7351
7352 static void
7353 disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7354 {
7355   struct bp_location *loc, **locp_tmp;
7356   int disabled_shlib_breaks = 0;
7357
7358   /* SunOS a.out shared libraries are always mapped, so do not
7359      disable breakpoints; they will only be reported as unloaded
7360      through clear_solib when GDB discards its shared library
7361      list.  See clear_solib for more information.  */
7362   if (exec_bfd != NULL
7363       && bfd_get_flavour (exec_bfd) == bfd_target_aout_flavour)
7364     return;
7365
7366   ALL_BP_LOCATIONS (loc, locp_tmp)
7367   {
7368     /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL.  */
7369     struct breakpoint *b = loc->owner;
7370
7371     if (solib->pspace == loc->pspace
7372         && !loc->shlib_disabled
7373         && (((b->type == bp_breakpoint
7374               || b->type == bp_jit_event
7375               || b->type == bp_hardware_breakpoint)
7376              && (loc->loc_type == bp_loc_hardware_breakpoint
7377                  || loc->loc_type == bp_loc_software_breakpoint))
7378             || is_tracepoint (b))
7379         && solib_contains_address_p (solib, loc->address))
7380       {
7381         loc->shlib_disabled = 1;
7382         /* At this point, we cannot rely on remove_breakpoint
7383            succeeding so we must mark the breakpoint as not inserted
7384            to prevent future errors occurring in remove_breakpoints.  */
7385         loc->inserted = 0;
7386
7387         /* This may cause duplicate notifications for the same breakpoint.  */
7388         observer_notify_breakpoint_modified (b);
7389
7390         if (!disabled_shlib_breaks)
7391           {
7392             target_terminal_ours_for_output ();
7393             warning (_("Temporarily disabling breakpoints "
7394                        "for unloaded shared library \"%s\""),
7395                      solib->so_name);
7396           }
7397         disabled_shlib_breaks = 1;
7398       }
7399   }
7400 }
7401
7402 /* FORK & VFORK catchpoints.  */
7403
7404 /* An instance of this type is used to represent a fork or vfork
7405    catchpoint.  It includes a "struct breakpoint" as a kind of base
7406    class; users downcast to "struct breakpoint *" when needed.  A
7407    breakpoint is really of this type iff its ops pointer points to
7408    CATCH_FORK_BREAKPOINT_OPS.  */
7409
7410 struct fork_catchpoint
7411 {
7412   /* The base class.  */
7413   struct breakpoint base;
7414
7415   /* Process id of a child process whose forking triggered this
7416      catchpoint.  This field is only valid immediately after this
7417      catchpoint has triggered.  */
7418   ptid_t forked_inferior_pid;
7419 };
7420
7421 /* Implement the "insert" breakpoint_ops method for fork
7422    catchpoints.  */
7423
7424 static int
7425 insert_catch_fork (struct bp_location *bl)
7426 {
7427   return target_insert_fork_catchpoint (PIDGET (inferior_ptid));
7428 }
7429
7430 /* Implement the "remove" breakpoint_ops method for fork
7431    catchpoints.  */
7432
7433 static int
7434 remove_catch_fork (struct bp_location *bl)
7435 {
7436   return target_remove_fork_catchpoint (PIDGET (inferior_ptid));
7437 }
7438
7439 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7440    catchpoints.  */
7441
7442 static int
7443 breakpoint_hit_catch_fork (const struct bp_location *bl,
7444                            struct address_space *aspace, CORE_ADDR bp_addr,
7445                            const struct target_waitstatus *ws)
7446 {
7447   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7448
7449   if (ws->kind != TARGET_WAITKIND_FORKED)
7450     return 0;
7451
7452   c->forked_inferior_pid = ws->value.related_pid;
7453   return 1;
7454 }
7455
7456 /* Implement the "print_it" breakpoint_ops method for fork
7457    catchpoints.  */
7458
7459 static enum print_stop_action
7460 print_it_catch_fork (bpstat bs)
7461 {
7462   struct ui_out *uiout = current_uiout;
7463   struct breakpoint *b = bs->breakpoint_at;
7464   struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
7465
7466   annotate_catchpoint (b->number);
7467   if (b->disposition == disp_del)
7468     ui_out_text (uiout, "\nTemporary catchpoint ");
7469   else
7470     ui_out_text (uiout, "\nCatchpoint ");
7471   if (ui_out_is_mi_like_p (uiout))
7472     {
7473       ui_out_field_string (uiout, "reason",
7474                            async_reason_lookup (EXEC_ASYNC_FORK));
7475       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7476     }
7477   ui_out_field_int (uiout, "bkptno", b->number);
7478   ui_out_text (uiout, " (forked process ");
7479   ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
7480   ui_out_text (uiout, "), ");
7481   return PRINT_SRC_AND_LOC;
7482 }
7483
7484 /* Implement the "print_one" breakpoint_ops method for fork
7485    catchpoints.  */
7486
7487 static void
7488 print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
7489 {
7490   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7491   struct value_print_options opts;
7492   struct ui_out *uiout = current_uiout;
7493
7494   get_user_print_options (&opts);
7495
7496   /* Field 4, the address, is omitted (which makes the columns not
7497      line up too nicely with the headers, but the effect is relatively
7498      readable).  */
7499   if (opts.addressprint)
7500     ui_out_field_skip (uiout, "addr");
7501   annotate_field (5);
7502   ui_out_text (uiout, "fork");
7503   if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7504     {
7505       ui_out_text (uiout, ", process ");
7506       ui_out_field_int (uiout, "what",
7507                         ptid_get_pid (c->forked_inferior_pid));
7508       ui_out_spaces (uiout, 1);
7509     }
7510 }
7511
7512 /* Implement the "print_mention" breakpoint_ops method for fork
7513    catchpoints.  */
7514
7515 static void
7516 print_mention_catch_fork (struct breakpoint *b)
7517 {
7518   printf_filtered (_("Catchpoint %d (fork)"), b->number);
7519 }
7520
7521 /* Implement the "print_recreate" breakpoint_ops method for fork
7522    catchpoints.  */
7523
7524 static void
7525 print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
7526 {
7527   fprintf_unfiltered (fp, "catch fork");
7528   print_recreate_thread (b, fp);
7529 }
7530
7531 /* The breakpoint_ops structure to be used in fork catchpoints.  */
7532
7533 static struct breakpoint_ops catch_fork_breakpoint_ops;
7534
7535 /* Implement the "insert" breakpoint_ops method for vfork
7536    catchpoints.  */
7537
7538 static int
7539 insert_catch_vfork (struct bp_location *bl)
7540 {
7541   return target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
7542 }
7543
7544 /* Implement the "remove" breakpoint_ops method for vfork
7545    catchpoints.  */
7546
7547 static int
7548 remove_catch_vfork (struct bp_location *bl)
7549 {
7550   return target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
7551 }
7552
7553 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7554    catchpoints.  */
7555
7556 static int
7557 breakpoint_hit_catch_vfork (const struct bp_location *bl,
7558                             struct address_space *aspace, CORE_ADDR bp_addr,
7559                             const struct target_waitstatus *ws)
7560 {
7561   struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7562
7563   if (ws->kind != TARGET_WAITKIND_VFORKED)
7564     return 0;
7565
7566   c->forked_inferior_pid = ws->value.related_pid;
7567   return 1;
7568 }
7569
7570 /* Implement the "print_it" breakpoint_ops method for vfork
7571    catchpoints.  */
7572
7573 static enum print_stop_action
7574 print_it_catch_vfork (bpstat bs)
7575 {
7576   struct ui_out *uiout = current_uiout;
7577   struct breakpoint *b = bs->breakpoint_at;
7578   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7579
7580   annotate_catchpoint (b->number);
7581   if (b->disposition == disp_del)
7582     ui_out_text (uiout, "\nTemporary catchpoint ");
7583   else
7584     ui_out_text (uiout, "\nCatchpoint ");
7585   if (ui_out_is_mi_like_p (uiout))
7586     {
7587       ui_out_field_string (uiout, "reason",
7588                            async_reason_lookup (EXEC_ASYNC_VFORK));
7589       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7590     }
7591   ui_out_field_int (uiout, "bkptno", b->number);
7592   ui_out_text (uiout, " (vforked process ");
7593   ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
7594   ui_out_text (uiout, "), ");
7595   return PRINT_SRC_AND_LOC;
7596 }
7597
7598 /* Implement the "print_one" breakpoint_ops method for vfork
7599    catchpoints.  */
7600
7601 static void
7602 print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
7603 {
7604   struct fork_catchpoint *c = (struct fork_catchpoint *) b;
7605   struct value_print_options opts;
7606   struct ui_out *uiout = current_uiout;
7607
7608   get_user_print_options (&opts);
7609   /* Field 4, the address, is omitted (which makes the columns not
7610      line up too nicely with the headers, but the effect is relatively
7611      readable).  */
7612   if (opts.addressprint)
7613     ui_out_field_skip (uiout, "addr");
7614   annotate_field (5);
7615   ui_out_text (uiout, "vfork");
7616   if (!ptid_equal (c->forked_inferior_pid, null_ptid))
7617     {
7618       ui_out_text (uiout, ", process ");
7619       ui_out_field_int (uiout, "what",
7620                         ptid_get_pid (c->forked_inferior_pid));
7621       ui_out_spaces (uiout, 1);
7622     }
7623 }
7624
7625 /* Implement the "print_mention" breakpoint_ops method for vfork
7626    catchpoints.  */
7627
7628 static void
7629 print_mention_catch_vfork (struct breakpoint *b)
7630 {
7631   printf_filtered (_("Catchpoint %d (vfork)"), b->number);
7632 }
7633
7634 /* Implement the "print_recreate" breakpoint_ops method for vfork
7635    catchpoints.  */
7636
7637 static void
7638 print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
7639 {
7640   fprintf_unfiltered (fp, "catch vfork");
7641   print_recreate_thread (b, fp);
7642 }
7643
7644 /* The breakpoint_ops structure to be used in vfork catchpoints.  */
7645
7646 static struct breakpoint_ops catch_vfork_breakpoint_ops;
7647
7648 /* An instance of this type is used to represent an solib catchpoint.
7649    It includes a "struct breakpoint" as a kind of base class; users
7650    downcast to "struct breakpoint *" when needed.  A breakpoint is
7651    really of this type iff its ops pointer points to
7652    CATCH_SOLIB_BREAKPOINT_OPS.  */
7653
7654 struct solib_catchpoint
7655 {
7656   /* The base class.  */
7657   struct breakpoint base;
7658
7659   /* True for "catch load", false for "catch unload".  */
7660   unsigned char is_load;
7661
7662   /* Regular expression to match, if any.  COMPILED is only valid when
7663      REGEX is non-NULL.  */
7664   char *regex;
7665   regex_t compiled;
7666 };
7667
7668 static void
7669 dtor_catch_solib (struct breakpoint *b)
7670 {
7671   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7672
7673   if (self->regex)
7674     regfree (&self->compiled);
7675   xfree (self->regex);
7676
7677   base_breakpoint_ops.dtor (b);
7678 }
7679
7680 static int
7681 insert_catch_solib (struct bp_location *ignore)
7682 {
7683   return 0;
7684 }
7685
7686 static int
7687 remove_catch_solib (struct bp_location *ignore)
7688 {
7689   return 0;
7690 }
7691
7692 static int
7693 breakpoint_hit_catch_solib (const struct bp_location *bl,
7694                             struct address_space *aspace,
7695                             CORE_ADDR bp_addr,
7696                             const struct target_waitstatus *ws)
7697 {
7698   struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
7699   struct breakpoint *other;
7700
7701   if (ws->kind == TARGET_WAITKIND_LOADED)
7702     return 1;
7703
7704   ALL_BREAKPOINTS (other)
7705   {
7706     struct bp_location *other_bl;
7707
7708     if (other == bl->owner)
7709       continue;
7710
7711     if (other->type != bp_shlib_event)
7712       continue;
7713
7714     if (self->base.pspace != NULL && other->pspace != self->base.pspace)
7715       continue;
7716
7717     for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
7718       {
7719         if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
7720           return 1;
7721       }
7722   }
7723
7724   return 0;
7725 }
7726
7727 static void
7728 check_status_catch_solib (struct bpstats *bs)
7729 {
7730   struct solib_catchpoint *self
7731     = (struct solib_catchpoint *) bs->breakpoint_at;
7732   int ix;
7733
7734   if (self->is_load)
7735     {
7736       struct so_list *iter;
7737
7738       for (ix = 0;
7739            VEC_iterate (so_list_ptr, current_program_space->added_solibs,
7740                         ix, iter);
7741            ++ix)
7742         {
7743           if (!self->regex
7744               || regexec (&self->compiled, iter->so_name, 0, NULL, 0) == 0)
7745             return;
7746         }
7747     }
7748   else
7749     {
7750       char *iter;
7751
7752       for (ix = 0;
7753            VEC_iterate (char_ptr, current_program_space->deleted_solibs,
7754                         ix, iter);
7755            ++ix)
7756         {
7757           if (!self->regex
7758               || regexec (&self->compiled, iter, 0, NULL, 0) == 0)
7759             return;
7760         }
7761     }
7762
7763   bs->stop = 0;
7764   bs->print_it = print_it_noop;
7765 }
7766
7767 static enum print_stop_action
7768 print_it_catch_solib (bpstat bs)
7769 {
7770   struct breakpoint *b = bs->breakpoint_at;
7771   struct ui_out *uiout = current_uiout;
7772
7773   annotate_catchpoint (b->number);
7774   if (b->disposition == disp_del)
7775     ui_out_text (uiout, "\nTemporary catchpoint ");
7776   else
7777     ui_out_text (uiout, "\nCatchpoint ");
7778   ui_out_field_int (uiout, "bkptno", b->number);
7779   ui_out_text (uiout, "\n");
7780   if (ui_out_is_mi_like_p (uiout))
7781     ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
7782   print_solib_event (1);
7783   return PRINT_SRC_AND_LOC;
7784 }
7785
7786 static void
7787 print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
7788 {
7789   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7790   struct value_print_options opts;
7791   struct ui_out *uiout = current_uiout;
7792   char *msg;
7793
7794   get_user_print_options (&opts);
7795   /* Field 4, the address, is omitted (which makes the columns not
7796      line up too nicely with the headers, but the effect is relatively
7797      readable).  */
7798   if (opts.addressprint)
7799     {
7800       annotate_field (4);
7801       ui_out_field_skip (uiout, "addr");
7802     }
7803
7804   annotate_field (5);
7805   if (self->is_load)
7806     {
7807       if (self->regex)
7808         msg = xstrprintf (_("load of library matching %s"), self->regex);
7809       else
7810         msg = xstrdup (_("load of library"));
7811     }
7812   else
7813     {
7814       if (self->regex)
7815         msg = xstrprintf (_("unload of library matching %s"), self->regex);
7816       else
7817         msg = xstrdup (_("unload of library"));
7818     }
7819   ui_out_field_string (uiout, "what", msg);
7820   xfree (msg);
7821 }
7822
7823 static void
7824 print_mention_catch_solib (struct breakpoint *b)
7825 {
7826   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7827
7828   printf_filtered (_("Catchpoint %d (%s)"), b->number,
7829                    self->is_load ? "load" : "unload");
7830 }
7831
7832 static void
7833 print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
7834 {
7835   struct solib_catchpoint *self = (struct solib_catchpoint *) b;
7836
7837   fprintf_unfiltered (fp, "%s %s",
7838                       b->disposition == disp_del ? "tcatch" : "catch",
7839                       self->is_load ? "load" : "unload");
7840   if (self->regex)
7841     fprintf_unfiltered (fp, " %s", self->regex);
7842   fprintf_unfiltered (fp, "\n");
7843 }
7844
7845 static struct breakpoint_ops catch_solib_breakpoint_ops;
7846
7847 /* A helper function that does all the work for "catch load" and
7848    "catch unload".  */
7849
7850 static void
7851 catch_load_or_unload (char *arg, int from_tty, int is_load,
7852                       struct cmd_list_element *command)
7853 {
7854   struct solib_catchpoint *c;
7855   struct gdbarch *gdbarch = get_current_arch ();
7856   int tempflag;
7857   struct cleanup *cleanup;
7858
7859   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
7860
7861   if (!arg)
7862     arg = "";
7863   arg = skip_spaces (arg);
7864
7865   c = XCNEW (struct solib_catchpoint);
7866   cleanup = make_cleanup (xfree, c);
7867
7868   if (*arg != '\0')
7869     {
7870       int errcode;
7871
7872       errcode = regcomp (&c->compiled, arg, REG_NOSUB);
7873       if (errcode != 0)
7874         {
7875           char *err = get_regcomp_error (errcode, &c->compiled);
7876
7877           make_cleanup (xfree, err);
7878           error (_("Invalid regexp (%s): %s"), err, arg);
7879         }
7880       c->regex = xstrdup (arg);
7881     }
7882
7883   c->is_load = is_load;
7884   init_catchpoint (&c->base, gdbarch, tempflag, NULL,
7885                    &catch_solib_breakpoint_ops);
7886
7887   discard_cleanups (cleanup);
7888   install_breakpoint (0, &c->base, 1);
7889 }
7890
7891 static void
7892 catch_load_command_1 (char *arg, int from_tty,
7893                       struct cmd_list_element *command)
7894 {
7895   catch_load_or_unload (arg, from_tty, 1, command);
7896 }
7897
7898 static void
7899 catch_unload_command_1 (char *arg, int from_tty,
7900                         struct cmd_list_element *command)
7901 {
7902   catch_load_or_unload (arg, from_tty, 0, command);
7903 }
7904
7905 DEF_VEC_I(int);
7906
7907 /* An instance of this type is used to represent a syscall catchpoint.
7908    It includes a "struct breakpoint" as a kind of base class; users
7909    downcast to "struct breakpoint *" when needed.  A breakpoint is
7910    really of this type iff its ops pointer points to
7911    CATCH_SYSCALL_BREAKPOINT_OPS.  */
7912
7913 struct syscall_catchpoint
7914 {
7915   /* The base class.  */
7916   struct breakpoint base;
7917
7918   /* Syscall numbers used for the 'catch syscall' feature.  If no
7919      syscall has been specified for filtering, its value is NULL.
7920      Otherwise, it holds a list of all syscalls to be caught.  The
7921      list elements are allocated with xmalloc.  */
7922   VEC(int) *syscalls_to_be_caught;
7923 };
7924
7925 /* Implement the "dtor" breakpoint_ops method for syscall
7926    catchpoints.  */
7927
7928 static void
7929 dtor_catch_syscall (struct breakpoint *b)
7930 {
7931   struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
7932
7933   VEC_free (int, c->syscalls_to_be_caught);
7934
7935   base_breakpoint_ops.dtor (b);
7936 }
7937
7938 static const struct inferior_data *catch_syscall_inferior_data = NULL;
7939
7940 struct catch_syscall_inferior_data
7941 {
7942   /* We keep a count of the number of times the user has requested a
7943      particular syscall to be tracked, and pass this information to the
7944      target.  This lets capable targets implement filtering directly.  */
7945
7946   /* Number of times that "any" syscall is requested.  */
7947   int any_syscall_count;
7948
7949   /* Count of each system call.  */
7950   VEC(int) *syscalls_counts;
7951
7952   /* This counts all syscall catch requests, so we can readily determine
7953      if any catching is necessary.  */
7954   int total_syscalls_count;
7955 };
7956
7957 static struct catch_syscall_inferior_data*
7958 get_catch_syscall_inferior_data (struct inferior *inf)
7959 {
7960   struct catch_syscall_inferior_data *inf_data;
7961
7962   inf_data = inferior_data (inf, catch_syscall_inferior_data);
7963   if (inf_data == NULL)
7964     {
7965       inf_data = XZALLOC (struct catch_syscall_inferior_data);
7966       set_inferior_data (inf, catch_syscall_inferior_data, inf_data);
7967     }
7968
7969   return inf_data;
7970 }
7971
7972 static void
7973 catch_syscall_inferior_data_cleanup (struct inferior *inf, void *arg)
7974 {
7975   xfree (arg);
7976 }
7977
7978
7979 /* Implement the "insert" breakpoint_ops method for syscall
7980    catchpoints.  */
7981
7982 static int
7983 insert_catch_syscall (struct bp_location *bl)
7984 {
7985   struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
7986   struct inferior *inf = current_inferior ();
7987   struct catch_syscall_inferior_data *inf_data
7988     = get_catch_syscall_inferior_data (inf);
7989
7990   ++inf_data->total_syscalls_count;
7991   if (!c->syscalls_to_be_caught)
7992     ++inf_data->any_syscall_count;
7993   else
7994     {
7995       int i, iter;
7996
7997       for (i = 0;
7998            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
7999            i++)
8000         {
8001           int elem;
8002
8003           if (iter >= VEC_length (int, inf_data->syscalls_counts))
8004             {
8005               int old_size = VEC_length (int, inf_data->syscalls_counts);
8006               uintptr_t vec_addr_offset
8007                 = old_size * ((uintptr_t) sizeof (int));
8008               uintptr_t vec_addr;
8009               VEC_safe_grow (int, inf_data->syscalls_counts, iter + 1);
8010               vec_addr = ((uintptr_t) VEC_address (int,
8011                                                   inf_data->syscalls_counts)
8012                           + vec_addr_offset);
8013               memset ((void *) vec_addr, 0,
8014                       (iter + 1 - old_size) * sizeof (int));
8015             }
8016           elem = VEC_index (int, inf_data->syscalls_counts, iter);
8017           VEC_replace (int, inf_data->syscalls_counts, iter, ++elem);
8018         }
8019     }
8020
8021   return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
8022                                         inf_data->total_syscalls_count != 0,
8023                                         inf_data->any_syscall_count,
8024                                         VEC_length (int,
8025                                                     inf_data->syscalls_counts),
8026                                         VEC_address (int,
8027                                                      inf_data->syscalls_counts));
8028 }
8029
8030 /* Implement the "remove" breakpoint_ops method for syscall
8031    catchpoints.  */
8032
8033 static int
8034 remove_catch_syscall (struct bp_location *bl)
8035 {
8036   struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
8037   struct inferior *inf = current_inferior ();
8038   struct catch_syscall_inferior_data *inf_data
8039     = get_catch_syscall_inferior_data (inf);
8040
8041   --inf_data->total_syscalls_count;
8042   if (!c->syscalls_to_be_caught)
8043     --inf_data->any_syscall_count;
8044   else
8045     {
8046       int i, iter;
8047
8048       for (i = 0;
8049            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8050            i++)
8051         {
8052           int elem;
8053           if (iter >= VEC_length (int, inf_data->syscalls_counts))
8054             /* Shouldn't happen.  */
8055             continue;
8056           elem = VEC_index (int, inf_data->syscalls_counts, iter);
8057           VEC_replace (int, inf_data->syscalls_counts, iter, --elem);
8058         }
8059     }
8060
8061   return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
8062                                         inf_data->total_syscalls_count != 0,
8063                                         inf_data->any_syscall_count,
8064                                         VEC_length (int,
8065                                                     inf_data->syscalls_counts),
8066                                         VEC_address (int,
8067                                                      inf_data->syscalls_counts));
8068 }
8069
8070 /* Implement the "breakpoint_hit" breakpoint_ops method for syscall
8071    catchpoints.  */
8072
8073 static int
8074 breakpoint_hit_catch_syscall (const struct bp_location *bl,
8075                               struct address_space *aspace, CORE_ADDR bp_addr,
8076                               const struct target_waitstatus *ws)
8077 {
8078   /* We must check if we are catching specific syscalls in this
8079      breakpoint.  If we are, then we must guarantee that the called
8080      syscall is the same syscall we are catching.  */
8081   int syscall_number = 0;
8082   const struct syscall_catchpoint *c
8083     = (const struct syscall_catchpoint *) bl->owner;
8084
8085   if (ws->kind != TARGET_WAITKIND_SYSCALL_ENTRY
8086       && ws->kind != TARGET_WAITKIND_SYSCALL_RETURN)
8087     return 0;
8088
8089   syscall_number = ws->value.syscall_number;
8090
8091   /* Now, checking if the syscall is the same.  */
8092   if (c->syscalls_to_be_caught)
8093     {
8094       int i, iter;
8095
8096       for (i = 0;
8097            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8098            i++)
8099         if (syscall_number == iter)
8100           break;
8101       /* Not the same.  */
8102       if (!iter)
8103         return 0;
8104     }
8105
8106   return 1;
8107 }
8108
8109 /* Implement the "print_it" breakpoint_ops method for syscall
8110    catchpoints.  */
8111
8112 static enum print_stop_action
8113 print_it_catch_syscall (bpstat bs)
8114 {
8115   struct ui_out *uiout = current_uiout;
8116   struct breakpoint *b = bs->breakpoint_at;
8117   /* These are needed because we want to know in which state a
8118      syscall is.  It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
8119      or TARGET_WAITKIND_SYSCALL_RETURN, and depending on it we
8120      must print "called syscall" or "returned from syscall".  */
8121   ptid_t ptid;
8122   struct target_waitstatus last;
8123   struct syscall s;
8124
8125   get_last_target_status (&ptid, &last);
8126
8127   get_syscall_by_number (last.value.syscall_number, &s);
8128
8129   annotate_catchpoint (b->number);
8130
8131   if (b->disposition == disp_del)
8132     ui_out_text (uiout, "\nTemporary catchpoint ");
8133   else
8134     ui_out_text (uiout, "\nCatchpoint ");
8135   if (ui_out_is_mi_like_p (uiout))
8136     {
8137       ui_out_field_string (uiout, "reason",
8138                            async_reason_lookup (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY
8139                                                 ? EXEC_ASYNC_SYSCALL_ENTRY
8140                                                 : EXEC_ASYNC_SYSCALL_RETURN));
8141       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8142     }
8143   ui_out_field_int (uiout, "bkptno", b->number);
8144
8145   if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
8146     ui_out_text (uiout, " (call to syscall ");
8147   else
8148     ui_out_text (uiout, " (returned from syscall ");
8149
8150   if (s.name == NULL || ui_out_is_mi_like_p (uiout))
8151     ui_out_field_int (uiout, "syscall-number", last.value.syscall_number);
8152   if (s.name != NULL)
8153     ui_out_field_string (uiout, "syscall-name", s.name);
8154
8155   ui_out_text (uiout, "), ");
8156
8157   return PRINT_SRC_AND_LOC;
8158 }
8159
8160 /* Implement the "print_one" breakpoint_ops method for syscall
8161    catchpoints.  */
8162
8163 static void
8164 print_one_catch_syscall (struct breakpoint *b,
8165                          struct bp_location **last_loc)
8166 {
8167   struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8168   struct value_print_options opts;
8169   struct ui_out *uiout = current_uiout;
8170
8171   get_user_print_options (&opts);
8172   /* Field 4, the address, is omitted (which makes the columns not
8173      line up too nicely with the headers, but the effect is relatively
8174      readable).  */
8175   if (opts.addressprint)
8176     ui_out_field_skip (uiout, "addr");
8177   annotate_field (5);
8178
8179   if (c->syscalls_to_be_caught
8180       && VEC_length (int, c->syscalls_to_be_caught) > 1)
8181     ui_out_text (uiout, "syscalls \"");
8182   else
8183     ui_out_text (uiout, "syscall \"");
8184
8185   if (c->syscalls_to_be_caught)
8186     {
8187       int i, iter;
8188       char *text = xstrprintf ("%s", "");
8189
8190       for (i = 0;
8191            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8192            i++)
8193         {
8194           char *x = text;
8195           struct syscall s;
8196           get_syscall_by_number (iter, &s);
8197
8198           if (s.name != NULL)
8199             text = xstrprintf ("%s%s, ", text, s.name);
8200           else
8201             text = xstrprintf ("%s%d, ", text, iter);
8202
8203           /* We have to xfree the last 'text' (now stored at 'x')
8204              because xstrprintf dynamically allocates new space for it
8205              on every call.  */
8206           xfree (x);
8207         }
8208       /* Remove the last comma.  */
8209       text[strlen (text) - 2] = '\0';
8210       ui_out_field_string (uiout, "what", text);
8211     }
8212   else
8213     ui_out_field_string (uiout, "what", "<any syscall>");
8214   ui_out_text (uiout, "\" ");
8215 }
8216
8217 /* Implement the "print_mention" breakpoint_ops method for syscall
8218    catchpoints.  */
8219
8220 static void
8221 print_mention_catch_syscall (struct breakpoint *b)
8222 {
8223   struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8224
8225   if (c->syscalls_to_be_caught)
8226     {
8227       int i, iter;
8228
8229       if (VEC_length (int, c->syscalls_to_be_caught) > 1)
8230         printf_filtered (_("Catchpoint %d (syscalls"), b->number);
8231       else
8232         printf_filtered (_("Catchpoint %d (syscall"), b->number);
8233
8234       for (i = 0;
8235            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8236            i++)
8237         {
8238           struct syscall s;
8239           get_syscall_by_number (iter, &s);
8240
8241           if (s.name)
8242             printf_filtered (" '%s' [%d]", s.name, s.number);
8243           else
8244             printf_filtered (" %d", s.number);
8245         }
8246       printf_filtered (")");
8247     }
8248   else
8249     printf_filtered (_("Catchpoint %d (any syscall)"),
8250                      b->number);
8251 }
8252
8253 /* Implement the "print_recreate" breakpoint_ops method for syscall
8254    catchpoints.  */
8255
8256 static void
8257 print_recreate_catch_syscall (struct breakpoint *b, struct ui_file *fp)
8258 {
8259   struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
8260
8261   fprintf_unfiltered (fp, "catch syscall");
8262
8263   if (c->syscalls_to_be_caught)
8264     {
8265       int i, iter;
8266
8267       for (i = 0;
8268            VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
8269            i++)
8270         {
8271           struct syscall s;
8272
8273           get_syscall_by_number (iter, &s);
8274           if (s.name)
8275             fprintf_unfiltered (fp, " %s", s.name);
8276           else
8277             fprintf_unfiltered (fp, " %d", s.number);
8278         }
8279     }
8280   print_recreate_thread (b, fp);
8281 }
8282
8283 /* The breakpoint_ops structure to be used in syscall catchpoints.  */
8284
8285 static struct breakpoint_ops catch_syscall_breakpoint_ops;
8286
8287 /* Returns non-zero if 'b' is a syscall catchpoint.  */
8288
8289 static int
8290 syscall_catchpoint_p (struct breakpoint *b)
8291 {
8292   return (b->ops == &catch_syscall_breakpoint_ops);
8293 }
8294
8295 /* Initialize a new breakpoint of the bp_catchpoint kind.  If TEMPFLAG
8296    is non-zero, then make the breakpoint temporary.  If COND_STRING is
8297    not NULL, then store it in the breakpoint.  OPS, if not NULL, is
8298    the breakpoint_ops structure associated to the catchpoint.  */
8299
8300 static void
8301 init_catchpoint (struct breakpoint *b,
8302                  struct gdbarch *gdbarch, int tempflag,
8303                  char *cond_string,
8304                  const struct breakpoint_ops *ops)
8305 {
8306   struct symtab_and_line sal;
8307
8308   init_sal (&sal);
8309   sal.pspace = current_program_space;
8310
8311   init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
8312
8313   b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
8314   b->disposition = tempflag ? disp_del : disp_donttouch;
8315 }
8316
8317 void
8318 install_breakpoint (int internal, struct breakpoint *b, int update_gll)
8319 {
8320   add_to_breakpoint_chain (b);
8321   set_breakpoint_number (internal, b);
8322   if (!internal)
8323     mention (b);
8324   observer_notify_breakpoint_created (b);
8325
8326   if (update_gll)
8327     update_global_location_list (1);
8328 }
8329
8330 static void
8331 create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
8332                                     int tempflag, char *cond_string,
8333                                     const struct breakpoint_ops *ops)
8334 {
8335   struct fork_catchpoint *c = XNEW (struct fork_catchpoint);
8336
8337   init_catchpoint (&c->base, gdbarch, tempflag, cond_string, ops);
8338
8339   c->forked_inferior_pid = null_ptid;
8340
8341   install_breakpoint (0, &c->base, 1);
8342 }
8343
8344 /* Exec catchpoints.  */
8345
8346 /* An instance of this type is used to represent an exec catchpoint.
8347    It includes a "struct breakpoint" as a kind of base class; users
8348    downcast to "struct breakpoint *" when needed.  A breakpoint is
8349    really of this type iff its ops pointer points to
8350    CATCH_EXEC_BREAKPOINT_OPS.  */
8351
8352 struct exec_catchpoint
8353 {
8354   /* The base class.  */
8355   struct breakpoint base;
8356
8357   /* Filename of a program whose exec triggered this catchpoint.
8358      This field is only valid immediately after this catchpoint has
8359      triggered.  */
8360   char *exec_pathname;
8361 };
8362
8363 /* Implement the "dtor" breakpoint_ops method for exec
8364    catchpoints.  */
8365
8366 static void
8367 dtor_catch_exec (struct breakpoint *b)
8368 {
8369   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8370
8371   xfree (c->exec_pathname);
8372
8373   base_breakpoint_ops.dtor (b);
8374 }
8375
8376 static int
8377 insert_catch_exec (struct bp_location *bl)
8378 {
8379   return target_insert_exec_catchpoint (PIDGET (inferior_ptid));
8380 }
8381
8382 static int
8383 remove_catch_exec (struct bp_location *bl)
8384 {
8385   return target_remove_exec_catchpoint (PIDGET (inferior_ptid));
8386 }
8387
8388 static int
8389 breakpoint_hit_catch_exec (const struct bp_location *bl,
8390                            struct address_space *aspace, CORE_ADDR bp_addr,
8391                            const struct target_waitstatus *ws)
8392 {
8393   struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8394
8395   if (ws->kind != TARGET_WAITKIND_EXECD)
8396     return 0;
8397
8398   c->exec_pathname = xstrdup (ws->value.execd_pathname);
8399   return 1;
8400 }
8401
8402 static enum print_stop_action
8403 print_it_catch_exec (bpstat bs)
8404 {
8405   struct ui_out *uiout = current_uiout;
8406   struct breakpoint *b = bs->breakpoint_at;
8407   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8408
8409   annotate_catchpoint (b->number);
8410   if (b->disposition == disp_del)
8411     ui_out_text (uiout, "\nTemporary catchpoint ");
8412   else
8413     ui_out_text (uiout, "\nCatchpoint ");
8414   if (ui_out_is_mi_like_p (uiout))
8415     {
8416       ui_out_field_string (uiout, "reason",
8417                            async_reason_lookup (EXEC_ASYNC_EXEC));
8418       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8419     }
8420   ui_out_field_int (uiout, "bkptno", b->number);
8421   ui_out_text (uiout, " (exec'd ");
8422   ui_out_field_string (uiout, "new-exec", c->exec_pathname);
8423   ui_out_text (uiout, "), ");
8424
8425   return PRINT_SRC_AND_LOC;
8426 }
8427
8428 static void
8429 print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
8430 {
8431   struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8432   struct value_print_options opts;
8433   struct ui_out *uiout = current_uiout;
8434
8435   get_user_print_options (&opts);
8436
8437   /* Field 4, the address, is omitted (which makes the columns
8438      not line up too nicely with the headers, but the effect
8439      is relatively readable).  */
8440   if (opts.addressprint)
8441     ui_out_field_skip (uiout, "addr");
8442   annotate_field (5);
8443   ui_out_text (uiout, "exec");
8444   if (c->exec_pathname != NULL)
8445     {
8446       ui_out_text (uiout, ", program \"");
8447       ui_out_field_string (uiout, "what", c->exec_pathname);
8448       ui_out_text (uiout, "\" ");
8449     }
8450 }
8451
8452 static void
8453 print_mention_catch_exec (struct breakpoint *b)
8454 {
8455   printf_filtered (_("Catchpoint %d (exec)"), b->number);
8456 }
8457
8458 /* Implement the "print_recreate" breakpoint_ops method for exec
8459    catchpoints.  */
8460
8461 static void
8462 print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8463 {
8464   fprintf_unfiltered (fp, "catch exec");
8465   print_recreate_thread (b, fp);
8466 }
8467
8468 static struct breakpoint_ops catch_exec_breakpoint_ops;
8469
8470 static void
8471 create_syscall_event_catchpoint (int tempflag, VEC(int) *filter,
8472                                  const struct breakpoint_ops *ops)
8473 {
8474   struct syscall_catchpoint *c;
8475   struct gdbarch *gdbarch = get_current_arch ();
8476
8477   c = XNEW (struct syscall_catchpoint);
8478   init_catchpoint (&c->base, gdbarch, tempflag, NULL, ops);
8479   c->syscalls_to_be_caught = filter;
8480
8481   install_breakpoint (0, &c->base, 1);
8482 }
8483
8484 static int
8485 hw_breakpoint_used_count (void)
8486 {
8487   int i = 0;
8488   struct breakpoint *b;
8489   struct bp_location *bl;
8490
8491   ALL_BREAKPOINTS (b)
8492   {
8493     if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
8494       for (bl = b->loc; bl; bl = bl->next)
8495         {
8496           /* Special types of hardware breakpoints may use more than
8497              one register.  */
8498           i += b->ops->resources_needed (bl);
8499         }
8500   }
8501
8502   return i;
8503 }
8504
8505 /* Returns the resources B would use if it were a hardware
8506    watchpoint.  */
8507
8508 static int
8509 hw_watchpoint_use_count (struct breakpoint *b)
8510 {
8511   int i = 0;
8512   struct bp_location *bl;
8513
8514   if (!breakpoint_enabled (b))
8515     return 0;
8516
8517   for (bl = b->loc; bl; bl = bl->next)
8518     {
8519       /* Special types of hardware watchpoints may use more than
8520          one register.  */
8521       i += b->ops->resources_needed (bl);
8522     }
8523
8524   return i;
8525 }
8526
8527 /* Returns the sum the used resources of all hardware watchpoints of
8528    type TYPE in the breakpoints list.  Also returns in OTHER_TYPE_USED
8529    the sum of the used resources of all hardware watchpoints of other
8530    types _not_ TYPE.  */
8531
8532 static int
8533 hw_watchpoint_used_count_others (struct breakpoint *except,
8534                                  enum bptype type, int *other_type_used)
8535 {
8536   int i = 0;
8537   struct breakpoint *b;
8538
8539   *other_type_used = 0;
8540   ALL_BREAKPOINTS (b)
8541     {
8542       if (b == except)
8543         continue;
8544       if (!breakpoint_enabled (b))
8545         continue;
8546
8547       if (b->type == type)
8548         i += hw_watchpoint_use_count (b);
8549       else if (is_hardware_watchpoint (b))
8550         *other_type_used = 1;
8551     }
8552
8553   return i;
8554 }
8555
8556 void
8557 disable_watchpoints_before_interactive_call_start (void)
8558 {
8559   struct breakpoint *b;
8560
8561   ALL_BREAKPOINTS (b)
8562   {
8563     if (is_watchpoint (b) && breakpoint_enabled (b))
8564       {
8565         b->enable_state = bp_call_disabled;
8566         update_global_location_list (0);
8567       }
8568   }
8569 }
8570
8571 void
8572 enable_watchpoints_after_interactive_call_stop (void)
8573 {
8574   struct breakpoint *b;
8575
8576   ALL_BREAKPOINTS (b)
8577   {
8578     if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
8579       {
8580         b->enable_state = bp_enabled;
8581         update_global_location_list (1);
8582       }
8583   }
8584 }
8585
8586 void
8587 disable_breakpoints_before_startup (void)
8588 {
8589   current_program_space->executing_startup = 1;
8590   update_global_location_list (0);
8591 }
8592
8593 void
8594 enable_breakpoints_after_startup (void)
8595 {
8596   current_program_space->executing_startup = 0;
8597   breakpoint_re_set ();
8598 }
8599
8600
8601 /* Set a breakpoint that will evaporate an end of command
8602    at address specified by SAL.
8603    Restrict it to frame FRAME if FRAME is nonzero.  */
8604
8605 struct breakpoint *
8606 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8607                           struct frame_id frame_id, enum bptype type)
8608 {
8609   struct breakpoint *b;
8610
8611   /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8612      tail-called one.  */
8613   gdb_assert (!frame_id_artificial_p (frame_id));
8614
8615   b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
8616   b->enable_state = bp_enabled;
8617   b->disposition = disp_donttouch;
8618   b->frame_id = frame_id;
8619
8620   /* If we're debugging a multi-threaded program, then we want
8621      momentary breakpoints to be active in only a single thread of
8622      control.  */
8623   if (in_thread_list (inferior_ptid))
8624     b->thread = pid_to_thread_id (inferior_ptid);
8625
8626   update_global_location_list_nothrow (1);
8627
8628   return b;
8629 }
8630
8631 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8632    The new breakpoint will have type TYPE, and use OPS as it
8633    breakpoint_ops.  */
8634
8635 static struct breakpoint *
8636 momentary_breakpoint_from_master (struct breakpoint *orig,
8637                                   enum bptype type,
8638                                   const struct breakpoint_ops *ops)
8639 {
8640   struct breakpoint *copy;
8641
8642   copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
8643   copy->loc = allocate_bp_location (copy);
8644   set_breakpoint_location_function (copy->loc, 1);
8645
8646   copy->loc->gdbarch = orig->loc->gdbarch;
8647   copy->loc->requested_address = orig->loc->requested_address;
8648   copy->loc->address = orig->loc->address;
8649   copy->loc->section = orig->loc->section;
8650   copy->loc->pspace = orig->loc->pspace;
8651   copy->loc->probe = orig->loc->probe;
8652
8653   if (orig->loc->source_file != NULL)
8654     copy->loc->source_file = xstrdup (orig->loc->source_file);
8655
8656   copy->loc->line_number = orig->loc->line_number;
8657   copy->frame_id = orig->frame_id;
8658   copy->thread = orig->thread;
8659   copy->pspace = orig->pspace;
8660
8661   copy->enable_state = bp_enabled;
8662   copy->disposition = disp_donttouch;
8663   copy->number = internal_breakpoint_number--;
8664
8665   update_global_location_list_nothrow (0);
8666   return copy;
8667 }
8668
8669 /* Make a deep copy of momentary breakpoint ORIG.  Returns NULL if
8670    ORIG is NULL.  */
8671
8672 struct breakpoint *
8673 clone_momentary_breakpoint (struct breakpoint *orig)
8674 {
8675   /* If there's nothing to clone, then return nothing.  */
8676   if (orig == NULL)
8677     return NULL;
8678
8679   return momentary_breakpoint_from_master (orig, orig->type, orig->ops);
8680 }
8681
8682 struct breakpoint *
8683 set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8684                                 enum bptype type)
8685 {
8686   struct symtab_and_line sal;
8687
8688   sal = find_pc_line (pc, 0);
8689   sal.pc = pc;
8690   sal.section = find_pc_overlay (pc);
8691   sal.explicit_pc = 1;
8692
8693   return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
8694 }
8695 \f
8696
8697 /* Tell the user we have just set a breakpoint B.  */
8698
8699 static void
8700 mention (struct breakpoint *b)
8701 {
8702   b->ops->print_mention (b);
8703   if (ui_out_is_mi_like_p (current_uiout))
8704     return;
8705   printf_filtered ("\n");
8706 }
8707 \f
8708
8709 static struct bp_location *
8710 add_location_to_breakpoint (struct breakpoint *b,
8711                             const struct symtab_and_line *sal)
8712 {
8713   struct bp_location *loc, **tmp;
8714   CORE_ADDR adjusted_address;
8715   struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
8716
8717   if (loc_gdbarch == NULL)
8718     loc_gdbarch = b->gdbarch;
8719
8720   /* Adjust the breakpoint's address prior to allocating a location.
8721      Once we call allocate_bp_location(), that mostly uninitialized
8722      location will be placed on the location chain.  Adjustment of the
8723      breakpoint may cause target_read_memory() to be called and we do
8724      not want its scan of the location chain to find a breakpoint and
8725      location that's only been partially initialized.  */
8726   adjusted_address = adjust_breakpoint_address (loc_gdbarch,
8727                                                 sal->pc, b->type);
8728
8729   loc = allocate_bp_location (b);
8730   for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
8731     ;
8732   *tmp = loc;
8733
8734   loc->requested_address = sal->pc;
8735   loc->address = adjusted_address;
8736   loc->pspace = sal->pspace;
8737   loc->probe = sal->probe;
8738   gdb_assert (loc->pspace != NULL);
8739   loc->section = sal->section;
8740   loc->gdbarch = loc_gdbarch;
8741
8742   if (sal->symtab != NULL)
8743     loc->source_file = xstrdup (sal->symtab->filename);
8744   loc->line_number = sal->line;
8745
8746   set_breakpoint_location_function (loc,
8747                                     sal->explicit_pc || sal->explicit_line);
8748   return loc;
8749 }
8750 \f
8751
8752 /* Return 1 if LOC is pointing to a permanent breakpoint, 
8753    return 0 otherwise.  */
8754
8755 static int
8756 bp_loc_is_permanent (struct bp_location *loc)
8757 {
8758   int len;
8759   CORE_ADDR addr;
8760   const gdb_byte *bpoint;
8761   gdb_byte *target_mem;
8762   struct cleanup *cleanup;
8763   int retval = 0;
8764
8765   gdb_assert (loc != NULL);
8766
8767   addr = loc->address;
8768   bpoint = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
8769
8770   /* Software breakpoints unsupported?  */
8771   if (bpoint == NULL)
8772     return 0;
8773
8774   target_mem = alloca (len);
8775
8776   /* Enable the automatic memory restoration from breakpoints while
8777      we read the memory.  Otherwise we could say about our temporary
8778      breakpoints they are permanent.  */
8779   cleanup = save_current_space_and_thread ();
8780
8781   switch_to_program_space_and_thread (loc->pspace);
8782   make_show_memory_breakpoints_cleanup (0);
8783
8784   if (target_read_memory (loc->address, target_mem, len) == 0
8785       && memcmp (target_mem, bpoint, len) == 0)
8786     retval = 1;
8787
8788   do_cleanups (cleanup);
8789
8790   return retval;
8791 }
8792
8793 /* Build a command list for the dprintf corresponding to the current
8794    settings of the dprintf style options.  */
8795
8796 static void
8797 update_dprintf_command_list (struct breakpoint *b)
8798 {
8799   char *dprintf_args = b->extra_string;
8800   char *printf_line = NULL;
8801
8802   if (!dprintf_args)
8803     return;
8804
8805   dprintf_args = skip_spaces (dprintf_args);
8806
8807   /* Allow a comma, as it may have terminated a location, but don't
8808      insist on it.  */
8809   if (*dprintf_args == ',')
8810     ++dprintf_args;
8811   dprintf_args = skip_spaces (dprintf_args);
8812
8813   if (*dprintf_args != '"')
8814     error (_("Bad format string, missing '\"'."));
8815
8816   if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
8817     printf_line = xstrprintf ("printf %s", dprintf_args);
8818   else if (strcmp (dprintf_style, dprintf_style_call) == 0)
8819     {
8820       if (!dprintf_function)
8821         error (_("No function supplied for dprintf call"));
8822
8823       if (dprintf_channel && strlen (dprintf_channel) > 0)
8824         printf_line = xstrprintf ("call (void) %s (%s,%s)",
8825                                   dprintf_function,
8826                                   dprintf_channel,
8827                                   dprintf_args);
8828       else
8829         printf_line = xstrprintf ("call (void) %s (%s)",
8830                                   dprintf_function,
8831                                   dprintf_args);
8832     }
8833   else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
8834     {
8835       if (target_can_run_breakpoint_commands ())
8836         printf_line = xstrprintf ("agent-printf %s", dprintf_args);
8837       else
8838         {
8839           warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8840           printf_line = xstrprintf ("printf %s", dprintf_args);
8841         }
8842     }
8843   else
8844     internal_error (__FILE__, __LINE__,
8845                     _("Invalid dprintf style."));
8846
8847   /* Manufacture a printf/continue sequence.  */
8848   if (printf_line)
8849     {
8850       struct command_line *printf_cmd_line, *cont_cmd_line = NULL;
8851
8852       if (strcmp (dprintf_style, dprintf_style_agent) != 0)
8853         {
8854           cont_cmd_line = xmalloc (sizeof (struct command_line));
8855           cont_cmd_line->control_type = simple_control;
8856           cont_cmd_line->body_count = 0;
8857           cont_cmd_line->body_list = NULL;
8858           cont_cmd_line->next = NULL;
8859           cont_cmd_line->line = xstrdup ("continue");
8860         }
8861
8862       printf_cmd_line = xmalloc (sizeof (struct command_line));
8863       printf_cmd_line->control_type = simple_control;
8864       printf_cmd_line->body_count = 0;
8865       printf_cmd_line->body_list = NULL;
8866       printf_cmd_line->next = cont_cmd_line;
8867       printf_cmd_line->line = printf_line;
8868
8869       breakpoint_set_commands (b, printf_cmd_line);
8870     }
8871 }
8872
8873 /* Update all dprintf commands, making their command lists reflect
8874    current style settings.  */
8875
8876 static void
8877 update_dprintf_commands (char *args, int from_tty,
8878                          struct cmd_list_element *c)
8879 {
8880   struct breakpoint *b;
8881
8882   ALL_BREAKPOINTS (b)
8883     {
8884       if (b->type == bp_dprintf)
8885         update_dprintf_command_list (b);
8886     }
8887 }
8888
8889 /* Create a breakpoint with SAL as location.  Use ADDR_STRING
8890    as textual description of the location, and COND_STRING
8891    as condition expression.  */
8892
8893 static void
8894 init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
8895                      struct symtabs_and_lines sals, char *addr_string,
8896                      char *filter, char *cond_string,
8897                      char *extra_string,
8898                      enum bptype type, enum bpdisp disposition,
8899                      int thread, int task, int ignore_count,
8900                      const struct breakpoint_ops *ops, int from_tty,
8901                      int enabled, int internal, unsigned flags,
8902                      int display_canonical)
8903 {
8904   int i;
8905
8906   if (type == bp_hardware_breakpoint)
8907     {
8908       int target_resources_ok;
8909
8910       i = hw_breakpoint_used_count ();
8911       target_resources_ok =
8912         target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
8913                                             i + 1, 0);
8914       if (target_resources_ok == 0)
8915         error (_("No hardware breakpoint support in the target."));
8916       else if (target_resources_ok < 0)
8917         error (_("Hardware breakpoints used exceeds limit."));
8918     }
8919
8920   gdb_assert (sals.nelts > 0);
8921
8922   for (i = 0; i < sals.nelts; ++i)
8923     {
8924       struct symtab_and_line sal = sals.sals[i];
8925       struct bp_location *loc;
8926
8927       if (from_tty)
8928         {
8929           struct gdbarch *loc_gdbarch = get_sal_arch (sal);
8930           if (!loc_gdbarch)
8931             loc_gdbarch = gdbarch;
8932
8933           describe_other_breakpoints (loc_gdbarch,
8934                                       sal.pspace, sal.pc, sal.section, thread);
8935         }
8936
8937       if (i == 0)
8938         {
8939           init_raw_breakpoint (b, gdbarch, sal, type, ops);
8940           b->thread = thread;
8941           b->task = task;
8942
8943           b->cond_string = cond_string;
8944           b->extra_string = extra_string;
8945           b->ignore_count = ignore_count;
8946           b->enable_state = enabled ? bp_enabled : bp_disabled;
8947           b->disposition = disposition;
8948
8949           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8950             b->loc->inserted = 1;
8951
8952           if (type == bp_static_tracepoint)
8953             {
8954               struct tracepoint *t = (struct tracepoint *) b;
8955               struct static_tracepoint_marker marker;
8956
8957               if (strace_marker_p (b))
8958                 {
8959                   /* We already know the marker exists, otherwise, we
8960                      wouldn't see a sal for it.  */
8961                   char *p = &addr_string[3];
8962                   char *endp;
8963                   char *marker_str;
8964
8965                   p = skip_spaces (p);
8966
8967                   endp = skip_to_space (p);
8968
8969                   marker_str = savestring (p, endp - p);
8970                   t->static_trace_marker_id = marker_str;
8971
8972                   printf_filtered (_("Probed static tracepoint "
8973                                      "marker \"%s\"\n"),
8974                                    t->static_trace_marker_id);
8975                 }
8976               else if (target_static_tracepoint_marker_at (sal.pc, &marker))
8977                 {
8978                   t->static_trace_marker_id = xstrdup (marker.str_id);
8979                   release_static_tracepoint_marker (&marker);
8980
8981                   printf_filtered (_("Probed static tracepoint "
8982                                      "marker \"%s\"\n"),
8983                                    t->static_trace_marker_id);
8984                 }
8985               else
8986                 warning (_("Couldn't determine the static "
8987                            "tracepoint marker to probe"));
8988             }
8989
8990           loc = b->loc;
8991         }
8992       else
8993         {
8994           loc = add_location_to_breakpoint (b, &sal);
8995           if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
8996             loc->inserted = 1;
8997         }
8998
8999       if (bp_loc_is_permanent (loc))
9000         make_breakpoint_permanent (b);
9001
9002       if (b->cond_string)
9003         {
9004           char *arg = b->cond_string;
9005           loc->cond = parse_exp_1 (&arg, loc->address,
9006                                    block_for_pc (loc->address), 0);
9007           if (*arg)
9008               error (_("Garbage '%s' follows condition"), arg);
9009         }
9010
9011       /* Dynamic printf requires and uses additional arguments on the
9012          command line, otherwise it's an error.  */
9013       if (type == bp_dprintf)
9014         {
9015           if (b->extra_string)
9016             update_dprintf_command_list (b);
9017           else
9018             error (_("Format string required"));
9019         }
9020       else if (b->extra_string)
9021         error (_("Garbage '%s' at end of command"), b->extra_string);
9022     }
9023
9024   b->display_canonical = display_canonical;
9025   if (addr_string)
9026     b->addr_string = addr_string;
9027   else
9028     /* addr_string has to be used or breakpoint_re_set will delete
9029        me.  */
9030     b->addr_string
9031       = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
9032   b->filter = filter;
9033 }
9034
9035 static void
9036 create_breakpoint_sal (struct gdbarch *gdbarch,
9037                        struct symtabs_and_lines sals, char *addr_string,
9038                        char *filter, char *cond_string,
9039                        char *extra_string,
9040                        enum bptype type, enum bpdisp disposition,
9041                        int thread, int task, int ignore_count,
9042                        const struct breakpoint_ops *ops, int from_tty,
9043                        int enabled, int internal, unsigned flags,
9044                        int display_canonical)
9045 {
9046   struct breakpoint *b;
9047   struct cleanup *old_chain;
9048
9049   if (is_tracepoint_type (type))
9050     {
9051       struct tracepoint *t;
9052
9053       t = XCNEW (struct tracepoint);
9054       b = &t->base;
9055     }
9056   else
9057     b = XNEW (struct breakpoint);
9058
9059   old_chain = make_cleanup (xfree, b);
9060
9061   init_breakpoint_sal (b, gdbarch,
9062                        sals, addr_string,
9063                        filter, cond_string, extra_string,
9064                        type, disposition,
9065                        thread, task, ignore_count,
9066                        ops, from_tty,
9067                        enabled, internal, flags,
9068                        display_canonical);
9069   discard_cleanups (old_chain);
9070
9071   install_breakpoint (internal, b, 0);
9072 }
9073
9074 /* Add SALS.nelts breakpoints to the breakpoint table.  For each
9075    SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9076    value.  COND_STRING, if not NULL, specified the condition to be
9077    used for all breakpoints.  Essentially the only case where
9078    SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9079    function.  In that case, it's still not possible to specify
9080    separate conditions for different overloaded functions, so
9081    we take just a single condition string.
9082    
9083    NOTE: If the function succeeds, the caller is expected to cleanup
9084    the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9085    array contents).  If the function fails (error() is called), the
9086    caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9087    COND and SALS arrays and each of those arrays contents.  */
9088
9089 static void
9090 create_breakpoints_sal (struct gdbarch *gdbarch,
9091                         struct linespec_result *canonical,
9092                         char *cond_string, char *extra_string,
9093                         enum bptype type, enum bpdisp disposition,
9094                         int thread, int task, int ignore_count,
9095                         const struct breakpoint_ops *ops, int from_tty,
9096                         int enabled, int internal, unsigned flags)
9097 {
9098   int i;
9099   struct linespec_sals *lsal;
9100
9101   if (canonical->pre_expanded)
9102     gdb_assert (VEC_length (linespec_sals, canonical->sals) == 1);
9103
9104   for (i = 0; VEC_iterate (linespec_sals, canonical->sals, i, lsal); ++i)
9105     {
9106       /* Note that 'addr_string' can be NULL in the case of a plain
9107          'break', without arguments.  */
9108       char *addr_string = (canonical->addr_string
9109                            ? xstrdup (canonical->addr_string)
9110                            : NULL);
9111       char *filter_string = lsal->canonical ? xstrdup (lsal->canonical) : NULL;
9112       struct cleanup *inner = make_cleanup (xfree, addr_string);
9113
9114       make_cleanup (xfree, filter_string);
9115       create_breakpoint_sal (gdbarch, lsal->sals,
9116                              addr_string,
9117                              filter_string,
9118                              cond_string, extra_string,
9119                              type, disposition,
9120                              thread, task, ignore_count, ops,
9121                              from_tty, enabled, internal, flags,
9122                              canonical->special_display);
9123       discard_cleanups (inner);
9124     }
9125 }
9126
9127 /* Parse ADDRESS which is assumed to be a SAL specification possibly
9128    followed by conditionals.  On return, SALS contains an array of SAL
9129    addresses found.  ADDR_STRING contains a vector of (canonical)
9130    address strings.  ADDRESS points to the end of the SAL.
9131
9132    The array and the line spec strings are allocated on the heap, it is
9133    the caller's responsibility to free them.  */
9134
9135 static void
9136 parse_breakpoint_sals (char **address,
9137                        struct linespec_result *canonical)
9138 {
9139   /* If no arg given, or if first arg is 'if ', use the default
9140      breakpoint.  */
9141   if ((*address) == NULL
9142       || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
9143     {
9144       /* The last displayed codepoint, if it's valid, is our default breakpoint
9145          address.  */
9146       if (last_displayed_sal_is_valid ())
9147         {
9148           struct linespec_sals lsal;
9149           struct symtab_and_line sal;
9150           CORE_ADDR pc;
9151
9152           init_sal (&sal);              /* Initialize to zeroes.  */
9153           lsal.sals.sals = (struct symtab_and_line *)
9154             xmalloc (sizeof (struct symtab_and_line));
9155
9156           /* Set sal's pspace, pc, symtab, and line to the values
9157              corresponding to the last call to print_frame_info.
9158              Be sure to reinitialize LINE with NOTCURRENT == 0
9159              as the breakpoint line number is inappropriate otherwise.
9160              find_pc_line would adjust PC, re-set it back.  */
9161           get_last_displayed_sal (&sal);
9162           pc = sal.pc;
9163           sal = find_pc_line (pc, 0);
9164
9165           /* "break" without arguments is equivalent to "break *PC"
9166              where PC is the last displayed codepoint's address.  So
9167              make sure to set sal.explicit_pc to prevent GDB from
9168              trying to expand the list of sals to include all other
9169              instances with the same symtab and line.  */
9170           sal.pc = pc;
9171           sal.explicit_pc = 1;
9172
9173           lsal.sals.sals[0] = sal;
9174           lsal.sals.nelts = 1;
9175           lsal.canonical = NULL;
9176
9177           VEC_safe_push (linespec_sals, canonical->sals, &lsal);
9178         }
9179       else
9180         error (_("No default breakpoint address now."));
9181     }
9182   else
9183     {
9184       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
9185
9186       /* Force almost all breakpoints to be in terms of the
9187          current_source_symtab (which is decode_line_1's default).
9188          This should produce the results we want almost all of the
9189          time while leaving default_breakpoint_* alone.
9190
9191          ObjC: However, don't match an Objective-C method name which
9192          may have a '+' or '-' succeeded by a '['.  */
9193       if (last_displayed_sal_is_valid ()
9194           && (!cursal.symtab
9195               || ((strchr ("+-", (*address)[0]) != NULL)
9196                   && ((*address)[1] != '['))))
9197         decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
9198                           get_last_displayed_symtab (),
9199                           get_last_displayed_line (),
9200                           canonical, NULL, NULL);
9201       else
9202         decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
9203                           cursal.symtab, cursal.line, canonical, NULL, NULL);
9204     }
9205 }
9206
9207
9208 /* Convert each SAL into a real PC.  Verify that the PC can be
9209    inserted as a breakpoint.  If it can't throw an error.  */
9210
9211 static void
9212 breakpoint_sals_to_pc (struct symtabs_and_lines *sals)
9213 {    
9214   int i;
9215
9216   for (i = 0; i < sals->nelts; i++)
9217     resolve_sal_pc (&sals->sals[i]);
9218 }
9219
9220 /* Fast tracepoints may have restrictions on valid locations.  For
9221    instance, a fast tracepoint using a jump instead of a trap will
9222    likely have to overwrite more bytes than a trap would, and so can
9223    only be placed where the instruction is longer than the jump, or a
9224    multi-instruction sequence does not have a jump into the middle of
9225    it, etc.  */
9226
9227 static void
9228 check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9229                             struct symtabs_and_lines *sals)
9230 {
9231   int i, rslt;
9232   struct symtab_and_line *sal;
9233   char *msg;
9234   struct cleanup *old_chain;
9235
9236   for (i = 0; i < sals->nelts; i++)
9237     {
9238       struct gdbarch *sarch;
9239
9240       sal = &sals->sals[i];
9241
9242       sarch = get_sal_arch (*sal);
9243       /* We fall back to GDBARCH if there is no architecture
9244          associated with SAL.  */
9245       if (sarch == NULL)
9246         sarch = gdbarch;
9247       rslt = gdbarch_fast_tracepoint_valid_at (sarch, sal->pc,
9248                                                NULL, &msg);
9249       old_chain = make_cleanup (xfree, msg);
9250
9251       if (!rslt)
9252         error (_("May not have a fast tracepoint at 0x%s%s"),
9253                paddress (sarch, sal->pc), (msg ? msg : ""));
9254
9255       do_cleanups (old_chain);
9256     }
9257 }
9258
9259 /* Issue an invalid thread ID error.  */
9260
9261 static void ATTRIBUTE_NORETURN
9262 invalid_thread_id_error (int id)
9263 {
9264   error (_("Unknown thread %d."), id);
9265 }
9266
9267 /* Given TOK, a string specification of condition and thread, as
9268    accepted by the 'break' command, extract the condition
9269    string and thread number and set *COND_STRING and *THREAD.
9270    PC identifies the context at which the condition should be parsed.
9271    If no condition is found, *COND_STRING is set to NULL.
9272    If no thread is found, *THREAD is set to -1.  */
9273
9274 static void
9275 find_condition_and_thread (char *tok, CORE_ADDR pc,
9276                            char **cond_string, int *thread, int *task,
9277                            char **rest)
9278 {
9279   *cond_string = NULL;
9280   *thread = -1;
9281   *task = 0;
9282   *rest = NULL;
9283
9284   while (tok && *tok)
9285     {
9286       char *end_tok;
9287       int toklen;
9288       char *cond_start = NULL;
9289       char *cond_end = NULL;
9290
9291       tok = skip_spaces (tok);
9292
9293       if ((*tok == '"' || *tok == ',') && rest)
9294         {
9295           *rest = savestring (tok, strlen (tok));
9296           return;
9297         }
9298
9299       end_tok = skip_to_space (tok);
9300
9301       toklen = end_tok - tok;
9302
9303       if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9304         {
9305           struct expression *expr;
9306
9307           tok = cond_start = end_tok + 1;
9308           expr = parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
9309           xfree (expr);
9310           cond_end = tok;
9311           *cond_string = savestring (cond_start, cond_end - cond_start);
9312         }
9313       else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9314         {
9315           char *tmptok;
9316
9317           tok = end_tok + 1;
9318           tmptok = tok;
9319           *thread = strtol (tok, &tok, 0);
9320           if (tok == tmptok)
9321             error (_("Junk after thread keyword."));
9322           if (!valid_thread_id (*thread))
9323             invalid_thread_id_error (*thread);
9324         }
9325       else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9326         {
9327           char *tmptok;
9328
9329           tok = end_tok + 1;
9330           tmptok = tok;
9331           *task = strtol (tok, &tok, 0);
9332           if (tok == tmptok)
9333             error (_("Junk after task keyword."));
9334           if (!valid_task_id (*task))
9335             error (_("Unknown task %d."), *task);
9336         }
9337       else if (rest)
9338         {
9339           *rest = savestring (tok, strlen (tok));
9340           return;
9341         }
9342       else
9343         error (_("Junk at end of arguments."));
9344     }
9345 }
9346
9347 /* Decode a static tracepoint marker spec.  */
9348
9349 static struct symtabs_and_lines
9350 decode_static_tracepoint_spec (char **arg_p)
9351 {
9352   VEC(static_tracepoint_marker_p) *markers = NULL;
9353   struct symtabs_and_lines sals;
9354   struct cleanup *old_chain;
9355   char *p = &(*arg_p)[3];
9356   char *endp;
9357   char *marker_str;
9358   int i;
9359
9360   p = skip_spaces (p);
9361
9362   endp = skip_to_space (p);
9363
9364   marker_str = savestring (p, endp - p);
9365   old_chain = make_cleanup (xfree, marker_str);
9366
9367   markers = target_static_tracepoint_markers_by_strid (marker_str);
9368   if (VEC_empty(static_tracepoint_marker_p, markers))
9369     error (_("No known static tracepoint marker named %s"), marker_str);
9370
9371   sals.nelts = VEC_length(static_tracepoint_marker_p, markers);
9372   sals.sals = xmalloc (sizeof *sals.sals * sals.nelts);
9373
9374   for (i = 0; i < sals.nelts; i++)
9375     {
9376       struct static_tracepoint_marker *marker;
9377
9378       marker = VEC_index (static_tracepoint_marker_p, markers, i);
9379
9380       init_sal (&sals.sals[i]);
9381
9382       sals.sals[i] = find_pc_line (marker->address, 0);
9383       sals.sals[i].pc = marker->address;
9384
9385       release_static_tracepoint_marker (marker);
9386     }
9387
9388   do_cleanups (old_chain);
9389
9390   *arg_p = endp;
9391   return sals;
9392 }
9393
9394 /* Set a breakpoint.  This function is shared between CLI and MI
9395    functions for setting a breakpoint.  This function has two major
9396    modes of operations, selected by the PARSE_CONDITION_AND_THREAD
9397    parameter.  If non-zero, the function will parse arg, extracting
9398    breakpoint location, address and thread.  Otherwise, ARG is just
9399    the location of breakpoint, with condition and thread specified by
9400    the COND_STRING and THREAD parameters.  If INTERNAL is non-zero,
9401    the breakpoint number will be allocated from the internal
9402    breakpoint count.  Returns true if any breakpoint was created;
9403    false otherwise.  */
9404
9405 int
9406 create_breakpoint (struct gdbarch *gdbarch,
9407                    char *arg, char *cond_string,
9408                    int thread, char *extra_string,
9409                    int parse_condition_and_thread,
9410                    int tempflag, enum bptype type_wanted,
9411                    int ignore_count,
9412                    enum auto_boolean pending_break_support,
9413                    const struct breakpoint_ops *ops,
9414                    int from_tty, int enabled, int internal,
9415                    unsigned flags)
9416 {
9417   volatile struct gdb_exception e;
9418   char *copy_arg = NULL;
9419   char *addr_start = arg;
9420   struct linespec_result canonical;
9421   struct cleanup *old_chain;
9422   struct cleanup *bkpt_chain = NULL;
9423   int pending = 0;
9424   int task = 0;
9425   int prev_bkpt_count = breakpoint_count;
9426
9427   gdb_assert (ops != NULL);
9428
9429   init_linespec_result (&canonical);
9430
9431   TRY_CATCH (e, RETURN_MASK_ALL)
9432     {
9433       ops->create_sals_from_address (&arg, &canonical, type_wanted,
9434                                      addr_start, &copy_arg);
9435     }
9436
9437   /* If caller is interested in rc value from parse, set value.  */
9438   switch (e.reason)
9439     {
9440     case GDB_NO_ERROR:
9441       if (VEC_empty (linespec_sals, canonical.sals))
9442         return 0;
9443       break;
9444     case RETURN_ERROR:
9445       switch (e.error)
9446         {
9447         case NOT_FOUND_ERROR:
9448
9449           /* If pending breakpoint support is turned off, throw
9450              error.  */
9451
9452           if (pending_break_support == AUTO_BOOLEAN_FALSE)
9453             throw_exception (e);
9454
9455           exception_print (gdb_stderr, e);
9456
9457           /* If pending breakpoint support is auto query and the user
9458              selects no, then simply return the error code.  */
9459           if (pending_break_support == AUTO_BOOLEAN_AUTO
9460               && !nquery (_("Make %s pending on future shared library load? "),
9461                           bptype_string (type_wanted)))
9462             return 0;
9463
9464           /* At this point, either the user was queried about setting
9465              a pending breakpoint and selected yes, or pending
9466              breakpoint behavior is on and thus a pending breakpoint
9467              is defaulted on behalf of the user.  */
9468           {
9469             struct linespec_sals lsal;
9470
9471             copy_arg = xstrdup (addr_start);
9472             lsal.canonical = xstrdup (copy_arg);
9473             lsal.sals.nelts = 1;
9474             lsal.sals.sals = XNEW (struct symtab_and_line);
9475             init_sal (&lsal.sals.sals[0]);
9476             pending = 1;
9477             VEC_safe_push (linespec_sals, canonical.sals, &lsal);
9478           }
9479           break;
9480         default:
9481           throw_exception (e);
9482         }
9483       break;
9484     default:
9485       throw_exception (e);
9486     }
9487
9488   /* Create a chain of things that always need to be cleaned up.  */
9489   old_chain = make_cleanup_destroy_linespec_result (&canonical);
9490
9491   /* ----------------------------- SNIP -----------------------------
9492      Anything added to the cleanup chain beyond this point is assumed
9493      to be part of a breakpoint.  If the breakpoint create succeeds
9494      then the memory is not reclaimed.  */
9495   bkpt_chain = make_cleanup (null_cleanup, 0);
9496
9497   /* Resolve all line numbers to PC's and verify that the addresses
9498      are ok for the target.  */
9499   if (!pending)
9500     {
9501       int ix;
9502       struct linespec_sals *iter;
9503
9504       for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9505         breakpoint_sals_to_pc (&iter->sals);
9506     }
9507
9508   /* Fast tracepoints may have additional restrictions on location.  */
9509   if (!pending && type_wanted == bp_fast_tracepoint)
9510     {
9511       int ix;
9512       struct linespec_sals *iter;
9513
9514       for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9515         check_fast_tracepoint_sals (gdbarch, &iter->sals);
9516     }
9517
9518   /* Verify that condition can be parsed, before setting any
9519      breakpoints.  Allocate a separate condition expression for each
9520      breakpoint.  */
9521   if (!pending)
9522     {
9523       struct linespec_sals *lsal;
9524
9525       lsal = VEC_index (linespec_sals, canonical.sals, 0);
9526
9527       if (parse_condition_and_thread)
9528         {
9529             char *rest;
9530             /* Here we only parse 'arg' to separate condition
9531                from thread number, so parsing in context of first
9532                sal is OK.  When setting the breakpoint we'll 
9533                re-parse it in context of each sal.  */
9534
9535             find_condition_and_thread (arg, lsal->sals.sals[0].pc, &cond_string,
9536                                        &thread, &task, &rest);
9537             if (cond_string)
9538                 make_cleanup (xfree, cond_string);
9539             if (rest)
9540               make_cleanup (xfree, rest);
9541             if (rest)
9542               extra_string = rest;
9543         }
9544       else
9545         {
9546             /* Create a private copy of condition string.  */
9547             if (cond_string)
9548             {
9549                 cond_string = xstrdup (cond_string);
9550                 make_cleanup (xfree, cond_string);
9551             }
9552             /* Create a private copy of any extra string.  */
9553             if (extra_string)
9554               {
9555                 extra_string = xstrdup (extra_string);
9556                 make_cleanup (xfree, extra_string);
9557               }
9558         }
9559
9560       ops->create_breakpoints_sal (gdbarch, &canonical, lsal,
9561                                    cond_string, extra_string, type_wanted,
9562                                    tempflag ? disp_del : disp_donttouch,
9563                                    thread, task, ignore_count, ops,
9564                                    from_tty, enabled, internal, flags);
9565     }
9566   else
9567     {
9568       struct breakpoint *b;
9569
9570       make_cleanup (xfree, copy_arg);
9571
9572       if (is_tracepoint_type (type_wanted))
9573         {
9574           struct tracepoint *t;
9575
9576           t = XCNEW (struct tracepoint);
9577           b = &t->base;
9578         }
9579       else
9580         b = XNEW (struct breakpoint);
9581
9582       init_raw_breakpoint_without_location (b, gdbarch, type_wanted, ops);
9583
9584       b->addr_string = copy_arg;
9585       if (parse_condition_and_thread)
9586         b->cond_string = NULL;
9587       else
9588         {
9589           /* Create a private copy of condition string.  */
9590           if (cond_string)
9591             {
9592               cond_string = xstrdup (cond_string);
9593               make_cleanup (xfree, cond_string);
9594             }
9595           b->cond_string = cond_string;
9596         }
9597       b->extra_string = NULL;
9598       b->ignore_count = ignore_count;
9599       b->disposition = tempflag ? disp_del : disp_donttouch;
9600       b->condition_not_parsed = 1;
9601       b->enable_state = enabled ? bp_enabled : bp_disabled;
9602       if ((type_wanted != bp_breakpoint
9603            && type_wanted != bp_hardware_breakpoint) || thread != -1)
9604         b->pspace = current_program_space;
9605
9606       install_breakpoint (internal, b, 0);
9607     }
9608   
9609   if (VEC_length (linespec_sals, canonical.sals) > 1)
9610     {
9611       warning (_("Multiple breakpoints were set.\nUse the "
9612                  "\"delete\" command to delete unwanted breakpoints."));
9613       prev_breakpoint_count = prev_bkpt_count;
9614     }
9615
9616   /* That's it.  Discard the cleanups for data inserted into the
9617      breakpoint.  */
9618   discard_cleanups (bkpt_chain);
9619   /* But cleanup everything else.  */
9620   do_cleanups (old_chain);
9621
9622   /* error call may happen here - have BKPT_CHAIN already discarded.  */
9623   update_global_location_list (1);
9624
9625   return 1;
9626 }
9627
9628 /* Set a breakpoint.
9629    ARG is a string describing breakpoint address,
9630    condition, and thread.
9631    FLAG specifies if a breakpoint is hardware on,
9632    and if breakpoint is temporary, using BP_HARDWARE_FLAG
9633    and BP_TEMPFLAG.  */
9634
9635 static void
9636 break_command_1 (char *arg, int flag, int from_tty)
9637 {
9638   int tempflag = flag & BP_TEMPFLAG;
9639   enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9640                              ? bp_hardware_breakpoint
9641                              : bp_breakpoint);
9642   struct breakpoint_ops *ops;
9643   const char *arg_cp = arg;
9644
9645   /* Matching breakpoints on probes.  */
9646   if (arg && probe_linespec_to_ops (&arg_cp) != NULL)
9647     ops = &bkpt_probe_breakpoint_ops;
9648   else
9649     ops = &bkpt_breakpoint_ops;
9650
9651   create_breakpoint (get_current_arch (),
9652                      arg,
9653                      NULL, 0, NULL, 1 /* parse arg */,
9654                      tempflag, type_wanted,
9655                      0 /* Ignore count */,
9656                      pending_break_support,
9657                      ops,
9658                      from_tty,
9659                      1 /* enabled */,
9660                      0 /* internal */,
9661                      0);
9662 }
9663
9664 /* Helper function for break_command_1 and disassemble_command.  */
9665
9666 void
9667 resolve_sal_pc (struct symtab_and_line *sal)
9668 {
9669   CORE_ADDR pc;
9670
9671   if (sal->pc == 0 && sal->symtab != NULL)
9672     {
9673       if (!find_line_pc (sal->symtab, sal->line, &pc))
9674         error (_("No line %d in file \"%s\"."),
9675                sal->line, sal->symtab->filename);
9676       sal->pc = pc;
9677
9678       /* If this SAL corresponds to a breakpoint inserted using a line
9679          number, then skip the function prologue if necessary.  */
9680       if (sal->explicit_line)
9681         skip_prologue_sal (sal);
9682     }
9683
9684   if (sal->section == 0 && sal->symtab != NULL)
9685     {
9686       struct blockvector *bv;
9687       struct block *b;
9688       struct symbol *sym;
9689
9690       bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
9691       if (bv != NULL)
9692         {
9693           sym = block_linkage_function (b);
9694           if (sym != NULL)
9695             {
9696               fixup_symbol_section (sym, sal->symtab->objfile);
9697               sal->section = SYMBOL_OBJ_SECTION (sym);
9698             }
9699           else
9700             {
9701               /* It really is worthwhile to have the section, so we'll
9702                  just have to look harder. This case can be executed
9703                  if we have line numbers but no functions (as can
9704                  happen in assembly source).  */
9705
9706               struct minimal_symbol *msym;
9707               struct cleanup *old_chain = save_current_space_and_thread ();
9708
9709               switch_to_program_space_and_thread (sal->pspace);
9710
9711               msym = lookup_minimal_symbol_by_pc (sal->pc);
9712               if (msym)
9713                 sal->section = SYMBOL_OBJ_SECTION (msym);
9714
9715               do_cleanups (old_chain);
9716             }
9717         }
9718     }
9719 }
9720
9721 void
9722 break_command (char *arg, int from_tty)
9723 {
9724   break_command_1 (arg, 0, from_tty);
9725 }
9726
9727 void
9728 tbreak_command (char *arg, int from_tty)
9729 {
9730   break_command_1 (arg, BP_TEMPFLAG, from_tty);
9731 }
9732
9733 static void
9734 hbreak_command (char *arg, int from_tty)
9735 {
9736   break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
9737 }
9738
9739 static void
9740 thbreak_command (char *arg, int from_tty)
9741 {
9742   break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
9743 }
9744
9745 static void
9746 stop_command (char *arg, int from_tty)
9747 {
9748   printf_filtered (_("Specify the type of breakpoint to set.\n\
9749 Usage: stop in <function | address>\n\
9750        stop at <line>\n"));
9751 }
9752
9753 static void
9754 stopin_command (char *arg, int from_tty)
9755 {
9756   int badInput = 0;
9757
9758   if (arg == (char *) NULL)
9759     badInput = 1;
9760   else if (*arg != '*')
9761     {
9762       char *argptr = arg;
9763       int hasColon = 0;
9764
9765       /* Look for a ':'.  If this is a line number specification, then
9766          say it is bad, otherwise, it should be an address or
9767          function/method name.  */
9768       while (*argptr && !hasColon)
9769         {
9770           hasColon = (*argptr == ':');
9771           argptr++;
9772         }
9773
9774       if (hasColon)
9775         badInput = (*argptr != ':');    /* Not a class::method */
9776       else
9777         badInput = isdigit (*arg);      /* a simple line number */
9778     }
9779
9780   if (badInput)
9781     printf_filtered (_("Usage: stop in <function | address>\n"));
9782   else
9783     break_command_1 (arg, 0, from_tty);
9784 }
9785
9786 static void
9787 stopat_command (char *arg, int from_tty)
9788 {
9789   int badInput = 0;
9790
9791   if (arg == (char *) NULL || *arg == '*')      /* no line number */
9792     badInput = 1;
9793   else
9794     {
9795       char *argptr = arg;
9796       int hasColon = 0;
9797
9798       /* Look for a ':'.  If there is a '::' then get out, otherwise
9799          it is probably a line number.  */
9800       while (*argptr && !hasColon)
9801         {
9802           hasColon = (*argptr == ':');
9803           argptr++;
9804         }
9805
9806       if (hasColon)
9807         badInput = (*argptr == ':');    /* we have class::method */
9808       else
9809         badInput = !isdigit (*arg);     /* not a line number */
9810     }
9811
9812   if (badInput)
9813     printf_filtered (_("Usage: stop at <line>\n"));
9814   else
9815     break_command_1 (arg, 0, from_tty);
9816 }
9817
9818 void dprintf_command (char *arg, int from_tty);
9819
9820 /* The dynamic printf command is mostly like a regular breakpoint, but
9821    with a prewired command list consisting of a single output command,
9822    built from extra arguments supplied on the dprintf command
9823    line.  */
9824
9825 void
9826 dprintf_command (char *arg, int from_tty)
9827 {
9828   create_breakpoint (get_current_arch (),
9829                      arg,
9830                      NULL, 0, NULL, 1 /* parse arg */,
9831                      0, bp_dprintf,
9832                      0 /* Ignore count */,
9833                      pending_break_support,
9834                      &dprintf_breakpoint_ops,
9835                      from_tty,
9836                      1 /* enabled */,
9837                      0 /* internal */,
9838                      0);
9839 }
9840
9841 static void
9842 agent_printf_command (char *arg, int from_tty)
9843 {
9844   error (_("May only run agent-printf on the target"));
9845 }
9846
9847 /* Implement the "breakpoint_hit" breakpoint_ops method for
9848    ranged breakpoints.  */
9849
9850 static int
9851 breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
9852                                   struct address_space *aspace,
9853                                   CORE_ADDR bp_addr,
9854                                   const struct target_waitstatus *ws)
9855 {
9856   if (ws->kind != TARGET_WAITKIND_STOPPED
9857       || ws->value.sig != GDB_SIGNAL_TRAP)
9858     return 0;
9859
9860   return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
9861                                          bl->length, aspace, bp_addr);
9862 }
9863
9864 /* Implement the "resources_needed" breakpoint_ops method for
9865    ranged breakpoints.  */
9866
9867 static int
9868 resources_needed_ranged_breakpoint (const struct bp_location *bl)
9869 {
9870   return target_ranged_break_num_registers ();
9871 }
9872
9873 /* Implement the "print_it" breakpoint_ops method for
9874    ranged breakpoints.  */
9875
9876 static enum print_stop_action
9877 print_it_ranged_breakpoint (bpstat bs)
9878 {
9879   struct breakpoint *b = bs->breakpoint_at;
9880   struct bp_location *bl = b->loc;
9881   struct ui_out *uiout = current_uiout;
9882
9883   gdb_assert (b->type == bp_hardware_breakpoint);
9884
9885   /* Ranged breakpoints have only one location.  */
9886   gdb_assert (bl && bl->next == NULL);
9887
9888   annotate_breakpoint (b->number);
9889   if (b->disposition == disp_del)
9890     ui_out_text (uiout, "\nTemporary ranged breakpoint ");
9891   else
9892     ui_out_text (uiout, "\nRanged breakpoint ");
9893   if (ui_out_is_mi_like_p (uiout))
9894     {
9895       ui_out_field_string (uiout, "reason",
9896                       async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
9897       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
9898     }
9899   ui_out_field_int (uiout, "bkptno", b->number);
9900   ui_out_text (uiout, ", ");
9901
9902   return PRINT_SRC_AND_LOC;
9903 }
9904
9905 /* Implement the "print_one" breakpoint_ops method for
9906    ranged breakpoints.  */
9907
9908 static void
9909 print_one_ranged_breakpoint (struct breakpoint *b,
9910                              struct bp_location **last_loc)
9911 {
9912   struct bp_location *bl = b->loc;
9913   struct value_print_options opts;
9914   struct ui_out *uiout = current_uiout;
9915
9916   /* Ranged breakpoints have only one location.  */
9917   gdb_assert (bl && bl->next == NULL);
9918
9919   get_user_print_options (&opts);
9920
9921   if (opts.addressprint)
9922     /* We don't print the address range here, it will be printed later
9923        by print_one_detail_ranged_breakpoint.  */
9924     ui_out_field_skip (uiout, "addr");
9925   annotate_field (5);
9926   print_breakpoint_location (b, bl);
9927   *last_loc = bl;
9928 }
9929
9930 /* Implement the "print_one_detail" breakpoint_ops method for
9931    ranged breakpoints.  */
9932
9933 static void
9934 print_one_detail_ranged_breakpoint (const struct breakpoint *b,
9935                                     struct ui_out *uiout)
9936 {
9937   CORE_ADDR address_start, address_end;
9938   struct bp_location *bl = b->loc;
9939   struct ui_file *stb = mem_fileopen ();
9940   struct cleanup *cleanup = make_cleanup_ui_file_delete (stb);
9941
9942   gdb_assert (bl);
9943
9944   address_start = bl->address;
9945   address_end = address_start + bl->length - 1;
9946
9947   ui_out_text (uiout, "\taddress range: ");
9948   fprintf_unfiltered (stb, "[%s, %s]",
9949                       print_core_address (bl->gdbarch, address_start),
9950                       print_core_address (bl->gdbarch, address_end));
9951   ui_out_field_stream (uiout, "addr", stb);
9952   ui_out_text (uiout, "\n");
9953
9954   do_cleanups (cleanup);
9955 }
9956
9957 /* Implement the "print_mention" breakpoint_ops method for
9958    ranged breakpoints.  */
9959
9960 static void
9961 print_mention_ranged_breakpoint (struct breakpoint *b)
9962 {
9963   struct bp_location *bl = b->loc;
9964   struct ui_out *uiout = current_uiout;
9965
9966   gdb_assert (bl);
9967   gdb_assert (b->type == bp_hardware_breakpoint);
9968
9969   if (ui_out_is_mi_like_p (uiout))
9970     return;
9971
9972   printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9973                    b->number, paddress (bl->gdbarch, bl->address),
9974                    paddress (bl->gdbarch, bl->address + bl->length - 1));
9975 }
9976
9977 /* Implement the "print_recreate" breakpoint_ops method for
9978    ranged breakpoints.  */
9979
9980 static void
9981 print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
9982 {
9983   fprintf_unfiltered (fp, "break-range %s, %s", b->addr_string,
9984                       b->addr_string_range_end);
9985   print_recreate_thread (b, fp);
9986 }
9987
9988 /* The breakpoint_ops structure to be used in ranged breakpoints.  */
9989
9990 static struct breakpoint_ops ranged_breakpoint_ops;
9991
9992 /* Find the address where the end of the breakpoint range should be
9993    placed, given the SAL of the end of the range.  This is so that if
9994    the user provides a line number, the end of the range is set to the
9995    last instruction of the given line.  */
9996
9997 static CORE_ADDR
9998 find_breakpoint_range_end (struct symtab_and_line sal)
9999 {
10000   CORE_ADDR end;
10001
10002   /* If the user provided a PC value, use it.  Otherwise,
10003      find the address of the end of the given location.  */
10004   if (sal.explicit_pc)
10005     end = sal.pc;
10006   else
10007     {
10008       int ret;
10009       CORE_ADDR start;
10010
10011       ret = find_line_pc_range (sal, &start, &end);
10012       if (!ret)
10013         error (_("Could not find location of the end of the range."));
10014
10015       /* find_line_pc_range returns the start of the next line.  */
10016       end--;
10017     }
10018
10019   return end;
10020 }
10021
10022 /* Implement the "break-range" CLI command.  */
10023
10024 static void
10025 break_range_command (char *arg, int from_tty)
10026 {
10027   char *arg_start, *addr_string_start, *addr_string_end;
10028   struct linespec_result canonical_start, canonical_end;
10029   int bp_count, can_use_bp, length;
10030   CORE_ADDR end;
10031   struct breakpoint *b;
10032   struct symtab_and_line sal_start, sal_end;
10033   struct cleanup *cleanup_bkpt;
10034   struct linespec_sals *lsal_start, *lsal_end;
10035
10036   /* We don't support software ranged breakpoints.  */
10037   if (target_ranged_break_num_registers () < 0)
10038     error (_("This target does not support hardware ranged breakpoints."));
10039
10040   bp_count = hw_breakpoint_used_count ();
10041   bp_count += target_ranged_break_num_registers ();
10042   can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
10043                                                    bp_count, 0);
10044   if (can_use_bp < 0)
10045     error (_("Hardware breakpoints used exceeds limit."));
10046
10047   arg = skip_spaces (arg);
10048   if (arg == NULL || arg[0] == '\0')
10049     error(_("No address range specified."));
10050
10051   init_linespec_result (&canonical_start);
10052
10053   arg_start = arg;
10054   parse_breakpoint_sals (&arg, &canonical_start);
10055
10056   cleanup_bkpt = make_cleanup_destroy_linespec_result (&canonical_start);
10057
10058   if (arg[0] != ',')
10059     error (_("Too few arguments."));
10060   else if (VEC_empty (linespec_sals, canonical_start.sals))
10061     error (_("Could not find location of the beginning of the range."));
10062
10063   lsal_start = VEC_index (linespec_sals, canonical_start.sals, 0);
10064
10065   if (VEC_length (linespec_sals, canonical_start.sals) > 1
10066       || lsal_start->sals.nelts != 1)
10067     error (_("Cannot create a ranged breakpoint with multiple locations."));
10068
10069   sal_start = lsal_start->sals.sals[0];
10070   addr_string_start = savestring (arg_start, arg - arg_start);
10071   make_cleanup (xfree, addr_string_start);
10072
10073   arg++;        /* Skip the comma.  */
10074   arg = skip_spaces (arg);
10075
10076   /* Parse the end location.  */
10077
10078   init_linespec_result (&canonical_end);
10079   arg_start = arg;
10080
10081   /* We call decode_line_full directly here instead of using
10082      parse_breakpoint_sals because we need to specify the start location's
10083      symtab and line as the default symtab and line for the end of the
10084      range.  This makes it possible to have ranges like "foo.c:27, +14",
10085      where +14 means 14 lines from the start location.  */
10086   decode_line_full (&arg, DECODE_LINE_FUNFIRSTLINE,
10087                     sal_start.symtab, sal_start.line,
10088                     &canonical_end, NULL, NULL);
10089
10090   make_cleanup_destroy_linespec_result (&canonical_end);
10091
10092   if (VEC_empty (linespec_sals, canonical_end.sals))
10093     error (_("Could not find location of the end of the range."));
10094
10095   lsal_end = VEC_index (linespec_sals, canonical_end.sals, 0);
10096   if (VEC_length (linespec_sals, canonical_end.sals) > 1
10097       || lsal_end->sals.nelts != 1)
10098     error (_("Cannot create a ranged breakpoint with multiple locations."));
10099
10100   sal_end = lsal_end->sals.sals[0];
10101   addr_string_end = savestring (arg_start, arg - arg_start);
10102   make_cleanup (xfree, addr_string_end);
10103
10104   end = find_breakpoint_range_end (sal_end);
10105   if (sal_start.pc > end)
10106     error (_("Invalid address range, end precedes start."));
10107
10108   length = end - sal_start.pc + 1;
10109   if (length < 0)
10110     /* Length overflowed.  */
10111     error (_("Address range too large."));
10112   else if (length == 1)
10113     {
10114       /* This range is simple enough to be handled by
10115          the `hbreak' command.  */
10116       hbreak_command (addr_string_start, 1);
10117
10118       do_cleanups (cleanup_bkpt);
10119
10120       return;
10121     }
10122
10123   /* Now set up the breakpoint.  */
10124   b = set_raw_breakpoint (get_current_arch (), sal_start,
10125                           bp_hardware_breakpoint, &ranged_breakpoint_ops);
10126   set_breakpoint_count (breakpoint_count + 1);
10127   b->number = breakpoint_count;
10128   b->disposition = disp_donttouch;
10129   b->addr_string = xstrdup (addr_string_start);
10130   b->addr_string_range_end = xstrdup (addr_string_end);
10131   b->loc->length = length;
10132
10133   do_cleanups (cleanup_bkpt);
10134
10135   mention (b);
10136   observer_notify_breakpoint_created (b);
10137   update_global_location_list (1);
10138 }
10139
10140 /*  Return non-zero if EXP is verified as constant.  Returned zero
10141     means EXP is variable.  Also the constant detection may fail for
10142     some constant expressions and in such case still falsely return
10143     zero.  */
10144
10145 static int
10146 watchpoint_exp_is_const (const struct expression *exp)
10147 {
10148   int i = exp->nelts;
10149
10150   while (i > 0)
10151     {
10152       int oplenp, argsp;
10153
10154       /* We are only interested in the descriptor of each element.  */
10155       operator_length (exp, i, &oplenp, &argsp);
10156       i -= oplenp;
10157
10158       switch (exp->elts[i].opcode)
10159         {
10160         case BINOP_ADD:
10161         case BINOP_SUB:
10162         case BINOP_MUL:
10163         case BINOP_DIV:
10164         case BINOP_REM:
10165         case BINOP_MOD:
10166         case BINOP_LSH:
10167         case BINOP_RSH:
10168         case BINOP_LOGICAL_AND:
10169         case BINOP_LOGICAL_OR:
10170         case BINOP_BITWISE_AND:
10171         case BINOP_BITWISE_IOR:
10172         case BINOP_BITWISE_XOR:
10173         case BINOP_EQUAL:
10174         case BINOP_NOTEQUAL:
10175         case BINOP_LESS:
10176         case BINOP_GTR:
10177         case BINOP_LEQ:
10178         case BINOP_GEQ:
10179         case BINOP_REPEAT:
10180         case BINOP_COMMA:
10181         case BINOP_EXP:
10182         case BINOP_MIN:
10183         case BINOP_MAX:
10184         case BINOP_INTDIV:
10185         case BINOP_CONCAT:
10186         case BINOP_IN:
10187         case BINOP_RANGE:
10188         case TERNOP_COND:
10189         case TERNOP_SLICE:
10190
10191         case OP_LONG:
10192         case OP_DOUBLE:
10193         case OP_DECFLOAT:
10194         case OP_LAST:
10195         case OP_COMPLEX:
10196         case OP_STRING:
10197         case OP_ARRAY:
10198         case OP_TYPE:
10199         case OP_TYPEOF:
10200         case OP_DECLTYPE:
10201         case OP_NAME:
10202         case OP_OBJC_NSSTRING:
10203
10204         case UNOP_NEG:
10205         case UNOP_LOGICAL_NOT:
10206         case UNOP_COMPLEMENT:
10207         case UNOP_ADDR:
10208         case UNOP_HIGH:
10209         case UNOP_CAST:
10210
10211         case UNOP_CAST_TYPE:
10212         case UNOP_REINTERPRET_CAST:
10213         case UNOP_DYNAMIC_CAST:
10214           /* Unary, binary and ternary operators: We have to check
10215              their operands.  If they are constant, then so is the
10216              result of that operation.  For instance, if A and B are
10217              determined to be constants, then so is "A + B".
10218
10219              UNOP_IND is one exception to the rule above, because the
10220              value of *ADDR is not necessarily a constant, even when
10221              ADDR is.  */
10222           break;
10223
10224         case OP_VAR_VALUE:
10225           /* Check whether the associated symbol is a constant.
10226
10227              We use SYMBOL_CLASS rather than TYPE_CONST because it's
10228              possible that a buggy compiler could mark a variable as
10229              constant even when it is not, and TYPE_CONST would return
10230              true in this case, while SYMBOL_CLASS wouldn't.
10231
10232              We also have to check for function symbols because they
10233              are always constant.  */
10234           {
10235             struct symbol *s = exp->elts[i + 2].symbol;
10236
10237             if (SYMBOL_CLASS (s) != LOC_BLOCK
10238                 && SYMBOL_CLASS (s) != LOC_CONST
10239                 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
10240               return 0;
10241             break;
10242           }
10243
10244         /* The default action is to return 0 because we are using
10245            the optimistic approach here: If we don't know something,
10246            then it is not a constant.  */
10247         default:
10248           return 0;
10249         }
10250     }
10251
10252   return 1;
10253 }
10254
10255 /* Implement the "dtor" breakpoint_ops method for watchpoints.  */
10256
10257 static void
10258 dtor_watchpoint (struct breakpoint *self)
10259 {
10260   struct watchpoint *w = (struct watchpoint *) self;
10261
10262   xfree (w->cond_exp);
10263   xfree (w->exp);
10264   xfree (w->exp_string);
10265   xfree (w->exp_string_reparse);
10266   value_free (w->val);
10267
10268   base_breakpoint_ops.dtor (self);
10269 }
10270
10271 /* Implement the "re_set" breakpoint_ops method for watchpoints.  */
10272
10273 static void
10274 re_set_watchpoint (struct breakpoint *b)
10275 {
10276   struct watchpoint *w = (struct watchpoint *) b;
10277
10278   /* Watchpoint can be either on expression using entirely global
10279      variables, or it can be on local variables.
10280
10281      Watchpoints of the first kind are never auto-deleted, and even
10282      persist across program restarts.  Since they can use variables
10283      from shared libraries, we need to reparse expression as libraries
10284      are loaded and unloaded.
10285
10286      Watchpoints on local variables can also change meaning as result
10287      of solib event.  For example, if a watchpoint uses both a local
10288      and a global variables in expression, it's a local watchpoint,
10289      but unloading of a shared library will make the expression
10290      invalid.  This is not a very common use case, but we still
10291      re-evaluate expression, to avoid surprises to the user.
10292
10293      Note that for local watchpoints, we re-evaluate it only if
10294      watchpoints frame id is still valid.  If it's not, it means the
10295      watchpoint is out of scope and will be deleted soon.  In fact,
10296      I'm not sure we'll ever be called in this case.
10297
10298      If a local watchpoint's frame id is still valid, then
10299      w->exp_valid_block is likewise valid, and we can safely use it.
10300
10301      Don't do anything about disabled watchpoints, since they will be
10302      reevaluated again when enabled.  */
10303   update_watchpoint (w, 1 /* reparse */);
10304 }
10305
10306 /* Implement the "insert" breakpoint_ops method for hardware watchpoints.  */
10307
10308 static int
10309 insert_watchpoint (struct bp_location *bl)
10310 {
10311   struct watchpoint *w = (struct watchpoint *) bl->owner;
10312   int length = w->exact ? 1 : bl->length;
10313
10314   return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
10315                                    w->cond_exp);
10316 }
10317
10318 /* Implement the "remove" breakpoint_ops method for hardware watchpoints.  */
10319
10320 static int
10321 remove_watchpoint (struct bp_location *bl)
10322 {
10323   struct watchpoint *w = (struct watchpoint *) bl->owner;
10324   int length = w->exact ? 1 : bl->length;
10325
10326   return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
10327                                    w->cond_exp);
10328 }
10329
10330 static int
10331 breakpoint_hit_watchpoint (const struct bp_location *bl,
10332                            struct address_space *aspace, CORE_ADDR bp_addr,
10333                            const struct target_waitstatus *ws)
10334 {
10335   struct breakpoint *b = bl->owner;
10336   struct watchpoint *w = (struct watchpoint *) b;
10337
10338   /* Continuable hardware watchpoints are treated as non-existent if the
10339      reason we stopped wasn't a hardware watchpoint (we didn't stop on
10340      some data address).  Otherwise gdb won't stop on a break instruction
10341      in the code (not from a breakpoint) when a hardware watchpoint has
10342      been defined.  Also skip watchpoints which we know did not trigger
10343      (did not match the data address).  */
10344   if (is_hardware_watchpoint (b)
10345       && w->watchpoint_triggered == watch_triggered_no)
10346     return 0;
10347
10348   return 1;
10349 }
10350
10351 static void
10352 check_status_watchpoint (bpstat bs)
10353 {
10354   gdb_assert (is_watchpoint (bs->breakpoint_at));
10355
10356   bpstat_check_watchpoint (bs);
10357 }
10358
10359 /* Implement the "resources_needed" breakpoint_ops method for
10360    hardware watchpoints.  */
10361
10362 static int
10363 resources_needed_watchpoint (const struct bp_location *bl)
10364 {
10365   struct watchpoint *w = (struct watchpoint *) bl->owner;
10366   int length = w->exact? 1 : bl->length;
10367
10368   return target_region_ok_for_hw_watchpoint (bl->address, length);
10369 }
10370
10371 /* Implement the "works_in_software_mode" breakpoint_ops method for
10372    hardware watchpoints.  */
10373
10374 static int
10375 works_in_software_mode_watchpoint (const struct breakpoint *b)
10376 {
10377   /* Read and access watchpoints only work with hardware support.  */
10378   return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
10379 }
10380
10381 static enum print_stop_action
10382 print_it_watchpoint (bpstat bs)
10383 {
10384   struct cleanup *old_chain;
10385   struct breakpoint *b;
10386   const struct bp_location *bl;
10387   struct ui_file *stb;
10388   enum print_stop_action result;
10389   struct watchpoint *w;
10390   struct ui_out *uiout = current_uiout;
10391
10392   gdb_assert (bs->bp_location_at != NULL);
10393
10394   bl = bs->bp_location_at;
10395   b = bs->breakpoint_at;
10396   w = (struct watchpoint *) b;
10397
10398   stb = mem_fileopen ();
10399   old_chain = make_cleanup_ui_file_delete (stb);
10400
10401   switch (b->type)
10402     {
10403     case bp_watchpoint:
10404     case bp_hardware_watchpoint:
10405       annotate_watchpoint (b->number);
10406       if (ui_out_is_mi_like_p (uiout))
10407         ui_out_field_string
10408           (uiout, "reason",
10409            async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10410       mention (b);
10411       make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10412       ui_out_text (uiout, "\nOld value = ");
10413       watchpoint_value_print (bs->old_val, stb);
10414       ui_out_field_stream (uiout, "old", stb);
10415       ui_out_text (uiout, "\nNew value = ");
10416       watchpoint_value_print (w->val, stb);
10417       ui_out_field_stream (uiout, "new", stb);
10418       ui_out_text (uiout, "\n");
10419       /* More than one watchpoint may have been triggered.  */
10420       result = PRINT_UNKNOWN;
10421       break;
10422
10423     case bp_read_watchpoint:
10424       if (ui_out_is_mi_like_p (uiout))
10425         ui_out_field_string
10426           (uiout, "reason",
10427            async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10428       mention (b);
10429       make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10430       ui_out_text (uiout, "\nValue = ");
10431       watchpoint_value_print (w->val, stb);
10432       ui_out_field_stream (uiout, "value", stb);
10433       ui_out_text (uiout, "\n");
10434       result = PRINT_UNKNOWN;
10435       break;
10436
10437     case bp_access_watchpoint:
10438       if (bs->old_val != NULL)
10439         {
10440           annotate_watchpoint (b->number);
10441           if (ui_out_is_mi_like_p (uiout))
10442             ui_out_field_string
10443               (uiout, "reason",
10444                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10445           mention (b);
10446           make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10447           ui_out_text (uiout, "\nOld value = ");
10448           watchpoint_value_print (bs->old_val, stb);
10449           ui_out_field_stream (uiout, "old", stb);
10450           ui_out_text (uiout, "\nNew value = ");
10451         }
10452       else
10453         {
10454           mention (b);
10455           if (ui_out_is_mi_like_p (uiout))
10456             ui_out_field_string
10457               (uiout, "reason",
10458                async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10459           make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10460           ui_out_text (uiout, "\nValue = ");
10461         }
10462       watchpoint_value_print (w->val, stb);
10463       ui_out_field_stream (uiout, "new", stb);
10464       ui_out_text (uiout, "\n");
10465       result = PRINT_UNKNOWN;
10466       break;
10467     default:
10468       result = PRINT_UNKNOWN;
10469     }
10470
10471   do_cleanups (old_chain);
10472   return result;
10473 }
10474
10475 /* Implement the "print_mention" breakpoint_ops method for hardware
10476    watchpoints.  */
10477
10478 static void
10479 print_mention_watchpoint (struct breakpoint *b)
10480 {
10481   struct cleanup *ui_out_chain;
10482   struct watchpoint *w = (struct watchpoint *) b;
10483   struct ui_out *uiout = current_uiout;
10484
10485   switch (b->type)
10486     {
10487     case bp_watchpoint:
10488       ui_out_text (uiout, "Watchpoint ");
10489       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10490       break;
10491     case bp_hardware_watchpoint:
10492       ui_out_text (uiout, "Hardware watchpoint ");
10493       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10494       break;
10495     case bp_read_watchpoint:
10496       ui_out_text (uiout, "Hardware read watchpoint ");
10497       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10498       break;
10499     case bp_access_watchpoint:
10500       ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
10501       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
10502       break;
10503     default:
10504       internal_error (__FILE__, __LINE__,
10505                       _("Invalid hardware watchpoint type."));
10506     }
10507
10508   ui_out_field_int (uiout, "number", b->number);
10509   ui_out_text (uiout, ": ");
10510   ui_out_field_string (uiout, "exp", w->exp_string);
10511   do_cleanups (ui_out_chain);
10512 }
10513
10514 /* Implement the "print_recreate" breakpoint_ops method for
10515    watchpoints.  */
10516
10517 static void
10518 print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10519 {
10520   struct watchpoint *w = (struct watchpoint *) b;
10521
10522   switch (b->type)
10523     {
10524     case bp_watchpoint:
10525     case bp_hardware_watchpoint:
10526       fprintf_unfiltered (fp, "watch");
10527       break;
10528     case bp_read_watchpoint:
10529       fprintf_unfiltered (fp, "rwatch");
10530       break;
10531     case bp_access_watchpoint:
10532       fprintf_unfiltered (fp, "awatch");
10533       break;
10534     default:
10535       internal_error (__FILE__, __LINE__,
10536                       _("Invalid watchpoint type."));
10537     }
10538
10539   fprintf_unfiltered (fp, " %s", w->exp_string);
10540   print_recreate_thread (b, fp);
10541 }
10542
10543 /* The breakpoint_ops structure to be used in hardware watchpoints.  */
10544
10545 static struct breakpoint_ops watchpoint_breakpoint_ops;
10546
10547 /* Implement the "insert" breakpoint_ops method for
10548    masked hardware watchpoints.  */
10549
10550 static int
10551 insert_masked_watchpoint (struct bp_location *bl)
10552 {
10553   struct watchpoint *w = (struct watchpoint *) bl->owner;
10554
10555   return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
10556                                         bl->watchpoint_type);
10557 }
10558
10559 /* Implement the "remove" breakpoint_ops method for
10560    masked hardware watchpoints.  */
10561
10562 static int
10563 remove_masked_watchpoint (struct bp_location *bl)
10564 {
10565   struct watchpoint *w = (struct watchpoint *) bl->owner;
10566
10567   return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
10568                                         bl->watchpoint_type);
10569 }
10570
10571 /* Implement the "resources_needed" breakpoint_ops method for
10572    masked hardware watchpoints.  */
10573
10574 static int
10575 resources_needed_masked_watchpoint (const struct bp_location *bl)
10576 {
10577   struct watchpoint *w = (struct watchpoint *) bl->owner;
10578
10579   return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
10580 }
10581
10582 /* Implement the "works_in_software_mode" breakpoint_ops method for
10583    masked hardware watchpoints.  */
10584
10585 static int
10586 works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10587 {
10588   return 0;
10589 }
10590
10591 /* Implement the "print_it" breakpoint_ops method for
10592    masked hardware watchpoints.  */
10593
10594 static enum print_stop_action
10595 print_it_masked_watchpoint (bpstat bs)
10596 {
10597   struct breakpoint *b = bs->breakpoint_at;
10598   struct ui_out *uiout = current_uiout;
10599
10600   /* Masked watchpoints have only one location.  */
10601   gdb_assert (b->loc && b->loc->next == NULL);
10602
10603   switch (b->type)
10604     {
10605     case bp_hardware_watchpoint:
10606       annotate_watchpoint (b->number);
10607       if (ui_out_is_mi_like_p (uiout))
10608         ui_out_field_string
10609           (uiout, "reason",
10610            async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10611       break;
10612
10613     case bp_read_watchpoint:
10614       if (ui_out_is_mi_like_p (uiout))
10615         ui_out_field_string
10616           (uiout, "reason",
10617            async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10618       break;
10619
10620     case bp_access_watchpoint:
10621       if (ui_out_is_mi_like_p (uiout))
10622         ui_out_field_string
10623           (uiout, "reason",
10624            async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10625       break;
10626     default:
10627       internal_error (__FILE__, __LINE__,
10628                       _("Invalid hardware watchpoint type."));
10629     }
10630
10631   mention (b);
10632   ui_out_text (uiout, _("\n\
10633 Check the underlying instruction at PC for the memory\n\
10634 address and value which triggered this watchpoint.\n"));
10635   ui_out_text (uiout, "\n");
10636
10637   /* More than one watchpoint may have been triggered.  */
10638   return PRINT_UNKNOWN;
10639 }
10640
10641 /* Implement the "print_one_detail" breakpoint_ops method for
10642    masked hardware watchpoints.  */
10643
10644 static void
10645 print_one_detail_masked_watchpoint (const struct breakpoint *b,
10646                                     struct ui_out *uiout)
10647 {
10648   struct watchpoint *w = (struct watchpoint *) b;
10649
10650   /* Masked watchpoints have only one location.  */
10651   gdb_assert (b->loc && b->loc->next == NULL);
10652
10653   ui_out_text (uiout, "\tmask ");
10654   ui_out_field_core_addr (uiout, "mask", b->loc->gdbarch, w->hw_wp_mask);
10655   ui_out_text (uiout, "\n");
10656 }
10657
10658 /* Implement the "print_mention" breakpoint_ops method for
10659    masked hardware watchpoints.  */
10660
10661 static void
10662 print_mention_masked_watchpoint (struct breakpoint *b)
10663 {
10664   struct watchpoint *w = (struct watchpoint *) b;
10665   struct ui_out *uiout = current_uiout;
10666   struct cleanup *ui_out_chain;
10667
10668   switch (b->type)
10669     {
10670     case bp_hardware_watchpoint:
10671       ui_out_text (uiout, "Masked hardware watchpoint ");
10672       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10673       break;
10674     case bp_read_watchpoint:
10675       ui_out_text (uiout, "Masked hardware read watchpoint ");
10676       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10677       break;
10678     case bp_access_watchpoint:
10679       ui_out_text (uiout, "Masked hardware access (read/write) watchpoint ");
10680       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
10681       break;
10682     default:
10683       internal_error (__FILE__, __LINE__,
10684                       _("Invalid hardware watchpoint type."));
10685     }
10686
10687   ui_out_field_int (uiout, "number", b->number);
10688   ui_out_text (uiout, ": ");
10689   ui_out_field_string (uiout, "exp", w->exp_string);
10690   do_cleanups (ui_out_chain);
10691 }
10692
10693 /* Implement the "print_recreate" breakpoint_ops method for
10694    masked hardware watchpoints.  */
10695
10696 static void
10697 print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
10698 {
10699   struct watchpoint *w = (struct watchpoint *) b;
10700   char tmp[40];
10701
10702   switch (b->type)
10703     {
10704     case bp_hardware_watchpoint:
10705       fprintf_unfiltered (fp, "watch");
10706       break;
10707     case bp_read_watchpoint:
10708       fprintf_unfiltered (fp, "rwatch");
10709       break;
10710     case bp_access_watchpoint:
10711       fprintf_unfiltered (fp, "awatch");
10712       break;
10713     default:
10714       internal_error (__FILE__, __LINE__,
10715                       _("Invalid hardware watchpoint type."));
10716     }
10717
10718   sprintf_vma (tmp, w->hw_wp_mask);
10719   fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
10720   print_recreate_thread (b, fp);
10721 }
10722
10723 /* The breakpoint_ops structure to be used in masked hardware watchpoints.  */
10724
10725 static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
10726
10727 /* Tell whether the given watchpoint is a masked hardware watchpoint.  */
10728
10729 static int
10730 is_masked_watchpoint (const struct breakpoint *b)
10731 {
10732   return b->ops == &masked_watchpoint_breakpoint_ops;
10733 }
10734
10735 /* accessflag:  hw_write:  watch write, 
10736                 hw_read:   watch read, 
10737                 hw_access: watch access (read or write) */
10738 static void
10739 watch_command_1 (char *arg, int accessflag, int from_tty,
10740                  int just_location, int internal)
10741 {
10742   volatile struct gdb_exception e;
10743   struct breakpoint *b, *scope_breakpoint = NULL;
10744   struct expression *exp;
10745   struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
10746   struct value *val, *mark, *result;
10747   struct frame_info *frame;
10748   char *exp_start = NULL;
10749   char *exp_end = NULL;
10750   char *tok, *end_tok;
10751   int toklen = -1;
10752   char *cond_start = NULL;
10753   char *cond_end = NULL;
10754   enum bptype bp_type;
10755   int thread = -1;
10756   int pc = 0;
10757   /* Flag to indicate whether we are going to use masks for
10758      the hardware watchpoint.  */
10759   int use_mask = 0;
10760   CORE_ADDR mask = 0;
10761   struct watchpoint *w;
10762
10763   /* Make sure that we actually have parameters to parse.  */
10764   if (arg != NULL && arg[0] != '\0')
10765     {
10766       char *value_start;
10767
10768       /* Look for "parameter value" pairs at the end
10769          of the arguments string.  */
10770       for (tok = arg + strlen (arg) - 1; tok > arg; tok--)
10771         {
10772           /* Skip whitespace at the end of the argument list.  */
10773           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10774             tok--;
10775
10776           /* Find the beginning of the last token.
10777              This is the value of the parameter.  */
10778           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10779             tok--;
10780           value_start = tok + 1;
10781
10782           /* Skip whitespace.  */
10783           while (tok > arg && (*tok == ' ' || *tok == '\t'))
10784             tok--;
10785
10786           end_tok = tok;
10787
10788           /* Find the beginning of the second to last token.
10789              This is the parameter itself.  */
10790           while (tok > arg && (*tok != ' ' && *tok != '\t'))
10791             tok--;
10792           tok++;
10793           toklen = end_tok - tok + 1;
10794
10795           if (toklen == 6 && !strncmp (tok, "thread", 6))
10796             {
10797               /* At this point we've found a "thread" token, which means
10798                  the user is trying to set a watchpoint that triggers
10799                  only in a specific thread.  */
10800               char *endp;
10801
10802               if (thread != -1)
10803                 error(_("You can specify only one thread."));
10804
10805               /* Extract the thread ID from the next token.  */
10806               thread = strtol (value_start, &endp, 0);
10807
10808               /* Check if the user provided a valid numeric value for the
10809                  thread ID.  */
10810               if (*endp != ' ' && *endp != '\t' && *endp != '\0')
10811                 error (_("Invalid thread ID specification %s."), value_start);
10812
10813               /* Check if the thread actually exists.  */
10814               if (!valid_thread_id (thread))
10815                 invalid_thread_id_error (thread);
10816             }
10817           else if (toklen == 4 && !strncmp (tok, "mask", 4))
10818             {
10819               /* We've found a "mask" token, which means the user wants to
10820                  create a hardware watchpoint that is going to have the mask
10821                  facility.  */
10822               struct value *mask_value, *mark;
10823
10824               if (use_mask)
10825                 error(_("You can specify only one mask."));
10826
10827               use_mask = just_location = 1;
10828
10829               mark = value_mark ();
10830               mask_value = parse_to_comma_and_eval (&value_start);
10831               mask = value_as_address (mask_value);
10832               value_free_to_mark (mark);
10833             }
10834           else
10835             /* We didn't recognize what we found.  We should stop here.  */
10836             break;
10837
10838           /* Truncate the string and get rid of the "parameter value" pair before
10839              the arguments string is parsed by the parse_exp_1 function.  */
10840           *tok = '\0';
10841         }
10842     }
10843
10844   /* Parse the rest of the arguments.  */
10845   innermost_block = NULL;
10846   exp_start = arg;
10847   exp = parse_exp_1 (&arg, 0, 0, 0);
10848   exp_end = arg;
10849   /* Remove trailing whitespace from the expression before saving it.
10850      This makes the eventual display of the expression string a bit
10851      prettier.  */
10852   while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
10853     --exp_end;
10854
10855   /* Checking if the expression is not constant.  */
10856   if (watchpoint_exp_is_const (exp))
10857     {
10858       int len;
10859
10860       len = exp_end - exp_start;
10861       while (len > 0 && isspace (exp_start[len - 1]))
10862         len--;
10863       error (_("Cannot watch constant value `%.*s'."), len, exp_start);
10864     }
10865
10866   exp_valid_block = innermost_block;
10867   mark = value_mark ();
10868   fetch_subexp_value (exp, &pc, &val, &result, NULL);
10869
10870   if (just_location)
10871     {
10872       int ret;
10873
10874       exp_valid_block = NULL;
10875       val = value_addr (result);
10876       release_value (val);
10877       value_free_to_mark (mark);
10878
10879       if (use_mask)
10880         {
10881           ret = target_masked_watch_num_registers (value_as_address (val),
10882                                                    mask);
10883           if (ret == -1)
10884             error (_("This target does not support masked watchpoints."));
10885           else if (ret == -2)
10886             error (_("Invalid mask or memory region."));
10887         }
10888     }
10889   else if (val != NULL)
10890     release_value (val);
10891
10892   tok = skip_spaces (arg);
10893   end_tok = skip_to_space (tok);
10894
10895   toklen = end_tok - tok;
10896   if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
10897     {
10898       struct expression *cond;
10899
10900       innermost_block = NULL;
10901       tok = cond_start = end_tok + 1;
10902       cond = parse_exp_1 (&tok, 0, 0, 0);
10903
10904       /* The watchpoint expression may not be local, but the condition
10905          may still be.  E.g.: `watch global if local > 0'.  */
10906       cond_exp_valid_block = innermost_block;
10907
10908       xfree (cond);
10909       cond_end = tok;
10910     }
10911   if (*tok)
10912     error (_("Junk at end of command."));
10913
10914   if (accessflag == hw_read)
10915     bp_type = bp_read_watchpoint;
10916   else if (accessflag == hw_access)
10917     bp_type = bp_access_watchpoint;
10918   else
10919     bp_type = bp_hardware_watchpoint;
10920
10921   frame = block_innermost_frame (exp_valid_block);
10922
10923   /* If the expression is "local", then set up a "watchpoint scope"
10924      breakpoint at the point where we've left the scope of the watchpoint
10925      expression.  Create the scope breakpoint before the watchpoint, so
10926      that we will encounter it first in bpstat_stop_status.  */
10927   if (exp_valid_block && frame)
10928     {
10929       if (frame_id_p (frame_unwind_caller_id (frame)))
10930         {
10931           scope_breakpoint
10932             = create_internal_breakpoint (frame_unwind_caller_arch (frame),
10933                                           frame_unwind_caller_pc (frame),
10934                                           bp_watchpoint_scope,
10935                                           &momentary_breakpoint_ops);
10936
10937           scope_breakpoint->enable_state = bp_enabled;
10938
10939           /* Automatically delete the breakpoint when it hits.  */
10940           scope_breakpoint->disposition = disp_del;
10941
10942           /* Only break in the proper frame (help with recursion).  */
10943           scope_breakpoint->frame_id = frame_unwind_caller_id (frame);
10944
10945           /* Set the address at which we will stop.  */
10946           scope_breakpoint->loc->gdbarch
10947             = frame_unwind_caller_arch (frame);
10948           scope_breakpoint->loc->requested_address
10949             = frame_unwind_caller_pc (frame);
10950           scope_breakpoint->loc->address
10951             = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
10952                                          scope_breakpoint->loc->requested_address,
10953                                          scope_breakpoint->type);
10954         }
10955     }
10956
10957   /* Now set up the breakpoint.  */
10958
10959   w = XCNEW (struct watchpoint);
10960   b = &w->base;
10961   if (use_mask)
10962     init_raw_breakpoint_without_location (b, NULL, bp_type,
10963                                           &masked_watchpoint_breakpoint_ops);
10964   else
10965     init_raw_breakpoint_without_location (b, NULL, bp_type,
10966                                           &watchpoint_breakpoint_ops);
10967   b->thread = thread;
10968   b->disposition = disp_donttouch;
10969   b->pspace = current_program_space;
10970   w->exp = exp;
10971   w->exp_valid_block = exp_valid_block;
10972   w->cond_exp_valid_block = cond_exp_valid_block;
10973   if (just_location)
10974     {
10975       struct type *t = value_type (val);
10976       CORE_ADDR addr = value_as_address (val);
10977       char *name;
10978
10979       t = check_typedef (TYPE_TARGET_TYPE (check_typedef (t)));
10980       name = type_to_string (t);
10981
10982       w->exp_string_reparse = xstrprintf ("* (%s *) %s", name,
10983                                           core_addr_to_string (addr));
10984       xfree (name);
10985
10986       w->exp_string = xstrprintf ("-location %.*s",
10987                                   (int) (exp_end - exp_start), exp_start);
10988
10989       /* The above expression is in C.  */
10990       b->language = language_c;
10991     }
10992   else
10993     w->exp_string = savestring (exp_start, exp_end - exp_start);
10994
10995   if (use_mask)
10996     {
10997       w->hw_wp_mask = mask;
10998     }
10999   else
11000     {
11001       w->val = val;
11002       w->val_valid = 1;
11003     }
11004
11005   if (cond_start)
11006     b->cond_string = savestring (cond_start, cond_end - cond_start);
11007   else
11008     b->cond_string = 0;
11009
11010   if (frame)
11011     {
11012       w->watchpoint_frame = get_frame_id (frame);
11013       w->watchpoint_thread = inferior_ptid;
11014     }
11015   else
11016     {
11017       w->watchpoint_frame = null_frame_id;
11018       w->watchpoint_thread = null_ptid;
11019     }
11020
11021   if (scope_breakpoint != NULL)
11022     {
11023       /* The scope breakpoint is related to the watchpoint.  We will
11024          need to act on them together.  */
11025       b->related_breakpoint = scope_breakpoint;
11026       scope_breakpoint->related_breakpoint = b;
11027     }
11028
11029   if (!just_location)
11030     value_free_to_mark (mark);
11031
11032   TRY_CATCH (e, RETURN_MASK_ALL)
11033     {
11034       /* Finally update the new watchpoint.  This creates the locations
11035          that should be inserted.  */
11036       update_watchpoint (w, 1);
11037     }
11038   if (e.reason < 0)
11039     {
11040       delete_breakpoint (b);
11041       throw_exception (e);
11042     }
11043
11044   install_breakpoint (internal, b, 1);
11045 }
11046
11047 /* Return count of debug registers needed to watch the given expression.
11048    If the watchpoint cannot be handled in hardware return zero.  */
11049
11050 static int
11051 can_use_hardware_watchpoint (struct value *v)
11052 {
11053   int found_memory_cnt = 0;
11054   struct value *head = v;
11055
11056   /* Did the user specifically forbid us to use hardware watchpoints? */
11057   if (!can_use_hw_watchpoints)
11058     return 0;
11059
11060   /* Make sure that the value of the expression depends only upon
11061      memory contents, and values computed from them within GDB.  If we
11062      find any register references or function calls, we can't use a
11063      hardware watchpoint.
11064
11065      The idea here is that evaluating an expression generates a series
11066      of values, one holding the value of every subexpression.  (The
11067      expression a*b+c has five subexpressions: a, b, a*b, c, and
11068      a*b+c.)  GDB's values hold almost enough information to establish
11069      the criteria given above --- they identify memory lvalues,
11070      register lvalues, computed values, etcetera.  So we can evaluate
11071      the expression, and then scan the chain of values that leaves
11072      behind to decide whether we can detect any possible change to the
11073      expression's final value using only hardware watchpoints.
11074
11075      However, I don't think that the values returned by inferior
11076      function calls are special in any way.  So this function may not
11077      notice that an expression involving an inferior function call
11078      can't be watched with hardware watchpoints.  FIXME.  */
11079   for (; v; v = value_next (v))
11080     {
11081       if (VALUE_LVAL (v) == lval_memory)
11082         {
11083           if (v != head && value_lazy (v))
11084             /* A lazy memory lvalue in the chain is one that GDB never
11085                needed to fetch; we either just used its address (e.g.,
11086                `a' in `a.b') or we never needed it at all (e.g., `a'
11087                in `a,b').  This doesn't apply to HEAD; if that is
11088                lazy then it was not readable, but watch it anyway.  */
11089             ;
11090           else
11091             {
11092               /* Ahh, memory we actually used!  Check if we can cover
11093                  it with hardware watchpoints.  */
11094               struct type *vtype = check_typedef (value_type (v));
11095
11096               /* We only watch structs and arrays if user asked for it
11097                  explicitly, never if they just happen to appear in a
11098                  middle of some value chain.  */
11099               if (v == head
11100                   || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
11101                       && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
11102                 {
11103                   CORE_ADDR vaddr = value_address (v);
11104                   int len;
11105                   int num_regs;
11106
11107                   len = (target_exact_watchpoints
11108                          && is_scalar_type_recursive (vtype))?
11109                     1 : TYPE_LENGTH (value_type (v));
11110
11111                   num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
11112                   if (!num_regs)
11113                     return 0;
11114                   else
11115                     found_memory_cnt += num_regs;
11116                 }
11117             }
11118         }
11119       else if (VALUE_LVAL (v) != not_lval
11120                && deprecated_value_modifiable (v) == 0)
11121         return 0;       /* These are values from the history (e.g., $1).  */
11122       else if (VALUE_LVAL (v) == lval_register)
11123         return 0;       /* Cannot watch a register with a HW watchpoint.  */
11124     }
11125
11126   /* The expression itself looks suitable for using a hardware
11127      watchpoint, but give the target machine a chance to reject it.  */
11128   return found_memory_cnt;
11129 }
11130
11131 void
11132 watch_command_wrapper (char *arg, int from_tty, int internal)
11133 {
11134   watch_command_1 (arg, hw_write, from_tty, 0, internal);
11135 }
11136
11137 /* A helper function that looks for the "-location" argument and then
11138    calls watch_command_1.  */
11139
11140 static void
11141 watch_maybe_just_location (char *arg, int accessflag, int from_tty)
11142 {
11143   int just_location = 0;
11144
11145   if (arg
11146       && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
11147           || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
11148     {
11149       arg = skip_spaces (arg);
11150       just_location = 1;
11151     }
11152
11153   watch_command_1 (arg, accessflag, from_tty, just_location, 0);
11154 }
11155
11156 static void
11157 watch_command (char *arg, int from_tty)
11158 {
11159   watch_maybe_just_location (arg, hw_write, from_tty);
11160 }
11161
11162 void
11163 rwatch_command_wrapper (char *arg, int from_tty, int internal)
11164 {
11165   watch_command_1 (arg, hw_read, from_tty, 0, internal);
11166 }
11167
11168 static void
11169 rwatch_command (char *arg, int from_tty)
11170 {
11171   watch_maybe_just_location (arg, hw_read, from_tty);
11172 }
11173
11174 void
11175 awatch_command_wrapper (char *arg, int from_tty, int internal)
11176 {
11177   watch_command_1 (arg, hw_access, from_tty, 0, internal);
11178 }
11179
11180 static void
11181 awatch_command (char *arg, int from_tty)
11182 {
11183   watch_maybe_just_location (arg, hw_access, from_tty);
11184 }
11185 \f
11186
11187 /* Helper routines for the until_command routine in infcmd.c.  Here
11188    because it uses the mechanisms of breakpoints.  */
11189
11190 struct until_break_command_continuation_args
11191 {
11192   struct breakpoint *breakpoint;
11193   struct breakpoint *breakpoint2;
11194   int thread_num;
11195 };
11196
11197 /* This function is called by fetch_inferior_event via the
11198    cmd_continuation pointer, to complete the until command.  It takes
11199    care of cleaning up the temporary breakpoints set up by the until
11200    command.  */
11201 static void
11202 until_break_command_continuation (void *arg, int err)
11203 {
11204   struct until_break_command_continuation_args *a = arg;
11205
11206   delete_breakpoint (a->breakpoint);
11207   if (a->breakpoint2)
11208     delete_breakpoint (a->breakpoint2);
11209   delete_longjmp_breakpoint (a->thread_num);
11210 }
11211
11212 void
11213 until_break_command (char *arg, int from_tty, int anywhere)
11214 {
11215   struct symtabs_and_lines sals;
11216   struct symtab_and_line sal;
11217   struct frame_info *frame;
11218   struct gdbarch *frame_gdbarch;
11219   struct frame_id stack_frame_id;
11220   struct frame_id caller_frame_id;
11221   struct breakpoint *breakpoint;
11222   struct breakpoint *breakpoint2 = NULL;
11223   struct cleanup *old_chain;
11224   int thread;
11225   struct thread_info *tp;
11226
11227   clear_proceed_status ();
11228
11229   /* Set a breakpoint where the user wants it and at return from
11230      this function.  */
11231
11232   if (last_displayed_sal_is_valid ())
11233     sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
11234                           get_last_displayed_symtab (),
11235                           get_last_displayed_line ());
11236   else
11237     sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
11238                           (struct symtab *) NULL, 0);
11239
11240   if (sals.nelts != 1)
11241     error (_("Couldn't get information on specified line."));
11242
11243   sal = sals.sals[0];
11244   xfree (sals.sals);    /* malloc'd, so freed.  */
11245
11246   if (*arg)
11247     error (_("Junk at end of arguments."));
11248
11249   resolve_sal_pc (&sal);
11250
11251   tp = inferior_thread ();
11252   thread = tp->num;
11253
11254   old_chain = make_cleanup (null_cleanup, NULL);
11255
11256   /* Note linespec handling above invalidates the frame chain.
11257      Installing a breakpoint also invalidates the frame chain (as it
11258      may need to switch threads), so do any frame handling before
11259      that.  */
11260
11261   frame = get_selected_frame (NULL);
11262   frame_gdbarch = get_frame_arch (frame);
11263   stack_frame_id = get_stack_frame_id (frame);
11264   caller_frame_id = frame_unwind_caller_id (frame);
11265
11266   /* Keep within the current frame, or in frames called by the current
11267      one.  */
11268
11269   if (frame_id_p (caller_frame_id))
11270     {
11271       struct symtab_and_line sal2;
11272
11273       sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11274       sal2.pc = frame_unwind_caller_pc (frame);
11275       breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
11276                                               sal2,
11277                                               caller_frame_id,
11278                                               bp_until);
11279       make_cleanup_delete_breakpoint (breakpoint2);
11280
11281       set_longjmp_breakpoint (tp, caller_frame_id);
11282       make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
11283     }
11284
11285   /* set_momentary_breakpoint could invalidate FRAME.  */
11286   frame = NULL;
11287
11288   if (anywhere)
11289     /* If the user told us to continue until a specified location,
11290        we don't specify a frame at which we need to stop.  */
11291     breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11292                                            null_frame_id, bp_until);
11293   else
11294     /* Otherwise, specify the selected frame, because we want to stop
11295        only at the very same frame.  */
11296     breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11297                                            stack_frame_id, bp_until);
11298   make_cleanup_delete_breakpoint (breakpoint);
11299
11300   proceed (-1, GDB_SIGNAL_DEFAULT, 0);
11301
11302   /* If we are running asynchronously, and proceed call above has
11303      actually managed to start the target, arrange for breakpoints to
11304      be deleted when the target stops.  Otherwise, we're already
11305      stopped and delete breakpoints via cleanup chain.  */
11306
11307   if (target_can_async_p () && is_running (inferior_ptid))
11308     {
11309       struct until_break_command_continuation_args *args;
11310       args = xmalloc (sizeof (*args));
11311
11312       args->breakpoint = breakpoint;
11313       args->breakpoint2 = breakpoint2;
11314       args->thread_num = thread;
11315
11316       discard_cleanups (old_chain);
11317       add_continuation (inferior_thread (),
11318                         until_break_command_continuation, args,
11319                         xfree);
11320     }
11321   else
11322     do_cleanups (old_chain);
11323 }
11324
11325 /* This function attempts to parse an optional "if <cond>" clause
11326    from the arg string.  If one is not found, it returns NULL.
11327
11328    Else, it returns a pointer to the condition string.  (It does not
11329    attempt to evaluate the string against a particular block.)  And,
11330    it updates arg to point to the first character following the parsed
11331    if clause in the arg string.  */
11332
11333 static char *
11334 ep_parse_optional_if_clause (char **arg)
11335 {
11336   char *cond_string;
11337
11338   if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
11339     return NULL;
11340
11341   /* Skip the "if" keyword.  */
11342   (*arg) += 2;
11343
11344   /* Skip any extra leading whitespace, and record the start of the
11345      condition string.  */
11346   *arg = skip_spaces (*arg);
11347   cond_string = *arg;
11348
11349   /* Assume that the condition occupies the remainder of the arg
11350      string.  */
11351   (*arg) += strlen (cond_string);
11352
11353   return cond_string;
11354 }
11355
11356 /* Commands to deal with catching events, such as signals, exceptions,
11357    process start/exit, etc.  */
11358
11359 typedef enum
11360 {
11361   catch_fork_temporary, catch_vfork_temporary,
11362   catch_fork_permanent, catch_vfork_permanent
11363 }
11364 catch_fork_kind;
11365
11366 static void
11367 catch_fork_command_1 (char *arg, int from_tty, 
11368                       struct cmd_list_element *command)
11369 {
11370   struct gdbarch *gdbarch = get_current_arch ();
11371   char *cond_string = NULL;
11372   catch_fork_kind fork_kind;
11373   int tempflag;
11374
11375   fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11376   tempflag = (fork_kind == catch_fork_temporary
11377               || fork_kind == catch_vfork_temporary);
11378
11379   if (!arg)
11380     arg = "";
11381   arg = skip_spaces (arg);
11382
11383   /* The allowed syntax is:
11384      catch [v]fork
11385      catch [v]fork if <cond>
11386
11387      First, check if there's an if clause.  */
11388   cond_string = ep_parse_optional_if_clause (&arg);
11389
11390   if ((*arg != '\0') && !isspace (*arg))
11391     error (_("Junk at end of arguments."));
11392
11393   /* If this target supports it, create a fork or vfork catchpoint
11394      and enable reporting of such events.  */
11395   switch (fork_kind)
11396     {
11397     case catch_fork_temporary:
11398     case catch_fork_permanent:
11399       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11400                                           &catch_fork_breakpoint_ops);
11401       break;
11402     case catch_vfork_temporary:
11403     case catch_vfork_permanent:
11404       create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
11405                                           &catch_vfork_breakpoint_ops);
11406       break;
11407     default:
11408       error (_("unsupported or unknown fork kind; cannot catch it"));
11409       break;
11410     }
11411 }
11412
11413 static void
11414 catch_exec_command_1 (char *arg, int from_tty, 
11415                       struct cmd_list_element *command)
11416 {
11417   struct exec_catchpoint *c;
11418   struct gdbarch *gdbarch = get_current_arch ();
11419   int tempflag;
11420   char *cond_string = NULL;
11421
11422   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11423
11424   if (!arg)
11425     arg = "";
11426   arg = skip_spaces (arg);
11427
11428   /* The allowed syntax is:
11429      catch exec
11430      catch exec if <cond>
11431
11432      First, check if there's an if clause.  */
11433   cond_string = ep_parse_optional_if_clause (&arg);
11434
11435   if ((*arg != '\0') && !isspace (*arg))
11436     error (_("Junk at end of arguments."));
11437
11438   c = XNEW (struct exec_catchpoint);
11439   init_catchpoint (&c->base, gdbarch, tempflag, cond_string,
11440                    &catch_exec_breakpoint_ops);
11441   c->exec_pathname = NULL;
11442
11443   install_breakpoint (0, &c->base, 1);
11444 }
11445
11446 static enum print_stop_action
11447 print_it_exception_catchpoint (bpstat bs)
11448 {
11449   struct ui_out *uiout = current_uiout;
11450   struct breakpoint *b = bs->breakpoint_at;
11451   int bp_temp, bp_throw;
11452
11453   annotate_catchpoint (b->number);
11454
11455   bp_throw = strstr (b->addr_string, "throw") != NULL;
11456   if (b->loc->address != b->loc->requested_address)
11457     breakpoint_adjustment_warning (b->loc->requested_address,
11458                                    b->loc->address,
11459                                    b->number, 1);
11460   bp_temp = b->disposition == disp_del;
11461   ui_out_text (uiout, 
11462                bp_temp ? "Temporary catchpoint "
11463                        : "Catchpoint ");
11464   if (!ui_out_is_mi_like_p (uiout))
11465     ui_out_field_int (uiout, "bkptno", b->number);
11466   ui_out_text (uiout,
11467                bp_throw ? " (exception thrown), "
11468                         : " (exception caught), ");
11469   if (ui_out_is_mi_like_p (uiout))
11470     {
11471       ui_out_field_string (uiout, "reason", 
11472                            async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
11473       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
11474       ui_out_field_int (uiout, "bkptno", b->number);
11475     }
11476   return PRINT_SRC_AND_LOC;
11477 }
11478
11479 static void
11480 print_one_exception_catchpoint (struct breakpoint *b, 
11481                                 struct bp_location **last_loc)
11482 {
11483   struct value_print_options opts;
11484   struct ui_out *uiout = current_uiout;
11485
11486   get_user_print_options (&opts);
11487   if (opts.addressprint)
11488     {
11489       annotate_field (4);
11490       if (b->loc == NULL || b->loc->shlib_disabled)
11491         ui_out_field_string (uiout, "addr", "<PENDING>");
11492       else
11493         ui_out_field_core_addr (uiout, "addr",
11494                                 b->loc->gdbarch, b->loc->address);
11495     }
11496   annotate_field (5);
11497   if (b->loc)
11498     *last_loc = b->loc;
11499   if (strstr (b->addr_string, "throw") != NULL)
11500     ui_out_field_string (uiout, "what", "exception throw");
11501   else
11502     ui_out_field_string (uiout, "what", "exception catch");
11503 }
11504
11505 static void
11506 print_mention_exception_catchpoint (struct breakpoint *b)
11507 {
11508   struct ui_out *uiout = current_uiout;
11509   int bp_temp;
11510   int bp_throw;
11511
11512   bp_temp = b->disposition == disp_del;
11513   bp_throw = strstr (b->addr_string, "throw") != NULL;
11514   ui_out_text (uiout, bp_temp ? _("Temporary catchpoint ")
11515                               : _("Catchpoint "));
11516   ui_out_field_int (uiout, "bkptno", b->number);
11517   ui_out_text (uiout, bp_throw ? _(" (throw)")
11518                                : _(" (catch)"));
11519 }
11520
11521 /* Implement the "print_recreate" breakpoint_ops method for throw and
11522    catch catchpoints.  */
11523
11524 static void
11525 print_recreate_exception_catchpoint (struct breakpoint *b, 
11526                                      struct ui_file *fp)
11527 {
11528   int bp_temp;
11529   int bp_throw;
11530
11531   bp_temp = b->disposition == disp_del;
11532   bp_throw = strstr (b->addr_string, "throw") != NULL;
11533   fprintf_unfiltered (fp, bp_temp ? "tcatch " : "catch ");
11534   fprintf_unfiltered (fp, bp_throw ? "throw" : "catch");
11535   print_recreate_thread (b, fp);
11536 }
11537
11538 static struct breakpoint_ops gnu_v3_exception_catchpoint_ops;
11539
11540 static int
11541 handle_gnu_v3_exceptions (int tempflag, char *cond_string,
11542                           enum exception_event_kind ex_event, int from_tty)
11543 {
11544   char *trigger_func_name;
11545  
11546   if (ex_event == EX_EVENT_CATCH)
11547     trigger_func_name = "__cxa_begin_catch";
11548   else
11549     trigger_func_name = "__cxa_throw";
11550
11551   create_breakpoint (get_current_arch (),
11552                      trigger_func_name, cond_string, -1, NULL,
11553                      0 /* condition and thread are valid.  */,
11554                      tempflag, bp_breakpoint,
11555                      0,
11556                      AUTO_BOOLEAN_TRUE /* pending */,
11557                      &gnu_v3_exception_catchpoint_ops, from_tty,
11558                      1 /* enabled */,
11559                      0 /* internal */,
11560                      0);
11561
11562   return 1;
11563 }
11564
11565 /* Deal with "catch catch" and "catch throw" commands.  */
11566
11567 static void
11568 catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
11569                            int tempflag, int from_tty)
11570 {
11571   char *cond_string = NULL;
11572
11573   if (!arg)
11574     arg = "";
11575   arg = skip_spaces (arg);
11576
11577   cond_string = ep_parse_optional_if_clause (&arg);
11578
11579   if ((*arg != '\0') && !isspace (*arg))
11580     error (_("Junk at end of arguments."));
11581
11582   if (ex_event != EX_EVENT_THROW
11583       && ex_event != EX_EVENT_CATCH)
11584     error (_("Unsupported or unknown exception event; cannot catch it"));
11585
11586   if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
11587     return;
11588
11589   warning (_("Unsupported with this platform/compiler combination."));
11590 }
11591
11592 /* Implementation of "catch catch" command.  */
11593
11594 static void
11595 catch_catch_command (char *arg, int from_tty, struct cmd_list_element *command)
11596 {
11597   int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11598
11599   catch_exception_command_1 (EX_EVENT_CATCH, arg, tempflag, from_tty);
11600 }
11601
11602 /* Implementation of "catch throw" command.  */
11603
11604 static void
11605 catch_throw_command (char *arg, int from_tty, struct cmd_list_element *command)
11606 {
11607   int tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11608
11609   catch_exception_command_1 (EX_EVENT_THROW, arg, tempflag, from_tty);
11610 }
11611
11612 void
11613 init_ada_exception_breakpoint (struct breakpoint *b,
11614                                struct gdbarch *gdbarch,
11615                                struct symtab_and_line sal,
11616                                char *addr_string,
11617                                const struct breakpoint_ops *ops,
11618                                int tempflag,
11619                                int from_tty)
11620 {
11621   if (from_tty)
11622     {
11623       struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11624       if (!loc_gdbarch)
11625         loc_gdbarch = gdbarch;
11626
11627       describe_other_breakpoints (loc_gdbarch,
11628                                   sal.pspace, sal.pc, sal.section, -1);
11629       /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11630          version for exception catchpoints, because two catchpoints
11631          used for different exception names will use the same address.
11632          In this case, a "breakpoint ... also set at..." warning is
11633          unproductive.  Besides, the warning phrasing is also a bit
11634          inappropriate, we should use the word catchpoint, and tell
11635          the user what type of catchpoint it is.  The above is good
11636          enough for now, though.  */
11637     }
11638
11639   init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
11640
11641   b->enable_state = bp_enabled;
11642   b->disposition = tempflag ? disp_del : disp_donttouch;
11643   b->addr_string = addr_string;
11644   b->language = language_ada;
11645 }
11646
11647 /* Splits the argument using space as delimiter.  Returns an xmalloc'd
11648    filter list, or NULL if no filtering is required.  */
11649 static VEC(int) *
11650 catch_syscall_split_args (char *arg)
11651 {
11652   VEC(int) *result = NULL;
11653   struct cleanup *cleanup = make_cleanup (VEC_cleanup (int), &result);
11654
11655   while (*arg != '\0')
11656     {
11657       int i, syscall_number;
11658       char *endptr;
11659       char cur_name[128];
11660       struct syscall s;
11661
11662       /* Skip whitespace.  */
11663       while (isspace (*arg))
11664         arg++;
11665
11666       for (i = 0; i < 127 && arg[i] && !isspace (arg[i]); ++i)
11667         cur_name[i] = arg[i];
11668       cur_name[i] = '\0';
11669       arg += i;
11670
11671       /* Check if the user provided a syscall name or a number.  */
11672       syscall_number = (int) strtol (cur_name, &endptr, 0);
11673       if (*endptr == '\0')
11674         get_syscall_by_number (syscall_number, &s);
11675       else
11676         {
11677           /* We have a name.  Let's check if it's valid and convert it
11678              to a number.  */
11679           get_syscall_by_name (cur_name, &s);
11680
11681           if (s.number == UNKNOWN_SYSCALL)
11682             /* Here we have to issue an error instead of a warning,
11683                because GDB cannot do anything useful if there's no
11684                syscall number to be caught.  */
11685             error (_("Unknown syscall name '%s'."), cur_name);
11686         }
11687
11688       /* Ok, it's valid.  */
11689       VEC_safe_push (int, result, s.number);
11690     }
11691
11692   discard_cleanups (cleanup);
11693   return result;
11694 }
11695
11696 /* Implement the "catch syscall" command.  */
11697
11698 static void
11699 catch_syscall_command_1 (char *arg, int from_tty, 
11700                          struct cmd_list_element *command)
11701 {
11702   int tempflag;
11703   VEC(int) *filter;
11704   struct syscall s;
11705   struct gdbarch *gdbarch = get_current_arch ();
11706
11707   /* Checking if the feature if supported.  */
11708   if (gdbarch_get_syscall_number_p (gdbarch) == 0)
11709     error (_("The feature 'catch syscall' is not supported on \
11710 this architecture yet."));
11711
11712   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11713
11714   arg = skip_spaces (arg);
11715
11716   /* We need to do this first "dummy" translation in order
11717      to get the syscall XML file loaded or, most important,
11718      to display a warning to the user if there's no XML file
11719      for his/her architecture.  */
11720   get_syscall_by_number (0, &s);
11721
11722   /* The allowed syntax is:
11723      catch syscall
11724      catch syscall <name | number> [<name | number> ... <name | number>]
11725
11726      Let's check if there's a syscall name.  */
11727
11728   if (arg != NULL)
11729     filter = catch_syscall_split_args (arg);
11730   else
11731     filter = NULL;
11732
11733   create_syscall_event_catchpoint (tempflag, filter,
11734                                    &catch_syscall_breakpoint_ops);
11735 }
11736
11737 static void
11738 catch_command (char *arg, int from_tty)
11739 {
11740   error (_("Catch requires an event name."));
11741 }
11742 \f
11743
11744 static void
11745 tcatch_command (char *arg, int from_tty)
11746 {
11747   error (_("Catch requires an event name."));
11748 }
11749
11750 /* A qsort comparison function that sorts breakpoints in order.  */
11751
11752 static int
11753 compare_breakpoints (const void *a, const void *b)
11754 {
11755   const breakpoint_p *ba = a;
11756   uintptr_t ua = (uintptr_t) *ba;
11757   const breakpoint_p *bb = b;
11758   uintptr_t ub = (uintptr_t) *bb;
11759
11760   if ((*ba)->number < (*bb)->number)
11761     return -1;
11762   else if ((*ba)->number > (*bb)->number)
11763     return 1;
11764
11765   /* Now sort by address, in case we see, e..g, two breakpoints with
11766      the number 0.  */
11767   if (ua < ub)
11768     return -1;
11769   return ua > ub ? 1 : 0;
11770 }
11771
11772 /* Delete breakpoints by address or line.  */
11773
11774 static void
11775 clear_command (char *arg, int from_tty)
11776 {
11777   struct breakpoint *b, *prev;
11778   VEC(breakpoint_p) *found = 0;
11779   int ix;
11780   int default_match;
11781   struct symtabs_and_lines sals;
11782   struct symtab_and_line sal;
11783   int i;
11784   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
11785
11786   if (arg)
11787     {
11788       sals = decode_line_with_current_source (arg,
11789                                               (DECODE_LINE_FUNFIRSTLINE
11790                                                | DECODE_LINE_LIST_MODE));
11791       default_match = 0;
11792     }
11793   else
11794     {
11795       sals.sals = (struct symtab_and_line *)
11796         xmalloc (sizeof (struct symtab_and_line));
11797       make_cleanup (xfree, sals.sals);
11798       init_sal (&sal);          /* Initialize to zeroes.  */
11799
11800       /* Set sal's line, symtab, pc, and pspace to the values
11801          corresponding to the last call to print_frame_info.  If the
11802          codepoint is not valid, this will set all the fields to 0.  */
11803       get_last_displayed_sal (&sal);
11804       if (sal.symtab == 0)
11805         error (_("No source file specified."));
11806
11807       sals.sals[0] = sal;
11808       sals.nelts = 1;
11809
11810       default_match = 1;
11811     }
11812
11813   /* We don't call resolve_sal_pc here.  That's not as bad as it
11814      seems, because all existing breakpoints typically have both
11815      file/line and pc set.  So, if clear is given file/line, we can
11816      match this to existing breakpoint without obtaining pc at all.
11817
11818      We only support clearing given the address explicitly 
11819      present in breakpoint table.  Say, we've set breakpoint 
11820      at file:line.  There were several PC values for that file:line,
11821      due to optimization, all in one block.
11822
11823      We've picked one PC value.  If "clear" is issued with another
11824      PC corresponding to the same file:line, the breakpoint won't
11825      be cleared.  We probably can still clear the breakpoint, but 
11826      since the other PC value is never presented to user, user
11827      can only find it by guessing, and it does not seem important
11828      to support that.  */
11829
11830   /* For each line spec given, delete bps which correspond to it.  Do
11831      it in two passes, solely to preserve the current behavior that
11832      from_tty is forced true if we delete more than one
11833      breakpoint.  */
11834
11835   found = NULL;
11836   make_cleanup (VEC_cleanup (breakpoint_p), &found);
11837   for (i = 0; i < sals.nelts; i++)
11838     {
11839       int is_abs, sal_name_len;
11840
11841       /* If exact pc given, clear bpts at that pc.
11842          If line given (pc == 0), clear all bpts on specified line.
11843          If defaulting, clear all bpts on default line
11844          or at default pc.
11845
11846          defaulting    sal.pc != 0    tests to do
11847
11848          0              1             pc
11849          1              1             pc _and_ line
11850          0              0             line
11851          1              0             <can't happen> */
11852
11853       sal = sals.sals[i];
11854       is_abs = sal.symtab == NULL ? 1 : IS_ABSOLUTE_PATH (sal.symtab->filename);
11855       sal_name_len = is_abs ? 0 : strlen (sal.symtab->filename);
11856
11857       /* Find all matching breakpoints and add them to 'found'.  */
11858       ALL_BREAKPOINTS (b)
11859         {
11860           int match = 0;
11861           /* Are we going to delete b?  */
11862           if (b->type != bp_none && !is_watchpoint (b))
11863             {
11864               struct bp_location *loc = b->loc;
11865               for (; loc; loc = loc->next)
11866                 {
11867                   /* If the user specified file:line, don't allow a PC
11868                      match.  This matches historical gdb behavior.  */
11869                   int pc_match = (!sal.explicit_line
11870                                   && sal.pc
11871                                   && (loc->pspace == sal.pspace)
11872                                   && (loc->address == sal.pc)
11873                                   && (!section_is_overlay (loc->section)
11874                                       || loc->section == sal.section));
11875                   int line_match = 0;
11876
11877                   if ((default_match || sal.explicit_line)
11878                       && loc->source_file != NULL
11879                       && sal.symtab != NULL
11880                       && sal.pspace == loc->pspace
11881                       && loc->line_number == sal.line)
11882                     {
11883                       if (filename_cmp (loc->source_file,
11884                                         sal.symtab->filename) == 0)
11885                         line_match = 1;
11886                       else if (!IS_ABSOLUTE_PATH (sal.symtab->filename)
11887                                && compare_filenames_for_search (loc->source_file,
11888                                                                 sal.symtab->filename,
11889                                                                 sal_name_len))
11890                         line_match = 1;
11891                     }
11892
11893                   if (pc_match || line_match)
11894                     {
11895                       match = 1;
11896                       break;
11897                     }
11898                 }
11899             }
11900
11901           if (match)
11902             VEC_safe_push(breakpoint_p, found, b);
11903         }
11904     }
11905
11906   /* Now go thru the 'found' chain and delete them.  */
11907   if (VEC_empty(breakpoint_p, found))
11908     {
11909       if (arg)
11910         error (_("No breakpoint at %s."), arg);
11911       else
11912         error (_("No breakpoint at this line."));
11913     }
11914
11915   /* Remove duplicates from the vec.  */
11916   qsort (VEC_address (breakpoint_p, found),
11917          VEC_length (breakpoint_p, found),
11918          sizeof (breakpoint_p),
11919          compare_breakpoints);
11920   prev = VEC_index (breakpoint_p, found, 0);
11921   for (ix = 1; VEC_iterate (breakpoint_p, found, ix, b); ++ix)
11922     {
11923       if (b == prev)
11924         {
11925           VEC_ordered_remove (breakpoint_p, found, ix);
11926           --ix;
11927         }
11928     }
11929
11930   if (VEC_length(breakpoint_p, found) > 1)
11931     from_tty = 1;       /* Always report if deleted more than one.  */
11932   if (from_tty)
11933     {
11934       if (VEC_length(breakpoint_p, found) == 1)
11935         printf_unfiltered (_("Deleted breakpoint "));
11936       else
11937         printf_unfiltered (_("Deleted breakpoints "));
11938     }
11939   breakpoints_changed ();
11940
11941   for (ix = 0; VEC_iterate(breakpoint_p, found, ix, b); ix++)
11942     {
11943       if (from_tty)
11944         printf_unfiltered ("%d ", b->number);
11945       delete_breakpoint (b);
11946     }
11947   if (from_tty)
11948     putchar_unfiltered ('\n');
11949
11950   do_cleanups (cleanups);
11951 }
11952 \f
11953 /* Delete breakpoint in BS if they are `delete' breakpoints and
11954    all breakpoints that are marked for deletion, whether hit or not.
11955    This is called after any breakpoint is hit, or after errors.  */
11956
11957 void
11958 breakpoint_auto_delete (bpstat bs)
11959 {
11960   struct breakpoint *b, *b_tmp;
11961
11962   for (; bs; bs = bs->next)
11963     if (bs->breakpoint_at
11964         && bs->breakpoint_at->disposition == disp_del
11965         && bs->stop)
11966       delete_breakpoint (bs->breakpoint_at);
11967
11968   ALL_BREAKPOINTS_SAFE (b, b_tmp)
11969   {
11970     if (b->disposition == disp_del_at_next_stop)
11971       delete_breakpoint (b);
11972   }
11973 }
11974
11975 /* A comparison function for bp_location AP and BP being interfaced to
11976    qsort.  Sort elements primarily by their ADDRESS (no matter what
11977    does breakpoint_address_is_meaningful say for its OWNER),
11978    secondarily by ordering first bp_permanent OWNERed elements and
11979    terciarily just ensuring the array is sorted stable way despite
11980    qsort being an unstable algorithm.  */
11981
11982 static int
11983 bp_location_compare (const void *ap, const void *bp)
11984 {
11985   struct bp_location *a = *(void **) ap;
11986   struct bp_location *b = *(void **) bp;
11987   /* A and B come from existing breakpoints having non-NULL OWNER.  */
11988   int a_perm = a->owner->enable_state == bp_permanent;
11989   int b_perm = b->owner->enable_state == bp_permanent;
11990
11991   if (a->address != b->address)
11992     return (a->address > b->address) - (a->address < b->address);
11993
11994   /* Sort locations at the same address by their pspace number, keeping
11995      locations of the same inferior (in a multi-inferior environment)
11996      grouped.  */
11997
11998   if (a->pspace->num != b->pspace->num)
11999     return ((a->pspace->num > b->pspace->num)
12000             - (a->pspace->num < b->pspace->num));
12001
12002   /* Sort permanent breakpoints first.  */
12003   if (a_perm != b_perm)
12004     return (a_perm < b_perm) - (a_perm > b_perm);
12005
12006   /* Make the internal GDB representation stable across GDB runs
12007      where A and B memory inside GDB can differ.  Breakpoint locations of
12008      the same type at the same address can be sorted in arbitrary order.  */
12009
12010   if (a->owner->number != b->owner->number)
12011     return ((a->owner->number > b->owner->number)
12012             - (a->owner->number < b->owner->number));
12013
12014   return (a > b) - (a < b);
12015 }
12016
12017 /* Set bp_location_placed_address_before_address_max and
12018    bp_location_shadow_len_after_address_max according to the current
12019    content of the bp_location array.  */
12020
12021 static void
12022 bp_location_target_extensions_update (void)
12023 {
12024   struct bp_location *bl, **blp_tmp;
12025
12026   bp_location_placed_address_before_address_max = 0;
12027   bp_location_shadow_len_after_address_max = 0;
12028
12029   ALL_BP_LOCATIONS (bl, blp_tmp)
12030     {
12031       CORE_ADDR start, end, addr;
12032
12033       if (!bp_location_has_shadow (bl))
12034         continue;
12035
12036       start = bl->target_info.placed_address;
12037       end = start + bl->target_info.shadow_len;
12038
12039       gdb_assert (bl->address >= start);
12040       addr = bl->address - start;
12041       if (addr > bp_location_placed_address_before_address_max)
12042         bp_location_placed_address_before_address_max = addr;
12043
12044       /* Zero SHADOW_LEN would not pass bp_location_has_shadow.  */
12045
12046       gdb_assert (bl->address < end);
12047       addr = end - bl->address;
12048       if (addr > bp_location_shadow_len_after_address_max)
12049         bp_location_shadow_len_after_address_max = addr;
12050     }
12051 }
12052
12053 /* Download tracepoint locations if they haven't been.  */
12054
12055 static void
12056 download_tracepoint_locations (void)
12057 {
12058   struct bp_location *bl, **blp_tmp;
12059   struct cleanup *old_chain;
12060
12061   if (!target_can_download_tracepoint ())
12062     return;
12063
12064   old_chain = save_current_space_and_thread ();
12065
12066   ALL_BP_LOCATIONS (bl, blp_tmp)
12067     {
12068       struct tracepoint *t;
12069
12070       if (!is_tracepoint (bl->owner))
12071         continue;
12072
12073       if ((bl->owner->type == bp_fast_tracepoint
12074            ? !may_insert_fast_tracepoints
12075            : !may_insert_tracepoints))
12076         continue;
12077
12078       /* In tracepoint, locations are _never_ duplicated, so
12079          should_be_inserted is equivalent to
12080          unduplicated_should_be_inserted.  */
12081       if (!should_be_inserted (bl) || bl->inserted)
12082         continue;
12083
12084       switch_to_program_space_and_thread (bl->pspace);
12085
12086       target_download_tracepoint (bl);
12087
12088       bl->inserted = 1;
12089       t = (struct tracepoint *) bl->owner;
12090       t->number_on_target = bl->owner->number;
12091     }
12092
12093   do_cleanups (old_chain);
12094 }
12095
12096 /* Swap the insertion/duplication state between two locations.  */
12097
12098 static void
12099 swap_insertion (struct bp_location *left, struct bp_location *right)
12100 {
12101   const int left_inserted = left->inserted;
12102   const int left_duplicate = left->duplicate;
12103   const int left_needs_update = left->needs_update;
12104   const struct bp_target_info left_target_info = left->target_info;
12105
12106   /* Locations of tracepoints can never be duplicated.  */
12107   if (is_tracepoint (left->owner))
12108     gdb_assert (!left->duplicate);
12109   if (is_tracepoint (right->owner))
12110     gdb_assert (!right->duplicate);
12111
12112   left->inserted = right->inserted;
12113   left->duplicate = right->duplicate;
12114   left->needs_update = right->needs_update;
12115   left->target_info = right->target_info;
12116   right->inserted = left_inserted;
12117   right->duplicate = left_duplicate;
12118   right->needs_update = left_needs_update;
12119   right->target_info = left_target_info;
12120 }
12121
12122 /* Force the re-insertion of the locations at ADDRESS.  This is called
12123    once a new/deleted/modified duplicate location is found and we are evaluating
12124    conditions on the target's side.  Such conditions need to be updated on
12125    the target.  */
12126
12127 static void
12128 force_breakpoint_reinsertion (struct bp_location *bl)
12129 {
12130   struct bp_location **locp = NULL, **loc2p;
12131   struct bp_location *loc;
12132   CORE_ADDR address = 0;
12133   int pspace_num;
12134
12135   address = bl->address;
12136   pspace_num = bl->pspace->num;
12137
12138   /* This is only meaningful if the target is
12139      evaluating conditions and if the user has
12140      opted for condition evaluation on the target's
12141      side.  */
12142   if (gdb_evaluates_breakpoint_condition_p ()
12143       || !target_supports_evaluation_of_breakpoint_conditions ())
12144     return;
12145
12146   /* Flag all breakpoint locations with this address and
12147      the same program space as the location
12148      as "its condition has changed".  We need to
12149      update the conditions on the target's side.  */
12150   ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
12151     {
12152       loc = *loc2p;
12153
12154       if (!is_breakpoint (loc->owner)
12155           || pspace_num != loc->pspace->num)
12156         continue;
12157
12158       /* Flag the location appropriately.  We use a different state to
12159          let everyone know that we already updated the set of locations
12160          with addr bl->address and program space bl->pspace.  This is so
12161          we don't have to keep calling these functions just to mark locations
12162          that have already been marked.  */
12163       loc->condition_changed = condition_updated;
12164
12165       /* Free the agent expression bytecode as well.  We will compute
12166          it later on.  */
12167       if (loc->cond_bytecode)
12168         {
12169           free_agent_expr (loc->cond_bytecode);
12170           loc->cond_bytecode = NULL;
12171         }
12172     }
12173 }
12174
12175 /* If SHOULD_INSERT is false, do not insert any breakpoint locations
12176    into the inferior, only remove already-inserted locations that no
12177    longer should be inserted.  Functions that delete a breakpoint or
12178    breakpoints should pass false, so that deleting a breakpoint
12179    doesn't have the side effect of inserting the locations of other
12180    breakpoints that are marked not-inserted, but should_be_inserted
12181    returns true on them.
12182
12183    This behaviour is useful is situations close to tear-down -- e.g.,
12184    after an exec, while the target still has execution, but breakpoint
12185    shadows of the previous executable image should *NOT* be restored
12186    to the new image; or before detaching, where the target still has
12187    execution and wants to delete breakpoints from GDB's lists, and all
12188    breakpoints had already been removed from the inferior.  */
12189
12190 static void
12191 update_global_location_list (int should_insert)
12192 {
12193   struct breakpoint *b;
12194   struct bp_location **locp, *loc;
12195   struct cleanup *cleanups;
12196   /* Last breakpoint location address that was marked for update.  */
12197   CORE_ADDR last_addr = 0;
12198   /* Last breakpoint location program space that was marked for update.  */
12199   int last_pspace_num = -1;
12200
12201   /* Used in the duplicates detection below.  When iterating over all
12202      bp_locations, points to the first bp_location of a given address.
12203      Breakpoints and watchpoints of different types are never
12204      duplicates of each other.  Keep one pointer for each type of
12205      breakpoint/watchpoint, so we only need to loop over all locations
12206      once.  */
12207   struct bp_location *bp_loc_first;  /* breakpoint */
12208   struct bp_location *wp_loc_first;  /* hardware watchpoint */
12209   struct bp_location *awp_loc_first; /* access watchpoint */
12210   struct bp_location *rwp_loc_first; /* read watchpoint */
12211
12212   /* Saved former bp_location array which we compare against the newly
12213      built bp_location from the current state of ALL_BREAKPOINTS.  */
12214   struct bp_location **old_location, **old_locp;
12215   unsigned old_location_count;
12216
12217   old_location = bp_location;
12218   old_location_count = bp_location_count;
12219   bp_location = NULL;
12220   bp_location_count = 0;
12221   cleanups = make_cleanup (xfree, old_location);
12222
12223   ALL_BREAKPOINTS (b)
12224     for (loc = b->loc; loc; loc = loc->next)
12225       bp_location_count++;
12226
12227   bp_location = xmalloc (sizeof (*bp_location) * bp_location_count);
12228   locp = bp_location;
12229   ALL_BREAKPOINTS (b)
12230     for (loc = b->loc; loc; loc = loc->next)
12231       *locp++ = loc;
12232   qsort (bp_location, bp_location_count, sizeof (*bp_location),
12233          bp_location_compare);
12234
12235   bp_location_target_extensions_update ();
12236
12237   /* Identify bp_location instances that are no longer present in the
12238      new list, and therefore should be freed.  Note that it's not
12239      necessary that those locations should be removed from inferior --
12240      if there's another location at the same address (previously
12241      marked as duplicate), we don't need to remove/insert the
12242      location.
12243      
12244      LOCP is kept in sync with OLD_LOCP, each pointing to the current
12245      and former bp_location array state respectively.  */
12246
12247   locp = bp_location;
12248   for (old_locp = old_location; old_locp < old_location + old_location_count;
12249        old_locp++)
12250     {
12251       struct bp_location *old_loc = *old_locp;
12252       struct bp_location **loc2p;
12253
12254       /* Tells if 'old_loc' is found among the new locations.  If
12255          not, we have to free it.  */
12256       int found_object = 0;
12257       /* Tells if the location should remain inserted in the target.  */
12258       int keep_in_target = 0;
12259       int removed = 0;
12260
12261       /* Skip LOCP entries which will definitely never be needed.
12262          Stop either at or being the one matching OLD_LOC.  */
12263       while (locp < bp_location + bp_location_count
12264              && (*locp)->address < old_loc->address)
12265         locp++;
12266
12267       for (loc2p = locp;
12268            (loc2p < bp_location + bp_location_count
12269             && (*loc2p)->address == old_loc->address);
12270            loc2p++)
12271         {
12272           /* Check if this is a new/duplicated location or a duplicated
12273              location that had its condition modified.  If so, we want to send
12274              its condition to the target if evaluation of conditions is taking
12275              place there.  */
12276           if ((*loc2p)->condition_changed == condition_modified
12277               && (last_addr != old_loc->address
12278                   || last_pspace_num != old_loc->pspace->num))
12279             {
12280               force_breakpoint_reinsertion (*loc2p);
12281               last_pspace_num = old_loc->pspace->num;
12282             }
12283
12284           if (*loc2p == old_loc)
12285             found_object = 1;
12286         }
12287
12288       /* We have already handled this address, update it so that we don't
12289          have to go through updates again.  */
12290       last_addr = old_loc->address;
12291
12292       /* Target-side condition evaluation: Handle deleted locations.  */
12293       if (!found_object)
12294         force_breakpoint_reinsertion (old_loc);
12295
12296       /* If this location is no longer present, and inserted, look if
12297          there's maybe a new location at the same address.  If so,
12298          mark that one inserted, and don't remove this one.  This is
12299          needed so that we don't have a time window where a breakpoint
12300          at certain location is not inserted.  */
12301
12302       if (old_loc->inserted)
12303         {
12304           /* If the location is inserted now, we might have to remove
12305              it.  */
12306
12307           if (found_object && should_be_inserted (old_loc))
12308             {
12309               /* The location is still present in the location list,
12310                  and still should be inserted.  Don't do anything.  */
12311               keep_in_target = 1;
12312             }
12313           else
12314             {
12315               /* This location still exists, but it won't be kept in the
12316                  target since it may have been disabled.  We proceed to
12317                  remove its target-side condition.  */
12318
12319               /* The location is either no longer present, or got
12320                  disabled.  See if there's another location at the
12321                  same address, in which case we don't need to remove
12322                  this one from the target.  */
12323
12324               /* OLD_LOC comes from existing struct breakpoint.  */
12325               if (breakpoint_address_is_meaningful (old_loc->owner))
12326                 {
12327                   for (loc2p = locp;
12328                        (loc2p < bp_location + bp_location_count
12329                         && (*loc2p)->address == old_loc->address);
12330                        loc2p++)
12331                     {
12332                       struct bp_location *loc2 = *loc2p;
12333
12334                       if (breakpoint_locations_match (loc2, old_loc))
12335                         {
12336                           /* Read watchpoint locations are switched to
12337                              access watchpoints, if the former are not
12338                              supported, but the latter are.  */
12339                           if (is_hardware_watchpoint (old_loc->owner))
12340                             {
12341                               gdb_assert (is_hardware_watchpoint (loc2->owner));
12342                               loc2->watchpoint_type = old_loc->watchpoint_type;
12343                             }
12344
12345                           /* loc2 is a duplicated location. We need to check
12346                              if it should be inserted in case it will be
12347                              unduplicated.  */
12348                           if (loc2 != old_loc
12349                               && unduplicated_should_be_inserted (loc2))
12350                             {
12351                               swap_insertion (old_loc, loc2);
12352                               keep_in_target = 1;
12353                               break;
12354                             }
12355                         }
12356                     }
12357                 }
12358             }
12359
12360           if (!keep_in_target)
12361             {
12362               if (remove_breakpoint (old_loc, mark_uninserted))
12363                 {
12364                   /* This is just about all we can do.  We could keep
12365                      this location on the global list, and try to
12366                      remove it next time, but there's no particular
12367                      reason why we will succeed next time.
12368                      
12369                      Note that at this point, old_loc->owner is still
12370                      valid, as delete_breakpoint frees the breakpoint
12371                      only after calling us.  */
12372                   printf_filtered (_("warning: Error removing "
12373                                      "breakpoint %d\n"), 
12374                                    old_loc->owner->number);
12375                 }
12376               removed = 1;
12377             }
12378         }
12379
12380       if (!found_object)
12381         {
12382           if (removed && non_stop
12383               && breakpoint_address_is_meaningful (old_loc->owner)
12384               && !is_hardware_watchpoint (old_loc->owner))
12385             {
12386               /* This location was removed from the target.  In
12387                  non-stop mode, a race condition is possible where
12388                  we've removed a breakpoint, but stop events for that
12389                  breakpoint are already queued and will arrive later.
12390                  We apply an heuristic to be able to distinguish such
12391                  SIGTRAPs from other random SIGTRAPs: we keep this
12392                  breakpoint location for a bit, and will retire it
12393                  after we see some number of events.  The theory here
12394                  is that reporting of events should, "on the average",
12395                  be fair, so after a while we'll see events from all
12396                  threads that have anything of interest, and no longer
12397                  need to keep this breakpoint location around.  We
12398                  don't hold locations forever so to reduce chances of
12399                  mistaking a non-breakpoint SIGTRAP for a breakpoint
12400                  SIGTRAP.
12401
12402                  The heuristic failing can be disastrous on
12403                  decr_pc_after_break targets.
12404
12405                  On decr_pc_after_break targets, like e.g., x86-linux,
12406                  if we fail to recognize a late breakpoint SIGTRAP,
12407                  because events_till_retirement has reached 0 too
12408                  soon, we'll fail to do the PC adjustment, and report
12409                  a random SIGTRAP to the user.  When the user resumes
12410                  the inferior, it will most likely immediately crash
12411                  with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12412                  corrupted, because of being resumed e.g., in the
12413                  middle of a multi-byte instruction, or skipped a
12414                  one-byte instruction.  This was actually seen happen
12415                  on native x86-linux, and should be less rare on
12416                  targets that do not support new thread events, like
12417                  remote, due to the heuristic depending on
12418                  thread_count.
12419
12420                  Mistaking a random SIGTRAP for a breakpoint trap
12421                  causes similar symptoms (PC adjustment applied when
12422                  it shouldn't), but then again, playing with SIGTRAPs
12423                  behind the debugger's back is asking for trouble.
12424
12425                  Since hardware watchpoint traps are always
12426                  distinguishable from other traps, so we don't need to
12427                  apply keep hardware watchpoint moribund locations
12428                  around.  We simply always ignore hardware watchpoint
12429                  traps we can no longer explain.  */
12430
12431               old_loc->events_till_retirement = 3 * (thread_count () + 1);
12432               old_loc->owner = NULL;
12433
12434               VEC_safe_push (bp_location_p, moribund_locations, old_loc);
12435             }
12436           else
12437             {
12438               old_loc->owner = NULL;
12439               decref_bp_location (&old_loc);
12440             }
12441         }
12442     }
12443
12444   /* Rescan breakpoints at the same address and section, marking the
12445      first one as "first" and any others as "duplicates".  This is so
12446      that the bpt instruction is only inserted once.  If we have a
12447      permanent breakpoint at the same place as BPT, make that one the
12448      official one, and the rest as duplicates.  Permanent breakpoints
12449      are sorted first for the same address.
12450
12451      Do the same for hardware watchpoints, but also considering the
12452      watchpoint's type (regular/access/read) and length.  */
12453
12454   bp_loc_first = NULL;
12455   wp_loc_first = NULL;
12456   awp_loc_first = NULL;
12457   rwp_loc_first = NULL;
12458   ALL_BP_LOCATIONS (loc, locp)
12459     {
12460       /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12461          non-NULL.  */
12462       struct bp_location **loc_first_p;
12463       b = loc->owner;
12464
12465       if (!unduplicated_should_be_inserted (loc)
12466           || !breakpoint_address_is_meaningful (b)
12467           /* Don't detect duplicate for tracepoint locations because they are
12468            never duplicated.  See the comments in field `duplicate' of
12469            `struct bp_location'.  */
12470           || is_tracepoint (b))
12471         {
12472           /* Clear the condition modification flag.  */
12473           loc->condition_changed = condition_unchanged;
12474           continue;
12475         }
12476
12477       /* Permanent breakpoint should always be inserted.  */
12478       if (b->enable_state == bp_permanent && ! loc->inserted)
12479         internal_error (__FILE__, __LINE__,
12480                         _("allegedly permanent breakpoint is not "
12481                         "actually inserted"));
12482
12483       if (b->type == bp_hardware_watchpoint)
12484         loc_first_p = &wp_loc_first;
12485       else if (b->type == bp_read_watchpoint)
12486         loc_first_p = &rwp_loc_first;
12487       else if (b->type == bp_access_watchpoint)
12488         loc_first_p = &awp_loc_first;
12489       else
12490         loc_first_p = &bp_loc_first;
12491
12492       if (*loc_first_p == NULL
12493           || (overlay_debugging && loc->section != (*loc_first_p)->section)
12494           || !breakpoint_locations_match (loc, *loc_first_p))
12495         {
12496           *loc_first_p = loc;
12497           loc->duplicate = 0;
12498
12499           if (is_breakpoint (loc->owner) && loc->condition_changed)
12500             {
12501               loc->needs_update = 1;
12502               /* Clear the condition modification flag.  */
12503               loc->condition_changed = condition_unchanged;
12504             }
12505           continue;
12506         }
12507
12508
12509       /* This and the above ensure the invariant that the first location
12510          is not duplicated, and is the inserted one.
12511          All following are marked as duplicated, and are not inserted.  */
12512       if (loc->inserted)
12513         swap_insertion (loc, *loc_first_p);
12514       loc->duplicate = 1;
12515
12516       /* Clear the condition modification flag.  */
12517       loc->condition_changed = condition_unchanged;
12518
12519       if ((*loc_first_p)->owner->enable_state == bp_permanent && loc->inserted
12520           && b->enable_state != bp_permanent)
12521         internal_error (__FILE__, __LINE__,
12522                         _("another breakpoint was inserted on top of "
12523                         "a permanent breakpoint"));
12524     }
12525
12526   if (breakpoints_always_inserted_mode ()
12527       && (have_live_inferiors ()
12528           || (gdbarch_has_global_breakpoints (target_gdbarch))))
12529     {
12530       if (should_insert)
12531         insert_breakpoint_locations ();
12532       else
12533         {
12534           /* Though should_insert is false, we may need to update conditions
12535              on the target's side if it is evaluating such conditions.  We
12536              only update conditions for locations that are marked
12537              "needs_update".  */
12538           update_inserted_breakpoint_locations ();
12539         }
12540     }
12541
12542   if (should_insert)
12543     download_tracepoint_locations ();
12544
12545   do_cleanups (cleanups);
12546 }
12547
12548 void
12549 breakpoint_retire_moribund (void)
12550 {
12551   struct bp_location *loc;
12552   int ix;
12553
12554   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
12555     if (--(loc->events_till_retirement) == 0)
12556       {
12557         decref_bp_location (&loc);
12558         VEC_unordered_remove (bp_location_p, moribund_locations, ix);
12559         --ix;
12560       }
12561 }
12562
12563 static void
12564 update_global_location_list_nothrow (int inserting)
12565 {
12566   volatile struct gdb_exception e;
12567
12568   TRY_CATCH (e, RETURN_MASK_ERROR)
12569     update_global_location_list (inserting);
12570 }
12571
12572 /* Clear BKP from a BPS.  */
12573
12574 static void
12575 bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12576 {
12577   bpstat bs;
12578
12579   for (bs = bps; bs; bs = bs->next)
12580     if (bs->breakpoint_at == bpt)
12581       {
12582         bs->breakpoint_at = NULL;
12583         bs->old_val = NULL;
12584         /* bs->commands will be freed later.  */
12585       }
12586 }
12587
12588 /* Callback for iterate_over_threads.  */
12589 static int
12590 bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12591 {
12592   struct breakpoint *bpt = data;
12593
12594   bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12595   return 0;
12596 }
12597
12598 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12599    callbacks.  */
12600
12601 static void
12602 say_where (struct breakpoint *b)
12603 {
12604   struct ui_out *uiout = current_uiout;
12605   struct value_print_options opts;
12606
12607   get_user_print_options (&opts);
12608
12609   /* i18n: cagney/2005-02-11: Below needs to be merged into a
12610      single string.  */
12611   if (b->loc == NULL)
12612     {
12613       printf_filtered (_(" (%s) pending."), b->addr_string);
12614     }
12615   else
12616     {
12617       if (opts.addressprint || b->loc->source_file == NULL)
12618         {
12619           printf_filtered (" at ");
12620           fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
12621                           gdb_stdout);
12622         }
12623       if (b->loc->source_file)
12624         {
12625           /* If there is a single location, we can print the location
12626              more nicely.  */
12627           if (b->loc->next == NULL)
12628             printf_filtered (": file %s, line %d.",
12629                              b->loc->source_file, b->loc->line_number);
12630           else
12631             /* This is not ideal, but each location may have a
12632                different file name, and this at least reflects the
12633                real situation somewhat.  */
12634             printf_filtered (": %s.", b->addr_string);
12635         }
12636
12637       if (b->loc->next)
12638         {
12639           struct bp_location *loc = b->loc;
12640           int n = 0;
12641           for (; loc; loc = loc->next)
12642             ++n;
12643           printf_filtered (" (%d locations)", n);
12644         }
12645     }
12646 }
12647
12648 /* Default bp_location_ops methods.  */
12649
12650 static void
12651 bp_location_dtor (struct bp_location *self)
12652 {
12653   xfree (self->cond);
12654   if (self->cond_bytecode)
12655     free_agent_expr (self->cond_bytecode);
12656   xfree (self->function_name);
12657   xfree (self->source_file);
12658 }
12659
12660 static const struct bp_location_ops bp_location_ops =
12661 {
12662   bp_location_dtor
12663 };
12664
12665 /* Default breakpoint_ops methods all breakpoint_ops ultimately
12666    inherit from.  */
12667
12668 static void
12669 base_breakpoint_dtor (struct breakpoint *self)
12670 {
12671   decref_counted_command_line (&self->commands);
12672   xfree (self->cond_string);
12673   xfree (self->addr_string);
12674   xfree (self->filter);
12675   xfree (self->addr_string_range_end);
12676 }
12677
12678 static struct bp_location *
12679 base_breakpoint_allocate_location (struct breakpoint *self)
12680 {
12681   struct bp_location *loc;
12682
12683   loc = XNEW (struct bp_location);
12684   init_bp_location (loc, &bp_location_ops, self);
12685   return loc;
12686 }
12687
12688 static void
12689 base_breakpoint_re_set (struct breakpoint *b)
12690 {
12691   /* Nothing to re-set. */
12692 }
12693
12694 #define internal_error_pure_virtual_called() \
12695   gdb_assert_not_reached ("pure virtual function called")
12696
12697 static int
12698 base_breakpoint_insert_location (struct bp_location *bl)
12699 {
12700   internal_error_pure_virtual_called ();
12701 }
12702
12703 static int
12704 base_breakpoint_remove_location (struct bp_location *bl)
12705 {
12706   internal_error_pure_virtual_called ();
12707 }
12708
12709 static int
12710 base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12711                                 struct address_space *aspace,
12712                                 CORE_ADDR bp_addr,
12713                                 const struct target_waitstatus *ws)
12714 {
12715   internal_error_pure_virtual_called ();
12716 }
12717
12718 static void
12719 base_breakpoint_check_status (bpstat bs)
12720 {
12721   /* Always stop.   */
12722 }
12723
12724 /* A "works_in_software_mode" breakpoint_ops method that just internal
12725    errors.  */
12726
12727 static int
12728 base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12729 {
12730   internal_error_pure_virtual_called ();
12731 }
12732
12733 /* A "resources_needed" breakpoint_ops method that just internal
12734    errors.  */
12735
12736 static int
12737 base_breakpoint_resources_needed (const struct bp_location *bl)
12738 {
12739   internal_error_pure_virtual_called ();
12740 }
12741
12742 static enum print_stop_action
12743 base_breakpoint_print_it (bpstat bs)
12744 {
12745   internal_error_pure_virtual_called ();
12746 }
12747
12748 static void
12749 base_breakpoint_print_one_detail (const struct breakpoint *self,
12750                                   struct ui_out *uiout)
12751 {
12752   /* nothing */
12753 }
12754
12755 static void
12756 base_breakpoint_print_mention (struct breakpoint *b)
12757 {
12758   internal_error_pure_virtual_called ();
12759 }
12760
12761 static void
12762 base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12763 {
12764   internal_error_pure_virtual_called ();
12765 }
12766
12767 static void
12768 base_breakpoint_create_sals_from_address (char **arg,
12769                                           struct linespec_result *canonical,
12770                                           enum bptype type_wanted,
12771                                           char *addr_start,
12772                                           char **copy_arg)
12773 {
12774   internal_error_pure_virtual_called ();
12775 }
12776
12777 static void
12778 base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12779                                         struct linespec_result *c,
12780                                         struct linespec_sals *lsal,
12781                                         char *cond_string,
12782                                         char *extra_string,
12783                                         enum bptype type_wanted,
12784                                         enum bpdisp disposition,
12785                                         int thread,
12786                                         int task, int ignore_count,
12787                                         const struct breakpoint_ops *o,
12788                                         int from_tty, int enabled,
12789                                         int internal, unsigned flags)
12790 {
12791   internal_error_pure_virtual_called ();
12792 }
12793
12794 static void
12795 base_breakpoint_decode_linespec (struct breakpoint *b, char **s,
12796                                  struct symtabs_and_lines *sals)
12797 {
12798   internal_error_pure_virtual_called ();
12799 }
12800
12801 static struct breakpoint_ops base_breakpoint_ops =
12802 {
12803   base_breakpoint_dtor,
12804   base_breakpoint_allocate_location,
12805   base_breakpoint_re_set,
12806   base_breakpoint_insert_location,
12807   base_breakpoint_remove_location,
12808   base_breakpoint_breakpoint_hit,
12809   base_breakpoint_check_status,
12810   base_breakpoint_resources_needed,
12811   base_breakpoint_works_in_software_mode,
12812   base_breakpoint_print_it,
12813   NULL,
12814   base_breakpoint_print_one_detail,
12815   base_breakpoint_print_mention,
12816   base_breakpoint_print_recreate,
12817   base_breakpoint_create_sals_from_address,
12818   base_breakpoint_create_breakpoints_sal,
12819   base_breakpoint_decode_linespec,
12820 };
12821
12822 /* Default breakpoint_ops methods.  */
12823
12824 static void
12825 bkpt_re_set (struct breakpoint *b)
12826 {
12827   /* FIXME: is this still reachable?  */
12828   if (b->addr_string == NULL)
12829     {
12830       /* Anything without a string can't be re-set.  */
12831       delete_breakpoint (b);
12832       return;
12833     }
12834
12835   breakpoint_re_set_default (b);
12836 }
12837
12838 static int
12839 bkpt_insert_location (struct bp_location *bl)
12840 {
12841   if (bl->loc_type == bp_loc_hardware_breakpoint)
12842     return target_insert_hw_breakpoint (bl->gdbarch,
12843                                         &bl->target_info);
12844   else
12845     return target_insert_breakpoint (bl->gdbarch,
12846                                      &bl->target_info);
12847 }
12848
12849 static int
12850 bkpt_remove_location (struct bp_location *bl)
12851 {
12852   if (bl->loc_type == bp_loc_hardware_breakpoint)
12853     return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
12854   else
12855     return target_remove_breakpoint (bl->gdbarch, &bl->target_info);
12856 }
12857
12858 static int
12859 bkpt_breakpoint_hit (const struct bp_location *bl,
12860                      struct address_space *aspace, CORE_ADDR bp_addr,
12861                      const struct target_waitstatus *ws)
12862 {
12863   struct breakpoint *b = bl->owner;
12864
12865   if (ws->kind != TARGET_WAITKIND_STOPPED
12866       || ws->value.sig != GDB_SIGNAL_TRAP)
12867     return 0;
12868
12869   if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
12870                                  aspace, bp_addr))
12871     return 0;
12872
12873   if (overlay_debugging         /* unmapped overlay section */
12874       && section_is_overlay (bl->section)
12875       && !section_is_mapped (bl->section))
12876     return 0;
12877
12878   return 1;
12879 }
12880
12881 static int
12882 bkpt_resources_needed (const struct bp_location *bl)
12883 {
12884   gdb_assert (bl->owner->type == bp_hardware_breakpoint);
12885
12886   return 1;
12887 }
12888
12889 static enum print_stop_action
12890 bkpt_print_it (bpstat bs)
12891 {
12892   struct breakpoint *b;
12893   const struct bp_location *bl;
12894   int bp_temp;
12895   struct ui_out *uiout = current_uiout;
12896
12897   gdb_assert (bs->bp_location_at != NULL);
12898
12899   bl = bs->bp_location_at;
12900   b = bs->breakpoint_at;
12901
12902   bp_temp = b->disposition == disp_del;
12903   if (bl->address != bl->requested_address)
12904     breakpoint_adjustment_warning (bl->requested_address,
12905                                    bl->address,
12906                                    b->number, 1);
12907   annotate_breakpoint (b->number);
12908   if (bp_temp)
12909     ui_out_text (uiout, "\nTemporary breakpoint ");
12910   else
12911     ui_out_text (uiout, "\nBreakpoint ");
12912   if (ui_out_is_mi_like_p (uiout))
12913     {
12914       ui_out_field_string (uiout, "reason",
12915                            async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
12916       ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
12917     }
12918   ui_out_field_int (uiout, "bkptno", b->number);
12919   ui_out_text (uiout, ", ");
12920
12921   return PRINT_SRC_AND_LOC;
12922 }
12923
12924 static void
12925 bkpt_print_mention (struct breakpoint *b)
12926 {
12927   if (ui_out_is_mi_like_p (current_uiout))
12928     return;
12929
12930   switch (b->type)
12931     {
12932     case bp_breakpoint:
12933     case bp_gnu_ifunc_resolver:
12934       if (b->disposition == disp_del)
12935         printf_filtered (_("Temporary breakpoint"));
12936       else
12937         printf_filtered (_("Breakpoint"));
12938       printf_filtered (_(" %d"), b->number);
12939       if (b->type == bp_gnu_ifunc_resolver)
12940         printf_filtered (_(" at gnu-indirect-function resolver"));
12941       break;
12942     case bp_hardware_breakpoint:
12943       printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
12944       break;
12945     case bp_dprintf:
12946       printf_filtered (_("Dprintf %d"), b->number);
12947       break;
12948     }
12949
12950   say_where (b);
12951 }
12952
12953 static void
12954 bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
12955 {
12956   if (tp->type == bp_breakpoint && tp->disposition == disp_del)
12957     fprintf_unfiltered (fp, "tbreak");
12958   else if (tp->type == bp_breakpoint)
12959     fprintf_unfiltered (fp, "break");
12960   else if (tp->type == bp_hardware_breakpoint
12961            && tp->disposition == disp_del)
12962     fprintf_unfiltered (fp, "thbreak");
12963   else if (tp->type == bp_hardware_breakpoint)
12964     fprintf_unfiltered (fp, "hbreak");
12965   else
12966     internal_error (__FILE__, __LINE__,
12967                     _("unhandled breakpoint type %d"), (int) tp->type);
12968
12969   fprintf_unfiltered (fp, " %s", tp->addr_string);
12970   print_recreate_thread (tp, fp);
12971 }
12972
12973 static void
12974 bkpt_create_sals_from_address (char **arg,
12975                                struct linespec_result *canonical,
12976                                enum bptype type_wanted,
12977                                char *addr_start, char **copy_arg)
12978 {
12979   create_sals_from_address_default (arg, canonical, type_wanted,
12980                                     addr_start, copy_arg);
12981 }
12982
12983 static void
12984 bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
12985                              struct linespec_result *canonical,
12986                              struct linespec_sals *lsal,
12987                              char *cond_string,
12988                              char *extra_string,
12989                              enum bptype type_wanted,
12990                              enum bpdisp disposition,
12991                              int thread,
12992                              int task, int ignore_count,
12993                              const struct breakpoint_ops *ops,
12994                              int from_tty, int enabled,
12995                              int internal, unsigned flags)
12996 {
12997   create_breakpoints_sal_default (gdbarch, canonical, lsal,
12998                                   cond_string, extra_string,
12999                                   type_wanted,
13000                                   disposition, thread, task,
13001                                   ignore_count, ops, from_tty,
13002                                   enabled, internal, flags);
13003 }
13004
13005 static void
13006 bkpt_decode_linespec (struct breakpoint *b, char **s,
13007                       struct symtabs_and_lines *sals)
13008 {
13009   decode_linespec_default (b, s, sals);
13010 }
13011
13012 /* Virtual table for internal breakpoints.  */
13013
13014 static void
13015 internal_bkpt_re_set (struct breakpoint *b)
13016 {
13017   switch (b->type)
13018     {
13019       /* Delete overlay event and longjmp master breakpoints; they
13020          will be reset later by breakpoint_re_set.  */
13021     case bp_overlay_event:
13022     case bp_longjmp_master:
13023     case bp_std_terminate_master:
13024     case bp_exception_master:
13025       delete_breakpoint (b);
13026       break;
13027
13028       /* This breakpoint is special, it's set up when the inferior
13029          starts and we really don't want to touch it.  */
13030     case bp_shlib_event:
13031
13032       /* Like bp_shlib_event, this breakpoint type is special.  Once
13033          it is set up, we do not want to touch it.  */
13034     case bp_thread_event:
13035       break;
13036     }
13037 }
13038
13039 static void
13040 internal_bkpt_check_status (bpstat bs)
13041 {
13042   if (bs->breakpoint_at->type == bp_shlib_event)
13043     {
13044       /* If requested, stop when the dynamic linker notifies GDB of
13045          events.  This allows the user to get control and place
13046          breakpoints in initializer routines for dynamically loaded
13047          objects (among other things).  */
13048       bs->stop = stop_on_solib_events;
13049       bs->print = stop_on_solib_events;
13050     }
13051   else
13052     bs->stop = 0;
13053 }
13054
13055 static enum print_stop_action
13056 internal_bkpt_print_it (bpstat bs)
13057 {
13058   struct ui_out *uiout = current_uiout;
13059   struct breakpoint *b;
13060
13061   b = bs->breakpoint_at;
13062
13063   switch (b->type)
13064     {
13065     case bp_shlib_event:
13066       /* Did we stop because the user set the stop_on_solib_events
13067          variable?  (If so, we report this as a generic, "Stopped due
13068          to shlib event" message.) */
13069       print_solib_event (0);
13070       break;
13071
13072     case bp_thread_event:
13073       /* Not sure how we will get here.
13074          GDB should not stop for these breakpoints.  */
13075       printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
13076       break;
13077
13078     case bp_overlay_event:
13079       /* By analogy with the thread event, GDB should not stop for these.  */
13080       printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
13081       break;
13082
13083     case bp_longjmp_master:
13084       /* These should never be enabled.  */
13085       printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
13086       break;
13087
13088     case bp_std_terminate_master:
13089       /* These should never be enabled.  */
13090       printf_filtered (_("std::terminate Master Breakpoint: "
13091                          "gdb should not stop!\n"));
13092       break;
13093
13094     case bp_exception_master:
13095       /* These should never be enabled.  */
13096       printf_filtered (_("Exception Master Breakpoint: "
13097                          "gdb should not stop!\n"));
13098       break;
13099     }
13100
13101   return PRINT_NOTHING;
13102 }
13103
13104 static void
13105 internal_bkpt_print_mention (struct breakpoint *b)
13106 {
13107   /* Nothing to mention.  These breakpoints are internal.  */
13108 }
13109
13110 /* Virtual table for momentary breakpoints  */
13111
13112 static void
13113 momentary_bkpt_re_set (struct breakpoint *b)
13114 {
13115   /* Keep temporary breakpoints, which can be encountered when we step
13116      over a dlopen call and SOLIB_ADD is resetting the breakpoints.
13117      Otherwise these should have been blown away via the cleanup chain
13118      or by breakpoint_init_inferior when we rerun the executable.  */
13119 }
13120
13121 static void
13122 momentary_bkpt_check_status (bpstat bs)
13123 {
13124   /* Nothing.  The point of these breakpoints is causing a stop.  */
13125 }
13126
13127 static enum print_stop_action
13128 momentary_bkpt_print_it (bpstat bs)
13129 {
13130   struct ui_out *uiout = current_uiout;
13131
13132   if (ui_out_is_mi_like_p (uiout))
13133     {
13134       struct breakpoint *b = bs->breakpoint_at;
13135
13136       switch (b->type)
13137         {
13138         case bp_finish:
13139           ui_out_field_string
13140             (uiout, "reason",
13141              async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED));
13142           break;
13143
13144         case bp_until:
13145           ui_out_field_string
13146             (uiout, "reason",
13147              async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED));
13148           break;
13149         }
13150     }
13151
13152   return PRINT_UNKNOWN;
13153 }
13154
13155 static void
13156 momentary_bkpt_print_mention (struct breakpoint *b)
13157 {
13158   /* Nothing to mention.  These breakpoints are internal.  */
13159 }
13160
13161 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13162
13163    It gets cleared already on the removal of the first one of such placed
13164    breakpoints.  This is OK as they get all removed altogether.  */
13165
13166 static void
13167 longjmp_bkpt_dtor (struct breakpoint *self)
13168 {
13169   struct thread_info *tp = find_thread_id (self->thread);
13170
13171   if (tp)
13172     tp->initiating_frame = null_frame_id;
13173
13174   momentary_breakpoint_ops.dtor (self);
13175 }
13176
13177 /* Specific methods for probe breakpoints.  */
13178
13179 static int
13180 bkpt_probe_insert_location (struct bp_location *bl)
13181 {
13182   int v = bkpt_insert_location (bl);
13183
13184   if (v == 0)
13185     {
13186       /* The insertion was successful, now let's set the probe's semaphore
13187          if needed.  */
13188       bl->probe->pops->set_semaphore (bl->probe, bl->gdbarch);
13189     }
13190
13191   return v;
13192 }
13193
13194 static int
13195 bkpt_probe_remove_location (struct bp_location *bl)
13196 {
13197   /* Let's clear the semaphore before removing the location.  */
13198   bl->probe->pops->clear_semaphore (bl->probe, bl->gdbarch);
13199
13200   return bkpt_remove_location (bl);
13201 }
13202
13203 static void
13204 bkpt_probe_create_sals_from_address (char **arg,
13205                                      struct linespec_result *canonical,
13206                                      enum bptype type_wanted,
13207                                      char *addr_start, char **copy_arg)
13208 {
13209   struct linespec_sals lsal;
13210
13211   lsal.sals = parse_probes (arg, canonical);
13212
13213   *copy_arg = xstrdup (canonical->addr_string);
13214   lsal.canonical = xstrdup (*copy_arg);
13215
13216   VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13217 }
13218
13219 static void
13220 bkpt_probe_decode_linespec (struct breakpoint *b, char **s,
13221                             struct symtabs_and_lines *sals)
13222 {
13223   *sals = parse_probes (s, NULL);
13224   if (!sals->sals)
13225     error (_("probe not found"));
13226 }
13227
13228 /* The breakpoint_ops structure to be used in tracepoints.  */
13229
13230 static void
13231 tracepoint_re_set (struct breakpoint *b)
13232 {
13233   breakpoint_re_set_default (b);
13234 }
13235
13236 static int
13237 tracepoint_breakpoint_hit (const struct bp_location *bl,
13238                            struct address_space *aspace, CORE_ADDR bp_addr,
13239                            const struct target_waitstatus *ws)
13240 {
13241   /* By definition, the inferior does not report stops at
13242      tracepoints.  */
13243   return 0;
13244 }
13245
13246 static void
13247 tracepoint_print_one_detail (const struct breakpoint *self,
13248                              struct ui_out *uiout)
13249 {
13250   struct tracepoint *tp = (struct tracepoint *) self;
13251   if (tp->static_trace_marker_id)
13252     {
13253       gdb_assert (self->type == bp_static_tracepoint);
13254
13255       ui_out_text (uiout, "\tmarker id is ");
13256       ui_out_field_string (uiout, "static-tracepoint-marker-string-id",
13257                            tp->static_trace_marker_id);
13258       ui_out_text (uiout, "\n");
13259     }
13260 }
13261
13262 static void
13263 tracepoint_print_mention (struct breakpoint *b)
13264 {
13265   if (ui_out_is_mi_like_p (current_uiout))
13266     return;
13267
13268   switch (b->type)
13269     {
13270     case bp_tracepoint:
13271       printf_filtered (_("Tracepoint"));
13272       printf_filtered (_(" %d"), b->number);
13273       break;
13274     case bp_fast_tracepoint:
13275       printf_filtered (_("Fast tracepoint"));
13276       printf_filtered (_(" %d"), b->number);
13277       break;
13278     case bp_static_tracepoint:
13279       printf_filtered (_("Static tracepoint"));
13280       printf_filtered (_(" %d"), b->number);
13281       break;
13282     default:
13283       internal_error (__FILE__, __LINE__,
13284                       _("unhandled tracepoint type %d"), (int) b->type);
13285     }
13286
13287   say_where (b);
13288 }
13289
13290 static void
13291 tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
13292 {
13293   struct tracepoint *tp = (struct tracepoint *) self;
13294
13295   if (self->type == bp_fast_tracepoint)
13296     fprintf_unfiltered (fp, "ftrace");
13297   if (self->type == bp_static_tracepoint)
13298     fprintf_unfiltered (fp, "strace");
13299   else if (self->type == bp_tracepoint)
13300     fprintf_unfiltered (fp, "trace");
13301   else
13302     internal_error (__FILE__, __LINE__,
13303                     _("unhandled tracepoint type %d"), (int) self->type);
13304
13305   fprintf_unfiltered (fp, " %s", self->addr_string);
13306   print_recreate_thread (self, fp);
13307
13308   if (tp->pass_count)
13309     fprintf_unfiltered (fp, "  passcount %d\n", tp->pass_count);
13310 }
13311
13312 static void
13313 tracepoint_create_sals_from_address (char **arg,
13314                                      struct linespec_result *canonical,
13315                                      enum bptype type_wanted,
13316                                      char *addr_start, char **copy_arg)
13317 {
13318   create_sals_from_address_default (arg, canonical, type_wanted,
13319                                     addr_start, copy_arg);
13320 }
13321
13322 static void
13323 tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
13324                                    struct linespec_result *canonical,
13325                                    struct linespec_sals *lsal,
13326                                    char *cond_string,
13327                                    char *extra_string,
13328                                    enum bptype type_wanted,
13329                                    enum bpdisp disposition,
13330                                    int thread,
13331                                    int task, int ignore_count,
13332                                    const struct breakpoint_ops *ops,
13333                                    int from_tty, int enabled,
13334                                    int internal, unsigned flags)
13335 {
13336   create_breakpoints_sal_default (gdbarch, canonical, lsal,
13337                                   cond_string, extra_string,
13338                                   type_wanted,
13339                                   disposition, thread, task,
13340                                   ignore_count, ops, from_tty,
13341                                   enabled, internal, flags);
13342 }
13343
13344 static void
13345 tracepoint_decode_linespec (struct breakpoint *b, char **s,
13346                             struct symtabs_and_lines *sals)
13347 {
13348   decode_linespec_default (b, s, sals);
13349 }
13350
13351 struct breakpoint_ops tracepoint_breakpoint_ops;
13352
13353 /* The breakpoint_ops structure to be use on tracepoints placed in a
13354    static probe.  */
13355
13356 static void
13357 tracepoint_probe_create_sals_from_address (char **arg,
13358                                            struct linespec_result *canonical,
13359                                            enum bptype type_wanted,
13360                                            char *addr_start, char **copy_arg)
13361 {
13362   /* We use the same method for breakpoint on probes.  */
13363   bkpt_probe_create_sals_from_address (arg, canonical, type_wanted,
13364                                        addr_start, copy_arg);
13365 }
13366
13367 static void
13368 tracepoint_probe_decode_linespec (struct breakpoint *b, char **s,
13369                                   struct symtabs_and_lines *sals)
13370 {
13371   /* We use the same method for breakpoint on probes.  */
13372   bkpt_probe_decode_linespec (b, s, sals);
13373 }
13374
13375 static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
13376
13377 /* The breakpoint_ops structure to be used on static tracepoints with
13378    markers (`-m').  */
13379
13380 static void
13381 strace_marker_create_sals_from_address (char **arg,
13382                                         struct linespec_result *canonical,
13383                                         enum bptype type_wanted,
13384                                         char *addr_start, char **copy_arg)
13385 {
13386   struct linespec_sals lsal;
13387
13388   lsal.sals = decode_static_tracepoint_spec (arg);
13389
13390   *copy_arg = savestring (addr_start, *arg - addr_start);
13391
13392   canonical->addr_string = xstrdup (*copy_arg);
13393   lsal.canonical = xstrdup (*copy_arg);
13394   VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13395 }
13396
13397 static void
13398 strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
13399                                       struct linespec_result *canonical,
13400                                       struct linespec_sals *lsal,
13401                                       char *cond_string,
13402                                       char *extra_string,
13403                                       enum bptype type_wanted,
13404                                       enum bpdisp disposition,
13405                                       int thread,
13406                                       int task, int ignore_count,
13407                                       const struct breakpoint_ops *ops,
13408                                       int from_tty, int enabled,
13409                                       int internal, unsigned flags)
13410 {
13411   int i;
13412
13413   /* If the user is creating a static tracepoint by marker id
13414      (strace -m MARKER_ID), then store the sals index, so that
13415      breakpoint_re_set can try to match up which of the newly
13416      found markers corresponds to this one, and, don't try to
13417      expand multiple locations for each sal, given than SALS
13418      already should contain all sals for MARKER_ID.  */
13419
13420   for (i = 0; i < lsal->sals.nelts; ++i)
13421     {
13422       struct symtabs_and_lines expanded;
13423       struct tracepoint *tp;
13424       struct cleanup *old_chain;
13425       char *addr_string;
13426
13427       expanded.nelts = 1;
13428       expanded.sals = &lsal->sals.sals[i];
13429
13430       addr_string = xstrdup (canonical->addr_string);
13431       old_chain = make_cleanup (xfree, addr_string);
13432
13433       tp = XCNEW (struct tracepoint);
13434       init_breakpoint_sal (&tp->base, gdbarch, expanded,
13435                            addr_string, NULL,
13436                            cond_string, extra_string,
13437                            type_wanted, disposition,
13438                            thread, task, ignore_count, ops,
13439                            from_tty, enabled, internal, flags,
13440                            canonical->special_display);
13441       /* Given that its possible to have multiple markers with
13442          the same string id, if the user is creating a static
13443          tracepoint by marker id ("strace -m MARKER_ID"), then
13444          store the sals index, so that breakpoint_re_set can
13445          try to match up which of the newly found markers
13446          corresponds to this one  */
13447       tp->static_trace_marker_id_idx = i;
13448
13449       install_breakpoint (internal, &tp->base, 0);
13450
13451       discard_cleanups (old_chain);
13452     }
13453 }
13454
13455 static void
13456 strace_marker_decode_linespec (struct breakpoint *b, char **s,
13457                                struct symtabs_and_lines *sals)
13458 {
13459   struct tracepoint *tp = (struct tracepoint *) b;
13460
13461   *sals = decode_static_tracepoint_spec (s);
13462   if (sals->nelts > tp->static_trace_marker_id_idx)
13463     {
13464       sals->sals[0] = sals->sals[tp->static_trace_marker_id_idx];
13465       sals->nelts = 1;
13466     }
13467   else
13468     error (_("marker %s not found"), tp->static_trace_marker_id);
13469 }
13470
13471 static struct breakpoint_ops strace_marker_breakpoint_ops;
13472
13473 static int
13474 strace_marker_p (struct breakpoint *b)
13475 {
13476   return b->ops == &strace_marker_breakpoint_ops;
13477 }
13478
13479 /* Delete a breakpoint and clean up all traces of it in the data
13480    structures.  */
13481
13482 void
13483 delete_breakpoint (struct breakpoint *bpt)
13484 {
13485   struct breakpoint *b;
13486
13487   gdb_assert (bpt != NULL);
13488
13489   /* Has this bp already been deleted?  This can happen because
13490      multiple lists can hold pointers to bp's.  bpstat lists are
13491      especial culprits.
13492
13493      One example of this happening is a watchpoint's scope bp.  When
13494      the scope bp triggers, we notice that the watchpoint is out of
13495      scope, and delete it.  We also delete its scope bp.  But the
13496      scope bp is marked "auto-deleting", and is already on a bpstat.
13497      That bpstat is then checked for auto-deleting bp's, which are
13498      deleted.
13499
13500      A real solution to this problem might involve reference counts in
13501      bp's, and/or giving them pointers back to their referencing
13502      bpstat's, and teaching delete_breakpoint to only free a bp's
13503      storage when no more references were extent.  A cheaper bandaid
13504      was chosen.  */
13505   if (bpt->type == bp_none)
13506     return;
13507
13508   /* At least avoid this stale reference until the reference counting
13509      of breakpoints gets resolved.  */
13510   if (bpt->related_breakpoint != bpt)
13511     {
13512       struct breakpoint *related;
13513       struct watchpoint *w;
13514
13515       if (bpt->type == bp_watchpoint_scope)
13516         w = (struct watchpoint *) bpt->related_breakpoint;
13517       else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
13518         w = (struct watchpoint *) bpt;
13519       else
13520         w = NULL;
13521       if (w != NULL)
13522         watchpoint_del_at_next_stop (w);
13523
13524       /* Unlink bpt from the bpt->related_breakpoint ring.  */
13525       for (related = bpt; related->related_breakpoint != bpt;
13526            related = related->related_breakpoint);
13527       related->related_breakpoint = bpt->related_breakpoint;
13528       bpt->related_breakpoint = bpt;
13529     }
13530
13531   /* watch_command_1 creates a watchpoint but only sets its number if
13532      update_watchpoint succeeds in creating its bp_locations.  If there's
13533      a problem in that process, we'll be asked to delete the half-created
13534      watchpoint.  In that case, don't announce the deletion.  */
13535   if (bpt->number)
13536     observer_notify_breakpoint_deleted (bpt);
13537
13538   if (breakpoint_chain == bpt)
13539     breakpoint_chain = bpt->next;
13540
13541   ALL_BREAKPOINTS (b)
13542     if (b->next == bpt)
13543     {
13544       b->next = bpt->next;
13545       break;
13546     }
13547
13548   /* Be sure no bpstat's are pointing at the breakpoint after it's
13549      been freed.  */
13550   /* FIXME, how can we find all bpstat's?  We just check stop_bpstat
13551      in all threads for now.  Note that we cannot just remove bpstats
13552      pointing at bpt from the stop_bpstat list entirely, as breakpoint
13553      commands are associated with the bpstat; if we remove it here,
13554      then the later call to bpstat_do_actions (&stop_bpstat); in
13555      event-top.c won't do anything, and temporary breakpoints with
13556      commands won't work.  */
13557
13558   iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13559
13560   /* Now that breakpoint is removed from breakpoint list, update the
13561      global location list.  This will remove locations that used to
13562      belong to this breakpoint.  Do this before freeing the breakpoint
13563      itself, since remove_breakpoint looks at location's owner.  It
13564      might be better design to have location completely
13565      self-contained, but it's not the case now.  */
13566   update_global_location_list (0);
13567
13568   bpt->ops->dtor (bpt);
13569   /* On the chance that someone will soon try again to delete this
13570      same bp, we mark it as deleted before freeing its storage.  */
13571   bpt->type = bp_none;
13572   xfree (bpt);
13573 }
13574
13575 static void
13576 do_delete_breakpoint_cleanup (void *b)
13577 {
13578   delete_breakpoint (b);
13579 }
13580
13581 struct cleanup *
13582 make_cleanup_delete_breakpoint (struct breakpoint *b)
13583 {
13584   return make_cleanup (do_delete_breakpoint_cleanup, b);
13585 }
13586
13587 /* Iterator function to call a user-provided callback function once
13588    for each of B and its related breakpoints.  */
13589
13590 static void
13591 iterate_over_related_breakpoints (struct breakpoint *b,
13592                                   void (*function) (struct breakpoint *,
13593                                                     void *),
13594                                   void *data)
13595 {
13596   struct breakpoint *related;
13597
13598   related = b;
13599   do
13600     {
13601       struct breakpoint *next;
13602
13603       /* FUNCTION may delete RELATED.  */
13604       next = related->related_breakpoint;
13605
13606       if (next == related)
13607         {
13608           /* RELATED is the last ring entry.  */
13609           function (related, data);
13610
13611           /* FUNCTION may have deleted it, so we'd never reach back to
13612              B.  There's nothing left to do anyway, so just break
13613              out.  */
13614           break;
13615         }
13616       else
13617         function (related, data);
13618
13619       related = next;
13620     }
13621   while (related != b);
13622 }
13623
13624 static void
13625 do_delete_breakpoint (struct breakpoint *b, void *ignore)
13626 {
13627   delete_breakpoint (b);
13628 }
13629
13630 /* A callback for map_breakpoint_numbers that calls
13631    delete_breakpoint.  */
13632
13633 static void
13634 do_map_delete_breakpoint (struct breakpoint *b, void *ignore)
13635 {
13636   iterate_over_related_breakpoints (b, do_delete_breakpoint, NULL);
13637 }
13638
13639 void
13640 delete_command (char *arg, int from_tty)
13641 {
13642   struct breakpoint *b, *b_tmp;
13643
13644   dont_repeat ();
13645
13646   if (arg == 0)
13647     {
13648       int breaks_to_delete = 0;
13649
13650       /* Delete all breakpoints if no argument.  Do not delete
13651          internal breakpoints, these have to be deleted with an
13652          explicit breakpoint number argument.  */
13653       ALL_BREAKPOINTS (b)
13654         if (user_breakpoint_p (b))
13655           {
13656             breaks_to_delete = 1;
13657             break;
13658           }
13659
13660       /* Ask user only if there are some breakpoints to delete.  */
13661       if (!from_tty
13662           || (breaks_to_delete && query (_("Delete all breakpoints? "))))
13663         {
13664           ALL_BREAKPOINTS_SAFE (b, b_tmp)
13665             if (user_breakpoint_p (b))
13666               delete_breakpoint (b);
13667         }
13668     }
13669   else
13670     map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
13671 }
13672
13673 static int
13674 all_locations_are_pending (struct bp_location *loc)
13675 {
13676   for (; loc; loc = loc->next)
13677     if (!loc->shlib_disabled
13678         && !loc->pspace->executing_startup)
13679       return 0;
13680   return 1;
13681 }
13682
13683 /* Subroutine of update_breakpoint_locations to simplify it.
13684    Return non-zero if multiple fns in list LOC have the same name.
13685    Null names are ignored.  */
13686
13687 static int
13688 ambiguous_names_p (struct bp_location *loc)
13689 {
13690   struct bp_location *l;
13691   htab_t htab = htab_create_alloc (13, htab_hash_string,
13692                                    (int (*) (const void *, 
13693                                              const void *)) streq,
13694                                    NULL, xcalloc, xfree);
13695
13696   for (l = loc; l != NULL; l = l->next)
13697     {
13698       const char **slot;
13699       const char *name = l->function_name;
13700
13701       /* Allow for some names to be NULL, ignore them.  */
13702       if (name == NULL)
13703         continue;
13704
13705       slot = (const char **) htab_find_slot (htab, (const void *) name,
13706                                              INSERT);
13707       /* NOTE: We can assume slot != NULL here because xcalloc never
13708          returns NULL.  */
13709       if (*slot != NULL)
13710         {
13711           htab_delete (htab);
13712           return 1;
13713         }
13714       *slot = name;
13715     }
13716
13717   htab_delete (htab);
13718   return 0;
13719 }
13720
13721 /* When symbols change, it probably means the sources changed as well,
13722    and it might mean the static tracepoint markers are no longer at
13723    the same address or line numbers they used to be at last we
13724    checked.  Losing your static tracepoints whenever you rebuild is
13725    undesirable.  This function tries to resync/rematch gdb static
13726    tracepoints with the markers on the target, for static tracepoints
13727    that have not been set by marker id.  Static tracepoint that have
13728    been set by marker id are reset by marker id in breakpoint_re_set.
13729    The heuristic is:
13730
13731    1) For a tracepoint set at a specific address, look for a marker at
13732    the old PC.  If one is found there, assume to be the same marker.
13733    If the name / string id of the marker found is different from the
13734    previous known name, assume that means the user renamed the marker
13735    in the sources, and output a warning.
13736
13737    2) For a tracepoint set at a given line number, look for a marker
13738    at the new address of the old line number.  If one is found there,
13739    assume to be the same marker.  If the name / string id of the
13740    marker found is different from the previous known name, assume that
13741    means the user renamed the marker in the sources, and output a
13742    warning.
13743
13744    3) If a marker is no longer found at the same address or line, it
13745    may mean the marker no longer exists.  But it may also just mean
13746    the code changed a bit.  Maybe the user added a few lines of code
13747    that made the marker move up or down (in line number terms).  Ask
13748    the target for info about the marker with the string id as we knew
13749    it.  If found, update line number and address in the matching
13750    static tracepoint.  This will get confused if there's more than one
13751    marker with the same ID (possible in UST, although unadvised
13752    precisely because it confuses tools).  */
13753
13754 static struct symtab_and_line
13755 update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
13756 {
13757   struct tracepoint *tp = (struct tracepoint *) b;
13758   struct static_tracepoint_marker marker;
13759   CORE_ADDR pc;
13760
13761   pc = sal.pc;
13762   if (sal.line)
13763     find_line_pc (sal.symtab, sal.line, &pc);
13764
13765   if (target_static_tracepoint_marker_at (pc, &marker))
13766     {
13767       if (strcmp (tp->static_trace_marker_id, marker.str_id) != 0)
13768         warning (_("static tracepoint %d changed probed marker from %s to %s"),
13769                  b->number,
13770                  tp->static_trace_marker_id, marker.str_id);
13771
13772       xfree (tp->static_trace_marker_id);
13773       tp->static_trace_marker_id = xstrdup (marker.str_id);
13774       release_static_tracepoint_marker (&marker);
13775
13776       return sal;
13777     }
13778
13779   /* Old marker wasn't found on target at lineno.  Try looking it up
13780      by string ID.  */
13781   if (!sal.explicit_pc
13782       && sal.line != 0
13783       && sal.symtab != NULL
13784       && tp->static_trace_marker_id != NULL)
13785     {
13786       VEC(static_tracepoint_marker_p) *markers;
13787
13788       markers
13789         = target_static_tracepoint_markers_by_strid (tp->static_trace_marker_id);
13790
13791       if (!VEC_empty(static_tracepoint_marker_p, markers))
13792         {
13793           struct symtab_and_line sal2;
13794           struct symbol *sym;
13795           struct static_tracepoint_marker *tpmarker;
13796           struct ui_out *uiout = current_uiout;
13797
13798           tpmarker = VEC_index (static_tracepoint_marker_p, markers, 0);
13799
13800           xfree (tp->static_trace_marker_id);
13801           tp->static_trace_marker_id = xstrdup (tpmarker->str_id);
13802
13803           warning (_("marker for static tracepoint %d (%s) not "
13804                      "found at previous line number"),
13805                    b->number, tp->static_trace_marker_id);
13806
13807           init_sal (&sal2);
13808
13809           sal2.pc = tpmarker->address;
13810
13811           sal2 = find_pc_line (tpmarker->address, 0);
13812           sym = find_pc_sect_function (tpmarker->address, NULL);
13813           ui_out_text (uiout, "Now in ");
13814           if (sym)
13815             {
13816               ui_out_field_string (uiout, "func",
13817                                    SYMBOL_PRINT_NAME (sym));
13818               ui_out_text (uiout, " at ");
13819             }
13820           ui_out_field_string (uiout, "file", sal2.symtab->filename);
13821           ui_out_text (uiout, ":");
13822
13823           if (ui_out_is_mi_like_p (uiout))
13824             {
13825               const char *fullname = symtab_to_fullname (sal2.symtab);
13826
13827               if (fullname)
13828                 ui_out_field_string (uiout, "fullname", fullname);
13829             }
13830
13831           ui_out_field_int (uiout, "line", sal2.line);
13832           ui_out_text (uiout, "\n");
13833
13834           b->loc->line_number = sal2.line;
13835
13836           xfree (b->loc->source_file);
13837           if (sym)
13838             b->loc->source_file = xstrdup (sal2.symtab->filename);
13839           else
13840             b->loc->source_file = NULL;
13841
13842           xfree (b->addr_string);
13843           b->addr_string = xstrprintf ("%s:%d",
13844                                        sal2.symtab->filename,
13845                                        b->loc->line_number);
13846
13847           /* Might be nice to check if function changed, and warn if
13848              so.  */
13849
13850           release_static_tracepoint_marker (tpmarker);
13851         }
13852     }
13853   return sal;
13854 }
13855
13856 /* Returns 1 iff locations A and B are sufficiently same that
13857    we don't need to report breakpoint as changed.  */
13858
13859 static int
13860 locations_are_equal (struct bp_location *a, struct bp_location *b)
13861 {
13862   while (a && b)
13863     {
13864       if (a->address != b->address)
13865         return 0;
13866
13867       if (a->shlib_disabled != b->shlib_disabled)
13868         return 0;
13869
13870       if (a->enabled != b->enabled)
13871         return 0;
13872
13873       a = a->next;
13874       b = b->next;
13875     }
13876
13877   if ((a == NULL) != (b == NULL))
13878     return 0;
13879
13880   return 1;
13881 }
13882
13883 /* Create new breakpoint locations for B (a hardware or software breakpoint)
13884    based on SALS and SALS_END.  If SALS_END.NELTS is not zero, then B is
13885    a ranged breakpoint.  */
13886
13887 void
13888 update_breakpoint_locations (struct breakpoint *b,
13889                              struct symtabs_and_lines sals,
13890                              struct symtabs_and_lines sals_end)
13891 {
13892   int i;
13893   struct bp_location *existing_locations = b->loc;
13894
13895   if (sals_end.nelts != 0 && (sals.nelts != 1 || sals_end.nelts != 1))
13896     {
13897       /* Ranged breakpoints have only one start location and one end
13898          location.  */
13899       b->enable_state = bp_disabled;
13900       update_global_location_list (1);
13901       printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13902                            "multiple locations found\n"),
13903                          b->number);
13904       return;
13905     }
13906
13907   /* If there's no new locations, and all existing locations are
13908      pending, don't do anything.  This optimizes the common case where
13909      all locations are in the same shared library, that was unloaded.
13910      We'd like to retain the location, so that when the library is
13911      loaded again, we don't loose the enabled/disabled status of the
13912      individual locations.  */
13913   if (all_locations_are_pending (existing_locations) && sals.nelts == 0)
13914     return;
13915
13916   b->loc = NULL;
13917
13918   for (i = 0; i < sals.nelts; ++i)
13919     {
13920       struct bp_location *new_loc;
13921
13922       switch_to_program_space_and_thread (sals.sals[i].pspace);
13923
13924       new_loc = add_location_to_breakpoint (b, &(sals.sals[i]));
13925
13926       /* Reparse conditions, they might contain references to the
13927          old symtab.  */
13928       if (b->cond_string != NULL)
13929         {
13930           char *s;
13931           volatile struct gdb_exception e;
13932
13933           s = b->cond_string;
13934           TRY_CATCH (e, RETURN_MASK_ERROR)
13935             {
13936               new_loc->cond = parse_exp_1 (&s, sals.sals[i].pc,
13937                                            block_for_pc (sals.sals[i].pc), 
13938                                            0);
13939             }
13940           if (e.reason < 0)
13941             {
13942               warning (_("failed to reevaluate condition "
13943                          "for breakpoint %d: %s"), 
13944                        b->number, e.message);
13945               new_loc->enabled = 0;
13946             }
13947         }
13948
13949       if (sals_end.nelts)
13950         {
13951           CORE_ADDR end = find_breakpoint_range_end (sals_end.sals[0]);
13952
13953           new_loc->length = end - sals.sals[0].pc + 1;
13954         }
13955     }
13956
13957   /* Update locations of permanent breakpoints.  */
13958   if (b->enable_state == bp_permanent)
13959     make_breakpoint_permanent (b);
13960
13961   /* If possible, carry over 'disable' status from existing
13962      breakpoints.  */
13963   {
13964     struct bp_location *e = existing_locations;
13965     /* If there are multiple breakpoints with the same function name,
13966        e.g. for inline functions, comparing function names won't work.
13967        Instead compare pc addresses; this is just a heuristic as things
13968        may have moved, but in practice it gives the correct answer
13969        often enough until a better solution is found.  */
13970     int have_ambiguous_names = ambiguous_names_p (b->loc);
13971
13972     for (; e; e = e->next)
13973       {
13974         if (!e->enabled && e->function_name)
13975           {
13976             struct bp_location *l = b->loc;
13977             if (have_ambiguous_names)
13978               {
13979                 for (; l; l = l->next)
13980                   if (breakpoint_locations_match (e, l))
13981                     {
13982                       l->enabled = 0;
13983                       break;
13984                     }
13985               }
13986             else
13987               {
13988                 for (; l; l = l->next)
13989                   if (l->function_name
13990                       && strcmp (e->function_name, l->function_name) == 0)
13991                     {
13992                       l->enabled = 0;
13993                       break;
13994                     }
13995               }
13996           }
13997       }
13998   }
13999
14000   if (!locations_are_equal (existing_locations, b->loc))
14001     observer_notify_breakpoint_modified (b);
14002
14003   update_global_location_list (1);
14004 }
14005
14006 /* Find the SaL locations corresponding to the given ADDR_STRING.
14007    On return, FOUND will be 1 if any SaL was found, zero otherwise.  */
14008
14009 static struct symtabs_and_lines
14010 addr_string_to_sals (struct breakpoint *b, char *addr_string, int *found)
14011 {
14012   char *s;
14013   struct symtabs_and_lines sals = {0};
14014   volatile struct gdb_exception e;
14015
14016   gdb_assert (b->ops != NULL);
14017   s = addr_string;
14018
14019   TRY_CATCH (e, RETURN_MASK_ERROR)
14020     {
14021       b->ops->decode_linespec (b, &s, &sals);
14022     }
14023   if (e.reason < 0)
14024     {
14025       int not_found_and_ok = 0;
14026       /* For pending breakpoints, it's expected that parsing will
14027          fail until the right shared library is loaded.  User has
14028          already told to create pending breakpoints and don't need
14029          extra messages.  If breakpoint is in bp_shlib_disabled
14030          state, then user already saw the message about that
14031          breakpoint being disabled, and don't want to see more
14032          errors.  */
14033       if (e.error == NOT_FOUND_ERROR
14034           && (b->condition_not_parsed 
14035               || (b->loc && b->loc->shlib_disabled)
14036               || (b->loc && b->loc->pspace->executing_startup)
14037               || b->enable_state == bp_disabled))
14038         not_found_and_ok = 1;
14039
14040       if (!not_found_and_ok)
14041         {
14042           /* We surely don't want to warn about the same breakpoint
14043              10 times.  One solution, implemented here, is disable
14044              the breakpoint on error.  Another solution would be to
14045              have separate 'warning emitted' flag.  Since this
14046              happens only when a binary has changed, I don't know
14047              which approach is better.  */
14048           b->enable_state = bp_disabled;
14049           throw_exception (e);
14050         }
14051     }
14052
14053   if (e.reason == 0 || e.error != NOT_FOUND_ERROR)
14054     {
14055       int i;
14056
14057       for (i = 0; i < sals.nelts; ++i)
14058         resolve_sal_pc (&sals.sals[i]);
14059       if (b->condition_not_parsed && s && s[0])
14060         {
14061           char *cond_string, *extra_string;
14062           int thread, task;
14063
14064           find_condition_and_thread (s, sals.sals[0].pc,
14065                                      &cond_string, &thread, &task,
14066                                      &extra_string);
14067           if (cond_string)
14068             b->cond_string = cond_string;
14069           b->thread = thread;
14070           b->task = task;
14071           if (extra_string)
14072             b->extra_string = extra_string;
14073           b->condition_not_parsed = 0;
14074         }
14075
14076       if (b->type == bp_static_tracepoint && !strace_marker_p (b))
14077         sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
14078
14079       *found = 1;
14080     }
14081   else
14082     *found = 0;
14083
14084   return sals;
14085 }
14086
14087 /* The default re_set method, for typical hardware or software
14088    breakpoints.  Reevaluate the breakpoint and recreate its
14089    locations.  */
14090
14091 static void
14092 breakpoint_re_set_default (struct breakpoint *b)
14093 {
14094   int found;
14095   struct symtabs_and_lines sals, sals_end;
14096   struct symtabs_and_lines expanded = {0};
14097   struct symtabs_and_lines expanded_end = {0};
14098
14099   sals = addr_string_to_sals (b, b->addr_string, &found);
14100   if (found)
14101     {
14102       make_cleanup (xfree, sals.sals);
14103       expanded = sals;
14104     }
14105
14106   if (b->addr_string_range_end)
14107     {
14108       sals_end = addr_string_to_sals (b, b->addr_string_range_end, &found);
14109       if (found)
14110         {
14111           make_cleanup (xfree, sals_end.sals);
14112           expanded_end = sals_end;
14113         }
14114     }
14115
14116   update_breakpoint_locations (b, expanded, expanded_end);
14117 }
14118
14119 /* Default method for creating SALs from an address string.  It basically
14120    calls parse_breakpoint_sals.  Return 1 for success, zero for failure.  */
14121
14122 static void
14123 create_sals_from_address_default (char **arg,
14124                                   struct linespec_result *canonical,
14125                                   enum bptype type_wanted,
14126                                   char *addr_start, char **copy_arg)
14127 {
14128   parse_breakpoint_sals (arg, canonical);
14129 }
14130
14131 /* Call create_breakpoints_sal for the given arguments.  This is the default
14132    function for the `create_breakpoints_sal' method of
14133    breakpoint_ops.  */
14134
14135 static void
14136 create_breakpoints_sal_default (struct gdbarch *gdbarch,
14137                                 struct linespec_result *canonical,
14138                                 struct linespec_sals *lsal,
14139                                 char *cond_string,
14140                                 char *extra_string,
14141                                 enum bptype type_wanted,
14142                                 enum bpdisp disposition,
14143                                 int thread,
14144                                 int task, int ignore_count,
14145                                 const struct breakpoint_ops *ops,
14146                                 int from_tty, int enabled,
14147                                 int internal, unsigned flags)
14148 {
14149   create_breakpoints_sal (gdbarch, canonical, cond_string,
14150                           extra_string,
14151                           type_wanted, disposition,
14152                           thread, task, ignore_count, ops, from_tty,
14153                           enabled, internal, flags);
14154 }
14155
14156 /* Decode the line represented by S by calling decode_line_full.  This is the
14157    default function for the `decode_linespec' method of breakpoint_ops.  */
14158
14159 static void
14160 decode_linespec_default (struct breakpoint *b, char **s,
14161                          struct symtabs_and_lines *sals)
14162 {
14163   struct linespec_result canonical;
14164
14165   init_linespec_result (&canonical);
14166   decode_line_full (s, DECODE_LINE_FUNFIRSTLINE,
14167                     (struct symtab *) NULL, 0,
14168                     &canonical, multiple_symbols_all,
14169                     b->filter);
14170
14171   /* We should get 0 or 1 resulting SALs.  */
14172   gdb_assert (VEC_length (linespec_sals, canonical.sals) < 2);
14173
14174   if (VEC_length (linespec_sals, canonical.sals) > 0)
14175     {
14176       struct linespec_sals *lsal;
14177
14178       lsal = VEC_index (linespec_sals, canonical.sals, 0);
14179       *sals = lsal->sals;
14180       /* Arrange it so the destructor does not free the
14181          contents.  */
14182       lsal->sals.sals = NULL;
14183     }
14184
14185   destroy_linespec_result (&canonical);
14186 }
14187
14188 /* Prepare the global context for a re-set of breakpoint B.  */
14189
14190 static struct cleanup *
14191 prepare_re_set_context (struct breakpoint *b)
14192 {
14193   struct cleanup *cleanups;
14194
14195   input_radix = b->input_radix;
14196   cleanups = save_current_space_and_thread ();
14197   if (b->pspace != NULL)
14198     switch_to_program_space_and_thread (b->pspace);
14199   set_language (b->language);
14200
14201   return cleanups;
14202 }
14203
14204 /* Reset a breakpoint given it's struct breakpoint * BINT.
14205    The value we return ends up being the return value from catch_errors.
14206    Unused in this case.  */
14207
14208 static int
14209 breakpoint_re_set_one (void *bint)
14210 {
14211   /* Get past catch_errs.  */
14212   struct breakpoint *b = (struct breakpoint *) bint;
14213   struct cleanup *cleanups;
14214
14215   cleanups = prepare_re_set_context (b);
14216   b->ops->re_set (b);
14217   do_cleanups (cleanups);
14218   return 0;
14219 }
14220
14221 /* Re-set all breakpoints after symbols have been re-loaded.  */
14222 void
14223 breakpoint_re_set (void)
14224 {
14225   struct breakpoint *b, *b_tmp;
14226   enum language save_language;
14227   int save_input_radix;
14228   struct cleanup *old_chain;
14229
14230   save_language = current_language->la_language;
14231   save_input_radix = input_radix;
14232   old_chain = save_current_program_space ();
14233
14234   ALL_BREAKPOINTS_SAFE (b, b_tmp)
14235   {
14236     /* Format possible error msg.  */
14237     char *message = xstrprintf ("Error in re-setting breakpoint %d: ",
14238                                 b->number);
14239     struct cleanup *cleanups = make_cleanup (xfree, message);
14240     catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
14241     do_cleanups (cleanups);
14242   }
14243   set_language (save_language);
14244   input_radix = save_input_radix;
14245
14246   jit_breakpoint_re_set ();
14247
14248   do_cleanups (old_chain);
14249
14250   create_overlay_event_breakpoint ();
14251   create_longjmp_master_breakpoint ();
14252   create_std_terminate_master_breakpoint ();
14253   create_exception_master_breakpoint ();
14254
14255   /* While we're at it, reset the skip list too.  */
14256   skip_re_set ();
14257 }
14258 \f
14259 /* Reset the thread number of this breakpoint:
14260
14261    - If the breakpoint is for all threads, leave it as-is.
14262    - Else, reset it to the current thread for inferior_ptid.  */
14263 void
14264 breakpoint_re_set_thread (struct breakpoint *b)
14265 {
14266   if (b->thread != -1)
14267     {
14268       if (in_thread_list (inferior_ptid))
14269         b->thread = pid_to_thread_id (inferior_ptid);
14270
14271       /* We're being called after following a fork.  The new fork is
14272          selected as current, and unless this was a vfork will have a
14273          different program space from the original thread.  Reset that
14274          as well.  */
14275       b->loc->pspace = current_program_space;
14276     }
14277 }
14278
14279 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14280    If from_tty is nonzero, it prints a message to that effect,
14281    which ends with a period (no newline).  */
14282
14283 void
14284 set_ignore_count (int bptnum, int count, int from_tty)
14285 {
14286   struct breakpoint *b;
14287
14288   if (count < 0)
14289     count = 0;
14290
14291   ALL_BREAKPOINTS (b)
14292     if (b->number == bptnum)
14293     {
14294       if (is_tracepoint (b))
14295         {
14296           if (from_tty && count != 0)
14297             printf_filtered (_("Ignore count ignored for tracepoint %d."),
14298                              bptnum);
14299           return;
14300         }
14301       
14302       b->ignore_count = count;
14303       if (from_tty)
14304         {
14305           if (count == 0)
14306             printf_filtered (_("Will stop next time "
14307                                "breakpoint %d is reached."),
14308                              bptnum);
14309           else if (count == 1)
14310             printf_filtered (_("Will ignore next crossing of breakpoint %d."),
14311                              bptnum);
14312           else
14313             printf_filtered (_("Will ignore next %d "
14314                                "crossings of breakpoint %d."),
14315                              count, bptnum);
14316         }
14317       breakpoints_changed ();
14318       observer_notify_breakpoint_modified (b);
14319       return;
14320     }
14321
14322   error (_("No breakpoint number %d."), bptnum);
14323 }
14324
14325 /* Command to set ignore-count of breakpoint N to COUNT.  */
14326
14327 static void
14328 ignore_command (char *args, int from_tty)
14329 {
14330   char *p = args;
14331   int num;
14332
14333   if (p == 0)
14334     error_no_arg (_("a breakpoint number"));
14335
14336   num = get_number (&p);
14337   if (num == 0)
14338     error (_("bad breakpoint number: '%s'"), args);
14339   if (*p == 0)
14340     error (_("Second argument (specified ignore-count) is missing."));
14341
14342   set_ignore_count (num,
14343                     longest_to_int (value_as_long (parse_and_eval (p))),
14344                     from_tty);
14345   if (from_tty)
14346     printf_filtered ("\n");
14347 }
14348 \f
14349 /* Call FUNCTION on each of the breakpoints
14350    whose numbers are given in ARGS.  */
14351
14352 static void
14353 map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *,
14354                                                       void *),
14355                         void *data)
14356 {
14357   int num;
14358   struct breakpoint *b, *tmp;
14359   int match;
14360   struct get_number_or_range_state state;
14361
14362   if (args == 0)
14363     error_no_arg (_("one or more breakpoint numbers"));
14364
14365   init_number_or_range (&state, args);
14366
14367   while (!state.finished)
14368     {
14369       char *p = state.string;
14370
14371       match = 0;
14372
14373       num = get_number_or_range (&state);
14374       if (num == 0)
14375         {
14376           warning (_("bad breakpoint number at or near '%s'"), p);
14377         }
14378       else
14379         {
14380           ALL_BREAKPOINTS_SAFE (b, tmp)
14381             if (b->number == num)
14382               {
14383                 match = 1;
14384                 function (b, data);
14385                 break;
14386               }
14387           if (match == 0)
14388             printf_unfiltered (_("No breakpoint number %d.\n"), num);
14389         }
14390     }
14391 }
14392
14393 static struct bp_location *
14394 find_location_by_number (char *number)
14395 {
14396   char *dot = strchr (number, '.');
14397   char *p1;
14398   int bp_num;
14399   int loc_num;
14400   struct breakpoint *b;
14401   struct bp_location *loc;  
14402
14403   *dot = '\0';
14404
14405   p1 = number;
14406   bp_num = get_number (&p1);
14407   if (bp_num == 0)
14408     error (_("Bad breakpoint number '%s'"), number);
14409
14410   ALL_BREAKPOINTS (b)
14411     if (b->number == bp_num)
14412       {
14413         break;
14414       }
14415
14416   if (!b || b->number != bp_num)
14417     error (_("Bad breakpoint number '%s'"), number);
14418   
14419   p1 = dot+1;
14420   loc_num = get_number (&p1);
14421   if (loc_num == 0)
14422     error (_("Bad breakpoint location number '%s'"), number);
14423
14424   --loc_num;
14425   loc = b->loc;
14426   for (;loc_num && loc; --loc_num, loc = loc->next)
14427     ;
14428   if (!loc)
14429     error (_("Bad breakpoint location number '%s'"), dot+1);
14430     
14431   return loc;  
14432 }
14433
14434
14435 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14436    If from_tty is nonzero, it prints a message to that effect,
14437    which ends with a period (no newline).  */
14438
14439 void
14440 disable_breakpoint (struct breakpoint *bpt)
14441 {
14442   /* Never disable a watchpoint scope breakpoint; we want to
14443      hit them when we leave scope so we can delete both the
14444      watchpoint and its scope breakpoint at that time.  */
14445   if (bpt->type == bp_watchpoint_scope)
14446     return;
14447
14448   /* You can't disable permanent breakpoints.  */
14449   if (bpt->enable_state == bp_permanent)
14450     return;
14451
14452   bpt->enable_state = bp_disabled;
14453
14454   /* Mark breakpoint locations modified.  */
14455   mark_breakpoint_modified (bpt);
14456
14457   if (target_supports_enable_disable_tracepoint ()
14458       && current_trace_status ()->running && is_tracepoint (bpt))
14459     {
14460       struct bp_location *location;
14461      
14462       for (location = bpt->loc; location; location = location->next)
14463         target_disable_tracepoint (location);
14464     }
14465
14466   update_global_location_list (0);
14467
14468   observer_notify_breakpoint_modified (bpt);
14469 }
14470
14471 /* A callback for iterate_over_related_breakpoints.  */
14472
14473 static void
14474 do_disable_breakpoint (struct breakpoint *b, void *ignore)
14475 {
14476   disable_breakpoint (b);
14477 }
14478
14479 /* A callback for map_breakpoint_numbers that calls
14480    disable_breakpoint.  */
14481
14482 static void
14483 do_map_disable_breakpoint (struct breakpoint *b, void *ignore)
14484 {
14485   iterate_over_related_breakpoints (b, do_disable_breakpoint, NULL);
14486 }
14487
14488 static void
14489 disable_command (char *args, int from_tty)
14490 {
14491   if (args == 0)
14492     {
14493       struct breakpoint *bpt;
14494
14495       ALL_BREAKPOINTS (bpt)
14496         if (user_breakpoint_p (bpt))
14497           disable_breakpoint (bpt);
14498     }
14499   else if (strchr (args, '.'))
14500     {
14501       struct bp_location *loc = find_location_by_number (args);
14502       if (loc)
14503         {
14504           if (loc->enabled)
14505             {
14506               loc->enabled = 0;
14507               mark_breakpoint_location_modified (loc);
14508             }
14509           if (target_supports_enable_disable_tracepoint ()
14510               && current_trace_status ()->running && loc->owner
14511               && is_tracepoint (loc->owner))
14512             target_disable_tracepoint (loc);
14513         }
14514       update_global_location_list (0);
14515     }
14516   else
14517     map_breakpoint_numbers (args, do_map_disable_breakpoint, NULL);
14518 }
14519
14520 static void
14521 enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14522                         int count)
14523 {
14524   int target_resources_ok;
14525
14526   if (bpt->type == bp_hardware_breakpoint)
14527     {
14528       int i;
14529       i = hw_breakpoint_used_count ();
14530       target_resources_ok = 
14531         target_can_use_hardware_watchpoint (bp_hardware_breakpoint, 
14532                                             i + 1, 0);
14533       if (target_resources_ok == 0)
14534         error (_("No hardware breakpoint support in the target."));
14535       else if (target_resources_ok < 0)
14536         error (_("Hardware breakpoints used exceeds limit."));
14537     }
14538
14539   if (is_watchpoint (bpt))
14540     {
14541       /* Initialize it just to avoid a GCC false warning.  */
14542       enum enable_state orig_enable_state = 0;
14543       volatile struct gdb_exception e;
14544
14545       TRY_CATCH (e, RETURN_MASK_ALL)
14546         {
14547           struct watchpoint *w = (struct watchpoint *) bpt;
14548
14549           orig_enable_state = bpt->enable_state;
14550           bpt->enable_state = bp_enabled;
14551           update_watchpoint (w, 1 /* reparse */);
14552         }
14553       if (e.reason < 0)
14554         {
14555           bpt->enable_state = orig_enable_state;
14556           exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14557                              bpt->number);
14558           return;
14559         }
14560     }
14561
14562   if (bpt->enable_state != bp_permanent)
14563     bpt->enable_state = bp_enabled;
14564
14565   bpt->enable_state = bp_enabled;
14566
14567   /* Mark breakpoint locations modified.  */
14568   mark_breakpoint_modified (bpt);
14569
14570   if (target_supports_enable_disable_tracepoint ()
14571       && current_trace_status ()->running && is_tracepoint (bpt))
14572     {
14573       struct bp_location *location;
14574
14575       for (location = bpt->loc; location; location = location->next)
14576         target_enable_tracepoint (location);
14577     }
14578
14579   bpt->disposition = disposition;
14580   bpt->enable_count = count;
14581   update_global_location_list (1);
14582   breakpoints_changed ();
14583   
14584   observer_notify_breakpoint_modified (bpt);
14585 }
14586
14587
14588 void
14589 enable_breakpoint (struct breakpoint *bpt)
14590 {
14591   enable_breakpoint_disp (bpt, bpt->disposition, 0);
14592 }
14593
14594 static void
14595 do_enable_breakpoint (struct breakpoint *bpt, void *arg)
14596 {
14597   enable_breakpoint (bpt);
14598 }
14599
14600 /* A callback for map_breakpoint_numbers that calls
14601    enable_breakpoint.  */
14602
14603 static void
14604 do_map_enable_breakpoint (struct breakpoint *b, void *ignore)
14605 {
14606   iterate_over_related_breakpoints (b, do_enable_breakpoint, NULL);
14607 }
14608
14609 /* The enable command enables the specified breakpoints (or all defined
14610    breakpoints) so they once again become (or continue to be) effective
14611    in stopping the inferior.  */
14612
14613 static void
14614 enable_command (char *args, int from_tty)
14615 {
14616   if (args == 0)
14617     {
14618       struct breakpoint *bpt;
14619
14620       ALL_BREAKPOINTS (bpt)
14621         if (user_breakpoint_p (bpt))
14622           enable_breakpoint (bpt);
14623     }
14624   else if (strchr (args, '.'))
14625     {
14626       struct bp_location *loc = find_location_by_number (args);
14627       if (loc)
14628         {
14629           if (!loc->enabled)
14630             {
14631               loc->enabled = 1;
14632               mark_breakpoint_location_modified (loc);
14633             }
14634           if (target_supports_enable_disable_tracepoint ()
14635               && current_trace_status ()->running && loc->owner
14636               && is_tracepoint (loc->owner))
14637             target_enable_tracepoint (loc);
14638         }
14639       update_global_location_list (1);
14640     }
14641   else
14642     map_breakpoint_numbers (args, do_map_enable_breakpoint, NULL);
14643 }
14644
14645 /* This struct packages up disposition data for application to multiple
14646    breakpoints.  */
14647
14648 struct disp_data
14649 {
14650   enum bpdisp disp;
14651   int count;
14652 };
14653
14654 static void
14655 do_enable_breakpoint_disp (struct breakpoint *bpt, void *arg)
14656 {
14657   struct disp_data disp_data = *(struct disp_data *) arg;
14658
14659   enable_breakpoint_disp (bpt, disp_data.disp, disp_data.count);
14660 }
14661
14662 static void
14663 do_map_enable_once_breakpoint (struct breakpoint *bpt, void *ignore)
14664 {
14665   struct disp_data disp = { disp_disable, 1 };
14666
14667   iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14668 }
14669
14670 static void
14671 enable_once_command (char *args, int from_tty)
14672 {
14673   map_breakpoint_numbers (args, do_map_enable_once_breakpoint, NULL);
14674 }
14675
14676 static void
14677 do_map_enable_count_breakpoint (struct breakpoint *bpt, void *countptr)
14678 {
14679   struct disp_data disp = { disp_disable, *(int *) countptr };
14680
14681   iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14682 }
14683
14684 static void
14685 enable_count_command (char *args, int from_tty)
14686 {
14687   int count = get_number (&args);
14688
14689   map_breakpoint_numbers (args, do_map_enable_count_breakpoint, &count);
14690 }
14691
14692 static void
14693 do_map_enable_delete_breakpoint (struct breakpoint *bpt, void *ignore)
14694 {
14695   struct disp_data disp = { disp_del, 1 };
14696
14697   iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14698 }
14699
14700 static void
14701 enable_delete_command (char *args, int from_tty)
14702 {
14703   map_breakpoint_numbers (args, do_map_enable_delete_breakpoint, NULL);
14704 }
14705 \f
14706 static void
14707 set_breakpoint_cmd (char *args, int from_tty)
14708 {
14709 }
14710
14711 static void
14712 show_breakpoint_cmd (char *args, int from_tty)
14713 {
14714 }
14715
14716 /* Invalidate last known value of any hardware watchpoint if
14717    the memory which that value represents has been written to by
14718    GDB itself.  */
14719
14720 static void
14721 invalidate_bp_value_on_memory_change (struct inferior *inferior,
14722                                       CORE_ADDR addr, ssize_t len,
14723                                       const bfd_byte *data)
14724 {
14725   struct breakpoint *bp;
14726
14727   ALL_BREAKPOINTS (bp)
14728     if (bp->enable_state == bp_enabled
14729         && bp->type == bp_hardware_watchpoint)
14730       {
14731         struct watchpoint *wp = (struct watchpoint *) bp;
14732
14733         if (wp->val_valid && wp->val)
14734           {
14735             struct bp_location *loc;
14736
14737             for (loc = bp->loc; loc != NULL; loc = loc->next)
14738               if (loc->loc_type == bp_loc_hardware_watchpoint
14739                   && loc->address + loc->length > addr
14740                   && addr + len > loc->address)
14741                 {
14742                   value_free (wp->val);
14743                   wp->val = NULL;
14744                   wp->val_valid = 0;
14745                 }
14746           }
14747       }
14748 }
14749
14750 /* Create and insert a raw software breakpoint at PC.  Return an
14751    identifier, which should be used to remove the breakpoint later.
14752    In general, places which call this should be using something on the
14753    breakpoint chain instead; this function should be eliminated
14754    someday.  */
14755
14756 void *
14757 deprecated_insert_raw_breakpoint (struct gdbarch *gdbarch,
14758                                   struct address_space *aspace, CORE_ADDR pc)
14759 {
14760   struct bp_target_info *bp_tgt;
14761
14762   bp_tgt = XZALLOC (struct bp_target_info);
14763
14764   bp_tgt->placed_address_space = aspace;
14765   bp_tgt->placed_address = pc;
14766
14767   if (target_insert_breakpoint (gdbarch, bp_tgt) != 0)
14768     {
14769       /* Could not insert the breakpoint.  */
14770       xfree (bp_tgt);
14771       return NULL;
14772     }
14773
14774   return bp_tgt;
14775 }
14776
14777 /* Remove a breakpoint BP inserted by
14778    deprecated_insert_raw_breakpoint.  */
14779
14780 int
14781 deprecated_remove_raw_breakpoint (struct gdbarch *gdbarch, void *bp)
14782 {
14783   struct bp_target_info *bp_tgt = bp;
14784   int ret;
14785
14786   ret = target_remove_breakpoint (gdbarch, bp_tgt);
14787   xfree (bp_tgt);
14788
14789   return ret;
14790 }
14791
14792 /* One (or perhaps two) breakpoints used for software single
14793    stepping.  */
14794
14795 static void *single_step_breakpoints[2];
14796 static struct gdbarch *single_step_gdbarch[2];
14797
14798 /* Create and insert a breakpoint for software single step.  */
14799
14800 void
14801 insert_single_step_breakpoint (struct gdbarch *gdbarch,
14802                                struct address_space *aspace, 
14803                                CORE_ADDR next_pc)
14804 {
14805   void **bpt_p;
14806
14807   if (single_step_breakpoints[0] == NULL)
14808     {
14809       bpt_p = &single_step_breakpoints[0];
14810       single_step_gdbarch[0] = gdbarch;
14811     }
14812   else
14813     {
14814       gdb_assert (single_step_breakpoints[1] == NULL);
14815       bpt_p = &single_step_breakpoints[1];
14816       single_step_gdbarch[1] = gdbarch;
14817     }
14818
14819   /* NOTE drow/2006-04-11: A future improvement to this function would
14820      be to only create the breakpoints once, and actually put them on
14821      the breakpoint chain.  That would let us use set_raw_breakpoint.
14822      We could adjust the addresses each time they were needed.  Doing
14823      this requires corresponding changes elsewhere where single step
14824      breakpoints are handled, however.  So, for now, we use this.  */
14825
14826   *bpt_p = deprecated_insert_raw_breakpoint (gdbarch, aspace, next_pc);
14827   if (*bpt_p == NULL)
14828     error (_("Could not insert single-step breakpoint at %s"),
14829              paddress (gdbarch, next_pc));
14830 }
14831
14832 /* Check if the breakpoints used for software single stepping
14833    were inserted or not.  */
14834
14835 int
14836 single_step_breakpoints_inserted (void)
14837 {
14838   return (single_step_breakpoints[0] != NULL
14839           || single_step_breakpoints[1] != NULL);
14840 }
14841
14842 /* Remove and delete any breakpoints used for software single step.  */
14843
14844 void
14845 remove_single_step_breakpoints (void)
14846 {
14847   gdb_assert (single_step_breakpoints[0] != NULL);
14848
14849   /* See insert_single_step_breakpoint for more about this deprecated
14850      call.  */
14851   deprecated_remove_raw_breakpoint (single_step_gdbarch[0],
14852                                     single_step_breakpoints[0]);
14853   single_step_gdbarch[0] = NULL;
14854   single_step_breakpoints[0] = NULL;
14855
14856   if (single_step_breakpoints[1] != NULL)
14857     {
14858       deprecated_remove_raw_breakpoint (single_step_gdbarch[1],
14859                                         single_step_breakpoints[1]);
14860       single_step_gdbarch[1] = NULL;
14861       single_step_breakpoints[1] = NULL;
14862     }
14863 }
14864
14865 /* Delete software single step breakpoints without removing them from
14866    the inferior.  This is intended to be used if the inferior's address
14867    space where they were inserted is already gone, e.g. after exit or
14868    exec.  */
14869
14870 void
14871 cancel_single_step_breakpoints (void)
14872 {
14873   int i;
14874
14875   for (i = 0; i < 2; i++)
14876     if (single_step_breakpoints[i])
14877       {
14878         xfree (single_step_breakpoints[i]);
14879         single_step_breakpoints[i] = NULL;
14880         single_step_gdbarch[i] = NULL;
14881       }
14882 }
14883
14884 /* Detach software single-step breakpoints from INFERIOR_PTID without
14885    removing them.  */
14886
14887 static void
14888 detach_single_step_breakpoints (void)
14889 {
14890   int i;
14891
14892   for (i = 0; i < 2; i++)
14893     if (single_step_breakpoints[i])
14894       target_remove_breakpoint (single_step_gdbarch[i],
14895                                 single_step_breakpoints[i]);
14896 }
14897
14898 /* Check whether a software single-step breakpoint is inserted at
14899    PC.  */
14900
14901 static int
14902 single_step_breakpoint_inserted_here_p (struct address_space *aspace, 
14903                                         CORE_ADDR pc)
14904 {
14905   int i;
14906
14907   for (i = 0; i < 2; i++)
14908     {
14909       struct bp_target_info *bp_tgt = single_step_breakpoints[i];
14910       if (bp_tgt
14911           && breakpoint_address_match (bp_tgt->placed_address_space,
14912                                        bp_tgt->placed_address,
14913                                        aspace, pc))
14914         return 1;
14915     }
14916
14917   return 0;
14918 }
14919
14920 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
14921    non-zero otherwise.  */
14922 static int
14923 is_syscall_catchpoint_enabled (struct breakpoint *bp)
14924 {
14925   if (syscall_catchpoint_p (bp)
14926       && bp->enable_state != bp_disabled
14927       && bp->enable_state != bp_call_disabled)
14928     return 1;
14929   else
14930     return 0;
14931 }
14932
14933 int
14934 catch_syscall_enabled (void)
14935 {
14936   struct catch_syscall_inferior_data *inf_data
14937     = get_catch_syscall_inferior_data (current_inferior ());
14938
14939   return inf_data->total_syscalls_count != 0;
14940 }
14941
14942 int
14943 catching_syscall_number (int syscall_number)
14944 {
14945   struct breakpoint *bp;
14946
14947   ALL_BREAKPOINTS (bp)
14948     if (is_syscall_catchpoint_enabled (bp))
14949       {
14950         struct syscall_catchpoint *c = (struct syscall_catchpoint *) bp;
14951
14952         if (c->syscalls_to_be_caught)
14953           {
14954             int i, iter;
14955             for (i = 0;
14956                  VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
14957                  i++)
14958               if (syscall_number == iter)
14959                 return 1;
14960           }
14961         else
14962           return 1;
14963       }
14964
14965   return 0;
14966 }
14967
14968 /* Complete syscall names.  Used by "catch syscall".  */
14969 static VEC (char_ptr) *
14970 catch_syscall_completer (struct cmd_list_element *cmd,
14971                          char *text, char *word)
14972 {
14973   const char **list = get_syscall_names ();
14974   VEC (char_ptr) *retlist
14975     = (list == NULL) ? NULL : complete_on_enum (list, word, word);
14976
14977   xfree (list);
14978   return retlist;
14979 }
14980
14981 /* Tracepoint-specific operations.  */
14982
14983 /* Set tracepoint count to NUM.  */
14984 static void
14985 set_tracepoint_count (int num)
14986 {
14987   tracepoint_count = num;
14988   set_internalvar_integer (lookup_internalvar ("tpnum"), num);
14989 }
14990
14991 static void
14992 trace_command (char *arg, int from_tty)
14993 {
14994   struct breakpoint_ops *ops;
14995   const char *arg_cp = arg;
14996
14997   if (arg && probe_linespec_to_ops (&arg_cp))
14998     ops = &tracepoint_probe_breakpoint_ops;
14999   else
15000     ops = &tracepoint_breakpoint_ops;
15001
15002   if (create_breakpoint (get_current_arch (),
15003                          arg,
15004                          NULL, 0, NULL, 1 /* parse arg */,
15005                          0 /* tempflag */,
15006                          bp_tracepoint /* type_wanted */,
15007                          0 /* Ignore count */,
15008                          pending_break_support,
15009                          ops,
15010                          from_tty,
15011                          1 /* enabled */,
15012                          0 /* internal */, 0))
15013     set_tracepoint_count (breakpoint_count);
15014 }
15015
15016 static void
15017 ftrace_command (char *arg, int from_tty)
15018 {
15019   if (create_breakpoint (get_current_arch (),
15020                          arg,
15021                          NULL, 0, NULL, 1 /* parse arg */,
15022                          0 /* tempflag */,
15023                          bp_fast_tracepoint /* type_wanted */,
15024                          0 /* Ignore count */,
15025                          pending_break_support,
15026                          &tracepoint_breakpoint_ops,
15027                          from_tty,
15028                          1 /* enabled */,
15029                          0 /* internal */, 0))
15030     set_tracepoint_count (breakpoint_count);
15031 }
15032
15033 /* strace command implementation.  Creates a static tracepoint.  */
15034
15035 static void
15036 strace_command (char *arg, int from_tty)
15037 {
15038   struct breakpoint_ops *ops;
15039
15040   /* Decide if we are dealing with a static tracepoint marker (`-m'),
15041      or with a normal static tracepoint.  */
15042   if (arg && strncmp (arg, "-m", 2) == 0 && isspace (arg[2]))
15043     ops = &strace_marker_breakpoint_ops;
15044   else
15045     ops = &tracepoint_breakpoint_ops;
15046
15047   if (create_breakpoint (get_current_arch (),
15048                          arg,
15049                          NULL, 0, NULL, 1 /* parse arg */,
15050                          0 /* tempflag */,
15051                          bp_static_tracepoint /* type_wanted */,
15052                          0 /* Ignore count */,
15053                          pending_break_support,
15054                          ops,
15055                          from_tty,
15056                          1 /* enabled */,
15057                          0 /* internal */, 0))
15058     set_tracepoint_count (breakpoint_count);
15059 }
15060
15061 /* Set up a fake reader function that gets command lines from a linked
15062    list that was acquired during tracepoint uploading.  */
15063
15064 static struct uploaded_tp *this_utp;
15065 static int next_cmd;
15066
15067 static char *
15068 read_uploaded_action (void)
15069 {
15070   char *rslt;
15071
15072   VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
15073
15074   next_cmd++;
15075
15076   return rslt;
15077 }
15078
15079 /* Given information about a tracepoint as recorded on a target (which
15080    can be either a live system or a trace file), attempt to create an
15081    equivalent GDB tracepoint.  This is not a reliable process, since
15082    the target does not necessarily have all the information used when
15083    the tracepoint was originally defined.  */
15084   
15085 struct tracepoint *
15086 create_tracepoint_from_upload (struct uploaded_tp *utp)
15087 {
15088   char *addr_str, small_buf[100];
15089   struct tracepoint *tp;
15090
15091   if (utp->at_string)
15092     addr_str = utp->at_string;
15093   else
15094     {
15095       /* In the absence of a source location, fall back to raw
15096          address.  Since there is no way to confirm that the address
15097          means the same thing as when the trace was started, warn the
15098          user.  */
15099       warning (_("Uploaded tracepoint %d has no "
15100                  "source location, using raw address"),
15101                utp->number);
15102       sprintf (small_buf, "*%s", hex_string (utp->addr));
15103       addr_str = small_buf;
15104     }
15105
15106   /* There's not much we can do with a sequence of bytecodes.  */
15107   if (utp->cond && !utp->cond_string)
15108     warning (_("Uploaded tracepoint %d condition "
15109                "has no source form, ignoring it"),
15110              utp->number);
15111
15112   if (!create_breakpoint (get_current_arch (),
15113                           addr_str,
15114                           utp->cond_string, -1, NULL,
15115                           0 /* parse cond/thread */,
15116                           0 /* tempflag */,
15117                           utp->type /* type_wanted */,
15118                           0 /* Ignore count */,
15119                           pending_break_support,
15120                           &tracepoint_breakpoint_ops,
15121                           0 /* from_tty */,
15122                           utp->enabled /* enabled */,
15123                           0 /* internal */,
15124                           CREATE_BREAKPOINT_FLAGS_INSERTED))
15125     return NULL;
15126
15127   set_tracepoint_count (breakpoint_count);
15128   
15129   /* Get the tracepoint we just created.  */
15130   tp = get_tracepoint (tracepoint_count);
15131   gdb_assert (tp != NULL);
15132
15133   if (utp->pass > 0)
15134     {
15135       sprintf (small_buf, "%d %d", utp->pass, tp->base.number);
15136
15137       trace_pass_command (small_buf, 0);
15138     }
15139
15140   /* If we have uploaded versions of the original commands, set up a
15141      special-purpose "reader" function and call the usual command line
15142      reader, then pass the result to the breakpoint command-setting
15143      function.  */
15144   if (!VEC_empty (char_ptr, utp->cmd_strings))
15145     {
15146       struct command_line *cmd_list;
15147
15148       this_utp = utp;
15149       next_cmd = 0;
15150
15151       cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
15152
15153       breakpoint_set_commands (&tp->base, cmd_list);
15154     }
15155   else if (!VEC_empty (char_ptr, utp->actions)
15156            || !VEC_empty (char_ptr, utp->step_actions))
15157     warning (_("Uploaded tracepoint %d actions "
15158                "have no source form, ignoring them"),
15159              utp->number);
15160
15161   /* Copy any status information that might be available.  */
15162   tp->base.hit_count = utp->hit_count;
15163   tp->traceframe_usage = utp->traceframe_usage;
15164
15165   return tp;
15166 }
15167   
15168 /* Print information on tracepoint number TPNUM_EXP, or all if
15169    omitted.  */
15170
15171 static void
15172 tracepoints_info (char *args, int from_tty)
15173 {
15174   struct ui_out *uiout = current_uiout;
15175   int num_printed;
15176
15177   num_printed = breakpoint_1 (args, 0, is_tracepoint);
15178
15179   if (num_printed == 0)
15180     {
15181       if (args == NULL || *args == '\0')
15182         ui_out_message (uiout, 0, "No tracepoints.\n");
15183       else
15184         ui_out_message (uiout, 0, "No tracepoint matching '%s'.\n", args);
15185     }
15186
15187   default_collect_info ();
15188 }
15189
15190 /* The 'enable trace' command enables tracepoints.
15191    Not supported by all targets.  */
15192 static void
15193 enable_trace_command (char *args, int from_tty)
15194 {
15195   enable_command (args, from_tty);
15196 }
15197
15198 /* The 'disable trace' command disables tracepoints.
15199    Not supported by all targets.  */
15200 static void
15201 disable_trace_command (char *args, int from_tty)
15202 {
15203   disable_command (args, from_tty);
15204 }
15205
15206 /* Remove a tracepoint (or all if no argument).  */
15207 static void
15208 delete_trace_command (char *arg, int from_tty)
15209 {
15210   struct breakpoint *b, *b_tmp;
15211
15212   dont_repeat ();
15213
15214   if (arg == 0)
15215     {
15216       int breaks_to_delete = 0;
15217
15218       /* Delete all breakpoints if no argument.
15219          Do not delete internal or call-dummy breakpoints, these
15220          have to be deleted with an explicit breakpoint number 
15221          argument.  */
15222       ALL_TRACEPOINTS (b)
15223         if (is_tracepoint (b) && user_breakpoint_p (b))
15224           {
15225             breaks_to_delete = 1;
15226             break;
15227           }
15228
15229       /* Ask user only if there are some breakpoints to delete.  */
15230       if (!from_tty
15231           || (breaks_to_delete && query (_("Delete all tracepoints? "))))
15232         {
15233           ALL_BREAKPOINTS_SAFE (b, b_tmp)
15234             if (is_tracepoint (b) && user_breakpoint_p (b))
15235               delete_breakpoint (b);
15236         }
15237     }
15238   else
15239     map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
15240 }
15241
15242 /* Helper function for trace_pass_command.  */
15243
15244 static void
15245 trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
15246 {
15247   tp->pass_count = count;
15248   observer_notify_tracepoint_modified (tp->base.number);
15249   if (from_tty)
15250     printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
15251                      tp->base.number, count);
15252 }
15253
15254 /* Set passcount for tracepoint.
15255
15256    First command argument is passcount, second is tracepoint number.
15257    If tracepoint number omitted, apply to most recently defined.
15258    Also accepts special argument "all".  */
15259
15260 static void
15261 trace_pass_command (char *args, int from_tty)
15262 {
15263   struct tracepoint *t1;
15264   unsigned int count;
15265
15266   if (args == 0 || *args == 0)
15267     error (_("passcount command requires an "
15268              "argument (count + optional TP num)"));
15269
15270   count = strtoul (args, &args, 10);    /* Count comes first, then TP num.  */
15271
15272   while (*args && isspace ((int) *args))
15273     args++;
15274
15275   if (*args && strncasecmp (args, "all", 3) == 0)
15276     {
15277       struct breakpoint *b;
15278
15279       args += 3;                        /* Skip special argument "all".  */
15280       if (*args)
15281         error (_("Junk at end of arguments."));
15282
15283       ALL_TRACEPOINTS (b)
15284       {
15285         t1 = (struct tracepoint *) b;
15286         trace_pass_set_count (t1, count, from_tty);
15287       }
15288     }
15289   else if (*args == '\0')
15290     {
15291       t1 = get_tracepoint_by_number (&args, NULL, 1);
15292       if (t1)
15293         trace_pass_set_count (t1, count, from_tty);
15294     }
15295   else
15296     {
15297       struct get_number_or_range_state state;
15298
15299       init_number_or_range (&state, args);
15300       while (!state.finished)
15301         {
15302           t1 = get_tracepoint_by_number (&args, &state, 1);
15303           if (t1)
15304             trace_pass_set_count (t1, count, from_tty);
15305         }
15306     }
15307 }
15308
15309 struct tracepoint *
15310 get_tracepoint (int num)
15311 {
15312   struct breakpoint *t;
15313
15314   ALL_TRACEPOINTS (t)
15315     if (t->number == num)
15316       return (struct tracepoint *) t;
15317
15318   return NULL;
15319 }
15320
15321 /* Find the tracepoint with the given target-side number (which may be
15322    different from the tracepoint number after disconnecting and
15323    reconnecting).  */
15324
15325 struct tracepoint *
15326 get_tracepoint_by_number_on_target (int num)
15327 {
15328   struct breakpoint *b;
15329
15330   ALL_TRACEPOINTS (b)
15331     {
15332       struct tracepoint *t = (struct tracepoint *) b;
15333
15334       if (t->number_on_target == num)
15335         return t;
15336     }
15337
15338   return NULL;
15339 }
15340
15341 /* Utility: parse a tracepoint number and look it up in the list.
15342    If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
15343    If OPTIONAL_P is true, then if the argument is missing, the most
15344    recent tracepoint (tracepoint_count) is returned.  */
15345 struct tracepoint *
15346 get_tracepoint_by_number (char **arg,
15347                           struct get_number_or_range_state *state,
15348                           int optional_p)
15349 {
15350   extern int tracepoint_count;
15351   struct breakpoint *t;
15352   int tpnum;
15353   char *instring = arg == NULL ? NULL : *arg;
15354
15355   if (state)
15356     {
15357       gdb_assert (!state->finished);
15358       tpnum = get_number_or_range (state);
15359     }
15360   else if (arg == NULL || *arg == NULL || ! **arg)
15361     {
15362       if (optional_p)
15363         tpnum = tracepoint_count;
15364       else
15365         error_no_arg (_("tracepoint number"));
15366     }
15367   else
15368     tpnum = get_number (arg);
15369
15370   if (tpnum <= 0)
15371     {
15372       if (instring && *instring)
15373         printf_filtered (_("bad tracepoint number at or near '%s'\n"), 
15374                          instring);
15375       else
15376         printf_filtered (_("Tracepoint argument missing "
15377                            "and no previous tracepoint\n"));
15378       return NULL;
15379     }
15380
15381   ALL_TRACEPOINTS (t)
15382     if (t->number == tpnum)
15383     {
15384       return (struct tracepoint *) t;
15385     }
15386
15387   printf_unfiltered ("No tracepoint number %d.\n", tpnum);
15388   return NULL;
15389 }
15390
15391 void
15392 print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
15393 {
15394   if (b->thread != -1)
15395     fprintf_unfiltered (fp, " thread %d", b->thread);
15396
15397   if (b->task != 0)
15398     fprintf_unfiltered (fp, " task %d", b->task);
15399
15400   fprintf_unfiltered (fp, "\n");
15401 }
15402
15403 /* Save information on user settable breakpoints (watchpoints, etc) to
15404    a new script file named FILENAME.  If FILTER is non-NULL, call it
15405    on each breakpoint and only include the ones for which it returns
15406    non-zero.  */
15407
15408 static void
15409 save_breakpoints (char *filename, int from_tty,
15410                   int (*filter) (const struct breakpoint *))
15411 {
15412   struct breakpoint *tp;
15413   int any = 0;
15414   char *pathname;
15415   struct cleanup *cleanup;
15416   struct ui_file *fp;
15417   int extra_trace_bits = 0;
15418
15419   if (filename == 0 || *filename == 0)
15420     error (_("Argument required (file name in which to save)"));
15421
15422   /* See if we have anything to save.  */
15423   ALL_BREAKPOINTS (tp)
15424   {
15425     /* Skip internal and momentary breakpoints.  */
15426     if (!user_breakpoint_p (tp))
15427       continue;
15428
15429     /* If we have a filter, only save the breakpoints it accepts.  */
15430     if (filter && !filter (tp))
15431       continue;
15432
15433     any = 1;
15434
15435     if (is_tracepoint (tp))
15436       {
15437         extra_trace_bits = 1;
15438
15439         /* We can stop searching.  */
15440         break;
15441       }
15442   }
15443
15444   if (!any)
15445     {
15446       warning (_("Nothing to save."));
15447       return;
15448     }
15449
15450   pathname = tilde_expand (filename);
15451   cleanup = make_cleanup (xfree, pathname);
15452   fp = gdb_fopen (pathname, "w");
15453   if (!fp)
15454     error (_("Unable to open file '%s' for saving (%s)"),
15455            filename, safe_strerror (errno));
15456   make_cleanup_ui_file_delete (fp);
15457
15458   if (extra_trace_bits)
15459     save_trace_state_variables (fp);
15460
15461   ALL_BREAKPOINTS (tp)
15462   {
15463     /* Skip internal and momentary breakpoints.  */
15464     if (!user_breakpoint_p (tp))
15465       continue;
15466
15467     /* If we have a filter, only save the breakpoints it accepts.  */
15468     if (filter && !filter (tp))
15469       continue;
15470
15471     tp->ops->print_recreate (tp, fp);
15472
15473     /* Note, we can't rely on tp->number for anything, as we can't
15474        assume the recreated breakpoint numbers will match.  Use $bpnum
15475        instead.  */
15476
15477     if (tp->cond_string)
15478       fprintf_unfiltered (fp, "  condition $bpnum %s\n", tp->cond_string);
15479
15480     if (tp->ignore_count)
15481       fprintf_unfiltered (fp, "  ignore $bpnum %d\n", tp->ignore_count);
15482
15483     if (tp->commands)
15484       {
15485         volatile struct gdb_exception ex;       
15486
15487         fprintf_unfiltered (fp, "  commands\n");
15488         
15489         ui_out_redirect (current_uiout, fp);
15490         TRY_CATCH (ex, RETURN_MASK_ALL)
15491           {
15492             print_command_lines (current_uiout, tp->commands->commands, 2);
15493           }
15494         ui_out_redirect (current_uiout, NULL);
15495
15496         if (ex.reason < 0)
15497           throw_exception (ex);
15498
15499         fprintf_unfiltered (fp, "  end\n");
15500       }
15501
15502     if (tp->enable_state == bp_disabled)
15503       fprintf_unfiltered (fp, "disable\n");
15504
15505     /* If this is a multi-location breakpoint, check if the locations
15506        should be individually disabled.  Watchpoint locations are
15507        special, and not user visible.  */
15508     if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15509       {
15510         struct bp_location *loc;
15511         int n = 1;
15512
15513         for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15514           if (!loc->enabled)
15515             fprintf_unfiltered (fp, "disable $bpnum.%d\n", n);
15516       }
15517   }
15518
15519   if (extra_trace_bits && *default_collect)
15520     fprintf_unfiltered (fp, "set default-collect %s\n", default_collect);
15521
15522   do_cleanups (cleanup);
15523   if (from_tty)
15524     printf_filtered (_("Saved to file '%s'.\n"), filename);
15525 }
15526
15527 /* The `save breakpoints' command.  */
15528
15529 static void
15530 save_breakpoints_command (char *args, int from_tty)
15531 {
15532   save_breakpoints (args, from_tty, NULL);
15533 }
15534
15535 /* The `save tracepoints' command.  */
15536
15537 static void
15538 save_tracepoints_command (char *args, int from_tty)
15539 {
15540   save_breakpoints (args, from_tty, is_tracepoint);
15541 }
15542
15543 /* Create a vector of all tracepoints.  */
15544
15545 VEC(breakpoint_p) *
15546 all_tracepoints (void)
15547 {
15548   VEC(breakpoint_p) *tp_vec = 0;
15549   struct breakpoint *tp;
15550
15551   ALL_TRACEPOINTS (tp)
15552   {
15553     VEC_safe_push (breakpoint_p, tp_vec, tp);
15554   }
15555
15556   return tp_vec;
15557 }
15558
15559 \f
15560 /* This help string is used for the break, hbreak, tbreak and thbreak
15561    commands.  It is defined as a macro to prevent duplication.
15562    COMMAND should be a string constant containing the name of the
15563    command.  */
15564 #define BREAK_ARGS_HELP(command) \
15565 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15566 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15567 probe point.  Accepted values are `-probe' (for a generic, automatically\n\
15568 guessed probe type) or `-probe-stap' (for a SystemTap probe).\n\
15569 LOCATION may be a line number, function name, or \"*\" and an address.\n\
15570 If a line number is specified, break at start of code for that line.\n\
15571 If a function is specified, break at start of code for that function.\n\
15572 If an address is specified, break at that exact address.\n\
15573 With no LOCATION, uses current execution address of the selected\n\
15574 stack frame.  This is useful for breaking on return to a stack frame.\n\
15575 \n\
15576 THREADNUM is the number from \"info threads\".\n\
15577 CONDITION is a boolean expression.\n\
15578 \n\
15579 Multiple breakpoints at one place are permitted, and useful if their\n\
15580 conditions are different.\n\
15581 \n\
15582 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15583
15584 /* List of subcommands for "catch".  */
15585 static struct cmd_list_element *catch_cmdlist;
15586
15587 /* List of subcommands for "tcatch".  */
15588 static struct cmd_list_element *tcatch_cmdlist;
15589
15590 void
15591 add_catch_command (char *name, char *docstring,
15592                    void (*sfunc) (char *args, int from_tty,
15593                                   struct cmd_list_element *command),
15594                    completer_ftype *completer,
15595                    void *user_data_catch,
15596                    void *user_data_tcatch)
15597 {
15598   struct cmd_list_element *command;
15599
15600   command = add_cmd (name, class_breakpoint, NULL, docstring,
15601                      &catch_cmdlist);
15602   set_cmd_sfunc (command, sfunc);
15603   set_cmd_context (command, user_data_catch);
15604   set_cmd_completer (command, completer);
15605
15606   command = add_cmd (name, class_breakpoint, NULL, docstring,
15607                      &tcatch_cmdlist);
15608   set_cmd_sfunc (command, sfunc);
15609   set_cmd_context (command, user_data_tcatch);
15610   set_cmd_completer (command, completer);
15611 }
15612
15613 static void
15614 clear_syscall_counts (struct inferior *inf)
15615 {
15616   struct catch_syscall_inferior_data *inf_data
15617     = get_catch_syscall_inferior_data (inf);
15618
15619   inf_data->total_syscalls_count = 0;
15620   inf_data->any_syscall_count = 0;
15621   VEC_free (int, inf_data->syscalls_counts);
15622 }
15623
15624 static void
15625 save_command (char *arg, int from_tty)
15626 {
15627   printf_unfiltered (_("\"save\" must be followed by "
15628                        "the name of a save subcommand.\n"));
15629   help_list (save_cmdlist, "save ", -1, gdb_stdout);
15630 }
15631
15632 struct breakpoint *
15633 iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15634                           void *data)
15635 {
15636   struct breakpoint *b, *b_tmp;
15637
15638   ALL_BREAKPOINTS_SAFE (b, b_tmp)
15639     {
15640       if ((*callback) (b, data))
15641         return b;
15642     }
15643
15644   return NULL;
15645 }
15646
15647 /* Zero if any of the breakpoint's locations could be a location where
15648    functions have been inlined, nonzero otherwise.  */
15649
15650 static int
15651 is_non_inline_function (struct breakpoint *b)
15652 {
15653   /* The shared library event breakpoint is set on the address of a
15654      non-inline function.  */
15655   if (b->type == bp_shlib_event)
15656     return 1;
15657
15658   return 0;
15659 }
15660
15661 /* Nonzero if the specified PC cannot be a location where functions
15662    have been inlined.  */
15663
15664 int
15665 pc_at_non_inline_function (struct address_space *aspace, CORE_ADDR pc,
15666                            const struct target_waitstatus *ws)
15667 {
15668   struct breakpoint *b;
15669   struct bp_location *bl;
15670
15671   ALL_BREAKPOINTS (b)
15672     {
15673       if (!is_non_inline_function (b))
15674         continue;
15675
15676       for (bl = b->loc; bl != NULL; bl = bl->next)
15677         {
15678           if (!bl->shlib_disabled
15679               && bpstat_check_location (bl, aspace, pc, ws))
15680             return 1;
15681         }
15682     }
15683
15684   return 0;
15685 }
15686
15687 void
15688 initialize_breakpoint_ops (void)
15689 {
15690   static int initialized = 0;
15691
15692   struct breakpoint_ops *ops;
15693
15694   if (initialized)
15695     return;
15696   initialized = 1;
15697
15698   /* The breakpoint_ops structure to be inherit by all kinds of
15699      breakpoints (real breakpoints, i.e., user "break" breakpoints,
15700      internal and momentary breakpoints, etc.).  */
15701   ops = &bkpt_base_breakpoint_ops;
15702   *ops = base_breakpoint_ops;
15703   ops->re_set = bkpt_re_set;
15704   ops->insert_location = bkpt_insert_location;
15705   ops->remove_location = bkpt_remove_location;
15706   ops->breakpoint_hit = bkpt_breakpoint_hit;
15707   ops->create_sals_from_address = bkpt_create_sals_from_address;
15708   ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
15709   ops->decode_linespec = bkpt_decode_linespec;
15710
15711   /* The breakpoint_ops structure to be used in regular breakpoints.  */
15712   ops = &bkpt_breakpoint_ops;
15713   *ops = bkpt_base_breakpoint_ops;
15714   ops->re_set = bkpt_re_set;
15715   ops->resources_needed = bkpt_resources_needed;
15716   ops->print_it = bkpt_print_it;
15717   ops->print_mention = bkpt_print_mention;
15718   ops->print_recreate = bkpt_print_recreate;
15719
15720   /* Ranged breakpoints.  */
15721   ops = &ranged_breakpoint_ops;
15722   *ops = bkpt_breakpoint_ops;
15723   ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15724   ops->resources_needed = resources_needed_ranged_breakpoint;
15725   ops->print_it = print_it_ranged_breakpoint;
15726   ops->print_one = print_one_ranged_breakpoint;
15727   ops->print_one_detail = print_one_detail_ranged_breakpoint;
15728   ops->print_mention = print_mention_ranged_breakpoint;
15729   ops->print_recreate = print_recreate_ranged_breakpoint;
15730
15731   /* Internal breakpoints.  */
15732   ops = &internal_breakpoint_ops;
15733   *ops = bkpt_base_breakpoint_ops;
15734   ops->re_set = internal_bkpt_re_set;
15735   ops->check_status = internal_bkpt_check_status;
15736   ops->print_it = internal_bkpt_print_it;
15737   ops->print_mention = internal_bkpt_print_mention;
15738
15739   /* Momentary breakpoints.  */
15740   ops = &momentary_breakpoint_ops;
15741   *ops = bkpt_base_breakpoint_ops;
15742   ops->re_set = momentary_bkpt_re_set;
15743   ops->check_status = momentary_bkpt_check_status;
15744   ops->print_it = momentary_bkpt_print_it;
15745   ops->print_mention = momentary_bkpt_print_mention;
15746
15747   /* Momentary breakpoints for bp_longjmp and bp_exception.  */
15748   ops = &longjmp_breakpoint_ops;
15749   *ops = momentary_breakpoint_ops;
15750   ops->dtor = longjmp_bkpt_dtor;
15751
15752   /* Probe breakpoints.  */
15753   ops = &bkpt_probe_breakpoint_ops;
15754   *ops = bkpt_breakpoint_ops;
15755   ops->insert_location = bkpt_probe_insert_location;
15756   ops->remove_location = bkpt_probe_remove_location;
15757   ops->create_sals_from_address = bkpt_probe_create_sals_from_address;
15758   ops->decode_linespec = bkpt_probe_decode_linespec;
15759
15760   /* GNU v3 exception catchpoints.  */
15761   ops = &gnu_v3_exception_catchpoint_ops;
15762   *ops = bkpt_breakpoint_ops;
15763   ops->print_it = print_it_exception_catchpoint;
15764   ops->print_one = print_one_exception_catchpoint;
15765   ops->print_mention = print_mention_exception_catchpoint;
15766   ops->print_recreate = print_recreate_exception_catchpoint;
15767
15768   /* Watchpoints.  */
15769   ops = &watchpoint_breakpoint_ops;
15770   *ops = base_breakpoint_ops;
15771   ops->dtor = dtor_watchpoint;
15772   ops->re_set = re_set_watchpoint;
15773   ops->insert_location = insert_watchpoint;
15774   ops->remove_location = remove_watchpoint;
15775   ops->breakpoint_hit = breakpoint_hit_watchpoint;
15776   ops->check_status = check_status_watchpoint;
15777   ops->resources_needed = resources_needed_watchpoint;
15778   ops->works_in_software_mode = works_in_software_mode_watchpoint;
15779   ops->print_it = print_it_watchpoint;
15780   ops->print_mention = print_mention_watchpoint;
15781   ops->print_recreate = print_recreate_watchpoint;
15782
15783   /* Masked watchpoints.  */
15784   ops = &masked_watchpoint_breakpoint_ops;
15785   *ops = watchpoint_breakpoint_ops;
15786   ops->insert_location = insert_masked_watchpoint;
15787   ops->remove_location = remove_masked_watchpoint;
15788   ops->resources_needed = resources_needed_masked_watchpoint;
15789   ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15790   ops->print_it = print_it_masked_watchpoint;
15791   ops->print_one_detail = print_one_detail_masked_watchpoint;
15792   ops->print_mention = print_mention_masked_watchpoint;
15793   ops->print_recreate = print_recreate_masked_watchpoint;
15794
15795   /* Tracepoints.  */
15796   ops = &tracepoint_breakpoint_ops;
15797   *ops = base_breakpoint_ops;
15798   ops->re_set = tracepoint_re_set;
15799   ops->breakpoint_hit = tracepoint_breakpoint_hit;
15800   ops->print_one_detail = tracepoint_print_one_detail;
15801   ops->print_mention = tracepoint_print_mention;
15802   ops->print_recreate = tracepoint_print_recreate;
15803   ops->create_sals_from_address = tracepoint_create_sals_from_address;
15804   ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
15805   ops->decode_linespec = tracepoint_decode_linespec;
15806
15807   /* Probe tracepoints.  */
15808   ops = &tracepoint_probe_breakpoint_ops;
15809   *ops = tracepoint_breakpoint_ops;
15810   ops->create_sals_from_address = tracepoint_probe_create_sals_from_address;
15811   ops->decode_linespec = tracepoint_probe_decode_linespec;
15812
15813   /* Static tracepoints with marker (`-m').  */
15814   ops = &strace_marker_breakpoint_ops;
15815   *ops = tracepoint_breakpoint_ops;
15816   ops->create_sals_from_address = strace_marker_create_sals_from_address;
15817   ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
15818   ops->decode_linespec = strace_marker_decode_linespec;
15819
15820   /* Fork catchpoints.  */
15821   ops = &catch_fork_breakpoint_ops;
15822   *ops = base_breakpoint_ops;
15823   ops->insert_location = insert_catch_fork;
15824   ops->remove_location = remove_catch_fork;
15825   ops->breakpoint_hit = breakpoint_hit_catch_fork;
15826   ops->print_it = print_it_catch_fork;
15827   ops->print_one = print_one_catch_fork;
15828   ops->print_mention = print_mention_catch_fork;
15829   ops->print_recreate = print_recreate_catch_fork;
15830
15831   /* Vfork catchpoints.  */
15832   ops = &catch_vfork_breakpoint_ops;
15833   *ops = base_breakpoint_ops;
15834   ops->insert_location = insert_catch_vfork;
15835   ops->remove_location = remove_catch_vfork;
15836   ops->breakpoint_hit = breakpoint_hit_catch_vfork;
15837   ops->print_it = print_it_catch_vfork;
15838   ops->print_one = print_one_catch_vfork;
15839   ops->print_mention = print_mention_catch_vfork;
15840   ops->print_recreate = print_recreate_catch_vfork;
15841
15842   /* Exec catchpoints.  */
15843   ops = &catch_exec_breakpoint_ops;
15844   *ops = base_breakpoint_ops;
15845   ops->dtor = dtor_catch_exec;
15846   ops->insert_location = insert_catch_exec;
15847   ops->remove_location = remove_catch_exec;
15848   ops->breakpoint_hit = breakpoint_hit_catch_exec;
15849   ops->print_it = print_it_catch_exec;
15850   ops->print_one = print_one_catch_exec;
15851   ops->print_mention = print_mention_catch_exec;
15852   ops->print_recreate = print_recreate_catch_exec;
15853
15854   /* Syscall catchpoints.  */
15855   ops = &catch_syscall_breakpoint_ops;
15856   *ops = base_breakpoint_ops;
15857   ops->dtor = dtor_catch_syscall;
15858   ops->insert_location = insert_catch_syscall;
15859   ops->remove_location = remove_catch_syscall;
15860   ops->breakpoint_hit = breakpoint_hit_catch_syscall;
15861   ops->print_it = print_it_catch_syscall;
15862   ops->print_one = print_one_catch_syscall;
15863   ops->print_mention = print_mention_catch_syscall;
15864   ops->print_recreate = print_recreate_catch_syscall;
15865
15866   /* Solib-related catchpoints.  */
15867   ops = &catch_solib_breakpoint_ops;
15868   *ops = base_breakpoint_ops;
15869   ops->dtor = dtor_catch_solib;
15870   ops->insert_location = insert_catch_solib;
15871   ops->remove_location = remove_catch_solib;
15872   ops->breakpoint_hit = breakpoint_hit_catch_solib;
15873   ops->check_status = check_status_catch_solib;
15874   ops->print_it = print_it_catch_solib;
15875   ops->print_one = print_one_catch_solib;
15876   ops->print_mention = print_mention_catch_solib;
15877   ops->print_recreate = print_recreate_catch_solib;
15878
15879   ops = &dprintf_breakpoint_ops;
15880   *ops = bkpt_base_breakpoint_ops;
15881   ops->re_set = bkpt_re_set;
15882   ops->resources_needed = bkpt_resources_needed;
15883   ops->print_it = bkpt_print_it;
15884   ops->print_mention = bkpt_print_mention;
15885   ops->print_recreate = bkpt_print_recreate;
15886 }
15887
15888 /* Chain containing all defined "enable breakpoint" subcommands.  */
15889
15890 static struct cmd_list_element *enablebreaklist = NULL;
15891
15892 void
15893 _initialize_breakpoint (void)
15894 {
15895   struct cmd_list_element *c;
15896
15897   initialize_breakpoint_ops ();
15898
15899   observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
15900   observer_attach_inferior_exit (clear_syscall_counts);
15901   observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
15902
15903   breakpoint_objfile_key
15904     = register_objfile_data_with_cleanup (NULL, free_breakpoint_probes);
15905
15906   catch_syscall_inferior_data
15907     = register_inferior_data_with_cleanup (NULL,
15908                                            catch_syscall_inferior_data_cleanup);
15909
15910   breakpoint_chain = 0;
15911   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
15912      before a breakpoint is set.  */
15913   breakpoint_count = 0;
15914
15915   tracepoint_count = 0;
15916
15917   add_com ("ignore", class_breakpoint, ignore_command, _("\
15918 Set ignore-count of breakpoint number N to COUNT.\n\
15919 Usage is `ignore N COUNT'."));
15920   if (xdb_commands)
15921     add_com_alias ("bc", "ignore", class_breakpoint, 1);
15922
15923   add_com ("commands", class_breakpoint, commands_command, _("\
15924 Set commands to be executed when a breakpoint is hit.\n\
15925 Give breakpoint number as argument after \"commands\".\n\
15926 With no argument, the targeted breakpoint is the last one set.\n\
15927 The commands themselves follow starting on the next line.\n\
15928 Type a line containing \"end\" to indicate the end of them.\n\
15929 Give \"silent\" as the first line to make the breakpoint silent;\n\
15930 then no output is printed when it is hit, except what the commands print."));
15931
15932   c = add_com ("condition", class_breakpoint, condition_command, _("\
15933 Specify breakpoint number N to break only if COND is true.\n\
15934 Usage is `condition N COND', where N is an integer and COND is an\n\
15935 expression to be evaluated whenever breakpoint N is reached."));
15936   set_cmd_completer (c, condition_completer);
15937
15938   c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
15939 Set a temporary breakpoint.\n\
15940 Like \"break\" except the breakpoint is only temporary,\n\
15941 so it will be deleted when hit.  Equivalent to \"break\" followed\n\
15942 by using \"enable delete\" on the breakpoint number.\n\
15943 \n"
15944 BREAK_ARGS_HELP ("tbreak")));
15945   set_cmd_completer (c, location_completer);
15946
15947   c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
15948 Set a hardware assisted breakpoint.\n\
15949 Like \"break\" except the breakpoint requires hardware support,\n\
15950 some target hardware may not have this support.\n\
15951 \n"
15952 BREAK_ARGS_HELP ("hbreak")));
15953   set_cmd_completer (c, location_completer);
15954
15955   c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
15956 Set a temporary hardware assisted breakpoint.\n\
15957 Like \"hbreak\" except the breakpoint is only temporary,\n\
15958 so it will be deleted when hit.\n\
15959 \n"
15960 BREAK_ARGS_HELP ("thbreak")));
15961   set_cmd_completer (c, location_completer);
15962
15963   add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
15964 Enable some breakpoints.\n\
15965 Give breakpoint numbers (separated by spaces) as arguments.\n\
15966 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15967 This is used to cancel the effect of the \"disable\" command.\n\
15968 With a subcommand you can enable temporarily."),
15969                   &enablelist, "enable ", 1, &cmdlist);
15970   if (xdb_commands)
15971     add_com ("ab", class_breakpoint, enable_command, _("\
15972 Enable some breakpoints.\n\
15973 Give breakpoint numbers (separated by spaces) as arguments.\n\
15974 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15975 This is used to cancel the effect of the \"disable\" command.\n\
15976 With a subcommand you can enable temporarily."));
15977
15978   add_com_alias ("en", "enable", class_breakpoint, 1);
15979
15980   add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
15981 Enable some breakpoints.\n\
15982 Give breakpoint numbers (separated by spaces) as arguments.\n\
15983 This is used to cancel the effect of the \"disable\" command.\n\
15984 May be abbreviated to simply \"enable\".\n"),
15985                    &enablebreaklist, "enable breakpoints ", 1, &enablelist);
15986
15987   add_cmd ("once", no_class, enable_once_command, _("\
15988 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
15989 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15990            &enablebreaklist);
15991
15992   add_cmd ("delete", no_class, enable_delete_command, _("\
15993 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
15994 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15995            &enablebreaklist);
15996
15997   add_cmd ("count", no_class, enable_count_command, _("\
15998 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
15999 If a breakpoint is hit while enabled in this fashion,\n\
16000 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16001            &enablebreaklist);
16002
16003   add_cmd ("delete", no_class, enable_delete_command, _("\
16004 Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
16005 If a breakpoint is hit while enabled in this fashion, it is deleted."),
16006            &enablelist);
16007
16008   add_cmd ("once", no_class, enable_once_command, _("\
16009 Enable breakpoints for one hit.  Give breakpoint numbers.\n\
16010 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
16011            &enablelist);
16012
16013   add_cmd ("count", no_class, enable_count_command, _("\
16014 Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
16015 If a breakpoint is hit while enabled in this fashion,\n\
16016 the count is decremented; when it reaches zero, the breakpoint is disabled."),
16017            &enablelist);
16018
16019   add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
16020 Disable some breakpoints.\n\
16021 Arguments are breakpoint numbers with spaces in between.\n\
16022 To disable all breakpoints, give no argument.\n\
16023 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
16024                   &disablelist, "disable ", 1, &cmdlist);
16025   add_com_alias ("dis", "disable", class_breakpoint, 1);
16026   add_com_alias ("disa", "disable", class_breakpoint, 1);
16027   if (xdb_commands)
16028     add_com ("sb", class_breakpoint, disable_command, _("\
16029 Disable some breakpoints.\n\
16030 Arguments are breakpoint numbers with spaces in between.\n\
16031 To disable all breakpoints, give no argument.\n\
16032 A disabled breakpoint is not forgotten, but has no effect until re-enabled."));
16033
16034   add_cmd ("breakpoints", class_alias, disable_command, _("\
16035 Disable some breakpoints.\n\
16036 Arguments are breakpoint numbers with spaces in between.\n\
16037 To disable all breakpoints, give no argument.\n\
16038 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
16039 This command may be abbreviated \"disable\"."),
16040            &disablelist);
16041
16042   add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
16043 Delete some breakpoints or auto-display expressions.\n\
16044 Arguments are breakpoint numbers with spaces in between.\n\
16045 To delete all breakpoints, give no argument.\n\
16046 \n\
16047 Also a prefix command for deletion of other GDB objects.\n\
16048 The \"unset\" command is also an alias for \"delete\"."),
16049                   &deletelist, "delete ", 1, &cmdlist);
16050   add_com_alias ("d", "delete", class_breakpoint, 1);
16051   add_com_alias ("del", "delete", class_breakpoint, 1);
16052   if (xdb_commands)
16053     add_com ("db", class_breakpoint, delete_command, _("\
16054 Delete some breakpoints.\n\
16055 Arguments are breakpoint numbers with spaces in between.\n\
16056 To delete all breakpoints, give no argument.\n"));
16057
16058   add_cmd ("breakpoints", class_alias, delete_command, _("\
16059 Delete some breakpoints or auto-display expressions.\n\
16060 Arguments are breakpoint numbers with spaces in between.\n\
16061 To delete all breakpoints, give no argument.\n\
16062 This command may be abbreviated \"delete\"."),
16063            &deletelist);
16064
16065   add_com ("clear", class_breakpoint, clear_command, _("\
16066 Clear breakpoint at specified line or function.\n\
16067 Argument may be line number, function name, or \"*\" and an address.\n\
16068 If line number is specified, all breakpoints in that line are cleared.\n\
16069 If function is specified, breakpoints at beginning of function are cleared.\n\
16070 If an address is specified, breakpoints at that address are cleared.\n\
16071 \n\
16072 With no argument, clears all breakpoints in the line that the selected frame\n\
16073 is executing in.\n\
16074 \n\
16075 See also the \"delete\" command which clears breakpoints by number."));
16076   add_com_alias ("cl", "clear", class_breakpoint, 1);
16077
16078   c = add_com ("break", class_breakpoint, break_command, _("\
16079 Set breakpoint at specified line or function.\n"
16080 BREAK_ARGS_HELP ("break")));
16081   set_cmd_completer (c, location_completer);
16082
16083   add_com_alias ("b", "break", class_run, 1);
16084   add_com_alias ("br", "break", class_run, 1);
16085   add_com_alias ("bre", "break", class_run, 1);
16086   add_com_alias ("brea", "break", class_run, 1);
16087
16088   if (xdb_commands)
16089    add_com_alias ("ba", "break", class_breakpoint, 1);
16090
16091   if (dbx_commands)
16092     {
16093       add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
16094 Break in function/address or break at a line in the current file."),
16095                              &stoplist, "stop ", 1, &cmdlist);
16096       add_cmd ("in", class_breakpoint, stopin_command,
16097                _("Break in function or address."), &stoplist);
16098       add_cmd ("at", class_breakpoint, stopat_command,
16099                _("Break at a line in the current file."), &stoplist);
16100       add_com ("status", class_info, breakpoints_info, _("\
16101 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16102 The \"Type\" column indicates one of:\n\
16103 \tbreakpoint     - normal breakpoint\n\
16104 \twatchpoint     - watchpoint\n\
16105 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16106 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
16107 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
16108 address and file/line number respectively.\n\
16109 \n\
16110 Convenience variable \"$_\" and default examine address for \"x\"\n\
16111 are set to the address of the last breakpoint listed unless the command\n\
16112 is prefixed with \"server \".\n\n\
16113 Convenience variable \"$bpnum\" contains the number of the last\n\
16114 breakpoint set."));
16115     }
16116
16117   add_info ("breakpoints", breakpoints_info, _("\
16118 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
16119 The \"Type\" column indicates one of:\n\
16120 \tbreakpoint     - normal breakpoint\n\
16121 \twatchpoint     - watchpoint\n\
16122 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16123 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
16124 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
16125 address and file/line number respectively.\n\
16126 \n\
16127 Convenience variable \"$_\" and default examine address for \"x\"\n\
16128 are set to the address of the last breakpoint listed unless the command\n\
16129 is prefixed with \"server \".\n\n\
16130 Convenience variable \"$bpnum\" contains the number of the last\n\
16131 breakpoint set."));
16132
16133   add_info_alias ("b", "breakpoints", 1);
16134
16135   if (xdb_commands)
16136     add_com ("lb", class_breakpoint, breakpoints_info, _("\
16137 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
16138 The \"Type\" column indicates one of:\n\
16139 \tbreakpoint     - normal breakpoint\n\
16140 \twatchpoint     - watchpoint\n\
16141 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16142 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
16143 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
16144 address and file/line number respectively.\n\
16145 \n\
16146 Convenience variable \"$_\" and default examine address for \"x\"\n\
16147 are set to the address of the last breakpoint listed unless the command\n\
16148 is prefixed with \"server \".\n\n\
16149 Convenience variable \"$bpnum\" contains the number of the last\n\
16150 breakpoint set."));
16151
16152   add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
16153 Status of all breakpoints, or breakpoint number NUMBER.\n\
16154 The \"Type\" column indicates one of:\n\
16155 \tbreakpoint     - normal breakpoint\n\
16156 \twatchpoint     - watchpoint\n\
16157 \tlongjmp        - internal breakpoint used to step through longjmp()\n\
16158 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16159 \tuntil          - internal breakpoint used by the \"until\" command\n\
16160 \tfinish         - internal breakpoint used by the \"finish\" command\n\
16161 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16162 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
16163 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
16164 address and file/line number respectively.\n\
16165 \n\
16166 Convenience variable \"$_\" and default examine address for \"x\"\n\
16167 are set to the address of the last breakpoint listed unless the command\n\
16168 is prefixed with \"server \".\n\n\
16169 Convenience variable \"$bpnum\" contains the number of the last\n\
16170 breakpoint set."),
16171            &maintenanceinfolist);
16172
16173   add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
16174 Set catchpoints to catch events."),
16175                   &catch_cmdlist, "catch ",
16176                   0/*allow-unknown*/, &cmdlist);
16177
16178   add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
16179 Set temporary catchpoints to catch events."),
16180                   &tcatch_cmdlist, "tcatch ",
16181                   0/*allow-unknown*/, &cmdlist);
16182
16183   /* Add catch and tcatch sub-commands.  */
16184   add_catch_command ("catch", _("\
16185 Catch an exception, when caught."),
16186                      catch_catch_command,
16187                      NULL,
16188                      CATCH_PERMANENT,
16189                      CATCH_TEMPORARY);
16190   add_catch_command ("throw", _("\
16191 Catch an exception, when thrown."),
16192                      catch_throw_command,
16193                      NULL,
16194                      CATCH_PERMANENT,
16195                      CATCH_TEMPORARY);
16196   add_catch_command ("fork", _("Catch calls to fork."),
16197                      catch_fork_command_1,
16198                      NULL,
16199                      (void *) (uintptr_t) catch_fork_permanent,
16200                      (void *) (uintptr_t) catch_fork_temporary);
16201   add_catch_command ("vfork", _("Catch calls to vfork."),
16202                      catch_fork_command_1,
16203                      NULL,
16204                      (void *) (uintptr_t) catch_vfork_permanent,
16205                      (void *) (uintptr_t) catch_vfork_temporary);
16206   add_catch_command ("exec", _("Catch calls to exec."),
16207                      catch_exec_command_1,
16208                      NULL,
16209                      CATCH_PERMANENT,
16210                      CATCH_TEMPORARY);
16211   add_catch_command ("load", _("Catch loads of shared libraries.\n\
16212 Usage: catch load [REGEX]\n\
16213 If REGEX is given, only stop for libraries matching the regular expression."),
16214                      catch_load_command_1,
16215                      NULL,
16216                      CATCH_PERMANENT,
16217                      CATCH_TEMPORARY);
16218   add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16219 Usage: catch unload [REGEX]\n\
16220 If REGEX is given, only stop for libraries matching the regular expression."),
16221                      catch_unload_command_1,
16222                      NULL,
16223                      CATCH_PERMANENT,
16224                      CATCH_TEMPORARY);
16225   add_catch_command ("syscall", _("\
16226 Catch system calls by their names and/or numbers.\n\
16227 Arguments say which system calls to catch.  If no arguments\n\
16228 are given, every system call will be caught.\n\
16229 Arguments, if given, should be one or more system call names\n\
16230 (if your system supports that), or system call numbers."),
16231                      catch_syscall_command_1,
16232                      catch_syscall_completer,
16233                      CATCH_PERMANENT,
16234                      CATCH_TEMPORARY);
16235
16236   c = add_com ("watch", class_breakpoint, watch_command, _("\
16237 Set a watchpoint for an expression.\n\
16238 Usage: watch [-l|-location] EXPRESSION\n\
16239 A watchpoint stops execution of your program whenever the value of\n\
16240 an expression changes.\n\
16241 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16242 the memory to which it refers."));
16243   set_cmd_completer (c, expression_completer);
16244
16245   c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
16246 Set a read watchpoint for an expression.\n\
16247 Usage: rwatch [-l|-location] EXPRESSION\n\
16248 A watchpoint stops execution of your program whenever the value of\n\
16249 an expression is read.\n\
16250 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16251 the memory to which it refers."));
16252   set_cmd_completer (c, expression_completer);
16253
16254   c = add_com ("awatch", class_breakpoint, awatch_command, _("\
16255 Set a watchpoint for an expression.\n\
16256 Usage: awatch [-l|-location] EXPRESSION\n\
16257 A watchpoint stops execution of your program whenever the value of\n\
16258 an expression is either read or written.\n\
16259 If -l or -location is given, this evaluates EXPRESSION and watches\n\
16260 the memory to which it refers."));
16261   set_cmd_completer (c, expression_completer);
16262
16263   add_info ("watchpoints", watchpoints_info, _("\
16264 Status of specified watchpoints (all watchpoints if no argument)."));
16265
16266   /* XXX: cagney/2005-02-23: This should be a boolean, and should
16267      respond to changes - contrary to the description.  */
16268   add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
16269                             &can_use_hw_watchpoints, _("\
16270 Set debugger's willingness to use watchpoint hardware."), _("\
16271 Show debugger's willingness to use watchpoint hardware."), _("\
16272 If zero, gdb will not use hardware for new watchpoints, even if\n\
16273 such is available.  (However, any hardware watchpoints that were\n\
16274 created before setting this to nonzero, will continue to use watchpoint\n\
16275 hardware.)"),
16276                             NULL,
16277                             show_can_use_hw_watchpoints,
16278                             &setlist, &showlist);
16279
16280   can_use_hw_watchpoints = 1;
16281
16282   /* Tracepoint manipulation commands.  */
16283
16284   c = add_com ("trace", class_breakpoint, trace_command, _("\
16285 Set a tracepoint at specified line or function.\n\
16286 \n"
16287 BREAK_ARGS_HELP ("trace") "\n\
16288 Do \"help tracepoints\" for info on other tracepoint commands."));
16289   set_cmd_completer (c, location_completer);
16290
16291   add_com_alias ("tp", "trace", class_alias, 0);
16292   add_com_alias ("tr", "trace", class_alias, 1);
16293   add_com_alias ("tra", "trace", class_alias, 1);
16294   add_com_alias ("trac", "trace", class_alias, 1);
16295
16296   c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
16297 Set a fast tracepoint at specified line or function.\n\
16298 \n"
16299 BREAK_ARGS_HELP ("ftrace") "\n\
16300 Do \"help tracepoints\" for info on other tracepoint commands."));
16301   set_cmd_completer (c, location_completer);
16302
16303   c = add_com ("strace", class_breakpoint, strace_command, _("\
16304 Set a static tracepoint at specified line, function or marker.\n\
16305 \n\
16306 strace [LOCATION] [if CONDITION]\n\
16307 LOCATION may be a line number, function name, \"*\" and an address,\n\
16308 or -m MARKER_ID.\n\
16309 If a line number is specified, probe the marker at start of code\n\
16310 for that line.  If a function is specified, probe the marker at start\n\
16311 of code for that function.  If an address is specified, probe the marker\n\
16312 at that exact address.  If a marker id is specified, probe the marker\n\
16313 with that name.  With no LOCATION, uses current execution address of\n\
16314 the selected stack frame.\n\
16315 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16316 This collects arbitrary user data passed in the probe point call to the\n\
16317 tracing library.  You can inspect it when analyzing the trace buffer,\n\
16318 by printing the $_sdata variable like any other convenience variable.\n\
16319 \n\
16320 CONDITION is a boolean expression.\n\
16321 \n\
16322 Multiple tracepoints at one place are permitted, and useful if their\n\
16323 conditions are different.\n\
16324 \n\
16325 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16326 Do \"help tracepoints\" for info on other tracepoint commands."));
16327   set_cmd_completer (c, location_completer);
16328
16329   add_info ("tracepoints", tracepoints_info, _("\
16330 Status of specified tracepoints (all tracepoints if no argument).\n\
16331 Convenience variable \"$tpnum\" contains the number of the\n\
16332 last tracepoint set."));
16333
16334   add_info_alias ("tp", "tracepoints", 1);
16335
16336   add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
16337 Delete specified tracepoints.\n\
16338 Arguments are tracepoint numbers, separated by spaces.\n\
16339 No argument means delete all tracepoints."),
16340            &deletelist);
16341
16342   c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
16343 Disable specified tracepoints.\n\
16344 Arguments are tracepoint numbers, separated by spaces.\n\
16345 No argument means disable all tracepoints."),
16346            &disablelist);
16347   deprecate_cmd (c, "disable");
16348
16349   c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
16350 Enable specified tracepoints.\n\
16351 Arguments are tracepoint numbers, separated by spaces.\n\
16352 No argument means enable all tracepoints."),
16353            &enablelist);
16354   deprecate_cmd (c, "enable");
16355
16356   add_com ("passcount", class_trace, trace_pass_command, _("\
16357 Set the passcount for a tracepoint.\n\
16358 The trace will end when the tracepoint has been passed 'count' times.\n\
16359 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16360 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16361
16362   add_prefix_cmd ("save", class_breakpoint, save_command,
16363                   _("Save breakpoint definitions as a script."),
16364                   &save_cmdlist, "save ",
16365                   0/*allow-unknown*/, &cmdlist);
16366
16367   c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
16368 Save current breakpoint definitions as a script.\n\
16369 This includes all types of breakpoints (breakpoints, watchpoints,\n\
16370 catchpoints, tracepoints).  Use the 'source' command in another debug\n\
16371 session to restore them."),
16372                &save_cmdlist);
16373   set_cmd_completer (c, filename_completer);
16374
16375   c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
16376 Save current tracepoint definitions as a script.\n\
16377 Use the 'source' command in another debug session to restore them."),
16378                &save_cmdlist);
16379   set_cmd_completer (c, filename_completer);
16380
16381   c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
16382   deprecate_cmd (c, "save tracepoints");
16383
16384   add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
16385 Breakpoint specific settings\n\
16386 Configure various breakpoint-specific variables such as\n\
16387 pending breakpoint behavior"),
16388                   &breakpoint_set_cmdlist, "set breakpoint ",
16389                   0/*allow-unknown*/, &setlist);
16390   add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
16391 Breakpoint specific settings\n\
16392 Configure various breakpoint-specific variables such as\n\
16393 pending breakpoint behavior"),
16394                   &breakpoint_show_cmdlist, "show breakpoint ",
16395                   0/*allow-unknown*/, &showlist);
16396
16397   add_setshow_auto_boolean_cmd ("pending", no_class,
16398                                 &pending_break_support, _("\
16399 Set debugger's behavior regarding pending breakpoints."), _("\
16400 Show debugger's behavior regarding pending breakpoints."), _("\
16401 If on, an unrecognized breakpoint location will cause gdb to create a\n\
16402 pending breakpoint.  If off, an unrecognized breakpoint location results in\n\
16403 an error.  If auto, an unrecognized breakpoint location results in a\n\
16404 user-query to see if a pending breakpoint should be created."),
16405                                 NULL,
16406                                 show_pending_break_support,
16407                                 &breakpoint_set_cmdlist,
16408                                 &breakpoint_show_cmdlist);
16409
16410   pending_break_support = AUTO_BOOLEAN_AUTO;
16411
16412   add_setshow_boolean_cmd ("auto-hw", no_class,
16413                            &automatic_hardware_breakpoints, _("\
16414 Set automatic usage of hardware breakpoints."), _("\
16415 Show automatic usage of hardware breakpoints."), _("\
16416 If set, the debugger will automatically use hardware breakpoints for\n\
16417 breakpoints set with \"break\" but falling in read-only memory.  If not set,\n\
16418 a warning will be emitted for such breakpoints."),
16419                            NULL,
16420                            show_automatic_hardware_breakpoints,
16421                            &breakpoint_set_cmdlist,
16422                            &breakpoint_show_cmdlist);
16423
16424   add_setshow_auto_boolean_cmd ("always-inserted", class_support,
16425                                 &always_inserted_mode, _("\
16426 Set mode for inserting breakpoints."), _("\
16427 Show mode for inserting breakpoints."), _("\
16428 When this mode is off, breakpoints are inserted in inferior when it is\n\
16429 resumed, and removed when execution stops.  When this mode is on,\n\
16430 breakpoints are inserted immediately and removed only when the user\n\
16431 deletes the breakpoint.  When this mode is auto (which is the default),\n\
16432 the behaviour depends on the non-stop setting (see help set non-stop).\n\
16433 In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
16434 behaves as if always-inserted mode is on; if gdb is controlling the\n\
16435 inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
16436                                 NULL,
16437                                 &show_always_inserted_mode,
16438                                 &breakpoint_set_cmdlist,
16439                                 &breakpoint_show_cmdlist);
16440
16441   add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
16442                         condition_evaluation_enums,
16443                         &condition_evaluation_mode_1, _("\
16444 Set mode of breakpoint condition evaluation."), _("\
16445 Show mode of breakpoint condition evaluation."), _("\
16446 When this is set to \"host\", breakpoint conditions will be\n\
16447 evaluated on the host's side by GDB.  When it is set to \"target\",\n\
16448 breakpoint conditions will be downloaded to the target (if the target\n\
16449 supports such feature) and conditions will be evaluated on the target's side.\n\
16450 If this is set to \"auto\" (default), this will be automatically set to\n\
16451 \"target\" if it supports condition evaluation, otherwise it will\n\
16452 be set to \"gdb\""),
16453                            &set_condition_evaluation_mode,
16454                            &show_condition_evaluation_mode,
16455                            &breakpoint_set_cmdlist,
16456                            &breakpoint_show_cmdlist);
16457
16458   add_com ("break-range", class_breakpoint, break_range_command, _("\
16459 Set a breakpoint for an address range.\n\
16460 break-range START-LOCATION, END-LOCATION\n\
16461 where START-LOCATION and END-LOCATION can be one of the following:\n\
16462   LINENUM, for that line in the current file,\n\
16463   FILE:LINENUM, for that line in that file,\n\
16464   +OFFSET, for that number of lines after the current line\n\
16465            or the start of the range\n\
16466   FUNCTION, for the first line in that function,\n\
16467   FILE:FUNCTION, to distinguish among like-named static functions.\n\
16468   *ADDRESS, for the instruction at that address.\n\
16469 \n\
16470 The breakpoint will stop execution of the inferior whenever it executes\n\
16471 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16472 range (including START-LOCATION and END-LOCATION)."));
16473
16474   c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
16475 Set a dynamic printf at specified line or function.\n\
16476 dprintf location,format string,arg1,arg2,...\n\
16477 location may be a line number, function name, or \"*\" and an address.\n\
16478 If a line number is specified, break at start of code for that line.\n\
16479 If a function is specified, break at start of code for that function.\n\
16480 "));
16481   set_cmd_completer (c, location_completer);
16482
16483   add_setshow_enum_cmd ("dprintf-style", class_support,
16484                         dprintf_style_enums, &dprintf_style, _("\
16485 Set the style of usage for dynamic printf."), _("\
16486 Show the style of usage for dynamic printf."), _("\
16487 This setting chooses how GDB will do a dynamic printf.\n\
16488 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16489 console, as with the \"printf\" command.\n\
16490 If the value is \"call\", the print is done by calling a function in your\n\
16491 program; by default printf(), but you can choose a different function or\n\
16492 output stream by setting dprintf-function and dprintf-channel."),
16493                         update_dprintf_commands, NULL,
16494                         &setlist, &showlist);
16495
16496   dprintf_function = xstrdup ("printf");
16497   add_setshow_string_cmd ("dprintf-function", class_support,
16498                           &dprintf_function, _("\
16499 Set the function to use for dynamic printf"), _("\
16500 Show the function to use for dynamic printf"), NULL,
16501                           update_dprintf_commands, NULL,
16502                           &setlist, &showlist);
16503
16504   dprintf_channel = xstrdup ("");
16505   add_setshow_string_cmd ("dprintf-channel", class_support,
16506                           &dprintf_channel, _("\
16507 Set the channel to use for dynamic printf"), _("\
16508 Show the channel to use for dynamic printf"), NULL,
16509                           update_dprintf_commands, NULL,
16510                           &setlist, &showlist);
16511
16512   add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
16513                            &disconnected_dprintf, _("\
16514 Set whether dprintf continues after GDB disconnects."), _("\
16515 Show whether dprintf continues after GDB disconnects."), _("\
16516 Use this to let dprintf commands continue to hit and produce output\n\
16517 even if GDB disconnects or detaches from the target."),
16518                            NULL,
16519                            NULL,
16520                            &setlist, &showlist);
16521
16522   add_com ("agent-printf", class_vars, agent_printf_command, _("\
16523 agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16524 (target agent only) This is useful for formatted output in user-defined commands."));
16525
16526   automatic_hardware_breakpoints = 1;
16527
16528   observer_attach_about_to_proceed (breakpoint_about_to_proceed);
16529 }